Summary  
Multi-class classification with k-NN selects the most frequent label among the k nearest neighbors and requires no changes to the KNeighborsClassifier beyond supplying a target variable with more than two classes.

General domain of usage  
Movie review rating classification

**Mehrklassenklassifikation** mit k-NN ist genauso einfach wie die binäre Klassifikation. Es wird einfach die Klasse gewählt, die in der Nachbarschaft überwiegt.  


Der `KNeighborsClassifier` führt automatisch eine Mehrklassenklassifikation durch, wenn `y` mehr als zwei Merkmale enthält, sodass **keine Änderungen erforderlich sind**. Das Einzige, was sich ändert, ist die `y`-Variable, die an die `.fit()`-Methode übergeben wird.

Nun wird eine **Mehrklassenklassifikation mit k-NN** durchgeführt. Betrachten Sie dazu den folgenden Datensatz:

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())

Es ist dasselbe wie im Beispiel des vorherigen Kapitels, aber jetzt kann das Ziel drei Werte annehmen:
- **0**: "Hated it" (Bewertung ist weniger als 3/5);
- **1**: "Meh" (Bewertung zwischen 3/5 und 4/5);
- **2**: "Liked it" (Bewertung ist 4/5 oder höher).

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

Beherrschen Sie die grundlegenden Klassifikationsalgorithmen, die moderne Machine-Learning-Anwendungen antreiben. Erforschen Sie, wie Modelle wie k-NN, logistische Regression, Entscheidungsbäume und Random Forests Vorhersagen treffen, deren Genauigkeit bewerten und verstehen, wann welches Modell eingesetzt wird. Entwickeln Sie die Fähigkeiten, Modelle zu vergleichen und das beste für Ihre Daten auszuwählen.

Erfahren Sie, wie der k-nächste-Nachbarn-Algorithmus Vorhersagen auf Basis von Ähnlichkeiten trifft. Umgang mit mehreren Merkmalen, Parametereinstellung und Anwendung von Kreuzvalidierung zur Verbesserung der Genauigkeit.

Verstehen, wie die logistische Regression Wahrscheinlichkeiten modelliert und Ergebnisse klassifiziert. Anwendung der Implementierung, Interpretation von Entscheidungsgrenzen und Einsatz von Regularisierung zur Vermeidung von Overfitting.

Erfahren Sie, wie Entscheidungsbäume Daten anhand von Merkmalswerten in sinnvolle Gruppen unterteilen. Untersuchen Sie, wie Parameter wie Baumtiefe und minimale Stichprobengröße pro Blatt die Modellleistung und Generalisierung beeinflussen.

Erkunden, wie Random Forests mehrere Entscheidungsbäume kombinieren, um Genauigkeit und Robustheit zu verbessern.
Die Rolle des Zufalls verstehen und diese Ensemble-Methode auf reale Daten anwenden.

Bewertung von Modellen anhand von Metriken wie Genauigkeit, Präzision, Recall und F1-Score. Interpretation von Konfusionsmatrizen und Vergleich mehrerer Klassifikatoren zur Identifikation des leistungsstärksten Modells.

Mehrklassenklassifikation

Lösung