Entraîner un modèle à l’aide d’une image Docker personnalisée

S’APPLIQUE À : SDK Python azureml v1

Dans cet article, découvrez comment utiliser une image Docker personnalisée lors du déploiement de modèles formés avec Azure Machine Learning. Vous utiliserez les exemples de scripts de cet article pour classifier les images de PET en créant un réseau neuronal de convolution.

Azure Machine Learning fournit une image de base par défaut. Vous pouvez également utiliser des environnements de Azure Machine Learning pour spécifier une autre image de base, telle que l’une des images de base Azure Machine Learning gérées ou votre propre image personnalisée. Les images de base personnalisées vous permettent de gérer précisément vos dépendances et d’exercer un contrôle rigoureux des versions des composants lors de l’exécution des travaux de formation.

Prérequis

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

• Instance de calcul Azure Machine Learning (ni téléchargement ni installation nécessaires) :
  • Suivez le tutoriel décrit dans l’article Créer des ressources pour démarrer afin de créer un serveur de notebook dédié dans lequel le kit de développement logiciel (SDK) et l’exemple de référentiel sont préchargés.
• Votre propre serveur de Jupyter Notebook :
  • Créer un fichier de configuration d’espace de travail.
  • Installez le Kit de développement logiciel (SDK) Azure Machine Learning.
  • Créez un registre de conteneurs Azure ou autre registre Docker accessible sur Internet.

Configurer une expérience de formation

Dans cette section, vous allez configurer votre expérience de formation en initialisant un espace de travail, en définissant votre environnement et en configurant une cible de calcul.

Initialiser un espace de travail

L’espace de travail Azure Machine Learning est la ressource de niveau supérieur du service. Il vous offre un emplacement centralisé pour travailler avec 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 Workspace à partir du fichier config.son que vous avez créé en tant que prérequis.

from azureml.core import Workspace

ws = Workspace.from_config()

Définir votre environnement

Créez un objet Environment.

from azureml.core import Environment

fastai_env = Environment("fastai2")

L’image de base spécifiée dans le code suivant prend en charge la bibliothèque fast.ai, qui permet des fonctionnalités de deep-learning distribuées. Pour plus d’informations, consultez le référentiel Docker Hub fast.ai.

Lorsque vous utilisez votre image Docker personnalisée, vous avez peut-être déjà configuré votre environnement Python correctement. Dans ce cas, définissez l’user_managed_dependenciesindicateur sur True pour utiliser l’environnement Python intégré de votre image personnalisée. Par défaut, Azure Machine Learning crée un environnement Conda avec les dépendances que vous avez spécifiées. Le service exécute le script dans cet environnement au lieu d’utiliser des bibliothèques Python que vous avez installées sur l’image de base.

fastai_env.docker.base_image = "fastdotai/fastai2:latest"
fastai_env.python.user_managed_dependencies = True

Utiliser un registre de conteneurs privé (facultatif)

Pour utiliser une image à partir d’un registre de conteneurs privé qui ne se trouve pas dans votre espace de travail, utilisez docker.base_image_registry pour spécifier l’adresse du référentiel ainsi qu’un nom d’utilisateur et un mot de passe :

# Set the container registry information.
fastai_env.docker.base_image_registry.address = "myregistry.azurecr.io"
fastai_env.docker.base_image_registry.username = "username"
fastai_env.docker.base_image_registry.password = "password"

Utiliser un fichier Dockerfile personnalisé (facultatif)

Il est également possible d’utiliser un fichier Dockerfile personnalisé. Utilisez cette approche si vous devez installer des packages non-Python en tant que dépendances. N’oubliez pas de définir l’image de base sur None.

# Specify Docker steps as a string. 
dockerfile = r"""
FROM mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:20210615.v1
RUN echo "Hello from custom container!"
"""

# Set the base image to None, because the image is defined by Dockerfile.
fastai_env.docker.base_image = None
fastai_env.docker.base_dockerfile = dockerfile

# Alternatively, load the string from a file.
fastai_env.docker.base_image = None
fastai_env.docker.base_dockerfile = "./Dockerfile"

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

Créer ou attacher une cible de calcul

Vous devez créer une cible de calcul pour la formation de votre modèle. Dans ce tutoriel, vous allez créer AmlCompute comme ressource de calcul de formation.

La création de AmlCompute prend quelques minutes. Si laAmlCompute ressource figure déjà dans votre espace de travail, ce code ignore le processus de création.

À l’instar d’autres services Azure, certaines ressources (par exemple, AmlCompute) associées au service Azure Machine Learning présentent des limites. Pour plus d’informations, consultez Limites par défaut et comment demander un quota plus élevé.

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

# Choose a name for your cluster.
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)

    # Create the cluster.
    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)

    compute_target.wait_for_completion(show_output=True)

# Use get_status() to get a detailed status for the current AmlCompute.
print(compute_target.get_status().serialize())

Configurer votre tâche d’entraînement

Pour ce tutoriel, utilisez le script de formation train.py sur GitHub. Dans la pratique, vous pouvez utiliser n’importe quel script de formation personnalisé et l’exécuter, comme c’est le cas, avec Azure Machine Learning.

Créez ScriptRunConfig une ressource pour configurer votre travail en vue de son exécution sur lacible de calculsouhaitée.

from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory='fastai-example',
                      script='train.py',
                      compute_target=compute_target,
                      environment=fastai_env)

Envoyer votre tâche d’entraînement

Lorsque vous soumettez une exécution d’apprentissage à l’aide d’un ScriptRunConfig objet, la submit méthode retourne un objet de type ScriptRun. L’objet ScriptRun retourné vous donne un accès par programmation aux informations sur l’exécution de l’apprentissage.

from azureml.core import Experiment

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

Étapes suivantes

Dans cet article, vous avez formé un modèle à l’aide d’une image Docker personnalisée. Pour en savoir plus sur Azure Machine Learning, consultez les articles suivants :

• Suivre les métriques d’exécution durant la formation.
• Déployer un modèle à l’aide d’une image Docker personnalisée.