Entrenamiento de modelos de PyTorch a gran escala con Azure Machine Learning

SE APLICA A: SDK de Python azure-ai-ml v2 (actual)

En este artículo, aprenderá a entrenar, ajustar hiperparámetros e implementar un modelo de PyTorch mediante el SDK de Python de Azure Machine Learning v2.

Utilizas scripts de ejemplo para clasificar imágenes de pavos y pollos para construir una red neuronal de profundo aprendizaje (DNN) basada en el tutorial de aprendizaje por transferencia de PyTorch. El aprendizaje por transferencia es una técnica que aplica los conocimientos que se adquieren al resolver un problema en un problema diferente, pero relacionado. El aprendizaje por transferencia reduce el proceso de entrenamiento, ya que requiere menos datos, tiempo y recursos de proceso que el entrenamiento que se realiza desde cero. Para más información sobre el aprendizaje por transferencia, consulte Aprendizaje profundo frente a aprendizaje automático.

Ya sea que esté entrenando un modelo de aprendizaje profundo de PyTorch desde cero o que esté llevando un modelo existente a la nube, use Azure Machine Learning para escalar las tareas de entrenamiento de código abierto mediante recursos de computación elásticos en la nube. Puede compilar, implementar y supervisar modelos de nivel de producción, así como crear versiones de dichos mismos, mediante Azure Machine Learning.

Requisitos previos

• Suscripción a Azure. Si todavía no la tiene, cree una cuenta gratuita.
• Python 3.10 o posterior.
• Ejecute el código de este artículo mediante una instancia de proceso de Azure Machine Learning o su propio cuaderno de Jupyter Notebook.
  • Instancia de Proceso de Azure Machine Learning (no se necesitan descargas ni instalación):
    • Complete el Inicio rápido: Introducción a Azure Machine Learning para crear un servidor de cuadernos dedicado ya cargado con el SDK y el repositorio de ejemplo.
    • En la pestaña Ejemplos de la sección Cuadernos del área de trabajo, busque un cuaderno completado y expandido; para ello, vaya a este directorio: SDK v2/sdk/python/jobs/single-step/pytorch/train-hyperparameter-tune-deploy-with-pytorch
  • Su servidor de Jupyter Notebook:
    • Instale el SDK (V2) de Azure Machine Learning.
    • Descargue el archivo de script de entrenamiento pytorch_train.py.

También puede encontrar una versión de cuaderno de Jupyter completada de esta guía en la página de ejemplos de GitHub.

Configurar el trabajo

En esta sección se configura el trabajo para el entrenamiento mediante la carga de los paquetes de Python necesarios, la conexión a un área de trabajo, la creación de un recurso de proceso para ejecutar un trabajo de comando y la creación de un entorno para ejecutar el trabajo.

Conexión a un área de trabajo

En primer lugar, conéctese al área de trabajo de Azure Machine Learning. El área de trabajo es el recurso de nivel superior para el servicio. Proporciona un lugar centralizado para trabajar con todos los artefactos que se crean al usar Azure Machine Learning.

Use DefaultAzureCredential para acceder al área de trabajo. Esta credencial controla la mayoría de los escenarios de autenticación del SDK de Azure.

Si DefaultAzureCredential no funciona, consulte azure.identity package o Configurar autenticación para obtener más credenciales disponibles.

# Handle to the workspace
from azure.ai.ml import MLClient

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

from azure.identity import InteractiveBrowserCredential
credential = InteractiveBrowserCredential()

A continuación, obtenga un identificador para el espacio de trabajo proporcionando su ID de suscripción, el nombre del grupo de recursos y el nombre del espacio de trabajo. Para buscar estos parámetros:

1. Busque el nombre del área de trabajo en la esquina superior derecha de la barra de herramientas de Estudio de Azure Machine Learning.
2. Seleccione el nombre del área de trabajo para mostrar el identificador de suscripción y el grupo de recursos.
3. Copie los valores del grupo de recursos y el identificador de suscripción en el código.

# Get a handle to the workspace
ml_client = MLClient(
    credential=credential,
    subscription_id="<SUBSCRIPTION_ID>",
    resource_group_name="<RESOURCE_GROUP>",
    workspace_name="<AML_WORKSPACE_NAME>",
)

