1.5. Stochastischer Gradientenabstieg#

Stochastischer Gradientenabstieg (SGD) ist ein einfacher, aber sehr effizienter Ansatz zur Anpassung von linearen Klassifikatoren und Regressoren unter konvexen Verlustfunktionen wie (linearen) Support Vector Machines und Logistischer Regression. Obwohl SGD in der Machine-Learning-Community schon lange bekannt ist, hat er in letzter Zeit im Kontext des großskaligen Lernens beträchtliche Aufmerksamkeit erfahren.

SGD wurde erfolgreich auf große und spärliche Machine-Learning-Probleme angewendet, die häufig bei der Textklassifizierung und der Verarbeitung natürlicher Sprache auftreten. Da die Daten spärlich sind, skalieren die Klassifikatoren in diesem Modul problemlos für Probleme mit mehr als \(10^5\) Trainingsbeispielen und mehr als \(10^5\) Merkmalen.

Streng genommen ist SGD lediglich eine Optimierungstechnik und entspricht keiner spezifischen Familie von Machine-Learning-Modellen. Es ist nur eine Möglichkeit, ein Modell zu trainieren. Oft hat eine Instanz von SGDClassifier oder SGDRegressor einen äquivalenten Schätzer in der scikit-learn API, der potenziell eine andere Optimierungstechnik verwendet. Beispielsweise führt die Verwendung von SGDClassifier(loss='log_loss') zu einer logistischen Regression, d. h. einem Modell, das äquivalent zu LogisticRegression ist, die über SGD trainiert wird, anstatt durch einen der anderen Löser in LogisticRegression trainiert zu werden. Ebenso lösen SGDRegressor(loss='squared_error', penalty='l2') und Ridge über unterschiedliche Wege dasselbe Optimierungsproblem.

Die Vorteile des stochastischen Gradientenabstiegs sind:

  • Effizienz.

  • Einfache Implementierung (viele Möglichkeiten zur Code-Optimierung).

Die Nachteile des stochastischen Gradientenabstiegs umfassen:

  • SGD erfordert eine Reihe von Hyperparametern wie den Regularisierungsparameter und die Anzahl der Iterationen.

  • SGD ist empfindlich gegenüber Skalierung der Merkmale.

Warnung

Stellen Sie sicher, dass Sie Ihre Trainingsdaten mischen (shuffling), bevor Sie das Modell anpassen, oder verwenden Sie shuffle=True, um nach jeder Iteration zu mischen (standardmäßig verwendet). Idealerweise sollten die Merkmale standardisiert werden, z. B. mit make_pipeline(StandardScaler(), SGDClassifier()) (siehe Pipelines).

1.5.1. Klassifizierung#

Die Klasse SGDClassifier implementiert eine einfache stochastische Gradientenabstieg-Lernroutine, die verschiedene Verlustfunktionen und Strafen für die Klassifizierung unterstützt. Unten sehen Sie die Entscheidungsgrenze eines mit Hinge-Loss trainierten SGDClassifier, äquivalent zu einem linearen SVM.

../_images/sphx_glr_plot_sgd_separating_hyperplane_001.png

Wie andere Klassifikatoren muss SGD mit zwei Arrays angepasst werden: einem Array X der Form (n_samples, n_features), das die Trainingsbeispiele enthält, und einem Array y der Form (n_samples,) , das die Zielwerte (Klassenbezeichnungen) für die Trainingsbeispiele enthält.

>>> from sklearn.linear_model import SGDClassifier
>>> X = [[0., 0.], [1., 1.]]
>>> y = [0, 1]
>>> clf = SGDClassifier(loss="hinge", penalty="l2", max_iter=5)
>>> clf.fit(X, y)
SGDClassifier(max_iter=5)

Nach dem Trainieren kann das Modell dann zur Vorhersage neuer Werte verwendet werden.

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

SGD passt ein lineares Modell an die Trainingsdaten an. Das Attribut coef_ enthält die Modellparameter.

>>> clf.coef_
array([[9.9, 9.9]])

Das Attribut intercept_ enthält den Achsenabschnitt (auch Offset oder Bias genannt).

