Classification par méthode k-voisinage (kNN) par python ([High school information department information II] matériel pédagogique pour la formation des enseignants)
introduction
La méthode k-plus proche voisin (kNN) est un algorithme d'apprentissage automatique simple qui détermine la valeur prédite en prenant une décision majoritaire parmi les k éléments les plus proches de la valeur à prédire. L'explication suivante est intuitive et facile à comprendre.
Dans la figure de droite, la marque du sourire correspond à la position de la valeur que vous souhaitez prédire et montre la plage du voisinage lorsque k = 3. Dans ce cas, ◆ est la valeur prévue de la marque du sourire.
Dans cet article, j'aimerais réécrire la partie implémentée par R pour la classification par la méthode k-voisinage dans le matériel pédagogique en python.
Matériel pédagogique
[Matériel de formation des enseignants du Département de l'information du lycée "Information II" (principal): Ministère de l'éducation, de la culture, des sports, de la science et de la technologie](https://www.mext.go.jp/a_menu/shotou/zyouhou/detail/mext_00742.html "Département de l'information du lycée Matériel pédagogique "Information II" pour la formation des enseignants (partie principale): Ministère de l'éducation, de la culture, des sports, des sciences et de la technologie ") Chapter 3 Information and Data Science Second Half (PDF: 7,6 Mo)
environnement
- ipython
- Colaboratory - Google Colab
Parties à reprendre dans le matériel pédagogique
Learning 15 Prédiction par classification: "3.k-Classification par la méthode du quartier"
Données traitées cette fois
Téléchargez les données de reconnaissance de chiffres de kaggle de la même manière que le matériel pédagogique. C'est "train.csv" à utiliser.
https://www.kaggle.com/c/digit-recognizer/data
Exemple d'implémentation et résultat en python
Lecture des données d'entraînement et des données de test
Les informations sur 42000 numéros manuscrits sont stockées dans train.csv, et les informations sur un numéro manuscrit sont l'étiquette de réponse correcte (numéro de réponse correct) dans la première colonne (étiquette) et 784 dans la deuxième colonne et les suivantes (pixel). Cela ressemble à une valeur de gradation de niveaux de gris de 256 niveaux (0-255) de (28 x 28) pixels.
Ici, nous utiliserons les 1000 premières données comme données d'entraînement et les 100 données suivantes comme données de test.
import numpy as np
import pandas as pd
from IPython.display import display
mnist = pd.read_csv('/content/train.csv')
mnist_light = mnist.iloc[:1000,:]
mnist_light_test = mnist.iloc[1000:1100,:]
#Données d'entraînement
Y_mnist_light = mnist_light[['label']].values.ravel()
#display(Y_mnist_light)
X_mnist_light = mnist_light.drop('label', axis = 1)
#display(X_mnist_light)
#données de test
Y_mnist_light_test = mnist_light_test[['label']].values.ravel()
#display(Y_mnist_light_test)
X_mnist_light_test = mnist_light_test.drop('label', axis = 1)
#display(X_mnist_light_test)
Formation et prédiction des données d'entraînement
Après un entraînement avec la méthode k-voisinage et des données d'apprentissage lorsque k = 3, la valeur prédite est obtenue à partir de 100 données de test. Le taux de réponse correct est affiché en comparant avec l'étiquette (valeur de réponse correcte) des données de test.
from sklearn.neighbors import KNeighborsClassifier
from sklearn import metrics
from sklearn.metrics import accuracy_score
# sklearn.neighbors.Utiliser le classificateur KNeighbors
knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_mnist_light, Y_mnist_light)
#Exécution prédictive
pred_y = knn.predict(X_mnist_light_test)
display(pred_y)
#Confirmer la bonne réponse
result_compare = pred_y == Y_mnist_light_test
display(result_compare)
minist_accuracy_score = accuracy_score(Y_mnist_light_test, pred_y)
#Taux de réponse correct
print(minist_accuracy_score)
Le résultat de l'exécution est le suivant.
array([1, 5, 1, 7, 9, 8, 9, 5, 7, 4, 7, 2, 8, 1, 4, 3, 8, 6, 2, 7, 2, 6,
7, 8, 1, 8, 8, 1, 9, 0, 9, 4, 6, 6, 8, 2, 3, 5, 4, 5, 4, 1, 3, 7,
1, 5, 0, 0, 9, 5, 5, 7, 6, 8, 2, 8, 4, 2, 3, 6, 2, 8, 0, 2, 4, 7,
3, 4, 4, 5, 4, 3, 3, 1, 5, 1, 0, 2, 2, 2, 9, 5, 1, 6, 6, 9, 4, 1,
7, 2, 2, 0, 7, 0, 6, 8, 0, 5, 7, 4])
array([ True, True, True, True, False, True, True, True, True,
True, True, True, False, True, True, False, True, True,
True, False, True, True, True, True, True, True, True,
True, True, True, False, False, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, False, True, False, True, True, True,
True, True, True, True, True, True, True, True, False,
True, True, True, True, True, True, True, True, False,
True, True, True, True, True, True, True, True, True,
True, False, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True])
0.89
Le taux de réponse correcte est de 0,89.
Confirmation des numéros manuscrits réellement incorrects
Parmi les données de test, la cinquième donnée de test est incorrectement reconnue. Nous vérifions en fait le mauvais numéro.
import matplotlib.pyplot as plt
#Affichage des données de test
fig, axes = plt.subplots(2, 5)
fig.subplots_adjust(left=0, right=1, bottom=0, top=1.0, hspace=0.1, wspace=0.1)
for i in range(2):
for j in range(5):
axes[i, j].imshow(X_mnist_light_test.values[i*5+j].reshape((28, 28)), cmap='gray')
axes[i, j].set_xticks([])
axes[i, j].set_yticks([])
plt.show()
Le résultat de l'exécution est le suivant.
Le numéro manuscrit le plus à droite dans la rangée supérieure avait un libellé (valeur de réponse correcte) de 4, mais il semble que la valeur prédite ait été mal reconnue comme 9. Cela ressemble à un nombre qui peut être jugé visuellement comme 9.
Changement du taux de réponse correct lors du changement de la matrice mixte et de la valeur de k
L'axe vertical est la valeur prédite, l'axe horizontal est le libellé de réponse correcte et un tableau indiquant le nombre s'affiche.
from sklearn.metrics import confusion_matrix
cfm = confusion_matrix(Y_mnist_light_test, pred_y)
print(cfm)
Le résultat de l'exécution est le suivant.
[[ 7 0 0 0 0 0 0 0 0 0]
[ 0 10 0 0 0 0 0 0 0 0]
[ 0 0 13 0 0 0 0 1 1 0]
[ 0 0 0 5 0 1 0 0 0 0]
[ 0 0 0 0 11 0 0 0 0 1]
[ 0 0 0 0 0 10 0 0 0 0]
[ 0 0 0 0 0 0 9 0 0 0]
[ 1 0 0 0 0 0 0 10 0 1]
[ 0 0 0 2 0 0 0 0 10 1]
[ 0 1 0 0 1 0 0 0 0 4]]
Ensuite, le taux de réponse correct est affiché dans un graphique lorsque la valeur de k est modifiée pour voir ce qui convenait pour la valeur de k.
n_neighbors_chg_list = []
# n_Graphique lorsque les voisins sont modifiés
for i in range(1,100):
# sklearn.neighbors.Utiliser le classificateur KNeighbors
knn_temp = KNeighborsClassifier(n_neighbors = i)
knn_temp.fit(X_mnist_light, Y_mnist_light)
#Exécution prédictive
pred_y_temp = knn_temp.predict(X_mnist_light_test)
#Taux de réponse correct
minist_accuracy_score_temp = accuracy_score(Y_mnist_light_test, pred_y_temp)
#Stocker dans la baie
n_neighbors_chg_list.append(minist_accuracy_score_temp)
plt.plot(n_neighbors_chg_list)
Le résultat de l'exécution est le suivant.
En général, si la valeur de k est grande, même s'il y a une valeur aberrante, l'effet sur le résultat est faible, donc l'effet du bruit peut être réduit, mais les limites de la classe ont tendance à ne pas être claires. La valeur appropriée de k change en fonction du nombre de données d'apprentissage, etc., mais dans cet essai, le taux de réponse correcte avait tendance à diminuer à mesure que k augmentait.
Code source
https://gist.github.com/ereyester/01237a69f6b8ae73c55ccca33c931ade
Recommended Posts