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

**Moniluokkainen luokittelu** k-NN:llä on yhtä helppoa kuin binääriluokittelu. Valitaan vain luokka, joka on enemmistönä naapurustossa.  


`KNeighborsClassifier` suorittaa automaattisesti moniluokkaisen luokittelun, jos `y` sisältää enemmän kuin kaksi ominaisuutta, joten **mitään ei tarvitse muuttaa**. Ainoa muutos on `y`-metodille syötettävä `.fit()`-muuttuja.

Seuraavaksi suoritetaan **moniluokkainen luokittelu k-NN:llä**. Tarkastellaan seuraavaa aineistoa:

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

Se on sama kuin edellisen luvun esimerkissä, mutta nyt tavoitemuuttuja voi saada kolme arvoa:
- **0**: "Inhosi sitä" (arvosana alle 3/5);
- **1**: "Meh" (arvosana välillä 3/5 ja 4/5);
- **2**: "Piti siitä" (arvosana 4/5 tai korkeampi).

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

Hallitse keskeiset luokittelualgoritmit, jotka ovat modernin koneoppimisen ytimessä. Tutustu siihen, miten mallit kuten k-NN, logistinen regressio, päätöspuut ja satunnaismetsät tekevät ennusteita, arvioi niiden tarkkuutta ja ymmärrä, milloin kutakin kannattaa käyttää. Kehitä taitoja vertailla malleja ja valita paras vaihtoehto aineistosi perusteella.

Opi, miten k-lähimmän naapurin algoritmi tekee ennusteita samankaltaisuuden perusteella. Sisältää useiden piirteiden käsittelyn, parametrien säätämisen ja ristiinvalidoinnin hyödyntämisen tarkkuuden parantamiseksi.

Ymmärrä, miten logistinen regressio mallintaa todennäköisyyksiä ja luokittelee tuloksia. Harjoittele sen toteuttamista, päätösrajojen tulkintaa sekä regularisoinnin soveltamista ylisovittamisen estämiseksi.

Opi, kuinka päätöspuut jakavat dataa merkityksellisiin ryhmiin ominaisuuksien arvojen perusteella. Tutustu siihen, miten parametrit, kuten puun syvyys ja lehden miniminäytteiden määrä, vaikuttavat mallin suorituskykyyn ja yleistettävyyteen.

Tutustu siihen, miten satunnaismetsät yhdistävät useita päätöspuita parantaakseen tarkkuutta ja vankkuutta. Ymmärrä satunnaisuuden rooli ja sovella tätä yhdistelmämallia reaalimaailman dataan.

Mallien arviointi mittareilla, kuten tarkkuus, precision, recall ja F1-pisteet. Sekamatriksien tulkinta ja useiden luokittelijoiden vertailu parhaan mallin tunnistamiseksi.

Moniluokkainen Luokittelu

Ratkaisu