>>> clf.intercept_
array([-9.9])

Ob das Modell einen Achsenabschnitt, d. h. eine befangene Hyperebene, verwenden soll oder nicht, wird durch den Parameter fit_intercept gesteuert.

Der signierte Abstand zur Hyperebene (berechnet als Skalarprodukt zwischen den Koeffizienten und dem Eingabebeispiel plus dem Achsenabschnitt) wird durch SGDClassifier.decision_function gegeben.

>>> clf.decision_function([[2., 2.]])
array([29.6])

Die konkrete Verlustfunktion kann über den Parameter loss eingestellt werden. SGDClassifier unterstützt die folgenden Verlustfunktionen:

  • loss="hinge": (Soft-Margin) linearer Support Vector Machine,

  • loss="modified_huber": geglätteter Hinge-Loss,

  • loss="log_loss": logistische Regression,

  • sowie alle unten aufgeführten Regressionsverluste. In diesem Fall wird das Ziel als \(-1\) oder \(1\) kodiert, und das Problem wird als Regressionsproblem behandelt. Die vorhergesagte Klasse entspricht dann dem Vorzeichen des vorhergesagten Ziels.

Bitte beachten Sie den mathematischen Abschnitt unten für die Formeln. Die ersten beiden Verlustfunktionen sind "lazy", sie aktualisieren die Modellparameter nur, wenn ein Beispiel die Margenbeschränkung verletzt, was das Training sehr effizient macht und zu spärlicheren Modellen führen kann (d. h. mit mehr Nullkoeffizienten), auch wenn eine \(L_2\)-Strafe verwendet wird.

Die Verwendung von loss="log_loss" oder loss="modified_huber" aktiviert die Methode predict_proba, die für jedes Stichprobenpaar \(x\) eine Vektordichte von Wahrscheinlichkeitsschätzungen \(P(y|x)\) liefert.

>>> clf = SGDClassifier(loss="log_loss", max_iter=5).fit(X, y)
>>> clf.predict_proba([[1., 1.]])
array([[0.00, 0.99]])

Die konkrete Strafe kann über den Parameter penalty eingestellt werden. SGD unterstützt die folgenden Strafen:

  • penalty="l2": \(L_2\)-Norm-Strafe auf coef_.

  • penalty="l1": \(L_1\)-Norm-Strafe auf coef_.

  • penalty="elasticnet": Konvexe Kombination aus \(L_2\) und \(L_1\); (1 - l1_ratio) * L2 + l1_ratio * L1.

Die Standardeinstellung ist penalty="l2". Die \(L_1\)-Strafe führt zu spärlichen Lösungen, wobei die meisten Koeffizienten auf Null gesetzt werden. Das Elastic Net [11] löst einige Mängel der \(L_1\)-Strafe bei stark korrelierten Attributen. Der Parameter l1_ratio steuert die konvexe Kombination von \(L_1\)- und \(L_2\)-Strafen.

SGDClassifier unterstützt die Multiklassenklassifizierung, indem mehrere Binärklassifikatoren in einem "One-versus-All" (OVA)-Schema kombiniert werden. Für jede der \(K\) Klassen wird ein Binärklassifikator gelernt, der zwischen dieser und allen \(K-1\) anderen Klassen diskriminiert. Zur Testzeit berechnen wir den Konfidenzscore (d. h. die signierten Abstände zur Hyperebene) für jeden Klassifikator und wählen die Klasse mit der höchsten Konfidenz. Die folgende Abbildung veranschaulicht den OVA-Ansatz auf dem Iris-Datensatz. Die gestrichelten Linien stellen die drei OVA-Klassifikatoren dar; die Hintergrundfarben zeigen die durch die drei Klassifikatoren induzierte Entscheidungsoberfläche.

../_images/sphx_glr_plot_sgd_iris_001.png

