openstef 3.4.19__py3-none-any.whl → 3.4.21__py3-none-any.whl

openstef/data_classes/prediction_job.py

@@ -25,10 +25,13 @@ class PredictionJobDataClass(BaseModel):
         - ``"xgb_quantile"``
         - ``"lgb"``
         - ``"linear"``
+        - ``"linear_quantile"``
 
     If unsure what to pick, choose ``"xgb"``.
 
     """
+    model_kwargs: Optional[dict]
+    """The model parameters that should be used."""
     forecast_type: str
     """The type of forecasts that should be made.
 

openstef/enums.py

@@ -10,6 +10,7 @@ class MLModelType(Enum):
     XGB_QUANTILE = "xgb_quantile"
     LGB = "lgb"
     LINEAR = "linear"
+    LINEAR_QUANTILE = "linear_quantile"
     ARIMA = "arima"
 
 

openstef/feature_engineering/missing_values_transformer.py

@@ -0,0 +1,99 @@
+# 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, List, Optional
+
+import numpy as np
+import pandas as pd
+from sklearn.impute import SimpleImputer
+from sklearn.preprocessing import FunctionTransformer
+from sklearn.utils.validation import check_array
+
+
+class MissingValuesTransformer:
+    """MissingValuesTransformer handles missing values in data by imputing them with a given strategy.
+
+    It also removes columns that are always null from the data.
+
+    """
+
+    in_feature_names: Optional[List[str]] = None
+    _n_in_features: Optional[int] = None
+
+    non_null_feature_names: List[str] = None
+
+    def __init__(
+        self,
+        missing_values: Union[int, float, str, None] = np.nan,
+        imputation_strategy: str = None,
+        fill_value: Union[str, int, float] = None,
+    ):
+        """Initialize missing values handler.
+
+        Args:
+            missing_values: The placeholder for the missing values. All occurrences of
+                `missing_values` will be imputed.
+            imputation_strategy: The imputation strategy to use
+                Can be one of "mean", "median", "most_frequent", "constant" or None.
+            fill_value: When strategy == "constant", fill_value is used to replace all
+                occurrences of missing_values.
+
+        """
+        self.missing_values = missing_values
+        self.imputation_strategy = imputation_strategy
+        self.fill_value = fill_value
+
+    def fit(self, x, y=None):
+        """Fit the imputer on the input data."""
+        _ = check_array(x, force_all_finite="allow-nan")
+        if not isinstance(x, pd.DataFrame):
+            x = pd.DataFrame(np.asarray(x))
+
+        self.in_feature_names = list(x.columns)
+        self._n_in_features = x.shape[1]
+
+        # Remove always null columns
+        is_column_null = x.isnull().all(axis="index")
+        self.non_null_feature_names = list(x.columns[~is_column_null])
+
+        # Build the proper imputation transformer
+        # - Identity function if strategy is None
+        # - SimpleImputer with the dedicated strategy
+        if self.imputation_strategy is None:
+            self.imputer_ = FunctionTransformer(func=self._identity)
+        else:
+            self.imputer_ = SimpleImputer(
+                missing_values=self.missing_values,
+                strategy=self.imputation_strategy,
+                fill_value=self.fill_value,
+            ).set_output(transform="pandas")
+
+        # Imputers do not support labels
+        self.imputer_.fit(X=x, y=None)
+
+    def transform(self, x) -> pd.DataFrame:
+        """Transform the input data by imputing missing values."""
+        _ = check_array(x, force_all_finite="allow-nan")
+        if not isinstance(x, pd.DataFrame):
+            x = pd.DataFrame(np.asarray(x))
+
+        x = x[self.non_null_feature_names]
+
+        return self.imputer_.transform(x)
+
+    def fit_transform(self, x, y=None):
+        """Fit the imputer on the input data and transform it.
+
+        Returns:
+            The data with missing values imputed.
+
+        """
+        self.fit(x, y)
+        return self.transform(x)
+
+    @classmethod
+    def _identity(cls, x):
+        return x
+
+    def __sklearn_is_fitted__(self) -> bool:
+        return self.in_feature_names is not None

openstef/model/model_creator.py

