Comment tracer une limite de décision pour les algorithmes d'apprentissage automatique en Python
Comment tracer une limite de décision pour les algorithmes d’apprentissage automatique en Python 
10 septembre 2020
14 798
lit
@
kvssetty
[email protégé]
Formateur et enseignant indépendant en Data science et Machine learning
Les algorithmes de classification apprennent à attribuer des étiquettes de classe aux exemples (observations ou points de données), bien que leurs décisions puissent sembler opaques.
Ce tutoriel est rédigé par
KVS Setty
Vous pouvez trouver le code source complet sur
mon dépôt git
Un diagnostic populaire pour comprendre les décisions prises par un algorithme de classification est le
surface de décision
.Il s’agit d’un graphique qui montre comment un algorithme d’apprentissage automatique entraîné prédit une grille grossière dans l’espace des caractéristiques d’entrée.
Un graphique de surface de décision est un outil puissant pour comprendre comment un modèle donné «voit» la tâche de prédiction et comment il a décidé de diviser l’espace des caractéristiques en entrée par étiquette de classe.
Dans ce tutoriel, vous découvrirez comment tracer une surface de décision pour un algorithme de machine learning de classification.
Après avoir terminé ce tutoriel, vous saurez :
La surface de décision est un outil de diagnostic pour comprendre comment un algorithme de classification divise l’espace des caractéristiques.
Comment tracer une surface de décision pour l’utilisation d’étiquettes de classe nettes pour un algorithme d’apprentissage automatique.
Comment tracer et interpréter une surface de décision à l’aide de probabilités prédites.
Commençons.
Présentation du didacticiel
Ce tutoriel est divisé en quatre parties ;elles sont:
Surface de décision
Ensemble de données et modèle
Tracer une surface de décision
Tracer la surface de décision d’un arbre de décision sur l’ensemble de données d’iris
Surface de décision
Les algorithmes d’apprentissage automatique de classification apprennent à attribuer des étiquettes aux exemples d’entrée (observations).
Considérez les entités numériques en entrée pour la tâche de classification définissant un espace d’entités en entrée continu.
Nous pouvons penser à chaque entité en entrée définissant un axe ou une dimension sur un espace d’entités.Deux entités en entrée définiraient un espace d’entités qui est un plan, avec des points représentant les coordonnées en entrée dans l’espace en entrée.S’il y avait trois variables d’entrée, l’espace des caractéristiques serait un volume tridimensionnel. S’il y avait
m
variables d’entrée, l’espace de fonctionnalité être un
hyperplan à n dimensions
.Difficile de visualiser les espaces au-delà des trois dimensions.
Chaque point de l’espace peut se voir attribuer une étiquette de classe.En termes d’espace de caractéristiques bidimensionnel, nous pouvons penser à chaque point sur le rabotage ayant une couleur différente, en fonction de la classe qui lui est attribuée.
L’objectif d’un algorithme de classification est d’apprendre à diviser l’espace des caractéristiques de telle sorte que les étiquettes soient attribuées correctement aux points de l’espace des caractéristiques, ou du moins, aussi correctement que possible.
Il s’agit d’une compréhension géométrique utile de la modélisation de la classification prédictive.Nous pouvons aller plus loin.
Une fois qu’un algorithme d’apprentissage automatique de classification divise un espace de caractéristiques, nous pouvons alors classer chaque point de l’espace de caractéristiques, sur une grille arbitraire, pour avoir une idée de la façon dont l’algorithme a choisi de diviser l’espace de caractéristiques.
C’est ce qu’on appelle un
surface de décision
ou
limite de décision
, et il fournit un outil de diagnostic pour comprendre un modèle sur une tâche de modélisation de classification prédictive.
Bien que la notion de « surface » suggère un espace d’entités bidimensionnel, la méthode peut être utilisée avec des espaces d’entités à plus de deux dimensions, où une surface est créée pour chaque paire d’entités en entrée.
Maintenant que nous savons ce qu’est une surface de décision, définissons ensuite un ensemble de données et un modèle pour lesquels nous explorons plus tard la limite de décision.
Ensemble de données et modèle
Dans cette section, nous allons définir une tâche de classification et un modèle prédictif pour apprendre la tâche.
Ensemble de données de classification synthétique
Nous pouvons utiliser le
make_blobs() fonction scikit-learn
définir une tâche de classification avec un espace de caractéristiques numériques à deux dimensions et chaque point étant affecté à l’une des deux étiquettes de classe, par exemple une tâche de classification binaire.
…# générer datasetX, y = make_blobs(n_samples=
1000
, centres=
2
, n_caractéristiques=
2
, état_aléatoire=
26
, cluster_std=
3
)
Une fois défini, nous pouvons ensuite créer un nuage de points de l’espace des caractéristiques avec la première caractéristique définissant l’axe des x, la deuxième caractéristique définissant l’axe des y et chaque échantillon représenté comme un point dans l’espace des caractéristiques.
Nous pouvons ensuite colorer les points du nuage de points en fonction de leur étiquette de classe en tant que 0 ou 1.
…# créer un nuage de points
pour
échantillons
de
chaque
classer
importer
numpy
comme
np
importer
pandas
comme
pd
importer
Matplotlib
.
pyplot
comme
plt
%
matplotlib
en ligne
Importer
marin
comme
sns
sns
.
nuage de points
(
X
=
“x1”
, y=
“x2”
, teinte=
‘classer’
, données=données)
En combinant tout cela, l’exemple complet de définition et de traçage d’un ensemble de données de classification synthétique est répertorié ci-dessous.
En 1]:
# générer un ensemble de données de classification binaire et un tracé
importer
numpy
comme
np
importer
pandas
comme
pd
importer
matplotlib.pyplot
comme
plt%matplotlib en ligne
importer
marin
comme
sns
de
sklearn.datasets
importer
make_blobs# génère datasetX, y = make_blobs(n_samples=
1000
, centres=
2
, n_caractéristiques=
2
, état_aléatoire=
1
, cluster_std=
3
)
En 2]:
X_df = pd.DataFrame(X, colonnes=[
‘x1’
,
‘x2’
])X_df.head()
Sortie[2]:
Dans [3]:
y_df = pd.DataFrame(y, colonnes=[
“classer”
])
Dans [4]:
y_df.head()
Sortie[4]:
Dans [5] :
cadres
= [
X_df
, y_df]
Les données
= pd.concat(
cadres
,
axe
=1)
Les données
.diriger()
Sortie[5]:
Dans [6]:
# créer un nuage de points
pour
échantillons
de
chaque
classer
sns
.
nuage de points
(
X
= 
“x1”
, y=
“x2”
, teinte=
‘classer’
, données=données)
Sortie[6]:
0x1a62b1ec0f0
>
L’exécution de l’exemple ci-dessus a créé l’ensemble de données, puis trace l’ensemble de données sous forme de nuage de points avec des points colorés par étiquette de classe.
Nous pouvons voir une séparation claire entre les exemples des deux classes et nous pouvons imaginer comment un modèle d’apprentissage automatique pourrait tracer une ligne pour séparer les deux classes, par exemple une ligne diagonale passant par le milieu des deux groupes.
Ajuster le modèle de classification prédictif
Nous pouvons maintenant ajuster un modèle sur notre jeu de données.
Dans ce cas, nous ajusterons un algorithme de régression logistique car nous pouvons prédire à la fois des étiquettes de classe précises et des probabilités, que nous pouvons utiliser dans notre surface de décision.
Nous pouvons définir le modèle, puis l’adapter à l’ensemble de données d’apprentissage.
…
# définir le modèle
modèle = Régression Logistique()
# correspond au modèle
model.fit(X, y)
Une fois défini, nous pouvons utiliser le modèle pour faire une prédiction pour l’ensemble de données d’apprentissage afin d’avoir une idée de la façon dont il a appris à diviser l’espace des caractéristiques de l’ensemble de données d’apprentissage et à attribuer des étiquettes.
pyhton…# faire des prédictionsyhat = model.predict(X)
Les prédictions peuvent être évaluées en utilisant la précision de la classification.
…# évalue les prédictionsacc = precision_score(y, yhat)print(
‘Précision:%3f’
% acc)
en combinant tout cela, l’exemple complet d’ajustement et d’évaluation d’un modèle sur l’ensemble de données de classification binaire synthétique est répertorié ci-dessous.
Dans [7]:
# Exemple
de
ajustement et évaluation d’un modèle sur l’ensemble de données de classification
de
sklearn.datasets
importer
make_blobs
de
sklearn.linear_model
importer
Régression logistique
de
sklearn.metrics
importer
precision_score# générer datasetX, y = make_blobs(n_samples=
1000
, centres=
2
, n_caractéristiques=
2
, état_aléatoire=
1
, cluster_std=
3
)# définir le modelmodel = LogisticRegression()# adapter le modelmodel.fit(X, y)# faire des prédictionsyhat = model.predict(X)# évaluer les prédictionsacc = precision_score(y, yhat)print(
‘Précision:%3f’
% acc)
Précision:
0,972
L’exécution de l’exemple correspond au modèle et fait une prédiction pour chaque exemple.
Vos résultats spécifiques peuvent varier étant donné la nature stochastique de l’algorithme d’apprentissage.Essayez d’exécuter l’exemple plusieurs fois.
Dans ce cas, nous pouvons voir que le modèle a atteint une performance d’environ 97,2 %.
Maintenant que nous avons un ensemble de données et un modèle, explorons comment nous pouvons développer une surface de décision.
Tracer une surface de décision
Nous pouvons créer une limite de décision en ajustant un modèle sur l’ensemble de données d’apprentissage, puis en utilisant le modèle pour faire des prédictions pour une grille de valeurs dans le domaine d’entrée.
Une fois que nous avons la grille de prédictions, nous pouvons tracer les valeurs et leur étiquette de classe.
Un nuage de points pourrait être utilisé si une grille suffisamment fine était prise.Une meilleure approche consiste à utiliser un tracé de contour qui peut interpoler les couleurs entre les points.
Les
contourf() fonction Matplotlib
peut être utilisé.
Cela nécessite quelques étapes.
Tout d’abord, nous devons définir une grille de points à travers l’espace des caractéristiques.
Pour ce faire, nous pouvons trouver les valeurs minimales et maximales pour chaque caractéristique et étendre la grille d’un cran au-delà pour garantir que tout l’espace des caractéristiques est couvert.
…# définir les limites
de
le domainemin1, max1 = X[:,
0
].min()
-1
, X[:,
0
].max()+
1
min2, max2 = X[:,
1
].min()
-1
, X[:,
1
].max()+
1
Nous pouvons ensuite créer un échantillon uniforme dans chaque dimension en utilisant le
ranger()
fonctionner à une résolution choisie.Nous utiliserons une résolution de 0,1 dans ce cas.
…# définit les échelles x et yx1grid = arange(min1, max1,
0,1
)x2grid = arange(min2, max2,
0,1
)
Maintenant, nous devons transformer cela en une grille.
Nous pouvons utiliser le
meshgrid() fonction NumPy
pour créer une grille à partir de ces deux vecteurs.
Si la première caractéristique x1 est notre axe x de l’espace des caractéristiques, alors nous avons besoin d’une ligne de valeurs x1 de la grille pour chaque point sur l’axe y.
De même, si nous prenons x2 comme axe des y de l’espace des caractéristiques, nous avons besoin d’une colonne de valeurs x2 de la grille pour chaque point sur l’axe des x.
Les
maillage ()
La fonction le fera pour nous, en dupliquant les lignes et les colonnes pour nous selon les besoins.Il renvoie deux grilles pour les deux vecteurs d’entrée.La première grille de valeurs x et la seconde de valeurs y, organisées en une grille de rangées et de colonnes de taille appropriée dans l’espace des caractéristiques.
…# tout créer
de
les lignes et les lignes
de
la grillexx, yy = meshgrid(x1grid, x2grid)
Nous devons ensuite aplatir la grille pour créer des échantillons que nous pouvons intégrer au modèle et faire une prédiction.
Pour ce faire, nous aplatissons d’abord chaque grille en un vecteur.
…# aplatit chaque grille en un vecteurr1, r2 = xx.flatten(), yy.flatten()r1, r2 = r1.reshape((len(r1),
1
)), r2.reshape((len(r2),
1
))
Ensuite, nous empilons les vecteurs côte à côte sous forme de colonnes dans un ensemble de données d’entrée, par exemple comme notre ensemble de données d’apprentissage d’origine, mais à une résolution beaucoup plus élevée.
… # vecteurs de pile horizontaux pour créer une entrée x1,x2
pour
la grille de modèle = hstack((r1,r2))
Nous pouvons ensuite intégrer cela dans notre modèle et obtenir une prédiction pour chaque point de la grille.
…# faire des prédictions
pour
le gridyhat = model.predict(grid)
Jusqu’ici tout va bien.
Nous avons une grille de valeurs à travers l’espace des caractéristiques et les étiquettes de classe comme prédit par notre modèle.
Ensuite, nous devons tracer la grille de valeurs sous la forme d’un tracé de contour.
Les
fonction contourf()
prend des grilles séparées pour chaque axe, tout comme ce qui a été renvoyé de notre précédent appel à meshgrid().Super!
Nous pouvons donc utiliser xx et yy que nous avons préparés plus tôt et simplement remodeler les prédictions (yhat) du modèle pour avoir la même forme.
…# remodeler les prédictions dans une grillezz = yhat.reshape(xx.shape)
Nous traçons ensuite la surface de décision avec une palette de couleurs à deux couleurs.
…# tracer la grille
de
valeurs x, y et z
comme
a surfacepyplot.contourf(xx, yy, zz, cmap=
‘Apparié’
)
Nous pouvons ensuite tracer les points réels de l’ensemble de données sur le dessus pour voir dans quelle mesure ils ont été séparés par la surface de décision de la régression logistique.
L’exemple complet de tracé d’une surface de décision pour un modèle de régression logistique sur notre ensemble de données de classification binaire synthétique est répertorié ci-dessous.
Dans [8] :
# surface de décision pour la régression logistique sur un ensemble de données de classification binaire
importer
numpy en tant que npfrom sklearn.datasets
importer
make_blobsfrom sklearn.linear_model
importer
Régression logistique
# générer un ensemble de données
X,
oui
= make_blobs(
n_échantillons=1000,
centres=2,
n_caractéristiques=2,
état_aléatoire=1,
cluster_std=3)
# définir les limites du domaine
min1,
max1
= X[:,
0
].min()-
1
, X[:,
0
].max()+
1
min2,
max2
= X[:,
1
].min()-
1 
, X[:,
1
].max()+
1
# définir l’échelle x et y
x1grille
= np.arange(min1, max1,
0,1
)
x2grid
= np.arange(min2, max2,
0,1
)
# crée toutes les lignes et lignes de la grille
xx,
aa
= np.meshgrid(x1grid, x2grid)
# aplatir chaque grille en un vecteur
r1,
r2
= xx.flatten(), yy.flatten()r1,
r2
= r1.reshape((len(r1),
1
)), r2.reshape((len(r2),
1
))
# vecteurs de pile horizontaux pour créer une entrée x1,x2 pour le modèle
la grille
= np.hpile((r1,r2))
# définir le modèle
maquette
= Régression Logistique()
# correspond au modèle
model.fit(X, y)
# faire des prédictions pour la grille
ouais
= model.predict(grille)
# remodeler les prédictions dans une grille
zz
= yhat.reshape(xx.shape)
# tracer la grille des valeurs x, y et z comme une surface
plt.contourf(xx, yy, zz,
cmap=’Appairé’)
# créer un nuage de points pour les échantillons de chaque classe
pour class_value
dans
gamme(
2
):
# obtient les index de ligne pour les échantillons avec cette classe
ligne_ix
= np.où(
oui
== valeur_classe)
# créer un scatter de ces échantillons
plt.scatter(X[ligne_ix,
0
], X[ligne_ix,
1
],
cmap=’Appairé’)
Nous pouvons ajouter plus de profondeur à la surface de décision en utilisant le modèle pour prédire les probabilités au lieu des étiquettes de classe.
…# faire des prédictions
pour
le gridyhat = model.predict_proba(grid)# ne garde que les probabilités
pour
classer
0
ouais
= ouais[:,
0
]
Une fois tracé, nous pouvons voir à quel point il est certain ou probable que chaque point de l’espace des caractéristiques appartient à chacune des étiquettes de classe, comme le voit le modèle.
Nous pouvons utiliser un
carte de couleur différente
qui a des gradations, et montre une légende afin que nous puissions interpréter les couleurs.
…# tracer la grille
de
valeurs x, y et z
comme
une surfacec = pyplot.contourf(xx, yy, zz, cmap=
‘RdBu’
)# ajouter une légende, appelée une couleur barpyplot.colorbar(c)
L’exemple complet de création d’une surface de décision à l’aide de probabilités est répertorié ci-dessous.
Dans [9]:
# surface de décision de probabilité
pour
régression logistique sur un jeu de données de classification binaire
importer
numpy
comme
np
de
sklearn.datasets
importer
make_blobs
de
sklearn.linear_model
importer
LogisticRegression# generate datasetX, y = make_blobs(n_samples=
1000
, centres=
2
, n_caractéristiques=
2
, état_aléatoire=
1
, cluster_std=
3
)# définir les limites
de
le domainemin1, max1 = X[:,
0
].min()
-1
, X[:,
0
].max()+
1
min2, max2 = X[:,
1
].min()
-1
, X[:,
1
].max()+
1
# définir les échelles x et yx1grid = np.arange(min1, max1,
0,1
)x2grid = np.arange(min2, max2,
0,1
)# créer tout
de
les lignes et les lignes
de
la grillexx, yy = np.meshgrid(x1grid, x2grid)# aplatit chaque grille en un vecteurr1, r2 = xx.flatten(), yy.flatten()r1, r2 = r1.reshape((len(r1),
1
)), r2.reshape((len(r2),
1
))# vecteurs de pile horizontaux pour créer une entrée x1,x2
pour
the modelgrid = np.hstack((r1,r2))# define the modelmodel = LogisticRegression()# fit the modelmodel.fit(X, y)# faire des prédictions
pour
le gridyhat = model.predict_proba(grid)# ne garde que les probabilités
pour
classer
0
ouais
= ouais[:,
0
]# remodeler les prédictions dans une grillezz = yhat.reshape(xx.shape)# tracer la grille
de
valeurs x, y et z
comme
une surfacec = plt.contourf(xx, yy, zz, cmap=
‘RdBu’
)# ajouter une légende, appelée une couleur barplt.colorbar(c)# créer un nuage de points
pour
échantillons
de
chaque
classer
pour
valeur_classe
dans
gamme
(2): #
avoir
ligne
index
pour
échantillons
avec
cette
classer
ligne_ix
= np.where(y == class_value) # crée un scatter
de 
ces échantillons plt.scatter(X[row_ix,
0
], X[ligne_ix,
1
], cmap=
‘Apparié’
)
L’exécution de l’exemple prédit la probabilité d’appartenance à une classe pour chaque point de la grille dans l’espace des entités et trace le résultat.
Ici, nous pouvons voir que le modèle est incertain (couleurs plus claires) vers le milieu du domaine, étant donné le bruit d’échantillonnage dans cette zone de l’espace des caractéristiques.Nous pouvons également voir que le modèle est très confiant (tout en couleurs) dans les moitiés inférieure gauche et supérieure droite du domaine.
Ensemble, les surfaces nettes de décision de classe et de probabilité sont des outils de diagnostic puissants pour comprendre votre modèle et comment il divise l’espace des caractéristiques pour votre tâche de modélisation prédictive.
Tracer la surface de décision d’un arbre de décision sur l’ensemble de données d’iris
Tracez la surface de décision d’un arbre de décision formé sur des paires de caractéristiques de l’ensemble de données d’iris.
Voir
arbre de décision
pour plus d’informations sur l’estimateur.
Pour chaque paire de caractéristiques d’iris, l’arbre de décision apprend des limites de décision constituées de combinaisons de règles de seuillage simples déduites des échantillons d’apprentissage.
Nous montrons également l’arborescence d’un modèle construit sur l’ensemble des fonctionnalités.
Dans [10]:
importer
numpy
comme
np
importer
matplotlib.pyplot
comme
plt
de
sklearn.datasets
importer
load_iris
de
sklearn.tree
importer
DecisionTreeClassifier, plot_tree# Paramètresn_classes =
3
plot_colors =
“ryb”
plot_step =
0,02
# Charger datairis = load_iris()
pour
pairidx, paire
dans
énumérer([[
0
,
1
], [
0
,
2
], [
0
,
3
], [
1
,
2
], [
1
,
3
], [
2
,
3
]]): # Nous ne prenons que les deux caractéristiques correspondantes X = iris.data[:, pair] y = iris.target # Entraîner clf = DecisionTreeClassifier().fit(X, y) # Tracer la limite de décision plt.subplot(
2
,
3
, pairidx +
1
) x_min, x_max = X[:,
0
].min() –
1
, X[:,
0
].max() +
1
y_min, y_max = X[:,
1
].min() –
1
, X[:,
1
].max() +
1
xx, yy = np.meshgrid(np.arange(x_min, x_max, plot_step), np.arange(y_min, y_max, plot_step)) plt.tight_layout(h_pad=
0,5
, w_pad=
0,5
, pad=
2.5
) Z = clf.predict(np.c_[xx.ravel(), yy.ravel()]) Z = Z.reshape(xx.shape) cs = plt.contourf(xx, yy, Z, cmap=plt. cm.RdYlBu) plt.xlabel(iris.feature_names[pair[
0
]]) plt.ylabel(iris.feature_names[pair[
1
]]) # Tracer les points d’entraînement
pour
je, couleur
dans
zip(range(n_classes), plot_colors): idx = np.where(y == i) plt.scatter(X[idx,
0
], X[idx,
1
], c=color, label=iris.target_names[i], cmap=plt.cm.RdYlBu, edgecolor=
‘le noir’
, s=
15
)plt.suptitle(
“Surface de décision d’un arbre de décision utilisant des caractéristiques appariées”
)plt.légende(loc=
‘en bas à droite’
, borderpad=
0
, handletextpad=
0
)plt.axe(
“serré”
)plt.figure()clf = DecisionTreeClassifier().fit(iris.data, iris.target)plot_tree(clf, filled=True)plt.show()
Sommaire
Dans ce didacticiel, vous avez découvert comment tracer une surface de décision pour un algorithme d’apprentissage automatique de classification.
Concrètement, vous avez appris :
La surface de décision est un outil de diagnostic pour comprendre comment un algorithme de classification divise l’espace des caractéristiques.
Comment tracer une surface de décision pour l’utilisation d’étiquettes de classe nettes pour un algorithme d’apprentissage automatique.
Comment tracer et interpréter une surface de décision à l’aide de probabilités prédites.
Avez-vous des questions?
Posez vos questions dans la section commentaires du post, j’essaie de faire de mon mieux pour y répondre.
Auparavant publié à h
ttps://kvssetty.com/plot-a-decision-surface-for-machine-learning-algorithms-in-python/
Partenaire avec nous pour le développement de produits numériques
Histoires liées
Objet
#
intelligence artificielle
Pycaret: un moyen plus rapide de créer des modèles d’apprentissage automatique
par
@
davisdavid
#
apprentissage automatique
Les 6 meilleurs environnements de développement intégrés (IDE) pour les programmeurs Python
par
@
ruchirkakkad
#
programmation-python
Comment l’augmentation des données affectera-t-elle l’apprentissage automatique?
par
@
loup
#
ai
«Je ne peux pas imaginer faire autre chose», déclare Lisa First-Willis, PDG de Truvelop
par
@
truvelop
#
startups-de-l’année
Mots clés
#
science des données
#
apprentissage automatique
#
python3
#
programmation-python
#
python
#
python-top-histoire
#
python-tutoriels
#
développeurs-python
Rejoignez Hacker Midi
Créez votre compte gratuit pour débloquer votre expérience de lecture personnalisée.