Notebooks auf Container Runtime für ML¶

Übersicht¶

Sie können Snowflake Notebooks auf Container Runtime für ML ausführen. Container Runtime für ML basiert auf Snowpark Container Services und bietet Ihnen eine flexible Container-Infrastruktur, mit der Sie eine Vielzahl von Workflows vollständig innerhalb von Snowflake erstellen und operationalisieren können. Container Runtime für ML bietet Software- und Hardware-Optionen zur Unterstützung fortgeschrittener Data Science- und Machine Learning-Workloads. Im Vergleich zu virtuellen Warehouses bietet Container Runtime für ML eine flexiblere Umgebung, in der Sie Pakete aus verschiedenen Quellen installieren und Computeressourcen, einschließlich GPU-Maschinentypen, auswählen können, während Sie gleichzeitig SQL-Abfragen auf Warehouses für eine optimale Performance durchführen.

Dieses Dokument beschreibt einige Überlegungen zur Verwendung von Notebooks auf Container Runtime für ML. Sie können auch den Schnellstart Erste Schritte mit Snowflake Notebook Container Runtime ausprobieren, um mehr über die Verwendung von Container Runtime für ML in Ihrer Entwicklung zu erfahren.

Voraussetzungen¶

Bevor Sie Snowflake Notebooks für Container Runtime für ML verwenden können, muss die Rolle ACCOUNTADMIN die Schritte zur Einrichtung des Notebooks abschließen, um die erforderlichen Ressourcen zu erstellen und Berechtigungen für diese Ressourcen zu erteilen. Detaillierte Schritte finden Sie unter User Setup-Anweisungen für Snowflake Notebooks.

Notebook auf Container Runtime für ML erstellen¶

Wenn Sie ein Notebook auf Container Runtime für ML erstellen, wählen Sie ein Warehouse, eine Laufzeit und einen Computepool, um die Ressourcen für die Ausführung Ihres Notebooks bereitzustellen. Die von Ihnen gewählte Laufzeit ermöglicht Ihnen den Zugriff auf verschiedene Python-Pakete, je nach Ihrem Anwendungsfall. Unterschiedliche Warehouse-Größen oder Computepools haben unterschiedliche Auswirkungen auf Kosten und Leistung. Alle diese Einstellungen können bei Bedarf später geändert werden.

Gehen Sie folgendermaßen vor, um ein Snowflake-Notebook zu erstellen, das auf Container Runtime für ML läuft:

1. Melden Sie sich bei Snowsight an.

2. Wählen Sie Notebooks aus.

3. Wählen Sie + Notebook aus.

4. Geben Sie einen Namen für Ihr Notebook ein.

5. Wählen Sie eine Datenbank und ein Schema aus, in dem Sie Ihr Notebook speichern möchten. Dieser Parameter kann nach dem Erstellen des Notebooks nicht mehr geändert werden.

   Bemerkung

   Die Datenbank und das Schema werden nur für die Speicherung Ihrer Notebooks benötigt. Sie können jede Datenbank und jedes Schema, auf das Ihre Rolle Zugriff hat, von Ihrem Notebook aus abfragen.

6. Wählen Sie die Run on container als Ihre Python-Umgebung aus.

7. Wählen Sie den Runtime-Typ aus: CPU oder GPU.

8. Wählen Sie Compute pool aus.

9. Ändern Sie das ausgewählte Warehouse, das Sie für die Ausführung von SQL- und Snowpark-Abfragen verwenden möchten.

   Hinweise zur Größe eines Warehouses finden Sie unter Warehouse-Empfehlungen für die Ausführung von Snowflake Notebooks.

10. Um Ihr Notizbuch zu erstellen und zu öffnen, wählen Sie Create aus.

Runtime:

Diese Vorschau bietet zwei Arten von Laufzeiten: CPU und GPU. Jedes Laufzeit-Image enthält einen Basissatz von Python-Paketen und Versionen, die von Snowflake überprüft und integriert wurden. Alle Laufzeit-Images unterstützen Datenanalyse, Modellierung und Training mit Snowpark Python, Snowflake ML, und Streamlit.

