code: def load_checkpoint(
      model, filename, map_location="cpu", strict=False, logger=None
  ):
      """Load checkpoint from a file or URI.
  
      Args:
          model (Module): Module to load checkpoint.
          filename (str): Accept local filepath, URL, ``torchvision://xxx``,
              ``open-mmlab://xxx``. Please refer to ``docs/model_zoo.md`` for
              details.
          map_location (str): Same as :func:`torch.load`.
          strict (bool): Whether to allow different params for the model and
              checkpoint.
          logger (:mod:`logging.Logger` or None): The logger for error message.
  
      Returns:
          dict or OrderedDict: The loaded checkpoint.
      """
      checkpoint = _load_checkpoint(filename, map_location)
      # OrderedDict is a subclass of dict
      if not isinstance(checkpoint, dict):
          raise RuntimeError(
              f"No state_dict found in checkpoint file {filename}"
          )
      # get state_dict from checkpoint
      if "state_dict" in checkpoint:
          state_dict = checkpoint["state_dict"]
      elif "model" in checkpoint:
          state_dict = checkpoint["model"]
      else:
          state_dict = checkpoint
      # strip prefix of state_dict
      if list(state_dict.keys())[0].startswith("module."):
          state_dict = {k[7:]: v for k, v in state_dict.items()}
  
      # for MoBY, load model of online branch
      if sorted(list(state_dict.keys()))[0].startswith("encoder"):
          state_dict = {
              k.replace("encoder.", ""): v
              for k, v in state_dict.items()
              if k.startswith("encoder.")
          }
  
      # reshape absolute position embedding
      if state_dict.get("absolute_pos_embed") is not None:
          absolute_pos_embed = state_dict["absolute_pos_embed"]
          N1, L, C1 = absolute_pos_embed.size()
          N2, C2, H, W = model.absolute_pos_embed.size()
          if N1 != N2 or C1 != C2 or L != H * W:
              logger.warning(
                  "Error in loading absolute_pos_embed, pass"
              )
          else:
              state_dict[
                  "absolute_pos_embed"
              ] = absolute_pos_embed.view(N2, H, W, C2).permute(
                  0, 3, 1, 2
              )
  
      # interpolate position bias table if needed
      relative_position_bias_table_keys = [
          k
          for k in state_dict.keys()
          if "relative_position_bias_table" in k
      ]
      for table_key in relative_position_bias_table_keys:
          table_pretrained = state_dict[table_key]
          table_current = model.state_dict()[table_key]
          L1, nH1 = table_pretrained.size()
          L2, nH2 = table_current.size()
          if nH1 != nH2:
              logger.warning(f"Error in loading {table_key}, pass")
          else:
              if L1 != L2:
                  S1 = int(L1**0.5)
                  S2 = int(L2**0.5)
                  table_pretrained_resized = F.interpolate(
                      table_pretrained.permute(1, 0).view(
                          1, nH1, S1, S1
                      ),
                      size=(S2, S2),
                      mode="bicubic",
                  )
                  state_dict[table_key] = table_pretrained_resized.view(
                      nH2, L2
                  ).permute(1, 0)
  
      # load state_dict
      load_state_dict(model, state_dict, strict, logger)
      return checkpoint
  
imports: import io
  import os
  import os.path
  import pkgutil
  import time
  import warnings
  from collections import OrderedDict
  from importlib import import_module
  from tempfile import TemporaryDirectory
  import torch
  import torchvision
  from torch.optim import Optimizer
  from torch.utils import model_zoo
  from torch.nn import functional
  import annotator.uniformer.mmcv
  from annotator.uniformer.mmcv.fileio import FileClient
  from annotator.uniformer.mmcv.fileio import load
  from annotator.uniformer.mmcv.parallel import is_module_wrapper
  from annotator.uniformer.mmcv.utils import mkdir_or_exist
  from annotator.uniformer.mmcv.runner import get_dist_info
label_desc: Use image node_id 12 for calling a global function with example usage: load_checkpoint(model, filename, map_location, strict, logger) and returns: checkpoint