code: def load_model(model_uri, model=None, dst_path=None, **kwargs):
      """
      Load a paddle model from a local file or a run.
  
      Args:
          model_uri: The location, in URI format, of the MLflow model, for example:
              - ``/Users/me/path/to/local/model``
              - ``relative/path/to/local/model``
              - ``s3://my_bucket/path/to/model``
              - ``runs:/<mlflow_run_id>/run-relative/path/to/model``
              - ``models:/<model_name>/<model_version>``
              - ``models:/<model_name>/<stage>``
          model: Required when loading a `paddle.Model` model saved with `training=True`.
          dst_path: The local filesystem path to which to download the model artifact.
              This directory must already exist. If unspecified, a local output
              path will be created.
          kwargs: The keyword arguments to pass to `paddle.jit.load`
              or `model.load`.
  
      For more information about supported URI schemes, see
      `Referencing Artifacts <https://www.mlflow.org/docs/latest/concepts.html#
      artifact-locations>`_.
  
      Returns:
          A paddle model.
  
      .. code-block:: python
          :caption: Example
  
          import mlflow.paddle
  
          pd_model = mlflow.paddle.load_model("runs:/96771d893a5e46159d9f3b49bf9013e2/pd_models")
          # use Pandas DataFrame to make predictions
          np_array = ...
          predictions = pd_model(np_array)
      """
      import paddle
  
      local_model_path = _download_artifact_from_uri(
          artifact_uri=model_uri, output_path=dst_path
      )
      flavor_conf = _get_flavor_configuration(
          model_path=local_model_path, flavor_name=FLAVOR_NAME
      )
      _add_code_from_conf_to_system_path(local_model_path, flavor_conf)
      pd_model_artifacts_path = os.path.join(
          local_model_path, flavor_conf["pickled_model"]
      )
      if model is None:
          return paddle.jit.load(pd_model_artifacts_path, **kwargs)
      elif not isinstance(model, paddle.Model):
          raise TypeError(
              f"Invalid object type `{type(model)}` for `model`, must be `paddle.Model`"
          )
      else:
          contains_pdparams = _contains_pdparams(local_model_path)
          if not contains_pdparams:
              raise TypeError(
                  "This model can't be loaded via `model.load` because a '.pdparams' file "
                  "doesn't exist. Please leave `model` unspecified to load the model via "
                  "`paddle.jit.load` or set `training` to True when saving a model."
              )
  
          model.load(pd_model_artifacts_path, **kwargs)
          return model
  
imports: import logging
  import os
  from typing import Any, Dict, Optional
  import yaml
  import mlflow
  from mlflow import pyfunc
  from mlflow.models import Model, ModelInputExample, ModelSignature
  from mlflow.models.model import MLMODEL_FILE_NAME
  from mlflow.models.signature import _infer_signature_from_input_example
  from mlflow.models.utils import _save_example
  from mlflow.tracking._model_registry import DEFAULT_AWAIT_MAX_SLEEP_SECONDS
  from mlflow.tracking.artifact_utils import _download_artifact_from_uri
  from mlflow.utils.autologging_utils import autologging_integration, safe_patch
  from mlflow.utils.docstring_utils import LOG_MODEL_PARAM_DOCS, format_docstring
  from mlflow.utils.environment import _CONDA_ENV_FILE_NAME, _CONSTRAINTS_FILE_NAME, _PYTHON_ENV_FILE_NAME, _REQUIREMENTS_FILE_NAME, _mlflow_conda_env, _process_conda_env, _process_pip_requirements, _PythonEnv, _validate_env_arguments
  from mlflow.utils.file_utils import write_to
  from mlflow.utils.model_utils import _add_code_from_conf_to_system_path, _get_flavor_configuration, _validate_and_copy_code_paths, _validate_and_prepare_target_save_path
  from mlflow.utils.requirements_utils import _get_pinned_requirement
label_desc: Use image node_id 4 for calling a global function with example usage: load_model(model_uri, model, dst_path) and returns: paddle, model