KNN¶

def fit(self, dataset: list[list[float]], labels: list[Any]) -> KNN:
    """Fit the KNN model to the given dataset and labels.

    Args:
        dataset: The input dataset to fit the model to.
        labels: The labels corresponding to the input dataset.

    Returns:
        The fitted KNN instance.

    Raises:
        ValueError: If features, labels, or the neighbor count are invalid.
        TypeError: If std_transform is not a boolean.
    """
    _validate_dataset(dataset)
    self._validate_k(len(dataset))
    if not isinstance(self.std_transform, bool):
        msg = "std_transform must be a boolean"
        raise TypeError(msg)
    if len(labels) != len(dataset):
        msg = "The number of labels must match the number of samples"
        raise ValueError(msg)
    try:
        for label in labels:
            hash(label)
    except TypeError as exc:
        msg = "Each label must be hashable"
        raise ValueError(msg) from exc

    standardizer = None
    if self.std_transform:
        standardizer = Standardizer()
        fitted_data = standardizer.fit_transform(dataset)
    else:
        fitted_data = [row.copy() for row in dataset]
    # Commit a complete fit; validation or preprocessing failures leave the old model intact.
    self.dataset_ = fitted_data
    self.labels_ = labels.copy()
    self.standardizer_ = standardizer
    return self

def predict(self, x: list[float]) -> Any:  # noqa: ANN401
    """Predict the label of the input data.

    Args:
        x: The input data to predict.

    Returns:
        The predicted label.

    Raises:
        ValueError: If the model is unfitted or the query or neighbor count is invalid.
    """
    if self.dataset_ is None or self.labels_ is None:
        msg = "The model is not fitted yet!"
        raise ValueError(msg)

    self._validate_k(len(self.dataset_))
    _validate_dataset([x], len(self.dataset_[0]))
    if self.std_transform:
        if self.standardizer_ is None:
            msg = "Cannot find the standardization!"
            raise ValueError(msg)
        x = self.standardizer_.transform([x])[0]
    distances = [euclidean_distance(x, point) for point in self.dataset_]
    # get k-nearest neighbors' label
    k_nearest_labels = [
        label for _, label in sorted(zip(distances, self.labels_, strict=True), key=lambda x: x[0])
    ][: self.k]
    label = Counter(k_nearest_labels).most_common(1)[0][0]
    return label

def fit(self, dataset: list[list[float]]) -> Standardizer:
    """Fit the standardization model to the given dataset.

    Args:
        dataset: The input dataset to fit the model to.

    Returns:
        The fitted Standardizer instance.

    Raises:
        ValueError: If features are empty, inconsistent, non-finite, or cannot be scaled.
    """
    dimension = _validate_dataset(dataset)
    try:
        means = self._dataset_column_means(dataset)
        stds = self._dataset_column_stds(dataset)
    except OverflowError as exc:
        msg = "Standardization statistics exceed the floating-point range"
        raise ValueError(msg) from exc
    self._dimension = dimension
    self._means = means
    self._stds = stds
    return self

def transform(self, dataset: list[list[float]]) -> list[list[float]]:
    """Transform the given dataset using the fitted standardization model.

    Args:
        dataset: The input dataset to transform.

    Returns:
        New standardized rows; the input dataset is unchanged.

    Raises:
        ValueError: If unfitted or given invalid or unrepresentable feature values.
    """
    if self._dimension is None:
        msg = "The model is not fitted yet!"
        raise ValueError(msg)
    return self.standardization(dataset)

def fit_transform(self, dataset: list[list[float]]) -> list[list[float]]:
    """Fit the standardization model to the dataset and transform it in one step.

    Args:
        dataset: The input dataset to fit and transform.

    Returns:
        New standardized rows; the input dataset is unchanged.
    """
    self.fit(dataset)
    return self.transform(dataset)

def standardization(self, dataset: list[list[float]]) -> list[list[float]]:
    """Standardize the given numerical dataset.

    The standardization is performed by subtracting the mean and dividing
    by the standard deviation for each feature.
    When the standard deviation is 0, all the values in the column are the same,
    here we set std to 1 to make every value in the column become 0 and avoid division by zero.

    Args:
        dataset: The input dataset to standardize.

    Returns:
        New standardized rows; the input dataset is unchanged.

    Raises:
        ValueError: If the model has not been fitted yet.
    """
    if self._dimension is None:
        msg = "The model is not fitted yet!"
        raise ValueError(msg)
    _validate_dataset(dataset, self._dimension)
    # Small nonzero standard deviations carry real variation regardless of feature units.
    scales = [1.0 if std == 0.0 else std for std in self._stds]
    result = [
        [(value - mean) / scale for value, mean, scale in zip(row, self._means, scales, strict=True)]
        for row in dataset
    ]
    if not all(math.isfinite(value) for row in result for value in row):
        msg = "Standardized values exceed the floating-point range"
        raise ValueError(msg)
    return result