Entraîner des modèles

Utiliser Snowflake ML pour développer des modèles de machine learning et d’apprentissage profond avec des frameworks open source populaires. Snowflake ML fournit des environnements de développement flexibles, un accès efficace aux données et des ressources de calcul puissantes, sans frais de gestion supplémentaires.

Vous pouvez entraîner un modèle dans un notebook Snowflake ou dans une tâche ML Snowflake.

Les notebooks Snowflake sont des environnements interactifs que vous pouvez utiliser pour le machine learning. Pour plus d’informations sur l’utilisation de Snowflake Notebooks pour les workflows de machine learning, voir Notebooks sur Container Runtime pour ML.

Les tâches ML Snowflake vous permettent d’exécuter des workflows ML depuis n’importe quel environnement. Pour plus d’informations sur l’utilisation des tâches ML Snowflake, voir Tâches Snowflake ML.

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.

Entraînement avec l’open source

Lorsque vous utilisez un notebook Snowflake ou une tâche ML, vous avez accès à Container Runtime pour ML. Container Runtime pour ML est un environnement qui possède des paquets et des frameworks populaires que vous pouvez utiliser pour entraîner vos modèles. Les paquets incluent scikit-learn, numpy et scipy. Pour plus d’informations, voir Container Runtime pour ML.

L’exemple suivant entraîne un modèle de régression logistique à l’aide de 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

En plus de scikit-learn, vous pouvez utiliser les bibliothèques XGBoost et LightGBM pour développer de puissants modèles de classification, de régression et de classement.

L’exemple suivant charge les données d’une table Snowflake à l’aide du DataConnector Snowflake, le convertit en DataFrame pandas, et entraîne un modèle XGBoost. Le DataConnector accélère le chargement des données et la conversion des dataframes pandas. Pour plus d’informations sur le DataConnector, consultez Charger des données structurées à partir de tables 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

Entraîner des modèles d’apprentissage profond

Vous pouvez utiliser une image d’exécution de conteneur optimisée par GPU pour entraîner les modèles d’apprentissage profond avec PyTorch, TensorFlow et d’autres frameworks. Vous pouvez utiliser les bibliothèques préinstallées ou vous pouvez étendre l’image de base avec des paquets provenant de référentiels publics ou privés.

Vous pouvez obtenir des ressources de calcul GPU à la demande à partir de vos pools de calcul disponibles. Vous ne payez que les ressources que vous utilisez.

Avec l’image d’exécution de conteneur GPU, vous pouvez utiliser des fonctionnalités telles que l’apprentissage distribué pour accélérer le développement de modèles à grande échelle.

Pour un exemple de chargement de données efficace avec DataConnector et un entraînement distribué, voir Exécuter des modèles PyTorch distribués sur Snowflake : une solution ML de bout en bout.

L’exemple suivant charge les données efficacement :

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

L’exemple suivant entraîne un modèle :

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

Gérer des tâches d’entraînement complexes

L’entraînement de modèles sur des ensembles de données volumineux, des architectures de modèles complexes et des hyperparamètres nécessite beaucoup de temps, d’argent et l’accès à des ressources qui facilitent un traitement aussi complexe. Avec Snowflake ML, vous pouvez entraîner de tels modèles en toute confiance.

Infrastructure d’entraînement entièrement gérée

Snowflake ML fournit une infrastructure d’entraînement entièrement gérée via les notebooks et les tâches ML sur Container Runtime. Vous n’avez pas besoin de gérer des images personnalisées ou de provisionner des ressources. Vous pouvez apporter votre charge de travail, sélectionner les nœuds de calcul appropriés dans la liste déterminée par l’administrateur et commencer l’entraînement.

Déplacement de données efficace et accéléré

Le chargement de grandes quantités de données en mémoire pour le traitement avec des paquets d’entraînement peut être lent, en particulier lorsque vous essayez de lire directement dans un objet tel qu’un dataframe pandas. Snowflake ML rend le chargement des données efficace en utilisant le traitement distribué des pools de calcul sous-jacents. Utilisez le connecteur de données pour charger depuis vos tables et zones de préparation Snowflake vers des objets open source tels que des dataframes pandas et des ensemble de données PyTorch ou TensorFlow.

Entraînement distribué et réglage des hyperparamètres

L’entraînement de modèle ML sur de grands ensembles de données peuvent dépasser les ressources d’un seul nœud. Avec les APIs distribuées de Snowflake, vous pouvez faire évoluer les workflows d’ingénierie des fonctionnalités et d’entraînement sur plusieurs nœuds pour améliorer les performances. Avec les APIs distribuées, vous pouvez effectuer les opérations suivantes :

  • Exploiter des fonctionnalités de prétraitement distribuées dans snowflake.ml.modeling.preprocessing.

  • Développer votre entraînement de modèle sur un ou plusieurs nœuds à l’aide d’APIs d’entraînement optimisées dans Container Runtime pour ML.

  • Accélérer le réglage des hyperparamètres avec le HPO distribué de Snowflake ML, optimisé pour les données stockées dans Snowflake. Vous pouvez également utiliser des bibliothèques open source comme hyperopt ou optuna.

En plus d’utiliser les APIs distribuées de Snowflake pour mettre à l’échelle vos flux de travail, vous pouvez également utiliser Ray. Ray est un cadre open-source qui fournit un moyen simple et flexible de faire évoluer les applications Python. Il vous permet d’exécuter votre code en parallèle sur plusieurs nœuds. Pour plus d’informations sur l’utilisation de Ray avec Snowflake ML, consultez le Guide de prise en main de Ray.

Effectuer une intégration à MLOps

Snowflake fournit une plateforme MLOps entièrement intégrée à laquelle vous pouvez accéder via Snowflake Notebooks et les tâches ML. Cela vous permet d’entraîner des modèles à l’aide de fonctionnalités prêtes pour la production, de gérer des expériences et des modèles, et de déployer des modèles entraînés en production.

Vous pouvez utiliser les fonctionnalités suivantes pour votre workflow MLOps :

  • Créer et gérer des fonctionnalités via le Feature Store

  • Exécuter le prétraitement des fonctionnalités à l’échelle avec OSS et les APIs SnowflakeML

  • Gérer les expériences avec le suivi des expériences intégré

  • Enregistrer et gérer le modèle entraîné

  • Exécuter des pipelines d’inférence sur le modèle enregistré

  • Surveiller la migration et la précision du modèle déployé

Prochaines étapes

Après avoir entraîné vos modèles, vous pouvez :

Langage: Français