text: from collections import defaultdict, deque, OrderedDict
  import copy
  import datetime
  import hashlib
  import time
  import paddle
  import paddle.distributed as dist
  
  import errno
  import os
  
  
  class SmoothedValue(object):
      """Track a series of values and provide access to smoothed values over a
      window or the global series average.
      """
  
      def __init__(self, window_size=20, fmt=None):
          if fmt is None:
              fmt = "{median:.4f} ({global_avg:.4f})"
          self.deque = deque(maxlen=window_size)
          self.total = 0.0
          self.count = 0
          self.fmt = fmt
  
      def update(self, value, n=1):
          self.deque.append(value)
          self.count += n
          self.total += value * n
  
      def synchronize_between_processes(self):
          """
          Warning: does not synchronize the deque!
          """
          t = paddle.to_tensor([self.count, self.total], dtype='float64')
          t = t.numpy().tolist()
          self.count = int(t[0])
          self.total = t[1]
  
      @property
      def median(self):
          d = paddle.to_tensor(list(self.deque))
          return d.median().numpy().item()
  
      @property
      def avg(self):
          d = paddle.to_tensor(list(self.deque), dtype='float32')
          return d.mean().numpy().item()
  
      @property
      def global_avg(self):
          return self.total / self.count
  
      @property
      def max(self):
          return max(self.deque)
  
      @property
      def value(self):
          return self.deque[-1]
  
      def __str__(self):
          return self.fmt.format(
              median=self.median,
              avg=self.avg,
              global_avg=self.global_avg,
              max=self.max,
              value=self.value)
  
  
  class MetricLogger(object):
      def __init__(self, delimiter="\t"):
          self.meters = defaultdict(SmoothedValue)
          self.delimiter = delimiter
  
      def update(self, **kwargs):
          for k, v in kwargs.items():
              if isinstance(v, paddle.Tensor):
                  v = v.item()
              assert isinstance(v, (float, int))
              self.meters[k].update(v)
  
      def __getattr__(self, attr):
          if attr in self.meters:
              return self.meters[attr]
          if attr in self.__dict__:
              return self.__dict__[attr]
          raise AttributeError("'{}' object has no attribute '{}'".format(
              type(self).__name__, attr))
  
      def __str__(self):
          loss_str = []
          for name, meter in self.meters.items():
              loss_str.append("{}: {}".format(name, str(meter)))
          return self.delimiter.join(loss_str)
  
      def synchronize_between_processes(self):
          for meter in self.meters.values():
              meter.synchronize_between_processes()
  
      def add_meter(self, name, meter):
          self.meters[name] = meter
  
      def log_every(self, iterable, print_freq, header=None):
          i = 0
          if not header:
              header = ''
          start_time = time.time()
          end = time.time()
          iter_time = SmoothedValue(fmt='{avg:.4f}')
          data_time = SmoothedValue(fmt='{avg:.4f}')
          space_fmt = ':' + str(len(str(len(iterable)))) + 'd'
          log_msg = self.delimiter.join([
              header, '[{0' + space_fmt + '}/{1}]', 'eta: {eta}', '{meters}',
              'time: {time}', 'data: {data}'
          ])
          for obj in iterable:
              data_time.update(time.time() - end)
              yield obj
              iter_time.update(time.time() - end)
              if i % print_freq == 0:
                  eta_seconds = iter_time.global_avg * (len(iterable) - i)
                  eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
                  print(
                      log_msg.format(
                          i,
                          len(iterable),
                          eta=eta_string,
                          meters=str(self),
                          time=str(iter_time),
                          data=str(data_time)))
              i += 1
              end = time.time()
          total_time = time.time() - start_time
          total_time_str = str(datetime.timedelta(seconds=int(total_time)))
          print('{} Total time: {}'.format(header, total_time_str))
  
  
  def accuracy(output, target, topk=(1, )):
      """Computes the accuracy over the k top predictions for the specified values of k"""
      with paddle.no_grad():
          maxk = max(topk)
          batch_size = target.shape[0]
  
          _, pred = output.topk(maxk, 1, True, True)
          pred = pred.t()
          correct = pred.equal(target)
  
          res = []
          for k in topk:
              correct_k = correct.astype(paddle.int32)[:k].flatten().sum(
                  dtype='float32')
              res.append(correct_k / batch_size)
          return res
  
  
  def get_world_size():
      return dist.get_world_size()
  
  
  def mkdir(path):
      try:
          os.makedirs(path)
      except OSError as e:
          if e.errno != errno.EEXIST:
              raise
  