Gestire il ciclo di vita del modello nel catalogo unity

Importante

• Questo articolo documenta i Modelli in Unity Catalog, che Databricks consiglia per la gestione e la distribuzione dei modelli. Se l'area di lavoro non è abilitata per Unity Catalog, la funzionalità in questa pagina non è disponibile. Invece, vedere Gestire il ciclo di vita del modello usando il Registro modelli dell’area di lavoro (legacy). Per indicazioni su come eseguire l'aggiornamento dal Registro modelli di area di lavoro al catalogo Unity, vedere Eseguire la migrazione di flussi di lavoro e modelli a Unity Catalog.
• I modelli in Unity Catalog non sono disponibili nelle aree di Azure per enti pubblici.

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 fornisce una versione ospitata di MLflow Model Registry in Unity Catalog. 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 l'agente di intelligenza artificiale generativa e il ciclo di vita del modello di apprendimento automatico.

Requisiti

1. Il catalogo unity deve essere abilitato nell'area di lavoro. Consultare Iniziare a utilizzare Unity Catalog per creare un metastore di Unity Catalog, abilitarlo in uno spazio di lavoro e creare un catalogo. Se Unity Catalog non è abilitato, usare il registro del modello dell'area di lavoro .

2. È 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 per l'ambiente di calcolo deve essere Utente singolo. Per altre informazioni, vedere Modalità di accesso. Con Databricks Runtime 15.4 LTS ML e versioni successive, è anche possibile usare modalità di accesso dedicato al gruppo.

3. 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 privilegio sullo schema. Per concedere questo privilegio, usare l'interfaccia utente di Esplora cataloghi o il seguente comando GRANT SQL:

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

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 l'area di lavoro catalogo predefinito 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), i modelli vengono creati automaticamente e caricati dal catalogo predefinito. Non è necessario eseguire questo passaggio.

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, sono necessari i privilegi CREATE_MODEL e USE SCHEMA sullo schema contenitore e il 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.

Le versioni del modello ML in UC devono avere una firma del modello. Se non si registrano già modelli MLflow con firme nei carichi di lavoro di training del modello, è possibile:

• Usare la registrazione automatica di Databricks, che registra automaticamente i modelli con firme per molti framework di Machine Learning più diffusi. Vedere i 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, consultare la documentazione di MLflow.

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

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 consenta di gestire il traffico di produzione. Il catalogo, lo schema e il modello registrato che avvolgono la versione del modello riflettono il suo ambiente (prod) e le regole di governance associate (ad esempio, i privilegi possono essere configurati in modo che solo gli amministratori possano eliminare dal catalogo prod), ma non riflettono il suo 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.

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.register_model(
  "runs:/<run_uuid>/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.

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

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 Unitye selezionare un modello di destinazione dall'elenco a discesa.

   

3. Fare clic su Registra.

   

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.

Distribuire modelli usando alias

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 ai privilegi di USE SCHEMA e USE CATALOG per lo schema e il catalogo contenente il modello.

È possibile impostare, aggiornare e rimuovere alias per i modelli nel catalogo Unity usando Esplora cataloghi. È possibile gestire gli alias in un modello registrato nella pagina dei dettagli del modello e configurare gli alias per una versione specifica del modello nella pagina dei dettagli della versione del modello.

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 i carichi di lavoro di inferenza

Autorizzazioni necessarie: privilegi di EXECUTE per il modello registrato, oltre ai privilegi USE SCHEMA e USE CATALOG nello schema e nel catalogo contenente 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 "Campione" viene aggiornata per fare riferimento a una nuova versione del modello, il carico di lavoro di inferenza batch lo preleva automaticamente alla successiva 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)

I modelli che servono gli endpoint possono anche fare riferimento a una versione del modello in base all'alias. È possibile scrivere flussi di lavoro di distribuzione per ottenere una versione del modello in base all'alias e aggiornare un endpoint di gestione del modello per soddisfare tale versione, usando il modello di che gestisce l'API REST. 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. Per informazioni dettagliate, vedere i privilegi del catalogo Unity e gli oggetti proteggibili.

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 di Databricks a Databricks. Vedi Aggiungi modelli a una condivisione (per i provider) e Ottieni l'accesso nel modello 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 derivazione dei dati viene acquisita automaticamente anche per i modelli registrati usando le API dell'archivio funzionalità. Vedere Governance e derivazione delle funzionalità.

Quando si registra il modello in Unity Catalog, le informazioni di derivazione vengono salvate automaticamente e sono visibili nella scheda derivazione dell'interfaccia utente della versione del modello in Catalog Explorer.

Il seguente codice illustra un esempio.

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,
        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. Per informazioni dettagliate, vedere i privilegi di Unity Catalog e gli oggetti proteggibili. Per le procedure consigliate sull'organizzazione dei modelli tra cataloghi e schemi, vedere Organizzare i dati.

È 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 i modelli nell'interfaccia utente

Autorizzazioni necessarie: per visualizzare un modello registrato e le relative versioni del modello nell'interfaccia utente, è necessario EXECUTE privilegio per il modello registrato, oltre ai privilegi USE SCHEMA e USE CATALOG sullo schema e sul catalogo contenente il modello

