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

openstef/model/regressors/custom_regressor.py

@@ -1,64 +0,0 @@
-# SPDX-FileCopyrightText: 2017-2023 Alliander N.V. <korte.termijn.prognoses@alliander.com> # noqa E501>
-#
-# SPDX-License-Identifier: MPL-2.0
-"""This module defines the custom regressor."""
-import inspect
-from abc import abstractmethod
-from importlib import import_module
-from typing import Type
-
-import pandas as pd
-
-from openstef.model.objective import (
-    EVAL_METRIC,
-    TEST_FRACTION,
-    VALIDATION_FRACTION,
-    RegressorObjective,
-)
-from openstef.model.regressors.regressor import OpenstfRegressor
-
-
-class CustomOpenstfRegressor(OpenstfRegressor):
-    """A custom regressor allows to load any custom model that is not included with openSTEF."""
-
-    @staticmethod
-    @abstractmethod
-    def valid_kwargs() -> list[str]:
-        ...
-
-    @classmethod
-    @abstractmethod
-    def objective(self) -> Type[RegressorObjective]:
-        ...
-
-
-def load_custom_model(custom_model_path) -> CustomOpenstfRegressor:
-    """Load the external custom model."""
-    path_elements = custom_model_path.split(".")
-    module_path = ".".join(path_elements[:-1])
-    module = import_module(module_path)
-    model_name = path_elements[-1]
-    model_class = getattr(module, model_name)
-
-    if (
-        not inspect.isclass(model_class)
-        or inspect.isabstract(model_class)
-        or not issubclass(model_class, CustomOpenstfRegressor)
-    ):
-        raise ValueError(
-            f"The path {custom_model_path!r} does not correspond to a concrete"
-            " CustomOpenstfRegressor subclass"
-        )
-
-    return model_class
-
-
-def is_custom_type(model_type):
-    return isinstance(model_type, str) and "." in model_type
-
-
-def create_custom_objective(
-    custom_model_path,
-):
-    model_class = load_custom_model(custom_model_path)
-    return model_class.objective()

openstef/model/regressors/dazls.py

