text: 
  import torch
  import glob
  import random
  import numpy as np
  from typing import Dict, List, Tuple
  import os
  import shutil
  import logging
  logger = logging.getLogger(__name__)
  
  
  def set_seed(args):
      random.seed(args.seed)
      np.random.seed(args.seed)
      torch.manual_seed(args.seed)
      if args.n_gpu > 0:
          torch.cuda.manual_seed_all(args.seed)
  
  
  def _sorted_checkpoints(args, checkpoint_prefix="checkpoint", use_mtime=False):
      ordering_and_checkpoint_path = []
  
      glob_checkpoints = glob.glob(os.path.join(args.output_dir, "{}-*".format(checkpoint_prefix)))
  
      for path in glob_checkpoints:
          if use_mtime:
              ordering_and_checkpoint_path.append((os.path.getmtime(path), path))
          else:
              regex_match = re.match(".*{}-([0-9]+)".format(checkpoint_prefix), path)
              if regex_match and regex_match.groups():
                  ordering_and_checkpoint_path.append((int(regex_match.groups()[0]), path))
  
      checkpoints_sorted = sorted(ordering_and_checkpoint_path)
      checkpoints_sorted = [checkpoint[1] for checkpoint in checkpoints_sorted]
      return checkpoints_sorted
  
  
  def _rotate_checkpoints(args, checkpoint_prefix="checkpoint", use_mtime=False):
      if not args.save_total_limit:
          return
      if args.save_total_limit <= 0:
          return
  
      # Check if we should delete older checkpoint(s)
      checkpoints_sorted = _sorted_checkpoints(args, checkpoint_prefix, use_mtime)
      if len(checkpoints_sorted) <= args.save_total_limit:
          return
  
      number_of_checkpoints_to_delete = max(0, len(checkpoints_sorted) - args.save_total_limit)
      checkpoints_to_be_deleted = checkpoints_sorted[:number_of_checkpoints_to_delete]
      for checkpoint in checkpoints_to_be_deleted:
          logger.info("Deleting older checkpoint [{}] due to args.save_total_limit".format(checkpoint))
          shutil.rmtree(checkpoint)
  
  
  def save_checkpoint(model, optimizer, scheduler, tokenizer, args):
      checkpoint_prefix = "checkpoint"
      # Save model checkpoint
      output_dir = os.path.join(args.output_dir, "{}-{}".format(checkpoint_prefix, global_step))
      os.makedirs(output_dir, exist_ok=True)
      model_to_save = (model.module if hasattr(model, "module") else model)  # Take care of distributed/parallel training
      model_to_save.save_pretrained(output_dir)
      tokenizer.save_pretrained(output_dir)
  
      torch.save(args, os.path.join(output_dir, "training_args.bin"))
      logger.info("Saving model checkpoint to %s", output_dir)
  
      _rotate_checkpoints(args, checkpoint_prefix)
  
      torch.save(optimizer.state_dict(), os.path.join(output_dir, "optimizer.pt"))
      torch.save(scheduler.state_dict(), os.path.join(output_dir, "scheduler.pt"))
      logger.info("Saving optimizer and scheduler states to %s", output_dir)
  