Créer, entraîner et utiliser un modèle Snowflake ML dans une application¶

Cette rubrique fournit un exemple de la façon d’entraîner un modèle Snowflake ML dans une Snowflake Native App à l’aide du paquet Python scikit-learn. L’exemple de cette rubrique peut être utilisé pour entraîner des modèles sur les données dans le compte du consommateurs ou du fournisseur.

Créer un schéma versionné pour conserver les procédures stockées¶

Dans le script de configuration, créez un schéma versionné qui contient la procédure stockée, comme le montre l’exemple suivant :

Créer un schéma versionné pour la procédure stockée

CREATE OR ALTER VERSIONED SCHEMA core;
GRANT USAGE ON SCHEMA core TO APPLICATION ROLE app_public;

Créer une procédure stockée pour créer et entraîner un modèle¶

Créez une procédure stockée pour la fonction Python que vous utilisez pour entraîner un modèle, comme indiqué dans l’exemple suivant :

CREATE OR REPLACE PROCEDURE core.py_log_model(db STRING, schema STRING, mname STRING, mvname STRING)
RETURNS STRING
LANGUAGE python
RUNTIME_VERSION = 3.11
HANDLER = 'log_model'
PACKAGES = ('snowflake-snowpark-python','scikit-learn', 'snowflake-ml-python >=1.6.2', 'pandas', 'numpy')
AS '
  -- <body of the stored procedure>
';
Cet exemple crée une procédure stockée nommée py_log_model et déclare les paquets Python requis pour entraîner un modèle avec scikit-learn :

snowflake-snowpark-python

scikit-learn

snowflake-ml-python

pandas

numpy

xgboost

Après avoir créé une procédure stockée, ajoutez le code suivant au corps de la procédure stockée :

Ajouter le code Python dans le corps de la procédure stockée

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

def log_model(sp_session, mname, mvname):
    reg = Registry(session=sp_session, schema_name=''stateful_schema'')

    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 = reg.log_model(
        clf_xgb,
        model_name=f"{mname}",
        version_name=f"{mvname}",
        options={"enable_explainability": False},
    )
    return "success"
La fonction log_model permet d’effectuer les opérations suivantes :

Utilise pandas et numpy pour créer un DataFrame qui servira de données d’entraînement pour le modèle.

Crée une instance de XGBoost qui servira d’algorithme d’entraînement pour les données.

Appelle la fonction fit() de XGBoost pour créer un modèle et l’entraîner sur l’ensemble de données.

Appelle la fonction log_model() de Snowflake Model Registry pour ajouter le modèle au registre de modèles.

Note

Les modèles créés par une application doivent être stockés dans un registre de modèles. Les applications ne peuvent pas accéder aux modèles qui sont stockés dans une zone de préparation.

Facultatif : Pour permettre aux consommateurs d’exécuter la procédure stockée afin d’entraîner le modèle, accordez le privilège USAGE pour la procédure stockée :
```
GRANT USAGE ON PROCEDURE core.py_log_model(STRING, STRING) TO APPLICATION ROLE app_public;
```

Créer une procédure stockée pour exécuter un modèle¶

Créez une procédure stockée pour la fonction Python que vous utilisez pour appeler le modèle.

  CREATE OR REPLACE PROCEDURE core.py_call_predict(mname STRING, mvname STRING)
  RETURNS TABLE()
  LANGUAGE python
  RUNTIME_VERSION = 3.11
  HANDLER = 'run_model'
  PACKAGES = ('snowflake-snowpark-python','scikit-learn', 'snowflake-ml-python>=1.6.2', 'pandas', 'xgboost')
  AS
'
-- <body of the stored procedure>
';

Ajouter le code Python que vous utilisez pour appeler le modèle

import _snowflake
from snowflake.ml.registry import Registry
import pandas as pd
from sklearn import datasets

def run_model(sp_session, mname, mvname):
  iris = datasets.load_iris()
  df = pd.DataFrame(data=iris["data"], columns=iris["feature_names"])
  df.columns = [s.replace(" (CM)", "").replace(" ", "") for s in df.columns.str.upper()]

  reg = Registry(session=sp_session, schema_name="stateful_schema")
  mv = reg.get_model(mname).version(mvname)

  pred = mv.run(df.head(10), function_name="predict")
  return sp_session.create_dataframe(pred)
La fonction run_model permet d’effectuer les opérations suivantes :

Exécute la fonction load_iris() pour charger l’ensemble de données de machine learning Iris.

Utilise pandas pour créer un DataFrame sur la base de l’ensemble de données Iris.

Exécute la fonction get_model() pour obtenir le registre de modèles.

Exécute la fonction Predict sur le modèle.

Renvoie le résultat.

Facultatif : Pour permettre aux consommateurs d’exécuter la procédure stockée afin d’entraîner le modèle, accordez le privilège USAGE pour la procédure stockée :
```
GRANT USAGE ON PROCEDURE core.py_call_predict(STRING, STRING) TO APPLICATION ROLE app_public;
```

Exécuter les procédures stockées¶

Si l’application accorde le privilège USAGE pour ces procédures stockées à un rôle d’application, les consommateurs peuvent appeler les procédures stockées pour entraîner et exécuter les modèles, comme le montrent les exemples suivants :

CALL my_app.core.py_log_model('md1', 'V1');

Cette commande appelle la procédure stockée py_log_model pour entraîner le modèle.

CALL my_app.core.py_call_predict('md1', 'V1');

Cette commande appelle la procédure stockée py_call_predict pour appeler la fonction Predict sur le modèle.