Entraîner des modèles PyTorch à grande échelle avec le SDK Azure Machine Learning (v1)

  • Article

S’APPLIQUE À :SDK Python azureml v1

Dans cet article, découvrez comment exécuter vos scripts d’entraînement PyTorch à l’échelle de l’entreprise à l’aide d’Azure Machine Learning.

Les exemples de scripts de cet article classifient des images de poulets et de dindes pour créer un réseau neuronal de Deep Learning (DNN) sur la base du tutoriel sur l’apprentissage de transfert de PyTorch. L’apprentissage de transfert est une technique qui applique les connaissances acquises lors de la résolution d’un problème à un problème différent, mais connexe. L’apprentissage de transfert permet de raccourcir le processus d’entraînement en demandant moins de données, de temps et de ressources de calcul qu’un entraînement partant de zéro. Pour en savoir plus sur l’apprentissage de transfert, consultez l’article Deep Learning et Machine Learning.

Que vous soyez en train de former un modèle PyTorch d’apprentissage profond ou que vous déposez un modèle existant dans le Cloud, vous pouvez utiliser Azure Machine Learning pour effectuer un scale-out des tâches de formation Open source à l’aide des ressources de calcul de Cloud élastique. Vous pouvez créer, déployer, mettre à jour et surveiller des modèles de niveau production avec Azure Machine Learning.

Prérequis

Exécutez ce code sur l’un de ces environnements :

Avant de pouvoir exécuter le code de cet article pour créer un cluster GPU, vous devez demander une augmentation de quota pour votre espace de travail.

Configurer l’expérience

Cette section configure l’expérience d’entraînement via le chargement des packages Python requis, l’initialisation d’un espace de travail, la création de la cible de calcul et la définition de l’environnement d’entraînement.

Importer des packages

Tout d’abord, importez les bibliothèques Python nécessaires.

import os
import shutil

from azureml.core.workspace import Workspace
from azureml.core import Experiment
from azureml.core import Environment

from azureml.core.compute import ComputeTarget, AmlCompute
from azureml.core.compute_target import ComputeTargetException

Initialiser un espace de travail

L’espace de travail Azure Machine Learning est la ressource de niveau supérieur du service. Il vous fournit un emplacement centralisé dans lequel utiliser tous les artefacts que vous créez. Dans le kit de développement logiciel (SDK) Python, vous pouvez accéder aux artefacts de l’espace de travail en créant un objet workspace.

Créez un objet d’espace de travail à partir du fichier config.json créé dans la section Conditions préalables.

ws = Workspace.from_config()

Obtenir les données

Le jeu de données se compose de 120 images de formation par dindes et poules, avec 100 images de validations par classe. Nous téléchargeons et extrayons le jeu de données dans le cadre de notre script d’entraînement pytorch_train.py. Les images sont un sous-ensemble du Jeu de données Open Images v5. Pour plus d’étapes relatives à la création d’un fichier JSONL pour effectuer la formation avec vos propres données, consultez ce notebook Jupyter.

Préparer un script d’apprentissage

Dans ce didacticiel, le script de formation, pytorch_train.py, est déjà fourni. En pratique, vous pouvez prendre n’importe quel script d’entraînement tel quel et l’exécuter avec Azure Machine Learning.

Créez un dossier pour votre ou vos scripts d’entraînement.

project_folder = './pytorch-birds'
os.makedirs(project_folder, exist_ok=True)
shutil.copy('pytorch_train.py', project_folder)

Créer une cible de calcul

Créez une cible de calcul sur laquelle vous exécuterez votre tâche PyTorch. Dans cet exemple, créez un cluster de calcul Azure Machine Learning compatible avec le GPU.

Important

Avant de pouvoir créer un cluster GPU, vous devez demander une augmentation de quota pour votre espace de travail.


# Choose a name for your CPU cluster
cluster_name = "gpu-cluster"

# Verify that cluster does not exist already
try:
    compute_target = ComputeTarget(workspace=ws, name=cluster_name)
    print('Found existing compute target')
except ComputeTargetException:
    print('Creating a new compute target...')
    compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_NC6', 
                                                           max_nodes=4)

    # Create the cluster with the specified name and configuration
    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)

    # Wait for the cluster to complete, show the output log
    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)

Si vous souhaitez plutôt créer un cluster UC, indiquez une autre taille de machine virtuelle pour le paramètre vm_size, tel que STANDARD_D2_V2.

Pour plus d’informations sur les cibles de calcul, consultez l’article Qu’est-ce qu’une cible de calcul.

Définir votre environnement

