Apporter vos propres types de modèles via des fichiers sérialisés

Le registre des modèles prend en charge plusieurs types de modèles intégrés. Vous pouvez également connecter d’autres types de modèles, y compris ceux formés à l’aide d’outils externes ou obtenus à partir de référentiels open source, à condition qu’ils soient sérialisables et qu’ils étendent la classe snowflake.ml.model.custom_model.CustomModel.

Ce guide explique comment :

  • Créer des modèles personnalisés.

  • Les connecter au Snowflake Model Registry.

  • Les déployer pour l’inférence.

Note

Ce démarrage rapide fournit un exemple de connexion d’un modèle personnalisé PyCaret.

Définition du contexte du modèle à l’aide d’arguments de type mot-clé

Snowflake ML autorise un nombre arbitraire d’arguments de type mot-clé lors de l’instanciation de la classe ModelContext, ce qui vous permet d’inclure facilement des paramètres, des fichiers de configuration ou des instances de vos propres classes de modèles lors de la définition et de l’initialisation d’un modèle personnalisé.

Les attributs du contexte du modèle peuvent être des types de modèles pris en charge, tels que les types de modèles intégrés ou un chemin, tel qu’un chemin vers un répertoire contenant un modèle, un paramètre ou un fichier de configuration.

Vous trouverez ci-dessous un exemple montrant comment fournir des arguments de mot-clé par le biais du contexte du modèle et comment les utiliser dans une classe de modèle personnalisée :

import json
import pandas as pd
from snowflake.ml.model import custom_model

# Initialize ModelContext with keyword arguments
# my_model can be any kind of model
mc = custom_model.ModelContext(
    my_model=my_model,
)

# Define a custom model class that utilizes the context
class ExampleBringYourOwnModel(custom_model.CustomModel):
    def __init__(self, context: custom_model.ModelContext) -> None:
        super().__init__(context)

    @custom_model.inference_api
    def predict(self, input: pd.DataFrame) -> pd.DataFrame:
        # Use the model 'my_model' from the context to make predictions
        model_output = self.context['my_model'].predict(input)
        return pd.DataFrame({'output': model_output})
Copy

Tester et connecter un modèle personnalisé

Vous pouvez tester un modèle personnalisé en l’exécutant localement.

my_model = ExampleBringYourOwnModel(mc)
output_df = my_model.predict(input_df)
Copy

Lorsque le modèle fonctionne comme prévu, connectez-le au Snowflake Model Registry. Comme indiqué dans l’exemple de code suivant, fournissez conda_dependencies (ou pip_requirements) pour spécifier les bibliothèques dont la classe de modèle a besoin. Fournissez sample_input_data (un pandas ou un DataFrame Snowpark) pour déduire la signature d’entrée du modèle. Vous pouvez également fournir une signature du modèle.

reg = Registry(session=sp_session, database_name="ML", schema_name="REGISTRY")
mv = reg.log_model(my_model_pipeline,
            model_name="my_custom_model_pipeline",
            version_name="v1",
            conda_dependencies=["scikit-learn"],
            comment="My Custom ML Model Pipeline",
            sample_input_data=train_features)
output_df = mv.run(input_df)
Copy

Exemple : Connecter un modèle PyCaret

PyCaret est un paquet tiers à faible code et à haute efficacité que Snowflake ne supporte pas de manière native. Vous pouvez apporter vos propres types de modèles par des méthodes similaires.

Étape 1 : Définir le contexte du modèle

Avant de connecter le modèle, définissez un ModelContext qui fait référence à votre propre type de modèle qui n’est pas pris en charge nativement par Snowflake ML. Dans ce cas, nous spécifions le chemin vers le modèle sérialisé (pickled) à l’aide de l’attribut model_file du contexte.

pycaret_mc = custom_model.ModelContext(
  model_file = 'pycaret_best_model.pkl',
)
Copy

Étape 2 : Créer une classe de modèle personnalisée

Définissez une classe de modèle personnalisée pour connecter un type de modèle sans support natif. Dans cet exemple, une classe PyCaretModel, dérivée de CustomModel, est définie pour que le modèle puisse être connecté au registre.