Bei der Multiklassenklassifizierung ist coef_ ein zweidimensionales Array der Form (n_classes, n_features) und intercept_ ist ein eindimensionales Array der Form (n_classes,). Die \(i\)-te Zeile von coef_ enthält den Gewichtsvektor des OVA-Klassifikators für die \(i\)-te Klasse; die Klassen sind in aufsteigender Reihenfolge indiziert (siehe Attribut classes_). Beachten Sie, dass prinzipiell, da sie die Erstellung eines Wahrscheinlichkeitsmodells ermöglichen, loss="log_loss" und loss="modified_huber" besser für die One-vs-All-Klassifizierung geeignet sind.

SGDClassifier unterstützt sowohl gewichtete Klassen als auch gewichtete Instanzen über die Fit-Parameter class_weight und sample_weight. Weitere Informationen finden Sie in den folgenden Beispielen und in der Dokumentation von SGDClassifier.fit.

SGDClassifier unterstützt Averaged SGD (ASGD) [10]. Die Mittelung kann durch Setzen von average=True aktiviert werden. ASGD führt die gleichen Updates wie das reguläre SGD durch (siehe Mathematische Formulierung), aber anstatt den letzten Wert der Koeffizienten als Attribut coef_ zu verwenden (d. h. die Werte des letzten Updates), wird coef_ stattdessen auf den durchschnittlichen Wert der Koeffizienten über alle Updates gesetzt. Dasselbe geschieht für das Attribut intercept_. Bei Verwendung von ASGD kann die Lernrate größer und sogar konstant sein, was bei einigen Datensätzen zu einer Beschleunigung der Trainingszeit führt.

Für die Klassifizierung mit einem logistischen Verlust ist eine weitere Variante von SGD mit einer Mittelungsstrategie als Stochastischer Durchschnittsgradient (SAG) Algorithmus verfügbar, der als Solver in LogisticRegression erhältlich ist.

Beispiele

1.5.2. Regression#

Die Klasse SGDRegressor implementiert eine einfache stochastische Gradientenabstieg-Lernroutine, die verschiedene Verlustfunktionen und Strafen zur Anpassung linearer Regressionsmodelle unterstützt. SGDRegressor eignet sich gut für Regressionsprobleme mit einer großen Anzahl von Trainingsbeispielen (> 10.000), für andere Probleme empfehlen wir Ridge, Lasso oder ElasticNet.

Die konkrete Verlustfunktion kann über den Parameter loss eingestellt werden. SGDRegressor unterstützt die folgenden Verlustfunktionen:

  • loss="squared_error": Gewöhnliche kleinste Quadrate,

  • loss="huber": Huber-Verlust für robuste Regression,

  • loss="epsilon_insensitive": lineare Support Vector Regression.

Bitte beachten Sie den mathematischen Abschnitt unten für die Formeln. Die Huber- und Epsilon-insensitiven Verlustfunktionen können für robuste Regression verwendet werden. Die Breite des unempfindlichen Bereichs muss über den Parameter epsilon festgelegt werden. Dieser Parameter hängt von der Skala der Zielvariablen ab.

Der Parameter penalty bestimmt die zu verwendende Regularisierung (siehe Beschreibung oben im Klassifizierungsabschnitt).

SGDRegressor unterstützt auch Averaged SGD [10] (auch hier siehe Beschreibung oben im Klassifizierungsabschnitt).

Für Regression mit quadratischem Verlust und \(L_2\)-Strafe ist eine weitere Variante von SGD mit einer Mittelungsstrategie als Stochastischer Durchschnittsgradient (SAG) Algorithmus verfügbar, der als Solver in Ridge erhältlich ist.

Beispiele

1.5.3. Online One-Class SVM#

Die Klasse sklearn.linear_model.SGDOneClassSVM implementiert eine Online-Linearversion der One-Class SVM unter Verwendung eines stochastischen Gradientenabstiegs. In Kombination mit Kernel-Approximationstechniken kann sklearn.linear_model.SGDOneClassSVM verwendet werden, um die Lösung einer kernelisierten One-Class SVM, implementiert in sklearn.svm.OneClassSVM, mit linearer Komplexität in Bezug auf die Anzahl der Stichproben zu approximieren. Beachten Sie, dass die Komplexität einer kernelisierten One-Class SVM im besten Fall quadratisch in der Anzahl der Stichproben ist. sklearn.linear_model.SGDOneClassSVM eignet sich somit gut für Datensätze mit einer großen Anzahl von Trainingsbeispielen (über 10.000), für die die SGD-Variante um mehrere Größenordnungen schneller sein kann.

