Administración del ciclo de vida del modelo en Unity Catalog

Importante

En este artículo se describe cómo usar los modelos en Unity Catalog como parte del flujo de trabajo de aprendizaje automático para administrar el ciclo de vida completo de los modelos de ML. Databricks proporciona una versión hospedada del Registro de modelos de MLflow en Unity Catalog. Los modelos de Unity Catalog amplían las ventajas de Unity Catalog a los modelos de ML, incluidos el control de acceso centralizado, la auditoría, el linaje y la detección de modelos entre áreas de trabajo. Los modelos de Unity Catalog son compatibles con el cliente de Python de MLflow de código abierto.

Las principales características de los modelos de Unity Catalog incluyen las siguientes:

  • El espacio de nombres y la gobernanza de los modelos, con los que puedes agrupar y controlar modelos en el nivel de entorno, de proyecto o de equipo ("Conceder acceso de solo lectura a los modelos de producción a los científicos de datos").
  • Linaje cronológico del modelo (qué experimento y ejecución de MLflow produjo el modelo en un momento determinado).
  • Servicio de modelos.
  • Control de versiones de los modelos.
  • Implementación de modelos mediante alias. Por ejemplo, marca la versión "Champion" de un modelo dentro del prod catálogo.

Si el catálogo predeterminado del área de trabajo está configurado en un catálogo de Unity, los modelos registrados mediante las API de MLflow, como mlflow.<model-type>.log_model(..., registered_model_name) o mlflow.register_model(model_uri, name), se registran en el catálogo de Unity de forma predeterminada.

En este artículo se incluyen instrucciones para los modelos tanto de la interfaz de usuario de Unity Catalog y como de API.

Para obtener información general sobre los conceptos del Registro de modelos, consulte Administración del ciclo de vida de ML mediante MLflow.

Requisitos

  1. El Unity Catalog debe estar habilitado en tu área de trabajo. Consulta Introducción al uso de Unity Catalog para crear un metastore de Unity Catalog, habilitarlo en un área de trabajo y crear un catálogo. Si Unity Catalog no está habilitado, todavía puede usar el Registro de modelos del área de trabajo clásico.

  2. Tu área de trabajo debe estar asociada a un metastore de Unity Catalog que admita la herencia de privilegios. Esto se aplica a todas las metastores creadas después del 25 de agosto de 2022. Si se ejecuta en una tienda de metadatos anterior, sigue los documentos para actualizarla.

  3. Debes tener acceso para ejecutar comandos en un clúster con acceso a Unity Catalog.

  4. Para crear nuevos modelos registrados, necesitas el CREATE_MODEL privilegio en un esquema, además de los privilegios USE SCHEMA y USE CATALOG en el esquema y su catálogo envolvente. CREATE_MODELes un nuevo privilegio a nivel de esquema que puede conceder mediante la interfaz de usuario del Catalog Explorer o el comando SQL GRANT, como se muestra a continuación.

    GRANT CREATE_MODEL ON SCHEMA <schema-name> TO <principal>
    

Actualizar cargas de trabajo de entrenamiento a Unity Catalog

En esta sección se incluyen las instrucciones para actualizar las cargas de trabajo de entrenamiento existentes a Unity Catalog.

Instalación del cliente de Python de MLflow

También puede usar modelos de Unity Catalog en Databricks Runtime 11.3 LTS y versiones posteriores instalando la versión más reciente del cliente de Python de MLflow en su cuaderno, con el siguiente código.

%pip install --upgrade "mlflow-skinny[databricks]"
dbutils.library.restartPython()

Configuración del cliente de MLflow para acceder a los modelos de Unity Catalog

De forma predeterminada, el cliente de Python de MLflow crea modelos en el registro de modelos del área de trabajo de Databricks. Para actualizar a los modelos en Unity Catalog, configura el cliente de MLflow:

import mlflow
mlflow.set_registry_uri("databricks-uc")

Nota:

