Einführung

Dieses Mal werde ich die Theorie über die Support-Vektor-Maschine zusammenfassen, die einer der Algorithmen für maschinelles Lernen ist.

Ich würde es begrüßen, wenn Sie mit mir auskommen könnten.

Unterstützung der Vektormaschinentheorie

Lassen Sie uns zunächst die Theorie der Support-Vektor-Maschinen zusammenfassen.

Harter und weicher Rand

Die Support Vector Machine (svm) ist einer der Algorithmen für maschinelles Lernen, die im Bereich der Datenanalyse aufgrund ihrer Generalisierungsleistung und ihres breiten Anwendungsbereichs häufig verwendet werden.

Es wird hauptsächlich für binäre Klassifizierungsprobleme verwendet, die auf der Idee der Maximierung der Margen basieren. Es kann auch auf Klassifizierungs- und Regressionsprobleme mehrerer Klassen angewendet werden.

Es hat die Schwäche, dass es aufgrund seines hohen Rechenaufwands im Vergleich zu anderen Algorithmen für maschinelles Lernen nicht für große Datenmengen geeignet ist.

Ein Rand, der linear trennbare Daten (in zwei durch eine gerade Linie geteilt) voraussetzt, wird als "harter Rand" bezeichnet, und ein Rand, der eine Fehldiskriminierung aufgrund nicht linear trennbarer Daten ermöglicht, wird als "weicher Rand" bezeichnet. Ich werde.

Ich schrieb, dass die lineare Trennbarkeit durch eine gerade Linie in zwei Teile geteilt werden kann, aber da dies nur für zweidimensionale Daten gilt, verallgemeinere ich das Konzept der linearen Trennbarkeit auf eine Menge im n-dimensionalen Raum. Die Fähigkeit, sich in einer n-1-dimensionalen Superebene zu trennen, ist als linear trennbar definiert.

Wenn Daten auf einer zweidimensionalen Ebene durch eine eindimensionale Linie klassifiziert werden können, spricht man von einer linearen Trennbarkeit. Wenn Daten in einem dreidimensionalen Raum durch eine zweidimensionale Ebene klassifiziert werden können, kann auch gesagt werden, dass eine lineare Trennung möglich ist.

Auf diese Weise wird die n-1-dimensionale Ebene (nicht ausschließlich eine Ebene), die n-dimensionale Daten klassifiziert, als "getrennte Superebene" bezeichnet, und der Abstand zwischen der getrennten Superebene und den Daten, die der getrennten Superebene am nächsten liegen. Wird als "Rand" bezeichnet und das Ziel dieses Algorithmus ist es, diesen Rand zu maximieren.

Außerdem werden die Daten, die der "getrennten Superebene" am nächsten liegen, als "Unterstützungsvektor" bezeichnet. Unten abgebildet.

Es ist intuitiv klar, dass Sie die Genauigkeit erhöhen können, indem Sie eine "Superplane" erstellen, die den in der Abbildung gezeigten "Rand" maximiert.

Dieses Mal werden die Daten zur Veranschaulichung in zwei Dimensionen dargestellt, aber stellen Sie sich die Daten im n-dimensionalen Raum als durch eine n-1-dimensionale Superebene geteilt vor.

Im zweidimensionalen Zahlenvektorraum kann die gerade Linie, die die beiden Daten teilt, als $ ax + durch + c = 0 $ ausgedrückt werden, wie in der obigen Abbildung gezeigt, und die Parameter $ a, b, c $ werden angepasst. Auf diese Weise können Sie alle geraden Linien darstellen.

Überlagerungsgleichung im n-dimensionalen Zahlenvektorraum

Dieses Mal nehmen wir eine Superebene im n-dimensionalen Zahlenvektorraum an, sodass die Formel für diese Superebene durch die folgende Formel gegeben ist. Betrachten Sie nun den Fall, in dem insgesamt N Daten vorhanden sind.

W^TX_i + b = 0 \quad (i = 1, 2, 3, ...N)

Verwenden wir nun diese Superebenengleichung, um die Gleichung abzuleiten, die zur Optimierung des harten Randes verwendet wird (ein linear trennbares Problem).

Ableitung der Formel zur Optimierung der harten Marge

Die Berechnung des Teils von $ W ^ TX_i + b = 0 $ ergibt $ w_1x_1 + w_2x_2 + ... w_nx_n + b = 0 $, was eine geradlinige Gleichung in zwei Dimensionen $ ax + durch + c = 0 $ ist Sie können intuitiv verstehen, dass es sich um eine Superebenengleichung handelt, die sich auf n Dimensionen erstreckt.

Wenn man bedenkt, dass die dreieckigen Daten in der Figur zur Menge von $ K_1 $ gehören und die Sterndaten in der Figur zur Menge von $ K_2 $ gehören, können wir sehen, dass die folgende Gleichung erfüllt ist.

W^TX_i + b > 0 \quad (X_i \in K_1)\\
W^TX_i + b < 0 \quad (X_i \in K_2)

Führen Sie die Beschriftungsvariable t ein, um diesen Ausdruck zusammen darzustellen.

Sei $ t_i = 1 $, wenn die i-ten Daten $ x_i $ zur Klasse 1 gehören, und $ t_i = -1 $, wenn sie zur Klasse 2 gehören.

