Summary  
Multi-class classification with k-NN uses the KNeighborsClassifier to handle targets with more than two classes by selecting the most frequent class among the nearest neighbors.

General domain of usage  
Movie rating classification

**Multi-class classification** with k-NN is as easy as binary classification. We just pick the class that prevails in the neighborhood.  


The `KNeighborsClassifier` automatically performs a multi-class classification if `y` has more than two features, so you **do not need to change anything**. The only thing that changes is the `y` variable fed to the `.fit()` method.

Now, you will perform a **multi-class classification with k-NN**. Consider the following dataset:

import pandas as pd

df = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b71ff7ac-3932-41d2-a4d8-060e24b00129/starwars_multiple.csv')
print(df.head())

It is the same as in the previous chapter's example, but now the target can take three values:
- **0**: "Hated it" (rating is less than 3/5);
- **1**: "Meh" (rating between 3/5 and 4/5);
- **2**: "Liked it" (rating is 4/5 or higher).

import unittest
import importlib
import numpy as np


def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


def get_first_differing_index(expected_array, actual_array):
    for i, (val_1, val_2) in enumerate(zip(expected_array, actual_array)):
        if not np.array_equal(val_1, val_2):
            return i, expected_array[i], actual_array[i]

    if len(expected_array) > len(actual_array):
        return len(actual_array), expected_array[len(actual_array)], None
    else:
        return len(expected_array), None, actual_array[len(expected_array)]


class TestUserCode(unittest.TestCase):

    def test_scaler_is_declared(self):
        import user_code

        variable = 'scaler'
        _dynamic_test(
            self,
            hasattr(user_code, variable),
            f"The `{variable}` variable is declared.",
            f"Expected `{variable}` to be declared."
        )

    def test_scaler_is_standard_scaler(self):
        import user_code
        from sklearn.preprocessing import StandardScaler

        try:
            condition = isinstance(user_code.scaler, StandardScaler)
            failure_message = f"Expected `scaler` to be a `StandardScaler`, but got `{type(user_code.scaler).__name__}`."
        except AttributeError:
            condition = False
            failure_message = "The `scaler` variable is not declared."

        _dynamic_test(
            self,
            condition,
            "`scaler` is a `StandardScaler`.",
            failure_message
        )

    def test_X_train_is_scaled_correctly(self):
        import user_code
        from sklearn.preprocessing import StandardScaler

        df = user_code.pd.read_csv(
            'https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b71ff7ac-3932-41d2-a4d8-060e24b00129/starwars_multiple.csv')
        X_train = df.drop('StarWars6', axis=1)

        scaler = StandardScaler()
        expected_value = scaler.fit_transform(X_train)

        variable = 'X_train'
        actual_value = getattr(user_code, variable, None)
        condition = False
        if actual_value is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_value, np.ndarray):
            failure_message = f"`{variable}` is not a `numpy.ndarray`."
        elif actual_value.size == 0:
            failure_message = f"`{variable}` is empty."
        elif np.array_equal(actual_value, expected_value):
            condition = True
            failure_message = None
        else:
            idx, expected_element, actual_element = get_first_differing_index(expected_value, actual_value)
            failure_message = f"Expected `{variable}` to contain `{expected_element}` at index {idx}, but got `{actual_element}`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains the correct data.",
            failure_message
        )

    def test_X_test_is_scaled_correctly(self):
        import user_code
        from sklearn.preprocessing import StandardScaler

        df = user_code.pd.read_csv(
            'https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b71ff7ac-3932-41d2-a4d8-060e24b00129/starwars_multiple.csv')
        X_train = df.drop('StarWars6', axis=1)
        X_test = np.array([[5, 5], [4.5, 4]])

        scaler = StandardScaler()
        scaler.fit(X_train)
        expected_value = scaler.transform(X_test)

        variable = 'X_test'
        actual_value = getattr(user_code, variable, None)
        condition = False
        if actual_value is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_value, np.ndarray):
            failure_message = f"`{variable}` is not a `numpy.ndarray`."
        elif actual_value.size == 0:
            failure_message = f"`{variable}` is empty."
        elif np.array_equal(actual_value, expected_value):
            condition = True
            failure_message = None
        else:
            idx, expected_element, actual_element = get_first_differing_index(expected_value, actual_value)
            failure_message = f"Expected `{variable}` to contain `{expected_element}` at index {idx}, but got `{actual_element}`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains the correct data.",
            failure_message
        )

    def test_knn_is_declared(self):
        import user_code

        variable = 'knn'
        _dynamic_test(
            self,
            hasattr(user_code, variable),
            f"The `{variable}` variable is declared.",
            f"Expected `{variable}` to be declared."
        )

    def test_knn_is_initialized_correctly(self):
        import user_code
        from sklearn.neighbors import KNeighborsClassifier

        variable = 'knn'
        actual_value = getattr(user_code, variable, None)
        if actual_value is None:
            condition = False
            failure_message = f"The `{variable}` variable is not declared."
        elif isinstance(actual_value, KNeighborsClassifier):
            condition = actual_value.n_neighbors == 13
            failure_message = f"Expected `{variable}` to be a `KNeighborsClassifier` with `13` neighbors, but got `n_neighbors={actual_value.n_neighbors}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `KNeighborsClassifier`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` is a `KNeighborsClassifier` with `13` neighbors.",
            failure_message
        )

    def test_y_pred_is_declared(self):
        import user_code

        variable = 'y_pred'
        _dynamic_test(
            self,
            hasattr(user_code, variable),
            f"The `{variable}` variable is declared.",
            f"Expected `{variable}` to be declared."
        )

    def test_y_pred_is_correct(self):
        import user_code

        expected_value = np.array([2, 1])

        variable = 'y_pred'
        actual_value = getattr(user_code, variable, None)
        condition = False
        if actual_value is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_value, np.ndarray):
            failure_message = f"`{variable}` is not a `numpy.ndarray`."
        elif actual_value.size == 0:
            failure_message = f"`{variable}` is empty."
        elif np.array_equal(actual_value, expected_value):
            condition = True
            failure_message = None
        else:
            idx, expected_element, actual_element = get_first_differing_index(expected_value, actual_value)
            failure_message = f"Expected `{variable}` to contain `{expected_element}` at index {idx}, but got `{actual_element}`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains the correct data.",
            failure_message
        )


if __name__ == '__main__':
    unittest.main()

test_main.py

Introduces classification techniques for predicting categorical outcomes using Python. Focuses on building, training, and evaluating classification models, interpreting decision boundaries, and applying common algorithms to real-world datasets.


Multi-Class Classification

Lösung

Multi-Class Classification

Lösung