code: def load_model(config, model, optimizer=None):
      """
      load model from checkpoint or pretrained_model
      """
      logger = get_logger()
      checkpoints = config.get("checkpoints")
      pretrained_model = config.get("pretrained_model")
      best_model_dict = {}
      if checkpoints:
          if checkpoints.endswith(".pdparams"):
              checkpoints = checkpoints.replace(".pdparams", "")
          assert os.path.exists(
              checkpoints + ".pdparams"
          ), "The {}.pdparams does not exists!".format(checkpoints)
  
          # load params from trained model
          params = paddle.load(checkpoints + ".pdparams")
          state_dict = model.state_dict()
          new_state_dict = {}
          for key, value in state_dict.items():
              if key not in params:
                  logger.warning(
                      "{} not in loaded params {} !".format(
                          key, params.keys()
                      )
                  )
                  continue
              pre_value = params[key]
              if list(value.shape) == list(pre_value.shape):
                  new_state_dict[key] = pre_value
              else:
                  logger.warning(
                      "The shape of model params {} {} not matched with loaded params shape {} !".format(
                          key, value.shape, pre_value.shape
                      )
                  )
          model.set_state_dict(new_state_dict)
  
          if optimizer is not None:
              if os.path.exists(checkpoints + ".pdopt"):
                  optim_dict = paddle.load(checkpoints + ".pdopt")
                  optimizer.set_state_dict(optim_dict)
              else:
                  logger.warning(
                      "{}.pdopt is not exists, params of optimizer is not loaded".format(
                          checkpoints
                      )
                  )
  
          if os.path.exists(checkpoints + ".states"):
              with open(checkpoints + ".states", "rb") as f:
                  states_dict = (
                      pickle.load(f)
                      if six.PY2
                      else pickle.load(f, encoding="latin1")
                  )
              best_model_dict = states_dict.get("best_model_dict", {})
              if "epoch" in states_dict:
                  best_model_dict["start_epoch"] = (
                      states_dict["epoch"] + 1
                  )
          logger.info("resume from {}".format(checkpoints))
      elif pretrained_model:
          load_pretrained_params(model, pretrained_model)
      else:
          logger.info("train from scratch")
      return best_model_dict
  
file_path: PaddleOCR/test_tipc/supplementary/utils.py
imports: import os
  import sys
  import logging
  import functools
  import paddle.distributed
label_desc: Use image node_id 3 for calling a global function with example usage: load_model(config, model, optimizer) and returns: best_model_dict