Registre des modèles de Snowflake¶

Récupération et mise à jour des commentaires¶

Utilisez l’attribut comment du modèle pour récupérer et mettre à jour le commentaire du modèle :

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"

Récupération et mise à jour des balises¶

Les balises sont des métadonnées utilisées pour enregistrer l’objectif, l’algorithme, l’ensemble de données d’entraînement, l’étape du cycle de vie d’un modèle ou toute autre information que vous choisissez. Vous pouvez définir des balises lors de l’enregistrement du modèle ou à tout moment par la suite. Vous pouvez également mettre à jour les valeurs des balises existantes ou les supprimer complètement.

Pour obtenir toutes les balises d’un modèle sous la forme d’un dictionnaire Python, utilisez show_tags :

print(m.show_tags())

Pour ajouter une nouvelle balise ou modifier la valeur d’une balise existante, utilisez set_tag :

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

Pour récupérer la valeur d’une balise, utilisez get_tag :

m.get_tag("live_version")

Pour supprimer une balise, utilisez unset_tag :

m.unset_tag("live_version")

Changement du nom d’un modèle¶

Utilisez la méthode rename pour renommer ou déplacer un modèle. Spécifiez un nom entièrement qualifié comme nouveau nom pour déplacer le modèle vers une base de données ou un schéma différent.

m.rename("MY_MODEL_TOO")

Suppression des versions du modèle¶

Vous pouvez supprimer une version de modèle en utilisant la méthode delete_version du modèle :

m.delete_version("rc1")

Version par défaut¶

Une version d’un modèle peut être désignée comme modèle par défaut. Récupérez ou définissez l’attribut default du modèle pour obtenir la version actuelle par défaut (sous la forme d’un objet ModelVersion) ou pour la modifier (à l’aide d’une chaîne) :

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

Alias de la version du modèle¶

Vous pouvez attribuer un alias à une version de modèle à l’aide de la commande SQL ALTER MODEL. Vous pouvez utiliser un alias chaque fois qu’un nom de version est nécessaire, par exemple pour obtenir une référence à une version de modèle, en Python ou en SQL. Un alias donné ne peut être attribué qu’à une seule version de modèle à la fois.

Outre les alias que vous créez, les alias système suivants sont disponibles dans tous les modèles :

• DEFAULT fait référence à la version par défaut du modèle.

• FIRST fait référence à la version la plus ancienne du modèle en fonction du moment de la création.

• LAST fait référence à la version la plus récente du modèle en fonction du moment de la création.

Les noms d’alias que vous créez doivent être différents de tout nom de version ou alias existant dans le modèle, y compris les alias système.

Obtention d’une référence à une version de modèle¶

Pour obtenir une référence à une version spécifique d’un modèle en tant qu’instance ModelVersion , utilisez la méthode version du modèle. Utilisez l’attribut default du modèle pour obtenir la version par défaut du modèle :

m = reg.get_model("MyModel")

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

Une fois que vous avez une référence à une version spécifique d’un modèle (comme la variable mv dans cet exemple), vous pouvez récupérer ou mettre à jour ses commentaires ou ses métriques et appeler les méthodes (ou fonctions) du modèle comme indiqué dans les sections suivantes.

Récupération et mise à jour des commentaires¶

Comme pour les modèles, les versions de modèle peuvent avoir des commentaires, qui peuvent être consultés et définis via l’attribut comment ou description de la version de modèle :

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

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

Récupération et mise à jour des métriques¶

Les métriques sont des paires clé-valeur utilisées pour suivre la précision de la prédiction et d’autres caractéristiques de la version du modèle. Vous pouvez définir des métriques lors de la création d’une version de modèle ou en utilisant la méthode set_metric. Une valeur métrique peut être n’importe quel objet Python qui peut être sérialisé en JSON, y compris les nombres, les chaînes, les listes et les dictionnaires. Contrairement aux balises, les noms des métriques et les valeurs possibles ne doivent pas être définis à l’avance.

Une mesure de la précision du test peut être générée à l’aide de accuracy_score de sklearn :

from sklearn import metrics

test_accuracy = metrics.accuracy_score(test_labels, prediction)

La matrice de confusion peut être générée de la même manière à l’aide de sklearn :

test_confusion_matrix = metrics.confusion_matrix(test_labels, prediction)

Vous pouvez ensuite définir ces valeurs comme métriques :

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

