Skip to content

Imputer

Bases: TableTransformer

Replace missing values with the given strategy.

Parameters:

Name Type Description Default
strategy ImputerStrategy

The strategy used to impute missing values. Use the classes nested inside Imputer.Strategy to specify it.

 required

Examples:

>>> from safeds.data.tabular.containers import Column, Table
>>> from safeds.data.tabular.transformation import Imputer
>>>
>>> table = Table.from_columns(
...     [
...         Column("a", [1, 3, None]),
...         Column("b", [None, 2, 3]),
...     ],
... )
>>> transformer = Imputer(Imputer.Strategy.Constant(0))
>>> transformed_table = transformer.fit_and_transform(table)
Source code in src/safeds/data/tabular/transformation/_imputer.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
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
class Imputer(TableTransformer):
    """
    Replace missing values with the given strategy.

    Parameters
    ----------
    strategy : ImputerStrategy
        The strategy used to impute missing values. Use the classes nested inside `Imputer.Strategy` to specify it.

    Examples
    --------
    >>> from safeds.data.tabular.containers import Column, Table
    >>> from safeds.data.tabular.transformation import Imputer
    >>>
    >>> table = Table.from_columns(
    ...     [
    ...         Column("a", [1, 3, None]),
    ...         Column("b", [None, 2, 3]),
    ...     ],
    ... )
    >>> transformer = Imputer(Imputer.Strategy.Constant(0))
    >>> transformed_table = transformer.fit_and_transform(table)
    """

    class Strategy:
        class Constant(ImputerStrategy):
            """
            An imputation strategy for imputing missing data with given constant values.

            Parameters
            ----------
            value :
                The given value to impute missing values.
            """

            def __init__(self, value: Any):
                self._value = value

            def __str__(self) -> str:
                return f"Constant({self._value})"

            def _augment_imputer(self, imputer: sk_SimpleImputer) -> None:
                imputer.strategy = "constant"
                imputer.fill_value = self._value

        class Mean(ImputerStrategy):
            """An imputation strategy for imputing missing data with mean values."""

            def __str__(self) -> str:
                return "Mean"

            def _augment_imputer(self, imputer: sk_SimpleImputer) -> None:
                imputer.strategy = "mean"

        class Median(ImputerStrategy):
            """An imputation strategy for imputing missing data with median values."""

            def __str__(self) -> str:
                return "Median"

            def _augment_imputer(self, imputer: sk_SimpleImputer) -> None:
                imputer.strategy = "median"

        class Mode(ImputerStrategy):
            """An imputation strategy for imputing missing data with mode values. The lowest value will be used if there are multiple values with the same highest count."""

            def __str__(self) -> str:
                return "Mode"

            def _augment_imputer(self, imputer: sk_SimpleImputer) -> None:
                imputer.strategy = "most_frequent"

    def __init__(self, strategy: ImputerStrategy):
        self._strategy = strategy

        self._wrapped_transformer: sk_SimpleImputer | None = None
        self._column_names: list[str] | None = None

    # noinspection PyProtectedMember
    def fit(self, table: Table, column_names: list[str] | None) -> Imputer:
        """
        Learn a transformation for a set of columns in a table.

        This transformer is not modified.

        Parameters
        ----------
        table : Table
            The table used to fit the transformer.
        column_names : list[str] | None
            The list of columns from the table used to fit the transformer. If `None`, all columns are used.

        Returns
        -------
        fitted_transformer : TableTransformer
            The fitted transformer.

        Raises
        ------
        UnknownColumnNameError
            If column_names contain a column name that is missing in the table
        ValueError
            If the table contains 0 rows
        NonNumericColumnError
            If the strategy is set to either Mean or Median and the specified columns of the table contain non-numerical data.
        """
        if column_names is None:
            column_names = table.column_names
        else:
            missing_columns = sorted(set(column_names) - set(table.column_names))
            if len(missing_columns) > 0:
                raise UnknownColumnNameError(missing_columns)

        if table.number_of_rows == 0:
            raise ValueError("The Imputer cannot be fitted because the table contains 0 rows")

        if (isinstance(self._strategy, Imputer.Strategy.Mean | Imputer.Strategy.Median)) and table.keep_only_columns(
            column_names,
        ).remove_columns_with_non_numerical_values().number_of_columns < len(
            column_names,
        ):
            raise NonNumericColumnError(
                str(
                    sorted(
                        set(table.keep_only_columns(column_names).column_names)
                        - set(
                            table.keep_only_columns(column_names)
                            .remove_columns_with_non_numerical_values()
                            .column_names,
                        ),
                    ),
                ),
            )

        if isinstance(self._strategy, Imputer.Strategy.Mode):
            multiple_most_frequent = {}
            for name in column_names:
                if len(table.get_column(name).mode()) > 1:
                    multiple_most_frequent[name] = table.get_column(name).mode()
            if len(multiple_most_frequent) > 0:
                warnings.warn(
                    "There are multiple most frequent values in a column given to the Imputer.\nThe lowest values"
                    " are being chosen in this cases. The following columns have multiple most frequent"
                    f" values:\n{multiple_most_frequent}",
                    UserWarning,
                    stacklevel=2,
                )

        wrapped_transformer = sk_SimpleImputer()
        self._strategy._augment_imputer(wrapped_transformer)
        wrapped_transformer.fit(table._data[column_names])

        result = Imputer(self._strategy)
        result._wrapped_transformer = wrapped_transformer
        result._column_names = column_names

        return result

    # noinspection PyProtectedMember
    def transform(self, table: Table) -> Table:
        """
        Apply the learned transformation to a table.

        The table is not modified.

        Parameters
        ----------
        table : Table
            The table to which the learned transformation is applied.

        Returns
        -------
        transformed_table : Table
            The transformed table.

        Raises
        ------
        TransformerNotFittedError
            If the transformer has not been fitted yet.
        UnknownColumnNameError
            If the input table does not contain all columns used to fit the transformer.
        ValueError
            If the table contains 0 rows.
        """
        # Transformer has not been fitted yet
        if self._wrapped_transformer is None or self._column_names is None:
            raise TransformerNotFittedError

        # Input table does not contain all columns used to fit the transformer
        missing_columns = sorted(set(self._column_names) - set(table.column_names))
        if len(missing_columns) > 0:
            raise UnknownColumnNameError(missing_columns)

        if table.number_of_rows == 0:
            raise ValueError("The Imputer cannot transform the table because it contains 0 rows")

        data = table._data.reset_index(drop=True)
        data[self._column_names] = pd.DataFrame(
            self._wrapped_transformer.transform(data[self._column_names]),
            columns=self._column_names,
        )
        return Table._from_pandas_dataframe(data, table.schema)

    def is_fitted(self) -> bool:
        """
        Check if the transformer is fitted.

        Returns
        -------
        is_fitted : bool
            Whether the transformer is fitted.
        """
        return self._wrapped_transformer is not None

    def get_names_of_added_columns(self) -> list[str]:
        """
        Get the names of all new columns that have been added by the Imputer.

        Returns
        -------
        added_columns : list[str]
            A list of names of the added columns, ordered as they will appear in the table.

        Raises
        ------
        TransformerNotFittedError
            If the transformer has not been fitted yet.
        """
        if not self.is_fitted():
            raise TransformerNotFittedError
        return []

    # (Must implement abstract method, cannot instantiate class otherwise.)
    def get_names_of_changed_columns(self) -> list[str]:
        """
         Get the names of all columns that may have been changed by the Imputer.

        Returns
        -------
        changed_columns : list[str]
             The list of (potentially) changed column names, as passed to fit.

        Raises
        ------
        TransformerNotFittedError
            If the transformer has not been fitted yet.
        """
        if self._column_names is None:
            raise TransformerNotFittedError
        return self._column_names

    def get_names_of_removed_columns(self) -> list[str]:
        """
        Get the names of all columns that have been removed by the Imputer.

        Returns
        -------
        removed_columns : list[str]
            A list of names of the removed columns, ordered as they appear in the table the Imputer was fitted on.

        Raises
        ------
        TransformerNotFittedError
            If the transformer has not been fitted yet.
        """
        if not self.is_fitted():
            raise TransformerNotFittedError
        return []

