K-Nearest Neighbors (KNN) in Python – Tutorial

K-nearest neighbors (kNN) ist eine überwachte maschinelle Lernmethode, die sowohl für Klassifikations- als auch für Regressionsaufgaben verwendet werden kann. Ich betrachte KNN als einen Algorithmus, der aus dem wirklichen Leben stammt. Menschen werden oft von den Menschen in ihrer Umgebung beeinflusst.

Die Idee hinter dem K-Nearest Neighbors Algorithmus

Unser Verhalten wird von den Gefährten geprägt, mit denen wir aufwachsen. Auch unsere Eltern formen unsere Persönlichkeiten auf verschiedene Weise. Wenn du unter Leuten aufwächst, die Sport lieben, ist es sehr wahrscheinlich, dass du auch Sport lieben wirst. Natürlich gibt es Ausnahmen. KNN funktioniert ähnlich.

Wenn du einen engen Freund hast und die meiste Zeit mit ihm/ihr verbringst, wirst du am Ende ähnliche Interessen haben und dieselben Dinge mögen. Das ist kNN mit k=1.

Wenn du ständig mit einer Gruppe von 5 Personen zusammen bist, hat jeder in der Gruppe einen Einfluss auf dein Verhalten und du wirst am Ende der Durchschnitt von 5 sein. Das ist kNN mit k=5.

Der kNN-Klassifikator bestimmt die Klasse eines Datenpunktes mit dem Prinzip der Mehrheitswahl. Wenn k auf 5 gesetzt ist, werden die Klassen der 5 nächsten Punkte untersucht. Die Vorhersage erfolgt gemäß der vorherrschenden Klasse. Ähnlich nimmt die kNN-Regression den Mittelwert der 5 nächsten Orte.

Wir sehen Menschen, die nahe beieinander sind, aber wie werden Datenpunkte als nahe betrachtet? Der Abstand zwischen Datenpunkten wird gemessen. Es gibt verschiedene Techniken zur Abstandsschätzung. Der euklidische Abstand (Minkowski-Abstand mit p=2) ist eine der am häufigsten verwendeten Distanzmessungen. Die Grafik unten erklärt, wie man den euklidischen Abstand zwischen zwei Punkten in einem zweidimensionalen Raum berechnet. Er wird bestimmt durch das Quadrat der Differenz zwischen den x- und y-Koordinaten der Standorte.

Implementierung des K-Nearest Neighbors (KNN) Algorithmus in Python

Lassen Sie uns nun mit der Implementierung von KNN in Python beginnen. Wir werden die Schritte durchgehen, um Ihnen zu helfen, den Code zu verstehen und besser zu interpretieren.

1. Importieren der Module

import numpy as np
import pandas as pd

import matplotlib.pyplot as plt

from sklearn.datasets import make_blobs
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split

2. Erstellen des Datensatzes

Scikit-learn bietet viele Werkzeuge zur Erstellung synthetischer Datensätze, die großartig sind, um maschinelle Lernalgorithmen zu testen. Ich werde die Methode „make blobs“ nutzen.

X, y = make_blobs(n_samples = 500, n_features = 2, centers = 4,cluster_std = 1.5, random_state = 4)

Dieser Code erzeugt einen Datensatz von 500 Proben, die in vier Klassen mit insgesamt zwei Merkmalen unterteilt sind. Mit den zugehörigen Parametern können Sie schnell die Anzahl der Proben, Merkmale und Klassen ändern. Wir können auch die Verteilung jeder Gruppe (oder Klasse) ändern.

3. Visualisierung des Datensatzes

plt.style.use('seaborn')
plt.figure(figsize = (10,10))
plt.scatter(X[:,0], X[:,1], c=y, marker= '*',s=100,edgecolors='black')
plt.show()

4. Aufteilung der Daten in Trainings- und Testdatensätze

Es ist kritisch, einen Datensatz für jede überwachte maschinelle Lernmethode in Trainings- und Testsets aufzuteilen. Zuerst trainieren wir das Modell und testen es dann an verschiedenen Teilen des Datensatzes. Wenn wir die Daten nicht trennen, testen wir das Modell nur mit Daten, die es bereits kennt. Mit der Methode train_test_split können wir die Tests einfach trennen.

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 0)

Mit den Optionen für Trainingsgröße und Testgröße können wir bestimmen, wie viel der ursprünglichen Daten für Trainings- und Testsätze verwendet wird. Die Standardtrennung beträgt 75% für das Trainingsset und 25% für das Testset.

5. Implementierung des KNN-Klassifikators

