[PYTHON] [Übersetzung] scikit-learn 0.18 Benutzerhandbuch 1.4. Support Vector Machine

http://scikit-learn.org/0.18/modules/svm.html Google-Übersetzung von überwachtem Lernen Inhalt des Benutzerhandbuchs [scikit-learn 0.18 Benutzerhandbuch 1. Überwachtes Lernen](http://qiita.com/nazoking@github/items/267f2371757516f8c168#1-%E6%95%99%E5%B8%AB%E4%BB%98 Von% E3% 81% 8D% E5% AD% A6% E7% BF% 92)

1.4. Support Vector Machine

** Support Vector Machine (SVM) ** ist "[Kategorie](# 141-% E5% 88% 86% E9% A1% 9E)", "[Return](# 142% E5% 9B% 9E% E5) % B8% B0) "und" [Ausreißererkennung](# 143-% E5% AF% 86% E5% BA% A6% E6% 8E% A8% E5% AE% 9A% E6% 96% B0% E8% A6% 8F% E6% 80% A7% E6% A4% 9C% E5% 87% BA) “ist eine Reihe von überwachten Lernmethoden.

Die Vorteile der Support Vector Machine sind:

Die Nachteile der Support Vector Machine sind:

Unterstützung für Scikit-Lernen Die Vektormaschine unterstützt hohe Dichte (die in die von numpy.ndarray und numpy.asarray konvertiert werden kann) und spärliche (beliebige scipy.sparse) Probenvektoren als Eingabe. Um SVM für spärliche Datenvorhersagen verwenden zu können, muss es jedoch mit solchen Daten kompatibel sein. Verwenden Sie für eine optimale Leistung "numpy.ndarray" (dicht) oder "scipy.sparse.csr_matrix" (spärlich) in C-Reihenfolge mit "dtype = float64".

1.4.1. Klassifizierung

SVC, NuSVC /modules/generated/sklearn.svm.NuSVC.html#sklearn.svm.NuSVC) und [LinearSVC](http://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html#sklearn .svm.LinearSVC) ist eine Klasse, die eine Mehrklassenklassifizierung für Datensätze durchführen kann.

SVC und NuSVC sind ähnlich, akzeptieren jedoch leicht unterschiedliche Parametersätze und haben unterschiedliche mathematische Formulierungen (siehe Abschnitt [Mathematische Formulierungen](# 147% E6% 95% B0% E5% AD% A6). % E7% 9A% 84% E5% 87% A6% E6% 96% B9)). Andererseits ist LinearSVC ein weiterer Support-Vektor-Klassifikator für lineare Kernel. Es ist eine Implementierung. Beachten Sie, dass LinearSVC das Schlüsselwort "Kernel" nicht akzeptiert. Dies wird als linear angesehen. Außerdem haben einige Mitglieder von SVC und NuSVC so etwas wie "support_" nicht. SVC, NuSVC und LinearSVC verwenden zwei Arrays der Größe "[n_samples, n_features]", um Trainingsmuster, das Array X der Klassenbezeichnung (Zeichenfolge oder Ganzzahl) und die Größe "[n_samples]" als Eingaben zu speichern. Ich werde es nehmen.

>>> from sklearn import svm
>>> X = [[0, 0], [1, 1]]
>>> y = [0, 1]
>>> clf = svm.SVC()
>>> clf.fit(X, y)  
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape=None, degree=3, gamma='auto', kernel='rbf',
    max_iter=-1, probability=False, random_state=None, shrinking=True,
    tol=0.001, verbose=False)

Nach dem Anpassen können Sie das Modell verwenden, um neue Werte vorherzusagen.

>>> clf.predict([[2., 2.]])
array([1])

Die SVM-Entscheidungsfunktion basiert auf mehreren Teilmengen von Trainingsdaten, die als Unterstützungsvektoren bezeichnet werden. Einige Eigenschaften dieser Unterstützungsvektoren befinden sich in den Elementen "support_vectors_", "support_" und "n_support".

>>> # get support vectors
>>> clf.support_vectors_
array([[ 0.,  0.],
       [ 1.,  1.]])
>>> # get indices of support vectors
>>> clf.support_ 
array([0, 1]...)
>>> # get number of support vectors for each class
>>> clf.n_support_ 
array([1, 1]...)

1.4.1.1 Klassifizierung mehrerer Klassen

SVC und NuSVC implementieren einen "Eins-gegen-Eins" -Ansatz für die Mehrfachklassifizierung (Knerr et al., 1990). Wenn "n_class" die Anzahl der Klassen ist, wird ein Klassifizierer von "n_class * (n_class -1) / 2" erstellt, wobei jede Trainingsdaten aus zwei Klassen stammen. Um eine konsistente Schnittstelle mit anderen Klassifizierern bereitzustellen, aggregiert die Option "entscheidungsfunktionsform" die Ergebnisse des Klassifizierers "Eins gegen Eins" zu einer Determinante der Form "(n_samples, n_classes)". mach es möglich.

>>> X = [[0], [1], [2], [3]]
>>> Y = [0, 1, 2, 3]
>>> clf = svm.SVC(decision_function_shape='ovo')
>>> clf.fit(X, Y) 
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape='ovo', degree=3, gamma='auto', kernel='rbf',
    max_iter=-1, probability=False, random_state=None, shrinking=True,
    tol=0.001, verbose=False)
