Snowflake Model Registry¶

Erforderliche Berechtigungen¶

Um ein Modell zu erstellen, müssen Sie entweder Eigentümer des Schemas sein, in dem das Modell erstellt wird, oder über die Berechtigung CREATE MODEL für dieses Schema verfügen. Um ein Modell zu verwenden, müssen Sie entweder Eigentümer des Modells sein oder über die Berechtigung USAGE für das Modell verfügen. Die Berechtigung USAGE erlaubt es den Berechtigungsempfängern, das Modell für Inferenz zu nutzen, ohne dessen Interna einsehen zu können. Um Benutzern Zugriff auf alle bestehenden Modelle in einem Schema zu geben, verwenden Sie GRANT USAGE ON ALL MODELS IN SCHEMA <> TO ROLE <für die Schemarolle>;. Sie können Benutzern auch automatisch Zugriff auf zukünftige Modelle geben, die in einem Schema erstellt wurden, und zwar über GRANT USAGE ON FUTURE MODELS IN SCHEMA <> TO ROLE <für die Schemarolle>;.

Wenn eine Benutzerrolle USAGE-Berechtigungen auf ein Modell hat, erscheint sie auf der Snowsight-Model Registry-Seite. Weitere Informationen zur Funktionsweise von Berechtigungen in Snowflake finden Sie unter Zugriffssteuerungsrechte.

Aktuelle Einschränkungen¶

Die folgenden Beschränkungen gelten für Modelle und Modellversionen:

Öffnen der Snowflake Model Registry¶

Modelle sind Snowflake-Objekte erster Klasse und können zusammen mit anderen Snowflake-Objekten in einer Datenbank und einem Schema organisiert werden. Die Snowflake Model Registry stellt eine Python-Klasse zum Verwalten von Modellen innerhalb eines Schemas bereit. Somit kann jedes Snowflake-Schema als Registry verwendet werden. Es ist nicht notwendig, ein Schema für diesen Zweck zu initialisieren oder anderweitig vorzubereiten. Snowflake empfiehlt das Erstellen eines oder mehrerer dedizierter Schemas für diesen Zweck, z. B. ML.REGISTRY. Sie können das Schema mit CREATE SCHEMA erstellen.

Bevor Sie Modelle in der Registry erstellen oder ändern können, müssen Sie die Registry öffnen. Wenn Sie die Registry öffnen, erhalten Sie eine Referenz auf die Registry, mit der Sie neue Modelle hinzufügen und Referenzen auf vorhandene Modelle erhalten können.

from snowflake.ml.registry import Registry

reg = Registry(session=sp_session, database_name="ML", schema_name="REGISTRY")

Registrieren von Modellen und Versionen¶

Das Hinzufügen eines Modells zur Registry wird als Protokollierung (Logging) des Modells bezeichnet. Ein Modell wird protokolliert, indem die log_model-Methode der Registry aufgerufen wird. Diese Methode serialisiert das Modell — ein Python-Objekt — und erstellt daraus ein Snowflake-Modellobjekt. Diese Methode fügt dem Modell auch Metadaten, wie z. B. eine Beschreibung, hinzu, wie im log_model-Aufruf angegeben.

Jedes Modell kann unbegrenzt viele Versionen haben. Um weitere Versionen des Modells zu protokollieren, rufen Sie log_model erneut mit demselben model_name-Wert, aber einem anderen version_name-Wert auf.

Sie können einem Modell keine Tags hinzufügen, wenn es der Registry hinzugefügt wird, da Tags Attribute des Modells sind und log_model eine bestimmte Modellversion hinzufügt, wobei es ein Modell nur beim Hinzufügen der ersten Version erstellt. Sie können aber nach der Protokollierung der ersten Version des Modells die Tags des Modells aktualisieren.

