Udostępnij za pomocą

Zarządzanie cyklem życia modelu w Unity Catalog

Ważne

W tym artykule opisano sposób używania modeli w Unity Catalog jako część procesu uczenia maszynowego, aby zarządzać pełnym cyklem życia modeli uczenia maszynowego. Usługa Databricks udostępnia hostowaną wersję rejestru modeli MLflow w Unity Catalog. Modele w Katalogu Unity rozszerzają korzyści Katalogu Unity na modele uczenia maszynowego, w tym scentralizowaną kontrolę dostępu, inspekcję, pochodzenie i odnajdywanie modeli między różnymi obszarami roboczymi. Modele w katalogu Unity są zgodne z klientem MLflow dla języka Python o otwartym kodzie źródłowym.

Aby zapoznać się z omówieniem pojęć dotyczących rejestru modeli, zobacz MLflow for ML model lifecycle (Cykl życia modelu uczenia maszynowego MLflow).

MLflow 3 znacznie usprawnia rejestr modeli MLflow w Unity Catalog, co pozwala modelom bezpośrednio przechwytywać dane, takie jak parametry i metryki, oraz udostępniać je we wszystkich obszarach roboczych i eksperymentach. Domyślny identyfikator URI rejestru w MLflow 3 to databricks-uc, co oznacza, że zostanie użyty rejestr modeli MLflow w katalogu Unity Catalog. Aby uzyskać więcej informacji, zobacz Wprowadzenie do platformy MLflow 3 dla modeli i ulepszeń rejestru modeli za pomocą platformy MLflow 3.

Wymagania

  • Unity Catalog musi być włączony w waszym obszarze roboczym. Zobacz Rozpocznij korzystanie z Unity Catalog, aby utworzyć Metastore Unity Catalog, włączyć go w obszarze roboczym i utworzyć wykaz. Jeśli Unity Catalog nie jest włączony, użyj rejestru modeli przestrzeni roboczej.

  • Musisz użyć zasobu obliczeniowego, który ma dostęp do Unity Catalog. W przypadku obciążeń uczenia maszynowego oznacza to, że tryb dostępu obliczeniowego musi być dedykowany (dawniej pojedynczy użytkownik). Aby uzyskać więcej informacji, zobacz Tryby dostępu. W środowisku Databricks Runtime 15.4 LTS ML i nowszym można również użyć trybu dedykowanego dostępu grupy.

  • Do utworzenia nowych zarejestrowanych modeli potrzebne są następujące uprawnienia:

    • USE SCHEMA i USE CATALOG uprawnienia schematu i jego otaczającego wykazu.
    • CREATE MODEL lub CREATE FUNCTION uprawnienia w schemacie. Aby udzielić uprawnień, użyj interfejsu użytkownika Eksploratora wykazu lub polecenia SQLGRANT:
    GRANT CREATE MODEL ON SCHEMA <schema-name> TO <principal>

  • Jeśli wystąpią problemy z autoryzacją podczas próby zarejestrowania modelu, spróbuj ustawić zmienną środowiskową MLFLOW_USE_DATABRICKS_SDK_MODEL_ARTIFACTS_REPO_FOR_UC na True. Dołącz komórkę do notesu przy użyciu następującego kodu:

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

    Tej metody nie można używać w przypadku modeli udostępnionych z funkcją Delta Sharing, które używają magazynu domyślnego.

Uwaga

Obszar roboczy musi być połączony z metastore katalogu Unity, który obsługuje dziedziczenie uprawnień. Dotyczy to wszystkich magazynów metadanych utworzonych po 25 sierpnia 2022 r. Jeśli korzystasz ze starszego magazynu metadanych, postępuj zgodnie z instrukcjami, aby zaktualizować.

Zainstaluj i skonfiguruj klienta MLflow dla Unity Catalog

Ta sekcja zawiera instrukcje dotyczące instalowania i konfigurowania klienta MLflow dla Unity Catalog.

Instalowanie klienta języka Python MLflow

Obsługa modeli w Unity Catalog jest zawarta w Databricks Runtime 13.2 ML i nowszych wersjach (Databricks Runtime 15.0 ML i nowszych wersjach w Chinach na platformie Azure).

