class_docstr: Randomized Lasso.
  
  Randomized Lasso works by subsampling the training data and
  computing a Lasso estimate where the penalty of a random subset of
  coefficients has been scaled. By performing this double
  randomization several times, the method assigns high scores to
  features that are repeatedly selected across randomizations. This
  is known as stability selection. In short, features selected more
  often are considered good features.
  
  Read more in the :ref:`User Guide <randomized_l1>`.
  
  Parameters
  ----------
  alpha : float, 'aic', or 'bic', optional
      The regularization parameter alpha parameter in the Lasso.
      Warning: this is not the alpha parameter in the stability selection
      article which is scaling.
  
  scaling : float, optional
      The s parameter used to randomly scale the penalty of different
      features (See :ref:`User Guide <randomized_l1>` for details ).
      Should be between 0 and 1.
  
  sample_fraction : float, optional
      The fraction of samples to be used in each randomized design.
      Should be between 0 and 1. If 1, all samples are used.
  
  n_resampling : int, optional
      Number of randomized models.
  
  selection_threshold: float, optional
      The score above which features should be selected.
  
  fit_intercept : boolean, optional
      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).
  
  verbose : boolean or integer, optional
      Sets the verbosity amount
  
  normalize : boolean, optional, default False
      If True, the regressors X will be normalized before regression.
      This parameter is ignored when `fit_intercept` is set to False.
      When the regressors are normalized, note that this makes the
      hyperparameters learned more robust and almost independent of
      the number of samples. The same property is not valid for
      standardized data. However, if you wish to standardize, please
      use `preprocessing.StandardScaler` before calling `fit` on an
      estimator with `normalize=False`.
  
  precompute : True | False | 'auto'
      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 in the Lars algorithm.
  
  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.
  
  n_jobs : integer, optional
      Number of CPUs to use during the resampling. If '-1', use
      all the CPUs
  
  random_state : int, RandomState instance or None, optional (default=None)
      If int, random_state is the seed used by the random number generator;
      If RandomState instance, random_state is the random number generator;
      If None, the random number generator is the RandomState instance used
      by `np.random`.
  
  pre_dispatch : int, or string, optional
      Controls the number of jobs that get dispatched during parallel
      execution. Reducing this number can be useful to avoid an
      explosion of memory consumption when more jobs get dispatched
      than CPUs can process. This parameter can be:
  
          - None, in which case all the jobs are immediately
            created and spawned. Use this for lightweight and
            fast-running jobs, to avoid delays due to on-demand
            spawning of the jobs
  
          - An int, giving the exact number of total jobs that are
            spawned
  
          - A string, giving an expression as a function of n_jobs,
            as in '2*n_jobs'
  
  memory : Instance of joblib.Memory or string
      Used for internal caching. By default, no caching is done.
      If a string is given, it is the path to the caching directory.
  
  Attributes
  ----------
  scores_ : array, shape = [n_features]
      Feature scores between 0 and 1.
  
  all_scores_ : array, shape = [n_features, n_reg_parameter]
      Feature scores between 0 and 1 for all values of the regularization         parameter. The reference article suggests ``scores_`` is the max of         ``all_scores_``.
  
  Examples
  --------
  >>> from sklearn.linear_model import RandomizedLasso
  >>> randomized_lasso = RandomizedLasso()
  
  Notes
  -----
  See examples/linear_model/plot_sparse_recovery.py for an example.
  
  References
  ----------
  Stability selection
  Nicolai Meinshausen, Peter Buhlmann
  Journal of the Royal Statistical Society: Series B
  Volume 72, Issue 4, pages 417-473, September 2010
  DOI: 10.1111/j.1467-9868.2010.00740.x
  
  See also
  --------
  RandomizedLogisticRegression, Lasso, ElasticNet
code: def _make_estimator_and_params(self, X, y):
      assert self.precompute in (True, False, None, "auto")
      alpha = self.alpha
      if isinstance(alpha, six.string_types) and alpha in (
          "aic",
          "bic",
      ):
          model = LassoLarsIC(
              precompute=self.precompute,
              criterion=self.alpha,
              max_iter=self.max_iter,
              eps=self.eps,
          )
          model.fit(X, y)
          self.alpha_ = alpha = model.alpha_
      return _randomized_lasso, dict(
          alpha=alpha,
          max_iter=self.max_iter,
          eps=self.eps,
          precompute=self.precompute,
      )
  
imports: import itertools
  from abc import ABCMeta, abstractmethod
  import warnings
  import numpy
  from scipy.sparse import issparse
  from scipy import sparse
  from scipy.interpolate import interp1d
  from .base import _preprocess_data
  from ..base import BaseEstimator, TransformerMixin
  from ..externals import six
  from ..externals.joblib import Memory, Parallel, delayed
  from ..utils import as_float_array, check_random_state, check_X_y, check_array, safe_mask
  from ..utils.validation import check_is_fitted
  from .least_angle import lars_path, LassoLarsIC
  from .logistic import LogisticRegression
  from ..exceptions import ConvergenceWarning
label_desc: Use image node_id 2 for calling the RandomizedLasso obj's underlying member method code with example usage: obj._make_estimator_and_params(X, y) and returns: _randomized_lasso,  dict