Nächstes Kapitel: Einführung in neuronale Netzwerke
Nächste-Nachbarn-Klassifikation mit sklearn¶
Einführung¶
Die zugrundeliegenden Konzepte des K-Nächsten-Nachbarn-Klassifikators (KNN) finden Sie im Kapitel [Nächste-Nachbarn-Klassifikation] (naechste_nachbarn_klassifikation.php) unseres Tutorials über Maschinelles Lernen. In diesem Kapitel zeigten wir auch einfache Funktionen, die in Python geschrieben wurden, um die grundlegenden Prinzipien zu demonstrieren.
Anstatt diese Funktionen zu nutzen, - obwohl sie beeindruckende Ergebnisse zeigten, - empfehlen wir, die Funktionalitäten des sklearn-Moduls
zu verwenden.
kNN-Klassifikatoren von sklearn¶
neighbors
ist ein Paket des sklearn
module,
welches Funktionalitäten für Nächste-Nachbarn-Klassifikatoren
zur Verfügung stellt.
Die Klassen in sklearn.neighbors
können sowohl
numpy arrays als auch scipy.sparse-Matrizen als
Eingabe verarbeiten.
Für dichte Matrizen werden eine große Anzahl
möglicher Entfernungsmetriken unterstützt.
Für dünnbesetzte Matrizen werden beliebige
Minkowski-Metriken für Suchvorgänge unterstützt.
scikit-learn implementiert zwei verschiedene nächste-Nachbarn-Klassifikatoren:
- K-Nächster-Nachbar
- basiert auf den k-nächsten Nachbarn der Stichprobe, die zu klassifizieren sind. Der Wert `k` ist ein vom Benutzer spezifizierter Wert. Dies ist der am häufigsten engewendete Klassifikator der beiden.
- Radius-Nächster-Nachbar
- basiert auf der Anzahl der Nachbarn einer Stichprobe innerhalb eines festen Umkreises `r`. `r` ist eine von den Anwendenden zu bestimmende `flot`-Zahl. Dieser Klassifikationtyp wird seltener angewendet.
KNeighborsClassifier¶
Wir erstellen einen künstlichen Datensatz mit drei Klassen, um den K-Nächster Nachbarnklassifizierer KNeighborsClassifier
von sklearn.neighbors
testen.
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt
import numpy as np
centers = [[2, 3], [5, 5], [7, 9]]
n_classes = len(centers)
data, labels = make_blobs(n_samples=50,
centers=np.array(centers),
random_state=1)
Let us visualize what we have created:
import matplotlib.pyplot as plt
colours = ('green', 'red', 'blue')
n_classes = 3
fig, ax = plt.subplots()
for n_class in range(0, n_classes):
ax.scatter(data[labels==n_class, 0], data[labels==n_class, 1],
c=colours[n_class], s=10, label=str(n_class))
ax.legend(loc='upper right');
Wir sind nun bereit die Klassifikation mit kNeighborsClassifier
durchzuführen:
# Create and fit a nearest-neighbor classifier
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier()
knn.fit(data, labels)
KNeighborsClassifier(algorithm='auto',
leaf_size=30,
metric='minkowski',
metric_params=None,
n_jobs=1,
n_neighbors=5,
p=2,
weights='uniform')
predicted = knn.predict(data)
print("Ergebnisse der Klassifikation:")
print(predicted)
print("Sollwerte:")
print(labels)
Um das Ergebnis zu evaluieren benötigen wir die Funktion accuracy_score
aus dem Modul sklearn.metrics
. Um zu sehen, wie sie arbeitet, benutzen wir folgendes kleines Beispiel:
from sklearn.metrics import accuracy_score
y_pred = [0, 2, 1, 3, 2]
y_true = [0, 1, 2, 3, 2]
print(accuracy_score(y_true, y_pred))
print(accuracy_score(y_true, y_pred, normalize=False))
Der erste Aufruf von accuracy_score
liefert 0.6
zurück, was bedeutet, dass 60% der Stichproben korrekt bestimmt wurden. Der Parameter normalize
wurde per Default auf True
gesetzt. Beim zweiten Aufruf setzen wir normalize
auf False
. Dies bedeutet, dass wir die Anzahl der Elemente erhalten, die korrekt vorhergesagt worden waren.
Nun sind wir bereit, unsere Ergebnisse aus der Klassifizierung des vorigen Beispiels zu bewerten:
print(accuracy_score(predicted, labels))
data[:5], labels[:5]
Im folgenden Beispiel benutzen wir den Iris-Datensatz:
from sklearn import datasets
from sklearn.model_selection import train_test_split
iris = datasets.load_iris()
data, labels = iris.data, iris.target
res = train_test_split(data, labels,
train_size=0.8,
test_size=0.2,
random_state=42)
train_data, test_data, train_labels, test_labels = res
# Create and fit a nearest-neighbor classifier
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier()
knn.fit(train_data, train_labels)
KNeighborsClassifier(algorithm='auto',
leaf_size=30,
metric='minkowski',
metric_params=None,
n_jobs=1,
n_neighbors=5,
p=2, # p=2 is equivalent to euclidian distance
weights='uniform')
print("Ergebnisse der Klassifikation:")
test_data_predicted = knn.predict(test_data)
print(test_data_predicted)
print("Sollwerte:")
print(test_labels)
print(accuracy_score(test_data_predicted, test_labels))
print("Ergebnisse der Klassifikation:")
learn_data_predicted = knn.predict(train_data)
print(learn_data_predicted)
print("Sollwerte:")
print(train_labels)
print(accuracy_score(learn_data_predicted, train_labels))
RadiusNeighborsClassifier¶
Die Arbeitsweise des k-Nächsten-Nachbarnklassifikators besteht darin, einen Kreis um die zu klassifizierende Stichprobe zu bestimmen der genau k Elemente enthält. Der Radius-Nachbarn-Klassifikator hingegen hat eine feste Länge für den Radius des umgebenden Kreis. Es lokalisiert alle Elemente in den Trainingsdaten, die sich innerhalb dieses Kreis mit der angegebenen Radiuslänge befinden. Als Folge des festen Radiusansatzes bieten dichte Regionen der Stichprobenverteilung mehr Informationen und sparse
Regionen bieten weniger Informationen, was sich oft als vorteilhaft erweist.
from sklearn.neighbors import RadiusNeighborsClassifier
X = [[0, 1], [0.5, 1], [3, 1], [3, 2], [1.3, 0.8], [2.5, 2.5]]
y = [0, 0, 1, 1, 0, 1]
neigh = RadiusNeighborsClassifier(radius=1.0)
neigh.fit(X, y)
print(neigh.predict([[1.5, 1.2]]))
print(neigh.predict([[3.1, 2.1]]))
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt
import numpy as np
centers = [[2, 3], [5, 5], [7, 9]]
n_classes = len(centers)
data, labels = make_blobs(n_samples=155,
centers=np.array(centers),
cluster_std = 1.3,
random_state=1)
import matplotlib.pyplot as plt
colours = ('green', 'red', 'blue')
n_classes = 3
fig, ax = plt.subplots()
for n_class in range(0, n_classes):
ax.scatter(data[labels==n_class, 0], data[labels==n_class, 1],
c=colours[n_class], s=10, label=str(n_class))
rnn = RadiusNeighborsClassifier(radius=0.5)
rnn.fit(data, labels)
predicted = rnn.predict(data)
print(accuracy_score(predicted, labels))
Nun wollen wir dies mit dem k-Nächsten-Nachbarn-Klassifikator vergleichen:
knn = KNeighborsClassifier()
knn.fit(data, labels)
KNeighborsClassifier(algorithm='auto',
leaf_size=30,
metric='minkowski',
metric_params=None,
n_jobs=1,
n_neighbors=6,
p=2, # p=2 is equivalent to euclidian distance
weights='uniform')
predicted = knn.predict(data)
print(accuracy_score(predicted, labels))
Nächstes Kapitel: Einführung in neuronale Netzwerke