class_docstr: Sparse inverse covariance w/ cross-validated choice of the l1 penalty
  
  Read more in the :ref:`User Guide <sparse_inverse_covariance>`.
  
  Parameters
  ----------
  alphas : integer, or list positive float, optional
      If an integer is given, it fixes the number of points on the
      grids of alpha to be used. If a list is given, it gives the
      grid to be used. See the notes in the class docstring for
      more details.
  
  n_refinements: strictly positive integer
      The number of times the grid is refined. Not used if explicit
      values of alphas are passed.
  
  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.
  
  tol : positive float, optional
      The tolerance to declare convergence: if the dual gap goes below
      this value, iterations are stopped.
  
  enet_tol : positive float, optional
      The tolerance for the elastic net solver used to calculate the descent
      direction. This parameter controls the accuracy of the search direction
      for a given column update, not of the overall parameter estimate. Only
      used for mode='cd'.
  
  max_iter : integer, optional
      Maximum number of iterations.
  
  mode: {'cd', 'lars'}
      The Lasso solver to use: coordinate descent or LARS. Use LARS for
      very sparse underlying graphs, where number of features is greater
      than number of samples. Elsewhere prefer cd which is more numerically
      stable.
  
  n_jobs : int, optional
      number of jobs to run in parallel (default 1).
  
  verbose : boolean, optional
      If verbose is True, the objective function and duality gap are
      printed at each iteration.
  
  assume_centered : Boolean
      If True, data are not centered before computation.
      Useful when working with data whose mean is almost, but not exactly
      zero.
      If False, data are centered before computation.
  
  Attributes
  ----------
  covariance_ : numpy.ndarray, shape (n_features, n_features)
      Estimated covariance matrix.
  
  precision_ : numpy.ndarray, shape (n_features, n_features)
      Estimated precision matrix (inverse covariance).
  
  alpha_ : float
      Penalization parameter selected.
  
  cv_alphas_ : list of float
      All penalization parameters explored.
  
  `grid_scores`: 2D numpy.ndarray (n_alphas, n_folds)
      Log-likelihood score on left-out data across folds.
  
  n_iter_ : int
      Number of iterations run for the optimal alpha.
  
  See Also
  --------
  graph_lasso, GraphLasso
  
  Notes
  -----
  The search for the optimal penalization parameter (alpha) is done on an
  iteratively refined grid: first the cross-validated scores on a grid are
  computed, then a new refined grid is centered around the maximum, and so
  on.
  
  One of the challenges which is faced here is that the solvers can
  fail to converge to a well-conditioned estimate. The corresponding
  values of alpha then come out as missing values, but the optimum may
  be close to these missing values.