Mathematische Details#

Die Implementierung basiert auf der Implementierung des stochastischen Gradientenabstiegs. Tatsächlich ist das ursprüngliche Optimierungsproblem der One-Class SVM gegeben durch

\[\begin{split}\begin{aligned} \min_{w, \rho, \xi} & \quad \frac{1}{2}\Vert w \Vert^2 - \rho + \frac{1}{\nu n} \sum_{i=1}^n \xi_i \\ \text{s.t.} & \quad \langle w, x_i \rangle \geq \rho - \xi_i \quad 1 \leq i \leq n \\ & \quad \xi_i \geq 0 \quad 1 \leq i \leq n \end{aligned}\end{split}\]

wobei \(\nu \in (0, 1]\) der vom Benutzer angegebene Parameter ist, der den Anteil der Ausreißer und den Anteil der Support-Vektoren steuert. Wenn man die Schlupfvariablen \(\xi_i\) eliminiert, ist dieses Problem äquivalent zu

\[\min_{w, \rho} \frac{1}{2}\Vert w \Vert^2 - \rho + \frac{1}{\nu n} \sum_{i=1}^n \max(0, \rho - \langle w, x_i \rangle) \, .\]

Wenn wir mit der Konstanten \(\nu\) multiplizieren und den Achsenabschnitt \(b = 1 - \rho\) einführen, erhalten wir das folgende äquivalente Optimierungsproblem:

\[\min_{w, b} \frac{\nu}{2}\Vert w \Vert^2 + b\nu + \frac{1}{n} \sum_{i=1}^n \max(0, 1 - (\langle w, x_i \rangle + b)) \, .\]

Dies ähnelt den Optimierungsproblemen, die in Abschnitt Mathematische Formulierung mit \(y_i = 1, 1 \leq i \leq n\) und \(\alpha = \nu/2\) untersucht werden, wobei \(L\) die Hinge-Loss-Funktion und \(R\) die \(L_2\)-Norm ist. Wir müssen lediglich den Term \(b\nu\) in die Optimierungsschleife aufnehmen.

Wie SGDClassifier und SGDRegressor unterstützt SGDOneClassSVM Averaged SGD. Die Mittelung kann durch Setzen von average=True aktiviert werden.

Beispiele

1.5.4. Stochastischer Gradientenabstieg für spärliche Daten#

Hinweis

Die spärliche Implementierung liefert geringfügig andere Ergebnisse als die dichte Implementierung, aufgrund einer reduzierten Lernrate für den Achsenabschnitt. Siehe Implementierungsdetails.

Es gibt eine eingebaute Unterstützung für spärliche Daten, die in jedem Matrixformat vorliegen, das von scipy.sparse unterstützt wird. Für maximale Effizienz sollten Sie jedoch das CSR-Matrixformat verwenden, wie in scipy.sparse.csr_matrix definiert.

Beispiele

1.5.5. Komplexität#

Der Hauptvorteil von SGD ist seine Effizienz, die im Wesentlichen linear von der Anzahl der Trainingsbeispiele abhängt. Wenn \(X\) eine Matrix der Größe \(n \times p\) (mit \(n\) Stichproben und \(p\) Merkmalen) ist, hat das Training Kosten von \(O(k n \bar p)\), wobei \(k\) die Anzahl der Iterationen (Epochen) und \(\bar p\) die durchschnittliche Anzahl der Nicht-Null-Attribute pro Stichprobe ist.

Jüngste theoretische Ergebnisse zeigen jedoch, dass die Laufzeit, um eine bestimmte gewünschte Optimierungsgenauigkeit zu erreichen, nicht mit der Größe des Trainingsdatensatzes zunimmt.

1.5.6. Abbruchkriterium#