Modele można również używać w katalogu Unity na środowisku uruchomieniowym Databricks Runtime 11.3 LTS lub nowszym, instalując najnowszą wersję klienta MLflow dla języka Python w notesie za pomocą poniższego kodu.

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

Konfigurować klienta MLflow, aby uzyskać dostęp do modeli w katalogu Unity

Jeśli domyślny katalog obszaru roboczego znajduje się w Unity Catalog (zamiast hive_metastore) i uruchamiasz klaster przy użyciu Databricks Runtime 13.3 LTS lub nowszego (Databricks Runtime 15.0 lub nowszego w regionach Chin Azure) lub przy użyciu MLflow 3, modele są automatycznie tworzone i ładowane z katalogu domyślnego.

W przypadku innych obszarów roboczych klient języka Python MLflow tworzy modele w rejestrze modeli obszaru roboczego usługi Databricks. Aby zaktualizować modele w Unity Catalog, użyj następującego kodu w notatnikach, aby skonfigurować klienta MLflow.

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

W przypadku niewielkiej liczby obszarów roboczych, gdzie katalog domyślny został skonfigurowany jako katalog w Unity Catalog przed styczniem 2024 roku i gdy rejestr modeli obszarów roboczych był używany przed styczniem 2024 roku, należy ręcznie ustawić domyślny katalog na Unity Catalog, używając polecenia pokazanego powyżej.

Trenuj i rejestruj modele zgodne z katalogiem Unity

Wymagane uprawnienia: aby utworzyć nowy zarejestrowany model, potrzebne są uprawnienia CREATE MODEL i USE SCHEMA w otaczającym schemacie oraz uprawnienie USE CATALOG w otaczającym katalogu. Aby utworzyć nowe wersje modelu w ramach zarejestrowanego modelu, musisz być właścicielem zarejestrowanego modelu i mieć USE SCHEMAUSE CATALOG uprawnienia do schematu i katalogu zawierającego model.

Jeśli wystąpią problemy z autoryzacją podczas próby zarejestrowania modelu, spróbuj ustawić zmienną środowiskową MLFLOW_USE_DATABRICKS_SDK_MODEL_ARTIFACTS_REPO_FOR_UC na True. Tej metody nie można używać w przypadku modeli udostępnionych z funkcją Delta Sharing, które używają magazynu domyślnego. Zobacz Wymagania.

Nowe wersje modelu uczenia maszynowego w interfejsie użytkownika muszą mieć podpis modelu. Jeśli nie rejestrujesz jeszcze modeli MLflow z podpisami w procesach trenowania modelu, możesz rozważyć następujące opcje:

  • Użyj Databricks autologging, które automatycznie rejestruje modele z sygnaturami dla wielu popularnych platform uczenia maszynowego. Zobacz obsługiwane frameworki w dokumentacji MLflow.
  • W MLflow 2.5.0 lub nowszym można określić przykład wejściowy w wywołaniu mlflow.<flavor>.log_model, a podpis modelu jest wyprowadzany automatycznie. Aby uzyskać więcej informacji, zapoznaj się z dokumentacją platformy MLflow.

Następnie przekaż trzypoziomową nazwę modelu do interfejsów API MLflow w postaci <catalog>.<schema>.<model>.

Wersje modelu, które nie mają podpisów, mają pewne ograniczenia. Aby uzyskać listę tych ograniczeń oraz dodać lub zaktualizować podpis dla istniejącej wersji modelu, zobacz Dodawanie lub aktualizowanie podpisu dla istniejącej wersji modelu.

Przykłady w tej sekcji umożliwiają tworzenie i dostęp do modeli w schemacie ml_team w katalogu prod.

Przykłady trenowania modelu w tej sekcji tworzą nową wersję modelu i rejestrują ją w katalogu prod. Użycie katalogu prod nie musi oznaczać, że wersja modelu obsługuje ruch w środowisku produkcyjnym. Katalog, schemat i zarejestrowany model wersji odzwierciedlają jego środowisko (prod) i skojarzone zasady zarządzania (na przykład uprawnienia można skonfigurować tak, aby tylko administratorzy mogli usunąć katalog prod), ale nie jego stan wdrożenia. Aby zarządzać stanem wdrożenia, użyj aliasów modelu.

Zarejestruj model w katalogu Unity przy użyciu funkcji autologowania

