10 visualisations étonnantes d'apprentissage automatique que vous devriez connaître en 2023

Yellowbrick for creating machine learning plots with less code

La visualisation des données joue un rôle important dans l'apprentissage automatique.

Les cas d'utilisation de la visualisation de données dans l'apprentissage automatique incluent :

• Réglage hyperparamètre
• Évaluation des performances du modèle
• Validation des hypothèses du modèle
• Trouver des valeurs aberrantes
• Sélection des fonctionnalités les plus importantes
• Identifier les modèles et les corrélations entre les caractéristiques

Les visualisations qui sont directement liées aux éléments clés ci-dessus dans l'apprentissage automatique sont appelées visualisations d'apprentissage automatique.

La création de visualisations d'apprentissage automatique est parfois un processus compliqué car il nécessite beaucoup de code à écrire, même en Python. Mais, grâce à l'open-source de Python brique jaune bibliothèque, même des visualisations d'apprentissage automatique complexes peuvent être créées avec moins de code. Cette bibliothèque étend l'API Scikit-learn et fournit des fonctions de haut niveau pour les diagnostics visuels qui ne sont pas fournies par Scikit-learn.

Aujourd'hui, je vais discuter en détail des types de visualisations d'apprentissage automatique suivants, de leurs cas d'utilisation et de la mise en œuvre de Yellowbrick.

Yellowbrick ML Visualizations
-----------------------------
01. Priniciapal Component Plot
02. Validation Curve
03. Courbe d'apprentissage
04. Elbow Plot
05. Silhouette Plot
06. Class Imbalance Plot
07. Residuals Plot
08. Prediction Error Plot
09. Cook’s Distance Plot
10. Feature Importances Plot

Installation

L'installation de Yellowbrick peut être effectuée en exécutant l'une des commandes suivantes.

• pépin installateur de paquets:

pip install yellowbrick

• compter installateur de paquets:

conda install -c districtdatalabs yellowbrick

Utilisation de Yellowbrick

Les visualiseurs Yellowbrick ont ​​une syntaxe de type Scikit-learn. Un visualiseur est un objet qui apprend à partir des données pour produire une visualisation. Il est souvent utilisé avec un estimateur Scikit-learn. Pour entraîner un visualiseur, nous appelons sa méthode fit().

Sauvegarder l'intrigue

Pour enregistrer un tracé créé à l'aide d'un visualiseur Yellowbrick, nous appelons la méthode show() comme suit. Cela enregistrera le tracé sous forme de fichier PNG sur le disque.

visualizer.show(outpath="name_of_the_plot.png")

Utilisation

Le diagramme des composantes principales visualise les données de grande dimension dans un nuage de points 2D ou 3D. Par conséquent, ce tracé est extrêmement utile pour identifier des modèles importants dans des données de grande dimension.

Mise en œuvre de Yellowbrick

La création de cette parcelle avec la méthode traditionnelle est complexe et prend du temps. Nous devons d'abord appliquer PCA à l'ensemble de données, puis utiliser la bibliothèque matplotlib pour créer le nuage de points.

Au lieu de cela, nous pouvons utiliser la classe de visualiseur PCA de Yellowbrick pour obtenir la même fonctionnalité. Il utilise la méthode d'analyse en composantes principales, réduit la dimensionnalité de l'ensemble de données et crée le nuage de points avec 2 ou 3 lignes de code ! Tout ce que nous avons à faire est de spécifier des arguments de mots-clés dans la classe PCA().

Prenons un exemple pour mieux comprendre cela. Ici, on utilise le cancer du sein jeu de données (voir Citation à la fin) qui compte 30 caractéristiques et 569 échantillons de deux classes (Malin et les Bénin). En raison de la haute dimensionnalité (30 caractéristiques) des données, il est impossible de tracer les données d'origine dans un nuage de points 2D ou 3D à moins d'appliquer l'ACP à l'ensemble de données.

Le code suivant explique comment nous pouvons utiliser le visualiseur PCA de Yellowbrick pour créer un nuage de points 2D d'un ensemble de données à 30 dimensions.

Nous pouvons également créer un nuage de points 3D en définissant projection=3dans la classe PCA().

Les paramètres les plus importants du visualiseur PCA incluent :

