Skip to content

SimpleImputer

Bases: TableTransformer

Replace missing values using the given strategy.

Parameters:

Name Type Description Default
strategy Strategy

How to replace missing values.

 required
value_to_replace float | str | None

The value that should be replaced.

 None
selector str | list[str] | None

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

 None

Examples:

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

Classes:

Name Description
Strategy

Various strategies to replace missing values.

Methods:

Name Description
fit

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

Learn a transformation for a set of columns in a table and apply the learned transformation to the same table.
transform

Apply the learned transformation to a table.

Attributes:

Name Type Description
is_fitted bool

Whether the transformer is fitted.
strategy Strategy

The strategy used to replace missing values.
value_to_replace Any

The value that should be replaced.
Source code in src/safeds/data/tabular/transformation/_simple_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
class SimpleImputer(TableTransformer):
    """
    Replace missing values using the given strategy.

    Parameters
    ----------
    strategy:
        How to replace missing values.
    value_to_replace:
        The value that should be replaced.
    selector:
        The list of columns used to fit the transformer. If `None`, all columns are used.

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

    class Strategy(ABC):
        """
        Various strategies to replace missing values.

        Use the static factory methods to create instances of this class.
        """

        @abstractmethod
        def __eq__(self, other: object) -> bool: ...

        @abstractmethod
        def __hash__(self) -> int: ...

        @abstractmethod
        def __str__(self) -> str: ...

        @abstractmethod
        def _get_replacement(self, table: Table) -> dict[str, Any]:
            """Return a polars expression to compute the replacement value for each column of a data frame."""

        @staticmethod
        def constant(value: Any) -> SimpleImputer.Strategy:
            """
            Replace missing values with the given constant value.

            Parameters
            ----------
            value:
                The value to replace missing values.
            """
            return _Constant(value)

        @staticmethod
        def mean() -> SimpleImputer.Strategy:
            """Replace missing values with the mean of each column."""
            return _Mean()

        @staticmethod
        def median() -> SimpleImputer.Strategy:
            """Replace missing values with the median of each column."""
            return _Median()

        @staticmethod
        def mode() -> SimpleImputer.Strategy:
            """Replace missing values with the mode of each column."""
            return _Mode()

    # ------------------------------------------------------------------------------------------------------------------
    # Dunder methods
    # ------------------------------------------------------------------------------------------------------------------

    def __init__(
        self,
        strategy: SimpleImputer.Strategy,
        *,
        selector: str | list[str] | None = None,
        value_to_replace: float | str | None = None,
    ) -> None:
        super().__init__(selector)

        # Parameters
        self._strategy = strategy
        self._value_to_replace = value_to_replace

        # Internal state
        self._replacement: dict[str, Any] | None = None

    def __hash__(self) -> int:
        return _structural_hash(
            super().__hash__(),
            self._strategy,
            self._value_to_replace,
            # Leave out the internal state for faster hashing
        )

    # ------------------------------------------------------------------------------------------------------------------
    # Properties
    # ------------------------------------------------------------------------------------------------------------------

    @property
    def is_fitted(self) -> bool:
        """Whether the transformer is fitted."""
        return self._replacement is not None

    @property
    def strategy(self) -> SimpleImputer.Strategy:
        """The strategy used to replace missing values."""
        return self._strategy

    @property
    def value_to_replace(self) -> Any:
        """The value that should be replaced."""
        return self._value_to_replace

    # ------------------------------------------------------------------------------------------------------------------
    # Learning and transformation
    # ------------------------------------------------------------------------------------------------------------------

    def fit(self, table: Table) -> SimpleImputer:
        """
        Learn a transformation for a set of columns in a table.

        This transformer is not modified.

        Parameters
        ----------
        table:
            The table used to fit the transformer.

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

        Raises
        ------
        ColumnNotFoundError
            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 isinstance(self._strategy, _Mean | _Median):
            if self._selector is None:
                column_names = [name for name in table.column_names if table.get_column_type(name).is_numeric]
            else:
                column_names = self._selector
                _check_columns_exist(table, column_names)
                _check_columns_are_numeric(table, column_names, operation="fit a SimpleImputer")
        else:  # noqa: PLR5501
            if self._selector is None:
                column_names = table.column_names
            else:
                column_names = self._selector
                _check_columns_exist(table, column_names)

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

        # Learn the transformation
        replacement = self._strategy._get_replacement(table)

        # Create a copy with the learned transformation
        result = SimpleImputer(self._strategy, selector=column_names, value_to_replace=self._value_to_replace)
        result._replacement = replacement

        return result

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

        The table is not modified.

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

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

        Raises
        ------
        NotFittedError
            If the transformer has not been fitted yet.
        ColumnNotFoundError
            If the input table does not contain all columns used to fit the transformer.
        """
        import polars as pl

        # Used in favor of is_fitted, so the type checker is happy
        if self._selector is None or self._replacement is None:
            raise NotFittedError(kind="transformer")

        _check_columns_exist(table, self._selector)

        columns = [
            (pl.col(name).replace(old=self._value_to_replace, new=self._replacement[name])) for name in self._selector
        ]

        return Table._from_polars_lazy_frame(
            table._lazy_frame.with_columns(columns),
        )

is_fitted

Whether the transformer is fitted.

strategy

The strategy used to replace missing values.

value_to_replace

The value that should be replaced.

Strategy

Bases: ABC

Various strategies to replace missing values.

Use the static factory methods to create instances of this class.

Methods:

Name Description
constant

Replace missing values with the given constant value.
mean

Replace missing values with the mean of each column.
median

Replace missing values with the median of each column.
mode

Replace missing values with the mode of each column.
Source code in src/safeds/data/tabular/transformation/_simple_imputer.py 
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
class Strategy(ABC):
    """
    Various strategies to replace missing values.

    Use the static factory methods to create instances of this class.
    """

    @abstractmethod
    def __eq__(self, other: object) -> bool: ...

    @abstractmethod
    def __hash__(self) -> int: ...

    @abstractmethod
    def __str__(self) -> str: ...

    @abstractmethod
    def _get_replacement(self, table: Table) -> dict[str, Any]:
        """Return a polars expression to compute the replacement value for each column of a data frame."""

    @staticmethod
    def constant(value: Any) -> SimpleImputer.Strategy:
        """
        Replace missing values with the given constant value.

        Parameters
        ----------
        value:
            The value to replace missing values.
        """
        return _Constant(value)

    @staticmethod
    def mean() -> SimpleImputer.Strategy:
        """Replace missing values with the mean of each column."""
        return _Mean()

    @staticmethod
    def median() -> SimpleImputer.Strategy:
        """Replace missing values with the median of each column."""
        return _Median()

    @staticmethod
    def mode() -> SimpleImputer.Strategy:
        """Replace missing values with the mode of each column."""
        return _Mode()

constant

Replace missing values with the given constant value.

Parameters:

Name Type Description Default
value Any

The value to replace missing values.

 required
Source code in src/safeds/data/tabular/transformation/_simple_imputer.py 
63
64
65
66
67
68
69
70
71
72
73
@staticmethod
def constant(value: Any) -> SimpleImputer.Strategy:
    """
    Replace missing values with the given constant value.

    Parameters
    ----------
    value:
        The value to replace missing values.
    """
    return _Constant(value)

mean

Replace missing values with the mean of each column.

Source code in src/safeds/data/tabular/transformation/_simple_imputer.py 
75
76
77
78
@staticmethod
def mean() -> SimpleImputer.Strategy:
    """Replace missing values with the mean of each column."""
    return _Mean()

median

Replace missing values with the median of each column.

Source code in src/safeds/data/tabular/transformation/_simple_imputer.py 
80
81
82
83
@staticmethod
def median() -> SimpleImputer.Strategy:
    """Replace missing values with the median of each column."""
    return _Median()

mode

Replace missing values with the mode of each column.

Source code in src/safeds/data/tabular/transformation/_simple_imputer.py 
85
86
87
88
@staticmethod
def mode() -> SimpleImputer.Strategy:
    """Replace missing values with the mode of each column."""
    return _Mode()

fit

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

Returns:

Name Type Description
fitted_transformer SimpleImputer

The fitted transformer.

Raises:

Type Description
ColumnNotFoundError

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/_simple_imputer.py 
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
def fit(self, table: Table) -> SimpleImputer:
    """
    Learn a transformation for a set of columns in a table.

    This transformer is not modified.

    Parameters
    ----------
    table:
        The table used to fit the transformer.

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

    Raises
    ------
    ColumnNotFoundError
        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 isinstance(self._strategy, _Mean | _Median):
        if self._selector is None:
            column_names = [name for name in table.column_names if table.get_column_type(name).is_numeric]
        else:
            column_names = self._selector
            _check_columns_exist(table, column_names)
            _check_columns_are_numeric(table, column_names, operation="fit a SimpleImputer")
    else:  # noqa: PLR5501
        if self._selector is None:
            column_names = table.column_names
        else:
            column_names = self._selector
            _check_columns_exist(table, column_names)

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

    # Learn the transformation
    replacement = self._strategy._get_replacement(table)

    # Create a copy with the learned transformation
    result = SimpleImputer(self._strategy, selector=column_names, value_to_replace=self._value_to_replace)
    result._replacement = replacement

    return result