Aby zarejestrować model, użyj metody interfejsu API register_model() klienta MLflow. Zobacz 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")

Rejestrowanie modelu przy użyciu interfejsu 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"
)

Zarejestruj model w Unity Catalog z automatycznie wnioskowanym podpisem

Obsługa automatycznie wnioskowanych podpisów jest dostępna w środowisku MLflow w wersji 2.5.0 lub nowszej i jest obsługiwana w środowisku Databricks Runtime 11.3 LTS ML i nowszym. Aby użyć automatycznie wnioskowanych podpisów, użyj następującego kodu, aby zainstalować najnowszego klienta języka Python MLflow w notesie:

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

Poniższy kod przedstawia przykład automatycznie wnioskowanego podpisu. Należy pamiętać, że użycie registered_model_name w wywołaniu log_model() rejestruje model w katalogu Unity, dlatego należy podać pełną trzypoziomową nazwę modelu w formacie <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",
    )

Rejestrowanie modelu przy użyciu interfejsu użytkownika

Wykonaj te kroki:

  1. Na stronie przebiegu eksperymentu kliknij pozycję Zarejestruj model w prawym górnym rogu interfejsu użytkownika.

  2. W oknie dialogowym wybierz Katalog Unity, a następnie model docelowy z listy rozwijanej.

    Okno dialogowe Rejestrowanie wersji modelu z menu rozwijanego

  3. Kliknij pozycję Zarejestruj.

    Okno dialogowe Rejestrowanie wersji modelu za pomocą przycisku

Zarejestrowanie modelu może zająć trochę czasu. Aby monitorować postęp, przejdź do modelu docelowego w Unity Catalog i regularnie odświeżaj.

Dodawanie lub aktualizowanie podpisu dla istniejącej wersji modelu

Wersje modelu, które nie mają podpisów, mają następujące ograniczenia:

  • Jeśli podano podpis, dane wejściowe modelu są sprawdzane podczas wnioskowania i zgłaszany jest błąd, jeśli dane wejściowe nie są zgodne z podpisem. Bez podpisu nie ma automatycznego wymuszania danych wejściowych, a modele muszą być w stanie obsłużyć nieoczekiwane dane wejściowe.
  • Korzystanie z wersji modelu z funkcjami sztucznej inteligencji wymaga podania schematu w wywołaniu funkcji.
  • Używanie wersji modelu z obsługą modelu nie generuje automatycznie przykładów danych wejściowych.

Aby dodać lub zaktualizować sygnaturę wersji modelu, zobacz dokumentację platformy MLflow.

Używanie aliasów modelu

Aliasy modelu umożliwiają przypisanie modyfikowalnego, nazwanego odwołania do określonej wersji zarejestrowanego modelu. Możesz użyć aliasów, aby wskazać stan wdrożenia wersji modelu. Na przykład można przydzielić alias "Champion" do wersji modelu, który jest obecnie używany w środowisku produkcyjnym, i kierować obciążenia korzystające z modelu produkcyjnego na ten alias. Następnie można zaktualizować model produkcyjny, ponownie przypisując alias "Champion" do innej wersji modelu.

Ustawianie i usuwanie aliasów w modelach

Wymagane uprawnienia: właściciel zarejestrowanego modelu oraz USE SCHEMAUSE CATALOG uprawnienia do schematu i katalogu zawierającego model.

Możesz ustawić, zaktualizować i usunąć aliasy dla modeli w wykazie aparatu Unity przy użyciu Eksploratora wykazu. Zobacz Wyświetlanie modeli i zarządzanie nimi w interfejsie użytkownika.

Aby ustawić, zaktualizować i usunąć aliasy przy użyciu interfejsu API klienta MLflow, zapoznaj się z poniższymi przykładami:

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

Aby uzyskać więcej informacji na temat interfejsów API klienta aliasów, zobacz dokumentację interfejsu API platformy MLflow.

Ładowanie wersji modelu według aliasu dla obciążeń związanych z wnioskowaniem

Wymagane uprawnienia: EXECUTE uprawnienia do zarejestrowanego modelu oraz USE SCHEMAUSE CATALOG uprawnienia schematu i katalogu zawierającego model.

