Einführung

Nach Kapitel 4, Ausführungsbeispiel für Erste Mustererkennung Wird in Python reproduziert. Diesmal ist Kapitel 5 "k Nächste-Nachbar-Methode (kNN-Methode)".

Wir haben jedoch die Reproduktion des Ausführungsbeispiels unter Verwendung der handgeschriebenen ETL1-Zahlendatenbank (Ausführungsbeispiel 5.1, Ausführungsbeispiel 5.2, Abbildung 5.9 (a)) abgebrochen, da es einen Teil gibt, in dem die Daten zufällig abgetastet werden. .. .. Die Betriebsumgebung des beschriebenen Codes ist numpy 1.16.2, pandas 0.24.2, scikit-learn 0.20.3.

Ausführungsbeispiel 5.2 Finden Sie die optimale Anzahl von Nachbarn k

Die k-Nearest-Neighbour-Methode (kNN-Methode) ist eine Identifikationsmethode, bei der k Templates in der nächsten Umgebung einer Stichprobe entnommen werden und die Stichprobe zu der Klasse gehört, zu der sie am meisten gehören. Unten ist der Code.

Laden der erforderlichen Bibliotheken

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style('whitegrid')
from sklearn.preprocessing import StandardScaler

--k Implementierung der Methode des nächsten Nachbarn

class kNearestNeiborsClassifier:
    def __init__(self, k=5):
        self._k = k
        self._templates = None
        self._classes = None
    
    def fit(self, templates, classes):
        self._templates = templates
        self._classes = classes
    
    def predict(self, X):
        pred = np.zeros(len(X))
        for i in range(len(X)): #Verarbeiten Sie jede Probe mit einer for-Anweisung, um die Lesbarkeit sicherzustellen
            distance = np.sum((X[i, :] - self._templates)**2, axis=1) #Berechnen Sie den euklidischen Abstand zwischen X und der Vorlage
            idx = np.argsort(distance)[:self._k] #Ermitteln Sie den Index von k Formen mit dem kürzesten Abstand zu X.
            _, count = np.unique(self._classes[idx], return_counts=True) #Berechnen Sie die Anzahl der Vorlagen, die zu jeder Klasse gehören, aus k Vorlagen
            cls = np.where(count == np.max(count))[0] #Identifizieren Sie die Klasse, die die Anzahl der Vorlagen maximiert, zu denen sie gehört
            if len(cls) == 1:
                pred[i] =  cls[0] #Wenn eine Klasse die größte Anzahl von Vorlagen hat, zu denen sie gehört, geben Sie diese Klasse zurück
            else:
                pred[i] =  np.nan #Wenn es mehrere Klassen gibt, die die Anzahl der Vorlagen maximieren, zu denen sie gehören, wird np abgelehnt..Gibt nan zurück
        return pred
    
    def error_rate(self, y_true, y_pred):
        return np.sum(((y_true==1)&(y_pred==0))|((y_true==0)&(y_pred==1)))/len(y_pred) #Berechnen Sie die Fehlerrate, indem Sie Ablehnungen ausschließen
    
    def reject_rate(self, y_pred):
        return np.sum(np.isnan(y_pred))/len(y_pred) #Ablehnungsrate

Lesen von Pima Indian Daten

Die Daten stammen aus R-Datensätzen.

pima_train = pd.read_csv('https://raw.githubusercontent.com/vincentarelbundock/Rdatasets/master/csv/MASS/Pima.tr.csv')
pima_test = pd.read_csv('https://raw.githubusercontent.com/vincentarelbundock/Rdatasets/master/csv/MASS/Pima.te.csv')

--Berechnen Sie die Fehlerrate mit der Holdout-Methode

#Trainingsdaten (X._train, Y_Zug) und Verifizierungsdaten (X)_test, Y_Test-Vorbereitungen
sc = StandardScaler()
X_train = sc.fit_transform(pima_train.drop(['Unnamed: 0', 'type'], axis=1))
Y_train = pima_train['type'].map({'Yes':1, 'No':0}).values

X_test = sc.transform(pima_test.drop(['Unnamed: 0', 'type'], axis=1))
Y_test = pima_test['type'].map({'Yes':1, 'No':0}).values

#Berechnen Sie die Fehlerrate, wenn k (nur ungerade Zahl) geändert wird
hold_out_error_rate_list = np.empty((0,2), int)
for k in range(1, 120, 2):
    knn = kNearestNeiborsClassifier(k=k)
    knn.fit(X_train, Y_train)
    Y_pred = knn.predict(X_test)
    error_rate = knn.error_rate(y_true=Y_test, y_pred=Y_pred)
    hold_out_error_rate_list = np.append(hold_out_error_rate_list, np.array([[k, error_rate]]), axis=0)