• échelle: booléen, par défaut True. Cela indique si les données doivent être mises à l'échelle ou non. Nous devons mettre à l'échelle les données avant d'exécuter PCA. En savoir plus sur ici.
• projection: int, la valeur par défaut est 2. Lorsque projection=2, un nuage de points 2D est créé. Lorsque projection=3, un nuage de points 3D est créé.
• Des classes: liste, par défaut None. Cela indique les étiquettes de classe pour chaque classe dans y. Les noms de classe seront les étiquettes de la légende.

Utilisation

La courbe de validation trace l'influence d'un unique hyperparamètre sur le train et ensemble de validation. En examinant la courbe, nous pouvons déterminer les conditions de surajustement, de sous-ajustement et de justesse du modèle pour les valeurs spécifiées de l'hyperparamètre donné. Lorsqu'il y a plusieurs hyperparamètres à régler en même temps, la courbe de validation ne peut pas être utilisée. Instated, vous pouvez utiliser la recherche par grille ou la recherche aléatoire.

Mise en œuvre de Yellowbrick

La création d'une courbe de validation avec la méthode traditionnelle est complexe et prend du temps. Au lieu de cela, nous pouvons utiliser le visualiseur ValidationCurve de Yellowbrick.

Pour tracer une courbe de validation dans Yellowbirck, nous allons construire un classificateur de forêt aléatoire en utilisant le même cancer du sein jeu de données (voir Citation à la fin). Nous tracerons l'influence de la profondeur max hyperparamètre dans le modèle de forêt aléatoire.

Le code suivant explique comment nous pouvons utiliser le visualiseur ValidationCurve de Yellowbrick pour créer une courbe de validation à l'aide du cancer du sein jeu de données.

Le modèle commence à sur-ajuster après la profondeur max valeur de 6. Lorsque max_depth=6, le modèle s'adapte très bien aux données de formation et se généralise également bien sur de nouvelles données invisibles.

Les paramètres les plus importants du visualiseur ValidationCurve incluent :

• estimateur : Il peut s'agir de n'importe quel modèle Scikit-learn ML tel qu'un arbre de décision, une forêt aléatoire, une machine à vecteurs de support, etc.
• nom_paramètre : C'est le nom de l'hyperparamètre que nous voulons surveiller.
• plage_param : Cela inclut les valeurs possibles pour nom_param.
• CV: int, définit le nombre de plis pour la validation croisée.
• notation : chaîne, contient la méthode de notation du modèle. Pour le classement, précision est préféré.

Utilisation

La courbe d'apprentissage trace les erreurs ou précisions de formation et de validation par rapport au nombre d'époques ou au nombre d'instances de formation. Vous pouvez penser que les courbes d'apprentissage et de validation semblent identiques, mais le nombre d'itérations est tracé sur l'axe des x de la courbe d'apprentissage tandis que les valeurs de l'hyperparamètre sont tracées sur l'axe des x de la courbe de validation.

Les utilisations de la courbe d'apprentissage comprennent :

• La courbe d'apprentissage est utilisée pour détecter sous-ajustement, surajustement et les juste à droite conditions du modèle.
• La courbe d'apprentissage est utilisée pour identifier slow convergence, oscillant, oscillant avec divergence et les bonne convergence scénarios lors de la recherche du taux d'apprentissage optimal d'un réseau neuronal ou d'un modèle ML.
• La courbe d'apprentissage est utilisée pour voir dans quelle mesure notre modèle bénéficie de l'ajout de données d'entraînement supplémentaires. Lorsqu'il est utilisé de cette manière, l'axe des x indique le nombre d'instances d'entraînement.

Mise en œuvre de Yellowbrick

Créer la courbe d'apprentissage avec la méthode traditionnelle est complexe et prend du temps. Au lieu de cela, nous pouvons utiliser le visualiseur LearningCurve de Yellowbrick.

Pour tracer une courbe d'apprentissage dans Yellowbirck, nous allons créer un classificateur de vecteur de support en utilisant le même cancer du sein jeu de données (voir Citation à la fin).

Le code suivant explique comment nous pouvons utiliser le visualiseur LearningCurve de Yellowbrick pour créer une courbe de validation à l'aide du cancer du sein jeu de données.