Obciążenia wnioskowania wsadowego mogą odwoływać się do wersji modelu według aliasu. Poniższy fragment kodu ładuje i stosuje wersję modelu "Champion" na potrzeby wnioskowania wsadowego. Jeśli wersja "Champion" zostanie zaktualizowana w celu odwołania się do nowej wersji modelu, obciążenie wnioskowania wsadowego automatycznie wykryje ją podczas następnego wykonania. Dzięki temu można rozdzielić wdrożenia modeli od obciążeń wnioskowania wsadowego.

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)

Punkty końcowe obsługujące model mogą również odwoływać się do wersji modelu według aliasu. Możesz napisać przepływy pracy wdrażania, aby uzyskać wersję modelu według aliasu i zaktualizować punkt końcowy serwujący model, aby obsługiwał tę wersję, używając interfejsu API REST do obsługi modeli. Na przykład:

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

Ładować wersję modelu według numeru wersji dla obciążeń inferencyjnych

Wersje modelu można również załadować według numeru wersji:

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)

Udostępnianie modeli między obszarami roboczymi

Udostępnianie modeli użytkownikom w tym samym regionie

Jeśli masz odpowiednie uprawnienia, możesz uzyskać dostęp do modeli w Unity Catalog z dowolnego obszaru roboczego dołączonego do magazynu metadanych, który zawiera modele. Na przykład możesz uzyskać dostęp do modeli z prod katalogu w obszarze roboczym deweloperskim, aby ułatwić porównywanie nowo opracowanych modeli z punktem odniesienia produkcyjnym.

Aby współpracować z innymi użytkownikami (udostępniać uprawnienia do zapisu) w zarejestrowanym modelu, musisz przyznać własność modelu grupie zawierającej siebie i użytkownikom, z którymi chcesz współpracować. Współpracownicy muszą także mieć uprawnienia USE CATALOG i USE SCHEMA dotyczące katalogu i schematu zawierającego model. Aby uzyskać szczegółowe informacje, zobacz Uprawnienia Unity Catalog i obiekty zabezpieczalne.

Udostępnianie modeli użytkownikom w innym regionie lub koncie

Aby udostępnić modele użytkownikom w innych regionach lub kontach, użyj przepływu udostępniania danych usługi Delta Sharing Databricks-to-Databricks. Zobacz Dodawanie modeli do udziału (dla dostawców) i Uzyskiwanie dostępu w modelu databricks-to-Databricks (dla adresatów). Jako odbiorca, po utworzeniu wykazu z udziału, uzyskujesz dostęp do modeli w tym udostępnionym wykazie tak samo jak w przypadku dowolnego innego modelu w Unity Catalog.

Śledzenie pochodzenia danych w modelu w Unity Catalog

Uwaga

Obsługa pochodzenia tabel w wykazie aparatu Unity jest dostępna w środowisku MLflow 2.11.0 lub nowszym.

Podczas trenowania modelu na tabeli w Unity Catalog, można śledzić pochodzenie modelu od zestawów danych źródłowych, na których był trenowany i oceniany. W tym celu użyj mlflow.log_input. Spowoduje to zapisanie informacji o tabeli wejściowej z przebiegiem MLflow, który wygenerował model. Pochodzenie danych jest również automatycznie przechwytywane dla modeli rejestrowanych przy użyciu interfejsów API magazynu funkcji. Zobacz Zarządzanie cechami i pochodzenie danych.

Po zarejestrowaniu modelu w Unity Catalog informacje o pochodzeniu są automatycznie zapisywane i widoczne na karcie Pochodzenie na stronie wersji modelu w Eksploratorze Katalogu. Zobacz informacje o wersji modelu i ścieżkę modelu.

Poniższy kod przedstawia przykład.

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

Kontrola dostępu do modeli

W Unity Catalog, zarejestrowane modele są podtypem obiektu do zabezpieczenia FUNCTION. Aby udzielić dostępu do modelu zarejestrowanego w Unity Catalog, należy użyć GRANT ON FUNCTION. Eksplorator wykazu służy również do ustawiania własności i uprawnień modelu. Aby uzyskać szczegółowe informacje, zobacz Zarządzanie uprawnieniami w Unity Catalogu i model obiektów Unity Catalogu.

