text: import os
  import torch
  import numpy as np
  
  
  def mkdir_if_missing(directory):
      if not os.path.exists(directory):
          try:
              os.makedirs(directory)
          except OSError as e:
              if e.errno != errno.EEXIST:
                  raise
  
  
  class AverageMeter(object):
      def __init__(self, name, fmt=':f'):
          self.name = name
          self.fmt = fmt
          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 __str__(self):
          fmtstr = '{name} {val' + self.fmt + '} ({avg' + self.fmt + '})'
          return fmtstr.format(**self.__dict__)
  
  
  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) + ']'
  
  
  @torch.no_grad()
  def fill_memory_bank(loader, model, memory_bank):
      model.eval()
      memory_bank.reset()
  
      for i, batch in enumerate(loader):
          images = batch['image'].cuda(non_blocking=True)
          targets = batch['target'].cuda(non_blocking=True)
          output = model(images)
          memory_bank.update(output, targets)
          if i % 100 == 0:
              print('Fill Memory Bank [%d/%d]' %(i, len(loader)))
  
  
  def confusion_matrix(predictions, gt, class_names, output_file=None):
      # Plot confusion_matrix and store result to output_file
      import sklearn.metrics
      import matplotlib.pyplot as plt
      confusion_matrix = sklearn.metrics.confusion_matrix(gt, predictions)
      confusion_matrix = confusion_matrix / np.sum(confusion_matrix, 1)
      
      fig, axes = plt.subplots(1)
      plt.imshow(confusion_matrix, cmap='Blues')
      axes.set_xticks([i for i in range(len(class_names))])
      axes.set_yticks([i for i in range(len(class_names))])
      axes.set_xticklabels(class_names, ha='right', fontsize=8, rotation=40)
      axes.set_yticklabels(class_names, ha='right', fontsize=8)
      
      for (i, j), z in np.ndenumerate(confusion_matrix):
          if i == j:
              axes.text(j, i, '%d' %(100*z), ha='center', va='center', color='white', fontsize=6)
          else:
              pass
  
      plt.tight_layout()
      if output_file is None:
          plt.show()
      else:
          plt.savefig(output_file, dpi=300, bbox_inches='tight')
      plt.close()
  