emhass 0.11.2__py3-none-any.whl → 0.11.3__py3-none-any.whl

emhass/machine_learning_forecaster.py

@@ -13,13 +13,14 @@ from sklearn.linear_model import ElasticNet
 from sklearn.neighbors import KNeighborsRegressor
 from sklearn.metrics import r2_score
 
-from skforecast.ForecasterAutoreg import ForecasterAutoreg
-from skforecast.model_selection import bayesian_search_forecaster
-from skforecast.model_selection import backtesting_forecaster
+from skforecast.recursive import ForecasterRecursive
+from skforecast.model_selection import bayesian_search_forecaster, backtesting_forecaster, TimeSeriesFold
 
 import warnings
+
 warnings.filterwarnings("ignore", category=DeprecationWarning)
 
+
 class MLForecaster:
     r"""
     A forecaster class using machine learning models with auto-regressive approach and features\
@@ -37,8 +38,16 @@ class MLForecaster:
     
     """
 
-    def __init__(self, data: pd.DataFrame, model_type: str, var_model: str, sklearn_model: str,
-                 num_lags: int, emhass_conf: dict, logger: logging.Logger) -> None:
+    def __init__(
+        self,
+        data: pd.DataFrame,
+        model_type: str,
+        var_model: str,
+        sklearn_model: str,
+        num_lags: int,
+        emhass_conf: dict,
+        logger: logging.Logger,
+    ) -> None:
         r"""Define constructor for the forecast class.
 
         :param data: The data that will be used for train/test
@@ -72,8 +81,8 @@ class MLForecaster:
         # A quick data preparation
         self.data.index = pd.to_datetime(self.data.index)
         self.data.sort_index(inplace=True)
-        self.data = self.data[~self.data.index.duplicated(keep='first')]
-    
+        self.data = self.data[~self.data.index.duplicated(keep="first")]
+
     @staticmethod
     def add_date_features(data: pd.DataFrame) -> pd.DataFrame:
         """Add date features from the input DataFrame timestamp
@@ -84,32 +93,36 @@ class MLForecaster:
         :rtype: pd.DataFrame
         """
         df = copy.deepcopy(data)
-        df['year'] = [i.year for i in df.index]
-        df['month'] = [i.month for i in df.index]
-        df['day_of_week'] = [i.dayofweek for i in df.index]
-        df['day_of_year'] = [i.dayofyear for i in df.index]
-        df['day'] = [i.day for i in df.index]
-        df['hour'] = [i.hour for i in df.index]
+        df["year"] = [i.year for i in df.index]
+        df["month"] = [i.month for i in df.index]
+        df["day_of_week"] = [i.dayofweek for i in df.index]
+        df["day_of_year"] = [i.dayofyear for i in df.index]
+        df["day"] = [i.day for i in df.index]
+        df["hour"] = [i.hour for i in df.index]
         return df
 
     @staticmethod
     def neg_r2_score(y_true, y_pred):
         """The negative of the r2 score."""
         return -r2_score(y_true, y_pred)
-    
+
     @staticmethod
     def generate_exog(data_last_window, periods, var_name):
         """Generate the exogenous data for future timestamps."""
-        forecast_dates = pd.date_range(start=data_last_window.index[-1]+data_last_window.index.freq, 
-                                       periods=periods, 
-                                       freq=data_last_window.index.freq)
-        exog = pd.DataFrame({var_name:[np.nan]*periods},
-                            index=forecast_dates)
+        forecast_dates = pd.date_range(
+            start=data_last_window.index[-1] + data_last_window.index.freq,
+            periods=periods,
+            freq=data_last_window.index.freq,
+        )
+        exog = pd.DataFrame({var_name: [np.nan] * periods}, index=forecast_dates)
         exog = MLForecaster.add_date_features(exog)
         return exog
-    
-    def fit(self, split_date_delta: Optional[str] = '48h', perform_backtest: Optional[bool] = False
-            ) -> Tuple[pd.DataFrame, pd.DataFrame]:
+
+    def fit(
+        self,
+        split_date_delta: Optional[str] = "48h",
+        perform_backtest: Optional[bool] = False,
+    ) -> Tuple[pd.DataFrame, pd.DataFrame]:
         r"""The fit method to train the ML model.
 
         :param split_date_delta: The delta from now to `split_date_delta` that will be used \
