Escala tus cargas de trabajo de aprendizaje automático en Amazon ECS impulsado por instancias AWS Trainium.

Escalá tus cargas de trabajo de aprendizaje automático en Amazon ECS con AWS Trainium.

Ejecutar cargas de trabajo de aprendizaje automático (ML) con contenedores se está convirtiendo en una práctica común. Los contenedores pueden encapsular completamente no solo su código de entrenamiento, sino todo el conjunto de dependencias hasta las bibliotecas y controladores de hardware. Lo que obtiene es un entorno de desarrollo de ML consistente y portátil. Con los contenedores, escalar en un clúster se vuelve mucho más fácil.

A finales de 2022, AWS anunció la disponibilidad general de las instancias Amazon EC2 Trn1 impulsadas por aceleradores AWS Trainium, que están diseñadas específicamente para el entrenamiento de aprendizaje profundo de alto rendimiento. Las instancias Trn1 ofrecen hasta un 50% de ahorro en los costos de entrenamiento en comparación con otras instancias comparables de Amazon Elastic Compute Cloud (Amazon EC2). Además, se lanzó el AWS Neuron SDK para mejorar esta aceleración, brindando a los desarrolladores herramientas para interactuar con esta tecnología, como compilar, tiempo de ejecución y perfil para lograr entrenamientos de modelos eficientes en términos de costo y alto rendimiento.

Amazon Elastic Container Service (Amazon ECS) es un servicio de orquestación de contenedores completamente administrado que simplifica la implementación, administración y escalado de aplicaciones en contenedores. Simplemente describa su aplicación y los recursos requeridos, y Amazon ECS lanzará, supervisará y escalará su aplicación en opciones de cómputo flexibles con integraciones automáticas con otros servicios de AWS de apoyo que su aplicación necesita.

En esta publicación, le mostramos cómo ejecutar sus trabajos de entrenamiento de ML en un contenedor utilizando Amazon ECS para implementar, administrar y escalar su carga de trabajo de ML.

Resumen de la solución

Le guiaremos a través de los siguientes pasos de alto nivel:

  1. Provisión de un clúster ECS de instancias Trn1 con AWS CloudFormation.
  2. Construya una imagen de contenedor personalizada con Neuron SDK y envíela a Amazon Elastic Container Registry (Amazon ECR).
  3. Cree una definición de tarea para definir un trabajo de entrenamiento de ML que se ejecutará en Amazon ECS.
  4. Ejecute la tarea de ML en Amazon ECS.

Requisitos previos

Para seguir adelante, se da por sentado que tiene familiaridad con los servicios principales de AWS como Amazon EC2 y Amazon ECS.

Provisión de un clúster ECS de instancias Trn1

Para comenzar, inicie la plantilla CloudFormation proporcionada, que aprovisionará los recursos necesarios, como una VPC, un clúster ECS y una instancia Trainium EC2.

Usamos Neuron SDK para ejecutar cargas de trabajo de aprendizaje profundo en instancias basadas en AWS Inferentia y Trainium. Lo admite en su ciclo de vida de desarrollo de ML de extremo a extremo para crear nuevos modelos, optimizarlos y luego implementarlos para producción. Para entrenar su modelo con Trainium, debe instalar Neuron SDK en las instancias EC2 donde se ejecutarán las tareas de ECS para asignar el NeuronDevice asociado con el hardware, así como la imagen Docker que se enviará a Amazon ECR para acceder a los comandos para entrenar su modelo.

Las versiones estándar de Amazon Linux 2 o Ubuntu 20 no vienen con los controladores Neuron de AWS instalados. Por lo tanto, tenemos dos opciones diferentes.

La primera opción es utilizar una imagen de máquina Amazon Deep Learning (DLAMI) que ya tenga Neuron SDK instalado. Hay una muestra disponible en el repositorio de GitHub . Puede elegir un DLAMI en función del sistema operativo . Luego, ejecute el siguiente comando para obtener el ID de AMI:

aws ec2 describe-images --region us-east-1 --owners amazon --filters 'Name=name,Values=Deep Learning AMI Neuron PyTorch 1.13.? (Amazon Linux 2) ????????' 'Name=state,Values=available' --query 'reverse(sort_by(Images, &CreationDate))[:1].ImageId' --output text

La salida será la siguiente:

ami-06c40dd4f80434809

Este ID de AMI puede cambiar con el tiempo, así que asegúrese de usar el comando para obtener el ID de AMI correcto.