Le modèle ne bénéficiera pas de l'ajout d'instances de formation supplémentaires. Le modèle a déjà été formé avec 569 instances de formation. La précision de la validation ne s'améliore pas après 175 instances d'entraînement.

Les paramètres les plus importants du visualiseur LearningCurve incluent :

• estimateur : Il peut s'agir de n'importe quel modèle Scikit-learn ML tel qu'un arbre de décision, une forêt aléatoire, une machine à vecteurs de support, etc.
• CV: int, définit le nombre de plis pour la validation croisée.
• notation : chaîne, contient la méthode de notation du modèle. Pour le classement, précision est préféré.

Utilisation

Le diagramme Elbow est utilisé pour sélectionner le nombre optimal de clusters dans le clustering K-Means. Le modèle s'adapte le mieux au point où le coude apparaît dans le graphique en courbes. Le coude est le point d'inflexion sur le graphique.

Mise en œuvre de Yellowbrick

La création du diagramme Elbow avec la méthode traditionnelle est complexe et prend du temps. Au lieu de cela, nous pouvons utiliser KElbowVisualizer de Yellowbrick.

Pour tracer une courbe d'apprentissage dans Yellowbirck, nous allons construire un modèle de clustering K-Means en utilisant le iris jeu de données (voir Citation à la fin).

Le code suivant explique comment nous pouvons utiliser KElbowVisualizer de Yellowbrick pour créer un tracé Elbow en utilisant le iris jeu de données.

La coude se produit à k = 4 (annoté par une ligne pointillée). Le graphique indique que le nombre optimal de clusters pour le modèle est de 4. En d'autres termes, le modèle est bien ajusté avec 4 clusters.

Les paramètres les plus importants du KElbowVisualizer incluent :

• estimateur : Instance de modèle K-Means
• k: int ou tuple. S'il s'agit d'un entier, il calculera les scores des clusters dans la plage de (2, k). S'il s'agit d'un tuple, il calculera les scores des clusters dans la plage donnée, par exemple (3, 11).

Utilisation

Le diagramme de silhouette est utilisé pour sélectionner le nombre optimal de clusters dans le clustering K-Means et également pour détecter le déséquilibre des clusters. Ce tracé fournit des résultats très précis par rapport au tracé du coude.

Mise en œuvre de Yellowbrick

La création du tracé de la silhouette avec la méthode traditionnelle est complexe et prend du temps. Au lieu de cela, nous pouvons utiliser SilhouetteVisualizer de Yellowbrick.

Pour créer un diagramme de silhouette dans Yellowbirck, nous allons construire un modèle de clustering K-Means en utilisant le iris jeu de données (voir Citation à la fin).

Les blocs de code suivants expliquent comment nous pouvons utiliser SilhouetteVisualizer de Yellowbrick pour créer des tracés de silhouette à l'aide de iris ensemble de données avec différentes valeurs de k (nombre de clusters).

k = 2

En modifiant le nombre de clusters dans la classe KMeans(), nous pouvons exécuter le code ci-dessus à différents moments pour créer des tracés de silhouette lorsque k=3, k=4 et k=5.

k = 3

k = 4

k = 5

Le tracé de la silhouette contient une forme de couteau par cluster. Chaque forme de couteau est créée par des barres qui représentent tous les points de données du cluster. Ainsi, la largeur d'une forme de couteau représente le nombre de toutes les instances du cluster. La longueur de la barre représente le coefficient de silhouette pour chaque instance. La ligne pointillée indique le score de la silhouette — Source : Clustering K-Means pratique (écrit par moi).

Un tracé avec des largeurs à peu près égales de formes de couteau nous indique que les clusters sont bien équilibrés et ont à peu près le même nombre d'instances dans chaque cluster - l'une des hypothèses les plus importantes du clustering K-Means.

Lorsque les barres en forme de couteau prolongent la ligne pointillée, les clusters sont bien séparés - une autre hypothèse importante dans le clustering K-Means.

Lorsque k=3, les clusters sont bien équilibrés et bien séparés. Ainsi, le nombre optimal de clusters dans notre exemple est de 3.

Les paramètres les plus importants du SilhouetteVisualizer incluent :

