Entrenamiento de un modelo con una imagen de Docker personalizada

Artículo
09/03/2024

SE APLICA A: Azure ML del SDK de Python v1

En este artículo, aprenderá a usar una imagen personalizada de Docker al entrenar modelos con Azure Machine Learning. Usará los scripts de ejemplo de este artículo para clasificar imágenes de mascotas creando una red neuronal convolucional.

Azure Machine Learning proporciona una imagen base de Docker predeterminada. También puede usar entornos de Azure Machine Learning para especificar una imagen base diferente, como una de las de Azure Machine Learning imágenes base mantenidas o su propia imagen personalizada. Las imágenes base personalizadas permiten administrar estrechamente las dependencias y mantener un mayor control sobre las versiones de los componentes al ejecutar trabajos de entrenamiento.

Requisitos previos

Ejecute el código en cualquiera de los siguientes entornos.

Instancia de Proceso de Azure Machine Learning (no se necesitan descargas ni instalación):
- Complete el tutorial Crear recursos para empezar para crear un servidor de cuadernos dedicado en el que se habrán cargado previamente el SDK y el repositorio de ejemplos.
Su propio servidor de Jupyter Notebook:
- Cree un archivo de configuración del área de trabajo.
- Instale el SDK de Azure Machine Learning.
- Cree un registro de contenedor de Azure u otro registro de Docker accesible en Internet.

Configuración de un experimento de entrenamiento

En esta sección, configurará un experimento de entrenamiento inicializando un área de trabajo, definiendo un entorno y configurando un destino de proceso.

Inicialización de un área de trabajo

El área de trabajo de Azure Machine Learning es el recurso de nivel superior para el servicio. Además, proporciona un lugar centralizado para trabajar con todos los artefactos que cree. En el SDK de Python, puede acceder a los artefactos del área de trabajo mediante la creación de un objeto Workspace.

Cree un objeto Workspace a partir del archivo config.json que creó como un requisito previo.

from azureml.core import Workspace

ws = Workspace.from_config()

Definición del entorno

Cree un objeto Environment.

from azureml.core import Environment

fastai_env = Environment("fastai2")

La imagen base especificada en el siguiente código es compatible con la biblioteca fast.ai, que permite funcionalidades de aprendizaje profundo distribuido. Para obtener más información, consulte el repositorio de Docker Hub fast.ai.

Al usar la imagen personalizada de Docker, es posible que ya tenga el entorno de Python configurado correctamente. En ese caso, establezca la marca user_managed_dependencies en True para usar el entorno de Python integrado de la imagen personalizada. De forma predeterminada, Azure Machine Learning crea un entorno de Conda con las dependencias que especificó. El servicio ejecuta el script en ese entorno en lugar de usar las bibliotecas de Python que haya instalado en la imagen base.

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

Uso de un registro de contenedor privado (opcional)

Para usar una imagen desde un registro de contenedor privado que no esté en el área de trabajo, use docker.base_image_registry para especificar la dirección del repositorio y un nombre de usuario y contraseña:

# 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"

Uso de un Dockerfile personalizado (opcional)

También es posible usar un Dockerfile personalizado. Use este enfoque si necesita instalar paquetes que no son de Python como dependencias. Recuerde establecer la imagen base en 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"

Importante

Azure Machine Learning solo admite imágenes de Docker que proporcionan el software siguiente:

Ubuntu 18.04 o posterior.
Conda 4.7.# o posterior.
Python 3.7+.
Se requiere un shell compatible con POSIX disponible en /bin/sh en cualquier imagen de contenedor usada para el entrenamiento.

Para obtener más información sobre la creación y la administración de los entornos de Azure Machine Learning, consulte Creación y uso de entornos de software en Azure Machine Learning.

Creación o conexión de un destino de proceso

Para entrenar el modelo, necesita crear un destino de proceso. En este tutorial, creará una instancia de AmlCompute como recurso de proceso de entrenamiento.

La creación de AmlCompute tarda unos minutos. Si el recurso AmlCompute ya está en el área de trabajo, este código omite el proceso de creación.

Al igual que en otros servicios de Azure, existen límites en determinados recursos (por ejemplo, AmlCompute) asociados con Azure Machine Learning Service. Para obtener más información, consulte Límites predeterminados y cómo solicitar una cuota más alta.

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())

Importante

Use las SKU de CPU para cualquier compilación de imagen en el proceso.

Configuración del trabajo de entrenamiento

Para este tutorial, use el script de entrenamiento train.py en GitHub. En la práctica, puede tomar cualquier script de entrenamiento personalizado tal cual y ejecutarlo con Azure Machine Learning.

Cree un recurso ScriptRunConfig para configurar el trabajo para que se ejecute en el destino de proceso que desee.

from azureml.core import ScriptRunConfig

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

Enviar su trabajo de aprendizaje

Cuando se envía una ejecución de entrenamiento mediante un objeto ScriptRunConfig, el método submit devuelve un objeto de tipo ScriptRun. El objeto ScriptRun devuelto proporciona acceso mediante programación a información sobre la ejecución de entrenamiento.

from azureml.core import Experiment

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

Advertencia

Azure Machine Learning ejecuta scripts de entrenamiento mediante la copia de todo el directorio de origen. Si tiene información confidencial que no quiere cargar, use un archivo .ignore o no lo incluya en el directorio de origen. En su lugar, acceda a los datos mediante un almacén de datos.

Pasos siguientes

En este artículo, ha entrenado un modelo mediante una imagen de Docker personalizada. Consulte estos otros artículos para obtener más información sobre Azure Machine Learning:

Seguimiento de las métricas de ejecución durante el entrenamiento.
Implementación de un modelo con una imagen de Docker personalizada.

Compartir vía