`sklearn`-kirjastossa satunnaismetsän luokitusversio toteutetaan `RandomForestClassifier`-luokalla:

Lasket myös ristiinvalidoinnin tarkkuuden käyttämällä `cross_val_score()`-funktiota:

Lopuksi tulostat **kunkin piirteen tärkeyden**. `feature_importances_`-attribuutti palauttaa taulukon tärkeyspisteitä – nämä pisteet kuvaavat, kuinka paljon kukin piirre vaikutti **Gini-epäpuhtauden vähentämiseen** kaikissa päätössolmuissa, joissa kyseistä piirrettä käytettiin. Toisin sanoen, mitä enemmän piirre **auttaa jakamaan dataa** hyödyllisellä tavalla, sitä suurempi on sen **tärkeys**.

Attribuutti antaa kuitenkin vain **pisteet ilman piirteen nimiä**. Molempien näyttämiseksi voit yhdistää ne Pythonin `zip()`-funktiolla:

```python
for feature, importance in zip(X.columns, model.feature_importances_):
    print(feature, importance)
```

Tämä tulostaa **kunkin piirteen nimen ja sen tärkeyspisteen**, mikä helpottaa ymmärtämään, mihin piirteisiin malli tukeutui eniten.

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_random_forest_is_declared(self):
        import user_code

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

    def test_random_forest_is_fitted_model(self):
        import user_code
        from sklearn.ensemble import RandomForestClassifier

        variable = 'random_forest'
        actual_value = getattr(user_code, variable, None)
        condition = False
        if actual_value is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif isinstance(actual_value, RandomForestClassifier):
            if actual_value.random_state == 42:
                if hasattr(actual_value, 'feature_importances_'):
                    condition = True
                    failure_message = None
                else:
                    failure_message = f"`{variable}` is is not fitted yet."
            else:
                failure_message = f"Expected `{variable}` to have `random_state=42`, but got `{actual_value.random_state}`."
        else:
            failure_message = f"`{variable}` is not a `RandomForestClassifier`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` is a correctly fitted `RandomForestClassifier`.",
            failure_message
        )

    def test_cv_scores_is_declared(self):
        import user_code

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

    def test_cv_scores_is_correct(self):
        import user_code
        import pandas as pd
        from sklearn.ensemble import RandomForestClassifier
        from sklearn.model_selection import cross_val_score

        df = pd.read_csv(
            'https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b71ff7ac-3932-41d2-a4d8-060e24b00129/titanic.csv')
        X = df.drop('Survived', axis=1)
        y = df['Survived']

        random_forest = RandomForestClassifier(random_state=42).fit(X, y)
        expected_value = cross_val_score(random_forest, X, y, cv=10)

        variable = 'cv_scores'
        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 len(actual_value) == 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 scores.",
            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: Satunnaismetsän Toteuttaminen

Ratkaisu

Awesome!

Haaste: Satunnaismetsän Toteuttaminen

Ratkaisu