TechCodeview

• K-Nearest Neighbor ist einer der einfachsten Algorithmen für maschinelles Lernen, der auf der Technik des überwachten Lernens basiert.
• Der K-NN-Algorithmus geht von der Ähnlichkeit zwischen dem neuen Fall/den neuen Daten und den verfügbaren Fällen aus und ordnet den neuen Fall der Kategorie zu, die den verfügbaren Kategorien am ähnlichsten ist.
• Der K-NN-Algorithmus speichert alle verfügbaren Daten und klassifiziert einen neuen Datenpunkt basierend auf der Ähnlichkeit. Das heißt, wenn neue Daten auftauchen, können sie mithilfe des K-NN-Algorithmus problemlos in eine Well-Suite-Kategorie klassifiziert werden.
• Der K-NN-Algorithmus kann sowohl für die Regression als auch für die Klassifizierung verwendet werden, wird jedoch hauptsächlich für Klassifizierungsprobleme verwendet.
• K-NN ist ein nichtparametrischer Algorithmus , was bedeutet, dass keine Annahmen über die zugrunde liegenden Daten getroffen werden.
• Es wird auch a genannt Lazy-Learner-Algorithmus weil es nicht sofort aus dem Trainingssatz lernt, sondern den Datensatz speichert und zum Zeitpunkt der Klassifizierung eine Aktion am Datensatz ausführt.
• Der KNN-Algorithmus speichert in der Trainingsphase einfach den Datensatz und wenn er neue Daten erhält, klassifiziert er diese Daten in eine Kategorie, die den neuen Daten sehr ähnlich ist.
Beispiel:Angenommen, wir haben ein Bild von einem Lebewesen, das einer Katze und einem Hund ähnelt, möchten aber wissen, ob es sich um eine Katze oder einen Hund handelt. Für diese Identifizierung können wir also den KNN-Algorithmus verwenden, da dieser auf einem Ähnlichkeitsmaß basiert. Unser KNN-Modell findet ähnliche Merkmale des neuen Datensatzes wie die Bilder von Katzen und Hunden und ordnet ihn basierend auf den ähnlichsten Merkmalen entweder der Kategorie „Katze“ oder „Hund“ zu.

Warum brauchen wir einen K-NN-Algorithmus?

Angenommen, es gibt zwei Kategorien, nämlich Kategorie A und Kategorie B, und wir haben einen neuen Datenpunkt x1, sodass dieser Datenpunkt in welcher dieser Kategorien liegen wird. Um diese Art von Problem zu lösen, benötigen wir einen K-NN-Algorithmus. Mit Hilfe von K-NN können wir die Kategorie oder Klasse eines bestimmten Datensatzes leicht identifizieren. Betrachten Sie das folgende Diagramm:

Wie funktioniert K-NN?

Die Funktionsweise von K-NN kann anhand des folgenden Algorithmus erklärt werden:

Schritt 1:Wählen Sie die Anzahl K der Nachbarn ausSchritt 2:Berechnen Sie den euklidischen Abstand von K Anzahl der Nachbarn Schritt 3:Nehmen Sie die K nächsten Nachbarn gemäß der berechneten euklidischen Entfernung.Schritt 4:Zählen Sie unter diesen k Nachbarn die Anzahl der Datenpunkte in jeder Kategorie.Schritt 5:Ordnen Sie die neuen Datenpunkte der Kategorie zu, für die die Anzahl der Nachbarn maximal ist.Schritt 6:Unser Modell ist fertig.

Angenommen, wir haben einen neuen Datenpunkt und müssen ihn in die erforderliche Kategorie einordnen. Betrachten Sie das folgende Bild:

burak ozcivit

• Zuerst wählen wir die Anzahl der Nachbarn, also wählen wir k=5.
• Als nächstes berechnen wir die Euklidische Entfernung zwischen den Datenpunkten. Der euklidische Abstand ist der Abstand zwischen zwei Punkten, den wir bereits in der Geometrie untersucht haben. Es kann wie folgt berechnet werden:

• Durch die Berechnung des euklidischen Abstands erhalten wir die nächsten Nachbarn als drei nächste Nachbarn in Kategorie A und zwei nächste Nachbarn in Kategorie B. Betrachten Sie das folgende Bild:

• Wie wir sehen können, gehören die drei nächsten Nachbarn zur Kategorie A, daher muss dieser neue Datenpunkt zur Kategorie A gehören.

