openstef 3.4.23__py3-none-any.whl → 3.4.25__py3-none-any.whl

openstef/data_classes/prediction_job.py

@@ -26,6 +26,7 @@ class PredictionJobDataClass(BaseModel):
         - ``"lgb"``
         - ``"linear"``
         - ``"linear_quantile"``
+        - ``"xgb_multioutput_quantile"``
 
     If unsure what to pick, choose ``"xgb"``.
 

openstef/enums.py

@@ -8,6 +8,7 @@ from enum import Enum
 class MLModelType(Enum):
     XGB = "xgb"
     XGB_QUANTILE = "xgb_quantile"
+    XGB_MULTIOUTPUT_QUANTILE = "xgb_multioutput_quantile"
     LGB = "lgb"
     LINEAR = "linear"
     LINEAR_QUANTILE = "linear_quantile"

openstef/metrics/metrics.py

@@ -431,3 +431,54 @@ def xgb_quantile_obj(
     hess = np.ones_like(preds)
 
     return grad, hess
+
+
+def arctan_loss(y_true, y_pred, taus, s=0.1):
+    """Compute the arctan pinball loss.
+
+    Note that XGBoost outputs the predictions in a slightly peculiar manner.
+    Suppose we have 100 data points and we predict 10 quantiles. The predictions
+    will be an array of size (1000 x 1). We first resize this to a (100x10) array
+    where each row corresponds to the 10 predicted quantile for a single data
+    point. We then use a for-loop (over the 10 columns) to calculate the gradients
+    and second derivatives. Legibility was chosen over efficiency. This part
+    can be made more efficient.
+
+    Args:
+        y_true: An array containing the true observations.
+        y_pred: An array containing the predicted quantiles.
+        taus: A list containing the true desired coverage of the quantiles.
+        s: A smoothing parameter.
+
+    Returns:
+        grad: An array containing the (negative) gradients with respect to y_pred.
+        hess: An array containing the second derivative with respect to y_pred.
+
+    """
+    size = len(y_true)
+    n_dim = len(taus)  # The number of columns
+    n_rows = size // n_dim
+
+    # Resize the predictions and targets.
+    # Each column corresponds to a quantile, each row to a data point.
+    y_pred = np.reshape(y_pred, (n_rows, n_dim))
+    y_true = np.reshape(y_true, (n_rows, n_dim))
+
+    # Calculate the differences
+    u = y_true - y_pred
+
+    # Calculate the gradient and second derivatives
+    grad = np.zeros_like(y_pred)
+    hess = np.zeros_like(y_pred)
+    z = u / s
+    for i, tau in enumerate(taus):
+        x = 1 + z[:, i] ** 2
+        grad[:, i] = (
+            tau - 0.5 + 1 / np.pi * np.arctan(z[:, i]) + z[:, i] / (np.pi) * x**-1
+        )
+        hess[:, i] = 2 / (np.pi * s) * x ** (-2)
+
+    # Reshape back to the original shape.
+    grad = grad.reshape(size)
+    hess = hess.reshape(size)
+    return -grad / n_dim, hess / n_dim

openstef/model/model_creator.py

@@ -15,6 +15,9 @@ from openstef.model.regressors.linear_quantile import LinearQuantileOpenstfRegre
 from openstef.model.regressors.regressor import OpenstfRegressor
 from openstef.model.regressors.xgb import XGBOpenstfRegressor
 from openstef.model.regressors.xgb_quantile import XGBQuantileOpenstfRegressor
+from openstef.model.regressors.xgb_multioutput_quantile import (
+    XGBMultiOutputQuantileOpenstfRegressor,
+)
 from openstef.settings import Settings
 
 structlog.configure(
@@ -87,6 +90,16 @@ valid_model_kwargs = {
         "max_depth",
         "early_stopping_rounds",
     ],
+    MLModelType.XGB_MULTIOUTPUT_QUANTILE: [
+        "quantiles",
+        "gamma",
+        "colsample_bytree",
+        "subsample",
+        "min_child_weight",
+        "max_depth",
+        "early_stopping_rounds",
+        "arctan_smoothing",
+    ],
     MLModelType.LINEAR: [
         "missing_values",
         "imputation_strategy",
@@ -117,6 +130,7 @@ class ModelCreator:
         MLModelType.XGB: XGBOpenstfRegressor,
         MLModelType.LGB: LGBMOpenstfRegressor,
         MLModelType.XGB_QUANTILE: XGBQuantileOpenstfRegressor,
+        MLModelType.XGB_MULTIOUTPUT_QUANTILE: XGBMultiOutputQuantileOpenstfRegressor,
         MLModelType.LINEAR: LinearOpenstfRegressor,
         MLModelType.LINEAR_QUANTILE: LinearQuantileOpenstfRegressor,
         MLModelType.ARIMA: ARIMAOpenstfRegressor,

openstef/model/objective.py

@@ -349,6 +349,36 @@ class XGBQuantileRegressorObjective(RegressorObjective):
         )
 
 
+class XGBMultioutputQuantileRegressorObjective(RegressorObjective):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.model_type = MLModelType.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)

openstef/model/objective_creator.py

@@ -12,6 +12,7 @@ from openstef.model.objective import (
     RegressorObjective,
     XGBQuantileRegressorObjective,
     XGBRegressorObjective,
+    XGBMultioutputQuantileRegressorObjective,
 )
 from openstef.model.regressors.custom_regressor import (
     create_custom_objective,
@@ -24,7 +25,9 @@ class ObjectiveCreator:
         MLModelType.XGB: XGBRegressorObjective,
         MLModelType.LGB: LGBRegressorObjective,
         MLModelType.XGB_QUANTILE: XGBQuantileRegressorObjective,
+        MLModelType.XGB_MULTIOUTPUT_QUANTILE: XGBMultioutputQuantileRegressorObjective,
         MLModelType.LINEAR: LinearRegressorObjective,
+        MLModelType.LINEAR_QUANTILE: LinearRegressorObjective,
         MLModelType.ARIMA: ARIMARegressorObjective,
     }
 

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.
-    This model has two sub-models:
-
-    - domain model : a model taking a set of 'input' features of a substation and make an 'initial' prediction.
-      Input features can be features such as: weather, geospatial, total load, etc.
-      These features are always directly related to the components' size in some way.
-
-
-    - adaptation model : a model taking a set of 'meta' features of a substation and refines the domain model's
-      prediction. Next to the features, it is trained on the domain model's predictions.
-      'Meta' features are features related to the uncertainty of the data, and include:
-      variance of the total load, standard deviation of the total load, etc.
-
-    Any data-driven model can be plugged and used as the base for the domain and the adaptation model.
-
-    CAUTION : 'Meta' features should be kept out of the domain model, and vice versa input features should be
-    kept out 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)
-
-    Args:
-        - BaseEstimator (object) : a base model that can be used to carry out predictions.
+    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
-            "hour",  # Hour of the day
-            "minute",  # Minute of the hour
-        ]
-        self.adaptation_model_input_columns = [
-            "var_total",  # Variance of the total load
-            "sem_total",  # Standard Error of the Mean of the total load
+            "total_load",
         ]
         self.target_columns = ["total_wind_part", "total_solar_part"]
 
