Dans `sklearn`, la version classification de la Forêt Aléatoire est implémentée à l'aide de `RandomForestClassifier` :

Vous calculerez également la précision de la validation croisée à l'aide de la fonction `cross_val_score()` :

À la fin, affichage de **l'importance de chaque caractéristique**. L'attribut `feature_importances_` renvoie un tableau de scores d'importance : ces scores représentent la contribution de chaque caractéristique à la **réduction de l'impureté de Gini** à travers tous les nœuds de décision où cette caractéristique a été utilisée. Autrement dit, plus une caractéristique **aide à séparer les données** de manière pertinente, plus son **importance** est élevée.

Cependant, cet attribut fournit uniquement les **scores sans les noms des caractéristiques**. Pour afficher les deux, il est possible de les associer à l'aide de la fonction `zip()` de Python :

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

Cela affiche chaque **nom de caractéristique avec son score d'importance**, ce qui facilite la compréhension des caractéristiques sur lesquelles le modèle s'est le plus appuyé.

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

Maîtrisez les principaux algorithmes de classification qui alimentent l'apprentissage automatique moderne. Découvrez comment des modèles tels que k-NN, la régression logistique, les arbres de décision et les forêts aléatoires effectuent des prédictions, évaluez leur précision et comprenez quand utiliser chacun d'eux. Développez les compétences nécessaires pour comparer les modèles et choisir le plus adapté à vos données.

Découvrez comment l'algorithme des k plus proches voisins effectue des prédictions basées sur la similarité. Apprenez à gérer plusieurs caractéristiques, à ajuster les paramètres et à appliquer la validation croisée pour améliorer la précision.

Comprendre comment la régression logistique modélise les probabilités et classe les résultats. S'exercer à l'implémenter, à interpréter les frontières de décision et à appliquer la régularisation pour éviter le surapprentissage.

Découvrez comment les arbres de décision divisent les données en groupes significatifs selon les valeurs des caractéristiques. Explorez l'influence de paramètres tels que la profondeur de l'arbre et le nombre minimal d'échantillons par feuille sur la performance et la généralisation du modèle.

Découvrez comment les forêts aléatoires combinent plusieurs arbres de décision pour améliorer la précision et la robustesse. Comprenez le rôle de l'aléatoire et appliquez cette méthode d'ensemble à des données réelles.

Évaluation des modèles à l'aide de métriques telles que l'exactitude, la précision, le rappel et le score F1. Interprétation des matrices de confusion et comparaison de plusieurs classificateurs afin d'identifier le modèle le plus performant.

Défi : Implémentation d'une Forêt Aléatoire

Solution