@@ -1,116 +0,0 @@
-# SPDX-FileCopyrightText: 2017-2023 Contributors to the OpenSTEF project <korte.termijn.prognoses@alliander.com> # noqa E501>
-#
-# SPDX-License-Identifier: MPL-2.0
-"""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.pipeline import Pipeline
-from sklearn.preprocessing import MinMaxScaler
-
-
-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.
-
-    """
-
-    model_: Pipeline
-
-    def __init__(self):
-        """Initialize DAZL model."""
-        self.__name__ = "DAZLS"
-
-        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.baseline_input_columns = [
-            "radiation",  # Weather parameter
-            "windspeed_100m",  # Weather parameter
-            "total_load",
-        ]
-        self.target_columns = ["total_wind_part", "total_solar_part"]
-
-    def fit(self, features, target):
-        """Fit the model.
-
-        In this function we scale the input of the domain and adaptation models of the DAZLS MODEL. Then we fit the
-        two models. We separate the features into domain_model_input, adaptation_model_input and target, and we use them
-        for the fitting and the training of the models.
-
-        Args:
-            features: inputs for domain and adaptation model (domain_model_input, adaptation_model_input)
-            target: the expected output (y_train)
-
-        """
-        x, y = (
-            features.loc[:, self.baseline_input_columns],
-            target.loc[:, self.target_columns],
-        )
-
-        self.model_.fit(x, y)
-
-    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
-        adaptation_model_input_columns to separate x in test data for domain model and adaptation model respectively.
-
-        There is an option available to return the domain model and adaptation model predictions separately to more
-        easily investigate the effectiveness of the models.
-
-        Args:
-            x: domain_model_test_data, adaptation_model_test_data
-            return_sub_preds : a flag value indicating to return the predictions of the domain model and adaptation
-                               model separately. (Default: False.)
-
-        Returns:
-            prediction: The output prediction after both models.
-
-        """
-        model_test_data = x.loc[:, self.baseline_input_columns]
-
-        return self.model_.predict(model_test_data)
-
-    def score(self, truth, prediction):
-        """Evaluation of the prediction's output.
-
-        Args:
-            truth: real values
-            prediction: predicted values
-
-        Returns:
-            RMSE and R2 scores
-
-        """
-        rmse = (mean_squared_error(truth, prediction)) ** 0.5
-        r2_score_value = r2_score(truth, prediction)
-        return rmse, r2_score_value
-
-    def __str__(self):
-        """String method of the DAZLs model, provides a summary of the model for easy inspection.
-
-        Returns:
-            Summary represented by a string
-
-        """
-        summary_str = (
-            f"{self.__name__} model summary:\n\n"
-            f"Model: {self.model_} \n"
-            f"\tInput columns: {self.baseline_input_columns} \n"
-            f"\tScaler: {self.model_['scaler']} \n\n"
-            f"\tRegressor: {self.model_['regressor']} \n\n"
-        )
-
-        return summary_str

openstef/model/regressors/flatliner.py

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

openstef/model/regressors/gblinear_quantile.py

@@ -1,334 +0,0 @@
-# SPDX-FileCopyrightText: 2017-2025 Contributors to the OpenSTEF project <korte.termijn.prognoses@alliander.com> # noqa E501>
-#
-# SPDX-License-Identifier: MPL-2.0
-import math
-import re
-from typing import Union, Optional, List
-
-import numpy as np
-import pandas as pd
-from sklearn.model_selection import train_test_split
-import xgboost as xgb
-from sklearn.preprocessing import StandardScaler
-from sklearn.utils.validation import check_is_fitted
-
-from openstef.feature_engineering.missing_values_transformer import (
-    MissingValuesTransformer,
-)
-from openstef.model.metamodels.feature_clipper import FeatureClipper
-from openstef.model.regressors.regressor import OpenstfRegressor
-
-DEFAULT_QUANTILES: tuple[float, ...] = (0.9, 0.5, 0.1)
-
-
-class GBLinearQuantileOpenstfRegressor(OpenstfRegressor):
-    is_fitted_: bool = False
-
-    TO_KEEP_FEATURES: List[str] = [
-        "T-7d",
-        "T-1d",
-    ]
-    TO_IGNORE_FEATURES: List[str] = [
-        "Month",
-        "Quarter",
-    ]
-
-    def __init__(
-        self,
-        quantiles: tuple[float, ...] = DEFAULT_QUANTILES,
-        missing_values: Union[int, float, str, None] = np.nan,
-        imputation_strategy: Optional[str] = "mean",
-        fill_value: Union[str, int, float] = None,
-        weight_scale_percentile: int = 95,
-        weight_exponent: float = 1,
-        weight_floor: float = 0.1,
-        validation_fraction: float = 0.2,
-        no_fill_future_values_features: List[str] = None,
-        clipped_features: List[str] = None,
-        learning_rate: float = 0.15,
-        num_boost_round: int = 500,
-        early_stopping_rounds: int = 10,
-        reg_alpha: float = 0.0001,
-        reg_lambda: float = 0.1,
-        updater: str = "shotgun",
-        feature_selector: str = "shuffle",
-        top_k: int = 0,
-    ):
-        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!"
-            )
-
-        if clipped_features is None:
-            clipped_features = ["APX"]
-
-        self.quantiles = quantiles
-        self.weight_scale_percentile = weight_scale_percentile
-        self.weight_exponent = weight_exponent
-        self.weight_floor = weight_floor
-        self.imputer_ = MissingValuesTransformer(
-            missing_values=missing_values,
-            imputation_strategy=imputation_strategy,
-            fill_value=fill_value,
-            no_fill_future_values_features=no_fill_future_values_features,
-        )
-        self.x_scaler_ = StandardScaler()
-        self.y_scaler_ = StandardScaler()
-        self.validation_fraction = validation_fraction
-        self.model_: xgb.Booster = None
-        self.feature_clipper_ = FeatureClipper(columns=clipped_features)
-
-        self.learning_rate = learning_rate
-        self.num_boost_round = num_boost_round
-        self.early_stopping_rounds = early_stopping_rounds
-        self.reg_alpha = reg_alpha
-        self.reg_labmda = reg_lambda
-        self.updater = updater
-        self.feature_selector = feature_selector
-        self.top_k = top_k
-
-    @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
-
-        """
-
-        if feature_name in self.TO_KEEP_FEATURES:
-            return False
-
-        return (
-            # Ignore named features
-            feature_name in self.TO_IGNORE_FEATURES
-            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
-            or
-            # Ignore infeed MFFBAS profiles
-            re.match(r"E\d.*_I", 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) -> OpenstfRegressor:
-        if not isinstance(y, pd.Series):
-            y = pd.Series(np.asarray(y), name="load")
-
-        x = self._remove_ignored_features(x)
-        self.feature_clipper_.fit(x)
-
-        # Fix nan columns
-        x, y = self.imputer_.fit_transform(x, y)
-        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 = self._calculate_sample_weights(y.values.squeeze())
-
-        # Split the data into training and validation sets
-        x_train, x_val, y_train, y_val, weight_train, weight_val = train_test_split(
-            x_scaled,
-            y_scaled,
-            sample_weight,
-            test_size=self.validation_fraction,
-            random_state=42,
-        )
-
-        # Preserve feature names
-        x_train = pd.DataFrame(x_train, columns=x.columns)
-        x_val = pd.DataFrame(x_val, columns=x.columns)
-
-        dtrain = xgb.DMatrix(x_train, label=y_train, weight=weight_train)
-        dval = xgb.DMatrix(x_val, label=y_val, weight=weight_val)
-
-        xgb_params = {
-            # Use the quantile objective function.
-            "objective": "reg:quantileerror",  # This is pinball loss
-            "booster": "gblinear",
-            "updater": self.updater,
-            "alpha": self.reg_alpha,
-            "lambda": self.reg_labmda,
-            "feature_selector": self.feature_selector,
-            "quantile_alpha": np.array(self.quantiles),
-            "learning_rate": self.learning_rate,
-        }
-
-        if self.top_k > 0:
-            xgb_params["top_k"] = self.top_k
-
-        self.model_ = xgb.train(
-            params=xgb_params,
-            dtrain=dtrain,
-            num_boost_round=self.num_boost_round,
-            early_stopping_rounds=self.early_stopping_rounds,
-            evals=[(dtrain, "train"), (dval, "val")],
-        )
-
-        self._Booster = self.model_
-
-        self.is_fitted_ = True
-
-        self.feature_importances_ = self._get_feature_importances_from_booster(
-            self.model_
-        )
-
-        return self
-
-    def _calculate_sample_weights(self, y: np.array):
-        """Calculate sample weights based on the y values of arbitrary scale.
-
-        The resulting weights are in the range [0,1] and are used to put more emphasis
-        on certain samples. The sample weighting function does:
-
-        * Rescale data to a [-1, 1] range using quantile scaling. 90% of the data will
-          be within this range. Rest is outside.
-        * Calculate the weight by taking the exponent of scaled data.
-          * exponent=0: Results in uniform weights for all samples.
-          * exponent=1: Results in linearly increasing weights for samples that are
-            closer to the extremes.
-          * exponent>1: Results in exponentially increasing weights for samples that are
-            closer to the extremes.
-        * Clip the data to [0, 1] range with weight_floor as the minimum weight.
-          * Weight floor is used to make sure that all the samples are considered.
-
-        """
-        return np.clip(
-            _weight_exp(
-                _scale_percentile(y, percentile=self.weight_scale_percentile),
-                exponent=self.weight_exponent,
-            ),
-            a_min=self.weight_floor,
-            a_max=1,
-        )
-
-    def predict(self, x: pd.DataFrame, quantile: float = 0.5, **kwargs) -> np.array:
-        check_is_fitted(self)
-
-        # Preprocess input data
-        x = self._remove_ignored_features(x)
-        x = self.feature_clipper_.transform(x)
-        x = self.imputer_.transform(x)
-        x_scaled = self.x_scaler_.transform(x)
-
-        # Preserve feature names
-        x_scaled = pd.DataFrame(x_scaled, columns=x.columns)
-
-        d_x_scaled = xgb.DMatrix(x_scaled)
-
-        # Make prediction
-        y_pred = self.model_.predict(d_x_scaled)
-
-        # When multiple quantiles are trained,
-        # we need to select the requested quantile
-        if len(self.quantiles) > 1:
-            # Get index of the quantile value in the quantiles list
-            quantile_index = self.quantiles.index(quantile)
-
-            # Get the quantile prediction
-            y_pred = y_pred[:, quantile_index]
-
-        # Inverse scaling
-        y_pred = self.y_scaler_.inverse_transform(y_pred.reshape(-1, 1))[:, 0]
-
-        return y_pred
-
-    @classmethod
-    def _get_feature_importances_from_booster(cls, booster: xgb.Booster) -> np.ndarray:
-        """Gets feature importances from a XGB booster.
-
-        This is based on the feature_importance_ property defined in:
-        https://github.com/dmlc/xgboost/blob/master/python-package/xgboost/sklearn.py.
-
-        Args:
-            booster: Booster object,
-                most of the times the median model (quantile=0.5) is preferred
-
-        Returns:
-            Ndarray with normalized feature importances.
-
-        """
-        # Get score
-        score = booster.get_score(importance_type="weight")
-
-        if type(next(iter(score.values()))) is list:
-            num_quantiles = len(next(iter(score.values())))
-
-            # Select middle quantile, assuming odd number of quantiles
-            quantile_index = num_quantiles // 2
-
-            score = {f: score[f][quantile_index] for f in score}
-
-        # Get feature names from booster
-        feature_names = booster.feature_names
-
-        # Get importance
-        feature_importance = [score.get(f, 0.0) for f in feature_names]
-        # Convert to array
-        features_importance_array = np.array(feature_importance, dtype=np.float32)
-
-        total = features_importance_array.sum()  # For normalizing
-        if total == 0:
-            return features_importance_array
-        return features_importance_array / total  # Normalize
-
-    @classmethod
-    def _get_param_names(cls):
-        return [
-            "quantiles",
-        ]
-
-    def __sklearn_is_fitted__(self) -> bool:
-        return self.is_fitted_
-
-
-def _scale_percentile(x: np.ndarray, percentile: int = 95):
-    return np.abs(x / np.percentile(np.abs(x), percentile))
-
-
-def _weight_exp(x: np.ndarray, exponent: float = 1):
-    return np.abs(x) ** exponent

openstef/model/regressors/lgbm.py

@@ -1,29 +0,0 @@
-# SPDX-FileCopyrightText: 2017-2023 Contributors to the OpenSTEF project <korte.termijn.prognoses@alliander.com> # noqa E501>
-#
-# SPDX-License-Identifier: MPL-2.0
-
-from lightgbm import LGBMRegressor
-
-from openstef.model.regressors.regressor import OpenstfRegressor
-
-
-class LGBMOpenstfRegressor(LGBMRegressor, OpenstfRegressor):
-    """LGBM Regressor which implements the Openstf regressor API."""
-
-    gain_importance_name = "gain"
-    weight_importance_name = "split"
-
-    @property
-    def feature_names(self):
-        return self._Booster.feature_name()
-
-    @property
-    def can_predict_quantiles(self):
-        return False
-
-    @staticmethod
-    def _get_importance_names():
-        return {
-            "gain_importance_name": "gain",
-            "weight_importance_name": "split",
-        }