Ahora puede cambiar este ID de AMI en el script de CloudFormation y utilizar Neuron SDK listo para usar. Para hacer esto, busque EcsAmiId en Parámetros:

"EcsAmiId": { 
    "Type": "String", 
    "Description": "AMI ID", 
    "Default": "ami-09def9404c46ac27c" 
}

La segunda opción es crear una instancia completando el campo userdata durante la creación de la pila. No es necesario instalarlo porque CloudFormation lo configurará. Para obtener más información, consulte la Guía de configuración de Neuron .

Para esta publicación, usamos la opción 2 en caso de que necesite usar una imagen personalizada. Complete los siguientes pasos:

  1. Inicie la plantilla de CloudFormation proporcionada.
  2. Para KeyName , ingrese un nombre para su par de claves deseado, y se precargarán los parámetros. Para esta publicación, usamos trainium-key .
  3. Ingrese un nombre para su pila.
  4. Si está ejecutando en la región us-east-1, puede mantener los valores para ALBName y AZIds en su valor predeterminado.

Para verificar qué zona de disponibilidad en la región tiene Trn1 disponible, ejecute el siguiente comando:

aws ec2 describe-instance-type-offerings --region us-east1 --location-type availability-zone --filter Name=instance-type,Values=trn1.2xlarge

  1. Seleccione Siguiente y termine de crear la pila.

Cuando la pila esté completa, puede pasar al siguiente paso.

Preparar y empujar una imagen de ECR con el Neuron SDK

Amazon ECR es un registro de contenedores totalmente administrado que ofrece alojamiento de alto rendimiento, para que pueda implementar de manera confiable imágenes y artefactos de aplicaciones en cualquier lugar. Usamos Amazon ECR para almacenar una imagen personalizada de Docker que contiene nuestros scripts y paquetes de Neuron necesarios para entrenar un modelo con trabajos de ECS en instancias Trn1. Puede crear un repositorio de ECR utilizando la Interfaz de línea de comandos de AWS (AWS CLI) o la Consola de administración de AWS . Para esta publicación, utilizamos la consola. Complete los siguientes pasos:

  1. En la consola de Amazon ECR, cree un nuevo repositorio.
  2. Para Configuración de visibilidad , seleccione Privado .
  3. Para Nombre del repositorio , ingrese un nombre.
  4. Seleccione Crear repositorio .

Ahora que tiene un repositorio, construyamos y empujemos una imagen, que podría construirse localmente (en su computadora portátil) o en un entorno de AWS Cloud9. Estamos entrenando un modelo de perceptrón multicapa (MLP). Para el código original, consulte el Tutorial de entrenamiento de perceptrón multicapa .

  1. Copie los archivos train.py y model.py en un proyecto.

Ya es compatible con Neuron, por lo que no necesita cambiar ningún código.

  1. 5. Cree un archivo Dockerfile que tenga los comandos para instalar los scripts de entrenamiento y el SDK de Neuron:
FROM amazonlinux:2

RUN echo $'[neuron] \n\
name=Neuron YUM Repository \n\
baseurl=https://yum.repos.neuron.amazonaws.com \n\
enabled=1' > /etc/yum.repos.d/neuron.repo

RUN rpm --import https://yum.repos.neuron.amazonaws.com/GPG-PUB-KEY-AMAZON-AWS-NEURON.PUB

RUN yum install aws-neuronx-collectives-2.* -y
RUN yum install aws-neuronx-runtime-lib-2.* -y
RUN yum install aws-neuronx-tools-2.* -y
RUN yum install -y tar gzip pip
RUN yum install -y python3 python3-pip
RUN yum install -y python3.7-venv gcc-c++
RUN python3.7 -m venv aws_neuron_venv_pytorch

# Activar Python venv
ENV PATH="/aws_neuron_venv_pytorch/bin:$PATH"
RUN python -m pip install -U pip
RUN python -m pip install wget
RUN python -m pip install awscli

RUN python -m pip config set global.extra-index-url https://pip.repos.neuron.amazonaws.com
RUN python -m pip install torchvision tqdm torch-neuronx neuronx-cc==2.* pillow
RUN mkdir -p /opt/ml/mnist_mlp
COPY model.py /opt/ml/mnist_mlp/model.py
COPY train.py /opt/ml/mnist_mlp/train.py
RUN chmod +x /opt/ml/mnist_mlp/train.py
CMD ["python3", "/opt/ml/mnist_mlp/train.py"]

