Condividi tramite

Gestire il ciclo di vita del modello nel catalogo unity

Importante

Questo articolo descrive come usare Modelli in Unity Catalog come parte del flusso di lavoro di Machine Learning per gestire il ciclo di vita completo dei modelli di Machine Learning. Databricks offre una versione ospitata di MLflow Model Registry nel catalogo unity. I modelli in Unity Catalog estendono i vantaggi di Unity Catalog ai modelli di Machine Learning, inclusi il controllo di accesso centralizzato, il controllo, la derivazione e l'individuazione dei modelli nelle aree di lavoro. I modelli in Unity Catalog sono compatibili con il client Python MLflow open source.

Per una panoramica dei concetti relativi al Registro modelli, vedere MLflow per il ciclo di vita del modello di Machine Learning.

MLflow 3 apporta miglioramenti significativi al Registro modelli MLflow nel catalogo unity, consentendo ai modelli di acquisire direttamente dati come parametri e metriche e renderli disponibili in tutte le aree di lavoro e in tutti gli esperimenti. L'URI predefinito del Registro di sistema in MLflow 3 è databricks-uc, ovvero verrà usato il Registro di sistema del modello MLflow nel catalogo Unity. Per altre informazioni, vedere Introduzione a MLflow 3 per i modelli e i miglioramenti del Registro di sistema dei modelli con MLflow 3.

Requisiti

  • Il catalogo unity deve essere abilitato nell'area di lavoro. Vedere Introduzione all'uso di Unity Catalog per creare un metastore del catalogo Unity, abilitarlo in un'area di lavoro e creare un catalogo. Se Unity Catalog non è abilitato, usare il registro del modello dell'area di lavoro .

  • È necessario usare una risorsa di calcolo che abbia accesso a Unity Catalog. Per i carichi di lavoro di Machine Learning, ciò significa che la modalità di accesso del calcolo deve essere Dedicata (in precedenza un singolo utente). Per altre informazioni, vedere Modalità di accesso. Con Databricks Runtime 15.4 LTS ML e versioni successive, è anche possibile usare la modalità di accesso al gruppo dedicato.

  • Per creare nuovi modelli registrati, sono necessari i privilegi seguenti:

    • USE SCHEMA e USE CATALOG privilegi per lo schema e il catalogo che lo contiene.
    • CREATE MODEL o CREATE FUNCTION privilegio sullo schema. Per concedere privilegi, usare l'interfaccia utente di Esplora cataloghi o il comando SQLGRANT:
    GRANT CREATE MODEL ON SCHEMA <schema-name> TO <principal>

  • Se si verificano problemi di autorizzazione quando si tenta di registrare un modello, provare a impostare la variabile MLFLOW_USE_DATABRICKS_SDK_MODEL_ARTIFACTS_REPO_FOR_UC di ambiente su True. Includere una cella nel notebook con il codice seguente:

    import os
os.environ['MLFLOW_USE_DATABRICKS_SDK_MODEL_ARTIFACTS_REPO_FOR_UC'] = 'True'

    Questo approccio non può essere usato per i modelli condivisi con condivisione delta che usano l'archiviazione predefinita.

Nota

L'area di lavoro deve essere collegata a un metastore di Unity Catalog che supporta l'ereditarietà dei privilegi. Questo vale per tutti i metastore creati dopo il 25 agosto 2022. Se in esecuzione in un metastore precedente, seguire la documentazione per eseguire l'aggiornamento.

Installare e configurare il client MLflow per il catalogo Unity

Questa sezione include istruzioni per l'installazione e la configurazione del client MLflow per Unity Catalog.

Installare il client Python MLflow

Il supporto per i modelli in Unity Catalog è incluso in Databricks Runtime 13.2 ML e versioni successive (Databricks Runtime 15.0 ML e versioni successive in Azure Cina).

È anche possibile usare i modelli in Unity Catalog in Databricks Runtime 11.3 LTS e versioni successive installando la versione più recente del client Python MLflow nel notebook usando il codice seguente.

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

Configurare il client MLflow per accedere ai modelli nel catalogo unity

