1.1. Lineare Modelle#

Die folgenden Methoden sind für Regressionen gedacht, bei denen der Zielwert als lineare Kombination der Merkmale erwartet wird. In mathematischer Notation, wenn \(\hat{y}\) der vorhergesagte Wert ist.

\[\hat{y}(w, x) = w_0 + w_1 x_1 + ... + w_p x_p\]

Im gesamten Modul bezeichnen wir den Vektor \(w = (w_1, ..., w_p)\) als coef_ und \(w_0\) als intercept_.

Für Klassifikation mit verallgemeinerten linearen Modellen siehe Logistische Regression.

1.1.1. Gewöhnliche kleinste Quadrate#

LinearRegression passt ein lineares Modell mit Koeffizienten \(w = (w_1, ..., w_p)\) an, um die Summe der quadrierten Residuen zwischen den beobachteten Zielwerten im Datensatz und den vom linearen Ansatz vorhergesagten Zielwerten zu minimieren. Mathematisch löst es ein Problem der Form

\[\min_{w} || X w - y||_2^2\]

../_images/sphx_glr_plot_ols_ridge_001.png

LinearRegression nimmt in seiner fit Methode die Argumente X, y, sample_weight entgegen und speichert die Koeffizienten \(w\) des linearen Modells in seinen Attributen coef_ und intercept_.

>>> from sklearn import linear_model
>>> reg = linear_model.LinearRegression()
>>> reg.fit([[0, 0], [1, 1], [2, 2]], [0, 1, 2])
LinearRegression()
>>> reg.coef_
array([0.5, 0.5])
>>> reg.intercept_
0.0

Die Koeffizientenschätzungen für Ordinary Least Squares beruhen auf der Unabhängigkeit der Merkmale. Wenn Merkmale korreliert sind und einige Spalten der Designmatrix \(X\) eine annähernd lineare Abhängigkeit aufweisen, wird die Designmatrix fast singulär und als Ergebnis wird die Kleinste-Quadrate-Schätzung sehr empfindlich gegenüber Zufallsfehlern im beobachteten Zielwert, was zu einer großen Varianz führt. Diese Situation der Multikollinearität kann zum Beispiel auftreten, wenn Daten ohne experimentelles Design gesammelt werden.

Beispiele

Gewöhnliche kleinste Quadrate und Ridge Regression

1.1.1.1. Nicht-negative kleinste Quadrate#

Es ist möglich, alle Koeffizienten auf nicht-negativ zu beschränken, was nützlich sein kann, wenn sie einige physikalische oder natürlich nicht-negative Mengen darstellen (z. B. Häufigkeiten oder Preise von Waren). LinearRegression akzeptiert einen booleschen Parameter positive: Wenn dieser auf True gesetzt ist, werden die Non-Negative Least Squares angewendet.

Beispiele

Nicht-negative kleinste Quadrate

1.1.1.2. Komplexität der gewöhnlichen kleinsten Quadrate#

Die Lösung der kleinsten Quadrate wird mithilfe der Singulärwertzerlegung von \(X\) berechnet. Wenn \(X\) eine Matrix der Form (n_samples, n_features) ist, hat diese Methode Kosten von \(O(n_{\text{samples}} n_{\text{features}}^2)\), vorausgesetzt, dass \(n_{\text{samples}} \geq n_{\text{features}}\).

1.1.2. Ridge-Regression und Klassifikation#

1.1.2.1. Regression#

Ridge Regression adressiert einige Probleme der Gewöhnlichen kleinsten Quadrate, indem sie eine Strafe auf die Größe der Koeffizienten auferlegt. Die Ridge-Koeffizienten minimieren eine bestrafte Summe der quadrierten Residuen

\[\min_{w} || X w - y||_2^2 + \alpha ||w||_2^2\]

Der Komplexitätsparameter \(\alpha \geq 0\) steuert die Stärke der Schrumpfung: Je größer der Wert von \(\alpha\), desto größer ist die Stärke der Schrumpfung und desto robuster werden die Koeffizienten gegenüber Kollinearität.

../_images/sphx_glr_plot_ridge_path_001.png

Wie bei anderen linearen Modellen nimmt Ridge in seiner fit Methode die Arrays X, y entgegen und speichert die Koeffizienten \(w\) des linearen Modells in seinem Mitglied coef_.

>>> from sklearn import linear_model
>>> reg = linear_model.Ridge(alpha=.5)
>>> reg.fit([[0, 0], [0, 0], [1, 1]], [0, .1, 1])
Ridge(alpha=0.5)
>>> reg.coef_
array([0.34545455, 0.34545455])
>>> reg.intercept_
np.float64(0.13636)

Beachten Sie, dass die Klasse Ridge dem Benutzer erlaubt, anzugeben, dass der Solver automatisch gewählt werden soll, indem solver="auto" gesetzt wird. Wenn diese Option angegeben wird, wählt Ridge zwischen den "lbfgs", "cholesky" und "sparse_cg" Solvern. Ridge beginnt, die Bedingungen in der folgenden Tabelle von oben nach unten zu prüfen. Wenn die Bedingung wahr ist, wird der entsprechende Solver gewählt.

Solver	Bedingung
‘lbfgs’	Die Option `positive=True` ist angegeben.
‘cholesky’	Das Eingabearray X ist nicht dünn besetzt (sparse).
‘sparse_cg’	Keine der obigen Bedingungen ist erfüllt.

Beispiele

1.1.2.2. Klassifikation#

Der Ridge Regressor hat eine Klassifikator-Variante: RidgeClassifier. Dieser Klassifikator wandelt binäre Ziele zunächst in {-1, 1} um und behandelt das Problem dann als Regressionsaufgabe, wobei er dasselbe Ziel wie oben optimiert. Die vorhergesagte Klasse entspricht dem Vorzeichen der Vorhersage des Regressors. Für die Multiklassenklassifikation wird das Problem als Multi-Output-Regression behandelt, und die vorhergesagte Klasse entspricht der Ausgabe mit dem höchsten Wert.

Es mag fragwürdig erscheinen, eine (bestrafte) Kleinste-Quadrate-Verlustfunktion zur Anpassung eines Klassifikationsmodells anstelle der traditionelleren Logistik- oder Hinge-Verlustfunktionen zu verwenden. In der Praxis können jedoch alle diese Modelle zu ähnlichen Kreuzvalidierungsergebnissen in Bezug auf Genauigkeit oder Präzision/Recall führen, während die von RidgeClassifier verwendete bestrafte Kleinste-Quadrate-Verlustfunktion eine sehr unterschiedliche Wahl der numerischen Solver mit unterschiedlichen Rechenleistungsprofilen ermöglicht.

Der RidgeClassifier kann deutlich schneller sein als z. B. LogisticRegression bei einer hohen Anzahl von Klassen, da er die Projektionsmatrix \((X^T X)^{-1} X^T\) nur einmal berechnen kann.

Dieser Klassifikator wird manchmal als Least Squares Support Vector Machine mit einem linearen Kernel bezeichnet.

Beispiele

Klassifikation von Textdokumenten mit spärlichen Merkmalen

1.1.2.3. Ridge-Komplexität#

Diese Methode hat die gleiche Komplexitätsordnung wie Gewöhnliche kleinste Quadrate.

1.1.2.4. Einstellen des Regularisierungsparameters: Leave-One-Out-Kreuzvalidierung#

RidgeCV und RidgeClassifierCV implementieren Ridge-Regression/Klassifikation mit integrierter Kreuzvalidierung des Alpha-Parameters. Sie funktionieren auf die gleiche Weise wie GridSearchCV, außer dass standardmäßig effiziente Leave-One-Out- Kreuzvalidierung verwendet wird. Bei Verwendung der Standard- Kreuzvalidierung kann Alpha aufgrund der verwendeten Formulierung zur Berechnung des Leave-One-Out-Fehlers nicht 0 sein. Siehe [RL2007] für Details.

Anwendungsbeispiel

>>> import numpy as np
>>> from sklearn import linear_model
>>> reg = linear_model.RidgeCV(alphas=np.logspace(-6, 6, 13))
>>> reg.fit([[0, 0], [0, 0], [1, 1]], [0, .1, 1])
RidgeCV(alphas=array([1.e-06, 1.e-05, 1.e-04, 1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01,
      1.e+02, 1.e+03, 1.e+04, 1.e+05, 1.e+06]))
>>> reg.alpha_
np.float64(0.01)

