Gestire il ciclo di vita del modello nel catalogo Unity

Questo articolo descrive come usare il modelli nel catalogo Unity come parte del flusso di lavoro di apprendimento automatico per gestire il ciclo di vita completo dei modelli di ML. Databricks offre una versione ospitata di MLflow Model Registry nel catalogo Unity. I modelli nel catalogo Unity estendono i vantaggi del catalogo Unity 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 nel catalogo Unity sono compatibili con il client Python MLflow open source.

Per una panoramica dei concetti relativi al registro del modello, si veda Gestione del ciclo di vita di ML con MLflow.

Requisiti

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

2. È necessario usare una risorsa di calcolo che abbia accesso al catalogo Unity. 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.

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

   • I privilegi USE SCHEMA e USE CATALOG per lo schema e il relativo catalogo di inclusione.
   • Privilegio CREATE_MODEL per lo schema. Per concedere questo privilegio, usare l'interfaccia utente di Esplora cataloghi o il comando SQL GRANT seguente:

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

Installare e configurare il client MLflow per il catalogo Unity

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

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 nel catalogo Unity 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é in hive_metastore) ed è in esecuzione un cluster usando Databricks Runtime 13.3 LTS o versione successiva (Databricks Runtime 15.0 o versione successiva nelle regioni Azure China), 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 nel catalogo Unity, 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 nel catalogo Unity 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 sul catalogo Unity usando il comando illustrato in precedenza.

Eseguire il training e la registrazione di modelli compatibili con il catalogo Unity

Autorizzazioni necessarie: per creare un nuovo modello registrato, sono necessari i privilegi CREATE_MODEL e USE SCHEMA per lo schema di inclusione e il privilegio USE CATALOG nel catalogo contenitore. Per creare nuove versioni del modello in un modello registrato, è necessario essere il proprietario del modello registrato e disporre dei privilegi USE SCHEMA e USE CATALOG dello schema e del 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 nello schema ml_team nel catalogo prod.

Gli esempi di training del modello in questa sezione creano una nuova versione del modello e la registrano nel catalogo prod. L'uso del catalogo prod non significa necessariamente che la versione del modello gestisce 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 catalogo prod), ma non il relativo stato di distribuzione. Per gestire lo stato della distribuzione, usare gli alias del modello.

Registrare un modello nel catalogo Unity usando l'assegnazione automatica

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 nel catalogo Unity 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 Unity e 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 nel catalogo Unity 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 "Campione" a una versione del modello diversa.

Impostare ed eliminare alias nei modelli

Autorizzazioni necessarie: proprietario del modello registrato, oltre USE SCHEMA e USE 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. È 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 EXECUTE del modello registrato, oltre ai privilegi USE SCHEMA e USE 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 "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 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 nel catalogo Unity 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 avere anche i privilegi USE CATALOG e USE SCHEMA per il catalogo e lo schema che contiene il modello. Vedere Privilegi del catalogo Unity e oggetti a protezione diretta per maggiori dettagli.

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. 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 nel catalogo Unity.

Tenere traccia della derivazione dei dati di un modello nel catalogo Unity

Quando si esegue il training di un modello in una tabella nel catalogo Unity, è 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 nel catalogo Unity, le informazioni di derivazione vengono salvate automaticamente ed è visibile nella scheda Derivazione dell'interfaccia utente della versione del modello in Esplora cataloghi.

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

Nel catalogo Unity i modelli registrati sono un sottotipo dell'oggetto a protezione diretta FUNCTION. Per concedere l'accesso a un modello registrato nel catalogo Unity, usare GRANT ON FUNCTION. Per maggiori dettagli, vedere Privilegi del catalogo Unity e oggetti a protezione diretta. 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 su securable_type e "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 versioni dei modelli nell’interfaccia utente, servono i privilegi EXECUTE del modello registrato, oltre ai privilegi USE SCHEMA e USE CATALOG ai privilegi per lo schema e il catalogo che contiene il modello

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

Rinominare un modello

Autorizzazioni necessarie: proprietario del modello registrato, privilegio CREATE_MODEL dello schema contenente il modello registrato e i privilegi USE SCHEMA e USE CATALOG ai privilegi per lo schema e il catalogo che contiene 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 nel catalogo Unity 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 USE SCHEMA e USE 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 di Esplora cataloghi o l'API.

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

Per eliminare un modello o una versione del modello nel catalogo Unity, 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: proprietario di o con privilegi APPLY_TAG del modello registrato, oltre ai privilegi USE SCHEMA e USE CATALOG ai privilegi per lo schema e il catalogo che contiene il modello.

Per informazioni su come impostare ed eliminare tag usando l'interfaccia utente, vedere Aggiungere e aggiornare i tag usando Esplora cataloghi .

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 USE SCHEMA e USE 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. Consultare 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.

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

Per aggiungere una descrizione a una versione del modello nel catalogo Unity, 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 la descrizione di un modello registrato, vedere il metodo update_registered_model() dell'API MLflow Client:

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

Per aggiornare la descrizione di una versione del modello, usare il metodo update_model_version() dell'API MLflow Client:

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:

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

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 dei modelli in Unity Catalog

Prendi il notebook

Eseguire la migrazione di flussi di lavoro e modelli al catalogo Unity

Databricks consiglia di usare modelli nel catalogo Unity 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: creare un modello registrato per ogni ambiente nel flusso di lavoro MLOps, usando spazi dei nomi a tre livelli e 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	Esportare e importare manualmente modelli tra aree di lavoro o configurare connessioni ai registri modelli remoti usando token di accesso personali e ambiti dei segreti dell'area di lavoro.	Accesso predefinito ai modelli tra aree di lavoro nello stesso account. Non è necessaria alcuna configurazione.
Configura autorizzazioni	Assegnare le autorizzazioni a livello di area di lavoro.	Assegnare le autorizzazioni a livello di account, che applica una governance coerente tra le aree di lavoro.
Accedere ai modelli in Databricks markplace	Non disponibile.	Caricare modelli dal marketplace di Databricks nel metastore del catalogo Unity e accedervi tra aree di lavoro.

Gli articoli collegati di seguito descrivono come eseguire la migrazione dei flussi di lavoro (processi di training del modello e inferenza batch) e modelli dal Registro dei modelli dell'area di lavoro al catalogo Unity.

• Aggiornare i flussi di lavoro ML ai modelli di destinazione nel catalogo Unity
• Aggiornare i modelli al catalogo Unity

Limiti

• Le fasi non sono supportate per i modelli nel catalogo Unity. Databricks consiglia di usare lo spazio dei nomi a tre livelli nel catalogo Unity 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 gli 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 log 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.