openstef 3.4.56__py3-none-any.whl → 4.0.0a3__py3-none-any.whl

openstef/model/objective.py

@@ -1,426 +0,0 @@
-# SPDX-FileCopyrightText: 2017-2023 Contributors to the OpenSTEF project <korte.termijn.prognoses@alliander.com> # noqa E501>
-#
-# SPDX-License-Identifier: MPL-2.0
-import copy
-from datetime import datetime, timezone
-from typing import Any, Callable, Optional
-
-import optuna
-import pandas as pd
-
-from openstef.enums import ModelType
-from openstef.metrics import metrics
-from openstef.metrics.reporter import Report, Reporter
-from openstef.model.regressors.regressor import OpenstfRegressor
-from openstef.model.standard_deviation_generator import StandardDeviationGenerator
-from openstef.model_selection.model_selection import split_data_train_validation_test
-
-EARLY_STOPPING_ROUNDS: int = 10
-TEST_FRACTION: float = 0.15
-VALIDATION_FRACTION: float = 0.15
-# See https://xgboost.readthedocs.io/en/latest/parameter.html for all possibilities
-EVAL_METRIC: str = "mae"
-
-# https://optuna.readthedocs.io/en/stable/faq.html#objective-func-additional-args
-
-
-class RegressorObjective:
-    """Regressor optuna objective function.
-
-    Use any of the derived classes for optimization using an optuna study.
-    The constructor is used to set the "input_data", specify the splitting function
-    and its arguments and optionally add some configuration.
-    Next the instance will be called by he optuna study during optimization.
-
-    Example usage:
-
-    .. code-block:: py
-
-        # initialize a (derived class) objective function
-        objective = XGBRegressorObjective(input_data, test_fraction)
-        # use the objective function
-        study.optimize(objective)
-
-    """
-
-    def __init__(
-        self,
-        model: OpenstfRegressor,
-        input_data: pd.DataFrame,
-        split_func: Optional[Callable] = None,
-        split_args: Optional[dict[str, Any]] = None,
-        test_fraction=TEST_FRACTION,
-        validation_fraction=VALIDATION_FRACTION,
-        eval_metric=EVAL_METRIC,
-        verbose=False,
-    ):
-        self.input_data = input_data
-        self.train_data = None
-        self.validation_data = None
-        self.test_data = None
-        self.model = model
-        self.start_time = datetime.now(timezone.utc)
-        self.test_fraction = test_fraction
-        self.validation_fraction = validation_fraction
-        self.eval_metric = eval_metric
-        self.eval_metric_function = metrics.get_eval_metric_function(eval_metric)
-        self.verbose = verbose
-        # Should be set on a derived classes
-        self.model_type = None
-        self.track_trials = {}
-
-        # split function and arguments
-        self.split_func = split_func
-        self.split_args = split_args
-
-        # default behavior for splitting
-        if self.split_func is None:
-            self.split_func = split_data_train_validation_test
-            self.split_args = None
-
-    def __call__(
-        self,
-        trial: optuna.trial.FrozenTrial,
-    ) -> float:
-        """Optuna objective function.
-
-        Args: trial
-
-        Returns:
-            Mean absolute error for this trial.
-
-        """
-        # Perform data preprocessing
-        split_args = self.split_args
-        if split_args is None:
-            split_args = {
-                "stratification_min_max": True,
-                "back_test": True,
-            }
-        (
-            self.train_data,
-            self.validation_data,
-            self.test_data,
-            self.operational_score_data,
-        ) = self.split_func(
-            self.input_data,
-            test_fraction=self.test_fraction,
-            validation_fraction=self.validation_fraction,
-            **split_args,
-        )
-
-        # Test if first column is "load" and last column is "horizon"
-        if (
-            self.train_data.columns[0] != "load"
-            or self.train_data.columns[-1] != "horizon"
-        ):
-            raise RuntimeError(
-                "Column order in train input data not as expected, "
-                "could not train a model!"
-            )
-
-        # Split in x, y data (x are the features, y is the load)
-        train_x, train_y = self.train_data.iloc[:, 1:-1], self.train_data.iloc[:, 0]
-        valid_x, valid_y = (
-            self.validation_data.iloc[:, 1:-1],
-            self.validation_data.iloc[:, 0],
-        )
-        test_x, test_y = self.test_data.iloc[:, 1:-1], self.test_data.iloc[:, 0]
-
-        # Configure evals for early stopping
-        eval_set = [(train_x, train_y), (valid_x, valid_y)]
-
-        # get the parameters used in this trial
-        hyper_params = self.get_params(trial)
-
-        # insert parameters into model
-        self.model.set_params(**hyper_params)
-
-        # create the specific pruning callback
-        pruning_callback = self.get_pruning_callback(trial)
-        if pruning_callback is None:
-            callbacks = None
-        else:
-            callbacks = [pruning_callback]
-
-        # validation_0 and validation_1 are available
-        self.model.fit(
-            train_x,
-            train_y,
-            eval_set=eval_set,
-            early_stopping_rounds=EARLY_STOPPING_ROUNDS,
-            verbose=self.verbose,
-            eval_metric=self.eval_metric,
-            callbacks=callbacks,
-        )
-
-        self.model.feature_importance_dataframe = self.model.set_feature_importance()
-
-        # Do confidence interval determination
-        self.model = StandardDeviationGenerator(
-            self.validation_data
-        ).generate_standard_deviation_data(self.model)
-
-        forecast_y = self.model.predict(test_x)
-        score = self.eval_metric_function(test_y, forecast_y)
-
-        # Convert float32 to float because float32 is not JSON serializable
-        self.track_trials[f" trial: {trial.number}"] = {
-            "score": float(score),
-            "params": hyper_params,
-        }
-        trial.set_user_attr(key="model", value=copy.deepcopy(self.model))
-        return score
-
-    def get_params(self, trial: optuna.trial.FrozenTrial) -> dict:
-        """Get parameters for objective without model specific get_params function.
-
-        Args: trial
-
-        Returns:
-            Dictionary with hyperparameter name as key and hyperparamer value as value.
-
-        """
-        default_params = {
-            "learning_rate": trial.suggest_float("learning_rate", 0.01, 0.5),
-            "alpha": trial.suggest_float("alpha", 0, 1.0),
-            "lambda": trial.suggest_float("lambda", 1e-8, 1.0),
-            "subsample": trial.suggest_float("subsample", 0.4, 1.0),
-            "min_child_weight": trial.suggest_int("min_child_weight", 1, 16),
-            "max_depth": trial.suggest_int("max_depth", 3, 10),
-            "colsample_bytree": trial.suggest_float("colsample_bytree", 0.5, 1.0),
-            "max_delta_step": trial.suggest_int("max_delta_step", 0, 10),
-        }
-
-        # Compare the list to the default parameter space
-        model_parameters = self.model.get_params()
-        keys = [x for x in model_parameters.keys() if x in default_params.keys()]
-        # create a dictionary with the matching parameters
-        params = {parameter: default_params[parameter] for parameter in keys}
-
-        return params
-
-    def get_pruning_callback(self, trial: optuna.trial.FrozenTrial):
-        return None
-
-    def get_trial_track(self) -> dict:
-        """Get a dictionary of al trials.
-
-        Returns:
-            Dict with al trials and it's parameters
-
-        """
-        return self.track_trials
-
-    def create_report(self, model: OpenstfRegressor) -> Report:
-        """Generate a report from the data available inside the objective function.
-
-        Args:
-            model: OpenstfRegressor, model to create a report on
-
-        Returns:
-            Report about the model
-
-        """
-        # Report about the training process
-        reporter = Reporter(self.train_data, self.validation_data, self.test_data)
-        report = reporter.generate_report(model)
-
-        return report
-
-    @classmethod
-    def get_default_values(cls) -> dict:
-        return {
-            "learning_rate": 0.3,
-            "alpha": 0.0,
-            "lambda": 1.0,
-            "subsample": 1.0,
-            "min_child_weight": 1,
-            "max_depth": 6,
-            "colsample_bytree": 1,
-            "max_delta_step": 0,
-        }
-
-
-class XGBRegressorObjective(RegressorObjective):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.model_type = ModelType.XGB
-
-    # extend the parameters with the model specific ones per implementation
-    def get_params(self, trial: optuna.trial.FrozenTrial) -> dict:
-        """Get parameters for XGB Regressor Objective with objective specific parameters.
-
-        Args: trial
-
-        Returns:
-            Dictionary with hyperparameter name as key and hyperparamer value as value.
-
-        """
-        # Filtered default parameters
-        model_params = super().get_params(trial)
-
-        # XGB specific parameters
-        params = {
-            "gamma": trial.suggest_float("gamma", 0.0, 1.0),
-            "booster": trial.suggest_categorical("booster", ["gbtree", "dart"]),
-        }
-        return {**model_params, **params}
-
-    def get_pruning_callback(self, trial: optuna.trial.FrozenTrial):
-        return optuna.integration.XGBoostPruningCallback(
-            trial, observation_key=f"validation_1-{self.eval_metric}"
-        )
-
-    @classmethod
-    def get_default_values(cls) -> dict:
-        default_parameter_values = super().get_default_values()
-        default_parameter_values.update({"gamma": 0.0, "booster": "gbtree"})
-        return default_parameter_values
-
-
-class LGBRegressorObjective(RegressorObjective):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.model_type = ModelType.LGB
-
-    def get_params(self, trial: optuna.trial.FrozenTrial) -> dict:
-        """Get parameters for LGB Regressor Objective with objective specific parameters.
-
-        Args: trial
-
-        Returns:
-            Dictionary with hyperparameter name as key and hyperparamer value as value.
-
-        """
-        # Filtered default parameters
-        model_params = super().get_params(trial)
-
-        # LGB specific parameters
-        params = {
-            "num_leaves": trial.suggest_int("num_leaves", 16, 62),
-            "boosting_type": trial.suggest_categorical(
-                "boosting_type", ["gbdt", "dart", "rf"]
-            ),
-            "tree_learner": trial.suggest_categorical(
-                "tree_learner", ["serial", "feature", "data", "voting"]
-            ),
-            "n_estimators": trial.suggest_int("n_estimators", 50, 150),
-            "min_split_gain": trial.suggest_float("min_split_gain", 1e-8, 1),
-            "subsample_freq": trial.suggest_int("subsample_freq", 1, 10),
-        }
-        return {**model_params, **params}
-
-    def get_pruning_callback(self, trial: optuna.trial.FrozenTrial):
-        metric = self.eval_metric
-        if metric == "mae":
-            metric = "l1"
-        return optuna.integration.LightGBMPruningCallback(
-            trial, metric=metric, valid_name="valid_1"
-        )
-
-
-class XGBQuantileRegressorObjective(RegressorObjective):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.model_type = ModelType.XGB_QUANTILE
-
-    def get_params(self, trial: optuna.trial.FrozenTrial) -> dict:
-        """Get parameters for XGBQuantile Regressor Objective with objective specific parameters.
-
-        Args: trial
-
-        Returns:
-            Dictionary with hyperparameter name as key and hyperparamer value as value.
-
-        """
-        # Filtered default parameters
-        model_params = super().get_params(trial)
-
-        # XGB specific parameters
-        params = {
-            "gamma": trial.suggest_float("gamma", 1e-8, 1.0),
-        }
-        return {**model_params, **params}
-
-    def get_pruning_callback(self, trial: optuna.trial.FrozenTrial):
-        return optuna.integration.XGBoostPruningCallback(
-            trial, observation_key=f"validation_1-{self.eval_metric}"
-        )
-
-
-class XGBMultioutputQuantileRegressorObjective(RegressorObjective):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.model_type = ModelType.XGB_QUANTILE
-
-    def get_params(self, trial: optuna.trial.FrozenTrial) -> dict:
-        """Get parameters for XGB Multioutput Quantile Regressor Objective with objective specific parameters.
-
-        Args: trial
-
-        Returns:
-            Dictionary with hyperparameter name as key and hyperparamer value as value.
-
-        """
-        # Filtered default parameters
-        model_params = super().get_params(trial)
-
-        # XGB specific parameters
-        params = {
-            "gamma": trial.suggest_float("gamma", 1e-8, 1.0),
-            "arctan_smoothing": trial.suggest_float("arctan_smoothing", 0.025, 0.15),
-        }
-        return {**model_params, **params}
-
-    def get_pruning_callback(self, trial: optuna.trial.FrozenTrial):
-        return optuna.integration.XGBoostPruningCallback(
-            trial, observation_key=f"validation_1-{self.eval_metric}"
-        )
-
-
-class LinearRegressorObjective(RegressorObjective):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.model_type = ModelType.LINEAR
-
-    def get_params(self, trial: optuna.trial.FrozenTrial) -> dict:
-        """Get parameters for Linear Regressor Objective with objective specific parameters.
-
-        Args: trial
-
-        Returns:
-            Dictionary with hyperparameter name as key and hyperparamer value as value.
-
-        """
-        # Imputation strategy
-        params = {
-            "imputation_strategy": trial.suggest_categorical(
-                "imputation_strategy", ["mean", "median", "most_frequent"]
-            ),
-        }
-        return params
-
-
-class ARIMARegressorObjective(RegressorObjective):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.model_type = ModelType.ARIMA
-
-    def get_params(self, trial: optuna.trial.FrozenTrial) -> dict:
-        """Get parameters for ARIMA Regressor Objective with objective specific parameters.
-
-        Temporary, it seems strange to use optuna for ARIMA models,
-        it is usually done via statistical analysis and heuristics.
-
-        Args: trial
-
-        Returns:
-            Dictionary with hyperparameter name as key and hyperparamer value as value.
-
-        """
-        # Imputation strategy
-        params = {
-            "trend": trial.suggest_categorical("trend", ["n", "c", "t", "ct"]),
-        }
-        return params