Pour définir l’environnement Azure Machine Learning qui encapsule les dépendances de votre script d’entraînement, vous pouvez définir un environnement personnalisé ou utiliser un environnement Azure Machine Learning organisé.

Utiliser un environnement organisé

Azure Machine Learning fournit des environnements prédéfinis et organisés si vous ne souhaitez pas définir votre propre environnement. Il existe plusieurs environnements organisés d’UC et de GPU pour PyTorch qui correspondent à différentes versions de PyTorch.

Si vous souhaitez utiliser un environnement organisé, vous pouvez exécuter la commande suivante à la place :

curated_env_name = 'AzureML-PyTorch-1.6-GPU'
pytorch_env = Environment.get(workspace=ws, name=curated_env_name)

Pour voir les packages inclus dans l’environnement organisé, vous pouvez écrire les dépendances conda sur le disque :

pytorch_env.save_to_directory(path=curated_env_name)

Assurez-vous que l’environnement organisé comprend toutes les dépendances requises par votre script d’entraînement. Si ce n’est pas le cas, vous devez modifier l’environnement pour qu’il inclue les dépendances manquantes. Si l’environnement est modifié, vous devez lui attribuer un nouveau nom, car le préfixe « AzureML » est réservé aux environnements organisés. Si vous avez modifié le fichier YAML de dépendances conda, vous pouvez créer un environnement à partir de celui-ci avec un nouveau nom, par exemple :

pytorch_env = Environment.from_conda_specification(name='pytorch-1.6-gpu', file_path='./conda_dependencies.yml')

Si, à la place, vous avez directement modifié l’objet de l’environnement organisé, vous pouvez cloner cet environnement avec un nouveau nom :

pytorch_env = pytorch_env.clone(new_name='pytorch-1.6-gpu')

Créer un environnement personnalisé

Vous pouvez également créer votre propre environnement Azure Machine Learning qui encapsule les dépendances de votre script d’entraînement.

Tout d’abord, définissez vos dépendances conda dans un fichier YAML ; dans cet exemple, le fichier est nommé conda_dependencies.yml.

channels:
- conda-forge
dependencies:
- python=3.7
- pip=21.3.1
- pip:
  - azureml-defaults
  - torch==1.6.0
  - torchvision==0.7.0
  - future==0.17.1
  - pillow

Créez un environnement Azure Machine Learning à partir de cette spécification de l’environnement Conda. L’environnement sera empaqueté dans un conteneur Docker au moment de l’exécution.

Par défaut, si aucune image de base n’est spécifiée, Azure Machine Learning utilise une image de processeur azureml.core.environment.DEFAULT_CPU_IMAGE comme image de base. Dans la mesure où cet exemple exécute l’entraînement sur un cluster GPU, vous devez spécifier une image de base GPU avec les dépendances et les pilotes GPU nécessaires. Azure Machine Learning gère un ensemble d’images de base publiées sur Microsoft Container Registry (MCR) que vous pouvez utiliser. Pour plus d’informations, consultez le dépôt GitHub AzureML-Containers.

pytorch_env = Environment.from_conda_specification(name='pytorch-1.6-gpu', file_path='./conda_dependencies.yml')

# Specify a GPU base image
pytorch_env.docker.enabled = True
pytorch_env.docker.base_image = 'mcr.microsoft.com/azureml/openmpi3.1.2-cuda10.1-cudnn7-ubuntu18.04'

Conseil

Si vous le souhaitez, vous pouvez simplement capturer toutes vos dépendances directement dans un Dockerfile ou une image Docker personnalisé et créer votre environnement à partir de là. Pour plus d’informations, consultez Effectuer l’entraînement avec une image personnalisée.

Pour plus d’informations sur la création et l’utilisation d’environnements, consultez Créer et utiliser des environnements logiciels dans Azure Machine Learning.

Configurer et envoyer votre exécution d’entrainement

Créer un ScriptRunConfig

Créez un objet ScriptRunConfig pour spécifier les détails de configuration de votre travail d’entraînement, y compris votre script d’entraînement, l’environnement à utiliser et la cible de calcul sur laquelle effectuer l’exécution. Les arguments de votre script d’entraînement sont transmis via la ligne de commande s’ils sont spécifiés dans le paramètre arguments. Le code suivant permet de configurer une tâche PyTorch à nœud unique.

from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory=project_folder,
                      script='pytorch_train.py',
                      arguments=['--num_epochs', 30, '--output_dir', './outputs'],
                      compute_target=compute_target,
                      environment=pytorch_env)

Avertissement

