Klassifizierung nach der k-Nachbarschaftsmethode (kNN) nach Python ([Informationen zur Informationsabteilung der High School II] Unterrichtsmaterialien für die Lehrerausbildung)

Einführung

Die k-Nearest-Neighbour-Methode (kNN) ist ein einfacher Algorithmus für maschinelles Lernen, der den vorhergesagten Wert bestimmt, indem eine Mehrheitsentscheidung unter den k Elementen getroffen wird, die dem vorherzusagenden Wert am nächsten liegen. Die folgende Erklärung ist intuitiv und leicht zu verstehen.

In der Abbildung rechts ist das Lächeln die Position des Werts, den Sie vorhersagen möchten, und zeigt den Bereich der Umgebung an, wenn k = 3 ist. In diesem Fall ist ◆ der vorhergesagte Wert der Lächelnmarke.

In diesem Artikel möchte ich den von R implementierten Teil für die Klassifizierung nach der k-Nachbarschaftsmethode in den Unterrichtsmaterialien zu Python umschreiben.

Lehrmaterial

[Informationsabteilung der High School "Information II" Lehrmaterialien (Lehrer): Ministerium für Bildung, Kultur, Sport, Wissenschaft und Technologie](https://www.mext.go.jp/a_menu/shotou/zyouhou/detail/mext_00742.html "Informationsabteilung der High School Unterrichtsmaterialien "Information II" für die Lehrerausbildung (Hauptteil): Ministerium für Bildung, Kultur, Sport, Wissenschaft und Technologie ") Kapitel 3 Informations- und Datenwissenschaft, zweite Hälfte (PDF: 7,6 MB)

Umgebung

• ipython
• Colaboratory - Google Colab

Teile, die in den Unterrichtsmaterialien aufgenommen werden sollen

Lernen 15 Vorhersage nach Klassifikation: "3.k-Klassifikation nach Nachbarschaftsmethode"

Diesmal werden Daten verarbeitet

Laden Sie die Daten zur Ziffernerkennung von kaggle auf die gleiche Weise wie das Lehrmaterial herunter. Es ist "train.csv" zu verwenden.

https://www.kaggle.com/c/digit-recognizer/data

Implementierungsbeispiel und Ergebnis in Python

Trainingsdaten und Testdaten lesen

Informationen zu 42.000 handgeschriebenen Nummern werden in train.csv gespeichert, und die Informationen zu einer handschriftlichen Nummer sind das richtige Antwortetikett (richtige Antwortnummer) in der ersten Spalte (Etikett) und 784 in der zweiten und den folgenden Spalten (Pixel). Es sieht aus wie ein Graustufenabstufungswert (0-255) in 256 Schritten von (28 x 28) Pixel.

Hier werden wir die ersten 1.000 Daten als Trainingsdaten und die nächsten 100 Daten als Testdaten verwenden.

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,:]

#Trainingsdaten
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)

#Testdaten
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)

Training und Vorhersage von Trainingsdaten

Nach dem Training mit der k-Nachbarschaftsmethode und den Trainingsdaten bei k = 3 wird der vorhergesagte Wert aus 100 Testdaten erhalten. Die richtige Antwortrate wird durch Vergleich mit dem Etikett (korrekter Antwortwert) der Testdaten angezeigt.

from sklearn.neighbors import KNeighborsClassifier
from sklearn import metrics
from sklearn.metrics import accuracy_score

# sklearn.neighbors.Verwenden Sie den KNeighbors Classifier
knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_mnist_light, Y_mnist_light)

#Vorausschauende Ausführung
pred_y = knn.predict(X_mnist_light_test)
display(pred_y)

#Bestätigen Sie die richtige Antwort
result_compare = pred_y == Y_mnist_light_test
display(result_compare)

minist_accuracy_score = accuracy_score(Y_mnist_light_test, pred_y)

#Richtige Antwortrate
print(minist_accuracy_score)

Das Ausführungsergebnis ist wie folgt.

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

Die richtige Antwortrate beträgt 0,89.

Bestätigung von tatsächlich falschen handschriftlichen Nummern

Von den Testdaten werden die fünften Testdaten falsch erkannt. Wir überprüfen tatsächlich die falsche Nummer.

import matplotlib.pyplot as plt

#Anzeige der Testdaten
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()

Das Ausführungsergebnis ist wie folgt.

Die handschriftliche Zahl ganz rechts in der oberen Reihe hatte eine Bezeichnung (korrekter Antwortwert) von 4, aber es scheint, dass der vorhergesagte Wert als 9 falsch erkannt wurde. Es sieht aus wie eine Zahl, die visuell als 9 beurteilt werden kann.

Änderung der korrekten Antwortrate beim Ändern der gemischten Matrix und des Werts von k

Die vertikale Achse ist der vorhergesagte Wert und die horizontale Achse ist das richtige Antwortetikett. Eine Tabelle mit der Nummer wird angezeigt.

from sklearn.metrics import confusion_matrix

cfm = confusion_matrix(Y_mnist_light_test, pred_y)

print(cfm)

Das Ausführungsergebnis ist wie folgt.

[[ 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]]

Als nächstes wird die richtige Antwortrate in einem Diagramm angezeigt, wenn der Wert von k geändert wird, um zu sehen, was für den Wert von k geeignet war.

n_neighbors_chg_list = []

# n_Diagramm, wenn Nachbarn geändert werden
for i in range(1,100):
    # sklearn.neighbors.Verwenden Sie den KNeighbors Classifier
    knn_temp = KNeighborsClassifier(n_neighbors = i)
    knn_temp.fit(X_mnist_light, Y_mnist_light)

    #Vorausschauende Ausführung
    pred_y_temp = knn_temp.predict(X_mnist_light_test)

    #Richtige Antwortrate
    minist_accuracy_score_temp = accuracy_score(Y_mnist_light_test, pred_y_temp)

    #Im Array speichern
    n_neighbors_chg_list.append(minist_accuracy_score_temp)

plt.plot(n_neighbors_chg_list)

Das Ausführungsergebnis ist wie folgt.

Wenn der Wert von k groß ist, selbst wenn es einen Ausreißer gibt, ist die Auswirkung auf das Ergebnis im Allgemeinen gering, so dass die Auswirkung von Rauschen verringert werden kann, aber die Grenzen der Klasse sind tendenziell unklar. Der geeignete Wert von k ändert sich in Abhängigkeit von der Anzahl der Trainingsdaten usw., aber in diesem Versuch nahm die korrekte Antwortrate tendenziell ab, wenn k zunahm.

Quellcode

https://gist.github.com/ereyester/01237a69f6b8ae73c55ccca33c931ade