Kernel-Approximationstechniken in Scikit-Learn

Einführung

In diesem Tutorial wird Ihnen der Prozess des Einsatzes von Kernel-Approximationstechniken in scikit-learn erklärt.

Kernel-Methoden wie Support Vector Machines (SVM) sind leistungsstarke Techniken zur nicht-linearen Klassifikation. Diese Methoden basieren auf dem Konzept einer Kernel-Funktion, die die Eingabedaten in einen hochdimensionalen Merkmalsraum abbildet. Arbeiten mit expliziten Merkmalsabbildungen kann jedoch rechenintensiv sein, insbesondere für große Datensätze. Kernel-Approximationsmethoden bieten eine Lösung, indem sie niedrigdimensionale Approximationen des Kernel-Merkmalsraums generieren.

In diesem Tutorial werden wir mehrere Kernel-Approximationstechniken in scikit-learn erkunden, darunter die Nystroem-Methode, die Approximation des Radial Basis Function (RBF)-Kernels, die Approximation des Additive Chi Squared (ACS)-Kernels, die Approximation des Skewed Chi Squared (SCS)-Kernels und die Polynomkernel-Approximation mit Tensor Sketch. Wir werden zeigen, wie diese Techniken verwendet werden, und diskutieren ihre Vor- und Nachteile.

VM-Tipps

Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Skills Graph

Nystroem-Methode zur Kernel-Approximation

Die Nystroem-Methode ist eine allgemeine Technik zur Approximation von Kernen unter Verwendung einer niedergradigen Approximation. Sie entnimmt einer Stichprobe des Datensatzes, auf dem der Kernel ausgewertet wird. Standardmäßig verwendet sie den RBF-Kernel, kann aber mit jeder Kernel-Funktion oder einer vorgegebenen Kernel-Matrix verwendet werden.

Um die Nystroem-Methode zur Kernel-Approximation zu verwenden, führen Sie die folgenden Schritte aus:

1. Initialisieren Sie das Nystroem-Objekt mit der gewünschten Anzahl von Komponenten (d.h., der Ziel-Dimensionalität der Merkmalstransformation).

from sklearn.kernel_approximation import Nystroem

n_components = 100
nystroem = Nystroem(n_components=n_components)

2. Passen Sie das Nystroem-Objekt an Ihre Trainingsdaten an.

nystroem.fit(X_train)

3. Transformieren Sie Ihre Trainings- und Testdaten mit dem Nystroem-Objekt.

X_train_transformed = nystroem.transform(X_train)
X_test_transformed = nystroem.transform(X_test)

Radial Basis Function (RBF)-Kernel-Approximation

Die RBFSampler-Klasse implementiert eine approximative Abbildung für den RBF-Kernel, auch bekannt als Random Kitchen Sinks. Diese Technik ermöglicht es uns, eine Kernel-Abbildung explizit zu modellieren, bevor wir ein lineares Algorithmus wie linearer SVM oder logistische Regression anwenden.

Um RBFSampler zur Kernel-Approximation zu verwenden, führen Sie die folgenden Schritte aus:

1. Initialisieren Sie das RBFSampler-Objekt mit dem gewünschten Wert von gamma (dem Parameter des RBF-Kernels) und der Anzahl der Komponenten.

from sklearn.kernel_approximation import RBFSampler

gamma = 0.1
n_components = 100
rbf_sampler = RBFSampler(gamma=gamma, n_components=n_components)

2. Passen Sie das RBFSampler-Objekt an Ihre Trainingsdaten an.

rbf_sampler.fit(X_train)

3. Transformieren Sie Ihre Trainings- und Testdaten mit dem RBFSampler-Objekt.

X_train_transformed = rbf_sampler.transform(X_train)
X_test_transformed = rbf_sampler.transform(X_test)

Additive Chi Squared (ACS)-Kernel-Approximation

Der ACS-Kernel ist ein Kernel für Histogramme, der in der Computer Vision häufig verwendet wird. Die AdditiveChi2Sampler-Klasse bietet eine approximative Abbildung für diesen Kernel.

Um AdditiveChi2Sampler zur Kernel-Approximation zu verwenden, führen Sie die folgenden Schritte aus:

