Notebooks sur Container Runtime pour ML¶

Vue d’ensemble¶

Vous pouvez exécuter Snowflake Notebooks. sur Container Runtime pour ML. Container Runtime pour ML est optimisé par Snowpark Container Services, vous offrant une infrastructure de conteneur flexible qui prend en charge la création et l’opérationnalisation d’une grande variété de flux de travail entièrement dans Snowflake. Container Runtime pour ML fournit des options logicielles et matérielles pour prendre en charge les charges de travail avancées de science des données et de machine learning. Par rapport aux entrepôts virtuels, Container Runtime pour ML fournit un environnement de calcul plus flexible dans lequel vous pouvez installer des paquets à partir de plusieurs sources et sélectionner des ressources de calcul, notamment des types de poste GPU, tout en continuant à exécuter des requêtes SQL sur les entrepôts pour des performances optimales.

Ce document aborde quelques considérations relatives à l’utilisation de notebooks sur Container Runtime pour ML. Vous pouvez également consulter le guide de démarrage rapide Prise en main de Snowflake Notebook Container Runtime pour en savoir plus sur l’utilisation de Container Runtime pour ML dans votre développement.

Conditions préalables¶

Avant de commencer à utiliser Snowflake Notebooks sur Container Runtime pour ML, le rôle ACCOUNTADMIN doit compléter les étapes de configuration de notebook pour créer les ressources nécessaires et accorder des privilèges à ces ressources. Pour les étapes détaillées, voir Instructions de configuration de l’utilisateur pour Snowflake Notebooks.

Créer un notebook sur Container Runtime pour ML¶

Lorsque vous créez un notebook sur Container Runtime pour ML, vous sélectionnez un entrepôt, un runtime et un pool de calcul pour fournir les ressources nécessaires à l’exécution de votre notebook. Le runtime que vous sélectionnez vous donne accès à des paquets Python différents suivant votre cas d’utilisation. Des tailles d’entrepôt ou pools de calcul différents ont des implications différentes en termes de coûts et de performances. Tous ces paramètres peuvent être modifiés ultérieurement, si nécessaire.

Pour créer un notebook Snowflake à exécuter sur Container Runtime pour ML, procédez comme suit :

1. Connectez-vous à Snowsight.

2. Sélectionnez Notebooks.

3. Sélectionnez + Notebook.

4. Saisissez un nom pour votre notebook.

5. Sélectionnez une base de données et un schéma dans lesquels stocker votre notebook. Ce paramètre ne peut pas être modifié après la création du notebook.

   Note

   La base de données et le schéma ne sont nécessaires que pour stocker vos notebooks. Vous pouvez interroger n’importe quelle base de données et n’importe quel schéma auxquels votre rôle a accès depuis votre notebook.

6. Sélectionnez Run on container comme environnement Python.

7. Sélectionnez le type de Runtime : CPU ou GPU.

8. Sélectionnez un Compute pool.

9. Modifiez l’entrepôt sélectionné à utiliser pour exécuter des requêtes SQL et Snowpark.

   Pour savoir quelle taille d’entrepôt utiliser, consultez Recommandations de l’entrepôt pour l’utilisation de Snowflake Notebooks.

10. Pour créer et ouvrir votre notebook, sélectionnez Create.

Runtime :

Cette avant-première fournit deux types de runtime : CPU et GPU. Chaque image de runtime contient un ensemble de base de paquets et de versions Python de base vérifiés et intégrés par Snowflake. Toutes les images de runtime prennent en charge l’analyse, la modélisation et l’apprentissage des données avec Snowpark Python, Snowflake ML et Streamlit.

Pour installer des paquets supplémentaires à partir d’un référentiel public, vous pouvez utiliser pip. Une intégration d’accès externe (EAI) est requise pour que Snowflake Notebooks puisse installer des paquets à partir de points de terminaison externes. Pour configurer des EAIs, voir Configurer l’accès externe pour Snowflake Notebooks. Cependant, si un paquet fait déjà partie de l’image de base, vous ne pouvez pas modifier la version du paquet en installant une version différente via pip install. Pour une liste des paquets préinstallés, voir Container Runtime pour ML.

Compute pool :

Un pool de calcul fournit les ressources de calcul pour le noyau de votre notebook et le code Python. Utilisez des pools de calcul basés sur CPU plus petits pour commencer, et sélectionnez des pools de calcul basés sur GPU de mémoire supérieure pour optimiser les scénarios d’utilisation de GPU intensive tels que la vision par ordinateur ou les LLMs/VLMs.

Notez que chaque nœud de calcul est limité à l’exécution d’un seul notebook par utilisateur à la fois. Vous devez définir le paramètre MAX_NODES sur une valeur supérieure à celle utilisée lors de la création de pools de calcul pour notebooks. Pour un exemple, voir Créer des ressources de calcul. Pour plus de détails sur les pools de calcul Snowpark Container Services, voir Snowpark Container Services : utilisation des pools de calcul.

Lorsqu’un notebook n’est pas utilisé, pensez à l’arrêter pour libérer les ressources de nœud. Vous pouvez fermer un notebook en sélectionnant End session dans le bouton de connexion déroulant.

Exécuter un notebook sur Container Runtime pour ML¶

Après avoir créé votre notebook, vous pouvez immédiatement commencer à exécuter du code en ajoutant et en exécutant des cellules. Pour obtenir des informations sur l’ajout de cellules, consultez Développez et exécutez du code dans des Snowflake Notebooks.

!pip install transformers scipy ftfy accelerate

Exécution de charges de travail ML¶

Notebooks sur Container Runtime pour ML est bien adapté à l’exécution de charges de travail ML telles que l’apprentissage de modèles et le réglage de paramètres. Les runtimes sont préinstallés avec les paquets ML courants. Avec la configuration d’EAI, vous pouvez installer tous les autres paquets dont vous avez besoin via !pip install.

Les exemples suivants montrent comment utiliser certaines des bibliothèques disponibles pour votre charge de travail 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)

Remarques relatives aux coûts/à la facturation¶

Lors de l’exécution de notebooks sur Container Runtime pour ML, vous pouvez encourir des coûts de calcul d’entrepôt et des coûts de calcul SPCS.

Snowflake Notebooks nécessite un entrepôt virtuel pour l’exécution de requêtes SQL et Snowpark à des fins d’optimisation des performances. Par conséquent, vous pourriez également encourir des coûts de calcul d’entrepôt virtuel si vous utilisez SQL dans des cellules SQL et des requêtes push-down Snowpark exécutées dans des cellules Python. Le diagramme suivant montre où le calcul a lieu pour chaque type de cellule.

L’exemple Python suivant utilise la bibliothèque xgboost. Les données sont extraites dans le conteneur et le calcul s’effectue sur 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)

Pour en savoir plus sur les coûts d’entrepôt, voir Vue d’ensemble des entrepôts et Recommandations de l’entrepôt pour l’utilisation de Snowflake Notebooks.