FEDOT

1
import datetime
2
from contextlib import contextmanager
3

4

5
class ComposerTimer:
6
    def __init__(self):
7
        self.data_definition_fit_spend_time = None
8
        self.data_definition_predict_spend_time = None
9
        self.preprocessing_spend_time = None
10
        self.fitting_spend_time = None
11
        self.predicting_spend_time = None
12
        self.tuning_composing_spend_time = None
13
        self.tuning_post_spend_time = None
14
        self.train_on_full_dataset_time = None
15
        self.compoising_spend_time = None
16

17
        self.reset_timer()
18

19
    def reset_timer(self):
20
        self.data_definition_fit_spend_time = datetime.timedelta(minutes=0)
21
        self.data_definition_predict_spend_time = datetime.timedelta(minutes=0)
22
        self.preprocessing_spend_time = datetime.timedelta(minutes=0)
23
        self.fitting_spend_time = datetime.timedelta(minutes=0)
24
        self.predicting_spend_time = datetime.timedelta(minutes=0)
25
        self.tuning_composing_spend_time = datetime.timedelta(minutes=0)
26
        self.tuning_post_spend_time = datetime.timedelta(minutes=0)
27
        self.train_on_full_dataset_time = datetime.timedelta(minutes=0)
28
        self.compoising_spend_time = datetime.timedelta(minutes=0)
29

30
    @contextmanager
31
    def launch_data_definition(self, stage: str):
32
        starting_time = datetime.datetime.now()
33
        yield
34

35
        ending_time = datetime.datetime.now()
36
        if stage == 'fit':
37
            self.data_definition_fit_spend_time += ending_time - starting_time
38

39
        elif stage == 'predict':
40
            self.data_definition_predict_spend_time += ending_time - starting_time
41

42
    @contextmanager
43
    def launch_preprocessing(self):
44
        starting_time = datetime.datetime.now()
45
        yield
46
        ending_time = datetime.datetime.now()
47
        self.preprocessing_spend_time += ending_time - starting_time
48

49
    @contextmanager
50
    def launch_fitting(self):
51
        starting_time = datetime.datetime.now()
52
        yield
53
        ending_time = datetime.datetime.now()
54
        self.fitting_spend_time += ending_time - starting_time
55

56
    @contextmanager
57
    def launch_predicting(self):
58
        starting_time = datetime.datetime.now()
59
        yield
60
        ending_time = datetime.datetime.now()
61
        self.predicting_spend_time += ending_time - starting_time
62

63
    @contextmanager
64
    def launch_tuning(self, stage: str):
65
        starting_time = datetime.datetime.now()
66
        yield
67
        ending_time = datetime.datetime.now()
68

69
        if stage == 'composing':
70
            self.tuning_composing_spend_time += ending_time - starting_time
71

72
        elif stage == 'post':
73
            self.tuning_post_spend_time += ending_time - starting_time
74

75
    @contextmanager
76
    def launch_train_inference(self):
77
        starting_time = datetime.datetime.now()
78
        yield
79
        ending_time = datetime.datetime.now()
80
        self.train_on_full_dataset_time += ending_time - starting_time
81

82
    @contextmanager
83
    def launch_composing(self):
84
        starting_time = datetime.datetime.now()
85
        yield
86
        ending_time = datetime.datetime.now()
87
        self.compoising_spend_time += ending_time - starting_time
88

89
    @property
90
    def report(self) -> dict:
91
        """ Return dict with the next columns:
92
            - 'Data Definition (fit)': Time spent on data definition in fit().
93
            - 'Data Preprocessing': Total time spent on preprocessing data, includes fitting and predicting stages.
94
            - 'Fitting (summary)': Total time spent on Composing, Tuning and Training Inference.
95
            - 'Composing': Time spent on searching for the best pipeline.
96
            - 'Train Inference': Time spent on training the pipeline found during composing.
97
            - 'Tuning (composing)': Time spent on hyperparameters tuning in whole fitting, if with_tune is True.
98
            - 'Tuning (after)': Time spent on .tune() (hyperparameters tuning) after composing.
99
            - 'Data Definition (predict)': Time spent on data definition in predict().
100
            - 'Predicting': Time spent on predicting (inference).
101
        """
102

103
        output = {
104
            'Data Definition (fit)': self.data_definition_fit_spend_time,
105
            'Data Preprocessing': self.preprocessing_spend_time,
106
            'Fitting (summary)': self.fitting_spend_time,
107
            'Composing': self.compoising_spend_time,
108
            'Train Inference': self.train_on_full_dataset_time,
109
            'Tuning (composing)': self.tuning_composing_spend_time,
110
            'Tuning (after)': self.tuning_post_spend_time,
111
            'Data Definition (predict)': self.data_definition_predict_spend_time,
112
            'Predicting': self.predicting_spend_time,
113
        }
114

115
        return output
116

117

118
fedot_composer_timer = ComposerTimer()
119