>>> dec = clf.decision_function([[1]])
>>> dec.shape[1] # 4 classes: 4*3/2 = 6
6
>>> clf.decision_function_shape = "ovr"
>>> dec = clf.decision_function([[1]])
>>> dec.shape[1] # 4 classes
4

LinearSVC hingegen implementiert eine "One-vs-Rest" -Multiklassenstrategie und trainiert das n_class-Modell. Wenn es nur zwei Klassen gibt, wird nur ein Modell trainiert.

>>>
>>> lin_clf = svm.LinearSVC()
>>> lin_clf.fit(X, Y) 
LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,
     intercept_scaling=1, loss='squared_hinge', max_iter=1000,
     multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,
     verbose=0)
>>> dec = lin_clf.decision_function([[1]])
>>> dec.shape[1]
4

Eine vollständige Beschreibung der Determinante finden Sie unter [Formulierung](# svm-mathematische Formulierung). LinearSVC implementiert auch eine alternative Mehrklassenstrategie, die sogenannte Mehrklassen-SVM, die von Crammer und Singer unter Verwendung der Option "multi_class =" crammer_singer "entwickelt wurde. Diese Methode ist konsistent. Dies gilt nicht für die Klassifizierung "One-vs-Rest". In der Praxis sind die Ergebnisse ziemlich gleich, aber die Ausführungszeit ist erheblich kürzer, weshalb normalerweise die Klassifizierung "Eins gegen Ruhe" bevorzugt wird. Für "one-vs-rest" LinearSVC haben die Attribute von "coef_" und "intercept_" die Form "[n_class, n_features]" bzw. "[n_class]". Jede Koeffizientenreihe entspricht einem der vielen "One-vs-Rest" -Klassifikatoren "n_class" und ist in der Reihenfolge der "One" -Klasse dem Achsenabschnitt ähnlich. Für den SVC "Eins gegen Eins" ist das Attributlayout etwas komplizierter. Für einen linearen Kernel ist das Layout von "coef_" und "intercept_" wie oben in LinearSVC beschrieben, außer dass die Form von "coef_" "[n_class * (n_class --1) / 2, n_features]" ist. Ist das gleiche wie. Viele binäre Klassifikatoren. Die Reihenfolge von Klasse 0 bis Klasse n ist "0 bis 1", "0 bis 2", ... "0 bis n", "1 bis 2", "1 bis 3", "1 bis n". .. .. "n-1 gegen n". Die Form von "dual_coef_" ist "[n_class-1, n_SV]", was ein ziemlich schwieriges Layout ist. Die Spalte entspricht einem Unterstützungsvektor, der in einem der "n_class * (n_class - 1) / 2" "Eins-gegen-Eins" -Klassifikatoren enthalten ist. Jeder Unterstützungsvektor wird im Klassifikator "n_class - 1" verwendet. Der Eintrag "n_class -1" in jeder Zeile entspricht dem doppelten Koeffizienten dieser Klassifizierer. Dies kann im Beispiel klarer sein: Klasse 0 mit 3 Unterstützungsvektoren $ v ^ {0} \ _ 0, v ^ {1} \ _ 0, v ^ {2} \ _ 0 $ bzw. 2 Unterstützungsvektoren $ v ^ {0} \ _1 Betrachten Sie drei Klassenprobleme, Klasse 1 und Klasse 2 mit v ^ {1} \ _1 $, $ v ^ {0} \ _2, v ^ {1} \ _2 $. Jeder Unterstützungsvektor $ v ^ {j} \ _i $ hat zwei Doppelkoeffizienten. Nennen wir den Koeffizienten $ v ^ {j} \ _i $ des Unterstützungsvektors im Klassifikator zwischen den Klassen $ i $ und $ k $ $ \ alpha ^ {j} \ _ {i, k} $. Dann wird dual_coef_ zu:

$\alpha^{0}_{0,1}$ $\alpha^{0}_{0,2}$ Klasse 0 unterstützt Vektorkoeffizienten
$\alpha^{1}_{0,1}$ $\alpha^{1}_{0,2}$
$\alpha^{2}_{0,1} $ $\alpha^{2}_{0,2}$
$\alpha^{0}_{1,0}$ $\alpha^{0}_{1,2}$ Unterstützungsvektorkoeffizienten der Klasse 1
$\alpha^{1}_{1,0}$ $\alpha^{1}_{1,2}$
$\alpha^{0}_{2,0}$ $\alpha^{0}_{2,1}$ Klasse 2 unterstützt Vektorkoeffizienten
$\alpha^{1}_{2,0}$ $\alpha^{1}_{2,1}$

1.4.1.2. Punktzahl und Wahrscheinlichkeit

Die SVC-Methode entscheidungsfunktion gibt eine Bewertung pro Klasse für jede Stichprobe (oder eine Bewertung pro Stichprobe im binären Fall). Wenn die Konstruktoroption "Wahrscheinlichkeit" auf "Wahr" gesetzt ist, ist die Schätzung der Klassenmitgliedschaftswahrscheinlichkeit (aus den Methoden von "Predict_Proba" und "Predict_log_proba") gültig. Für Binärdaten werden Wahrscheinlichkeiten mithilfe der Platt-Skalierung kalibriert: logistische Regression der SVM-Scores, angepasst durch zusätzliche Kreuzvalidierung der Trainingsdaten. Für Multiklassen wurde dies wie bei Wu et al. (2004) erweitert. Es ist unnötig zu erwähnen, dass die gegenseitige Validierung bei der Platt-Skalierung eine teure Operation für große Datenmengen ist. Außerdem können die Wahrscheinlichkeitsschätzungen in dem Sinne inkonsistent mit der Bewertung sein, dass der "Argmax" der Bewertung nicht der Argmax der Wahrscheinlichkeit ist. (Zum Beispiel kann bei einer binären Klassifizierung eine Stichprobe mit "Vorhersagen" gekennzeichnet werden, wenn sie zu einer Klasse mit einer Wahrscheinlichkeit von <½ gemäß "Vorhersagen_Proba" gehört.) Es ist auch bekannt, dass die Methode von Platt theoretische Probleme aufweist. Wenn Sie Konfidenzwerte benötigen, diese aber keine Wahrscheinlichkeiten sein müssen, ist es eine gute Idee, "Wahrscheinlichkeit = Falsch" zu setzen und "Entscheidungsfunktion" anstelle von "Vorhersage_Proba" zu verwenden.

--Referenz: Wu, Lin und Weng, "Wahrscheinlichkeitsschätzung der Klassifizierung mehrerer Klassen durch paarweise Kombination", JMLR 5: 975 -1005, 2004.

1.4.1.3 Ungleichgewichtsproblem

Sie können die Schlüsselwörter "class_weight" und "sample_weight" in Problemen verwenden, in denen Sie eine bestimmte Klasse oder eine bestimmte einzelne Stichprobe stärker hervorheben möchten. SVC (nicht NuSVC) implementiert das Schlüsselwort "class_weight" in der "fit" -Methode. Dies ist ein Wörterbuch der Form "{class_label: value}", wobei value eine Gleitkommazahl> 0 ist, die den Parameter "C" von "class_label" auf "C * value" setzt.

SVC, NuSVC, SVR, NuSVR und OneClassSVM implementieren auch Gewichte für einzelne Stichproben der Methode "fit" mit dem Schlüsselwort "sample_weight". Wie "class_weight" setzen sie den Parameter "C" im i-ten Beispiel auf "C * sample_weight [i]".

--Beispiel:

1.4.2. Zurück

Die Support Vector Classification-Methode kann erweitert werden, um Regressionsprobleme zu lösen. Diese Methode wird als Support-Vektor-Regression bezeichnet. Das durch die Unterstützungvektorklassifizierung (wie oben beschrieben) erzeugte Modell hängt nur von einer Teilmenge der Trainingsdaten ab, da die Kostenfunktion für die Erstellung des Modells keine Trainingspunkte über den Spielraum hinaus berücksichtigt. In ähnlicher Weise hängt das durch die Unterstützung-Vektor-Regression erzeugte Modell nur von einer Teilmenge der Trainingsdaten ab, da die Kostenfunktion, die das Modell erstellt, Trainingsdaten ignoriert, die nahe an der Modellvorhersage liegen. Es gibt drei Arten von Support-Vektor-Regressionsimplementierungen: SVR, NuSVR und LinearSVR. LinearSVR bietet eine schnellere Implementierung als SVR, während NuSVR ein etwas anderes Format als SVR und LinearSVR implementiert, jedoch nur den linearen Kernel berücksichtigt. Weitere Informationen finden Sie unter Implementierungsdetails (# svm-Implementierungsdetails). Wie die Klassifizierungsklasse wird die Anpassungsmethode als Argumentvektor X, y verwendet. In diesem Fall wird erwartet, dass y einen Gleitkommawert anstelle eines ganzzahligen Werts hat.

>>>
>>> from sklearn import svm
>>> X = [[0, 0], [2, 2]]
>>> y = [0.5, 2.5]
>>> clf = svm.SVR()
>>> clf.fit(X, y) 
SVR(C=1.0, cache_size=200, coef0=0.0, degree=3, epsilon=0.1, gamma='auto',
kernel='rbf', max_iter=-1, shrinking=True, tol=0.001, verbose=False)
>>> clf.predict([[1, 1]])
array([ 1.5])

--Beispiel:

1.4.3 Dichteschätzung, Neuheitserkennung

Eine Klasse von SVM wird zur Erkennung von Neuheiten verwendet. Das heißt, bei einer Reihe von Stichproben werden die weichen Grenzen der Menge erkannt, sodass die neue Menge als zu dieser Menge gehörig klassifiziert wird. Die Klasse, die dies implementiert, ist OneClassSVM. In diesem Fall hat die "fit" -Methode keine Klassenbezeichnung und verwendet das Array X als Eingabe, da es sich um eine Art unbeaufsichtigtes Lernen handelt. Weitere Informationen zu dieser Verwendung finden Sie im Abschnitt "[Erkennung von Neuheiten und Ausreißern](http://qiita.com/nazoking@github/items/e3c4d203abafb8accbab#271-%E6%96%B0%E8%A6%8F%". E6% 80% A7% E3% 81% AE% E6% A4% 9C% E5% 87% BA) ".

--Beispiel:

1.4.4. Komplex

Support-Vektor-Maschinen sind ein leistungsstarkes Werkzeug, aber mit zunehmender Anzahl von Trainingsvektoren steigen ihre Rechen- und Speicheranforderungen schnell. Das Kernstück von SVM ist ein sekundäres Planungsproblem (QP), das den Unterstützungsvektor vom Rest des Trainingsvektors trennt. Der in dieser libsvm basierte Implementierung verwendete QP-Solver hängt von der Effizienz des libsvm-Cache ab, $ O (n \ _ {features} \ times n \ _ {samples} ^ 2) $ und $ O (n \ _ {features} \ times n \ _ {samples} ^ 3) $ Wird tatsächlich verwendet (abhängig vom Datensatz). Wenn die Daten sehr spärlich sind, ersetzen Sie $ n_ {features} $ durch die durchschnittliche Anzahl von Nicht-Null-Features im Beispielvektor. Für Linear sind die in der liblinear Implementierung von LinearSVC verwendeten Algorithmen wesentlich effizienter als der libsvm-basierte SVC-Compiler. Es kann nahezu linear auf Millionen von Samples und Features skaliert werden.

1.4.5 Praktische Tipps

1.4.6 Kernelfunktion

Die Kernelfunktion kann eine der folgenden sein:

--Linear: $ \ langle x, x '\ rangle $. --Polygon: $ (\ gamma \ langle x, x '\ rangle + r) ^ d $. $ D $ gibt das Schlüsselwort grad und $ r $ mit coef0 an.