Para crear su propio Dockerfile utilizando Neuron, consulte Desarrollo en la instancia del acelerador AWS ML, donde puede encontrar guías para otros sistemas operativos y marcos de ML.

  1. 6. Cree una imagen y luego envíela a Amazon ECR utilizando el siguiente código (proporcione su región, ID de cuenta y repositorio de ECR):
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin {ID-de-cuenta}.dkr.ecr.{su-región}.amazonaws.com

docker build -t mlp_trainium .

docker tag mlp_trainium:latest {ID-de-cuenta}.dkr.ecr.us-east-1.amazonaws.com/mlp_trainium:latest

docker push {ID-de-cuenta}.dkr.ecr.{su-región}.amazonaws.com/{nombre-de-su-repositorio-ECR}:latest

Después de esto, la versión de su imagen debería ser visible en el repositorio de ECR que creó.

Ejecute la tarea de entrenamiento de ML como una tarea de ECS

Para ejecutar la tarea de entrenamiento de ML en Amazon ECS, primero debe crear una definición de tarea. Se requiere una definición de tarea para ejecutar contenedores Docker en Amazon ECS.

  1. En la consola de Amazon ECS, elija Definiciones de tareas en el panel de navegación.
  2. En el menú Crear nueva definición de tarea, elija Crear nueva definición de tarea con JSON.

Puede utilizar la siguiente plantilla de definición de tarea como base. Tenga en cuenta que en el campo de imagen, puede usar la generada en el paso anterior. Asegúrese de que incluya su ID de cuenta y el nombre de su repositorio de ECR.

Para asegurarse de que Neuron esté instalado, puede verificar si el volumen /dev/neuron0 está asignado en el bloque de dispositivos. Esto se asigna a un único NeuronDevice que se ejecuta en la instancia trn1.2xlarge con dos núcleos.

  1. Cree su definición de tarea utilizando la siguiente plantilla:
{
    "family": "mlp_trainium",
    "containerDefinitions": [
        {
            "name": "mlp_trainium",
            "image": "{ID-de-cuenta}.dkr.ecr.us-east-1.amazonaws.com/{nombre-de-su-repositorio-ECR}",
            "cpu": 0,
            "memoryReservation": 1000,
            "portMappings": [],
            "essential": true,
            "environment": [],
            "mountPoints": [],
            "volumesFrom": [],
            "linuxParameters": {
                "capabilities": {
                    "add": [
                        "IPC_LOCK"
                    ]
                },
                "devices": [
                    {
                        "hostPath": "/dev/neuron0",
                        "containerPath": "/dev/neuron0",
                        "permissions": [
                            "read",
                            "write"
                        ]
                    }
                ]
            },
            ,
            "logConfiguration": {
                "logDriver": "awslogs",
                "options": {
                    "awslogs-create-group": "true",
                    "awslogs-group": "/ecs/task-logs",
                    "awslogs-region": "us-east-1",
                    "awslogs-stream-prefix": "ecs"
                }
            }
        }
    ],
    "networkMode": "awsvpc",
    "placementConstraints": [
        {
            "type": "memberOf",
            "expression": "attribute:ecs.os-type == linux"
        },
        {
            "type": "memberOf",
            "expression": "attribute:ecs.instance-type == trn1.2xlarge"
        }
    ],
    "requiresCompatibilities": [
        "EC2"
    ],
    "cpu": "1024",
    "memory": "3072"
}

También puede completar este paso en la CLI de AWS utilizando la siguiente definición de tarea o con el siguiente comando:

aws ecs register-task-definition \
--family mlp-trainium \
--container-definitions '[{    
    "name": "my-container-1",    
    "image": "{ID-de-cuenta}.dkr.ecr.us-east-1.amazonaws.com/{nombre-de-su-repositorio-ECR}",
    "cpu": 0,
    "memoryReservation": 1000,
    "portMappings": [],
    "essential": true,
    "environment": [],
    "mountPoints": [],
    "volumesFrom": [],
    "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
            "awslogs-create-group": "true",
            "awslogs-group": "/ecs/task-logs",
            "awslogs-region": "us-east-1",
            "awslogs-stream-prefix": "ecs"
        }
    },
    "linuxParameters": {
        "capabilities": {
            "add": [
                "IPC_LOCK"
            ]
        },
        "devices": [{
            "hostPath": "/dev/neuron0",
            "containerPath": "/dev/neuron0",
            "permissions": ["read", "write"]
        }]
    }
}]' \
--requires-compatibilities EC2
--cpu "8192" \
--memory "16384" \
--placement-constraints '[{
    "type": "memberOf",
    "expression": "attribute:ecs.instance-type == trn1.2xlarge"
}, {
    "type": "memberOf",
    "expression": "attribute:ecs.os-type == linux"
}]'