Si el catálogo predeterminado del área de trabajo está en Unity Catalog (en lugar de hive_metastore) y ejecuta un clúster mediante Databricks Runtime 13.3 LTS o versiones posteriores (Databricks Runtime 15.0 ML o versiones posteriores en Azure China), los modelos se crean automáticamente en el catálogo predeterminado y no se cargan, sin necesidad de configuración. No hay ningún cambio en el comportamiento de otras versiones de Databricks Runtime. Un pequeño número de áreas de trabajo en las que el catálogo predeterminado se configuró en un catálogo de Unity Catalog antes de enero de 2024 y el registro del modelo de área de trabajo se usó antes de enero de 2024 están exentas de este comportamiento.

Entrenamiento y registro de modelos compatibles con el Unity Catalog

Permisos necesarios: para crear un nuevo modelo registrado, necesitas los privilegios CREATE_MODEL y USE SCHEMA en el esquema envolvente y el privilegio USE CATALOG en el catálogo envolvente. Para crear nuevas versiones de modelo a partir de un modelo registrado, debes ser el propietario del modelo registrado y tener los privilegios USE SCHEMA y USE CATALOG en el esquema y el catálogo que contiene el modelo.

Las versiones del modelo ML en UC deben tener una firma de modelo. Si aún no registras modelos de MLflow con firmas en las cargas de trabajo de entrenamiento del modelo, puedes hacer lo siguiente:

  • Usa el registro automático de Databricks, que registra automáticamente los modelos con firmas para muchos marcos de ML populares. Consulta los marcos admitidos en la documentación de MLflow.
  • Con MLflow 2.5.0 y versiones posteriores, puede especificar un ejemplo de entrada en su llamada mlflow.<flavor>.log_model y la firma del modelo se deducirá automáticamente. Para más información, consulte la documentación de MLflow.

Después, pasa el nombre de tres niveles del modelo a las API de MLflow, con el formato <catalog>.<schema>.<model>.

Los ejemplos de esta sección crean y acceden a modelos en el ml_team esquema a partir del catálogo prod.

Los ejemplos de entrenamiento de modelos de esta sección crean una nueva versión del modelo y la registran en el catálogo prod. Utilizar el catálogo prod no significa necesariamente que la versión del modelo tenga tráfico de producción. El catálogo, el esquema y el modelo registrado de la versión del modelo reflejan su entorno (prod) y las reglas de gobernanza asociadas (por ejemplo, los privilegios se pueden configurar para que solo los administradores puedan eliminar en el catálogo prod), pero no su estado de implementación. Para administrar el estado de implementación, use alias de modelos.

Registro de un modelo en Unity Catalog mediante el registro automático

from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier

# Train a sklearn model on the iris dataset
X, y = datasets.load_iris(return_X_y=True, as_frame=True)
clf = RandomForestClassifier(max_depth=7)
clf.fit(X, y)

# Note that the UC model name follows the pattern
# <catalog_name>.<schema_name>.<model_name>, corresponding to
# the catalog, schema, and registered model name
# in Unity Catalog under which to create the version
# The registered model will be created if it doesn't already exist
autolog_run = mlflow.last_active_run()
model_uri = "runs:/{}/model".format(autolog_run.info.run_id)
mlflow.register_model(model_uri, "prod.ml_team.iris_model")

Registre un modelo en Unity Catalog con firma deducida automáticamente

El soporte técnico para firmas deducidas automáticamente está disponible en la versión 2.5.0 de MLflow y versiones posteriores, y es compatible con Databricks Runtime 11.3 LTS ML y posteriores. Para usar firmas deducidas automáticamente, use el siguiente código para instalar el cliente de Python de MLflow más reciente en su cuaderno:

%pip install --upgrade "mlflow-skinny[databricks]"
dbutils.library.restartPython()

En el siguiente código se muestra un ejemplo de firma deducida automáticamente.

from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier

with mlflow.start_run():
    # Train a sklearn model on the iris dataset
    X, y = datasets.load_iris(return_X_y=True, as_frame=True)
    clf = RandomForestClassifier(max_depth=7)
    clf.fit(X, y)
    # Take the first row of the training dataset as the model input example.
    input_example = X.iloc[[0]]
    # Log the model and register it as a new version in UC.
    mlflow.sklearn.log_model(
        sk_model=clf,
        artifact_path="model",
        # The signature is automatically inferred from the input example and its predicted output.
        input_example=input_example,
        registered_model_name="prod.ml_team.iris_model",
    )