Verschiedene Kernel werden bei der Initialisierung durch das Schlüsselwort "Kernel" angegeben:

>>> linear_svc = svm.SVC(kernel='linear')
>>> linear_svc.kernel
'linear'
>>> rbf_svc = svm.SVC(kernel='rbf')
>>> rbf_svc.kernel
'rbf'

1.4.6.1 Benutzerdefinierter Kernel

Sie können Ihren eigenen Kernel definieren, indem Sie dem Kernel Python-Funktionen geben oder die Gramm-Matrix vorberechnen. Ein Klassifizierer mit einem benutzerdefinierten Kernel verhält sich wie jeder andere Klassifizierer, mit Ausnahme der folgenden:

1.4.6.1.1. Verwenden Sie Python-Funktionen als Kernel

Sie können auch Ihren eigenen vordefinierten Kernel verwenden, indem Sie eine Funktion an das Konstruktor-Schlüsselwort "Kernel" übergeben. Der Kernel muss zwei Formmatrizen "(n_samples_1, n_features)", "(n_samples_2, n_features)" als Argumente verwenden und eine Kernelmatrix der Form "(n_samples_1, n_samples_2)" zurückgeben. Der folgende Code definiert einen linearen Kernel und erstellt eine Klassifiziererinstanz, die diesen Kernel verwendet.

