mlflow.paddle

The mlflow.paddle 模块提供用于记录和加载 paddle 模型的 API。 该模块以以下 flavors 导出 paddle 模型：

Paddle (native) format

这是可以重新加载回 paddle 的主要 flavor。

mlflow.pyfunc

为通用的基于 pyfunc 的部署工具和批量推理而生成。 注意：只有那些定义了 predict() 的 paddle 模型才会添加 mlflow.pyfunc 风格，因为 predict() 是 pyfunc 模型推理所必需的。

mlflow.paddle.autolog(log_every_n_epoch=1, log_models=True, disable=False, exclusive=False, silent=False, registered_model_name=None, extra_tags=None)

注意

已知 Autologging 与以下包版本兼容： 2.5.2 <= paddlepaddle <= 3.1.0。在与超出此范围的包版本一起使用时，Autologging 可能无法成功。

启用（或禁用）并配置从 PaddlePaddle 到 MLflow 的 autologging。

当 fit 方法（属于 paddle.Model）被调用时，会执行自动记录。

Parameters

• log_every_n_epoch – 如果指定，则每n个轮次记录一次指标。默认情况下，指标在每个轮次之后记录。

• log_models – 如果 True，训练后的模型会被记录为 MLflow 模型工件。 如果 False，训练后的模型不会被记录。

• disable – 如果 True，则禁用 PaddlePaddle 的 autologging 集成。如果 False，则启用 PaddlePaddle 的 autologging 集成。

• exclusive – 如果 True，自动记录的内容不会记录到用户创建的 fluent 运行。 如果 False，自动记录的内容会记录到活动的 fluent 运行，该运行可能是用户创建的。

• silent – 如果 True，在 PyTorch Lightning autologging 期间抑制来自 MLflow 的所有事件日志和警告。如果 False，则在 PaddlePaddle autologging 期间显示所有事件和警告。

• registered_model_name – 如果提供，每次训练模型时，会将模型注册为具有此名称的注册模型的新版本。如果该注册模型尚不存在，则会创建它。

• extra_tags – 一个字典，用于在 autologging 创建的每个托管运行上设置额外标签。

Example

import paddle
import mlflow
from mlflow import MlflowClient


def show_run_data(run_id):
    run = mlflow.get_run(run_id)
    print(f"params: {run.data.params}")
    print(f"metrics: {run.data.metrics}")
    client = MlflowClient()
    artifacts = [f.path for f in client.list_artifacts(run.info.run_id, "model")]
    print(f"artifacts: {artifacts}")


class LinearRegression(paddle.nn.Layer):
    def __init__(self):
        super().__init__()
        self.fc = paddle.nn.Linear(13, 1)

    def forward(self, feature):
        return self.fc(feature)


train_dataset = paddle.text.datasets.UCIHousing(mode="train")
eval_dataset = paddle.text.datasets.UCIHousing(mode="test")
model = paddle.Model(LinearRegression())
optim = paddle.optimizer.SGD(learning_rate=1e-2, parameters=model.parameters())
model.prepare(optim, paddle.nn.MSELoss(), paddle.metric.Accuracy())
mlflow.paddle.autolog()
with mlflow.start_run() as run:
    model.fit(train_dataset, eval_dataset, batch_size=16, epochs=10)
show_run_data(run.info.run_id)

Output

params: {
    "learning_rate": "0.01",
    "optimizer_name": "SGD",
}
metrics: {
    "loss": 17.482044,
    "step": 25.0,
    "acc": 0.0,
    "eval_step": 6.0,
    "eval_acc": 0.0,
    "eval_batch_size": 6.0,
    "batch_size": 4.0,
    "eval_loss": 24.717455,
}
artifacts: [
    "model/MLmodel",
    "model/conda.yaml",
    "model/model.pdiparams",
    "model/model.pdiparams.info",
    "model/model.pdmodel",
    "model/requirements.txt",
]

mlflow.paddle.get_default_conda_env()

Returns

默认的 Conda 环境，用于由调用 save_model() 和 log_model() 生成的 MLflow 模型。

