AWS Batch: Formación distribuida sin servidor multiregión

por

La creación de una huella global y el acceso a la escala son una de las muchas mejores prácticas en AWS. Al crear arquitecturas que aprovechan esa escala y también la utilización eficiente de datos (tanto en rendimiento como en costo), puede comenzar a ver cuán importante es el acceso a escala. Por ejemplo, dentro del desarrollo de vehículos autónomos (AV), los datos se adquieren geográficamente localmente para la campaña de conducción. Es relevante y más eficiente desde una perspectiva de aprendizaje automático (ML) ejecutar la tubería de cómputo en la misma región de AWS que los datos generados.

Para más detalles, diga que su organización adquiere datos de video 4K en una campaña de conducción en San Francisco, Estados Unidos. Paralelamente, sus colegas adquieren una campaña de conducción en Stuttgart, Alemania. Ambas campañas de video pueden generar algunas TB de datos por día. Idealmente, transferiría los datos a las Regiones cercanas a donde generó los datos (en este caso, us-west-1 y eu-central-1 ). Si el flujo de trabajo etiqueta estos datos, entonces ejecutar la capacitación distribuida local en sus respectivas Regiones tiene sentido desde un punto de vista de costo y rendimiento, mientras se mantiene la coherencia en los hiperparámetros utilizados para entrenar ambos conjuntos de datos.

Para comenzar con la capacitación distribuida en AWS, use Amazon SageMaker que proporciona gran parte del trabajo pesado indiferenciado requerido para el entrenamiento distribuido (por ejemplo, TensorFlow optimizado con Horovod). Además, su facturación por segundo proporciona una gestión eficiente de los costos. Estos beneficios liberan su enfoque para el desarrollo e implementación de modelos en una arquitectura completamente administrada.

Amazon SageMaker es un ecosistema de servicios de ML administrados para ayudar con el etiquetado de verdad, capacitación de modelos, optimización de hiperparámetros e implementación. Puede acceder a estos servicios utilizando cuadernos Jupyter AWS CLI o Amazon SageMaker Python SDK . Particularmente con el SDK, necesita un pequeño cambio de código para iniciar y distribuir la carga de trabajo de ML.

En la arquitectura anterior, el depósito S3 sirve como fuente para los archivos de entrada de entrenamiento. El SDK de SageMaker Python creará una instancia de los recursos informáticos necesarios y la imagen de Docker para ejecutar la capacitación modelo que obtiene los datos del S3. Los artefactos del modelo de salida se guardan en un depósito de salida S3.

Debido a que el SDK de Amazon SageMaker Python abstrae la implementación de la infraestructura y está completamente basada en API, puede organizar las solicitudes de trabajos de capacitación a través del SDK de manera escalable.

En el anterior Escenario AV, por ejemplo, puede activar los datos de entrenamiento de entrada del conjunto de datos cargado, que rastreó de manera relacional. Puede acoplar esto con AWS Batch que ofrece un mecanismo de matriz de trabajos que puede enviar estos trabajos de capacitación distribuida de manera escalable pasando hiperparámetros relevantes en tiempo de ejecución. Considere el siguiente ejemplo de arquitectura.

En esta arquitectura anterior, se utiliza una base de datos relacional para rastrear, por ejemplo, metadatos de campañas AV a nivel mundial. Se puede generar una consulta SQL que llena el archivo de entrada JOBARRAY en AWS Batch. AWS Batch luego organiza la creación de instancias de la cuadrícula de clústeres que se ejecutan globalmente en múltiples regiones de AWS.

Está de pie una cuadrícula de clústeres, implementada globalmente, basada en datos en Amazon S3 que se genera en la zona. Consultar los metadatos de una base de datos central para organizar las entradas de capacitación con acceso a la capacidad en las cuatro Regiones. Puede incluir algunas combinaciones relacionales adicionales, que seleccionan datos para la copia transitiva en función del precio a pedido o al contado por región y la capacidad de reserva.

Implementación de Amazon SageMaker

El ejemplo en esta publicación ejecuta el modelo Imagenet2012 / Resnet50, con los registros Imagenet2012 TF replicados en todas las regiones. Para este flujo de trabajo avanzado, debe preparar dos imágenes Docker . Una imagen es para llamar al SDK de Amazon SageMaker para preparar el envío del trabajo, y la segunda imagen es para ejecutar el entorno TensorFlow 1.13 habilitado para Horovod.

