text: """Taken from https://github.com/Bjarten/early-stopping-pytorch"""
  
  import numpy as np
  import torch
  
  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, path='checkpoint.pt', trace_func=print, rank=0):
          """
          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'
              trace_func (function): trace print function.
                              Default: print            
          """
          self.patience = patience
          self.verbose = verbose
          self.counter = 0
          self.best_score = None
          self.early_stop = False
          self.val_loss_min = np.Inf
          self.val_auc_max = np.Inf
          self.delta = delta
          self.path = path
          self.trace_func = trace_func
          self.rank = rank
          
      def __call__(self, metric, model):
  
          #score = -val_loss
          score = metric
  
          if self.best_score is None:
              self.best_score = score
              self.save_checkpoint(metric, model)
          elif score < self.best_score + self.delta:
              self.counter += 1
              self.trace_func(f'EarlyStopping counter: {self.counter} out of {self.patience}')
              if self.counter >= self.patience:
                  self.early_stop = True
          else:
              self.best_score = score
              if self.rank == 0:
                  self.save_checkpoint(metric, model)
              self.counter = 0
  
      def save_checkpoint(self, val_loss, model):
          '''Saves model when validation loss decrease.'''
          if self.verbose:
              self.trace_func(f'Proc[{self.rank}]Validation auc increased ({self.val_loss_min:.6f} --> {val_loss:.6f}).  Saving model ...')
          torch.save(model.state_dict(), self.path)
          self.val_loss_min = val_loss
  