Class LarsScikitsLearnNode

Least Angle Regression model a.k.a. LAR

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

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

**Parameters**

n_nonzero_coefs : int, optional
    Target number of non-zero coefficients. Use ``np.inf`` for no limit.

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.

verbose : boolean or integer, optional
    Sets the verbosity amount

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

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.

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

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 ``n_nonzero_coefs`` or ``n_features``,         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)         | list 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.Lars(n_nonzero_coefs=1)
>>> clf.fit([[-1, 1], [0, 0], [1, 1]], [-1.1111, 0, -1.1111])
... # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
Lars(copy_X=True, eps=..., fit_intercept=True, fit_path=True,
   n_nonzero_coefs=1, normalize=True, positive=False, precompute='auto',
   verbose=False)
>>> print(clf.coef_) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
[ 0. -1.11...]

See also

lars_path, LarsCV
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.Lars 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.Lars 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