El resultado de la ejecución de este script es un manejador de espacio de trabajo que se puede utilizar para gestionar otros recursos y trabajos.

Cree un recurso de cálculo para ejecutar el trabajo

Azure Machine Learning necesita un recurso de proceso para ejecutar un trabajo. Este recurso puede ser máquinas únicas o multinodo con el sistema operativo Linux o Windows, o un tejido de proceso específico, como Spark.

En el siguiente script de ejemplo, se aprovisiona un clúster de proceso de Linux. Para obtener la lista completa de tamaños y precios de las máquinas virtuales, consulte la página de precios de Azure Machine Learning . Como necesita un clúster de GPU para este ejemplo, seleccione un Standard_NC4as_T4_v3 modelo y cree un proceso de Azure Machine Learning.

from azure.ai.ml.entities import AmlCompute

gpu_compute_target = "gpu-cluster"

try:
    # let's see if the compute target already exists
    gpu_cluster = ml_client.compute.get(gpu_compute_target)
    print(
        f"You already have a cluster named {gpu_compute_target}, we'll reuse it as is."
    )

except Exception:
    print("Creating a new gpu compute target...")

    # Let's create the Azure ML compute object with the intended parameters
    gpu_cluster = AmlCompute(
        # Name assigned to the compute cluster
        name="gpu-cluster",
        # Azure ML Compute is the on-demand VM service
        type="amlcompute",
        # VM Family
        size="STANDARD_NC4AS_T4_V3",
        # Minimum running nodes when there is no job running
        min_instances=0,
        # Nodes in cluster
        max_instances=4,
        # How many seconds will the node running after the job termination
        idle_time_before_scale_down=180,
        # Dedicated or LowPriority. The latter is cheaper but there is a chance of job termination
        tier="Dedicated",
    )

    # Now, we pass the object to MLClient's create_or_update method
    gpu_cluster = ml_client.begin_create_or_update(gpu_cluster).result()

print(
    f"AMLCompute with name {gpu_cluster.name} is created, the compute size is {gpu_cluster.size}"
)

Creación de un entorno de trabajo

Para ejecutar un trabajo de Azure Machine Learning, necesita un entorno. Un entorno de Azure Machine Learning encapsula las dependencias, como el entorno de ejecución de software y las bibliotecas, necesarios para ejecutar el script de aprendizaje automático en el recurso de proceso. Este entorno es similar a un entorno de Python en la máquina local.

Azure Machine Learning permite usar un entorno mantenido (o listo) o crear un entorno personalizado mediante una imagen de Docker o una configuración de Conda. En este artículo, reutilizará el entorno de Azure Machine Learning mantenido AzureML-acpt-pytorch-2.8-cuda12.6. Use la versión más reciente de este entorno mediante la @latest directiva .

curated_env_name = "AzureML-acpt-pytorch-2.8-cuda12.6@latest"

Configuración y envío del trabajo de entrenamiento

En esta sección, introducirá los datos para el entrenamiento. A continuación, se explica cómo ejecutar un trabajo de entrenamiento mediante un script de entrenamiento que proporcione. Aprenderá a compilar el trabajo de entrenamiento mediante la configuración del comando para ejecutar el script de entrenamiento. Después, enviará el trabajo de entrenamiento para que se ejecute en Azure Machine Learning.

Obtención de los datos de entrenamiento

El conjunto de datos consta de aproximadamente 120 imágenes de entrenamiento para dos clases (pavos y pollos), con 100 imágenes de validación para cada clase. Las imágenes son un subconjunto del conjunto de datos Open Images v5. El script de entrenamiento pytorch_train.py descarga y extrae el conjunto de datos.

Preparar el script de entrenamiento

En la sección de requisitos previos, proporcionó el script de entrenamiento pytorch_train.py. En la práctica, debería poder usar cualquier script de entrenamiento personalizado tal cual y ejecutarlo con Azure Machine Learning sin tener que modificar el código.

El script de entrenamiento proporcionado descarga los datos, entrena un modelo y registra el modelo.

Compilación del trabajo de entrenamiento

