mlflow.models

mlflow.models 模块提供了一个 API，用于以“风格”保存机器学习模型，以便不同的下游工具能够理解。

内置的风格有

有关详细信息，请参阅 MLflow 模型指南。

class mlflow.models.EvaluationArtifact(uri, content=None)[source]

Bases: object

一个模型评估的产物，包含产物 URI 和内容。

property content: 产物的具体内容（表示方式可能不同）。

property uri: str: 产物的 URI。

class mlflow.models.EvaluationResult(metrics, artifacts, run_id=None)[source]

Bases: object

表示 mlflow.evaluate() API 调用产生的模型评估输出，包含标量指标和输出产物（如性能图）。

property artifacts: dict[str, 'mlflow.models.EvaluationArtifact']: 一个字典，将标准化产物名称（例如，“roc_data”）映射到产物内容和位置信息。

classmethod load(path)[source]: 从指定的本地文件系统路径加载评估结果。

property metrics: dict[str, typing.Any]: 一个字典，将标量指标名称映射到标量指标值。

property run_id: str: 评估结果所记录的 MLflow 运行的 ID。

save(path)[source]: 将评估结果写入指定的本地文件系统路径。

property tables: dict[str, 'pd.DataFrame']: 一个字典，将标准化产物名称（例如，“eval_results_table”）映射到对应的表格内容（pandas DataFrame）。

class mlflow.models.FlavorBackend(config, **kwargs)[source]

Bases: object

风格后端抽象类。该类定义了 MLflow 模型风格的本地模型部署的 API 接口。

abstract build_image(model_uri, image_name, install_java=False, install_mlflow=False, mlflow_home=None, enable_mlserver=False, base_image=None)[source]

can_build_image()[source]

返回: 如果此风格具有用于构建能够服务模型的 Docker 容器的 build_image 方法，则返回 True，否则返回 False。

abstract can_score_model()[source]

检查此风格后端是否可以在当前环境中部署。

返回: 如果此风格后端可以在当前环境中应用，则返回 True。

abstract generate_dockerfile(model_uri, output_dir, install_java=False, install_mlflow=False, mlflow_home=None, enable_mlserver=False, base_image=None)[source]

abstract predict(model_uri, input_path, output_path, content_type)[source]

使用指定的 URI 指向的已保存 MLflow 模型生成预测。输入和输出从文件或标准输入/输出读取和写入。

参数

model_uri – 指向要用于评分的 MLflow 模型的 URI。
input_path – 输入数据文件的路径。如果未指定，则从标准输入读取数据。
output_path – 输出预测文件的路径。如果未指定，则将数据写入标准输出。
content_type – 指定输入格式。可以是 {json, csv} 之一。

prepare_env(model_uri, capture_output=False)[source]: 执行预测或服务模型所需的任何准备工作，例如下载依赖项或初始化 conda 环境。准备完成后，调用 predict 或 serve 应该会很快。

abstract serve(model_uri, port, host, timeout, enable_mlserver, synchronous=True, stdout=None, stderr=None)[source]

在本地服务指定的 MLflow 模型。

参数

model_uri – 指向要用于评分的 MLflow 模型的 URI。
port – 用于模型部署的端口。
host – 用于模型部署的主机。默认为 localhost。
timeout – 服务请求的超时时间（秒）。默认为 60。
enable_mlserver – 是否使用 MLServer 或本地评分服务器。
synchronous – 如果为 True，则等待服务器进程退出并返回 0，如果进程以非零返回码退出，则引发异常。如果为 False，则立即返回服务器进程 Popen 实例。
stdout – 重定向服务器标准输出。
stderr – 重定向服务器标准错误。

class mlflow.models.MetricThreshold(threshold=None, min_absolute_change=None, min_relative_change=None, greater_is_better=None)[source]

Bases: object

此类允许您定义模型验证的指标阈值。允许的阈值包括：threshold、min_absolute_change、min_relative_change。

参数

threshold –
(可选) 一个数字，表示指标的值阈值。
- 如果指标的值越大越好，则指标值必须 >= threshold 才能通过验证。
- 否则，指标值必须 <= threshold 才能通过验证。
min_absolute_change –
(可选) 一个正数，表示候选模型与基线模型进行比较时必须满足的最小绝对变化才能通过验证。
- 如果指标的值越大越好，则指标值必须 >= 基线模型指标值 + min_absolute_change 才能通过验证。
- 否则，指标值必须 <= 基线模型指标值 - min_absolute_change 才能通过验证。
min_relative_change –
(可选) 一个介于 0 和 1 之间的浮点数，表示候选模型与基线模型进行比较时必须满足的最小相对变化（以基线模型指标值的百分比表示）。
- 如果指标的值越大越好，则指标值必须 >= 基线模型指标值 * (1 + min_relative_change)
- 否则，指标值必须 <= 基线模型指标值 * (1 - min_relative_change)
- 请注意，如果基线模型指标值为 0，则阈值会回退到执行简单的验证，即候选指标值优于基线指标值。如果越大越好，则指标值 >= 基线模型指标值 + 1e-10；如果越小越好，则指标值 <= 基线模型指标值 - 1e-10。
greater_is_better – 一个必需的布尔值，表示指标的值越大越好。

property greater_is_better: 一个布尔值，表示指标的值越大越好。

property min_absolute_change: 与基线模型进行模型比较时，为通过比较所需的最小绝对变化值。

property min_relative_change: 与基线模型进行模型比较时，为通过比较所需的最小相对变化值的浮点数。

property threshold: 阈值的值。

class mlflow.models.Model(artifact_path=None, run_id=None, utc_time_created=None, flavors=None, signature=None, saved_input_example_info: Optional[dict[str, typing.Any]] = None, model_uuid: Optional[Union[str, Callable[[], str]]] = <function Model.<lambda>>, mlflow_version: str | None = '3.8.0', metadata: Optional[dict[str, typing.Any]] = None, model_size_bytes: Optional[int] = None, resources: Optional[Union[str, list[mlflow.models.resources.Resource]]] = None, env_vars: Optional[list[str]] = None, auth_policy: Optional[mlflow.models.auth_policy.AuthPolicy] = None, model_id: Optional[str] = None, prompts: Optional[list[str]] = None, **kwargs)[source]

Bases: object

一个 MLflow 模型，可以支持多种模型风格。提供实现新模型风格的 API。

add_flavor(name, **params) → mlflow.models.model.Model[source]: 添加一个条目，说明如何以给定格式服务模型。

property auth_policy: dict[str, dict[str, typing.Any]]

一个可选的字典，其中包含服务模型所需的身份验证策略。

Getter: 检索服务模型所需的身份验证策略。
Setter: 设置服务模型所需的身份验证策略。
类型: Dict[str, dict]

property env_vars: list[str] | None

classmethod from_dict(model_dict) → mlflow.models.model.Model[source]: 从其 YAML 表示加载模型。

get_input_schema()[source]: 检索模型的输入模式，前提是模型已保存了模式定义。

get_model_info(logged_model: Optional[LoggedModel] = None) → mlflow.models.model.ModelInfo[source]: 创建一个 ModelInfo 实例，其中包含模型元数据。

get_output_schema()[source]: 检索模型的输出模式，前提是模型已保存了模式定义。

get_params_schema()[source]: 检索模型的参数模式，前提是模型已保存了模式定义。

get_serving_input(path: str) → str | None[source]

从模型目录加载服务输入示例。如果没有服务输入示例，则返回 None。

参数: path – 模型目录的路径。
返回: 服务输入示例或 None，如果模型没有服务输入示例。

get_tags_dict() → dict[str, typing.Any][source]

classmethod load(path) → mlflow.models.model.Model[source]

从其 YAML 表示加载模型。

参数: path – 指向 Model 对象的 MLmodel YAML 文件表示的本地文件系统路径或 URI，或者指向包含 MLmodel YAML 文件表示的目录。
返回: Model 对象的一个实例。