• estimateur : Instance de modèle K-Means
• les couleurs: string, une collection de couleurs utilisées pour chaque forme de couteau. 'yellowbrick' ou l'une des chaînes de carte de couleurs Matplotlib telles que 'Accent', 'Set1', etc.

Utilisation

Le diagramme de déséquilibre des classes détecte le déséquilibre des classes dans la colonne cible dans les jeux de données de classification.

Un déséquilibre de classe se produit lorsqu'une classe a beaucoup plus d'instances que l'autre classe. Par exemple, un ensemble de données lié à la détection des spams comporte 9900 100 instances pour la catégorie "Pas de spam" et seulement XNUMX instances pour la catégorie "Spam". Le modèle ne parviendra pas à saisir la classe minoritaire (la Spam Catégorie). En conséquence, le modèle ne sera pas précis pour prédire la classe minoritaire lorsqu'un déséquilibre de classe se produit - Source : Top 20 des erreurs d'apprentissage automatique et d'apprentissage en profondeur qui se produisent secrètement dans les coulisses (écrit par moi).

Mise en œuvre de Yellowbrick

La création du diagramme de déséquilibre de classe avec la méthode traditionnelle est complexe et prend du temps. Au lieu de cela, nous pouvons utiliser le visualiseur ClassBalance de Yellowbrick.

Pour tracer un diagramme de déséquilibre de classe dans Yellowbirck, nous utiliserons le cancer du sein jeu de données (jeu de données de classification, voir Citation à la fin).

Le code suivant explique comment nous pouvons utiliser le visualiseur ClassBalance de Yellowbrick pour créer un tracé de déséquilibre de classe à l'aide du cancer du sein jeu de données.

Il existe plus de 200 instances dans le Malin classe et plus de 350 instances dans la Bénin classer. Par conséquent, nous ne pouvons pas voir beaucoup de déséquilibre de classe ici bien que les instances ne soient pas également réparties entre les deux classes.

Les paramètres les plus importants du visualiseur ClassBalance incluent :

• Étiquettes: list, les noms des classes uniques dans la colonne cible.

Utilisation

Le tracé des résidus en régression linéaire est utilisé pour déterminer si les résidus (valeurs observées-valeurs prédites) ne sont pas corrélés (indépendants) en analysant la variance des erreurs dans un modèle de régression.

Le tracé des résidus est créé en traçant les résidus par rapport aux prédictions. S'il existe une sorte de modèle entre les prédictions et les résidus, cela confirme que le modèle de régression ajusté n'est pas parfait. Si les points sont dispersés de manière aléatoire autour de l'axe des x, le modèle de régression est bien ajusté aux données.

Mise en œuvre de Yellowbrick

La création du graphique des résidus avec la méthode traditionnelle est complexe et prend du temps. Au lieu de cela, nous pouvons utiliser le visualiseur ResidualsPlot de Yellowbrick.

Pour tracer un graphique des résidus dans Yellowbirck, nous utiliserons le Numérique (Publicité.csv, Voir Citation à la fin) jeu de données.

Le code suivant explique comment nous pouvons utiliser le visualiseur ResidualsPlot de Yellowbrick pour créer un graphique des résidus à l'aide du Numérique jeu de données.

Nous pouvons clairement voir une sorte de modèle non linéaire entre les prédictions et les résidus dans le graphique des résidus. Le modèle de régression ajusté n'est pas parfait, mais il est assez bon.

Les paramètres les plus importants du visualiseur ResidualsPlot incluent :

• estimateur : Il peut s'agir de n'importe quel régresseur Scikit-learn.
• hist : booléen, par défaut True. S'il faut tracer l'histogramme des résidus, qui est utilisé pour vérifier une autre hypothèse — Les résidus sont approximativement distribués normalement avec la moyenne 0 et un écart type fixe.

Utilisation

Le graphique d'erreur de prédiction dans la régression linéaire est une méthode graphique utilisée pour évaluer un modèle de régression.

Le diagramme d'erreur de prédiction est créé en traçant les prédictions par rapport aux valeurs cibles réelles.

Si le modèle fait des prédictions très précises, les points doivent être sur la ligne à 45 degrés. Sinon, les points sont dispersés autour de cette ligne.

Mise en œuvre de Yellowbrick

