Créer un arbre de décision

Dans ce module, vous allez utiliser le fichier YDF (Yggdrasil) Decision Forest) entraîne et interprète un arbre de décision.

Ce module s'inspire du cours 🧭 Premiers pas avec YDF tutoriel.

Préliminaires

Avant d'étudier le jeu de données, procédez comme suit:

1. Créez un nouveau Colab notebook.
2. Installez la bibliothèque YDF en plaçant et en exécutant la ligne de code suivante. dans votre nouveau notebook Colab:

   !pip install ydf -U
   

3. Importez les bibliothèques suivantes:

   import ydf
   import numpy as np
   import pandas as pd
   

Le jeu de données des manchots de Palmer

Ce Colab utilise <ph type="x-smartling-placeholder"></ph> l'ensemble de données "Palmer Penguins", qui contient les mesures de taille de trois espèces de manchots:

• À jugulaire
• Gentoo
• Adelie

Il s'agit d'un problème de classification dont l'objectif est de prédire les espèces penguin à partir des données du jeu de données sur les manchots de Palmer. Voici les manchots:

<ph type="x-smartling-placeholder"></ph> Figure 16. Trois espèces de manchots différentes. Image de @allisonhorst

 

Le code suivant appelle un Pandas pour charger en mémoire le jeu de données des manchots de Palmer:

path = "https://storage.googleapis.com/download.tensorflow.org/data/palmer_penguins/penguins.csv"
dataset = pd.read_csv(path)
label = "species"

# Display the first 3 examples.
dataset.head(3)

Le tableau suivant formate les 3 premiers exemples du manchot de Palmer ensemble de données:

<ph type="x-smartling-placeholder"></ph> Tableau 3. Les 3 premiers exemples chez les manchots de Palmer

	espèce	island	bill_length_mm	bill_depth_mm	flipper_length_mm	body_mass_g	sex	année
0	Adelie	Torgersen	39,1	18,7	181,0	3 750	male	2007
1	Adelie	Torgersen	39,5	17,4	186,0	3 800,0	female	2007
2	Adelie	Torgersen	40,3	18.0	195,0	3 250	female	2007

L'ensemble de données complet contient des données numériques (par exemple, bill_depth_mm), catégorielle (par exemple, island) et les caractéristiques manquantes. Contrairement aux réseaux de neurones les forêts de décision sont compatibles avec tous ces types de caractéristiques de manière native. l'encodage one-hot, la normalisation ou la fonctionnalité supplémentaire is_present.

La cellule de code suivante divise l'ensemble de données en un ensemble d'entraînement et un ensemble de test set:

# Use the ~20% of the examples as the testing set
# and the remaining ~80% of the examples as the training set.
np.random.seed(1)
is_test = np.random.rand(len(dataset)) < 0.2

train_dataset = dataset[~is_test]
test_dataset = dataset[is_test]

print("Training examples: ", len(train_dataset))
# >> Training examples: 272

print("Testing examples: ", len(test_dataset))
# >> Testing examples: 72

Entraîner un arbre de décision avec des hyperparamètres par défaut