Pour récupérer les métriques d’une version de modèle sous la forme d’un dictionnaire Python, utilisez show_metrics.

metrics = mv.show_metrics()

Pour supprimer une métrique, appelez delete_metric.

mv.delete_metric("test_accuracy")

Récupération des explications du modèle¶

Le registre de modèles peut expliquer les résultats d’un modèle, en vous indiquant quelles fonctionnalités d’entrée contribuent le plus aux prédictions, en calculant les valeurs de Shapley. Cette fonctionnalité en avant-première est disponible par défaut dans toutes les vues de modèle créées dans Snowflake 8.31 et versions ultérieures via le modèle explain sous-jacent. Vous pouvez appeler explain depuis SQL ou via une méthode run de vue de modèle en Python.

Pour plus de détails sur cette fonctionnalité, voir Explicabilité des modèles.

Exportation d’une version du modèle¶

Utilisez mv.export pour exporter les fichiers d’un modèle vers un répertoire local ; le répertoire est créé s’il n’existe pas :

mv.export("~/mymodel/")

Par défaut, les fichiers exportés comprennent le code, l’environnement de chargement du modèle et les poids du modèle. Pour exporter également les fichiers nécessaires à l’exécution du modèle dans un entrepôt, indiquez export_mode = ExportMode.FULL :

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

Chargement d’une version de modèle¶

Utilisez mv.load pour charger l’objet du modèle Python d’origine qui a été ajouté au registre. Vous pouvez alors utiliser le modèle pour l’inférence comme si vous l’aviez défini dans votre code Python.

clf = mv.load()

Pour garantir le bon fonctionnement d’un modèle à partir du registre, l’environnement Python cible (c’est-à-dire les versions de l’interpréteur Python et de toutes les bibliothèques) doit être identique à l’environnement à partir duquel le modèle a été enregistré. Spécifiez force=True dans l’appel load pour forcer le chargement du modèle même si l’environnement est différent.

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

L’argument facultatif options est un dictionnaire d’options pour le chargement du modèle. Actuellement, l’argument ne prend en charge que l’option use_gpu.

L’exemple suivant illustre l’utilisation de l’argument options :

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

ML Snowpark¶

Le registre prend en charge les modèles créés à l’aide des APIs Snowpark ML modeling (modèles dérivés de snowpark.ml.modeling.framework.base.BaseEstimator). Les options supplémentaires suivantes peuvent être utilisées dans le dictionnaire options lors de l’appel à log_model :

Il n’est pas nécessaire de spécifier sample_input_data ou signatures lors de l’enregistrement d’un modèle Snowpark ML ; ces éléments sont automatiquement déduits lors de l’ajustement.

import pandas as pd
import numpy as np
from sklearn import datasets
from snowflake.ml.modeling.xgboost import XGBClassifier

iris = datasets.load_iris()
df = pd.DataFrame(data=np.c_[iris["data"], iris["target"]], columns=iris["feature_names"] + ["target"])
df.columns = [s.replace(" (CM)", "").replace(" ", "") for s in df.columns.str.upper()]

input_cols = ["SEPALLENGTH", "SEPALWIDTH", "PETALLENGTH", "PETALWIDTH"]
label_cols = "TARGET"
output_cols = "PREDICTED_TARGET"

clf_xgb = XGBClassifier(
        input_cols=input_cols, output_cols=output_cols, label_cols=label_cols, drop_input_cols=True
)
clf_xgb.fit(df)
model_ref = registry.log_model(
    clf_xgb,
    model_name="XGBClassifier",
    version_name="v1",
)
model_ref.run(df.drop(columns=label_cols).head(10), function_name='predict_proba')

scikit-learn¶

Le registre prend en charge les modèles créés à l’aide de scikit-learn (modèles dérivés de sklearn.base.BaseEstimator ou sklearn.pipeline.Pipeline). Les options supplémentaires suivantes peuvent être utilisées dans le dictionnaire options lors de l’appel à log_model :

Vous devez spécifier le paramètre sample_input_data ou signatures lorsque vous enregistrez un modèle scikit-learn afin que le registre connaisse les signatures des méthodes cibles.

from sklearn import datasets, ensemble