La création du diagramme d'erreur de prédiction avec la méthode traditionnelle est complexe et prend du temps. Au lieu de cela, nous pouvons utiliser le visualiseur PredictionError de Yellowbrick.

Pour tracer un tracé d'erreur de prédiction dans Yellowbirck, nous utiliserons le Numérique (Publicité.csv, Voir Citation à la fin) jeu de données.

Le code suivant explique comment nous pouvons utiliser le visualiseur PredictionError de Yellowbrick pour créer un graphique des résidus à l'aide du Numérique jeu de données.

Les points ne sont pas exactement sur la ligne à 45 degrés, mais le modèle est assez bon.

Les paramètres les plus importants du visualiseur PredictionError incluent :

• estimateur : Il peut s'agir de n'importe quel régresseur Scikit-learn.
• identité: booléen, par défaut True. Que ce soit pour tracer la ligne à 45 degrés.

Utilisation

La distance de Cook mesure l'impact des instances sur la régression linéaire. Les instances avec des impacts importants sont considérées comme des valeurs aberrantes. Un ensemble de données avec un grand nombre de valeurs aberrantes ne convient pas à la régression linéaire sans prétraitement. Simplement, le diagramme de distance de Cook est utilisé pour détecter les valeurs aberrantes dans l'ensemble de données.

Mise en œuvre de Yellowbrick

La création du diagramme de distance de Cook avec la méthode traditionnelle est complexe et prend du temps. Au lieu de cela, nous pouvons utiliser le visualiseur CooksDistance de Yellowbrick.

Pour tracer un tracé de distance de Cook à Yellowbirck, nous utiliserons le Numérique (Publicité.csv, Voir Citation à la fin) jeu de données.

Le code suivant explique comment nous pouvons utiliser le visualiseur CooksDistance de Yellowbrick pour créer un tracé de distance de Cook à l'aide du Numérique jeu de données.

Certaines observations prolongent la ligne de seuil (rouge horizontale). Ce sont des valeurs aberrantes. Nous devons donc préparer les données avant de créer un modèle de régression.

Les paramètres les plus importants du visualiseur CooksDistance incluent :

• draw_threshold : booléen, par défaut True. S'il faut tracer la ligne de seuil.

Utilisation

Le diagramme des importances des fonctionnalités est utilisé pour sélectionner les fonctionnalités importantes minimales requises pour produire un modèle ML. Étant donné que toutes les fonctionnalités ne contribuent pas de la même manière au modèle, nous pouvons supprimer les fonctionnalités moins importantes du modèle. Cela réduira la complexité du modèle. Les modèles simples sont faciles à former et à interpréter.

Le diagramme des importances des fonctionnalités visualise les importances relatives de chaque fonctionnalité.

Mise en œuvre de Yellowbrick

La création du diagramme d'importance des caractéristiques avec la méthode traditionnelle est complexe et prend du temps. Au lieu de cela, nous pouvons utiliser le visualiseur FeatureImportances de Yellowbrick.

Pour tracer un diagramme des importances des caractéristiques dans Yellowbirck, nous utiliserons le cancer du sein jeu de données (voir Citation à la fin) qui contient 30 fonctionnalités.

Le code suivant explique comment nous pouvons utiliser le visualiseur FeatureImportances de Yellowbrick pour créer un graphique des importances des caractéristiques à l'aide du cancer du sein jeu de données.

Les 30 entités de l'ensemble de données n'ont pas toutes beaucoup contribué au modèle. Nous pouvons supprimer les entités avec de petites barres du jeu de données et réajuster le modèle avec les entités sélectionnées.

Les paramètres les plus importants du visualiseur FeatureImportances incluent :

• estimateur : Toutes Estimateur Scikit-learn qui prend en charge soit feature_importances_ attribut ou coef_ attribuer.
• relatif: booléen, par défaut True. S'il faut tracer l'importance relative en pourcentage. Si False, le score numérique brut de l'importance de la fonctionnalité est affiché.
• absolu: booléen, par défaut False. S'il faut considérer uniquement l'amplitude des coefficients en évitant les signes négatifs.