Ahora que tiene todos los recursos necesarios para ejecutar el trabajo, compílelo mediante el SDK de Python de Azure Machine Learning v2. En este ejemplo, cree un command.

Un command de Azure Machine Learning es un recurso que especifica todos los detalles necesarios para ejecutar el código de entrenamiento en la nube. Estos detalles incluyen las entradas y salidas, el tipo de hardware que se va a usar, el software que se va a instalar y cómo ejecutar el código. command contiene información para ejecutar un único comando.

Configuración del comando

Use el propósito command general para ejecutar el script de entrenamiento y realizar las tareas deseadas. Cree un objeto command para especificar los detalles de configuración del trabajo de entrenamiento.

from azure.ai.ml import command
from azure.ai.ml import Input

job = command(
    inputs=dict(
        num_epochs=30, learning_rate=0.001, momentum=0.9, output_dir="./outputs"
    ),
    compute=gpu_compute_target,
    environment=curated_env_name,
    code="./src/",  # location of source code
    command="python pytorch_train.py --num_epochs ${{inputs.num_epochs}} --output_dir ${{inputs.output_dir}}",
    experiment_name="pytorch-birds",
    display_name="pytorch-birds-image",
)

• Las entradas de este comando incluyen el número de épocas, velocidad de aprendizaje, impulso y directorio de salida.
• Para los valores de parámetro:
  1. Proporcione el clúster de proceso gpu_compute_target = "gpu-cluster" que creó para ejecutar este comando.
  2. Proporcione el entorno curado que ha inicializado anteriormente.
  3. Si no usa el cuaderno completado en la carpeta Ejemplos, especifique la ubicación del archivo pytorch_train.py.
  4. Configure la propia acción de la línea de comandos. En este caso, el comando es python pytorch_train.py. Puede acceder a las entradas y salidas en el comando a través de la notación ${{ ... }}.
  5. Configura los metadatos, como el nombre para mostrar y el nombre del experimento. Un experimento es un contenedor para todas las iteraciones que se realizan en un proyecto determinado. Todos los trabajos que envíe en el mismo nombre del experimento aparecen junto a otros en Azure Machine Learning Studio.

Enviar el trabajo

Ahora, envíe el trabajo para que se ejecute en Azure Machine Learning. Esta vez, use create_or_update en ml_client.jobs.

ml_client.jobs.create_or_update(job)

Cuando finaliza el trabajo, registra un modelo en el área de trabajo como resultado del entrenamiento. También genera un vínculo para ver el trabajo en Azure Machine Learning Studio.

¿Qué ocurre durante la ejecución del trabajo?

A medida que se ejecuta el trabajo, pasa por las siguientes fases:

• Preparación: el proceso crea una imagen de Docker según el entorno definido. Carga la imagen en el registro de contenedor del área de trabajo y la almacena en caché para las ejecuciones posteriores. El proceso también transmite registros al historial de trabajos, por lo que puede verlos para supervisar el progreso. Si especifica un entorno mantenido, el proceso usa la imagen almacenada en caché que respalda ese entorno mantenido.

• Escalado: el clúster intenta escalar hacia arriba si requiere más nodos para ejecutar el proceso de los que están disponibles actualmente.

• En ejecución: el proceso carga todos los scripts de la carpeta de scripts src en el destino de cómputo. Monta o copia almacenes de datos. Ejecuta el script. El proceso transmite salidas de stdout y la carpeta ./logs al historial de trabajos. Puede usar estas salidas para supervisar el trabajo.

Ajuste de hiperparámetros del modelo

Ha entrenado el modelo con un conjunto de parámetros. Ahora, vea si puede mejorar aún más la precisión del modelo. Ajuste y optimice los hiperparámetros del modelo mediante las funcionalidades de sweep Azure Machine Learning.

Para ajustar los hiperparámetros del modelo, defina el espacio de parámetros que se va a buscar durante el entrenamiento. Sustituya algunos de los parámetros transferidos al trabajo de entrenamiento por entradas especiales del paquete azure.ml.sweep.

Dado que el script de entrenamiento usa una programación de velocidad de aprendizaje para degradar la velocidad de aprendizaje cada varias épocas, puede ajustar la velocidad de aprendizaje inicial y los parámetros de impulso.