>>> import numpy as np
>>> from sklearn import svm
>>> def my_kernel(X, Y):
...     return np.dot(X, Y.T)
...
>>> clf = svm.SVC(kernel=my_kernel)

--Beispiel:

1.4.6.1.2 Verwendung der Gramm-Matrix

Setzen Sie "kernel =" vorberechnet "und übergeben Sie die Gramm-Matrix anstelle von X in der Anpassungsmethode. Zu diesem Zeitpunkt müssen Kernelwerte zwischen allen Trainings- und Testvektoren bereitgestellt werden.

>>> import numpy as np
>>> from sklearn import svm
>>> X = np.array([[0, 0], [1, 1]])
>>> y = [0, 1]
>>> clf = svm.SVC(kernel='precomputed')
>>> # linear kernel computation
>>> gram = np.dot(X, X.T)
>>> clf.fit(gram, y) 
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape=None, degree=3, gamma='auto',
    kernel='precomputed', max_iter=-1, probability=False,
    random_state=None, shrinking=True, tol=0.001, verbose=False)
>>> # predict on training examples
>>> clf.predict(gram)
array([0, 1])

1.4.6.1.3. RBF-Kernel-Parameter

Beim Training von SVMs mit dem Kernel der Radial Basis Function (RBF) sind zwei Parameter zu berücksichtigen: "C" und "Gamma". Der Parameter "C", der allen SVM-Kerneln gemeinsam ist, beseitigt eine Fehlklassifizierung von Trainingsbeispielen zur Vereinfachung der Entscheidungstabelle. Ein niedriges C zielt darauf ab, die Entscheidungstabelle zu glätten, und ein hohes "C" zielt darauf ab, alle Trainingsbeispiele korrekt zu klassifizieren. gamma definiert, wie viel Einfluss ein Trainingsbeispiel haben wird. Je größer das "Gamma" ist, desto stärker sind die anderen Beispiele betroffen. Die richtige Auswahl von "C" und "Gamma" ist wichtig für die SVM-Leistung. Man verwendet sklearn.model_selection.GridSearchCV mit C und gamma Es wird empfohlen, exponentiell weit entfernt zu verwenden.