Das Festlegen des Werts des Attributs cv löst die Verwendung von Kreuzvalidierung mit GridSearchCV aus, z. B. cv=10 für 10-fache Kreuzvalidierung, anstelle von Leave-One-Out-Kreuzvalidierung.

1.1.3. Lasso#

Das Lasso ist ein lineares Modell, das dünn besetzte Koeffizienten schätzt, d. h., es kann Koeffizienten exakt auf Null setzen. Es ist in einigen Kontexten nützlich, da es dazu neigt, Lösungen mit weniger Nicht-Null-Koeffizienten zu bevorzugen und damit effektiv die Anzahl der Merkmale, von denen die gegebene Lösung abhängt, zu reduzieren. Aus diesem Grund sind Lasso und seine Varianten fundamental für das Feld der komprimierten Abtastung. Unter bestimmten Bedingungen kann es die exakte Menge der Nicht-Null-Koeffizienten wiederherstellen (siehe Komprimierte Abtastung: Tomographierekonstruktion mit L1-Prior (Lasso)).

Mathematisch besteht es aus einem linearen Modell mit einem hinzugefügten Regularisierungsterm. Die zu minimierende Zielfunktion ist

\[\min_{w} P(w) = {\frac{1}{2n_{\text{samples}}} ||X w - y||_2 ^ 2 + \alpha ||w||_1}\]

Der Lasso-Schätzer löst somit die Kleinsten-Quadrate-Methode mit der hinzugefügten Strafe \(\alpha ||w||_1\), wobei \(\alpha\) eine Konstante ist und \(||w||_1\) die \(\ell_1\)-Norm des Koeffizientenvektors ist.

Die Implementierung in der Klasse Lasso verwendet Coordinate Descent als Algorithmus zur Anpassung der Koeffizienten. Siehe Least Angle Regression für eine weitere Implementierung.

>>> from sklearn import linear_model
>>> reg = linear_model.Lasso(alpha=0.1)
>>> reg.fit([[0, 0], [1, 1]], [0, 1])
Lasso(alpha=0.1)
>>> reg.predict([[1, 1]])
array([0.8])

Die Funktion lasso_path ist für Low-Level-Aufgaben nützlich, da sie die Koeffizienten entlang des gesamten Pfades möglicher Werte berechnet.

Beispiele

Hinweis

Merkmalsauswahl mit Lasso

Da die Lasso-Regression dünn besetzte Modelle liefert, kann sie somit zur Merkmalsauswahl verwendet werden, wie in L1-basierte Merkmalsauswahl beschrieben.

1.1.3.1. Coordinate Descent mit Gap Safe Screening Rules#

Coordinate Descent (CD) ist eine Strategie zur Lösung eines Minimierungsproblems, das jeweils ein einzelnes Merkmal \(j\) betrachtet. Auf diese Weise wird das Optimierungsproblem auf ein 1-dimensionales Problem reduziert, das einfacher zu lösen ist

\[\min_{w_j} {\frac{1}{2n_{\text{samples}}} ||x_j w_j + X_{-j}w_{-j} - y||_2 ^ 2 + \alpha |w_j|}\]

wobei der Index \(-j\) alle Merkmale außer \(j\) bedeutet. Die Lösung ist

\[w_j = \frac{S(x_j^T (y - X_{-j}w_{-j}), \alpha)}{||x_j||_2^2}\]

mit der Soft-Thresholding-Funktion \(S(z, \alpha) = \operatorname{sign}(z) \max(0, |z|-\alpha)\). Beachten Sie, dass die Soft-Thresholding-Funktion exakt Null ist, wann immer \(\alpha \geq |z|\). Der CD-Solver durchläuft dann die Merkmale entweder in einem Zyklus, wählt ein Merkmal nach dem anderen in der Reihenfolge, die durch X vorgegeben ist (selection="cyclic"), oder wählt zufällig Merkmale aus (selection="random"). Er stoppt, wenn der Dualitätsabstand kleiner als die angegebene Toleranz tol ist.

Eine clevere Methode zur Beschleunigung des Coordinate Descent Algorithmus ist das Aussortieren von Merkmalen, so dass im Optimum \(\text{w}_j = 0\) ist. Gap Safe Screening Rules sind ein solches Werkzeug. Sie können jederzeit während des Optimierungsalgorithmus angeben, welche Merkmale sicher ausgeschlossen, d. h. mit Sicherheit auf Null gesetzt werden können.

1.1.3.2. Einstellen des Regularisierungsparameters#

Der Parameter alpha steuert den Grad der Dünnbesetztheit der geschätzten Koeffizienten.

1.1.3.2.1. Verwendung von Kreuzvalidierung#

scikit-learn stellt Objekte zur Verfügung, die den Lasso alpha Parameter per Kreuzvalidierung einstellen: LassoCV und LassoLarsCV. LassoLarsCV basiert auf dem unten erklärten Least Angle Regression Algorithmus.

Für hochdimensionale Datensätze mit vielen kollinearen Merkmalen ist LassoCV meist vorzuziehen. LassoLarsCV hat jedoch den Vorteil, dass es mehr relevante Werte des alpha Parameters untersucht, und wenn die Anzahl der Stichproben im Vergleich zur Anzahl der Merkmale sehr klein ist, ist es oft schneller als LassoCV.

1.1.3.2.2. Informationskriterien-basierte Modellauswahl#

Alternativ schlägt der Schätzer LassoLarsIC die Verwendung des Akaike Information Criterion (AIC) und des Bayes Information Criterion (BIC) vor. Es ist eine rechentechnisch günstigere Alternative zur Ermittlung des optimalen Alpha-Werts, da der Regularisierungspfad nur einmal anstatt k+1 Mal bei Verwendung von k-facher Kreuzvalidierung berechnet wird.

Tatsächlich werden diese Kriterien auf dem In-Sample-Trainingsdatensatz berechnet. Kurz gesagt, sie bestrafen die übermäßig optimistischen Scores der verschiedenen Lasso-Modelle durch ihre Flexibilität (siehe unten den Abschnitt „Mathematische Details“).

Solche Kriterien erfordern jedoch eine korrekte Schätzung der Freiheitsgrade der Lösung, sind für große Stichproben (asymptotische Ergebnisse) abgeleitet und gehen davon aus, dass das korrekte Modell unter den untersuchten Kandidaten ist. Sie versagen auch tendenziell, wenn das Problem schlecht konditioniert ist (z. B. mehr Merkmale als Stichproben).

../_images/sphx_glr_plot_lasso_lars_ic_001.png

Beispiele

1.1.3.2.3. AIC- und BIC-Kriterien#

Die Definition von AIC (und damit BIC) kann in der Literatur variieren. In diesem Abschnitt geben wir weitere Informationen über das in scikit-learn berechnete Kriterium.

1.1.3.2.4. Vergleich mit dem Regularisierungsparameter von SVM#

Die Äquivalenz zwischen alpha und dem Regularisierungsparameter von SVM, C, ist gegeben durch alpha = 1 / C oder alpha = 1 / (n_samples * C), abhängig vom Schätzer und der genauen Zielfunktion, die vom Modell optimiert wird.

1.1.4. Multi-Task Lasso#

Das MultiTaskLasso ist ein lineares Modell, das Koeffizienten für mehrere Regressionsprobleme gemeinsam schätzt: y ist ein 2D-Array der Form (n_samples, n_tasks). Die Einschränkung besteht darin, dass die ausgewählten Merkmale für alle Regressionsprobleme, auch Task genannt, gleich sind.

Die folgende Abbildung vergleicht die Position der Nicht-Null-Einträge in der Koeffizientenmatrix W, die mit einem einfachen Lasso oder einem MultiTaskLasso erhalten werden. Die Lasso-Schätzungen ergeben verstreute Nicht-Nullwerte, während die Nicht-Nullwerte des MultiTaskLasso vollständige Spalten sind.

Anpassen eines Zeitreihenmodells, das erzwingt, dass jedes aktive Merkmal zu jeder Zeit aktiv ist.

Beispiele

Gemeinsame Merkmalsauswahl mit Multi-Task Lasso

1.1.5. Elastic-Net#

