Introduction
En apprentissage automatique, les arbres de décision sont des modèles couramment utilisés. Cependant, les arbres de décision ont tendance à surapprendre les données d'entraînement, ce qui peut les rendre peu performants sur les données de test. Une manière d'éviter le surapprentissage est de tailler l'arbre de décision. La taille par complexité de coût est une méthode populaire pour tailler les arbres de décision. Dans ce laboratoire, nous utiliserons scikit-learn pour démontrer la taille par complexité de coût pour les arbres de décision.
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 limites de Jupyter Notebook.
Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous réglerons rapidement le problème pour vous.
Charger les données
Nous utiliserons le jeu de données du cancer du sein de scikit-learn. Ce jeu de données a 30 caractéristiques et une variable cible binaire indiquant si un patient a un cancer malin ou bénin.
from sklearn.datasets import load_breast_cancer
X, y = load_breast_cancer(return_X_y=True)
Diviser les données
Nous allons diviser les données en un ensemble d'entraînement et un ensemble de test.
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
Déterminer les valeurs appropriées d'alpha
Nous voulons déterminer les valeurs appropriées d'alpha à utiliser pour tailler l'arbre de décision. Nous pouvons le faire en traçant l'impureté totale des feuilles en fonction des alphas effectifs de l'arbre taillé.
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt
clf = DecisionTreeClassifier(random_state=0)
path = clf.cost_complexity_pruning_path(X_train, y_train)
ccp_alphas, impurities = path.ccp_alphas, path.impurities
fig, ax = plt.subplots()
ax.plot(ccp_alphas[:-1], impurities[:-1], marker="o", drawstyle="steps-post")
ax.set_xlabel("alpha effectif")
ax.set_ylabel("impureté totale des feuilles")
ax.set_title("Impureté totale vs alpha effectif pour l'ensemble d'entraînement")
Entraîner les arbres de décision
Ensuite, nous allons entraîner un arbre de décision en utilisant chacune des valeurs d'alpha effectives. La dernière valeur de ccp_alphas est la valeur d'alpha qui taille l'arbre complet, laissant un arbre avec un seul nœud.
clfs = []
for ccp_alpha in ccp_alphas:
clf = DecisionTreeClassifier(random_state=0, ccp_alpha=ccp_alpha)
clf.fit(X_train, y_train)
clfs.append(clf)
print(
"Nombre de nœuds dans le dernier arbre est : {} avec ccp_alpha : {}".format(
clfs[-1].tree_.node_count, ccp_alphas[-1]
)
)
Supprimer les arbres triviaux
Nous allons supprimer l'arbre trivial avec un seul nœud de la liste d'arbres de décision.
clfs = clfs[:-1]
ccp_alphas = ccp_alphas[:-1]
Tracer le nombre de nœuds et la profondeur de l'arbre
Nous allons tracer le nombre de nœuds et la profondeur de l'arbre au fur et à mesure que alpha augmente.
node_counts = [clf.tree_.node_count for clf in clfs]
depth = [clf.tree_.max_depth for clf in clfs]
fig, ax = plt.subplots(2, 1)
ax[0].plot(ccp_alphas, node_counts, marker="o", drawstyle="steps-post")
ax[0].set_xlabel("alpha")
ax[0].set_ylabel("nombre de nœuds")
ax[0].set_title("Nombre de nœuds vs alpha")
ax[1].plot(ccp_alphas, depth, marker="o", drawstyle="steps-post")
ax[1].set_xlabel("alpha")
ax[1].set_ylabel("profondeur de l'arbre")
ax[1].set_title("Profondeur vs alpha")
fig.tight_layout()
Déterminer la meilleure valeur d'alpha
Nous voulons déterminer la meilleure valeur d'alpha à utiliser pour tailler l'arbre de décision. Nous pouvons le faire en traçant la précision en fonction d'alpha pour les ensembles d'entraînement et de test.
train_scores = [clf.score(X_train, y_train) for clf in clfs]
test_scores = [clf.score(X_test, y_test) for clf in clfs]
fig, ax = plt.subplots()
ax.set_xlabel("alpha")
ax.set_ylabel("précision")
ax.set_title("Précision vs alpha pour les ensembles d'entraînement et de test")
ax.plot(ccp_alphas, train_scores, marker="o", label="train", drawstyle="steps-post")
ax.plot(ccp_alphas, test_scores, marker="o", label="test", drawstyle="steps-post")
ax.legend()
plt.show()
Sommaire
Dans ce laboratoire, nous avons démontré comment utiliser scikit-learn pour effectuer une taille basée sur la complexité de coût pour les arbres de décision. Nous avons divisé les données en un ensemble d'entraînement et de test, déterminé les valeurs d'alpha appropriées à utiliser pour la taille, entraîné des arbres de décision en utilisant les valeurs d'alpha effectives, tracé le nombre de nœuds et la profondeur de l'arbre, et déterminé la meilleure valeur d'alpha à utiliser pour la taille en fonction de la précision des ensembles d'entraînement et de test.