docs: def score(self, X, y=None, **kwargs):
          """
          Generates the predicted target values using the Scikit-Learn
          estimator.
  
          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
  
          Returns
          -------
          score_ : float
              Global accuracy unless micro or macro scores are requested.
          """
  
          # Compute the predictions for the test data
          y_pred = self._get_y_scores(X)
  
          # Note: In the above, _get_y_scores calls either a decision_function or
          # predict_proba, which should return a 2D array. But in a binary
          # classification using an estimator with only a decision_function, y_pred
          # will instead be 1D, meaning only one curve can be plotted. In this case,
          # we set the _binary_decision attribute to True to ensure only one curve is
          # computed and plotted later on.
          if y_pred.ndim == 1:
              self._binary_decision = True
  
              # Raise an error if it's a binary decision and user has set micro,
              # macro, or per_class to True
              if self.micro or self.macro or self.per_class:
                  raise ModelError(
                      "Micro, macro, and per-class scores are not defined for "
                      "binary classification for estimators with only "
                      "decision_function methods; set micro, macro, and "
                      "per-class params to False."
                  )
          else:
              self._binary_decision = False
              # If it's not a binary decision, at least one of micro, macro, or
              # per_class must be True
              if not self.micro and not self.macro and not self.per_class:
                  raise YellowbrickValueError(
                      "no curves will be drawn; specify micro, macro, or per_class"
                  )
  
          # Classes may be label encoded so only use what's in y to compute.
          # The self.classes_ attribute will be used as names for labels.
          classes = np.unique(y)
          n_classes = len(classes)
  
          # Store the false positive rate, true positive rate and curve info.
          self.fpr = dict()
          self.tpr = dict()
          self.roc_auc = dict()
  
          # If the decision is binary, compute the ROC curve and ROC area
          if self._binary_decision == True:
              self.fpr[0], self.tpr[0], _ = roc_curve(y, y_pred)
              self.roc_auc[0] = auc(self.fpr[0], self.tpr[0])
          else:
              # Otherwise compute the ROC curve and ROC area for each class
              for i, c in enumerate(classes):
                  self.fpr[i], self.tpr[i], _ = roc_curve(y, y_pred[:,i], pos_label=c)
                  self.roc_auc[i] = auc(self.fpr[i], self.tpr[i])
  
          # Compute micro average
          if self.micro:
              self._score_micro_average(y, y_pred, classes, n_classes)
  
          # Compute macro average
          if self.macro:
              self._score_macro_average(n_classes)
  
          # Draw the Curves
          self.draw()
  
          # Set score to micro average if specified
          if self.micro:
              self.score_ = self.roc_auc[MICRO]
  
          # Set score to macro average if not micro
          if self.macro:
              self.score_ = self.roc_auc[MACRO]
  
          # Set score to the base score if neither macro nor micro
          self.score_ = self.estimator.score(X, y)
  
          return self.score_