openstef 3.4.11__py3-none-any.whl → 3.4.13__py3-none-any.whl

openstef/data_classes/prediction_job.py

@@ -25,7 +25,6 @@ class PredictionJobDataClass(BaseModel):
         - ``"xgb_quantile"``
         - ``"lgb"``
         - ``"linear"``
-        - ``"proloaf"`` (extra dependencies requiered, see README)
 
     If unsure what to pick, choose ``"xgb"``.
 

openstef/enums.py

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

openstef/feature_engineering/apply_features.py

@@ -14,9 +14,6 @@ Examples of features that are added:
 import pandas as pd
 
 from openstef.data_classes.prediction_job import PredictionJobDataClass
-from openstef.feature_engineering.historic_features import (
-    add_historic_load_as_a_feature,
-)
 from openstef.feature_engineering.holiday_features import (
     generate_holiday_feature_functions,
 )
@@ -69,9 +66,6 @@ def apply_features(
                             np.random.uniform(0.7,1.7, 200)))
 
     """
-    # Add if needed the proloaf feature (historic_load)
-    data = add_historic_load_as_a_feature(data, pj)
-
     # Get lag feature functions
     feature_functions = generate_lag_feature_functions(feature_names, horizon)
 

openstef/feature_engineering/feature_applicator.py

@@ -149,11 +149,7 @@ class TrainFeatureApplicator(AbstractFeatureApplicator):
 
         # NOTE this is required since apply_features could add additional features
         if self.feature_names is not None:
-            # Add horizon to requested features else it is removed, and if needed the proloaf feature (historic_load)
-            if pj.get("model") == "proloaf":
-                features = self.feature_names + ["historic_load"] + ["horizon"]
-            else:
-                features = self.feature_names + ["horizon"]
+            features = self.feature_names + ["horizon"]
             result = remove_non_requested_feature_columns(result, features)
 
         # Sort all features except for the (first) load and (last) horizon columns

openstef/model/model_creator.py

@@ -15,11 +15,6 @@ from openstef.model.regressors.xgb_quantile import XGBQuantileOpenstfRegressor
 from openstef.model.regressors.arima import ARIMAOpenstfRegressor
 
 logger = structlog.get_logger(__name__)
-try:
-    from openstef.model.regressors.proloaf import OpenstfProloafRegressor
-except ImportError:
-    logger.info("Proloaf not available, setting constructor to None")
-    OpenstfProloafRegressor = None
 
 valid_model_kwargs = {
     MLModelType.XGB: [
@@ -84,27 +79,6 @@ valid_model_kwargs = {
         "max_depth",
         "early_stopping_rounds",
     ],
-    MLModelType.ProLoaf: [
-        "relu_leak",
-        "encoder_features",
-        "decoder_features",
-        "core_layers",
-        "rel_linear_hidden_size",
-        "rel_core_hidden_size",
-        "dropout_fc",
-        "dropout_core",
-        "training_metric",
-        "metric_options",
-        "optimizer_name",
-        "early_stopping_patience",
-        "early_stopping_margin",
-        "learning_rate",
-        "max_epochs",
-        "device",
-        "batch_size",
-        "history_horizon",
-        "horizon_minutes",
-    ],
     MLModelType.LINEAR: [
         "missing_values",
         "imputation_strategy",
@@ -127,7 +101,6 @@ class ModelCreator:
         MLModelType.XGB: XGBOpenstfRegressor,
         MLModelType.LGB: LGBMOpenstfRegressor,
         MLModelType.XGB_QUANTILE: XGBQuantileOpenstfRegressor,
-        MLModelType.ProLoaf: OpenstfProloafRegressor,
         MLModelType.LINEAR: LinearOpenstfRegressor,
         MLModelType.ARIMA: ARIMAOpenstfRegressor,
     }

openstef/model/objective.py

@@ -2,7 +2,7 @@
 #
 # 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
@@ -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,
             }
         (
@@ -349,53 +349,6 @@ class XGBQuantileRegressorObjective(RegressorObjective):
         )
 
 
-class ProLoafRegressorObjective(RegressorObjective):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.model_type = MLModelType.ProLoaf
-
-    def get_params(self, trial: optuna.trial.FrozenTrial) -> dict:
-        """Get parameters for ProLoaf 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)
-
-        # ProLoaf 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),
-        }
-        return {**model_params, **params}
-
-    def get_pruning_callback(self, trial: optuna.trial.FrozenTrial):
-        return optuna.integration.PyTorchLightningPruningCallback(
-            trial, monitor="val_loss"
-        )
-
-
 class LinearRegressorObjective(RegressorObjective):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)