È possibile visualizzare e gestire modelli registrati e versioni dei modelli nel Catalogo Unity usando Catalog Explorer.

Rinominare un modello

Autorizzazioni necessarie: proprietario del modello registrato, privilegio CREATE_MODEL per lo schema contenente il modello registrato e privilegi USE SCHEMA e USE CATALOG nello schema e nel catalogo contenente il modello.

Per rinominare un modello registrato, usare il metodo rename_registered_model() dell'API MLflow Client:

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

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.

   

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

Caricare 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 ai privilegi di USE SCHEMA e USE CATALOG per lo schema e il catalogo contenente il modello.

È possibile eliminare un modello registrato o una versione del modello all'interno di un modello registrato usando l'interfaccia utente di Esplora cataloghi 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. Nella pagina del modello o nella pagina della versione del modello, fare clic sul menu kebab nell’angolo in alto a destra.

   Dalla pagina del modello:

   

   Dalla pagina della versione del modello:

   

2. Selezionare Elimina.

3. Viene visualizzata una finestra di dialogo di conferma. Cliccare 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: essere il proprietario o avere il privilegio di APPLY_TAG sul modello registrato, oltre ai privilegi di USE SCHEMA e USE CATALOG sullo schema e il catalogo che contengono il modello.

Consultare per aggiungere e aggiornare i tag usando Esplora Catalogo su come impostare ed eliminare i tag utilizzando l'interfaccia utente.

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 di versione del modello e del modello registrati devono soddisfare i vincoli a livello di piattaforma.

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

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

Autorizzazioni necessarie: proprietario del modello registrato, oltre ai privilegi di USE SCHEMA e USE CATALOG per lo schema e il catalogo contenente 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 di intelligenza artificiale.
• Per aggiungere commenti personalizzati, fare clic su Aggiungi. Immettere i commenti nella finestra di dialogo e fare clic su Salva.

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.

   

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 search_registered_models() di MLflow Python:

client=MlflowClient()
client.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

client=MlflowClient()
[pprint(mv) for mv in client.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_version client 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.

Notebook di esempio di modelli in Unity Catalog

Ottieni notebook

Eseguire la migrazione di flussi di lavoro e modelli a Unity Catalog

Databricks consiglia di usare modelli in Unity Catalog per migliorare la governance, semplificare la condivisione tra aree di lavoro e ambienti e flussi di lavoro MLOps più flessibili. La tabella confronta le funzionalità del Registro dei modelli di area di lavoro e del catalogo Unity.

Funzionalità	Registro modelli dell'area di lavoro (legacy)	Modelli nel catalogo unity (scelta consigliata)
Fare riferimento alle versioni del modello in base a alias denominati	Fasi del Registro modelli: spostare le versioni del modello in una delle quattro fasi fisse per farvi riferimento da tale fase. Impossibile rinominare o aggiungere fasi.	Alias del Registro di sistema dei modelli: creare fino a 10 riferimenti denominati personalizzati e riassegnati alle versioni del modello per ogni modello registrato.
Creare ambienti controllati dall'accesso per i modelli	Fasi del Registro modelli: usare le fasi all'interno di un modello registrato per indicare l'ambiente delle versioni del modello, con i controlli di accesso solo per due delle quattro fasi fisse (Staging e Production).	Modelli registrati: crea un modello registrato per ciascun ambiente nel flusso di lavoro MLOps, utilizzando namespace suddivisi in tre livelli e le autorizzazioni di Unity Catalog per esprimere la governance.
Alzare di livello i modelli tra ambienti (modello di distribuzione)	Usare l'API transition_model_version_stage() client MLflow per spostare una versione del modello in una fase diversa, potenzialmente interrompendo i flussi di lavoro che fanno riferimento alla fase precedente.	Usare l'API copy_model_version() client MLflow per copiare una versione del modello da un modello registrato a un altro.
Accedere e condividere modelli tra le aree di lavoro	Esporta e importa manualmente modelli tra aree di lavoro, oppure configura connessioni ai registri di modelli remoti usando token di accesso personale e ambiti segreti delle aree di lavoro.	Accesso predefinito ai modelli tra aree di lavoro nello stesso account. Non è necessaria alcuna configurazione.
Configura autorizzazioni	Impostare le autorizzazioni a livello di area di lavoro.	Impostare le autorizzazioni a livello di account, che applica una governance coerente tra le aree di lavoro.
Accedere ai modelli nel marketplace di Databricks	Non disponibile.	Caricare modelli dal marketplace di Databricks nel metastore di Unity Catalog e accedervi tra aree di lavoro.

Gli articoli collegati di seguito descrivono come migrare i flussi di lavoro e i modelli dalla Registrazione del Modello dell'Area di Lavoro al Catalogo Unity, inclusi i processi di addestramento del modello e inferenza batch.

• Aggiornare i flussi di lavoro ML per indirizzare i modelli nel Catalogo di Unity
• Aggiornare i modelli al catalogo Unity

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. 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 parametro order_by 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, MlflowClient().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, utilizzare registri 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 SDK per elencare i modelli in uno schema.