from azure.ai.ml.sweep import Uniform

# we will reuse the command_job created before. we call it as a function so that we can apply inputs
job_for_sweep = job(
    learning_rate=Uniform(min_value=0.0005, max_value=0.005),
    momentum=Uniform(min_value=0.9, max_value=0.99),
)

A continuación, configure el barrido en el trabajo de comando mediante algunos parámetros específicos del barrido, como la métrica principal para inspeccionar y el algoritmo de muestreo que se va a usar.

En el código siguiente, el muestreo aleatorio intenta diferentes conjuntos de configuración de hiperparámetros en un intento de maximizar la métrica principal, best_val_acc.

Defina también una directiva de terminación anticipada, BanditPolicy, para finalizar las ejecuciones que tengan un rendimiento deficiente. BanditPolicy finaliza cualquier ejecución que no esté dentro del factor de margen de la métrica de evaluación principal. Esta política se aplica cada época (ya que la métrica best_val_acc se notifica cada época y evaluation_interval=1). La primera evaluación de política se retrasa hasta después de las primeras 10 épocas (delay_evaluation=10).

from azure.ai.ml.sweep import BanditPolicy

sweep_job = job_for_sweep.sweep(
    compute="gpu-cluster",
    sampling_algorithm="random",
    primary_metric="best_val_acc",
    goal="Maximize",
    max_total_trials=8,
    max_concurrent_trials=4,
    early_termination_policy=BanditPolicy(
        slack_factor=0.15, evaluation_interval=1, delay_evaluation=10
    ),
)

Ahora, envíe este trabajo como antes. Esta vez, va a ejecutar un trabajo de barrido que barrerá el trabajo de entrenamiento.

returned_sweep_job = ml_client.create_or_update(sweep_job)

# stream the output and wait until the job is finished
ml_client.jobs.stream(returned_sweep_job.name)

# refresh the latest status of the job after streaming
returned_sweep_job = ml_client.jobs.get(name=returned_sweep_job.name)

Puede supervisar el trabajo mediante el vínculo de la interfaz de usuario de Studio que se presenta durante la ejecución del trabajo.

Identificación del mejor modelo

Cuando finalicen todas las ejecuciones, busque la ejecución que generó el modelo con la mayor precisión.

from azure.ai.ml.entities import Model

if returned_sweep_job.status == "Completed":

    # First let us get the run which gave us the best result
    best_run = returned_sweep_job.properties["best_child_run_id"]

    # lets get the model from this run
    model = Model(
        # the script stores the model as "outputs"
        path="azureml://jobs/{}/outputs/artifacts/paths/outputs/".format(best_run),
        name="run-model-example",
        description="Model created from run.",
        type="custom_model",
    )

else:
    print(
        "Sweep job status: {}. Please wait until it completes".format(
            returned_sweep_job.status
        )
    )

Implementación del modelo como un punto de conexión en línea

Ahora puede implementar el modelo como punto de conexión en línea, es decir, como servicio web en la nube de Azure.

Para implementar un Machine Learning Service, normalmente necesita lo siguiente:

• Los recursos del modelo que desea implementar. Estos recursos incluyen el archivo y los metadatos del modelo que ya registró en el trabajo de entrenamiento.
• Algún código que se ejecutará como servicio. El código ejecuta el modelo en una solicitud de entrada determinada (un script de entrada). Este script recibe datos enviados a un servicio web implementado y lo pasa al modelo. Una vez que el modelo procesa los datos, el script devuelve la respuesta del modelo al cliente. El script es específico para el modelo, y debe entender los datos que el modelo espera y devuelve. Cuando se usa un modelo de MLFlow, Azure Machine Learning crea automáticamente este script.

Para más información sobre la implementación, consulte Implementación y puntuación de un modelo de Machine Learning con un punto de conexión en línea administrado mediante el SDK de Python v2.

Creación de un punto de conexión en línea

Como primer paso para implementar el modelo, cree el punto de conexión en línea. El nombre del punto de conexión debe ser único en toda la región de Azure. Para este artículo, cree un nombre único mediante un identificador único universal (UUID).

import uuid

