[PYTHON]
Hauptkomponentenanalyse Die Hauptkomponentenanalyse (PCA) ist eine der leistungsstarken Methoden zum Zusammenfassen von Daten (die die Originaldaten mit einer kleinen Anzahl von Daten darstellen). Komprimieren Sie beispielsweise mithilfe der Hauptkomponentenanalyse die Bewertungsdaten für Mathematik und Landessprache (2D) von 10 Schülern. Zeigt das Bild an, das in eine Dimension konvertiert werden soll.
Anstatt die Punktzahl jedes Einzelnen nur mit der mathematischen Punktzahl (1 Dimension) zu erklären, wie in der Abbildung rechts gezeigt Es ist möglich, mit einem kleineren Fehler zu erklären, indem eine neue Achse vorbereitet und neue eindimensionale Daten erstellt werden, wie in der Abbildung links gezeigt.
Die Abbildung links zeigt ein Diagramm der Datenkomprimierung mithilfe der Hauptkomponentenanalyse. Mithilfe der Hauptkomponentenanalyse die Achse (die Achse der ersten Hauptkomponente), die alle Daten am effizientesten erklären kann Es wird eine Achse (Achse der zweiten Hauptkomponente) erstellt, die die Daten erklärt, die von sich aus nicht am effizientesten erklärt werden können.
Denn die erste Hauptkomponente kann die Originaldaten gut ausdrücken Daten können effizient komprimiert werden, indem die Informationen der zweiten Hauptkomponente verworfen (nicht verwendet) werden.
Als praktisches Beispiel für die Analyse von Hauptkomponenten, die Bewertung und den Vergleich von Produkten und Dienstleistungen (auf eine Dimension komprimiert) Datenvisualisierung (auf 2 oder 3 Dimensionen komprimiert), Vorverarbeitung für die Regressionsanalyse usw.
Die Hauptkomponentenanalyse ist äußerst praktisch und zu einem der wichtigsten Themen im Bereich des maschinellen Lernens geworden.
Fluss bis zur Feature-Konvertierung
Die Datenkomprimierung (Feature-Konvertierung) wird gemäß dem folgenden Verfahren unter Verwendung der Hauptkomponentenanalyse durchgeführt.
- Standardisieren Sie die Daten.
- Berechnen Sie die Korrelationsmatrix zwischen Merkmalen.
- Finden Sie den Eigenvektor und den Eigenwert der Korrelationsmatrix.
- Wählen Sie k der erhaltenen Eigenwerte aus den größten und wählen Sie die entsprechenden Eigenvektoren aus. Geben Sie für diesen Wert von k die Anzahl der Dimensionen an, die Sie komprimieren möchten.
- Erstellen Sie eine Feature-Konvertierungsmatrix WW aus k Eigenvektoren.
- Nehmen Sie das Produkt der d-dimensionalen Daten XX und der Matrix WW, um die k-dimensionalen konvertierten Daten X'X 'zu erhalten.
Die folgende Abbildung zeigt ein Bild eines Wein-Datensatzes, der mit Merkmalen transformiert und die Daten von 13 Dimensionen auf 2 Dimensionen zusammengefasst wurden.
Vorbereitung der Daten
Wir werden die Hauptkomponenten analysieren. Die verwendeten Daten sind die im "UCI Machine Learning Repository" veröffentlichten Weindaten. Repräsentiert die Traubentypdaten (Etiketten 1-3) und die chemischen Eigenschaften des Weins für 178 Zeilen Weinprobe Es besteht aus Feature-Daten (13 Typen).
Holen Sie sich die Daten wie folgt.
import pandas as pd
df_wine = pd.read_csv("./5030_unsupervised_learning_data/wine.csv", header = None)
#Merkmalsdaten werden in X und Etikettendaten in y gespeichert.
# df_Die erste Spalte des Weins enthält Etikettendaten, und die zweite und die folgenden Spalten sind Merkmalsdaten.
X, y = df_wine.iloc[:, 1:].values, df_wine.iloc[:, 0].values
print(X.shape)
Standardisierung
Die Weindaten werden im Voraus konvertiert, sodass der Durchschnitt 0 und die Varianz 1 für jede Merkmalsmenge beträgt. Dies nennt man Standardisierung.
Durch die Standardisierung wird es möglich, verschiedene Arten von Daten mit unterschiedlichen Einheiten und Standardwerten wie Alkoholgehalt und Weinton auf dieselbe Weise zu behandeln.
import numpy as np
#Standardisierung
X = (X - X.mean(axis=0)) / X.std(axis=0)
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
df_wine = pd.read_csv("./5030_unsupervised_learning_data/wine.csv", header=None)
X, y = df_wine.iloc[:, 1:].values, df_wine.iloc[:, 0].values
#Visualisieren Sie Daten vor der Standardisierung
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 3))
ax1.set_title('before')
ax2.set_title('before')
ax1.scatter(X[:, 0], X[:, 1])
ax2.scatter(X[:, 5], X[:, 6])
plt.show()
print("before")
print("mean: ", X.mean(axis=0), "\nstd: ", X.std(axis=0))
#Ersetzen Sie X-standardisierte Daten
X = (X - X.mean(axis=0)) / X.std(axis=0)
#Visualisieren Sie Daten nach der Standardisierung
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 3))
ax1.set_title('after')
ax2.set_title('after')
ax1.scatter(X[:, 0], X[:, 1])
ax2.scatter(X[:, 5], X[:, 6])
plt.show()
print("after")
print("mean: ", X.mean(axis=0), "\nstd: ", X.std(axis=0))
Berechnung der Korrelationsmatrix
Berechnen Sie die Korrelationsmatrix der Daten, um die Ähnlichkeit jeder Merkmalsmenge zu überprüfen.
Der Korrelationskoeffizient ist ein Index, der die Stärke der linearen Beziehung zwischen zwei Daten angibt und einen Wert von -1 bis 1 annimmt. Wenn der Korrelationskoeffizient nahe bei 1 liegt (die positive Korrelation ist stark), wenn einer der beiden Daten zunimmt, wie in der Abbildung links gezeigt. Es hat eine linear funktionale Verteilung, in der auch die andere zunimmt.
Wenn die negative Korrelation stark ist, hat sie eine lineare Verteilung, in der eine zunimmt und die andere abnimmt.
Wenn der Korrelationskoeffizient nahe bei 0 liegt, gibt es nicht viel lineare Beziehung, wie in der folgenden Abbildung gezeigt (r = 0).
Hier wird der Korrelationskoeffizient jeder der 13 Arten von Weincharakteristikdaten beibehalten. Finden Sie die 13x13-Korrelationsmatrix. Die zu erhaltende Korrelationsmatrix hat die folgende Form.
Holen Sie sich die Korrelationsmatrix wie folgt. Die corrcoef () -Funktion ist nicht die Korrelation zwischen Spalten (horizontal) Erstellen Sie eine Korrelationsmatrix für jede Korrelation zwischen Zeilen (vertikale Richtung). Wenn daher nichts unternommen wird, ist die Korrelationsmatrix zwischen den Daten Ich werde gefragt.
X wird in X.T transponiert, um die Korrelationsmatrix zwischen Merkmalen anstelle von Daten zu finden
import numpy as np
R = np.corrcoef(X.T)
Es ist eine Evolutionsgeschichte, aber die Korrelationsmatrix selbst kann vor der Standardisierung auf die gleiche Weise mit X berechnet werden. Für später vorstandardisiert.
Es gibt auch eine Hauptkomponentenanalyse, die eine Kovarianzmatrix anstelle einer Korrelationsmatrix verwendet.
Der Code zum Erstellen einer quadratischen Einheitsmatrix lautet wie folgt.
import numpy as np
# np.identity(Matrixgröße)
identity = np.identity(3)
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
Als praktische Methode
import pandas as pd
import numpy as np
df_wine = pd.read_csv("./5030_unsupervised_learning_data/wine.csv", header=None)
X, y = df_wine.iloc[:, 1:].values, df_wine.iloc[:, 0].values
#Erstellen Sie eine Korrelationsmatrix (13x13)
R = np.corrcoef(X.T)
#Diagonale Komponente 0
_R = R - np.identity(13)
#Ermitteln Sie den Index, der den maximalen Korrelationskoeffizienten verwendet
index = np.where(_R == _R.max())
print(R[index[0][0], index[1][0]])
print(index)
Einzigartige Wertzerlegung
Wenden Sie als nächstes eine mathematische Methode an, die als Eigenwertzerlegung bezeichnet wird, auf die erhaltene Korrelationsmatrix. Ruft den Eigenvektor und den Eigenwert ab.
Wenn eine Eigenwertzerlegung durchgeführt wird, besteht die ursprüngliche 13 × 13-dimensionale Matrix R aus 13 speziellen 13-dimensionalen Vektoren.
(Eindeutiger Vektor)
Und 13 Sonderzahlen
(Eindeutiger Wert)
Wird zerlegt in.
Intuitiv enthält die ursprüngliche Matrix Informationen, die in Richtung des Eigenvektors konzentriert sind. Man kann sagen, dass der entsprechende eindeutige Wert den Konzentrationsgrad der Information angibt.
Sie können numpy verwenden, um die Eigenwertzerlegung wie folgt zu berechnen: 13 Eigenwerte und 13 Eigenvektoren von R werden in Eigvalen bzw. Eigveken gespeichert.
import numpy as np
#Holen Sie sich das Eigenpaar aus der Korrelationsmatrix. numpy.linalg.acht gibt sie in aufsteigender Reihenfolge der Eigenwerte zurück
eigvals, eigvecs = np.linalg.eigh(R)
Die Korrelationsmatrix R, die Matrix V mit Eigenvektoren und die Diagonalmatrix D mit Eigenwerten erfüllen die folgenden Gleichungen.
Die Elemente sind wie folgt.
Der Eigenvektor der Korrelationsmatrix repräsentiert den Hauptkomponentenvektor Die Komponenten des Eigenvektors zeigen die Auswirkung jedes Merkmals auf die Hauptkomponente.
Auch der einem größeren Eigenwert entsprechende Eigenvektor ist stark an der Zusammensetzung der ursprünglichen Matrix beteiligt.
Mit anderen Worten, durch Ignorieren des Eigenvektors (Hauptkomponentenvektor), der dem kleinen Eigenwert entspricht Informationsverlust kann unterdrückt werden, während die Anzahl der Funktionen reduziert wird.
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
df_wine = pd.read_csv("./5030_unsupervised_learning_data/wine.csv", header=None)
X, y = df_wine.iloc[:, 1:].values, df_wine.iloc[:, 0].values
#Erstellen Sie eine Korrelationsmatrix (13x13)
R = np.corrcoef(X.T)
#Einzigartige Wertzerlegung
eigvals, eigvecs = np.linalg.eigh(R)
#Visualisierung
plt.bar(range(13), eigvals)
plt.title("distribution of eigvals")
plt.xlabel("index")
plt.ylabel("eigvals")
plt.show()
#Bitte löschen Sie es nicht. Es wird verwendet, um das Ausführungsergebnis zu überprüfen.
print(eigvals)
Feature-Konvertierung
In der vorherigen Sitzung haben wir die Korrelationsmatrix in Eigenwerte und Eigenvektoren zerlegt. Dann werden die beiden Eigenvektoren verwendet, die dem größten Eigenwert und dem zweitgrößten Eigenwert entsprechen.
Erstellen Sie eine 13x2-Matrix W, die 13-dimensionale Features in 2 Dimensionen konvertiert, und erstellen Sie Wine-Daten X mit 13-dimensionalen Features. Konvertiert in neue Wine-Daten X 'mit nur den zweidimensionalen Merkmalen der ersten und zweiten Hauptkomponente.
Erstellen Sie die Konvertierungsmatrix W wie folgt.
#Verkettet die Eigenvektoren, die den größten und zweitgrößten Eigenwerten in Spaltenrichtung entsprechen
W = np.c_[eigvecs[:,-1], eigvecs[:,-2]]
Aus dem Obigen wurde eine 13-mal-2-Matrix erstellt. Darüber hinaus ist es durch Nehmen des Produkts dieser Matrix W und der Originaldaten X möglich, eine mit X komprimierte Matrix X'zu erzeugen.
Die Berechnung des Matrixprodukts erfolgt nach folgendem Code
import numpy as np
X_pca = X.dot(W)
Unter Verwendung des Eigenvektors und des Eigenwerts gilt auch die folgende Gleichung.
Die beiden Eigenwerte vom größten seien λ1, λ2 und die entsprechenden Eigenvektoren seien v1 und v2. Diese v1 und v2 sind Konvertierungsmatrizen.
Das Multiplizieren von R mit dem Eigenvektor v1 ergibt neue Daten, die sich gut in Richtung v1 erstrecken (große Varianz)
Das Multiplizieren von R mit dem Eigenvektor v2 ist orthogonal zum Vektor v1 (kann nicht durch v1 erklärt werden). Sie können neue Daten erhalten, die in v2-Richtung gut wachsen (mit einer großen Streuung).
In ähnlicher Weise wird X mit den Eigenvektoren v1 und v2 multipliziert Sie können Feature-Daten erhalten, die sich gut in zwei orthogonale Richtungen erstrecken.
Hauptkomponentenanalyse mit Scikit-Learn
Bisher haben wir die Feature-Konvertierung mithilfe der Hauptkomponentenanalyse implementiert. Tatsächlich können Sie mit der PCA-Klasse in sklearn.decomposition ganz einfach dasselbe tun. Verwenden Sie die PCA-Klasse wie folgt.
from sklearn.decomposition import PCA
#Erstellen Sie eine PCA-Instanz, indem Sie die Anzahl der Hauptkomponenten angeben. Geben Sie die Anzahl der Dimensionen nach der Konvertierung mit einem Argument an.
pca = PCA(n_components=2)
#Lernen Sie das Transformationsmodell aus den Daten und transformieren Sie es.
X_pca = pca.fit_transform(X)
Die Methode fit_transform () generiert automatisch intern eine Transformationsmatrix.
Hauptkomponentenanalyse als Vorbehandlung
Unter Anwendung des bisher Gelernten wenden wir die Hauptkomponentenanalyse auf die Vorverarbeitung der Regressionsanalyse an. Durch vorheriges Komprimieren der Daten ist es möglich, ein vielseitigeres Regressionsanalysemodell zu generieren, das gegen Störungen wie Ausreißer resistent ist.
Teilen Sie die Daten zunächst in Trainingsdaten und Testdaten auf.
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=0)
Wenn beim Durchführen einer Merkmalskonvertierung unterschiedliche Konvertierungsmatrizen für Trainingsdaten und Testdaten erhalten werden, wird eine Merkmalskonvertierung durchgeführt. Es ist nicht möglich, die Daten nach der Feature-Konvertierung zu vergleichen, da die Konvertierungsmatrix unterschiedlich ist.
Gleiches gilt für die Standardisierung. Dies kann unpraktisch sein
Verwenden Sie bei der Durchführung von Standardisierungs- und Hauptkomponentenanalysen gemeinsame Kriterien für Trainings- und Testdaten.
Bei der Standardisierung ist es zweckmäßig, die StandardScalar-Klasse wie folgt zu verwenden.
from sklearn.preprocessing import StandardScaler
#Erstellen Sie eine Instanz für die Standardisierung
sc = StandardScaler()
#Lernen Sie das Transformationsmodell aus den Trainingsdaten und wenden Sie dasselbe Modell auf die Testdaten an
X_train_std = sc.fit_transform(X_train)
X_test_std = sc.transform(X_test)
Verwenden Sie bei der Analyse der Hauptkomponenten die folgende PCA-Klasse.
from sklearn.decomposition import PCA
#Generieren Sie eine Instanz der Hauptkomponentenanalyse
pca = PCA(n_components=2)
#Lernen Sie das Transformationsmodell aus den Trainingsdaten und wenden Sie dasselbe Modell auf die Testdaten an
X_train_pca = pca.fit_transform(X_train_std)
X_test_pca = pca.transform(X_test_std)
Zur Überprüfung wird die Regressionsanalyse wie folgt durchgeführt.
from sklearn.linear_model import LogisticRegression
#Generieren Sie eine Instanz der logistischen Regression
lr = LogisticRegression()
#Klassifizierungsmodell lernen
lr.fit(X, y)
#Punktzahl anzeigen
print(lr.score(X, y))
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
df_wine = pd.read_csv("./5030_unsupervised_learning_data/wine.csv", header=None)
X, y = df_wine.iloc[:, 1:].values, df_wine.iloc[:, 0].values
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.4, random_state=0)
#Erstellen Sie eine Instanz für die Standardisierung
sc = StandardScaler()
#Lernen Sie das Transformationsmodell aus den Trainingsdaten und wenden Sie es auf die Testdaten an
X_train_std = sc.fit_transform(X_train)
X_test_std = sc.transform(X_test)
#Generieren Sie eine Instanz der Hauptkomponentenanalyse
pca = PCA(n_components=2)
#Lernen Sie das Transformationsmodell aus den Trainingsdaten und wenden Sie es auf die Testdaten an
X_train_pca = pca.fit_transform(X_train_std)
X_test_pca = pca.transform(X_test_std)
#Generieren Sie eine Instanz der logistischen Regression
lr = LogisticRegression()
#Lernen Sie das Klassifizierungsmodell mit Trainingsdaten nach der Dimensionsreduktion
lr.fit(X_train_pca, y_train)
#Punktzahl anzeigen
print(lr.score(X_train_pca, y_train))
print(lr.score(X_test_pca, y_test))
Kernel-Hauptkomponentenanalyse
Kernel-Hauptkomponentenanalyse
Viele Algorithmen für maschinelles Lernen, wie beispielsweise die Regressionsanalyse, können linear getrennt werden Es wird davon ausgegangen, dass die Daten angegeben werden. In der Praxis sind Daten jedoch schwer linear zu trennen Mit anderen Worten, die meisten Daten müssen nicht linear getrennt werden. In dieser Sitzung eine Kernel-PCA, die Daten verarbeiten kann, die nicht linear getrennt werden müssen.
"Kernel PCA(kernel PCA)Wird in diesem Abschnitt behandelt.
Zunächst mit Kernel PCA Daten X eines gegebenen NxM (Anzahl der Daten x Art des Merkmals) Remake es in Daten K von völlig neuem NxM´ (Anzahl der Daten x Art der Features) (Kernel-Trick).
Wenn Kernel-Tricks verwendet werden, nehmen die Arten von Features im Allgemeinen zu (Features werden erweitert). Dies erleichtert die lineare Trennung.
Es ist bekannt, dass die Verwendung der Hauptkomponentenanalyse für stark nichtlineare Daten nicht funktioniert. Durch Erweitern der Daten auf die Kernelmatrix K wird es möglich, eine Hauptkomponentenanalyse durchzuführen.
Die folgende Abbildung zeigt zweidimensionale Daten, die nach dem Erhöhen der Features mithilfe von Kernel-Tricks in einem Kreis verteilt sind. Es ist die Zahl, die die Hauptkomponentenanalyse durchgeführt und die Merkmalsmenge auf zwei zurückgesetzt und aufgetragen hat.
Unter Verwendung der Kernel-PCA können die folgenden Daten erhalten werden, die im zweidimensionalen Raum nicht linear getrennt werden können. Es kann in linear trennbare Daten konvertiert werden.
Kernel-Trick 1
Berechnen Sie zunächst die Kernel-Matrix K. Die folgende Matrix wird als Kernelmatrix bezeichnet, und die Ähnlichkeit wird für jedes Paar von Beispieldaten berechnet. Die Kernelmatrix der Daten X von N x M (Anzahl der Daten x Art der Merkmale) ist Es wird N x N (Anzahl der Daten x Anzahl der Daten). Sie können die Kernelmatrix K wie Daten behandeln und Analysen wie Regression und Klassifizierung durchführen.
Hier gezeigt
Ist
Es wird als "Kernelfunktion" bezeichnet und es gibt verschiedene Typen.
Dieses Mal werden wir die Kernelfunktion "Gaußscher Kernel" in "Radio-based function (RBF)" verwenden, die durch die folgende Formel ausgedrückt wird. Zwei Daten mit dieser Formel
Repräsentiert den Ähnlichkeitsgrad.
Wie X repräsentiert K einzelne Daten in Zeilen und Features (Ähnlichkeit mit anderen Daten) in Spalten.
Hier
ist unten Es ist eine Funktion des Graphen wie.
を大きくするとより近接するものだけに注目したような特徴量行列Kが作られます。
Kernel-Trick 2
Implementieren Sie die folgenden Funktionen, die für Kernel-Tricks verwendet werden.
Sie können die Kernelmatrix wie folgt berechnen:
#Berechnen Sie das Quadrat der Entfernung zwischen Daten (quadratische euklidische Entfernung)
M = np.sum((X - X[:, np.newaxis])**2, axis=2)
#Berechnen Sie die Kernel-Matrix
K = np.exp(-gamma * M)
Um den Abstand zwischen Daten zu ermitteln, wird hier eine Funktion namens Numpy Array Broadcast verwendet (Erweitert die Matrix automatisch, richtet die Form der Matrix aus und führt die Operation aus.)
import numpy as np
np.random.seed(39)
X = np.random.rand(8, 3)
#Berechnen Sie den quadratischen euklidischen Abstand pro Paar
M =np.sum((X - X[:, np.newaxis])**2, axis=2)
#Berechnen Sie die Kernel-Matrix
gamma = 15
K = np.exp(-gamma * M)
# ---------------------------
#K ist ein numpy Array.
#Die Größe des Numpy-Arrays A kann wie folgt ermittelt und angezeigt werden.
print(K.shape)
#
# ---------------------------
print(M) #Bitte löschen Sie es nicht. Es wird verwendet, um das Ausführungsergebnis zu überprüfen.
print(K) #Bitte löschen Sie es nicht. Es wird verwendet, um das Ausführungsergebnis zu überprüfen.
Feature-Konvertierung
Ersetzen der ursprünglichen Daten X durch die Kernelmatrix K durch K wie bei der Standardmethode zur Analyse der Hauptkomponenten Es kann in linear trennbare Daten X 'umgewandelt werden, indem eine Eigenwertzerlegung, Merkmalsumwandlung usw. durchgeführt wird.
Ursprünglich ist K eine Erweiterung der Merkmalsmenge von X, so dass die durch Merkmalsumwandlung von K erhaltene Matrix ist Es kann als transformierte Matrix von X-Merkmalen behandelt werden.
Mit dem, was wir bisher gelernt haben, werden wir die zirkulären Daten mithilfe der Kernel-Hauptkomponentenanalyse in Features umwandeln.
Als Entwicklung Die aus dem Eigenvektor der Kernmatrix K erzeugte Umwandlungsmatrix W ist Sie können X auch so behandeln, wie es ist, als X ', das dimensional komprimiert und zusammengefasst wird.
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_circles
#Holen Sie sich Daten, bei denen die Daten in einem Kreis verteilt sind
X, y = make_circles(n_samples=1000, random_state=123, noise=0.1, factor=0.2)
#Berechnen Sie den quadratischen euklidischen Abstand pro Paar
M = np.sum((X - X[:, np.newaxis])**2, axis=2)
#Berechnen Sie die symmetrische Kernelmatrix
gamma = 15
K = np.exp(-gamma * M)
#Holen Sie sich das eindeutige Paar aus der Kernel-Matrix. numpy.linalg.acht gibt sie in aufsteigender Reihenfolge der Eigenwerte zurück
eigvals, eigvecs = np.linalg.eigh(K)
#Top k Eigenvektoren(Projizierte Probe)Sammeln
W = np.column_stack((eigvecs[:, -1], eigvecs[:, -2]))
#Finden Sie das innere Produkt von K und W, um linear trennbare Daten zu erhalten.
X_kpca = K.dot(W)
#Visualisierung
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 3))
ax1.scatter(X[y == 0, 0], X[y == 0, 1], color="r", marker="^")
ax1.scatter(X[y == 1, 0], X[y == 1, 1], color="b", marker="o")
ax2.scatter(X_kpca[y == 0, 0], X_kpca[y == 0, 1], color="r", marker="^")
ax2.scatter(X_kpca[y == 1, 0], X_kpca[y == 1, 1], color="b", marker="o")
ax1.set_title("circle_data")
ax2.set_title("kernel_pca")
plt.show()
print(M) #Bitte löschen Sie es nicht. Es wird verwendet, um das Ausführungsergebnis zu überprüfen.
print(K) #Bitte löschen Sie es nicht. Es wird verwendet, um das Ausführungsergebnis zu überprüfen.
print(W) #Bitte löschen Sie es nicht. Es wird verwendet, um das Ausführungsergebnis zu überprüfen.
print(X_kpca) #Bitte löschen Sie es nicht. Es wird verwendet, um das Ausführungsergebnis zu überprüfen.
Kernel-Hauptkomponentenanalyse mit scikit-learn
Die Kernel-Hauptkomponentenanalyse ähnelt der Standard-PCA
sklearn.Einfache Implementierung durch Zerlegung.
Die Verwendung entspricht fast der Standard-PCA. Mit Argumenten können Sie die Anzahl der komprimierten Dimensionen und den Kerneltyp angeben, der in der Standard-PCA nicht enthalten ist.
from sklearn.decomposition import KernelPCA
#Der diesmal verwendete Kernel (radiale Basisfunktion) ist der Kernel="rbf"Kann mit angegeben werden.
kpca = KernelPCA(n_components=2, kernel="rbf", gamma=15)
X_kpca = kpca.fit_transform(X)
Hier werden die mondförmigen Daten wie in der folgenden Abbildung gezeigt getrennt. Holen Sie sich die Daten wie folgt:
from sklearn.datasets import make_moons
#Holen Sie sich Monddaten
X, y = make_moons(n_samples=100, random_state=123)
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
#Kernel-PCA importieren
# ---------------------------
from sklearn.decomposition import KernelPCA
# ---------------------------
#Holen Sie sich Monddaten
X, y = make_moons(n_samples=100, random_state=123)
#Instanziieren Sie die KernelPCA-Klasse
kpca = KernelPCA(n_components=2, kernel="rbf", gamma=15)
#Konvertieren Sie Daten X mit Kernel PCA
X_kpca = kpca.fit_transform(X)
#Visualisierung
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 3))
ax1.scatter(X[y == 0, 0], X[y == 0, 1], c="r")
ax1.scatter(X[y == 1, 0], X[y == 1, 1], c="b")
ax1.set_title("moon_data")
ax2.scatter(X_kpca[y == 0, 0], X_kpca[y == 0, 1], c="r")
ax2.scatter(X_kpca[y == 1, 0], X_kpca[y == 1, 1], c="b")
ax2.set_title("kernel_PCA")
plt.show()
print(X_kpca) #Bitte löschen Sie es nicht. Es wird verwendet, um das Ausführungsergebnis zu überprüfen.
Recommended Posts