Seguimiento del linaje de datos de un modelo en Unity Catalog

Nota:

La compatibilidad con la tabla para modelar el linaje en Unity Catalog está disponible en MLflow 2.11.0 y versiones posteriores.

Al entrenar un modelo en una tabla de Unity Catalog, puedes realizar un seguimiento del linaje del modelo a los conjuntos de datos ascendentes en los que se entrenó y evaluó. Para ello, usa mlflow.log_input. Esto guarda la información de la tabla de entrada con la ejecución de MLflow que generó el modelo. El linaje de datos también se captura automáticamente para los modelos registrados mediante las API del almacén de características. Consulte Visualización del linaje del almacén de características.

Al registrar el modelo en Unity Catalog, la información de linaje se guarda automáticamente y está visible en la pestaña Linaje de la interfaz de usuario de la versión del modelo en el Explorador de catálogos.

El código siguiente muestra un ejemplo.

import mlflow
import pandas as pd
import pyspark.pandas as ps
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestRegressor

# Write a table to Unity Catalog
iris = load_iris()
iris_df = pd.DataFrame(iris.data, columns=iris.feature_names)
iris_df.rename(
  columns = {
    'sepal length (cm)':'sepal_length',
    'sepal width (cm)':'sepal_width',
    'petal length (cm)':'petal_length',
    'petal width (cm)':'petal_width'},
  inplace = True
)
iris_df['species'] = iris.target
ps.from_pandas(iris_df).to_table("prod.ml_team.iris", mode="overwrite")

# Load a Unity Catalog table, train a model, and log the input table
dataset = mlflow.data.load_delta(table_name="prod.ml_team.iris", version="0")
pd_df = dataset.df.toPandas()
X = pd_df.drop("species", axis=1)
y = pd_df["species"]
with mlflow.start_run():
    clf = RandomForestRegressor(n_estimators=100)
    clf.fit(X, y)
    mlflow.log_input(dataset, "training")

Visualización de modelos en la UI

Permisos necesarios: para ver un modelo registrado y sus versiones de modelo en la IU, necesitas el privilegio EXECUTE en el modelo registrado, además de los privilegios USE SCHEMA y USE CATALOG en el esquema y el catálogo que contiene el modelo

Puede establecer, actualizar y quitar alias para modelos en Unity Catalog usando Catalog Explorer.

Control del acceso a los modelos

Más información sobre cómo controlar el acceso a los modelos registrados en Unity Catalog aquí: Privilegios y objetos protegibles de Unity Catalog. Para conocer los procedimientos recomendados para organizar modelos entre catálogos y esquemas, consulte Organizar datos.

Puede configurar los permisos de modelo mediante programación mediante las Concesiones API de REST. Al configurar los permisos de modelo, establezca securable_type a "FUNCTION" en Solicitudes de API REST. Por ejemplo, utilice PATCH /api/2.1/unity-catalog/permissions/function/{full_name} para actualizar los permisos de modelo registrados.

Implementar y organizar modelos con alias y etiquetas

Los alias y etiquetas de modelo facilitan organizar y administrar modelos en el catálogo de Unity.

Los alias de modelo permiten asignar una referencia mutable y nominal a una versión determinada dentro de un modelo registrado. Puede usar alias para indicar el estado de implementación de una versión de modelo. Por ejemplo, podría asignar un alias "Champion" a la versión de modelo actualmente en producción y dirigirse a este alias en cargas de trabajo que usan el modelo de producción. Puede actualizar el modelo de producción reasignando el alias "Champion" a otra versión del modelo.

Las etiquetas son pares clave-valor que se asocian a modelos registrados y versiones de modelo, permitiendo etiquetarlos y clasificarlos por función o estado. Por ejemplo, podría aplicar una etiqueta con clave "task" y valor "question-answering" (que se muestra en la UI como task:question-answering) a los modelos registrados destinados a las tareas de respuesta a preguntas. En el nivel de versión del modelo, podría etiquetar las versiones que se someten a la validación previa a la implementación con validation_status:pending y las desactivadas para la implementación con validation_status:approved.

Consulte las siguientes secciones para obtener información sobre cómo usar alias y etiquetas.

Establecer y eliminar de alias en modelos

