Class ElasticNetCVScikitsLearnNode

Elastic Net model with iterative fitting along a regularization path

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

The best model is selected by cross-validation.

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

**Parameters**

l1_ratio : float or array of floats, optional
    float between 0 and 1 passed to ElasticNet (scaling between
    l1 and l2 penalties). For ``l1_ratio = 0``
    the penalty is an L2 penalty. For ``l1_ratio = 1`` it is an L1 penalty.
    For ``0 < l1_ratio < 1``, the penalty is a combination of L1 and L2
    This parameter can be a list, in which case the different
    values are tested by cross-validation and the one giving the best
    prediction score is used. Note that a good choice of list of
    values for l1_ratio is often to put more values close to 1
    (i.e. Lasso) and less close to 0 (i.e. Ridge), as in ``[.1, .5, .7,
    .9, .95, .99, 1]``

eps : float, optional
    Length of the path. ``eps=1e-3`` means that
    ``alpha_min / alpha_max = 1e-3``.

n_alphas : int, optional
    Number of alphas along the regularization path, used for each l1_ratio.

alphas : numpy array, optional
    List of alphas where to compute the models.
    If None alphas are set automatically

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 : 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``.

cv : int, cross-validation generator or an iterable, optional
    Determines the cross-validation splitting strategy.
    Possible inputs for cv are:


    - None, to use the default 3-fold cross-validation,
    - integer, to specify the number of folds.
    - An object to be used as a cross-validation generator.
    - An iterable yielding train/test splits.

    For integer/None inputs, :class:`KFold` is used.

    Refer :ref:`User Guide <cross_validation>` for the various
    cross-validation strategies that can be used here.

verbose : bool or integer
    Amount of verbosity.

n_jobs : integer, optional
    Number of CPUs to use during the cross validation. If ``-1``, use
    all the CPUs.

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'.

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.

**Attributes**

``alpha_`` : float
    The amount of penalization chosen by cross validation

``l1_ratio_`` : float
    The compromise between l1 and l2 penalization chosen by
    cross validation

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

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

``mse_path_`` : array, shape (n_l1_ratio, n_alpha, n_folds)
    Mean square error for the test set on each fold, varying l1_ratio and
    alpha.

``alphas_`` : numpy array, shape (n_alphas,) or (n_l1_ratio, n_alphas)
    The grid of alphas used for fitting, for each l1_ratio.

``n_iter_`` : int
    number of iterations run by the coordinate descent solver to reach
    the specified tolerance for the optimal alpha.

**Notes**

See examples/linear_model/lasso_path_with_crossvalidation.py
for an example.

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

The parameter l1_ratio corresponds to alpha in the glmnet R package
while alpha corresponds to the lambda parameter in glmnet.
More specifically, the optimization objective is::


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

If you are interested in controlling the L1 and L2 penalty
separately, keep in mind that this is equivalent to::


    a * L1 + b * L2

for::


    alpha = a + b and l1_ratio = a / (a + b).

See also

enet_path
ElasticNet

Overrides: object.__init__

Predict using the linear model

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

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

Fit is on grid of alphas and best alpha estimated by cross-validation.

Parameters

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

Training data. Pass directly as float64, Fortran-contiguous data to avoid unnecessary memory duplication. If y is mono-output, X can be sparse.

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

Target values

Overrides: Node.stop_training