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

**Multiklassifikation** med k-NN er lige så let som binær klassifikation. Vi vælger blot den klasse, der dominerer i nabolaget.  


`KNeighborsClassifier` udfører automatisk multiklassifikation, hvis `y` har mere end to funktioner, så du **behøver ikke ændre noget**. Det eneste, der ændres, er `y`-variablen, der gives til `.fit()`-metoden.

Nu skal du udføre en **multiklassifikation med k-NN**. Overvej følgende datasæt:

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

Det er det samme som i eksemplet fra det forrige kapitel, men nu kan målet antage tre værdier:
- **0**: "Havde det" (bedømmelse er mindre end 3/5);
- **1**: "Meh" (bedømmelse mellem 3/5 og 4/5);
- **2**: "Kunne lide det" (bedømmelse er 4/5 eller højere).

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

Behersk de centrale klassifikationsalgoritmer, der driver moderne maskinlæring. Udforsk hvordan modeller som k-NN, logistisk regression, beslutningstræer og random forests foretager forudsigelser, evaluerer deres nøjagtighed, og forstå hvornår hver model bør anvendes. Opbyg færdigheder til at sammenligne modeller og vælge den bedste til dine data.

Opdag, hvordan k-nærmeste naboer-algoritmen foretager forudsigelser baseret på lighed. Lær at håndtere flere egenskaber, justere parametre og anvende krydsvalidering for at forbedre nøjagtigheden.

Forstå, hvordan logistisk regression modellerer sandsynligheder og klassificerer udfald. Øv implementering, fortolkning af beslutningsgrænser og anvendelse af regularisering for at forhindre overfitting.

Lær, hvordan beslutningstræer opdeler data i meningsfulde grupper baseret på featureværdier. Udforsk, hvordan parametre som trædybde og minimum antal prøver per blad påvirker modellens ydeevne og generalisering.

Undersøg, hvordan random forests kombinerer flere beslutningstræer for at forbedre nøjagtighed og robusthed. Forstå betydningen af tilfældighed og anvend denne ensemble-metode på virkelige data.

Evaluering af modeller ved hjælp af metrikker såsom nøjagtighed, præcision, recall og F1-score. Lær at fortolke forvekslingsmatrixer og sammenligne flere klassifikatorer for at identificere den bedst præsterende model.

Multiklassifikation

Løsning

Awesome!

Multiklassifikation

Løsning