code: def scoreModels(
      models,
      X,
      y,
      metric=roc_auc_score,
      predict_proba=True,
      n_jobs=-1,
      verbose=10,
  ):
      """
      Parallelizes scoring all models using provided metric for given models on scoring data
      :param models: The lists of fitted models you wish to score, fitted using fitModels
      :param X: The X data ou wish to use for prediction
      :param y: The ground truth y data you wish to compare the predictions to
      :param metric: The metric you wish to use to score the predictions using
          Defaults to roc_auc_score
      :param predict_proba: Choice between 'predict_proba' and 'predict' for scoring routine
          Default True means predict_proba and False means predict
      :param n_jobs: Number of cores to use in parallelization (defaults to -1: all cores)
      :param verbose: The level of verbosity of reporting updates on parallel process
          Default is 10 (send an update at the completion of each job)
      :return: Returns a list of scores in the same order as the list of models
  
      Example usage:
          from sklearn.metrics import recall_score
          myScores = scoreModels(myModels, X_val, y_val, recall_score)
  
      """
      return Parallel(n_jobs=n_jobs, verbose=np.ceil(verbose / 10))(
          delayed(scoreOne)(m, X, y, metric, predict_proba)
          for m in models
      )
  
file_path: parfit/parfit/score.py
imports: from joblib import Parallel, delayed
  from sklearn.metrics import roc_auc_score
  import numpy
  import warnings
label_desc: Use image node_id 3 for calling a global function with example usage: scoreModels(models, X, y, metric, predict_proba, n_jobs, verbose) and returns: Parallel