Strategy

Source code in src/safeds/data/tabular/transformation/_imputer.py 
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
class Strategy:
    class Constant(ImputerStrategy):
        """
        An imputation strategy for imputing missing data with given constant values.

        Parameters
        ----------
        value :
            The given value to impute missing values.
        """

        def __init__(self, value: Any):
            self._value = value

        def __str__(self) -> str:
            return f"Constant({self._value})"

        def _augment_imputer(self, imputer: sk_SimpleImputer) -> None:
            imputer.strategy = "constant"
            imputer.fill_value = self._value

    class Mean(ImputerStrategy):
        """An imputation strategy for imputing missing data with mean values."""

        def __str__(self) -> str:
            return "Mean"

        def _augment_imputer(self, imputer: sk_SimpleImputer) -> None:
            imputer.strategy = "mean"

    class Median(ImputerStrategy):
        """An imputation strategy for imputing missing data with median values."""

        def __str__(self) -> str:
            return "Median"

        def _augment_imputer(self, imputer: sk_SimpleImputer) -> None:
            imputer.strategy = "median"

    class Mode(ImputerStrategy):
        """An imputation strategy for imputing missing data with mode values. The lowest value will be used if there are multiple values with the same highest count."""

        def __str__(self) -> str:
            return "Mode"

        def _augment_imputer(self, imputer: sk_SimpleImputer) -> None:
            imputer.strategy = "most_frequent"

