Entrenamiento de modelos de TensorFlow a gran escala con el SDK (v1) de Azure Machine Learning

SE APLICA A:Azure ML del SDK de Python v1

• v1
• v2 (versión actual)

En este artículo, aprenderá a ejecutar los scripts de entrenamiento de TensorFlow a gran escala con Azure Machine Learning.

En este ejemplo se entrena y registra un modelo de TensorFlow para clasificar dígitos manuscritos mediante una red neuronal profunda (DNN).

Tanto si se va a desarrollar un modelo de TensorFlow desde el principio como si va a incorporar un modelo existente a la nube, puede usar Azure Machine Learning para escalar horizontalmente trabajos de entrenamiento de código abierto para crear, implementar, versionar y supervisar modelos de nivel de producción.

Requisitos previos

Ejecute este código en cualquiera de estos entornos:

• Instancia de Proceso de Azure Machine Learning: no se necesitan descargas ni instalación

  • Complete la Guía de inicio rápido: Introducción a Azure Machine Learning para crear un servidor de cuadernos dedicado previamente cargado con el SDK y el repositorio de ejemplo.
  • En la carpeta de aprendizaje profundo de ejemplos en el servidor de cuadernos, vaya a este directorio: carpeta how-to-use-azureml > ml-frameworks > tensorflow > train-hyperparameter-tune-deploy-with-tensorflow, en donde encontrará un cuaderno completado y expandido.

• Su propio servidor de Jupyter Notebook

  • Instale el SDK de Azure Machine Learning (>= 1.15.0).
  • Cree un archivo de configuración del área de trabajo.
  • Descarga de los archivos de script de ejemplotf_mnist.py y utils.py

  También puede encontrar una versión de Jupyter Notebook completada de esta guía en la página de ejemplos de GitHub. El cuaderno incluye secciones expandidas que abarcan el ajuste de hiperparámetros inteligente, la implementación de modelos y los widgets del cuaderno.

Para poder ejecutar el código de este artículo a fin de crear un clúster de GPU, deberá solicitar un aumento de cuota para el área de trabajo.

Configuración del experimento

En esta sección, para configurar el experimento de entrenamiento, se cargan los paquetes de Python necesarios, se inicializa un área de trabajo,se crea el destino de proceso y se define el entorno de entrenamiento.

Importación de paquetes

En primer lugar, importe las bibliotecas de Python necesarias.

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

Inicialización de un área de trabajo

El área de trabajo de Azure Machine Learning es el recurso de nivel superior para el servicio. 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 de área de trabajo a partir del archivo config.json creado en la sección de requisitos previos.

ws = Workspace.from_config()

Crear un conjunto de datos de archivo

Un objeto FileDataset hace referencia a uno o varios archivos del almacén de archivos del área de trabajo o direcciones URL públicas. Los archivos pueden estar en cualquier formato y la clase le permite descargar o montar los archivos en el proceso. Si crea un objeto FileDataset, se crea una referencia a la ubicación de los orígenes de datos. Si aplicó alguna transformación al conjunto de datos, también se almacenará en el conjunto de datos. Los datos se mantienen en la ubicación existente, por lo que no se genera ningún costo de almacenamiento adicional. Para más información sobre el paquete Dataset, consulte el artículo sobre la creación de conjuntos de datos de registro.

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)

Use el método register() para registrar el conjunto de datos en el área de trabajo de modo que pueda compartirlo con otros usuarios, reutilizarlo en varios experimentos y hacer referencia a él por nombre en el script de entrenamiento.

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

Creación de un destino de proceso

Cree un destino de proceso en el que ejecutar el trabajo de TensorFlow. En este ejemplo, cree un clúster de proceso de Azure Machine Learning habilitado para GPU.

Importante

Para poder crear un clúster de GPU, deberá solicitar un aumento de cuota para el área de trabajo.

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)

Nota

También puede usar máquinas virtuales de prioridad baja para ejecutar algunas o todas las cargas de trabajo. Consulte los procedimientos para la creación de una máquina virtual de prioridad baja.

Para más información sobre los destinos de proceso, vea el artículo ¿Qué es un destino de proceso?