# Creating a unique name for the endpoint
online_endpoint_name = "aci-birds-endpoint-" + str(uuid.uuid4())[:8]

from azure.ai.ml.entities import ManagedOnlineEndpoint

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="Classify turkey/chickens using transfer learning with PyTorch",
    auth_mode="key",
    tags={"data": "birds", "method": "transfer learning", "framework": "pytorch"},
)

endpoint = ml_client.begin_create_or_update(endpoint).result()

print(f"Endpoint {endpoint.name} provisioning state: {endpoint.provisioning_state}")

Después de crear el punto de conexión, recupéralo de la siguiente manera:

endpoint = ml_client.online_endpoints.get(name=online_endpoint_name)

print(
    f'Endpint "{endpoint.name}" with provisioning state "{endpoint.provisioning_state}" is retrieved'
)

Implementación del modelo en el punto de conexión

Implemente el modelo mediante el script de entrada. Un punto de conexión puede tener varias implementaciones. Mediante el uso de reglas, el punto de conexión puede dirigir el tráfico a estas implementaciones.

En el siguiente código, creará una implementación única que controla el 100 % del tráfico entrante. El código usa un nombre de color arbitrario azul para la implementación. También puede usar cualquier otro nombre como verde o rojo para la implementación.

Código para implementar el modelo en el punto de conexión:

• Implementa la mejor versión del modelo que registró anteriormente.
• Puntúa el modelo mediante el archivo score.py .
• Usa el entorno mantenido (que ha especificado anteriormente) para realizar la inferencia.

from azure.ai.ml.entities import (
    ManagedOnlineDeployment,
    Model,
    Environment,
    CodeConfiguration,
)

online_deployment_name = "aci-blue"

# create an online deployment.
blue_deployment = ManagedOnlineDeployment(
    name=online_deployment_name,
    endpoint_name=online_endpoint_name,
    model=model,
    environment=curated_env_name,
    code_configuration=CodeConfiguration(code="./score/", scoring_script="score.py"),
    instance_type="STANDARD_NC4AS_T4_V3",
    instance_count=1,
)

blue_deployment = ml_client.begin_create_or_update(blue_deployment).result()

Prueba del modelo implementado

Después de implementar el modelo en el punto de conexión, use el invoke método en el punto de conexión para predecir la salida del modelo implementado.

Para probar el punto de conexión, use una imagen de ejemplo para la predicción. En primer lugar, muestre la imagen.

# install pillow if PIL cannot imported
%pip install pillow
import json
from PIL import Image
import matplotlib.pyplot as plt

%matplotlib inline
plt.imshow(Image.open("test_img.jpg"))

Cree una función para dar formato y cambiar el tamaño de la imagen.

# install torch and torchvision if needed
%pip install torch
%pip install torchvision

import torch
from torchvision import transforms


def preprocess(image_file):
    """Preprocess the input image."""
    data_transforms = transforms.Compose(
        [
            transforms.Resize(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
        ]
    )

    image = Image.open(image_file)
    image = data_transforms(image).float()
    image = torch.tensor(image)
    image = image.unsqueeze(0)
    return image.numpy()

Dé formato a la imagen y conviértela en un archivo JSON.

image_data = preprocess("test_img.jpg")
input_data = json.dumps({"data": image_data.tolist()})
with open("request.json", "w") as outfile:
    outfile.write(input_data)

Invoque el punto de conexión con este JSON e imprima el resultado.

# test the blue deployment
result = ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="request.json",
    deployment_name=online_deployment_name,
)

print(result)

Limpieza de recursos

Si ya no necesita el punto de conexión, elimínelo para dejar de usar el recurso. Asegúrese de que ninguna otra implementación use el punto de conexión antes de eliminarla.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Contenido relacionado

En este artículo, usted entrenó y registró una red neuronal de aprendizaje profundo utilizando PyTorch en Azure Machine Learning. También ha implementado el modelo en un punto de conexión en línea. Para más información sobre Azure Machine Learning, consulte los artículos siguientes:

• Seguimiento de las métricas de ejecución durante el entrenamiento
• Ajustar los hiperparámetros
• Arquitectura de referencia para el entrenamiento del aprendizaje profundo distribuido en Azure