@@ -11,6 +11,7 @@ from openstef.model.regressors.arima import ARIMAOpenstfRegressor
 from openstef.model.regressors.custom_regressor import is_custom_type, load_custom_model
 from openstef.model.regressors.lgbm import LGBMOpenstfRegressor
 from openstef.model.regressors.linear import LinearOpenstfRegressor
+from openstef.model.regressors.linear_quantile import LinearQuantileOpenstfRegressor
 from openstef.model.regressors.regressor import OpenstfRegressor
 from openstef.model.regressors.xgb import XGBOpenstfRegressor
 from openstef.model.regressors.xgb_quantile import XGBQuantileOpenstfRegressor
@@ -91,6 +92,14 @@ valid_model_kwargs = {
         "imputation_strategy",
         "fill_value",
     ],
+    MLModelType.LINEAR_QUANTILE: [
+        "alpha",
+        "quantiles",
+        "solver",
+        "missing_values",
+        "imputation_strategy",
+        "fill_value",
+    ],
     MLModelType.ARIMA: [
         "backtest_max_horizon",
         "order",
@@ -109,6 +118,7 @@ class ModelCreator:
         MLModelType.LGB: LGBMOpenstfRegressor,
         MLModelType.XGB_QUANTILE: XGBQuantileOpenstfRegressor,
         MLModelType.LINEAR: LinearOpenstfRegressor,
+        MLModelType.LINEAR_QUANTILE: LinearQuantileOpenstfRegressor,
         MLModelType.ARIMA: ARIMAOpenstfRegressor,
     }
 

openstef/model/regressors/linear_quantile.py