Permisos necesarios: ser propietario del modelo registrado, más los privilegios USE SCHEMA y USE CATALOG en el esquema y el catálogo que contiene el modelo.

Puede establecer, actualizar y quitar alias para modelos en Unity Catalog mediante Catalog Explorer. Puede administrar alias en un modelo registrado en la página de detalles del modelo y configurar alias para una versión de modelo específica en la página de detalles de la versión del modelo.

Para establecer, actualizar y eliminar alias mediante la API de cliente de MLflow, consulte los siguientes ejemplos:

from mlflow import MlflowClient
client = MlflowClient()

# create "Champion" alias for version 1 of model "prod.ml_team.iris_model"
client.set_registered_model_alias("prod.ml_team.iris_model", "Champion", 1)

# reassign the "Champion" alias to version 2
client.set_registered_model_alias("prod.ml_team.iris_model", "Champion", 2)

# get a model version by alias
client.get_model_version_by_alias("prod.ml_team.iris_model", "Champion")

# delete the alias
client.delete_registered_model_alias("prod.ml_team.iris_model", "Champion")

Establecer y eliminar etiquetas en modelos

Permisos necesarios: ser propietario o tener privilegio APPLY_TAG sobre el modelo registrado, más los privilegios USE SCHEMAy USE CATALOG en el esquema y el catálogo que contiene el modelo.

Vea Administrar etiquetas en Catalog Explorer para saber cómo establecer y eliminar etiquetas mediante la UI.

Para establecer y eliminar etiquetas mediante la API de cliente de MLflow, consulte los siguientes ejemplos:

from mlflow import MlflowClient
client = MlflowClient()

# Set registered model tag
client.set_registered_model_tag("prod.ml_team.iris_model", "task", "classification")

# Delete registered model tag
client.delete_registered_model_tag("prod.ml_team.iris_model", "task")

# Set model version tag
client.set_model_version_tag("prod.ml_team.iris_model", "1", "validation_status", "approved")

# Delete model version tag
client.delete_model_version_tag("prod.ml_team.iris_model", "1", "validation_status")

Tanto las etiquetas de modelo registrado como las de versión de modelo deben cumplir las restricciones de toda la plataforma.

Para saber más sobre las API de cliente de alias y etiquetas, consulte la documentación de la API de MLflow.

Implementación de modelos para la inferencia

Consumo de versiones de modelo por alias en cargas de trabajo de inferencia

Permisos necesarios: privilegio EXECUTE del modelo registrado, más los privilegios USE SCHEMA y USE CATALOG en el esquema y el catálogo que contiene el modelo.

Puedes escribir cargas de trabajo de inferencia por lotes que hagan referencia a una versión del modelo por alias. Por ejemplo, el siguiente fragmento de código carga y aplica la versión del modelo "Champion" para la inferencia por lotes. Si la versión "Champion" se actualiza para hacer referencia a una nueva versión del modelo, la carga de trabajo de inferencia por lotes la recoge automáticamente en su siguiente ejecución. Esto te permite desacoplar las implementaciones de modelos de las cargas de trabajo de inferencia por lotes.

import mlflow.pyfunc
model_version_uri = "models:/prod.ml_team.iris_model@Champion"
champion_version = mlflow.pyfunc.load_model(model_version_uri)
champion_version.predict(test_x)

También puedes escribir flujos de trabajo de implementación para obtener una versión del modelo por alias y actualizar un punto de conexión de servicio de modelo para atender esa versión, mediante el modelo que sirve la API de REST:

import mlflow
import requests
client = mlflow.tracking.MlflowClient()
champion_version = client.get_model_version_by_alias("prod.ml_team.iris_model", "Champion")
# Invoke the model serving REST API to update endpoint to serve the current "Champion" version
model_name = champion_version.name
model_version = champion_version.version
requests.request(...)

Consumo de versiones de modelo por número de versión en cargas de trabajo de inferencia

También puedes cargar las versiones del modelo por número de versión:

import mlflow.pyfunc
# Load version 1 of the model "prod.ml_team.iris_model"
model_version_uri = "models:/prod.ml_team.iris_model/1"
first_version = mlflow.pyfunc.load_model(model_version_uri)
first_version.predict(test_x)

Uso compartido de modelos en áreas de trabajo