from pycaret.classification import load_model, predict_model

class PyCaretModel(custom_model.CustomModel):
    def __init__(self, context: custom_model.ModelContext) -> None:
        super().__init__(context)
        model_dir = self.context["model_file"][:-4]  # Remove '.pkl' suffix
        self.model = load_model(model_dir, verbose=False)
        self.model.memory = '/tmp/'  # Update memory directory

    @custom_model.inference_api
    def predict(self, X: pd.DataFrame) -> pd.DataFrame:
        model_output = predict_model(self.model, data=X)
        return pd.DataFrame({
            "prediction_label": model_output['prediction_label'],
            "prediction_score": model_output['prediction_score']
        })
Copy

Note

Comme indiqué, définissez le répertoire de la mémoire du modèle sur /tmp/. Les nœuds de l’entrepôt de Snowflake ont un accès restreint aux répertoires. /tmp est toujours accessible en écriture et constitue un choix sûr lorsque le modèle a besoin d’un emplacement pour écrire des fichiers. Cela peut ne pas être nécessaire pour d’autres types de modèles.

Étape 3 : Tester le modèle personnalisé

Testez le modèle PyCaret localement à l’aide d’un code comme le suivant.

test_data = [
    [1, 237, 1, 1.75, 1.99, 0.00, 0.00, 0, 0, 0.5, 1.99, 1.75, 0.24, 'No', 0.0, 0.0, 0.24, 1],
    # Additional test rows...
]
col_names = ['Id', 'WeekofPurchase', 'StoreID', 'PriceCH', 'PriceMM', 'DiscCH', 'DiscMM',
            'SpecialCH', 'SpecialMM', 'LoyalCH', 'SalePriceMM', 'SalePriceCH',
            'PriceDiff', 'Store7', 'PctDiscMM', 'PctDiscCH', 'ListPriceDiff', 'STORE']

test_df = pd.DataFrame(test_data, columns=col_names)

my_pycaret_model = PyCaretModel(pycaret_mc)
output_df = my_pycaret_model.predict(test_df)
Copy

Étape 4 : Définir une signature de modèle

Dans cet exemple, utilisez les données de l’échantillon pour déduire une signature de modèle pour la validation des entrées :

predict_signature = model_signature.infer_signature(input_data=test_df, output_data=output_df)
Copy

Étape 5 : Connecter le modèle

Le code suivant connecte (enregistre) le modèle dans le registre des modèles de Snowflake.

snowml_registry = Registry(session)

custom_mv = snowml_registry.log_model(
    my_pycaret_model,
    model_name="'my_pycaret_best_model",
    version_name="version_1",
    conda_dependencies=["pycaret==3.0.2", "scipy==1.11.4", "joblib==1.2.0"],
    options={"relax_version": False},
    signatures={"predict": predict_signature},
    comment = 'My PyCaret classification experiment using the CustomModel API'
)
Copy

Étape 6 : Vérifier le modèle dans le registre

Pour vérifier que le modèle est disponible dans le registre des modèles, utilisez la fonctionnalité show_models.

snowml_registry.show_models()
Copy

Étape 7 : Faire des prédictions avec le modèle enregistré

Utilisez la fonctionnalité run pour appeler le modèle de prédiction.

snowpark_df = session.create_dataframe(test_data, schema=col_nms)

custom_mv.run(snowpark_df).show()
Copy

Prochaines étapes

Après avoir déployé un modèle PyCaret via le Snowflake Model Registry, vous pouvez voir le modèle dans Snowsight. Naviguez jusqu’à la page Models sous AI & ML. Si vous ne le voyez pas, assurez-vous que vous utilisez le rôle ACCOUNTADMIN ou le rôle que vous avez utilisé pour connecter le modèle.

Pour utiliser le modèle depuis SQL, utilisez SQL comme suit :

SELECT
    my_pycaret_model!predict(*) AS predict_dict,
    predict_dict['prediction_label']::text AS prediction_label,
    predict_dict['prediction_score']::double AS prediction_score
from pycaret_input_data;
Copy
Langage: Français