@@ -0,0 +1,243 @@
+# 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 Dict, Union, Set
+
+import numpy as np
+import pandas as pd
+from sklearn.base import RegressorMixin
+from sklearn.linear_model import QuantileRegressor
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.utils.validation import check_is_fitted
+
+from openstef.feature_engineering.missing_values_transformer import (
+    MissingValuesTransformer,
+)
+from openstef.model.regressors.regressor import OpenstfRegressor
+
+DEFAULT_QUANTILES: tuple[float, ...] = (0.9, 0.5, 0.1)
+
+
+class LinearQuantileOpenstfRegressor(OpenstfRegressor, RegressorMixin):
+    quantiles: tuple[float, ...]
+    alpha: float
+    solver: str
+
+    imputer_: MissingValuesTransformer
+    x_scaler_: MinMaxScaler
+    y_scaler_: MinMaxScaler
+    models_: Dict[float, QuantileRegressor]
+
+    is_fitted_: bool = False
+
+    FEATURE_IGNORE_LIST: Set[str] = {
+        "IsWeekendDay",
+        "IsWeekDay",
+        "IsSunday",
+        "Month",
+        "Quarter",
+    }
+
+    def __init__(
+        self,
+        quantiles: tuple[float, ...] = DEFAULT_QUANTILES,
+        alpha: float = 0.0,
+        solver: str = "highs",
+        missing_values: Union[int, float, str, None] = np.nan,
+        imputation_strategy: str = None,
+        fill_value: Union[str, int, float] = None,
+    ):
+        """Initialize LinearQuantileOpenstfRegressor.
+
+        Model that provides quantile regression with SKLearn QuantileRegressor.
+        For each desired quantile an QuantileRegressor model is trained,
+        these can later be used to predict quantiles.
+
+        This model is sensitive to feature quality and therefore has logic to remove
+        some custom features produced by OpenSTEF. The features that are removed are:
+        - Holiday features (is_christmas, is_*)
+        - Lagged features (T-1d, T-*)
+        - Point in time features (IsWeekendDay, IsWeekDay, IsSunday, Month, Quarter)
+
+        Args:
+            quantiles: Tuple with desired quantiles, quantile 0.5 is required.
+                For example: (0.1, 0.5, 0.9)
+            alpha: Regularization constant for L1 regularization
+            solver: Solver to use for optimization
+            missing_values: Value to be considered as missing value
+            imputation_strategy: Imputation strategy
+            fill_value: Fill value
+
+        """
+        super().__init__()
+
+        # Check if quantile 0.5 is present. This is required.
+        if 0.5 not in quantiles:
+            raise ValueError(
+                "Cannot train quantile model as 0.5 is not in requested quantiles!"
+            )
+
+        self.quantiles = quantiles
+        self.alpha = alpha
+        self.solver = solver
+        self.imputer_ = MissingValuesTransformer(
+            missing_values=missing_values,
+            imputation_strategy=imputation_strategy,
+            fill_value=fill_value,
+        )
+        self.x_scaler_ = MinMaxScaler(feature_range=(-1, 1))
+        self.y_scaler_ = MinMaxScaler(feature_range=(-1, 1))
+        self.models_ = {
+            quantile: QuantileRegressor(alpha=alpha, quantile=quantile, solver=solver)
+            for quantile in quantiles
+        }
+
+    @property
+    def feature_names(self) -> list:
+        """The names of the features used to train the model."""
+        check_is_fitted(self)
+        return self.imputer_.non_null_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 _is_feature_ignored(self, feature_name: str) -> bool:
+        """Check if a feature is ignored by the model.
+
+        Args:
+            feature_name: Feature name
+
+        Returns:
+            True if the feature is ignored, False otherwise
+
+        """
+        return (
+            # Ignore named features
+            feature_name in self.FEATURE_IGNORE_LIST
+            or
+            # Ignore holiday features
+            re.match(r"is_", feature_name) is not None
+            or
+            # Ignore lag features
+            re.match(r"T-", feature_name) is not None
+        )
+
+    def _remove_ignored_features(self, x: pd.DataFrame) -> pd.DataFrame:
+        """Remove ignored features from the input data.
+
+        Args:
+            x: Input data
+
+        Returns:
+            Data without ignored features
+
+        """
+        return x.drop(columns=[c for c in x.columns if self._is_feature_ignored(c)])
+
+    def fit(self, x: pd.DataFrame, y: pd.Series, **kwargs) -> RegressorMixin:
+        """Fits linear quantile model.
+
+        Args:
+            x: Feature matrix
+            y: Labels
+
+        Returns:
+            Fitted LinearQuantile model
+
+        """
+        if not isinstance(y, pd.Series):
+            y = pd.Series(np.asarray(y), name="load")
+
+        x = self._remove_ignored_features(x)
+
+        # Fix nan columns
+        x = self.imputer_.fit_transform(x)
+        if x.isna().any().any():
+            raise ValueError(
+                "There are nan values in the input data. Set "
+                "imputation_strategy to solve them."
+            )
+
+        # Apply feature scaling
+        x_scaled = self.x_scaler_.fit_transform(x)
+        y_scaled = self.y_scaler_.fit_transform(y.to_frame())[:, 0]
+
+        # Add more focus on extreme / peak values
+        sample_weight = np.abs(y_scaled)
+
+        # Fit quantile regressors
+        for quantile in self.quantiles:
+            self.models_[quantile].fit(
+                X=x_scaled, y=y_scaled, sample_weight=sample_weight
+            )
+
+        self.is_fitted_ = True
+
+        self.feature_importances_ = self._get_feature_importance_from_linear()
+
+        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)
+
+        # Preprocess input data
+        x = self._remove_ignored_features(x)
+        x = self.imputer_.transform(x)
+        x_scaled = self.x_scaler_.transform(x)
+
+        # Make prediction
+        y_pred = self.models_[quantile].predict(X=x_scaled)
+
+        # Inverse scaling
+        y_pred = self.y_scaler_.inverse_transform(y_pred.reshape(-1, 1))[:, 0]
+
+        return y_pred
+
+    def _get_feature_importance_from_linear(self, quantile: float = 0.5) -> np.array:
+        check_is_fitted(self)
+        feature_importance_linear = np.abs(self.models_[quantile].coef_)
+        reg_feature_importances_dict = dict(
+            zip(self.imputer_.non_null_feature_names, feature_importance_linear)
+        )
+        return np.array(
+            [
+                reg_feature_importances_dict.get(c, 0)
+                for c in self.imputer_.in_feature_names
+            ]
+        )
+
+    @classmethod
+    def _get_param_names(cls):
+        return [
+            "quantiles",
+            "alpha",
+            "solver",
+        ]
+
+    def __sklearn_is_fitted__(self) -> bool:
+        return self.is_fitted_