openstef/model/objective_creator.py

@@ -8,7 +8,6 @@ from openstef.enums import MLModelType
 from openstef.model.objective import (
     LGBRegressorObjective,
     LinearRegressorObjective,
-    ProLoafRegressorObjective,
     RegressorObjective,
     XGBQuantileRegressorObjective,
     XGBRegressorObjective,
@@ -25,7 +24,6 @@ class ObjectiveCreator:
         MLModelType.XGB: XGBRegressorObjective,
         MLModelType.LGB: LGBRegressorObjective,
         MLModelType.XGB_QUANTILE: XGBQuantileRegressorObjective,
-        MLModelType.ProLoaf: ProLoafRegressorObjective,
         MLModelType.LINEAR: LinearRegressorObjective,
         MLModelType.ARIMA: ARIMARegressorObjective,
     }

openstef/pipeline/optimize_hyperparameters.py

@@ -175,18 +175,6 @@ def optimize_hyperparameters_pipeline_core(
         horizons=horizons, feature_names=feature_names, feature_modules=feature_modules
     ).add_features(validated_data, pj=pj)
 
-    # Adds additional proloaf features to the input data, historic_load (equal to the load, first column)
-    if pj["model"] == "proloaf" and "historic_load" not in list(
-        validated_data_with_features.columns
-    ):
-        validated_data_with_features[
-            "historic_load"
-        ] = validated_data_with_features.iloc[:, 0]
-        # Make sure horizons is last column
-        temp_cols = validated_data_with_features.columns.tolist()
-        new_cols = temp_cols[:-2] + [temp_cols[-1]] + [temp_cols[-2]]
-        validated_data_with_features = validated_data_with_features[new_cols]
-
     # Create objective (NOTE: this is a callable class)
     objective = ObjectiveCreator.create_objective(model_type=pj["model"])
 