Se il catalogo predefinito dell'area di lavoro si trova in Unity Catalog (anziché hive_metastore) ed è in esecuzione un cluster usando Databricks Runtime 13.3 LTS o versione successiva (Databricks Runtime 15.0 o versione successiva nelle aree di Azure Cina) o usando MLflow 3, i modelli vengono creati automaticamente nel catalogo predefinito e caricati.

Per altre aree di lavoro, il client Python MLflow crea modelli nel registro dei modelli dell'area di lavoro in Databricks. Per eseguire l'aggiornamento ai modelli in Unity Catalog, usare il codice seguente nei notebook per configurare il client MLflow:

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

Per un numero ridotto di aree di lavoro in cui sia il catalogo predefinito è stato configurato per un catalogo in Unity Catalog prima di gennaio 2024 che il registro dei modelli di area di lavoro è stato usato prima di gennaio 2024, è necessario impostare manualmente il catalogo predefinito su Catalogo Unity usando il comando illustrato in precedenza.

Eseguire il training e registrare modelli compatibili con il catalogo Unity

Autorizzazioni necessarie: Per creare un nuovo modello registrato, è necessario disporre dei privilegi CREATE MODEL e USE SCHEMA sullo schema contenitore e del privilegio USE CATALOG sul catalogo contenitore. Per creare nuove versioni del modello in un modello registrato, è necessario essere il proprietario del modello registrato e avere USE SCHEMA e USE CATALOG privilegi per lo schema e il catalogo contenente il modello.

Se si verificano problemi di autorizzazione quando si tenta di registrare un modello, provare a impostare la variabile MLFLOW_USE_DATABRICKS_SDK_MODEL_ARTIFACTS_REPO_FOR_UC di ambiente su True. Questo approccio non può essere usato per i modelli condivisi con condivisione delta che usano l'archiviazione predefinita. Vedere Requisiti.

Le nuove versioni del modello di Machine Learning in UC devono avere una firma del modello. Se non registri già modelli MLflow con firme nei carichi di lavoro di addestramento del modello, è possibile:

  • Usare l'autologging di Databricks, che registra automaticamente i modelli con firme per molti dei più popolari framework di Machine Learning. Vedere framework supportati nella documentazione di MLflow.
  • Con MLflow 2.5.0 e versioni successive, è possibile specificare un esempio di input nella chiamata mlflow.<flavor>.log_model e la firma del modello viene dedotta automaticamente. Per altre informazioni, vedere la documentazione di MLflow.

Passare quindi il nome a tre livelli del modello alle API MLflow, nel formato <catalog>.<schema>.<model>.

Le versioni del modello che non hanno firme presentano alcune limitazioni. Per un elenco di queste limitazioni e per aggiungere o aggiornare una firma per una versione del modello esistente, vedere Aggiungere o aggiornare una firma per una versione del modello esistente.

Gli esempi in questa sezione creano e accedono ai modelli dello schema ml_team e del catalogo prod.

Gli esempi di addestramento del modello in questa sezione creano una nuova versione del modello e la registrano nel catalogo prod. L'uso del catalogo prod non implica necessariamente che la versione del modello gestisca il traffico di produzione. La versione del modello che racchiude il catalogo, lo schema e il modello registrato riflettono il relativo ambiente (prod) e le regole di governance associate (ad esempio, i privilegi possono essere configurati in modo che solo gli amministratori possano eliminare dal prod catalogo), ma non il relativo stato di distribuzione. Per gestire lo stato della distribuzione, usare gli alias del modello.

Registrare un modello in Unity Catalog utilizzando l'autologging

Per registrare un modello, usare il metodo register_model() dell'API MLflow Client. Vedere mlflow.register_model.

MLflow 3

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,
# and the model version will contain all parameters and metrics
# logged with the corresponding MLflow Logged Model.
logged_model = mlflow.last_logged_model()
mlflow.register_model(logged_model.model_uri, "prod.ml_team.iris_model")

MLflow 2.x

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")

Registrare un modello usando l'API

MLflow 3

mlflow.register_model(
  "models:/<model_id>", "prod.ml_team.iris_model"
)