openstef/pipeline/optimize_hyperparameters.py

@@ -247,7 +247,7 @@ def optuna_optimization(
         - The objective object used by optuna
 
     """
-    model = ModelCreator.create_model(pj["model"])
+    model = ModelCreator.create_model(pj["model"], **(pj.model_kwargs or {}))
     # Apply set to default hyperparameters if they are specified in the pj
     if pj.default_modelspecs:
         valid_hyper_parameters = {

openstef/pipeline/train_create_forecast_backtest.py

@@ -61,6 +61,7 @@ def train_model_and_forecast_back_test(
         InputDataWrongColumnOrderError: when input data has a invalid column order.
         ValueError: when the horizon is a string and the corresponding column in not in the input data
         InputDataOngoingZeroFlatlinerError: when all recent load measurements are zero.
+
     """
     if pj.backtest_split_func is None:
         backtest_split_func = backtest_split_default
@@ -132,6 +133,7 @@ def train_model_and_forecast_test_core(
     Raises:
         NotImplementedError: When using invalid model type in the prediction job.
         InputDataWrongColumnOrderError: When 'load' column is not first and 'horizon' column is not last.
+
     """
     model = train_model.train_pipeline_step_train_model(
         pj, modelspecs, train_data, validation_data

openstef/pipeline/train_model.py

@@ -450,6 +450,7 @@ def train_pipeline_step_train_model(
     model = ModelCreator.create_model(
         pj["model"],
         quantiles=pj["quantiles"],
+        **(pj.model_kwargs or {}),
     )
 
     # split x and y data

openstef/postprocessing/postprocessing.py

@@ -258,9 +258,9 @@ def sort_quantiles(
 ) -> pd.DataFrame:
     """Sort quantile values so quantiles do not cross.
 
-    This function assumes that all quantile columns start with 'quantile_P'
-    For more academic details on why this is mathematically sounds,
-    please refer to Quantile and Probability Curves Without Crossing (Chernozhukov, 2010)
+    This function assumes that all quantile columns start with 'quantile_P' For more academic details on why this is
+    mathematically sounds, please refer to Quantile and Probability Curves Without Crossing (Chernozhukov, 2010)
+
     """
     p_columns = [col for col in forecast.columns if col.startswith(quantile_col_start)]
 

openstef/tasks/calculate_kpi.py

@@ -72,6 +72,8 @@ def check_kpi_task(
     context: TaskContext,
     start_time: datetime,
     end_time: datetime,
+    threshold_optimizing=THRESHOLD_OPTIMIZING,
+    threshold_retraining=THRESHOLD_RETRAINING,
 ) -> None:
     # Apply default parameters if none are provided
     if start_time is None:
@@ -102,20 +104,20 @@ def check_kpi_task(
 
     # Add pid to the list of pids that should be retrained or optimized if
     # performance is insufficient
-    if kpis["47.0h"]["rMAE"] > THRESHOLD_RETRAINING:
+    if kpis["47.0h"]["rMAE"] > threshold_retraining:
         context.logger.warning(
             "Need to retrain model, retraining threshold rMAE 47h exceeded",
             t_ahead="47.0h",
             rMAE=kpis["47.0h"]["rMAE"],
-            retraining_threshold=THRESHOLD_RETRAINING,
+            retraining_threshold=threshold_retraining,
         )
 
-    if kpis["47.0h"]["rMAE"] > THRESHOLD_OPTIMIZING:
+    if kpis["47.0h"]["rMAE"] > threshold_optimizing:
         context.logger.warning(
             "Need to optimize hyperparameters, optimizing threshold rMAE 47h exceeded",
             t_ahead="47.0h",
             rMAE=kpis["47.0h"]["rMAE"],
-            optimizing_threshold=THRESHOLD_OPTIMIZING,
+            optimizing_threshold=threshold_optimizing,
         )
 
 

openstef/tasks/create_basecase_forecast.py

@@ -32,7 +32,10 @@ T_AHEAD_DAYS: int = 14
 
 
 def create_basecase_forecast_task(
-    pj: PredictionJobDataClass, context: TaskContext
+    pj: PredictionJobDataClass,
+    context: TaskContext,
+    t_behind_days=T_BEHIND_DAYS,
+    t_ahead_days=T_AHEAD_DAYS,
 ) -> None:
     """Top level task that creates a basecase forecast.
 
@@ -41,6 +44,8 @@ def create_basecase_forecast_task(
     Args:
         pj: Prediction job
         context: Contect object that holds a config manager and a database connection
+        t_behind_days: number of days included as history. This is used to generated lagged features for the to-be-forecasted period
+        t_ahead_days: number of days a basecase forecast is created for
 
     """
     # Check pipeline types
@@ -63,8 +68,8 @@ def create_basecase_forecast_task(
         return
 
     # Define datetime range for input data
-    datetime_start = datetime.utcnow() - timedelta(days=T_BEHIND_DAYS)
-    datetime_end = datetime.utcnow() + timedelta(days=T_AHEAD_DAYS)
+    datetime_start = datetime.utcnow() - timedelta(days=t_behind_days)
+    datetime_end = datetime.utcnow() + timedelta(days=t_ahead_days)
 
     # Retrieve input data
     input_data = context.database.get_model_input(

openstef/tasks/create_components_forecast.py

@@ -43,7 +43,10 @@ T_AHEAD_DAYS = 3
 
 
 def create_components_forecast_task(
-    pj: PredictionJobDataClass, context: TaskContext
+    pj: PredictionJobDataClass,
+    context: TaskContext,
+    t_behind_days: int = T_BEHIND_DAYS,
+    t_ahead_days: int = T_AHEAD_DAYS,
 ) -> None:
     """Top level task that creates a components forecast.
 
@@ -52,6 +55,8 @@ def create_components_forecast_task(
     Args:
         pj: Prediction job
         context: Contect object that holds a config manager and a database connection
+        t_behind_days: number of days in the past that the component forecast is created for
+        t_ahead_days: number of days in the future that the component forecast is created for
 
     Raises:
         ComponentForecastTooShortHorizonError: If the forecast horizon is too short
@@ -71,8 +76,8 @@ def create_components_forecast_task(
         return
 
     # Define datetime range for input data
-    datetime_start = datetime.utcnow() - timedelta(days=T_BEHIND_DAYS)
-    datetime_end = datetime.utcnow() + timedelta(days=T_AHEAD_DAYS)
+    datetime_start = datetime.utcnow() - timedelta(days=t_behind_days)
+    datetime_end = datetime.utcnow() + timedelta(days=t_ahead_days)
 
     logger.info(
         "Get predicted load", datetime_start=datetime_start, datetime_end=datetime_end

openstef/tasks/create_forecast.py

@@ -34,7 +34,9 @@ from openstef.validation.validation import detect_ongoing_zero_flatliner
 T_BEHIND_DAYS: int = 14
 
 
-def create_forecast_task(pj: PredictionJobDataClass, context: TaskContext) -> None:
+def create_forecast_task(
+    pj: PredictionJobDataClass, context: TaskContext, t_behind_days: int = T_BEHIND_DAYS
+) -> None:
     """Top level task that creates a forecast.
 
     On this task level all database and context manager dependencies are resolved.
@@ -45,6 +47,7 @@ def create_forecast_task(pj: PredictionJobDataClass, context: TaskContext) -> No
     Args:
         pj: Prediction job
         context: Contect object that holds a config manager and a database connection
+        t_behind_days: number of days included as history. This is used to generated lagged features for the to-be-forecasted period
 
     """
     # Check pipeline types
@@ -70,7 +73,7 @@ def create_forecast_task(pj: PredictionJobDataClass, context: TaskContext) -> No
     mlflow_tracking_uri = context.config.paths_mlflow_tracking_uri
 
     # Define datetime range for input data
-    datetime_start = datetime.utcnow() - timedelta(days=T_BEHIND_DAYS)
+    datetime_start = datetime.utcnow() - timedelta(days=t_behind_days)
     datetime_end = datetime.utcnow() + timedelta(seconds=pj.horizon_minutes * 60)
 
     # Retrieve input data

{openstef-3.4.19.dist-info → openstef-3.4.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openstef
-Version: 3.4.19
+Version: 3.4.21
 Summary: Open short term energy forecaster
 Home-page: https://github.com/OpenSTEF/openstef
 Author: Alliander N.V
@@ -128,3 +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.19.dist-info → openstef-3.4.21.dist-info}/RECORD

@@ -1,7 +1,7 @@
 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=f3Gw-HlNXeqMZahIAEYSZkPKtKWeNt3tfOJBL45Z2fM,629
+openstef/enums.py,sha256=LRKvmrCP_ntLE-r-AzKeSGt569WUfX0uX5db8Rk_Ag8,669
 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
@@ -29,7 +29,7 @@ openstef/data/dazls_model_3.4.7/dazls_stored_3.4.7_target_scaler.z.license,sha25
 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=lORSocNT8wkq4JhPFsDM8A3EDRi2Pyx28IaVroImfEk,5048
+openstef/data_classes/prediction_job.py,sha256=t4PtGFWAX27AeaqDOtdhECuiosuCiuL0hBK7D1l3ghU,5165
 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
@@ -39,6 +39,7 @@ openstef/feature_engineering/feature_applicator.py,sha256=DR7jayrEMlra4BFL1Ps5WV
 openstef/feature_engineering/general.py,sha256=tgU4_1stag9jJmaQAfWCMhfBscznVuQvW5hPK_z9_9g,4438
 openstef/feature_engineering/holiday_features.py,sha256=3Ff4Lkm26h8wJVoBplUewt4HfsvOUS9zj0x0MxewIm8,7842
 openstef/feature_engineering/lag_features.py,sha256=Dr6qS8UhdgEHPZZSe-w6ibtjl_lcbcQohhqdZN9fqEU,5652
+openstef/feature_engineering/missing_values_transformer.py,sha256=pKz_vRZRzfUNBw9Z-mF2AXRPeCzKbTha2gPb73bpkdw,3381
 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
@@ -48,7 +49,7 @@ openstef/model/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,16
 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=q8gGsFvxcV4DUtlaUaAsJCD3Em4UA9k6CkL76gzwd_E,4979
+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/serializer.py,sha256=IUiiAWvoGVoWzmS-akI6LC7jHRY5Ln_vOCBZy1LnESY,17238
@@ -62,6 +63,7 @@ openstef/model/regressors/custom_regressor.py,sha256=Hsmxahc9nfSWD0aEZ6cm4pxW2no
 openstef/model/regressors/dazls.py,sha256=cCYFewJEv3Fn01wdZpaKNSiYmEwzuED7PQrrWzwyTEg,8084
 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=TmZi1p0H3cNFCQEdYhl36dvtxGOJ1d2EmY5BfUBRtiA,7650
 openstef/model/regressors/regressor.py,sha256=uJcx59AyCPE9f_yPcAQ59h2ZS7eNsDpIHJrladKvHIw,3461
 openstef/model/regressors/xgb.py,sha256=HggA1U10srzdysjV560BMMX66kfaxCKAnOZB3JyyT_Y,808
 openstef/model/regressors/xgb_quantile.py,sha256=PzKIxqN_CnEPFmzXACNuzLSmZSHbooTuiJ5ckJ9vh_E,7805
@@ -74,19 +76,19 @@ openstef/pipeline/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU
 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_forecast.py,sha256=F09civdIumNQwJq2hraea5QTQx7DgvEliXKs4Y3f8Mc,5689
-openstef/pipeline/optimize_hyperparameters.py,sha256=qcwbNyTEpp2ncH1-j8LimE_ISFvn7JLUUFukW07Y-wg,11018
-openstef/pipeline/train_create_forecast_backtest.py,sha256=7uNeY8dKtJLha_LkwroyU76oB54R9p3zRlTJAJj4OoI,6048
-openstef/pipeline/train_model.py,sha256=wIiIt2iDd4juhmzBJ-lyq0cEi5oEXmPL8BBvsGBVrAs,19625
+openstef/pipeline/optimize_hyperparameters.py,sha256=3SLkcLR7XC4IeN48C-XT_lxlfCqW_D0NoMpZcrB9UUM,11045
+openstef/pipeline/train_create_forecast_backtest.py,sha256=-kZqCWal5zYLL0k0Sapks1zTmU5unNAooVPaPos1_7E,6050
+openstef/pipeline/train_model.py,sha256=Bxtwb8xQvyEYIo-6D5yNvvXl3WfCZLY1ok8aqaKv6zg,19660
 openstef/pipeline/utils.py,sha256=23mB31p19FoGWelLJzxNmqlzGwEr3fCDBEA37V2kpYY,2167
 openstef/postprocessing/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/postprocessing/postprocessing.py,sha256=vJZ57TZ3MbG4c78P2cq8Sxs6VHl6kjFvt_bie5dNK7U,9324
+openstef/postprocessing/postprocessing.py,sha256=iR1dhfIqBSRl1NpQiMAceDsY-fHs1qnzDc-b5jFdzvc,9321
 openstef/preprocessing/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/preprocessing/preprocessing.py,sha256=bM_cSSSb2vGTD79RGzUrI6KoELbzlCyJwc7jqQGNEsE,1454
 openstef/tasks/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/tasks/calculate_kpi.py,sha256=oDru-mjtYnKz6ludzwkMBYvxTwbB9Ab5MIYnKDi47cQ,11788
-openstef/tasks/create_basecase_forecast.py,sha256=Hk9fDljXvo5TfeS3nWHrerWi7y-lQzoJEaqWbqaxHOs,3852
-openstef/tasks/create_components_forecast.py,sha256=cvgtYqJ7kCTdEfpLEyrAyIsHfWxR17M2rPYdkZKsEU8,5869
-openstef/tasks/create_forecast.py,sha256=FPILsCqt2lT2QIjseXyKjViZG6SVRoGCxoj9tPiozIg,5575
+openstef/tasks/calculate_kpi.py,sha256=78DuK30ohWIHuc6oneRXalcNMXQ5mzy2qDr9xsPdSQs,11882
+openstef/tasks/create_basecase_forecast.py,sha256=lxor1E3WQ_XAZDYWdNJKE1PY57scz39bKu2Id9U2GwE,4126
+openstef/tasks/create_components_forecast.py,sha256=j4m9AGjnMDx23FmsaZGPYn9rBMHsRd_h-m1RAfhF8to,6139
+openstef/tasks/create_forecast.py,sha256=NWd2fdbZ9CKDi190v7PF14IUdz6pyME2A-ssRNDdaYs,5750
 openstef/tasks/create_solar_forecast.py,sha256=bTr7NThTF6Yj405qAqRaJmlBUrL7HATqVVzsi9hMdMw,15049
 openstef/tasks/create_wind_forecast.py,sha256=RhshkmNSyFWx4Y6yQn02GzHjWTREbN5A5GAeWv0JpcE,2907
 openstef/tasks/optimize_hyperparameters.py,sha256=s-z8YQJF6Lf3DdYgKHEpAdlbFJ3a-0Gj0Ahsqj1DErc,4758
@@ -98,8 +100,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.19.dist-info/LICENSE,sha256=7Pm2fWFFHHUG5lDHed1vl5CjzxObIXQglnYsEdtjo_k,14907
-openstef-3.4.19.dist-info/METADATA,sha256=RsQKfgm0rY888-Z-WS7OKf7B_23PNoUtaa5s9qAo7aI,7392
-openstef-3.4.19.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-openstef-3.4.19.dist-info/top_level.txt,sha256=kD0H4PqrQoncZ957FvqwfBxa89kTrun4Z_RAPs_HhLs,9
-openstef-3.4.19.dist-info/RECORD,,
+openstef-3.4.21.dist-info/LICENSE,sha256=7Pm2fWFFHHUG5lDHed1vl5CjzxObIXQglnYsEdtjo_k,14907
+openstef-3.4.21.dist-info/METADATA,sha256=oQxA5n-ScXZWQLROZ2yZZzNK7wJQt2tRk0rWzSpycEE,7393
+openstef-3.4.21.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+openstef-3.4.21.dist-info/top_level.txt,sha256=kD0H4PqrQoncZ957FvqwfBxa89kTrun4Z_RAPs_HhLs,9
+openstef-3.4.21.dist-info/RECORD,,