Ejecutar la tarea en Amazon ECS

Después de haber creado el clúster ECS, empujado la imagen a Amazon ECR y creado la definición de tarea, ejecutamos la definición de tarea para entrenar un modelo en Amazon ECS.

  1. En la consola de Amazon ECS, elija Clústeres en el panel de navegación.
  2. Abra su clúster.
  3. En la pestaña Tareas, elija Ejecutar nueva tarea.

  1. Para el Tipo de lanzamiento, elija EC2.

  1. Para el Tipo de aplicación, seleccione Tarea.
  2. Para la Familia, elija la definición de tarea que creó.

  1. En la sección de Redes, especifique la VPC creada por la pila de CloudFormation, la subred y el grupo de seguridad.

  1. Elija Crear.

Puede supervisar su tarea en la consola de Amazon ECS.

También puede ejecutar la tarea usando la AWS CLI:

aws ecs run-task --cluster <nombre-de-su-clúster> --task-definition <nombre-de-su-tarea> --count 1 --network-configuration '{"awsvpcConfiguration": {"subnets": ["<nombre-de-su-subred> "], "securityGroups": ["<nombre-de-su-grupo-de-seguridad> "] }}'

El resultado se verá como la siguiente captura de pantalla.

También puede verificar los detalles del trabajo de entrenamiento a través del grupo de registro de Amazon CloudWatch.

Después de entrenar sus modelos, puede almacenarlos en Amazon Simple Storage Service (Amazon S3).

Limpiar

Para evitar gastos adicionales, puede cambiar el grupo de escalado automático a Capacidad mínima y Capacidad deseada a cero, para apagar las instancias de Trainium. Para hacer una limpieza completa, elimine la pila de CloudFormation para eliminar todos los recursos creados por esta plantilla.

Conclusión

En este post, mostramos cómo utilizar Amazon ECS para implementar tus trabajos de entrenamiento de ML. Creamos una plantilla de CloudFormation para crear el clúster ECS de instancias Trn1, construimos una imagen personalizada de Docker, la subimos a Amazon ECR y ejecutamos el trabajo de entrenamiento de ML en el clúster ECS utilizando una instancia Trainium.

Para obtener más información sobre Neuron y lo que puedes hacer con Trainium, consulta los siguientes recursos:

  • Escalar el entrenamiento de modelos de lenguaje grandes (LLM) con Amazon EC2 Trn1 UltraClusters
  • Escalar el entrenamiento distribuido con AWS Trainium y Amazon EKS
  • Neuron FAQ

We will continue to update Zepes; if you have any questions or suggestions, please contact us!

Share:

Was this article helpful?

93 out of 132 found this helpful

Related articles

    Discover more

    Inteligencia Artificial

    Modelado de temas en producción

    En el artículo anterior, discutimos cómo realizar la Modelización de Temas utilizando ChatGPT y obtuvimos excelentes ...

    Inteligencia Artificial

    Construyendo una Red Neuronal Convolucional con PyTorch

    Esta entrada de blog proporciona un tutorial sobre la construcción de una red neuronal convolucional para la clasific...

    Inteligencia Artificial

    Usando los valores SHAP para la interpretación del modelo en Aprendizaje Automático

    Descubre cómo SHAP puede ayudarte a entender el impacto de las características del modelo en las predicciones.

    Inteligencia Artificial

    Práctica con Aprendizaje Supervisado Regresión Lineal

    Si estás buscando una experiencia práctica con un tutorial detallado pero amigable para principiantes sobre cómo impl...

    Inteligencia Artificial

    Luchando contra los 'hechos' falsos con dos pequeñas palabras

    Los investigadores han desarrollado un método para disminuir las alucinaciones en modelos de lenguaje grandes (LLMs) ...

    Inteligencia Artificial

    Esta revisión de investigación de IA explora la integración de imágenes satelitales y aprendizaje profundo para medir la pobreza basada en activos.

    Investigadores de la Universidad de Lund y la Universidad de Halmstad llevaron a cabo una revisión sobre la inteligen...