--Beispiel:

1.4.7 Mathematische Vorschrift

Support-Vektor-Maschinen bauen Superflugzeuge oder Paare von Superflugzeugen in höher- oder unendlich dimensionalen Räumen, die für Klassifizierung, Regression oder andere Aufgaben verwendet werden. Intuitiv ist im Allgemeinen der Generalisierungsfehler des Klassifikators umso kleiner, je größer der Spielraum ist, so dass eine gute Trennung durch die Superebene mit dem größten Abstand zum nächsten Trainingsdatenpunkt (sogenannter Funktionsspielraum) dieser Klasse erreicht wird. Erreicht.

1.4.7.1. SVC

Bei gegebenem Vektor y der beiden Klassen von Trainingsvektoren $ x_i \ in \ mathbb {R} ^ p $ ist $ i = 1 ... n $ und $ y \ in \ mathbb {R} ^ n $ $ \ varepsilon $ Der SVC war ein Problem:

\min_ {w, b, \zeta} \frac{1}{2} w^T w + C \sum_{i=1}^{n} \zeta_i

\begin{align}
\textrm {subject to } & y_i (w^T \phi (x_i) + b) \geq 1 - \zeta_i,\\
 & \zeta_i \geq 0, i=1, ..., n
\end{align}

Das Doppel

