docs: def fit(self, X, y=None):
          """
          Fits the RFECV with the wrapped model to the specified data and draws
          the rfecv curve with the optimal number of features found.
  
          Parameters
          ----------
          X : array-like, shape (n_samples, n_features)
              Training vector, where n_samples is the number of samples and
              n_features is the number of features.
  
          y : array-like, shape (n_samples) or (n_samples, n_features), optional
              Target relative to X for classification or regression.
  
          Returns
          -------
          self : instance
              Returns the instance of the RFECV visualizer.
          """
          X, y = check_X_y(X, y, "csr")
          n_features = X.shape[1]
  
          # This check is kind of unnecessary since RFE will do it, but it's
          # nice to get it out of the way ASAP and raise a meaningful error.
          if 0.0 < self.step < 1.0:
              step = int(max(1, self.step * n_features))
          else:
              step = int(self.step)
  
          if step < 0:
              raise YellowbrickValueError("step must be >0")
  
          # Create the RFE model
          rfe = RFE(self.estimator, step=step)
          self.n_feature_subsets_ = np.arange(1, n_features+step, step)
  
          # Create the cross validation params
          # TODO: handle random state
          cv_params = {
              key: self.get_params()[key]
              for key in ('groups', 'cv', 'scoring')
          }
  
          # Perform cross-validation for each feature subset
          scores = []
          for n_features_to_select in self.n_feature_subsets_:
              rfe.set_params(n_features_to_select=n_features_to_select)
              scores.append(cross_val_score(rfe, X, y, **cv_params))
  
          # Convert scores to array
          self.cv_scores_ = np.array(scores)
  
          # Find the best RFE model
          bestidx = self.cv_scores_.mean(axis=1).argmax()
          self.n_features_ = self.n_feature_subsets_[bestidx]
  
          # Fit the final RFE model for the number of features
          self.rfe_estimator_ = rfe
          self.rfe_estimator_.set_params(n_features_to_select=self.n_features_)
          self.rfe_estimator_.fit(X, y)
  
          # Rewrap the visualizer to use the rfe estimator
          self._wrapped = self.rfe_estimator_
  
          # Hoist the RFE params to the visualizer
          self.support_ = self.rfe_estimator_.support_
          self.ranking_ = self.rfe_estimator_.ranking_
  
          self.draw()
          return self