Was ich getan habe

Siehe [Tutorial] von Scikit Learn (http://scikit-learn.org/stable/auto_examples/neighbors/plot_classification.html#example-neighbors-plot-classification-py) --Verwenden eines beschrifteten Datensatzes
Ändern Sie den Wert und das Gewicht von k
Implementierte k-Nachbarschaftsmethode in Python

Beispieldaten importieren

Verwenden Sie den Iris-Datensatz. Die Eingabedaten sind 4 Dimensionen, aber nur die ersten 2 Dimensionen werden zur einfachen Visualisierung verwendet.

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline 
from matplotlib.colors import ListedColormap
from sklearn import neighbors, datasets, metrics

iris = datasets.load_iris() #4D mit einem Datensatz von 150 Proben
                            #Die Länge und Breite des Gaku der Pflanze, die Länge und Breite der Blütenblätter und die Einheit sind cm.
iris_X = iris.data[:, :2]  #Verwenden Sie nur die ersten zweidimensionalen Merkmale der vier Dimensionen
iris_y = iris.target #Richtiges Antwortetikett, 0, 1,3 Arten von 2

Unterteilt in Lehrerdaten und Testdaten

np.random.seed(0) #Zufällige Starteinstellung, es muss nicht 0 sein
indices = np.random.permutation(len(iris_X)) # 0~Sortieren Sie 149 Zahlen nach dem Zufallsprinzip
#Teilen Sie 140 Datensätze in 105 Lehrerdaten und 35 Testdaten
iris_X_train = iris_X[indices[:-35]]
iris_y_train = iris_y[indices[:-35]]
iris_X_test = iris_X[indices[-35:]]
iris_y_test = iris_y[indices[-35:]]

Erstellen einer Farbkarte

Erstellen Sie 3 Farben entsprechend der Anzahl der richtigen Beschriftungen. Es gibt zwei, eine für Lehrerdaten (cmap_bold) und eine für Trainingsergebnisse (cmap_light).

cmap_light = ListedColormap(['#FFAAAA', '#AAFFAA', '#AAAAFF'])
cmap_bold = ListedColormap(['#FF0000', '#00FF00', '#0000FF'])

Variable Einstellungen

Der diesmal verwendete Klassifikator ist KNeighbors Classifier. Das k der Variablen ist das wichtigste, und die k Daten, die den Probendaten am nächsten liegen, gehören zu welchem Label, und die Labels der Probendaten werden mit Stimmenmehrheit klassifiziert. Der Standardwert ist 5. Die andere Variable "Gewichte", die wir dieses Mal diskutieren werden, hat zwei Werte, "einheitlich" und "Abstand".

--uniform: Gibt unabhängig vom Abstand zwischen den Daten ein einheitliches Gewicht. Dies ist die Standardeinstellung. --distance: Die Gewichte werden umgekehrt proportional zur Entfernung angegeben. Je näher die Entfernung ist, desto größer ist der Effekt.

Es gibt andere Variablen wie den Algorithmus. Weitere Informationen finden Sie hier (http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.RadiusNeighborsClassifier.html#sklearn.neighbors.RadiusNeighborsClassifier).

h = 0.1 #Maschenweite
k_list = [1, 5, 10, 30] #Anzahl von k
weights_list =['uniform', 'distance']
score = np.zeros((len(k_list)*2,5)) # score

Lernen und Visualisieren von Ergebnissen

Da es sich bei der Eingabe um zweidimensionale Daten handelt, versuchen Sie, die Klassifizierungsgrenze mit einer Farbkarte anzuzeigen.

plt.figure(figsize=(8*len(k_list), 12))
i = 1 #Für Nebenhandlung
for weights in weights_list:
    for k in k_list:
        clf = neighbors.KNeighborsClassifier(k, weights=weights)
        clf.fit(iris_X_train, iris_y_train)
        x1_min, x1_max = iris_X[:, 0].min() - 1, iris_X[:, 0].max() + 1 #Holen Sie sich das Minimum und Maximum der ersten Dimension von X.
        x2_min, x2_max = iris_X[:, 1].min() - 1, iris_X[:, 1].max() + 1 #Holen Sie sich das Minimum und Maximum der zweiten Dimension von X.
        # x1_von min bis x1_bis max, x2_von min bis x2_Erzeugt ein gleichmäßig verteiltes Gitterarray in h-Schritten bis zu max
        xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, h), np.arange(x2_min, x2_max, h))
        #Vorhersage für jeden Punkt im Netz/ .ravel()Mit np in ein eindimensionales Array konvertieren.c_[]In xx1,Kombiniere xx2 alle xx2
        Z = clf.predict(np.c_[xx1.ravel(), xx2.ravel()])
        Z = Z.reshape(xx1.shape) #Formatänderung arrangieren
        plt.subplot(2,len(k_list),i) #2 Zeilen x k_Im i-ten Diagramm des Diagramms in der Listenspalte
        plt.pcolormesh(xx1, xx2, Z, cmap=cmap_light) #Zeichnen Sie die Lernergebnisse
        plt.scatter(iris_X_train[:, 0], iris_X_train[:, 1], c=iris_y_train, cmap=cmap_bold) #Plotten Sie Lehrerdaten
        plt.scatter(iris_X_test[:, 0], iris_X_test[:, 1], c=iris_y_test, cmap=cmap_light) #Plotten Sie die Testdaten
        plt.xlim(xx1.min(), xx1.max())
        plt.ylim(xx2.min(), xx2.max())
        plt.title("k = %i, weights = '%s'" % (k, weights), fontsize=30)
        score[i-1,3] = k
        score[i-1,0] = metrics.f1_score(iris_y_test, clf.predict(iris_X_test),average='weighted')
        score[i-1,1] = metrics.precision_score(iris_y_test, clf.predict(iris_X_test))
        score[i-1,2] = metrics.recall_score(iris_y_test,clf.predict(iris_X_test))
        i = i + 1
plt.show

Das Ergebnis sieht so aus. Wenn der obere Teil des Diagramms gleichmäßig ist und der untere Teil der Abstand ist. Je weiter links, desto größer wird k. Es ist wunderbar, es visualisieren zu können.

Wenn k klein ist, neigt es dazu, überlernt zu werden.
Entfernung scheint plausibler zu sein ――Aber Betrachtung des f-Wertes ist Uniform besser
Wenn k = 1 ist, ist das Ergebnis das gleiche, unabhängig davon, welches Gewicht verwendet wird.

Zeichnen wir den f-Wert der Testdaten für die grafische Praxis.

plt.figure(figsize=(10, 4))
i = 0
for weights in weights_list:
    plt.subplot(1,2,i+1)
    plt.plot(score[i*len(k_list):(i+1)*len(k_list),0])
    plt.plot(score[i*len(k_list):(i+1)*len(k_list),1])
    plt.plot(score[i*len(k_list):(i+1)*len(k_list),2])
    plt.xticks([0,1,2,3],k_list)
    plt.ylim(score[:,:3].min()-0.05, 1.05)
    plt.title("weights = %s" % weights)
    plt.legend(('f1', 'prec', 'recall'), loc='upper right')
    plt.xlabel("k_neighbors")
    plt.ylabel("f1, prec, recall")
    i = i + 1
plt.show

Dieses Mal habe ich die Anzahl der Features zur Visualisierung auf zwei reduziert, aber ich würde gerne sehen, ob eine Erhöhung der Anzahl der Features die Genauigkeit verbessern und gleichzeitig das Überlernen unterdrücken kann.