@@ -76,34 +52,15 @@ class Dazls(BaseEstimator):
         Args:
             features: inputs for domain and adaptation model (domain_model_input, adaptation_model_input)
             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, return_sub_preds: bool = False):
+    def predict(self, x: np.array):
         """Make a prediction.
 
         For the prediction we use the test data x. We use domain_model_input_columns and
@@ -119,41 +76,10 @@ class Dazls(BaseEstimator):
 
         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
-        )
+        model_test_data = x.loc[:, self.baseline_input_columns]
 
-        if return_sub_preds:
-            prediction_domain = self.target_scaler.inverse_transform(
-                domain_model_test_data_pred
-            )
-            return prediction, prediction_domain
-        else:
-            return prediction
+        return self.model_.predict(model_test_data)
 
     def score(self, truth, prediction):
         """Evaluation of the prediction's output.
@@ -164,7 +90,6 @@ class Dazls(BaseEstimator):
 
         Returns:
             RMSE and R2 scores
-
         """
         rmse = (mean_squared_error(truth, prediction)) ** 0.5
         r2_score_value = r2_score(truth, prediction)
@@ -175,17 +100,13 @@ class Dazls(BaseEstimator):
 
         Returns:
             Summary represented by a string
-
         """
         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/xgb_multioutput_quantile.py