Definición del entorno

Para definir el entorno de Azure Machine Learning que encapsula las dependencias del script de entrenamiento, puede definir un entorno personalizado, o bien usar uno mantenido de Azure Machine Learning.

Uso de un entorno mantenido

Si no quiere definir un entorno propio, Azure Machine Learning proporciona entornos mantenidos precompilados. Azure Machine Learning tiene varios entornos mantenidos con CPU y GPU para TensorFlow correspondientes a las diferentes versiones de TensorFlow. Puede usar la versión más reciente de este entorno mediante la directiva @latest. Para obtener más información, consulte Entornos mantenidos de Azure Machine Learning.

Si quiere usar un entorno mantenido, el código será similar al del ejemplo siguiente:

curated_env_name = 'AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu'
tf_env = Environment.get(workspace=ws, name=curated_env_name)

Para ver los paquetes incluidos en el entorno mantenido, puede escribir las dependencias de Conda en el disco:

tf_env.save_to_directory(path=curated_env_name)

Asegúrese de que el entorno mantenido incluye todas las dependencias requeridas por el script de entrenamiento. Si no es así, tendrá que modificar el entorno para incluir las dependencias que faltan. Si se modifica el entorno, tendrá que asignarle un nuevo nombre, ya que el prefijo "AzureML" está reservado para entornos mantenidos. Si ha modificado el archivo YAML de dependencias de Conda, puede crear un nuevo entorno a partir de él con un nuevo nombre, por ejemplo:

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

Si en su lugar ha modificado directamente el objeto del entorno mantenido, puede clonar ese entorno con un nuevo nombre:

tf_env = tf_env.clone(new_name='my-AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu')

Creación de un entorno personalizado

También puede crear un entorno propio de Azure Machine Learning que encapsule las dependencias del script de entrenamiento.

En primer lugar, defina las dependencias de Conda en un archivo YAML; en este ejemplo, el archivo se llama conda_dependencies.yml.

channels:
- conda-forge
dependencies:
- python=3.7
- pip:
  - azureml-defaults
  - tensorflow-gpu==2.2.0

Cree un entorno de Azure Machine Learning a partir de esta especificación de entorno de Conda. El entorno se empaquetará en un contenedor de Docker en tiempo de ejecución.

De manera predeterminada, si no se especifica ninguna imagen base, Azure Machine Learning usará una imagen de CPU azureml.core.environment.DEFAULT_CPU_IMAGE como imagen base. Dado que en este ejemplo el entrenamiento se ejecuta en un clúster con GPU, deberá especificar una imagen de base con GPU que tenga los controladores y las dependencias de GPU necesarios. Azure Machine Learning mantiene un conjunto de imágenes de base publicadas en Microsoft Container Registry (MCR) que puede usar; consulte el repositorio de GitHub Azure/AzureML-Containers para más información.

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'

Sugerencia

Opcionalmente, puede capturar todas las dependencias directamente en una imagen de Docker personalizada o un archivo Dockerfile y crear el entorno a partir de ahí. Para más información, consulte Entrenamiento de un modelo con una imagen personalizada de Docker.

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

Configuración y envío de la ejecución de entrenamiento

Creación de ScriptRunConfig

Cree un objeto ScriptRunConfig para especificar los detalles de configuración del trabajo de entrenamiento, incluido el script de entrenamiento, el entorno que se va a usar y el destino de proceso en el que se ejecutará. Cualquier argumento del script de entrenamiento se pasará mediante la línea de comandos si se especifica en el parámetro 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)

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 conjunto de datos de Azure Machine Learning.

Para más información sobre la configuración de trabajos con ScriptRunConfig, consulte Envío de una ejecución de entrenamiento a un destino de proceso.

Advertencia

Si anteriormente usaba el estimador de TensorFlow para configurar los trabajos de entrenamiento de TensorFlow, tenga en cuenta que los estimadores se han dejado de utilizar a partir de la versión del SDK 1.19.0. Con el SDK >= 1.15.0 de Azure Machine Learning, ScriptRunConfig es la forma recomendada de configurar los trabajos de entrenamiento, incluidos los que usan marcos de aprendizaje profundo. Para ver preguntas habituales sobre migración, consulte la guía sobre migración del estimador a ScriptRunConfig.

