Modelos de treinamento

Uso do Snowflake ML para desenvolver modelos de aprendizado de máquina e aprendizado profundo com estruturas populares de código aberto. O Snowflake ML fornece ambientes de desenvolvimento flexíveis, acesso eficiente aos dados e recursos de computação poderosos sem a sobrecarga de gerenciamento.

É possível treinar um modelo em um Snowflake Notebook ou em um Snowflake ML Trabalho.

Os notebooks Snowflake são ambientes interativos que você pode usar para aprendizado de máquina. Para obter mais informações sobre o uso do Snowflake Notebooks para fluxos de trabalho de aprendizado de máquina, consulte Notebooks no Container Runtime para ML.

Os trabalhos do Snowflake ML permitem que você execute fluxos de trabalho de ML de qualquer ambiente. Para obter mais informações sobre o uso do Snowflake ML Trabalhos, consulte Snowflake ML Jobs.

With Snowflake Experiments, you can compare your trained models in an organized manner. Use information logged during model training to evaluate the results and select the best model for your needs. For more information, see Run an experiment to compare and select models.

Treinamento com código aberto

Quando você usa um notebook Snowflake ou ML do trabalho, você tem acesso ao Container Runtime para ML. O Container Runtime para ML é um ambiente que possui pacotes e estruturas populares que você pode usar para treinar seus modelos. Os pacotes incluem scikit-learn, numpy e scipy. Para obter mais informações, consulte Container Runtime para ML.

O exemplo a seguir treina um modelo de regressão logística usando o scikit-learn:

import pandas as pd
from snowflake.ml.data.data_connector import DataConnector
from snowflake.snowpark.context import get_active_session
from sklearn.linear_model import LogisticRegression

# Get the active Snowpark session
session = get_active_session()

# Specify training table location
table_name = "TRAINING_TABLE"  # Replace with your actual Snowflake table name

# Load table into DataConnector
data_connector = DataConnector.from_dataframe(session.table(table_name))

# Convert to pandas DataFrame
pandas_df = data_connector.to_pandas()

# Assuming 'TARGET' is the label column in your Snowflake table
label_column_name = 'TARGET'

# Separate features (X) and target (y)
X, y = pandas_df.drop(label_column_name, axis=1), pandas_df[label_column_name]

# Initialize and fit a Logistic Regression model
logistic_regression_model = LogisticRegression(max_iter=1000)  # Increased max_iter for convergence
logistic_regression_model.fit(X, y)
Copy

Além do scikit-learn, você pode usar o XGBoost e LightGBM Bibliotecas para desenvolver modelos poderosos de classificação, regressão e classificação.

O exemplo a seguir carrega dados de uma tabela Snowflake usando a Snowflake DataConnector, o converte em um pandas DataFrame, e treina um XGBoost Modelo. O DataConnector acelera o carregamento de dados e a conversão de dataframe do pandas. Para obter mais informações sobre o DataConnector, consulte Carregamento de dados estruturados de tabelas do Snowflake

from snowflake.ml.data.data_connector import DataConnector
from snowflake.snowpark.context import get_active_session
import xgboost as xgb

session = get_active_session()

# Specify training table location
table_name = "TRAINING_TABLE"

# Load table into DataConnector
data_connector = DataConnector.from_dataframe(session.table(table_name))

pandas_df = data_connector.to_pandas()
label_column_name = 'TARGET'
X, y = pandas_df.drop(label_column_name, axis=1), pandas_df[label_column_name]

clf = xgb.Classifier()
clf.fit(X, y)
Copy

Treinamento de modelos de aprendizado profundo

Você pode usar uma GPUimagem de tempo de execução de contêiner com tecnologia para treinar modelos de aprendizado profundo com PyTorch, TensorFlowe outros frameworks. Você pode usar as bibliotecas pré-instaladas ou pode estender a imagem base com pacotes de repositórios públicos ou privados.

Você pode obter GPU computar sob demanda de seus pools de computação disponíveis. Você só paga pelos recursos que utiliza.

Com a GPU da imagem de tempo de execução do contêiner, você pode usar recursos como treinamento distribuído para acelerar o desenvolvimento de modelos de grande escala.

Para um exemplo de carregamento eficiente de dados com DataConnector e treinamento distribuído, consulte Execução de distribuídas PyTorch Modelos no Snowflake: Uma de ponta a ponta ML Solução.

O exemplo a seguir carrega os dados de forma eficiente:

import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from snowflake.ml.data.data_connector import DataConnector

example_snowpark_dataframe = session.table("EXAMPLE_TRAINING_DATA")

# Connector from a Snowflake table
data_connector = DataConnector.from_dataframe(example_snowpark_dataframe)

# Load as a torch dataset
torch_dataset = data_connector.to_torch_dataset(batch_size=32)
train_loader = DataLoader(torch_dataset, batch_size=None)