\min_{\alpha} \frac{1}{2} \alpha^T Q \alpha - e^T \alpha

\begin{align}
\textrm {subject to } & y^T \alpha = 0\\
& 0 \leq \alpha_i \leq C, i=1, ..., n
\end{align}

Wobei $ e $ der Vektor aller Einsen ist, $ C> 0 $ die Obergrenze ist, $ Q $ die n × n positive halbpositive Festwertmatrix ist, $ Q_ {ij} \ äquiv y_i y_j K (x_i, x_j) $. Wobei $ K (x_i, x_j) = \ phi (x_i) ^ T \ phi (x_j) $ der Kernel ist. Hier wird der Trainingsvektor durch die Funktion $ \ phi $ implizit auf einen höheren (möglicherweise unendlichen) Raum abgebildet. Die Determinante ist:

\operatorname{sgn}(\sum_{i=1}^n y_i \alpha_i K(x_i, x) + \rho)

** Hinweis **: SVM-Modelle, die von libsvm und liblinear abgeleitet sind, verwenden C als Regularisierungsparameter, aber die meisten anderen Schätzer verwenden Alpha. Die Beziehung zwischen den beiden ist $ C = \ frac {n \ _samples} {alpha}. $. Auf diesen Parameter kann über das Mitglied dual_coef_ zugegriffen werden, das das Produkt $ y_i \ alpha_i $ enthält , support_vectors_, das die Unterstützungsvektoren enthält, und intercept_, das den unabhängigen Term $ \ rho $ enthält.

--Referenz:

1.4.7.2. NuSVC

Einführung eines neuen Parameters, $ \ nu $, der die Anzahl der Unterstützungsvektoren und Trainingsfehler steuert. Parameter $ \ nu \ in (0, 1] $ ist die Obergrenze der Trainingsfehlerrate und die Untergrenze der Unterstützungsvektorrate. Es stellt sich heraus, dass die $ \ nu $ -SVC-Formulierung eine Neuparametrisierung von C-SVC ist und daher mathematisch äquivalent ist.

1.4.7.3. SVR

Wenn der Trainingsvektor $ x_i \ mathbb {R} ^ p $, i = 1, ..., n und der Vektor $ \ mathbb {R} ^ n \ varepsilon $ -SVR gegeben sind, werden die folgenden Probleme gelöst Machen.

    \min_ {w, b, \zeta, \zeta^*} \frac{1}{2} w^T w + C \sum_{i=1}^{n} (\zeta_i + \zeta_i^*)

\begin{align}
    \textrm {subject to } & y_i - w^T \phi (x_i) - b \leq \varepsilon + \zeta_i,\\
                          & w^T \phi (x_i) + b - y_i \leq \varepsilon + \zeta_i^*,\\
                          & \zeta_i, \zeta_i^* \geq 0, i=1, ..., n

\end{align}

Das Doppel

   \min_{\alpha, \alpha^*} \frac{1}{2} (\alpha - \alpha^*)^T Q (\alpha - \alpha^*) + \varepsilon e^T (\alpha + \alpha^*) - y^T (\alpha - \alpha^*)

\begin{align}
   \textrm {subject to } & e^T (\alpha - \alpha^*) = 0\\
   & 0 \leq \alpha_i, \alpha_i^* \leq C, i=1, ..., n