示例

from mlflow.models import Model

# Load the Model object from a local MLmodel file
model1 = Model.load("~/path/to/my/MLmodel")

# Load the Model object from a remote model directory
model2 = Model.load("s3://mybucket/path/to/my/model")

load_input_example(path: Optional[str] = None) → str | None[source]

加载与模型一起保存的输入示例。如果模型没有示例元数据（即模型保存时没有示例），则返回 None。如果存在模型元数据但示例文件丢失，则引发 FileNotFoundError。

参数: path – 模型或运行 URI，或指向 model 目录的路径。例如：models://<model_name>/<model_version>、runs:/<run_id>/<artifact_path> 或 /path/to/model
返回: 输入示例（NumPy ndarray、SciPy csc_matrix、SciPy csr_matrix、pandas DataFrame、dict）或 None，如果模型没有示例。

load_input_example_params(path: str)[source]

加载与模型一起保存的输入示例的参数。如果 input_example 中没有参数，则返回 None。

参数: path – 模型目录的路径。
返回: params（dict）或 None，如果模型没有参数。

classmethod log(artifact_path, flavor, registered_model_name=None, await_registration_for=300, metadata=None, run_id=None, resources=None, auth_policy=None, prompts=None, name: Optional[str] = None, model_type: Optional[str] = None, params: Optional[dict[str, typing.Any]] = None, tags: Optional[dict[str, typing.Any]] = None, step: int = 0, model_id: Optional[str] = None, **kwargs) → mlflow.models.model.ModelInfo[source]

使用提供的风格模块记录模型。如果当前没有活动的运行，此方法将创建一个新的活动运行。

参数

artifact_path – Deprecated. Use name instead.
flavor – 用于保存模型的风格模块。该模块必须具有 save_model 函数，该函数会将模型持久化为有效的 MLflow 模型。
registered_model_name – 如果提供，则在 registered_model_name 下创建一个模型版本，如果给定名称的注册模型不存在，也会创建该注册模型。
await_registration_for – 等待模型版本完成创建并处于 READY 状态的秒数。默认情况下，函数等待五分钟。指定 0 或 None 可跳过等待。
metadata – {{ metadata }}
run_id – 与此模型关联的运行 ID。
resources – {{ resources }}
auth_policy – {{ auth_policy }}
prompts – {{ prompts }}
name – 模型的名称。
model_type – {{ model_type }}
params – {{ params }}
tags – {{ tags }}
step – {{ step }}
model_id – {{ model_id }}
kwargs – 传递给模型的额外参数。

返回

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

property metadata: dict[str, typing.Any] | None

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

Getter: 检索已应用于模型实例的自定义元数据。
Setter: 设置一个自定义键值对字典，以包含在模型实例中。
类型: Optional[Dict[str, Any]]
返回: 如果定义了，则为用户定义的元数据字典。

示例

# Create and log a model with metadata to the Model Registry
from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
import mlflow
from mlflow.models import infer_signature

with mlflow.start_run():
    iris = datasets.load_iris()
    clf = RandomForestClassifier()
    clf.fit(iris.data, iris.target)
    signature = infer_signature(iris.data, iris.target)
    mlflow.sklearn.log_model(
        clf,
        name="iris_rf",
        signature=signature,
        registered_model_name="model-with-metadata",
        metadata={"metadata_key": "metadata_value"},
    )

# model uri for the above model
model_uri = "models:/model-with-metadata/1"

# Load the model and access the custom metadata
model = mlflow.pyfunc.load_model(model_uri=model_uri)
assert model.metadata.metadata["metadata_key"] == "metadata_value"

property model_size_bytes: int | None

一个可选的整数，表示模型大小（以字节为单位）。

Getter: 检索模型保存时计算出的模型大小。
Setter: 为模型实例设置模型大小。
类型: Optional[int]

property resources: dict[str, dict[mlflow.models.resources.ResourceType, list[dict[str, typing.Any]]]]

一个可选的字典，其中包含服务模型所需的资源。

Getter: 检索服务模型所需的资源。
Setter: 设置服务模型所需的资源。
类型: Dict[str, Dict[ResourceType, List[Dict]]]

save(path) → None[source]: 将模型写入本地 YAML 文件。

property saved_input_example_info: dict[str, typing.Any] | None: 一个包含已保存输入示例元数据的字典，例如 {"artifact_path": "input_example.json", "type": "dataframe", "pandas_orient": "split"}。

property signature

模型对象预期输入和输出的可选定义，包含字段名和数据类型。签名支持基于列和基于张量的输入和输出。

Getter: 检索模型实例的签名（如果模型已保存签名定义）。
Setter: 为模型实例设置签名。
类型: Optional[ModelSignature]

to_dict() → dict[str, typing.Any][source]: 将模型序列化为字典。

to_json() → str[source]: 将模型写入 JSON。

to_yaml(stream=None) → str[source]: 将模型写入 YAML 字符串。

class mlflow.models.ModelConfig(*, development_config: Optional[Union[str, dict[str, typing.Any]]] = None)[source]

Bases: object

ModelConfig 用于在代码中读取 YAML 配置文件或字典。

参数: development_config – YAML 配置文件路径或包含配置的字典。如果未提供配置，则会引发错误。

在模型代码中的使用示例

from mlflow.models import ModelConfig

# Load the configuration from a dictionary
config = ModelConfig(development_config={"key1": "value1"})
print(config.get("key1"))

模型配置的 yaml 文件

key1: value1
another_key:
    - value2
    - value3

模型代码中的 yaml 用法示例

from mlflow.models import ModelConfig

# Load the configuration from a file
config = ModelConfig(development_config="config.yaml")
print(config.get("key1"))

当在模型文件中本地调用 ModelConfig 时，可以传递 development_config，它将用作模型的配置。

示例：在记录模型代码时使用 ModelConfig： agent.py

import mlflow
from mlflow.models import ModelConfig

config = ModelConfig(development_config={"key1": "value1"})

class TestModel(mlflow.pyfunc.PythonModel):
    def predict(self, context, model_input, params=None):
        return config.get("key1")

mlflow.models.set_model(TestModel())

但是，在记录模型时，此 development_config 配置文件将被覆盖。当在记录模型时未传递 model_config 时，尝试使用 ModelConfig 加载模型时会引发错误。注意：development_config 在记录模型时不使用。

示例：使用 agent.py 记录模型： deploy.py

model_config = {"key1": "value2"}
with mlflow.start_run():
    model_info = mlflow.pyfunc.log_model(
        name="model", python_model="agent.py", model_config=model_config
    )

loaded_model = mlflow.pyfunc.load_model(model_info.model_uri)

# This will print "value2" as the model_config passed in while logging the model
print(loaded_model.predict(None))

get(key)[source]: 获取配置中顶级参数的值。

to_dict()[source]: 将配置作为字典返回。

class mlflow.models.ModelSignature(inputs: Optional[Union[mlflow.types.schema.Schema, Any]] = None, outputs: Optional[Union[mlflow.types.schema.Schema, Any]] = None, params: Optional[mlflow.types.schema.ParamSchema] = None)[source]

Bases: object

ModelSignature 指定模型输入、输出和参数的模式。

ModelSignature 可以通过训练数据集 推断、使用模型预测和推断参数，或者通过传递输入和输出 Schema 和参数 ParamSchema 手动构造。

classmethod from_dict(signature_dict: dict[str, typing.Any])[source]

从字典表示形式反序列化。

参数: signature_dict – 模型签名的字典表示形式。预期的字典格式： {‘inputs’: <json 字符串>, ‘outputs’: <json 字符串>, ‘params’: <json 字符串>” }
返回: 使用字典数据填充的 ModelSignature。

to_dict() → dict[str, typing.Any][source]

序列化为“jsonable”字典。

输入和输出模式表示为 json 字符串。这样可以在 MLmodel yaml 文件中嵌入时使其紧凑。