label_col = 'TARGET'
feature_cols = ['FEATURE1', 'FEATURE2']

for batch_idx, batch in enumerate(dataloader):
    y = batch_data.pop(label_col).squeeze()
    X = torch.stack(
        [tensor.squeeze() for key, tensor in batch.items() if key in feature_cols]
    )
Copy

O exemplo a seguir treina um modelo:

# ------------------------
# Tiny MLP for binary classification
# ------------------------
input_dim = X.shape[1]

class MLP(nn.Module):
    def __init__(self, d_in):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(d_in, 64), nn.ReLU(),
            nn.Linear(64, 32), nn.ReLU(),
            nn.Linear(32, 1)  # logits
        )

    def forward(self, x):
        return self.net(x).squeeze(1)

DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = MLP(input_dim).to(DEVICE)
opt = torch.optim.Adam(model.parameters(), lr=1e-3)
criterion = nn.BCEWithLogitsLoss()

# ------------------------
# Train
# ------------------------
EPOCHS = 5

for epoch in range(1, EPOCHS + 1):
    model.train()
    for xb, yb in train_loader:
        xb, yb = xb.to(DEVICE), yb.to(DEVICE)
        logits = model(xb)
        loss = criterion(logits, yb)
        opt.zero_grad()
        loss.backward()
        opt.step()
    acc = evaluate(val_loader)
    print(f"epoch {epoch} val_acc={acc:.3f}")
Copy

Como lidar com tarefas de treinamento complexas

O treinamento de modelos em grandes conjuntos de dados, arquiteturas de modelos complexas e hiperparâmetros requer tempo, custo e acesso significativos a recursos que facilitam esse processamento complexo. Com Snowflake ML, você pode treinar esses modelos com confiança.

Infraestrutura de treinamento totalmente gerenciada

O Snowflake ML fornece infraestrutura de treinamento totalmente gerenciada por meio de Notebooks e trabalhos de ML em Container Runtime. Você não precisa gerenciar imagens personalizadas ou provisionar recursos. Você pode trazer sua carga de trabalho, selecionar os nós de computação apropriados na lista determinada pelo administrador e iniciar o treinamento.

Movimentação de dados eficiente e acelerada

Carregar grandes quantidades de dados na memória para processamento com pacotes de treinamento pode ser lento, especialmente quando você está tentando ler diretamente em um objeto como um dataframe do pandas. O Snowflake ML torna o carregamento de dados eficiente usando o processamento distribuído dos pools de computação subjacentes. Use o Data Connector para carregar de suas tabelas e estágios do Snowflake em objetos de código aberto, como pandas DataFrames, PyTorch conjuntos de dados e TensorFlow Conjuntos de dados.

Treinamento distribuído e ajuste de hiperparâmetros

Treinamento ML Modelos em grandes conjuntos de dados podem exceder os recursos de um único nó. Com distribuídas do Snowflake APIs, você pode dimensionar fluxos de trabalho de engenharia de recursos e treinamento em vários nós para melhorar o desempenho. Com a distribuída APIs, você pode fazer o seguinte:

  • Como aproveitar as funções de pré-processamento distribuídas no snowflake.ml.modeling.preprocessing.

  • Dimensione seu treinamento de modelo em um ou mais nós usando treinamento otimizado APIs em Container Runtime para ML.

  • Aceleração do ajuste de hiperparâmetros com Snowflake MLde distribuído HPO, otimizado para dados armazenados em Snowflake. Você também pode usar bibliotecas de código aberto como hyperopt ou optuna.

Além de usar APIs distribuídas do Snowflake para dimensionar seus fluxos de trabalho, você também pode usar o Ray. Ray é uma estrutura de código aberto que oferece uma maneira simples e flexível de dimensionar aplicativos Python. Ele permite que você execute seu código em paralelo para vários nós. Para obter mais informações sobre o uso do Ray com o Snowflake ML, consulte o Guia de introdução do Ray.

Integrar ao MLOps

O Snowflake fornece uma totalmente integrada MLOps Plataforma que você pode acessar por meio do Snowflake Notebooks e ML Trabalhos. Isso permite que você treine modelos usando recursos prontos para produção, gerencie experimentos e modelos e implante modelos treinados para produção.

Você pode usar os seguintes recursos para seu MLOps Fluxo de trabalho:

  • Criação e gerenciamento de recursos através do Feature Store

  • Execute o pré-processamento de recursos em escala com OSS e SnowflakeML APIs

  • Gerenciamento de experiências com rastreamento de experiências integrado

  • Registro e gerenciamento do modelo treinado

  • Executar pipelines de inferência no modelo registrado

  • Monitoramento do modelo implantado quanto a desvio e precisão

Próximos passos

Após treinar seus modelos, você pode:

Linguagem: Português