t_i = \left\{
\begin{array}{ll}
1 & (X_i \in K_1) \\
-1 & (X_i \in K_2)
\end{array}
\right.

Unter Verwendung von $ t_i $, das auf diese Weise definiert wurde, kann der bedingte Ausdruck wie folgt ausgedrückt werden.

t_i(W^TX_i + b) > 0 \quad (i = 1, 2, 3, ...N)

Auf diese Weise könnte der bedingte Ausdruck in einer Zeile ausgedrückt werden.

Der Rand ist der Abstand zwischen einem Punkt im n-dimensionalen Raum und einer Superebene. Lassen Sie uns also den Abstand zwischen einem Punkt und einer geraden Linie überprüfen. Der Abstand zwischen einem zweidimensionalen Punkt und einer geraden Linie wird durch die folgende Formel ausgedrückt, wobei angenommen wird, dass der Punkt $ A (x_0, y_0) $ und die gerade Linie $ l ist: ax + by + c = 0 $.

d = \frac{|ax_0 + by_0 + c|}{\sqrt{a^2+b^2}}

Der Abstand zwischen einem Punkt im n-dimensionalen Raum und der Superebene wird durch die folgende Formel ausgedrückt.

d = \frac{|w_1x_1 + w_2x_2... + w_nx_n + b|}{\sqrt{w_1^2+w_2^2...+w_n^2}} = \frac{|W^TX_i + b|}{||w||}

Daher wird die Bedingung zum Maximieren des Randes M aus den obigen Gleichungen durch die folgende Gleichung ausgedrückt.

max_{w, b}M, \quad　\frac{t_i(W^TX_i + b)}{||W||} \geq M  \quad (i = 1, 2, 3, ...N)

Ich bin mir nicht sicher, also werde ich es erklären.

DatenX_aWenn Sie gewählt habenX_aUnd super FlugzeugW^TX + b=0Die Entfernung zu$　\frac{t_i(W^TX_a + b)}{||W||}$Es wird ausgedrückt als.

|W^TX_a + b|Mit der Labelvariablen tt_i(W^TX_a + b)Es wird ausgedrückt als.

Ebenfalls,max_{w, b}MIst eine Variablew, bEs bedeutet, M unter zu maximieren$\frac{t_i(W^TX_i + b)}{||W||} \geq M $Die Bedingung bedeutet, dass der Abstand zwischen der Superplane und allen Daten größer sein sollte als der Rand M.

Das Optimieren von M, das diese Formel erfüllt, optimiert daher die Unterstützungsvektormaschine.

$\frac{t_i(W^TX_i + b)}{||W||} \geq M $Teilen Sie beide Seiten von durch M und führen Sie die folgenden Bedingungen ein.

\frac{W}{M||W||} = \tilde{W}\\
\frac{b}{M||W||} = \tilde{b}

Dann wird der bedingte Ausdruck des Optimierungsproblems wie folgt ausgedrückt.

t_i(\tilde{W^T}X_i + \tilde{b}) \geq 1

Die obige Formel gilt für alle Daten, aber $ X_i $, wenn die Gleichheit gilt, ist $ X_i $ für die nächsten Daten.

Mit anderen Worten, $ \ tilde {M} $, ein vereinfachter Rand M, wird durch die folgende Formel ausgedrückt.

\tilde{M} = \frac{t_i(\tilde{W^T}X_i + \tilde{b})}{||\tilde{W}||} = \frac{1}{||\tilde{W}||}

Bei dieser Gleichungstransformation ist das Optimierungsproblem wie folgt.

max_{\tilde{W}, \tilde{b}}\frac{1}{||\tilde{W}||}, \quad　t_i(\tilde{W^T}X_i + \tilde{b}) \geq 1 \quad (i = 1, 2, 3, ...N)

Es wird ziemlich schwierig. Mach weiter.

Die Tilda wurde aufgrund der Transformation der Formel auf dem Weg angebracht, aber lassen Sie sie der Einfachheit halber entfernen. Und\frac{1}{||\tilde{W}||}Für den Teil bedeutet dies, die Umkehrung der Norm zu maximieren. Der Einfachheit halber wandeln wir die Norm in ein Problem um, das das Quadrat minimiert. Die Formeltransformation dieses Teils ist ein kleiner Schub. Zur Vereinfachung späterer Berechnungen\frac{1}{2}Ich werde anziehen.

min_{W, b}\frac{1}{2}||W||^2, \quad t_i(W^TX_i + b)\geq 1 \quad (i = 1, 2, 3, ...N)

Das heißt, die obige Gleichung lösent_i(W^TX_i + b)\geq 1Unter der Bedingung\frac{1}{2}||W||^2Sie können den Spielraum maximieren, indem Sie ihn minimieren. Dies ist die Formel für das Optimierungsproblem, wenn es linear trennbar ist.

Diese Bedingung kann jedoch nur linear trennbare Probleme lösen. Das heißt, es kann nur auf harte Ränder angewendet werden.

Lassen Sie uns die Randbedingung $ t_i (W ^ TX_i + b) \ geq 1 $ in der obigen Formel lockern, damit wir uns mit dem Problem (weicher Rand) befassen können, das nicht linear getrennt werden kann.

Unten abgebildet.

Betrachten Sie das in dieser Abbildung gezeigte Problem der linearen Untrennbarkeit. Wie der rote Pfeil in der Abbildung zeigt, haben die Daten die Innenseite des Randes eingegeben.

In Anbetracht der bisherigen Geschichte ist es natürlich, dass der Unterstützungsvektor (Daten, die der Superplane am nächsten liegen) auf der Superplane vorhanden ist, die $ W ^ TX_i + b = 1 $ erfüllt.

Die durch den roten Pfeil in der Figur angezeigten Daten erfüllen nicht $ t_i (W ^ TX_i + b) \ geq 1 $, können jedoch die Bedingung $ t_i (W ^ TX_i + b) \ geq 0,5 $ erfüllen.

Lassen Sie uns daher die Einschränkung lockern, indem Sie die Slug-Variable $ \ xi $ einführen. Es ist wie folgt definiert.

t_i(W^TX_i + b)\geq 1 - \xi_i \\
\xi_i = max\Bigl\{0, M - \frac{t_i(W^TX_i + b)}{||W||}\Bigr\}

Aus der obigen Formel lösen wir die Einschränkung nur, wenn sich die Daten innerhalb des Randes befinden.

Daher wird durch die Einführung dieser Slug-Variablen das Margenoptimierungsproblem wie folgt.

min_{W, \xi}\Bigl\{\frac{1}{2}||W||^2 + C\sum_{i=1}^{N} \xi_i\Bigr\} \Quad-Einschränkungsbedingung\quad
t_i(W^TX_i + b)\geq 1 - \xi_i\\
\xi_i = max\Bigl\{0, M - \frac{t_i(W^TX_i + b)}{||W||}\Bigr\}\\
i = 1, 2, 3, ... N

Das heißt, der Spielraum zu maximieren\frac{1}{2}||W||^2Wenn Sie minimieren, werden natürlich mehr Daten in den Rand gelangen.C\sum_{i=1}^{N} \xi_iWird steigen. Daher soll dieses Optimierungsproblem minimiert werden, während die beiden widersprüchlichen Begriffe ausgeglichen werden.

Rückblick bisher

Bisher haben wir die Gleichungen für das Optimierungsproblem in harten und weichen Rändern abgeleitet. Es ist unten zusammengefasst.

Wenn es ein harter Rand ist

min_{W, b}\frac{1}{2}||W||^2, \quad t_i(W^TX_i + b)\geq 1 \quad (i = 1, 2, 3, ...N)

Zum Zeitpunkt der weichen Marge

min_{W, \xi}\Bigl\{\frac{1}{2}||W||^2 + C\sum_{i=1}^{N} \xi_i\Bigr\} \quad \quad
t_i(W^TX_i + b)\geq 1 - \xi_i\\
\xi_i = max\Bigl\{0, M - \frac{t_i(W^TX_i + b)}{||W||}\Bigr\}\\
i = 1, 2, 3, ... N

Der weiche Rand wurde für Probleme verwendet, die nicht linear trennbar waren, und der harte Rand wurde für Probleme verwendet, die linear trennbar waren.

Optimierungsprobleme lösen

Lassen Sie uns nun über die Lösung des Optimierungsproblems nachdenken.

Bei der Lösung dieses Optimierungsproblems ist es selten, die obige Gleichung direkt zu lösen.

Die obige Formel wird als "Hauptproblem" des Optimierungsproblems bezeichnet, aber in vielen Fällen wird dieses "Hauptproblem" in einer anderen Form als "Doppelproblem" bezeichnet, anstatt dieses "Hauptproblem" direkt zu lösen. Wir werden das Optimierungsproblem lösen, indem wir es in eine Formel konvertieren und die Formel lösen.

Verwenden wir nun die unbestimmte Multiplikatormethode von Lagrange, um dieses Optimierungsproblem zu lösen.

Die unbestimmte Multiplikatormethode von Lagrange finden Sie im Artikel hier.

Bitte beachten Sie, dass ich es nicht vollständig verstehe, daher denke ich, dass es einige Teile gibt, denen es an Genauigkeit mangelt. Ich werde es kurz erklären.

Über Lagranges unentschlossene Multiplikatormethode

Die unbestimmte Multiplikatormethode von Lagrange ist eine typische Methode für eingeschränkte Optimierungsprobleme.

Betrachten Sie den Fall, in dem die Zielfunktion $ f (X) $ unter der Bedingung von n Ungleichungsbeschränkungen $ g (X) _i \ leqq0, i = 1, 2, 3, ... n $ minimiert wird.

Definieren Sie zunächst die folgende Lagrange-Funktion.

L(X, α) = f(X) + \sum_{i=1}^{n}α_ig_i(X)

Dieses ungleichheitsbeschränkte Optimierungsproblem führt zu dem Problem, $ (\ tilde {X}, \ tilde {α}) $ zu finden, die die folgenden vier Bedingungen für die Lagrange-Funktion erfüllen.

 \frac{\partial L(X, α)}{\partial X}=0\\
\frac{\partial L(X, α)}{\partial α_i} = g_i(X)\leqq 0, \quad (i=1, 2,... n)\\
0 \leqq α, \quad (i = 1,2, ...n)\\
α_ig_i(X) = 0, \quad (i = 1, 2,...n)

Auf diese Weise ist es möglich, anstatt das Optimierungsproblem direkt zu lösen, das Optimierungsproblem unter Verwendung einer anderen Gleichung unter Verwendung der unbestimmten Multiplikatormethode von Lagrange zu lösen. Sie haben diese andere Formel das "doppelte Problem" genannt.

Gilt für Optimierungsprobleme

Wenden wir nun die unbestimmte Multiplikatormethode von Lagrange auf die Soft-Margin-Gleichung der Support-Vektor-Maschine an.

Die Zielfunktion ist:

min_{W, \xi}\Bigl\{\frac{1}{2}||W||^2 + C\sum_{i=1}^{N} \xi_i\Bigr\}

Die Ungleichheitsbedingung ist:

t_i(W^TX_i + b)\geq 1 - \xi_i \quad \xi_i \geq 0 \quad i = 1, 2,...N

Dieses Mal haben alle n Daten zwei Ungleichheitsbeschränkungen. Wenn also die Lagrange-Multiplikatoren α und β sind, ist die Lagrange-Funktion wie folgt.

L(W,b,\xi,α,β)=\frac{1}{2}||W||^2 + C\sum_{i=1}^{N} \xi_i-\sum_{i=1}^{N}α_i\bigl\{t_i(W^TX_i+b)-1+\xi_i\bigl\}-\sum_{i=1}^{N}β_i\xi_i

Bei der Lösung eines Optimierungsproblems sind folgende Bedingungen erfüllt:

\frac{\partial L(W,b,\xi,α,β)}{\partial W}= W - \sum_{i=1}^{N}α_it_iX_i=0\\
\frac{\partial L(W,b,\xi,α,β)}{\partial b}= -\sum_{i=1}^{N}α_it_i = 0\\
\frac{\partial L(W,b,\xi,α,β)}{\partial W} = C - α_i -β_i = 0

Das Folgende ist eine Zusammenfassung dieser drei Formeln.

W =\sum_{i=1}^{N}α_it_iX_i\\
\sum_{i=1}^{N}α_it_i = 0\\
C = α_i + β_i

Wenn Sie diese drei Formeln in die Lagrange-Funktion einsetzen und unser Bestes geben, um zu berechnen, ist die Formel mit nur der Variablen α wie unten gezeigt.

\tilde{L}(α) = \sum_{i=1}^{N}α_i - \frac{1}{2}\sum_{i=1}^{N}\sum_{i=j}^{N}α_iα_jt_it_j{X_i}^TX_j

Da α 0 oder mehr ist, findet das Doppelproblem auch α, das die folgenden Bedingungen erfüllt.

max\Bigl\{{\tilde{L}(α) = \sum_{i=1}^{N}α_i - \frac{1}{2}\sum_{i=1}^{N}\sum_{i=j}^{N}α_iα_jt_it_j{X_i}^TX_j\Bigr\}}\\
\sum_{i=1}^{N}α_it_i = 0, \quad 0 \leqq α_i \leqq C, i = 1,2,...N

Auf diese Weise konnten wir die Formel für das Doppelproblem der Support-Vektor-Maschine am weichen Rand ableiten.

Lassen Sie uns nun die Kernel-Methode zusammenfassen, eine der Methoden zur einfachen Lösung dieses doppelten Problems.

Über die Kernel-Methode

Lassen Sie uns die Kernel-Methode erklären.

Schauen wir uns nun ein Zitat aus Wikipedia an.

Die Kernel-Methode (Kernel-Methode) ist eine der Methoden zur Mustererkennung und wird in Kombination mit Algorithmen wie der Diskriminierung verwendet. Eine bekannte Methode besteht darin, sie in Kombination mit einer Support-Vektor-Maschine zu verwenden. Der Zweck der Mustererkennung besteht im Allgemeinen darin, die Struktur von Daten zu finden und zu untersuchen (z. B. Cluster, Rankings, Hauptkomponenten, Korrelationen, Klassifikationen). Um dieses Ziel zu erreichen, ordnet die Kernel-Methode Daten einem hochdimensionalen Merkmalsraum zu. Jede Koordinate des Merkmalsraums entspricht einem Merkmal des Datenelements, und der Datensatz wird durch Zuordnung zum Merkmalsraum (Merkmalszuordnung) in einen Satz von Punkten im euklidischen Raum umgewandelt. Bei der Analyse der Datenstruktur im Feature-Space werden in Kombination mit der Kernel-Methode verschiedene Methoden verwendet. Eine Vielzahl von Zuordnungen kann als Merkmalszuordnungen verwendet werden (im Allgemeinen werden nichtlineare Zuordnungen verwendet), und entsprechend unterschiedliche Datenstrukturen können gefunden werden.

Sie können sich die Kernel-Methode als eine Methode zum Zuordnen und Trennen von niedrigdimensionalen Daten zu hochdimensionalen Daten vorstellen.

Streng anders, aber ein grobes Verständnis ist hier in Ordnung.

Lassen Sie uns nun sehen, warum die Kernel-Methode in Support-Vektor-Maschinen verwendet wird.

Warum unterstützen Vektormaschinen die Kernel-Methode?

Betrachten Sie den Fall der Klassifizierung der folgenden zwei Datentypen.

Bei solchen zweidimensionalen Daten ist es nicht möglich, zwei Datentypen durch eine eindimensionale Gerade zu trennen.

Erweitern wir diese Daten auf mehrdimensionale Daten, um dieses linear untrennbare Problem zu lösen.

Insbesondere wenn die zweidimensionalen Daten $ X = (x_1, x_2) $ auf fünf Dimensionen erweitert werden, werden sie über die folgende Funktion abgebildet.

ψ(X) = (x^2_1, x^2_2, x_1x_2, x_1, x_2)

Auf diese Weise wird die Erweiterung der Datendimension auf eine höhere Dimension als "hochdimensionaler Merkmalsraum" bezeichnet, während der Raum der ersten Eingabedaten als "Eingaberaum" bezeichnet wird.

Verallgemeinern wir die obige Formel. Die Funktion, die die Daten im n-dimensionalen Eingaberaum auf den höherdimensionalen r-dimensionalen Merkmalsraum abbildet, ist wie folgt definiert.

ψ(X) = (φ_1(X), φ_2(X), φ_3(X), ...φ_r(X))

Funktionen wie $ φ_1 (X) $ sind Funktionen, die die Daten der ursprünglichen Funktion kombinieren und Änderungen hinzufügen.

Wenn Daten mit einer solchen Funktion in einen hochdimensionalen Merkmalsraum erweitert werden, werden sie zu Daten, die zu einem bestimmten Zeitpunkt durch eine Trennungs-Superebene getrennt werden können. Mit anderen Worten, wenn letztendlich jedes Datenelement auf eine andere Dimension erweitert wird und wenn es n Daten gibt, kann es auf n Dimensionen erweitert werden, kann es immer durch eine Superebene mit n-1-Dimensionstrennung getrennt werden.

Mit anderen Worten, es werden linear trennbare Daten.

Danach wird durch Trennen dieser getrennten Superebene und Konvertieren in die getrennte Superebene der Originaldaten die Kurve, die die Daten im Eingaberaum trennt (genau genommen wird die Kurve auf eine Dimension erweitert, die eine Dimension kleiner als der Eingaberaum ist. Sie können bekommen, was Sie getan haben).

Betrachten wir nun die Gleichung für das Optimierungsproblem im hochdimensionalen Merkmalsraum.

Bevor die Formel des Optimierungsproblems des hochdimensionalen Merkmalsraums betrachtet wird, wird das Optimierungsproblem des Eingaberaums überprüft.

Überprüfung der Probleme bei der Optimierung des Eingaberaums

max\Bigl\{{\tilde{L}(α) = \sum_{i=1}^{N}α_i - \frac{1}{2}\sum_{i=1}^{N}\sum_{i=j}^{N}α_iα_jt_it_j{X_i}^TX_j\Bigr\}}\\
\sum_{i=1}^{N}α_it_i = 0, \quad 0 \leqq α_i \leqq C, i = 1,2,...N

Die Daten im hochdimensionalen Merkmalsraum sind eine Abbildung der Daten im Eingaberaum $ X_i ^ T $, $ X_j $ 1 unter Verwendung der Funktion $ ψ (X) $, so dass das Optimierungsproblem im hochdimensionalen Merkmalsraum wie folgt ist. Wird sein.

max\Bigl\{{\tilde{L}(α) = \sum_{i=1}^{N}α_i - \frac{1}{2}\sum_{i=1}^{N}\sum_{i=j}^{N}α_iα_jt_it_j{ψ(X)_i}^Tψ(X)_j\Bigr\}}\\
\sum_{i=1}^{N}α_it_i = 0, \quad 0 \leqq α_i \leqq C, i = 1,2,...N

Sie können sehen, dass dieses Optimierungsproblem im hochdimensionalen Merkmalsraum gelöst werden sollte.

Verwenden Sie die Kernel-Methode

Die Probleme hier sind:

{ψ(X)_i}^Tψ(X)_j

Je höher der Merkmalsraum ist, desto lächerlicher wird der Rechenaufwand in diesem Begriff.

Eine Methode, die die Berechnung dieses Teils vereinfacht, wird als Kernel-Trick bezeichnet.

Definieren Sie die Kernelfunktion wie folgt:

K(X_i, X_j) = {ψ(X)_i}^Tψ(X)_j

Es ist etwas schwierig, aber Sie können diese Kernelfunktion verwenden, um das innere Produkt zu berechnen, ohne $ ψ (X) $ direkt zu berechnen.

Auf diese Weise ist es notwendig, bestimmte Bedingungen zu erfüllen, um das innere Produkt zu berechnen, ohne $ ψ (X) $ direkt zu berechnen, aber ~~ ich verstehe nicht ~~ Es ist schwer zu erklären, daher ist es hilfreich. Ich werde nur die Seite posten, die wird.

Satz von Mercer [Kernel mit korrektem Wert](http://ibisforest.org/index.php?%E6%AD%A3%E5%AE%9A%E5%80%A4%E3%82%AB%E3%83%BC%E3 % 83% 8D% E3% 83% AB)

Diese Methode ist sehr nützlich, da $ ψ (X) $ nur in Form eines inneren Produkts in einem doppelten Problem auftritt.

Die folgenden drei Kernelfunktionen werden verwendet.

Gaußscher Kernel

K(X_i, X_j) = exp\bigl\{-\frac{||X_i -X_j||^2}{2σ^2}\bigl\}

Polygonkernel

K(X_i, X_j) = (X_i^TX_j + c)^d

`Sigmaid Kernel``

K(X_i, X_j) = tanh(bX_i^TX_j + c)

Schauen wir uns nun ein konkretes Beispiel an, in dem das innere Produkt vom polymorphen Kern leicht berechnet werden kann.

Spezifisches Beispiel für die Kernel-Methode

Stellen Sie sich eine Funktion vor, die einen zweidimensionalen Eingaberaum einem dreidimensionalen Merkmalsraum zuordnet, wie unten gezeigt.

ψ(X) = ψ(x_1, x_2) = (x_1^2, \sqrt{2}x_1x_2, x_2^2)

Mit dieser Funktion sind die beiden zweidimensionalen Vektoren X und Y wie folgt.

ψ(X) = ψ(x_1, x_2) = (x_1^2, \sqrt{2}x_1x_2, x_2^2)\\
ψ(Y) = ψ(y_1, y_2) = (y_1^2, \sqrt{2}y_1y_2, y_2^2)

Betrachten wir das innere Produkt davon.

\begin{align}
ψ(X)^Tψ(Y) & = (x_1^2, \sqrt{2}x_1x_2, x_2^2)^T(y_1^2, \sqrt{2}y_1y_2, y_2^2)\\
&=x_1^2y_1^2 + 2x_1y_1x_2y_2 + x_2^2y_2^2\\
&= (x_1y_1 + x_2y_2)^2\\
&=((x_1,x_2)^T(y_1,y_2))^2\\
&=(X^TY)^2

\end{align}

Auf diese Weise kann $ ψ (X) ^ Tψ (Y) $ berechnet werden, indem das innere Produkt des ursprünglichen Vektors quadriert wird, ohne $ ψ (X) ^ Tψ (Y) $ direkt zu berechnen. Ich werde.

Wenn Sie mehr über die Kernel-Methode erfahren möchten, lesen Sie bitte den Artikel hier.

Lassen Sie uns nun die Implementierung der Support Vector Machine zusammenfassen.

Unterstützung der Implementierung von Vektormaschinen

Klassifizierungsproblem: harter Rand

Wir werden svm implementieren, das linear trennbare Daten trennt.

Die verwendeten Daten sind der Iris-Datensatz.

Über den Iris-Datensatz

Irisdaten sind Daten einer Blumensorte namens Iris.

Es gibt 50 Daten zu jeder der drei Irisarten "Setosa", "Virginica" und "Virginica" für insgesamt 150 Daten.

Schauen wir uns den Inhalt an.

from sklearn.datasets import load_iris
import pandas as pd

iris = load_iris()
iris_df = pd.DataFrame(iris.data, columns=iris.feature_names)

print(iris_df.head())

sepal length (cm) sepal width (cm) petal length (cm) petal width (cm) 0 5.1 3.5 1.4 0.2 1 4.9 3.0 1.4 0.2 2 4.7 3.2 1.3 0.2 3 4.6 3.1 1.5 0.2 4 5.0 3.6 1.4 0.2

Da jeder Spaltenname in "iris.feature_names" gespeichert ist, können Sie die obigen Daten ausgeben, indem Sie sie an das Argument "Dataframe of Pandas" übergeben.

"Sepal Length" speichert die Blütenblattlänge, "Sepal Width" speichert die Blütenblattbreite, "Petal Length" speichert die Blütenblattlänge und "Petal Width" speichert die Daten der Blütenblattbreite. Ich bin.

Sie können das richtige Antwortetikett wie unten gezeigt anzeigen.

print(iris.target)

[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]

Auf diese Weise werden die Iris-Sorten "setosa", "versicolor" und "virginica" auf 0, 1 bzw. 2 gesetzt.

Dies ist das Ende der Erklärung der Irisdaten.

Implementierung

Lassen Sie uns einen Datensatz mit dem folgenden Code erstellen.

import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.svm import LinearSVC
from sklearn.datasets import load_iris
import mglearn

iris = load_iris()
X = iris.data[:100, 2:]
Y = iris.target[:100]
print(X.shape)
print(Y.shape)

(100, 2) (100,)

Dieses Mal werden wir anhand der Daten "Blütenblattlänge" und "Blütenblattbreite" von "Setosa" und "Versicolor" klassifizieren.

Zeichnen Sie die Daten mit dem folgenden Code.

mglearn.discrete_scatter(X[:, 0], X[:, 1], Y)
plt.legend(['setosa', 'versicolor'], loc='best')
plt.show()

Der Code von "mglearn.discrete_scatter (X [:, 0], X [:, 1], Y)" verwendet die X-Achse als erstes Argument, die Y-Achse als zweites Argument und die korrekte Antwortbezeichnung als drittes Argument und die Streuung Machen Sie eine Handlung.

loc = 'best' passt die Legende so an, dass sie dem Diagramm nicht im Wege steht.

Aus den obigen Daten können Sie deutlich erkennen, dass sie durch eine gerade Linie getrennt werden können. Es ist eher zu einfach.

Erstellen wir ein Modell mit dem folgenden Code.

X_train, X_test, Y_train, Y_test = train_test_split(X, Y, stratify=Y, random_state=0)
svm = LinearSVC()
svm.fit(X_train, Y_train)

Die Modellerstellung selbst endet mit diesem Code. Es ist einfach.

Lassen Sie uns anhand des folgenden Codes veranschaulichen, wie das Modell aussieht.

plt.figure(figsize=(10, 6))
mglearn.plots.plot_2d_separator(svm, X)
mglearn.discrete_scatter(X[:, 0], X[:, 1], Y)
plt.xlabel('petal length')
plt.ylabel('petal width')
plt.legend(['setosa', 'versicolor'], loc='best')
plt.show()

Sie können sehen, dass die Grenzen, die die Daten trennen, erstellt werden.

Der Teil von mglearn.plots.plot_2d_separator (svm, X) ist etwas verwirrend, deshalb werde ich es erklären. Lassen Sie uns den Definitionscode überprüfen.

plot_2d_separator(classifier, X, fill=False, ax=None, eps=None, alpha=1,cm=cm2, linewidth=None, threshold=None,linestyle="solid"):

Diese Funktion zeichnet eine Grenzlinie, wenn Sie das Klassifizierungsmodell als erstes Argument und die Originaldaten als zweites Argument übergeben.

Damit ist die Implementierung des SVM-Modells für linear trennbare Probleme abgeschlossen.

Klassifizierungsproblem: Weicher Rand

Dieses Mal werden wir uns mit dem Thema der weichen Margen befassen.

import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.svm import LinearSVC
from sklearn.datasets import load_iris
import mglearn

iris = load_iris()

X = iris.data[50:, 2:]
Y = iris.target[50:] - 1

mglearn.discrete_scatter(X[:, 0], X[:, 1], Y)
plt.legend(['versicolor', 'virginica'], loc='best')
plt.show()

Jetzt zeichnen wir die Daten für "Blütenblattlänge" und "Blütenblattbreite" für "Versicolor" und "Verginica".

Es ist ein unmögliches Problem, sich vollständig linear zu trennen.

Hier ist eine Überprüfung der Soft-Margin-Formel. Informationen zur Ableitung finden Sie im Artikel hier.

min_{W, \xi}\Bigl\{\frac{1}{2}||W||^2 + C\sum_{i=1}^{N} \xi_i\Bigr\} \quad \quad
t_i(W^TX_i + b)\geq 1 - \xi_i\\
\xi_i = max\Bigl\{0, M - \frac{t_i(W^TX_i + b)}{||W||}\Bigr\}\\
i = 1, 2, 3, ... N

Da die Daten innerhalb des Randes liegen, wurde das Limit durch den Ausdruck $ C \ sum_ {i = 1} ^ {N} \ xi_i $ gelockert.

Der Wert dieses C ist standardmäßig 1.0 in "skleaarn". Lassen Sie uns diese Zahl ändern und sehen, wie sich die Zahl ändert. Der folgende Code definiert eine Funktion, die die den Argumenten zugewiesenen Modellgrenzen darstellt.

def make_separate(model):
    mglearn.plots.plot_2d_separator(svm, X)
    mglearn.discrete_scatter(X[:, 0], X[:, 1], Y)
    plt.xlabel('petal length')
    plt.ylabel('petal width')
    plt.legend(['setosa', 'versicolor'], loc='best')
    plt.show()

Zeichnen wir die Figur mit dem folgenden Code. Sei "C = 0,1".

X_train, X_test, Y_train, Y_test = train_test_split(X, Y, stratify=Y, random_state=0)
svm = LinearSVC(C=0.1)
svm.fit(X_train, Y_train)
make_separate(svm)
print(svm.score(X_test, Y_test))

0.96

Als nächstes ist "C = 1,0".

svm = LinearSVC(C=1.0)
svm.fit(X_train, Y_train)
make_separate(svm)
print(svm.score(X_test, Y_test))

1.0

Als nächstes ist "C = 100".

svm = LinearSVC(C=100)
svm.fit(X_train, Y_train)
make_separate(svm)
print(svm.score(X_test, Y_test))

1.0

Es ist wichtig, ein geeignetes C einzustellen. Es scheint gut zu sein, die Situation zu sehen, während verschiedene Dinge geändert werden.

Dies ist das Ende der Implementierung von Soft Margin.

Lassen Sie uns nun die Implementierung zusammenfassen, wenn die Kernel-Methode verwendet wird, und die Implementierung, wenn sie nicht verwendet wird.

Ohne Verwendung der Kernel-Methode implementiert

Dieses Mal werden wir die Probleme klassifizieren, die ohne die Verwendung der Kernel-Methode nicht linear getrennt werden können.

Hier wird die Methode, die die Kernelfunktion nicht verwendet, so definiert, dass sie die Kernelmethode nicht verwendet.

Bereiten wir die Daten mit dem folgenden Code vor und veranschaulichen sie.

import mglearn
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.svm import LinearSVC
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.svm import SVC

moons = make_moons(n_samples=300, noise=0.2, random_state=0)

X = moons[0]
Y = moons[1]
plt.figure(figsize=(12, 8))
mglearn.discrete_scatter(X[:, 0], X[:, 1], Y)
plt.plot()
plt.show()

make_moons ist eine Funktion, die Daten in Form eines zweidimensionalen Mondes erstellt.

Sie können die Anzahl der Samples und das Rauschen einstellen.

Wie Sie der Abbildung entnehmen können, ist eine lineare Trennung eindeutig nicht möglich.

Lassen Sie uns die Daten in diesem Eingaberaum den Daten im höherdimensionalen Merkmalsraum zuordnen, um diese nicht linear trennbaren Daten in linear trennbare Daten umzuwandeln.

X_train, X_test, Y_train, Y_test = train_test_split(X, Y, stratify=Y, random_state=0)
poly = PolynomialFeatures(degree=2)
X_train_poly = poly.fit_transform(X_train)
X_test_poly = poly.fit_transform(X_test)

Damit können die Daten im Eingaberaum auf den hochdimensionalen Merkmalsraum abgebildet werden.

Lassen Sie uns überprüfen, welche Art von Daten zugeordnet wurden.

print(poly.get_feature_names())
print(X_train_poly.shape)

['1', 'x0', 'x1', 'x0^2', 'x0 x1', 'x1^2'] (225, 6)

Auf diese Weise wird der zweidimensionale Eingaberaum auf den sechsdimensionalen Merkmalsraum erweitert.

Standardisieren Sie die Daten mit dem folgenden Code.

scaler = StandardScaler()
X_train_poly_scaled = scaler.fit_transform(X_train_poly)
X_test_poly_scaled = scaler.fit_transform(X_test_poly)

Datenstandardisierung bedeutet, den Durchschnitt für alle Daten zu subtrahieren und dann durch die Standardabweichung zu dividieren, um den Durchschnitt der Daten auf 0 und die Varianz auf 1 zu setzen.

Ich habe es in einem leicht verständlichen Artikel hier geschrieben.

Lassen Sie uns nun das Modell mit dem folgenden Code implementieren und bewerten.

lin_svm = LinearSVC()
lin_svm.fit(X_train_poly_scaled, Y_train)
print(lin_svm.score(X_test_poly_scaled, Y_test))

0.84

Es ist ein wenig niedrig. Lassen Sie es uns einer höheren Dimension zuordnen.

Das Zuordnen zu einer höheren Dimension und das Standardisieren ist jedoch mühsam. Verwenden wir also etwas, das als "Pipeline" bezeichnet wird.

poly_scaler_svm = Pipeline([
    ('poly', PolynomialFeatures(degree=3)),
    ('scaler', StandardScaler()),
    ('svm', LinearSVC())
])
poly_scaler_svm.fit(X_train, Y_train)
print(poly_scaler_svm.score(X_test, Y_test))

0.9733333333333334

Auf diese Weise kann "Pipeline" verwendet werden, um die Zuordnung von Daten zu einer höheren Dimension zu vereinfachen, sie zu standardisieren und in das SVM-Modell einzufügen. Durch Setzen von "Grad = 3" wird es einem höherdimensionalen Merkmalsraum zugeordnet.

Die Genauigkeit ist ziemlich gut. Es ist sehr effektiv, wenn es einer höheren Dimension zugeordnet wird.

Als nächstes zeichnen wir diese Figur. Unten ist der Code.

_x0 = np.linspace(-1.5, 2.7, 100)
_x1 = np.linspace(-1.5, 1.5, 100)
x0, x1 = np.meshgrid(_x0, _x1)
X = np.hstack((x0.ravel().reshape(-1, 1), x1.ravel().reshape(-1, 1)))
y_decision = model.decision_function(X).reshape(x0.shape)
plt.contourf(x0, x1, y_decision, levels=[y_decision.min(), 0, y_decision.max()], alpha=0.3)
plt.figure(figsize=(12, 8))
mglearn.discrete_scatter(X[:, 0], X[:, 1], Y)
plt.show()

Sie können sehen, dass die Linien ziemlich sauber sind. Lassen Sie uns den Code erklären.

_x0 = np.linspace(-1.5, 2.7, 100)
_x1 = np.linspace(-1.5, 1.5, 100)
x0, x1 = np.meshgrid(_x0, _x1)

Die Gitterpunkte werden hier mit dem Code erstellt. Weitere Informationen finden Sie im Artikel hier.

np.linspace erstellt ein numpy-Array, indem der Startpunkt im ersten Argument, der Endpunkt im zweiten Argument und die Anzahl der Punkte im dritten Argument angegeben werden. Indem wir es an np.meshgrid übergeben, erstellen wir 100x100 Gitterpunkte.

X = np.hstack((x0.ravel().reshape(-1, 1), x1.ravel().reshape(-1, 1)))

Nachdem Sie ein 100x100-Array mit (x0.ravel () in ein eindimensionales Array konvertiert haben, konvertieren Sie es in eine zweidimensionale 10000x1-Matrix mit reshape (-1, 1) und` np.hstack Durch "sind sie in der horizontalen Richtung von" Achse = 1 "verbunden, dh X ist eine 10000 × 2-Matrix.

y_decision = model.decision_function(X).reshape(x0.shape)
plt.contourf(x0, x1, y_decision, levels=[y_decision.min(), 0, y_decision.max()], alpha=0.3)

Der Abstand zwischen 10000 Gitterpunkten und der getrennten Superebene wird durch "model.decision_function (X)" berechnet und in 100 × 100-Daten konvertiert.

plt.contourf ist eine Funktion, die Konturlinien darstellt, und Sie können in Ebenen angeben, wo die Farbe geändert werden soll.

Damit ist die Implementierung abgeschlossen, bei der die Kernel-Methode nicht verwendet wird.

Implementierung mit der Kernel-Methode

Lassen Sie es uns mit der Kernel-Methode implementieren.

Bereiten wir die Daten vor. Soweit das gleiche.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.svm import SVC

moons = make_moons(n_samples=300, noise=0.2, random_state=0)

X = moons[0]
Y = moons[1]

X_train, X_test, Y_train, Y_test = train_test_split(X, Y, stratify=Y, random_state=0)

Lassen Sie uns das Modell mit dem folgenden Code implementieren.

karnel_svm = Pipeline([
    ('scaler', StandardScaler()),
    ('svm', SVC(kernel='poly', degree=3, coef0=1))
])

karnel_svm.fitX_train, Y_train()

Durch Angabe von "poly" im "karnel" -Argument von "SVC" können Sie den polymorphen Kernel angeben, und durch Angabe von "grad = 3" können Sie sich vorstellen, bis zu drei Dimensionen abzubilden.

Sie haben jetzt ein Modell erstellt. Als nächstes veranschaulichen wir dieses Modell. Ich mache das Gleiche noch einmal, aber es ist ein Ärger, also mache ich es zu einer Funktion.

def plot_decision_function(model):
    _x0 = np.linspace(-1.7, 2.7, 100)
    _x1 = np.linspace(-1.5, 1.7, 100)
    x0, x1 = np.meshgrid(_x0, _x1)
    X = np.hstack((x0.ravel().reshape(-1, 1), x1.ravel().reshape(-1, 1)))
    y_decision = model.decision_function(X).reshape(x0.shape)
    plt.contourf(x0, x1, y_decision, levels=[y_decision.min(), 0, y_decision.max()], alpha=0.3)

def plot_dataset(x, y):
    plt.plot(x[:, 0][y == 0], x[:, 1][y == 0], 'bo', ms=15)
    plt.plot(x[:, 0][y == 1], x[:, 1][y == 1], 'r^', ms=15)
    plt.xlabel('$x_1$', fontsize=20)
    plt.ylabel('$x_2$', fontsize=20, rotation=0)

plt.figure(figsize=(12, 8))
plot_decision_function(karnel_svm)
plot_dataset(X, Y)
plt.show()

Ich hätte es mit mglearn zeichnen können, aber diesmal habe ich es mit plt.plot gezeichnet. Diejenigen mit "Y = 0" werden mit blauen Kreisen gezeichnet, und diejenigen mit "Y = 1" werden mit roten Dreiecken gezeichnet.

Wie Sie sehen können, wird dasselbe Ergebnis mit oder ohne Kernel-Methode zurückgegeben. Es ist jedoch viel einfacher, intern mit der Kernel-Methode zu berechnen, daher halte ich es für besser, die Kernel-Methode so weit wie möglich zu verwenden.

Weitere Informationen zur Vereinfachung finden Sie im Artikel hier.

Am Ende

Vielen Dank, dass Sie bisher bei uns geblieben sind.

Es war ein sehr langer Artikel. Vielen Dank für das Lesen.

Danke für deine harte Arbeit.

[Python] Ich habe die Theorie und Implementierung der Support Vector Machine (SVM) ausführlich erklärt.