--Berechnen Sie die Fehlerrate mit der Ein-Ausschluss-Methode

#Datenaufbereitung
pima = pd.concat([pima_train, pima_test])
sc = StandardScaler()
X = sc.fit_transform(pima.drop(['Unnamed: 0', 'type'], axis=1))
Y = pima['type'].map({'Yes':1, 'No':0}).values

#Berechnen Sie die Fehlerrate, wenn k (nur ungerade Zahl) geändert wird
leave_one_out_error_rate_list = np.empty((0,2), int)
for k in range(1, 120, 2):
    error_list = []
    for i in range(len(X)):
        idx = np.ones(len(X), dtype=bool)
        idx[i] = False #Das Index i-Beispiel wird nicht für das Training verwendet
        
        knn = kNearestNeiborsClassifier(k=k)
        knn.fit(X[idx], Y[idx]) #Lernen Sie mit anderen Beispielen als Index i
        
        Y_pred = knn.predict(X[i].reshape([1, -1]))
        error = knn.error_rate(y_true=Y[i], y_pred=Y_pred) #Validiert mit Beispielindex i
        error_list.append(error)
    error_rate = np.mean(error_list)
    leave_one_out_error_rate_list = np.append(leave_one_out_error_rate_list, np.array([[k, error_rate]]), axis=0)

Änderung der Fehlerrate aufgrund der Differenz in k - Abb. 5.9 (b)

plt.scatter(hold_out_error_rate_list[:, 0], hold_out_error_rate_list[:, 1], label='hold out')
plt.scatter(leave_one_out_error_rate_list[:, 0], leave_one_out_error_rate_list[:, 1], label='leave one out')
plt.legend()
plt.xlabel('k')
plt.ylabel('error rate')
plt.show()

Ausführungsbeispiel 5.3 Bayes'sche Fehlerschätzung

Berechnung der Fehlerrate

#Berechnen Sie die Holdout-Fehlerrate, wenn k (ungerade) geändert wird
odd_error_rate_list = np.empty((0,2), int)
for k in range(1, 62, 2):
    knn = kNearestNeiborsClassifier(k=k)
    knn.fit(X_train, Y_train)
    Y_pred = knn.predict(X_test)
    error_rate = knn.error_rate(y_true=Y_test, y_pred=Y_pred)
    odd_error_rate_list = np.append(odd_error_rate_list, np.array([[k, error_rate]]), axis=0)

#Berechnen Sie die Holdout-Fehlerrate, wenn k (gerade) geändert wird
even_error_rate_list = np.empty((0,2), int)
for k in range(2, 62, 2):
    knn = kNearestNeiborsClassifier(k=k)
    knn.fit(X_train, Y_train)
    Y_pred = knn.predict(X_test)
    error_rate = knn.error_rate(y_true=Y_test, y_pred=Y_pred)
    even_error_rate_list = np.append(even_error_rate_list, np.array([[k, error_rate]]), axis=0)

Fehlerrate - Abb. 5.12 (a)

plt.scatter(odd_error_rate_list[:, 0], odd_error_rate_list[:, 1], label='odd')
plt.scatter(even_error_rate_list[:, 0], even_error_rate_list[:, 1], label='even')
plt.legend()
plt.xlabel('k')
plt.ylabel('error rate')
plt.show()

Berechnung der Ablehnungsrate

reject_rate_list = np.empty((0,2), int)
for k in range(2, 62, 2):
    knn = kNearestNeiborsClassifier(k=k)
    knn.fit(X_train, Y_train)
    Y_pred = knn.predict(X_test)
    reject_rate = knn.reject_rate(y_pred=Y_pred)
    reject_rate_list = np.append(reject_rate_list, np.array([[k, reject_rate]]), axis=0)

Ablehnungsrate - Abb. 5.12 (b)

plt.scatter(reject_rate_list[:, 0], reject_rate_list[:, 1])
plt.xlabel('k')
plt.ylabel('reject rate')
plt.show()

abschließend

Ich habe versucht, das Ausführungsbeispiel von Kapitel 5 von Hajipata in Python auszuführen. Wenn Sie Codefehler oder effizientere Implementierungsmethoden haben, würden wir uns freuen, wenn Sie eine Bearbeitungsanforderung stellen könnten.

Reproduzieren Sie das Ausführungsbeispiel von Kapitel 5 von Hajipata in Python

Einführung

Ausführungsbeispiel 5.2 Finden Sie die optimale Anzahl von Nachbarn k

Ausführungsbeispiel 5.3 Bayes'sche Fehlerschätzung

abschließend