\end{align}

Wobei $ e $ der Vektor aller Einsen ist, $ C> 0 $ die Obergrenze ist, $ Q $ die $ n $ mal $ n $ positive halbfeste Wertmatrix ist, $ Q_ {ij} \ equiv K (x_i ,, x_j) = \ phi (x_i) ^ T \ phi (x_j) $ ist der Kernel. Hier wird der Trainingsvektor durch die Funktion $ \ phi $ implizit auf einen höheren (möglicherweise unendlichen) Raum abgebildet. Die Determinante ist:

 \sum_{i=1}^n (\alpha_i - \alpha_i^*) K(x_i, x) + \rho

Auf diese Parameter kann über das Element dual_coef_ zugegriffen werden, das die Differenz $ \ alpha_i- \ alpha_i ^ * $ enthält, die support_vectors_, die die Unterstützungsvektoren enthält, und das intercept_, das den unabhängigen Term $ \ ρ $ enthält.

--Referenz:

1.4.8 Implementierungsdetails

Intern libsvm und [liblinear](http: //www.csie.) Um alle Berechnungen durchzuführen. Verwenden Sie ntu.edu.tw / ~ cjlin / liblinear /). Diese Bibliotheken werden mit C und Cython verpackt.

--Referenz: Informationen zur Implementierung und Einzelheiten des verwendeten Algorithmus finden Sie unter:

[scikit-learn 0.18 Benutzerhandbuch 1. Überwachtes Lernen](http://qiita.com/nazoking@github/items/267f2371757516f8c168#1-%E6%95%99%E5%B8%AB%E4%BB%98 Von% E3% 81% 8D% E5% AD% A6% E7% BF% 92)

© 2010 - 2016, Entwickler von Scikit-Learn (BSD-Lizenz).

Recommended Posts

[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 1.4. Support Vector Machine
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 4.5. Zufällige Projektion
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 1.11. Ensemble-Methode
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 1.15. Isotonische Regression
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 4.2 Merkmalsextraktion
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 1.16. Wahrscheinlichkeitskalibrierung
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 1.13 Funktionsauswahl
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 3.4. Modellpersistenz
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 2.8. Dichteschätzung
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 4.3. Datenvorverarbeitung
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 4.4. Unüberwachte Dimensionsreduzierung
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch Inhaltsverzeichnis
Maschinelles Lernen unterstützt Vektormaschine
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 1.12. Mehrklassenalgorithmus und Mehrfachetikettenalgorithmus
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 3.2. Optimieren der Hyperparameter des Schätzers
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 4.8. Konvertieren Sie das Vorhersageziel (y)
Maschinelles Lernen: Überwacht - Support Vector Machine
Algorithmus für maschinelles Lernen (Support Vector Machine)
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 2.7. Erkennung von Neuheiten und Ausreißern
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 3.1. Kreuzvalidierung: Bewerten Sie die Leistung des Schätzers
Algorithmus für maschinelles Lernen (Unterstützung von Vektor-Maschinenanwendungen)
Maschinelles Lernen ① SVM-Zusammenfassung (Support Vector Machine)
<Kurs> Maschinelles Lernen Kapitel 7: Support Vector Machine
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 3.3. Modellbewertung: Quantifizieren Sie die Qualität der Vorhersage
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 4.1. Pipeline- und Feature-Union: Kombination von Schätzern
Support Vector Machine (für Anfänger) -Code Edition-
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 3.5. Verifizierungskurve: Zeichnen Sie die Punktzahl, um das Modell zu bewerten
[Übersetzung] scikit-learn 0.18 Benutzerhandbuch 2.5. Zerlegen von Signalen in Komponenten (Matrixzerlegungsproblem)
[Übersetzung] scikit-learn 0.18 Einführung in maschinelles Lernen durch Tutorial scikit-learn
Berechnung der Support Vector Machine (SVM) (mit cvxopt)
Pandas Benutzerhandbuch "Multi-Index / Advanced Index" (offizielles Dokument Japanische Übersetzung)
Pandas Benutzerhandbuch "Manipulieren fehlender Daten" (offizielles Dokument Japanische Übersetzung)