Constant

Bases: ImputerStrategy

An imputation strategy for imputing missing data with given constant values.

Parameters:

Name Type Description Default
value Any

The given value to impute missing values.

 required
Source code in src/safeds/data/tabular/transformation/_imputer.py 
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
class Constant(ImputerStrategy):
    """
    An imputation strategy for imputing missing data with given constant values.

    Parameters
    ----------
    value :
        The given value to impute missing values.
    """

    def __init__(self, value: Any):
        self._value = value

    def __str__(self) -> str:
        return f"Constant({self._value})"

    def _augment_imputer(self, imputer: sk_SimpleImputer) -> None:
        imputer.strategy = "constant"
        imputer.fill_value = self._value

__init__(value)

Source code in src/safeds/data/tabular/transformation/_imputer.py 
50
51
def __init__(self, value: Any):
    self._value = value

__str__()

Source code in src/safeds/data/tabular/transformation/_imputer.py 
53
54
def __str__(self) -> str:
    return f"Constant({self._value})"

Mean

Bases: ImputerStrategy

An imputation strategy for imputing missing data with mean values.

Source code in src/safeds/data/tabular/transformation/_imputer.py 
60
61
62
63
64
65
66
67
class Mean(ImputerStrategy):
    """An imputation strategy for imputing missing data with mean values."""

    def __str__(self) -> str:
        return "Mean"

    def _augment_imputer(self, imputer: sk_SimpleImputer) -> None:
        imputer.strategy = "mean"

__str__()

Source code in src/safeds/data/tabular/transformation/_imputer.py 
63
64
def __str__(self) -> str:
    return "Mean"

Median

Bases: ImputerStrategy

An imputation strategy for imputing missing data with median values.

Source code in src/safeds/data/tabular/transformation/_imputer.py 
69
70
71
72
73
74
75
76
class Median(ImputerStrategy):
    """An imputation strategy for imputing missing data with median values."""

    def __str__(self) -> str:
        return "Median"

    def _augment_imputer(self, imputer: sk_SimpleImputer) -> None:
        imputer.strategy = "median"

__str__()

Source code in src/safeds/data/tabular/transformation/_imputer.py 
72
73
def __str__(self) -> str:
    return "Median"

Mode

Bases: ImputerStrategy

An imputation strategy for imputing missing data with mode values. The lowest value will be used if there are multiple values with the same highest count.

Source code in src/safeds/data/tabular/transformation/_imputer.py 
78
79
80
81
82
83
84
85
class Mode(ImputerStrategy):
    """An imputation strategy for imputing missing data with mode values. The lowest value will be used if there are multiple values with the same highest count."""

    def __str__(self) -> str:
        return "Mode"

    def _augment_imputer(self, imputer: sk_SimpleImputer) -> None:
        imputer.strategy = "most_frequent"