@@ -121,73 +134,100 @@ class MLForecaster:
         :return: The DataFrame containing the forecast data results without and with backtest
         :rtype: Tuple[pd.DataFrame, pd.DataFrame]
         """
-        self.logger.info("Performing a forecast model fit for "+self.model_type)
+        self.logger.info("Performing a forecast model fit for " + self.model_type)
         # Preparing the data: adding exogenous features
         self.data_exo = pd.DataFrame(index=self.data.index)
         self.data_exo = MLForecaster.add_date_features(self.data_exo)
         self.data_exo[self.var_model] = self.data[self.var_model]
-        self.data_exo = self.data_exo.interpolate(method='linear', axis=0, limit=None)
+        self.data_exo = self.data_exo.interpolate(method="linear", axis=0, limit=None)
         # train/test split
-        self.date_train = self.data_exo.index[-1]-pd.Timedelta('5days')+self.data_exo.index.freq # The last 5 days
-        self.date_split = self.data_exo.index[-1]-pd.Timedelta(split_date_delta)+self.data_exo.index.freq # The last 48h
-        self.data_train = self.data_exo.loc[:self.date_split-self.data_exo.index.freq,:]
-        self.data_test  = self.data_exo.loc[self.date_split:,:]
+        self.date_train = (
+            self.data_exo.index[-1] - pd.Timedelta("5days") + self.data_exo.index.freq
+        )  # The last 5 days
+        self.date_split = (
+            self.data_exo.index[-1]
+            - pd.Timedelta(split_date_delta)
+            + self.data_exo.index.freq
+        )  # The last 48h
+        self.data_train = self.data_exo.loc[
+            : self.date_split - self.data_exo.index.freq, :
+        ]
+        self.data_test = self.data_exo.loc[self.date_split :, :]
         self.steps = len(self.data_test)
         # Pick correct sklearn model
-        if self.sklearn_model == 'LinearRegression':
+        if self.sklearn_model == "LinearRegression":
             base_model = LinearRegression()
-        elif self.sklearn_model == 'ElasticNet':
+        elif self.sklearn_model == "ElasticNet":
             base_model = ElasticNet()
-        elif self.sklearn_model == 'KNeighborsRegressor':
+        elif self.sklearn_model == "KNeighborsRegressor":
             base_model = KNeighborsRegressor()
         else:
-            self.logger.error("Passed sklearn model "+self.sklearn_model+" is not valid. Defaulting to KNeighborsRegressor")
+            self.logger.error(
+                "Passed sklearn model "
+                + self.sklearn_model
+                + " is not valid. Defaulting to KNeighborsRegressor"
+            )
             base_model = KNeighborsRegressor()
         # Define the forecaster object
-        self.forecaster = ForecasterAutoreg(
+        self.forecaster = ForecasterRecursive(
             regressor = base_model,
             lags      = self.num_lags
             )
         # Fit and time it
-        self.logger.info("Training a "+self.sklearn_model+" model")
+        self.logger.info("Training a " + self.sklearn_model + " model")
         start_time = time.time()
-        self.forecaster.fit(y=self.data_train[self.var_model], 
-                            exog=self.data_train.drop(self.var_model, axis=1))
+        self.forecaster.fit(
+            y=self.data_train[self.var_model],
+            exog=self.data_train.drop(self.var_model, axis=1),
+        )
         self.logger.info(f"Elapsed time for model fit: {time.time() - start_time}")
         # Make a prediction to print metrics
-        predictions = self.forecaster.predict(steps=self.steps, exog=self.data_test.drop(self.var_model, axis=1))
-        pred_metric = r2_score(self.data_test[self.var_model],predictions)
-        self.logger.info(f"Prediction R2 score of fitted model on test data: {pred_metric}")
+        predictions = self.forecaster.predict(
+            steps=self.steps, exog=self.data_test.drop(self.var_model, axis=1)
+        )
+        pred_metric = r2_score(self.data_test[self.var_model], predictions)
+        self.logger.info(
+            f"Prediction R2 score of fitted model on test data: {pred_metric}"
+        )
         # Packing results in a DataFrame
-        df_pred = pd.DataFrame(index=self.data_exo.index,columns=['train','test','pred'])
-        df_pred['train'] = self.data_train[self.var_model]
-        df_pred['test'] = self.data_test[self.var_model]
-        df_pred['pred'] = predictions
+        df_pred = pd.DataFrame(
+            index=self.data_exo.index, columns=["train", "test", "pred"]
+        )
+        df_pred["train"] = self.data_train[self.var_model]
+        df_pred["test"] = self.data_test[self.var_model]
+        df_pred["pred"] = predictions
         df_pred_backtest = None
         if perform_backtest is True:
             # Using backtesting tool to evaluate the model
             self.logger.info("Performing simple backtesting of fitted model")
             start_time = time.time()
+            cv = TimeSeriesFold(
+                steps                 = self.num_lags,
+                initial_train_size    = None,
+                fixed_train_size      = False,
+                gap                   = 0,
+                allow_incomplete_fold = True,
+                refit                 = False
+            )
             metric, predictions_backtest = backtesting_forecaster(
                 forecaster         = self.forecaster,
                 y                  = self.data_train[self.var_model],
                 exog               = self.data_train.drop(self.var_model, axis=1),
-                initial_train_size = None,
-                fixed_train_size   = False,
-                steps              = self.num_lags,
+                cv                 = cv,
                 metric             = MLForecaster.neg_r2_score,
-                refit              = False,
-                verbose            = False
+                verbose            = False,
+                show_progress      = True
             )
             self.logger.info(f"Elapsed backtesting time: {time.time() - start_time}")
             self.logger.info(f"Backtest R2 score: {-metric}")
-            df_pred_backtest = pd.DataFrame(index=self.data_exo.index,columns=['train','pred'])
-            df_pred_backtest['train'] = self.data_exo[self.var_model]
-            df_pred_backtest['pred'] = predictions_backtest
+            df_pred_backtest = pd.DataFrame(
+                index=self.data_exo.index, columns=["train", "pred"]
+            )
+            df_pred_backtest["train"] = self.data_exo[self.var_model]
+            df_pred_backtest["pred"] = predictions_backtest
         return df_pred, df_pred_backtest
-    
-    def predict(self, data_last_window: Optional[pd.DataFrame] = None
-            ) -> pd.Series:
+
+    def predict(self, data_last_window: Optional[pd.DataFrame] = None) -> pd.Series:
         """The predict method to generate forecasts from a previously fitted ML model.
 
         :param data_last_window: The data that will be used to generate the new forecast, this \
