code: def average_checkpoints(inputs):
      """Loads checkpoints from inputs and returns a model with averaged weights. Original implementation taken from:
      https://github.com/pytorch/fairseq/blob/a48f235636557b8d3bc4922a6fa90f3a0fa57955/scripts/average_checkpoints.py#L16
  
      Args:
        inputs (List[str]): An iterable of string paths of checkpoints to load from.
      Returns:
        A dict of string keys mapping to various values. The 'model' key
        from the returned dict should correspond to an OrderedDict mapping
        string parameter names to torch Tensors.
      """
      params_dict = OrderedDict()
      params_keys = None
      new_state = None
      num_models = len(inputs)
      for fpath in inputs:
          with open(fpath, "rb") as f:
              state = torch.load(
                  f,
                  map_location=(
                      lambda s, _: torch.serialization.default_restore_location(
                          s, "cpu"
                      )
                  ),
                  weights_only=True,
              )
          # Copies over the settings from the first checkpoint
          if new_state is None:
              new_state = state
          model_params = state["model"]
          model_params_keys = list(model_params.keys())
          if params_keys is None:
              params_keys = model_params_keys
          elif params_keys != model_params_keys:
              raise KeyError(
                  f"For checkpoint {f}, expected list of params: {params_keys}, but found: {model_params_keys}"
              )
          for k in params_keys:
              p = model_params[k]
              if isinstance(p, torch.HalfTensor):
                  p = p.float()
              if k not in params_dict:
                  params_dict[k] = p.clone()
                  # NOTE: clone() is needed in case of p is a shared parameter
              else:
                  params_dict[k] += p
      averaged_params = OrderedDict()
      for k, v in params_dict.items():
          averaged_params[k] = v
          if averaged_params[k].is_floating_point():
              averaged_params[k].div_(num_models)
          else:
              averaged_params[k] //= num_models
      new_state["model"] = averaged_params
      return new_state
  
imports: import copy
  import datetime
  import errno
  import hashlib
  import os
  import time
  from collections import defaultdict, deque, OrderedDict
  from typing import List, Optional, Tuple
  import torch
  import torch.distributed
label_desc: Use image node_id 10 for calling a global function with example usage: average_checkpoints(inputs) and returns: new_state