Apprentissage Automatique et Réseaux Neuronaux - page 69
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
5.1 Lecture d'un jeu de données à partir d'un fichier texte tabulaire (L05 : Apprentissage automatique avec Scikit-Learn)
5.1 Lecture d'un jeu de données à partir d'un fichier texte tabulaire (L05 : Apprentissage automatique avec Scikit-Learn)
Bonjour à tous! J'espère que vous avez tous passé une excellente semaine et que vous avez eu la chance de travailler sur tout le matériel NumPy. Cette semaine, nous allons nous concentrer sur le traitement des données et l'apprentissage automatique avec scikit-learn, il est donc essentiel d'avoir une bonne compréhension de NumPy. Je pense qu'il est extrêmement utile de pratiquer le codage et d'appliquer les concepts que nous apprenons dans des exemples concrets, c'est pourquoi nous ferons du codage dès le début de cette conférence. Cela nous sera utile plus tard dans la classe lorsque nous utiliserons ces outils de manière intensive. En parlant de cela, il n'y a pas grand-chose d'autre à ajouter pour cette conférence, sauf que j'ai téléchargé le premier grand devoir, qui vous testera sur les concepts que nous avons abordés dans les conférences précédentes, y compris l'apprentissage supervisé et les exemples de code utilisant NumPy. C'est une excellente occasion d'acquérir une expérience pratique avec l'algorithme K-plus proche voisin et d'explorer davantage NumPy et scikit-learn.
Maintenant, pendant que vous plongez dans les vidéos, terminez les devoirs et répondez au quiz d'auto-évaluation, je veux vous rappeler de vous amuser et de vous amuser. L'automne, ma saison préférée, vient de commencer ici dans le Wisconsin, et j'aime le temps plus froid et les belles couleurs des feuilles changeantes. Au fait, je suis vraiment excité parce que je suis déjà allé dans un champ de citrouilles le week-end dernier et j'ai obtenu des citrouilles que j'ai hâte de sculpter pour Halloween. Alors, commençons par la conférence pour que je puisse revenir à mes petites citrouilles et les préparer pour Halloween.
Très bien, nous avons maintenant atteint la troisième partie des conférences sur les fondements du calcul. Dans cette conférence, nous aborderons plusieurs sujets, en commençant par la lecture d'un ensemble de données à partir d'un fichier texte tabulaire, tel qu'un fichier CSV, qui est le format de fichier le plus courant pour les tâches d'apprentissage automatique traditionnelles. Nous discuterons ensuite des techniques de traitement de données de base, y compris la mise en forme des données pour les algorithmes d'apprentissage automatique et les procédures de formation.
Après cela, nous nous plongerons dans l'apprentissage automatique avec scikit-learn. Mais avant cela, je souhaite récapituler brièvement les classes Python et la programmation orientée objet. Dans les exercices précédents, je vous ai demandé de vous préparer à Python ou de mieux comprendre ses concepts. Il est important d'avoir une bonne compréhension de la programmation orientée objet car scikit-learn en dépend fortement. Il est donc nécessaire de comprendre la programmation orientée objet pour comprendre le fonctionnement de scikit-learn.
Ensuite, nous discuterons de la préparation des données de formation à l'aide de l'API du transformateur scikit-learn. Nous couvrirons également la définition des pipelines scikit-learn, qui nous aident à enchaîner différentes opérations, telles que la préparation des ensembles de données, la mise à l'échelle, la normalisation, la réduction de la dimensionnalité et le classifieur lui-même. En utilisant des pipelines, nous pouvons créer des flux de travail de formation efficaces qui relient divers aspects du processus d'apprentissage automatique, ce qui rend les choses plus pratiques. C'est l'un des points forts de scikit-learn.
Pour cette conférence, j'ai décidé d'utiliser à nouveau des diapositives. Bien que Jupiter Lab soit un outil fantastique, je trouve plus facile d'expliquer certains concepts en annotant des exemples de code avec un stylo ou un crayon. Ainsi, dans ces diapositives, j'ai capturé des captures d'écran de Jupiter Lab et de Jupiter Notebook, que je vais annoter pendant la conférence. Cependant, j'ai également téléchargé l'intégralité du bloc-notes de code sur GitHub, où vous pouvez trouver des explications supplémentaires. Considérez ce document comme un cours optionnel ou des notes de cours pour votre référence.
Récapitulons rapidement où nous en sommes dans ce cours. Nous avons commencé par une introduction à l'apprentissage automatique, couvert les bases et exploré le fonctionnement de scikit-learn. Ensuite, nous nous sommes plongés dans Python, en découvrant NumPy et le calcul scientifique. Maintenant, nous entrons dans la phase de traitement des données et d'apprentissage automatique avec scikit-learn. Dans la prochaine conférence, nous reviendrons sur les concepts de base de l'apprentissage automatique tels que les arbres de décision, les méthodes d'ensemble et l'évaluation de modèles. Bien qu'il s'agisse de la dernière partie des cours sur les fondements informatiques, cela ne signifie pas que c'est la fin du cours. Après avoir terminé les cours sur les bases informatiques, nous passerons à des sujets plus avancés en apprentissage automatique, notamment l'apprentissage en profondeur et les réseaux de neurones.
Maintenant, plongeons dans le premier sujet de cette conférence : lire un ensemble de données à partir d'un fichier texte tabulaire. Lorsque vous travaillez avec l'apprentissage automatique, il est courant d'avoir des données stockées dans des formats tabulaires tels que des fichiers CSV (Comma-Separated Values). Ces fichiers contiennent des lignes et des colonnes de données, chaque ligne représentant un échantillon ou une instance, et chaque colonne représentant une fonctionnalité ou un attribut.
Pour lire dans un fichier CSV en Python, on peut utiliser la librairie Pandas. Pandas fournit de puissants outils de manipulation et d'analyse de données, ce qui en fait un choix populaire pour travailler avec des données tabulaires en Python. Prenons un exemple :
Dans cet exemple, nous importons d'abord la bibliothèque pandas et l'aliasons pd pour plus de commodité. Ensuite, nous utilisons la fonction read_csv() pour lire le fichier CSV data.csv dans un DataFrame, qui est une structure de données tabulaire à deux dimensions fournie par Pandas. Le DataFrame est stocké dans les données variables.
Après avoir lu les données, nous pouvons utiliser la fonction head() pour afficher les premières lignes du DataFrame. Cela nous permet d'inspecter rapidement les données et de vérifier qu'elles ont été lues correctement.
Pandas fournit un large éventail de fonctions et de méthodes pour manipuler et analyser les données. Nous pouvons effectuer diverses opérations telles que le filtrage des lignes, la sélection des colonnes, l'agrégation des données et bien plus encore. Si vous êtes nouveau sur Pandas, je vous encourage à explorer sa documentation et à expérimenter par vous-même différentes opérations.
Maintenant que nous savons comment lire les données, passons au sujet suivant : les techniques de base de traitement des données. Lorsque vous travaillez avec des données pour l'apprentissage automatique, il est essentiel de prétraiter et de préparer les données de manière appropriée. Cela inclut des tâches telles que la gestion des valeurs manquantes, l'encodage des variables catégorielles, la mise à l'échelle des caractéristiques numériques et la division des données en ensembles d'apprentissage et de test.
Une étape de prétraitement courante consiste à gérer les valeurs manquantes. Les valeurs manquantes sont souvent représentées par des valeurs NaN (Pas un nombre) ou NULL dans les données. Ces valeurs manquantes peuvent causer des problèmes lors de la formation de modèles d'apprentissage automatique, nous devons donc les gérer de manière appropriée. Pandas fournit plusieurs fonctions pour gérer les valeurs manquantes, telles que isna() pour vérifier les valeurs manquantes, fillna() pour remplir les valeurs manquantes avec une valeur spécifiée et dropna() pour supprimer les lignes ou les colonnes avec des valeurs manquantes.
L'encodage des variables catégorielles est une autre étape importante. Les modèles d'apprentissage automatique fonctionnent généralement avec des données numériques, nous devons donc convertir les variables catégorielles en une représentation numérique. Une technique d'encodage courante est l'encodage à chaud, où nous créons des colonnes binaires pour chaque catégorie et indiquons la présence ou l'absence d'une catégorie avec un 1 ou un 0, respectivement.
La mise à l'échelle des caractéristiques numériques est une autre étape de prétraitement courante. De nombreux algorithmes d'apprentissage automatique sont sensibles à l'échelle des fonctionnalités. Si les entités ont des échelles différentes, cela peut affecter les performances du modèle. Pour résoudre ce problème, nous pouvons mettre à l'échelle les fonctionnalités dans une plage standard, telle que 0 à 1 ou -1 à 1. Pandas fournit les classes MinMaxScaler et StandardScaler dans le module sklearn.preprocessing pour effectuer la mise à l'échelle des fonctionnalités.
Enfin, la division des données en ensembles d'apprentissage et de test est cruciale pour évaluer les performances des modèles d'apprentissage automatique. Nous divisons généralement les données en deux ensembles : un ensemble d'entraînement utilisé pour entraîner le modèle et un ensemble de test utilisé pour évaluer ses performances. Pandas fournit la fonction train_test_split() dans le module sklearn.model_selection pour diviser les données en ensembles d'apprentissage et de test.
Ensuite, nous utilisons la fonction train_test_split() pour diviser les données en ensembles d'apprentissage et de test. Nous passons les caractéristiques X et les étiquettes y, spécifions la taille de test souhaitée (par exemple, 0,2 pour un ensemble de test de 20 %) et définissons un état aléatoire pour la reproductibilité.
Après avoir divisé les données, nous pouvons utiliser l'ensemble d'entraînement (X_train et y_train) pour entraîner notre modèle d'apprentissage automatique et évaluer ses performances sur l'ensemble de test (X_test et y_test).
Voici quelques techniques de base de traitement des données dans l'apprentissage automatique à l'aide de la bibliothèque Pandas en Python. N'oubliez pas que le prétraitement et la préparation des données sont des étapes essentielles du pipeline d'apprentissage automatique, et qu'il existe de nombreuses autres techniques et outils disponibles en fonction des exigences spécifiques de votre projet.
5.2 Traitement de base des données (L05 : Machine Learning avec Scikit-Learn)
5.2 Traitement de base des données (L05 : Machine Learning avec Scikit-Learn)
Dans la vidéo précédente, nous avons expliqué comment lire un fichier texte tabulaire en tant qu'ensemble de données. Plus précisément, nous nous sommes concentrés sur le travail avec un fichier CSV et, plus précisément, l'ensemble de données Iris. Nous avons importé le jeu de données Iris d'un fichier CSV dans un Pandas DataFrame.
Dans cette vidéo, nous allons nous plonger dans la préparation des données dans le format approprié pour l'apprentissage automatique à l'aide de scikit-learn. Nous explorerons les techniques de base de traitement des données en utilisant Pandas et NumPy pour transformer les données en un format adapté à l'apprentissage automatique. Mais avant de continuer, récapitulons brièvement le concept de fonctions Python, car il sera utile lorsque nous discuterons de la transformation de valeurs dans un Pandas DataFrame.
Ici, nous avons une simple fonction Python appelée "some_func". Il prend un seul argument d'entrée, "x", et le convertit en une chaîne. Il concatène ensuite la valeur convertie avec la chaîne fixe "hello world". Si nous fournissons un entier, tel que 123, comme entrée, il sera converti en une chaîne ("123") et concaténé avec "hello world", ce qui donnera la chaîne finale. Il s'agit d'un aperçu de base du fonctionnement des fonctions Python, avec deux-points indiquant le corps de la fonction et une instruction de retour spécifiant la sortie. Bien qu'il puisse y avoir plusieurs lignes de code dans la fonction, l'instruction return marque la fin.
Un autre concept qui mérite d'être mentionné est celui des fonctions lambda. Les fonctions Lambda sont un raccourci pour définir de petites fonctions sans les nommer explicitement. Ils sont couramment utilisés lorsqu'il est nécessaire d'économiser des lignes de code et d'écrire rapidement des fonctions. Dans le cadre des transformations de données dans les colonnes Pandas, les fonctions lambda sont souvent utilisées. Alors que les fonctions lambda offrent une syntaxe plus concise, elles effectuent essentiellement les mêmes opérations que les fonctions régulières. Ils sont particulièrement utiles lorsqu'ils sont combinés avec la méthode apply sur une colonne Pandas DataFrame.
Dans la conférence précédente, nous avons lu l'ensemble de données Iris dans un Pandas DataFrame à partir du fichier CSV. L'ensemble de données Iris se compose de 150 lignes, mais nous n'affichons que les cinq premières lignes par souci de concision. L'ensemble de données comprend une colonne ID, qui n'est pas essentielle, suivie des caractéristiques représentées par la matrice de conception X. Nous avons également les étiquettes de classe, généralement notées y. Traditionnellement, scikit-learn et d'autres bibliothèques ne géraient pas les variables de chaîne comme des étiquettes de classe, il était donc courant de les convertir en entiers. Par exemple, "Iris setosa" serait converti en entier 0, "Iris versicolor" en 1 et "Iris virginica" en 2. Cette conversion était nécessaire car de nombreux algorithmes ont été conçus pour fonctionner avec des étiquettes de classe entières plutôt qu'avec des étiquettes de chaîne.
Cependant, scikit-learn prend désormais en charge les étiquettes de classe de chaîne dans la plupart des fonctions, éliminant ainsi le besoin de conversion explicite. En interne, la conversion est gérée automatiquement. Néanmoins, certains outils peuvent ne pas gérer correctement les données de chaîne, il est donc toujours recommandé de convertir les étiquettes de classe en entiers. Ce faisant, vous assurez la compatibilité avec divers outils et réduisez la probabilité de rencontrer des erreurs.
Pour illustrer le processus de conversion, nous utiliserons la fonction lambda conjointement avec la méthode apply. En appliquant une fonction lambda à la colonne d'espèces du DataFrame, nous pouvons convertir les étiquettes de classe de chaîne en étiquettes d'entiers. Cependant, il convient de mentionner que l'utilisation d'un dictionnaire de cartographie est souvent une meilleure approche. Il offre une meilleure lisibilité et permet une interprétation plus facile des transformations des étiquettes de classe. De plus, si vous avez besoin de récupérer ultérieurement les étiquettes de classe d'origine, vous pouvez définir un dictionnaire inversé et l'utiliser pour mapper les étiquettes d'entiers à leurs représentations de chaîne d'origine.
Pour démontrer la conversion, nous rechargeons l'ensemble de données à son état d'origine. Ensuite, au lieu d'utiliser apply, nous utilisons la fonction map pour convertir les étiquettes de chaîne en nombres entiers à l'aide du dictionnaire de mappage. Nous présentons également l'utilisation de l'attribut values, qui accède au tableau NumPy sous-jacent. Travailler avec des tableaux NumPy.
Travailler avec des tableaux NumPy peut être bénéfique pour plusieurs raisons. Les tableaux NumPy sont plus économes en mémoire que les Pandas DataFrames, ce qui les rend idéaux pour les grands ensembles de données. De plus, de nombreux algorithmes d'apprentissage automatique dans scikit-learn s'attendent à ce que les données d'entrée soient sous la forme de tableaux NumPy.
Pour convertir notre Pandas DataFrame en tableaux NumPy, nous pouvons simplement accéder à l'attribut values du DataFrame. Voyons un exemple :
De même, nous accédons à la colonne 'species' du DataFrame à l'aide de l'opérateur d'indexation [] et la convertissons en un tableau NumPy, en l'affectant à la variable y.
Maintenant, la variable X contient la matrice de caractéristiques sous la forme d'un tableau NumPy et la variable y contient les étiquettes de classe sous la forme d'un tableau NumPy. Nous pouvons utiliser ces tableaux comme entrées pour divers algorithmes d'apprentissage automatique.
Supposons que nous souhaitions diviser notre ensemble de données en ensembles d'entraînement et de test pour l'évaluation du modèle. Scikit-learn fournit une fonction utilitaire appelée train_test_split qui facilite cette tâche. Voici un exemple :
Après avoir appelé train_test_split, nous obtenons quatre tableaux : X_train et y_train contiennent les données d'apprentissage, tandis que X_test et y_test contiennent les données de test.
Vous pouvez désormais utiliser les tableaux X_train et y_train pour former votre modèle d'apprentissage automatique et évaluer ses performances à l'aide des tableaux X_test et y_test.
En résumé, en convertissant le Pandas DataFrame en tableaux NumPy, nous pouvons tirer parti des avantages de NumPy, tels que l'efficacité de la mémoire et la compatibilité avec les algorithmes d'apprentissage automatique. De plus, scikit-learn fournit des fonctions pratiques telles que train_test_split pour diviser les données en ensembles d'apprentissage et de test.
5.3 Programmation orientée objet et cours Python (L05 : Apprentissage automatique avec Scikit-Learn)
5.3 Programmation orientée objet et cours Python (L05 : Apprentissage automatique avec Scikit-Learn)
Avant d'aborder le sujet de l'apprentissage automatique avec scikit-learn dans la prochaine conférence, prenons un moment pour discuter de la programmation orientée objet, en particulier des classes Python. Comprendre les classes sera très pertinent car scikit-learn s'appuie fortement sur des concepts de programmation orientés objet. Vers la fin de cette vidéo, je démontrerai l'implémentation des K-plus proches voisins à l'aide de l'API scikit-learn, qui est l'approche utilisée par scikit-learn pour implémenter des estimateurs tels que des classificateurs.
Alors, commençons par discuter des classes Python. Pour mieux comprendre l'API scikit-learn, il est important de comprendre les bases des classes. En termes simples, une classe peut être considérée comme un modèle de création d'objets. Les objets sont des instances d'une classe et peuvent être visualisés comme différentes variantes de la même forme d'emporte-pièce utilisée pour fabriquer des cookies. La classe elle-même agit comme le modèle de l'emporte-pièce, tandis que les cookies représentent les objets créés à partir de la classe.
En Python, nous définissons une classe à l'aide du mot-clé class, suivi du nom de la classe. A l'intérieur de la classe, nous définissons différentes méthodes de classe. Les méthodes de classe sont similaires aux fonctions, mais elles ont un premier argument obligatoire appelé self, qui fait référence à l'objet lui-même. Cet argument self nous permet d'accéder aux attributs et méthodes de l'objet. En d'autres termes, il nous permet d'interagir avec les données et le comportement de l'objet.
Dans le contexte de l'exemple du véhicule, considérons une simple classe de véhicule naïf. Cette classe représente différents types de véhicules tels que les voitures, les motos ou les camions. La classe a diverses méthodes pour définir son comportement. La première méthode est la méthode __init__, également connue sous le nom de constructeur. Cette méthode est automatiquement exécutée lorsqu'un nouvel objet est créé à partir de la classe. Il accepte l'argument self et tous les arguments supplémentaires requis pour initialiser l'objet.
Dans la méthode __init__, nous définissons un attribut appelé horsepower, auquel est assignée la valeur fournie en argument. Cet attribut représente la puissance du véhicule. Lorsqu'un nouvel objet est créé, il aura un attribut de puissance auquel on peut accéder pour récupérer la valeur de la puissance.
En plus de la méthode __init__, nous pouvons définir d'autres méthodes qui modifient les attributs de l'objet. Par exemple, la méthode tune_motor double l'attribut de puissance du véhicule, simulant une mise au point du moteur. En appelant cette méthode sur l'objet véhicule, son attribut de puissance sera modifié en conséquence.
De plus, nous pouvons définir des méthodes qui renvoient des valeurs basées sur les attributs de l'objet. Dans l'exemple, la méthode horsepower_to_torque calcule la valeur de couple en fonction de la puissance de l'objet et d'une valeur RPM fournie. Cette méthode montre comment les attributs de l'objet peuvent être utilisés pour effectuer des calculs et renvoyer des résultats utiles.
Il convient de noter qu'en Python, il existe des conventions pour indiquer la visibilité des méthodes. Les méthodes avec un seul préfixe de soulignement, telles que _private_method, sont considérées comme privées et ne sont pas destinées à être utilisées directement par les utilisateurs de la classe. Cependant, les utilisateurs peuvent toujours accéder à ces méthodes et les appeler, bien que cela soit généralement déconseillé. Les méthodes avec un double préfixe souligné, comme __very_private_method, sont encore plus restreintes et nécessitent une syntaxe spécifique pour y accéder.
De plus, Python prend en charge l'héritage de classe, ce qui nous permet de créer des classes enfants qui héritent des propriétés et des méthodes d'une classe parent. Ce concept nous permet de créer des classes spécialisées avec des attributs et des comportements supplémentaires tout en tirant parti des fonctionnalités existantes définies dans la classe parent. Par exemple, nous pourrions créer une classe Car spécialisée qui hérite de la classe Vehicle et ajoute un attribut number_of_wheels spécifiquement pour les voitures.
Pour illustrer les concepts discutés, un exemple de classificateur K-plus proches voisins est fourni. Cette implémentation suit les conventions de l'API scikit-learn et illustre l'utilisation d'une classe d'estimateur dans scikit-learn. Voici une implémentation simplifiée :
Dans cet exemple, KNNClassifier est une classe représentant un classificateur des K plus proches voisins. Le constructeur prend un paramètre k, qui spécifie le nombre de voisins les plus proches à considérer.
La méthode fit est utilisée pour former le classifieur. Il prend deux arguments : X_train (les données d'apprentissage) et y_train (les étiquettes correspondantes). La méthode stocke simplement les données de formation et les étiquettes dans les attributs de l'objet pour une utilisation ultérieure.
La méthode de prédiction est utilisée pour faire des prédictions sur de nouvelles données. Il prend X_test (les données de test) comme argument et renvoie les étiquettes prédites pour les données de test. Pour chaque point de données dans X_test, la méthode calcule les distances à tous les points de données dans l'ensemble d'apprentissage à l'aide de la méthode _calculate_distance. Il sélectionne ensuite les k voisins les plus proches et détermine la classe majoritaire à l'aide de la méthode _majority_vote. L'étiquette prédite est ajoutée à la liste des prédictions.
La méthode _calculate_distance est une méthode privée (indiquée par le premier trait de soulignement) qui calcule la distance entre deux points de données. Il peut s'agir de la distance euclidienne ou de toute autre mesure de distance adaptée au problème.
La méthode _majority_vote est une autre méthode privée qui détermine la classe majoritaire parmi un ensemble de voisins. Cela peut être fait en comptant les occurrences de chaque étiquette de classe et en sélectionnant l'étiquette avec le nombre le plus élevé.
Cet exemple illustre la structure de base d'une classe d'estimateur dans scikit-learn. Bien sûr, scikit-learn fournit une implémentation plus sophistiquée et optimisée des K voisins les plus proches dans la classe KNeighborsClassifier, mais cette version simplifiée illustre les principes sous-jacents.
5.4 Introduction à Scikit-learn (L05 : Apprentissage automatique avec Scikit-Learn)
5.4 Introduction à Scikit-learn (L05 : Apprentissage automatique avec Scikit-Learn)
Dans cette vidéo relativement courte, l'objectif est d'introduire l'apprentissage automatique avec scikit-learn. Scikit-learn est une bibliothèque d'apprentissage automatique largement utilisée en Python qui fournit un ensemble complet d'outils et d'algorithmes pour diverses tâches d'apprentissage automatique. Bien que vous ayez peut-être déjà vu scikit-learn dans le contexte des conférences k-plus proche voisin (KNN), cette vidéo vise à prendre du recul et à présenter correctement la bibliothèque.
Après cette courte vidéo, il y aura une vidéo plus longue qui approfondira la préparation de l'ensemble de données de formation à l'aide de scikit-learn. Cela couvrira les techniques et les outils qui rendent la préparation des données plus pratique et efficace par rapport aux approches traditionnelles.
Dans la vidéo suivante, nous explorerons certains des concepts intéressants de scikit-learn, tels que la combinaison de techniques de prétraitement, l'ajustement du classificateur d'apprentissage automatique et la formation, à l'aide de pipelines scikit-learn. Cela permet un flux de travail plus rationalisé et efficace.
Maintenant, discutons plus en détail de l'apprentissage automatique avec scikit-learn. Scikit-learn est largement considéré comme la principale bibliothèque d'apprentissage automatique pour Python en raison de sa réputation établie, de sa large base d'utilisateurs et de sa convivialité. C'est une bibliothèque bien conçue qui offre une API cohérente et intuitive. Scikit-learn est également activement maintenu et régulièrement mis à jour, avec de nombreux contributeurs, ce qui en fait un choix robuste et fiable pour les tâches d'apprentissage automatique.
Il est important de noter que scikit-learn se concentre principalement sur les techniques traditionnelles d'apprentissage automatique et n'est pas destiné à l'apprentissage en profondeur. L'apprentissage en profondeur est un domaine à part avec ses propres bibliothèques spécialisées. Pour l'apprentissage en profondeur, d'autres bibliothèques comme TensorFlow ou PyTorch sont généralement utilisées. Cependant, pour les tâches d'apprentissage automatique traditionnelles, scikit-learn est souvent la bibliothèque de référence.
Scikit-learn existe depuis un certain temps, sa sortie initiale remontant à 2007. Malgré son âge, elle reste une bibliothèque populaire et activement entretenue. Il a commencé comme un projet Google Summer of Code par David Cournapeau et a obtenu des contributions de nombreux autres développeurs au fil du temps. Avec plus de 1 875 contributeurs sur GitHub et près de 150 000 utilisateurs, il est évident que scikit-learn est une bibliothèque très appréciée avec un soutien communautaire substantiel.
Vous pouvez trouver le site Web officiel de scikit-learn, qui comprend de la documentation, des didacticiels et d'autres ressources utiles. Si vous utilisez scikit-learn dans vos projets de recherche, c'est une bonne pratique de citer la bibliothèque comme référence, reconnaissant les efforts investis dans son développement.
Pour comprendre l'API Estimator de scikit-learn, examinons ses principaux composants. L'API Estimator est utilisée pour les tâches d'apprentissage supervisé et comprend des régresseurs pour l'analyse de régression et des classificateurs pour les tâches de classification. Lorsque vous utilisez scikit-learn, vous initialisez généralement un estimateur avec des hyperparamètres spécifiques, qui sont définis dans le constructeur de la classe.
Le processus d'ajustement est crucial pour un estimateur. Après l'initialisation, vous devez appeler la méthode fit, en fournissant les données d'entraînement (caractéristiques) et leurs étiquettes correspondantes. La méthode d'ajustement forme l'estimateur sur les données données, lui permettant de faire des prédictions plus tard. Au cours du processus d'ajustement, certains attributs sont attribués à l'estimateur, indiqués par un trait de soulignement final, indiquant qu'ils sont créés lors de l'ajustement du modèle.
Une fois le modèle ajusté, vous pouvez utiliser la méthode de prédiction pour faire des prédictions sur de nouvelles données. La méthode de prédiction prend les données de test (avec les mêmes caractéristiques que les données d'apprentissage) en entrée et renvoie les étiquettes prédites.
De plus, scikit-learn fournit une méthode de score qui calcule les performances du modèle. Pour les classificateurs, il représente souvent la précision, tandis que pour les régresseurs, il calcule généralement le coefficient de détermination (score R^2). Cette méthode est un moyen pratique d'évaluer les performances du modèle.
En plus de ces composants de base, scikit-learn propose également une large gamme de techniques et d'utilitaires de prétraitement pour améliorer votre flux de travail d'apprentissage automatique.
Un aspect important de l'apprentissage automatique est le prétraitement des données, qui consiste à transformer les données brutes en un format approprié pour former un modèle. Scikit-learn fournit divers modules de prétraitement capables de gérer des tâches telles que la mise à l'échelle des fonctionnalités, la gestion des valeurs manquantes, l'encodage des variables catégorielles, etc.
Par exemple, la classe StandardScaler peut être utilisée pour normaliser les fonctionnalités en soustrayant la moyenne et en mettant à l'échelle la variance unitaire. Ceci est important lorsque vous travaillez avec des fonctionnalités qui ont des échelles différentes, car cela aide les algorithmes à converger plus rapidement et à produire des résultats plus précis.
Une autre technique de prétraitement utile consiste à gérer les valeurs manquantes. La classe SimpleImputer fournit des stratégies pour remplacer les valeurs manquantes par des alternatives appropriées, telles que l'utilisation de la moyenne, de la médiane ou des valeurs les plus fréquentes des caractéristiques correspondantes.
Lorsqu'il s'agit de variables catégorielles, scikit-learn propose les classes OneHotEncoder et LabelEncoder. Le LabelEncoder convertit les étiquettes catégorielles en valeurs numériques, tandis que le OneHotEncoder transforme les caractéristiques catégorielles en une représentation vectorielle binaire, permettant aux algorithmes de travailler efficacement avec les données catégorielles.
Pour rationaliser votre flux de travail d'apprentissage automatique, scikit-learn fournit un outil puissant appelé pipelines. Un pipeline combine plusieurs étapes de prétraitement et un modèle d'apprentissage automatique dans un seul objet, ce qui facilite la gestion et l'application cohérente de l'ensemble du flux de travail.
Les pipelines garantissent que les mêmes étapes de prétraitement sont appliquées de manière cohérente aux ensembles de données de formation et de test, évitant ainsi les fuites de données et les erreurs potentielles. Ils simplifient également le processus de déploiement, car vous pouvez enregistrer l'intégralité de l'objet pipeline et le réutiliser sur de nouvelles données sans vous soucier des étapes de prétraitement individuelles.
En utilisant la fonctionnalité de pipeline de scikit-learn, vous pouvez enchaîner plusieurs techniques de prétraitement, telles que la mise à l'échelle, l'imputation de valeurs manquantes et l'encodage de variables catégorielles, avec le modèle d'apprentissage automatique souhaité. Cela se traduit par un flux de travail plus rationalisé et efficace, vous permettant de vous concentrer sur les aspects essentiels de votre projet d'apprentissage automatique.
Scikit-learn prend en charge une large gamme d'algorithmes d'apprentissage automatique, y compris la régression linéaire, la régression logistique, les machines à vecteurs de support, les arbres de décision, les forêts aléatoires, l'amplification de gradient et bien d'autres. Chaque algorithme est implémenté en tant que classe d'estimateur avec des méthodes cohérentes telles que l'ajustement, la prédiction et le score.
Pour sélectionner l'algorithme approprié pour votre tâche, scikit-learn fournit divers outils de sélection et d'évaluation de modèles. Celles-ci incluent des techniques de validation croisée, de réglage d'hyperparamètres et de métriques d'évaluation de modèles. La validation croisée permet d'évaluer les performances de votre modèle en divisant les données en plusieurs fractionnements de train-test, en formant et en évaluant le modèle sur différents sous-ensembles de données.
Le réglage des hyperparamètres consiste à trouver les valeurs optimales pour les hyperparamètres d'un modèle, qui sont des paramètres qui ne sont pas appris à partir des données mais qui sont définis avant la formation. Scikit-learn fournit des méthodes telles que la recherche par grille et la recherche aléatoire pour automatiser le processus de recherche des meilleures valeurs d'hyperparamètres.
Les mesures d'évaluation du modèle, telles que l'exactitude, la précision, le rappel, le score F1 et l'aire sous la courbe ROC, sont essentielles pour évaluer les performances de votre modèle sur différentes tâches. Scikit-learn propose une large gamme de ces métriques qui peuvent être facilement calculées et comparées.
Scikit-learn est une bibliothèque d'apprentissage automatique puissante et populaire en Python qui fournit une large gamme d'outils et d'algorithmes pour diverses tâches d'apprentissage automatique. Son API conviviale, sa documentation complète et sa communauté active en font un excellent choix pour les débutants et les praticiens expérimentés. Que vous ayez besoin de prétraiter vos données, de créer des pipelines, de sélectionner des modèles ou d'évaluer les performances, scikit-learn dispose des outils dont vous avez besoin pour faire le travail de manière efficace et efficiente.
5.5 API Scikit-learn Transformer (L05 : Apprentissage automatique avec Scikit-Learn)
5.5 API Scikit-learn Transformer (L05 : Apprentissage automatique avec Scikit-Learn)
Dans la vidéo, le présentateur se penche sur le processus de préparation d'un ensemble de données de formation à l'aide des utilitaires de scikit-learn et présente l'API de transformateur, qui est étroitement liée à l'API d'estimateur discutée dans une vidéo précédente. L'API d'estimateur est principalement utilisée pour les modèles d'apprentissage supervisé tels que les classificateurs et les modèles d'analyse de régression, tandis que l'API de transformateur est conçue pour les transformations de données.
Le présentateur commence par aborder les problèmes associés au sous-échantillonnage aléatoire, qui consiste à diviser un ensemble de données en deux sous-ensembles, généralement un ensemble d'apprentissage et un ensemble de test. Ils expliquent que la division aléatoire de l'ensemble de données peut entraîner des changements dans la distribution des étiquettes de classe, entraînant une fausse représentation des classes dans les ensembles d'apprentissage et de test. Pour surmonter ce défi, le présentateur suggère d'utiliser le fractionnement stratifié, qui garantit que la distribution ou les proportions des classes sont maintenues dans les sous-ensembles. Ils montrent ensuite comment réaliser un fractionnement stratifié à l'aide de la fonction train_test_split du sous-module model_selection de scikit-learn.
Ensuite, le présentateur se penche sur le concept de normalisation des données, en mettant l'accent sur deux techniques : la mise à l'échelle min-max et la normalisation. La mise à l'échelle min-max consiste à mettre à l'échelle une caractéristique de sorte que toutes ses valeurs se situent dans la plage de 0 à 1. Le présentateur fournit la formule de mise à l'échelle min-max, qui consiste à soustraire chaque valeur de la colonne de caractéristique par la valeur de caractéristique minimale, puis à diviser par la différence entre les valeurs maximales et minimales des caractéristiques.
En revanche, la standardisation consiste à transformer une caractéristique pour avoir une moyenne de zéro et un écart type de un. Le présentateur explique la formule de normalisation, qui consiste à soustraire chaque valeur de la colonne caractéristique par la moyenne de la caractéristique, puis à la diviser par l'écart type de la caractéristique. Ils mentionnent que la normalisation est plus couramment utilisée dans l'apprentissage automatique et est particulièrement utile pour certains algorithmes d'optimisation.
Pour illustrer l'application pratique de la mise à l'échelle et de la normalisation min-max, le présentateur fournit des exemples utilisant des colonnes de caractéristiques jouets. Ils soulignent que le choix entre l'utilisation de l'écart-type de l'échantillon ou de la population n'a pas d'impact significatif sur les résultats de l'apprentissage automatique, tant que les caractéristiques sont centrées et ont une variance approximativement unitaire. De plus, ils soulignent l'importance d'utiliser les paramètres (moyenne et écart type) calculés à partir de l'ensemble d'apprentissage pour mettre à l'échelle les ensembles de validation et de test, car les ensembles de validation et de test représentent des données invisibles.
La vidéo explore ensuite diverses techniques de transformation et de traitement des données dans l'apprentissage automatique. Il reconnaît que pour des procédures simples comme la normalisation, il est possible d'effectuer les transformations manuellement sans s'appuyer sur des bibliothèques distinctes ou des techniques avancées. Cependant, pour des transformations plus complexes telles que la sélection de caractéristiques, la réduction de la dimensionnalité des caractéristiques et l'extraction de caractéristiques, l'utilisation d'outils tels que l'API Transformer peut offrir une plus grande commodité et efficacité.
Ensuite, le présentateur se concentre sur le traitement des données catégorielles. Ils introduisent un jeu de données jouet comprenant trois colonnes de caractéristiques et une colonne d'étiquette, soulignant que les variables catégorielles peuvent être classées en deux types : ordinales et nominales. Les variables ordinales possèdent un ordre ou une hiérarchie spécifique, contrairement aux variables nominales. À titre d'illustration, ils mettent en évidence la colonne "taille" comme une variable ordinale, où les tailles de t-shirt comme M, L et XXL présentent un ordre clair. Pour gérer les variables ordinales, la vidéo recommande d'utiliser un dictionnaire de mappage pour transformer les valeurs en représentations numériques.
D'autre part, la vidéo présente les étiquettes de classe comme un exemple de données catégorielles nominales. Puisqu'il n'y a pas d'ordre inhérent entre les étiquettes de classe, le présentateur suggère d'utiliser l'encodeur d'étiquettes pour attribuer des valeurs entières uniques à chaque étiquette. L'encodeur d'étiquette est ajusté sur la colonne d'étiquette de classe pour créer un dictionnaire de mappage, qui est ensuite utilisé pour transformer les étiquettes de chaîne en étiquettes d'entiers.
Pour les colonnes de caractéristiques nominales telles que "couleur", où aucun ordre n'est implicite, l'utilisation de l'encodeur d'étiquettes peut introduire des informations trompeuses. Dans de tels cas, la vidéo introduit l'encodage à chaud comme alternative appropriée. Cette technique consiste à créer une nouvelle colonne de caractéristiques pour chaque valeur distincte dans la colonne de caractéristiques nominales et à attribuer des 0 et des 1 pour indiquer la présence ou l'absence d'une valeur particulière. Il est mentionné que la suppression de l'une des colonnes de caractéristiques résultantes peut éliminer la redondance sans perdre d'informations essentielles.
La vidéo aborde brièvement les données manquantes et propose quelques approches de base pour les gérer. Une stratégie consiste à supprimer les lignes ou les colonnes contenant des valeurs manquantes si elles se produisent de manière aléatoire et ne sont pas indicatives d'un problème systématique. Cela peut être accompli en utilisant la méthode dropna() dans la bibliothèque pandas. Une autre approche consiste à imputer les données manquantes en comblant les lacunes avec des mesures statistiques telles que la moyenne ou la médiane, en utilisant des outils tels que le transformateur SimpleImputer. Cependant, la vidéo met en garde que l'imputation doit être soigneusement considérée, car elle peut introduire des biais involontaires.
De plus, la vidéo mentionne la possibilité de prédire les valeurs manquantes en traitant le problème comme une tâche d'apprentissage supervisé. Dans ce scénario, la colonne de caractéristiques manquantes peut être considérée comme la variable cible, et les lignes sans données manquantes peuvent être utilisées comme données d'apprentissage pour ajuster un modèle de régression.
La vidéo fournit un aperçu complet des techniques de transformation des données, y compris l'importance de la préparation d'un ensemble de données de formation, l'application de la division stratifiée et la normalisation des données à l'aide de la mise à l'échelle et de la normalisation min-max. Il couvre en outre la gestion des données catégorielles, la distinction entre les variables ordinales et nominales, et introduit des techniques telles que les dictionnaires de mappage, les encodeurs d'étiquettes et l'encodage à chaud. De plus, la vidéo aborde brièvement les données manquantes et décrit des approches telles que la suppression ou l'imputation des valeurs manquantes, tout en mentionnant également la possibilité de prédire les valeurs manquantes grâce à un apprentissage supervisé.
5.6 Pipelines Scikit-learn (L05 : Apprentissage automatique avec Scikit-Learn)
5.6 Pipelines Scikit-learn (L05 : Apprentissage automatique avec Scikit-Learn)
Bon, tout le monde, nous avons enfin atteint la dernière partie de la conférence 5, qui est, à mon avis, la plus intéressante : les pipelines d'apprentissage sacrés. Ces pipelines sont des objets ou des classes incroyablement utiles qui nous permettent de combiner de manière transparente les étapes de traitement des données et de prédiction. Pour vous donner un aperçu, je vais présenter un organigramme du fonctionnement des pipelines, bien que je n'entre pas dans tous les détails pour l'instant.
Considérez un pipeline comme un estimateur avec une API de transformateur. Semblable à un estimateur, un pipeline a une méthode d'ajustement que nous pouvons utiliser sur l'ensemble d'apprentissage. En interne, le pipeline passe par plusieurs étapes d'ajustement et de transformation, et arrive finalement à l'étape d'ajustement finale. En fonction de ce que nous définissons dans notre pipeline, il peut effectuer diverses tâches telles que la mise à l'échelle des données (par exemple, la normalisation ou la mise à l'échelle min-max), la réduction de la dimensionnalité, la formation d'un algorithme d'apprentissage et le retour d'un modèle prédictif que nous pouvons utiliser sur l'ensemble de test. .
Lorsque nous appelons la méthode de prédiction sur l'ensemble de test, similaire à l'API d'estimation, le pipeline utilise en interne l'étape de transformation pour appliquer la même mise à l'échelle que celle effectuée sur l'ensemble d'apprentissage. Cela garantit la cohérence du traitement des données. Enfin, le pipeline utilise le modèle ajusté pour effectuer des prédictions, telles que le renvoi d'étiquettes de classe dans le cas d'un classifieur.
Permettez-moi d'illustrer cela avec un exemple de code simple d'un pipeline. Ici, je crée un pipeline à l'aide de la fonction make_pipeline du sous-module sklearn.pipeline de Sacred Learn. C'est un moyen pratique de créer des pipelines. Dans cet exemple, je construis un pipeline de base composé d'un scaler standard et d'un classificateur K-plus proche voisin. Le scaler standard, comme nous l'avons vu dans la vidéo précédente, normalise les données en leur donnant une moyenne nulle et une variance unitaire. Nous initialisons le scaler standard et le classificateur K-plus proche voisin en tant que composants du pipeline.
Une fois le pipeline créé, nous pouvons utiliser la méthode d'ajustement pour former le pipeline sur les données de formation. Ensuite, nous pouvons utiliser la méthode de prédiction pour faire des prédictions sur l'ensemble de test. Lorsque nous appelons fit, le pipeline applique d'abord le scaler standard pour apprendre la moyenne et l'écart type à partir des données d'apprentissage. Il utilise ensuite ces informations pour mettre à l'échelle les données, qui sont transmises à l'étape suivante, le classificateur K-plus proche voisin. Le classificateur reçoit l'ensemble d'apprentissage standardisé et exécute son algorithme d'apprentissage.
Pendant la prédiction, le même processus se produit, sauf qu'il n'y a pas besoin d'étape d'ajustement. Le pipeline réutilise les statistiques apprises lors de la formation pour mettre à l'échelle les données de test et applique le classificateur appris pour faire des prédictions.
Pour résumer, un pipeline nous permet d'enchaîner plusieurs objets, tels que des transformateurs et des estimateurs, pour créer un flux de travail cohérent. Il fournit un moyen pratique et efficace de gérer les étapes de traitement et de prédiction des données dans les tâches d'apprentissage automatique.
Examinons maintenant un pipeline en action en appliquant la méthode d'exclusion simple pour la sélection de modèle. La sélection du modèle implique le réglage des hyperparamètres pour sélectionner le meilleur modèle. Dans la méthode holdout, nous divisons les données en un ensemble d'apprentissage et un ensemble de test. Au sein de l'ensemble de formation, nous le divisons en un sous-ensemble pour l'apprentissage et un autre sous-ensemble pour la validation, où nous évaluons différents modèles avec divers paramètres d'hyperparamètres.
Dans scikit-learn, nous pouvons effectuer la méthode holdout et le réglage des hyperparamètres à l'aide d'une méthode appelée recherche de grille. La recherche de grille implique la création d'une grille de paramètres qui définit les combinaisons d'hyperparamètres que nous voulons évaluer. Par exemple, dans le cas des k plus proches voisins, nous pouvons considérer différentes valeurs pour le nombre de voisins (k) et la métrique de distance (p). La recherche de grille itère sur toutes les combinaisons possibles, en ajustant les modèles sur l'ensemble d'apprentissage et en les évaluant sur l'ensemble de validation.
Bien que la recherche de grille soit généralement utilisée avec la validation croisée K-fold, dans cet exemple, nous nous concentrerons sur la méthode holdout. Pour appliquer la méthode holdout et la recherche de grille à l'aide d'un pipeline, nous pouvons utiliser la classe GridSearchCV de scikit-learn. Cette classe nous permet de définir la grille de paramètres et le pipeline, et elle gère le processus d'ajustement des modèles et de leur évaluation.
Voici un exemple d'extrait de code pour montrer comment utiliser GridSearchCV avec un pipeline :
Ensuite, nous définissons le paramètre grid param_grid qui spécifie les différentes combinaisons d'hyperparamètres que nous voulons évaluer. Dans ce cas, nous faisons varier le nombre de voisins (n_neighbors) et la fonction de pondération (pondérations) pour le classificateur K-plus proche voisin. Notez que les noms de paramètres dans la grille sont précédés du nom du composant de pipeline suivi d'un double trait de soulignement (__).
Nous créons un objet GridSearchCV, en transmettant le pipeline, la grille de paramètres et le nombre souhaité de plis de validation croisée (cv). La classe GridSearchCV effectue automatiquement la recherche de grille en ajustant le pipeline sur les données d'apprentissage et en évaluant les modèles sur l'ensemble de validation.
Une fois la recherche de grille terminée, nous pouvons accéder aux meilleurs paramètres et au meilleur score à l'aide des attributs best_params_ et best_score_ de l'objet GridSearchCV. Nous imprimons ces valeurs pour voir quelle combinaison d'hyperparamètres a donné les meilleures performances.
Enfin, nous évaluons le meilleur modèle sur l'ensemble de test en y accédant à partir de l'attribut best_estimator_ de l'objet GridSearchCV et en calculant la précision à l'aide de la méthode de score.
Cet exemple montre comment nous pouvons tirer parti des pipelines et de la recherche de grille pour explorer efficacement différents paramètres d'hyperparamètres et sélectionner le meilleur modèle à l'aide de la méthode d'exclusion. En combinant les étapes de traitement des données et la formation de modèles dans un pipeline, nous pouvons rationaliser le flux de travail d'apprentissage automatique et expérimenter facilement différents composants et hyperparamètres.
6.1 Introduction aux arbres de décision (L06 : Arbres de décision)
6.1 Introduction aux arbres de décision (L06 : Arbres de décision)
Enfin, nous allons aborder un nouveau sujet - les arbres de décision. Les algorithmes d'arbre de décision peuvent être considérés comme des méthodes itératives de construction descendante pour les classificateurs et les modèles de régression. Pour garder les vidéos gérables et pas trop longues, j'ai divisé la conférence en sept parties.
Dans la première partie, nous donnerons un bref aperçu des arbres de décision, leur représentation conceptuelle et présenterons la terminologie de base. Ensuite, nous discuterons des algorithmes récursifs dans le contexte des arbres de décision et expliquerons brièvement ce que sont les algorithmes récursifs. Cette compréhension nous aidera à analyser la complexité d'exécution (Big O) des arbres de décision.
Ensuite, nous explorerons différents types d'arbres de décision. Actuellement, le deuxième apprenant implémente l'algorithme d'arbre de décision CART (Classification and Regression Trees) développé par Leo Breiman. Cependant, il existe d'autres algorithmes comme ID3 et C4.5, chacun avec ses propres avantages et inconvénients. Nous aborderons ces différentes méthodes et pourrions assigner un exercice de devoirs, mettant éventuellement en œuvre l'arbre de décision ID3.
Dans le cours, nous explorerons également divers critères de découpage utilisés pour les arbres de décision. Actuellement, le deuxième apprenant utilise CART, qui est généralement basé sur l'impureté Gini. Cependant, il permet de mélanger et de faire correspondre différents critères de fractionnement. Ces critères de fractionnement font référence aux fonctions ou mesures utilisées pour déterminer une bonne caractéristique pour fractionner un arbre de décision. Nous couvrirons les critères d'impureté et d'entropie de Gini et expliquerons pourquoi ils sont préférés à l'erreur de classification erronée lors de l'évaluation de la croissance des arbres et de la qualité de division.
Une fois que nous aurons couvert ces détails, nous nous pencherons sur les améliorations qui peuvent rendre les arbres de décision plus efficaces en termes de temps d'exécution de calcul et de précision de classification. Nous aborderons également le défi du surajustement et explorerons des techniques pour l'atténuer.
Enfin, nous fournirons un exemple de code qui illustre l'utilisation d'arbres de décision dans scikit-learn, une bibliothèque d'apprentissage automatique populaire. Cet exemple pratique vous aidera à renforcer votre compréhension des arbres de décision et de leur mise en œuvre.
Plongeons maintenant dans le concept de base d'un arbre de décision. Bien qu'il ne s'agisse pas strictement d'un problème d'apprentissage automatique, les arbres de décision concernent des scénarios de la vie quotidienne impliquant une prise de décision. Par exemple, nous pouvons considérer la décision de ce qu'il faut faire à un moment donné. Si nous avons du travail à faire, nous pouvons choisir de rester à l'intérieur et de terminer le travail. A l'inverse, si nous n'avons pas de travaux en cours, nous pouvons envisager de sortir en fonction des conditions météorologiques.
Disons que s'il fait beau et pas trop froid, on peut choisir d'aller à la plage. Cependant, si le temps est couvert, nous pourrions choisir d'aller courir à la place. En cas de pluie ou de neige, nous pourrions demander à nos amis leurs disponibilités. Si nos amis sont occupés, nous pourrions décider de rester à l'intérieur et de participer à des activités comme lire un livre. D'un autre côté, si nos amis sont libres, nous pouvons explorer des options comme aller au cinéma, jouer à des jeux vidéo en ligne ou discuter en ligne.
Ce schéma de base représente un arbre de décision, où chaque nœud correspond à une question ou à une décision, et les branches mènent à différentes options. Le nœud racine représente la première question ou décision dans l'arbre, tandis que les nœuds feuilles sont les sorties finales. Les nœuds internes sont les décisions intermédiaires qui guident le flux de l'arbre.
De plus, les nœuds d'un arbre de décision peuvent être classés en nœuds binaires ou multi-catégories. Les nœuds binaires n'offrent que deux options, tandis que les nœuds multi-catégories prennent en charge plus de deux options. Cependant, les divisions multi-catégories peuvent être converties en divisions binaires, comme indiqué précédemment.
Les arbres de décision peuvent également être interprétés comme des ensembles de règles, similaires aux instructions if-else en programmation. En fait, les arbres de décision peuvent être convertis en ensembles de règles, bien que la conversion inverse ne soit pas toujours possible. Cette caractéristique des arbres de décision les rend hautement interprétables et explicables, ce qui est crucial dans les domaines où l'interprétabilité et l'explicabilité sont importantes, comme dans les domaines juridiques et médicaux.
Pour construire un arbre de décision, nous avons besoin d'un ensemble de données contenant des exemples d'entrées et de sorties correspondantes. Chaque exemple se compose d'un ensemble de fonctionnalités (également appelées attributs ou prédicteurs) et d'une variable cible (la sortie que nous voulons prédire). L'algorithme d'arbre de décision analyse les caractéristiques et leurs relations pour déterminer la meilleure façon de diviser les données et de faire des prédictions.
Le processus de construction d'un arbre de décision implique la sélection de la meilleure caractéristique pour diviser les données à chaque nœud. L'objectif est de trouver la fonctionnalité qui fournit le plus de gain d'informations ou la meilleure répartition en termes de précision de classification. Ce processus est généralement effectué de manière récursive, en partant du nœud racine et en descendant jusqu'aux nœuds feuilles.
A chaque étape, l'algorithme évalue différents critères de séparation, tels que l'impureté de Gini ou l'entropie. L'impureté de Gini mesure la probabilité de mal classer un élément choisi au hasard dans l'ensemble, tandis que l'entropie mesure la quantité moyenne d'informations requises pour identifier l'étiquette de classe d'un élément choisi au hasard dans l'ensemble. Ces critères aident à déterminer la pureté des sous-ensembles résultants après une scission.
Une fois qu'une caractéristique est sélectionnée pour le fractionnement, les données sont divisées en sous-ensembles en fonction des valeurs de caractéristique possibles. Ce processus est répété récursivement pour chaque sous-ensemble jusqu'à ce qu'un critère d'arrêt soit satisfait. Le critère d'arrêt peut être d'atteindre une profondeur d'arbre maximale, d'atteindre un nombre minimum d'échantillons dans un nœud feuille ou d'atteindre un certain niveau de pureté dans les nœuds feuilles.
Pour prédire la variable cible pour une nouvelle instance à l'aide d'un arbre de décision formé, nous commençons au nœud racine et parcourons l'arbre en suivant les branches appropriées en fonction des valeurs de caractéristiques de l'instance. Finalement, nous atteignons un nœud feuille, qui fournit la sortie prédite.
Les arbres de décision présentent plusieurs avantages. Ils sont faciles à comprendre et à interpréter, ce qui en fait un choix populaire pour visualiser et expliquer le processus de prise de décision. Ils peuvent gérer à la fois des caractéristiques numériques et catégorielles, et ils peuvent être utilisés à la fois pour des tâches de classification et de régression. Les arbres de décision sont également robustes aux valeurs manquantes et aux valeurs aberrantes, car ils peuvent les gérer efficacement pendant le processus de fractionnement.
Cependant, les arbres de décision présentent également certaines limites. Ils peuvent facilement surajuster les données de formation, ce qui entraîne une mauvaise généralisation à des exemples invisibles. Cela peut être atténué en utilisant des techniques d'élagage ou en employant des méthodes d'ensemble comme les forêts aléatoires ou l'amplification de gradient. Les arbres de décision sont également sensibles aux petits changements dans les données de formation, et différentes divisions peuvent être générées pour des ensembles de données similaires. De plus, les arbres de décision peuvent avoir du mal à capturer les relations complexes entre les fonctionnalités.
En conclusion, les arbres de décision sont des modèles puissants et interprétables qui peuvent être utilisés pour des tâches de classification et de régression. Ils fournissent un cadre décisionnel clair en représentant les données sous forme d'arborescence avec des nœuds et des branches. Le choix des critères de fractionnement et des critères d'arrêt, ainsi que les techniques de gestion du surajustement, jouent un rôle important dans la construction d'arbres de décision précis et robustes.
6.2 Algorithmes récursifs & Big-O (L06 : Arbres de décision)
6.2 Algorithmes récursifs & Big-O (L06 : Arbres de décision)
Dans cette vidéo, notre discussion tourne autour des algorithmes récursifs, qui sont étroitement liés au concept de diviser pour mieux régner. Diviser pour mieux régner consiste à décomposer un problème en sous-problèmes plus petits, à les résoudre individuellement, puis à combiner les solutions. La formation et la prédiction d'arbres de décision, ainsi que divers algorithmes de division pour mieux régner, sont liés à ce concept. La récursivité est une technique couramment utilisée pour implémenter des algorithmes de division et de conquête, bien que ce ne soit pas la seule approche.
Pour saisir l'idée de récursivité, examinons un exemple d'algorithme récursif implémenté en Python. Pour les besoins de la discussion, j'ai intentionnellement caché le nom réel de la fonction pour vous encourager à analyser son objectif avant de plonger dans ses détails. Je vous encourage à prendre un moment pour réfléchir à ce que cette fonction pourrait faire. Vous pouvez mettre la vidéo en pause ou même l'expérimenter dans un cahier Jupyter pour comprendre son comportement.
En supposant que vous ayez pris le temps de l'analyser, explorons ensemble la fonction. Cette fonction particulière opère sur les listes Python. Par exemple, considérons une liste comme [1, 2, 3]. Le but de cette fonction est de déterminer la longueur d'un tableau ou d'une liste. Examinons comment cela fonctionne. La fonction prend une entrée, notée 'X' ici, et vérifie deux conditions. Premièrement, il vérifie si la liste est vide. Si c'est le cas, la fonction renvoie 0 car une liste vide a une longueur de zéro, qui agit comme condition d'arrêt. Sinon, si la liste n'est pas vide, la fonction renvoie 1 et s'appelle avec une entrée plus petite.
Si cela semble abstrait, décomposons-le étape par étape. Supposons que nous commencions avec une liste complète, telle que [1, 2, 3]. Initialement, la fonction vérifie si la liste est vide, ce qui n'est pas le cas. Par conséquent, il passe à l'instruction 'else', où il renvoie 1 et s'appelle de manière récursive avec une entrée plus petite. Dans ce cas, l'entrée devient [2, 3] puisque nous supprimons le premier élément de la liste d'origine. Nous répétons le processus : la fonction renvoie à nouveau 1, s'appelle elle-même avec la nouvelle entrée [3] et s'appelle finalement avec une liste vide.
En atteignant la liste vide, la fonction vérifie à nouveau la condition "if", qui est maintenant vraie. En conséquence, elle renvoie 0. Lorsque nous évaluons l'expression entière, nous obtenons la valeur 3. Par conséquent, cette fonction calcule la longueur d'un tableau à l'aide de la récursivité, où la fonction s'appelle elle-même dans sa propre définition. Il convient de noter que si la récursivité est une solution conceptuellement élégante en théorie informatique, ce n'est peut-être pas toujours l'approche la plus pratique pour la mise en œuvre. En Python, la récursivité limite le nombre d'auto-appels et des listes trop volumineuses peuvent provoquer une erreur Stack Overflow.
Continuons, explorons un autre exemple qui utilise la récursivité. Ici, nous abordons un problème de division pour mieux régner - trier une liste ou un tableau - à l'aide de l'algorithme de tri rapide. Semblable à la fonction précédente, quicksort utilise la récursivité comme moyen d'implémentation. L'algorithme utilise une condition d'arrêt, où la fonction renvoie le tableau tel quel s'il contient moins de deux éléments. Sinon, l'algorithme exécute la section principale du code.
Comment fonctionne le tri rapide ? Tout d'abord, nous sélectionnons un pivot, généralement le premier élément du tableau. Ensuite, nous créons deux nouvelles listes : une pour contenir les éléments plus petits que le pivot et une autre pour les éléments plus grands que le pivot. Nous parcourons le tableau, en excluant le pivot, et distribuons chaque élément dans la liste la plus petite ou la plus grande en fonction de sa comparaison avec le pivot. Ensuite, nous appelons récursivement le tri rapide sur les listes plus petites et plus grandes, en utilisant le pivot comme élément central. Finalement, le
les appels récursifs atteindront la condition d'arrêt lorsque les listes auront moins de deux éléments. À ce stade, la fonction renvoie simplement les listes triées.
Passons en revue un exemple pour comprendre le processus. Supposons que nous ayons une liste non triée [7, 2, 5, 1, 9, 3]. L'algorithme de tri rapide procédera comme suit :
En divisant de manière récursive la liste en sous-listes plus petites et en les triant, l'algorithme de tri rapide trie efficacement la liste entière.
En conclusion, les algorithmes récursifs jouent un rôle crucial dans les approches diviser pour mieux régner. Ils décomposent les problèmes en sous-problèmes plus petits et les résolvent individuellement, combinant éventuellement les solutions pour résoudre le problème initial. Les fonctions récursives s'appellent elles-mêmes dans leur propre définition, travaillant à plusieurs reprises sur des entrées plus petites jusqu'à atteindre une condition d'arrêt. Cependant, il est important de considérer la condition de terminaison pour éviter une récursivité infinie et garantir que l'algorithme converge vers une solution.
6.3 Types d'arbres de décision (L06 : Arbres de décision)
6.3 Types d'arbres de décision (L06 : Arbres de décision)
Dans les vidéos précédentes, nous nous sommes concentrés sur l'introduction d'arbres de décision et d'algorithmes récursifs. Passons maintenant aux différents types d'arbres de décision. Nous explorerons comment la modification de certains choix de conception peut conduire à différentes implémentations d'algorithmes d'arbre de décision.
Tout d'abord, récapitulons l'algorithme d'arbre de décision générique en pseudocode, dont nous avons parlé dans la vidéo précédente. Nous avons traité un problème de classification binaire, où les étiquettes de classe n'étaient que 1 et 0. Notre arbre suivait une structure binaire, impliquant une division binaire. Cela signifie que chaque nœud a été divisé en exactement deux nœuds enfants. De plus, nous n'avons considéré que les caractéristiques binaires, où les valeurs des caractéristiques pouvaient être 0 ou 1.
Cependant, comme nous l'avons démontré précédemment en utilisant la visualisation de l'arbre de décision dans scikit-learn, nous pouvons également utiliser des fonctionnalités continues et les convertir en divisions binaires. Par exemple, nous pouvons sélectionner une fonctionnalité, appelons-la xj, et la diviser en deux parties à l'aide d'un seuil, noté 't'. Ce critère de découpage peut être défini comme xj inférieur à t ou xj supérieur ou égal à t, qui peut être représenté par vrai ou faux. Cela nous permet d'effectuer une division binaire même avec des caractéristiques continues, car nous pouvons ajuster le seuil de décision pendant le processus de division. Vous aurez l'occasion de travailler sur une telle division dans les devoirs.
Maintenant, concentrons-nous sur l'implémentation de l'algorithme de l'arbre de décision. À chaque nœud de l'arbre de décision, nous considérons une seule caractéristique, notée xj, où 'j' varie de 1 à m, représentant jusqu'à m caractéristiques. Lorsque nous divisons un nœud parent en deux nœuds enfants, disons l'enfant zéro et l'enfant un, nous devons déterminer quelle fonctionnalité choisir pour la division. Pour les caractéristiques continues, nous devons également considérer le seuil de décision, où nous comparons si xj est supérieur ou égal à une valeur spécifique 't'. La sélection de la fonctionnalité et du seuil appropriés est cruciale, et nous avons besoin d'une mesure de qualité pour évaluer la qualité d'une division.
Pour résumer l'algorithme de croissance d'arbre générique, nous sélectionnons la fonctionnalité qui entraîne le plus grand gain d'informations lorsque le nœud parent est divisé. Le gain d'information est une mesure de la qualité d'une scission. Plus le gain d'information est élevé, meilleure est la division et la caractéristique choisie, y compris son seuil de division pour les caractéristiques continues. Dans la vidéo suivante, nous discuterons de deux mesures couramment utilisées pour évaluer la qualité d'une scission : l'entropie et l'impureté de Gini.
L'algorithme suit certaines conditions d'arrêt. Il s'arrête si les nœuds enfants sont purs, ce qui signifie que tous les points de données d'un nœud ont la même étiquette de classe. Alternativement, il s'arrête si le gain d'information est inférieur ou égal à zéro, indiquant aucune amélioration. Une fois que nous atteignons un nœud pur ou que nous ne parvenons pas à progresser, nous arrêtons de développer l'arbre.
Après avoir développé l'arbre de décision, nous pouvons l'utiliser pour faire des prédictions. Supposons que nous ayons un arbre à plusieurs niveaux, comprenant des nœuds parent et feuille. Pour prédire l'étiquette de classe d'un nouveau point de données, nous parcourons l'arbre en fonction des valeurs de caractéristiques du point de données. À chaque nœud, nous suivons la branche correspondante en fonction des conditions de fonctionnalité jusqu'à ce que nous atteignions un nœud feuille. Pour les nœuds feuilles, nous utilisons l'approche du vote majoritaire pour déterminer l'étiquette de classe. Cela signifie que nous prédisons l'étiquette de classe qui apparaît le plus fréquemment dans ce nœud feuille.
Il est important de noter que les arbres de décision peuvent gérer à la fois les problèmes de classification binaire et multi-classes. Le pseudocode dont nous avons parlé dans les diapositives précédentes portait sur la classification binaire, mais les arbres de décision peuvent gérer un nombre arbitraire d'étiquettes de classe. L'approche du vote majoritaire est applicable quel que soit le nombre de classes.
Lors du développement d'algorithmes d'arbre de décision, nous rencontrons divers choix de conception. Une question cruciale est de savoir comment diviser les nœuds. Nous devons définir le critère de fractionnement et déterminer comment comparer et évaluer les différents fractionnements. Les deux mesures couramment utilisées pour évaluer la qualité d'une scission sont l'entropie et l'impureté de Gini.
L'entropie est une mesure de l'impureté ou du désordre dans un nœud. Il quantifie l'incertitude associée aux étiquettes de classe des points de données dans ce nœud. L'entropie d'un nœud est calculée à l'aide de la formule suivante :
Entropie(nœud) = - somme(p(i) * log2(p(i))), pour toutes les classes i
où p(i) représente la proportion de points de données dans le nœud qui appartiennent à la classe i. La valeur d'entropie varie de 0 à 1, où 0 indique un nœud pur (tous les points de données appartiennent à la même classe) et 1 indique une impureté maximale (répartition égale des points de données dans toutes les classes).
Pour évaluer la qualité d'une division, nous calculons la moyenne pondérée des valeurs d'entropie pour les nœuds enfants résultants. C'est ce qu'on appelle le gain d'information. Le gain d'information se calcule comme suit :
Gain d'information = Entropie(parent) - somme((|Sv| / |S|) * Entropie(Sv)), pour tous les nœuds enfants v
où Entropy(parent) est l'entropie du nœud parent, |Sv| représente le nombre de points de données dans le nœud enfant v, et |S| est le nombre total de points de données dans le nœud parent. Le gain d'information mesure la réduction d'entropie obtenue en divisant le nœud en fonction d'une caractéristique particulière.
L'impureté Gini est une autre mesure utilisée pour évaluer la qualité d'une scission. Il quantifie la probabilité de mal classer un point de données choisi au hasard dans un nœud si nous attribuons une étiquette de classe basée sur la distribution des étiquettes de classe dans ce nœud. L'impureté Gini d'un nœud est calculée à l'aide de la formule suivante :
Gini(nœud) = 1 - somme(p(i)^2), pour toutes les classes i
où p(i) représente la proportion de points de données dans le nœud qui appartiennent à la classe i. Semblable à l'entropie, la valeur d'impureté Gini varie de 0 à 1, où 0 indique un nœud pur et 1 indique une impureté maximale.
Pour évaluer la qualité d'une scission, nous calculons la moyenne pondérée des valeurs d'impureté Gini pour les nœuds enfants résultants. C'est ce qu'on appelle l'indice d'impuretés de Gini. L'indice d'impuretés de Gini est calculé comme suit :
Index de Gini = sum((|Sv| / |S|) * Gini(Sv)), pour tous les nœuds enfants v
où |Sv| représente le nombre de points de données dans le nœud enfant v, et |S| est le nombre total de points de données dans le nœud parent. L'indice de Gini mesure la réduction de l'impureté de Gini obtenue en divisant le nœud en fonction d'une caractéristique particulière.
L'entropie et l'impureté de Gini sont couramment utilisées dans les algorithmes d'arbre de décision, et le choix entre eux dépend du problème spécifique et des caractéristiques des données. Dans scikit-learn, vous pouvez sélectionner le paramètre critère pour spécifier "entropie" ou "gini" lors de la construction de modèles d'arbre de décision.
Dans la prochaine vidéo, nous approfondirons ces mesures et discuterons de la façon de les utiliser pour déterminer les meilleures répartitions dans un algorithme d'arbre de décision.
6.4 Critères de fractionnement (L06 : Arbres de décision)
6.4 Critères de fractionnement (L06 : Arbres de décision)
Dans la vidéo, le conférencier plonge dans les subtilités des arbres de décision et introduit le concept de critères de fractionnement dans ce cadre. Les critères de fractionnement sont essentiellement les critères ou mesures utilisés pour déterminer la fonctionnalité la plus appropriée pour fractionner un nœud parent en ses nœuds enfants. Généralement, un jeu de données englobe plusieurs entités, notées x1, x2, x3, ..., xm, où j représente une valeur comprise entre 1 et m.
L'orateur souligne qu'à chaque nœud de l'arbre de décision, une décision critique doit être prise concernant la fonctionnalité à utiliser pour le processus de division. Pour identifier la fonctionnalité optimale, certains critères ou mesures sont définis pour comparer et évaluer les fonctionnalités disponibles. L'objectif est de sélectionner une caractéristique qui donne une meilleure répartition, améliorant ainsi la précision prédictive de l'arbre de décision.
Pour illustrer le fonctionnement des arbres de décision, l'orateur présente un jeu de données jouet composé de trois caractéristiques : x1, x2, x3 et d'une colonne indiquant l'étiquette de classe, y. Les étiquettes de classe dans cet ensemble de données sont binaires, prenant les valeurs de un ou de zéro. L'orateur note qu'en n'utilisant que deux fonctionnalités, il est possible d'atteindre une précision de formation de 100 % pour cet ensemble de données particulier.
Interpellant le public, l'orateur les invite à trouver deux règles basées sur les trois caractéristiques qui peuvent conduire à une précision d'entraînement de 100 %. Ils suggèrent de mettre la vidéo en pause pour envisager la solution. Par la suite, l'orateur révèle la solution, expliquant que seuls x1 et x2 sont les fonctionnalités pertinentes et utiles, tandis que x3 est apparemment aléatoire et ne contribue pas à la précision.
À l'avenir, l'orateur représente visuellement l'ensemble de données en traçant les valeurs de x1 et x2 sur un graphique. Les points rouges sur le graphique représentent les points de données appartenant à l'étiquette de classe un, tandis que les carrés bleus représentent les points de données étiquetés comme zéro. Sur la base du modèle observé dans les points de données, le locuteur procède à la création d'une scission, entraînant la formation d'un arbre de décision.
La répartition initiale est basée sur le fait que x1 est supérieur à 5,5. Cette division divise les données en deux régions, l'une étiquetée bleue et l'autre rouge. L'orateur note que si cette division classe correctement certains points de données, elle en classe également d'autres de manière erronée. La division suivante est basée sur le fait que x2 est supérieur à 10,5. Cela affine encore le processus de classification et conduit finalement à un arbre de décision qui atteint une précision de formation de 100 %.
Pour améliorer la clarté, le locuteur fournit une représentation visuelle plus claire de l'arbre de décision, expliquant les informations associées à chaque nœud. Chaque nœud symbolise un nœud parent qui subit un fractionnement, entraînant la création de nœuds enfants. Pour chaque nœud, la valeur de fractionnement (représentée par la valeur de caractéristique et le seuil), l'entropie (une mesure du contenu de l'information), le nombre d'exemples de formation (échantillons), la distribution des étiquettes de classe (lieu) et la classe majoritaire sont affichés.
L'arbre de décision est représenté dans une structure hiérarchique, avec des nœuds parents donnant lieu à des nœuds enfants. L'orateur souligne l'importance de chaque nœud, soulignant que les arbres de décision utilisent ces nœuds pour faire des prédictions basées sur les caractéristiques d'entrée.
Enfin, l'orateur mentionne une approche alternative pour atteindre une précision d'entraînement de 100 % en utilisant uniquement la deuxième fonctionnalité. Ils présentent un arbre de décision basé sur cette approche alternative, montrant comment la caractéristique deux peut être divisée aux valeurs 7,5 et 10 pour séparer avec précision les points de données dans les classes souhaitées.
Dans un scénario idéal où nous avons des caractéristiques continues et des seuils correctement définis, les concepts susmentionnés s'appliqueraient. Au lieu d'utiliser la variable "V", nous utiliserions une variable xj, représentant une caractéristique continue inférieure ou égale à un seuil. Le deuxième nœud enfant symboliserait des valeurs supérieures au seuil. Dans ce cas, si nous possédons des caractéristiques continues, une formule similaire à celle d'avant peut être utilisée, mais nous devons maintenant incorporer une valeur de seuil dans la fonction. On peut comparer les valeurs pour vérifier si elles sont supérieures ou égales au seuil.
Par conséquent, si nous avons une fonctionnalité continue et un arbre binaire similaire à CART (Arbre de classification et de régression), nous n'avons besoin de faire la somme que sur deux nœuds enfants au lieu de plusieurs. Un nœud enfant correspond à des valeurs supérieures au seuil, tandis que l'autre représente des valeurs inférieures ou égales au seuil. Cette simplification est logique puisque nous nous concentrons sur les deux résultats possibles en fonction de la valeur seuil. Néanmoins, il est crucial de reconnaître que cette explication peut sembler dense, et un aspect important qui manque encore est le concept d'entropie, qui sera exploré dans les diapositives suivantes.
Dans ce contexte, l'entropie appartient à l'entropie de Shannon, introduite par Claude Shannon dans le domaine de la théorie de l'information. Elle s'écarte de l'entropie employée en biophysique ou en thermodynamique. L'entropie de Shannon sert de métrique pour quantifier l'impureté ou le désordre des nœuds enfants dans les arbres de décision. Il quantifie la quantité d'informations véhiculées par une variable aléatoire discrète qui possède deux résultats, apparentés à une distribution de Bernoulli. Dans la distribution de Bernoulli, un paramètre de probabilité noté p représente la probabilité qu'un événement se produise.
Shannon a défini l'information comme le nombre de bits nécessaires pour coder la valeur 1/p. En termes plus simples, il évalue le niveau de certitude ou d'incertitude associé à un événement. Le nombre de bits nécessaires peut être calculé comme le logarithme base 2 de 1/p. Lorsque la probabilité p augmente, le nombre de bits requis diminue, indiquant un degré de certitude plus élevé. Inversement, lorsque la probabilité approche de zéro, le nombre de bits requis augmente, ce qui implique un niveau d'incertitude plus élevé.
Pour illustrer ce concept, prenons quelques exemples. Si nous avons une probabilité de 0,5, le nombre de bits requis serait égal à 1. Si la probabilité est de 0, le nombre de bits requis serait infini, ce qui signifie une certitude absolue. Inversement, si la probabilité est de 1, le nombre de bits requis serait de 0, indiquant une incertitude complète. Par conséquent, la plage de valeurs pour le terme -log2(p) s'étend de moins l'infini à 0.
L'entropie de Shannon est calculée comme l'information moyenne sur tous les événements possibles. Il représente la moyenne pondérée des informations associées à chaque événement, les poids étant les probabilités respectives des événements. Dans le cas des arbres de décision, le concept d'entropie peut être appliqué pour évaluer l'impureté d'un nœud enfant. Si un nœud présente une distribution bien équilibrée des étiquettes de classe, il possédera une entropie plus élevée, ce qui signifie une plus grande impureté. Inversement, si un nœud affiche une distribution asymétrique où une classe domine, il possédera une entropie plus faible, indiquant une impureté plus faible. Cette notion s'aligne intuitivement, car un nœud avec une impureté plus élevée fournit moins d'informations à des fins de classification.
L'entropie offre un moyen de mesurer l'impureté ou le désordre dans les nœuds enfants des arbres de décision. Il permet l'évaluation de la pureté d'un nœud en fonction de la distribution des étiquettes de classe. Un nœud avec une entropie plus élevée suggère une distribution plus diversifiée, tandis qu'un nœud avec une entropie plus faible indique une distribution plus homogène. En tenant compte de l'entropie des nœuds enfants, des décisions plus éclairées peuvent être prises lors de la construction d'arbres de décision.