In questa sfida, utilizzerai il **Titanic dataset**, che contiene informazioni sui passeggeri del Titanic, inclusi età, sesso, dimensione della famiglia e altro ancora. L'obiettivo è prevedere se un passeggero è sopravvissuto o meno.

import pandas as pd

df = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b71ff7ac-3932-41d2-a4d8-060e24b00129/titanic.csv') 
print(df.head())

Per implementare l'albero decisionale, puoi utilizzare il `DecisionTreeClassifier` da `sklearn`:

Compito di costruzione di un albero decisionale e individuazione dei migliori valori di `max_depth` e `min_samples_leaf` tramite grid search.

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

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

    def test_param_grid_is_correct(self):
        import user_code
        expected_value = {'max_depth': [1, 2, 3, 4, 5, 6, 7], 'min_samples_leaf': [1, 2, 4, 6]}

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

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

    def test_grid_cv_is_correct(self):
        import user_code
        from sklearn.model_selection import GridSearchCV
        from sklearn.tree import DecisionTreeClassifier

        param_grid = {'max_depth': [1, 2, 3, 4, 5, 6, 7], 'min_samples_leaf': [1, 2, 4, 6]}

        variable = 'grid_cv'
        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,
                                   DecisionTreeClassifier) and actual_value.param_grid == param_grid and actual_value.cv is 10
            failure_message = f"Expected `{variable}` to be a `GridSearchCV` with `estimator=DecisionTreeClassifier()`, `param_grid={param_grid}`, and `cv=10`, 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_cv` is a `GridSearchCV` with `estimator=lr`, `param_grid=param_grid`, and `cv=None`.",
            failure_message
        )

    def test_best_score_is_correct(self):
        import user_code
        expected_value = 0.8316978776529339

        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

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 un Albero Decisionale

Soluzione