openstef/model/objective_creator.py

@@ -1,65 +0,0 @@
-# SPDX-FileCopyrightText: 2017-2023 Contributors to the OpenSTEF project <korte.termijn.prognoses@alliander.com> # noqa E501>
-#
-# SPDX-License-Identifier: MPL-2.0
-
-from typing import Union
-
-from openstef.enums import ModelType
-from openstef.model.objective import (
-    ARIMARegressorObjective,
-    LGBRegressorObjective,
-    LinearRegressorObjective,
-    RegressorObjective,
-    XGBQuantileRegressorObjective,
-    XGBRegressorObjective,
-    XGBMultioutputQuantileRegressorObjective,
-)
-from openstef.model.regressors.custom_regressor import (
-    create_custom_objective,
-    is_custom_type,
-)
-
-
-class ObjectiveCreator:
-    OBJECTIVES = {
-        ModelType.XGB: XGBRegressorObjective,
-        ModelType.LGB: LGBRegressorObjective,
-        ModelType.XGB_QUANTILE: XGBQuantileRegressorObjective,
-        ModelType.XGB_MULTIOUTPUT_QUANTILE: XGBMultioutputQuantileRegressorObjective,
-        ModelType.LINEAR: LinearRegressorObjective,
-        ModelType.LINEAR_QUANTILE: LinearRegressorObjective,
-        ModelType.GBLINEAR_QUANTILE: LinearRegressorObjective,
-        ModelType.ARIMA: ARIMARegressorObjective,
-    }
-
-    @staticmethod
-    def create_objective(model_type: Union[ModelType, str]) -> RegressorObjective:
-        """Create an objective function based on model type.
-
-        Args:
-            model_type: Model type to construct.
-
-        Raises:
-            NotImplementedError: When using an invalid model_type.
-
-        Returns:
-            Objective function
-
-        """
-        try:
-            # This will raise a ValueError when an invalid model_type str is used
-            # and nothing when a MLModelType enum is used.
-            if is_custom_type(model_type):
-                objective = create_custom_objective(model_type)
-            else:
-                model_type = ModelType(model_type)
-                objective = ObjectiveCreator.OBJECTIVES[model_type]
-        except ValueError as e:
-            valid_types = [t.value for t in ModelType]
-            raise NotImplementedError(
-                f"No objective for '{model_type}', "
-                f"valid model_types are: {valid_types}"
-                "or import a custom model"
-            ) from e
-
-        return objective

