Skip to content

Regressor

Bases: ABC

Abstract base class for all regressors.

Source code in src/safeds/ml/classical/regression/_regressor.py 
 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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
class Regressor(ABC):
    """Abstract base class for all regressors."""

    def __hash__(self) -> int:
        """
        Return a deterministic hash value for a regressor.

        Returns
        -------
        hash:
            The hash value.
        """
        return _structural_hash(self.__class__.__qualname__, self.is_fitted)

    @abstractmethod
    def fit(self, training_set: TabularDataset | ExperimentalTabularDataset) -> Regressor:
        """
        Create a copy of this regressor and fit it with the given training data.

        This regressor is not modified.

        Parameters
        ----------
        training_set:
            The training data containing the feature and target vectors.

        Returns
        -------
        fitted_regressor:
            The fitted regressor.

        Raises
        ------
        LearningError
            If the training data contains invalid values or if the training failed.
        """

    @abstractmethod
    def predict(self, dataset: Table | ExperimentalTable | ExperimentalTabularDataset) -> TabularDataset:
        """
        Predict a target vector using a dataset containing feature vectors. The model has to be trained first.

        Parameters
        ----------
        dataset:
            The dataset containing the feature vectors.

        Returns
        -------
        table:
            A dataset containing the given feature vectors and the predicted target vector.

        Raises
        ------
        ModelNotFittedError
            If the model has not been fitted yet.
        DatasetMissesFeaturesError
            If the dataset misses feature columns.
        PredictionError
            If predicting with the given dataset failed.
        """

    @property
    @abstractmethod
    def is_fitted(self) -> bool:
        """Whether the regressor is fitted."""

    @abstractmethod
    def _get_sklearn_regressor(self) -> RegressorMixin:
        """
        Return a new wrapped Regressor from sklearn.

        Returns
        -------
        wrapped_regressor:
            The sklearn Regressor.
        """

    # ------------------------------------------------------------------------------------------------------------------
    # Metrics
    # ------------------------------------------------------------------------------------------------------------------

    def summarize_metrics(self, validation_or_test_set: TabularDataset | ExperimentalTabularDataset) -> Table:
        """
        Summarize the regressor's metrics on the given data.

        Parameters
        ----------
        validation_or_test_set:
            The validation or test set.

        Returns
        -------
        metrics:
            A table containing the regressor's metrics.

        Raises
        ------
        TypeError
            If a table is passed instead of a tabular dataset.
        """
        mean_absolute_error = self.mean_absolute_error(validation_or_test_set)
        mean_squared_error = self.mean_squared_error(validation_or_test_set)

        return Table(
            {
                "metric": ["mean_absolute_error", "mean_squared_error"],
                "value": [mean_absolute_error, mean_squared_error],
            },
        )

    def mean_absolute_error(self, validation_or_test_set: TabularDataset | ExperimentalTabularDataset) -> float:
        """
        Compute the mean absolute error (MAE) of the regressor on the given data.

        Parameters
        ----------
        validation_or_test_set:
            The validation or test set.

        Returns
        -------
        mean_absolute_error:
            The calculated mean absolute error (the average of the distance of each individual row).

        Raises
        ------
        TypeError
            If a table is passed instead of a tabular dataset.
        """
        from sklearn.metrics import mean_absolute_error as sk_mean_absolute_error

        if not isinstance(validation_or_test_set, TabularDataset) and isinstance(validation_or_test_set, Table):
            raise PlainTableError

        if isinstance(validation_or_test_set, TabularDataset):
            expected = validation_or_test_set.target
            predicted = self.predict(validation_or_test_set.features).target

            # TODO: more efficient implementation using polars
            _check_metrics_preconditions(predicted, expected)
            return sk_mean_absolute_error(expected._data, predicted._data)
        elif isinstance(validation_or_test_set, ExperimentalTabularDataset):  # pragma: no cover
            expected_2 = validation_or_test_set.target
            predicted_2 = self.predict(validation_or_test_set.features).target

            # TODO: more efficient implementation using polars
            _check_metrics_preconditions_experimental(predicted_2, expected_2)
            return sk_mean_absolute_error(expected_2._series, predicted_2._data)

    # noinspection PyProtectedMember
    def mean_squared_error(self, validation_or_test_set: TabularDataset | ExperimentalTabularDataset) -> float:
        """
        Compute the mean squared error (MSE) on the given data.

        Parameters
        ----------
        validation_or_test_set:
            The validation or test set.

        Returns
        -------
        mean_squared_error:
            The calculated mean squared error (the average of the distance of each individual row squared).

        Raises
        ------
        TypeError
            If a table is passed instead of a tabular dataset.
        """
        from sklearn.metrics import mean_squared_error as sk_mean_squared_error

        if not isinstance(validation_or_test_set, TabularDataset) and isinstance(validation_or_test_set, Table):
            raise PlainTableError

        if isinstance(validation_or_test_set, TabularDataset):
            expected = validation_or_test_set.target
            predicted = self.predict(validation_or_test_set.features).target

            # TODO: more efficient implementation using polars
            _check_metrics_preconditions(predicted, expected)
            return sk_mean_squared_error(expected._data, predicted._data)
        elif isinstance(validation_or_test_set, ExperimentalTabularDataset):  # pragma: no cover
            expected_2 = validation_or_test_set.target
            predicted_2 = self.predict(validation_or_test_set.features).target

            # TODO: more efficient implementation using polars
            _check_metrics_preconditions_experimental(predicted_2, expected_2)
            return sk_mean_squared_error(expected_2._series, predicted_2._data)

