code: def save_model(
      pd_model,
      path,
      training=False,
      conda_env=None,
      code_paths=None,
      mlflow_model=None,
      signature: ModelSignature = None,
      input_example: ModelInputExample = None,
      pip_requirements=None,
      extra_pip_requirements=None,
      metadata=None,
  ):
      """
      Save a paddle model to a path on the local file system. Produces an MLflow Model
      containing the following flavors:
  
          - :py:mod:`mlflow.paddle`
          - :py:mod:`mlflow.pyfunc`. NOTE: This flavor is only included for paddle models
            that define `predict()`, since `predict()` is required for pyfunc model inference.
  
      Args:
          pd_model: paddle model to be saved.
          path: Local path where the model is to be saved.
          training: Only valid when saving a model trained using the PaddlePaddle high level API.
              If set to True, the saved model supports both re-training and
              inference. If set to False, it only supports inference.
          conda_env: {{ conda_env }}
          code_paths: A list of local filesystem paths to Python file dependencies (or directories
              containing file dependencies). These files are *prepended* to the system
              path when the model is loaded.
          mlflow_model: :py:mod:`mlflow.models.Model` this flavor is being added to.
          signature: {{ signature }}
          input_example: {{ input_example }}
          pip_requirements: {{ pip_requirements }}
          extra_pip_requirements: {{ extra_pip_requirements }}
          metadata: Custom metadata dictionary passed to the model and stored in the MLmodel file.
  
              .. Note:: Experimental: This parameter may change or be removed in a future
                                      release without warning.
  
      .. code-block:: python
          :caption: Example
  
          import mlflow.paddle
          import paddle
          from paddle.nn import Linear
          import paddle.nn.functional as F
          import numpy as np
          import os
          import random
          from sklearn.datasets import load_diabetes
          from sklearn.model_selection import train_test_split
          from sklearn import preprocessing
  
  
          def load_data():
              # dataset on boston housing prediction
              X, y = load_diabetes(return_X_y=True, as_frame=True)
              min_max_scaler = preprocessing.MinMaxScaler()
              X_min_max = min_max_scaler.fit_transform(X)
              X_normalized = preprocessing.scale(X_min_max, with_std=False)
              X_train, X_test, y_train, y_test = train_test_split(
                  X_normalized, y, test_size=0.2, random_state=42
              )
              y_train = y_train.reshape(-1, 1)
              y_test = y_test.reshape(-1, 1)
              return np.concatenate((X_train, y_train), axis=1), np.concatenate(
                  (X_test, y_test), axis=1
              )
  
  
          class Regressor(paddle.nn.Layer):
              def __init__(self):
                  super().__init__()
                  self.fc = Linear(in_features=13, out_features=1)
  
              @paddle.jit.to_static
              def forward(self, inputs):
                  x = self.fc(inputs)
                  return x
  
  
          model = Regressor()
          model.train()
          training_data, test_data = load_data()
          opt = paddle.optimizer.SGD(learning_rate=0.01, parameters=model.parameters())
          EPOCH_NUM = 10
          BATCH_SIZE = 10
          for epoch_id in range(EPOCH_NUM):
              np.random.shuffle(training_data)
              mini_batches = [
                  training_data[k : k + BATCH_SIZE]
                  for k in range(0, len(training_data), BATCH_SIZE)
              ]
              for iter_id, mini_batch in enumerate(mini_batches):
                  x = np.array(mini_batch[:, :-1]).astype("float32")
                  y = np.array(mini_batch[:, -1:]).astype("float32")
                  house_features = paddle.to_tensor(x)
                  prices = paddle.to_tensor(y)
                  predicts = model(house_features)
                  loss = F.square_error_cost(predicts, label=prices)
                  avg_loss = paddle.mean(loss)
                  if iter_id % 20 == 0:
                      print(f"epoch: {epoch_id}, iter: {iter_id}, loss is: {avg_loss.numpy()}")
                  avg_loss.backward()
                  opt.step()
                  opt.clear_grad()
          mlflow.log_param("learning_rate", 0.01)
          mlflow.paddle.log_model(model, "model")
          sk_path_dir = "./test-out"
          mlflow.paddle.save_model(model, sk_path_dir)
          print("Model saved in run %s" % mlflow.active_run().info.run_uuid)
      """
      import paddle
  
      _validate_env_arguments(
          conda_env, pip_requirements, extra_pip_requirements
      )
  
      _validate_and_prepare_target_save_path(path)
      code_dir_subpath = _validate_and_copy_code_paths(code_paths, path)
  
      if signature is None and input_example is not None:
          wrapped_model = _PaddleWrapper(pd_model)
          signature = _infer_signature_from_input_example(
              input_example, wrapped_model
          )
      elif signature is False:
          signature = None
  
      if mlflow_model is None:
          mlflow_model = Model()
      if signature is not None:
          mlflow_model.signature = signature
      if input_example is not None:
          _save_example(mlflow_model, input_example, path)
      if metadata is not None:
          mlflow_model.metadata = metadata
  
      model_data_subpath = "model"
      output_path = os.path.join(path, model_data_subpath)
  
      if isinstance(pd_model, paddle.Model):
          pd_model.save(output_path, training=training)
      else:
          paddle.jit.save(pd_model, output_path)
  
      # `PyFuncModel` only works for paddle models that define `predict()`.
      pyfunc.add_to_model(
          mlflow_model,
          loader_module="mlflow.paddle",
          model_path=model_data_subpath,
          conda_env=_CONDA_ENV_FILE_NAME,
          python_env=_PYTHON_ENV_FILE_NAME,
          code=code_dir_subpath,
      )
      mlflow_model.add_flavor(
          FLAVOR_NAME,
          pickled_model=model_data_subpath,
          paddle_version=paddle.__version__,
          code=code_dir_subpath,
      )
      mlflow_model.save(os.path.join(path, MLMODEL_FILE_NAME))
  
      if conda_env is None:
          if pip_requirements is None:
              default_reqs = get_default_pip_requirements()
              # To ensure `_load_pyfunc` can successfully load the model during the dependency
              # inference, `mlflow_model.save` must be called beforehand to save an MLmodel file.
              inferred_reqs = mlflow.models.infer_pip_requirements(
                  path,
                  FLAVOR_NAME,
                  fallback=default_reqs,
              )
              default_reqs = sorted(
                  set(inferred_reqs).union(default_reqs)
              )
          else:
              default_reqs = None
          (
              conda_env,
              pip_requirements,
              pip_constraints,
          ) = _process_pip_requirements(
              default_reqs,
              pip_requirements,
              extra_pip_requirements,
          )
      else:
          (
              conda_env,
              pip_requirements,
              pip_constraints,
          ) = _process_conda_env(conda_env)
  
      with open(os.path.join(path, _CONDA_ENV_FILE_NAME), "w") as f:
          yaml.safe_dump(conda_env, stream=f, default_flow_style=False)
  
      # Save `constraints.txt` if necessary
      if pip_constraints:
          write_to(
              os.path.join(path, _CONSTRAINTS_FILE_NAME),
              "\n".join(pip_constraints),
          )
  
      # Save `requirements.txt`
      write_to(
          os.path.join(path, _REQUIREMENTS_FILE_NAME),
          "\n".join(pip_requirements),
      )
  
      _PythonEnv.current().to_yaml(
          os.path.join(path, _PYTHON_ENV_FILE_NAME)
      )
  
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 3 for calling a global function with example usage: save_model(pd_model, path, training, conda_env, code_paths, mlflow_model, signature, input_example, pip_requirements, extra_pip_requirements, metadata) without return types