Eine einfache Python-Implementierung der k-Neighborhood-Methode (k-NN)
Übersicht über die k-Nachbarschaftsmethode
Der k-Nearist Neighbor ist ein Algorithmus für maschinelles Lernen, der überwacht und für Klassifizierungsprobleme verwendet wird. Ein sehr ähnlicher Name ist k-means, aber k-means wird für das Clustering beim unbeaufsichtigten Lernen verwendet.
Der k-Nachbarschaftsalgorithmus selbst ist sehr einfach. Berechnen Sie den Abstand zwischen den zu klassifizierenden Daten und den vorhandenen Daten und bestimmen Sie die Klasse durch die Mehrheit der Daten an k Punkten, die nahe beieinander liegen.
Wenn beispielsweise k = 1 ist, ist dies nur der Datenbegleiter mit der kürzesten Entfernung.
Es ist leichter zu verstehen, wenn Sie sich die Abbildung ansehen.
k Beispiel für eine Nachbarmethode. Proben (grüne Kreise) werden entweder in die erste Klasse (blaues Quadrat) oder in die zweite Klasse (rotes Dreieck) eingeteilt. Wenn k = 3 ist, befinden sich die Objekte im inneren Kreis in der Nähe, sodass sie in die zweite Klasse eingeteilt werden (mehr rote Dreiecke). Aber wenn k = 5 ist, kehrt es sich um. Zitat: wikipedia
Aus dem Obigen ergeben sich folgende Merkmale des k-Near-Verfahrens.
- Das einfachste unbeaufsichtigte Lernen
- Keine Vorkenntnisse zur Identifizierung erforderlich
- Die Bestimmung dauert einige Zeit, da der Abstand zu allen Daten zum Zeitpunkt der Bestimmung berechnet wird.
- Wenn die Dimension größer wird, gibt es ein Problem hinsichtlich der Berechnungskosten und der Genauigkeit (der sogenannte Dimensionsfluch macht süchtig).
Implementierung der k-Neighborhood-Methode (Python)
Einfache Implementierung
import numpy as np
import scipy.spatial.distance as distance
import scipy.stats as stats
import numpy as np
import scipy.spatial.distance as distance
import scipy.stats as stats
class knn:
def __init__(self,k):
self.k = k
self._fit_X = None #Vorhandene Daten speichern
self.classes = None #
self._y = None
def fit(self, X, label):
#X ist der ursprüngliche Datenpunkt, die Form(data_num, feature_num)
print("original data:\n", X)
print("label:\n", label)
self._fit_X = X
#Extrahieren Sie Klassen aus Beschriftungsdaten und erstellen Sie ein Array mit der Beschriftung als Index
# self.classes[self.label_indices] ==Es kann wie ein Etikett wiederhergestellt werden, also kehren Sie zurück_invers genannt
self.classes, self.label_indices = np.unique(label, return_inverse=True)
print("classes:\n", self.classes)
print("label_indices:\n", self.label_indices)
print("classes[label_indices]Überprüfen Sie, ob es mit wiederhergestellt werden kann:\n", self.classes[self.label_indices])
def neighbors(self, Y):
#Y ist der vorherzusagende Datenpunkt(Mehrere)damit, shape(test_num, feature_num)
#Da der Abstand zwischen dem vorherzusagenden Punkt und dem Datenpunkt berechnet wird, testen Sie_num * data_Berechnen Sie den Abstand mit num
dist = distance.cdist(Y, self._fit_X)
print("Abstand zwischen Testdaten und Originaldaten:\n", dist)
#dist ist Form(test_num, data_num)Wird
# [[1.41421356 1.11803399 2.6925824 2.23606798]Abstand zwischen Testpunkt 1 und jedem Punkt der Originaldaten
# [3. 2.6925824 1.80277564 1.41421356]Abstand zwischen Testpunkt 2 und jedem Punkt der Originaldaten
# [3.31662479 3.20156212 1.11803399 1.41421356]]Abstand zwischen Testpunkt 3 und jedem Punkt der Originaldaten
#Suchen Sie nach dem Messen der Entfernung den Index bis zum k-ten
#argpartition ist eine Funktion, die Daten bis zum k-ten und danach aufteilt
#Mit argsort können Sie die Reihenfolge der Entfernung sehen, aber k-Verwenden Sie die arg-Partition, da nn keine Informationen zum Entfernungsranking benötigt
neigh_ind = np.argpartition(dist, self.k)
# neigh_ind Form ist(test_num, feature_num)Wird
#K in der obigen dist=Ergebnis der arg-Partition in 2
#Zum Beispiel in der ersten Zeile Index 2,1 sind die beiden obersten Elemente. Betrachtet man die Entfernung oben, 0.5 und 1.5 entspricht
#Die zweite Zeile ist Index 3,2 ist die Top 2 Elemente, 1.73 und 1.80 ist äquivalent
#[[1 0 3 2]
# [3 2 1 0]
# [2 3 1 0]]
#Extrahieren Sie nur die Informationen bis zum k-ten
neigh_ind = neigh_ind[:, :self.k]
# neigh_ind Form ist(test_num, self.k)Wird
#[[1 0]Liste der Indizes der ursprünglichen Datenpunkte in der Nähe von Testpunkt 1
# [3 2]Liste der Indizes der ursprünglichen Datenpunkte in der Nähe von Testpunkt 2
# [2 3]]Liste der Indizes der ursprünglichen Datenpunkte in der Nähe von Testpunkt 3
return neigh_ind
def predict(self, Y):
#Form, um den Index bis zum k-ten zu finden(test_num, self.k)Wird
print("test data:\n",Y)
neigh_ind = self.neighbors(Y)
# stats.Finden Sie den häufigsten Wert im Modus. shape(test_num, 1) . _Ist die häufigste Zählung
# self.label_Indizes ist[0 0 1 1]Stellt die Bezeichnung jedes Punkts in den Originaldaten dar
# neigh_ind ist eine Liste von Indizes der Originaldaten in der Nähe jedes Testpunkts, jeder Form(est_num, k)Wird
# self.label_indices[neigh_ind]Sie können eine Liste der Beschriftungen in der Nähe jedes Testpunkts wie folgt erhalten
# [[0 0]Liste der Beschriftungen für Originaldatenpunkte in der Nähe von Testpunkt 1
# [1 1]Liste der Beschriftungen für Originaldatenpunkte in der Nähe von Testpunkt 2
# [1 1]]Liste der Beschriftungen für Originaldatenpunkte in der Nähe von Testpunkt 3
#Zeilenrichtung der obigen Daten(axis=1)Gegen den Modus(Häufigster Wert)Und verwenden Sie es als Bezeichnung, zu der jeder Testpunkt gehört
# _Ist die Zählung
mode, _ = stats.mode(self.label_indices[neigh_ind], axis=1)
#Modus ist Achse=Da es sich um 1 handelt, Form(test_num, 1)Also erhöhen(=flatten)ich werde es tun
# [[0]
# [1]
# [1]]
#Beachten Sie, dass np.intp ist der für den Index verwendete Datentyp
mode = np.asarray(mode.ravel(), dtype=np.intp)
print("Häufigster Wert jedes Etikettenindex der Testdaten:\n",mode)
#Wechseln Sie von der Indexnotation zur Bezeichnung des Markennamens. self.classes[mode]Gleich wie
result = self.classes.take(mode)
return result
Versuchen Sie vorherzusagen
K = knn(k=2)
#Legen Sie die Originaldaten und das Etikett fest
samples = [[0., 0., 0.], [0., .5, 0.], [1., 2., -2.5],[1., 2., -2.]]
label = ['a','a','b', 'b']
K.fit(samples, label)
#Daten, die Sie vorhersagen möchten
Y = [[1., 1., 0.],[2, 2, -1],[1, 1, -3]]
p = K.predict(Y)
print("result:\n", p)
Ausführungsergebnis
>>result
original data:
[[0.0, 0.0, 0.0], [0.0, 0.5, 0.0], [1.0, 2.0, -2.5], [1.0, 2.0, -2.0]]
label:
['a', 'a', 'b', 'b']
classes:
['a' 'b']
label_indices:
[0 0 1 1]
classes[label_indices]Überprüfen Sie, ob es mit wiederhergestellt werden kann:
['a' 'a' 'b' 'b']
test data:
[[1.0, 1.0, 0.0], [2, 2, -1], [1, 1, -3]]
Abstand zwischen Testdaten und Originaldaten:
[[1.41421356 1.11803399 2.6925824 2.23606798]
[3. 2.6925824 1.80277564 1.41421356]
[3.31662479 3.20156212 1.11803399 1.41421356]]
Häufigster Wert jedes Etikettenindex der Testdaten:
[0 1 1]
result:
['a' 'b' 'b']
Verweise
- Datenanalyse 10. "k-Nachbarschaftsmethode" von Daiji Suzuki
- Lassen Sie uns die Klassifizierung, Regressionsanalyse und den Modellanwendungsbereich \ (Anwendungsbereich ) mit der [k-Methode für den nächsten Nachbarn \ (k \ -Nächster Nachbar, k \ -NN ) festlegen! \ -Speaker Deck](https://speakerdeck.com/hkaneko/kzui-jin-bang-fa-k-nearest-neighbor-k-nn-dekurasufen-lei-hui-gui-fen-xi-moderufalseshi-yong- fan-wei-shi-yong-ling-yu-falseshe-ding-wosiyou)
- Grundlegendes zur [k-Nachbarschaftsmethode \ (k \ -Nearest Neighbor ) - OpenCV \ -Python Tutorials 1-Dokumentation](http://labs.eecs.tottori-u.ac.jp/sd/Member/oyamada/OpenCV/ html / py_tutorials / py_ml / py_knn / py_knn_understanding / py_knn_understanding.html)
- Maschinelles Lernen \ _k Nachbarschaftsmethode \ _ Theorie | Entwickler \ .IO
Recommended Posts
Erstellen Sie eine Python-Umgebung, um die Theorie und Implementierung von Deep Learning zu erlernen
Python: Berechnen Sie die konstante Flusstiefe eines rechteckigen Querschnitts mit der Brent-Methode