Primero, cree un rol IAM para llamar al Amazon SageMaker servicio y servicios posteriores para ejecutar la capacitación. Luego, cree el script dl-sagemaker.py . Esta es la secuencia de comandos de llamada principal en la API de capacitación de Amazon SageMaker.

Para obtener instrucciones sobre cómo crear la imagen Docker del modo de secuencia de comandos de Amazon SageMaker, consulte el TensorFlow framework repo en GitHub, en aws / sagemaker- Tensorflow-container . Después de su construcción, confirme esta imagen en cada Región en la que planea generar datos.

El siguiente ejemplo confirma esto en us-east-1 (Northern Virginia), us-west- 2 (Oregón), eu-west-1 (Irlanda) y eu-central-1 (Frankfurt). Cuando el soporte para TensorFlow 1.13 con Tensorpack está en el SDK de Amazon SageMaker Python, esto se convierte en un paso opcional. Para simplificar la implementación, mantenga el nombre de la imagen Amazon ECR igual en todas las regiones.

Para que el script de entrada principal llame al Amazon SageMaker SDK ( dl-sagemaker.py ), complete los siguientes pasos:

  1. Reemplace la entrada: 
     role = 'arn: aws: iam :: : role / sagemaker-sdk'
  2. Reemplace image_name con el nombre de la imagen Docker que creó: 
     importación os
de sagemaker.session import s3_input
de sagemaker.tensorflow import TensorFlow

role = 'arn: aws: iam :: : role / sagemaker-sdk'

num_gpus = int (os.environ.get ('GPUS_PER_HOST'))

distribuciones = {
'mpi': {
'enabled': verdadero,
'procesos_por_host': num_gpus,
'custom_mpi_options': '-mca btl_vader_single_copy_mechanism none -x HOROVOD_HIERARCHICAL_ALLREDUCE = 1 -x HOROVOD_FUSION_THRESHOLD = 16777216 -x NCCL_MIN_NRINGS = 8 -x NCCL_LAUNCH_MODE = PARAL
}
}

def main (aws_region, s3_location):
estimador = TensorFlow (
train_instance_type = 'ml.p3.16xlarge',
train_volume_size = 100,
train_instance_count = 10,
framework_version = '1.12',
py_version = 'py3',
image_name = " .dkr.ecr.% s.amazonaws.com / sage-py3-tf-hvd: último"% aws_region,
entry_point = 'sagemaker_entry.py',
dependencias = ['/Users/amrraga/git/github/deep-learning-models'],
script_mode = True,
rol = rol,
distribuciones = distribuciones,
base_job_name = 'dist-test',
)
estimator.fit (ubicación_3)

if __name__ == '__main__':
aws_region = os.environ.get ('AWS_DEFAULT_REGION')
s3_location = os.environ.get ('S3_LOCATION')

main (aws_region, s3_location)

El siguiente código es para sagemaker_entry.py la llamada interna para iniciar el script de capacitación:

 subproceso de importación
importar os

if __name__ == '__ main__':
    train_dir = os.environ.get ('SM_CHANNEL_TRAIN')
    subprocess.call (['python','-W ignore', 'deep-learning-models/models/resnet/tensorflow/train_imagenet_resnet_hvd.py', 
            "—data_dir=%s"%train_dir, 
            '—num_epochs=90', 
            '-b=256', 
            '—lr_decay_mode=poly', 
            '—warmup_epochs=10', 
            '—clear_log'])

El siguiente código es para sage_wrapper.sh el contenedor general de AWS Batch para descargar la definición de matriz de S3 e iniciar las llamadas globales de API de Amazon SageMaker: [19659023] #! / bin / bash -xe
###################################
env
###################################
echo “DESCARGANDO ARCHIVOS DE ARREGLO DE MANIFIESTO DE SAGEMAKER …”
aws s3 cp $ S3_ARRAY_FILE sage_array.txt
si [[ -z “${AWS_BATCH_JOB_ARRAY_INDEX}” ]]; entonces
echo “NO ES UN TRABAJO DE ARREGLO … SALIENDO”
salida 1
más
LINE = $ ((AWS_BATCH_JOB_ARRAY_INDEX + 1))
SAGE_SYSTEM = $ (sed -n $ {LINE} p sage_array.txt)
mientras IFS =, lea -r f1 f2 f3; hacer
exportar AWS_DEFAULT_REGION = $ {f1}
exportar S3_LOCATION = $ {f2}
hecho <<< $ SAGE_SYSTEM
fi

GPUS_PER_HOST = 8 python3 dl-sagemaker.py

