Skip to content

KNearestNeighborsImputer

Bases: TableTransformer

The KNearestNeighborsImputer replaces missing values in given Columns with the mean value of the K-nearest neighbors.

Parameters:

Name Type Description Default
neighbor_count int

The number of neighbors to consider when imputing missing values.

 required
selector str | list[str] | None

The list of columns used to impute missing values. If 'None', all columns are used.

 None
value_to_replace float | str | None

The placeholder for the missing values. All occurrences ofmissing_values will be imputed.

 None

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.
neighbor_count int

The number of neighbors to consider when imputing missing values.
value_to_replace float | str | None

The value to replace.
Source code in src/safeds/data/tabular/transformation/_k_nearest_neighbors_imputer.py 
 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
class KNearestNeighborsImputer(TableTransformer):
    """
    The KNearestNeighborsImputer replaces missing values in given Columns with the mean value of the K-nearest neighbors.

    Parameters
    ----------
    neighbor_count:
        The number of neighbors to consider when imputing missing values.
    selector:
        The list of columns used to impute missing values. If 'None', all columns are used.
    value_to_replace:
        The placeholder for the missing values. All occurrences of`missing_values` will be imputed.
    """

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

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

        _check_bounds(name="neighbor_count", actual=neighbor_count, lower_bound=_ClosedBound(1))

        # parameter
        self._neighbor_count: int = neighbor_count
        self._value_to_replace: float | str | None = value_to_replace

        # attributes
        self._wrapped_transformer: sk_KNNImputer | None = None

    def __hash__(self) -> int:
        return _structural_hash(
            super().__hash__(),
            self._neighbor_count,
            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._wrapped_transformer is not None

    @property
    def neighbor_count(self) -> int:
        """The number of neighbors to consider when imputing missing values."""
        return self._neighbor_count

    @property
    def value_to_replace(self) -> float | str | None:
        """The value to replace."""
        return self._value_to_replace

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

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

        **Note:** This transformer is not modified.

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

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

        Raises
        ------
        ColumnNotFoundError
            If one of the columns, that should be fitted is not in the table.
        """
        from sklearn.impute import KNNImputer as sk_KNNImputer

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

        if self._selector is None:
            column_names = table.column_names
        else:
            column_names = self._selector
            _check_columns_exist(table, column_names)

        value_to_replace = self._value_to_replace

        if self._value_to_replace is None:
            from numpy import nan

            value_to_replace = nan

        wrapped_transformer = sk_KNNImputer(n_neighbors=self._neighbor_count, missing_values=value_to_replace)
        wrapped_transformer.set_output(transform="polars")
        wrapped_transformer.fit(
            table.select_columns(column_names)._data_frame,
        )

        result = KNearestNeighborsImputer(self._neighbor_count, selector=column_names)
        result._wrapped_transformer = wrapped_transformer

        return result

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

        **Note:** The given table is not modified.

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

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

        Raises
        ------
        NotFittedError
            If the transformer is not fitted.
        ColumnNotFoundError
            If one of the columns, that should be transformed is not in the table.
        """
        if self._selector is None or self._wrapped_transformer is None:
            raise NotFittedError(kind="transformer")

        _check_columns_exist(table, self._selector)

        new_data = self._wrapped_transformer.transform(
            table.select_columns(self._selector)._data_frame,
        )

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

is_fitted

Whether the transformer is fitted.

neighbor_count

The number of neighbors to consider when imputing missing values.

value_to_replace

The value to replace.

fit

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

Note: 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 KNearestNeighborsImputer

The fitted transformer.

Raises:

Type Description
ColumnNotFoundError

If one of the columns, that should be fitted is not in the table.
Source code in src/safeds/data/tabular/transformation/_k_nearest_neighbors_imputer.py 
 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
def fit(self, table: Table) -> KNearestNeighborsImputer:
    """
    Learn a transformation for a set of columns in a table.

    **Note:** This transformer is not modified.

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

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

    Raises
    ------
    ColumnNotFoundError
        If one of the columns, that should be fitted is not in the table.
    """
    from sklearn.impute import KNNImputer as sk_KNNImputer

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

    if self._selector is None:
        column_names = table.column_names
    else:
        column_names = self._selector
        _check_columns_exist(table, column_names)

    value_to_replace = self._value_to_replace

    if self._value_to_replace is None:
        from numpy import nan

        value_to_replace = nan

    wrapped_transformer = sk_KNNImputer(n_neighbors=self._neighbor_count, missing_values=value_to_replace)
    wrapped_transformer.set_output(transform="polars")
    wrapped_transformer.fit(
        table.select_columns(column_names)._data_frame,
    )

    result = KNearestNeighborsImputer(self._neighbor_count, selector=column_names)
    result._wrapped_transformer = wrapped_transformer

    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.

Note: The given table is not modified.

Parameters:

Name Type Description Default
table Table

The table to wich the learned transformation is applied.

 required

Returns:

Name Type Description
transformed_table Table

The transformed table.

Raises:

Type Description
NotFittedError

If the transformer is not fitted.
ColumnNotFoundError

If one of the columns, that should be transformed is not in the table.
Source code in src/safeds/data/tabular/transformation/_k_nearest_neighbors_imputer.py 
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
def transform(self, table: Table) -> Table:
    """
    Apply the learned transformation to a table.

    **Note:** The given table is not modified.

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

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

    Raises
    ------
    NotFittedError
        If the transformer is not fitted.
    ColumnNotFoundError
        If one of the columns, that should be transformed is not in the table.
    """
    if self._selector is None or self._wrapped_transformer is None:
        raise NotFittedError(kind="transformer")

    _check_columns_exist(table, self._selector)

    new_data = self._wrapped_transformer.transform(
        table.select_columns(self._selector)._data_frame,
    )

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