__str__()

Source code in src/safeds/data/tabular/transformation/_imputer.py 
81
82
def __str__(self) -> str:
    return "Mode"

__init__(strategy)

Source code in src/safeds/data/tabular/transformation/_imputer.py 
87
88
89
90
91
def __init__(self, strategy: ImputerStrategy):
    self._strategy = strategy

    self._wrapped_transformer: sk_SimpleImputer | None = None
    self._column_names: list[str] | None = None

fit(table, column_names)

Learn a transformation for a set of columns in a table.

This transformer is not modified.

Parameters:

Name Type Description Default
table Table

The table used to fit the transformer.

 required
column_names list[str] | None

The list of columns from the table used to fit the transformer. If None, all columns are used.

 required

Returns:

Name Type Description
fitted_transformer TableTransformer

The fitted transformer.

Raises:

Type Description
UnknownColumnNameError

If column_names contain a column name that is missing in the table
ValueError

If the table contains 0 rows
NonNumericColumnError

If the strategy is set to either Mean or Median and the specified columns of the table contain non-numerical data.
Source code in src/safeds/data/tabular/transformation/_imputer.py 
 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
def fit(self, table: Table, column_names: list[str] | None) -> Imputer:
    """
    Learn a transformation for a set of columns in a table.

    This transformer is not modified.

    Parameters
    ----------
    table : Table
        The table used to fit the transformer.
    column_names : list[str] | None
        The list of columns from the table used to fit the transformer. If `None`, all columns are used.

    Returns
    -------
    fitted_transformer : TableTransformer
        The fitted transformer.

    Raises
    ------
    UnknownColumnNameError
        If column_names contain a column name that is missing in the table
    ValueError
        If the table contains 0 rows
    NonNumericColumnError
        If the strategy is set to either Mean or Median and the specified columns of the table contain non-numerical data.
    """
    if column_names is None:
        column_names = table.column_names
    else:
        missing_columns = sorted(set(column_names) - set(table.column_names))
        if len(missing_columns) > 0:
            raise UnknownColumnNameError(missing_columns)

    if table.number_of_rows == 0:
        raise ValueError("The Imputer cannot be fitted because the table contains 0 rows")

    if (isinstance(self._strategy, Imputer.Strategy.Mean | Imputer.Strategy.Median)) and table.keep_only_columns(
        column_names,
    ).remove_columns_with_non_numerical_values().number_of_columns < len(
        column_names,
    ):
        raise NonNumericColumnError(
            str(
                sorted(
                    set(table.keep_only_columns(column_names).column_names)
                    - set(
                        table.keep_only_columns(column_names)
                        .remove_columns_with_non_numerical_values()
                        .column_names,
                    ),
                ),
            ),
        )

    if isinstance(self._strategy, Imputer.Strategy.Mode):
        multiple_most_frequent = {}
        for name in column_names:
            if len(table.get_column(name).mode()) > 1:
                multiple_most_frequent[name] = table.get_column(name).mode()
        if len(multiple_most_frequent) > 0:
            warnings.warn(
                "There are multiple most frequent values in a column given to the Imputer.\nThe lowest values"
                " are being chosen in this cases. The following columns have multiple most frequent"
                f" values:\n{multiple_most_frequent}",
                UserWarning,
                stacklevel=2,
            )

    wrapped_transformer = sk_SimpleImputer()
    self._strategy._augment_imputer(wrapped_transformer)
    wrapped_transformer.fit(table._data[column_names])

    result = Imputer(self._strategy)
    result._wrapped_transformer = wrapped_transformer
    result._column_names = column_names

    return result

get_names_of_added_columns()

Get the names of all new columns that have been added by the Imputer.

Returns:

Name Type Description
added_columns list[str]

A list of names of the added columns, ordered as they will appear in the table.

Raises:

Type Description
TransformerNotFittedError