ElasticNet ist ein lineares Regressionsmodell, das sowohl mit \(\ell_1\)- als auch mit \(\ell_2\)-Norm-Regularisierung der Koeffizienten trainiert wird. Diese Kombination ermöglicht das Erlernen eines dünn besetzten Modells, bei dem nur wenige Gewichte Nicht-Null sind, wie bei Lasso, während die Regularisierungseigenschaften von Ridge beibehalten werden. Wir steuern die konvexe Kombination von \(\ell_1\) und \(\ell_2\) mit dem Parameter l1_ratio.

Elastic-Net ist nützlich, wenn mehrere Merkmale miteinander korreliert sind. Lasso wählt wahrscheinlich eines dieser Merkmale zufällig aus, während Elastic-Net wahrscheinlich beide auswählt.

Ein praktischer Vorteil des Kompromisses zwischen Lasso und Ridge ist, dass Elastic-Net dadurch einige der Stabilität von Ridge gegenüber Rotationen erbt.

Die zu minimierende Zielfunktion ist in diesem Fall

\[\min_{w} { \frac{1}{2n_{\text{samples}}} ||X w - y||_2 ^ 2 + \alpha \rho ||w||_1 + \frac{\alpha(1-\rho)}{2} ||w||_2 ^ 2}\]

../_images/sphx_glr_plot_lasso_lasso_lars_elasticnet_path_002.png

Die Klasse ElasticNetCV kann verwendet werden, um die Parameter alpha (\(\alpha\)) und l1_ratio (\(\rho\)) mittels Kreuzvalidierung festzulegen.

Beispiele

1.1.6. Multi-Task Elastic-Net#

Das MultiTaskElasticNet ist ein Elastic-Net-Modell, das sparse Koeffizienten für mehrere Regressionsprobleme gemeinsam schätzt: Y ist ein 2D-Array der Form (n_samples, n_tasks). Die Einschränkung besteht darin, dass die ausgewählten Merkmale für alle Regressionsprobleme, auch Aufgaben genannt, gleich sind.

Mathematisch gesehen besteht es aus einem linearen Modell, das mit einer gemischten \(\ell_1\)- \(\ell_2\)-Norm und \(\ell_2\)-Norm zur Regularisierung trainiert wird. Die zu minimierende Zielfunktion ist

\[\min_{W} { \frac{1}{2n_{\text{samples}}} ||X W - Y||_{\text{Fro}}^2 + \alpha \rho ||W||_{2 1} + \frac{\alpha(1-\rho)}{2} ||W||_{\text{Fro}}^2}\]

Die Implementierung in der Klasse MultiTaskElasticNet verwendet Coordinate Descent als Algorithmus zur Anpassung der Koeffizienten.

Die Klasse MultiTaskElasticNetCV kann verwendet werden, um die Parameter alpha (\(\alpha\)) und l1_ratio (\(\rho\)) mittels Kreuzvalidierung festzulegen.

1.1.7. Least Angle Regression#

Least-Angle-Regression (LARS) ist ein Regressionsalgorithmus für hochdimensionale Daten, der von Bradley Efron, Trevor Hastie, Iain Johnstone und Robert Tibshirani entwickelt wurde. LARS ähnelt der vorwärtsgerichteten schrittweisen Regression. In jedem Schritt findet es das Merkmal, das am stärksten mit dem Ziel korreliert ist. Wenn mehrere Merkmale gleich stark korreliert sind, fährt es nicht entlang desselben Merkmals fort, sondern bewegt sich in einer Richtung, die zwischen den Merkmalen winkeltreu ist.

Die Vorteile von LARS sind

Es ist numerisch effizient in Kontexten, in denen die Anzahl der Merkmale deutlich größer ist als die Anzahl der Stichproben.
Es ist rechnerisch genauso schnell wie die Vorwärtsselektion und hat die gleiche Komplexitätsordnung wie die gewöhnliche kleinste Quadrate.
Es erzeugt einen vollständigen stückweise linearen Lösungspfad, der für die Kreuzvalidierung oder ähnliche Versuche zur Feinabstimmung des Modells nützlich ist.
Wenn zwei Merkmale fast gleich stark mit dem Ziel korreliert sind, sollten ihre Koeffizienten ungefähr im gleichen Tempo ansteigen. Der Algorithmus verhält sich somit, wie die Intuition es erwarten würde, und ist auch stabiler.
Es kann leicht modifiziert werden, um Lösungen für andere Schätzer wie Lasso zu erzeugen.

Die Nachteile der LARS-Methode umfassen

Da LARS auf einer iterativen Neuanpassung der Residuen basiert, scheint es besonders empfindlich auf die Auswirkungen von Rauschen zu reagieren. Dieses Problem wird von Weisberg im Diskussionsabschnitt des Artikels von Efron et al. (2004) in den Annals of Statistics ausführlich erörtert.

Das LARS-Modell kann über den Schätzer Lars oder seine Low-Level-Implementierung lars_path oder lars_path_gram verwendet werden.

1.1.8. LARS Lasso#

LassoLars ist ein Lasso-Modell, das mit dem LARS-Algorithmus implementiert wird, und im Gegensatz zur Implementierung, die auf Coordinate Descent basiert, liefert dies die exakte Lösung, die stückweise linear in Bezug auf die Norm seiner Koeffizienten ist.

../_images/sphx_glr_plot_lasso_lasso_lars_elasticnet_path_001.png

>>> from sklearn import linear_model
>>> reg = linear_model.LassoLars(alpha=.1)
>>> reg.fit([[0, 0], [1, 1]], [0, 1])
LassoLars(alpha=0.1)
>>> reg.coef_
array([0.6, 0.        ])

Beispiele

Lasso, Lasso-LARS und Elastic Net Pfade

Der LARS-Algorithmus liefert den vollständigen Pfad der Koeffizienten entlang des Regularisierungsparameters fast kostenlos, daher ist eine gängige Operation, den Pfad mit einer der Funktionen lars_path oder lars_path_gram abzurufen.

1.1.9. Orthogonal Matching Pursuit (OMP)#

OrthogonalMatchingPursuit und orthogonal_mp implementieren den OMP-Algorithmus zur Annäherung der Anpassung eines linearen Modells mit Einschränkungen für die Anzahl der nicht-null Koeffizienten (d. h. die \(\ell_0\)-Pseudo-Norm).

Als vorwärtsgerichtete Merkmalsauswahlmethode wie Least Angle Regression kann Orthogonal Matching Pursuit den optimalen Lösungsvvektor mit einer festen Anzahl von nicht-null Elementen annähern

\[\underset{w}{\operatorname{arg\,min\,}} ||y - Xw||_2^2 \text{ subject to } ||w||_0 \leq n_{\text{nonzero_coefs}}\]

Alternativ kann Orthogonal Matching Pursuit einen bestimmten Fehler anstelle einer bestimmten Anzahl von nicht-null Koeffizienten anstreben. Dies kann wie folgt ausgedrückt werden:

\[\underset{w}{\operatorname{arg\,min\,}} ||w||_0 \text{ subject to } ||y-Xw||_2^2 \leq \text{tol}\]

OMP basiert auf einem gierigen Algorithmus, der in jedem Schritt das Atom einschließt, das am stärksten mit dem aktuellen Residuum korreliert ist. Er ähnelt der einfacheren Matching Pursuit (MP)-Methode, ist aber besser, da in jeder Iteration das Residuum durch orthogonale Projektion auf den Raum der zuvor gewählten Dictionary-Elemente neu berechnet wird.

Beispiele

Orthogonal Matching Pursuit

1.1.10. Bayesian Regression#

Bayesian-Regressionstechniken können verwendet werden, um Regularisierungsparameter in den Schätzungsprozess einzubeziehen: Der Regularisierungsparameter wird nicht hart eingestellt, sondern an die vorliegenden Daten angepasst.

Dies kann durch Einführung von uninformierenden Priors über die Hyperparameter des Modells geschehen. Die in der Ridge-Regression und Klassifizierung verwendete \(\ell_2\)-Regularisierung ist gleichbedeutend mit der Suche nach einer Maximum-A-Posteriori-Schätzung unter einem Gaußschen Prior für die Koeffizienten \(w\) mit der Präzision \(\lambda^{-1}\). Anstatt lambda manuell festzulegen, ist es möglich, es als Zufallsvariable zu behandeln, die aus den Daten geschätzt wird.

Um ein vollständig probabilistisches Modell zu erhalten, wird angenommen, dass die Ausgabe \(y\) Gaußsch um \(X w\) verteilt ist

\[p(y|X,w,\alpha) = \mathcal{N}(y|X w,\alpha^{-1})\]

