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

  • Article

S’APPLIQUE À :Kit de développement logiciel (SDK) Python azureml v1

Dans cet article, découvrez comment exécuter vos scripts d’entraînement TensorFlow à grande échelle avec Azure Machine Learning.

Cet exemple forme et inscrit un modèle TensorFlow pour classer les chiffres manuscrits à l’aide d’un réseau neuronal profond (DNN).

Que vous développiez complètement un modèle TensorFlow ou que vous transmettiez un modèle existant dans le cloud, vous pouvez utiliser Azure Machine Learning pour effectuer un scale-out des travaux de formation Open source afin de créer, déployer, versionner et surveiller des modèles de niveau production.

Prérequis

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

  • Instance de calcul Azure Machine Learning : pas de téléchargement ni d’installation nécessaire

    • Suivez le guide de démarrage rapide Prise en main d’Azure Machine Learning pour créer un serveur de notebook dédié sur lequel sont préchargés le SDK et l’exemple de dépôt.
    • Dans le dossier des exemples de Deep Learning sur le serveur de notebooks, recherchez un notebook finalisé et développé en accédant à ce répertoire : dossier how-to-use-azureml > ml-frameworks > tensorflow > train-hyperparameter-tune-deploy-with-tensorflow.

  • Votre propre serveur de notebooks Jupyter

    Vous trouverez également une version Jupyter Notebook complète de ce guide sur la page des exemples GitHub. Le notebook inclut des sections développées couvrant l’optimisation des hyperparamètres intelligents, les modèles de déploiement et les widgets de notebook.

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 urllib
import shutil
import azureml

from azureml.core import Experiment
from azureml.core import Workspace, Run
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()

Créer un jeu de données de fichier

Un objet FileDataset référence un ou plusieurs fichiers dans votre magasin de données d’espace de travail ou vos URL publiques. Les fichiers peuvent être de n’importe quel format, et la classe vous offre la possibilité de télécharger ou de monter les fichiers dans votre calcul. En créant un FileDataset, vous créez une référence à l’emplacement de la source de données. Si vous avez appliqué des transformations au jeu de données, celles-ci seront également stockées dans le jeu de données. Les données restant à leur emplacement existant, aucun coût de stockage supplémentaire n’est encouru. Pour plus d’informations sur le package Dataset, consultez l’article sur la création de jeux de données.

from azureml.core.dataset import Dataset

web_paths = [
            'http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz'
            ]
dataset = Dataset.File.from_files(path = web_paths)

Utilisez la méthode register() pour inscrire des jeux de données dans votre espace de travail afin de pouvoir les partager avec d’autres personnes, les réutiliser dans différentes expériences et y faire référence par nom dans votre script d’entraînement.

dataset = dataset.register(workspace=ws,
                           name='mnist-dataset',
                           description='training and test dataset',
                           create_new_version=True)

# list the files referenced by dataset
dataset.to_path()

Créer une cible de calcul

Créez une cible de calcul sur laquelle vous exécuterez votre tâche TensorFlow. 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.

cluster_name = "gpu-cluster"

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)

    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)

    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)

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é

Le cas échéant, Azure Machine Learnin fournit des environnements prédéfinis et organisés si vous ne souhaitez pas définir votre propre environnement. Azure Machine Learning intègre plusieurs environnements organisés processeur et GPU pour TensorFlow correspondant à différentes versions de TensorFlow. Vous pouvez utiliser la dernière version de cet environnement à l’aide de la directive @latest. Pour plus d’informations, consultez Environnements organisés Azure Machine Learning.

Si vous voulez utiliser un environnement curé, le code sera similaire à l’exemple suivant :

curated_env_name = 'AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu'
tf_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 :


tf_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 :


tf_env = Environment.from_conda_specification(name='AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-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 :


tf_env = tf_env.clone(new_name='my-AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-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:
  - azureml-defaults
  - tensorflow-gpu==2.2.0

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 ; consultez le dépôt GitHub Azure/AzureML-Containers pour plus d’informations.

tf_env = Environment.from_conda_specification(name='AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu', file_path='./conda_dependencies.yml')

# Specify a GPU base image
tf_env.docker.enabled = True
tf_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.

from azureml.core import ScriptRunConfig

args = ['--data-folder', dataset.as_mount(),
        '--batch-size', 64,
        '--first-layer-neurons', 256,
        '--second-layer-neurons', 128,
        '--learning-rate', 0.01]

src = ScriptRunConfig(source_directory=script_folder,
                      script='tf_mnist.py',
                      arguments=args,
                      compute_target=compute_target,
                      environment=tf_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 l’estimateur TensorFlow pour configurer vos travaux d’apprentissage TensorFlow, veuillez noter que les estimateurs sont déconseillés à partir de la version 1.19.0 du kit de développement logiciel (SDK). Avec la version >= 1.15.0 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 une 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(workspace=ws, name='Tutorial-TF-Mnist').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.

Facultatif : en spécifiant les paramètres model_framework, model_framework_version et resource_configuration, le modèle de déploiement sans code devient disponible. Cela vous permet de déployer directement votre modèle en tant que service web à partir du modèle inscrit, et l’objet ResourceConfiguration définit la ressource de calcul pour le service web.

from azureml.core import Model
from azureml.core.resource_configuration import ResourceConfiguration

model = run.register_model(model_name='tf-mnist', 
                           model_path='outputs/model',
                           model_framework=Model.Framework.TENSORFLOW,
                           model_framework_version='2.0',
                           resource_configuration=ResourceConfiguration(cpu=1, memory_in_gb=0.5))

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 tf_mnist.py, un objet de sauvegarde TensorFlow 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)
run.download_files(prefix='outputs/model', output_directory='./model', append_prefix=False)

Entraînement distribué

Azure Machine Learning prend également en charge les tâches TensorFlow 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 TensorFlow et Azure Machine Learning gère l’orchestration à votre place.

Azure Machine Learning prend en charge l’exécution des tâches TensorFlow distribuées avec l’API d’entraînement distribuée intégrée de Horovod et TensorFlow.

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

Déployer un modèle TensorFlow

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.

(Préversion) Modèle de déploiement sans code

Important

Cette fonctionnalité est actuellement disponible en préversion publique. Cette préversion est fournie sans contrat de niveau de service et n’est pas recommandée pour les charges de travail de production. Certaines fonctionnalités peuvent être limitées ou non prises en charge.

Pour plus d’informations, consultez Conditions d’Utilisation Supplémentaires relatives aux Évaluations Microsoft Azure.

Au lieu de l’itinéraire de déploiement traditionnel, vous pouvez également utiliser la fonctionnalité de déploiement sans code (préversion) pour TensorFlow. En inscrivant votre modèle comme indiqué ci-dessus avec les paramètres model_framework, model_framework_version et resource_configuration, vous pouvez utiliser la fonction statique deploy() pour déployer votre modèle.

service = Model.deploy(ws, "tensorflow-web-service", [model])

Le guide pratique complet couvre de manière plus approfondie le déploiement dans Azure Machine Learning.

Étapes suivantes

Dans cet article, vous avez effectué l’apprentissage d’un modèle TensorFlow et l’avez inscrit et vous avez découvert les options de déploiement. Consultez ces autres articles pour en savoir plus sur Azure Machine Learning.