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

openstef/model/regressors/linear.py

@@ -1,90 +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 the linear regressor."""
-import numpy as np
-from sklearn.linear_model import LinearRegression
-from sklearn.utils.validation import check_is_fitted
-
-from openstef.model.metamodels.missing_values_handler import MissingValuesHandler
-from openstef.model.regressors.regressor import OpenstfRegressor
-
-
-class LinearRegressor(MissingValuesHandler):
-    """Linear Regressor wrapped in the metamodel `MissingValuesHandler`.
-
-    This regressor can handle missing values by imputation strategy.
-
-    Args:
-        missing_values : int, float, str, np.nan or None, default=np.nan
-            The placeholder for the missing values. All occurrences of
-            `missing_values` will be imputed. For pandas' dataframes with
-            nullable integer dtypes with missing values, `missing_values`
-            should be set to `np.nan`, since `pd.NA` will be converted to `np.nan`.
-
-        imputation_strategy : str, default=None
-            The imputation strategy.
-            - If None no imputation is performed.
-            - If "mean", then replace missing values using the mean along
-            each column. Can only be used with numeric data.
-            - If "median", then replace missing values using the median along
-            each column. Can only be used with numeric data.
-            - If "most_frequent", then replace missing using the most frequent
-            value along each column. Can be used with strings or numeric data.
-            If there is more than one such value, only the smallest is returned.
-            - If "constant", then replace missing values with fill_value. Can be
-            used with strings or numeric data.
-
-        fill_value : str or numerical value, default=None
-            When strategy == "constant", fill_value is used to replace all
-            occurrences of missing_values.
-            If left to the default, fill_value will be 0 when imputing numerical
-            data and "missing_value" for strings or object data types.
-
-    """
-
-    def __init__(self, missing_values=np.nan, imputation_strategy=None, fill_value=0):
-        """Initialize Linear regressor."""
-        super().__init__(
-            LinearRegression(),
-            missing_values=missing_values,
-            imputation_strategy=imputation_strategy,
-            fill_value=fill_value,
-        )
-
-
-class LinearOpenstfRegressor(LinearRegressor, OpenstfRegressor):
-    """Linear Regressor which implements the Openstf regressor API."""
-
-    @staticmethod
-    def _get_importance_names():
-        return {
-            "gain_importance_name": "total_gain",
-            "weight_importance_name": "weight",
-        }
-
-    def fit(self, x, y, **kwargs):
-        """Fit model."""
-        super().fit(x, y)
-        self.feature_importances_ = self._get_feature_importance_from_linear()
-        return self
-
-    def _get_feature_importance_from_linear(self):
-        check_is_fitted(self)
-        feature_importance_linear = np.abs(self.regressor_.coef_)
-        reg_feature_importances_dict = dict(
-            zip(self.non_null_columns_, feature_importance_linear)
-        )
-        return np.array(
-            [reg_feature_importances_dict.get(c, 0) for c in self.feature_in_names_]
-        )
-
-    @property
-    def feature_names(self):
-        """The names of he features used to train the model."""
-        return self.feature_in_names_
-
-    @property
-    def can_predict_quantiles(self):
-        """Indicates wether this model can make quantile predictions."""
-        return False

openstef/model/regressors/linear_quantile.py

@@ -1,305 +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 Dict, Union, Set, Optional, List
-
-import numpy as np
-import pandas as pd
-from sklearn.base import RegressorMixin
-from sklearn.linear_model import QuantileRegressor
-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 LinearQuantileOpenstfRegressor(OpenstfRegressor, RegressorMixin):
-    quantiles: tuple[float, ...]
-    alpha: float
-    solver: str
-
-    imputer_: MissingValuesTransformer
-    x_scaler_: StandardScaler
-    y_scaler_: StandardScaler
-    models_: Dict[float, QuantileRegressor]
-    feature_clipper_: FeatureClipper
-
-    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: Optional[str] = "mean",
-        fill_value: Union[str, int, float] = None,
-        weight_scale_percentile: int = 95,
-        weight_exponent: float = 1,
-        weight_floor: float = 0.1,
-        no_fill_future_values_features: List[str] = None,
-        clipped_features: List[str] = 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)
-        - Infeed MFFBAS profiles (E*_I)
-
-        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
-            weight_scale_percentile: Percentile used in scaling of the samples
-            weight_exponent: Exponent used in sample weighing
-            weight_floor: Minimum weight for samples
-            no_fill_future_values_features: The features for which it does not make sense
-                to fill future values. Rows that contain trailing null values for these
-                features will be removed from the data.
-
-        """
-        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 = ["day_ahead_electricity_price"]
-
-        self.quantiles = quantiles
-        self.alpha = alpha
-        self.solver = solver
-        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.feature_clipper_ = FeatureClipper(columns=clipped_features)
-        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
-            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) -> 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)
-        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())
-
-        # 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 _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:
-        """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.feature_clipper_.transform(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_.non_null_feature_names
-            ]
-        )
-
-    @classmethod
-    def _get_param_names(cls):
-        return [
-            "quantiles",
-            "alpha",
-            "solver",
-        ]
-
-    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/regressor.py

@@ -1,114 +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 abc import abstractmethod
-from typing import Union
-
-import numpy as np
-import pandas as pd
-from sklearn.base import BaseEstimator, RegressorMixin
-
-
-class OpenstfRegressor(BaseEstimator):
-    """This class defines the interface to which all ML models within OpenSTEF should adhere.
-
-    Required methods are indicated by abstractmethods, for which concrete implementations of ML models should have a
-    definition. Common functionality which is required for the automated pipelines in OpenSTEF is defined in this class.
-
-    """
-
-    def __init__(self):
-        self.feature_importance_dataframe = None
-        self.feature_importances_ = None
-
-    def score(self, X, y):
-        """Makes `score` method from RegressorMixin available."""
-        return RegressorMixin.score(self, X, y)
-
-    ## Define abstract methods required to be implemented by concrete models
-    @property
-    @abstractmethod
-    def feature_names(self) -> list:
-        """Retrieve the model input feature names.
-
-        Returns:
-            The list of feature names
-
-        """
-
-    @property
-    @abstractmethod
-    def can_predict_quantiles(self) -> bool:
-        """Attribute that indicates if the model predict particular quantiles.
-
-        e.g. XGBQuantileOpenstfRegressor
-
-        """
-
-    @abstractmethod
-    def predict(self, x: pd.DataFrame, **kwargs) -> np.array:
-        """Makes a prediction. Only available after the model has been trained.
-
-        Args:
-            x: Feature matrix
-            kwargs: model-specific keywords
-
-        Returns:
-            Prediction
-
-        """
-
-    @abstractmethod
-    def fit(self, x: np.array, y: np.array, **kwargs) -> RegressorMixin:
-        """Fits the regressor.
-
-        Args:
-            x: Feature matrix
-            y: Labels
-            kwargs: model-specific keywords
-
-        Returns:
-            Fitted model
-
-        """
-
-    def set_feature_importance(self) -> Union[pd.DataFrame, None]:
-        """Get feature importance.
-
-        Returns:
-            DataFrame with feature importance.
-
-        """
-        # returns a dict if we can get feature importance else returns None
-        importance_names = self._get_importance_names()
-        # if the model doesn't support feature importance return None
-        if importance_names is None:
-            return None
-
-        gain = self._fraction_importance(importance_names["gain_importance_name"])
-        weight_importance = self._fraction_importance(
-            importance_names["weight_importance_name"]
-        )
-
-        feature_importance = pd.DataFrame(
-            {"gain": gain, "weight": weight_importance}, index=self.feature_names
-        )
-
-        feature_importance.sort_values(by="gain", ascending=False, inplace=True)
-        return feature_importance
-
-    def _fraction_importance(self, importance: str) -> np.ndarray:
-        self.importance_type = importance
-        feature_importance = self.feature_importances_
-        feature_importance = feature_importance / sum(feature_importance)
-        return feature_importance
-
-    @staticmethod
-    def _get_importance_names() -> Union[dict, None]:
-        """Get importance names if applicable.
-
-        Returns:
-            A dict or None, return None if the model can't get feature importance
-
-        """
-        return None

openstef/model/regressors/xgb.py

@@ -1,52 +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 typing import Optional
-
-import numpy as np
-from sklearn.base import RegressorMixin
-
-from xgboost import XGBRegressor
-
-from openstef.model.regressors.regressor import OpenstfRegressor
-
-
-class XGBOpenstfRegressor(XGBRegressor, OpenstfRegressor):
-    """XGB Regressor which implements the Openstf regressor API."""
-
-    gain_importance_name = "total_gain"
-    weight_importance_name = "weight"
-
-    @property
-    def feature_names(self):
-        return self._Booster.feature_names
-
-    @property
-    def can_predict_quantiles(self):
-        return False
-
-    @staticmethod
-    def _get_importance_names():
-        return {
-            "gain_importance_name": "total_gain",
-            "weight_importance_name": "weight",
-        }
-
-    def fit(
-        self,
-        x: np.array,
-        y: np.array,
-        *,
-        early_stopping_rounds: Optional[int] = None,
-        callbacks: Optional[list] = None,
-        eval_metric: Optional[str] = None,
-        **kwargs
-    ):
-        if early_stopping_rounds is not None:
-            self.set_params(early_stopping_rounds=early_stopping_rounds)
-        if callbacks is not None:
-            self.set_params(callbacks=callbacks)
-        if eval_metric is not None:
-            self.set_params(eval_metric=eval_metric)
-
-        super().fit(x, y, **kwargs)