Wie wählt man den Wert von K im K-NN-Algorithmus aus?

Im Folgenden sind einige Punkte aufgeführt, die Sie bei der Auswahl des K-Werts im K-NN-Algorithmus beachten sollten:

• Es gibt keine bestimmte Möglichkeit, den besten Wert für „K“ zu bestimmen, daher müssen wir einige Werte ausprobieren, um den besten Wert daraus zu ermitteln. Der am meisten bevorzugte Wert für K ist 5.
• Ein sehr niedriger Wert für K, beispielsweise K=1 oder K=2, kann verrauscht sein und zu Ausreißern im Modell führen.
• Große Werte für K sind gut, es kann jedoch zu Schwierigkeiten kommen.

Vorteile des KNN-Algorithmus:

• Es ist einfach umzusetzen.
• Es ist robust gegenüber den verrauschten Trainingsdaten
• Es kann effektiver sein, wenn die Trainingsdaten groß sind.

Nachteile des KNN-Algorithmus:

• Es muss immer der Wert von K bestimmt werden, was mit der Zeit komplex sein kann.
• Der Rechenaufwand ist hoch, da der Abstand zwischen den Datenpunkten für alle Trainingsbeispiele berechnet wird.

Python-Implementierung des KNN-Algorithmus

Um die Python-Implementierung des K-NN-Algorithmus durchzuführen, verwenden wir dasselbe Problem und denselben Datensatz, die wir in der logistischen Regression verwendet haben. Aber hier werden wir die Leistung des Modells verbessern. Unten finden Sie die Problembeschreibung:

Problem für den K-NN-Algorithmus: Es gibt einen Automobilhersteller, der ein neues SUV-Auto hergestellt hat. Das Unternehmen möchte die Anzeigen den Nutzern zukommen lassen, die am Kauf dieses SUV interessiert sind. Für dieses Problem verfügen wir über einen Datensatz, der die Informationen mehrerer Benutzer über das soziale Netzwerk enthält. Der Datensatz enthält viele Informationen, aber die Geschätztes Gehalt Und Alter Wir werden für die unabhängige Variable und die berücksichtigen Gekaufte Variable ist für die abhängige Variable. Unten ist der Datensatz:

Schritte zur Implementierung des K-NN-Algorithmus:

• Datenvorverarbeitungsschritt
• Anpassen des K-NN-Algorithmus an den Trainingssatz
• Vorhersage des Testergebnisses
• Testgenauigkeit des Ergebnisses (Erstellung einer Verwirrungsmatrix)
• Visualisierung des Testsatzergebnisses.

Datenvorverarbeitungsschritt:

Der Schritt der Datenvorverarbeitung bleibt genau derselbe wie bei der logistischen Regression. Unten ist der Code dafür:

 # importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd #importing datasets data_set= pd.read_csv('user_data.csv') #Extracting Independent and dependent Variable x= data_set.iloc[:, [2,3]].values y= data_set.iloc[:, 4].values # Splitting the dataset into training and test set. from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test= train_test_split(x, y, test_size= 0.25, random_state=0) #feature Scaling from sklearn.preprocessing import StandardScaler st_x= StandardScaler() x_train= st_x.fit_transform(x_train) x_test= st_x.transform(x_test) 

Durch die Ausführung des obigen Codes wird unser Datensatz in unser Programm importiert und gut vorverarbeitet. Nach der Funktionsskalierung sieht unser Testdatensatz folgendermaßen aus:

Aus dem obigen Ausgabebild können wir erkennen, dass unsere Daten erfolgreich skaliert wurden.

Anpassen des K-NN-Klassifikators an die Trainingsdaten:
Jetzt passen wir den K-NN-Klassifikator an die Trainingsdaten an. Dazu importieren wir die KNeighborsClassifier Klasse von Sklearn-Nachbarn Bibliothek. Nach dem Importieren der Klasse erstellen wir die Klassifikator Objekt der Klasse. Der Parameter dieser Klasse wird sein
n_Nachbarn:Um die erforderlichen Nachbarn des Algorithmus zu definieren. Normalerweise dauert es 5.metric='minkowski':Dies ist der Standardparameter und bestimmt den Abstand zwischen den Punkten.p=2:Sie entspricht der standardmäßigen euklidischen Metrik.
Und dann passen wir den Klassifikator an die Trainingsdaten an. Unten ist der Code dafür:

 #Fitting K-NN classifier to the training set from sklearn.neighbors import KNeighborsClassifier classifier= KNeighborsClassifier(n_neighbors=5, metric='minkowski', p=2 ) classifier.fit(x_train, y_train) 