mlflow.paddle.get_default_pip_requirements()

Returns

该列表列出了由此 flavor 生成的 MLflow Models 的默认 pip 依赖项。 对 save_model() 和 log_model() 的调用会生成一个 pip 环境，该环境至少包含这些依赖项。

mlflow.paddle.load_model(model_uri, model=None, dst_path=None, **kwargs)

从本地文件或运行中加载 paddle 模型。

Parameters

• model_uri – 以 URI 格式表示的 MLflow 模型的位置，例如： - /Users/me/path/to/local/model - relative/path/to/local/model - s3://my_bucket/path/to/model - runs://run-relative/path/to/model - models:// - models://

• model – 在加载使用 paddle.Model 并以 training=True 保存的模型时必需。

• dst_path – 要将模型工件下载到的本地文件系统路径。该目录必须已存在。如果未指定，将创建一个本地输出路径。

• kwargs – 要传递给 paddle.jit.load 或 model.load 的关键字参数。

有关受支持的 URI 方案的更多信息，请参阅 Referencing Artifacts.

Returns

一个 paddle 模型。

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)

mlflow.paddle.log_model(pd_model, artifact_path: str | None = None, training=False, conda_env=None, code_paths=None, registered_model_name=None, signature: mlflow.models.signature.ModelSignature = None, input_example: Union[pandas.core.frame.DataFrame, numpy.ndarray, dict, list, csr_matrix, csc_matrix, str, bytes, tuple] = None, await_registration_for=300, pip_requirements=None, extra_pip_requirements=None, metadata=None, name: str | None = None, params: dict[str, typing.Any] | None = None, tags: dict[str, typing.Any] | None = None, model_type: str | None = None, step: int = 0, model_id: str | None = None)

将 paddle 模型记录为当前运行的 MLflow 工件。生成一个包含以下 flavors 的 MLflow Model：

• mlflow.paddle

• mlflow.pyfunc. 注意：此 flavor 仅包含在定义 predict() 的 paddle 模型中，因为 predict() 是 pyfunc 模型推理所必需的。

Parameters

• pd_model – 要保存的 paddle 模型。

• artifact_path – 已弃用。请改用 name。

• training – 仅在使用 PaddlePaddle 高级 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 环境的字典表示，或指向 conda 环境 yaml 文件的路径。如果提供，则描述此模型应在何种环境中运行。至少，它应指定 get_default_conda_env() 中包含的依赖项。如果 None，则会将通过 mlflow.models.infer_pip_requirements() 推断的 pip 依赖添加到模型的 conda 环境中。如果依赖推断失败，则回退使用 get_default_pip_requirements。来自 conda_env 的 pip 依赖将被写入 pip requirements.txt 文件，完整的 conda 环境将被写入 conda.yaml。下面是一个 conda 环境的 示例 字典表示：

  {
      "name": "mlflow-env",
      "channels": ["conda-forge"],
      "dependencies": [
          "python=3.8.15",
          {
              "pip": [
                  "paddle==x.y.z"
              ],
          },
      ],
  }
  

• code_paths –

  本地文件系统中指向 Python 文件依赖（或包含文件依赖的目录）路径的列表。这些文件在模型加载时会被预先添加到系统路径中。如果为某个模型声明了依赖文件且多个文件之间存在导入依赖关系，那么这些文件应从一个共同的根路径声明相对导入，以避免在加载模型时发生导入错误。

  有关 code_paths 功能、推荐的使用模式和限制的详细说明，请参阅 code_paths usage guide。

• registered_model_name – 如果提供，将在 registered_model_name 下创建一个模型版本，并在不存在同名的注册模型时创建该注册模型。

• signature –

  一个 ModelSignature 类的实例，用于描述模型的输入和输出。如果未指定但提供了 input_example，则会根据提供的输入示例和模型自动推断签名。要在提供输入示例时禁用自动签名推断，请将 signature 设置为 False。要手动推断模型签名，请在具有有效模型输入，例如省略了目标列的训练数据集，以及有效模型输出，例如在训练数据集上生成的模型预测的数据集上调用 infer_signature()，例如：

  from mlflow.models import infer_signature
  
  train = df.drop_column("target_label")
  predictions = ...  # 计算模型预测
  signature = infer_signature(train, predictions)
  