MLflow 2.x

mlflow.register_model(
  "runs:/<run_id>/model", "prod.ml_team.iris_model"
)

Registrare un modello in Unity Catalog con firma dedotta automaticamente

Il supporto per le firme dedotte automaticamente è disponibile in MLflow versione 2.5.0 e successive ed è supportato in Databricks Runtime 11.3 LTS ML e versioni successive. Per usare firme dedotte automaticamente, usare il codice seguente per installare il client Python MLflow più recente nel notebook:

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

Il codice seguente mostra un esempio di firma dedotta automaticamente. Si noti che utilizzare registered_model_name nella chiamata log_model() registra il modello su Unity Catalog, quindi è necessario fornire il nome completo del modello a tre livelli nel formato <catalog>.<schema>.<model>.

MLflow 3

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,
        name="model",
        # The signature is automatically inferred from the input example and its predicted output.
        input_example=input_example,
        # Use three-level name to register model in Unity Catalog.
        registered_model_name="prod.ml_team.iris_model",
    )

MLflow 2.x

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,
        # Use three-level name to register model in Unity Catalog.
        registered_model_name="prod.ml_team.iris_model",
    )

Registrare un modello usando l'interfaccia utente

Seguire questa procedura:

  1. Nella pagina di esecuzione dell'esperimento fare clic su Registra modello nell'angolo superiore destro dell'interfaccia utente.

  2. Nella finestra di dialogo selezionare Catalogo Unity e selezionare un modello di destinazione dall'elenco a discesa.

    Finestra di dialogo per registrare la versione del modello con menu a discesa

  3. Fare clic su Registra.

    Finestra di dialogo per registrare versione modello con pulsante

La registrazione di un modello può richiedere tempo. Per monitorare lo stato di avanzamento, passare al modello di destinazione in Unity Catalog e aggiornare periodicamente.

Aggiungere o aggiornare una firma per una versione del modello esistente

Le versioni del modello che non hanno firme presentano le limitazioni seguenti:

  • Se viene fornita una firma, gli input del modello vengono controllati all'inferenza e viene segnalato un errore se gli input non corrispondono alla firma. Senza una firma, non esiste alcuna imposizione automatica dell'input e i modelli devono essere in grado di gestire input imprevisti.
  • L'uso di una versione del modello con le funzioni di intelligenza artificiale richiede la fornitura di uno schema nella chiamata di funzione.
  • L'uso di una versione del modello con Model Serving non genera automaticamente esempi di input.

Per aggiungere o aggiornare una firma della versione del modello, vedere la documentazione di MLflow.

Usare gli alias del modello

Gli alias del modello consentono di assegnare un riferimento modificabile denominato a una determinata versione di un modello registrato. È possibile usare alias per indicare lo stato di distribuzione di una versione del modello. Ad esempio, è possibile allocare un alias "Campione" alla versione del modello attualmente in produzione e impostare come destinazione questo alias nei carichi di lavoro che usano il modello di produzione. È quindi possibile aggiornare il modello di produzione riassegnando l'alias "Champion" a una versione del modello diversa.

Impostare ed eliminare alias nei modelli

Autorizzazioni necessarie: proprietario del modello registrato, oltre USE SCHEMAUSE CATALOG ai privilegi per lo schema e il catalogo che contiene il modello.

È possibile impostare, aggiornare e rimuovere alias per i modelli nel catalogo unity usando Esplora cataloghi. Vedere Visualizzare e gestire i modelli nell'interfaccia utente.

Per impostare, aggiornare ed eliminare alias usando l'API client MLflow, vedere gli esempi seguenti:

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")

Per altre informazioni sulle API client alias, vedere la documentazione dell'API MLflow.

Caricare la versione del modello in base all'alias per compiti di inferenza

Autorizzazioni necessarie: EXECUTE privilegi per il modello registrato, oltre USE SCHEMAUSE CATALOG ai privilegi per lo schema e il catalogo che contiene il modello.

