Notebooks no Container Runtime para ML¶

Visão geral¶

Você pode executar o Snowflake Notebooks no Container Runtime for ML. O Container Runtime for ML é fornecido pelo Snowpark Container Services, oferecendo uma infraestrutura de contêiner flexível que oferece suporte à criação e operacionalização de uma ampla variedade de fluxos de trabalho inteiramente dentro do Snowflake. O Container Runtime for ML fornece opções de software e hardware para dar suporte a cargas de trabalho avançadas de ciência de dados e machine learning (aprendizado de máquina). Comparado aos warehouses virtuais, o Container Runtime for ML fornece um ambiente de computação mais flexível, onde você pode instalar pacotes de várias fontes e selecionar recursos de computação, incluindo tipos de máquina de GPU, enquanto ainda executa consultas SQL em warehouses para um desempenho ideal.

Este documento descreve algumas considerações para usar notebooks no Container Runtime for ML. Você também pode experimentar o guia de início rápido Introdução ao Snowflake Notebook Container Runtime para saber mais sobre como usar o Container Runtime for ML no seu desenvolvimento.

Pré-requisitos¶

Antes de começar a usar o Snowflake Notebooks no Container Runtime for ML, a função ACCOUNTADMIN deve concluir as etapas de configuração do notebook para criar os recursos necessários e conceder privilégios a esses recursos. Para obter etapas detalhadas, consulte Instruções de configuração do usuário para Snowflake Notebooks.

Criar um notebook no Container Runtime for ML¶

Ao criar um notebook no Container Runtime for ML, você escolhe um warehouse, um tempo de execução e um pool de computação para fornecer os recursos para executar seu notebook. O tempo de execução escolhido lhe dará acesso a diferentes pacotes Python com base no seu caso de uso. Diferentes tamanhos de warehouse ou pools de computação têm diferentes implicações de custo e desempenho. Todas essas configurações podem ser alteradas posteriormente, se necessário.

Para criar um Snowflake Notebook para execução no Container Runtime for ML, siga estas etapas:

1. Faça login no Snowsight.

2. Selecione Notebooks.

3. Selecione + Notebook.

4. Insira um nome para seu notebook.

5. Selecione um banco de dados e um esquema para armazenar seu notebook. Este parâmetro não pode ser alterado após a criação do notebook.

   Nota

   O banco de dados e o esquema são necessários apenas para armazenar seus notebooks. Você pode consultar qualquer banco de dados e esquema aos quais sua função tenha acesso a partir do seu notebook.

6. Selecione o Run on container como seu ambiente Python.

7. Selecione o tipo de Runtime: CPU ou GPU.

8. Selecione um Compute pool.

9. Altere o warehouse selecionado a ser usado para executar consultas SQL e Snowpark.

   Para obter orientação sobre o tamanho do warehouse a ser usado, consulte Recomendações de warehouse para execução dos notebooks Snowflake.

10. Para criar e abrir seu notebook, selecione Create.

Runtime:

Essa visualização fornece dois tipos de tempos de execução: CPU e GPU. Cada imagem de tempo de execução contém um conjunto base de versões e pacotes Python verificados e integrados pelo Snowflake. Todas as imagens de tempo de execução oferecem suporte à análise de dados, modelagem e treinamento com o Snowpark Python, Snowflake ML e Streamlit.

Para instalar pacotes adicionais de um repositório público, você pode usar o pip. Uma integração de acesso externo (EAI) é necessária para que o Snowflake Notebooks instale pacotes de pontos de extremidade externos. Para configurar EAIs, consulte Configurar acesso externo para o Snowflake Notebooks. Entretanto, se um pacote já fizer parte da imagem base, você não poderá alterar a versão do pacote instalando uma versão diferente com pip install. Para uma lista dos pacotes pré-instalados, consulte Container Runtime para ML.

Compute pool:

Um pool de computação fornece os recursos de computação para o kernel do seu notebook e o código Python. Use pools de computação menores e baseados em CPU para começar e selecione pools de computação com mais memória e baseados em GPU para otimizar cenários de uso intensivo de GPU, como visão computacional ou LLMs/VLMs.

Observe que cada nó de computação está limitado a executar um notebook por usuário por vez. Você deve definir o parâmetro MAX_NODES com um valor maior que um ao criar pools de computação para notebooks. Para obter um exemplo, consulte Criar recursos de computação. Para mais detalhes sobre pools de computação do Snowpark Container Services, consulte Snowpark Container Services: como trabalhar com pools de computação.

