Tracer les forêts d'iris

Introduction

Ce laboratoire montre comment tracer les surfaces de décision des forêts d'arbres aléatoires sur l'ensemble de données iris à l'aide de la bibliothèque scikit-learn de Python. L'ensemble de données iris est un ensemble de données couramment utilisé pour les tâches de classification. Dans ce laboratoire, nous comparerons les surfaces de décision apprises par un classifieur d'arbre de décision, un classifieur à forêt aléatoire, un classifieur extra-trees et un classifieur AdaBoost.

Conseils sur la VM

Une fois le démarrage de la VM terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous résoudrons rapidement le problème pour vous.

Skills Graph

Importation des bibliothèques

Dans cette étape, nous allons importer les bibliothèques nécessaires pour tracer les surfaces de décision sur l'ensemble de données iris.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap

from sklearn.datasets import load_iris
from sklearn.ensemble import (
    RandomForestClassifier,
    ExtraTreesClassifier,
    AdaBoostClassifier,
)
from sklearn.tree import DecisionTreeClassifier

Définition des paramètres

Dans cette étape, nous allons définir les paramètres nécessaires pour tracer les surfaces de décision sur l'ensemble de données iris.

## Paramètres
n_classes = 3
n_estimators = 30
cmap = plt.cm.RdYlBu
plot_step = 0.02  ## largeur d'étape fine pour les contours de la surface de décision
plot_step_coarser = 0.5  ## largeurs d'étapes pour les prédictions grossières du classifieur
RANDOM_SEED = 13  ## fixer la graine à chaque itération

Chargement des données

Dans cette étape, nous allons charger l'ensemble de données iris.

## Chargement des données
iris = load_iris()

Définition des modèles

Dans cette étape, nous allons définir les modèles à utiliser pour tracer les surfaces de décision sur l'ensemble de données iris.

models = [
    DecisionTreeClassifier(max_depth=None),
    RandomForestClassifier(n_estimators=n_estimators),
    ExtraTreesClassifier(n_estimators=n_estimators),
    AdaBoostClassifier(DecisionTreeClassifier(max_depth=3), n_estimators=n_estimators),
]

Tracer les surfaces de décision

Dans cette étape, nous allons tracer les surfaces de décision des modèles définis sur l'ensemble de données iris.

plot_idx = 1

for pair in ([0, 1], [0, 2], [2, 3]):
    for model in models:
        ## Nous ne prenons que les deux caractéristiques correspondantes
        X = iris.data[:, pair]
        y = iris.target

        ## Mélange
        idx = np.arange(X.shape[0])
        np.random.seed(RANDOM_SEED)
        np.random.shuffle(idx)
        X = X[idx]
        y = y[idx]

        ## Standardisation
        mean = X.mean(axis=0)
        std = X.std(axis=0)
        X = (X - mean) / std

        ## Entraînement
        model.fit(X, y)

        scores = model.score(X, y)
        ## Crée un titre pour chaque colonne et la console en utilisant str() et
        ## en coupant les parties inutiles de la chaîne de caractères
        model_title = str(type(model)).split(".")[-1][:-2][: -len("Classifier")]

        model_details = model_title
        if hasattr(model, "estimators_"):
            model_details += " avec {} estimateurs".format(len(model.estimators_))
        print(model_details + " avec les caractéristiques", pair, "a un score de", scores)

        plt.subplot(3, 4, plot_idx)
        if plot_idx <= len(models):
            ## Ajoute un titre au sommet de chaque colonne
            plt.title(model_title, fontsize=9)

        ## Maintenant, trace la limite de décision en utilisant un maillage fin comme entrée pour un
        ## tracé de contour rempli
        x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
        y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
        xx, yy = np.meshgrid(
            np.arange(x_min, x_max, plot_step), np.arange(y_min, y_max, plot_step)
        )

        ## Trace soit un seul DecisionTreeClassifier ou mélange alpha les
        ## surfaces de décision de l'ensemble des classifieurs
        if isinstance(model, DecisionTreeClassifier):
            Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
            Z = Z.reshape(xx.shape)
            cs = plt.contourf(xx, yy, Z, cmap=cmap)
        else:
            ## Choisis le niveau de mélange alpha par rapport au nombre
            ## d'estimateurs
            ## qui sont utilisés (notant que AdaBoost peut utiliser moins d'estimateurs
            ## que son maximum s'il atteint une bonne approximation assez tôt)
            estimator_alpha = 1.0 / len(model.estimators_)
            for tree in model.estimators_:
                Z = tree.predict(np.c_[xx.ravel(), yy.ravel()])
                Z = Z.reshape(xx.shape)
                cs = plt.contourf(xx, yy, Z, alpha=estimator_alpha, cmap=cmap)

        ## Construit un maillage plus grossier pour tracer un ensemble de classifications d'ensemble
        ## pour montrer comment celles-ci sont différentes de ce que nous voyons dans les
        ## surfaces de décision. Ces points sont régulièrement espacés et n'ont pas
        ## d'effet de contour noir
        xx_coarser, yy_coarser = np.meshgrid(
            np.arange(x_min, x_max, plot_step_coarser),
            np.arange(y_min, y_max, plot_step_coarser),
        )
        Z_points_coarser = model.predict(
            np.c_[xx_coarser.ravel(), yy_coarser.ravel()]
        ).reshape(xx_coarser.shape)
        cs_points = plt.scatter(
            xx_coarser,
            yy_coarser,
            s=15,
            c=Z_points_coarser,
            cmap=cmap,
            edgecolors="none",
        )

        ## Trace les points d'entraînement, ceux-ci sont regroupés et ont un
        ## contour noir
        plt.scatter(
            X[:, 0],
            X[:, 1],
            c=y,
            cmap=ListedColormap(["r", "y", "b"]),
            edgecolor="k",
            s=20,
        )
        plot_idx += 1  ## passe au prochain tracé dans la séquence

plt.suptitle("Classifieurs sur des sous-ensembles de caractéristiques de l'ensemble de données Iris", fontsize=12)
plt.axis("tight")
plt.tight_layout(h_pad=0.2, w_pad=0.2, pad=2.5)
plt.show()

Sommaire

Dans ce laboratoire, nous avons appris à tracer les surfaces de décision des forêts d'arbres aléatoires sur l'ensemble de données iris à l'aide de la bibliothèque scikit-learn de Python. Nous avons comparé les surfaces de décision apprises par un classifieur à arbre de décision, un classifieur à forêt aléatoire, un classifieur Extra-Trees et un classifieur AdaBoost. Nous avons également appris à définir des modèles, à tracer des surfaces de décision et à charger des données en Python.