Uprawnienia modelu można skonfigurować programowo przy użyciu interfejsu REST API do zarządzania uprawnieniami. Podczas konfigurowania uprawnień modelu ustaw wartość securable_type na "FUNCTION" w żądaniach interfejsu API REST. Na przykład użyj polecenia PATCH /api/2.1/unity-catalog/permissions/function/{full_name} , aby zaktualizować zarejestrowane uprawnienia modelu.

Wyświetlanie modeli i zarządzanie nimi w interfejsie użytkownika

Wymagane uprawnienia: aby wyświetlić zarejestrowany model i jego wersje modelu w interfejsie użytkownika, potrzebujesz EXECUTE uprawnień do zarejestrowanego modelu oraz USE SCHEMAUSE CATALOG uprawnień w schemacie i wykazie zawierającym model

Zarejestrowane modele i wersje modeli można wyświetlać i zarządzać nimi w Katalogu Unity przy użyciu Eksploratora Katalogu Unity.

Wyświetlanie informacji o modelu

Aby wyświetlić modele w Eksploratorze wykazu:

  1. Kliknij ikonę Dane.Wykaz na pasku bocznym.

  2. Wybierz zasób obliczeniowy z listy rozwijanej w prawym górnym rogu.

  3. W drzewie Eksploratora katalogu po lewej stronie, otwórz katalog i wybierz schemat.

  4. Jeśli schemat zawiera jakiekolwiek modele, są one wyświetlane w drzewie w obszarze Modele, jak pokazano.

    Sekcja drzewa eksploratora katalogu przedstawiająca modele.

  5. Kliknij model, aby wyświetlić więcej informacji. Na stronie szczegółów modelu zostanie wyświetlona lista wersji modelu z dodatkowymi informacjami.

    strona szczegółów modelu

Ustawianie aliasów modelu

Aby ustawić alias modelu przy użyciu interfejsu użytkownika:

  1. Na stronie szczegółów modelu umieść kursor nad wierszem wersji modelu, do której chcesz dodać alias. Zostanie wyświetlony przycisk Dodaj alias .
  2. Kliknij pozycję Dodaj alias.
  3. Wprowadź alias lub wybierz jeden z menu rozwijanego. W oknie dialogowym można dodać wiele aliasów.
  4. Kliknij pozycję Zapisz aliasy.

Jak dodać alias do wersji modelu ze strony szczegółów modelu.

Aby usunąć alias:

  1. Umieść kursor nad wierszem dotyczącym wersji modelu i kliknij ikonę ołówka obok wskazanego aliasu.
  2. W oknie dialogowym kliknij X obok aliasu, który chcesz usunąć.
  3. Kliknij pozycję Zapisz aliasy.

Jak usunąć alias z wersji modelu na stronie szczegółów modelu.

Wyświetlanie informacji o wersji modelu i pochodzenia modelu

Aby wyświetlić więcej informacji na temat wersji modelu, kliknij jej nazwę na liście modeli. Zostanie wyświetlona strona wersji modelu. Ta strona zawiera link do źródłowego przebiegu MLflow, który stworzył tę wersję. W MLflow 3 można również wyświetlić wszystkie parametry i metryki zarejestrowane wraz z odpowiednim modelem zarejestrowanym w MLflow.

MLflow 3

Strona wersji modelu MLflow 3

MLflow 2.x

Strona wersji modelu MLflow 2.x

Na tej stronie można wyświetlić pochodzenie modelu w następujący sposób:

  1. Wybierz kartę Rodowód. Lewy pasek boczny pokazuje składniki, które zostały zanotowane z modelem.

    zakładka linia pochodzenia na stronie modelu w Eksploratorze katalogu

  2. Kliknij Zobacz wykres pochodzenia. Zostanie wyświetlony wykres pochodzenia. Aby uzyskać szczegółowe informacje na temat eksplorowania grafu pochodzenia, zobacz Przechwytywanie i eksplorowanie grafu pochodzenia.

    ekran rodowodu

  3. Aby zamknąć wykres pochodzenia, kliknij przycisk zamknięcia wykresu pochodzenia w prawym górnym rogu.

Zmienianie nazwy modelu

Wymagane uprawnienia: właściciel zarejestrowanego modelu, CREATE MODEL uprawnienia do schematu zawierającego zarejestrowany model oraz USE SCHEMA uprawnienia schematu i USE CATALOG katalogu zawierającego model.

