def METHOD_NAME(
    self,
    load_path: str,
    policy: Optional[TorchPolicy] = None,
    reset_global_steps: bool = False,
) -> None:
    saved_state_dict = torch.load(load_path)
    if policy is None:
        modules = self.modules
        policy = self.policy
    else:
        modules = policy.get_modules()
    policy = cast(TorchPolicy, policy)
    for name, mod in modules.items():
        try:
            if isinstance(mod, torch.nn.Module):
                missing_keys, unexpected_keys = mod.load_state_dict(
                    saved_state_dict[name], strict=False
                )
                if missing_keys:
                    logger.warning(
                        f"Did not find these keys {missing_keys} in checkpoint. Initializing."
                    )
                if unexpected_keys:
                    logger.warning(
                        f"Did not expect these keys {unexpected_keys} in checkpoint. Ignoring."
                    )
            else:
                # If module is not an nn.Module, try to load as one piece
                mod.load_state_dict(saved_state_dict[name])
        # KeyError is raised if the module was not present in the last run but is being
        # accessed in the saved_state_dict.
        # ValueError is raised by the optimizer's load_state_dict if the parameters have
        # have changed. Note, the optimizer uses a completely different load_state_dict
        # function because it is not an nn.Module.
        # RuntimeError is raised by PyTorch if there is a size mismatch between modules
        # of the same name. This will still partially assign values to those layers that
        # have not changed shape.
        except (KeyError, ValueError, RuntimeError) as err:
            logger.warning(f"Failed to load for module {name}. Initializing")
            logger.debug(f"Module loading error : {err}")
    if reset_global_steps:
        policy.set_step(0)
        logger.info(
            "Starting training from step 0 and saving to {}.".format(
                self.model_path
            )
        )
    else:
        logger.info(f"Resuming training from step {policy.get_current_step()}.")