code: def integrity_score(self, X, method='predict', normalize=True,
                          num_format=lambda x: str(x)):
          
          X = np.array(X)
          if not X.ndim > 1:
              X = np.array([X])
  
          method = str(method).strip().lower()
          if method not in ['predict', 'predict_proba']:
              error = "The given method '{}' isn't supported.".format(method)
              raise AttributeError(error)
  
          if method == 'predict':
              y_true = self.estimator.predict(X)
              y_pred = self.predict(X, tnp_dir='tmp_integrity_score',
                                    keep_tmp_dir=True, num_format=num_format)
              return accuracy_score(y_true, y_pred, normalize=normalize)
  
          return False
docs: Compute the accuracy of the ported classifier.
  
          Parameters
          ----------
          :param X : ndarray, shape (n_samples, n_features)
              Input data.
  
          :param method : string, default: 'predict'
              The method which should be tested.
  
          :param normalize : bool, default: True
              If ``False``, return the number of correctly classified samples.
              Otherwise, return the fraction of correctly classified samples.
  
          :param num_format : lambda x, default: lambda x: str(x)
              The representation of the floating-point values.
  
          Returns
          -------
          score : float
              If ``normalize == True``, return the correctly classified samples
              (float), else it returns the number of correctly classified samples
              (int).
              The best performance is 1 with ``normalize == True`` and the number
              of samples with ``normalize == False``.