Aby zmienić nazwę zarejestrowanego modelu, użyj metody interfejsu API rename_registered_model() klienta MLflow, gdzie <full-model-name> jest pełną nazwą 3-poziomową modelu i <new-model-name> jest nazwą modelu bez wykazu lub schematu.

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

Na przykład poniższy kod zmienia nazwę modelu hello_world na hello.

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

Kopiowanie wersji modelu

Wersję modelu można skopiować z jednego modelu do innego w Unity Catalog.

Kopiowanie wersji modelu przy użyciu interfejsu użytkownika

Wykonaj te kroki:

  1. Na stronie wersji modelu kliknij pozycję Kopiuj tę wersję w prawym górnym rogu interfejsu użytkownika.

  2. Wybierz model docelowy z listy rozwijanej i kliknij pozycję Kopiuj.

    Okno dialogowe Kopiowania wersji modelu

Kopiowanie modelu może zająć trochę czasu. Aby monitorować postęp, przejdź do modelu docelowego w Unity Catalog i regularnie odświeżaj.

Kopiowanie wersji modelu przy użyciu interfejsu API

Aby skopiować wersję modelu, użyj interfejsu API języka Python copy_model_version() platformy MLflow:

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

Usuwanie modelu lub wersji modelu

Wymagane uprawnienia: właściciel zarejestrowanego modelu oraz USE SCHEMAUSE CATALOG uprawnienia do schematu i katalogu zawierającego model.

Możesz usunąć zarejestrowany model lub wersję modelu w ramach zarejestrowanego modelu przy użyciu interfejsu użytkownika lub interfejsu API.

Ostrzeżenie

Nie można cofnąć tej akcji. Kiedy usuniesz model, wszystkie artefakty modelu przechowywane przez Unity Catalog oraz wszystkie metadane związane z zarejestrowanym modelem zostaną usunięte.

Usuń wersję modelu lub model za pomocą interfejsu użytkownika

Aby usunąć model lub wersję modelu w katalogu Unity, postępuj zgodnie z poniższymi krokami.

  1. W Eksploratorze wykazu na stronie modelu lub na stronie wersji modelu kliknij ikonę menu kebab Kebab. W prawym górnym rogu.

    Na stronie modelu:

    menu kebab na stronie modelu z opcją usunięcia

    Na stronie wersji modelu:

    menu kebab z usunięciem na stronie wersji modelu

  2. Wybierz Usuń.

  3. Pojawia się okno dialogowe potwierdzenia. Kliknij przycisk Usuń , aby potwierdzić.

Usuń wersję modelu lub model za pomocą interfejsu API

Aby usunąć wersję modelu, użyj metody delete_model_version() interfejsu API klienta platformy MLflow:

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

Aby usunąć model, użyj metody delete_registered_model() interfejsu API klienta platformy MLflow:

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

Używanie tagów w modelach

Tagi to pary klucz-wartość, które są skojarzone z zarejestrowanymi modelami i wersjami modelu, co umożliwia etykietowanie i kategoryzowanie ich według funkcji lub stanu. Można na przykład zastosować tag z kluczem "task" i wartością "question-answering" (wyświetlaną w interfejsie użytkownika jako task:question-answering) do zarejestrowanych modeli przeznaczonych do zadań odpowiadania na pytania. Na poziomie wersji modelu można oznaczyć wersje w ramach weryfikacji przed wdrożeniem za pomocą oznaczenia validation_status:pending i te, które są gotowe do wdrożenia za pomocą oznaczenia validation_status:approved.

Wymagane uprawnienia: właściciel lub osoba posiadająca APPLY TAG uprawnienia do zarejestrowanego modelu oraz USE SCHEMA oraz USE CATALOG uprawnienia w schemacie i wykazie zawierającym model.

Zobacz Stosowanie tagów do zabezpieczanych obiektów Unity Catalog, aby dowiedzieć się, jak ustawiać i usuwać tagi przy użyciu interfejsu użytkownika.

Aby ustawić i usunąć tagi przy użyciu interfejsu API klienta MLflow, zobacz poniższe przykłady:

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