Siempre que tengas los privilegios adecuados, puedes acceder a los modelos en Unity Catalog desde cualquier área de trabajo. Por ejemplo, puedes acceder a los modelos desde el catálogo prod de un área de trabajo de desarrollo para facilitar la comparación de los modelos recién desarrollados con la línea base de producción.

Para colaborar con otros usuarios (compartir privilegios de escritura) en un modelo registrado que has creado, debes conceder la propiedad del modelo a un grupo en el que estés tú y los usuarios con los que quieres colaborar. Los colaboradores también deben tener los privilegios USE CATALOG y USE SCHEMA en el catálogo y el esquema que contiene el modelo. Consulta Privilegios de Unity Catalog y objetos protegibles para saber más.

Anotación de un modelo o una versión de un modelo

Permisos necesarios: ser propietario del modelo registrado, más los privilegios USE SCHEMA y USE CATALOG en el esquema y el catálogo que contiene el modelo.

Para proporcionar información acerca de un modelo o una versión de un modelo, anótelo. Por ejemplo, puede que desee incluir información general del problema o información sobre la metodología y el algoritmo usados.

Anotación de un modelo o una versión de un modelo mediante la interfaz de usuario

Consulte Datos del documento en el Explorador de catálogos mediante comentarios de Markdown.

Anotación de un modelo o una versión de un modelo mediante la API

Para actualizar la descripción de un modelo registrado, usa el método update_registered_model() de Client API de MLflow:

client = MlflowClient()
client.update_registered_model(
  name="<model-name>",
  description="<description>"
)

Para actualizar la descripción de una versión del modelo, use el método update_model_version() de Client API de MLflow:

client = MlflowClient()
client.update_model_version(
  name="<model-name>",
  version=<model-version>,
  description="<description>"
)

Cambio del nombre de un modelo (solo API)

Permisos necesarios: ser propietario del modelo registrado, tener el privilegio CREATE_MODEL en el esquema que contiene el modelo registrado y los privilegios USE SCHEMA y USE CATALOG en el esquema y el catálogo que contiene el modelo.

Para cambiar el nombre de un modelo inscrito, use el método rename_registered_model() de Client API de MLflow:

client=MlflowClient()
client.rename_registered_model("<model-name>", "<new-model-name>")

Eliminación de un modelo o una versión de un modelo

Permisos necesarios: ser propietario del modelo registrado, más los privilegios USE SCHEMA y USE CATALOG en el esquema y el catálogo que contiene el modelo.

Puede eliminar un modelo registrado o una versión de modelo dentro de un modelo registrado mediante la IU de Catalog Explorer o la API.

Eliminación de una versión de un modelo o un modelo mediante la API

Advertencia

No es posible deshacer esta acción. Al eliminar un modelo, no solo se eliminan todos los artefactos del modelo almacenados por Unity Catalog, sino también todos los metadatos asociados al modelo inscrito.

Eliminación de una versión de un modelo

Para eliminar una versión del modelo, use el método delete_model_version() de Client API de MLflow:

# Delete versions 1,2, and 3 of the model
client = MlflowClient()
versions=[1, 2, 3]
for version in versions:
  client.delete_model_version(name="<model-name>", version=version)

Eliminación de un modelo

Para eliminar un modelo, use el método delete_registered_model() de Client API de MLflow:

client = MlflowClient()
client.delete_registered_model(name="<model-name>")

Enumerar y buscar modelos

Puedes enumerar los modelos registrados en el catálogo de Unity con la API de Python search_registered_models() de MLflow:

client=MlflowClient()
client.search_registered_models()

También puedes buscar un nombre de modelo específico y mostrar los detalles de su versión con el método search_model_versions():

from pprint import pprint

client=MlflowClient()
[pprint(mv) for mv in client.search_model_versions("name='<model-name>'")]

Ejemplo

Este ejemplo muestra cómo usar modelos del Unity Catalog para compilar una aplicación de aprendizaje automático.

Ejemplo de modelos en Unity Catalog

Migración de flujos de trabajo y modelos a Unity Catalog

Databricks recomienda usar Modelos en Unity Catalog para mejorar la gobernanza, facilitar el uso compartido entre áreas de trabajo y entornos, y flujos de trabajo de MLOps más flexibles. En la tabla se comparan las funcionalidades del registro de modelos del área de trabajo y el catálogo de Unity.