@@ -199,21 +239,33 @@ class MLForecaster:
         :rtype: pd.Series
         """
         if data_last_window is None:
-            predictions = self.forecaster.predict(steps=self.num_lags, exog=self.data_test.drop(self.var_model, axis=1))
+            predictions = self.forecaster.predict(
+                steps=self.num_lags, exog=self.data_test.drop(self.var_model, axis=1)
+            )
         else:
-            data_last_window = data_last_window.interpolate(method='linear', axis=0, limit=None)
+            data_last_window = data_last_window.interpolate(
+                method="linear", axis=0, limit=None
+            )
             if self.is_tuned:
-                exog = MLForecaster.generate_exog(data_last_window, self.lags_opt, self.var_model)
-                predictions = self.forecaster.predict(steps=self.lags_opt, 
-                                                      last_window=data_last_window[self.var_model],
-                                                      exog=exog.drop(self.var_model, axis=1))
+                exog = MLForecaster.generate_exog(
+                    data_last_window, self.lags_opt, self.var_model
+                )
+                predictions = self.forecaster.predict(
+                    steps=self.lags_opt,
+                    last_window=data_last_window[self.var_model],
+                    exog=exog.drop(self.var_model, axis=1),
+                )
             else:
-                exog = MLForecaster.generate_exog(data_last_window, self.num_lags, self.var_model)
-                predictions = self.forecaster.predict(steps=self.num_lags, 
-                                                      last_window=data_last_window[self.var_model],
-                                                      exog=exog.drop(self.var_model, axis=1))
+                exog = MLForecaster.generate_exog(
+                    data_last_window, self.num_lags, self.var_model
+                )
+                predictions = self.forecaster.predict(
+                    steps=self.num_lags,
+                    last_window=data_last_window[self.var_model],
+                    exog=exog.drop(self.var_model, axis=1),
+                )
         return predictions
-    
+
     def tune(self, debug: Optional[bool] = False) -> pd.DataFrame:
         """Tuning a previously fitted model using bayesian optimization.
 