openstef/model/regressors/__init__.py

@@ -1,3 +0,0 @@
-# SPDX-FileCopyrightText: 2017-2023 Contributors to the OpenSTEF project <korte.termijn.prognoses@alliander.com> # noqa E501>
-#
-# SPDX-License-Identifier: MPL-2.0

openstef/model/regressors/arima.py

@@ -1,197 +0,0 @@
-# SPDX-FileCopyrightText: 2017-2023 Alliander N.V. <korte.termijn.prognoses@alliander.com> # noqa E501>
-#
-# SPDX-License-Identifier: MPL-2.0
-"""This module contains the SARIMAX regressor wrapper around statsmodels implementation."""
-import numpy as np
-import pandas as pd
-import statsmodels.api as sm
-from sklearn.metrics import r2_score
-from sklearn.model_selection import TimeSeriesSplit
-
-from openstef.model.regressors.regressor import OpenstfRegressor
-
-
-class ARIMAOpenstfRegressor(OpenstfRegressor):
-    """Wrapper around statmodels implementation of (S)ARIMA(X) model.
-
-    The fit of an ARIMA statsmodels produces a result object which is used to perform the various computations around forecasting.
-    (see https://www.statsmodels.org/dev/generated/statsmodels.tsa.arima.model.ARIMAResults.html)
-
-    To make a prediction, it needs to update the result object's historic data,
-    ie the past values of the target/endogenous data and the features/exogenous data,
-    applying the fitted parameters to these new data unrelated to the original training data.
-    This update can be performed by the method `update_historic_data`.
-
-    In the following code, we use interchangeably the statmodels and scikit-learn terminology for the variables:
-        - the features 'x' is equivalent to the exogenous data: 'exog' for short.
-        - the target 'y' is equivalent to the endogenous data: 'endog' for short.
-    More information here https://www.statsmodels.org/stable/endog_exog.html.
-
-    """
-
-    def __init__(
-        self,
-        backtest_max_horizon=1440,
-        order=(0, 0, 0),
-        seasonal_order=(0, 0, 0, 0),
-        trend=None,
-    ):
-        self.backtest_max_horizon = backtest_max_horizon
-        self.order = order
-        self.seasonal_order = seasonal_order
-        self.trend = trend
-
-    def fit(self, x, y, **kwargs):
-        dates = x.index
-        self.model_ = sm.tsa.arima.ARIMA(
-            endog=y,
-            exog=x,
-            dates=dates,
-            order=self.order,
-            seasonal_order=self.seasonal_order,
-            trend=self.trend,
-        )
-        self.results_ = self.model_.fit()
-        self.feature_in_names_ = list(x.columns)
-        return self
-
-    def update_historic_data(self, x_past, y_past):
-        """Apply the fitted parameters to new data unrelated to the original training data. It's a side-effect.
-
-        Creates a new result object using the current fitted parameters,
-        applied to a completely new dataset that is assumed to be unrelated to the model’s original data.
-        The new results can then be used for analysis or forecasting.
-        It should be used before forecasting, to wedge the historic data just before the first forecast timestamp,
-        with:
-            - New observations from the modeled time-series process.
-            - New observations of exogenous regressors.
-
-        Parameters
-        ----------
-        x_past : pd.DataFrame
-            The exogenous (features) data.
-        y_past : pd.DataFrame
-            The endogenous (target) data.
-
-        """
-        self.results_ = self.results_.apply(
-            endog=y_past,
-            exog=x_past,
-        )
-
-    def predict_quantile(self, start, end, exog, quantile):
-        """Quantile prediction.
-
-        It relies on the parameters' confidence intervals.
-
-        Parameters
-        ----------
-        start : int, str, or datetime, optional
-            Zero-indexed observation number at which to start forecasting, i.e.,
-            the first forecast is start. Can also be a date string to parse or a datetime type.
-            Default is the the zeroth observation.
-        end : int, str, or datetime, optional
-            Zero-indexed observation number at which to end forecasting, i.e.,
-            the last forecast is end. Can also be a date string to parse or a datetime type.
-            However, if the dates index does not have a fixed frequency,
-            end must be an integer index if you want out of sample prediction.
-            Default is the last observation in the sample.
-        exog : pd.DataFrame
-            Exogenous data (features).
-        quantile : float
-            The quantile for the confidence interval.
-
-        Returns
-        -------
-        pd.Serie
-            The quantile prediction.
-
-        """
-        alpha = quantile
-        idx = 0
-        if quantile > 0.5:
-            alpha = 1 - quantile
-            idx = 1
-        return (
-            self.results_.get_prediction(start, end, exog=exog)
-            .conf_int(alpha=alpha)
-            .iloc[:, idx]
-        )
-
-    def predict(self, x, quantile: float = 0.5, **kwargs):
-        start = x.iloc[0].name
-        end = x.iloc[-1].name
-        predictions = self.results_.predict(start, end, exog=x).to_numpy()
-        if quantile != 0.5:
-            predictions = self.predict_quantile(start, end, exog=x, quantile=quantile)
-        return predictions
-
-    def set_feature_importance(self):
-        """Because report needs 'weight' and 'gain' as importance metrics, we set the values to these names.
-
-        - 'weight' is corresponding to the coefficients values
-        - 'gain' is corresponding to the pvalue for the nullity test of each coefficient
-
-        """
-        importances = pd.DataFrame(
-            {"weight": self.results_.params, "gain": self.results_.pvalues}
-        )
-        return importances
-
-    @property
-    def feature_names(self):
-        """The names of he features used to train the model."""
-        return self.feature_in_names_
-
-    @property
-    def can_predict_quantiles(self):
-        """Indicates wether this model can make quantile predictions."""
-        return True
-
-    def score(self, x, y):
-        """Compute R2 score with backtesting strategy.
-
-        The backtest  is performed by the Time Series cross-validator of scikit-learn which
-        returns first k folds as train set and the (k+1)th fold as test set in the kth split.
-        (see https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.TimeSeriesSplit.html)
-
-        It needs to update the historic data with (x_past, y_past) for each split.
-
-        """
-        ys_true = []
-        ys_pred = []
-
-        # Build the cross-validator
-        freq = pd.infer_freq(x.index)
-        if not (freq[0].isdigit()):
-            freq = f"1{freq}"
-        max_horizon_delta = pd.Timedelta(self.backtest_max_horizon, "minutes")
-        freq_delta = pd.Timedelta(freq)
-        test_size = max_horizon_delta // freq_delta
-        n_splits = (x.shape[0] // test_size) - 1
-        time_series_cross_validator = TimeSeriesSplit(
-            n_splits=n_splits, test_size=test_size
-        )
-
-        # Backtesting
-        for apply_index, test_index in time_series_cross_validator.split(x):
-            # Update the historic data to the current split (ie the k first folds)
-            updated_results = self.results_.apply(
-                y.iloc[apply_index], x.iloc[apply_index]
-            )
-
-            # The (k+1)th fold as the test data
-            x_test, y_true_test = x.iloc[test_index], y.iloc[test_index]
-            start_test = x_test.iloc[0].name
-            end_test = x_test.iloc[-1].name
-
-            # Compute and gather the predictions
-            y_pred_test = updated_results.predict(
-                start=start_test, end=end_test, exog=x_test
-            )
-            ys_true.append(y_true_test)
-            ys_pred.append(y_pred_test)
-
-        ys_true = np.concatenate(ys_true)
-        ys_pred = np.concatenate(ys_pred)
-        return r2_score(ys_true, ys_pred)