Die Klassen SGDClassifier und SGDRegressor bieten zwei Kriterien, um den Algorithmus zu stoppen, wenn ein bestimmtes Konvergenzniveau erreicht ist.

  • Bei early_stopping=True wird die Eingabe auf einen Trainingssatz und einen Validierungssatz aufgeteilt. Das Modell wird dann auf dem Trainingssatz angepasst, und das Abbruchkriterium basiert auf dem Vorhersage-Score (unter Verwendung der Methode score), der auf dem Validierungssatz berechnet wird. Die Größe des Validierungssatzes kann mit dem Parameter validation_fraction geändert werden.

  • Bei early_stopping=False wird das Modell auf den gesamten Eingabedaten angepasst, und das Abbruchkriterium basiert auf der Zielfunktion, die auf den Trainingsdaten berechnet wird.

In beiden Fällen wird das Kriterium einmal pro Epoche ausgewertet, und der Algorithmus stoppt, wenn das Kriterium n_iter_no_change Mal hintereinander nicht verbessert wird. Die Verbesserung wird mit absoluter Toleranz tol bewertet, und der Algorithmus stoppt in jedem Fall nach einer maximalen Anzahl von Iterationen max_iter.

Siehe Frühes Stoppen von Stochastic Gradient Descent für ein Beispiel für die Auswirkungen des frühen Stoppens.

1.5.7. Tipps zur praktischen Anwendung#

  • Stochastischer Gradientenabstieg ist empfindlich gegenüber Skalierung der Merkmale, daher wird dringend empfohlen, Ihre Daten zu skalieren. Skalieren Sie beispielsweise jedes Attribut im Eingabevektor \(X\) auf \([0,1]\) oder \([-1,1]\), oder standardisieren Sie es so, dass es den Mittelwert \(0\) und die Varianz \(1\) hat. Beachten Sie, dass die *gleiche* Skalierung auf den Testvektor angewendet werden muss, um aussagekräftige Ergebnisse zu erzielen. Dies kann leicht mit StandardScaler erfolgen.

    from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)  # Don't cheat - fit only on training data
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)  # apply same transformation to test data

# Or better yet: use a pipeline!
from sklearn.pipeline import make_pipeline
est = make_pipeline(StandardScaler(), SGDClassifier())
est.fit(X_train)
est.predict(X_test)

    Wenn Ihre Attribute eine intrinsische Skala haben (z. B. Worthäufigkeiten oder Indikatormerkmale), ist keine Skalierung erforderlich.

  • Das Finden eines geeigneten Regularisierungsterms \(\alpha\) geschieht am besten durch automatische Hyperparameter-Suche, z. B. mit GridSearchCV oder RandomizedSearchCV, normalerweise im Bereich 10.0**-np.arange(1,7).

  • Empirisch haben wir festgestellt, dass SGD nach etwa \(10^6\) Trainingsstichproben konvergiert. Daher ist eine vernünftige erste Schätzung für die Anzahl der Iterationen max_iter = np.ceil(10**6 / n), wobei n die Größe des Trainingsdatensatzes ist.

  • Wenn Sie SGD auf mit PCA extrahierte Merkmale anwenden, ist es oft ratsam, die Merkmalswerte mit einer Konstante c zu skalieren, so dass die durchschnittliche \(L_2\)-Norm der Trainingsdaten eins ergibt.

  • Wir haben festgestellt, dass Averaged SGD mit einer größeren Anzahl von Merkmalen und einem höheren eta0 am besten funktioniert.

Referenzen

1.5.8. Mathematische Formulierung#

Hier beschreiben wir die mathematischen Details des SGD-Verfahrens. Eine gute Übersicht mit Konvergenzraten finden Sie in [12].

Gegeben sei eine Menge von Trainingsbeispielen \(\{(x_1, y_1), \ldots, (x_n, y_n)\}\), wobei \(x_i \in \mathbf{R}^m\) und \(y_i \in \mathbf{R}\) (\(y_i \in \{-1, 1\}\) für die Klassifizierung), ist unser Ziel, eine lineare Scoring-Funktion \(f(x) = w^T x + b\) mit Modellparametern \(w \in \mathbf{R}^m\) und Achsenabschnitt \(b \in \mathbf{R}\) zu lernen. Um Vorhersagen für binäre Klassifizierung zu treffen, betrachten wir einfach das Vorzeichen von \(f(x)\). Um die Modellparameter zu finden, minimieren wir den regulierten Trainingsfehler gegeben durch