Im folgenden Beispiel ist clf, kurz für „classifier“, das Python-Modellobjekt, das bereits an anderer Stelle in Ihrem Code erstellt wurde. Sie können beim Registrieren einen Kommentar und Tags hinzufügen, wie hier gezeigt. Die Kombination aus Name und Version muss im Schema eindeutig sein. Sie können conda_dependencies-Listen angeben; die angegebenen Pakete werden mit dem Modell bereitgestellt.

from snowflake.ml.model import type_hints
mv = reg.log_model(clf,
                   model_name="my_model",
                   version_name="v1",
                   conda_dependencies=["scikit-learn"],
                   comment="My awesome ML model",
                   metrics={"score": 96},
                   sample_input_data=train_features,
                   task=type_hints.Task.TABULAR_BINARY_CLASSIFICATION)

Im Folgenden werden die Argumente von log_model beschrieben.

Erforderliche Argumente

Optionale Argumente

log_model gibt ein snowflake.ml.model.ModelVersion-Objekt zurück, das die Version des Modells repräsentiert, die der Registry hinzugefügt wurde.

Nach der Registrierung kann das Modell selbst nicht mehr geändert werden (allerdings können seine Metadaten geändert werden). Um ein Modell und alle seine Versionen zu löschen, verwenden Sie die Methode delete_model der Registry.

Verwenden von Modellartefakten¶

Nachdem ein Modell protokolliert wurde, stehen seine Artefakte (die Dateien, die das Modell unterstützen, einschließlich seiner serialisierten Python-Objekte und verschiedener Metadaten-Dateien wie z. B. die Manifest-Datei) in einem internen Stagingbereich zur Verfügung. Artefakte können nicht verändert werden, aber Sie können die Artefakte der Modelle, deren Eigentümer Sie sind, anzeigen oder herunterladen.

Sie können auf Modellartefakte aus einem Stagingbereich zugreifen, indem Sie z. B. den Befehl GET oder sein Äquivalent in Snowpark Python FileOperation.get verwenden.

Allerdings können Sie Modellartefakte nicht mit der üblichen Syntax des Stagingbereichs verwenden. Verwenden Sie stattdessen eine snow://-URL, was eine allgemeinere Methode zum Angeben des Speicherorts von Objekten in Snowflake ist. Beispielweise kann eine Version innerhalb eines Modells durch eine URL im Format snow://model/<model_name>/versions/<version_name>/ angegeben werden.

Wenn Sie den Namen des Modells und die gewünschte Version kennen, können Sie den Befehl LIST verwenden, um die Artefakte des Modells wie folgt anzuzeigen:

LIST 'snow://model/my_model/versions/V3/';

Die Ausgabe sieht wie folgt aus:

name                                      size                  md5                      last_modified
versions/V3/MANIFEST.yml           30639    2f6186fb8f7d06e737a4dfcdab8b1350        Thu, 18 Jan 2024 09:24:37 GMT
versions/V3/functions/apply.py      2249    e9df6db11894026ee137589a9b92c95d        Thu, 18 Jan 2024 09:24:37 GMT
versions/V3/functions/predict.py    2251    132699b4be39cc0863c6575b18127f26        Thu, 18 Jan 2024 09:24:37 GMT
versions/V3/model.zip             721663    e92814d653cecf576f97befd6836a3c6        Thu, 18 Jan 2024 09:24:37 GMT
versions/V3/model/env/conda.yml          332        1574be90b7673a8439711471d58ec746        Thu, 18 Jan 2024 09:24:37 GMT
versions/V3/model/model.yaml       25718    33e3d9007f749bb2e98f19af2a57a80b        Thu, 18 Jan 2024 09:24:37 GMT

Um eines dieser Artefakte abzurufen, verwenden Sie den SQL-Befehl GET:

GET 'snow://model/model_my_model/versions/V3/MANIFEST.yml'

Oder das Äquivalent in Snowpark Python:

session.file.get('snow://model/my_model/versions/V3/MANIFEST.yml', 'model_artifacts')

Löschen von Modellen¶

Verwenden Sie die delete_model-Methode der Registry, um ein Modell und alle seine Versionen zu löschen:

reg.delete_model("mymodel")

Abrufen von Modellen aus der Registry¶

Um Informationen zu jedem Modell zu erhalten, verwenden Sie die Methode show_models:

model_df = reg.show_models()

Das Ergebnis von show_models ist ein pandas-DataFrame. Die verfügbaren Spalten sind hier aufgelistet:

Um stattdessen eine Liste der Modelle in der Registry zu erhalten, jedes als Model-Instanz, verwenden Sie die Methode models:

model_list = reg.models()

Um eine Referenz auf ein bestimmtes Modell aus der Registry über den Namen zu erhalten, verwenden Sie die Methode get_model der Registry:

m = reg.get_model("MyModel")

Nachdem Sie einen Verweis auf ein Modell haben, entweder eines aus der von der Methode models zurückgegebenen Liste oder eines, das mit get_model abgerufen wurde, können Sie deren Metadaten und Versionen weiterverwenden.

Anzeigen und Aktualisieren der Metadaten eines Modells¶

Sie können die in der Registry vorliegenden Metadatenattribute eines Modells anzeigen und aktualisieren, einschließlich Name, Kommentar, Tags und Metriken.

print(m.comment)
m.comment = "A better description than the one I provided originally"

print(m.description)
m.description = "A better description than the one I provided originally"

print(m.show_tags())

m.set_tag("live_version", "v1")

m.get_tag("live_version")

m.unset_tag("live_version")

m.rename("MY_MODEL_TOO")

Verwenden von Modellversionen¶

Ein Modell kann beliebig viele Versionen haben, die jeweils durch eine Zeichenfolge identifiziert sind. Sie können für den Versionsnamen jede beliebige Namenskonvention verwenden. Beim Protokollieren eines Modells wird eine spezifische Version des Modells protokolliert. Um weitere Versionen eines Modells zu protokollieren, rufen Sie log_model erneut mit demselben model_name-Wert, aber einem anderen version_name-Wert auf.

Eine Version eines Modells wird durch eine Instanz der Klasse snowflake.ml.model.ModelVersion repräsentiert.

Um eine Liste aller Versionen eines Modells zu erhalten, rufen Sie die Methode versions des Modellobjekts auf. Das Ergebnis ist eine Liste von ModelVersion-Instanzen:

version_list = m.versions()

Um stattdessen Informationen zu jedem Modell als DataFrame zu erhalten, rufen Sie die Methode show_versions des Modells auf:

version_df = m.show_versions()

Der Ergebnis-DataFrame enthält die folgenden Spalten:

m.delete_version("rc1")

default_version = m.default
m.default = "v2"

m = reg.get_model("MyModel")

mv = m.version("v1")
mv = m.default

print(mv.comment)
print(mv.description)

mv.comment = "A model version comment"
mv.description = "Same as setting the comment"

from sklearn import metrics

test_accuracy = metrics.accuracy_score(test_labels, prediction)

test_confusion_matrix = metrics.confusion_matrix(test_labels, prediction)

# scalar metric
mv.set_metric("test_accuracy", test_accuracy)

# hierarchical (dictionary) metric
mv.set_metric("evaluation_info", {"dataset_used": "my_dataset", "accuracy": test_accuracy, "f1_score": f1_score})

# multivalent (matrix) metric
mv.set_metric("confusion_matrix", test_confusion_matrix)

metrics = mv.show_metrics()

mv.delete_metric("test_accuracy")

mv.export("~/mymodel/")

mv.export("~/mymodel/", export_mode=ExportMode.FULL)

clf = mv.load()

conda_env = session.file.get("snow://model/<modelName>/versions/<versionName>/runtimes/python_runtime/env/conda.yml", ".")
open("~/conda.yml", "w").write(conda_env)

conda env create --name newenv --file=~/conda.yml
conda activate newenv

clf = mv.load(options={"use_gpu": True})

Aufrufen von Modellmethoden¶