Zarówno zarejestrowane tagi modelu, jak i wersji modelu muszą spełniać ograniczenia dotyczące całej platformy.

Aby uzyskać więcej informacji na temat interfejsów API klienta tagów, zobacz dokumentację interfejsu API platformy MLflow.

Dodaj opis (komentarz) do modelu lub wersji modelu

Wymagane uprawnienia: właściciel zarejestrowanego modelu oraz USE SCHEMAUSE CATALOG uprawnienia do schematu i katalogu zawierającego model.

Możesz dołączyć opis tekstowy dla dowolnego modelu lub wersji modelu w katalogu Unity. Na przykład możesz podać omówienie problemu lub informacji na temat używanej metodologii i algorytmu.

W przypadku modeli można również używać komentarzy generowanych przez sztuczną inteligencję. Zobacz Dodawanie komentarzy generowanych przez sztuczną inteligencję do obiektów katalogu Unity.

Dodawanie opisu do modelu przy użyciu interfejsu użytkownika

Aby dodać opis modelu, możesz użyć komentarzy generowanych przez sztuczną inteligencję lub wprowadzić własne komentarze. W razie potrzeby można edytować komentarze generowane przez sztuczną inteligencję.

  • Aby dodać automatycznie wygenerowane komentarze, kliknij przycisk Wygeneruj przez AI.
  • Aby dodać własne komentarze, kliknij przycisk Dodaj. Wprowadź komentarze w oknie dialogowym, a następnie kliknij przycisk Zapisz.

Przyciski opisu modelu uc

Dodawanie opisu do wersji modelu przy użyciu interfejsu użytkownika

Aby dodać opis do wersji modelu w katalogu Unity, wykonaj następujące kroki:

  1. Na stronie wersja modelu kliknij ikonę ołówka w obszarze Opis.

    ikona ołówka w celu dodania komentarzy do wersji modelu

  2. Wprowadź komentarze w oknie dialogowym, a następnie kliknij przycisk Zapisz.

Dodawanie opisu do modelu lub wersji modelu przy użyciu interfejsu API

Aby zaktualizować opis zarejestrowanego modelu, użyj metody interfejsu API update_registered_model() klienta MLflow:

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

Aby zaktualizować opis wersji modelu, użyj metody update_model_version() interfejsu API klienta platformy MLflow:

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

Wyszukiwanie i przeglądanie modeli

Aby uzyskać listę zarejestrowanych modeli w katalogu Unity, użyj funkcji API MLflow search_registered_models() języka Python.

mlflow.search_registered_models()

Aby wyszukać określoną nazwę modelu i uzyskać informacje o wersjach tego modelu, użyj polecenia search_model_versions():

from pprint import pprint

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

Uwaga

Nie wszystkie pola i operatory interfejsu API wyszukiwania są obsługiwane w przypadku modeli w Unity Catalog. Zobacz Ograniczenia, aby poznać szczegóły.

Pobieranie plików modelu (zaawansowany przypadek użycia)

W większości przypadków, aby załadować modele, należy użyć interfejsów API MLflow, takich jak mlflow.pyfunc.load_model lub mlflow.<flavor>.load_model (na przykład mlflow.transformers.load_model w przypadku modeli HuggingFace).

W niektórych przypadkach może być konieczne pobranie plików modelu w celu debugowania zachowania modelu lub problemów z ładowaniem modelu. Pliki modelu można pobrać przy użyciu metody mlflow.artifacts.download_artifactsw następujący sposób:

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)

Promowanie modelu w różnych środowiskach

Databricks rekomenduje wdrożenie potoków uczenia maszynowego w formie kodu. Eliminuje to konieczność promowania modeli w różnych środowiskach, ponieważ wszystkie modele produkcyjne mogą być tworzone za pośrednictwem zautomatyzowanych przepływów pracy trenowania w środowisku produkcyjnym.

Jednak w niektórych przypadkach ponowne trenowanie modeli w różnych środowiskach może być zbyt kosztowne. Zamiast tego możesz kopiować wersje modeli między zarejestrowanymi modelami w katalogu Unity, aby przenieść je w różnych środowiskach.

Do wykonania przykładowego kodu poniżej potrzebne są następujące uprawnienia:

  • USE CATALOG w katalogach staging i prod .
  • USE SCHEMA w schematach staging.ml_team i prod.ml_team.
  • EXECUTEna .staging.ml_team.fraud_detection

