Kuten aiemmissa luvuissa on esitetty, mallin ennusteet voivat vaihdella **k**-arvon (naapureiden määrä) mukaan. k-NN-mallia rakennettaessa on tärkeää valita sellainen k-arvo, joka tuottaa **parhaan suorituskyvyn**.

Yleinen lähestymistapa on käyttää **ristivalidointia** mallin suorituskyvyn arviointiin. Voit suorittaa silmukan ja laskea ristivalidointipisteet **eri k-arvojen välillä**, ja valita sitten sen, jolla on korkein pistemäärä. Tämä on yleisimmin käytetty menetelmä.

Tämän toteuttamiseen `sklearn` tarjoaa kätevän työkalun: `GridSearchCV`-luokan.

`param_grid`-parametri ottaa **sanakirjan**, jossa avaimet ovat parametrien nimiä ja arvot ovat listoja kokeiltavista vaihtoehdoista. Esimerkiksi, jos haluat testata arvoja `1`–`99` `n_neighbors`-parametrille, voit kirjoittaa:
```python
param_grid = {'n_neighbors': range(1, 100)}
```
Kun kutsut `.fit(X, y)`-metodia `GridSearchCV`-oliolle, se käy läpi parametriverkon löytääkseen parhaat parametrit ja **kouluttaa mallin uudelleen koko aineistolla** käyttäen näitä parhaita parametreja.

Voit tarkastella **parasta pistemäärää** `.best_score_`-attribuutilla ja tehdä ennusteita optimoidulla mallilla käyttämällä `.predict()`-metodia. Samoin voit hakea **parhaan mallin** itsessään `.best_estimator_`-attribuutilla.

import unittest
import importlib


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)


class TestUserCode(unittest.TestCase):

    def test_param_grid_is_declared(self):
        import user_code

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

    def test_para_grid_is_dict(self):
        import user_code

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

        _dynamic_test(
            self,
            condition,
            "`param_grid` is a `dict`.",
            failure_message
        )

    def test_param_grid_is_correct(self):
        import user_code
        expected_value = {'n_neighbors': [3, 9, 18, 27]}

        variable = 'param_grid'
        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, dict):
            condition = actual_value == expected_value
            failure_message = f"Expected `{variable}` to contain `{expected_value}`, but got `{actual_value}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `dict`."

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

    def test_grid_search_is_declared(self):
        import user_code

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

    def test_grid_search_is_correct(self):
        import user_code
        from sklearn.model_selection import GridSearchCV
        from sklearn.neighbors import KNeighborsClassifier

        knn = KNeighborsClassifier()
        param_grid = {'n_neighbors': [3, 9, 18, 27]}

        variable = 'grid_search'
        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, GridSearchCV):
            condition = isinstance(actual_value.estimator, KNeighborsClassifier) and actual_value.param_grid == param_grid and actual_value.cv == 4
            failure_message = f"Expected `{variable}` to be a `GridSearchCV` with `knn` as the model, `4` folds, and `param_grid` as the grid of parameters, but got `estimator={actual_value.estimator}`, `param_grid={actual_value.param_grid}`, and `cv={actual_value.cv}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `GridSearchCV`."

        _dynamic_test(
            self,
            condition,
            "`grid_search` is a `GridSearchCV` with `estimator=knn`, `param_grid=param_grid`, and `cv=4`.",
            failure_message
        )

    def test_best_model_is_declared(self):
        import user_code

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

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

        variable = 'best_model'
        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 == 27
            failure_message = f"Expected `{variable}` to be a `KNeighborsClassifier` with `27` neighbors, but got `n_neighbors={actual_value.n_neighbors}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `KNeighborsClassifier`."

        _dynamic_test(
            self,
            condition,
            "`best_model` is a `KNeighborsClassifier` with `27` neighbors.",
            failure_message
        )

    def test_best_score_is_declared(self):
        import user_code

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

    def test_best_score_is_correct(self):
        import user_code
        expected_value = 0.8039505464098539

        variable = 'best_score'
        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, float):
            condition = actual_value == expected_value
            failure_message = f"Expected `{variable}` to contain `{expected_value}`, but got `{actual_value}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `float`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` is correct.",
            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.

Haaste: Parhaan K-arvon Valinta

Ratkaisu