Registre des modèles de Snowflake¶

Privilèges requis¶

Pour créer un modèle, vous devez posséder le schéma dans lequel le modèle est créé ou avoir le privilège CREATE MODEL sur ce schéma. Pour utiliser un modèle, vous devez en être le propriétaire ou avoir le privilège USAGE sur ce modèle. Le privilège USAGE permet aux bénéficiaires d’utiliser le modèle à des fins d’inférence sans pouvoir en voir les éléments internes. Pour donner aux utilisateurs l’accès à tous les modèles existants dans un schéma, utilisez le rôle GRANT USAGE ON ALL MODELS IN SCHEMA <du schéma> TO ROLE <>; Vous pouvez également donner aux utilisateurs l’accès aux futurs modèles créés automatiquement dans un schéma via GRANT USAGE ON FUTURE MODELS IN SCHEMA <rôle> TO ROLE <du schéma>;. .

Si le rôle d’un utilisateur a USAGE sur un modèle, il apparaît dans la page de registre des modèles de Snowsight. Pour plus de détails sur le fonctionnement des privilèges dans Snowflake, voir Privilèges de contrôle d’accès.

Limites actuelles¶

Les limites suivantes s’appliquent aux modèles et aux versions de modèles :

Ouverture du registre des modèles de Snowflake¶

Les modèles sont des objets Snowflake de première classe et peuvent être organisés au sein d’une base de données et d’un schéma avec d’autres objets Snowflake. Le registre des modèles de Snowflake fournit une classe Python pour la gestion des modèles au sein d’un schéma. Ainsi, tout schéma Snowflake peut être utilisé comme registre. Il n’est pas nécessaire d’initialiser ou de préparer un schéma à cette fin. Snowflake recommande de créer un ou plusieurs schémas dédiés à cet effet, comme ML.REGISTRY. Vous pouvez créer le schéma en utilisant CREATE SCHEMA.

Avant de pouvoir créer ou modifier des modèles dans le registre, vous devez ouvrir le registre. L’ouverture du registre renvoie une référence à celui-ci, que vous pouvez ensuite utiliser pour ajouter de nouveaux modèles et obtenir des références à des modèles existants.

from snowflake.ml.registry import Registry

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

Enregistrement des modèles et des versions¶

L’ajout d’un modèle au registre s’appelle la journalisation du modèle. Enregistrer un modèle en appelant la méthode log_model du registre. Cette méthode sérialise le modèle, un objet Python, et crée un objet modèle Snowflake à partir de celui-ci. Cette méthode ajoute des métadonnées, telles qu’une description, au modèle tel que spécifié dans l’appel log_model.

Chaque modèle peut avoir des versions illimitées. Pour enregistrer d’autres versions du modèle, appelez à nouveau log_model avec le même model_name mais un version_name différent.

Vous ne pouvez pas ajouter de balises à un modèle lorsqu’il est ajouté au registre, car les balises sont des attributs du modèle, et log_model ajoute une version spécifique du modèle, en créant uniquement un modèle lors de l’ajout de sa première version. Vous pouvez mettre à jour les balises du modèle après avoir journalisé la première version du modèle.

Dans l’exemple suivant, clf, abréviation de « classificateur », est l’objet modèle Python, qui a déjà été créé ailleurs dans votre code. Vous pouvez ajouter un commentaire au moment de l’enregistrement, comme indiqué ici. La combinaison du nom et de la version doit être unique dans le schéma. Vous pouvez spécifier des listes de conda_dependencies ; les paquets spécifiés seront déployés avec le modèle.

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)

Les arguments de log_model sont décrits ici.

Arguments requis

Arguments facultatifs

log_model renvoie un objet snowflake.ml.model.ModelVersion qui représente la version du modèle qui a été ajoutée au registre.

Une fois enregistré, le modèle lui-même ne peut pas être modifié (bien que vous puissiez modifier ses métadonnées). Pour supprimer un modèle et toutes ses versions, utilisez la méthode delete_model du registre.

Utilisation d’artefacts de modèles¶

Une fois qu’un modèle a été enregistré, ses artefacts (les fichiers qui soutiennent le modèle, y compris ses objets Python sérialisés et divers fichiers de métadonnées tels que son manifeste) sont disponibles sur une zone de préparation interne. Les artefacts ne peuvent pas être modifiés, mais vous pouvez voir ou télécharger les artefacts des modèles que vous possédez.

Vous pouvez accéder aux artefacts de modèle à partir d’une zone de préparation en utilisant, par exemple, la commande GET ou son équivalent dans Snowpark Python, FileOperation. get.

Cependant, vous ne pouvez pas vous adresser aux artefacts de modèle en utilisant la syntaxe habituelle des zones de préparation. Utilisez plutôt une snow:// URL, une manière plus générale de spécifier l’emplacement des objets dans Snowflake. Par exemple, une version à l’intérieur d’un modèle peut être spécifiée par une URL de la forme snow://model/<nom_modèle>/versions/<nom_version>/.

Connaissant le nom du modèle et la version souhaitée, vous pouvez utiliser la commande LIST pour voir les artefacts du modèle comme suit :

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

Le résultat ressemble à ceci :

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

Pour récupérer l’un de ces artefacts, utilisez la commande SQL GET.

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

Ou l’équivalent avec Snowpark Python :

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

Suppression de modèles¶

