2. Analyse multivariée énoncée dans Python 8-3. Méthode de voisinage K [vérification d'intersection]

Le précédent a capturé visuellement la différence entre les ** deux types de fonctions de pondération uniforme et distance ** dans la méthode * k-voisinage.

import numpy as np
import pandas as pd

#bibliothèques basées sur sklearn
from sklearn import datasets #base de données
from sklearn.model_selection import train_test_split #Répartition des données
from sklearn.neighbors import KNeighborsClassifier #Modèle de classification
from sklearn.neighbors import KNeighborsRegressor #Modèle de régression

#bibliothèques basées sur matplotlib
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap

!pip install japanize-matplotlib #Module compatible avec l'affichage japonais
import japanize_matplotlib

Modèle de retour-Prix de la maison à Boston-

⑴ Création de données

#Obtenir l'ensemble de données
boston = datasets.load_boston()

#Extraire les variables explicatives et les variables objectives
X = boston.data[:, 5].reshape(len(boston.data), 1)
y = (boston.target).reshape(len(boston.target), 1)

#Division des données pour la formation / les tests
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 0)

⑵ Vérification croisée

#paramètre k
n_neighbors = 14

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

for w in ['uniform', 'distance']:
    #Génération de modèle
    model = KNeighborsRegressor(n_neighbors, weights=w)
    model = model.fit(X_train, y_train)

    #Taux de réponse correct des données d'entraînement
    r_train = model.score(X_train, y_train)
    score.append(r_train)

    #Taux de réponse correct des données de test
    r_test = model.score(X_test, y_test)    
    score.append(r_test)

#Représenté dans un bloc de données
score = np.array(score)
pd.DataFrame(score.reshape(2,2), 
             columns = ['train', 'test'],
             index = ['uniform', 'distance'])

image.png

⑶ Visualisation

#paramètre k
n_neighbors = 14

#Génération d'instance
model_u = KNeighborsRegressor(n_neighbors, weights='uniform')
model_d = KNeighborsRegressor(n_neighbors, weights='distance')

#Génération de modèle
model_u = model_u.fit(X_train, y_train)
model_d = model_d.fit(X_train, y_train)

#Prévoir
y_u = model_u.predict(X_test)
y_d = model_d.predict(X_test)

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

#Nuage de points
plt.scatter(X_test, y_u, color='slateblue', lw=1, label='Valeur prédite(uniform)')
plt.scatter(X_test, y_d, color='tomato', lw=1, label='Valeur prédite(distance)')
plt.scatter(X_test, y_test, color='lightgrey', label='La valeur de mesure(test)')

plt.legend(fontsize=15)
plt.xlim(3, 9.5)
plt.show()

image.png

Modèle de classification-longueur et largeur des pièces d'iris-

  • L'ensemble de données "iris" attaché à sklearn est utilisé, mais comme nous voulons simplifier le problème, nous restreignons la variable objectif "type" à seulement deux (versicolour = 1, virginica = 2) et la classons comme binaire. ..
  • Dans ces deux types, il est difficile de séparer les limites car les individus sont mélangés dans les deux variables données. Sachant cela, observez la différence entre uniforme et distance.

⑴ Création de données

#Obtenir l'ensemble de données
iris = datasets.load_iris()

#Extraire uniquement les variables explicatives et les variables objectives
X = iris.data[:, :2]
y = iris.target
y = y.reshape(-1, 1) #Conversion de forme

#Définissez chaque variable après avoir extrait seulement 2 valeurs
data = np.hstack([X, y]) # X,Combinez y
data = data[data[:, 2] != 0] #Extraire seulement 2 valeurs
X = data[:, :2]
y = data[:, -1]

#Répartition des données
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify = y, random_state = 0)

⑵ Vérification croisée

  • Le paramètre k (nombre de k) est mis à 15 à la suite du précédent.
#paramètre k
n_neighbors = 15

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

for i, w in enumerate(['uniform', 'distance']):
    #Génération de modèle
    model = KNeighborsClassifier(n_neighbors, weights=w)
    model = model.fit(X_train, y_train)

    #Données d'entraînement
    r_train = model.score(X_train, y_train)
    score.append(r_train)

    #données de test
    r_test = model.score(X_test, y_test)    
    score.append(r_test)

#Représenté dans un bloc de données
score = np.array(score)
pd.DataFrame(score.reshape(2,2), 
             columns = ['train', 'test'],
             index = ['uniform', 'distance'])

image.png

  • L'uniforme est de 74,7% pour les données d'entraînement et de 60,0% pour les données de test.
  • D'autre part, la distance est un taux élevé de 92,0% dans les données d'entraînement, ce qui correspond à une diminution de 40% des données de test à 52,0%.

⑶ Visualisation

  • L'espacement du maillage transmis au modèle pour prédire la limite est également de 0,02, ce qui est le même que Dernière fois.
#paramètre k
n_neighbors = 15

#Espacement des mailles
h = 0.02

#Générer une carte de couleurs pour le mappage
cmap_surface = ListedColormap(['mistyrose', 'lightcyan'])
cmap_dot = ListedColormap(['tomato', 'slateblue'])
  • Transmettez les mêmes données de test à deux modèles dont les fonctions de poids sont uniformes et la distance, respectivement, génèrent une limite et y tracent les données de test mesurées.
plt.figure(figsize=(18,6))

for j, w in enumerate(['uniform', 'distance']):
    #Générer un modèle
    model = KNeighborsClassifier(n_neighbors, weights = w)
    model = model.fit(X_train, y_train)

    #Définir les données de test
    X, y = X_test, y_test

    # 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 = np.c_[xx.ravel(), yy.ravel()] #Aplatir à une dimension, puis joindre
    Z = model.predict(z) #Prévoir
    Z = Z.reshape(xx.shape) #Conversion de forme

    #dessin
    plt.subplot(1, 2, j + 1)
    plt.pcolormesh(xx, yy, Z, cmap=cmap_surface) #Tracé de couleur
    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('La longueur de la pièce', fontsize=12)
    plt.ylabel('Largeur de la pièce', fontsize=12)
    plt.title("'%s'" % (w), fontsize=18)

plt.show()

image.png

  • Le modèle de distance a des limites compliquées en raison du surentraînement dans les données d'entraînement, et il y a des taches partout, mais elles ne correspondent pas aux données de test et n'ont aucun sens.
  • L'idée d'uniformité est que la relation de position est constante (toujours constante) et que la distance entre eux est considérée comme accidentelle (cela s'est produit).
  • Il semble que la distance, qui saisit ces contingences en tant qu'informations et reflète fortement les caractéristiques des données, ne convient pas à la génération de modèles qui nécessite une généralité.

Recommended Posts