Um zusätzliche Pakete aus einem öffentlichen Repository zu installieren, können Sie pip verwenden. Für Snowflake-Notebooks ist eine Integration des externen Zugriffs (EAI) erforderlich, um Pakete von externen Endpunkten zu installieren. Um EAIs zu konfigurieren, lesen Sie Einrichten des externen Zugriffs für Snowflake Notebooks. Wenn ein Paket jedoch bereits Teil des Basisbilds ist, können Sie die Version des Pakets nicht ändern, indem Sie eine andere Version mit pip install installieren. Eine Liste der vorinstallierten Pakete finden Sie unter Container Runtime für ML.

Compute pool:

Ein Computepool stellt die Computeressourcen für Ihren Notebook-Kernel und Python-Code bereit. Verwenden Sie für den Anfang kleinere, CPU-basierte Computepools und wählen Sie für die Optimierung auf GPU basierende Computepools mit höherem Speicher für intensive GPU-Nutzungsszenarios wie Computer Vision oder LLMs/VLMs.

Beachten Sie, dass auf jedem Serverknoten jeweils nur ein Notebook pro Benutzer ausgeführt werden kann. Sie sollten den Parameter MAX_NODES auf einen Wert größer als eins einstellen, wenn Sie Computepools für Notebooks erstellen. Ein Beispiel dazu finden Sie unter Computeressourcen erstellen. Weitere Informationen zu Snowpark Container Services Computpools finden Sie unter Snowpark Container Services: Verwenden von Computepools.

Wenn ein Notebook nicht benutzt wird, sollten Sie es herunterfahren, um Ressourcen im Knoten freizugeben. Sie können ein Notebook herunterfahren, indem Sie in der Dropdown-Schaltfläche „Verbindung“ die Option End session auswählen.

Notebook auf Container Runtime für ML ausführen¶

Nachdem Sie Ihr Notebook erstellt haben, können Sie sofort mit der Ausführung von Code beginnen, indem Sie Zellen hinzufügen und ausführen. Informationen zum Hinzufügen von Zellen finden Sie unter Code in Snowflake Notebooks entwickeln und ausführen.

!pip install transformers scipy ftfy accelerate

Ausführen von ML-Workloads¶

Notebooks auf Container Runtime für ML eignen sich gut für die Ausführung von ML-Workloads wie z. B. Modelltraining und Parameter-Tuning. Die Laufzeiten sind mit den üblichen ML-Paketen von vorinstalliert. Wenn EAI eingestellt ist, können Sie alle anderen Pakete, die Sie benötigen, mit !pip install installieren.

Die folgenden Beispiele zeigen, wie Sie einige der verfügbaren Bibliotheken für Ihren ML-Workload verwenden können.

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)

Hinweise zu Kosten/Abrechnung¶

Wenn Sie Notebooks auf Container Runtime für ML ausführen, können Ihnen sowohl Warehouse-Computekosten als auch SPCS-Computekosten entstehen.

Snowflake Notebooks erfordern ein virtuelles Warehouse, um SQL- und Snowpark-Abfragen zur Optimierung der Leistung auszuführen. Daher können auch bei der Verwendung von SQL in SQL-Zellen und Snowpark-Pushdown-Abfragen, die in Python-Zellen ausgeführt werden, Computekosten im virtuellen Warehouse anfallen. Das folgende Diagramm zeigt, wo die Berechnungen für jede Art von Zelle stattfinden.

Das folgende Python-Beispiel verwendet zum Beispiel die xgboost-Bibliothek. Die Daten werden in den Container gezogen und die Berechnung erfolgt auf 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)

Mehr über die Kosten von Warehouses erfahren Sie unter Übersicht zu Warehouses und Warehouse-Empfehlungen für die Ausführung von Snowflake Notebooks.