iris_X, iris_y = datasets.load_iris(return_X_y=True, as_frame=True)
clf = ensemble.RandomForestClassifier(random_state=42)
clf.fit(iris_X, iris_y)
model_ref = registry.log_model(
    clf,
    model_name="RandomForestClassifier",
    version_name="v1",
    sample_input_data=iris_X,
    options={
        "method_options": {
            "predict": {"case_sensitive": True},
            "predict_proba": {"case_sensitive": True},
            "predict_log_proba": {"case_sensitive": True},
        }
    },
)
model_ref.run(iris_X[-10:], function_name='"predict_proba"')

XGBoost¶

Le registre prend en charge les modèles créés à l’aide de XGBoost (modèles dérivés de xgboost.XGBModel ou xgboost.Booster). Les options supplémentaires suivantes peuvent être utilisées dans le dictionnaire options lors de l’appel à log_model :

Vous devez spécifier le paramètre sample_input_data ou signatures lors de l’enregistrement d’un modèle XGBoost afin que le registre connaisse les signatures des méthodes cibles.

import xgboost
from sklearn import datasets, model_selection

cal_X, cal_y = datasets.load_breast_cancer(as_frame=True, return_X_y=True)
cal_X_train, cal_X_test, cal_y_train, cal_y_test = model_selection.train_test_split(cal_X, cal_y)
params = dict(n_estimators=100, reg_lambda=1, gamma=0, max_depth=3, objective="binary:logistic")
regressor = xgboost.train(params, xgboost.DMatrix(data=cal_X_train, label=cal_y_train))
model_ref = registry.log_model(
    regressor,
    model_name="xgBooster",
    version_name="v1",
    sample_input_data=cal_X_test,
    options={
        "target_methods": ["predict"],
        "method_options": {
            "predict": {"case_sensitive": True},
        },
    },
)
model_ref.run(cal_X_test[-10:])

PyTorch¶

Le registre prend en charge les modèles PyTorch (classes dérivées de torch.nn.Module ou torch.jit.ModuleScript) si la méthode forward du modèle accepte une ou plusieurs instances torch.Tensor en entrée et renvoie un torch.Tensor ou un tuple de celles-ci. Le registre convertit les DataFrames pandas et les tenseurs lors de l’appel du modèle et du renvoi des résultats. Les tenseurs correspondent aux colonnes du dataframe.

Par exemple, supposons que votre modèle accepte deux tenseurs comme suit :

import torch

class TorchModel(torch.nn.Module):
    def __init__(self, n_input: int, n_hidden: int, n_out: int, dtype: torch.dtype = torch.float32) -> None:
        super().__init__()
        self.model = torch.nn.Sequential(
            torch.nn.Linear(n_input, n_hidden, dtype=dtype),
            torch.nn.ReLU(),
            torch.nn.Linear(n_hidden, n_out, dtype=dtype),
            torch.nn.Sigmoid(),
        )

    def forward(self, tensor_1: torch.Tensor, tensor_2: torch.Tensor) -> torch.Tensor:
        return self.model(tensor_1) + self.model(tensor_2)

Si vous souhaitez transmettre torch.Tensor([[1,2],[3,4]]) en tant que tensor_1 et torch.Tensor([[5,6], [7,8]]) en tant que tensor_2, créez un DataFrame comme celui-ci pour le transmettre au modèle :

import pandas as pd
tensors = pd.DataFrame([[[1,2],[5,6]],[[3,4],[7,8]]])

Le DataFrame de tensors ressemble alors à ceci :

        0       1
0  [1, 2]  [5, 6]
1  [3, 4]  [7, 8]

De même, si votre modèle renvoie deux tenseurs, tels que (torch.Tensor([[1,2],[3,4]]), torch.Tensor([[5,6], [7,8]])), le résultat est un DataFrame comme celui ci-dessus.

Lorsque vous fournissez un échantillon de données d’entrée pour un modèle PyTorch, vous devez fournir soit une liste de tenseurs (qui sera convertie en un DataFrame pandas), soit un DataFrame. Une liste peut contenir un seul tenseur, mais un tenseur seul n’est pas accepté.

import torch
import numpy as np

class TorchModel(torch.nn.Module):
        def __init__(self, n_input: int, n_hidden: int, n_out: int, dtype: torch.dtype = torch.float32) -> None:
                super().__init__()
                self.model = torch.nn.Sequential(
                        torch.nn.Linear(n_input, n_hidden, dtype=dtype),
                        torch.nn.ReLU(),
                        torch.nn.Linear(n_hidden, n_out, dtype=dtype),
                        torch.nn.Sigmoid(),
                )

        def forward(self, tensor: torch.Tensor) -> torch.Tensor:
                return self.model(tensor)

