Überwachtes Lernen mithilfe der Kernel-Dichteschätzung

Dieser Artikel wurde von Anfängern des maschinellen Lernens verfasst. Bitte beachten Sie.

Der vorherige Artikel war hier. Der nächste Artikel ist hier.

Beziehung zwischen Kernel-Dichteschätzung und überwachtem Lernen

Ich habe es ohne Erlaubnis verbunden. Weitere Informationen (nicht sehr detailliert) finden Sie im vorherigen Artikel (https://qiita.com/sorax/items/8663906fae41798a00b8). Die einfache Zusammenfassung lautet "Ich habe versucht, die Kernel-Dichteschätzung als Klassifikator für überwachtes Lernen zu verwenden!".

Objektorientierung

Ich habe das in Vorheriger Artikel zusammengefasste Skript so geändert, dass es objektorientiert ist. Der Name lautet "Gaußscher Kernel-Dichteschätzungsklassifikator" oder kurz "GKDE-Klassifikator". Ich habe es nur willkürlich benannt.

↓ Skript ↓

import numpy as np

class GKDEClassifier(object):
    
    def __init__(self, bw_method="scotts_factor", weights="None"):
 # Kernelbandbreite
        self.bw_method = bw_method
 # Kerngewicht
        self.weights = weights
        
    def fit(self, X, y):
 Anzahl der Etiketten für # y
        self.y_num = len(np.unique(y))
 # Liste mit geschätzten Wahrscheinlichkeitsdichtefunktionen
        self.kernel_ = []
 # Speichern Sie die Wahrscheinlichkeitsdichtefunktion
        for i in range(self.y_num):
            kernel = gaussian_kde(X[y==i].T)
            self.kernel_.append(kernel)
        return self

    def predict(self, X):
 # Liste zum Speichern von Vorhersageetiketten
        pred = []
 #Liste, in der die Wahrscheinlichkeiten nach Bezeichnung der Testdaten gespeichert werden
        self.p_ = []
 # Speichern Sie die Wahrscheinlichkeit nach Etikett
        for i in range(self.y_num):
            self.p_.append(self.kernel_[i].evaluate(X.T).tolist())
 # ndarray
        self.p_ = np.array(self.p_)
 # Zuweisung von Vorhersageetiketten
        for j in range(self.p_.shape[1]):
            pred.append(np.argmax(self.p_.T[j]))
        return pred

Weisen Sie Beschriftungen in der Reihenfolge 0, 1, 2 ... zu (in aufsteigender Reihenfolge nicht negativer Ganzzahlen). Vielleicht: LabelEncoder

(Hinzugefügt am 08.08.2018: Teil 3 hat den geänderten Code veröffentlicht.)

\ _ \ _ Init \ _ \ _ Methode

Initialisiert das Objekt. Geben Sie hier die Parameter an, die für die Schätzung der Kerneldichte erforderlich sind, dh die Argumente, die für die Initialisierung von gaussian_kde von SciPy erforderlich sind. Dieses Mal habe ich den gleichen Wert wie den Standardwert von gaussian_kde festgelegt.

Anpassungsmethode

Das Lernen wird anhand von Lehrerdaten durchgeführt. Nach dem Schätzen der Kerneldichte mit gaussian_kde werden die geschätzte Dichtefunktion von Label 0, die geschätzte Dichtefunktion von Label 1 usw. der Reihe nach gespeichert.

Vorhersagemethode

Testdaten vorhersagen.

for i in range(self.y_num):
            self.p_.append(self.kernel_[i].evaluate(X.T).tolist())

Hier werden die geschätzten Dichtefunktionen einzeln aus kernel_ extrahiert und die Wahrscheinlichkeitsdichte der Testdaten berechnet.

Nachfolgende Skripte sind durcheinander. Ich wollte es prägnanter schreiben, aber es hat sich nicht so verhalten, wie ich es erwartet hatte ... Es gibt einen Codierungsanfänger. Beweg dich einfach. Es ist besser, sich nur zu bewegen.

Aus diesem Grund ist der objektorientierte Klassifikator zur Schätzung der Gaußschen Kerndichte vollständig.

Wein-Datensatz

Kombination mit PCA

Der Weindatensatz enthält 13 Funktionen, wird jedoch nach der Standardisierung auf 4 Dimensionen reduziert. Lassen Sie uns nach der Dimensionsreduktion lernen und mit den Daten klassifizieren.

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

# Datensatz laden
wine = datasets.load_wine()
X = wine.data
y = wine.target

# Datenaufteilung
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
random_state=1, stratify=y)

# Standardisierung
sc = StandardScaler()
sc = sc.fit(X_train)
X_train_std = sc.transform(X_train)
X_test_std = sc.transform(X_test)

# Dimensionsreduzierung
pca = PCA(n_components=4)
X_train_pca = pca.fit_transform(X_train_std)
X_test_pca = pca.transform(X_test_std)

# Lernen und Vorhersagen
f = GKDEClassifier()
f.fit(X_train_pca, y_train)
y_pred = f.predict(X_test_pca)

Ergebnis ist ……?

from sklearn.metrics import accuracy_score

print(accuracy_score(y_test, y_pred))
 0.9722222222222222

Hurra. Da es 36 Testdaten gibt, beträgt die korrekte Antwortrate 35/36. Es ist sehr gut.

Keine Dimensionsreduzierung

Was wird passieren?

# Lernen und Vorhersagen
f = GKDEClassifier()
f.fit(X_train_std, y_train)
y_pred = f.predict(X_test_std)

print(accuracy_score(y_test, y_pred))
 0.9722222222222222

Ergebnis: Gleich.

Rundschreiben

Ich habe einen kreisförmigen Datensatz erstellt.

from sklearn.datasets import make_circles
from matplotlib import pyplot as plt

X, y = make_circles(n_samples=1000, random_state=1, noise=0.1, factor=0.2)
plt.scatter(X[y==0, 0], X[y==0, 1], c="red", marker="^", alpha=0.5)
plt.scatter(X[y==1, 0], X[y==1, 1], c="blue", marker="o", alpha=0.5)
plt.show()

Das Etikett ist in der Mitte und am äußeren Rand unterschiedlich. Können Sie es richtig klassifizieren?

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,
random_state=1, stratify=y)

f = GKDEClassifier()
f.fit(X_train, y_train)
y_pred = f.predict(X_test)

print(accuracy_score(y_test, y_pred))
 0.9933333333333333

Fazit: Großer Sieg.

Schließlich

Es wurde so gut kategorisiert, aber ich habe vergessen, was wichtig ist. Das ist die akademische Korrektheit dieser Klassifizierungsmethode. Nächstes Mal werde ich darüber diskutieren.

Fortsetzung auf Teil 3

[PYTHON] [Maschinelles Lernen] Überwachtes Lernen mithilfe der Kernel-Dichteschätzung Teil 2