2. Multivariate Analyse in Python 8-1. K Nachbarschaftsmethode (Scikit-Learn)

• Es gibt mehrere Gruppen, und die Attribute der zu ihnen gehörenden Stichprobengruppen sind bekannt. Wenn eine weitere ** neue Stichprobe hinzugefügt wird, ist es ** k-NN, um herauszufinden, zu welcher Gruppe sie gehört **. (K-nächster Nachbar: k Nachbarschaftsmethode) **.
• Insbesondere handelt es sich um eine Klassifizierungsmethode, bei der ** K-Stücke mit ähnlichen Attributen wie die neue Stichprobe ** aus der vorhandenen Stichprobengruppe erhalten und als Mehrheitsgruppe unter ihnen bestimmt werden. Deshalb werden diese ** k ** Stücke ** k-NN ** genannt.

• Wenn k = 3 ist, wird es als blaue Gruppe beurteilt, und wenn k = 12, wird es als grüne Gruppe klassifiziert, sodass sich die Beurteilung in Abhängigkeit von der Anzahl von k unterscheidet.

** Kann auch für die Regression verwendet werden, aber hier werden wir einen Klassifizierungsfall durchführen. ** ** **

⑴ Bibliothek importieren

import numpy as np
import pandas as pd

from sklearn import datasets
# sklearn.Nachbarmodul k-NN-Methode
from sklearn.neighbors import KNeighborsClassifier
#Dienstprogramm sklearn data split
from sklearn.model_selection import train_test_split

import matplotlib.pyplot as plt
#Methode zum Generieren einer Farbkarte
from matplotlib.colors import ListedColormap

#Japanisches Anzeigemodul von matplotlib
!pip install japanize-matplotlib
import japanize_matplotlib

Bereiten Sie die Daten vor

• Holen Sie sich die "Iris" aus dem Scikit-Learn-Datensatz.
• Es gibt 4 Merkmalsgrößen, die die Länge und Breite der "Blütenblätter" und "Gaku" der Iris messen. Es handelt sich um die Daten von insgesamt 150 Proben, die aus jeweils 3 Typen x 50 bestehen. Diese drei Typen entsprechen Gruppen.

⑵ Datenerfassung

iris = datasets.load_iris()

• Überprüfen Sie den Inhalt der Daten für jede der erklärenden Variablen (Merkmale) und objektiven Variablen (Typen).

#Erklärende Variable (Merkmalsbetrag)
print("Etikette:\n", iris.feature_names)
print("gestalten:\n", iris.data.shape)
print("Erste 10 Zeilen:\n", iris.data[0:10, :]) 

#Zielvariable (Typ)
print("Etikette:\n", iris.target_names)
print("gestalten:\n", iris.target.shape)
print("Vollanzeige:\n", iris.target)

⑶ Datenaufteilung

X_train, X_test, y_train, y_test = train_test_split(
    iris.data, 
    iris.target,
    stratify = iris.target, #Geschichtete Stichprobe
    random_state = 0)

• Das Argument stratify = iris.target gibt ** geschichtete Stichproben ** nach Typ (iris.target) an. Die Standardeinstellung ist die Zufallsstichprobe. Daher werden wir sie hier so aufteilen, dass drei Arten von Zusammensetzungsverhältnissen für Training und Test beibehalten werden.
• Überprüfen Sie den Inhalt nur der Zielvariablen für das Training.

print("gestalten:", y_train.shape)

#Holen Sie sich die Anzahl der eindeutigen Elemente
np.unique(y_train, return_counts=True)

• Standardmäßig sind 75% für das Training vorgesehen, und der Inhalt der 112 Proben ist gleichmäßig auf drei Typen verteilt.

Bestimmen Sie die Anzahl von k

⑷ Führen Sie k-NN aus, während Sie den Parameter k ändern

• Führen Sie k-NN aus, während Sie k von 3 auf 20 ändern, und beobachten Sie die Änderung der Genauigkeitsrate der Trainingsdaten und der Testdaten.

#Variable, die die Genauigkeitsrate speichert
training_accuracy = []
test_accuracy = []

#k beim Ändern von k-Führen Sie NN aus und erhalten Sie die richtige Antwortrate
for k in range(3,21):
    #Übergeben Sie k, um eine Instanz zu erstellen, die Daten anzupassen und ein Modell zu generieren
    kNN = KNeighborsClassifier(n_neighbors = k)
    kNN.fit(X_train, y_train)
    #Erhalten Sie die richtige Antwortrate mit Punktzahl und speichern Sie sie nacheinander
    training_accuracy.append(kNN.score(X_train, y_train))
    test_accuracy.append(kNN.score(X_test, y_test))

#Konvertieren Sie die Genauigkeitsrate in ein Numpy-Array
training_accuracy = np.array(training_accuracy)
test_accuracy = np.array(test_accuracy)

⑸ Wählen Sie den optimalen k-Parameter

• Visualisieren Sie die Änderung der richtigen Antwortrate zwischen den Trainingsdaten und den Testdaten und zeigen Sie den Unterschied in der richtigen Antwortrate in einem Diagramm.

#Änderungen der Genauigkeitsrate für Training und Test
plt.figure(figsize=(6, 4))