wobei \(\alpha\) wiederum als Zufallsvariable behandelt wird, die aus den Daten geschätzt werden soll.

Die Vorteile der Bayesschen Regression sind

Sie passt sich an die vorhandenen Daten an.
Sie kann verwendet werden, um Regularisierungsparameter in den Schätzungsprozess einzubeziehen.

Die Nachteile der Bayesschen Regression umfassen

Die Inferenz des Modells kann zeitaufwendig sein.

1.1.10.1. Bayesian Ridge Regression#

BayesianRidge schätzt ein probabilistisches Modell des Regressionsproblems wie oben beschrieben. Der Prior für die Koeffizienten \(w\) wird durch eine sphärische Gaußsche Verteilung gegeben

\[p(w|\lambda) = \mathcal{N}(w|0,\lambda^{-1}\mathbf{I}_{p})\]

Die Priors über \(\alpha\) und \(\lambda\) werden als Gamma-Verteilungen gewählt, dem konjugierten Prior für die Präzision des Gaußschen. Das resultierende Modell wird als Bayesian Ridge Regression bezeichnet und ist ähnlich der klassischen Ridge.

Die Parameter \(w\), \(\alpha\) und \(\lambda\) werden während der Anpassung des Modells gemeinsam geschätzt, wobei die Regularisierungsparameter \(\alpha\) und \(\lambda\) durch Maximierung der logarithmischen marginalen Likelihood geschätzt werden. Die scikit-learn-Implementierung basiert auf dem Algorithmus, der in Anhang A von (Tipping, 2001) beschrieben ist, wobei die Aktualisierung der Parameter \(\alpha\) und \(\lambda\) wie in (MacKay, 1992) vorgeschlagen erfolgt. Der Anfangswert des Maximierungsverfahrens kann mit den Hyperparametern alpha_init und lambda_init festgelegt werden.

Es gibt vier weitere Hyperparameter, \(\alpha_1\), \(\alpha_2\), \(\lambda_1\) und \(\lambda_2\) der Gamma-Prior-Verteilungen über \(\alpha\) und \(\lambda\). Diese werden normalerweise als *uninformierend* gewählt. Standardmäßig sind \(\alpha_1 = \alpha_2 = \lambda_1 = \lambda_2 = 10^{-6}\).

Bayesian Ridge Regression wird für Regressionen verwendet

>>> from sklearn import linear_model
>>> X = [[0., 0.], [1., 1.], [2., 2.], [3., 3.]]
>>> Y = [0., 1., 2., 3.]
>>> reg = linear_model.BayesianRidge()
>>> reg.fit(X, Y)
BayesianRidge()

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

>>> reg.predict([[1, 0.]])
array([0.50000013])

Die Koeffizienten \(w\) des Modells können abgerufen werden

>>> reg.coef_
array([0.49999993, 0.49999993])

Aufgrund des Bayesschen Rahmens unterscheiden sich die gefundenen Gewichte leicht von denen, die durch Ordinary Least Squares gefunden werden. Die Bayesian Ridge Regression ist jedoch robuster gegenüber schlecht gestellten Problemen.

Beispiele

Kurvenanpassung mit Bayes'scher Ridge-Regression

1.1.10.2. Automatic Relevance Determination - ARD#

Die automatische Relevanzbestimmung (wie sie in ARDRegression implementiert ist) ist eine Art lineares Modell, das der Bayesschen Ridge-Regression sehr ähnlich ist, aber zu dünneren Koeffizienten \(w\) führt [1] [2].

ARDRegression legt einen anderen Prior auf \(w\): Es wird von der sphärischen Gaußschen Verteilung zu einer zentrierten elliptischen Gaußschen Verteilung übergegangen. Das bedeutet, dass jeder Koeffizient \(w_{i}\) selbst aus einer Gaußschen Verteilung gezogen werden kann, zentriert auf Null und mit einer Präzision \(\lambda_{i}\)

\[p(w|\lambda) = \mathcal{N}(w|0,A^{-1})\]

wobei \({A}\) eine positiv definite Diagonalmatrix ist und \(\text{diag}(A) = \lambda = \{\lambda_{1},...,\lambda_{p}\}\).

Im Gegensatz zur Bayesschen Ridge-Regression hat jede Koordinate von \(w_{i}\) ihre eigene Standardabweichung \(\frac{1}{\lambda_i}\). Der Prior über alle \(\lambda_i\) wird als dieselbe Gamma-Verteilung gewählt, die durch die Hyperparameter \(\lambda_1\) und \(\lambda_2\) gegeben ist.

ARD ist in der Literatur auch als Sparse Bayesian Learning und Relevance Vector Machine bekannt [3] [4].

Siehe Vergleich von linearen Bayesschen Regressoren für einen ausgearbeiteten Vergleich zwischen ARD und Bayesscher Ridge-Regression.

Siehe L1-basierte Modelle für sparse Signale für einen Vergleich zwischen verschiedenen Methoden - Lasso, ARD und ElasticNet - auf korrelierten Daten.

Referenzen

1.1.11. Logistische Regression#

Die logistische Regression wird in LogisticRegression implementiert. Trotz ihres Namens wird sie im Sinne der scikit-learn/ML-Nomenklatur als lineares Modell für die Klassifizierung und nicht für die Regression implementiert. Die logistische Regression ist in der Literatur auch als Logit-Regression, Maximum-Entropie-Klassifikation (MaxEnt) oder Log-lineare Klassifikator bekannt. In diesem Modell werden die Wahrscheinlichkeiten, die die möglichen Ergebnisse eines einzelnen Versuchs beschreiben, mithilfe einer logistischen Funktion modelliert.

Diese Implementierung kann binäre, One-vs-Rest- oder multinomale logistische Regressionen mit optionaler \(\ell_1\)-, \(\ell_2\)- oder Elastic-Net-Regularisierung anpassen.

Hinweis

Regularisierung

Standardmäßig wird eine Regularisierung angewendet, was in der maschinellen Lernens üblich ist, aber nicht in der Statistik. Ein weiterer Vorteil der Regularisierung ist die Verbesserung der numerischen Stabilität. Keine Regularisierung entspricht der Einstellung von C auf einen sehr hohen Wert.

Hinweis

Logistische Regression als Spezialfall der Generalisierten Linearen Modelle (GLM)

Die logistische Regression ist ein Spezialfall der Generalisierten Linearen Modelle mit einer Binomial-/Bernoulli-bedingten Verteilung und einem Logit-Link. Die numerische Ausgabe der logistischen Regression, die die vorhergesagte Wahrscheinlichkeit ist, kann als Klassifikator verwendet werden, indem ein Schwellenwert (standardmäßig 0,5) angewendet wird. So ist sie in scikit-learn implementiert, daher erwartet sie ein kategorisches Ziel, was die logistische Regression zu einem Klassifikator macht.

Beispiele

1.1.11.1. Binärer Fall#

Zur Vereinfachung der Notation nehmen wir an, dass das Ziel \(y_i\) für den Datenpunkt \(i\) Werte aus der Menge \(\{0, 1\}\) annimmt. Nach der Anpassung sagt die Methode predict_proba von LogisticRegression die Wahrscheinlichkeit der positiven Klasse \(P(y_i=1|X_i)\) als

\[\hat{p}(X_i) = \operatorname{expit}(X_i w + w_0) = \frac{1}{1 + \exp(-X_i w - w_0)}.\]

Als Optimierungsproblem minimiert die binäre logistische Regression mit einem Regularisierungsterm \(r(w)\) die folgende Kostenfunktion:

(1)#\[\min_{w} \frac{1}{S}\sum_{i=1}^n s_i \left(-y_i \log(\hat{p}(X_i)) - (1 - y_i) \log(1 - \hat{p}(X_i))\right) + \frac{r(w)}{S C}\,,\]

wobei \({s_i}\) den vom Benutzer zugewiesenen Gewichten für ein bestimmtes Trainingsbeispiel entspricht (der Vektor \(s\) wird durch elementweise Multiplikation der Klassen- und Stichprobengewichte gebildet) und die Summe \(S = \sum_{i=1}^n s_i\).

Wir bieten derzeit vier Optionen für den Regularisierungs- oder Strafterm \(r(w)\) über die Argumente C und l1_ratio an

