docs: def fit(self, X, y, **kwargs):
          """
          Fit is the entry point for the visualizer. Given instances described
          by X and binary classes described in the target y, fit performs n
          trials by shuffling and splitting the dataset then computing the
          precision, recall, f1, and queue rate scores for each trial. The
          scores are aggregated by the quantiles expressed then drawn.
  
          Parameters
          ----------
          X : ndarray or DataFrame of shape n x m
              A matrix of n instances with m features
  
          y : ndarray or Series of length n
              An array or series of target or class values. The target y must
              be a binary classification target.
  
          kwargs: dict
              keyword arguments passed to Scikit-Learn API.
  
          Returns
          -------
          self : instance
              Returns the instance of the visualizer
  
          raises: YellowbrickValueError
              If the target y is not a binary classification target.
          """
          # Check target before metrics raise crazy exceptions
          if type_of_target(y) != 'binary':
              raise YellowbrickValueError("multiclass format is not supported")
  
          # Make arrays indexable for cross validation
          X, y = indexable(X, y)
  
          # TODO: parallelize trials with joblib (using sklearn utility)
          # NOTE: parallelization with matplotlib is tricy at best!
          trials = [
              metric
              for idx in range(self.n_trials)
              for metric in self._split_fit_score_trial(X, y, idx)
          ]
  
          # Compute maximum number of uniform thresholds across all trials
          n_thresholds = np.array([len(t['thresholds']) for t in trials]).min()
          self.thresholds_ = np.linspace(0.0, 1.0, num=n_thresholds)
  
          # Filter metrics and collect values for uniform thresholds
          metrics = frozenset(METRICS) - self._check_exclude(self.exclude)
          uniform_metrics = defaultdict(list)
  
          for trial in trials:
              rows = defaultdict(list)
              for t in self.thresholds_:
                  idx = bisect.bisect_left(trial['thresholds'], t)
                  for metric in metrics:
                      rows[metric].append(trial[metric][idx])
  
              for metric, row in rows.items():
                  uniform_metrics[metric].append(row)
  
          # Convert metrics to metric arrays
          uniform_metrics = {
              metric: np.array(values)
              for metric, values in uniform_metrics.items()
          }
  
          # Perform aggregation and store cv_scores_
          quantiles = self._check_quantiles(self.quantiles)
          self.cv_scores_ = {}
  
          for metric, values in uniform_metrics.items():
              # Compute the lower, median, and upper plots
              lower, median, upper = mstats.mquantiles(
                  values, prob=quantiles, axis=0
              )
  
              # Store the aggregates in cv scores
              self.cv_scores_[metric] = median
              self.cv_scores_["{}_lower".format(metric)] = lower
              self.cv_scores_["{}_upper".format(metric)] = upper
  
          # Draw and always return self
          self.draw()
          return self