fit_and_transform

Learn a transformation for a set of columns in a table and apply the learned transformation to the same table.

Note: Neither this transformer nor the given table are modified.

Parameters:

Name Type Description Default
table Table

The table used to fit the transformer. The transformer is then applied to this table.

 required

Returns:

Name Type Description
fitted_transformer Self

The fitted transformer.
transformed_table Table

The transformed table.
Source code in src/safeds/data/tabular/transformation/_table_transformer.py 
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
def fit_and_transform(self, table: Table) -> tuple[Self, Table]:
    """
    Learn a transformation for a set of columns in a table and apply the learned transformation to the same table.

    **Note:** Neither this transformer nor the given table are modified.

    Parameters
    ----------
    table:
        The table used to fit the transformer. The transformer is then applied to this table.

    Returns
    -------
    fitted_transformer:
        The fitted transformer.
    transformed_table:
        The transformed table.
    """
    fitted_transformer = self.fit(table)
    transformed_table = fitted_transformer.transform(table)
    return fitted_transformer, transformed_table

transform

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
NotFittedError

If the transformer has not been fitted yet.
ColumnNotFoundError

If the input table does not contain all columns used to fit the transformer.
Source code in src/safeds/data/tabular/transformation/_simple_imputer.py 
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
def transform(self, table: Table) -> Table:
    """
    Apply the learned transformation to a table.

    The table is not modified.

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

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

    Raises
    ------
    NotFittedError
        If the transformer has not been fitted yet.
    ColumnNotFoundError
        If the input table does not contain all columns used to fit the transformer.
    """
    import polars as pl

    # Used in favor of is_fitted, so the type checker is happy
    if self._selector is None or self._replacement is None:
        raise NotFittedError(kind="transformer")

    _check_columns_exist(table, self._selector)

    columns = [
        (pl.col(name).replace(old=self._value_to_replace, new=self._replacement[name])) for name in self._selector
    ]

    return Table._from_polars_lazy_frame(
        table._lazy_frame.with_columns(columns),
    )