• input_example – 一个或多个有效模型输入实例。输入示例用于提示应向模型提供何种数据。它将被转换为一个 Pandas DataFrame，然后使用 Pandas 的 split-oriented 格式序列化为 json，或者转换为一个 numpy array，其中示例将通过将其转换为列表的方式序列化为 json。字节使用 base64 编码。当 signature 参数为 None 时，输入示例用于推断模型签名。

• await_registration_for – 等待模型版本完成创建并处于 READY 状态的秒数。默认情况下，函数等待五分钟。指定 0 或 None 可跳过等待。

• pip_requirements – 要么是 pip 依赖字符串的可迭代对象 (例如 ["paddle", "-r requirements.txt", "-c constraints.txt"]) 或者是本地文件系统上 pip requirements 文件的字符串路径 (例如 "requirements.txt")。如果提供，这会描述该模型应运行的环境。如果 None，默认的依赖列表会由 mlflow.models.infer_pip_requirements() 从当前软件环境中推断出。如果依赖推断失败，则回退使用 get_default_pip_requirements。依赖和约束会被自动解析并分别写入 requirements.txt 和 constraints.txt 文件，并作为模型的一部分存储。依赖也会被写入模型的 conda 环境 (conda.yaml) 文件的 pip 部分。

• extra_pip_requirements –

  要么是一个 pip 需求字符串的可迭代对象（例如 ["pandas", "-r requirements.txt", "-c constraints.txt"]），要么是本地文件系统上 pip requirements 文件的字符串路径（例如 "requirements.txt"）。如果提供，该参数描述了附加的 pip 依赖，这些依赖会被追加到基于用户当前软件环境自动生成的默认 pip 依赖集合中。requirements 和 constraints 会被自动解析并分别写入 requirements.txt 和 constraints.txt 文件，并作为模型的一部分存储。依赖项也会被写入模型的 conda 环境（conda.yaml）文件的 pip 部分。

  警告

  以下参数不能同时指定：

  • conda_env

  • pip_requirements

  • extra_pip_requirements

  This example 演示了如何使用 pip_requirements 和 extra_pip_requirements 指定 pip 依赖。

• metadata – 传递给模型并存储在 MLmodel 文件中的自定义元数据字典。

• name – 模型名称。

• params – 一个用于与模型一同记录的参数字典。

• tags – 一个要与模型一起记录的标签字典。

• model_type – 模型的类型。

• step – 在该步记录模型输出和指标

• model_id – 模型的 ID。

Returns

一个 ModelInfo 实例，包含已记录模型的元数据。

Example

import mlflow.paddle


def load_data(): ...


class Regressor: ...


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):
    ...
mlflow.log_param("learning_rate", 0.01)
mlflow.paddle.log_model(model, name="model")
sk_path_dir = ...
mlflow.paddle.save_model(model, sk_path_dir)

mlflow.paddle.save_model(pd_model, path, training=False, conda_env=None, code_paths=None, mlflow_model=None, signature: mlflow.models.signature.ModelSignature = None, input_example: Union[pandas.core.frame.DataFrame, numpy.ndarray, dict, list, csr_matrix, csc_matrix, str, bytes, tuple] = None, pip_requirements=None, extra_pip_requirements=None, metadata=None)

将 paddle 模型保存到本地文件系统的某个路径。生成一个包含以下 flavors 的 MLflow Model：

• mlflow.paddle

• mlflow.pyfunc. 注意：该 flavor 仅包含在定义 predict() 的 paddle 模型中，因为 predict() 是 pyfunc 模型推理所必需的。

Parameters

• pd_model – 要保存的 paddle 模型。

• path – 模型要保存的本地路径。

• training – 仅在使用 PaddlePaddle 高层 API 保存已训练模型时有效。如果设置为 True，保存的模型同时支持重新训练和推理。如果设置为 False，则仅支持推理。