If the transformer has not been fitted yet.
Source code in src/safeds/data/tabular/transformation/_imputer.py 
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
def get_names_of_added_columns(self) -> list[str]:
    """
    Get the names of all new columns that have been added by the Imputer.

    Returns
    -------
    added_columns : list[str]
        A list of names of the added columns, ordered as they will appear in the table.

    Raises
    ------
    TransformerNotFittedError
        If the transformer has not been fitted yet.
    """
    if not self.is_fitted():
        raise TransformerNotFittedError
    return []

get_names_of_changed_columns()

Get the names of all columns that may have been changed by the Imputer.

Returns:

Name Type Description
changed_columns list[str]

The list of (potentially) changed column names, as passed to fit.

Raises:

Type Description
TransformerNotFittedError

If the transformer has not been fitted yet.
Source code in src/safeds/data/tabular/transformation/_imputer.py 
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
def get_names_of_changed_columns(self) -> list[str]:
    """
     Get the names of all columns that may have been changed by the Imputer.

    Returns
    -------
    changed_columns : list[str]
         The list of (potentially) changed column names, as passed to fit.

    Raises
    ------
    TransformerNotFittedError
        If the transformer has not been fitted yet.
    """
    if self._column_names is None:
        raise TransformerNotFittedError
    return self._column_names

get_names_of_removed_columns()

Get the names of all columns that have been removed by the Imputer.

Returns:

Name Type Description
removed_columns list[str]

A list of names of the removed columns, ordered as they appear in the table the Imputer was fitted on.

Raises:

Type Description
TransformerNotFittedError

If the transformer has not been fitted yet.
Source code in src/safeds/data/tabular/transformation/_imputer.py 
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
def get_names_of_removed_columns(self) -> list[str]:
    """
    Get the names of all columns that have been removed by the Imputer.

    Returns
    -------
    removed_columns : list[str]
        A list of names of the removed columns, ordered as they appear in the table the Imputer was fitted on.

    Raises
    ------
    TransformerNotFittedError
        If the transformer has not been fitted yet.
    """
    if not self.is_fitted():
        raise TransformerNotFittedError
    return []

is_fitted()

Check if the transformer is fitted.

Returns:

Name Type Description
is_fitted bool

Whether the transformer is fitted.
Source code in src/safeds/data/tabular/transformation/_imputer.py 
218
219
220
221
222
223
224
225
226
227
def is_fitted(self) -> bool:
    """
    Check if the transformer is fitted.

    Returns
    -------
    is_fitted : bool
        Whether the transformer is fitted.
    """
    return self._wrapped_transformer is not None

transform(table)

Apply the learned transformation to a table.

The table is not modified.

Parameters:

Name Type Description Default
table Table

The table to which the learned transformation is applied.

 required

Returns:

Name Type Description
transformed_table Table

The transformed table.

Raises:

Type Description
TransformerNotFittedError

If the transformer has not been fitted yet.
UnknownColumnNameError

If the input table does not contain all columns used to fit the transformer.
ValueError

If the table contains 0 rows.
Source code in src/safeds/data/tabular/transformation/_imputer.py 
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
204
205
206
207
208
209
210
211
212
213
214
215
216
def transform(self, table: Table) -> Table:
    """
    Apply the learned transformation to a table.

    The table is not modified.

    Parameters
    ----------
    table : Table
        The table to which the learned transformation is applied.

    Returns
    -------
    transformed_table : Table
        The transformed table.

    Raises
    ------
    TransformerNotFittedError
        If the transformer has not been fitted yet.
    UnknownColumnNameError
        If the input table does not contain all columns used to fit the transformer.
    ValueError
        If the table contains 0 rows.
    """
    # Transformer has not been fitted yet
    if self._wrapped_transformer is None or self._column_names is None:
        raise TransformerNotFittedError

    # Input table does not contain all columns used to fit the transformer
    missing_columns = sorted(set(self._column_names) - set(table.column_names))
    if len(missing_columns) > 0:
        raise UnknownColumnNameError(missing_columns)

    if table.number_of_rows == 0:
        raise ValueError("The Imputer cannot transform the table because it contains 0 rows")

    data = table._data.reset_index(drop=True)
    data[self._column_names] = pd.DataFrame(
        self._wrapped_transformer.transform(data[self._column_names]),
        columns=self._column_names,
    )
    return Table._from_pandas_dataframe(data, table.schema)