I carichi di lavoro di inferenza batch possono fare riferimento a una versione del modello in base all'alias. Il frammento di codice seguente carica e applica la versione del modello "Campione" per l'inferenza batch. Se la versione "Principale" viene aggiornata per fare riferimento a una nuova versione del modello, il carico di lavoro di inferenza batch lo utilizza automaticamente durante la prossima esecuzione. In questo modo è possibile separare le distribuzioni di modelli dai carichi di lavoro di inferenza batch.

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)

Gli endpoint di servizio del modello possono anche fare riferimento a una versione del modello tramite un alias. È possibile scrivere flussi di lavoro di distribuzione per ottenere una versione del modello in base all'alias e aggiornare un endpoint del modello che serve tale versione, usando l'API REST del modello. Ad esempio:

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(...)

Caricare la versione del modello in base al numero di versione per i carichi di lavoro di inferenza

È anche possibile caricare le versioni del modello in base al numero di versione:

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)

Condividere modelli tra le aree di lavoro

Condividere modelli con gli utenti nella stessa area

Se si hanno i privilegi appropriati, è possibile accedere ai modelli in Unity Catalog da qualsiasi area di lavoro collegata al metastore contenente il modello. Ad esempio, è possibile accedere ai modelli dal catalogo prod in un'area di lavoro di sviluppo per facilitare il confronto dei modelli appena sviluppati con la baseline di produzione.

Per collaborare con altri utenti (condividere privilegi di scrittura) su un modello registrato creato, è necessario concedere la proprietà del modello a un gruppo contenente se stessi e agli utenti con cui si vuole collaborare. I collaboratori devono inoltre disporre dei privilegi di USE CATALOG e USE SCHEMA per il catalogo e lo schema che contengono il modello. Vedere Privilegi del catalogo Unity e oggetti protetti per informazioni dettagliate.

Condividere modelli con utenti in un'altra area o account

Per condividere modelli con utenti in altre aree o account, usare il flusso di condivisione Delta Databricks-to-Databricks. Vedere Aggiungere modelli a una condivisione (per i provider) e Ottenere l'accesso nel modello da Databricks a Databricks (per i destinatari). Come destinatario, dopo aver creato un catalogo da una condivisione, si accede ai modelli in tale catalogo condiviso allo stesso modo di qualsiasi altro modello in Unity Catalog.

Tenere traccia della derivazione dei dati di un modello in Unity Catalog

Nota

Il supporto per la derivazione da tabella a modello in Unity Catalog è disponibile in MLflow 2.11.0 e versioni successive.

Quando si esegue il training di un modello in una tabella in Unity Catalog, è possibile tenere traccia della derivazione del modello nei set di dati upstream su cui è stato eseguito il training e la valutazione. A tale scopo, usare mlflow.log_input. In questo modo vengono salvate le informazioni della tabella di input con l'esecuzione MLflow che ha generato il modello. La lineage dei dati viene acquisita automaticamente anche per i modelli registrati utilizzando le API del feature store. Vedere Governance delle funzionalità e derivazione.

Quando si registra il modello in Unity Catalog, le informazioni di derivazione vengono salvate automaticamente ed è visibile nella scheda Derivazione della pagina della versione del modello in Esplora cataloghi. Vedere Visualizzare le informazioni sulla versione del modello e la derivazione del modello.

Il seguente codice illustra un esempio.

MLflow 3

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")
    # 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,
        name="model",
        # The signature is automatically inferred from the input example and its predicted output.
        input_example=input_example,
        # Use three-level name to register model in Unity Catalog.
        registered_model_name="prod.ml_team.iris_classifier",
    )

MLflow 2.x

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")
    # 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,
        # Use three-level name to register model in Unity Catalog.
        registered_model_name="prod.ml_team.iris_classifier",
    )

Controllare l'accesso ai modelli

In Unity Catalog, i modelli registrati sono un sottotipo dell'oggetto proteggibile FUNCTION. Per concedere l'accesso a un modello registrato in Unity Catalog, usare GRANT ON FUNCTION. È anche possibile usare Esplora cataloghi per impostare la proprietà e le autorizzazioni del modello. Per informazioni dettagliate, vedere Gestire i privilegi nel catalogo unity e nel modello a oggetti del catalogo Unity.