1. Tracé des composantes principales : ACP(), Utilisation — Visualise les données de grande dimension dans un nuage de points 2D ou 3D qui peut être utilisé pour identifier des modèles importants dans les données de grande dimension.
2. Courbe de Validation : Courbe de Validation(), Utilisation — Trace l'influence d'un unique hyperparamètre sur le train et ensemble de validation.
3. Courbe d'apprentissage: Courbe d'apprentissage(), Utilisation — Détecte sous-ajustement, surajustement et les juste à droite conditions d'un modèle, Identifie slow convergence, oscillant, oscillant avec divergence et les bonne convergence scénarios lors de la recherche du taux d'apprentissage optimal d'un réseau de neurones, montre à quel point notre modèle bénéficie de l'ajout de plus de données de formation.
4. Courbe du coude : KElbowVisualizer(), Utilisation — Sélectionne le nombre optimal de clusters dans le clustering K-Means.
5. Tracé des silhouettes : Visualiseur de silhouette(), Utilisation — Sélectionne le nombre optimal de clusters dans le clustering K-Means, Détecte le déséquilibre des clusters dans le clustering K-Means.
6. Diagramme de déséquilibre de classe : Balance de classe(), Utilisation — Détecte le déséquilibre des classes dans la colonne cible dans les jeux de données de classification.
7. Graphique des résidus : RésiduelsPlot(), Utilisation — Détermine si les résidus (valeurs observées-valeurs prédites) ne sont pas corrélés (indépendants) en analysant la variance des erreurs dans un modèle de régression.
8. Graphique d'erreur de prédiction : Erreur de prédiction(), Utilisation — Méthode graphique utilisée pour évaluer un modèle de régression.
9. Tracé de la distance de Cook : CuisiniersDistance(), Utilisation — Détecte les valeurs aberrantes dans le jeu de données en fonction des distances de Cook des instances.
10. Tracé des importances des fonctionnalités : FeatureImportances(), Utilisation : sélectionne les fonctionnalités importantes minimales requises en fonction de l'importance relative de chaque fonctionnalité pour produire un modèle ML.

C'est la fin de l'article d'aujourd'hui.

S'il vous plaît laissez-moi savoir si vous avez des questions ou des commentaires.

Read next (Recommended)

• Yellowbrick for Visualizing Features’ Importances Using a Single Line of Code

• Validation Curve Explained — Plot the influence of a single hyperparameter

• Plotting the Learning Curve to Analyze the Training Performance of a Neural Network

• Clustering K-Means pratique

Support me as a writer

I hope you enjoyed reading this article. If you’d like to support me as a writer, kindly consider signing up for a membership to get unlimited access to Medium. It only costs $5 per month and I will receive a portion of your membership fee.

Thank you so much for your continuous support! See you in the next article. Happy learning to everyone!

Informations sur l'ensemble de données sur le cancer du sein

• Citation: Dua, D. et Graff, C. (2019). Référentiel d'apprentissage automatique de l'UCI [http://archive.ics.uci.edu/ml]. Irvine, Californie : Université de Californie, École d'information et d'informatique.
• La source: https://archive.ics.uci.edu/ml/datasets/breast+cancer+wisconsin+(diagnostic)
• Licence: Dr William H. Wolberg (Département de chirurgie générale.
  Université du Wisconsin), Rue Nick W. (Département Informatique.
  Université du Wisconsin) et Olvi L. Mangasarien (Computer Sciences Dept. University of Wisconsin) détient les droits d'auteur de cet ensemble de données. Nick Street a fait don de cet ensemble de données au public sous le Licence internationale Creative Commons Attribution 4.0 (CC BY 4.0). Vous pouvez en savoir plus sur les différents types de licence d'ensemble de données ici.

Informations sur l'ensemble de données Iris

• Citation: Dua, D. et Graff, C. (2019). Référentiel d'apprentissage automatique de l'UCI [http://archive.ics.uci.edu/ml]. Irvine, Californie : Université de Californie, École d'information et d'informatique.
• La source: https://archive.ics.uci.edu/ml/datasets/iris
• Licence: RA Fisher détient les droits d'auteur de cet ensemble de données. Michael Marshall a fait don de cet ensemble de données au public sous le Licence de dédicace au domaine public Creative Commons (CC0). Vous pouvez en savoir plus sur les différents types de licence d'ensemble de données ici.

Informations sur l'ensemble de données publicitaires

Bibliographie