Ponadto musisz być właścicielem zarejestrowanego modelu prod.ml_team.fraud_detection.

Poniższy fragment kodu używa interfejsu API klienta MLflow dostępnego copy_model_versionw środowisku MLflow w wersji 2.8.0 lub nowszej.

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)

Gdy wersja modelu znajduje się w środowisku produkcyjnym, możesz wykonać dowolną niezbędną weryfikację przed wdrożeniem. Następnie możesz oznaczyć wersję modelu do wdrożenia przy użyciu aliasów.

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

W powyższym przykładzie tylko użytkownicy, którzy mogą odczytywać z staging.ml_team.fraud_detection zarejestrowanego modelu i zapisywać do zarejestrowanego modelu prod.ml_team.fraud_detection, mogą promować modele przejściowe do środowiska produkcyjnego. Ci sami użytkownicy mogą również używać aliasów do zarządzania wersjami modelu wdrożonych w środowisku produkcyjnym. Nie musisz konfigurować żadnych innych reguł ani zasad w celu nadzorowania promowania i wdrażania modelu.

Możesz dostosować ten przepływ, aby podwyższyć poziom wersji modelu w wielu środowiskach, które pasują do konfiguracji, takich jak dev, qai prod. Kontrola dostępu jest wymuszana zgodnie z konfiguracją w każdym środowisku.

Przykładowy notatnik

W tym przykładowym notebooku pokazano, jak używać modeli w interfejsach API Unity Catalog do zarządzania modelami, w tym rejestrowania modeli i wersji modeli, dodawania opisów, ładowania i wdrażania modeli, używania aliasów modelu oraz usuwania modeli i wersji modelu.

MLflow 3

Przykładowy notatnik dotyczący modeli w Unity Catalog dla MLflow 3

Pobierz laptopa

MLflow 2.x

Przykładowy notatnik modeli w katalogu Unity

Pobierz laptopa

Ograniczenia

  • Etapy w modelach nie są wspierane w Unity Catalog. Usługa Databricks zaleca używanie trzy-poziomowej przestrzeni nazw w wykazie aparatu Unity do wyrażania środowiska, w których znajduje się model, i używania aliasów do promowania modeli na potrzeby wdrażania. Aby uzyskać szczegółowe informacje, zobacz Podwyższanie poziomu modelu w różnych środowiskach .
  • Webhooki nie są obsługiwane w przypadku modeli w Unity Catalog. Zobacz sugerowane alternatywy w przewodniku uaktualniania.
  • Niektóre pola i operatory interfejsu API wyszukiwania nie są obsługiwane dla modeli w katalogu Unity. Można temu zapobiec, wywołując interfejsy API wyszukiwania przy użyciu obsługiwanych filtrów i skanując wyniki. Poniżej przedstawiono kilka przykładów:
    • Parametr order_by nie jest obsługiwany w interfejsach API klienta search_model_versions ani search_registered_models .
    • Filtry oparte na tagach (tags.mykey = 'myvalue') nie są obsługiwane dla search_model_versions ani search_registered_models.
    • Operatory inne niż dokładna równość (na przykład , LIKE, ILIKE) !=nie są obsługiwane dla search_model_versions lub search_registered_models.
    • Wyszukiwanie zarejestrowanych modeli według nazwy (na przykład search_registered_models(filter_string="name='main.default.mymodel'") nie jest obsługiwane. Aby pobrać określony zarejestrowany model według nazwy, użyj get_registered_model.
  • Powiadomienia e-mail oraz wątki dyskusji dotyczące komentarzy na temat zarejestrowanych modeli i ich wersji nie są obsługiwane w Unity Catalog.
  • Dziennik aktywności nie jest obsługiwany dla modeli w Unity Catalog. Aby monitorować aktywność modeli w Unity Catalog, użyj dzienników audytu.
  • search_registered_models może zwracać nieaktualne wyniki dla modeli udostępnionych za pośrednictwem Delta Sharing. Aby zapewnić najnowsze wyniki, użyj interfejsu wiersza poleceń Databricks lub zestawu SDK, aby wyświetlić modele w schemacie.
  • Last updated on