n_input, n_hidden, n_out, batch_size, learning_rate = 10, 15, 1, 100, 0.01
dtype = torch.float32
x = np.random.rand(batch_size, n_input)
data_x = torch.from_numpy(x).to(dtype=dtype)
data_y = (torch.rand(size=(batch_size, 1)) < 0.5).to(dtype=dtype)

model = TorchModel(n_input, n_hidden, n_out, dtype=dtype)
loss_function = torch.nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
for _epoch in range(100):
        pred_y = model.forward(data_x)
        loss = loss_function(pred_y, data_y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()


model_ref = registry.log_model(
    model,
    model_name="torchModel",
    version_name="v1",
    sample_input_data=[data_x],
)
model_ref.run([data_x])

TensorFlow¶

Les modèles qui étendent tensorflow.Module ou tensorflow.keras.Model sont pris en charge lorsqu’ils acceptent et renvoient des tenseurs et qu’ils sont compilables ou compilés.

• La méthode __call__ pour un tensorflow.Module ou la méthode call pour un tensorflow.keras.Model accepte un ou plusieurs tensorflow.Tensor ou tensorflow.Variable en entrée et renvoie un tensorflow.Tensor ou tensorflow.Variable ou un tuple de l’un de ces types.

• Si votre modèle étend Module, il doit être compilable, ce qui signifie que la méthode __call__ est décorée par @tensorflow.function ; voir la documentation tf.function. S’il étend Model, il doit être compilé ; voir la documentation de compilation.

Le registre convertit les DataFrames pandas et les tenseurs lors de l’appel du modèle et du renvoi des résultats. Les tenseurs correspondent aux colonnes du dataframe.

Par exemple, supposons que votre modèle accepte deux tenseurs comme suit :

import tensorflow as tf

class KerasModel(tf.keras.Model):
    def  __init__(self, n_hidden: int, n_out: int) -> None:
        super().__init__()
        self.fc_1 = tf.keras.layers.Dense(n_hidden, activation="relu")
        self.fc_2 = tf.keras.layers.Dense(n_out, activation="sigmoid")

    def call(self, tensor_1: tf.Tensor, tensor_2: tf.Tensor) -> tf.Tensor:
        input = tensor_1 + tensor_2
        x = self.fc_1(input)
        x = self.fc_2(x)
        return x

Si vous souhaitez transmettre tf.Tensor([[1,2],[3,4]]) en tant que tensor_1 et tf.Tensor([[5,6], [7,8]]) en tant que tensor_2, créez un DataFrame comme celui-ci pour le transmettre au modèle :

import pandas as pd
tensors = pd.DataFrame([[[1,2],[5,6]],[[3,4],[7,8]]])

Le DataFrame de tensors ressemble alors à ceci :

        0       1
0  [1, 2]  [5, 6]
1  [3, 4]  [7, 8]

De même, si votre modèle renvoie deux tenseurs, tels que (tf.Tensor([[1,2],[3,4]]), tf.Tensor([[5,6], [7,8]])), le résultat est un DataFrame comme celui ci-dessus.

Lorsque vous fournissez un échantillon de données d’entrée pour un modèle TensorFlow, vous devez fournir soit une liste de tenseurs (qui sera convertie en un DataFrame pandas), soit un DataFrame. Une liste peut contenir un seul tenseur, mais un tenseur seul n’est pas accepté.

import tensorflow as tf
import numpy as np

class KerasModel(tf.keras.Model):
        def __init__(self, n_hidden: int, n_out: int) -> None:
                super().__init__()
                self.fc_1 = tf.keras.layers.Dense(n_hidden, activation="relu")
                self.fc_2 = tf.keras.layers.Dense(n_out, activation="sigmoid")

        def call(self, tensor: tf.Tensor) -> tf.Tensor:
                input = tensor
                x = self.fc_1(input)
                x = self.fc_2(x)
                return x

n_input, n_hidden, n_out, batch_size, learning_rate = 10, 15, 1, 100, 0.01
dtype = tf.float32
x = np.random.rand(batch_size, n_input)
data_x = tf.convert_to_tensor(x, dtype=dtype)
raw_data_y = tf.random.uniform((batch_size, 1))
raw_data_y = tf.where(raw_data_y > 0.5, tf.ones_like(raw_data_y), tf.zeros_like(raw_data_y))
data_y = tf.cast(raw_data_y, dtype=dtype)

model = KerasModel(n_hidden, n_out)
model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=learning_rate), loss=tf.keras.losses.MeanSquaredError())
model.fit(data_x, data_y, batch_size=batch_size, epochs=100)