echo “ENTRENAMIENTO DE SAGEMAKER COMPLETO”
salida 0

Por último, el siguiente código es para el Dockerfile, para construir la imagen de orquestación por lotes:

 DESDE amazonlinux: último

### SAGEMAKER PYTHON SDK

Ejecutar yum update -y
EJECUTAR amazon-linux-extras instalar epel
EJECUTAR yum instalar python3-pip git -y
EJECUTAR pip3 instalar tensorflow sagemaker awscli

### API SCRIPTS

EJECUTAR mkdir / api
AGREGAR dl-sagemaker.py / api
AGREGAR sagemaker_entry.py / api
AGREGAR sage_wrapper.sh / api
EJECUTAR chmod + x /api/sage_wrapper.sh

### DEPENDENCIAS DE SAGEMAKER SDK

EJECUTAR git clone https://github.com/aws-samples/deep-learning-models.git / api / deep-learning-models

Confirme la imagen Docker construida en ECR en la misma región que el SDK de Amazon SageMaker Python. Desde esta región, puede implementar todos sus trabajadores de clúster ML distribuidos de Amazon SageMaker a nivel mundial.

Con AWS Batch, no necesita ninguna configuración única para crear una instancia de un entorno informático. Debido a que solo está utilizando AWS Batch para iniciar las API de Amazon SageMaker, la configuración predeterminada es suficiente. Adjunte una cola de trabajos al entorno de cómputo y cree el archivo de definición de trabajo con lo siguiente:

 {
    "jobDefinitionName": "sagemaker-python-sdk-jobdef",
    "jobDefinitionArn": "arn: aws: lote: us-east-1: : definición de trabajo / sagemaker-python-sdk-jobdef: 1",
    "revisión": 1,
    "Estado: Activo",
    "type": "contenedor",
    "parámetros": {},
    "containerProperties": {
        "image": " .dkr.ecr.us-east-1.amazonaws.com / batch / sagemaker-sdk: último",
        "vcpus": 2,
        "memoria": 2048,
        "comando": [
            "/api/sage_wrapper.sh"
        ],
        "jobRoleArn": "arn: aws: iam :: : role / ecsTaskExecutionRole",
        "volúmenes": [],
        "medio ambiente": [
            {
                "name": "S3_ARRAY_FILE",
                "value": "s3://ragab-ml/"
            }
        ],
        "mountPoints": [],
        "ulimits": [],
        "resourceRequirements": []
    }
}

Para importar al inicio del trabajo, cargue un archivo JOBARRAY de ejemplo en S3:

 us-east-1, s3: // ragab-ml / imagenet2012 / tf-imagenet / resized
us-west-2, s3: // ragab-ml-pdx / imagenet2012 / tf-imagenet / resized
eu-west-1, s3: // ragab-ml-dub / imagenet2012 / tf-imagenet / resized
eu-central-1, s3: // ragab-ml-fra / imagenet2012 / tf-imagenet / resized

En la página Trabajos envíe un trabajo que cambie la ruta de la S3_ARRAY_FILE . Se inicia una matriz de trabajos con cada nodo dedicado a enviar y monitorear un trabajo de capacitación de ML en una Región separada. Si selecciona una región candidata donde se está ejecutando un trabajo, puede ver algoritmos adicionales, métricas de instancia y más detalles de registro.

Un aspecto notable de esta implementación es que en el ejemplo anterior, lanzó una cuadrícula de grupos de 480 GPU en cuatro regiones, con un total de 360,000 imágenes / seg combinadas. Este proceso mejoró el tiempo de obtención de resultados y escaneo de parámetros optimizado.

Conclusión

Al implementar esta arquitectura, ahora tiene una plataforma de capacitación ML escalable, eficiente y distribuida globalmente. En el script de AWS Batch, puede levantar cualquier número de parámetros en el archivo de matriz para distribuir la carga de trabajo. Por ejemplo, puede usar no solo diferentes archivos de entrenamiento de entrada, sino también diferentes hiperparámetros, imágenes de contenedores Docker o incluso diferentes algoritmos, todos implementados a escala global.

Tenga en cuenta también que cualquier servicio de ML distribuido sin servidor de back-end puede ejecutar estos cargas de trabajo Por ejemplo, es posible reemplazar los componentes de Amazon SageMaker con Amazon EKS . ¡Ahora encienda sus cargas de trabajo ML con una huella global!

Abra la consola Amazon SageMaker para comenzar. Si tiene alguna pregunta, déjela en los comentarios.

 

Dejá un comentario