Container Runtime pour ML¶

Vue d’ensemble¶

Container Runtime pour ML est un ensemble d’environnements personnalisables préconfigurés conçus pour le machine learning sur Snowpark Container Services, couvrant l’expérimentation interactive et les charges de travail ML par lots telles que l’entraînement de modèles, le réglage des hyperparamètres, l’inférence par lots et le réglage fin. Cela inclut les frameworks de machine learning et d’apprentissage profond les plus connus. Utilisés avec les Notebooks Snowflake, ils offrent une expérience de ML de bout en bout.

Environnement d’exécution¶

Container Runtime pour ML fournit un environnement rempli de paquets et de bibliothèques qui prennent en charge une grande variété de tâches de développement ML à l’intérieur de Snowflake. En plus des paquets préinstallés, vous pouvez importer des paquets à partir de sources externes telles que des référentiels PyPI publics ou des référentiels de paquets hébergés en interne qui fournissent une liste de paquets approuvés pour une utilisation au sein de votre organisation.

Les exécutions de vos charges de travail ML Python personnalisées et de vos APIs d’entraînement personnalisées se produisent dans Snowpark Container Services, qui offre la possibilité de s’exécuter sur des pools de calcul par CPU ou GPU. Lors de l’utilisation d’APIs ML Snowflake, Container Runtime pour ML répartit le traitement entre les ressources disponibles.

Traitement distribué¶

Les APIs de modélisation et de chargement de données de ML Snowflake sont créées à partir du framework de traitement distribué de ML de Snowflake. Celui-ci maximise l’utilisation des ressources en exploitant pleinement la puissance de calcul disponible. Par défaut, ce framework utilise tous les GPUs sur des nœuds de plusieurs GPU, offrant des améliorations de performances significatives par rapport aux paquets open source et réduisant le temps d’exécution global.

Les charges de travail de machine learning, y compris le chargement et déchargement de données, sont exécutées dans un environnement de calcul géré par Snowflake. Ce framework permet une mise à l’échelle dynamique des ressources en fonction des exigences spécifiques de la tâche à accomplir, telles que l’entraînement de modèles ou le chargement de données. Le nombre de ressources, y compris l’allocation de GPU et de mémoire pour chaque tâche, peut être facilement configuré via les APIs fournies.

Optimisation du chargement et déchargement de données¶

Container Runtime fournit un ensemble d’APIs de connecteurs de données qui permettent de connecter les sources de données Snowflake (y compris les tables, DataFrames et les jeux de données) à des cadres ML populaires tels que PyTorch et TensorFlow, en tirant pleinement parti de plusieurs cœurs ou GPUs. Une fois chargées, les données peuvent être traitées à l’aide de paquets open source ou de l’une des APIs ML de Snowflake, y compris les versions distribuées décrites ci-dessous. Ces APIs se trouvent dans l’espace de noms snowflake.ml.data.

La classe snowflake.ml.data.data_connector.DataConnector connecte les DataFrames Snowpark ou les jeux de données Snowflake ML aux TensorFlow ou DataSets PyTorch ou aux DataFrames Pandas. Instanciez un connecteur à l’aide de l’une des méthodes de classe suivantes :

• DataConnector.from_dataframe : accepte un DataFrame Snowpark.

• DataConnector.from_dataset : accepte un jeu de données ML Snowflake, spécifié par nom et version.

• DataConnector.from_sources : accepte une liste de sources, chacune pouvant être un DataFrame ou un jeu de données.

Une fois que vous avez instancié le connecteur (en appelant l’instance, par exemple, data_connector), appelez les méthodes suivantes pour produire le type de sortie souhaité.

• data_connector.to_tf_dataset : renvoie un jeu de données TensorFlow pouvant être utilisé avec TensorFlow.

• data_connector.to_torch_dataset : renvoie un jeu de données PyTorch pouvant être utilisé avec PyTorch.

Pour plus d’informations sur ces APIs, voir la référence d’API Snowflake ML.

Construire avec l’open source¶

Avec les images CPU et GPU de base qui sont pré-remplies avec les paquets ML populaires , et la possibilité d’installer des bibliothèques supplémentaires à l’aide de pip, les utilisateurs peuvent employer des cadres open source familiers et innovants dans les Snowflake Notebooks, sans déplacer les données hors de Snowflake. Vous pouvez faire évoluer le traitement en utilisant les APIs distribuées de Snowflake pour le chargement et déchargement des données, l’entraînement et l’optimisation des hyperparamètres, avec les APIs familières des paquets OSS les plus répandus, avec de petites modifications de l’interface pour permettre la mise à l’échelle des configurations.

Le code suivant illustre la création d’un classificateur XGBoost à l’aide de ces APIs :

from snowflake.snowpark.context import get_active_session
from snowflake.ml.data.data_connector import DataConnector
import pandas as pd
import xgboost as xgb
from sklearn.model_selection import train_test_split

session = get_active_session()

# Use the DataConnector API to pull in large data efficiently
df = session.table("my_dataset")
pandas_df = DataConnector.from_dataframe(df).to_pandas()

# Build with open source

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)

Un entraînement optimisé¶

Container Runtime for ML offre un ensemble d’APIs d’entraînements distribuées , y compris des versions distribuées de LightGBM, PyTorch, et XGBoost, qui tirent pleinement parti des ressources disponibles dans l’environnement de conteneur. Vous les trouverez dans l’espace de noms snowflake.ml.modeling.distributors. Les APIs des classes distribuées sont similaires à celles des versions standards.

Pour plus d’informations sur ces APIs, voir la référence d’API.

APIs de modélisation Snowflake ML¶

Lorsque les APIs de modélisation de Snowflake ML sont utilisées dans un Notebook, toute l’exécution a lieu dans l’environnement d’exécution du conteneur et non dans l’entrepôt de requêtes, à l’exception des APIs snowflake.ml.modeling.preprocessing, qui sont exécutées dans l’entrepôt de requêtes.

Spécification de l’image Container Runtime¶

Vous pouvez choisir entre des types d’images de CPU ou de GPU lors de la création d’un notebook à exécuter sur Container Runtime. Les deux images sont préinstallées avec des frameworks ML populaires, comme scikit-learn et PyTorch. Vous pouvez également utiliser Snowpark ML et tout ce qu’il inclut.

Prochaines étapes¶

• Pour essayer le notebook en utilisant Container Runtime pour ML, voir Notebooks sur Container Runtime pour ML.