Ce que j'ai fait

Reportez-vous au [Tutoriel] de Scikit learn (http://scikit-learn.org/stable/auto_examples/neighbors/plot_classification.html#example-neighbors-plot-classification-py) --Utilisation d'un ensemble de données étiqueté --Modifier la valeur et le poids de k
Méthode k-voisinage implémentée en python

Importer des exemples de données

Utilisez le jeu de données iris. Les données d'entrée sont de 4 dimensions, mais seules les 2 premières dimensions sont utilisées pour une visualisation facile.

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, avec un ensemble de données de 150 échantillons
                            #La longueur et la largeur du gaku de la plante, la longueur et la largeur des pétales et l'unité sont en cm.
iris_X = iris.data[:, :2]  #Utilisez uniquement les premières caractéristiques bidimensionnelles des quatre dimensions
iris_y = iris.target #Étiquette de réponse correcte, 0, 1,3 types de 2

Divisé en données de l'enseignant et données de test

np.random.seed(0) #Paramètre de départ aléatoire, il n'est pas nécessaire que ce soit 0
indices = np.random.permutation(len(iris_X)) # 0~Trier au hasard 149 numéros
#Divisez 140 ensembles de données en 105 données d'enseignants et 35 données de test
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:]]

Créer une carte de couleurs

Créez 3 couleurs en fonction du nombre d'étiquettes correctes. Il y en a deux, un pour les données de l'enseignant (cmap_bold) et un pour les résultats de la formation (cmap_light).

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

Paramètres variables

Le classificateur utilisé cette fois est KNeighbors Classifier. Le k de la variable est le plus important, et les k données les plus proches des données de l'échantillon appartiennent à quelle étiquette, et les étiquettes des données de l'échantillon sont classées par le vote majoritaire. La valeur par défaut est 5. Il existe deux variables, «uniforme» et «distance», pour les «poids», qui est une autre variable dont nous discuterons cette fois.

--uniform: donne un poids uniforme quelle que soit la distance entre les données. C'est la valeur par défaut. --distance: les poids sont donnés en proportion inverse de la distance de sorte que plus la distance est proche, plus l'effet est grand.

Il existe d'autres variables telles que l'algorithme. Pour plus d'informations, cliquez ici (http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.RadiusNeighborsClassifier.html#sklearn.neighbors.RadiusNeighborsClassifier).

h = 0.1 #Mesh taille
k_list = [1, 5, 10, 30] #Nombre de k
weights_list =['uniform', 'distance']
score = np.zeros((len(k_list)*2,5)) # score

Apprentissage et visualisation des résultats

Étant donné que l'entrée est des données bidimensionnelles, essayez d'afficher la limite de classification avec une carte de couleurs.

plt.figure(figsize=(8*len(k_list), 12))
i = 1 #Pour la sous-parcelle
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 #Obtenez le minimum et le maximum de la première dimension de X
        x2_min, x2_max = iris_X[:, 1].min() - 1, iris_X[:, 1].max() + 1 #Obtenez le minimum et le maximum de la deuxième dimension de X
        # x1_de min à x1_jusqu'à max, x2_de min à x2_Génère des matrices de grille régulièrement espacées par incréments de h jusqu'à max.
        xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, h), np.arange(x2_min, x2_max, h))
        #Prédiction pour chaque point du maillage/ .ravel()Convertir en un tableau à une dimension avec np.c_[]Dans xx1,Combinez xx2 tous les xx2
        Z = clf.predict(np.c_[xx1.ravel(), xx2.ravel()])
        Z = Z.reshape(xx1.shape) #Organiser le changement de format
        plt.subplot(2,len(k_list),i) #2 lignes x k_Dans le i-ème graphique du graphique dans la colonne de liste
        plt.pcolormesh(xx1, xx2, Z, cmap=cmap_light) #Tracer les résultats d'apprentissage
        plt.scatter(iris_X_train[:, 0], iris_X_train[:, 1], c=iris_y_train, cmap=cmap_bold) #Tracer les données des enseignants
        plt.scatter(iris_X_test[:, 0], iris_X_test[:, 1], c=iris_y_test, cmap=cmap_light) #Tracer les données de test
        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

Le résultat ressemble à ceci. Lorsque la partie supérieure du graphique est uniforme et la partie inférieure est la distance. Plus on est à gauche, plus k devient grand. C'est merveilleux de pouvoir le visualiser.

Si k est petit, il a tendance à être surappris.
la distance semble plus plausible ――Mais en regardant la valeur f, l'uniformité est meilleure --Lorsque k = 1, le résultat est le même quel que soit le poids utilisé.

Tracez la valeur f des données de test pour pratiquer la représentation graphique.

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

Cette fois, j'ai réduit le nombre de fonctionnalités à deux pour la visualisation, mais j'aimerais voir si l'augmentation du nombre de fonctionnalités peut améliorer la précision tout en supprimant le surapprentissage.