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

**Flervalsklassificering** med k-NN är lika enkel som binär klassificering. Vi väljer helt enkelt den klass som dominerar i grannskapet.  


`KNeighborsClassifier` utför automatiskt en flervalsklassificering om `y` har fler än två egenskaper, så du **behöver inte ändra något**. Det enda som ändras är `y`-variabeln som matas in i `.fit()`-metoden.

Nu kommer du att utföra en **flervalsklassificering med k-NN**. Betrakta följande 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())

Det är samma som i föregående kapitels exempel, men nu kan målet anta tre värden:
- **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

Behärska de centrala klassificeringsalgoritmerna som driver modern maskininlärning. Utforska hur modeller som k-NN, logistisk regression, beslutsträd och random forests gör prediktioner, utvärderar deras noggrannhet och förstå när varje modell bör användas. Bygg upp färdigheter för att jämföra modeller och välja den mest lämpliga för dina data.

Utforska hur algoritmen k-närmsta grannar gör förutsägelser baserat på likhet. Lär dig hantera flera variabler, justera parametrar och använda korsvalidering för att förbättra noggrannheten.

Förstå hur logistisk regression modellerar sannolikheter och klassificerar utfall. Öva på att implementera metoden, tolka beslutsgränser och tillämpa regularisering för att förhindra överanpassning.

Lär dig hur beslutsträd delar upp data i meningsfulla grupper baserat på egenskapsvärden. Utforska hur parametrar som trädets djup och minsta antal prover per blad påverkar modellens prestanda och generaliseringsförmåga.

Utforska hur random forest kombinerar flera beslutsträd för att förbättra noggrannhet och robusthet. Förstå slumpens roll och tillämpa denna ensemblemetod på verkliga data.

Utvärdera modeller med hjälp av mått såsom noggrannhet, precision, återkallelse och F1-poäng. Lära sig att tolka förväxlingsmatriser och jämföra flera klassificerare för att identifiera den modell som presterar bäst.

Multiklassklassificering

Lösning

Awesome!

Multiklassklassificering

Lösning