È possibile configurare le autorizzazioni del modello a livello di codice usando l'API REST Grant. Quando si configurano le autorizzazioni del modello, impostare securable_type su "FUNCTION" nelle richieste dell'API REST. Ad esempio, usare PATCH /api/2.1/unity-catalog/permissions/function/{full_name} per aggiornare le autorizzazioni del modello registrato.

Visualizzare e gestire i modelli nell'interfaccia utente

Autorizzazioni necessarie: per visualizzare un modello registrato e le relative versioni del modello nell'interfaccia utente, è necessario EXECUTE disporre dei privilegi per il modello registrato, oltre USE SCHEMAUSE CATALOG ai privilegi per lo schema e il catalogo contenente il modello

È possibile visualizzare e gestire i modelli registrati e le versioni dei modelli nel catalogo unity usando Esplora cataloghi.

Visualizzare le informazioni sul modello

Per visualizzare i modelli in Esplora cataloghi:

  1. Fare clic sull'icona Dati.Catalogo nella barra laterale.

  2. Selezionare una risorsa di calcolo nell'elenco a discesa in alto a destra.

  3. Nell'albero esplora cataloghi a sinistra aprire un catalogo e selezionare uno schema.

  4. Se lo schema contiene modelli, vengono visualizzati nell'albero in Modelli, come illustrato.

    Sezione dell'albero di Esplora cataloghi che mostra i modelli.

  5. Fare clic su un modello per visualizzare altre informazioni. La pagina dei dettagli del modello mostra un elenco di versioni del modello con informazioni aggiuntive.

    pagina dei dettagli del modello

Impostare gli alias del modello

Per impostare un alias del modello usando l'interfaccia utente:

  1. Nella pagina dei dettagli del modello, passa il puntatore del mouse sulla riga della versione del modello a cui si desidera aggiungere un alias. Viene visualizzato il pulsante Aggiungi alias .
  2. Fare clic su Aggiungi alias.
  3. Immettere un alias o selezionarne uno dal menu a discesa. È possibile aggiungere più alias nella finestra di dialogo.
  4. Fare clic su Salva alias.

Come aggiungere un alias a una versione del modello dalla pagina dei dettagli del modello.

Per rimuovere un alias:

  1. Sposta il cursore sulla riga per la versione del modello e fai clic sull'icona a forma di matita vicino all'alias.
  2. Nella finestra di dialogo fare clic sull'alias X che si desidera rimuovere.
  3. Fare clic su Salva alias.

Come rimuovere un alias da una versione del modello nella pagina dei dettagli del modello.

Visualizzare le informazioni sulla versione del modello e la derivazione del modello

Per visualizzare altre informazioni su una versione del modello, fare clic sul nome nell'elenco dei modelli. Verrà visualizzata la pagina della versione del modello. Questa pagina include un collegamento all'esecuzione dell'origine MLflow che ha creato la versione. In MLflow 3 è anche possibile visualizzare tutti i parametri e le metriche registrati con il modello MLflow registrato corrispondente.

MLflow 3

Pagina della versione del modello MLflow 3

MLflow 2.x

Pagina della versione del modello MLflow 2.x

Da questa pagina è possibile visualizzare la derivazione del modello nel modo seguente:

  1. Selezionare la scheda Derivazione . La barra laterale sinistra mostra i componenti registrati con il modello.

    Scheda Derivazione nella pagina di modello in Esplora Catalogo

  2. Fare clic su Visualizza grafico di derivazione. Viene visualizzato il grafico di derivazione. Per informazioni dettagliate sull'esplorazione del grafico di derivazione, vedere Acquisire ed esplorare la derivazione.

    schermata di tracciamento

  3. Per chiudere il grafico di derivazione, fare clic sul pulsante Chiudi per il grafico di derivazione nell'angolo superiore destro.

Rinominare un modello

Autorizzazioni necessarie: proprietario del modello registrato, CREATE MODEL privilegio per lo schema contenente il modello registrato e USE SCHEMAUSE CATALOG privilegi per lo schema e il catalogo contenente il modello.