返回: 输入和输出模式表示为 json 字符串的字典表示形式。

class mlflow.models.Resource[source]

Bases: abc.ABC

定义服务模型所需资源的基类。

参数

type (ResourceType) – 资源类型。
target_uri (str) – 资源托管的目标 URI。

abstract classmethod from_dict(data: dict[str, str])[source]: 将字典转换为 Resource。子类必须实现此方法。

abstract property target_uri: str: 资源托管的目标 URI（必须由子类定义）。

abstract to_dict()[source]: 将资源转换为字典。子类必须实现此方法。

abstract property type: mlflow.models.resources.ResourceType: 资源类型（必须由子类定义）。

class mlflow.models.ResourceType(value)[source]

Bases: enum.Enum

定义服务模型所需不同类型资源的枚举。

APP = 'app'

FUNCTION = 'function'

GENIE_SPACE = 'genie_space'

LAKEBASE = 'lakebase'

SERVING_ENDPOINT = 'serving_endpoint'

SQL_WAREHOUSE = 'sql_warehouse'

TABLE = 'table'

UC_CONNECTION = 'uc_connection'

VECTOR_SEARCH_INDEX = 'vector_search_index'

mlflow.models.add_libraries_to_model(model_uri, run_id=None, registered_model_name=None)[source]

给定一个注册的模型 URI（例如 models://），此实用程序会将模型与所有必需的模型库一起重新记录到模型注册表中。必需的模型库作为模型工件与模型一起存储。此外，模型（例如 conda.yaml、requirements.txt）的支持文件将被修改以使用添加的库。

默认情况下，此实用程序会在 model_uri 指定的同一注册模型下创建一个新的模型版本。可以通过指定 registered_model_name 参数来覆盖此行为。

参数

model_uri – 模型注册表中格式为 models:// 的注册模型 URI。
run_id – 记录带有库的模型所在的运行 ID。如果为 None，则带有库的模型将记录到由 model_uri 指定的模型版本的源运行；如果模型版本没有源运行，则创建一个新运行。
registered_model_name – 新模型版本（带有库的模型）将在此输入的 registered_model_name 下注册。如果为 None，则将新版本记录到模型注册表中的现有模型。

注意

此实用程序仅适用于已注册到模型注册表中的模型。

注意

库仅与添加它们的平台兼容。不支持跨平台库。

示例

# Create and log a model to the Model Registry
import pandas as pd
from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
import mlflow
import mlflow.sklearn
from mlflow.models import infer_signature

with mlflow.start_run():
    iris = datasets.load_iris()
    iris_train = pd.DataFrame(iris.data, columns=iris.feature_names)
    clf = RandomForestClassifier(max_depth=7, random_state=0)
    clf.fit(iris_train, iris.target)
    signature = infer_signature(iris_train, clf.predict(iris_train))
    mlflow.sklearn.log_model(
        clf,
        name="iris_rf",
        signature=signature,
        registered_model_name="model-with-libs",
    )

# model uri for the above model
model_uri = "models:/model-with-libs/1"

# Import utility
from mlflow.models.utils import add_libraries_to_model

# Log libraries to the original run of the model
add_libraries_to_model(model_uri)

# Log libraries to some run_id
existing_run_id = "21df94e6bdef4631a9d9cb56f211767f"
add_libraries_to_model(model_uri, run_id=existing_run_id)

# Log libraries to a new run
with mlflow.start_run():
    add_libraries_to_model(model_uri)

# Log libraries to a new registered model named 'new-model'
with mlflow.start_run():
    add_libraries_to_model(model_uri, registered_model_name="new-model")

mlflow.models.build_docker(model_uri=None, name='mlflow-pyfunc', env_manager='virtualenv', mlflow_home=None, install_java=False, install_mlflow=False, enable_mlserver=False, base_image=None)[source]

构建一个 Docker 镜像，其默认入口点使用 python_function 风格在端口 8080 上服务 MLflow 模型。容器服务由 model_uri 引用（如果已指定）的模型。如果未指定 model_uri，则必须将 MLflow 模型目录作为卷挂载到容器内的 /opt/ml/model 目录。

重要提示

自 MLflow 2.10.1 起，使用 --model-uri 构建的 Docker 镜像不会安装 Java 以提高性能，除非模型风格是 ["johnsnowlabs", "h2o" "spark"] 之一。如果您需要为其他风格安装 Java，例如使用 SparkML 的自定义 Python 模型，请指定 install-java=True 来强制安装 Java。对于早期版本，Java 始终安装到镜像中。

警告

如果未指定 model_uri，则生成的镜像不支持使用 RFunc 服务器服务模型。

注意：默认情况下，容器将启动 nginx 和 uvicorn 进程。如果您不需要启动 nginx 进程（例如，如果您将容器部署到 Google Cloud Run），可以通过环境变量 DISABLE_NGINX 来禁用它。

docker run -p 5001:8080 -e DISABLE_NGINX=true "my-image-name"

有关“python_function”风格的更多信息，请参阅 https://www.mlflow.org/docs/latest/python_api/mlflow.pyfunc.html。

参数

model_uri – 模型 URI。本地路径、“runs:/” URI 或远程存储 URI（例如，“s3://” URI）。有关模型工件支持的远程 URI 的更多信息，请参阅 https://mlflow.org.cn/docs/latest/tracking.html#artifact-stores。
name – 要构建的 Docker 镜像的名称。默认为“mlflow-pyfunc”。
env_manager – 如果指定，则使用指定的环境管理器为 MLmodel 创建环境。支持以下值：（1）virtualenv（默认）：使用 virtualenv 和 pyenv 进行 Python 版本管理（2）conda：使用 conda（3）local：使用本地环境而不创建新环境。
mlflow_home – MLflow 项目的本地克隆路径。仅用于开发。
install_java – 如果指定，则在镜像中安装 Java。默认值为 False，以减小镜像大小和构建时间。需要 Java 的模型风格将自动启用此设置，例如 Spark 风格。（此参数仅在 MLflow 2.10.1 及更高版本中可用。在早期版本中，Java 始终安装到镜像中。）
install_mlflow – 如果指定并且存在要激活的 conda 或 virtualenv 环境，则在激活后会将 mlflow 安装到环境中。安装的 mlflow 版本将与调用此命令时使用的版本相同。
enable_mlserver – 如果指定，则镜像将使用 Seldon MLserver 作为后端构建。
base_image – Docker 镜像的基础镜像。如果未指定，则默认镜像为 UBUNTU_BASE_IMAGE = “ubuntu:22.04” 或 PYTHON_SLIM_BASE_IMAGE = “python:{version}-slim” 注意：如果使用自定义镜像，不保证镜像能够正常工作。您可能会发现构建在 ubuntu 镜像之上的镜像具有更高的兼容性。此外，您必须安装 Java 和 virtualenv 才能使镜像正常工作。

mlflow.models.convert_input_example_to_serving_input(input_example) → str | None[source]

用于将模型的输入示例转换为可用于评分服务器的模型推理的服务输入示例的辅助函数。

参数: input_example – 模型输入示例。支持的类型有 pandas.DataFrame、numpy.ndarray、(name -> numpy.ndarray) 的字典、list、标量和具有 json 可序列化值的 dict。
返回: 作为 json 字符串的服务输入示例。

mlflow.models.evaluate(model=None, data=None, *, model_type=None, targets=None, predictions=None, dataset_path=None, feature_names=None, evaluators=None, evaluator_config=None, extra_metrics=None, custom_artifacts=None, env_manager='local', model_config=None, inference_params=None, model_id=None, _called_from_genai_evaluate=False)[source]

在给定数据和选定指标上评估模型性能。

此函数使用指定的 evaluators 在指定数据集上评估 PyFunc 模型或自定义可调用对象，并将结果指标和工件记录到 MLflow 跟踪服务器。用户也可以跳过设置 model，直接在 data 中放置模型输出来进行评估。有关详细信息，请阅读模型评估文档。

