Snowflake Native Batch-Inferenz (SQL)¶

Auswählen einer Laufzeitumgebung¶

Sie können ein Modell entweder in einem Virtual Warehouse oder in einem hosten SPCS-Computepool hosten. Verwenden Sie die folgenden Informationen, um festzustellen, wo Sie Ihr Modell hosten.

So führen Sie das Modell auf dem Warehouse aus¶

Um Ihr Modell in einem Warehouse zu hosten, geben Sie WAREHOUSE im Argument „target_platforms“ zum Protokollieren des Modells an. Weitere Informationen dazu finden Sie unter dem Thema zum Verwenden von Abhängigkeiten und Zielplattformen.

Um Informationen darüber zu erhalten, ob ein vorhandenes Modell in einem Warehouse ausgeführt werden kann, führen Sie SHOW VERSIONS IN MODEL aus. Wenn für die Spalte „runnable_in“ der Wert WAREHOUSE festgelegt ist, können Sie es ausführen.

So führen Sie das Modell unter SPCS aus¶

Damit Sie das Modell in SPCS verwenden können, müssen Sie das Modell als Dienst bereitstellen. Weitere Informationen zum Bereitstellen eines Modells für SPCS finden Sie im Thema zum Bereitstellen des Modells für Online-Inferenz. Stellen Sie sicher, dass das automatische Anhalten aktiv ist.

Verwenden Sie ein Warehouse der Größe XSMALL oder SMALL, um Ihre Inferenzanfragen an den SPCS-Computepool weiterzuleiten. Ein Warehouse kann mehrere Threads pro Knoten ausführen und mit jeder Anfrage eine große Anzahl von Inferenzanfragen senden. Folglich kann der Dienst, der in SPCS ausgeführt wird, leicht überfordert werden. Daher wird empfohlen, ein Warehouse der Größe XSMALL oder SMALL zu nutzen, wenn das Modell in SPCS bereitgestellt wird.

Verbinden mit Modell-Registry¶

Rufen Sie das Modell, das Sie für Inferenzanfragen verwenden, aus der Modell-Registry ab. Verwenden Sie den folgenden Code, um das Modell abzurufen:

from snowflake.ml.registry import Registry

registry = Registry(session=session, database_name=DATABASE, schema_name=REGISTRY_SCHEMA)
mv = registry.get_model('my_model').version('my_version')  # returns ModelVersion

Batch-Inferenz-Job ausführen¶

Verwenden Sie die Run-Methode des Modellversionsobjekts, um einen Batch-Inferenz-Job auszuführen. Mit der Run-Methode können Sie Folgendes tun:

• Einen Inferenz-Job entweder in einem Warehouse oder in einem SPCS-Computepool ausführen.

• Einen Snowpark- oder pandas-Datenframe mit den Inferenzdaten bereitstellen.

Die Run-Methode gibt einen Datenframe zurück, der dem Typ des von Ihnen angegebenen Datenframes entspricht. Wenn Sie zum Beispiel einen pandas-Datenframe als Eingabe angeben, erhalten Sie einen pandas-Datenframe als Ausgabe.

Das folgende Beispiel führt einen Batch-Inferenz-Job für ein Warehouse aus:

# Run inference on a warehouse
# mv: snowflake.ml.model.ModelVersion
remote_prediction = mv.run(input_features, function_name="predict")
remote_prediction.show()

Um die Inferenz in SPCS anstelle eines Warehouses auszuführen, fügen Sie das service_name-Argument für den run-Aufruf hinzu:

# Run inference on SPCS
# mv: snowflake.ml.model.ModelVersion
remote_prediction = mv.run(input_features, function_name="predict", service_name="example_spcs_service")
remote_prediction.show()

Um die Methoden zu sehen, die Sie von einem Modell aus aufrufen können, führen Sie „mv.show_functions“ aus. Der Rückgabewert dieser Methode ist eine Liste von ModelFunctionInfo-Objekten. Jedes dieser Objekte enthält die folgenden Attribute:

• name: Der Name der Funktion, die von Python oder SQL aufgerufen werden kann.

• target_method: Der Name der Python-Methode in dem ursprünglich protokollierten Modell.

# Get signature of the inference function in Python
# mv: snowflake.ml.model.ModelVersion
mv.show_functions()

Übergeben von Parametern während der Inferenz¶

Wenn die Signatur des Modells Parameter enthält, die im Objekt ParamSpec definiert sind, können Sie Parameterwerte zur Inferenzzeit mithilfe des Arguments params übergeben. Jeder Parameter, der nicht im Dictionary enthalten ist, verwendet seinen Standardwert aus der Signatur. Das params-Argument funktioniert auf dieselbe Weise, unabhängig davon, ob Sie die Inferenz für ein Warehouse oder für SPCS ausführen.

# Pass parameters to override default values
# mv: snowflake.ml.model.ModelVersion
remote_prediction = mv.run(
    input_features,
    function_name="predict",
    params={"temperature": 0.9, "max_tokens": 512}
)

So führen Sie das Modell auf dem Warehouse aus¶

Verwenden Sie die Syntax MODEL(model_name)!method_name(...), um Methoden eines Modells aufzurufen. Die für ein Modell verfügbaren Methoden werden durch die zugrunde liegende Python-Modellklasse bestimmt. Viele Arten von Modellen verwenden zum Beispiel eine Methode namens Vorhersage für die Inferenz.

Um eine Methode des Standardmodells aufzurufen, verwenden Sie die folgende Syntax. Fügen Sie alle Methodenargumente in Klammern ein und geben Sie in der FROM-Klausel die Tabelle an, die die Inferenzdaten enthält.