• conda_env –

  要么是 Conda 环境的字典表示，要么是指向 conda 环境 yaml 文件的路径。如果提供，则描述应在该环境中运行此模型。至少，它应指定位于 get_default_conda_env() 中的依赖项。如果 None，会将一个带有由 mlflow.models.infer_pip_requirements() 推断的 pip 依赖项的 conda 环境添加到模型中。如果依赖推断失败，则回退使用 get_default_pip_requirements。来自 conda_env 的 pip 依赖会写入 pip requirements.txt 文件，而完整的 conda 环境会写入 conda.yaml。以下是一个 示例 的 conda 环境字典表示：

  {
      "name": "mlflow-env",
      "channels": ["conda-forge"],
      "dependencies": [
          "python=3.8.15",
          {
              "pip": [
                  "paddle==x.y.z"
              ],
          },
      ],
  }
  

• code_paths –

  本地文件系统中指向 Python 文件依赖（或包含文件依赖的目录）路径的列表。这些文件在模型加载时会被预先添加到系统路径中。如果为某个模型声明了依赖文件且多个文件之间存在导入依赖关系，那么这些文件应从一个共同的根路径声明相对导入，以避免在加载模型时发生导入错误。

  有关 code_paths 功能、推荐的使用模式和限制的详细说明，请参阅 code_paths usage guide。

• mlflow_model – mlflow.models.Model 此 flavor 正在被添加到。

• signature –

  一个 ModelSignature 类的实例，用于描述模型的输入和输出。如果未指定但提供了 input_example，则会根据提供的输入示例和模型自动推断签名。要在提供输入示例时禁用自动签名推断，请将 signature 设置为 False。要手动推断模型签名，请在具有有效模型输入，例如省略了目标列的训练数据集，以及有效模型输出，例如在训练数据集上生成的模型预测的数据集上调用 infer_signature()，例如：

  from mlflow.models import infer_signature
  
  train = df.drop_column("target_label")
  predictions = ...  # 计算模型预测
  signature = infer_signature(train, predictions)
  

• input_example – 一个或多个有效模型输入实例。输入示例用于提示应向模型提供何种数据。它将被转换为一个 Pandas DataFrame，然后使用 Pandas 的 split-oriented 格式序列化为 json，或者转换为一个 numpy array，其中示例将通过将其转换为列表的方式序列化为 json。字节使用 base64 编码。当 signature 参数为 None 时，输入示例用于推断模型签名。

• pip_requirements – 可以是 pip 依赖字符串的可迭代对象 (例如 ["paddle", "-r requirements.txt", "-c constraints.txt"]) 或者是本地文件系统上 pip 要求文件的字符串路径（例如 "requirements.txt"）。如果提供，该字段描述了应在其上运行此模型的环境。如果 None，默认的依赖列表将由 mlflow.models.infer_pip_requirements() 从当前软件环境中推断。如果依赖推断失败，则回退使用 get_default_pip_requirements。依赖和约束会被自动解析并分别写入 requirements.txt 和 constraints.txt 文件，并作为模型的一部分存储。依赖还会被写入模型的 pip 部分的 conda 环境（conda.yaml）文件。

• extra_pip_requirements –

  要么是一个 pip 需求字符串的可迭代对象（例如 ["pandas", "-r requirements.txt", "-c constraints.txt"]），要么是本地文件系统上 pip requirements 文件的字符串路径（例如 "requirements.txt"）。如果提供，该参数描述了附加的 pip 依赖，这些依赖会被追加到基于用户当前软件环境自动生成的默认 pip 依赖集合中。requirements 和 constraints 会被自动解析并分别写入 requirements.txt 和 constraints.txt 文件，并作为模型的一部分存储。依赖项也会被写入模型的 conda 环境（conda.yaml）文件的 pip 部分。

  警告

  以下参数不能同时指定：

  • conda_env

  • pip_requirements

  • extra_pip_requirements

  This example 演示了如何使用 pip_requirements 和 extra_pip_requirements 指定 pip 依赖。

• metadata – 传递给模型并存储在 MLmodel 文件中的自定义元数据字典。

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, name="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_id)