Danach bauen wir ein kNN-Klassifikator-Objekt. Ich entwickle zwei Klassifikatoren mit k-Werten von 1 und 5, um die Relevanz des k-Wertes zu demonstrieren. Die Modelle werden dann mit einem Trainingsset trainiert. Der k-Wert wird mit dem Argument n_neighbors gewählt. Es muss nicht explizit angegeben werden, da der Standardwert 5 ist.

knn5 = KNeighborsClassifier(n_neighbors = 5)
knn1 = KNeighborsClassifier(n_neighbors=1)

6. Vorhersagen für die KNN-Klassifikatoren

Dann prognostizieren wir im Testset die Zielwerte und vergleichen sie mit den tatsächlichen Werten.

knn5.fit(X_train, y_train)
knn1.fit(X_train, y_train)

y_pred_5 = knn5.predict(X_test)
y_pred_1 = knn1.predict(X_test)

7. Vorhersagegenauigkeit für beide k-Werte

from sklearn.metrics import accuracy_score
print("Accuracy with k=5", accuracy_score(y_test, y_pred_5)*100)
print("Accuracy with k=1", accuracy_score(y_test, y_pred_1)*100)

Die Genauigkeit für die k-Werte ergibt sich wie folgt:

Accuracy with k=5 93.60000000000001
Accuracy with k=1 90.4

8. Visualisierung der Vorhersagen

Lassen Sie uns das Testset und die vorhergesagten Werte mit k=5 und k=1 ansehen, um den Einfluss der k-Werte zu sehen.

plt.figure(figsize = (15,5))
plt.subplot(1,2,1)
plt.scatter(X_test[:,0], X_test[:,1], c=y_pred_5, marker= '*', s=100,edgecolors='black')
plt.title("Predicted values with k=5", fontsize=20)

plt.subplot(1,2,2)
plt.scatter(X_test[:,0], X_test[:,1], c=y_pred_1, marker= '*', s=100,edgecolors='black')
plt.title("Predicted values with k=1", fontsize=20)
plt.show()

Wie man den besten k-Wert zur Implementierung von KNN findet

k=1: Das Modell ist zu eng und nicht richtig verallgemeinert. Es hat auch eine hohe Empfindlichkeit gegenüber Störungen. Das Modell sagt neue, bisher unbekannte Datenpunkte mit hoher Genauigkeit auf einem Trainingsset voraus, ist jedoch ein schlechter Vorhersager für frische, bisher ungesehene Datenpunkte. Infolgedessen haben wir wahrscheinlich ein überangepasstes Modell.

k=100: Das Modell ist übermäßig breit und unzuverlässig sowohl auf den Trainings- als auch auf den Testsets. Unteranpassung ist der Begriff für diese Situation.

Begrenzungen des K-Nearest Neighbors (KNN) Algorithmus

KNN ist ein einfacher Algorithmus zum Verstehen. Er verlässt sich nicht auf ein internes maschinelles Lernmodell, um Vorhersagen zu generieren. KNN ist eine Klassifizierungsmethode, die einfach wissen muss, wie viele Kategorien es gibt (eine oder mehrere). Das bedeutet, es kann schnell beurteilen, ob eine neue Kategorie hinzugefügt werden sollte, ohne zu wissen, wie viele andere es gibt.

Der Nachteil dieser Einfachheit ist, dass er ungewöhnliche Dinge (wie neue Krankheiten) nicht vorhersagen kann, was KNN nicht schaffen kann, da er nicht weiß, wie die Prävalenz eines seltenen Gegenstandes in einer gesunden Bevölkerung wäre.

Obwohl KNN eine hohe Genauigkeit auf dem Testset erreicht, ist es langsamer und teurer in Bezug auf Zeit und Speicher. Es benötigt eine erhebliche Menge an Speicher, um den gesamten Trainingsdatensatz für die Vorhersage zu speichern. Außerdem ist der euklidische Abstand sehr empfindlich gegenüber Größen, Merkmale im Datensatz mit großen Magnituden werden immer diejenigen mit kleinen Magnituden überwiegen.

Schlussfolgerung – K-Nearest Neighbors (KNN)

Hoffentlich haben Sie jetzt ein besseres Verständnis des KNN-Algorithmus. Wir haben eine Vielzahl von Ideen betrachtet, wie KNN den kompletten Datensatz speichert, um Vorhersagen zu generieren.

KNN ist einer von mehreren faulen Lernalgorithmen, die kein Lernmodell verwenden, um Vorhersagen zu machen. Durch die Durchschnittsbildung der Ähnlichkeit zwischen einer eingehenden Beobachtung und den bereits verfügbar Daten erzeugt KNN Vorhersagen in Echtzeit (just in time).

Danke fürs Lesen!