Strafe	\(r(w)\)
keine (`C=np.inf`)	\(0\)
\(\ell_1\) (`l1_ratio=1`)	\(\\|w\\|_1\)
\(\ell_2\) (`l1_ratio=0`)	\(\frac{1}{2}\\|w\\|_2^2 = \frac{1}{2}w^T w\)
ElasticNet (`0<l1_ratio<1`)	\(\frac{1 - \rho}{2}w^T w + \rho \\|w\\|_1\)

Bei ElasticNet steuert \(\rho\) (entspricht dem Parameter l1_ratio) die Stärke der \(\ell_1\)-Regularisierung im Vergleich zur \(\ell_2\)-Regularisierung. Elastic-Net ist äquivalent zu \(\ell_1\), wenn \(\rho = 1\) und äquivalent zu \(\ell_2\), wenn \(\rho=0\).

Beachten Sie, dass die Skalierung der Klassen- und Stichprobengewichte das Optimierungsproblem beeinflusst. Zum Beispiel ist die Multiplikation der Stichprobengewichte mit einer Konstante \(b>0\) äquivalent zur Multiplikation der (inversen) Regularisierungsstärke C mit \(b\).

1.1.11.2. Multinomialer Fall#

Der binäre Fall kann auf \(K\) Klassen erweitert werden, was zu einer multinominalen logistischen Regression führt, siehe auch log-lineares Modell.

Hinweis

Es ist möglich, ein \(K\)-Klassen-Klassifikationsmodell mit nur \(K-1\) Gewichtungsvektoren zu parametrisieren und die Wahrscheinlichkeit einer Klasse vollständig durch die Wahrscheinlichkeiten der anderen Klassen bestimmt zu lassen, indem die Tatsache genutzt wird, dass sich alle Klassenwahrscheinlichkeiten zu eins summieren müssen. Wir entscheiden uns bewusst dafür, das Modell mit \(K\) Gewichtungsvektoren zu überparametrisieren, um die Implementierung zu erleichtern und die symmetrische induktive Voreingenommenheit in Bezug auf die Reihenfolge der Klassen zu wahren, siehe [16]. Dieser Effekt wird besonders wichtig, wenn Regularisierung verwendet wird. Die Wahl der Überparametrisierung kann für unbestrafte Modelle nachteilig sein, da die Lösung dann nicht eindeutig sein kann, wie in [16] gezeigt.

Mathematische Details#

Sei \(y_i \in \{1, \ldots, K\}\) die Zielvariable (ordinal) für die Beobachtung \(i\). Anstelle eines einzelnen Koeffizientenvektors haben wir nun eine Koeffizientenmatrix \(W\), wobei jeder Zeilenvektor \(W_k\) der Klasse \(k\) entspricht. Wir zielen darauf ab, die Klassenwahrscheinlichkeiten \(P(y_i=k|X_i)\) über predict_proba wie folgt vorherzusagen:

\[\hat{p}_k(X_i) = \frac{\exp(X_i W_k + W_{0, k})}{\sum_{l=0}^{K-1} \exp(X_i W_l + W_{0, l})}.\]

Das Ziel der Optimierung wird

\[\min_W -\frac{1}{S}\sum_{i=1}^n \sum_{k=0}^{K-1} s_{ik} [y_i = k] \log(\hat{p}_k(X_i)) + \frac{r(W)}{S C}\,,\]

wobei \([P]\) die Iverson-Klammer darstellt, die \(0\) ergibt, wenn \(P\) falsch ist, und andernfalls \(1\).

Auch hier sind \(s_{ik}\) die vom Benutzer zugewiesenen Gewichte (Multiplikation von Stichproben- und Klassengewichten) mit ihrer Summe \(S = \sum_{i=1}^n \sum_{k=0}^{K-1} s_{ik}\).

Wir bieten derzeit vier Optionen für den Regularisierungs- oder Strafterm \(r(W)\) über die Argumente C und l1_ratio an, wobei \(m\) die Anzahl der Merkmale ist

Strafe	\(r(W)\)
keine (`C=np.inf`)	\(0\)
\(\ell_1\) (`l1_ratio=1`)	\(\\|W\\|_{1,1} = \sum_{i=1}^m\sum_{j=1}^{K}\|W_{i,j}\|\)
\(\ell_2\) (`l1_ratio=0`)	\(\frac{1}{2}\\|W\\|_F^2 = \frac{1}{2}\sum_{i=1}^m\sum_{j=1}^{K} W_{i,j}^2\)
ElasticNet (`0<l1_ratio<1`)	\(\frac{1 - \rho}{2}\\|W\\|_F^2 + \rho \\|W\\|_{1,1}\)

1.1.11.3. Solver#

Die in der Klasse LogisticRegression implementierten Solver sind „lbfgs“, „liblinear“, „newton-cg“, „newton-cholesky“, „sag“ und „saga“.

Die folgende Tabelle fasst die Strafen und die multinomale Mehrklassenunterstützung zusammen, die von jedem Solver unterstützt werden.

	Solver
Strafen	‘lbfgs’	‘liblinear’	‘newton-cg’	‘newton-cholesky’	‘sag’	‘saga’
L2-Strafe	yes	yes	yes	yes	yes	yes
L1-Strafe	no	yes	no	no	no	yes
Elastic-Net (L1 + L2)	no	no	no	no	no	yes
Keine Strafe	yes	no	yes	yes	yes	yes
Multiklassen-Unterstützung
multinomial multiclass	yes	no	yes	yes	yes	yes
Verhalten
Intercept bestrafen (schlecht)	no	yes	no	no	no	no
Schneller für große Datensätze	no	no	no	no	yes	yes
Robust gegenüber unskalierten Datensätzen	yes	yes	yes	yes	no	no

Der Solver „lbfgs“ wird standardmäßig wegen seiner Robustheit verwendet. Für n_samples >> n_features ist „newton-cholesky“ eine gute Wahl und kann eine hohe Präzision erreichen (winzige tol-Werte). Für große Datensätze ist der Solver „saga“ normalerweise schneller (als „lbfgs“), insbesondere für geringe Präzision (hohe tol). Für große Datensätze können Sie auch die Verwendung von SGDClassifier mit loss="log_loss" in Betracht ziehen, was möglicherweise noch schneller ist, aber mehr Feinabstimmung erfordert.

1.1.11.3.1. Unterschiede zwischen den Solvern#

Es kann einen Unterschied in den erzielten Scores zwischen LogisticRegression mit solver=liblinear oder LinearSVC und der externen liblinear-Bibliothek direkt geben, wenn fit_intercept=False und die angepassten coef_ (oder) die vorherzusagenden Daten null sind. Dies liegt daran, dass für die Stichprobe(n) mit decision_function null, LogisticRegression und LinearSVC die negative Klasse vorhersagen, während liblinear die positive Klasse vorhersagt. Beachten Sie, dass ein Modell mit fit_intercept=False und vielen Stichproben mit decision_function null wahrscheinlich ein Underfitting und ein schlechtes Modell ist, und es wird empfohlen, fit_intercept=True festzulegen und intercept_scaling zu erhöhen.

Details zu den Solvern#

