Skip to content

Dummy

sklego.dummy.RandomRegressor

Bases: BaseEstimator, RegressorMixin

A RandomRegressor makes random predictions only based on the y value that is seen.

The goal is that such a regressor can be used for benchmarking. It should be easily beatable.

Parameters:

Name Type Description Default
strategy Literal[uniform, normal]

How we want to select random values, either "uniform" or "normal"

 "uniform"
random_state int | None

The seed value used for the random number generator.

 None

Attributes:

Name Type Description
min_ float

The minimum value of y seen during fit.
max_ float

The maximum value of y seen during fit.
mu_ float

The mean value of y seen during fit.
sigma_ float

The standard deviation of y seen during fit.
n_features_in_ int

The number of features seen during fit.
dim_ int

Deprecated, please use n_features_in_ instead.

Examples:

from sklego.dummy import RandomRegressor
from sklearn.datasets import make_regression

X, y = make_regression(n_samples=10, n_features=2, random_state=42)

RandomRegressor(strategy="uniform", random_state=123).fit(X, y).predict(X).round(2)
# array([ 57.63, -66.05, -83.92,  13.88,  64.56, -24.77, 143.33,  54.12,
#     -7.34, -34.11])

RandomRegressor(strategy="normal", random_state=123).fit(X, y).predict(X).round(2)
# array([-128.45,   78.05,    7.23, -170.15,  -78.18,  142.9 , -261.39,
#     -63.34,  104.68, -106.75])
Source code in sklego/dummy.py 
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
class RandomRegressor(BaseEstimator, RegressorMixin):
    """A `RandomRegressor` makes random predictions only based on the `y` value that is seen.

    The goal is that such a regressor can be used for benchmarking. It _should be_ easily beatable.

    Parameters
    ----------
    strategy : Literal["uniform", "normal"], default="uniform"
        How we want to select random values, either "uniform" or "normal"
    random_state : int | None, default=None
        The seed value used for the random number generator.

    Attributes
    ----------
    min_ : float
        The minimum value of `y` seen during `fit`.
    max_ : float
        The maximum value of `y` seen during `fit`.
    mu_ : float
        The mean value of `y` seen during `fit`.
    sigma_ : float
        The standard deviation of `y` seen during `fit`.
    n_features_in_ : int
        The number of features seen during `fit`.
    dim_ : int
        Deprecated, please use `n_features_in_` instead.

    Examples
    --------
    ```py
    from sklego.dummy import RandomRegressor
    from sklearn.datasets import make_regression

    X, y = make_regression(n_samples=10, n_features=2, random_state=42)

    RandomRegressor(strategy="uniform", random_state=123).fit(X, y).predict(X).round(2)
    # array([ 57.63, -66.05, -83.92,  13.88,  64.56, -24.77, 143.33,  54.12,
    #     -7.34, -34.11])

    RandomRegressor(strategy="normal", random_state=123).fit(X, y).predict(X).round(2)
    # array([-128.45,   78.05,    7.23, -170.15,  -78.18,  142.9 , -261.39,
    #     -63.34,  104.68, -106.75])
    ```
    """

    _ALLOWED_STRATEGIES = ("uniform", "normal")

    def __init__(self, strategy="uniform", random_state=None):
        self.strategy = strategy
        self.random_state = random_state

    def fit(self, X: np.array, y: np.array) -> "RandomRegressor":
        """
        Fit the model using X, y as training data.

        :param X: array-like, shape=(n_columns, n_samples,) training data.
        :param y: array-like, shape=(n_samples,) training data.
        :return: Returns an instance of self.
        """
        if self.strategy not in self._ALLOWED_STRATEGIES:
            raise ValueError(f"strategy {self.strategy} is not in {self._ALLOWED_STRATEGIES}")
        X, y = check_X_y(X, y, estimator=self, dtype=FLOAT_DTYPES)
        self.n_features_in_ = X.shape[1]

        self.min_ = np.min(y)
        self.max_ = np.max(y)
        self.mu_ = np.mean(y)
        self.sigma_ = np.std(y)

        return self

    def predict(self, X):
        """Predict new data by generating random guesses following the given `strategy` based on the `y` statistics seen
        during `fit`.

        Parameters
        ----------
        X : array-like of shape (n_samples, n_features)
            The data to predict.

        Returns
        -------
        array-like of shape (n_samples,)
            The predicted data.
        """
        rs = check_random_state(self.random_state)
        check_is_fitted(self, ["n_features_in_", "min_", "max_", "mu_", "sigma_"])

        X = check_array(X, estimator=self, dtype=FLOAT_DTYPES)
        if X.shape[1] != self.n_features_in_:
            raise ValueError(f"Unexpected input dimension {X.shape[1]}, expected {self.dim_}")

        if self.strategy == "normal":
            return rs.normal(self.mu_, self.sigma_, X.shape[0])
        if self.strategy == "uniform":
            return rs.uniform(self.min_, self.max_, X.shape[0])

    @property
    def dim_(self):
        warn(
            "Please use `n_features_in_` instead of `dim_`, `dim_` will be deprecated in future versions",
            DeprecationWarning,
        )
        return self.n_features_in_

    @property
    def allowed_strategies(self):
        warn(
            "Please use `_ALLOWED_STRATEGIES` instead of `allowed_strategies`,"
            "`allowed_strategies` will be deprecated in future versions",
            DeprecationWarning,
        )
        return self._ALLOWED_STRATEGIES

fit(X, y)

Fit the model using X, y as training data.

:param X: array-like, shape=(n_columns, n_samples,) training data. :param y: array-like, shape=(n_samples,) training data. :return: Returns an instance of self.

Source code in sklego/dummy.py 
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
def fit(self, X: np.array, y: np.array) -> "RandomRegressor":
    """
    Fit the model using X, y as training data.

    :param X: array-like, shape=(n_columns, n_samples,) training data.
    :param y: array-like, shape=(n_samples,) training data.
    :return: Returns an instance of self.
    """
    if self.strategy not in self._ALLOWED_STRATEGIES:
        raise ValueError(f"strategy {self.strategy} is not in {self._ALLOWED_STRATEGIES}")
    X, y = check_X_y(X, y, estimator=self, dtype=FLOAT_DTYPES)
    self.n_features_in_ = X.shape[1]

    self.min_ = np.min(y)
    self.max_ = np.max(y)
    self.mu_ = np.mean(y)
    self.sigma_ = np.std(y)

    return self

predict(X)

Predict new data by generating random guesses following the given strategy based on the y statistics seen during fit.

Parameters:

Name Type Description Default
X array-like of shape (n_samples, n_features)

The data to predict.

 required

Returns:

Type Description
array-like of shape (n_samples,)

The predicted data.
Source code in sklego/dummy.py 
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
def predict(self, X):
    """Predict new data by generating random guesses following the given `strategy` based on the `y` statistics seen
    during `fit`.

    Parameters
    ----------
    X : array-like of shape (n_samples, n_features)
        The data to predict.

    Returns
    -------
    array-like of shape (n_samples,)
        The predicted data.
    """
    rs = check_random_state(self.random_state)
    check_is_fitted(self, ["n_features_in_", "min_", "max_", "mu_", "sigma_"])

    X = check_array(X, estimator=self, dtype=FLOAT_DTYPES)
    if X.shape[1] != self.n_features_in_:
        raise ValueError(f"Unexpected input dimension {X.shape[1]}, expected {self.dim_}")

    if self.strategy == "normal":
        return rs.normal(self.mu_, self.sigma_, X.shape[0])
    if self.strategy == "uniform":
        return rs.uniform(self.min_, self.max_, X.shape[0])