openstef 3.4.10__py3-none-any.whl → 3.4.44__py3-none-any.whl

openstef/model/objective.py

@@ -2,13 +2,13 @@
 #
 # SPDX-License-Identifier: MPL-2.0
 import copy
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Callable, Optional
 
 import optuna
 import pandas as pd
 
-from openstef.enums import MLModelType
+from openstef.enums import ModelType
 from openstef.metrics import metrics
 from openstef.metrics.reporter import Report, Reporter
 from openstef.model.regressors.regressor import OpenstfRegressor
@@ -59,7 +59,7 @@ class RegressorObjective:
         self.validation_data = None
         self.test_data = None
         self.model = model
-        self.start_time = datetime.utcnow()
+        self.start_time = datetime.now(timezone.utc)
         self.test_fraction = test_fraction
         self.validation_fraction = validation_fraction
         self.eval_metric = eval_metric
@@ -94,7 +94,7 @@ class RegressorObjective:
         split_args = self.split_args
         if split_args is None:
             split_args = {
-                "stratification_min_max": self.model_type != MLModelType.ProLoaf,
+                "stratification_min_max": True,
                 "back_test": True,
             }
         (
@@ -245,7 +245,7 @@ class RegressorObjective:
 class XGBRegressorObjective(RegressorObjective):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.model_type = MLModelType.XGB
+        self.model_type = ModelType.XGB
 
     # extend the parameters with the model specific ones per implementation
     def get_params(self, trial: optuna.trial.FrozenTrial) -> dict:
@@ -282,7 +282,7 @@ class XGBRegressorObjective(RegressorObjective):
 class LGBRegressorObjective(RegressorObjective):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.model_type = MLModelType.LGB
+        self.model_type = ModelType.LGB
 
     def get_params(self, trial: optuna.trial.FrozenTrial) -> dict:
         """Get parameters for LGB Regressor Objective with objective specific parameters.
@@ -323,7 +323,7 @@ class LGBRegressorObjective(RegressorObjective):
 class XGBQuantileRegressorObjective(RegressorObjective):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.model_type = MLModelType.XGB_QUANTILE
+        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.
@@ -349,13 +349,13 @@ class XGBQuantileRegressorObjective(RegressorObjective):
         )
 
 
-class ProLoafRegressorObjective(RegressorObjective):
+class XGBMultioutputQuantileRegressorObjective(RegressorObjective):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.model_type = MLModelType.ProLoaf
+        self.model_type = ModelType.XGB_QUANTILE
 
     def get_params(self, trial: optuna.trial.FrozenTrial) -> dict:
-        """Get parameters for ProLoaf Regressor Objective with objective specific parameters.
+        """Get parameters for XGB Multioutput Quantile Regressor Objective with objective specific parameters.
 
         Args: trial
 
@@ -366,40 +366,23 @@ class ProLoafRegressorObjective(RegressorObjective):
         # Filtered default parameters
         model_params = super().get_params(trial)
 
-        # ProLoaf specific parameters
+        # XGB specific parameters
         params = {
-            # TODO: look into optimizing this pipeline for proloaf
-            # "relu_leak": trial.suggest_float("relu_leak", 0.1, 1.0),
-            # "core_layers": trial.suggest_int("core_layers", 1, 3),
-            # "rel_linear_hidden_size": trial.suggest_float(
-            #    "rel_linear_hidden_size", 0.1, 1
-            # ),
-            # "rel_core_hidden_size": trial.suggest_float("rel_core_hidden_size", 0.1, 1),
-            # "dropout_fc": trial.suggest_float("dropout_fc", 0.1, 0.9),
-            # "dropout_core": trial.suggest_float("dropout_core", 0.1, 0.9),
-            # "early_stopping_patience": trial.suggest_int(
-            #    "early_stopping_patience", 5, 10
-            # ),
-            # "early_stopping_margin": trial.suggest_float(
-            #    "early_stopping_margin", 0.1, 0.9
-            # ),
-            "max_epochs": trial.suggest_int(
-                "max_epochs", 1, 1
-            ),  # TODO: change after having availability to gpu resource
-            "batch_size": trial.suggest_int("batch_size", 1, 24),
+            "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.PyTorchLightningPruningCallback(
-            trial, monitor="val_loss"
+        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 = MLModelType.LINEAR
+        self.model_type = ModelType.LINEAR
 
     def get_params(self, trial: optuna.trial.FrozenTrial) -> dict:
         """Get parameters for Linear Regressor Objective with objective specific parameters.
@@ -422,7 +405,7 @@ class LinearRegressorObjective(RegressorObjective):
 class ARIMARegressorObjective(RegressorObjective):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.model_type = MLModelType.ARIMA
+        self.model_type = ModelType.ARIMA
 
     def get_params(self, trial: optuna.trial.FrozenTrial) -> dict:
         """Get parameters for ARIMA Regressor Objective with objective specific parameters.

openstef/model/objective_creator.py

@@ -4,15 +4,15 @@
 
 from typing import Union
 
-from openstef.enums import MLModelType
+from openstef.enums import ModelType
 from openstef.model.objective import (
+    ARIMARegressorObjective,
     LGBRegressorObjective,
     LinearRegressorObjective,
-    ProLoafRegressorObjective,
     RegressorObjective,
     XGBQuantileRegressorObjective,
     XGBRegressorObjective,
-    ARIMARegressorObjective,
+    XGBMultioutputQuantileRegressorObjective,
 )
 from openstef.model.regressors.custom_regressor import (
     create_custom_objective,
@@ -22,16 +22,17 @@ from openstef.model.regressors.custom_regressor import (
 
 class ObjectiveCreator:
     OBJECTIVES = {
-        MLModelType.XGB: XGBRegressorObjective,
-        MLModelType.LGB: LGBRegressorObjective,
-        MLModelType.XGB_QUANTILE: XGBQuantileRegressorObjective,
-        MLModelType.ProLoaf: ProLoafRegressorObjective,
-        MLModelType.LINEAR: LinearRegressorObjective,
-        MLModelType.ARIMA: ARIMARegressorObjective,
+        ModelType.XGB: XGBRegressorObjective,
+        ModelType.LGB: LGBRegressorObjective,
+        ModelType.XGB_QUANTILE: XGBQuantileRegressorObjective,
+        ModelType.XGB_MULTIOUTPUT_QUANTILE: XGBMultioutputQuantileRegressorObjective,
+        ModelType.LINEAR: LinearRegressorObjective,
+        ModelType.LINEAR_QUANTILE: LinearRegressorObjective,
+        ModelType.ARIMA: ARIMARegressorObjective,
     }
 
     @staticmethod
-    def create_objective(model_type: Union[MLModelType, str]) -> RegressorObjective:
+    def create_objective(model_type: Union[ModelType, str]) -> RegressorObjective:
         """Create an objective function based on model type.
 
         Args:
@@ -50,10 +51,10 @@ class ObjectiveCreator:
             if is_custom_type(model_type):
                 objective = create_custom_objective(model_type)
             else:
-                model_type = MLModelType(model_type)
+                model_type = ModelType(model_type)
                 objective = ObjectiveCreator.OBJECTIVES[model_type]
         except ValueError as e:
-            valid_types = [t.value for t in MLModelType]
+            valid_types = [t.value for t in ModelType]
             raise NotImplementedError(
                 f"No objective for '{model_type}', "
                 f"valid model_types are: {valid_types}"

openstef/model/regressors/arima.py

@@ -5,9 +5,9 @@
 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
 
 

openstef/model/regressors/dazls.py

@@ -4,65 +4,41 @@
 """This module defines the DAZL model."""
 import numpy as np
 from sklearn.base import BaseEstimator
+from sklearn.compose import TransformedTargetRegressor
+from sklearn.linear_model import LinearRegression
 from sklearn.metrics import mean_squared_error, r2_score
-from sklearn.neighbors import KNeighborsRegressor
+from sklearn.pipeline import Pipeline
 from sklearn.preprocessing import MinMaxScaler
-from sklearn.utils import shuffle
 
 
 class Dazls(BaseEstimator):
     """DAZLS model.
 
-    The model carries out wind and solar power prediction for unseen target substations using training data from
-    other substations with known components.
-
-    Any data-driven model can be plugged and used as the base for the domain and the adaptation model.
-
-    For a full reference, see:
-    Teng, S.Y., van Nooten, C. C., van Doorn, J.M., Ottenbros, A., Huijbregts, M., Jansen, J.J.
-    Improving Near Real-Time Predictions of Renewable Electricity Production at Substation Level (Submitted)
+    The model carries out wind and solar power prediction for unseen target substations using training data from other
+    substations with known components.
 
     """
 
+    model_: Pipeline
+
     def __init__(self):
         """Initialize DAZL model."""
         self.__name__ = "DAZLS"
-        self.domain_model_scaler = MinMaxScaler(clip=True)
-        self.adaptation_model_scaler = MinMaxScaler(clip=True)
-        self.target_scaler = MinMaxScaler(clip=True)
-        self.domain_model = KNeighborsRegressor(n_neighbors=20, weights="uniform")
-        self.adaptation_model = KNeighborsRegressor(n_neighbors=20, weights="uniform")
+
+        regressor = TransformedTargetRegressor(
+            regressor=LinearRegression(),
+            transformer=MinMaxScaler(clip=True),
+        )
+
+        self.model_ = Pipeline(
+            [("scaler", MinMaxScaler(clip=True)), ("regressor", regressor)]
+        )
 
         # The input columns for the domain and adaptation models (with description)
-        self.domain_model_input_columns = [
+        self.baseline_input_columns = [
             "radiation",  # Weather parameter
             "windspeed_100m",  # Weather parameter
-            "total_substation",  # Substation's measured total load
-            "lat",  # Latitude
-            "lon",  # Longitude
-            "solar_on",  # Solar installed on substation: yes=1, no=0
-            "wind_on",  # Wind installed on substation: yes=1, no=0
-            "hour",  # Hour of the day
-            "minute",  # Minute of the hour
-            "var0",  # Variance of the total load
-            "var1",  # Variance of the total pv load (only available for calibration substations)
-            "var2",  # Variance of the total wind load (only available for calibration substations)
-            "sem0",  # Standard Error of the Mean of the total load
-            "sem1",  # Standard Error of the Mean of the total PV load (only available for calibration substations)
-        ]
-        self.adaptation_model_input_columns = [
-            "total_substation",
-            "lat",
-            "lon",
-            "solar_on",
-            "wind_on",
-            "hour",
-            "minute",
-            "var0",
-            "var1",
-            "var2",
-            "sem0",
-            "sem1",
+            "total_load",
         ]
         self.target_columns = ["total_wind_part", "total_solar_part"]
 
@@ -78,30 +54,12 @@ class Dazls(BaseEstimator):
             target: the expected output (y_train)
 
         """
-        x, x2, y = (
-            features.loc[:, self.domain_model_input_columns],
-            features.loc[:, self.adaptation_model_input_columns],
+        x, y = (
+            features.loc[:, self.baseline_input_columns],
             target.loc[:, self.target_columns],
         )
-        domain_model_input, adaptation_model_input, y_train = shuffle(
-            x, x2, y, random_state=999
-        )  # just shuffling
-
-        self.domain_model_scaler.fit(domain_model_input)
-        self.adaptation_model_scaler.fit(adaptation_model_input)
-        self.target_scaler.fit(y_train)
-        domain_model_input = self.domain_model_scaler.transform(domain_model_input)
-        adaptation_model_input = self.adaptation_model_scaler.transform(
-            adaptation_model_input
-        )
-        y_train = self.target_scaler.transform(y_train)
 
-        self.domain_model.fit(domain_model_input, y_train)
-        domain_model_pred = self.domain_model.predict(domain_model_input)
-        adaptation_model_input = np.concatenate(
-            (adaptation_model_input, domain_model_pred), axis=1
-        )
-        self.adaptation_model.fit(adaptation_model_input, y_train)
+        self.model_.fit(x, y)
 
     def predict(self, x: np.array):
         """Make a prediction.
@@ -109,37 +67,21 @@ class Dazls(BaseEstimator):
         For the prediction we use the test data x. We use domain_model_input_columns and
         adaptation_model_input_columns to separate x in test data for domain model and adaptation model respectively.
 
+        There is an option available to return the domain model and adaptation model predictions separately to more
+        easily investigate the effectiveness of the models.
+
         Args:
             x: domain_model_test_data, adaptation_model_test_data
+            return_sub_preds : a flag value indicating to return the predictions of the domain model and adaptation
+                               model separately. (Default: False.)
+
+        Returns:
             prediction: The output prediction after both models.
 
         """
-        domain_model_test_data, adaptation_model_test_data = (
-            x.loc[:, self.domain_model_input_columns],
-            x.loc[:, self.adaptation_model_input_columns],
-        )
-        # Rescale test data for both models (if required)
-        domain_model_test_data_scaled = self.domain_model_scaler.transform(
-            domain_model_test_data
-        )
-        adaptation_model_test_data_scaled = self.adaptation_model_scaler.transform(
-            adaptation_model_test_data
-        )
-        # Use the scaled data to make domain_model_prediction
-        domain_model_test_data_pred = self.domain_model.predict(
-            domain_model_test_data_scaled
-        )
-        # Use the domain_model_prediction to make adaptation_model_prediction
-        adaptation_model_test_data_pred = self.adaptation_model.predict(
-            np.concatenate(
-                [adaptation_model_test_data_scaled, domain_model_test_data_pred], axis=1
-            )
-        )
-        # Rescale adaptation_model_prediction (if required)
-        prediction = self.target_scaler.inverse_transform(
-            adaptation_model_test_data_pred
-        )
-        return prediction
+        model_test_data = x.loc[:, self.baseline_input_columns]
+
+        return self.model_.predict(model_test_data)
 
     def score(self, truth, prediction):
         """Evaluation of the prediction's output.
@@ -165,13 +107,10 @@ class Dazls(BaseEstimator):
         """
         summary_str = (
             f"{self.__name__} model summary:\n\n"
-            f"Domain Model: {self.domain_model} \n"
-            f"\tInput columns: {self.domain_model_input_columns} \n"
-            f"\tScaler: {self.domain_model_scaler} \n\n"
-            f"Adaptation Model: {self.adaptation_model} \n"
-            f"\tInput columns: {self.adaptation_model_input_columns} \n"
-            f"\tScaler: {self.adaptation_model_scaler} \n\n"
-            f"Target columns: {self.target_columns}"
+            f"Model: {self.model_} \n"
+            f"\tInput columns: {self.baseline_input_columns} \n"
+            f"\tScaler: {self.model_['scaler']} \n\n"
+            f"\tRegressor: {self.model_['regressor']} \n\n"
         )
 
         return summary_str

openstef/model/regressors/flatliner.py

@@ -0,0 +1,95 @@
+# SPDX-FileCopyrightText: 2017-2023 Contributors to the OpenSTEF project <korte.termijn.prognoses@alliander.com> # noqa E501>
+#
+# SPDX-License-Identifier: MPL-2.0
+import re
+from typing import List
+
+import numpy as np
+import pandas as pd
+from sklearn.base import RegressorMixin
+from sklearn.utils.validation import check_is_fitted
+
+from openstef.model.regressors.regressor import OpenstfRegressor
+
+
+class FlatlinerRegressor(OpenstfRegressor, RegressorMixin):
+    feature_names_: List[str] = []
+
+    def __init__(self, quantiles=None):
+        """Initialize FlatlinerRegressor.
+
+        The model always predicts 0.0, regardless of the input features. The model is meant to be used for flatliner
+        locations that still expect a prediction while preserving the prediction interface.
+
+        """
+        super().__init__()
+        self.quantiles = quantiles
+
+    @property
+    def feature_names(self) -> list:
+        """The names of the features used to train the model."""
+        check_is_fitted(self)
+        return self.feature_names_
+
+    @staticmethod
+    def _get_importance_names():
+        return {
+            "gain_importance_name": "total_gain",
+            "weight_importance_name": "weight",
+        }
+
+    @property
+    def can_predict_quantiles(self) -> bool:
+        """Attribute that indicates if the model predict particular quantiles."""
+        return True
+
+    def fit(self, x: pd.DataFrame, y: pd.Series, **kwargs) -> RegressorMixin:
+        """Fits flatliner model.
+
+        Args:
+            x: Feature matrix
+            y: Labels
+
+        Returns:
+            Fitted LinearQuantile model
+
+        """
+        self.feature_names_ = list(x.columns)
+        self.feature_importances_ = np.ones(len(self.feature_names_)) / (
+            len(self.feature_names_) or 1.0
+        )
+
+        return self
+
+    def predict(self, x: pd.DataFrame, quantile: float = 0.5, **kwargs) -> np.array:
+        """Makes a prediction for a desired quantile.
+
+        Args:
+            x: Feature matrix
+            quantile: Quantile for which a prediciton is desired,
+                note that only quantile are available for which a model is trained,
+                and that this is a quantile-model specific keyword
+
+        Returns:
+            Prediction
+
+        Raises:
+            ValueError in case no model is trained for the requested quantile
+
+        """
+        check_is_fitted(self)
+
+        return np.zeros(x.shape[0])
+
+    def _get_feature_importance_from_linear(self, quantile: float = 0.5) -> np.array:
+        check_is_fitted(self)
+        return np.array([0.0 for _ in self.feature_names_])
+
+    @classmethod
+    def _get_param_names(cls):
+        return [
+            "quantiles",
+        ]
+
+    def __sklearn_is_fitted__(self) -> bool:
+        return True