Funcionalidad Registro de modelos del área de trabajo (heredado) Modelos en el catálogo de Unity (recomendado)
Referencia de las versiones del modelo por alias con nombre Fases del registro de modelos: mueva las versiones del modelo a una de las cuatro fases fijas para hacer referencia a ellas por esa fase. No se puede cambiar el nombre ni agregar fases. Alias del registro de modelos: cree hasta 10 referencias con nombre personalizadas y reasignables a las versiones del modelo para cada modelo registrado.
Creación de entornos controlados por acceso para modelos Fases del registro de modelos: use fases dentro de un modelo registrado para indicar el entorno de sus versiones de modelo, con controles de acceso solo para dos de las cuatro fases fijas (Staging y Production). Modelos registrados: cree un modelo registrado para cada entorno en el flujo de trabajo de MLOps, utilizando espacios de nombres de tres niveles y permisos del catálogo de Unity para expresar la gobernanza.
Promoción de modelos entre entornos (implementar modelo) Use la API de cliente de MLflow de transition_model_version_stage() para mover una versión de modelo a otra fase, lo que podría interrumpir los flujos de trabajo que hacen referencia a la fase anterior. Use la API de cliente de MLflow de copy_model_version() para copiar una versión de modelo de un modelo registrado a otro.
Acceso y uso compartido de modelos entre áreas de trabajo Exporte e importe manualmente modelos entre áreas de trabajo o configure conexiones a registros de modelos remotos mediante tokens de acceso personal y ámbitos secretos del área de trabajo. Acceso de fábrica a los modelos entre áreas de trabajo de la misma cuenta. No requiere configuración.
Configuración de permisos Establezca permisos en el nivel de área de trabajo. Establezca permisos en el nivel de cuenta, que aplica una gobernanza coherente entre áreas de trabajo.
Obtención de acceso a los modelos de marketplace de Databricks No disponible. Cargue modelos desde el marketplace de Databricks en el metastore del catálogo de Unity y acceda a ellos entre áreas de trabajo.

Los artículos vinculados a continuación describen cómo migrar flujos de trabajo (trabajos de inferencia por lotes y entrenamiento de modelos) y modelos del registro de modelos del área de trabajo al catálogo de Unity.

Limitaciones de la compatibilidad con Unity Catalog

  • Las fases no son compatibles con los modelos en Unity Catalog. Databricks recomienda usar el espacio de nombres de tres niveles en Unity Catalog para expresar el entorno en el que se encuentra un modelo y usar alias para promover modelos que implementar. Consulte la guía de actualización para más información.
  • Los webhooks no son compatibles con modelos en Unity Catalog. Consulte alternativas en la guía de actualización.
  • Algunos campos y operadores de API de búsqueda no son compatibles con modelos en Unity Catalog. Esto se puede mitigar llamando a las API de búsqueda con filtros admitidos y examinando los resultados. A continuación se muestran algunos ejemplos:
    • El order_by parámetro no se admite en las API de cliente search_model_versions o search_registered_models.
    • Los filtros basados en etiquetas (tags.mykey = 'myvalue') no son compatibles consearch_model_versions ni search_registered_models.
    • Los operadores distintos a la igualdad exacta (por ejemplo, LIKE, ILIKE, !=) no son compatibles consearch_model_versions o search_registered_models.
    • No se admite la búsqueda de modelos registrados por nombre (por ejemplo, MlflowClient().search_registered_models(filter_string="name='main.default.mymodel'")). Para recuperar un modelo registrado determinado por nombre, use get_registered_model.
  • No se admiten en Unity Catalog ni emails con notificaciones ni hilos de comentarios sobre modelos registrados y versiones de modelos.
  • El registro de actividad no es compatible con los modelos en Unity Catalog. Sin embargo, puede realizar un seguimiento de la actividad en los modelos de Unity Catalog con registros de auditoría.
  • search_registered_models podría devolver resultados obsoletos para los modelos compartidos a través de Delta Sharing. Para garantizar los resultados más recientes, use la CLI de Databricks o SDK para enumerar los modelos de un esquema.