is_fitted: bool abstractmethod property

Whether the regressor is fitted.

fit(training_set) abstractmethod

Create a copy of this regressor and fit it with the given training data.

This regressor is not modified.

Parameters:

Name Type Description Default
training_set TabularDataset | ExperimentalTabularDataset

The training data containing the feature and target vectors.

 required

Returns:

Name Type Description
fitted_regressor Regressor

The fitted regressor.

Raises:

Type Description
LearningError

If the training data contains invalid values or if the training failed.
Source code in src/safeds/ml/classical/regression/_regressor.py 
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
@abstractmethod
def fit(self, training_set: TabularDataset | ExperimentalTabularDataset) -> Regressor:
    """
    Create a copy of this regressor and fit it with the given training data.

    This regressor is not modified.

    Parameters
    ----------
    training_set:
        The training data containing the feature and target vectors.

    Returns
    -------
    fitted_regressor:
        The fitted regressor.

    Raises
    ------
    LearningError
        If the training data contains invalid values or if the training failed.
    """

mean_absolute_error(validation_or_test_set)

Compute the mean absolute error (MAE) of the regressor on the given data.

Parameters:

Name Type Description Default
validation_or_test_set TabularDataset | ExperimentalTabularDataset

The validation or test set.

 required

Returns:

Name Type Description
mean_absolute_error float

The calculated mean absolute error (the average of the distance of each individual row).

Raises:

Type Description
TypeError

If a table is passed instead of a tabular dataset.
Source code in src/safeds/ml/classical/regression/_regressor.py 
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
def mean_absolute_error(self, validation_or_test_set: TabularDataset | ExperimentalTabularDataset) -> float:
    """
    Compute the mean absolute error (MAE) of the regressor on the given data.

    Parameters
    ----------
    validation_or_test_set:
        The validation or test set.

    Returns
    -------
    mean_absolute_error:
        The calculated mean absolute error (the average of the distance of each individual row).

    Raises
    ------
    TypeError
        If a table is passed instead of a tabular dataset.
    """
    from sklearn.metrics import mean_absolute_error as sk_mean_absolute_error

    if not isinstance(validation_or_test_set, TabularDataset) and isinstance(validation_or_test_set, Table):
        raise PlainTableError

    if isinstance(validation_or_test_set, TabularDataset):
        expected = validation_or_test_set.target
        predicted = self.predict(validation_or_test_set.features).target

        # TODO: more efficient implementation using polars
        _check_metrics_preconditions(predicted, expected)
        return sk_mean_absolute_error(expected._data, predicted._data)
    elif isinstance(validation_or_test_set, ExperimentalTabularDataset):  # pragma: no cover
        expected_2 = validation_or_test_set.target
        predicted_2 = self.predict(validation_or_test_set.features).target

        # TODO: more efficient implementation using polars
        _check_metrics_preconditions_experimental(predicted_2, expected_2)
        return sk_mean_absolute_error(expected_2._series, predicted_2._data)

mean_squared_error(validation_or_test_set)