model_ref = registry.log_model(
    model,
    model_name="tfModel",
    version_name="v1",
    sample_input_data=[data_x],
)
model_ref.run([data_x])

MLFlow¶

Modèles MLFlow qui fournissent une valeur PyFunc sont pris en charge. Si votre modèle MLFlow possède une signature, l’argument signature est déduit du modèle. Sinon, vous devez fournir soit signature soit sample_input_data.

Les options supplémentaires suivantes peuvent être utilisées dans le dictionnaire options lors de l’appel à log_model :

import mlflow
from sklearn import datasets, model_selection, ensemble

db = datasets.load_diabetes(as_frame=True)
X_train, X_test, y_train, y_test = model_selection.train_test_split(db.data, db.target)
with mlflow.start_run() as run:
    rf = ensemble.RandomForestRegressor(n_estimators=100, max_depth=6, max_features=3)
    rf.fit(X_train, y_train)

    # Use the model to make predictions on the test dataset.
    predictions = rf.predict(X_test)
    signature = mlflow.models.signature.infer_signature(X_test, predictions)
    mlflow.sklearn.log_model(
        rf,
        "model",
        signature=signature,
    )
    run_id = run.info.run_id


model_ref = registry.log_model(
    mlflow.pyfunc.load_model(f"runs:/{run_id}/model"),
    model_name="mlflowModel",
    version_name="v1",
    conda_dependencies=["mlflow<=2.4.0", "scikit-learn", "scipy"],
    options={"ignore_mlflow_dependencies": True}
)
model_ref.run(X_test)

Pipeline Hugging Face¶

Le registre prend en charge les classes du modèle Hugging Face définies comme des transformateurs qui dérivent de transformers.Pipeline. Le code suivant est un exemple d’enregistrement d’un modèle compatible :

lm_hf_model = transformers.pipeline(
    task="text-generation",
    model="bigscience/bloom-560m",
    token="...",  # Put your HuggingFace token here.
    return_full_text=False,
    max_new_tokens=100,
)

lmv = reg.log_model(lm_hf_model, model_name='bloom', version_name='v560m')

Le registre déduit l’argument signatures si le pipeline contient une tâche de la liste suivante :

• conversational

• fill-mask

• question-answering

• summarization

• table-question-answering

• text2text-generation

• text-classification (également appelé sentiment-analysis)

• text-generation

• token-classification (également appelé ner)

• translation

• translation_xx_to_yy

• zero-shot-classification

L’argument sample_input_data est totalement ignoré pour les modèles Hugging Face. Spécifiez l’argument signatures lors de l’enregistrement d’un modèle Hugging Face qui ne figure pas dans la liste ci-dessus afin que le registre connaisse les signatures des méthodes cibles.

Pour voir la signature déduite, utilisez la méthode show_functions. Le code suivant, par exemple, est le résultat de lmv.show_functions() où lmv est le modèle journalisé ci-dessus :

{'name': '__CALL__',
  'target_method': '__call__',
  'signature': ModelSignature(
                      inputs=[
                          FeatureSpec(dtype=DataType.STRING, name='inputs')
                      ],
                      outputs=[
                          FeatureSpec(dtype=DataType.STRING, name='outputs')
                      ]
                  )}]

Avec ces informations, vous pouvez appeler le modèle comme suit :

import pandas as pd
remote_prediction = lmv.run(pd.DataFrame(["Hello, how are you?"], columns=["inputs"]))

# Prepare model
import transformers
import pandas as pd

finbert_model = transformers.pipeline(
    task="text-classification",
    model="ProsusAI/finbert",
    top_k=2,
)

# Log the model
mv = registry.log_model(
    finbert_model,
    model_name="finbert",
    version_name="v1",
)

# Use the model
mv.run(pd.DataFrame(
        [
            ["I have a problem with my Snowflake that needs to be resolved asap!!", ""],
            ["I would like to have udon for today's dinner.", ""],
        ]
    )
)

0  [{"label": "negative", "score": 0.8106237053871155}, {"label": "neutral", "score": 0.16587384045124054}]
1  [{"label": "neutral", "score": 0.9263970851898193}, {"label": "positive", "score": 0.05286872014403343}]