Der Solver „liblinear“ verwendet einen Coordinate Descent (CD) Algorithmus und stützt sich auf die exzellente C++ LIBLINEAR Bibliothek, die mit scikit-learn ausgeliefert wird. Der in liblinear implementierte CD-Algorithmus kann jedoch kein echtes multinomales (mehrklassiges) Modell lernen. Wenn Sie „liblinear“ dennoch für Mehrklassenprobleme verwenden möchten, können Sie ein „one-vs-rest“-Schema OneVsRestClassifier(LogisticRegression(solver="liblinear")) verwenden, siehe :class:`~sklearn.multiclass.OneVsRestClassifier. Beachten Sie, dass die Minimierung der multinomalen Verlustfunktion voraussichtlich besser kalibrierte Ergebnisse liefert als ein „one-vs-rest“-Schema. Für die \(\ell_1\)-Regularisierung erlaubt sklearn.svm.l1_min_c die Berechnung der unteren Grenze für C, um ein nicht „nulles“ (alle Merkmalsgewichte auf Null) Modell zu erhalten.
Die Solver „lbfgs“, „newton-cg“, „newton-cholesky“ und „sag“ unterstützen nur \(\ell_2\)-Regularisierung oder keine Regularisierung und konvergieren bei einigen hochdimensionalen Daten schneller. Diese Solver (und „saga“) lernen ein echtes multinomales logistisches Regressionsmodell [5].
Der Solver „sag“ verwendet Stochastic Average Gradient Descent [6]. Er ist schneller als andere Solver für große Datensätze, wenn sowohl die Anzahl der Samples als auch die Anzahl der Features groß sind.
Der Solver „saga“ [7] ist eine Variante von „sag“, die auch die nicht-glatte \(\ell_1\)-Strafe (l1_ratio=1) unterstützt. Dies ist daher der Solver der Wahl für sparse multinomale logistische Regression. Er ist auch der einzige Solver, der Elastic-Net unterstützt (0 < l1_ratio < 1).
„lbfgs“ ist ein Optimierungsalgorithmus, der den Broyden–Fletcher–Goldfarb–Shanno-Algorithmus [8] approximiert, welcher zu den Quasi-Newton-Methoden gehört. Daher kann er mit einer breiten Palette unterschiedlicher Trainingsdaten umgehen und ist somit der Standard-Solver. Seine Leistung leidet jedoch unter schlecht skalierten Datensätzen und Datensätzen mit One-Hot-kodierten kategorialen Merkmalen mit seltenen Kategorien.
Der Solver „newton-cholesky“ ist ein exakter Newton-Solver, der die Hesse-Matrix berechnet und das resultierende lineare System löst. Er ist eine sehr gute Wahl für n_samples >> n_features und kann hohe Präzision (winzige Werte von tol) erreichen, hat aber einige Nachteile: Nur \(\ell_2\)-Regularisierung wird unterstützt. Darüber hinaus ist der Speicherverbrauch aufgrund der expliziten Berechnung der Hesse-Matrix quadratisch von n_features sowie von n_classes abhängig.

Einen Vergleich einiger dieser Solver finden Sie unter [9].

Referenzen

Hinweis

Merkmalsauswahl mit sparse logistischer Regression

Eine logistische Regression mit \(\ell_1\)-Strafe ergibt sparse Modelle und kann daher zur Merkmalsauswahl verwendet werden, wie in L1-basierte Merkmalsauswahl detailliert.

Hinweis

P-Wert-Schätzung

Es ist möglich, die P-Werte und Konfidenzintervalle für Koeffizienten bei Regressionsfällen ohne Strafe zu erhalten. Das Paket statsmodels unterstützt dies nativ. Innerhalb von sklearn könnte man stattdessen auch Bootstrapping verwenden.

LogisticRegressionCV implementiert logistische Regression mit integrierter Kreuzvalidierungsunterstützung, um die optimalen C- und l1_ratio-Parameter gemäß dem scoring-Attribut zu finden. Die Solver „newton-cg“, „sag“, „saga“ und „lbfgs“ sind für hochdimensionale dichte Daten aufgrund von Warm-Start (siehe Glossar) schneller.

1.1.12. Generalisierte lineare Modelle#

Generalisierte lineare Modelle (GLM) erweitern lineare Modelle auf zwei Arten [10]. Erstens sind die vorhergesagten Werte \(\hat{y}\) über eine inverse Link-Funktion \(h\) mit einer linearen Kombination der Eingabevariablen \(X\) verknüpft:

\[\hat{y}(w, X) = h(Xw).\]

Zweitens wird die quadratische Verlustfunktion durch die Einheits-Devianz \(d\) einer Verteilung aus der Exponentialfamilie (oder genauer gesagt eines reproduzierbaren Exponentialdispersionsmodells (EDM) [11]) ersetzt.

Das Minimierungsproblem wird zu

\[\min_{w} \frac{1}{2 n_{\text{samples}}} \sum_i d(y_i, \hat{y}_i) + \frac{\alpha}{2} ||w||_2^2,\]

wobei \(\alpha\) die L2-Regularisierungsstrafe ist. Wenn Sample-Gewichte bereitgestellt werden, handelt es sich bei dem Durchschnitt um einen gewichteten Durchschnitt.

Die folgende Tabelle listet einige spezifische EDMs und ihre Einheits-Devianz auf.

Verteilung	Zielbereich	Einheits-Devianz \(d(y, \hat{y})\)
Normal	\(y \in (-\infty, \infty)\)	\((y-\hat{y})^2\)
Bernoulli	\(y \in \{0, 1\}\)	\(2({y}\log\frac{y}{\hat{y}}+({1}-{y})\log\frac{{1}-{y}}{{1}-\hat{y}})\)
Kategorial	\(y \in \{0, 1, ..., k\}\)	\(2\sum_{i \in \{0, 1, ..., k\}} I(y = i) y_\text{i}\log\frac{I(y = i)}{\hat{I(y = i)}}\)
Poisson	\(y \in [0, \infty)\)	\(2(y\log\frac{y}{\hat{y}}-y+\hat{y})\)
Gamma	\(y \in (0, \infty)\)	\(2(\log\frac{\hat{y}}{y}+\frac{y}{\hat{y}}-1)\)
Inverse Gauß	\(y \in (0, \infty)\)	\(\frac{(y-\hat{y})^2}{y\hat{y}^2}\)

Die Wahrscheinlichkeitsdichtefunktionen (PDF) dieser Verteilungen sind in der folgenden Abbildung dargestellt:

../_images/poisson_gamma_tweedie_distributions.png — PDF einer Zufallsvariable Y, die Poisson-, Tweedie- (Power=1.5) und Gamma-Verteilungen mit unterschiedlichen Mittelwerten (\(\mu\)) folgt. Beachten Sie die Punktmasse bei \(Y=0\) für die Poisson- und die Tweedie-Verteilung (Power=1.5), aber nicht für die Gamma-Verteilung, die einen strikt positiven Zielbereich hat.#

Die Bernoulli-Verteilung ist eine diskrete Wahrscheinlichkeitsverteilung, die einen Bernoulli-Versuch modelliert – ein Ereignis mit nur zwei sich gegenseitig ausschließenden Ergebnissen. Die Kategorial-Verteilung ist eine Verallgemeinerung der Bernoulli-Verteilung für eine kategoriale Zufallsvariable. Während eine Zufallsvariable in einer Bernoulli-Verteilung zwei mögliche Ergebnisse hat, kann eine kategoriale Zufallsvariable einen von K möglichen Kategorien annehmen, wobei die Wahrscheinlichkeit jeder Kategorie separat angegeben wird.

Die Wahl der Verteilung hängt vom jeweiligen Problem ab.

Wenn die Zielwerte \(y\) Zählungen (nicht-negative ganzzahlige Werte) oder relative Häufigkeiten (nicht-negativ) sind, können Sie eine Poisson-Verteilung mit Log-Link verwenden.
Wenn die Zielwerte positiv sind und schief verteilt, können Sie eine Gamma-Verteilung mit Log-Link versuchen.
Wenn die Zielwerte stärker gestreut zu sein scheinen als bei einer Gamma-Verteilung, können Sie eine Inverse-Gauß-Verteilung (oder noch höhere Varianzpotenzen der Tweedie-Familie) ausprobieren.
Wenn die Zielwerte \(y\) Wahrscheinlichkeiten sind, können Sie die Bernoulli-Verteilung verwenden. Die Bernoulli-Verteilung mit einem Logit-Link kann für die binäre Klassifizierung verwendet werden. Die Kategorial-Verteilung mit einem Softmax-Link kann für die Mehrklassen-Klassifizierung verwendet werden.

Referenzen

1.1.12.1. Verwendung#

TweedieRegressor implementiert ein generalisiertes lineares Modell für die Tweedie-Verteilung, das es ermöglicht, jede der oben genannten Verteilungen mit dem entsprechenden power-Parameter zu modellieren. Insbesondere:

power = 0: Normalverteilung. Spezifische Schätzer wie Ridge, ElasticNet sind in diesem Fall im Allgemeinen besser geeignet.
power = 1: Poisson-Verteilung. PoissonRegressor ist zur Bequemlichkeit verfügbar. Er ist jedoch strikt äquivalent zu TweedieRegressor(power=1, link='log').
power = 2: Gamma-Verteilung. GammaRegressor ist zur Bequemlichkeit verfügbar. Er ist jedoch strikt äquivalent zu TweedieRegressor(power=2, link='log').
power = 3: Inverse-Gauß-Verteilung.

Die Link-Funktion wird durch den link-Parameter bestimmt.

Anwendungsbeispiel

>>> from sklearn.linear_model import TweedieRegressor
>>> reg = TweedieRegressor(power=1, alpha=0.5, link='log')
>>> reg.fit([[0, 0], [0, 1], [2, 2]], [0, 1, 2])
TweedieRegressor(alpha=0.5, link='log', power=1)
>>> reg.coef_
array([0.2463, 0.4337])
>>> reg.intercept_
np.float64(-0.7638)

Beispiele

1.1.13. Stochastische Gradientenabstieg - SGD#

Stochastischer Gradientenabstieg ist ein einfacher, aber sehr effizienter Ansatz zur Anpassung linearer Modelle. Er ist besonders nützlich, wenn die Anzahl der Samples (und die Anzahl der Features) sehr groß ist. Die Methode partial_fit ermöglicht Online-/Out-of-Core-Lernen.

Die Klassen SGDClassifier und SGDRegressor bieten Funktionalität zur Anpassung linearer Modelle für Klassifizierung und Regression mit verschiedenen (konvexen) Verlustfunktionen und verschiedenen Strafen. Z.B. mit loss="log" passt SGDClassifier ein logistisches Regressionsmodell an, während es mit loss="hinge" eine lineare Support Vector Machine (SVM) anpasst.

Weitere Details finden Sie im dedizierten Dokumentationsabschnitt Stochastischer Gradientenabstieg.

1.1.13.1. Perzeptron#

Das Perceptron ist ein weiterer einfacher Klassifikationsalgorithmus, der sich für die Verarbeitung großer Datenmengen eignet und auf SGD basiert. Standardmäßig:

Es erfordert keine Lernrate.
Es ist nicht regularisiert (gestraft).
Es aktualisiert sein Modell nur bei Fehlern.

Die letzte Eigenschaft impliziert, dass das Perzeptron etwas schneller zu trainieren ist als SGD mit dem Hinge-Loss und dass die resultierenden Modelle sparsamer sind.

Tatsächlich ist das Perceptron ein Wrapper um die Klasse SGDClassifier, die einen Perzeptron-Loss und eine konstante Lernrate verwendet. Weitere Details finden Sie im mathematischen Abschnitt des SGD-Verfahrens.

1.1.13.2. Passive Aggressive Algorithmen#

Die passiv-aggressiven (PA) Algorithmen sind eine weitere Familie von 2 Algorithmen (PA-I und PA-II) für das Online-Lernen im großen Maßstab, die von SGD abgeleitet sind. Sie ähneln dem Perzeptron, da sie keine Lernrate benötigen. Im Gegensatz zum Perzeptron enthalten sie jedoch einen Regularisierungsparameter eta0 (\(C\) im Referenzpapier).

Für die Klassifizierung kann SGDClassifier(loss="hinge", penalty=None, learning_rate="pa1", eta0=1.0) für PA-I oder mit learning_rate="pa2" für PA-II verwendet werden. Für die Regression kann SGDRegressor(loss="epsilon_insensitive", penalty=None, learning_rate="pa1", eta0=1.0) für PA-I oder mit learning_rate="pa2" für PA-II verwendet werden.

1.1.14. Robuste Regression: Ausreißer und Modellierungsfehler#

Robuste Regression zielt darauf ab, ein Regressionsmodell im Beisein korrupter Daten anzupassen: entweder Ausreißer oder Fehler im Modell.

../_images/sphx_glr_plot_theilsen_001.png

1.1.14.1. Unterschiedliche Szenarien und nützliche Konzepte#

Es gibt verschiedene Dinge, die man beachten sollte, wenn man mit durch Ausreißer korrumpierten Daten umgeht:

Ausreißer in X oder in y?

Ausreißer in y-Richtung

Ausreißer in X-Richtung
Anteil der Ausreißer gegenüber der Amplitude des Fehlers

Die Anzahl der Ausreißer ist wichtig, aber auch, wie stark sie Ausreißer sind.

Kleine Ausreißer

Große Ausreißer

Ein wichtiges Konzept der robusten Anpassung ist der sogenannte Breakdown-Point (Bruchpunkt): Der Anteil der Daten, der fehlerhaft sein kann, bis die Anpassung beginnt, die inliegenden Daten zu verfehlen.

Beachten Sie, dass robuste Anpassung in hochdimensionalen Umgebungen (großes n_features) im Allgemeinen sehr schwierig ist. Die hier vorgestellten robusten Modelle werden in diesen Umgebungen wahrscheinlich nicht funktionieren.

Abwägungen: Welcher Schätzer?

Scikit-learn bietet 3 robuste Regressionsschätzer: RANSAC, Theil-Sen und HuberRegressor.

HuberRegressor sollte schneller sein als RANSAC und Theil-Sen, es sei denn, die Anzahl der Samples ist sehr groß, d.h. n_samples >> n_features. Dies liegt daran, dass RANSAC und Theil-Sen auf kleineren Teilmengen der Daten passen. Allerdings sind sowohl Theil-Sen als auch RANSAC bei den Standardparametern wahrscheinlich nicht so robust wie HuberRegressor.
RANSAC ist schneller als Theil-Sen und skaliert viel besser mit der Anzahl der Samples.
RANSAC kommt besser mit großen Ausreißern in y-Richtung (häufigste Situation) zurecht.
Theil-Sen kommt besser mit mittelgroßen Ausreißern in X-Richtung zurecht, aber diese Eigenschaft verschwindet in hochdimensionalen Umgebungen.

Im Zweifelsfall verwenden Sie RANSAC.

1.1.14.2. RANSAC: RANdom SAmple Consensus#

RANSAC (RANdom SAmple Consensus) passt ein Modell aus zufälligen Teilmengen von Inlinern aus dem vollständigen Datensatz an.

RANSAC ist ein nicht-deterministischer Algorithmus, der nur mit einer gewissen Wahrscheinlichkeit ein vernünftiges Ergebnis liefert, was von der Anzahl der Iterationen abhängt (siehe Parameter max_trials). Er wird typischerweise für lineare und nicht-lineare Regressionsprobleme verwendet und ist besonders beliebt im Bereich der photogrammetrischen Computer Vision.

Der Algorithmus teilt die vollständigen Eingabe-Sample-Daten in eine Menge von Inlinern auf, die Rauschen enthalten können, und Ausreißer, die z.B. durch fehlerhafte Messungen oder ungültige Hypothesen über die Daten verursacht werden. Das resultierende Modell wird dann nur aus den bestimmten Inlinern geschätzt.

Beispiele

1.1.14.3. Theil-Sen-Schätzer: verallgemeinerter medianbasierter Schätzer#

Der TheilSenRegressor-Schätzer verwendet eine Verallgemeinerung des Medians in mehreren Dimensionen. Er ist daher robust gegenüber multivariaten Ausreißern. Beachten Sie jedoch, dass die Robustheit des Schätzers mit der Dimensionalität des Problems schnell abnimmt. Er verliert seine Robustheitseigenschaften und ist in hohen Dimensionen nicht besser als eine gewöhnliche kleinste Quadrate-Regression.

Beispiele

1.1.14.4. Huber-Regression#

Der HuberRegressor unterscheidet sich vom Ridge, da er eine lineare Verlustfunktion auf Stichproben anwendet, die durch den epsilon-Parameter als Ausreißer definiert sind. Eine Stichprobe wird als Inlier klassifiziert, wenn der absolute Fehler dieser Stichprobe kleiner als der Schwellenwert epsilon ist. Er unterscheidet sich vom TheilSenRegressor und RANSACRegressor, da er die Auswirkung von Ausreißern nicht ignoriert, sondern ihnen ein geringeres Gewicht gibt.

../_images/sphx_glr_plot_huber_vs_ridge_001.png

Beispiele

HuberRegressor vs Ridge auf Datensatz mit starken Ausreißern

Der HuberRegressor unterscheidet sich von der Verwendung von SGDRegressor mit der auf huber gesetzten Verlustfunktion in den folgenden Punkten.

Der HuberRegressor ist skaleninvariant. Sobald epsilon gesetzt ist, führt das Herunter- oder Hochskalieren von X und y um unterschiedliche Werte zu derselben Robustheit gegenüber Ausreißern wie zuvor. Im Vergleich zum SGDRegressor, bei dem epsilon neu gesetzt werden muss, wenn X und y skaliert werden.
Der HuberRegressor sollte effizienter für Daten mit einer geringen Anzahl von Stichproben sein, während der SGDRegressor eine Anzahl von Durchläufen über die Trainingsdaten benötigt, um dieselbe Robustheit zu erzielen.

Beachten Sie, dass dieser Schätzer sich von der R-Implementierung von Robuster Regression unterscheidet, da die R-Implementierung eine gewichtete kleinste Quadrate-Implementierung durchführt, bei der jeder Stichprobe Gewichte zugewiesen werden, basierend darauf, wie stark die Residuen einen bestimmten Schwellenwert überschreiten.

1.1.15. Quantilregression#

Die Quantilregression schätzt den Median oder andere Quantile von \(y\) bedingt auf \(X\), während die gewöhnliche kleinste Quadrate-Regression (OLS) den bedingten Mittelwert schätzt.

Quantilregression kann nützlich sein, wenn man an der Vorhersage eines Intervalls anstelle einer Punktvorhersage interessiert ist. Manchmal werden Vorhersageintervalle basierend auf der Annahme berechnet, dass der Vorhersagefehler normalverteilt ist mit Mittelwert Null und konstanter Varianz. Die Quantilregression liefert sinnvolle Vorhersageintervalle auch für Fehler mit nicht-konstanter (aber vorhersagbarer) Varianz oder nicht-normaler Verteilung.

../_images/sphx_glr_plot_quantile_regression_002.png

Basierend auf der Minimierung des Pinball-Verlusts können bedingte Quantile auch durch andere Modelle als lineare Modelle geschätzt werden. Zum Beispiel kann der GradientBoostingRegressor bedingte Quantile vorhersagen, wenn sein Parameter loss auf "quantile" gesetzt wird und der Parameter alpha auf das vorherzusagende Quantil gesetzt wird. Siehe das Beispiel in Vorhersageintervalle für Gradient Boosting Regression.

Die meisten Implementierungen der Quantilregression basieren auf einem linearen Programmierproblem. Die aktuelle Implementierung basiert auf scipy.optimize.linprog.

Beispiele

Quantilregression

1.1.16. Polynomielle Regression: Erweiterung von linearen Modellen mit Basis-Funktionen#

Ein gängiges Muster im maschinellen Lernen ist die Verwendung von linearen Modellen, die auf nichtlinearen Funktionen der Daten trainiert werden. Dieser Ansatz behält die im Allgemeinen schnelle Leistung von linearen Methoden bei, während er ihnen ermöglicht, eine viel breitere Palette von Daten anzupassen.

Hier ist ein Beispiel für die Anwendung dieser Idee auf eindimensionale Daten unter Verwendung von polynomiellen Merkmalen unterschiedlichen Grades:

../_images/sphx_glr_plot_polynomial_interpolation_001.png

Diese Abbildung wird unter Verwendung des PolynomialFeatures-Transformers erstellt, der eine Eingangsdatenmatrix in eine neue Datenmatrix eines gegebenen Grades transformiert. Er kann wie folgt verwendet werden:

>>> from sklearn.preprocessing import PolynomialFeatures
>>> import numpy as np
>>> X = np.arange(6).reshape(3, 2)
>>> X
array([[0, 1],
       [2, 3],
       [4, 5]])
>>> poly = PolynomialFeatures(degree=2)
>>> poly.fit_transform(X)
array([[ 1.,  0.,  1.,  0.,  0.,  1.],
       [ 1.,  2.,  3.,  4.,  6.,  9.],
       [ 1.,  4.,  5., 16., 20., 25.]])

Die Merkmale von X wurden von \([x_1, x_2]\) zu \([1, x_1, x_2, x_1^2, x_1 x_2, x_2^2]\) transformiert und können nun in jedem linearen Modell verwendet werden.

Diese Art der Vorverarbeitung kann mit den Werkzeugen Pipeline gestrafft werden. Ein einzelnes Objekt, das eine einfache polynomielle Regression darstellt, kann erstellt und wie folgt verwendet werden:

>>> from sklearn.preprocessing import PolynomialFeatures
>>> from sklearn.linear_model import LinearRegression
>>> from sklearn.pipeline import Pipeline
>>> import numpy as np
>>> model = Pipeline([('poly', PolynomialFeatures(degree=3)),
...                   ('linear', LinearRegression(fit_intercept=False))])
>>> # fit to an order-3 polynomial data
>>> x = np.arange(5)
>>> y = 3 - 2 * x + x ** 2 - x ** 3
>>> model = model.fit(x[:, np.newaxis], y)
>>> model.named_steps['linear'].coef_
array([ 3., -2.,  1., -1.])

Das auf polynomiellen Merkmalen trainierte lineare Modell kann die Eingangs-Polynomkoeffizienten exakt wiederherstellen.

In einigen Fällen ist es nicht notwendig, höhere Potenzen einzelner Merkmale einzuschließen, sondern nur die sogenannten *Interaktionsmerkmale*, die höchstens \(d\) verschiedene Merkmale multiplizieren. Diese können von PolynomialFeatures mit der Einstellung interaction_only=True erhalten werden.

Zum Beispiel ist bei der Behandlung von booleschen Merkmalen \(x_i^n = x_i\) für alle \(n\) und daher nutzlos; aber \(x_i x_j\) repräsentiert die Konjunktion von zwei Boole'schen Werten. Auf diese Weise können wir das XOR-Problem mit einem linearen Klassifikator lösen:

>>> from sklearn.linear_model import Perceptron
>>> from sklearn.preprocessing import PolynomialFeatures
>>> import numpy as np
>>> X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
>>> y = X[:, 0] ^ X[:, 1]
>>> y
array([0, 1, 1, 0])
>>> X = PolynomialFeatures(interaction_only=True).fit_transform(X).astype(int)
>>> X
array([[1, 0, 0, 0],
       [1, 0, 1, 0],
       [1, 1, 0, 0],
       [1, 1, 1, 1]])
>>> clf = Perceptron(fit_intercept=False, max_iter=10, tol=None,
...                  shuffle=False).fit(X, y)

Und die "Vorhersagen" des Klassifikators sind perfekt:

>>> clf.predict(X)
array([0, 1, 1, 0])
>>> clf.score(X, y)
1.0

1.1. Lineare Modelle#

1.1.1. Gewöhnliche kleinste Quadrate#

1.1.1.1. Nicht-negative kleinste Quadrate#

1.1.1.2. Komplexität der gewöhnlichen kleinsten Quadrate#

1.1.2. Ridge-Regression und Klassifikation#

1.1.2.1. Regression#

1.1.2.2. Klassifikation#

1.1.2.3. Ridge-Komplexität#

1.1.2.4. Einstellen des Regularisierungsparameters: Leave-One-Out-Kreuzvalidierung#

1.1.3. Lasso#

1.1.3.1. Coordinate Descent mit Gap Safe Screening Rules#

1.1.3.2. Einstellen des Regularisierungsparameters#

1.1.3.2.1. Verwendung von Kreuzvalidierung#

1.1.3.2.2. Informationskriterien-basierte Modellauswahl#

1.1.3.2.3. AIC- und BIC-Kriterien#

1.1.3.2.4. Vergleich mit dem Regularisierungsparameter von SVM#

1.1.4. Multi-Task Lasso#

1.1.5. Elastic-Net#

1.1.6. Multi-Task Elastic-Net#

1.1.7. Least Angle Regression#

1.1.8. LARS Lasso#

1.1.9. Orthogonal Matching Pursuit (OMP)#

1.1.10. Bayesian Regression#

1.1.10.1. Bayesian Ridge Regression#

1.1.10.2. Automatic Relevance Determination - ARD#

1.1.11. Logistische Regression#

1.1.11.1. Binärer Fall#

1.1.11.2. Multinomialer Fall#

1.1.11.3. Solver#

1.1.11.3.1. Unterschiede zwischen den Solvern#

1.1.12. Generalisierte lineare Modelle#

1.1.12.1. Verwendung#

1.1.13. Stochastische Gradientenabstieg - SGD#

1.1.13.1. Perzeptron#

1.1.13.2. Passive Aggressive Algorithmen#

1.1.14. Robuste Regression: Ausreißer und Modellierungsfehler#

1.1.14.1. Unterschiedliche Szenarien und nützliche Konzepte#

1.1.14.2. RANSAC: RANdom SAmple Consensus#

1.1.14.3. Theil-Sen-Schätzer: verallgemeinerter medianbasierter Schätzer#

1.1.14.4. Huber-Regression#

1.1.15. Quantilregression#

1.1.16. Polynomielle Regression: Erweiterung von linearen Modellen mit Basis-Funktionen#

Diese Seite