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

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

Le snowflake.ml.model.custom_model.ModelContext peut être instancié avec des arguments de type mot-clé définis par l’utilisateur. Les valeurs peuvent être des chemins de fichiers sous forme de chaînes ou des instances de types de modèles pris en charge </developer-guide/snowflake-ml/model-registry/built-in-models/overview>. Les fichiers et les modèles sérialisés seront empaquetés avec le modèle pour être utilisés dans la logique d’inférence du modèle.

Les fichiers peuvent être des modèles sérialisés, des fichiers de configuration ou des fichiers contenant des paramètres. Une utilisation courante consiste à charger un fichier pickle ou json dans le modèle personnalisé __init__ ou dans la méthode d’inférence.

Vous trouverez ci-dessous un exemple montrant comment fournir des modèles et des fichiers avec le contexte de modèle, et les utiliser dans une classe de modèle personnalisée :

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

# Initialize ModelContext with keyword arguments
# my_model can be any supported model type
# my_file_path is a local pickle file path
model_context = custom_model.ModelContext(
    my_model=my_model,
    my_file_path='/path/to/file.pkl',
)

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

        # Use 'my_file_path' key from the context to load the pickled object
        with open(self.context['my_file_path'], 'rb') as f:
            self.obj = pickle.load(f)

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

# Instantiate the custom model with the model context. This instance can be logged in the model registry.
my_model = ExampleBringYourOwnModel(model_context)

Tester et connecter un modèle personnalisé¶

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

my_model = ExampleBringYourOwnModel(model_context)
output_df = my_model.predict(input_df)

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,
            model_name="my_custom_model",
            version_name="v1",
            conda_dependencies=["scikit-learn"],
            comment="My Custom ML Model",
            sample_input_data=train_features)
output_df = mv.run(input_df)

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.

pycaret_model_context = custom_model.ModelContext(
  model_file = 'pycaret_best_model.pkl',
)

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

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_model_context)
output_df = my_pycaret_model.predict(test_df)

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

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

snowml_registry.show_models()

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

custom_mv.run(snowpark_df).show()

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;