Per rinominare un modello registrato, usare il metodo API rename_registered_model() client MLflow, dove <full-model-name> è il nome completo a 3 livelli del modello e <new-model-name> è il nome del modello senza il catalogo o lo schema.

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

Ad esempio, il codice seguente modifica il nome del modello hello_world in hello.

client=MlflowClient()
client.rename_registered_model("docs.models.hello_world", "hello")

Copiare una versione del modello

È possibile copiare una versione del modello da un modello a un altro nel catalogo unity.

Copiare una versione del modello usando l'interfaccia utente

Seguire questa procedura:

  1. Nella pagina della versione del modello fare clic su Copia questa versione nell'angolo superiore destro dell'interfaccia utente.

  2. Selezionare un modello di destinazione dall'elenco a discesa e fare clic su Copia.

    Finestra di dialogo Copia versione modello

Copiare un modello può richiedere tempo. Per monitorare lo stato di avanzamento, passare al modello di destinazione in Unity Catalog e aggiornare periodicamente.

Copiare la versione del modello usando l'API

Per copiare una versione del modello, usare l'API Python copy_model_version() di MLflow:

client = MlflowClient()
client.copy_model_version(
  "models:/<source-model-name>/<source-model-version>",
  "<destination-model-name>",
)

Eliminare un modello o una versione del modello

Autorizzazioni necessarie: proprietario del modello registrato, oltre USE SCHEMAUSE CATALOG ai privilegi per lo schema e il catalogo che contiene il modello.

È possibile eliminare un modello registrato o una versione del modello all'interno di un modello registrato usando l'interfaccia utente o l'API.

Avviso

Non è possibile annullare questa azione. Quando si elimina un modello, tutti gli artefatti del modello archiviati dal catalogo unity e tutti i metadati associati al modello registrato vengono eliminati.

Eliminare una versione del modello o un modello usando l'interfaccia utente

Per eliminare un modello o una versione del modello in Unity Catalog, seguire questa procedura.

  1. In Esplora cataloghi, nella pagina del modello o nella pagina della versione del modello, fare clic sull'icona del menu kebab Kebab menu icon. nell'angolo in alto a destra.

    Dalla pagina del modello:

    menu kebab della pagina modello con opzione di eliminazione

    Dalla pagina della versione del modello:

    menu kebab della pagina versione modello che permette l’eliminazione

  2. Selezionare Elimina.

  3. Viene visualizzata una finestra di dialogo di conferma. Fare clic su Elimina per confermare.

Eliminare una versione del modello o un modello usando l'API

Per eliminare una versione del modello, usare il metodo delete_model_version() dell'API MLflow Client:

# 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)

Per eliminare un modello, usare il metodo delete_registered_model() dell'API MLflow Client:

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

Usare i tag nei modelli

