Trainieren von Modellen

Verwenden Sie Snowflake ML um Machine Learning- und Deep Learning-Modelle mit gängigen Open-Source-Frameworks zu entwickeln. Snowflake ML bietet flexible Entwicklungsumgebungen, effizienten Datenzugriff und leistungsstarke Computeressourcen ohne Verwaltungsaufwand.

Sie können ein Modell entweder innerhalb eines Snowflake Notebooks oder eines Snowflake ML-Jobs trainieren.

Snowflake Notebooks sind interaktive Umgebungen, die Sie für maschinelles Lernen nutzen können. Weitere Informationen zur Verwendung von Snowflake Notebooks für Machine Learning-Workflows finden Sie unter Notebooks auf Container Runtime für ML.

Snowflake ML-Jobs ermöglichen es Ihnen, ML-Workflows aus jeder Umgebung auszuführen. Weitere Informationen zur Verwendung von Snowflake ML-Jobs finden Sie unter 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.

Trainieren mit Open Source

Wenn Sie ein Snowflake Notebook oder einen ML-Job verwenden, erhalten Sie Zugriff auf die Container Runtime für ML. Die Container Runtime für ML ist eine Umgebung mit gängigen Paketen und Frameworks, mit denen Sie Ihre Modelle trainieren können. Die Pakete enthalten scikit-learn, numpy und scipy. Weitere Informationen dazu finden Sie unter Container Runtime für ML.

Das folgende Beispiel trainiert ein logistisches Regressionsmodell mit 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

Zusätzlich zu scikit-learn können Sie auch die XGBoost- und LightGBM-Bibliotheken zur Entwicklung leistungsstarker Klassifizierungs-, Regressions- und Ranking-Modelle verwenden.

Im folgenden Beispiel werden Daten über den Snowflake DataConnector aus einer Snowflake-Tabelle geladen, in einen pandas-DataFrame geladen und es wird ein XGBoost-Modell trainiert. Der DataConnector beschleunigt das Laden von Daten und die Konvertierung von pandas-Datenframes. Weitere Informationen über den DataConnector finden Sie unter Laden von strukturierten Daten aus Snowflake-Tabellen.

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

Trainieren von Deep Learning-Modellen

Sie können ein GPU-gestütztes Container-Laufzeit-Image zum Trainieren von Deep Learning-Modellen mit PyTorch, TensorFlowund anderen Frameworks verwenden. Sie können die vorinstallierten Bibliotheken verwenden oder das Basisimage mit Paketen aus öffentlichen oder privaten Repositorys erweitern.

Sie können bei Bedarf GPU-Computing aus Ihren verfügbaren Computepools erhalten. Sie zahlen nur für die Ressourcen, die Sie nutzen.

Mit dem GPU-Container-Runtime-Image können Sie Features wie verteiltes Training nutzen, um die Entwicklung von umfangreichen Modellen zu beschleunigen.

Ein Beispiel für effizientes Laden von Daten mit DataConnector und verteiltes Training finden Sie unter Ausführen der verteilten PyTorch-Modellen auf Snowflake: Eine End-to-End-ML-Lösung.

Im folgenden Beispiel werden Daten effizient geladen:

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

Im folgenden Beispiel wird ein Modell trainiert:

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

Bearbeiten komplexer Trainingsaufgaben

Das Trainieren von Modellen mit großen Datensets, komplexen Modellarchitekturen und Hyperparametern erfordert erhebliche Zeit, Kosten und Zugang zu Ressourcen, die eine derart komplexe Verarbeitung unterstützen. Mit Snowflake MLkönnen Sie derartige Modelle problemlos trainieren.

Vollständig verwaltete Trainingsinfrastruktur

Snowflake ML bietet eine vollständig verwaltete Trainingsinfrastruktur über Notebooks und ML-Jobs für Container Runtime. Sie müssen keine benutzerdefinierten Images verwalten oder Ressourcen bereitstellen. Sie können Ihren Workload mitbringen, die entsprechenden Serverknoten aus der vom Admin festgelegten Liste auswählen und mit dem Training beginnen.

Effiziente und beschleunigte Datenbewegungen

Das Laden großer Datenmengen in den Arbeitsspeicher für die Verarbeitung mit Trainingspaketen kann langsam sein, insbesondere wenn Sie versuchen, Daten direkt in ein Objekt wie z. B. einen pandas-Datenframe zu lesen. Snowflake ML ermöglicht durch die verteilte Verarbeitung der zugrundeliegenden Computepools ein effizientes Laden von Daten. Verwenden Sie den Datenkonnektor, um Daten aus Ihren Snowflake-Tabellen und -Stagingbereichen in Open-Source-Objekte wie pandas-Datenframes, PyTorch-Datensets und TensorFlow-Datensets zu laden.

Verteiltes Training und Abstimmung von Hyperparametern

Das Training von ML-Modellen mit großen Datensets kann die Ressourcen eines einzelnen Knotens übersteigen. Mit der verteilten APIs von Snowflake können Sie Feature-Engineering- und Trainings-Workflows über mehrere Knoten hinweg skalieren, um die Leistung zu verbessern. Mit der verteilten APIs können Sie Folgendes tun:

  • Verteilte Vorverarbeitungsfunktionen in snowflake.ml.modeling.preprocessing nutzen.

  • Ihr Modelltraining mithilfe von optimiertem Training-APIs in Container Runtime für ML über einen oder mehrere Knoten hinweg skalieren.

  • Die Abstimmung von Hyperparametern mit verteilter HPO von Snowflake ML beschleunigen, optimiert für in Snowflake gespeicherte Daten. Sie können auch Open-Source-Bibliotheken wie hyperopt oder optuna verwenden.

Neben der Verwendung der verteilten APIs von Snowflake zur Skalierung Ihrer Workflows können Sie auch Ray verwenden. Ray ist ein Open-Source-Framework, das eine einfache und flexible Möglichkeit zur Skalierung von Python-Anwendungen bietet. Es ermöglicht Ihnen, Ihren Code parallel auf mehreren Knoten auszuführen. Weitere Informationen zur Verwendung von Ray mit Snowflake ML finden Sie im Ray Getting Started Guide.

Integration mit MLOps

Snowflake bietet eine vollständig integrierte MLOps-Plattform, auf die Sie über Snowflake Notebooks und ML-Jobs zugreifen können. So können Sie Modelle mit produktionsbereiten Features trainieren, Experimente und Modelle verwalten und trainierte Modelle in der Produktion einsetzen.

Sie können die folgenden Funktionen für Ihren MLOps-Workflow verwenden:

  • Erstellen und verwalten von Features über den Feature Store

  • Ausführen der Vorverarbeitung von Features in großem Umfang mit OSS und SnowflakeML APIs

  • Verwalten von Experimenten mit der integrierter Experimentverfolgung

  • Registrieren und Verwalten des trainierten Modells

  • Ausführen von Ableitungspipelines für das registrierte Modell

  • Überwachen des bereitgestellten Modells auf Abweichung und Genauigkeit

Nächste Schritte

Nach dem Training Ihrer Modelle können Sie Folgendes tun:

Sprache: Deutsch