Utilisez la méthode delete_model du registre pour supprimer un modèle et toutes ses versions :

reg.delete_model("mymodel")

Obtention de modèles à partir du registre¶

Pour obtenir des informations sur chaque modèle, utilisez la méthode show_models :

model_df = reg.show_models()

Le résultat de show_models est un DataFrame pandas. Les colonnes disponibles sont répertoriées ici :

Pour obtenir une liste des modèles dans le registre, chacun en tant qu’instance Model utilisez la méthode models :

model_list = reg.models()

Pour obtenir une référence à un modèle spécifique du registre par son nom, utilisez la méthode get_model du registre :

m = reg.get_model("MyModel")

Une fois que vous avez une référence à un modèle, soit dans la liste renvoyée par la méthode models soit en utilisant get_model, vous pouvez travailler avec ses métadonnées et ses versions.

Visualisation et mise à jour des métadonnées d’un modèle¶

Vous pouvez consulter et mettre à jour les attributs de métadonnées d’un modèle dans le registre, y compris son nom, son commentaire, ses balises et ses métriques.

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

Utilisation de versions de modèles¶

Un modèle peut avoir un nombre illimité de versions, chacune identifiée par une chaîne. Vous pouvez utiliser n’importe quelle convention de dénomination de version. L’enregistrement d’un modèle enregistre en fait une version spécifique du modèle. Pour enregistrer d’autres versions d’un modèle, appelez à nouveau log_model avec le même model_name mais un version_name différent.

Une version d’un modèle est représentée par une instance de la classe snowflake.ml.model.ModelVersion.

Pour obtenir la liste de toutes les versions d’un modèle, appelez la méthode versions de l’objet du modèle. Le résultat est une liste d’instances ModelVersion :

version_list = m.versions()

Pour obtenir des informations sur chaque modèle sous la forme d’un DataFrame, appelez la méthode show_versions du modèle :

version_df = m.show_versions()

Le DataFrame résultant contient les colonnes suivantes :

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

Appel de méthodes de modèle¶

Les versions de modèle peuvent avoir des méthodes, qui sont des fonctions associées pouvant être exécutées pour effectuer une inférence ou d’autres opérations sur le modèle. Les versions d’un modèle peuvent avoir des méthodes différentes, et les signatures de ces méthodes peuvent également différer.

Pour appeler une méthode d’une version de modèle, utilisez mv.run, où mv est un objet ModelVersion. Spécifiez le nom de la fonction à appeler et transmettez un DataFrame Snowpark ou pandas qui contient les données d’inférence, ainsi que tous les paramètres requis. La méthode est exécutée dans un entrepôt Snowflake.

La valeur de retour de la méthode est un DataFrame Snowpark ou pandas, correspondant au type de DataFrame transmis. Les DataFrames Snowpark sont évalués paresseusement, de sorte que la méthode n’est exécutée que lorsque la méthode collect, show ou to_pandas du DataFrame est appelée.

L’exemple suivant illustre l’exécution de la méthode predict d’un modèle. La méthode predict de ce modèle ne nécessite aucun paramètre en dehors des données d’inférence (test_features ici). Si c’était le cas, ils seraient transmis en tant qu’arguments supplémentaires après les données d’inférence.

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

Pour voir quelles méthodes peuvent être appelées sur un modèle donné, appelez mv.show_functions. La valeur de retour de cette méthode est une liste d’objets ModelFunctionInfo. Chacun de ces objets comprend les attributs suivants :

• name : Le nom de la fonction qui peut être appelée depuis Python ou SQL.

• target_method : le nom de la méthode Python dans le modèle original enregistré.

Partage de modèles¶

Le registre de modèles peut stocker deux types de modèles. Vous pouvez les distinguer en utilisant la colonne MODEL_TYPEdans la sortie de SHOW MODELS.

• CORTEX_FINETUNED : modèles générés avec Cortex Fine-tuning, qui ne contiennent pas de code utilisateur. Pour partager ce type de modèle, utilisez le Partage de données.

• USER_MODEL : modèles contenant du code utilisateur, tels que les modèles développés à l’aide des classes de modélisation Snowpark ML. Ces modèles ne peuvent actuellement pas être partagés. La possibilité de partager des modèles contenant du code utilisateur sera disponible dans une future version.

Considérations relatives aux clients¶

L’utilisation du registre des modèles de Snowflake engendre des coûts standard basés sur la consommation Snowflake. Il s’agit notamment des éléments suivants :

• Coût du stockage des artefacts, des métadonnées et des fonctions du modèle. Pour des informations générales sur les coûts de stockage, voir Exploration des coûts de stockage.

• Coût de la copie des fichiers entre les zones de préparation et Snowflake. Voir COPY FILES.

• Coût des opérations sur les objets de modèle sans serveur via l’interface Snowsight UI ou SQL ou Python, telles que l’affichage des modèles et des versions de modèle, et la modification des commentaires, des balises et des métriques du modèle.

• Les coûts de calcul d’entrepôts varient en fonction du type de modèle et de la quantité de données utilisées pour l’inférence. Pour obtenir des informations générales sur les coûts de calcul de Snowflake, consultez Comprendre le coût du calcul. Les coûts de calcul de l’entrepôt sont encourus pour :

  • Opérations de création de modèles et de versions

  • Invocation de méthodes d’un modèle