@@ -268,7 +256,7 @@ def optuna_optimization(
     if pj.train_split_func is None:
         split_func = split_data_train_validation_test
         split_args = {
-            "stratification_min_max": pj["model"] != "proloaf",
+            "stratification_min_max": True,
             "back_test": True,
         }
     else:

openstef/pipeline/train_create_forecast_backtest.py

@@ -59,7 +59,7 @@ def train_model_and_forecast_back_test(
     """
     if pj.backtest_split_func is None:
         backtest_split_func = backtest_split_default
-        backtest_split_args = {"stratification_min_max": pj["model"] != "proloaf"}
+        backtest_split_args = {"stratification_min_max": True}
     else:
         backtest_split_func, backtest_split_args = pj.backtest_split_func.load(
             required_arguments=["data", "n_folds"]

openstef/pipeline/train_model.py

@@ -348,10 +348,6 @@ def train_pipeline_step_compute_features(
         ValueError: when the horizon is a string and the corresponding column in not in the input data
 
     """
-    if pj["model"] == "proloaf":
-        # proloaf is only able to train with one horizon
-        horizons = [horizons[0]]
-
     if input_data.empty:
         raise InputDataInsufficientError("Input dataframe is empty")
     elif "load" not in input_data.columns:
@@ -523,7 +519,7 @@ def train_pipeline_step_split_data(
     if pj.train_split_func is None:
         split_func = split_data_train_validation_test
         split_args = {
-            "stratification_min_max": pj["model"] != "proloaf",
+            "stratification_min_max": True,
             "back_test": backtest,
         }
     else:

{openstef-3.4.11.dist-info → openstef-3.4.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openstef
-Version: 3.4.11
+Version: 3.4.13
 Summary: Open short term energy forecaster
 Home-page: https://github.com/OpenSTEF/openstef
 Author: Alliander N.V
@@ -22,6 +22,7 @@ Requires-Dist: matplotlib ~=3.7
 Requires-Dist: mlflow ~=2.3
 Requires-Dist: networkx ~=3.1
 Requires-Dist: optuna ~=3.1
+Requires-Dist: optuna-integration ~=3.6
 Requires-Dist: pandas ~=2.2.0
 Requires-Dist: plotly ~=5.18
 Requires-Dist: pvlib ==0.9.4
@@ -30,12 +31,8 @@ Requires-Dist: pymsteams ~=0.2.2
 Requires-Dist: scikit-learn ~=1.3
 Requires-Dist: scipy ~=1.10
 Requires-Dist: statsmodels ~=0.13.5
-Requires-Dist: structlog ~=23.1
+Requires-Dist: structlog <25,>=23.1
 Requires-Dist: xgboost ~=2.0
-Provides-Extra: proloaf
-Requires-Dist: proloaf ==0.2.0 ; extra == 'proloaf'
-Requires-Dist: torch ==1.10.0 ; extra == 'proloaf'
-Requires-Dist: pytorch-lightning ==1.5.1 ; extra == 'proloaf'
 
 <!--
 SPDX-FileCopyrightText: 2017-2023 Contributors to the OpenSTEF project <korte.termijn.prognoses@alliander.com>
@@ -57,20 +54,27 @@ SPDX-License-Identifier: MPL-2.0
 [![Technical Debt](https://sonarcloud.io/api/project_badges/measure?project=OpenSTEF_openstef&metric=sqale_index)](https://sonarcloud.io/dashboard?id=OpenSTEF_openstef)
 [![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=OpenSTEF_openstef&metric=vulnerabilities)](https://sonarcloud.io/dashboard?id=OpenSTEF_openstef)
 [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/5585/badge)](https://bestpractices.coreinfrastructure.org/projects/5585)
+[![Downloads](https://static.pepy.tech/badge/openstef)](https://pepy.tech/project/openstef)
+[![Downloads](https://static.pepy.tech/badge/openstef/month)](https://pepy.tech/project/openstef)
 
 # OpenSTEF
 OpenSTEF is a Python package designed for generating short-term forecasts in the energy sector. The repository includes all the essential components required for machine learning pipelines that facilitate the forecasting process. To utilize the package, users are required to furnish their own data storage and retrieval interface.
 
 # Table of contents
+- [OpenSTEF](#openstef)
+- [Table of contents](#table-of-contents)
 - [External information sources](#external-information-sources)
-- [Installation](install)
-- [Usage](usage)
-- [Reference Implementation](reference-implementation)
-- [Database connector for OpenSTEF](Openstef-dbc-Database-connector-for-openstef) 
-- [License](license)
-- [Licences third-party libraries](licenses-third-party-libraries)
-- [Contributing](contributing)
-- [Contact](contact)
+- [Installation](#installation)
+  - [Install the openstef package](#install-the-openstef-package)
+    - [Remark regarding installation within a **conda environment on Windows**:](#remark-regarding-installation-within-a-conda-environment-on-windows)
+- [Usage](#usage)
+  - [Reference Implementation](#reference-implementation)
+  - [Openstef-dbc - Database connector for openstef](#openstef-dbc---database-connector-for-openstef)
+  - [Example notebooks](#example-notebooks)
+  - [License](#license)
+  - [Licenses third-party libraries](#licenses-third-party-libraries)
+  - [Contributing](#contributing)
+  - [Contact](#contact)
 
 # External information sources
 - [Documentation website](https://openstef.github.io/openstef/index.html);
@@ -89,10 +93,6 @@ OpenSTEF is a Python package designed for generating short-term forecasts in the
 pip install openstef
 ```
 
-_**Optional**_: if you would like to use the proloaf model with OpenSTEF install the proloaf dependencies by running:
-```shell
-pip install openstef[proloaf]
-```
 ### Remark regarding installation within a **conda environment on Windows**:
 
 A version of the pywin32 package will be installed as a secondary dependency along with the installation of the openstef package. Since conda relies on an old version of pywin32, the new installation can break conda's functionality. The following command can solve this issue:

{openstef-3.4.11.dist-info → openstef-3.4.13.dist-info}/RECORD

@@ -1,6 +1,6 @@
 openstef/__init__.py,sha256=93UM6m0LLQhO69-mSqLuUy73jgs4W7Iuxfo3Lm8c98g,419
 openstef/__main__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/enums.py,sha256=dFpGFySauUt-m_bsPNcmc5WVG33ZXcWsbJeQp_4iEBE,753
+openstef/enums.py,sha256=4NxcBobpn1Z6J_qHaIsJCarZ2BGZph_S_1PcwCDjg5o,729
 openstef/exceptions.py,sha256=fVqjyrVMBiSGxcoZ3JfTcgZjIur1cPennZpfwqgc9qY,1992
 openstef/data/dutch_holidays_2020-2022.csv,sha256=pS-CjE0igYXd-2dG-MlqyvR2fgYgXkbNmgCKyTjmwxs,23704
 openstef/data/dutch_holidays_2020-2022.csv.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
@@ -27,15 +27,14 @@ 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=3SLvHDXlL-fBw8IFGBP_pKXTfWjQsKjgVxDyYlgic1o,3417
 openstef/data_classes/model_specifications.py,sha256=Uod1W3QzhRqVLb6zvXwxh9wRL3EHCzSvX0oDNd28cFk,1197
-openstef/data_classes/prediction_job.py,sha256=YrPaUACW7u09yabmwXkXu3fRpu-M90FPgprd7vjSP0A,4856
+openstef/data_classes/prediction_job.py,sha256=N2iD1B3LlnBAhvQaLJxIKe6K_0iWpTG0Qt6gHq5Vn6o,4789
 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=pKvTl2c-L5OUuRPWy9mr_OcGExSNbwDRhTuLmNzGFqE,4114
+openstef/feature_engineering/apply_features.py,sha256=-3fyisOVj9ckIkRe2iYfWutbXSX8iqBkcvt8AYr-gmE,3906
 openstef/feature_engineering/data_preparation.py,sha256=vFdCdXrX7RWWa4uj1D8rVkHymacbfhvwoLiEnUk-v6g,5399
 openstef/feature_engineering/feature_adder.py,sha256=aSqDl_gUrB3H2TD3cNvU5JniY_KOb4u4a2A6J7zB2BQ,6835
-openstef/feature_engineering/feature_applicator.py,sha256=FpEEirbOTuOKZipoGHYliKvY0r_XE5f2z-r8NiAx4oU,7712
+openstef/feature_engineering/feature_applicator.py,sha256=DR7jayrEMlra4BFL1Ps5WV2fxbkQ6VaOTa5RIKM-YNk,7447
 openstef/feature_engineering/general.py,sha256=igAPyejYN5d09-a_c53C79a0A4cHjvMCa47KC4IfgCo,4072
-openstef/feature_engineering/historic_features.py,sha256=aDxoS42ndUmLmwqpII8rZ_-L86NFer-Gw_fGf0TAobU,1215
 openstef/feature_engineering/holiday_features.py,sha256=3Ff4Lkm26h8wJVoBplUewt4HfsvOUS9zj0x0MxewIm8,7842
 openstef/feature_engineering/lag_features.py,sha256=Dr6qS8UhdgEHPZZSe-w6ibtjl_lcbcQohhqdZN9fqEU,5652
 openstef/feature_engineering/weather_features.py,sha256=wy3KFXUIIwSydFJZpiejsJMwURtDpv9l0HBHu-uLAGQ,15561
@@ -47,9 +46,9 @@ openstef/model/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,16
 openstef/model/basecase.py,sha256=caI6Q-8y0ymlxGK9Js_H3Vh0q6ruNHlGD5RG0_kE5M0,2878
 openstef/model/confidence_interval_applicator.py,sha256=7E1_JFLZ4-hyEhleacMvp5szdmYZS4tpKAjfhGvXXvg,8602
 openstef/model/fallback.py,sha256=VV9ehgnoMZtWzqKk9H1t8wnERFh5CyC4TvDIuRP_ZDI,2861
-openstef/model/model_creator.py,sha256=U1Lw4HFyajfxQ2o5lEnCxnmRC62DEu5PBHXrm_jnEJU,5582
-openstef/model/objective.py,sha256=qBZGij4P2uZXFt-1x4MxCkIRmpVY3TJoo4Mycxu9dO8,15433
-openstef/model/objective_creator.py,sha256=OiPPFSiSu7z9K_983ib5iqhhu6_9tt7iyTyKNZ2Iz68,2057
+openstef/model/model_creator.py,sha256=uDLn5fte8nGmxMOGA2xvTkeyslaA4kATuu-w1QOI4FI,4790
+openstef/model/objective.py,sha256=eqNBYGfhEVGegOm0PbizowuFImKblRqHgxkp9lgaKQc,13500
+openstef/model/objective_creator.py,sha256=QxHolw60aSvqSKO6VO-uDslwg3VC_T4BZ2cm-sy7E3U,1970
 openstef/model/serializer.py,sha256=Q7pKkA-K1bszER_tkOWhvwTQsj6-qZoX5zaXIemRKGs,16934
 openstef/model/standard_deviation_generator.py,sha256=Od9bzXi2TLb1v8Nz-VhBMZHSopWH6ssaDe8gYLlqO1I,2911
 openstef/model/metamodels/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
@@ -61,7 +60,6 @@ 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/proloaf.py,sha256=HjyfEQRiFMFzyfYSrFL3yPhduhL1igGr1FTO6d0ET7I,9081
 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=Oenhe0cMLAEXlinHZF588zNTjwR-hB7NB0anQZPwPKU,7710
@@ -74,9 +72,9 @@ openstef/pipeline/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU
 openstef/pipeline/create_basecase_forecast.py,sha256=7jig8lt-e3xwIWDSk-bMwUC45y2mwKe9-zDZYHiiQMY,4324
 openstef/pipeline/create_component_forecast.py,sha256=ksX5r7H5IrMrfPVuRK0OWOtsdns1Rrn1L9ZG0Si0TI4,6255
 openstef/pipeline/create_forecast.py,sha256=El9xXKN8DeIADy_76-V22wBY8AMSa4KEfYuW00jw85k,5083
-openstef/pipeline/optimize_hyperparameters.py,sha256=BnahfVHlE1z9so0gxPyd75OKCXSZvtFvuqicH6skm5U,10892
-openstef/pipeline/train_create_forecast_backtest.py,sha256=upuoiE01vjjxUu_sY0tANPqdOtpGKrQQ3azhVDnBJdc,5512
-openstef/pipeline/train_model.py,sha256=cPTXDUjsQK5o5ygMNnmH-DfXins1khAnvt8gVF5eK4Q,18677
+openstef/pipeline/optimize_hyperparameters.py,sha256=QlM_TN2sVelfrYFqZfy-gkRJMlt4j3fr65HvcEGhdac,10272
+openstef/pipeline/train_create_forecast_backtest.py,sha256=QkkpccW4BW0TC5uq22_juTcp8uvPZ4Qk-ewdnlYpNTE,5492
+openstef/pipeline/train_model.py,sha256=ELIHkGjzvIdV4V7IMiy8tw7A_wc1QJ7eXY_rPXOgytU,18533
 openstef/pipeline/utils.py,sha256=fkc-oNirJ-JiyuOAL08RFrnPYPwudWal_N-BO6Cw980,2086
 openstef/postprocessing/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/postprocessing/postprocessing.py,sha256=nehd0tDpkdIaWFJggQ-fDizIKdfmqJ3IOGfk0sDnrzk,8409
@@ -99,8 +97,8 @@ openstef/tasks/utils/predictionjobloop.py,sha256=Ysy3zF5lzPMz_asYDKeF5m0qgVT3tCt
 openstef/tasks/utils/taskcontext.py,sha256=yI6TntOkZcW8JiNVuw4uJIigEBL0_iIrkPklF4ZeCX4,5401
 openstef/validation/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/validation/validation.py,sha256=SaI-Mff9UOHQPnQ2jodXzZAVZilc-2AXZsPpSjDRqAg,10346
-openstef-3.4.11.dist-info/LICENSE,sha256=7Pm2fWFFHHUG5lDHed1vl5CjzxObIXQglnYsEdtjo_k,14907
-openstef-3.4.11.dist-info/METADATA,sha256=ZRh77dwGdWxFGtexZEx9ZvU7_KP6VKeBx4C8rVFhvx4,7872
-openstef-3.4.11.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-openstef-3.4.11.dist-info/top_level.txt,sha256=kD0H4PqrQoncZ957FvqwfBxa89kTrun4Z_RAPs_HhLs,9
-openstef-3.4.11.dist-info/RECORD,,
+openstef-3.4.13.dist-info/LICENSE,sha256=7Pm2fWFFHHUG5lDHed1vl5CjzxObIXQglnYsEdtjo_k,14907
+openstef-3.4.13.dist-info/METADATA,sha256=l5HsBWQbm_94pKxUsJxpOW6QAUBGw2Dd-z3_sdDxDWM,8124
+openstef-3.4.13.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+openstef-3.4.13.dist-info/top_level.txt,sha256=kD0H4PqrQoncZ957FvqwfBxa89kTrun4Z_RAPs_HhLs,9
+openstef-3.4.13.dist-info/RECORD,,

{openstef-3.4.11.dist-info → openstef-3.4.13.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

openstef/feature_engineering/historic_features.py

@@ -1,40 +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 historic load related functions used for feature engineering."""
-
-import pandas as pd
-import structlog
-
-from openstef.data_classes.prediction_job import PredictionJobDataClass
-
-
-def add_historic_load_as_a_feature(
-    data: pd.DataFrame,
-    pj: PredictionJobDataClass = None,
-) -> pd.DataFrame:
-    """Adds additional proloaf features to the input data, historic_load (equal to the load).
-
-    Args:
-        data: Dataframe to which the wind features have to be added
-        pj: Prediction job.
-
-    Returns:
-        DataFrame that is the same as input dataframe with extra columns for the added proloaf features
-
-    """
-    logger = structlog.get_logger(__name__)
-
-    if pj is None:
-        pj = {}
-
-    if pj.get("model") == "proloaf":
-        data["historic_load"] = data["load"]
-        logger.warning(
-            "The historic_load is added to the data, this is a copy of the load. Adding"
-            " this feature is in most of the cases not a good idea, it is designed for"
-            " the proloaf model."
-        )
-
-    return data

openstef/model/regressors/proloaf.py

@@ -1,281 +0,0 @@
-# SPDX-FileCopyrightText: 2017-2023 Alliander N.V. <korte.termijn.prognoses@alliander.com> # noqa E501>
-#
-# SPDX-License-Identifier: MPL-2.0
-from typing import Any, Union
-
-import numpy as np
-import pandas as pd
-
-# These imports will require the proloaf optional dependencies to be installed
-import proloaf.datahandler as dh
-import torch
-from proloaf.modelhandler import ModelWrapper
-
-from openstef.model.regressors.regressor import OpenstfRegressor
-
-# TODO: implement the hyperparameter optimalisation via optuna
-# TODO: set the default for hyperparameters in the init of OpenstfProloafRegressor
-# TODO: implement function for defining encoder and decoder features
-
-
-def divide_scaling_groups(x: pd.DataFrame) -> tuple[list[str], list[str], list[str]]:
-    """Divides the column names over different type of scaling groups.
-
-    Args:
-        x: Dataframe from which columns have to be divided
-
-    Returns:
-        List of all the grouped features for scaling (three groups)
-
-    """
-    minmax_scale_features = []
-    oh_scale_features = []
-    no_scale_features = []
-
-    for column in x.columns:
-        if (x[column].min() <= -1) or (x[column].max() >= 1):
-            minmax_scale_features.append(column)
-        elif x[column].dtype == "bool":
-            oh_scale_features.append(column)
-        else:
-            no_scale_features.append(column)
-
-    return minmax_scale_features, oh_scale_features, no_scale_features
-
-
-def apply_scaling(
-    scaler_features: tuple[list[str], list[str], list[str]],
-    data: pd.DataFrame,
-    scalers=None,
-):
-    """Applies different scaling methods to a certain dataframe (minmax, one hot, or no scaling).
-
-    Args:
-        scaler_features: Three different lists with features for each scaling
-        x: Dataframe from which columns have to be divided
-        scalers: scalers resulting from the previous scaling
-
-    Returns:
-        Dataframe with all the scaled features
-
-    """
-    selected_features, scalers = dh.scale_all(
-        data,
-        scalers=scalers,
-        feature_groups=[
-            {
-                "name": "main",
-                "scaler": ["minmax", -1.0, 1.0],
-                "features": scaler_features[0],
-            },
-            {"name": "aux", "scaler": None, "features": scaler_features[2]},
-        ],
-    )
-
-    # One hot encoding certain features
-    onehot_feature_groups = [
-        {
-            "name": "main",
-            "scaler": [
-                "onehot",
-            ],
-            "features": scaler_features[1],
-        }
-    ]
-    for group in onehot_feature_groups:
-        df_onehot = data.filter(group["features"])
-        result_oh_scale = np.transpose(np.array(df_onehot.iloc[:, :], dtype=np.int))
-        df_onehot.iloc[:, :] = result_oh_scale.T
-
-    if not df_onehot.columns.empty:
-        selected_features = pd.concat([selected_features, df_onehot], axis=1)
-    data = selected_features.iloc[:, :].replace(np.nan, 0)
-
-    return data, scalers
-
-
-class OpenstfProloafRegressor(OpenstfRegressor, ModelWrapper):
-    def __init__(
-        self,
-        name: str = "model",
-        core_net: str = "torch.nn.LSTM",
-        relu_leak: float = 0.1,
-        encoder_features: list[str] = [
-            "historic_load",
-        ],  # make sure historic load is present, TODO: implement so you can use None
-        decoder_features: list[str] = [
-            "air_density"
-        ],  # TODO: implement so you can use None
-        core_layers: int = 1,
-        rel_linear_hidden_size: float = 1.0,
-        rel_core_hidden_size: float = 1.0,
-        dropout_fc: float = 0.4,
-        dropout_core: float = 0.3,
-        training_metric: str = "nllgauss",
-        metric_options: dict[str, Any] = {},
-        optimizer_name: str = "adam",
-        early_stopping_patience: int = 7,
-        early_stopping_margin: float = 0,
-        learning_rate: float = 1e-3,
-        max_epochs: int = 100,
-        device: Union[str, int] = "cpu",  # "cuda" or "cpu"
-        batch_size: int = 6,
-        history_horizon: int = 24,
-        horizon_minutes: int = 2880,  # 2 days in minutes,
-    ):
-        self.device = device
-        self.batch_size = batch_size
-        self.history_horizon = history_horizon
-        self.forecast_horizon = int(horizon_minutes / 60)
-        ModelWrapper.__init__(
-            self,
-            name=name,
-            core_net=core_net,
-            relu_leak=relu_leak,
-            encoder_features=encoder_features,
-            decoder_features=decoder_features,
-            core_layers=core_layers,
-            rel_linear_hidden_size=rel_linear_hidden_size,
-            rel_core_hidden_size=rel_core_hidden_size,
-            dropout_fc=dropout_fc,
-            dropout_core=dropout_core,
-            training_metric=training_metric,
-            metric_options=metric_options,
-            optimizer_name=optimizer_name,
-            early_stopping_patience=early_stopping_patience,
-            early_stopping_margin=early_stopping_margin,
-            learning_rate=learning_rate,
-            max_epochs=max_epochs,
-        )
-        self.to(device)
-
-    @property
-    def feature_names(self):
-        return (
-            ["load"] + self.encoder_features + self.decoder_features
-        )  # TODO: gehele range, of een enkele feature
-
-    @property
-    def can_predict_quantiles(self):
-        return False
-
-    def predict(self, x: pd.DataFrame) -> np.ndarray:
-        x = x[list(self.feature_names)[1:]]
-        # Apply scaling and interpolation for NaN values
-        x = dh.fill_if_missing(x, periodicity=24)
-        x, _ = apply_scaling(
-            [
-                self.minmax_scale_features,
-                self.oh_scale_features,
-                self.no_scale_features,
-            ],
-            x,
-            self.scalers,
-        )
-
-        inputs_enc = torch.tensor(
-            x[self.encoder_features].to_numpy(), dtype=torch.float
-        ).unsqueeze(dim=0)
-        inputs_dec = torch.tensor(
-            x[self.decoder_features].to_numpy(), dtype=torch.float
-        ).unsqueeze(dim=0)
-        prediction = (
-            ModelWrapper.predict(self, inputs_enc, inputs_dec)[:, :, 0]
-            .squeeze()
-            .detach()
-            .numpy()
-        )
-
-        return prediction
-
-    def fit(
-        self,
-        x: pd.DataFrame,
-        y: pd.DataFrame,
-        eval_set: tuple = None,
-        early_stopping_rounds: int = None,
-        verbose: bool = False,
-        **kwargs,
-    ) -> ModelWrapper:
-        x = x[list(self.feature_names)[1:]]
-        # Apply scaling and interpolation for NaN values
-        x = dh.fill_if_missing(x, periodicity=24)
-        (
-            self.minmax_scale_features,
-            self.oh_scale_features,
-            self.no_scale_features,
-        ) = divide_scaling_groups(x)
-        x, self.scalers = apply_scaling(
-            [
-                self.minmax_scale_features,
-                self.oh_scale_features,
-                self.no_scale_features,
-            ],
-            x,
-            self.scalers,
-        )
-        y = y.to_frame()
-        self.target_id = [y.columns[0]]
-
-        df_train = pd.concat([x, y], axis="columns", verify_integrity=True)
-
-        print(f"{self.encoder_features = }")
-        print(f"{self.decoder_features = }")
-
-        train_dl, _, _ = dh.transform(
-            df=df_train,
-            encoder_features=self.encoder_features,
-            decoder_features=self.decoder_features,
-            batch_size=self.batch_size,
-            history_horizon=self.history_horizon,
-            forecast_horizon=self.forecast_horizon,
-            target_id=self.target_id,
-            train_split=1.0,
-            validation_split=1.0,
-            device=self.device,
-        )
-
-        val_x, val_y = eval_set[1][0], eval_set[1][1]
-        val_x = dh.fill_if_missing(val_x, periodicity=24)
-        val_x, _ = apply_scaling(
-            [
-                self.minmax_scale_features,
-                self.oh_scale_features,
-                self.no_scale_features,
-            ],
-            val_x,
-            self.scalers,
-        )
-
-        df_val = pd.concat([val_x, val_y], axis="columns", verify_integrity=True)
-        _, validation_dl, _ = dh.transform(
-            df=df_val,
-            encoder_features=self.encoder_features,
-            decoder_features=self.decoder_features,
-            batch_size=self.batch_size,
-            history_horizon=self.history_horizon,
-            forecast_horizon=self.forecast_horizon,
-            target_id=self.target_id,
-            train_split=0.0,
-            validation_split=1.0,
-            device=self.device,
-        )
-        self.to(self.device)
-        self.init_model()
-        self.is_fitted_ = True
-
-        return self.run_training(train_dl, validation_dl)
-
-    def get_params(self, deep=True):
-        model_params = self.get_model_config()
-        training_params = self.get_training_config()
-        return {**model_params, **training_params}
-
-    def set_params(self, **params):
-        self.update(**params)
-        return self
-
-
-if __name__ == "__main__":
-    test = OpenstfProloafRegressor()
-    print(test)