In `sklearn`, la versione per la classificazione della Random Forest è implementata tramite `RandomForestClassifier`:

Calcolerai inoltre l'accuratezza della validazione incrociata utilizzando la funzione `cross_val_score()`:

Alla fine, stamperai l'**importanza di ciascuna caratteristica**. L'attributo `feature_importances_` restituisce un array di punteggi di importanza: questi punteggi rappresentano quanto ogni caratteristica ha contribuito a **ridurre l'impurità di Gini** in tutti i nodi decisionali in cui quella caratteristica è stata utilizzata. In altre parole, più una caratteristica **aiuta a suddividere i dati** in modo utile, maggiore sarà la sua **importanza**.

Tuttavia, l'attributo fornisce solo i **punteggi senza i nomi delle caratteristiche**. Per visualizzarli entrambi, puoi abbinarli utilizzando la funzione `zip()` di Python:

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

Questo stampa ogni **nome della caratteristica insieme al suo punteggio di importanza**, facilitando la comprensione di quali caratteristiche sono state maggiormente utilizzate dal modello.

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

Apprendi i principali algoritmi di classificazione che alimentano il machine learning moderno. Esplora come modelli come k-NN, regressione logistica, alberi decisionali e foreste casuali effettuano previsioni, valuta la loro accuratezza e comprendi quando utilizzare ciascuno di essi. Sviluppa le competenze per confrontare i modelli e scegliere il più adatto ai tuoi dati.

Scopri come l'algoritmo dei k-nearest neighbors effettua previsioni basate sulla similarità. Impara a gestire più caratteristiche, ottimizzare i parametri e applicare la cross-validazione per migliorare l'accuratezza.

Comprendere come la regressione logistica modella le probabilità e classifica gli esiti. Esercitarsi nell'implementazione, nell'interpretazione delle frontiere di decisione e nell'applicazione della regolarizzazione per prevenire l'overfitting.

Scopri come gli alberi decisionali suddividono i dati in gruppi significativi in base ai valori delle caratteristiche. Esplora come parametri quali la profondità dell'albero e il numero minimo di campioni per foglia influenzano le prestazioni e la generalizzazione del modello.

Esplora come le random forest combinano più alberi decisionali per migliorare accuratezza e robustezza. Comprendi il ruolo della casualità e applica questo metodo ensemble a dati reali.

Valutazione dei modelli utilizzando metriche come accuratezza, precisione, richiamo e F1-score. Interpretazione delle matrici di confusione e confronto tra più classificatori per identificare il modello con le migliori prestazioni.

Sfida: Implementazione di una Random Forest

Soluzione