@@ -0,0 +1,261 @@
+# SPDX-FileCopyrightText: 2017-2023 Contributors to the OpenSTEF project <korte.termijn.prognoses@alliander.com> # noqa E501>
+#
+# SPDX-License-Identifier: MPL-2.0
+from functools import partial
+from typing import Dict, Optional, Sequence, Tuple, Union
+
+import numpy as np
+import pandas as pd
+import sklearn.base
+import xgboost as xgb
+from sklearn.compose import TransformedTargetRegressor
+from sklearn.preprocessing import StandardScaler
+from sklearn.utils.validation import check_array, check_is_fitted, check_X_y
+from xgboost import Booster
+
+import openstef.metrics.metrics as metrics
+from openstef.model.regressors.regressor import OpenstfRegressor
+
+DEFAULT_QUANTILES: tuple[float, ...] = (0.9, 0.5, 0.1)
+
+
+class XGBMultiOutputQuantileOpenstfRegressor(OpenstfRegressor):
+    r"""Model that provides multioutput quantile regression with XGBoost by default using the arctan loss function.
+
+    Arctan loss:
+        Refence: https://github.com/LaurensSluyterman/XGBoost_quantile_regression/tree/master
+        The key idea is to use a smooth approximation of the pinball loss, the arctan
+        pinball loss, that has a relatively large second derivative.
+
+        The approximation is given by:
+        $$L^{(\text{arctan})}_{\tau, s}(u) = (\tau - 0.5 + \frac{\arctan (u/s)}{\pi})u   + \frac{s}{\pi}$$.  # noqa E501
+
+        Some important settings:
+
+        * The parameter in the loss function determines the amount of smoothing. A
+            smaller values gives a closer approximation but also a much smaller second
+            derivative. A larger value gives more conservative quantiles when
+            is larger than 0.5, the quantile becomes larger and vice versa.
+            Values between 0.05 and 0.1 appear to work well. It may be a good idea to
+            optimize this parameter.
+        * Set min-child-weight to zero. The second derivatives can be a lot smaller
+            than 1 and this parameter may prevent any splits.
+        * Use a relatively small max-delta-step. We used a default of 0.5.
+            This prevents excessive steps that could happen due to the relatively
+            small second derivative.
+        * For the same reason, use a slightly lower learning rate of 0.05.
+
+    """
+
+    estimator_: TransformedTargetRegressor
+    quantile_indices_: Dict[float, int]
+
+    @staticmethod
+    def _get_importance_names():
+        return {
+            "gain_importance_name": "total_gain",
+            "weight_importance_name": "weight",
+        }
+
+    def __init__(
+        self,
+        quantiles: tuple[float, ...] = DEFAULT_QUANTILES,
+        gamma: float = 0.0,
+        colsample_bytree: float = 1.0,
+        subsample: float = 1.0,
+        min_child_weight: int = 0,
+        max_depth: int = 6,
+        learning_rate: float = 0.22,
+        alpha: float = 0.0,
+        max_delta_step: int = 0.5,
+        arctan_smoothing: float = 0.055,
+        early_stopping_rounds: Optional[int] = None,
+    ):
+        """Initialize XGBMultiQuantileRegressor.
+
+        Model that provides quantile regression with XGBoost.
+        For each desired quantile an XGBoost model is trained,
+        these can later be used to predict quantiles.
+
+        Args:
+            quantiles: Tuple with desired quantiles, quantile 0.5 is required.
+                For example: (0.1, 0.5, 0.9)
+            gamma: Gamma.
+            colsample_bytree: Colsample by tree.
+            subsample: Subsample.
+            min_child_weight: Minimum child weight.
+            max_depth: Maximum depth.
+            learning_rate: Learning rate.
+            alpha: Alpha.
+            max_delta_step: Maximum delta step.
+            arctan_smoothing: smoothing parameter of the arctan loss function.
+            early_stopping_rounds: Number of rounds to stop training if no improvement
+                is made.
+
+        Raises:
+            ValueError in case quantile 0.5 is not in the requested quantiles.
+
+        """
+        super().__init__()
+        if 0.5 not in quantiles:
+            raise ValueError(
+                "Cannot train quantile model as 0.5 is not in requested quantiles!"
+            )
+
+        self.quantiles = quantiles
+
+        # Set attributes for hyper parameters
+        self.subsample = subsample
+        self.min_child_weight = min_child_weight
+        self.max_depth = max_depth
+        self.gamma = gamma
+        self.alpha = alpha
+        self.max_delta_step = max_delta_step
+        self.colsample_bytree = colsample_bytree
+        self.learning_rate = learning_rate
+        self.early_stopping_rounds = early_stopping_rounds
+        self.arctan_smoothing = arctan_smoothing
+
+        # Get fitting parameters - only those required for xgbooster's
+        xgb_regressor_params = {
+            key: value
+            for key, value in self.get_params().items()
+            if key in xgb.XGBRegressor().get_params().keys()
+        }
+
+        # Define the model
+        objective = partial(
+            metrics.arctan_loss, taus=self.quantiles, s=arctan_smoothing
+        )
+        xgb_model: xgb.XGBRegressor = xgb.XGBRegressor(
+            objective=objective,
+            base_score=0,
+            multi_strategy="one_output_per_tree",
+            **xgb_regressor_params,
+        )
+        self.estimator_ = TransformedTargetRegressor(
+            regressor=xgb_model, transformer=StandardScaler()
+        )
+
+        # Set quantile indices to remap multioutput predictions
+        self.quantile_indices_ = {
+            quantile: i for i, quantile in enumerate(self.quantiles)
+        }
+
+    def fit(
+        self,
+        x: np.array,
+        y: np.array,
+        eval_set: Optional[Sequence[Tuple[np.array, np.array]]] = None,
+        verbose: Optional[Union[bool, int]] = 0,
+        **kwargs
+    ) -> OpenstfRegressor:
+        """Fits xgb quantile model.
+
+        Args:
+            x: Feature matrix.
+            y: Labels.
+            eval_set: Evaluation set to monitor training performance.
+            verbose: Verbosity level (disabled by default).
+
+        Returns:
+            Fitted XGBQuantile model.
+
+        """
+        if isinstance(y, pd.Series):
+            y = y.to_numpy()
+
+        if not isinstance(x, pd.DataFrame):
+            x = pd.DataFrame(np.asarray(x))
+
+        # Check/validate input
+        check_X_y(x, y, force_all_finite="allow-nan")
+
+        # Prepare inputs
+        y_multioutput = replicate_for_multioutput(y, len(self.quantiles))
+
+        # Define watchlist if eval_set is defined
+        eval_set_multioutput = []
+        if eval_set:
+            for x_eval, y_eval in eval_set:
+                if isinstance(y_eval, pd.Series):
+                    y_eval = y_eval.to_numpy()
+
+                y_eval_multioutput = replicate_for_multioutput(
+                    y=y_eval, num_quantiles=len(self.quantiles)
+                )
+                eval_set_multioutput.append((x_eval, y_eval_multioutput))
+
+            eval_set_multioutput.append((x, y_multioutput))
+
+        self.estimator_.fit(
+            X=x.copy(deep=True),
+            y=y_multioutput,
+            eval_set=eval_set_multioutput,
+            verbose=verbose,
+        )
+
+        # Update state of the estimator
+        self.feature_importances_ = self.estimator_.regressor_.feature_importances_
+        self.is_fitted_ = True
+
+        return self
+
+    def predict(self, x: np.array, quantile: float = 0.5) -> 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 if model is trained for this quantile
+        if quantile not in self.quantiles:
+            raise ValueError("No model trained for requested quantile!")
+
+        # Check/validate input
+        check_array(x, force_all_finite="allow-nan")
+        check_is_fitted(self)
+
+        # best_iteration is only available if early stopping was used during training
+        prediction: np.array
+        if hasattr(self.estimator_, "best_iteration"):
+            prediction = self.estimator_.predict(
+                X=x,
+                iteration_range=(0, self.estimator_.best_iteration + 1),
+            )
+        else:
+            prediction = self.estimator_.predict(X=x)
+
+        quantile_index = self.quantile_indices_[quantile]
+        return prediction[:, quantile_index]
+
+    @property
+    def feature_names(self):
+        return self.estimator_.feature_names_in_
+
+    @property
+    def can_predict_quantiles(self):
+        return True
+
+
+def replicate_for_multioutput(y: np.array, num_quantiles: int) -> np.array:
+    """Replicates a 1D array to a 2D array for multioutput regression.
+
+    Args:
+        y: 1D array.
+        num_quantiles: Number of columns in the output array.
+
+    Returns:
+        2D array with shape (len(y), num_quantiles)
+
+    """
+    return np.repeat(y[:, None], num_quantiles, axis=1)