Compute the mean squared error (MSE) on the given data.

Parameters:

Name Type Description Default
validation_or_test_set TabularDataset | ExperimentalTabularDataset

The validation or test set.

 required

Returns:

Name Type Description
mean_squared_error float

The calculated mean squared error (the average of the distance of each individual row squared).

Raises:

Type Description
TypeError

If a table is passed instead of a tabular dataset.
Source code in src/safeds/ml/classical/regression/_regressor.py 
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
def mean_squared_error(self, validation_or_test_set: TabularDataset | ExperimentalTabularDataset) -> float:
    """
    Compute the mean squared error (MSE) on the given data.

    Parameters
    ----------
    validation_or_test_set:
        The validation or test set.

    Returns
    -------
    mean_squared_error:
        The calculated mean squared error (the average of the distance of each individual row squared).

    Raises
    ------
    TypeError
        If a table is passed instead of a tabular dataset.
    """
    from sklearn.metrics import mean_squared_error as sk_mean_squared_error

    if not isinstance(validation_or_test_set, TabularDataset) and isinstance(validation_or_test_set, Table):
        raise PlainTableError

    if isinstance(validation_or_test_set, TabularDataset):
        expected = validation_or_test_set.target
        predicted = self.predict(validation_or_test_set.features).target

        # TODO: more efficient implementation using polars
        _check_metrics_preconditions(predicted, expected)
        return sk_mean_squared_error(expected._data, predicted._data)
    elif isinstance(validation_or_test_set, ExperimentalTabularDataset):  # pragma: no cover
        expected_2 = validation_or_test_set.target
        predicted_2 = self.predict(validation_or_test_set.features).target

        # TODO: more efficient implementation using polars
        _check_metrics_preconditions_experimental(predicted_2, expected_2)
        return sk_mean_squared_error(expected_2._series, predicted_2._data)

predict(dataset) abstractmethod

Predict a target vector using a dataset containing feature vectors. The model has to be trained first.

Parameters:

Name Type Description Default
dataset Table | ExperimentalTable | ExperimentalTabularDataset

The dataset containing the feature vectors.

 required

Returns:

Name Type Description
table TabularDataset

A dataset containing the given feature vectors and the predicted target vector.

Raises:

Type Description
ModelNotFittedError

If the model has not been fitted yet.
DatasetMissesFeaturesError

If the dataset misses feature columns.
PredictionError

If predicting with the given dataset failed.
Source code in src/safeds/ml/classical/regression/_regressor.py 
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
@abstractmethod
def predict(self, dataset: Table | ExperimentalTable | ExperimentalTabularDataset) -> TabularDataset:
    """
    Predict a target vector using a dataset containing feature vectors. The model has to be trained first.

    Parameters
    ----------
    dataset:
        The dataset containing the feature vectors.

    Returns
    -------
    table:
        A dataset containing the given feature vectors and the predicted target vector.

    Raises
    ------
    ModelNotFittedError
        If the model has not been fitted yet.
    DatasetMissesFeaturesError
        If the dataset misses feature columns.
    PredictionError
        If predicting with the given dataset failed.
    """

summarize_metrics(validation_or_test_set)

Summarize the regressor's metrics on the given data.

Parameters:

Name Type Description Default
validation_or_test_set TabularDataset | ExperimentalTabularDataset

The validation or test set.

 required

Returns:

Name Type Description
metrics Table

A table containing the regressor's metrics.

Raises:

Type Description
TypeError

If a table is passed instead of a tabular dataset.
Source code in src/safeds/ml/classical/regression/_regressor.py 
 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
def summarize_metrics(self, validation_or_test_set: TabularDataset | ExperimentalTabularDataset) -> Table:
    """
    Summarize the regressor's metrics on the given data.

    Parameters
    ----------
    validation_or_test_set:
        The validation or test set.

    Returns
    -------
    metrics:
        A table containing the regressor's metrics.

    Raises
    ------
    TypeError
        If a table is passed instead of a tabular dataset.
    """
    mean_absolute_error = self.mean_absolute_error(validation_or_test_set)
    mean_squared_error = self.mean_squared_error(validation_or_test_set)

    return Table(
        {
            "metric": ["mean_absolute_error", "mean_squared_error"],
            "value": [mean_absolute_error, mean_squared_error],
        },
    )