2. Analyse multivariée expliquée dans Python 8-1. Méthode de voisinage k (scikit-learn)

• Il existe plusieurs groupes et les attributs des groupes d'échantillons qui leur appartiennent sont connus, et lorsqu'un autre ** nouvel échantillon est ajouté, c'est ** k-NN pour savoir à quel groupe il appartient **. (K-Nearest Neighbor: méthode de voisinage k) **.
• Plus précisément, il s'agit d'une méthode de classification dans laquelle ** K pièces avec des attributs similaires à ceux du nouvel échantillon ** sont obtenues à partir du groupe d'échantillons existant et déterminées comme étant le groupe majoritaire parmi eux. C'est pourquoi ces ** k ** pièces sont appelées ** k-NN **.

• Si k = 3, il sera jugé comme un groupe bleu, et si k = 12, il sera classé comme un groupe vert, donc le jugement différera en fonction du nombre de k.

** Peut également être utilisé pour la régression, mais ici nous allons faire un cas de classification. ** **

⑴ Bibliothèque d'importation

import numpy as np
import pandas as pd

from sklearn import datasets
# sklearn.module de voisins k-Méthode NN
from sklearn.neighbors import KNeighborsClassifier
#utilitaire de fractionnement de données sklearn
from sklearn.model_selection import train_test_split

import matplotlib.pyplot as plt
#Méthode pour générer une carte de couleurs
from matplotlib.colors import ListedColormap

#Module d'affichage japonais de matplotlib
!pip install japanize-matplotlib
import japanize_matplotlib

Préparez les données

• Obtenez le "iris" de l'ensemble de données scikit-learn.
• Il y a 4 grandeurs de caractéristiques qui mesurent la longueur et la largeur des "pétales" et "gaku" des iris, et ce sont les données d'un total de 150 échantillons composés de 3 types x 50 chacun. Ces trois types correspondent à des groupes.

⑵ Acquisition de données

iris = datasets.load_iris()

• Vérifiez le contenu des données pour chacune des variables explicatives (caractéristiques) et des variables objectives (types).

#Variable explicative (montant de la fonction)
print("étiquette:\n", iris.feature_names)
print("forme:\n", iris.data.shape)
print("10 premières lignes:\n", iris.data[0:10, :]) 

#Variable objective (type)
print("étiquette:\n", iris.target_names)
print("forme:\n", iris.target.shape)
print("Affichage complet:\n", iris.target)

⑶ Division des données

X_train, X_test, y_train, y_test = train_test_split(
    iris.data, 
    iris.target,
    stratify = iris.target, #Échantillonnage stratifié
    random_state = 0)

• L'argument stratify = iris.target spécifie ** l'échantillonnage stratifié ** par type (iris.target). La valeur par défaut est l'échantillonnage aléatoire, nous allons donc le diviser ici pour qu'il conserve trois types de ratios de composition pour l'entraînement et les tests.
• Vérifiez uniquement le contenu de la variable objective pour la formation.

print("forme:", y_train.shape)

#Obtenez le nombre d'éléments uniques
np.unique(y_train, return_counts=True)

• Par défaut, 75% sont alloués à la formation et le contenu des 112 échantillons est uniformément réparti entre 3 types.

Déterminez le nombre de k

⑷ Exécutez k-NN tout en modifiant le paramètre k

• Exécutez k-NN en changeant k de 3 à 20 et observez le changement du taux de précision des données d'entraînement et des données de test.

#Variable qui stocke le taux de précision
training_accuracy = []
test_accuracy = []

#k en changeant k-Exécutez NN et obtenez le taux de réponse correct
for k in range(3,21):
    #Passez k pour créer une instance, ajuster les données et générer un modèle
    kNN = KNeighborsClassifier(n_neighbors = k)
    kNN.fit(X_train, y_train)
    #Obtenez le taux de réponse correct avec le score et stockez-le séquentiellement
    training_accuracy.append(kNN.score(X_train, y_train))
    test_accuracy.append(kNN.score(X_test, y_test))

#Convertir le taux de précision en tableau numpy
training_accuracy = np.array(training_accuracy)
test_accuracy = np.array(test_accuracy)

⑸ Sélectionnez le paramètre k optimal

• Visualisez le changement du taux de réponse correct entre les données d'entraînement et les données de test, et montrez la différence du taux de réponse correct dans un graphique.