plt.plot(range(3,21), training_accuracy, label='Ausbildung')
plt.plot(range(3,21), test_accuracy, label='Prüfung')

plt.xticks(np.arange(2, 21, 1)) #x-Achsenskala
plt.xlabel('k Nummer')
plt.ylabel('Richtige Antwortrate')
plt.title('Übergang der richtigen Antwortrate')

plt.grid()
plt.legend()

#Übergang der Differenz in der richtigen Antwortrate
plt.figure(figsize=(6, 4))

difference = np.abs(training_accuracy - test_accuracy) #Berechnen Sie die Differenz
plt.plot(range(3,21), difference, label='Unterschied')

plt.xticks(np.arange(2, 21, 1)) #x-Achsenskala
plt.xlabel('k Nummer')
plt.ylabel('Unterschied(train - test)')
plt.title('Übergang der Differenz in der richtigen Antwortrate')

plt.grid()
plt.legend()

plt.show()

• Als ich k von 3 auf 20 änderte, war es im Test konstant bei 100%, außer dass es bei k = 14 abfiel.
• Andererseits zeigt es im Training eine allmähliche Anstiegstendenz von k = 3 auf 6, bleibt dann flach bis k = 11 und fällt bei k = 12 ab, aber danach zeigt es eine zunehmende Tendenz beim Steigen und Fallen und k = 15 ist der Peak. Es hat sich gedreht, um abzunehmen.
• Wenn Sie sich den Übergang der Differenz in der richtigen Antwortrate ansehen, können Sie auch sehen, dass die ** richtige Antwortrate ** des Trainings und des Tests bei k = 15 am nächsten ** liegt.

Führen Sie k-NN aus und visualisieren Sie es

⑹ Führen Sie k-NN mit dem optimalen k-Parameter erneut aus

• Nehmen Sie k = 15 an und führen Sie k-NN erneut aus.
• Hier werden nur die ersten beiden der vier Merkmalsgrößen verwendet.

#Geben Sie die Anzahl von k an
k = 15

#Stellen Sie die erklärende Variable X und die Zielvariable y ein
X = iris.data[:, :2]
y = iris.target

#Erstellen Sie eine Instanz, passen Sie die Daten an und generieren Sie ein Modell
model = KNeighborsClassifier(n_neighbors=k)
model.fit(X, y)

⑺ Auf Konturdiagramm zeichnen (Isoliniendiagramm)

• Erstellen Sie die Netzdaten "Z", um die Grenzen jeder Gruppe auf einer zweidimensionalen Ebene zu zeichnen.

#Geben Sie den Netzabstand an
h = 0.02

#Erstellen Sie eine Farbkarte
cmap_surface = ListedColormap(['darkseagreen', 'mediumpurple', 'gold']) #Für Oberflächendiagramm
cmap_dot = ListedColormap(['darkgreen', 'darkslateblue', 'olive']) #Zum Streuzeichnen

# x,Ermitteln Sie die Minimal- und Maximalwerte der y-Achse
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
#Generieren Sie Rasterspalten in festgelegten Netzintervallen
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                     np.arange(y_min, y_max, h))

#Vorhersage durch Übergabe der Gittersequenz an das Modell
Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape) #Formkonvertierung

• Reduzieren Sie die Gittersequenzdaten von "xx" und "yy" mit der Funktion "ravel ()" auf eine Dimension und übergeben Sie sie an das Modell, um vorherzusagen, was mit der Funktion "c_ ()" von numpy kombiniert wird.
• Als Beispiel wird Z angezeigt, wenn der Maschenabstand auf 0,8 erweitert wird.

• Auf diese Weise sind Z Daten mit Typ- (Gruppen-) Informationen für jede Zelle, die in bestimmten Intervallen vernetzt ist.
• Zeichnen Sie darauf basierend ein Konturdiagramm (Isoliniendiagramm) und zeichnen Sie gleichzeitig einzelne Daten.

plt.figure(figsize=(6,5))

#Diagramm isolieren
plt.pcolormesh(xx, yy, Z, cmap=cmap_surface)
#Streudiagramm
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=cmap_dot, s=30)

plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.xlabel('sepal length')
plt.ylabel('sepal width')

plt.show()

• Die Funktion pcolormesh () von matplotlib erzeugt ein Farbdiagramm basierend auf einem unregelmäßigen rechteckigen Raster.
• Wenn das Argument einfach "(x, y, Z, c)" ist, sind "x, y" von links die Koordinaten des Netzes. Den Daten "Z", die Gruppeninformationen für jede Zelle enthalten, wird eine Farbe mit "c" zugewiesen.

Nachwort

• In diesem Beispiel sind die Gruppen 1 und 2 verschachtelt, und Sie können einen Sprungpunkt sehen. Wenn jedoch die Analyseachse (Kombination von Merkmalsgrößen) geändert wird, unterscheidet sich das Erscheinungsbild der Karte erheblich, und sowohl der vorhergesagte Bereich als auch die Daten werden klar zwischen den Gruppen aufgeteilt. Eine effektivere Analyseachse kann visuell erfasst werden.
• Als Verfahren ist es wichtig, zuerst den optimalen Wert von k zu bestimmen.