docs: def fit(self, X, y=None, **fit_params):
          """Fits the inverse covariance model according to the given training
          data and parameters.
  
          Parameters
          -----------
          X : 2D ndarray, shape (n_features, n_features)
              Input data.
  
          Returns
          -------
          self
          """
          # quic-specific outputs
          self.opt_ = None
          self.cputime_ = None
          self.iters_ = None
          self.duality_gap_ = None
  
          # these must be updated upon self.fit()
          self.path_ = None
          self.sample_covariance_ = None
          self.lam_scale_ = None
          self.lam_ = None
          self.is_fitted_ = False
  
          X = check_array(X, ensure_min_features=2, estimator=self)
          X = as_float_array(X, copy=False, force_all_finite=False)
          self.init_coefs(X)
  
          # either use passed in path, or make our own path
          lam_1 = self.lam_scale_
          lam_0 = 1e-2 * lam_1
          if self.path is None:
              self.path_ = np.logspace(np.log10(lam_0), np.log10(lam_1), 100)[::-1]
          elif isinstance(self.path, int):
              self.path_ = np.logspace(np.log10(lam_0), np.log10(lam_1), self.path)[::-1]
          else:
              self.path_ = self.path
  
          self.path_ = _validate_path(self.path_)
  
          # fit along the path, temporarily populate
          # self.precision_, self.covariance_ with path values so we can use our
          # inherited selection function
          if self.method == "quic":
              (self.precision_, self.covariance_, _, _, _, _) = quic(
                  self.sample_covariance_,
                  self.lam * self.lam_scale_,
                  mode="path",
                  tol=self.tol,
                  max_iter=self.max_iter,
                  Theta0=self.Theta0,
                  Sigma0=self.Sigma0,
                  path=self.path_,
                  msg=self.verbose,
              )
              self.is_fitted_ = True
          else:
              raise NotImplementedError("Only method='quic' has been implemented.")
  
          # apply EBIC criteria
          best_lam_idx = self.ebic_select(gamma=self.gamma)
          self.lam_ = self.lam * self.lam_scale_ * self.path_[best_lam_idx]
          self.precision_ = self.precision_[best_lam_idx]
          self.covariance_ = self.covariance_[best_lam_idx]
  
          self.is_fitted_ = True
          return self