1. Initialisieren Sie das AdditiveChi2Sampler-Objekt mit der gewünschten Anzahl von Proben (n) und dem Regularisierungsparameter (c).

from sklearn.kernel_approximation import AdditiveChi2Sampler

n_samples = 1000
c = 1.0
additive_chi2_sampler = AdditiveChi2Sampler(n_samples=n_samples, sample_steps=2, sample_interval=2, sample_octave=2, c=c)

2. Passen Sie das AdditiveChi2Sampler-Objekt an Ihre Trainingsdaten an.

additive_chi2_sampler.fit(X_train)

3. Transformieren Sie Ihre Trainings- und Testdaten mit dem AdditiveChi2Sampler-Objekt.

X_train_transformed = additive_chi2_sampler.transform(X_train)
X_test_transformed = additive_chi2_sampler.transform(X_test)

Skewed Chi Squared (SCS)-Kernel-Approximation

Der SCS-Kernel ist eine Variante des exponentiierten chi quadrat-Kernels, der eine einfache Monte Carlo-Approximation der Merkmalsabbildung ermöglicht. Die SkewedChi2Sampler-Klasse bietet eine approximative Abbildung für diesen Kernel.

Um SkewedChi2Sampler zur Kernel-Approximation zu verwenden, führen Sie die folgenden Schritte aus:

1. Initialisieren Sie das SkewedChi2Sampler-Objekt mit der gewünschten Anzahl von Proben (n) und dem Regularisierungsparameter (c).

from sklearn.kernel_approximation import SkewedChi2Sampler

n_samples = 1000
c = 1.0
skewed_chi2_sampler = SkewedChi2Sampler(n_samples=n_samples, sample_steps=2, sample_interval=2, sample_octave=1, c=c)

2. Passen Sie das SkewedChi2Sampler-Objekt an Ihre Trainingsdaten an.

skewed_chi2_sampler.fit(X_train)

3. Transformieren Sie Ihre Trainings- und Testdaten mit dem SkewedChi2Sampler-Objekt.

X_train_transformed = skewed_chi2_sampler.transform(X_train)
X_test_transformed = skewed_chi2_sampler.transform(X_test)

Polynomkernel-Approximation über Tensor Sketch

Der Polynomkernel ist eine beliebte Kernel-Funktion, die Interaktionen zwischen Merkmalen modelliert. Die PolynomialCountSketch-Klasse bietet eine skalierbare Methode zur Approximation dieses Kerns unter Verwendung des TensorSketch-Ansatzes.

Um PolynomialCountSketch zur Kernel-Approximation zu verwenden, führen Sie die folgenden Schritte aus:

1. Initialisieren Sie das PolynomialCountSketch-Objekt mit dem gewünschten Grad (d) und der Anzahl der Komponenten.

from sklearn.kernel_approximation import PolynomialCountSketch

degree = 3
n_components = 100
polynomial_count_sketch = PolynomialCountSketch(degree=degree, n_components=n_components)

2. Passen Sie das PolynomialCountSketch-Objekt an Ihre Trainingsdaten an.

polynomial_count_sketch.fit(X_train)

3. Transformieren Sie Ihre Trainings- und Testdaten mit dem PolynomialCountSketch-Objekt.

X_train_transformed = polynomial_count_sketch.transform(X_train)
X_test_transformed = polynomial_count_sketch.transform(X_test)

Zusammenfassung

Die Kernel-Approximation ist eine leistungsstarke Technik, die es uns ermöglicht, Kernel-Methoden effizient zu verwenden, insbesondere für große Datensätze. In diesem Tutorial haben wir mehrere Kernel-Approximationsmethoden in scikit-learn untersucht, darunter die Nystroem-Methode, die RBF-Kernel-Approximation, die ACS-Kernel-Approximation, die SCS-Kernel-Approximation und die Polynomkernel-Approximation über Tensor Sketch. Wir haben gelernt, wie diese Techniken verwendet werden, und diskutiert ihre Vor- und Nachteile. Indem wir die Kernel-Approximation nutzen, können wir Kernel-Methoden effektiv auf eine Vielzahl von maschinellen Lernaufgaben anwenden.