Modellversionen können Methoden haben, d. h. angehängte Funktionen, die ausgeführt werden können, um Inferenzen oder andere Modelloperationen auszuführen. Die Versionen eines Modells können unterschiedliche Methoden haben, und auch die Signaturen dieser Methoden können sich unterscheiden.

Um eine Methode einer Modellversion aufzurufen, verwenden Sie mv.run, wobei mv ein ModelVersion-Objekt ist. Geben Sie den Namen der aufzurufenden Funktion an und übergeben Sie eine Snowpark- oder pandas-DataFrame, die die Inferenzdaten enthält, zusammen mit allen erforderlichen Parametern. Die Methode wird in einem Snowflake-Warehouse ausgeführt.

Der Rückgabewert der Methode ist ein Snowpark- oder pandas-DataFrame, das dem Typ des übergebenen DataFrame entspricht. Snowpark-DataFrames wird im Lazy-Modus ausgewertet, d. h. die Methode wird nur ausgeführt, wenn die DataFrame-Methode collect, show oder to_pandas aufgerufen wird.

Im folgenden Beispiel wird die Ausführung der Methode predict eines Modells gezeigt. Die predict-Methode dieses Modells benötigt außer den Inferenzdaten (hier test_features) keine weiteren Parameter. Wenn dies der Fall wäre, würden sie als zusätzliche Argumente nach den Inferenzdaten übergeben werden.

remote_prediction = mv.run(test_features, function_name="predict")
remote_prediction.show()   # assuming test_features is Snowpark DataFrame

Um zu erfahren, welche Methoden für ein bestimmtes Modell aufgerufen werden können, rufen Sie mv.show_functions auf. Der Rückgabewert dieser Methode ist eine Liste von ModelFunctionInfo-Objekten. Jedes dieser Objekte enthält die folgenden Attribute:

• name: Name der Funktion, die von Python oder SQL aufgerufen werden kann.

• target_method: Name der Python-Methode in dem ursprünglich protokollierten Modell.

Freigeben von Modellen¶

Die Modell-Registry kann zwei Arten von Modellen speichern. Sie können sie anhand der MODEL_TYPE-Spalte in der Ausgabe von SHOW MODELS unterscheiden.

• CORTEX_FINETUNED: Modelle, die mit Cortex Fine-tuning erstellt wurden und keinen Benutzer-Code enthalten. Um diese Art von Modellen gemeinsam zu nutzen, verwenden Sie Datenfreigabe.

• USER_MODEL: Modelle, die Benutzer-Code enthalten, wie z. B. Modelle, die mit Snowpark ML Modellierungsklassen entwickelt wurden. Diese Modelle können derzeit nicht gemeinsam genutzt werden. Die Möglichkeit, Modelle, die Benutzer-Code enthalten, gemeinsam zu nutzen, wird in einem zukünftigen Release verfügbar sein.

Hinweise zu Kosten¶

Für die Verwendung der Snowflake Model Registry fallen die üblichen verbrauchsabhängigen Kosten von Snowflake an. Dazu zählen:

• Kosten für die Speicherung von Modellartefakten, Metadaten und Funktionen. Allgemeine Informationen zu den Kosten für den Speicher finden Sie unter Untersuchen der Speicherkosten.

• Kosten für das Kopieren von Dateien zwischen Stagingbereichen und Snowflake. Siehe COPY FILES.

• Kosten für serverlose Modellobjektoperationen über die Snowsight-UI oder die SQL- oder Python-Schnittstelle, z. B. das Anzeigen von Modellen und Modellversionen und das Ändern der Kommentare, Tags und Kennzahlen von Modellen.

• Warehouse-Computekosten, die je nach Typ des Modells und der Menge der für Interferenz verwendeten Daten variieren. Allgemeine Informationen zu den Snowflake-Computekosten finden Sie unter Erläuterungen zu den Computekosten. Warehouse-Computekosten fallen bei:

  • Operationen zum Erstellen von Modellen und Versionen

  • Aufrufen der Methoden eines Modells