默认评估器行为

默认评估器（可以通过 evaluators="default" 或 evaluators=None 调用）支持下面列出的模型类型。对于每种预定义的模型类型，默认评估器都会在选定的指标集上评估您的模型，并生成图等工件。请在下面查找更多详细信息。
对于“regressor”和“classifier”模型类型，默认评估器都会使用 SHAP 生成模型摘要图和特征重要性图。
对于回归模型，默认评估器还会记录
- metrics: example_count, mean_absolute_error, mean_squared_error, root_mean_squared_error, sum_on_target, mean_on_target, r2_score, max_error, mean_absolute_percentage_error。
对于二元分类模型，默认评估器还会记录
- 指标: 真阴性 (true_negatives), 假阳性 (false_positives), 假阴性 (false_negatives), 真阳性 (true_positives), 召回率 (recall), 精确率 (precision), F1 分数 (f1_score), 准确率 (accuracy_score), 样本数 (example_count), 对数损失 (log_loss), ROC AUC (roc_auc), 精确率-召回率 AUC (precision_recall_auc)。
- 产出物: 提升曲线图 (lift curve plot), 精确率-召回率曲线图 (precision-recall plot), ROC 曲线图 (ROC plot)。
对于多类别分类器，默认的评估器还会记录
- 指标: 准确率 (accuracy_score), 样本数 (example_count), 微平均 F1 分数 (f1_score_micro), 宏平均 F1 分数 (f1_score_macro), 对数损失 (log_loss)
- 产出物: 一个 CSV 文件用于“每类指标” (per-class metrics)，包括真阴性/假阳性/假阴性/真阳性/召回率/精确率/ROC AUC, 精确率-召回率合并曲线图 (precision-recall merged curves plot), ROC 合并曲线图 (ROC merged curves plot)。
对于问答模型，默认的评估器记录
- 指标: exact_match (精确匹配), token_count (词元数), toxicity (毒性)（需要安装 evaluate, torch）, flesch_kincaid_grade_level (弗莱什-金凯德阅读级别)（需要安装 textstat）和 ari_grade_level (ARI 阅读级别)。
- 产出物: 一个 JSON 文件，其中包含模型的输入、输出、目标（如果提供了 targets 参数），以及每行的指标，以表格形式呈现。
对于文本摘要模型，默认的评估器记录
- 指标: token_count (词元数), ROUGE (需要安装 evaluate, nltk, 和 rouge_score）, toxicity (毒性)（需要安装 evaluate, torch, transformers）, ari_grade_level (ARI 阅读级别)（需要安装 textstat）, flesch_kincaid_grade_level (弗莱什-金凯德阅读级别)（需要安装 textstat）。
- 产出物: 一个 JSON 文件，其中包含模型的输入、输出、目标（如果提供了 targets 参数），以及每行的指标，以表格形式呈现。
对于文本模型，默认的评估器记录
- 指标: token_count (词元数), toxicity (毒性)（需要安装 evaluate, torch, transformers）, ari_grade_level (ARI 阅读级别)（需要安装 textstat）, flesch_kincaid_grade_level (弗莱什-金凯德阅读级别)（需要安装 textstat）。
- 产出物: 一个 JSON 文件，其中包含模型的输入、输出、目标（如果提供了 targets 参数），以及每行的指标，以表格形式呈现。
对于检索模型，默认的评估器记录
- 指标: precision_at_k(k) (k 精度), recall_at_k(k) (k 召回率) 和 ndcg_at_k(k) (k NDCG) - 所有指标的默认值为 retriever_k = 3。
- 产出物: 一个 JSON 文件，其中包含模型的输入、输出、目标以及每行的指标，以表格形式呈现。
对于 sklearn 模型，默认的评估器还会记录通过 model.score 方法计算出的模型的评估标准（例如，分类器的平均准确率）。
上述列出的指标/产出物将被记录到当前激活的 MLflow 运行中。如果不存在活动的运行，则会创建一个新的 MLflow 运行来记录这些指标和产出物。
此外，关于指定的数据集的信息 - 哈希值、名称（如果指定）、路径（如果指定）以及评估它的模型的 UUID - 将被记录到 mlflow.datasets 标签中。
默认评估器的可用 evaluator_config 选项包括：
- log_model_explainability: 一个布尔值，指定是否记录模型可解释性洞察，默认值为 True。
- log_explainer: 如果为 True，则记录用于计算模型可解释性的 explainer。
  洞察作为模型。默认值为 False。
- explainability_algorithm: 一个字符串，用于指定模型可解释性的 SHAP Explainer 算法。支持的算法包括：'exact' (精确), 'permutation' (置换), 'partition' (划分), 'kernel' (核)。如果未设置，将使用具有“auto”（自动）算法的 shap.Explainer，它会根据模型选择最佳的 Explainer。
- explainability_nsamples: 用于计算模型可解释性洞察的样本行数。默认值为 2000。
- explainability_kernel_link: shap kernel explainer 使用的核链接函数。可用值为 "identity"（恒等）和 "logit"。默认值为 "identity"。
- max_classes_for_multiclass_roc_pr: 对于多类别分类任务，记录每类 ROC 曲线和精确率-召回率曲线的最大类别数。如果类别数大于配置的最大值，则不记录这些曲线。
- metric_prefix: 一个可选的前缀，在评估过程中生成的每个指标和产出物的名称前添加。
- log_metrics_with_dataset_info: 一个布尔值，指定在评估过程中是否将评估数据集的信息包含在记录到 MLflow Tracking 的每个指标的名称中，默认值为 True。
- pos_label: 如果指定，则为二元分类模型计算精确率、召回率、F1 等分类指标时使用的正类标签。对于多类别分类和回归模型，此参数将被忽略。
- average: 对于多类别分类模型，计算精确率、召回率、F1 等分类指标时使用的平均方法（默认值：'weighted'）。对于二元分类和回归模型，此参数将被忽略。
- sample_weights: 计算模型性能指标时应用于每个样本的权重。
- col_mapping: 一个字典，将输入数据集或输出预测中的列名映射到调用评估函数时使用的列名。
- retriever_k: 在 model_type="retriever" 时使用的参数，表示在计算内置指标 precision_at_k(k), recall_at_k(k) 和 ndcg_at_k(k) 时使用的 top-ranked 检索文档数量。默认值为 3。对于所有其他模型类型，此参数将被忽略。
评估数据集的局限性
- 对于分类任务，数据集标签用于推断总类别数。
- 对于二元分类任务，负类标签值必须是 0 或 -1 或 False，正类标签值必须是 1 或 True。
指标/产出物计算的局限性
- 对于分类任务，某些指标和产出物的计算需要模型输出类别概率。目前，对于 scikit-learn 模型，默认评估器会调用底层模型的 predict_proba 方法来获取概率。对于其他模型类型，默认评估器不计算需要概率输出的指标/产出物。
默认评估器记录模型可解释性洞察的局限性
- shap.Explainer 的 auto 算法对线性模型使用 Linear explainer，对树模型使用 Tree explainer。由于 SHAP 的 Linear 和 Tree explainers 不支持多类别分类，因此对于多类别分类任务，默认评估器会回退到使用 Exact 或 Permutation explainers。
- 目前不支持为 PySpark 模型记录模型可解释性洞察。
- 评估数据集的标签值必须是数值型或布尔型，所有特征值必须是数值型，并且每个特征列只能包含标量值。
启用环境恢复时的局限性
- 当为被评估模型启用环境恢复时（即指定了非本地的 env_manager），模型将被加载为一个客户端，该客户端在一个独立的 Python 环境中调用 MLflow 模型评分服务器进程，并安装模型的训练时依赖项。因此，模型的 predict_proba 方法（用于概率输出）或 score 方法（用于计算 sklearn 模型的评估标准）将变得不可访问，默认评估器也不会计算需要这些方法的指标或产出物。
- 由于模型是 MLflow 模型服务器进程，SHAP 解释的计算速度会变慢。因此，当指定了非本地 env_manager 时，模型可解释性将被禁用，除非 evaluator_config 选项 **log_model_explainability** 被明确设置为 True。

参数

model –
可选。如果指定，应为以下之一：
- 一个 pyfunc 模型实例
- 指向 pyfunc 模型的 URI
- 指向 MLflow Deployments 端点的 URI，例如 "endpoints:/my-chat"
- 一个可调用函数：此函数应能够接受模型输入并返回预测。它应遵循 predict 方法的签名。以下是一个有效函数的示例：
```
model = mlflow.pyfunc.load_model(model_uri)


def fn(model_input):
    return model.predict(model_input)
```
如果省略，则表示将使用静态数据集进行评估而不是模型。在这种情况下，data 参数必须是包含模型输出的 Pandas DataFrame 或 mlflow PandasDataset，并且 predictions 参数必须是 data 中包含模型输出的列的名称。
data –
以下之一：
- 一个 numpy 数组或评估特征列表，不包括标签。
- 一个包含评估特征、标签和可选模型输出的 Pandas DataFrame。
  在模型未指定时，模型输出是必需的。如果未指定 feature_names 参数，则除标签列和预测列之外的所有列都将被视为特征列。否则，只有 feature_names 中存在的列名才被视为特征列。
- 一个包含评估特征和标签的 Spark DataFrame。如果
  未指定 feature_names 参数，则除标签列外的所有列都将被视为特征列。否则，只有 feature_names 中存在的列名才被视为特征列。Spark DataFrame 中只有前 10000 行将被用作评估数据。
- 一个 mlflow.data.dataset.Dataset 实例，包含评估
  特征、标签以及可选的模型输出。模型输出仅支持 PandasDataset。当模型未指定时，模型输出是必需的，并且应通过 PandasDataset 的 predictions 属性指定。
model_type –
(可选) 描述模型类型的字符串。默认评估器支持以下模型类型：
- 'classifier' (分类器)
- 'regressor' (回归器)
- 'question-answering' (问答)
- 'text-summarization' (文本摘要)
- 'text' (文本)
- 'retriever' (检索器)
如果未指定 model_type，则必须通过 extra_metrics 参数提供要计算的指标列表。

注意

'question-answering', 'text-summarization', 'text', 和 'retriever' 是实验性的，可能会在未来的版本中更改或移除。
targets – 如果 data 是一个 numpy 数组或列表，则为评估标签的 numpy 数组或列表。如果 data 是一个 DataFrame，则为 data 中包含评估标签的列的字符串名称。对于分类器和回归器模型是必需的，但对于问答、文本摘要和文本模型是可选的。如果 data 是一个定义了目标的 mlflow.data.dataset.Dataset，则 targets 是可选的。

predictions –

可选。包含模型输出的列名。

当指定了 model 并且输出多列时，predictions 可用于指定用于存储模型输出以进行评估的列名。
当未指定 model 并且 data 是一个 pandas DataFrame 时，predictions 可用于指定 data 中包含模型输出的列名。

预测示例用法

# Evaluate a model that outputs multiple columns
data = pd.DataFrame({"question": ["foo"]})


def model(inputs):
    return pd.DataFrame({"answer": ["bar"], "source": ["baz"]})


results = evaluate(
    model=model,
    data=data,
    predictions="answer",
    # other arguments if needed
)

# Evaluate a static dataset
data = pd.DataFrame({"question": ["foo"], "answer": ["bar"], "source": ["baz"]})
results = evaluate(
    data=data,
    predictions="answer",
    # other arguments if needed
)

dataset_path – (可选) 数据存储的路径。不得包含双引号 (")。如果指定，路径将被记录到 mlflow.datasets 标签中，用于谱系追踪。
feature_names – (可选) 列表。如果 data 参数是 numpy 数组或列表，则 feature_names 是每个特征的特征名称列表。如果 feature_names=None，则使用 feature_{feature_index} 的格式生成特征名称。如果 data 参数是 Pandas DataFrame 或 Spark DataFrame，则 feature_names 是 DataFrame 中特征列的名称列表。如果 feature_names=None，则除标签列和预测列外的所有列都将被视为特征列。
evaluators – 用于模型评估的评估器名称，或评估器名称列表。如果未指定，将使用所有能够评估指定模型在指定数据集上的评估器。默认评估器可以称为 "default"。要查看所有可用的评估器，请调用 mlflow.models.list_evaluators()。
evaluator_config – 一个附加配置字典，用于提供给评估器。如果指定了多个评估器，每个配置应作为嵌套字典提供，其键为评估器名称。

extra_metrics –

(可选) 一个 EvaluationMetric 对象列表。这些指标将在预定义的 model_type 的默认指标之外进行计算，并且设置 model_type=None 将只计算 extra_metrics 中指定的指标。有关内置指标以及如何定义额外指标的更多信息，请参阅 mlflow.metrics 模块。

额外指标示例用法

import mlflow
import numpy as np


def root_mean_squared_error(eval_df, _builtin_metrics):
    return np.sqrt((np.abs(eval_df["prediction"] - eval_df["target"]) ** 2).mean())


rmse_metric = mlflow.models.make_metric(
    eval_fn=root_mean_squared_error,
    greater_is_better=False,
)
mlflow.evaluate(..., extra_metrics=[rmse_metric])

custom_artifacts –

(可选) 一个自定义产出物函数列表，具有以下签名：

def custom_artifact(
    eval_df: Union[pandas.Dataframe, pyspark.sql.DataFrame],
    builtin_metrics: Dict[str, float],
    artifacts_dir: str,
) -> Dict[str, Any]:
    """
    Args:
        eval_df:
            A Pandas or Spark DataFrame containing ``prediction`` and ``target``
            column.  The ``prediction`` column contains the predictions made by the
            model.  The ``target`` column contains the corresponding labels to the
            predictions made on that row.
        builtin_metrics:
            A dictionary containing the metrics calculated by the default evaluator.
            The keys are the names of the metrics and the values are the scalar
            values of the metrics. Refer to the DefaultEvaluator behavior section
            for what metrics will be returned based on the type of model (i.e.
            classifier or regressor).
        artifacts_dir:
            A temporary directory path that can be used by the custom artifacts
            function to temporarily store produced artifacts. The directory will be
            deleted after the artifacts are logged.

    Returns:
        A dictionary that maps artifact names to artifact objects
        (e.g. a Matplotlib Figure) or to artifact paths within ``artifacts_dir``.
    """
    ...

产出物可以表示的对象类型：

一个表示产出物文件路径的字符串 URI。MLflow 将根据文件扩展名推断产出物的类型。

JSON 对象的字符串表示。这将保存为 .json 产出物。

Pandas DataFrame。这将解析为 CSV 产出物。

Numpy 数组。这将保存为 .npy 产出物。

Matplotlib Figure。这将保存为图像产出物。请注意，matplotlib.pyplot.savefig 是在后台调用的，使用默认配置。要进行自定义，请用所需的配置保存图形并返回其文件路径，或在 matplotlib.rcParams 中通过环境变量定义自定义项。

其他对象将尝试使用默认协议进行 pickling。

自定义产出物示例用法

import mlflow
import matplotlib.pyplot as plt


def scatter_plot(eval_df, builtin_metrics, artifacts_dir):
    plt.scatter(eval_df["prediction"], eval_df["target"])
    plt.xlabel("Targets")
    plt.ylabel("Predictions")
    plt.title("Targets vs. Predictions")
    plt.savefig(os.path.join(artifacts_dir, "example.png"))
    plt.close()
    return {"pred_target_scatter": os.path.join(artifacts_dir, "example.png")}


def pred_sample(eval_df, _builtin_metrics, _artifacts_dir):
    return {"pred_sample": pred_sample.head(10)}


mlflow.evaluate(..., custom_artifacts=[scatter_plot, pred_sample])

env_manager –
指定一个环境管理器，用于在隔离的 Python 环境中加载候选 model 并恢复其依赖项。默认值为 local，支持以下值：
- virtualenv: (推荐) 使用 virtualenv 恢复训练模型时使用的 Python 环境。
- conda: 使用 Conda 恢复训练模型时使用的软件环境。
- local: 使用当前 Python 环境进行模型推理，这可能与训练模型时使用的环境不同，并可能导致错误或无效的预测。
model_config – 用于使用 pyfunc 加载模型的模型配置。检查模型的 pyfunc flavor 以了解哪些键适用于您的特定模型。如果未指定，则使用模型（如果有）的默认模型配置。
inference_params – (可选) 一个字典，包含在进行预测时传递给模型的推理参数，例如 {"max_tokens": 100}。仅当 model 是 MLflow Deployments 端点 URI（例如 "endpoints:/my-chat"）时使用。
model_id – (可选) MLflow LoggedModel 或 Model Version 的 ID，评估结果（例如指标和跟踪）将链接到该 ID。如果未指定 model_id 但指定了 model，则将使用 model 中的 ID。
_called_from_genai_evaluate – (可选) 仅内部使用。

返回

一个 mlflow.models.EvaluationResult 实例，包含使用给定数据集评估模型的指标。

mlflow.models.get_model_info(model_uri: str) → mlflow.models.model.ModelInfo[source]

获取指定模型的元数据，例如其输入/输出签名。

参数

model_uri –

MLflow 模型在 URI 格式中的位置。例如：

/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>
mlflow-artifacts:/path/to/model

For more information about supported URI schemes, see Referencing Artifacts.

返回

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

get_model_info 示例用法

import mlflow.models
import mlflow.sklearn
from sklearn.ensemble import RandomForestRegressor

with mlflow.start_run() as run:
    params = {"n_estimators": 3, "random_state": 42}
    X = [[0, 1]]
    y = [1]
    signature = mlflow.models.infer_signature(X, y)
    rfr = RandomForestRegressor(**params).fit(X, y)
    mlflow.log_params(params)
    mlflow.sklearn.log_model(rfr, name="sklearn-model", signature=signature)

model_uri = f"runs:/{run.info.run_id}/sklearn-model"
# Get model info with model_uri
model_info = mlflow.models.get_model_info(model_uri)
# Get model signature directly
model_signature = model_info.signature
assert model_signature == signature

mlflow.models.infer_pip_requirements(model_uri, flavor, fallback=None, timeout=None, extra_env_vars=None)[source]

通过创建子进程并加载模型来推断指定模型的 pip 需求，以确定导入了哪些包。

参数

model_uri – 模型的 URI。
flavor – 模型的 flavor 名称。
fallback – 如果提供，将吞掉推断过程中发生的意外错误，并返回 fallback 的值。否则，将引发错误。
timeout – 如果指定，则推断操作将受限于超时（以秒为单位）。
extra_env_vars – 要传递给子进程的额外环境变量字典。默认为 None。

返回

推断出的 pip 需求列表（例如 ["scikit-learn==0.24.2", ...]）。

mlflow.models.infer_signature(model_input: Any = None, model_output: MlflowInferableDataset = None, params: dict.str, typing.Any] | None = None) → mlflow.models.signature.ModelSignature[source]

从训练数据（输入）、模型预测（输出）和参数（用于推理）中推断 MLflow 模型签名。

签名将模型输入和输出表示为具有（可选）命名列的数据帧，并将数据类型指定为 mlflow.types.DataType 中定义的一种类型。它还包括用于推理的参数模式。如果用户数据包含不兼容的类型或未以以下支持的格式之一提供，此方法将引发异常。

输入应为以下之一：

pandas.DataFrame
pandas.Series
字典 { 名称 -> numpy.ndarray}
numpy.ndarray
pyspark.sql.DataFrame
scipy.sparse.csr_matrix
scipy.sparse.csc_matrix
字典/字典列表（JSON 可转换类型）

元素类型应可映射到 mlflow.types.DataType 之一。

对于 pyspark.sql.DataFrame 输入，DateType 和 TimestampType 类型的列都将被推断为 datetime 类型，在推断时将被强制转换为 TimestampType。

参数

model_input – 模型的有效输入。例如，训练数据集（的子集）。
model_output – 有效的模型输出。例如，模型对训练数据集（的子集）的预测。

params –

有效的推理参数。它应该是一个字典，其中包含在通过 pyfunc predict 方法传递 params 时可以设置在模型上的参数。

一个有效参数的示例：

from mlflow.models import infer_signature
from mlflow.transformers import generate_signature_output

# Define parameters for inference
params = {
    "num_beams": 5,
    "max_length": 30,
    "do_sample": True,
    "remove_invalid_values": True,
}

# Infer the signature including parameters
signature = infer_signature(
    data,
    generate_signature_output(model, data),
    params=params,
)

# Saving model with model signature
mlflow.transformers.save_model(
    model,
    path=model_path,
    signature=signature,
)

pyfunc_loaded = mlflow.pyfunc.load_model(model_path)

# Passing params to `predict` function directly
result = pyfunc_loaded.predict(data, params=params)

返回

ModelSignature (模型签名)

mlflow.models.list_evaluators()[source]: 返回所有可用评估器的名称列表。

mlflow.models.make_metric(*, eval_fn, greater_is_better, name=None, long_name=None, version=None, metric_details=None, metric_metadata=None, genai_metric_args=None)[source]

一个用于创建 EvaluationMetric 对象的工厂函数。

参数

eval_fn –

一个计算指标的函数，签名如下：

def eval_fn(
    predictions: pandas.Series,
    targets: pandas.Series,
    metrics: Dict[str, MetricValue],
    **kwargs,
) -> Union[float, MetricValue]:
    """
    Args:
        predictions: A pandas Series containing the predictions made by the model.
        targets: (Optional) A pandas Series containing the corresponding labels
            for the predictions made on that input.
        metrics: (Optional) A dictionary containing the metrics calculated by the
            default evaluator.  The keys are the names of the metrics and the values
            are the metric values.  To access the MetricValue for the metrics
            calculated by the system, make sure to specify the type hint for this
            parameter as Dict[str, MetricValue].  Refer to the DefaultEvaluator
            behavior section for what metrics will be returned based on the type of
            model (i.e. classifier or regressor).  kwargs: Includes a list of args
            that are used to compute the metric. These args could information coming
            from input data, model outputs or parameters specified in the
            `evaluator_config` argument of the `mlflow.evaluate` API.
        kwargs: Includes a list of args that are used to compute the metric. These
            args could be information coming from input data, model outputs,
            other metrics, or parameters specified in the `evaluator_config`
            argument of the `mlflow.evaluate` API.

    Returns: MetricValue with per-row scores, per-row justifications, and aggregate
        results.
    """
    ...

greater_is_better – 指标值越大越好。
name – 指标的名称。如果 eval_fn 是一个 lambda 函数或 eval_fn.__name__ 属性不可用，则必须指定此参数。
long_name – (可选) 指标的长名称。例如，"mse" 的 "mean_squared_error"。
version – (可选) 指标版本。例如 v1。
metric_details – (可选) 指标及其计算方式的描述。
metric_metadata – (可选) 包含指标元数据的字典。
genai_metric_args – (可选) 包含用户在调用 make_genai_metric 或 make_genai_metric_from_prompt 时指定的参数的字典。这些参数将被持久化，以便我们以后能够反序列化相同的指标对象。

另请参阅

mlflow.models.EvaluationMetric
mlflow.evaluate()

mlflow.models.predict(model_uri, input_data=None, input_path=None, content_type='json', output_path=None, env_manager='virtualenv', install_mlflow=False, pip_requirements_override=None, extra_envs=None)[source]

使用保存的 MLflow 模型生成 JSON 格式的预测。有关此函数接受的输入数据格式的信息，请参阅以下文档：https://www.mlflow.org/docs/latest/models.html#built-in-deployment-tools。

注意

为了提高调试目的的详细程度（以便在处理瞬态依赖项时检查完整的依赖项解析器操作），请考虑设置以下环境变量：

# For virtualenv
export PIP_VERBOSE=1

# For uv
export RUST_LOG=uv=debug

另请参阅

参数

model_uri – 模型的 URI。本地路径、本地或远程 URI，例如 runs:/, s3://。
input_data –
预测的输入数据。必须是 PyFunc 模型有效的输入。有关支持的输入类型，请参阅 mlflow.pyfunc.PyFuncModel.predict()。

注意

如果此 API 因 input_data 中的错误而失败，请使用 mlflow.models.convert_input_example_to_serving_input 手动验证您的输入数据。
input_path – 包含输入数据的文件路径。如果提供，‘input_data’ 必须为 None。
content_type – 输入数据的内容类型。可以是 {‘json’, ‘csv’} 之一。
output_path – 输出结果的 JSON 文件。如果未提供，则输出到 stdout。
env_manager –
指定创建 MLmodel 推理环境的方式：
- "virtualenv" (默认)：使用 virtualenv（以及 pyenv 进行 Python 版本管理）。
- "uv": 使用 uv。
- "local": 使用本地环境。
- "conda": 使用 conda。
install_mlflow – 如果指定并且存在要激活的 conda 或 virtualenv 环境，则在激活后会将 mlflow 安装到环境中。安装的 mlflow 版本将与调用此命令时使用的版本相同。
pip_requirements_override –
如果指定，则在模型推理环境中安装指定的 Python 依赖项。当您想要添加额外的依赖项或尝试使用记录模型中定义的依赖项的不同版本时，此功能特别有用。

提示

在验证 pip requirements override 按预期工作后，您可以使用 mlflow.models.update_model_requirements API 更新记录模型的依赖项，而无需重新记录它。请注意，已注册的模型是不可变的，因此您需要注册一个具有更新依赖项的新模型版本。
extra_envs –
如果指定，则会将一个字典形式的额外环境变量传递到模型推理环境中。这对于测试模型运行正常所需的环境变量很有用。默认情况下，会传递当前 os.environ 中存在的环境变量，并且此参数可用于覆盖它们。

注意

如果您的模型依赖项包含预发布版本，例如 mlflow==3.2.0rc0，并且您将 uv 用作环境管理器，请在 extra_envs 中将 UV_PRERELEASE 环境变量设置为“allow”，以允许安装预发布版本。例如：extra_envs={“UV_PRERELEASE”: “allow”}。

注意

此参数仅在 env_manager 设置为“virtualenv”、“conda”或“uv”时支持。

代码示例

import mlflow

run_id = "..."

mlflow.models.predict(
    model_uri=f"runs:/{run_id}/model",
    input_data={"x": 1, "y": 2},
    content_type="json",
)

# Run prediction with "uv" as the environment manager
mlflow.models.predict(
    model_uri=f"runs:/{run_id}/model",
    input_data={"x": 1, "y": 2},
    env_manager="uv",
)

# Run prediction with additional pip dependencies and extra environment variables
mlflow.models.predict(
    model_uri=f"runs:/{run_id}/model",
    input_data={"x": 1, "y": 2},
    content_type="json",
    pip_requirements_override=["scikit-learn==0.23.2"],
    extra_envs={"OPENAI_API_KEY": "some_value"},
)

# Run prediction with output_path
mlflow.models.predict(
    model_uri=f"runs:/{run_id}/model",
    input_data={"x": 1, "y": 2},
    env_manager="uv",
    output_path="output.json",
)

# Run prediction with pre-release versions
mlflow.models.predict(
    model_uri=f"runs:/{run_id}/model",
    input_data={"x": 1, "y": 2},
    env_manager="uv",
    extra_envs={"UV_PRERELEASE": "allow"},
)

mlflow.models.set_model(model) → None[source]

在将模型记录为代码时，此函数可用于设置要记录的模型对象。

参数

model –

要记录的模型对象。支持的模型类型有：

Python 函数或可调用对象。
Langchain 模型或 Langchain 模型路径。
Llama Index 模型或 Llama Index 模型路径。

mlflow.models.set_retriever_schema(*, primary_key: str, text_column: str, doc_uri: Optional[str] = None, other_columns: Optional[list[str]] = None, name: str | None = 'retriever')[source]

指定代理或生成式 AI 应用代码中检索器（retriever）的返回模式。

自 3.3.2 版本起弃用：此函数已弃用，将在将来的版本中移除。

注意：MLflow 建议您的检索器返回此处描述的默认 MLflow 检索器输出模式，在这种情况下，您无需调用 set_retriever_schema。读取 MLflow trace 并查找检索器 span 的 API（例如 MLflow 评估）将自动检测与 MLflow 默认检索器模式匹配的检索器 span。

如果您的检索器未返回默认的 MLflow 检索器输出模式，请调用此 API 来指定每个检索到的文档中的哪些字段对应于页面内容、文档 URI、文档 ID 等。这使得 MLflow 评估等下游功能能够正确识别这些字段。请注意，set_retriever_schema 假定您的检索器 span 返回对象列表。

参数

primary_key – 检索器或向量索引的主键。
text_column – 用于嵌入的文本列的名称。
doc_uri – 包含文档 URI 的列的名称。
other_columns – 向量索引的一部分，在 trace 日志记录期间需要检索的其他列的列表。
name – 检索器工具或向量存储索引的名称。

示例

from mlflow.models import set_retriever_schema

# The following call sets the schema for a custom retriever that retrieves content from
# MLflow documentation, with an output schema like:
# [
#     {
#         'document_id': '9a8292da3a9d4005a988bf0bfdd0024c',
#         'chunk_text': 'MLflow is an open-source platform, purpose-built to assist...',
#         'doc_uri': 'https://mlflow.org.cn/docs/latest/index.html',
#         'title': 'MLflow: A Tool for Managing the Machine Learning Lifecycle'
#     },
#     {
#         'document_id': '7537fe93c97f4fdb9867412e9c1f9e5b',
#         'chunk_text': 'A great way to get started with MLflow is...',
#         'doc_uri': 'https://mlflow.org.cn/docs/latest/getting-started/',
#         'title': 'Getting Started with MLflow'
#     },
# ...
# ]
set_retriever_schema(
    primary_key="chunk_id",
    text_column="chunk_text",
    doc_uri="doc_uri",
    other_columns=["title"],
    name="my_custom_retriever",
)

mlflow.models.set_signature(model_uri: str, signature: mlflow.models.signature.ModelSignature)[source]

为指定的模型工件设置模型签名。

该过程包括下载模型工件中的 MLmodel 文件（如果它是非本地的），更新其模型签名，然后覆盖现有的 MLmodel 文件。如果与模型工件关联的工件存储库不允许覆盖，则此函数将失败。

此外，由于模型注册表工件是只读的，因此位于模型注册表中并由 models:/ URI 方案表示的模型工件与此 API 不兼容。要为模型版本设置签名，请先加载源模型工件。然后，使用加载的模型工件和相应的签名生成新的模型版本。有关为模型版本设置签名的更多信息，请参阅此文档部分。

参数

model_uri –
MLflow 模型在 URI 格式中的位置。例如：
- /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
- mlflow-artifacts:/path/to/model
- models:/<model_id>
For more information about supported URI schemes, see Referencing Artifacts.

请注意，不}(\cite{models://}) 格式的模型 URI 不受支持。
signature – 要在模型上设置的模型签名。

示例

import mlflow
from mlflow.models import set_signature, infer_signature

# load model from run artifacts
run_id = "96771d893a5e46159d9f3b49bf9013e2"
artifact_path = "models"
model_uri = f"runs:/{run_id}/{artifact_path}"
model = mlflow.pyfunc.load_model(model_uri)

# determine model signature
test_df = ...
predictions = model.predict(test_df)
signature = infer_signature(test_df, predictions)

# set the signature for the logged model
set_signature(model_uri, signature)

mlflow.models.update_model_requirements(model_uri: str, operation: Literal['add', 'remove'], requirement_list: list[str]) → None[source]

向模型的 conda.yaml 和 requirements.txt 文件添加或删除需求。

该过程包括从模型工件下载这两个文件（如果它们是非本地的），使用指定的需求更新它们，然后覆盖现有文件。如果与模型工件关联的工件存储库不允许覆盖，则此函数将失败。

请注意，模型注册表 URI（即 models:/ 形式的 URI）不受支持，因为模型注册表中的工件是只读的。

如果添加需求，该函数将覆盖任何现有的重叠需求，否则将新的需求追加到现有列表中。

如果删除需求，该函数将忽略任何版本说明符，并删除所有指定包的名称。任何未在现有文件中找到的需求都将被忽略。

参数

model_uri –
MLflow 模型在 URI 格式中的位置。例如：
- /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
- mlflow-artifacts:/path/to/model
For more information about supported URI schemes, see Referencing Artifacts.
operation – 要执行的操作。必须是“add”或“remove”之一。
requirement_list – 要添加到模型或从模型中删除的需求列表。例如：[“numpy==1.20.3”, “pandas>=1.3.3”]

mlflow.models.validate_schema(data: Union[pandas.core.frame.DataFrame, pandas.core.series.Series, numpy.ndarray, scipy.sparse._csc.csc_matrix, scipy.sparse._csr.csr_matrix, List[Any], Dict[str, Any], datetime.datetime, bool, bytes, float, int, str, pyspark.sql.dataframe.DataFrame], expected_schema: mlflow.types.schema.Schema) → None[source]

验证输入数据是否具有预期的模式。

参数

data –
要验证的输入数据。支持的类型为：
- pandas.DataFrame
- pandas.Series
- numpy.ndarray
- scipy.sparse.csc_matrix
- scipy.sparse.csr_matrix
- List[Any]
- Dict[str, Any]
- str
expected_schema – 输入数据的预期模式。

引发

mlflow.exceptions.MlflowException – 当输入数据与模式不匹配时。

validate_schema 的示例用法

import mlflow.models

# Suppose you've already got a model_uri
model_info = mlflow.models.get_model_info(model_uri)
# Get model signature directly
model_signature = model_info.signature
# validate schema
mlflow.models.validate_schema(input_data, model_signature.inputs)

mlflow.models.validate_serving_input(model_uri: str, serving_input: str | dict[str, typing.Any])[source]

用于在模型服务之前验证模型是否可以服务且提供的输入是否有效的辅助函数。

参数

model_uri – 要服务的模型的 URI。
serving_input – 要验证的输入数据。应为字典或 JSON 字符串。

返回

来自模型的预测结果。

class mlflow.models.model.ModelInfo(artifact_path: str, flavors: dict[str, typing.Any], model_uri: str, model_uuid: str, run_id: str, saved_input_example_info: dict[str, typing.Any] | None, signature, utc_time_created: str, mlflow_version: str, metadata: Optional[dict[str, typing.Any]] = None, registered_model_version: Optional[int] = None, env_vars: Optional[list[str]] = None, prompts: Optional[list[str]] = None, logged_model: Optional[LoggedModel] = None)[source]

已记录的 MLflow Model 的元数据。

property artifact_path: str

标识已记录模型的 run 相对路径。

Getter: 检索已记录模型的相对路径。
类型: str

property creation_timestamp: int

返回已记录模型的创建时间戳。

Getter: 已记录模型的创建时间戳

property env_vars: list[str] | None

模型记录过程中使用的环境变量。

Getter: 获取模型记录过程中使用的环境变量。
类型: Optional[List[str]]

property flavors: dict[str, typing.Any]

一个字典，将 flavor 名称映射到如何将模型作为该 flavor 提供服务。

Getter: 获取已记录模型的 flavor 映射，该映射定义了模型服务中使用的参数
类型: Dict[str, str]

scikit-learn 已记录模型的示例 flavor 映射

{
    "python_function": {
        "model_path": "model.pkl",
        "loader_module": "mlflow.sklearn",
        "python_version": "3.8.10",
        "env": "conda.yaml",
    },
    "sklearn": {
        "pickled_model": "model.pkl",
        "sklearn_version": "0.24.1",
        "serialization_format": "cloudpickle",
    },
}

property metadata: dict[str, typing.Any] | None

添加到模型的用户定义的元数据。

Getter: 获取有关模型的用户定义的元数据
类型: Optional[Dict[str, Any]]

Model Metadata 的示例用法

# Create and log a model with metadata to the Model Registry

from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
import mlflow
from mlflow.models import infer_signature

with mlflow.start_run():
    iris = datasets.load_iris()
    clf = RandomForestClassifier()
    clf.fit(iris.data, iris.target)
    signature = infer_signature(iris.data, iris.target)
    mlflow.sklearn.log_model(
        clf,
        name="iris_rf",
        signature=signature,
        registered_model_name="model-with-metadata",
        metadata={"metadata_key": "metadata_value"},
    )

# model uri for the above model
model_uri = "models:/model-with-metadata/1"

# Load the model and access the custom metadata from its ModelInfo object
model = mlflow.pyfunc.load_model(model_uri=model_uri)
assert model.metadata.get_model_info().metadata["metadata_key"] == "metadata_value"

# Load the ModelInfo and access the custom metadata
model_info = mlflow.models.get_model_info(model_uri=model_uri)
assert model_info.metadata["metadata_key"] == "metadata_value"

property metrics: list[Metric] | None

返回已记录模型的指标。

Getter: 检索已记录模型的指标

property mlflow_version: str

用于记录模型的 MLflow 版本

Getter: 获取模型记录时安装的 MLflow 版本
类型: str

property model_id: str

已记录模型的模型 ID。

Getter: 获取已记录模型的模型 ID

property model_uri: str

已记录模型的 model_uri，格式为 'runs:/<run_id>/<artifact_path>'。

Getter: 从 URI runs:/<run_id> 路径封装中获取已记录模型的 URI 路径
类型: str

property model_uuid: str

已记录模型的 model_uuid，例如 '39ca11813cfc46b09ab83972740b80ca'。

Getter: [遗留] 获取已记录模型的 model_uuid（run_id）
类型: str

property name: str: 返回已记录模型的名称。

property params: dict[str, str]

返回已记录模型的参数。

Getter: 检索已记录模型的参数

property prompts: list[str] | None: 与模型关联的提示 URI 列表。

property registered_model_version: int | None

已注册的模型版本（如果模型已注册）。

Getter: 获取已注册的模型版本（如果模型已在模型注册表中注册）。
Setter: 设置已注册的模型版本。
类型: Optional[int]

property run_id: str

与已记录模型关联的 run_id，例如 '8ede7df408dd42ed9fc39019ef7df309'。

Getter: 获取已记录模型的 run_id 标识符
类型: str

property saved_input_example_info: dict[str, typing.Any] | None

一个包含已保存输入示例元数据的字典，例如 {"artifact_path": "input_example.json", "type": "dataframe", "pandas_orient": "split"}。

Getter: 获取模型记录期间指定的输入示例
类型: Optional[Dict[str, str]]

property signature

描述模型输入和输出的 ModelSignature。

Getter: 获取模型签名（如果已定义）
类型: Optional[ModelSignature]

property tags: dict[str, str]

返回已记录模型的标签。

Getter: 检索已记录模型的标签

property utc_time_created: str

已记录模型创建的 UTC 时间，例如 '2022-01-12 05:17:31.634689'。

Getter: 获取模型记录时的 UTC 格式时间戳
类型: str