Die k-Nachbarschaftsmethode verfügt über zwei Gewichtungsfunktionen (Gewichtungsmethoden), die zur Vorhersage verwendet werden.

** einheitlich: Bei einheitlichem Gewicht werden alle Punkte in der Nähe gleich gewichtet. ** ** **
** Entfernung: Gewichtet die Punkte als Umkehrung der Entfernung. Daher haben Nahpunkte mehr Einfluss als Fernpunkte. ** ** **

Die Standardeinstellung ist einheitlich, daher müssen Sie sie beim Erstellen einer Instanz als Argument übergeben, um die Entfernung zu erhöhen.

** Wie wirken sich diese Unterschiede auf die Prognoseergebnisse aus? ** ** ** Der Fall des Klassifizierungsmodells von Last time wird als Beispiel gezeigt.

Die Grenzen sind leicht unterschiedlich, aber es gibt einen deutlichen Unterschied, insbesondere in den roten Kreisen.
Im Allgemeinen wird die Entfernung genauer zu den Daten abgegrenzt.

** Außerdem möchte ich im Fall des Regressionsmodells vergleichen. ** ** **

⑴ Bibliothek importieren

import numpy as np
import pandas as pd

# scikit-Bibliothek lernen
from sklearn.datasets import load_boston             #Boston Home Preisdatensatz
from sklearn.model_selection import train_test_split #Dienstprogramm zur Datenaufteilung
from sklearn.neighbors import KNeighborsRegressor    # k-NR-Regressionsmodellmethode

#Visualisierungsbibliothek
import matplotlib.pyplot as plt
import seaborn as sns

#Japanisches Anzeigemodul von matplotlib
!pip install japanize-matplotlib
import japanize_matplotlib

Die k-Nachbarschaftsmethode wird hauptsächlich als Klassifizierungsmodell unter dem Namen k-NN (k-Nearest Neighbor) verwendet. Im Nachbarmodul von scikit-learn ist das ** Regressionsmodell die KNeighborsRegressor ** -Methode.

1. Bereiten Sie die Daten vor

Holen Sie sich "Boston" aus dem Scikit-Learn-Datensatz.
Insgesamt 506 Beispieldatensätze mit 13 Attributinformationen wie Kriminalitätsrate, durchschnittliche Anzahl der Zimmer pro Einheit und Verkehrszugang als erklärende Variablen, wobei der "Immobilienpreis" in der Großstadt Boston im Nordosten von Massachusetts die Zielvariable ist.

⑵ Datenerfassung und Organisation

#Datensatz abrufen
boston = load_boston()

#Konvertieren Sie erklärende Variablen in DataFrame
df = pd.DataFrame(boston.data, columns=boston.feature_names)

#Verketten Sie objektive Variablen
df = pd.concat([df, pd.DataFrame(boston.target, columns=['MEDV'])], axis=1)
print(df)

Die Spalte ganz rechts "MEDV" ist eine Abkürzung für den Medianwert, die der Zielvariablen (Hauspreis) entspricht, die als "Medianwert des Besitzes eines Hauses im Bereich von 1000 USD" definiert ist.
Insgesamt gibt es 13 erklärende Variablen, von der Spalte ganz links "CRIM (Kriminalitätsrate): Kriminalitätsrate" bis "LSTAT (niedrigerer Status): niedrigeres Klassenverhältnis". Der Einfachheit halber werden wir jedoch nur eine Variable auswählen. Ich werde.

(3) Untersuchung der Analyseachse durch Korrelationsmatrix

Erstellen Sie eine Korrelationsmatrix zwischen allen Variablen und konzentrieren Sie sich auf die Variablen, die stark mit dem Hauspreis korrelieren.

#Erstellen Sie eine Korrelationsmatrix
correlation_matrix = np.corrcoef(df.T)

#Zeilen- / Spaltenbezeichnung
names = ['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 
         'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV']

#Konvertieren Sie die Korrelationsmatrix in DataFrame
correlation_df = pd.DataFrame(correlation_matrix, columns = names, index = names)

#Zeichnen Sie eine Heatmap
plt.figure(figsize=(10,8))
sns.heatmap(correlation_df, annot=True, cmap='coolwarm')

Numpys corrcoef () Funktion wird für die Korrelationsmatrix verwendet, aber die Korrelation zwischen Variablen wird berechnet, indem die Zeilen und Spalten der übergebenen Daten mit .T transponiert werden.
Seaborn wird für die Heatmap verwendet. Das Argument "annot = True" von "heatmap ()" zeigt den Wert für jede Zelle in der Abbildung an.

