Erstellen, Trainieren und Verwenden eines Snowflake ML-Modells in einer App¶

Unter diesem Thema finden Sie ein Beispiel dafür, wie Sie ein Snowflake ML-Modell innerhalb einer Snowflake Native App mit dem Python-Paket scikit-learn trainieren können. Das Beispiel unter diesem Thema kann verwendet werden, um Modelle anhand von Daten in den Konten der Verbraucher oder Anbieter zu trainieren.

Erstellen eines versionierten Schemas, das die gespeicherten Prozeduren enthält¶

Erstellen Sie im Setup-Skript ein versioniertes Schema, das die gespeicherte Prozedur enthält wie im folgenden Beispiel gezeigt:

Erstellen eines versionierten Schemas für die gespeicherte Prozedur

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

Erstellen einer gespeicherten Prozedur zum Erstellen und Trainieren eines Modells¶

Erstellen Sie eine gespeicherte Prozedur für die Python-Funktion, die Sie zum Trainieren eines Modells verwenden, wie im folgenden Beispiel gezeigt:

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>
';
In diesem Beispiel wird eine gespeicherte Prozedur mit dem Namen py_log_model erstellt und die Python-Pakete deklariert, die zum Trainieren eines Modells mit scikit-learn erforderlich sind:

snowflake-snowpark-python

scikit-learn

snowflake-ml-python

pandas

numpy

xgboost

Nachdem Sie eine gespeicherte Prozedur erstellt haben, fügen Sie den folgenden Code in den Body der gespeicherten Prozedur ein:

Python-Code in den Body der gespeicherten Prozedur einfügen

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"
Die Funktion log_model hat folgende Aufgaben:

Verwendet pandas und numpy, um einen DataFrame zu erstellen, der als Trainingsdaten für das Modell dient.

Erzeugt eine Instanz von XGBoost, die als Trainingsalgorithmus für die Daten dient.

Ruft die Funktion fit() von XGBoost auf, um ein Modell zu erstellen und es mit dem Datensatz zu trainieren.

Ruft die Funktion log_model() von Snowflake Model Registry auf, um das Modell zur Modellregistrierung hinzuzufügen.

Bemerkung

Von einer Anwendung erstellte Modelle müssen in einer Modellregistrierung gespeichert werden. Anwendungen können nicht auf Modelle zugreifen, die in einem Stagingbereich gespeichert sind.

Optional: Damit Verbraucher die gespeicherte Prozedur ausführen können, um das Modell zu trainieren, gewähren Sie die Berechtigung USAGE für die gespeicherte Prozedur:
```
GRANT USAGE ON PROCEDURE core.py_log_model(STRING, STRING) TO APPLICATION ROLE app_public;
```

Erstellen einer gespeicherten Prozedur zur Ausführung eines Modells¶

Erstellen Sie eine gespeicherte Prozedur für die Python-Funktion, die Sie zum Aufrufen des Modells verwenden.

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

Python-Code hinzufügen, den Sie zum Aufrufen des Modells verwenden

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)
Die Funktion run_model bewirkt Folgendes:

Führt die Funktion load_iris() aus, um den Iris-Datensatz für maschinelles Lernen zu laden.

Verwendet pandas, um einen DataFrame auf der Grundlage des Iris-Datensatzes zu erstellen.

Führt die Funktion get_model() aus, um die Modellregistrierung zu erhalten.

Führt die Vorhersagefunktion für das Modell aus.

Gibt das Ergebnis zurück.

Optional: Damit Verbraucher die gespeicherte Prozedur ausführen können, um das Modell zu trainieren, gewähren Sie die Berechtigung USAGE für die gespeicherte Prozedur:
```
GRANT USAGE ON PROCEDURE core.py_call_predict(STRING, STRING) TO APPLICATION ROLE app_public;
```

Gespeicherte Prozeduren ausführen¶

Wenn die Anwendung einer Anwendungsrolle die Berechtigung USAGE für diese gespeicherten Prozeduren gewährt, können Verbraucher die gespeicherten Prozeduren aufrufen, um die Modelle zu trainieren und auszuführen wie in den folgenden Beispielen gezeigt:

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

Dieser Befehl ruft die gespeicherte Prozedur py_log_model auf, um das Modell zu trainieren.

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

Dieser Befehl ruft die gespeicherte Prozedur py_call_predict auf, um die Vorhersagefunktion für das Modell aufzurufen.