openstef/pipeline/create_component_forecast.py

@@ -18,7 +18,7 @@ from openstef.settings import Settings
 
 # Set the path for the Dazls stored model
 DAZLS_STORED = str(
-    PROJECT_ROOT / "openstef" / "data" / "dazls_model_3.4.7" / "dazls_stored_3.4.7_"
+    PROJECT_ROOT / "openstef" / "data" / "dazls_model_3.4.24" / "dazls_stored_3.4.24_"
 )
 
 
@@ -113,24 +113,7 @@ def create_components_forecast_pipeline(
         # Save and load the model as .sav file (or as .z file)
         # For the code contact: korte.termijn.prognoses@alliander.com
         dazls_model = Dazls()
-        dazls_model.domain_model = joblib.load(DAZLS_STORED + "domain_model.z")
-        dazls_model.domain_model_scaler = joblib.load(
-            DAZLS_STORED + "domain_model_scaler.z"
-        )
-        dazls_model.domain_model_input_columns = joblib.load(
-            DAZLS_STORED + "domain_model_features.z"
-        )
-
-        dazls_model.adaptation_model = joblib.load(DAZLS_STORED + "adaptation_model.z")
-        dazls_model.adaptation_model_scaler = joblib.load(
-            DAZLS_STORED + "adaptation_model_scaler.z"
-        )
-        dazls_model.adaptation_model_input_columns = joblib.load(
-            DAZLS_STORED + "adaptation_model_features.z"
-        )
-
-        dazls_model.target_columns = joblib.load(DAZLS_STORED + "target.z")
-        dazls_model.target_scaler = joblib.load(DAZLS_STORED + "target_scaler.z")
+        dazls_model.model_ = joblib.load(DAZLS_STORED + "baseline_model.z")
 
         logger.info("DAZLS model loaded", dazls_model=str(dazls_model))
 

{openstef-3.4.23.dist-info → openstef-3.4.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openstef
-Version: 3.4.23
+Version: 3.4.25
 Summary: Open short term energy forecaster
 Home-page: https://github.com/OpenSTEF/openstef
 Author: Alliander N.V
@@ -128,4 +128,4 @@ Please read [CODE_OF_CONDUCT.md](https://github.com/OpenSTEF/.github/blob/main/C
 
 # Contact
 Please read [SUPPORT.md](https://github.com/OpenSTEF/.github/blob/main/SUPPORT.md) for how to connect and get into contact with the OpenSTEF project
-
+ 

{openstef-3.4.23.dist-info → openstef-3.4.25.dist-info}/RECORD

@@ -1,35 +1,17 @@
 openstef/__init__.py,sha256=93UM6m0LLQhO69-mSqLuUy73jgs4W7Iuxfo3Lm8c98g,419
 openstef/__main__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/app_settings.py,sha256=EJTDtimctFQQ-3f7ZcOQaRYohpZk3JD6aZBWPFYM2_A,582
-openstef/enums.py,sha256=LRKvmrCP_ntLE-r-AzKeSGt569WUfX0uX5db8Rk_Ag8,669
+openstef/enums.py,sha256=i2EujJ6giJpzcxQYyVtr07D6DFnAmJpS7KEByZ2chMw,727
 openstef/exceptions.py,sha256=U4u2LTcdT6cmzpipT2Jh7kq9nCjT_-6gntn8yjuhGU0,1993
 openstef/settings.py,sha256=nSgkBqFxuqB3w7Rwo60i8j37c5ngDbt6vpjHS6QtJXQ,354
 openstef/data/dutch_holidays_2020-2022.csv,sha256=pS-CjE0igYXd-2dG-MlqyvR2fgYgXkbNmgCKyTjmwxs,23704
 openstef/data/dutch_holidays_2020-2022.csv.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
 openstef/data/pv_single_coefs.csv,sha256=jadIEYdHvl1lnV_06X_FASkJZ6C3Hecs5xZnH1gPMvI,24779
 openstef/data/pv_single_coefs.csv.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_adaptation_model.z,sha256=BRtD0Wr9DmMJypYxdWOY2xHFe_tg0-Jz9nnlInvswHM,29609700
-openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_adaptation_model.z.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_adaptation_model_features.z,sha256=J9mF1mqfVwrZoyzJ8VoWPehKIoGtRakfe1a1m5lZt5I,88
-openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_adaptation_model_features.z.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_adaptation_model_scaler.z,sha256=qukM4z9nZBi_70-1Y5RXpB2tEOwt8oI3KlDVkhnpnVM,879
-openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_adaptation_model_scaler.z.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_domain_model.z,sha256=Sissl8ax7pm7Y3zWeoE350GTC3-Dl6iAEQl5_zbZe7g,32608923
-openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_domain_model.z.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_domain_model_features.z,sha256=UUwyRZcUl4S884R86bL-8g9llaDHINmW5-WRoMJF0Do,123
-openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_domain_model_features.z.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_domain_model_scaler.z,sha256=MddERJN1LmFrgSgzEnIxrpvbL8-dn4iLsyCMXBQDs8o,1173
-openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_domain_model_scaler.z.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_model_card.md,sha256=HwYMHaYLqIZbxKbZEDVstp30P0VENLRdlVQJnmFxFqo,534
-openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_model_card.md.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_target.z,sha256=7GkwwyQPJosqmGa0LslpfYIf8qgLDMW9Krx8CM_YO10,40
-openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_target.z.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_target_scaler.z,sha256=HFldCZItBFxDkFrtg36RS-zyrHHGKOILXya-_hmluYM,686
-openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_target_scaler.z.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
 openstef/data_classes/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/data_classes/data_prep.py,sha256=gRSL7UiHvZis8m8z7VoTCZc0Ccffhef5_hmSyApnqK0,3417
 openstef/data_classes/model_specifications.py,sha256=Uod1W3QzhRqVLb6zvXwxh9wRL3EHCzSvX0oDNd28cFk,1197
-openstef/data_classes/prediction_job.py,sha256=t4PtGFWAX27AeaqDOtdhECuiosuCiuL0hBK7D1l3ghU,5165
+openstef/data_classes/prediction_job.py,sha256=hjJmOBzVNEb3w3Iqh6e1nSoHmToentMwnEghnvHodpI,5206
 openstef/data_classes/split_function.py,sha256=ljQIQQu1t1Y_CVWGAy25jrM6wG9odIVVQVimrT1n-1s,3358
 openstef/feature_engineering/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/feature_engineering/apply_features.py,sha256=-3fyisOVj9ckIkRe2iYfWutbXSX8iqBkcvt8AYr-gmE,3906
@@ -43,15 +25,15 @@ openstef/feature_engineering/missing_values_transformer.py,sha256=pKz_vRZRzfUNBw
 openstef/feature_engineering/weather_features.py,sha256=Lr9DItyHvJ2CpWQ1r6A83tJKtR2k_Wwn32FdFTGblO0,15750
 openstef/metrics/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/metrics/figure.py,sha256=KDoezYem9wdS13kUx7M7FOy-4u88Sg3OX1DuhNT6kgQ,9751
-openstef/metrics/metrics.py,sha256=t2BIqflvmwzfa6UqS5jpAtNvailpDgD0J09bxjvGlMc,13341
+openstef/metrics/metrics.py,sha256=si93EP2i34v3IPg-nOcm_aheoFAdu46i3azV_PjPmF8,15237
 openstef/metrics/reporter.py,sha256=w1Q6xWoYGmvnjwjXik-Gz7_gnb0lOeJMep-whEV5mNk,7897
 openstef/model/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/model/basecase.py,sha256=caI6Q-8y0ymlxGK9Js_H3Vh0q6ruNHlGD5RG0_kE5M0,2878
 openstef/model/confidence_interval_applicator.py,sha256=XAk3m4gPhneCoQJlOmyEcoeI0sdHNC-ch4T1CWWHPrQ,8934
 openstef/model/fallback.py,sha256=VV9ehgnoMZtWzqKk9H1t8wnERFh5CyC4TvDIuRP_ZDI,2861
-openstef/model/model_creator.py,sha256=XQXtYI_q4Q2a2P-8I3lUuTMZqet3nqsNE7mzmjNsxIg,5310
-openstef/model/objective.py,sha256=eqNBYGfhEVGegOm0PbizowuFImKblRqHgxkp9lgaKQc,13500
-openstef/model/objective_creator.py,sha256=Rjd2YF1Ie9Z-au_v4fOuR63IcM69EEeoe_5Hj_Dz8-E,1970
+openstef/model/model_creator.py,sha256=rQI7aEUcNI58x43vHmIRCIhymCis56SfLo3bhPBn410,5755
+openstef/model/objective.py,sha256=2wPoONbk11WbySyPyqFMmXBx2lDFeUq_7jFPaCNETao,14572
+openstef/model/objective_creator.py,sha256=_qIjq0ckrVIFr7k0L0NN0WyF0LIDaEYWA9NtVLzGs9g,2167
 openstef/model/serializer.py,sha256=IUiiAWvoGVoWzmS-akI6LC7jHRY5Ln_vOCBZy1LnESY,17238
 openstef/model/standard_deviation_generator.py,sha256=Od9bzXi2TLb1v8Nz-VhBMZHSopWH6ssaDe8gYLlqO1I,2911
 openstef/model/metamodels/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
@@ -60,12 +42,13 @@ openstef/model/metamodels/missing_values_handler.py,sha256=veyvYZHhKvlYZxaUpxRQ7
 openstef/model/regressors/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/model/regressors/arima.py,sha256=wt7FVykjSvljpl7vjtliq61SiyjQ7KKtw8PF9x0xf04,7587
 openstef/model/regressors/custom_regressor.py,sha256=Hsmxahc9nfSWD0aEZ6cm4pxW2noQ8B1SujS17_fmxcU,1768
-openstef/model/regressors/dazls.py,sha256=cCYFewJEv3Fn01wdZpaKNSiYmEwzuED7PQrrWzwyTEg,8084
+openstef/model/regressors/dazls.py,sha256=dQMx11kfMZCl4K61n8Dug2CyBhjlmiw3-ilv7KmowqM,3990
 openstef/model/regressors/lgbm.py,sha256=zCdn1euEdSFxYJzH8XqQFFnb6R4JVUnmineKjX_Gy-g,800
 openstef/model/regressors/linear.py,sha256=uOvZMLGZH_9nXfmS5honCMfyVeyGXP1Cza9A_BdXlVw,3665
 openstef/model/regressors/linear_quantile.py,sha256=N-cia8aba39Th6BzOdtcESLuxhY9YtSGaOYIc6STgag,7830
 openstef/model/regressors/regressor.py,sha256=uJcx59AyCPE9f_yPcAQ59h2ZS7eNsDpIHJrladKvHIw,3461
 openstef/model/regressors/xgb.py,sha256=HggA1U10srzdysjV560BMMX66kfaxCKAnOZB3JyyT_Y,808
+openstef/model/regressors/xgb_multioutput_quantile.py,sha256=xWzA7tymC_o-F1OS3I7vUKf9zP6RR1ZglEeY4NAgjU0,9146
 openstef/model/regressors/xgb_quantile.py,sha256=PzKIxqN_CnEPFmzXACNuzLSmZSHbooTuiJ5ckJ9vh_E,7805
 openstef/model_selection/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/model_selection/model_selection.py,sha256=R34tJBecZo6IiUwCCRLeBI2ZCX6GP8W7FDBlGFWtmG8,11167
@@ -74,7 +57,7 @@ openstef/monitoring/performance_meter.py,sha256=6aCGjJFXFq-7qwaJyBkF3MLqjgVK6FMF
 openstef/monitoring/teams.py,sha256=A-tlZeuAgolxFHjgT3gGjraxzW2dmuB-UAOz4xgYNIQ,6668
 openstef/pipeline/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/pipeline/create_basecase_forecast.py,sha256=YkpiqohETTAETb4GiVlK_btw5dpixJy2LmFZdm10iaI,4623
-openstef/pipeline/create_component_forecast.py,sha256=A0dmILy_BuAAf2U_9i2FOj6KItIdZdGzi6hNDk-da4Q,6416
+openstef/pipeline/create_component_forecast.py,sha256=XlE9oo37qwmZPE2Dgg19CDfFPRKgrLuyW069pS035UQ,5668
 openstef/pipeline/create_forecast.py,sha256=F09civdIumNQwJq2hraea5QTQx7DgvEliXKs4Y3f8Mc,5689
 openstef/pipeline/optimize_hyperparameters.py,sha256=3SLkcLR7XC4IeN48C-XT_lxlfCqW_D0NoMpZcrB9UUM,11045
 openstef/pipeline/train_create_forecast_backtest.py,sha256=-kZqCWal5zYLL0k0Sapks1zTmU5unNAooVPaPos1_7E,6050
@@ -100,8 +83,8 @@ openstef/tasks/utils/predictionjobloop.py,sha256=Ysy3zF5lzPMz_asYDKeF5m0qgVT3tCt
 openstef/tasks/utils/taskcontext.py,sha256=L9K14ycwgVxbIVUjH2DIn_QWbnu-OfxcGtQ1K9T6sus,5630
 openstef/validation/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/validation/validation.py,sha256=628xaDbAm8B4AYtFOAn8_SXLjejNfULGCfX3hVf_mU0,11119
-openstef-3.4.23.dist-info/LICENSE,sha256=7Pm2fWFFHHUG5lDHed1vl5CjzxObIXQglnYsEdtjo_k,14907
-openstef-3.4.23.dist-info/METADATA,sha256=ZtURJ-TH2PoNGcDMSM3F7sSASCuGOYUhI1i3qCzGlEY,7393
-openstef-3.4.23.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-openstef-3.4.23.dist-info/top_level.txt,sha256=kD0H4PqrQoncZ957FvqwfBxa89kTrun4Z_RAPs_HhLs,9
-openstef-3.4.23.dist-info/RECORD,,
+openstef-3.4.25.dist-info/LICENSE,sha256=7Pm2fWFFHHUG5lDHed1vl5CjzxObIXQglnYsEdtjo_k,14907
+openstef-3.4.25.dist-info/METADATA,sha256=RahtAo0FrqIzmTJhj7dvqCRL53PlDod_bUGASwLxnKU,7394
+openstef-3.4.25.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+openstef-3.4.25.dist-info/top_level.txt,sha256=kD0H4PqrQoncZ957FvqwfBxa89kTrun4Z_RAPs_HhLs,9
+openstef-3.4.25.dist-info/RECORD,,

openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_adaptation_model.z.license

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

openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_adaptation_model_features.z.license

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

openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_adaptation_model_scaler.z.license

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

openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_domain_model.z.license

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

openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_domain_model_features.z

@@ -1,2 +0,0 @@
-x^%�;
-�0DS����#U�}� $c��

openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_domain_model_features.z.license

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

openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_domain_model_scaler.z.license

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

openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_model_card.md

@@ -1,14 +0,0 @@
-"
-    # Model details : dazls_model_test_eval
-    
-    ## Description
-    **Model Name**: dazls_model_test_eval
-    **Author**: KTP, Alliander
-    **Model type**: Energy splitting model
-    **Model Architecture**: KNeighestNeighbours
-    **Date**: 2024-01-31
-    
-    ## Intended use
-    This is a DAZLs model aimed at determining the energy splits for substations. 
-    Each of these splits are determined based on a set of features that are available in production,
-    and in this case have their origin in the Dutch energy grid. 

openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_model_card.md.license

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

openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_target.z.license

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

openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_target_scaler.z.license

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