Envío de una ejecución

El objeto Run proporciona la interfaz para el historial de ejecución mientras se ejecuta el trabajo y cuando se ha completado.

run = Experiment(workspace=ws, name='Tutorial-TF-Mnist').submit(src)
run.wait_for_completion(show_output=True)

¿Qué ocurre mientras se lleva a cabo la ejecución?

Durante la ejecución del objeto, pasa por las fases siguientes:

• Preparando: se crea una imagen de Docker según el entorno definido. La imagen se carga en el registro de contenedor del área de trabajo y se almacena en memoria caché para ejecuciones posteriores. Los registros también se transmiten al historial de ejecución y se pueden consultar para supervisar el progreso. Si se especifica un entorno mantenido en su lugar, se usará la imagen almacenada en caché que respalda el entorno mantenido.

• Escalado: el clúster intenta escalar verticalmente si el clúster de Batch AI requiere más nodos para realizar la ejecución de los que se encuentran disponibles actualmente.

• En ejecución: todos los scripts de la carpeta de scripts se cargan en el destino de proceso, se montan o se copian los almacenes de datos y se ejecuta el script. Las salidas de stdout y la carpeta ./logs se transmiten al historial de ejecución y se pueden usar para supervisar la ejecución.

• Posprocesamiento: la carpeta ./outputs de la ejecución se copia en el historial de ejecución.

Registro o descarga de un modelo

Una vez que haya entrenado el modelo, puede registrarlo en el área de trabajo. El registro del modelo permite almacenar los modelos y crear versiones de ellos en el área de trabajo para simplificar la administración e implementación de modelos.

Opcional: al especificar los parámetros model_framework, model_framework_version y resource_configuration, está disponible la implementación del modelo sin código. Esto le permite implementar directamente el modelo como un servicio web desde el modelo registrado, y el objeto ResourceConfiguration define el recurso de proceso del servicio 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))

También puede descargar una copia local del modelo mediante el uso del objeto Run. En el script de entrenamiento, tf_mnist.py, un objeto de protector de TensorFlow guarda el modelo en una carpeta local (local para el destino de proceso). Puede usar el objeto Run para descargar una copia.

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

Entrenamiento distribuido

Azure Machine Learning también admite trabajos de TensorFlow distribuidos de varios nodos para que pueda escalar las cargas de trabajo de entrenamiento. Puede ejecutar fácilmente los trabajos distribuidos de TensorFlow y Azure Machine Learning se ocupará de administrar la orquestación automáticamente.

Azure Machine Learning admite la ejecución de trabajos distribuidos de TensorFlow con la API de entrenamiento distribuido integrada de TensorFlow y Horovod.

Para obtener más información sobre el entrenamiento distribuido, consulte la guía de entrenamiento de GPU distribuido.

Implementación de un modelo de TensorFlow

El procedimiento de implementación contiene una sección sobre el registro de modelos, pero puede ir directamente a la creación de un destino de proceso para la implementación, dado que ya tiene un modelo registrado.

(Versión preliminar) Implementación de modelo sin código

Importante

Esta característica actualmente está en su versión preliminar pública. Esta versión preliminar se ofrece sin Acuerdo de Nivel de Servicio y no se recomienda para cargas de trabajo de producción. Es posible que algunas características no sean compatibles o que tengan sus funcionalidades limitadas. Para más información, consulte Términos de uso complementarios de las Versiones Preliminares de Microsoft Azure.

En lugar de la ruta de implementación tradicional, también puede usar la característica de implementación sin código (versión preliminar) para TensorFlow. Mediante el registro del modelo como se ha mostrado anteriormente, con los parámetros model_framework, model_framework_version y resource_configuration, puede usar la función estática deploy() para implementar el modelo.

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

El procedimiento completo trata la implementación en Azure Machine Learning más detalladamente.

Pasos siguientes

En este artículo, ha entrenado y registrado un modelo de TensorFlow y ha aprendido acerca de las opciones de implementación. Consulte estos otros artículos para más información sobre Azure Machine Learning.

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