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:
- Créez un nouveau Colab notebook.
- 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
- 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:
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.
Optimiser l'hyperparamètre à l'aide de vos observations et de vos intents La guide d'amélioration des modèles peut être utile.
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.