Als Variablen, die eine starke Korrelation mit dem Immobilienpreis (MEDV) aufweisen, zeigt "Lower Class Ratio (LSTAT)" eine starke negative Korrelation bei -0,74 und "Average Number of Rooms pro Unit (RM)" ist bei 0,70 stark positiv. Zeigt die Korrelation von.
Je höher die Anzahl der Zimmer, desto höher der Preis. In Gebieten mit vielen einkommensschwachen Gruppen ist der Marktpreis normalerweise niedrig. Wir werden einfach die "durchschnittliche Anzahl der Zimmer pro Einheit (RM)" übernehmen.

⑷ Datenextraktion und -aufteilung

#Extrahieren Sie nur 2 Variablen
df_extraction = df[['RM', 'MEDV']]

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

X = X.reshape(len(X), 1) #In 2D konvertieren
y = y.reshape(len(y), 1)

#Datenaufteilung für Training / Test
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) #In 2D konvertieren
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)

Extrahieren Sie nur die erklärende Variable "RM" und die Zielvariable "MEDV" und teilen Sie sie als Variablen X und y für Training bzw. Test.

2. Untersuchung des k-Parameters

⑸ Führen Sie k-NR aus, während Sie den k-Parameter ändern

Führen Sie k-NR aus, während Sie k von 1 auf 20 ändern, und beobachten Sie die Änderung der Genauigkeitsrate der Trainingsdaten und Testdaten.

#Variable, die die Genauigkeitsrate speichert
train_accuracy = []
test_accuracy = []

for k in range(1,21):
    kNR = KNeighborsRegressor(n_neighbors = k) #Instanzgenerierung
    kNR.fit(X_train, y_train) #Lernen
    train_accuracy.append(kNR.score(X_train, y_train)) #Trainingsgenauigkeitsrate
    test_accuracy.append(kNR.score(X_test, y_test)) #Testgenauigkeitsrate

#Konvertieren Sie die richtige Antwortrate in ein Array
training_accuracy = np.array(train_accuracy)
test_accuracy = np.array(test_accuracy)

⑹ Wählen Sie den optimalen k-Parameter

Visualisieren Sie Änderungen der Genauigkeitsrate zwischen Training und Test und zeigen Sie den Unterschied in der Genauigkeitsrate in einem Diagramm.

#Änderungen in der richtigen Antwortrate für Schulungen und Tests
plt.figure(figsize=(6, 4))

plt.plot(range(1,21), train_accuracy, label='Ausbildung')
plt.plot(range(1,21), test_accuracy, label='Prüfung')

plt.xticks(np.arange(0, 21, 1)) #x-Achsenskala
plt.xlabel('k Nummer')
plt.ylabel('Richtige Antwortrate')
plt.title('Übergang der richtigen Antwortrate')

plt.grid()
plt.legend()

#Übergang der Differenz in der richtigen Antwortrate
plt.figure(figsize=(6, 4))

difference = np.abs(train_accuracy - test_accuracy) #Berechnen Sie die Differenz
plt.plot(range(1,21), difference, label='Unterschied')

plt.xticks(np.arange(0, 21, 1)) #x-Achsenskala
plt.xlabel('k Nummer')
plt.ylabel('Unterschied(train - test)')
plt.title('Übergang der Differenz in der richtigen Antwortrate')

plt.grid()
plt.legend()

plt.show()

Wenn k zunimmt, nimmt die Genauigkeitsrate des Trainings ab und umgekehrt nimmt die Anzahl der Tests zu, aber beide sind ab etwa k = 9 nahezu flach.
Betrachtet man den Unterschied, wird k = 14 angenommen, da er allmählich abnimmt, bis k = 14 ist.

3. Modellausführung und -bewertung

Erstellen Sie Dummy-Daten, die für die Vorhersage verwendet werden sollen.

⑺ Erstellen Sie Dummy-Daten

#Gleichstellungssequenz generieren
t = np.linspace(1, 10, 1000) #Startwert,Endwert,Elementanzahl

#Form in 2D konvertieren
T = t.reshape(1000, 1)

⑻ Ausführung und Visualisierung des Regressionsmodells

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='Daten')
    plt.plot(T, y_, color='navy', lw=1, label='Voraussichtlicher Wert')
    plt.legend()
    plt.title("weights = '%s'" % (w))

plt.tight_layout()
plt.show()

tight_layout () passt die Parameter des Unterplots (Achsenmarkierungen, Achsenbeschriftungen, Titelbereich) automatisch so an, dass das Unterplot genau in den Bereich des Diagramms passt.

Auf den ersten Blick sehen Sie, dass sich der Abstand im vorhergesagten Wert erheblich ändert und die Daten überpasst sind.
Auf der anderen Seite kann Uniform die Informationen zusammenfassen, und es ist kein Wunder, dass die Standardeinstellung Uniform ist.

2. Multivariate Analyse in Python 8-2. K Nachbarschaftsmethode [Gewichtungsmethode] [Rückgabemodell]