class_docstr_tok: ["Sparse","inverse","covariance","w\/","cross-validated","choice","of","the","l1","penalty","Read","more","in","the",":","ref",":","`","User","Guide","<","sparse_inverse_covariance",">","`",".","Parameters","--","--","--","--","--","alphas",":","integer",",","or","list","positive","float",",","optional","If","an","integer","is","given",",","it","fixes","the","number","of","points","on","the","grids","of","alpha","to","be","used",".","If","a","list","is","given",",","it","gives","the","grid","to","be","used",".","See","the","notes","in","the","class","docstring","for","more","details",".","n_refinements",":","strictly","positive","integer","The","number","of","times","the","grid","is","refined",".","Not","used","if","explicit","values","of","alphas","are","passed",".","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",".","tol",":","positive","float",",","optional","The","tolerance","to","declare","convergence",":","if","the","dual","gap","goes","below","this","value",",","iterations","are","stopped",".","enet_tol",":","positive","float",",","optional","The","tolerance","for","the","elastic","net","solver","used","to","calculate","the","descent","direction",".","This","parameter","controls","the","accuracy","of","the","search","direction","for","a","given","column","update",",","not","of","the","overall","parameter","estimate",".","Only","used","for","mode='cd","'",".","max_iter",":","integer",",","optional","Maximum","number","of","iterations",".","mode",":","{","'cd","'",",","'lars","'","}","The","Lasso","solver","to","use",":","coordinate","descent","or","LARS",".","Use","LARS","for","very","sparse","underlying","graphs",",","where","number","of","features","is","greater","than","number","of","samples",".","Elsewhere","prefer","cd","which","is","more","numerically","stable",".","n_jobs",":","int",",","optional","number","of","jobs","to","run","in","parallel","(","default","1",")",".","verbose",":","boolean",",","optional","If","verbose","is","True",",","the","objective","function","and","duality","gap","are","printed","at","each","iteration",".","assume_centered",":","Boolean","If","True",",","data","are","not","centered","before","computation",".","Useful","when","working","with","data","whose","mean","is","almost",",","but","not","exactly","zero",".","If","False",",","data","are","centered","before","computation",".","Attributes","--","--","--","--","--","covariance_",":","numpy.ndarray",",","shape","(","n_features",",","n_features",")","Estimated","covariance","matrix",".","precision_",":","numpy.ndarray",",","shape","(","n_features",",","n_features",")","Estimated","precision","matrix","(","inverse","covariance",")",".","alpha_",":","float","Penalization","parameter","selected",".","cv_alphas_",":","list","of","float","All","penalization","parameters","explored",".","`","grid_scores","`",":","2D","numpy.ndarray","(","n_alphas",",","n_folds",")","Log-likelihood","score","on","left-out","data","across","folds",".","n_iter_",":","int","Number","of","iterations","run","for","the","optimal","alpha",".","See","Also","--","--","--","--","graph_lasso",",","GraphLasso","Notes","--","--","-","The","search","for","the","optimal","penalization","parameter","(","alpha",")","is","done","on","an","iteratively","refined","grid",":","first","the","cross-validated","scores","on","a","grid","are","computed",",","then","a","new","refined","grid","is","centered","around","the","maximum",",","and","so","on",".","One","of","the","challenges","which","is","faced","here","is","that","the","solvers","can","fail","to","converge","to","a","well-conditioned","estimate",".","The","corresponding","values","of","alpha","then","come","out","as","missing","values",",","but","the","optimum","may","be","close","to","these","missing","values","."]
docstr: Fits the GraphLasso covariance model to X.
  
  Parameters
  ----------
  X : ndarray, shape (n_samples, n_features)
      Data from which to compute the covariance estimate
