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 avecscikit-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
etnumpy
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.