code: def score(self, X, y, **kwargs):
          
  
          # We're relying on predict to raise NotFitted
          y_pred = self.predict(X)
  
          y_type, y_true, y_pred = _check_targets(y, y_pred)
  
          if y_type not in ("binary", "multiclass"):
              raise YellowbrickValueError("%s is not supported" % y_type)
  
          indices = unique_labels(y_true, y_pred)
  
          if len(self.classes_) > len(indices):
              raise ModelError("y and y_pred contain zero values "
                               "for one of the specified classes")
          elif len(self.classes_) < len(indices):
              raise NotImplementedError("filtering classes is "
                                          "currently not supported")
  
          # Create a table of predictions whose rows are the true classes
          # and whose columns are the predicted classes; each element
          # is the count of predictions for that class that match the true
          # value of that class.
          self.predictions_ = np.array([
              [
                  (y_pred[y == label_t] == label_p).sum()
                  for label_p in indices
              ]
              for label_t in indices
          ])
  
          self.draw()
          self.score_ = self.estimator.score(X, y)
  
          return self.score_
docs: Generates a 2D array where each row is the count of the
          predicted classes and each column is the true class
  
          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 score