docstr_tok: ["Fits","the","GraphLasso","covariance","model","to","X.","Parameters","--","--","--","--","--","X",":","ndarray",",","shape","(","n_samples",",","n_features",")","Data","from","which","to","compute","the","covariance","estimate"]
code: def fit(self, X, y=None):
      """Fits the GraphLasso covariance model to X.
  
      Parameters
      ----------
      X : ndarray, shape (n_samples, n_features)
          Data from which to compute the covariance estimate
      """
      # Covariance does not make sense for a single feature
      X = check_array(X, ensure_min_features=2, estimator=self)
      if self.assume_centered:
          self.location_ = np.zeros(X.shape[1])
      else:
          self.location_ = X.mean(0)
      emp_cov = empirical_covariance(
          X, assume_centered=self.assume_centered
      )
  
      cv = check_cv(self.cv, y, classifier=False)
  
      # List of (alpha, scores, covs)
      path = list()
      n_alphas = self.alphas
      inner_verbose = max(0, self.verbose - 1)
  
      if isinstance(n_alphas, collections.Sequence):
          alphas = self.alphas
          n_refinements = 1
      else:
          n_refinements = self.n_refinements
          alpha_1 = alpha_max(emp_cov)
          alpha_0 = 1e-2 * alpha_1
          alphas = np.logspace(
              np.log10(alpha_0), np.log10(alpha_1), n_alphas
          )[::-1]
  
      t0 = time.time()
      for i in range(n_refinements):
          with warnings.catch_warnings():
              # No need to see the convergence warnings on this grid:
              # they will always be points that will not converge
              # during the cross-validation
              warnings.simplefilter("ignore", ConvergenceWarning)
              # Compute the cross-validated loss on the current grid
  
              # NOTE: Warm-restarting graph_lasso_path has been tried, and
              # this did not allow to gain anything (same execution time with
              # or without).
              this_path = Parallel(
                  n_jobs=self.n_jobs, verbose=self.verbose
              )(
                  delayed(graph_lasso_path)(
                      X[train],
                      alphas=alphas,
                      X_test=X[test],
                      mode=self.mode,
                      tol=self.tol,
                      enet_tol=self.enet_tol,
                      max_iter=int(0.1 * self.max_iter),
                      verbose=inner_verbose,
                  )
                  for train, test in cv.split(X, y)
              )
  
          # Little danse to transform the list in what we need
          covs, _, scores = zip(*this_path)
          covs = zip(*covs)
          scores = zip(*scores)
          path.extend(zip(alphas, scores, covs))
          path = sorted(path, key=operator.itemgetter(0), reverse=True)
  
          # Find the maximum (avoid using built in 'max' function to
          # have a fully-reproducible selection of the smallest alpha
          # in case of equality)
          best_score = -np.inf
          last_finite_idx = 0
          for index, (alpha, scores, _) in enumerate(path):
              this_score = np.mean(scores)
              if this_score >= 0.1 / np.finfo(np.float64).eps:
                  this_score = np.nan
              if np.isfinite(this_score):
                  last_finite_idx = index
              if this_score >= best_score:
                  best_score = this_score
                  best_index = index
  
          # Refine the grid
          if best_index == 0:
              # We do not need to go back: we have chosen
              # the highest value of alpha for which there are
              # non-zero coefficients
              alpha_1 = path[0][0]
              alpha_0 = path[1][0]
          elif (
              best_index == last_finite_idx
              and not best_index == len(path) - 1
          ):
              # We have non-converged models on the upper bound of the
              # grid, we need to refine the grid there
              alpha_1 = path[best_index][0]
              alpha_0 = path[best_index + 1][0]
          elif best_index == len(path) - 1:
              alpha_1 = path[best_index][0]
              alpha_0 = 0.01 * path[best_index][0]
          else:
              alpha_1 = path[best_index - 1][0]
              alpha_0 = path[best_index + 1][0]
  
          if not isinstance(n_alphas, collections.Sequence):
              alphas = np.logspace(
                  np.log10(alpha_1), np.log10(alpha_0), n_alphas + 2
              )
              alphas = alphas[1:-1]
  
          if self.verbose and n_refinements > 1:
              print(
                  "[GraphLassoCV] Done refinement % 2i out of %i: % 3is"
                  % (i + 1, n_refinements, time.time() - t0)
              )
  
      path = list(zip(*path))
      grid_scores = list(path[1])
      alphas = list(path[0])
      # Finally, compute the score with alpha = 0
      alphas.append(0)
      grid_scores.append(
          cross_val_score(
              EmpiricalCovariance(),
              X,
              cv=cv,
              n_jobs=self.n_jobs,
              verbose=inner_verbose,
          )
      )
      self.grid_scores = np.array(grid_scores)
      best_alpha = alphas[best_index]
      self.alpha_ = best_alpha
      self.cv_alphas_ = alphas
  
      # Finally fit the model with the selected alpha
      self.covariance_, self.precision_, self.n_iter_ = graph_lasso(
          emp_cov,
          alpha=best_alpha,
          mode=self.mode,
          tol=self.tol,
          enet_tol=self.enet_tol,
          max_iter=self.max_iter,
          verbose=inner_verbose,
          return_n_iter=True,
      )
      return self
  
imports: import warnings
  import operator
  import sys
  import time
  import numpy
  from scipy import linalg
  from .empirical_covariance_ import empirical_covariance, EmpiricalCovariance, log_likelihood
  from ..exceptions import ConvergenceWarning
  from ..utils.extmath import pinvh
  from ..utils.validation import check_random_state, check_array
  from ..linear_model import lars_path
  from ..linear_model import cd_fast
  from ..model_selection import check_cv, cross_val_score
  from ..externals.joblib import Parallel, delayed
  import collections
label_desc: Use image node_id 2 for calling the GraphLassoCV obj's underlying member method code with example usage: obj.fit(X, y) and returns: self