Azure Machine Learning exécute des scripts d’apprentissage en copiant l’intégralité du répertoire source. Si vous avez des données sensibles que vous ne souhaitez pas charger, utilisez un fichier .ignore ou ne l’incluez pas dans le répertoire source. Au lieu de cela, accédez à vos données à l’aide d’un jeu de données Azure Machine Learning.

Pour plus d’informations sur la configuration des travaux avec ScriptRunConfig, consultez Configurer et envoyer des exécutions d’entraînement.

Avertissement

Si vous utilisiez précédemment l’estimateur PyTorch pour configurer vos travaux d’entraînement PyTorch, veuillez noter que les estimateurs sont déconseillés depuis la version du kit SDK 1.19.0. Avec la version >= 1.15.0 et les versions ultérieures du kit SDK Azure Machine Learning, ScriptRunConfig correspond à la méthode recommandée pour configurer des tâches d’entraînement, y compris celles qui utilisent des frameworks de Deep Learning. Pour les questions courantes sur la migration, consultez le Guide de migration de l’estimateur vers ScriptRunConfig.

Envoyer votre exécution

L’objet d’exécution fournit l’interface à l’historique des exécutions pendant et après l’exécution de la tâche.

run = Experiment(ws, name='Tutorial-pytorch-birds').submit(src)
run.wait_for_completion(show_output=True)

Ce qui se passe lors de l’exécution

Quand l’exécution est lancée, elle passe par les phases suivantes :

  • Préparation : une image docker est créée en fonction de l’environnement défini. L’image est chargée dans le registre de conteneurs de l’espace de travail et mise en cache pour des exécutions ultérieures. Les journaux sont également transmis en continu à l’historique des exécutions et peuvent être affichés afin de surveiller la progression. Si un environnement organisé est spécifié à la place, l’image mise en cache qui stocke cet environnement organisé est utilisée.

  • Mise à l’échelle : le cluster tente de monter en puissance si le cluster Batch AI nécessite plus de nœuds pour l’exécution que la quantité disponible actuellement.

  • En cours d’exécution : tous les scripts dans le dossier de script sont chargés dans la cible de calcul, les magasins de données sont montés ou copiés, puis script est exécuté. Les sorties issues de stdout et du dossier ./logs sont transmises en continu à l’historique des exécutions et peuvent être utilisées pour superviser l’exécution.

  • Post-traitement : le dossier ./outputs de l’exécution est copié dans l’historique des exécutions.

Inscrire ou télécharger un modèle

Une fois que vous avez entraîné le modèle, vous pouvez l’inscrire sur votre espace de travail. L’inscription du modèle vous permet de stocker vos modèles et de suivre leurs versions dans votre espace de travail afin de simplifier la gestion et le déploiement des modèles.

model = run.register_model(model_name='pytorch-birds', model_path='outputs/model.pt')

Conseil

Le guide pratique de déploiement contient une section sur l’inscription des modèles, mais vous pouvez passer directement à la création d’une cible de calcul pour le déploiement, puisque vous disposez déjà d’un modèle inscrit.

Vous pouvez aussi télécharger une copie locale du modèle à l’aide de l’objet d’exécution. Dans le script de formation pytorch_train.py, un objet de sauvegarde PyTorch conserve le modèle dans un dossier local (local dans la cible de calcul). Vous pouvez utiliser l’objet d’exécution pour télécharger une copie.

# Create a model folder in the current directory
os.makedirs('./model', exist_ok=True)

# Download the model from run history
run.download_file(name='outputs/model.pt', output_file_path='./model/model.pt'),

Entraînement distribué

Azure Machine Learning prend également en charge les tâches PyTorch distribuées multinœuds, ce qui vous permet de mettre à l’échelle vos charges de travail d’entraînement. Vous pouvez facilement exécuter des tâches distribuées PyTorch et Azure Machine Learning gère l’orchestration à votre place.

Azure Machine Learning prend en charge l’exécution des tâches PyTorch distribuées avec le module DistributedDataParallel intégré de Horovod et PyTorch.

Pour plus d’informations sur l’entraînement distribué, consultez le Guide de l’entraînement de GPU distribué.

Exporter dans ONNX

Pour optimiser l’inférence avec le Runtime ONNX, convertissez votre modèle PyTorch formé au format ONNX. L’inférence, ou notation du modèle, est la phase où le modèle déployé est utilisé pour la prédiction, généralement sur des données de production. Pour obtenir un exemple, consultez le tutoriel sur l’exportation de modèle de PyTorch vers ONNX.

Étapes suivantes

Dans cet article, vous avez entraîné et inscrit un réseau neuronal Deep Learning à l’aide de PyTorch sur Azure Machine Learning. Pour savoir comment déployer un modèle, passez à notre article relatif aux modèles de déploiement.