Inferência em lote nativa do Snowflake (SQL)¶

Selecionando um ambiente de tempo de execução¶

Você pode hospedar um modelo em um warehouse virtual ou um pool de computação SPCS. Use as informações a seguir para determinar onde você hospedará seu modelo.

Para executar o modelo no warehouse¶

Para hospedar seu modelo em um warehouse, especifique WAREHOUSE no argumento target_platforms para registrar seu modelo. Para obter mais informações, consulte o tópico sobre como trabalhar com dependências e plataformas de destino.

Para obter informações sobre a possibilidade de um modelo existente ser executado em um warehouse, execute SHOW VERSIONS IN MODEL. Se o valor da coluna runnable_in for WAREHOUSE, você poderá executá-lo.

Para executar o modelo no SPCS¶

Para usar seu modelo no SPCS, você deve implantar o modelo como um serviço. Para obter mais informações sobre a implantação de um modelo no SPCS, consulte o tópico sobre como implantar o modelo para inferência online. Certifique-se de que a suspensão automática esteja ativa.

Use um warehouse XSMALL ou SMALL para rotear suas solicitações de inferência para o pool de computação SPCS. Um warehouse pode executar vários threads por nó e enviar um grande número de solicitações de inferência com cada solicitação. Consequentemente, o serviço que opera no SPCS pode ficar facilmente sobrecarregado. Portanto, a recomendação é utilizar um warehouse XSMALL ou SMALL quando o modelo é implantado no SPCS.

Conectar-se ao Model Registry¶

Recupere o modelo que você usa para solicitações de inferência do registro de modelos. Use o código a seguir para recuperar o modelo:

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

Executar o trabalho de inferência em lote¶

Use o método run do seu objeto de versão do modelo para executar um trabalho de inferência em lote. Usando o método run, você pode:

• Executar um trabalho de inferência em um warehouse ou em um pool de computação SPCS.

• Fornecer um dataframe Snowpark ou pandas com os dados de inferência.

O método run retorna um dataframe que corresponde ao tipo daquele que você especificou. Por exemplo, se você especificar um dataframe pandas como entrada, receberá um dataframe pandas como saída.

O exemplo a seguir executa um trabalho de inferência em lote em um warehouse:

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

Para executar a inferência no SPCS em vez de em um warehouse, adicione o argumento service_name à chamada run:

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

Para ver os métodos que você pode chamar de um modelo, execute mv.show_functions. O valor de retorno deste método é uma lista de objetos ModelFunctionInfo. Cada um desses objetos inclui os seguintes atributos:

• name: o nome da função que pode ser chamada em Python ou SQL.

• target_method: o nome do método Python no modelo registrado original.

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

Passando parâmetros durante a inferência¶

Se a assinatura do modelo incluir parâmetros definidos no objeto ParamSpec, você poderá passar valores de parâmetro no momento da inferência usando o argumento params. Qualquer parâmetro que não tenha sido incluído no dicionário usará o valor padrão da assinatura. O argumento params funciona da mesma maneira se você executa a inferência em um warehouse ou no SPCS.

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

Para executar o modelo no warehouse¶

Use a sintaxe MODEL(model_name)!method_name(...) para chamar ou invocar métodos de um modelo. Os métodos disponíveis em um modelo são determinados pela classe de modelo Python subjacente. Por exemplo, muitos tipos de modelos usam um método chamado predict para inferência.

Para chamar um método do modelo padrão, use a seguinte sintaxe. Inclua qualquer argumento de método entre parênteses e especifique a tabela que contém os dados de inferência na cláusula FROM.

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

Para invocar um método de uma versão específica de um modelo, crie um alias para a versão específica do modelo e chame o método por meio do alias.

Use a seguinte sintaxe para chamar um método de uma versão específica de um modelo.

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

O exemplo a seguir usa o alias LAST para chamar a versão mais recente de um modelo.

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

Passando parâmetros em SQL¶

Se a assinatura do modelo incluir parâmetros definidos com ParamSpec, você poderá passar valores de parâmetros como argumentos adicionais após as colunas de entrada. Os parâmetros podem ser especificados por posição ou por nome.

Ao utilizar argumentos posicionais, os parâmetros podem ser omitidos do lado direito, e os padrões da assinatura são usados:

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

Ao usar argumentos nomeados, todos os argumentos (incluindo as colunas de entrada) devem ser especificados por nome. Isso permite passar apenas parâmetros específicos, independentemente de sua posição:

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

Para executar o modelo no SPCS¶

Ao contrário da execução em um warehouse, as funções podem ser chamadas de um serviço chamando service_name!method_name(...).

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

Os parâmetros são passados da mesma forma que as funções de warehouse; ou todos por posição ou todos por nome:

-- 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¶

As tabelas dinâmicas oferecem um recurso robusto para os usuários do Snowflake realizarem inferência incremental nos dados recebidos. Use o SQL para definir uma tabela dinâmica que faça referência ao modelo e aplique-o às novas linhas recebidas em LOGINS_RAW.

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¶

A Snowpark Python API permite acessar o registro do modelo de forma programática e executar a inferência diretamente em DataFrames. Essa abordagem pode ser mais flexível e passível de manutenção, especialmente em ambientes orientados por código.

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

O exemplo de código acima executará a inferência usando MYMODEL em novos dados em LOGINS_RAW a cada 20 minutos automaticamente.

Imutável ou volátil¶

Esta incrementalidade é essencial e exige que todas as funções invocadas da definição da tabela dinâmica sejam designadas como IMMUTABLE. As funções de um modelo padrão normalmente são IMMUTABLE, mas o padrão dos modelos personalizados é VOLATILE. Se você já sabe que o modelo subjacente é imutável, é fundamental garantir que a função do modelo correspondente seja explicitamente marcada como imutável quando o modelo for registrado.