2. Analyse multivariée expliquée dans Python 8-2. Méthode de voisinage k [méthode de pondération] [modèle de retour]

• La méthode k-voisinage a deux fonctions de pondération (méthodes de pondération) utilisées pour la prédiction.

• ** uniforme: avec un poids uniforme, tous les points proches sont pondérés de manière égale. ** **
• ** distance: pondère les points comme l'inverse de la distance. Par conséquent, les points proches ont plus d'influence que les points distants. ** **

• La valeur par défaut est uniforme, vous devez donc la passer comme argument lors de la création d'une instance pour la rendre éloignée.

** Comment ces différences affectent-elles les résultats des prévisions? ** ** Le cas du modèle de classification de Dernière fois est présenté à titre d'exemple.

• Les limites sont légèrement différentes, mais il y a une nette différence surtout dans les cercles rouges.
• En général, la distance est plus fidèlement délimitée par rapport aux données.

** De plus, je voudrais comparer dans le cas du modèle de régression. ** **

⑴ Bibliothèque d'importation

import numpy as np
import pandas as pd

# scikit-apprendre la bibliothèque
from sklearn.datasets import load_boston             #Ensemble de données sur les prix des maisons de Boston
from sklearn.model_selection import train_test_split #Utilitaire de fractionnement de données
from sklearn.neighbors import KNeighborsRegressor    # k-Méthode du modèle de régression NR

#Bibliothèque de visualisation
import matplotlib.pyplot as plt
import seaborn as sns

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

• La méthode k-voisinage est principalement utilisée comme modèle de classification sous le nom de k-NN (k-Nearest Neighbor), mais dans le module voisins de scikit-learn, le ** modèle de régression est la méthode KNeighborsRegressor **.

1. Préparez les données

• Obtenez "Boston" à partir de l'ensemble de données scikit-learn.
• Un total de 506 ensembles de données d'échantillons avec 13 informations sur les attributs tels que le taux de criminalité, le nombre moyen de chambres par unité et l'accès au trafic comme variables explicatives, avec le «prix de l'immobilier» dans la grande ville de Boston, dans le nord-est du Massachusetts, comme variable objective.

⑵ Acquisition et organisation des données

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

#Convertir les variables explicatives en DataFrame
df = pd.DataFrame(boston.data, columns=boston.feature_names)

#Concaténer les variables objectives
df = pd.concat([df, pd.DataFrame(boston.target, columns=['MEDV'])], axis=1)
print(df)

