Class LassoLarsScikitsLearnNode

Lasso model fit with Least Angle Regression a.k.a. Lars

This node has been automatically generated by wrapping the ``sklearn.linear_model.least_angle.LassoLars`` class
from the ``sklearn`` library.  The wrapped instance can be accessed
through the ``scikits_alg`` attribute.

It is a Linear Model trained with an L1 prior as regularizer.

The optimization objective for Lasso is::


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

Read more in the :ref:`User Guide <least_angle_regression>`.

**Parameters**

alpha : float
    Constant that multiplies the penalty term. Defaults to 1.0.
    ``alpha = 0`` is equivalent to an ordinary least square, solved
    by :class:`LinearRegression`. For numerical reasons, using
    ``alpha = 0`` with the LassoLars object is not advised and you
    should prefer the LinearRegression object.

fit_intercept : boolean
    whether to calculate the intercept for this model. If set
    to false, no intercept will be used in calculations
    (e.g. data is expected to be already centered).

positive : boolean (default=False)
    Restrict coefficients to be >= 0. Be aware that you might want to
    remove fit_intercept which is set True by default.
    Under the positive restriction the model coefficients will not converge
    to the ordinary-least-squares solution for small values of alpha.
    Only coeffiencts up to the smallest alpha value (``alphas_[alphas_ >
    0.].min()`` when fit_path=True) reached by the stepwise Lars-Lasso
    algorithm are typically in congruence with the solution of the
    coordinate descent Lasso estimator.

verbose : boolean or integer, optional
    Sets the verbosity amount

normalize : boolean, optional, default False
    If True, the regressors X will be normalized before regression.

copy_X : boolean, optional, default True
    If True, X will be copied; else, it may be overwritten.

precompute : True | False | 'auto' | array-like
    Whether to use a precomputed Gram matrix to speed up
    calculations. If set to ``'auto'`` let us decide. The Gram
    matrix can also be passed as argument.

max_iter : integer, optional
    Maximum number of iterations to perform.

eps : float, optional
    The machine-precision regularization in the computation of the
    Cholesky diagonal factors. Increase this for very ill-conditioned
    systems. Unlike the ``tol`` parameter in some iterative
    optimization-based algorithms, this parameter does not control
    the tolerance of the optimization.

fit_path : boolean
    If ``True`` the full path is stored in the ``coef_path_`` attribute.
    If you compute the solution for a large problem or many targets,
    setting ``fit_path`` to ``False`` will lead to a speedup, especially
    with a small alpha.

**Attributes**

``alphas_`` : array, shape (n_alphas + 1,) | list of n_targets such arrays
    Maximum of covariances (in absolute value) at each iteration.         ``n_alphas`` is either ``max_iter``, ``n_features``, or the number of         nodes in the path with correlation greater than ``alpha``, whichever         is smaller.

``active_`` : list, length = n_alphas | list of n_targets such lists
    Indices of active variables at the end of the path.

``coef_path_`` : array, shape (n_features, n_alphas + 1) or list
    If a list is passed it's expected to be one of n_targets such arrays.
    The varying values of the coefficients along the path. It is not
    present if the ``fit_path`` parameter is ``False``.

``coef_`` : array, shape (n_features,) or (n_targets, n_features)
    Parameter vector (w in the formulation formula).

``intercept_`` : float | array, shape (n_targets,)
    Independent term in decision function.

``n_iter_`` : array-like or int.
    The number of iterations taken by lars_path to find the
    grid of alphas for each target.

**Examples**

>>> from sklearn import linear_model
>>> clf = linear_model.LassoLars(alpha=0.01)
>>> clf.fit([[-1, 1], [0, 0], [1, 1]], [-1, 0, -1])
... # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
LassoLars(alpha=0.01, copy_X=True, eps=..., fit_intercept=True,
     fit_path=True, max_iter=500, normalize=True, positive=False,
     precompute='auto', verbose=False)
>>> print(clf.coef_) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
[ 0.         -0.963257...]

See also

lars_path
lasso_path
Lasso
LassoCV
LassoLarsCV
sklearn.decomposition.sparse_encode

Overrides: object.__init__

Predict using the linear model

This node has been automatically generated by wrapping the sklearn.linear_model.least_angle.LassoLars class from the sklearn library. The wrapped instance can be accessed through the scikits_alg attribute.

Parameters

X : {array-like, sparse matrix}, shape = (n_samples, n_features)

Samples.

Returns

C : array, shape = (n_samples,)

Returns predicted values.

Overrides: Node.execute

Overrides: Node.is_invertible

(inherited documentation)

Overrides: Node.is_trainable

Fit the model using X, y as training data.

This node has been automatically generated by wrapping the sklearn.linear_model.least_angle.LassoLars class from the sklearn library. The wrapped instance can be accessed through the scikits_alg attribute.

parameters

X : array-like, shape (n_samples, n_features)

Training data.

y : array-like, shape (n_samples,) or (n_samples, n_targets)

Target values.

Xy : array-like, shape (n_samples,) or (n_samples, n_targets), optional

Xy = np.dot(X.T, y) that can be precomputed. It is useful only when the Gram matrix is precomputed.

returns

self : object

returns an instance of self.

Overrides: Node.stop_training