Vous pouvez entraîner votre premier arbre de décision à l'aide du CART les arbres de régression) d'apprentissage (c'est-à-dire les apprenants) sans en spécifier hyperparamètres. En effet, l'apprenant ydf.CartLearner fournit une bonne valeur par défaut des valeurs d'hyperparamètres. Vous en apprendrez plus sur le fonctionnement de ce type de modèle plus tard dans le cours.

model = ydf.CartLearner(label=label).train(train_dataset)

L'appel précédent n'a pas spécifié les colonnes à utiliser en tant que les caractéristiques d'entrée. Par conséquent, chaque colonne de l'ensemble d'entraînement est utilisée. L'appel ne spécifie pas non plus la sémantique (par exemple, numérique, catégorielle ou textuelle) ; des caractéristiques d'entrée. La sémantique des caractéristiques est donc automatiquement déduite.

Appelez model.plot_tree() pour afficher l'arbre de décision obtenu:

model.plot_tree()

Dans Colab, vous pouvez utiliser la souris pour afficher des détails sur des éléments spécifiques tels que comme distribution des classes dans chaque nœud.

<ph type="x-smartling-placeholder"></ph> Figure 17. Un arbre de décision entraîné avec les hyperparamètres par défaut.

Colab montre que la condition racine contient 243 exemples. Cependant, vous pouvez rappelez-vous que l'ensemble de données d'entraînement contenait 272 exemples. Les 29 autres des exemples ont été automatiquement réservés pour la validation et l'élagage d'arborescence.

La première condition teste la valeur de bill_depth_mm. Les tableaux 4 et 5 présentent la probabilité de différentes espèces en fonction du résultat de la première condition.

<ph type="x-smartling-placeholder"></ph> Tableau 4. Probabilité de différentes espèces si la valeur est bill_depth_mm ≥ 42.3

Espèces	Probabilité
Adélie (rouge)	8 %
Gentoo (bleu)	58 %
À jugulaire (vert)	36 %

 

<ph type="x-smartling-placeholder"></ph> Tableau 5. Probabilité de différentes espèces si bill_depth_mm < 42.3

Espèces	Probabilité
Adélie (rouge)	97 %
Gentoo (bleu)	2 %
À jugulaire (vert)	0 %

bill_depth_mm est une caractéristique numérique. Par conséquent, la valeur 42,3 a été trouvée à l'aide de la scission exacte pour la classification binaire avec caractéristiques.

Si bill_depth_mm ≥ 42.3 est "True", vérifier si le flipper_length_mm ≥ 207.5 distingue presque parfaitement les Gentoos et de les Gentoos + Adelie.

Le code suivant fournit la justesse de l'entraînement et du test du modèle:

train_evaluation = model.evaluate(train_dataset)
print("train accuracy:", train_evaluation.accuracy)
# >> train accuracy:  0.9338

test_evaluation = model.evaluate(test_dataset)
print("test accuracy:", test_evaluation.accuracy)
# >> test accuracy:  0.9167

Il est rare, mais possible, que la précision du test soit supérieure à celle de l'entraînement précision. Dans ce cas, l'ensemble de test diffère peut-être de l'ensemble d'entraînement. Toutefois, ce n'est pas le cas ici, puisque les fonctions d'entraînement test a été divisé de manière aléatoire. Il est plus probable que l'ensemble de données de test soit très petit (seuls 72 exemples), l'estimation de la justesse comporte donc du bruit.

En pratique, pour un si petit ensemble de données, l'utilisation validation croisée serait préférable, car il calculerait des valeurs de métrique d'évaluation plus précises. Cependant, dans cet exemple, nous continuons des tests dans le but de la simplicité.

Améliorer les hyperparamètres du modèle

Le modèle est un arbre de décision unique qui a été entraîné avec les hyperparamètres par défaut valeurs. Pour obtenir de meilleures prédictions, vous pouvez:

1. Faites appel à un outil d'apprentissage plus performant, forêt aléatoire ou des arbres à boosting de gradient dans un modèle de ML. Ces algorithmes d'apprentissage seront expliqués à la page suivante.

2. Optimiser l'hyperparamètre à l'aide de vos observations et de vos intents La guide d'amélioration des modèles peut être utile.

3. utiliser les réglages d'hyperparamètres ; pour tester automatiquement un grand nombre d'hyperparamètres possibles.

Comme nous n'avons pas encore vu la forêt et les arbres à boosting de gradient et le nombre d'exemples étant trop faible pour effectuer une des hyperparamètres, vous améliorerez manuellement le modèle.

L'arbre de décision ci-dessus est petit et la feuille avec 61 exemple contient une combinaison d'étiquettes Adelie et Chinstrap. Pourquoi l'algorithme n'a-t-il pas divisé cette feuille ? plus loin ? Il y a deux raisons possibles à cela :

• Le nombre minimal d'échantillons par feuille (min_examples=5 par défaut) peut avoir une valeur a été atteinte.
• L'arbre a peut-être été divisé, puis élagué pour éviter le surapprentissage.

Réduisez le nombre minimal d'exemples à 1 et observez les résultats:

model = ydf.CartLearner(label=label, min_examples=1).train(train_dataset)
model.plot_tree()

<ph type="x-smartling-placeholder"></ph> Figure 18. Un arbre de décision entraîné avec min_examples=1.

 

Le nœud feuille contenant 61 exemples a été divisé en plusieurs fois.

Pour déterminer si une division supplémentaire du nœud est intéressante, nous évaluons la qualité ce nouveau modèle sur l'ensemble de données de test:

print(model.evaluate(test_dataset).accuracy)
# >> 0.97222

La qualité du modèle s'est améliorée, la justesse du test est passée de 0,9167 à 0,97222. Ce changement d'hyperparamètre était une bonne idée.

Anciennes forêts de décision

En continuant à améliorer les hyperparamètres, nous pouvons probablement précision. Cependant, au lieu de ce processus manuel, nous pouvons entraîner un modèle comme une forêt aléatoire et voyez s'il fonctionne mieux.

model = ydf.RandomForestLearner(label=label).train(pandas_train_dataset)
print("Test accuracy: ", model.evaluate(pandas_test_dataset).accuracy)
# >> Test accuracy: 0.986111

La précision de la forêt aléatoire est meilleure que celle de notre arbre simple. Vous : dans les prochaines pages pourquoi.

Utilisation et limites

Comme indiqué précédemment, la qualité d'un arbre de décision unique est souvent inférieure à celle d'un arbre moderne des méthodes de machine learning telles que les forêts d'arbres décisionnels, les arbres à boosting de gradient et réseaux sociaux. Les arbres de décision restent toutefois utiles dans les cas suivants:

• En tant que référence simple et peu coûteuse pour évaluer des approches plus complexes.
• Lorsqu'il existe un compromis entre la qualité du modèle et l'interprétabilité.
• En tant que proxy pour l'interprétation du modèle de forêts de décision, que nous examinerons plus tard.