lasso_path#

sklearn.linear_model.lasso_path(X, y, *, eps=0.001, n_alphas=100, alphas=None, precompute='auto', Xy=None, copy_X=True, coef_init=None, verbose=False, return_n_iter=False, positive=False, **params)[Quelle]#

Berechnet den Lasso-Pfad mit Koordinatenabstieg.

Die Lasso-Optimierungsfunktion variiert für Mono- und Multi-Ausgaben.

Für Mono-Ausgaben-Aufgaben ist es

(1 / (2 * n_samples)) * ||y - Xw||^2_2 + alpha * ||w||_1

Für Multi-Ausgaben-Aufgaben ist es

(1 / (2 * n_samples)) * ||Y - XW||^2_Fro + alpha * ||W||_21

Wo

||W||_21 = \sum_i \sqrt{\sum_j w_{ij}^2}

d.h. die Summe der Norm jeder Zeile.

Lesen Sie mehr im Benutzerhandbuch.

Parameter:

X{array-like, sparse matrix} der Form (n_samples, n_features): Trainingsdaten. Direkt als Fortran-kontinuierliche Daten übergeben, um unnötige Speicherduplizierung zu vermeiden. Wenn y eine Mono-Ausgabe ist, kann X spärlich sein.
y{array-ähnlich, spärsitätsmatrix} der Form (n_samples,) oder (n_samples, n_targets): Zielwerte.
epsfloat, Standardwert=1e-3: Länge des Pfades. eps=1e-3 bedeutet, dass alpha_min / alpha_max = 1e-3.
n_alphasint, Standardwert=100: Anzahl der Alphas entlang des Regularisierungspfades.
alphasarray-ähnlich, Standardwert=None: Liste von Alphas, für die Modelle berechnet werden sollen. Wenn None, werden Alphas automatisch gesetzt.
precompute‘auto‘, bool oder array-ähnlich der Form (n_features, n_features), Standardwert=’auto’: Ob eine vorberechnete Gram-Matrix verwendet werden soll, um Berechnungen zu beschleunigen. Wenn auf 'auto' gesetzt, entscheiden wir. Die Gram-Matrix kann auch als Argument übergeben werden.
Xyarray-ähnlich der Form (n_features,) oder (n_features, n_targets), Standardwert=None: Xy = np.dot(X.T, y), was vorab berechnet werden kann. Dies ist nur nützlich, wenn die Gram-Matrix vorab berechnet wurde.
copy_Xbool, Standardwert=True: Wenn True, wird X kopiert; andernfalls kann es überschrieben werden.
coef_initarray-ähnlich der Form (n_features,), Standardwert=None: Die Anfangswerte der Koeffizienten.
verbosebool oder int, default=False: Ausmaß der Ausführlichkeit.
return_n_iterbool, Standard=False: Ob die Anzahl der Iterationen zurückgegeben werden soll oder nicht.
positivebool, Standardwert=False: Wenn True gesetzt, werden die Koeffizienten auf positiv erzwungen. (Nur erlaubt, wenn y.ndim == 1).
**paramskwargs: Schlüsselwortargumente, die an den Koordinatenabstiegslöser übergeben werden.

Gibt zurück:

alphasndarray der Form (n_alphas,): Die Alphas entlang des Pfades, auf dem Modelle berechnet werden.
coefsndarray der Form (n_features, n_alphas) oder (n_targets, n_features, n_alphas): Koeffizienten entlang des Pfades.
dual_gapsndarray der Form (n_alphas,): Die dualen Abstände am Ende der Optimierung für jedes Alpha.
n_iterslist von int: Die Anzahl der Iterationen, die der Koordinatenabstieg-Optimierer benötigt, um die angegebene Toleranz für jedes Alpha zu erreichen.

Siehe auch

lars_path: Berechnet den Least Angle Regression- oder Lasso-Pfad unter Verwendung des LARS-Algorithmus.
Lasso: Der Lasso ist ein lineares Modell, das spärliche Koeffizienten schätzt.
LassoLars: Lasso-Modell, angepasst mit Least Angle Regression, auch bekannt als Lars.
LassoCV: Lasso-Linearmodell mit iterativem Anpassen entlang eines Regularisierungspfades.
LassoLarsCV: Kreuzvalidiertes Lasso mit dem LARS-Algorithmus.
sklearn.decomposition.sparse_encode: Schätzer, der verwendet werden kann, um Signale in eine spärliche Linearkombination von Atomen aus einem festen Satz zu transformieren.

Anmerkungen

Ein Beispiel finden Sie unter Beispiele/linear_model/plot_lasso_lasso_lars_elasticnet_path.py.

Um unnötige Speicherduplizierung zu vermeiden, sollte das X-Argument der fit-Methode direkt als Fortran-kontinuierlicher numpy-Array übergeben werden.

Beachten Sie, dass in bestimmten Fällen der Lars-Solver erheblich schneller sein kann, um diese Funktionalität zu implementieren. Insbesondere kann lineare Interpolation verwendet werden, um Modellkoeffizienten zwischen den von lars_path ausgegebenen Werten abzurufen.

Der zugrunde liegende Koordinatenabstiegslöser verwendet "gap-safe screening rules", um die Anpassungszeit zu beschleunigen, siehe Benutzerhandbuch zum Koordinatenabstieg.

Beispiele

Vergleich von lasso_path und lars_path mit Interpolation

>>> import numpy as np
>>> from sklearn.linear_model import lasso_path
>>> X = np.array([[1, 2, 3.1], [2.3, 5.4, 4.3]]).T
>>> y = np.array([1, 2, 3.1])
>>> # Use lasso_path to compute a coefficient path
>>> _, coef_path, _ = lasso_path(X, y, alphas=[5., 1., .5])
>>> print(coef_path)
[[0.         0.         0.46874778]
 [0.2159048  0.4425765  0.23689075]]

>>> # Now use lars_path and 1D linear interpolation to compute the
>>> # same path
>>> from sklearn.linear_model import lars_path
>>> alphas, active, coef_path_lars = lars_path(X, y, method='lasso')
>>> from scipy import interpolate
>>> coef_path_continuous = interpolate.interp1d(alphas[::-1],
...                                             coef_path_lars[:, ::-1])
>>> print(coef_path_continuous([5., 1., .5]))
[[0.         0.         0.46915237]
 [0.2159048  0.4425765  0.23668876]]

Galeriebeispiele#

Lasso, Lasso-LARS und Elastic Net Pfade

lasso_path#

Galeriebeispiele#

Diese Seite