Ausgabe: Durch Ausführen des obigen Codes erhalten wir die Ausgabe wie folgt:

 Out[10]: KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski', metric_params=None, n_jobs=None, n_neighbors=5, p=2, weights='uniform') 

Vorhersage des Testergebnisses:Um das Ergebnis des Testsatzes vorherzusagen, erstellen wir eine y_pred Vektor, wie wir es in der logistischen Regression getan haben. Unten ist der Code dafür:

 #Predicting the test set result y_pred= classifier.predict(x_test) 

Ausgabe:

Die Ausgabe für den obigen Code ist:

Erstellen der Verwirrungsmatrix:
Jetzt erstellen wir die Verwirrungsmatrix für unser K-NN-Modell, um die Genauigkeit des Klassifikators zu überprüfen. Unten ist der Code dafür:

 #Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred) 

Im obigen Code haben wir die Funktion „confusion_matrix“ importiert und sie mit der Variablen cm aufgerufen.

Ausgabe: Durch Ausführen des obigen Codes erhalten wir die folgende Matrix:

Im obigen Bild sehen wir, dass es 64+29=93 richtige Vorhersagen und 3+4=7 falsche Vorhersagen gibt, während es bei der logistischen Regression 11 falsche Vorhersagen gab. Wir können also sagen, dass die Leistung des Modells durch die Verwendung des K-NN-Algorithmus verbessert wird.

Visualisierung des Trainingssatzergebnisses:
Jetzt visualisieren wir das Ergebnis des Trainingssatzes für das K-NN-Modell. Der Code bleibt derselbe wie bei der logistischen Regression, mit Ausnahme des Namens des Diagramms. Unten ist der Code dafür:

 #Visulaizing the trianing set result from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('K-NN Algorithm (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Ausgabe:

Durch Ausführen des obigen Codes erhalten wir die folgende Grafik:

Das Ausgabediagramm unterscheidet sich von dem Diagramm, das wir in der logistischen Regression erstellt haben. Es kann in den folgenden Punkten verstanden werden:

• Wie wir sehen können, zeigt die Grafik den roten und grünen Punkt. Die grünen Punkte gelten für die Variable „Gekauft“ (1) und die roten Punkte für die Variable „Nicht gekauft“ (0).
• Das Diagramm zeigt eine unregelmäßige Grenze anstelle einer geraden Linie oder Kurve, da es sich um einen K-NN-Algorithmus handelt, d. h. um den nächsten Nachbarn zu finden.
• Die Grafik hat Benutzer in die richtigen Kategorien eingeteilt, da sich die meisten Benutzer, die den SUV nicht gekauft haben, im roten Bereich befinden und Benutzer, die den SUV gekauft haben, im grünen Bereich.
• Die Grafik zeigt ein gutes Ergebnis, dennoch gibt es einige grüne Punkte im roten Bereich und rote Punkte im grünen Bereich. Dies stellt jedoch kein großes Problem dar, da durch die Verwendung dieses Modells Überanpassungsprobleme vermieden werden.
• Daher ist unser Modell gut trainiert.
Visualisierung des Testsatzergebnisses:
Nach dem Training des Modells testen wir nun das Ergebnis, indem wir einen neuen Datensatz, d. h. einen Testdatensatz, einfügen. Der Code bleibt bis auf einige kleinere Änderungen derselbe: wie z x_train und y_train wird ersetzt durch x_test und y_test .
Unten ist der Code dafür:

 #Visualizing the test set result from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('K-NN algorithm(Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Ausgabe:

Die obige Grafik zeigt die Ausgabe für den Testdatensatz. Wie wir in der Grafik sehen können, ist die vorhergesagte Ausgabe sehr gut, da die meisten roten Punkte im roten Bereich und die meisten grünen Punkte im grünen Bereich liegen.

Was ist Maven?

Allerdings gibt es im roten Bereich nur wenige grüne Punkte und im grünen Bereich einige rote Punkte. Das sind also die falschen Beobachtungen, die wir in der Verwirrungsmatrix beobachtet haben (7 Falsche Ausgabe).