code: import numpy as np
  import torch
  import random
  import matplotlib.pyplot as plt
  import os
  
  __all__ = [
      "seed_everything",
      "AverageMeter",
      "accuracy",
      "EarlyStopping",
      "matplotlib_imshow",
      "print_size_of_model",
  ]
  
  
  def seed_everything(seed):
      """
      Makes code deterministic using a given seed. Internally sets all seeds of torch, numpy and random.
      """
      random.seed(seed)
      os.environ["PYTHONHASHSEED"] = str(seed)
      np.random.seed(seed)
      torch.manual_seed(seed)
      torch.cuda.manual_seed(seed)
      torch.backends.cudnn.deterministic = True
      torch.backends.cudnn.benchmark = True
  
  
  class AverageMeter(object):
      """Computes and stores the average and current value"""
  
      def __init__(self):
          self.reset()
  
      def reset(self):
          self.val = 0
          self.avg = 0
          self.sum = 0
          self.count = 0
  
      def update(self, val, n=1):
          self.val = val
          self.sum += val * n
          self.count += n
          self.avg = self.sum / self.count
  
  
  def accuracy(output, target, topk=(1,)):
      """Computes the accuracy over the k top predictions for the specified values of k"""
      maxk = max(topk)
      batch_size = target.size(0)
      _, pred = output.topk(maxk, 1, True, True)
      pred = pred.t()
      correct = pred.eq(target.view(1, -1).expand_as(pred))
      return [correct[:k].view(-1).float().sum(0) * 100.0 / batch_size for k in topk]
  
  
  class ProgressMeter(object):
      def __init__(self, num_batches, meters, prefix=""):
          self.batch_fmtstr = self._get_batch_fmtstr(num_batches)
          self.meters = meters
          self.prefix = prefix
  
      def display(self, batch):
          entries = [self.prefix + self.batch_fmtstr.format(batch)]
          entries += [str(meter) for meter in self.meters]
          print("\t".join(entries))
  
      def _get_batch_fmtstr(self, num_batches):
          num_digits = len(str(num_batches // 1))
          fmt = "{:" + str(num_digits) + "d}"
          return "[" + fmt + "/" + fmt.format(num_batches) + "]"
  
  
  class EarlyStopping:
      """Early stops the training if validation loss doesn't improve after a given patience."""
  
      def __init__(self, patience=7, verbose=False, delta=0.0001, path="checkpoint.pt"):
          """
          Args:
              patience (int): How long to wait after last time validation loss improved.
                              Default: 7
              verbose (bool): If True, prints a message for each validation loss improvement. 
                              Default: False
              delta (float): Minimum change in the monitored quantity to qualify as an improvement.
                              Default: 0
              path (str): Path for the checkpoint to be saved to.
                              Default: 'checkpoint.pt'
          """
          self.patience = patience
          self.verbose = verbose
          self.counter = 0
          self.best_score = None
          self.early_stop = False
          self.val_loss_min = np.Inf
          self.delta = delta
          self.path = path
  
      def __call__(self, val_loss, model):
  
          score = -val_loss
  
          if self.best_score is None:
              self.best_score = score
              self.save_checkpoint(val_loss, model)
          elif score < self.best_score + self.delta:
              self.counter += 1
              print(f"EarlyStopping counter: {self.counter} out of {self.patience}")
              if self.counter >= self.patience:
                  self.early_stop = True
          else:
              self.best_score = score
              self.save_checkpoint(val_loss, model)
              self.counter = 0
  
      def save_checkpoint(self, val_loss, model):
          """Saves model when validation loss decrease."""
          if self.verbose:
              print(
                  f"Validation loss decreased ({self.val_loss_min:.6f} --> {val_loss:.6f}).  Saving model ..."
              )
          torch.save(model.state_dict(), self.path)
          self.val_loss_min = val_loss
  
  
  def print_size_of_model(model):
      torch.save(model.state_dict(), "temp.p")
      print("Size (MB):", os.path.getsize("temp.p") / 1e6)
      os.remove("temp.p")
  
  
  def matplotlib_imshow(img, one_channel=False):
      if one_channel:
          img = img.mean(dim=0)
      img = img / 2 + 0.5  # unnormalize
      npimg = img.numpy()
      if one_channel:
          plt.imshow(npimg, cmap="Greys")
      else:
          plt.imshow(np.transpose(npimg, (1, 2, 0)))
  
apis: numpy.transpose torch.cuda.manual_seed torch.manual_seed numpy.random.seed matplotlib.pyplot.imshow