| DayF core 1.2.1.2 DayF (Decision at your Fingertips) is an AutoML freeware development framework that let developers works with Machine Learning models without any idea of AI, simply taking a csv dataset and the objective column

workflow.py
1
4
5 '''
6 Copyright (C) e2its - All Rights Reserved
7 * Unauthorized copying of this file, via any medium is strictly prohibited
8 * Proprietary and confidential
9 *
10 * This file is part of gDayF project.
11 *
12 * Written by Jose L. Sanchez <e2its.es@gmail.com>, 2016-2019
13 '''
14
15 from gdayf.core.controller import Controller
16 from gdayf.logs.logshandler import LogsHandler
17 from gdayf.common.storagemetadata import StorageMetadata
18 from gdayf.persistence.persistencehandler import PersistenceHandler
19 from gdayf.common.utils import decode_ordered_dict_to_dataframe, xstr
20 from gdayf.common.constants import *
21 from gdayf.handlers.inputhandler import inputHandlerCSV
22 from json.decoder import JSONDecodeError
23 from json import load, dumps
24 from collections import OrderedDict
25 from pandas import DataFrame, set_option
26 from time import time
27 from pathlib import Path
28 from gdayf.core.experiment_context import Experiment_Context as E_C
29
30
32 class Workflow(object):
33
34 def __init__(self, user_id='PoC_gDayF'):
35 self._ec = E_C(user_id=user_id)
36 self._config = self._ec.config.get_config()
37 self._labels = self._ec.labels.get_config()['messages']['workflow']
38 self._logging = LogsHandler(self._ec)
39 self.timestamp = str(time())
40
41
42
49
50 def workflow(self, datapath, workflow, prefix=None, remove_models=EACH_BEST):
51
52 if isinstance(workflow, str):
53 file = open(workflow, 'r')
54 wf = load(file, object_hook=OrderedDict)
55 if self._ec.get_id_workflow() == 'default':
56 self._ec.set_id_workflow(Path(workflow).stem + '_' + self.timestamp)
57 else:
58 wf = workflow
59 if self._ec.get_id_workflow() == 'default':
60 self._ec.set_id_workflow(self._ec.get_id_workflow() + '_' + self.timestamp)
61
62 for wkey, wvalue in wf.items():
63 if prefix is None:
64 #_prefix = xstr(wvalue['parameters']['objective_column'])
65 _prefix = xstr(wvalue['parameters']['objective_column']) + '_' + wkey
66 else:
67 #_prefix = prefix + '_' + xstr(wvalue['parameters']['objective_column'])
68 _prefix = prefix + '_' + xstr(wvalue['parameters']['objective_column']) + '_' + wkey
69 if wvalue['parameters']['mode'] == "train":
70 self.train_workflow(datapath=datapath, wkey=wkey, workflow=wvalue,
71 prefix=_prefix, remove_models=remove_models)
72 elif wvalue['parameters']['mode'] == "predict":
73 self.predict_workflow(datapath=datapath, wkey=wkey, workflow=wvalue,
74 prefix=_prefix, remove_models=remove_models)
75 else:
76 self._logging.log_info('gDayF', "Workflow", self._labels["nothing_to_do"])
77
78
85
86 def train_workflow(self, datapath, wkey, workflow, prefix='main', remove_models=EACH_BEST):
87 set_option('display.max_rows', 500)
88 set_option('display.max_columns', 500)
89 set_option('display.width', 1000)
90
91 wf = workflow
92 pfix = prefix
93
94 error, dataset = self.check_path(datapath)
95 if dataset is None:
96 return error
97
98 controller = Controller(e_c=self._ec)
99 if controller.config_checks():
100 variables = dataset.columns.tolist()
101
102 #for wkey, wvalue in wf.items():
103 if wf["data"]["filtered_columns"] is not None:
104 for delete in wf["data"]["filtered_columns"]:
105 try:
106 variables.remove(delete)
107 except Exception:
108 self._logging.log_info('gDayF', "Workflow", self._labels["failed_var"], delete)
109 self._logging.log_info('gDayF', "Workflow", self._labels["variables_desc"], variables)
110 if wf["data"]["for_each"] is not None:
111 fe_column = wf["data"]["for_each"]
112 fe_data_exclusions = wf["data"]["for_each_exclusions"]
113 fe_filtered_data = wf["data"]["filtered_data"]
114 fe_parameters = wf["parameters"]
115 fe_next = wf["Next"]
116
117 for each in eval('dataset.'+fe_column+'.unique()'):
118 if fe_data_exclusions is None or each not in fe_data_exclusions:
119 aux_dataset = eval('dataset[dataset.' + fe_column + '== each]')
120 pfix = xstr(prefix + '_' + str(each))
121
122
123 if fe_filtered_data is not None:
124 qcolumn = fe_filtered_data["column"]
125 quantile = aux_dataset[qcolumn].quantile(q=fe_filtered_data["quantile"])
126 aux_dataset = eval('aux_dataset.loc[aux_dataset.' + qcolumn + '<= ' + str(quantile) + ']')
127 pfix = xstr(pfix + '_' + str(fe_filtered_data["quantile"]))
128
129
130 if fe_parameters is not None:
131 source_parameters = list()
132 source_parameters.append('controller.exec_analysis(')
133 source_parameters.append('datapath=aux_dataset.loc[:, variables]')
134 for ikey, ivalue in fe_parameters.items():
135 source_parameters.append(',')
136 source_parameters.append(ikey)
137 source_parameters.append('=')
138 if isinstance(ivalue, str) and ikey != "amode":
139 source_parameters.append('\'')
140 source_parameters.append(ivalue)
141 source_parameters.append('\'')
142 else:
143 source_parameters.append(str(ivalue))
144 source_parameters.append(')')
145
146 self._logging.log_info('gDayF', "Workflow", self._labels["desc_operation"],
147 ''.join(source_parameters))
148 status, recomendations = eval(''.join(source_parameters))
149 controller.remove_models(recomendations, mode=remove_models)
150 controller.reconstruct_execution_tree(recomendations, metric=fe_parameters['metric'],
151 store=True)
152
153 #model_id = recomendations[0]['model_id']
154 table_model_list = controller.table_model_list(ar_list=recomendations,
155 metric=eval(fe_parameters['metric']))
156 self._logging.log_info('gDayF', 'workflow', self._labels["results"]+'\n',
157 table_model_list.to_string(justify="left"))
158
159 #filename = self.storage_path('train', wkey + '_' + str(pfix) + '_' + 'train_performance'
160 if self._config['common']['workflow_summary_enabled']:
161 filename = self.storage_path('train', str(pfix) + '_' + 'train_performance'
162 , 'xls')
163 table_model_list.to_excel(filename, index=False, sheet_name='performance')
164 self.replicate_file('train', filename=filename)
165
166 prediction_frame = controller.exec_prediction(datapath=aux_dataset,
167 model_file=recomendations[0]['json_path'][0]['value'])
168 try:
169 if 'predict' in prediction_frame.columns.values:
170 prediction_frame.rename(columns={"predict": wkey}, inplace=True)
171 elif 'prediction' in prediction_frame.columns.values:
172 prediction_frame.rename(columns={"prediction": wkey}, inplace=True)
173
174 self._logging.log_info('gDayF', 'workflow', self._labels["results"]+'\n',
175 prediction_frame.to_string(index_names=False, justify="left"))
176
177 '''filename = self.storage_path('train', wkey + '_'
178 + str(pfix) + '_' + 'prediction', 'xls')'''
179 if self._config['common']['workflow_summary_enabled']:
180 filename = self.storage_path('train', str(pfix) + '_' + 'prediction', 'xls')
181 prediction_frame.to_excel(filename, index=False, sheet_name='train_prediction')
182 self.replicate_file('train', filename=filename)
183
184 except AttributeError as oexecution_error:
185 self._logging.log_info('gDayF', "Workflow", self._labels["failed_model"],
186 str(repr(oexecution_error)))
187
188 try:
189 if fe_next is not None and prediction_frame is not None:
190 self.workflow(prediction_frame, fe_next, pfix, remove_models=remove_models)
191 except Exception as oexecution_error:
192 self._logging.log_critical('gDayF', "Workflow", self._labels["failed_wf"], str(fe_next))
193 else:
194 aux_dataset = dataset
195
196 if wf["data"]["filtered_data"] is not None:
197 qcolumn = wf["data"]["filtered_data"]["column"]
198 quantile = aux_dataset[[qcolumn]].quatile([wf["data"]["filtered_data"]["quantile"]])
199 aux_dataset = aux_dataset.query('%s <= %s' % (qcolumn, quantile))
200
201 if wf['parameters'] is not None:
202 source_parameters = list()
203 source_parameters.append('controller.exec_analysis(')
204 source_parameters.append('datapath=aux_dataset.loc[:, variables]')
205 for ikey, ivalue in wf['parameters'].items():
206 source_parameters.append(',')
207 source_parameters.append(ikey)
208 source_parameters.append('=')
209 if isinstance(ivalue, str) and ikey != "amode":
210 source_parameters.append('\'')
211 source_parameters.append(ivalue)
212 source_parameters.append('\'')
213 else:
214 source_parameters.append(str(ivalue))
215 source_parameters.append(')')
216 self._logging.log_info('gDayF', "Workflow", self._labels["desc_operation"],
217 ''.join(source_parameters))
218 status, recomendations = eval(''.join(source_parameters))
219 controller.remove_models(recomendations, mode=remove_models)
220 controller.reconstruct_execution_tree(recomendations, metric=wf['parameters']['metric'], store=True)
221
222 model_id = recomendations[0]['model_id']
223 table_model_list = controller.table_model_list(ar_list=recomendations,
224 metric=eval(wf['parameters']['metric']))
225 self._logging.log_info('gDayF', 'workflow', self._labels["results"]+'\n',
226 table_model_list.to_string(justify="left"))
227
228 if self._config['common']['workflow_summary_enabled']:
229 '''filename = self.storage_path('train', wkey + '_' + str(pfix) + '_'
230 + 'train_performance', 'xls')'''
231 filename = self.storage_path('train', str(pfix) + '_' + 'train_performance', 'xls')
232 table_model_list.to_excel(filename, index=False, sheet_name="performace")
233 self.replicate_file('train', filename=filename)
234
235 prediction_frame = controller.exec_prediction(datapath=aux_dataset,
236 model_file=recomendations[0]['json_path'][0]['value'])
237 try:
238 if 'predict' in prediction_frame.columns.values:
239 prediction_frame.rename(columns={"predict": wkey}, inplace=True)
240 elif 'prediction' in prediction_frame.columns.values:
241 prediction_frame.rename(columns={"prediction": wkey}, inplace=True)
242
243 self._logging.log_info('gDayF', 'workflow', self._labels["results"]+'\n',
244 prediction_frame.to_string(index_names=False, justify="left"))
245
246 '''filename = self.storage_path('train', wkey + '_' + str(pfix) + '_'
247 + 'prediction', 'xls')'''
248 if self._config['common']['workflow_summary_enabled']:
249 filename = self.storage_path('train', str(pfix) + '_' + 'prediction', 'xls')
250 prediction_frame.to_excel(filename, index=False, sheet_name="train_prediction")
251 self.replicate_file('train', filename=filename)
252
253 except AttributeError as oexecution_error:
254 self._logging.log_info('gDayF', "Workflow", self._labels["failed_model"],
255 str(repr(oexecution_error)))
256
257 if wf['Next'] is not None and prediction_frame is not None:
258 try:
259 self.workflow(datapath=prediction_frame, workflow=wf['Next'],
260 prefix=pfix, remove_models=remove_models)
261 except Exception as oexecution_error:
262 self._logging.log_critical('gDayF', "Workflow", self._labels["failed_wf"], str(wf['Next']))
263 self._logging.log_critical('gDayF', "Workflow", self._labels["failed_wf"],
264 repr(oexecution_error))
265
266
267 controller.clean_handlers()
268 del controller
269
270
278
279 def predict_workflow(self, datapath, wkey, workflow, prefix='main', workflow_id='default', remove_models=EACH_BEST):
280 set_option('display.height', 1000)
281 set_option('display.max_rows', 500)
282 set_option('display.max_columns', 500)
283 set_option('display.width', 1000)
284
285 error, dataset = self.check_path(datapath)
286 if dataset is None:
287 return error
288
289 if isinstance(workflow, str):
290 file = open(workflow, 'r')
291 wf = load(file, object_hook=OrderedDict)
292 else:
293 wf = workflow
294 pfix = xstr(prefix)
295 controller = Controller(e_c=self._ec)
296 if controller.config_checks():
297 variables = dataset.columns.tolist()
298
299 #for wkey, wvalue in wf.items():
300 if wf["model"] is not None and \
301 (isinstance(wf["model"], str) or isinstance(wf["model"], dict)):
302
303 if wf["data"]["filtered_columns"] is not None:
304 for delete in wf["data"]["filtered_columns"]:
305 try:
306 variables.remove(delete)
307 except Exception:
308 self._logging.log_info('gDayF', "Workflow", self._labels["failed_var"], delete)
309
310 self._logging.log_info('gDayF', "Workflow", self._labels["variables_desc"], variables)
311
312 if wf["data"]["for_each"] is not None:
313 fe_column = wf["data"]["for_each"]
314 fe_data_exclusions = wf["data"]["for_each_exclusions"]
315 fe_filtered_data = wf["data"]["filtered_data"]
316 fe_next = wf["Next"]
317
318 for each in eval('dataset.' + fe_column + '.unique()'):
319 if fe_data_exclusions is None or each not in fe_data_exclusions:
320 aux_dataset = eval('dataset[dataset.' + fe_column + '== each]')
321 pfix = xstr(prefix + '_' + str(each))
322
323 if fe_filtered_data is not None:
324 qcolumn = fe_filtered_data["column"]
325 quantile = aux_dataset[qcolumn].quantile(q=fe_filtered_data["quantile"])
326 aux_dataset = eval('aux_dataset.loc[aux_dataset.' + qcolumn + '<= ' + str(quantile) + ']')
327 pfix = xstr(pfix + '_' + str(fe_filtered_data["quantile"]))
328
329 prediction_frame = controller.exec_prediction(datapath=aux_dataset,
330 model_file=wf["model"][str(each)])
331 try:
332 if 'predict' in prediction_frame.columns.values:
333 prediction_frame.rename(columns={"predict": wkey}, inplace=True)
334 elif 'prediction' in prediction_frame.columns.values:
335 prediction_frame.rename(columns={"prediction": wkey}, inplace=True)
336 except AttributeError:
337 self._logging.log_info('gDayF', "Workflow", self._labels["anomalies_operation"])
338
339 self._logging.log_info('gDayF', 'workflow', self._labels["results"]+'\n',
340 prediction_frame.to_string(index_names=False, justify="left"))
341
342 try:
343 if isinstance(prediction_frame, DataFrame) \
344 and self._config['common']['workflow_summary_enabled']:
345 '''filename = self.storage_path('predict', wkey + '_'
346 + str(pfix) + '_' + 'prediction', 'xls')'''
347 filename = self.storage_path('predict', str(pfix) + '_' +
348 str(self.timestamp) + '_' + 'prediction', 'xls')
349 prediction_frame.to_excel(filename, index=False, sheet_name="prediction")
350 self.replicate_file('predict', filename=filename)
351 elif self._config['common']['workflow_summary_enabled']:
352 for ikey, ivalue in prediction_frame['columns'].items():
353 ppDF = decode_ordered_dict_to_dataframe(ivalue)
354 if isinstance(ppDF, DataFrame):
355 '''filename = self.storage_path('predict', wkey + '_'
356 + str(pfix) + '_' + 'prediction_' + ikey, 'xls')'''
357 filename = self.storage_path('predict', str(pfix) + '_' +
358 str(self.timestamp) + '_' +
359 'prediction_' + ikey, 'xls')
360 ppDF.to_excel(filename, index=False, sheet_name="prediction")
361 self.replicate_file('predict', filename=filename)
362
363 filename = self.storage_path('predict', str(pfix) + '_' +
364 str(self.timestamp) + '_' + '_prediction', 'json')
365 with open(filename, 'w') as f:
366 f.write(dumps(prediction_frame['global_mse']))
367 self.replicate_file('predict', filename=filename)
368 except AttributeError:
369 self._logging.log_info('gDayF', "Workflow", self._labels["anomalies_operation"],
370 prediction_frame)
371
372 try:
373 if fe_next is not None and prediction_frame is not None:
374 self.workflow(prediction_frame, fe_next, pfix, remove_models=remove_models)
375 except Exception as oexecution_error:
376 self._logging.log_critical('gDayF', "Workflow", self._labels["failed_wf"], str(fe_next))
377 self._logging.log_critical('gDayF', "Workflow", self._labels["failed_wf"],
378 repr(oexecution_error))
379 else:
380 aux_dataset = dataset
381
382 prediction_frame = controller.exec_prediction(datapath=aux_dataset, model_file=wf["model"])
383 if 'predict' in prediction_frame.columns.values:
384 prediction_frame.rename(columns={"predict": wkey}, inplace=True)
385 elif 'prediction' in prediction_frame.columns.values:
386 prediction_frame.rename(columns={"prediction": wkey}, inplace=True)
387
388 self._logging.log_info('gDayF', 'workflow', self._labels["results"]+'\n',
389 prediction_frame.to_string(index_names=False, justify="left"))
390 if isinstance(prediction_frame, DataFrame) and self._config['common']['workflow_summary_enabled']:
391 filename = self.storage_path('predict', str(pfix) +
392 str(self.timestamp) + '_' + '_prediction', 'xls')
393 prediction_frame.to_excel(filename, index=False, sheet_name="prediction")
394 self.replicate_file('predict', filename=filename)
395 elif self._config['common']['workflow_summary_enabled']:
396 for ikey, ivalue in prediction_frame['columns'].items():
397 ppDF = decode_ordered_dict_to_dataframe(ivalue)
398 if isinstance(ppDF, DataFrame):
399 filename = self.storage_path('predict', str(pfix) + '_' +
400 str(self.timestamp) + '_' + 'prediction_' + ikey, 'xls')
401 ppDF.to_excel(filename, index=False, sheet_name="prediction")
402 self.replicate_file('predict', filename=filename)
403
404 filename = self.storage_path('predict', str(pfix) + '_' +
405 str(self.timestamp) + '_' + '_prediction', 'json')
406 with open(filename, 'w') as f:
407 f.write(dumps(prediction_frame))
408 self.replicate_file('predict', filename=filename)
409
410 if wf['Next'] is not None and prediction_frame is not None:
411 try:
412 self.workflow(datapath=prediction_frame, workflow=wf['Next'], prefix=pfix,
413 remove_models=remove_models)
414 except Exception as oexecution_error:
415 self._logging.log_critical('gDayF', "Workflow", self._labels["failed_wf"], str(wf['Next']))
416 self._logging.log_critical('gDayF', "Workflow", self._labels["failed_wf"],
417 repr(oexecution_error))
418
419 controller.clean_handlers()
420 del controller
421
422
425 def check_path(self, datapath):
426 if isinstance(datapath, str):
427 try:
428 self._logging.log_info('gDayF', "Workflow", self._labels["input_param"], datapath)
429 pd_dataset = inputHandlerCSV().inputCSV(filename=datapath)
430 return None, pd_dataset.copy()
431 except [IOError, OSError, JSONDecodeError]:
432 self._logging.log_critical('gDayF', "Workflow", self._labels["failed_input"], datapath)
433 return self._labels['failed_input'], None
434 elif isinstance(datapath, DataFrame):
435 self._logging.log_info('gDayF', "Controller", self._labels["input_param"], str(datapath.shape))
436 return None, datapath
437 else:
438 self._logging.log_critical('gDayF', "Workflow", self._labels["failed_input"], datapath)
439 return self._labels['failed_input'], None
440
441
446 def storage_path(self, mode, filename, filetype):
447 load_storage = StorageMetadata(self._ec)
448 if self._config['common']['workflow_summary_enabled']:
449 include = True
450 else:
451 include = False
452 for each_storage_type in load_storage.get_load_path(include=include):
453 if each_storage_type['type'] == 'localfs':
454 source_data = list()
455 primary_path = self._config['storage'][each_storage_type['type']]['value']
456 source_data.append(primary_path)
457 source_data.append('/')
458 source_data.append(self._ec.get_id_user())
459 source_data.append('/')
460 source_data.append(self._ec.get_id_workflow())
461 source_data.append('/')
462 source_data.append(self._config['common']['workflow_summary_dir'])
463 source_data.append('/')
464 source_data.append(mode)
465 source_data.append('/')
466
467 PersistenceHandler(self._ec).mkdir(type=each_storage_type['type'],
468 path=''.join(source_data), grants=self._config['storage']['grants'])
469 source_data.append(filename)
470 source_data.append('.' + filetype)
471
472 return ''.join(source_data)
473 return None
474
475
479 def replicate_file(self, mode, filename):
480 load_storage = StorageMetadata(self._ec).get_json_path()
481 persistence = PersistenceHandler(self._ec)
482 for each_storage_type in load_storage:
483 if each_storage_type['type'] in ['localfs', 'hdfs']:
484 source_data = list()
485 primary_path = self._config['storage'][each_storage_type['type']]['value']
486 source_data.append(primary_path)
487 source_data.append('/')
488 source_data.append(self._ec.get_id_user())
489 source_data.append('/')
490 source_data.append(self._ec.get_id_workflow())
491 source_data.append('/')
492 source_data.append(self._config['common']['workflow_summary_dir'])
493 source_data.append('/')
494 source_data.append(mode)
495 source_data.append('/')
496
497 '''if each_storage_type['type'] == 'hdfs':
498 source_data = self._config['storage'][each_storage_type['type']]['uri'] + ''.join(source_data)'''
499 each_storage_type['value'] = ''.join(source_data)
500
501 persistence.mkdir(type=each_storage_type['type'], path=each_storage_type['value'],
502 grants=self._config['storage']['grants'])
503 each_storage_type['value'] = each_storage_type['value'] + Path(filename).name
504
505 persistence.store_file(storage_json=load_storage, filename=filename)
506 del persistence
507
508
509
gdayf.handlers.inputhandler.inputHandlerCSV
Definition: inputhandler.py:20
gdayf.workflow.workflow.Workflow.storage_path
def storage_path(self, mode, filename, filetype)
Method managing storage path.
Definition: workflow.py:446
gdayf.workflow.workflow.Workflow.replicate_file
def replicate_file(self, mode, filename)
Method replicate files from primery to others.
Definition: workflow.py:479
gdayf.common.utils
Define all objects, functions and structs related to common utilities not associated to one concrete ...
Definition: utils.py:1
gdayf.handlers.inputhandler
Definition: inputhandler.py:1
gdayf.logs.logshandler
Define all objects, functions and structures related to logging event on DayF product logs...
Definition: logshandler.py:1
gdayf.common.storagemetadata.StorageMetadata
Class storage metadata format [{value: , fstype:[&#39;localfs&#39;, &#39;hdfs&#39;, &#39;mongoDB&#39;], hash_value : ""...
Definition: storagemetadata.py:24
gdayf.logs.logshandler.LogsHandler
Class oriented to manage all messages and interaction with DayF product logs.
Definition: logshandler.py:23
gdayf.workflow.workflow.Workflow.__init__
def __init__(self, user_id='PoC_gDayF')
Constructor.
Definition: workflow.py:34
gdayf.workflow.workflow.Workflow._config
_config
Definition: workflow.py:36
gdayf.workflow.workflow.Workflow._ec
_ec
Definition: workflow.py:35
gdayf.persistence.persistencehandler
Define all objects, functions and structures related to physically store information on persistence s...
Definition: persistencehandler.py:1
gdayf.workflow.workflow.Workflow.train_workflow
def train_workflow(self, datapath, wkey, workflow, prefix='main', remove_models=EACH_BEST)
Method leading train workflow executions.
Definition: workflow.py:86
gdayf.core.controller.Controller
Core class oriented to manage the comunication and execution messages pass for all components on syst...
Definition: controller.py:41
gdayf.workflow.workflow.Workflow.check_path
def check_path(self, datapath)
Method managing dataset load from datapath:
Definition: workflow.py:425
gdayf.workflow.workflow.Workflow._logging
_logging
Definition: workflow.py:38
gdayf.workflow.workflow.Workflow
Core class oriented to manage pipeline of workflows execution orchestrating the execution of actions ...
Definition: workflow.py:32
gdayf.workflow.workflow.Workflow.predict_workflow
def predict_workflow(self, datapath, wkey, workflow, prefix='main', workflow_id='default', remove_models=EACH_BEST)
Method leading predict workflow executions.
Definition: workflow.py:279
gdayf.core.experiment_context
Define all global objects, functions and structs related with an specific experiment.
Definition: experiment_context.py:1
gdayf.common.storagemetadata
Define all objects, functions and structured related to adding storage information metadata (json str...
Definition: storagemetadata.py:1
gdayf.workflow.workflow.Workflow.workflow
def workflow(self, datapath, workflow, prefix=None, remove_models=EACH_BEST)
Method leading workflow executions.
Definition: workflow.py:50
gdayf.persistence.persistencehandler.PersistenceHandler
Class to manage trasient information between all persistence options and models on an unified way...
Definition: persistencehandler.py:38
gdayf.common.constants
Definition: constants.py:1
gdayf.core.controller
Define all objects, functions and structured related to manage and execute actions over DayF core and...
Definition: controller.py:1
gdayf.workflow.workflow.Workflow._labels
_labels
Definition: workflow.py:37
gdayf.workflow.workflow.Workflow.timestamp
timestamp
Definition: workflow.py:39