Quando um notebook não estiver sendo usado, considere desligá-lo para liberar recursos do nó. Você pode desligar um notebook selecionando End session no botão suspenso de conexão.

Executar um notebook no Container Runtime for ML¶

Depois de criar seu notebook, você pode começar a executar o código imediatamente adicionando e executando células. Para obter mais informações sobre como adicionar células, consulte Desenvolvimento e execução de código nos Snowflake Notebooks.

!pip install transformers scipy ftfy accelerate

Execução de cargas de trabalho ML¶

Os Notebooks no Container Runtime for ML são adequados para executar cargas de trabalho ML, como treinamento de modelos e ajuste de parâmetros. Os tempos de execução vêm pré-instalados com pacotes ML comuns. Com a EAI definida, você pode instalar quaisquer outros pacotes necessários usando !pip install.

Os exemplos a seguir mostram como usar algumas das bibliotecas disponíveis para sua carga de trabalho ML.

from snowflake.snowpark.context import get_active_session
import pandas as pd
import xgboost as xgb
from sklearn.model_selection import train_test_split

session = get_active_session()
df = session.table("my_dataset")
# Pull data into local memory
df_pd = df.to_pandas()
X = df_pd[['feature1', 'feature2']]
y = df_pd['label']
# Split data into test and train in memory
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.15, random_state=34)
# Train in memory
model = xgb.XGBClassifier()
model.fit(X_train, y_train)
# Predict
y_pred = model.predict(X_test)

from snowflake.snowpark.context import get_active_session
from snowflake.ml.modeling.xgboost import XGBClassifier
from snowflake.ml.modeling.metrics import accuracy_score

session = get_active_session()
df = session.table("my_dataset")
feature_cols=['FEATURE1', 'FEATURE2']
label_col = 'LABEL'
predicted_col = [PREDICTED_LABEL]
df = df[features_cols + [label_col]]
# Split is pushed down to associated warehouse
train_df, test_df = df.random_split(weights=[0.85, 0.15], seed=34)

model = XGBClassifier(
    input_cols=feature_cols,
    label_cols=label_col,
    output_cols=predicted_col,
    # This will enable leveraging all GPUs on the node
    tree_method="gpu_hist",
)
# Train
model.fit(train_df)
# Predict
result = model.predict(test_df)

accuracy = accuracy_score(
df=result,
y_true_col_names=label_cols,
y_pred_col_names=predicted_col)

from snowflake.snowpark.context import get_active_session
from snowflake.ml.modeling.lightgbm import LGBMClassifier
from snowflake.ml.modeling.metrics import accuracy_score

session = get_active_session()
df = session.table("my_dataset")
feature_cols=['FEATURE1', 'FEATURE2']
label_col = 'LABEL'
predicted_col = [PREDICTED_LABEL]

df = df[features_cols + [label_col]]
# Split is pushed down to associated warehouse
train_df, test_df = df.random_split(weights=[0.85, 0.15], seed=34)

model = LGBMClassifier(
    input_cols=feature_cols,
    label_cols=label_col,
    ouput_cols=predicted_col,
    # This will enable leveraging all GPUs on the node
    device_type="gpu",
)

# Train
model.fit(train_df)
# Predict
result = model.predict(test_df)

accuracy = accuracy_score(
df=result,
y_true_col_names=label_cols,
y_pred_col_names=predicted_col)

Considerações sobre custos/faturamento¶

Ao executar notebooks no Container Runtime for ML, você pode incorrer em custos de computação de warehouse e computação do SPCS.

O Snowflake Notebooks exige um warehouse virtual para executar consultas SQL e do Snowpark para um desempenho otimizado. Portanto, você também pode incorrer em custos de computação de warehouse virtual se usar SQL em células SQL e consultas push-down do Snowpark executadas em células Python. O diagrama a seguir mostra onde a computação acontece para cada tipo de célula.

Por exemplo, o exemplo Python a seguir usa a biblioteca xgboost Os dados são puxados para o contêiner e a computação ocorre no Snowpark Container Services:

from snowflake.snowpark.context import get_active_session
import pandas as pd
import xgboost as xgb
from sklearn.model_selection import train_test_split

session = get_active_session()
df = session.table("my_dataset")
# Pull data into local memory
df_pd = df.to_pandas()
X = df_pd[['feature1', 'feature2']]
y = df_pd['label']
# Split data into test and train in memory
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.15, random_state=34)

Para saber mais sobre custos de warehouse, consulte Visão geral de warehouses e Recomendações de warehouse para execução dos notebooks Snowflake.