SELECT MODEL(<model_name>)!<method_name>(...) FROM <table_name>;

Um eine Methode aus einer bestimmten Version eines Modells aufzurufen, erstellen Sie einen Alias für die spezifisch Version des Modells und rufen dann die Methode über den Alias auf.

Verwenden Sie die folgende Syntax, um eine Methode aus einer bestimmten Version eines Modells aufzurufen.

SELECT MODEL(<model_name>,<version_or_alias_name>)!<method_name>(...) FROM <table_name>;

Das folgende Beispiel verwendet den Alias LAST, um die neueste Version eines Modells aufzurufen.

SELECT MODEL(my_model,LAST)!predict(...) FROM my_table;

Übergeben von Parametern in SQL¶

Wenn die Signatur des Modells Parameter enthält, die mit ParamSpec definiert sind, können Sie Parameterwerte als zusätzliche Argumente nach den Eingabespalten übergeben. Parameter können über die Position oder über den Namen angegeben werden.

Bei der Verwendung von Positionsargumenten können die Parameter auf der rechten Seite weggelassen werden, und die Standardwerte aus der Signatur werden verwendet:

-- Pass all parameters positionally (temperature, then max_tokens)
SELECT MODEL(my_model, v1)!predict(input_text, 0.9, 512) FROM my_table;

-- Omit max_tokens from the right; its default value from the signature is used
SELECT MODEL(my_model, v1)!predict(input_text, 0.9) FROM my_table;

Bei der Verwendung von benannten Argumenten müssen alle Argumente (einschließlich der Eingabespalten) mit dem Namen angegeben werden. So können Sie nur bestimmte Parameter übergeben, unabhängig von deren Position:

SELECT MODEL(my_model, v1)!predict(
    input_text => input_text,
    max_tokens => 512
) FROM my_table;

So führen Sie das Modell unter SPCS aus¶

Im Gegensatz zur Ausführung in einem Warehouse können Funktionen von einem Dienst aus aufgerufen werden, indem service_name!method_name(...) aufgerufen wird.

SELECT <mservice_name>!<method_name>(...) FROM <table_name>;

Parameter werden auf die gleiche Weise wie bei Warehouse-Funktionen übergeben, entweder alle positionsbezogen oder alle über den Namen:

-- Positional
SELECT my_service!predict(input_text, 0.9, 512) FROM my_table;

-- Named arguments (all arguments must be named)
SELECT my_service!predict(input_text => input_text, max_tokens => 512) FROM my_table;

SQL¶

Dynamische Tabellen bieten Snowflake-Benutzenden eine robuste Möglichkeit, um inkrementelle Inferenzen für eingehende Daten auszuführen. Verwenden Sie SQL, um eine dynamische Tabelle zu definieren, die das Modell referenziert und es auf neu eingehende Zeilen in LOGINS_RAW anwendet:

CREATE OR REPLACE DYNAMIC TABLE logins_with_predictions
    WAREHOUSE = my_wh
    TARGET_LAG = '20 minutes'
    REFRESH_MODE = INCREMENTAL
    INITIALIZE = on_create
    COMMENT = 'Dynamic table with continuously updated model predictions'
AS
SELECT
    login_id,
    user_id,
    location,
    event_time,
    MODEL(ml.registry.mymodel)!predict(l.user_id, l.location) AS prediction_result
FROM logins_raw;

Snowpark Python¶

Mit der Snowpark Python-API können Sie programmgesteuert auf die Modell-Registry zugreifen und Inferenzen direkt auf DataFrames ausführen. Dieser Ansatz kann flexibler und wartungsfreundlicher sein, insbesondere in codegesteuerten Umgebungen.

from snowflake.snowpark import Session
from snowflake.snowpark.functions import col
from snowflake.ml.registry import Registry

# Initialize the registry
reg = Registry(session=sp_session, database_name="ML", schema_name="REGISTRY")

# Retrieve the default model version from the registry
model = reg.get_model("MYMODEL")

# Load the source data
df_raw = sp_session.table("LOGINS_RAW")

# Run inference on the necessary features
predictions_df = model.run(df_raw.select("USER_ID", "LOCATION"))

# Join predictions back to the source data
joined_df = df_raw.join(predictions_df, on=["USER_ID", "LOCATION"])

# Create or replace a dynamic table from the joined DataFrame
joined_df.create_or_replace_dynamic_table(
    name="LOGINS_WITH_PREDICTIONS",
    warehouse="MY_WH",
    lag='20 minutes',
    refresh_mode='INCREMENTAL',
    initialize="ON_CREATE",
    comment="Dynamic table continuously updated with model predictions"
)

Das obige Codebeispiel führt automatisch alle 20 Minuten eine Inferenz mit MYMODEL auf neue Daten in LOGINS_RAW durch.

Unveränderlich im Vgl. zu flüchtig¶

Diese Inkrementalität ist wichtig und erfordert, dass alle Funktionen, die innerhalb der Definition der dynamischen Tabelle aufgerufen werden, als IMMUTABLE festgelegt werden. Während Funktionen innerhalb eines Standardmodells in der Regel sind IMMUTABLE sind, sind kundenspezifischen Modellen standardmäßig VOLATILE. Wenn das zugrunde liegende Modell als unveränderlich bekannt ist, muss unbedingt sichergestellt werden, dass die entsprechende Modellfunktion bei Protokollierung des Modells ausdrücklich als unveränderlich markiert wird.