I tag sono coppie chiave-valore associate a modelli registrati e versioni del modello, consentendo di etichettarli e classificarli in base alla funzione o allo stato. Ad esempio, è possibile applicare un tag con chiave "task" e valore "question-answering" (visualizzato nell'interfaccia utente come task:question-answering) ai modelli registrati destinati alle attività di risposta alle domande. A livello di versione del modello, è possibile contrassegnare le versioni in fase di convalida pre-distribuzione con validation_status:pending e quelle cancellate per la distribuzione con validation_status:approved.

Autorizzazioni necessarie: proprietario o con privilegio APPLY TAG sul modello registrato, più i privilegi USE SCHEMA e USE CATALOG sullo schema e sul catalogo contenente il modello.

Per informazioni su come impostare ed eliminare tag usando l'interfaccia utente, vedere Applicare tag a oggetti a protezione diretta di Unity Catalog .

Per impostare ed eliminare tag usando l'API client MLflow, vedere gli esempi seguenti:

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")

I tag dei modelli registrati e delle versioni dei modelli devono rispettare i vincoli a livello di piattaforma.

Per altre informazioni sulle API client dei tag, vedere la documentazione dell'API MLflow.

Aggiornare una descrizione (commenti) al modello o alla versione del modello

Autorizzazioni necessarie: proprietario del modello registrato, oltre USE SCHEMAUSE CATALOG ai privilegi per lo schema e il catalogo che contiene il modello.

È possibile includere una descrizione di testo per qualsiasi modello o versione del modello nel catalogo unity. Ad esempio, si può fornire una panoramica del problema o informazioni sulla metodologia e sull'algoritmo usato.

Per i modelli, è anche possibile usare i commenti generati dall'intelligenza artificiale. Vedere Aggiungere commenti generati dall'intelligenza artificiale agli oggetti del catalogo unity.

Aggiungere una descrizione a un modello usando l'interfaccia utente

Per aggiungere una descrizione per un modello, è possibile usare i commenti generati dall'intelligenza artificiale oppure immettere commenti personalizzati. È possibile modificare i commenti generati dall'intelligenza artificiale in base alle esigenze.

  • Per aggiungere commenti generati automaticamente, fare clic sul pulsante Genera intelligenza artificiale .
  • Per aggiungere commenti personalizzati, fare clic su Aggiungi. Immettere i commenti nella finestra di dialogo e fare clic su Salva.

Pulsanti per la descrizione del modello UC

Aggiungere una descrizione alla versione del modello usando l’interfaccia utente

Per aggiungere una descrizione a una versione del modello in Unity Catalog, seguire questa procedura:

  1. Nella pagina della versione del modello fare clic sull'icona a forma di matita in Descrizione.

    icona a forma di matita per aggiungere commenti a una versione del modello

  2. Immettere i commenti nella finestra di dialogo e fare clic su Salva.

Aggiungere una descrizione al modello o alla versione del modello usando l'API

Per aggiornare una descrizione del modello registrato, usare il metodo MLflow Client API update_registered_model():

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

Per aggiornare una descrizione della versione del modello, usare il metodo update_model_version() dell'API client MLflow:

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

Elencare e cercare modelli

Per ottenere un elenco di modelli registrati in Unity Catalog, usare l'API Python search_registered_models() di MLflow:

mlflow.search_registered_models()

Per cercare un nome di modello specifico e ottenere informazioni sulle versioni del modello, usare search_model_versions():

from pprint import pprint

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

Nota

Non tutti i campi e gli operatori dell'API di ricerca sono supportati per i modelli nel catalogo unity. Per informazioni dettagliate, vedere Limitazioni .

Scaricare i file del modello (caso d'uso avanzato)

Nella maggior parte dei casi, per caricare i modelli, è consigliabile usare API MLflow come mlflow.pyfunc.load_model o mlflow.<flavor>.load_model (ad esempio, mlflow.transformers.load_model per i modelli HuggingFace).

In alcuni casi potrebbe essere necessario scaricare i file del modello per eseguire il debug del comportamento del modello o i problemi di caricamento del modello. È possibile scaricare i file del modello usando mlflow.artifacts.download_artifacts, come indicato di seguito:

import mlflow
mlflow.set_registry_uri("databricks-uc")
model_uri = f"models:/{model_name}/{version}" # reference model by version or alias
destination_path = "/local_disk0/model"
mlflow.artifacts.download_artifacts(artifact_uri=model_uri, dst_path=destination_path)

Alzare di livello un modello in ambienti diversi

Databricks consiglia di distribuire pipeline di Machine Learning come codice. In questo modo si elimina la necessità di promuovere i modelli in ambienti, poiché tutti i modelli di produzione possono essere prodotti tramite flussi di lavoro di training automatizzati in un ambiente di produzione.

In alcuni casi, tuttavia, potrebbe essere troppo costoso ripetere il training dei modelli in ambienti diversi. È invece possibile copiare le versioni del modello tra i modelli registrati nel catalogo unity per promuoverle in ambienti diversi.

Per eseguire il codice di esempio seguente sono necessari i privilegi seguenti:

  • USE CATALOG nei cataloghi staging e prod.
  • USE SCHEMA negli schemi staging.ml_team e prod.ml_team.
  • EXECUTE su staging.ml_team.fraud_detection.

Inoltre, è necessario essere il proprietario del modello registrato prod.ml_team.fraud_detection.

Il frammento di codice seguente usa l'API copy_model_versionclient MLflow, disponibile in MLflow versione 2.8.0 e successive.

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

client = mlflow.tracking.MlflowClient()
src_model_name = "staging.ml_team.fraud_detection"
src_model_version = "1"
src_model_uri = f"models:/{src_model_name}/{src_model_version}"
dst_model_name = "prod.ml_team.fraud_detection"
copied_model_version = client.copy_model_version(src_model_uri, dst_model_name)

Dopo che la versione del modello si trova nell'ambiente di produzione, è possibile eseguire qualsiasi convalida di pre-distribuzione necessaria. È quindi possibile contrassegnare la versione del modello per la distribuzione usando alias.

client = mlflow.tracking.MlflowClient()
client.set_registered_model_alias(name="prod.ml_team.fraud_detection", alias="Champion", version=copied_model_version.version)

Nell'esempio precedente solo gli utenti che possono leggere dal modello registrato staging.ml_team.fraud_detection e scrivere nel modello registrato prod.ml_team.fraud_detection possono promuovere i modelli di staging nell'ambiente di produzione. Gli stessi utenti possono anche usare alias per gestire le versioni del modello distribuite all'interno dell'ambiente di produzione. Non è necessario configurare altre regole o criteri per gestire la promozione e la distribuzione dei modelli.

È possibile personalizzare questo flusso per alzare di livello la versione del modello in più ambienti che corrispondono alla configurazione, ad esempio dev, qa e prod. Il controllo di accesso viene applicato come configurato in ogni ambiente.

notebook di esempio

Questo notebook di esempio illustra come usare i modelli nelle API del catalogo Unity per gestire i modelli in Unity Catalog, inclusa la registrazione di modelli e versioni del modello, l'aggiunta di descrizioni, il caricamento e la distribuzione di modelli, l'uso degli alias del modello e l'eliminazione di modelli e versioni del modello.

MLflow 3

Notebook di esempio di modelli nel catalogo Unity per MLflow 3

Prendere il notebook

MLflow 2.x

Notebook di esempio di modelli in Unity Catalog

Prendere il notebook

Limiti

  • Le fasi non sono supportate per i modelli su Unity Catalog. Databricks consiglia di usare lo spazio dei nomi a tre livelli in Unity Catalog per esprimere l'ambiente in cui si trova un modello e usando alias per promuovere i modelli per la distribuzione. Per informazioni dettagliate, vedere Alzare di livello un modello in ambienti diversi .
  • I webhook non sono supportati per i modelli nel catalogo unity. Vedere le alternative suggerite nella guida all'aggiornamento.
  • Alcuni campi e operatori dell'API di ricerca non sono supportati per i modelli nel catalogo unity. Questa operazione può essere mitigata chiamando le API di ricerca usando filtri supportati e analizzando i risultati. Ecco alcuni esempi:
    • Il order_by parametro non è supportato nelle API client search_model_versions o search_registered_models .
    • I filtri basati su tag (tags.mykey = 'myvalue') non sono supportati per search_model_versions o search_registered_models.
    • Gli operatori diversi dall'uguaglianza esatta (ad esempio, LIKE, ILIKE, !=) non sono supportati per search_model_versions o search_registered_models.
    • La ricerca di modelli registrati in base al nome ( ad esempio, search_registered_models(filter_string="name='main.default.mymodel'") non è supportata. Per recuperare un particolare modello registrato in base al nome, usare get_registered_model.
  • Le notifiche di posta elettronica e i thread di discussione dei commenti sui modelli registrati e le versioni del modello non sono supportati nel catalogo unity.
  • Il registro delle attività non è supportato per i modelli nel Catalogo Unity. Per tenere traccia dell'attività sui modelli in Unity Catalog, usare i log di controllo.
  • search_registered_models potrebbe restituire risultati non aggiornati per i modelli condivisi tramite la condivisione delta. Per garantire i risultati più recenti, usare l'interfaccia della riga di comando di Databricks o l'SDK per elencare i modelli in uno schema.
  • Last updated on