\[E(w,b) = \frac{1}{n}\sum_{i=1}^{n} L(y_i, f(x_i)) + \alpha R(w)\]

wobei \(L\) eine Verlustfunktion ist, die die Modellpassung (Fehlpassung) misst, und \(R\) ein Regularisierungsterm (auch Strafe genannt) ist, der die Modellkomplexität bestraft; \(\alpha > 0\) ist ein nicht-negativer Hyperparameter, der die Stärke der Regularisierung steuert.

Details zu Verlustfunktionen#

Unterschiedliche Wahlen für \(L\) ergeben unterschiedliche Klassifikatoren oder Regressoren:

  • Hinge (Soft-Margin): äquivalent zur Support Vector Classification. \(L(y_i, f(x_i)) = \max(0, 1 - y_i f(x_i))\).

  • Perzeptron: \(L(y_i, f(x_i)) = \max(0, - y_i f(x_i))\).

  • Modifizierter Huber: \(L(y_i, f(x_i)) = \max(0, 1 - y_i f(x_i))^2\), wenn \(y_i f(x_i) > -1\), und \(L(y_i, f(x_i)) = -4 y_i f(x_i)\) andernfalls.

  • Log Loss: äquivalent zur Logistischen Regression. \(L(y_i, f(x_i)) = \log(1 + \exp (-y_i f(x_i)))\).

  • Quadratischer Fehler: Lineare Regression (Ridge oder Lasso abhängig von \(R\)). \(L(y_i, f(x_i)) = \frac{1}{2}(y_i - f(x_i))^2\).

  • Huber: weniger empfindlich gegenüber Ausreißern als Kleinste-Quadrate. Es ist äquivalent zu Kleinste-Quadrate, wenn \(|y_i - f(x_i)| \leq \varepsilon\), und \(L(y_i, f(x_i)) = \varepsilon |y_i - f(x_i)| - \frac{1}{2} \varepsilon^2\) andernfalls.

  • Epsilon-Insensitive: (Soft-Margin) äquivalent zur Support Vector Regression. \(L(y_i, f(x_i)) = \max(0, |y_i - f(x_i)| - \varepsilon)\).

Alle oben genannten Verlustfunktionen können als obere Schranke für den Fehlklassifizierungsfehler (Null-Eins-Verlust) betrachtet werden, wie in der nachstehenden Abbildung gezeigt.

../_images/sphx_glr_plot_sgd_loss_functions_001.png

Gängige Wahlen für den Regularisierungsterm \(R\) (den penalty Parameter) sind

  • \(L_2\)-Norm: \(R(w) := \frac{1}{2} \sum_{j=1}^{m} w_j^2 = ||w||_2^2\),

  • \(L_1\)-Norm: \(R(w) := \sum_{j=1}^{m} |w_j|\), was zu spärlichen Lösungen führt.

  • Elastic Net: \(R(w) := \frac{\rho}{2} \sum_{j=1}^{n} w_j^2 + (1-\rho) \sum_{j=1}^{m} |w_j|\), eine konvexe Kombination von \(L_2\) und \(L_1\), wobei \(\rho\) gegeben ist durch 1 - l1_ratio.

Die nachstehende Abbildung zeigt die Konturen der verschiedenen Regularisierungsterme in einem 2-dimensionalen Parameterraum (\(m=2\)) für \(R(w) = 1\).

../_images/sphx_glr_plot_sgd_penalties_001.png

1.5.8.1. SGD#

Stochastischer Gradientenabstieg ist eine Optimierungsmethode für Probleme ohne Nebenbedingungen. Im Gegensatz zum (Batch-)Gradientenabstieg approximiert SGD den wahren Gradienten von \(E(w,b)\), indem er jeweils ein einzelnes Trainingsbeispiel berücksichtigt.

