Class LassoScikitsLearnNode

Linear Model trained with L1 prior as regularizer (aka the Lasso)

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

The optimization objective for Lasso is::


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

Technically the Lasso model is optimizing the same objective function as
the Elastic Net with ``l1_ratio=1.0`` (no L2 penalty).

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

**Parameters**

alpha : float, optional
    Constant that multiplies the L1 term. Defaults to 1.0.
    ``alpha = 0`` is equivalent to an ordinary least square, solved
    by the :class:`LinearRegression` object. For numerical
    reasons, using ``alpha = 0`` is with the Lasso 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).

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. For sparse input
    this option is always ``True`` to preserve sparsity.
    WARNING : The ``'auto'`` option is deprecated and will
    be removed in 0.18.

max_iter : int, optional
    The maximum number of iterations

tol : float, optional
    The tolerance for the optimization: if the updates are
    smaller than ``tol``, the optimization code checks the
    dual gap for optimality and continues until it is smaller
    than ``tol``.

warm_start : bool, optional
    When set to True, reuse the solution of the previous call to fit as
    initialization, otherwise, just erase the previous solution.

positive : bool, optional
    When set to ``True``, forces the coefficients to be positive.

selection : str, default 'cyclic'
    If set to 'random', a random coefficient is updated every iteration
    rather than looping over features sequentially by default. This
    (setting to 'random') often leads to significantly faster convergence
    especially when tol is higher than 1e-4.

random_state : int, RandomState instance, or None (default)
    The seed of the pseudo random number generator that selects
    a random feature to update. Useful only when selection is set to
    'random'.

**Attributes**

``coef_`` : array, shape (n_features,) | (n_targets, n_features)
    parameter vector (w in the cost function formula)

``sparse_coef_`` : scipy.sparse matrix, shape (n_features, 1) |             (n_targets, n_features)
    ``sparse_coef_`` is a readonly property derived from ``coef_``

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

``n_iter_`` : int | array-like, shape (n_targets,)
    number of iterations run by the coordinate descent solver to reach
    the specified tolerance.

**Examples**

>>> from sklearn import linear_model
>>> clf = linear_model.Lasso(alpha=0.1)
>>> clf.fit([[0,0], [1, 1], [2, 2]], [0, 1, 2])
Lasso(alpha=0.1, copy_X=True, fit_intercept=True, max_iter=1000,
   normalize=False, positive=False, precompute=False, random_state=None,
   selection='cyclic', tol=0.0001, warm_start=False)
>>> print(clf.coef_)
[ 0.85  0.  ]
>>> print(clf.intercept_)
0.15

See also

lars_path
lasso_path
LassoLars
LassoCV
LassoLarsCV
sklearn.decomposition.sparse_encode

**Notes**

The algorithm used to fit the model is coordinate descent.

To avoid unnecessary memory duplication the X argument of the fit method
should be directly passed as a Fortran-contiguous numpy array.

Overrides: object.__init__

Predict using the linear model

This node has been automatically generated by wrapping the sklearn.linear_model.coordinate_descent.Lasso 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 model with coordinate descent.

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

Parameters

X : ndarray or scipy.sparse matrix, (n_samples, n_features)

Data

y : ndarray, shape (n_samples,) or (n_samples, n_targets)

Target

Notes

Coordinate descent is an algorithm that considers each column of data at a time hence it will automatically convert the X input as a Fortran-contiguous numpy array if necessary.

To avoid memory re-allocation it is advised to allocate the initial data in memory directly using that format.

Overrides: Node.stop_training