#Modifications du taux de précision pour la formation et les tests
plt.figure(figsize=(6, 4))

plt.plot(range(3,21), training_accuracy, label='Entraînement')
plt.plot(range(3,21), test_accuracy, label='tester')

plt.xticks(np.arange(2, 21, 1)) #échelle de l'axe des x
plt.xlabel('nombre k')
plt.ylabel('Taux de réponse correct')
plt.title('Transition du taux de réponse correcte')

plt.grid()
plt.legend()

#Transition de la différence de taux de réponse correcte
plt.figure(figsize=(6, 4))

difference = np.abs(training_accuracy - test_accuracy) #Calculez la différence
plt.plot(range(3,21), difference, label='Différence')

plt.xticks(np.arange(2, 21, 1)) #échelle de l'axe des x
plt.xlabel('nombre k')
plt.ylabel('Différence(train - test)')
plt.title('Transition de la différence de taux de réponse correcte')

plt.grid()
plt.legend()

plt.show()

• Quand j'ai changé k de 3 à 20, dans le test, il était constant à 100% sauf qu'il a chuté à k = 14.
• Par contre, en entraînement, il montre une tendance à l'augmentation progressive de k = 3 à 6, puis il reste plat jusqu'à k = 11, et il tombe à k = 12, mais après cela, il montre une tendance croissante en montant et en descendant, et k = 15 est le pic. Il s'est tourné vers la diminution.
• De plus, si vous regardez la transition de la différence dans le taux de réponse correct, vous pouvez voir que le ** taux de réponse correct ** de la formation et du test est le plus proche ** à k = 15.

Exécuter et visualiser k-NN

⑹ Réexécuter k-NN avec le paramètre k optimal

• Adoptez k = 15 et exécutez à nouveau k-NN.
• Ici, seules les deux premières des quatre quantités de caractéristiques seront utilisées.

#Spécifiez le nombre de k
k = 15

#Définir la variable explicative X et la variable objective y
X = iris.data[:, :2]
y = iris.target

#Créer une instance, ajuster les données et générer un modèle
model = KNeighborsClassifier(n_neighbors=k)
model.fit(X, y)

⑺ Tracé sur diagramme de contour (diagramme isoligne)

• Créez des données de maillage Z pour dessiner les limites de chaque groupe sur un plan bidimensionnel

#Spécifier l'espacement du maillage
h = 0.02

#Créer une carte de couleurs
cmap_surface = ListedColormap(['darkseagreen', 'mediumpurple', 'gold']) #Pour le graphique de surface
cmap_dot = ListedColormap(['darkgreen', 'darkslateblue', 'olive']) #Pour le dessin dispersé

# x,Obtenez les valeurs minimale et maximale de l'axe des y
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
#Générer des colonnes de grille à des intervalles de maillage spécifiés
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                     np.arange(y_min, y_max, h))

#Prédire en passant la séquence de grille au modèle
Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape) #Conversion de forme

• Aplatissez les données de séquence de grille de xx et yy à une dimension avec la fonctionravel (), et transmettez-la au modèle pour prédire ce qui est combiné avec la fonctionc_ ()de numpy.
• À titre d'exemple, Z s'affiche lorsque l'espacement du maillage est étendu à 0,8.

• De cette manière, Z correspond aux données contenant des informations de type (groupe) pour chaque cellule maillée à des intervalles spécifiés.
• Sur cette base, dessinez un diagramme de contour (diagramme isoligne) et tracez les données individuelles en même temps.

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

#Isoler le diagramme
plt.pcolormesh(xx, yy, Z, cmap=cmap_surface)
#Nuage de points
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()

• La fonction pcolormesh () de matplotlib produit un tracé de couleur basé sur une grille rectangulaire irrégulière.
• Si l'argument est simplement «(x, y, Z, c)», «x, y» à gauche sont les coordonnées du maillage. Les données «Z», qui ont des informations de groupe pour chaque cellule, reçoivent une couleur avec «c».

Épilogue

• Dans cet exemple, les groupes 1 et 2 sont entrelacés et vous pouvez voir un point de saut. Cependant, si l'axe d'analyse (combinaison de quantités d'entités) est modifié, l'apparence de la carte sera significativement différente et la zone prévue et les données seront clairement réparties entre les groupes. Un axe d'analyse plus efficace peut être saisi visuellement.
• En guise de procédure, il est important de déterminer d'abord la valeur optimale de k.