Die Klasse SGDClassifier implementiert eine erstklassige SGD-Leroutine. Der Algorithmus iteriert über die Trainingsbeispiele und aktualisiert für jedes Beispiel die Modellparameter gemäß der Update-Regel, die gegeben ist durch

\[w \leftarrow w - \eta \left[\alpha \frac{\partial R(w)}{\partial w} + \frac{\partial L(w^T x_i + b, y_i)}{\partial w}\right]\]

wobei \(\eta\) die Lernrate ist, die die Schrittgröße im Parameterraum steuert. Der Achsenabschnitt \(b\) wird ähnlich aktualisiert, aber ohne Regularisierung (und mit zusätzlichem Zerfall für spärliche Matrizen, wie im Detail in Implementierungsdetails beschrieben).

Die Lernrate \(\eta\) kann konstant sein oder allmählich abnehmen. Für Klassifikation ist die Standardlernratenkennlinie (learning_rate='optimal') gegeben durch

\[\eta^{(t)} = \frac {1}{\alpha (t_0 + t)}\]

wobei \(t\) der Zeitschritt ist (es gibt insgesamt n_samples * n_iter Zeitschritte), \(t_0\) wird basierend auf einer Heuristik von Léon Bottou bestimmt, so dass die erwarteten anfänglichen Updates mit der erwarteten Größe der Gewichte vergleichbar sind (dies setzt voraus, dass die Norm der Trainingsbeispiele ungefähr 1 ist). Die genaue Definition findet sich in _init_t in BaseSGD.

Für Regression ist die Standardlernratenkennlinie invers skalierend (learning_rate='invscaling'), gegeben durch

\[\eta^{(t)} = \frac{\eta_0}{t^{power\_t}}\]

wobei \(\eta_0\) und \(power\_t\) Hyperparameter sind, die vom Benutzer über eta0 und power_t gewählt werden.

Für eine konstante Lernrate verwenden Sie learning_rate='constant' und geben Sie die Lernrate mit eta0 an.

Für eine adaptiv abnehmende Lernrate verwenden Sie learning_rate='adaptive' und geben Sie die anfängliche Lernrate mit eta0 an. Wenn das Stoppkriterium erreicht ist, wird die Lernrate durch 5 geteilt und der Algorithmus stoppt nicht. Der Algorithmus stoppt, wenn die Lernrate unter 1e-6 fällt.

Die Modellparameter sind über die Attribute coef_ und intercept_ zugänglich: coef_ enthält die Gewichte \(w\) und intercept_ enthält \(b\).

Bei Verwendung von Averaged SGD (mit dem Parameter average) wird coef_ auf das durchschnittliche Gewicht über alle Updates gesetzt: coef_ \(= \frac{1}{T} \sum_{t=0}^{T-1} w^{(t)}\), wobei \(T\) die Gesamtzahl der Updates ist, die im Attribut t_ zu finden ist.

1.5.9. Implementierungsdetails#

Die Implementierung von SGD ist von Stochastic Gradient SVM von [7] beeinflusst. Ähnlich wie bei SvmSGD wird der Gewichtsvektor als Produkt eines Skalars und eines Vektors dargestellt, was eine effiziente Gewichtsaktualisierung im Falle einer \(L_2\)-Regularisierung ermöglicht. Im Falle von spärlichen Eingaben X wird der Achsenabschnitt mit einer kleineren Lernrate (multipliziert mit 0,01) aktualisiert, um der Tatsache Rechnung zu tragen, dass er häufiger aktualisiert wird. Trainingsbeispiele werden sequenziell aufgenommen und die Lernrate wird nach jedem beobachteten Beispiel gesenkt. Wir haben die Lernratenkennlinie von [8] übernommen. Für die multiklassifizierte Klassifizierung wird ein "one versus all"-Ansatz verwendet. Wir verwenden den truncaten Gradientenalgorithmus, der in [9] für \(L_1\)-Regularisierung (und das Elastic Net) vorgeschlagen wurde. Der Code ist in Cython geschrieben.

Referenzen