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.
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.