• La colonne la plus à droite «MEDV» est une abréviation de valeur médiane, qui correspond à la variable objective (prix de l'immobilier) définie comme «la valeur médiane de posséder une maison de l'ordre de 1 000 $».
• Il y a 13 variables explicatives au total, de la colonne la plus à gauche «CRIM (taux de criminalité): taux de criminalité» à «LSTAT (statut inférieur): rapport de classe inférieure», mais par souci de simplicité, nous ne sélectionnerons qu'une seule variable. Je vais.

(3) Examen de l'axe d'analyse par matrice de corrélation

• Créez une matrice de corrélation entre toutes les variables et concentrez-vous sur les variables qui sont fortement corrélées avec le prix du logement.

#Créer une matrice de corrélation
correlation_matrix = np.corrcoef(df.T)

#Libellé de ligne / colonne
names = ['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 
         'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV']

#Convertir la matrice de corrélation en DataFrame
correlation_df = pd.DataFrame(correlation_matrix, columns = names, index = names)

#Dessinez une carte thermique
plt.figure(figsize=(10,8))
sns.heatmap(correlation_df, annot=True, cmap='coolwarm')

• La fonction corrcoef () de Numpy est utilisée pour la matrice de corrélation, mais la corrélation entre les variables est calculée en transposant les lignes et les colonnes des données passées avec .T.
• Seaborn est utilisé pour la carte thermique. L'argument ʻannot = True de heatmap () `affiche la valeur de chaque cellule de la figure.

• En tant que variables qui montrent une forte corrélation avec le prix de l'immobilier (MEDV), le «rapport des classes inférieures (LSTAT)» montre une forte corrélation négative à -0,74 et le «nombre moyen de chambres par unité (RM)» est fortement positif à 0,70. Affiche la corrélation de.
• Habituellement, plus le nombre de chambres est élevé, plus le prix est élevé, et dans les zones avec de nombreux groupes à faible revenu, le prix du marché sera bas. Nous adopterons simplement le "nombre moyen de chambres par unité (RM)".

⑷ Extraction et division des données

#Extraire seulement 2 variables
df_extraction = df[['RM', 'MEDV']]

#Variable X,définir y
X = np.array(df_extraction['RM'])
y = np.array(df_extraction['MEDV'])

X = X.reshape(len(X), 1) #Convertir en 2D
y = y.reshape(len(y), 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)

X_train = X_train.reshape(len(X_train), 1) #Convertir en 2D
X_test = X_test.reshape(len(X_test), 1)
y_train = y_train.reshape(len(y_train), 1)
y_test = y_test.reshape(len(y_test), 1)

• Extraire uniquement la variable explicative «RM» et la variable objectif «MEDV», et les diviser en variables X et y pour la formation et les tests, respectivement.

2. Examen du paramètre k

⑸ Exécutez k-NR tout en modifiant le paramètre k

• Exécutez k-NR en changeant k de 1 à 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
train_accuracy = []
test_accuracy = []

for k in range(1,21):
    kNR = KNeighborsRegressor(n_neighbors = k) #Génération d'instance
    kNR.fit(X_train, y_train) #Apprentissage
    train_accuracy.append(kNR.score(X_train, y_train)) #Taux de précision de la formation
    test_accuracy.append(kNR.score(X_test, y_test)) #Taux d'exactitude des tests

#Convertir le taux de réponse correct en tableau
training_accuracy = np.array(train_accuracy)
test_accuracy = np.array(test_accuracy)

⑹ Sélectionnez le paramètre k optimal

• Visualisez les changements du taux de précision entre la formation et les tests, et montrez la différence de taux de précision dans un graphique.

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

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

plt.xticks(np.arange(0, 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(train_accuracy - test_accuracy) #Calculez la différence
plt.plot(range(1,21), difference, label='Différence')

plt.xticks(np.arange(0, 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()

• Au fur et à mesure que k augmente, le taux de précision de l'entraînement diminue, et inversement, le nombre de tests augmente, mais les deux sont presque plats à partir d'environ k = 9.
• En regardant la différence, k = 14 sera adopté car il diminue progressivement jusqu'à k = 14.

3. Exécution et évaluation du modèle

• Créez des données factices à utiliser pour la prédiction.

⑺ Créer des données factices

#Générer une séquence d'égalité
t = np.linspace(1, 10, 1000) #Valeur de départ,Valeur finale,Nombre d'éléments

#Convertir la forme en 2D
T = t.reshape(1000, 1)

⑻ Exécution et visualisation du modèle de régression

n_neighbors = 14

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

for i, w in enumerate(['uniform', 'distance']):
    model = KNeighborsRegressor(n_neighbors, weights=w)
    model = model.fit(X, y)
    y_ = model.predict(T)

    plt.subplot(1, 2, i + 1)
    plt.scatter(X, y, color='limegreen', label='Les données')
    plt.plot(T, y_, color='navy', lw=1, label='Valeur prédite')
    plt.legend()
    plt.title("weights = '%s'" % (w))

plt.tight_layout()
plt.show()

• tight_layout () ajuste automatiquement les paramètres du sous-tracé (échelle de l'axe, étiquette de l'axe, plage de titre) afin que le sous-tracé s'adapte parfaitement à la zone du graphique.

• À première vue, vous pouvez voir que la distance change considérablement dans la valeur prévue et que les données sont surajustées.
• D'un autre côté, uniforme est capable de résumer les informations, et il n'est pas étonnant que la valeur par défaut soit uniforme.