@@ -223,43 +275,76 @@ class MLForecaster:
         :rtype: pd.DataFrame
         """
         # Regressor hyperparameters search space
-        if self.sklearn_model == 'LinearRegression':
+        if self.sklearn_model == "LinearRegression":
             if debug:
+
                 def search_space(trial):
-                    search_space  = {'fit_intercept': trial.suggest_categorical('fit_intercept', [True]),
-                                     'lags': trial.suggest_categorical('lags', [3])} 
+                    search_space = {
+                        "fit_intercept": trial.suggest_categorical(
+                            "fit_intercept", [True]
+                        ),
+                        "lags": trial.suggest_categorical("lags", [3]),
+                    }
                     return search_space
             else:
+
                 def search_space(trial):
-                    search_space  = {'fit_intercept': trial.suggest_categorical('fit_intercept', [True, False]),
-                                     'lags': trial.suggest_categorical('lags', [6, 12, 24, 36, 48, 60, 72])}
+                    search_space = {
+                        "fit_intercept": trial.suggest_categorical(
+                            "fit_intercept", [True, False]
+                        ),
+                        "lags": trial.suggest_categorical(
+                            "lags", [6, 12, 24, 36, 48, 60, 72]
+                        ),
+                    }
                     return search_space
-        elif self.sklearn_model == 'ElasticNet':
+        elif self.sklearn_model == "ElasticNet":
             if debug:
+
                 def search_space(trial):
-                    search_space  = {'selection': trial.suggest_categorical('selection', ['random']),
-                                     'lags': trial.suggest_categorical('lags', [3])} 
+                    search_space = {
+                        "selection": trial.suggest_categorical("selection", ["random"]),
+                        "lags": trial.suggest_categorical("lags", [3]),
+                    }
                     return search_space
             else:
+
                 def search_space(trial):
-                    search_space  = {'alpha': trial.suggest_float('alpha', 0.0, 2.0),
-                                    'l1_ratio': trial.suggest_float('l1_ratio', 0.0, 1.0),
-                                    'selection': trial.suggest_categorical('selection', ['cyclic', 'random']),
-                                    'lags': trial.suggest_categorical('lags', [6, 12, 24, 36, 48, 60, 72])} 
+                    search_space = {
+                        "alpha": trial.suggest_float("alpha", 0.0, 2.0),
+                        "l1_ratio": trial.suggest_float("l1_ratio", 0.0, 1.0),
+                        "selection": trial.suggest_categorical(
+                            "selection", ["cyclic", "random"]
+                        ),
+                        "lags": trial.suggest_categorical(
+                            "lags", [6, 12, 24, 36, 48, 60, 72]
+                        ),
+                    }
                     return search_space
-        elif self.sklearn_model == 'KNeighborsRegressor':
+        elif self.sklearn_model == "KNeighborsRegressor":
             if debug:
+
                 def search_space(trial):
-                    search_space  = {'weights': trial.suggest_categorical('weights', ['uniform']),
-                                     'lags': trial.suggest_categorical('lags', [3])} 
+                    search_space = {
+                        "weights": trial.suggest_categorical("weights", ["uniform"]),
+                        "lags": trial.suggest_categorical("lags", [3]),
+                    }
                     return search_space
             else:
+
                 def search_space(trial):
-                    search_space  = {'n_neighbors': trial.suggest_int('n_neighbors', 2, 20),
-                                    'leaf_size': trial.suggest_int('leaf_size', 20, 40),
-                                    'weights': trial.suggest_categorical('weights', ['uniform', 'distance']),
-                                    'lags': trial.suggest_categorical('lags', [6, 12, 24, 36, 48, 60, 72])} 
+                    search_space = {
+                        "n_neighbors": trial.suggest_int("n_neighbors", 2, 20),
+                        "leaf_size": trial.suggest_int("leaf_size", 20, 40),
+                        "weights": trial.suggest_categorical(
+                            "weights", ["uniform", "distance"]
+                        ),
+                        "lags": trial.suggest_categorical(
+                            "lags", [6, 12, 24, 36, 48, 60, 72]
+                        ),
+                    }
                     return search_space
+
         # Bayesian search hyperparameter and lags with skforecast/optuna
         # Lags used as predictors
         if debug:
@@ -271,36 +356,50 @@ class MLForecaster:
         # The optimization routine call
         self.logger.info("Bayesian hyperparameter optimization with backtesting")
         start_time = time.time()
+        cv = TimeSeriesFold(
+            steps                 = num_lags,
+            initial_train_size    = len(self.data_exo.loc[:self.date_train]),
+            fixed_train_size      = True,
+            gap                   = 0,
+            skip_folds            = None,
+            allow_incomplete_fold = True,
+            refit                 = refit
+        )
         self.optimize_results, self.optimize_results_object = bayesian_search_forecaster(
             forecaster         = self.forecaster,
             y                  = self.data_train[self.var_model],
             exog               = self.data_train.drop(self.var_model, axis=1),
+            cv                 = cv,
             search_space       = search_space,
-            steps              = num_lags,
             metric             = MLForecaster.neg_r2_score,
-            refit              = refit,
-            initial_train_size = len(self.data_exo.loc[:self.date_train]),
-            fixed_train_size   = True,
             n_trials           = 10,
             random_state       = 123,
-            return_best        = True,
-            verbose            = False,
-            engine             = 'optuna'
+            return_best        = True
         )
         self.logger.info(f"Elapsed time: {time.time() - start_time}")
         self.is_tuned = True
-        predictions_opt = self.forecaster.predict(steps=self.num_lags, exog=self.data_test.drop(self.var_model, axis=1))
-        freq_hours = self.data_exo.index.freq.delta.seconds/3600
-        self.lags_opt = int(np.round(len(self.optimize_results.iloc[0]['lags'])))
-        self.days_needed = int(np.round(self.lags_opt*freq_hours/24))
-        df_pred_opt = pd.DataFrame(index=self.data_exo.index,columns=['train','test','pred_optim'])
-        df_pred_opt['train'] = self.data_train[self.var_model]
-        df_pred_opt['test'] = self.data_test[self.var_model]
-        df_pred_opt['pred_optim'] = predictions_opt
-        pred_optim_metric_train = -self.optimize_results.iloc[0]['neg_r2_score']
-        self.logger.info(f"R2 score for optimized prediction in train period: {pred_optim_metric_train}")
-        pred_optim_metric_test = r2_score(df_pred_opt.loc[predictions_opt.index,'test'],
-                                          df_pred_opt.loc[predictions_opt.index,'pred_optim'])
-        self.logger.info(f"R2 score for optimized prediction in test period: {pred_optim_metric_test}")
-        self.logger.info("Number of optimal lags obtained: "+str(self.lags_opt))
+        predictions_opt = self.forecaster.predict(
+            steps=self.num_lags, exog=self.data_test.drop(self.var_model, axis=1)
+        )
+        freq_hours = self.data_exo.index.freq.delta.seconds / 3600
+        self.lags_opt = int(np.round(len(self.optimize_results.iloc[0]["lags"])))
+        self.days_needed = int(np.round(self.lags_opt * freq_hours / 24))
+        df_pred_opt = pd.DataFrame(
+            index=self.data_exo.index, columns=["train", "test", "pred_optim"]
+        )
+        df_pred_opt["train"] = self.data_train[self.var_model]
+        df_pred_opt["test"] = self.data_test[self.var_model]
+        df_pred_opt["pred_optim"] = predictions_opt
+        pred_optim_metric_train = -self.optimize_results.iloc[0]["neg_r2_score"]
+        self.logger.info(
+            f"R2 score for optimized prediction in train period: {pred_optim_metric_train}"
+        )
+        pred_optim_metric_test = r2_score(
+            df_pred_opt.loc[predictions_opt.index, "test"],
+            df_pred_opt.loc[predictions_opt.index, "pred_optim"],
+        )
+        self.logger.info(
+            f"R2 score for optimized prediction in test period: {pred_optim_metric_test}"
+        )
+        self.logger.info("Number of optimal lags obtained: " + str(self.lags_opt))
         return df_pred_opt

emhass/machine_learning_regressor.py

@@ -76,8 +76,16 @@ class MLRegressor:
 
     """
 
