code: def evaluate(args, model, tokenizer, prefix="", patience=0):
      if args.model_type == "albert":
          model.albert.set_regression_threshold(
              args.regression_threshold
          )
          model.albert.set_patience(patience)
          model.albert.reset_stats()
      elif args.model_type == "bert":
          model.bert.set_regression_threshold(args.regression_threshold)
          model.bert.set_patience(patience)
          model.bert.reset_stats()
      else:
          raise NotImplementedError()
  
      # Loop to handle MNLI double evaluation (matched, mis-matched)
      eval_task_names = (
          ("mnli", "mnli-mm")
          if args.task_name == "mnli"
          else (args.task_name,)
      )
      eval_outputs_dirs = (
          (args.output_dir, args.output_dir + "-MM")
          if args.task_name == "mnli"
          else (args.output_dir,)
      )
  
      results = {}
      for eval_task, eval_output_dir in zip(
          eval_task_names, eval_outputs_dirs
      ):
          eval_dataset = load_and_cache_examples(
              args, eval_task, tokenizer, evaluate=True
          )
  
          if not os.path.exists(
              eval_output_dir
          ) and args.local_rank in [-1, 0]:
              os.makedirs(eval_output_dir)
  
          args.eval_batch_size = args.per_gpu_eval_batch_size * max(
              1, args.n_gpu
          )
          # Note that DistributedSampler samples randomly
          eval_sampler = SequentialSampler(eval_dataset)
          eval_dataloader = DataLoader(
              eval_dataset,
              sampler=eval_sampler,
              batch_size=args.eval_batch_size,
          )
  
          # multi-gpu eval
          if args.n_gpu > 1 and not isinstance(model, nn.DataParallel):
              model = nn.DataParallel(model)
  
          # Eval!
          logger.info(
              "***** Running evaluation {} *****".format(prefix)
          )
          logger.info("  Num examples = %d", len(eval_dataset))
          logger.info("  Batch size = %d", args.eval_batch_size)
          eval_loss = 0.0
          nb_eval_steps = 0
          preds = None
          out_label_ids = None
          for batch in tqdm(eval_dataloader, desc="Evaluating"):
              model.eval()
              batch = tuple(t.to(args.device) for t in batch)
  
              with torch.no_grad():
                  inputs = {
                      "input_ids": batch[0],
                      "attention_mask": batch[1],
                      "labels": batch[3],
                  }
                  inputs["token_type_ids"] = batch[2]
                  outputs = model(**inputs)
                  tmp_eval_loss, logits = outputs[:2]
  
                  eval_loss += tmp_eval_loss.mean().item()
              nb_eval_steps += 1
              if preds is None:
                  preds = logits.detach().cpu().numpy()
                  out_label_ids = (
                      inputs["labels"].detach().cpu().numpy()
                  )
              else:
                  preds = np.append(
                      preds, logits.detach().cpu().numpy(), axis=0
                  )
                  out_label_ids = np.append(
                      out_label_ids,
                      inputs["labels"].detach().cpu().numpy(),
                      axis=0,
                  )
  
          eval_loss = eval_loss / nb_eval_steps
          if args.output_mode == "classification":
              preds = np.argmax(preds, axis=1)
          elif args.output_mode == "regression":
              preds = np.squeeze(preds)
          result = compute_metrics(eval_task, preds, out_label_ids)
          results.update(result)
  
          output_eval_file = os.path.join(
              eval_output_dir, prefix, "eval_results.txt"
          )
          with open(output_eval_file, "w") as writer:
              logger.info("***** Eval results {} *****".format(prefix))
              for key in sorted(result.keys()):
                  logger.info("  %s = %s", key, str(result[key]))
                  print("  %s = %s" % (key, str(result[key])))
                  writer.write("%s = %s\n" % (key, str(result[key])))
  
      if args.eval_all_checkpoints and patience != 0:
          if args.model_type == "albert":
              model.albert.log_stats()
          elif args.model_type == "bert":
              model.bert.log_stats()
          else:
              raise NotImplementedError()
  
      return results
  
imports: import argparse
  import glob
  import json
  import logging
  import os
  import random
  import numpy
  import torch
  from pabee.modeling_pabee_albert import AlbertForSequenceClassificationWithPabee
  from pabee.modeling_pabee_bert import BertForSequenceClassificationWithPabee
  from torch import nn
  from torch.utils.data import DataLoader, RandomSampler, SequentialSampler, TensorDataset
  from torch.utils.data.distributed import DistributedSampler
  from tqdm import tqdm, trange
  import transformers
  from transformers import WEIGHTS_NAME, AdamW, AlbertConfig, AlbertTokenizer, BertConfig, BertTokenizer, get_linear_schedule_with_warmup
  from transformers import glue_compute_metrics
  from transformers import glue_convert_examples_to_features
  from transformers import glue_output_modes
  from transformers import glue_processors
  from transformers.trainer_utils import is_main_process
label_desc: Use image node_id 3 for calling a global function with example usage: evaluate(args, model, tokenizer, prefix, patience) and returns: results