Container Runtime¶

Vue d’ensemble¶

Container Runtime is a set of preconfigured customizable environments built for machine learning on Snowpark Container Services, covering interactive experimentation and batch ML workloads such as model training, hyperparameter tuning, batch inference and fine tuning. They include the most popular machine learning and deep learning frameworks. Used with Snowflake notebooks, they provide an end-to-end ML experience.

Environnement d’exécution¶

The Container Runtime provides an environment populated with packages and libraries that support a wide variety of ML development tasks inside Snowflake. In addition to the pre-installed packages, you can import packages from external sources like public PyPI repositories, or internally-hosted package repositories that provide a list of packages approved for use inside your organization.

Executions of your custom Python ML workloads and supported training APIs occur within Snowpark Container Services, which offers the ability to run on CPU or GPU compute pools. When using the Snowflake ML APIs, the Container Runtime distributes the processing across available resources.

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)

Le runtime de conteneur CPU contient des paquets différents de ceux du runtime de conteneur GPU. Les sections suivantes répertorient les paquets disponibles dans chaque runtime de conteneur.

Paquets Snowflake Runtime¶

Un entraînement optimisé¶

Container Runtime offers a set of distributed training APIs, including distributed versions of LightGBM, PyTorch, and XGBoost, that take full advantage of the available resources in the container environment. These are found in the snowflake.ml.modeling.distributors namespace. The APIs of the distributed classes are similar to those of the standard versions.

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

Prochaines étapes¶

• To try the notebook using Container Runtime, see Notebooks on Container Runtime.