-    def __init__(self: MLRegressor, data: pd.DataFrame, model_type: str, regression_model: str,
-                 features: list, target: str, timestamp: str, logger: logging.Logger) -> None:
+    def __init__(
+        self: MLRegressor,
+        data: pd.DataFrame,
+        model_type: str,
+        regression_model: str,
+        features: list,
+        target: str,
+        timestamp: str,
+        logger: logging.Logger,
+    ) -> None:
         r"""Define constructor for the forecast class.
 
         :param data: The data that will be used for train/test
@@ -116,7 +124,9 @@ class MLRegressor:
         self.grid_search = None
 
     @staticmethod
-    def add_date_features(data: pd.DataFrame, date_features: list, timestamp: str) -> pd.DataFrame:
+    def add_date_features(
+        data: pd.DataFrame, date_features: list, timestamp: str
+    ) -> pd.DataFrame:
         """Add date features from the input DataFrame timestamp.
 
         :param data: The input DataFrame
@@ -215,16 +225,25 @@ class MLRegressor:
         self.data_exo = self.data_exo.drop(self.target, axis=1)
         if self.timestamp is not None:
             self.data_exo = self.data_exo.drop(self.timestamp, axis=1)
-        X = self.data_exo 
-        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+        X = self.data_exo
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=0.2, random_state=42
+        )
         self.steps = len(X_test)
         base_model, param_grid = self.get_regression_model()
         if base_model is None:
             return False
         self.model = make_pipeline(StandardScaler(), base_model)
         # Create a grid search object
-        self.grid_search = GridSearchCV(self.model, param_grid, cv=5, scoring="neg_mean_squared_error",
-                                        refit=True, verbose=0, n_jobs=-1)
+        self.grid_search = GridSearchCV(
+            self.model,
+            param_grid,
+            cv=5,
+            scoring="neg_mean_squared_error",
+            refit=True,
+            verbose=0,
+            n_jobs=-1,
+        )
         # Fit the grid search object to the data
         self.logger.info("Training a %s model", self.regression_model)
         start_time = time.time()