Ejemplo: creación de una imagen personalizada para el entrenamiento (PyTorch + CPU/GPU)

Escenarios

En este ejemplo, cree una imagen personalizada escribiendo un Dockerfile en un host de Linux x86_64 que ejecute el sistema operativo Ubuntu 18.04.

Objetivo: crear e instalar imágenes de contenedor del siguiente software y utilizar las imágenes y las CPU/GPU para entrenamiento en ModelArts.

• ubuntu-18.04
• cuda-11.1
• python-3.7.13
• pytorch-1.8.1

Procedimiento

Antes de utilizar una imagen personalizada para crear un trabajo de entrenamiento, debe estar familiarizado con Docker y tener experiencia en desarrollo. El procedimiento detallado es el siguiente:

1. Requisitos previos
2. Paso 1 Crear un bucket de OBS y una carpeta
3. Paso 2 Preparar el script de entrenamiento y cargarlo en OBS
4. Paso 3 Preparar un host
5. Paso 4 Crear una imagen personalizada
6. Paso 5 Cargar una imagen en SWR
7. Paso 6 Crear un trabajo de entrenamiento en ModelArts

Requisitos previos

Ha creado un ID de Huawei y ha habilitado los servicios en Huawei Cloud. Además, la cuenta no está en mora ni congelada.

Paso 1 Crear un bucket de OBS y una carpeta

Cree un bucket y una carpeta en OBS para almacenar la muestra de conjunto de datos y el código de entrenamiento. Tabla 1 enumera las carpetas que se crearán. En el ejemplo, el nombre del bucket y los nombres de las carpetas junto con los nombres reales.

Para obtener detalles sobre cómo crear un bucket de OBS y una carpeta, consulte Creación de un bucket y Creación de una carpeta.

Asegúrese de que el directorio de OBS que utiliza y ModelArts están en la misma región.

Paso 2 Preparar el script de entrenamiento y cargarlo en OBS

Prepare el script de entrenamiento pytorch-verification.py y cárguelo en la carpeta obs://test-modelarts/pytorch/demo-code/ del bucket del OBS.

El archivo pytorch-verification.py contiene la siguiente información:

import torch
import torch.nn as nn

x = torch.randn(5, 3)
print(x)

available_dev = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
y = torch.randn(5, 3).to(available_dev)
print(y)

Paso 3 Preparar un host

Obtener un servidor Linux x86_64 que ejecute Ubuntu 18.04. Un ECS o su PC local servirán.

Para obtener detalles sobre cómo comprar un ECS, consulte Compra e inicio de sesión en un ECS de Linux. Seleccione una imagen pública. Se recomienda una imagen de Ubuntu 18.04.

Figura 1 Creación de un ECS con una imagen pública (x86)

Paso 4 Crear una imagen personalizada

Cree una imagen de contenedor con las siguientes configuraciones y utilice la imagen para crear un trabajo de entrenamiento en ModelArts:

• ubuntu-18.04
• cuda-11.1
• python-3.7.13
• pytorch-1.8.1

En esta sección se describe cómo escribir un Dockerfile para crear una imagen personalizada.

1. Instale Docker.

   A continuación se utiliza Linux x86_64 OS como ejemplo para describir cómo obtener el paquete de instalación de Docker. Para obtener más detalles sobre cómo instalar Docker, consulte los documentos oficiales de Docker.

   curl -fsSL get.docker.com -o get-docker.sh
   sh get-docker.sh

   Si se ejecuta el comando docker images, Docker se ha instalado. Si es así, omita este paso.

2. Ejecute el siguiente comando para verificar la versión del Docker Engine:

   docker version | grep -A 1 Engine

   Se muestra la siguiente información:

   ...
   Engine:
     Version:          18.09.0

   

   Utilice el motor de Docker de la versión anterior o posterior para crear una imagen personalizada.

3. Cree una carpeta denominada context.

   mkdir -p context

4. Obtenga el archivo pip.conf. En este ejemplo, se utiliza el origen pip proporcionado por Huawei Mirrors, que es el siguiente:

   [global]
   index-url = https://repo.huaweicloud.com/repository/pypi/simple
   trusted-host = repo.huaweicloud.com
   timeout = 120

   

   En Huawei Mirrors https://mirrors.huaweicloud.com/home, busque pypi para obtener el archivo pip.conf.

5. Descargue los siguientes archivos .whl desde https://download.pytorch.org/whl/torch_stable.html:
   • torch-1.8.1+cu111-cp37-cp37m-linux_x86_64.whl
   • torchaudio-0.8.1-cp37-cp37m-linux_x86_64.whl
   • torchvision-0.9.1+cu111-cp37-cp37m-linux_x86_64.whl
   

   El código de URL del símbolo + es %2B. Cuando busque un archivo en el sitio web anterior, reemplace el símbolo + en el nombre del archivo por %2B.

   Por ejemplo, torch-1.8.1%2Bcu111-cp37-cp37m-linux_x86_64.whl.

6. Descargue el archivo de instalación Miniconda3-py37_4.12.0-Linux-x86_64.sh (Python 3.7.13) desde https://repo.anaconda.com/miniconda/Miniconda3-py37_4.12.0-Linux-x86_64.sh.
7. Almacene el archivo de origen de pip, el archivo torch*.whl y el archivo de instalación de Miniconda3 en la carpeta context, que es la siguiente:

   context
   ├── Miniconda3-py37_4.12.0-Linux-x86_64.sh
   ├── pip.conf
   ├── torch-1.8.1+cu111-cp37-cp37m-linux_x86_64.whl
   ├── torchaudio-0.8.1-cp37-cp37m-linux_x86_64.whl
   └── torchvision-0.9.1+cu111-cp37-cp37m-linux_x86_64.whl

8. Escribe la imagen del contenedor Dockerfile.
   Cree un archivo vacío denominado Dockerfile en la carpeta context y copie el siguiente contenido en el archivo:

   # The host must be connected to the public network for creating a container image.
   
   # Base container image at https://github.com/NVIDIA/nvidia-docker/wiki/CUDA
   # 
   # https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
   # require Docker Engine >= 17.05
   #
   # builder stage
   FROM nvidia/cuda:11.1.1-runtime-ubuntu18.04 AS builder
   
   # The default user of the base container image is root.
   # USER root
   
   # Use the PyPI configuration provided by Huawei Mirrors.
   RUN mkdir -p /root/.pip/
   COPY pip.conf /root/.pip/pip.conf
   
   # Copy the installation files to the /tmp directory in the base container image.
   COPY Miniconda3-py37_4.12.0-Linux-x86_64.sh /tmp
   COPY torch-1.8.1+cu111-cp37-cp37m-linux_x86_64.whl /tmp
   COPY torchvision-0.9.1+cu111-cp37-cp37m-linux_x86_64.whl /tmp
   COPY torchaudio-0.8.1-cp37-cp37m-linux_x86_64.whl /tmp
   
   # https://conda.io/projects/conda/en/latest/user-guide/install/linux.html#installing-on-linux
   # Install Miniconda3 to the /home/ma-user/miniconda3 directory of the base container image.
   RUN bash /tmp/Miniconda3-py37_4.12.0-Linux-x86_64.sh -b -p /home/ma-user/miniconda3
   
   # Install torch*.whl using the default Miniconda3 Python environment in /home/ma-user/miniconda3/bin/pip.
   RUN cd /tmp && \
       /home/ma-user/miniconda3/bin/pip install --no-cache-dir \
       /tmp/torch-1.8.1+cu111-cp37-cp37m-linux_x86_64.whl \
       /tmp/torchvision-0.9.1+cu111-cp37-cp37m-linux_x86_64.whl \
       /tmp/torchaudio-0.8.1-cp37-cp37m-linux_x86_64.whl
   
   # Create the final container image.
   FROM nvidia/cuda:11.1.1-runtime-ubuntu18.04
   
   # Install vim and cURL in Huawei Mirrors.
   RUN cp -a /etc/apt/sources.list /etc/apt/sources.list.bak && \
       sed -i "s@http://.*archive.ubuntu.com@http://repo.huaweicloud.com@g" /etc/apt/sources.list && \
       sed -i "s@http://.*security.ubuntu.com@http://repo.huaweicloud.com@g" /etc/apt/sources.list && \
       apt-get update && \
       apt-get install -y vim curl && \
       apt-get clean && \
       mv /etc/apt/sources.list.bak /etc/apt/sources.list
   
   # Add user ma-user (UID = 1000, GID = 100).
   # A user group whose GID is 100 of the base container image exists. User ma-user can directly use it.
   RUN useradd -m -d /home/ma-user -s /bin/bash -g 100 -u 1000 ma-user
   
   # Copy the /home/ma-user/miniconda3 directory from the builder stage to the directory with the same name in the current container image.
   COPY --chown=ma-user:100 --from=builder /home/ma-user/miniconda3 /home/ma-user/miniconda3
   
   # Configure the preset environment variables of the container image.
   # Set PYTHONUNBUFFERED to 1 to avoid log loss.
   ENV PATH=$PATH:/home/ma-user/miniconda3/bin \
       PYTHONUNBUFFERED=1
   
   # Set the default user and working directory of the container image.
   USER ma-user
   WORKDIR /home/ma-user

   Para obtener detalles sobre cómo escribir un Dockerfile, consulte los documentos oficiales de Docker.

9. Verifique que se haya creado el Dockerfile. A continuación se muestra la carpeta context:

   context
   ├── Dockerfile
   ├── Miniconda3-py37_4.12.0-Linux-x86_64.sh
   ├── pip.conf
   ├── torch-1.8.1+cu111-cp37-cp37m-linux_x86_64.whl
   ├── torchaudio-0.8.1-cp37-cp37m-linux_x86_64.whl
   └── torchvision-0.9.1+cu111-cp37-cp37m-linux_x86_64.whl

10. Cree la imagen de contenedor. Ejecute el siguiente comando en el directorio donde se almacena el Dockerfile para crear la imagen de contenedor pytorch:1.8.1-cuda11.1:

    1	docker build . -t pytorch:1.8.1-cuda11.1

    La siguiente información de log mostrada durante la creación de la imagen indica que la imagen se ha creado.

    Successfully tagged pytorch:1.8.1-cuda11.1

Paso 5 Cargar una imagen en SWR

1. Inicie sesión en la consola de SWR y seleccione la región de destino.
   Figura 2 Consola de SWR
   
2. Haga clic en Create Organization en la esquina superior derecha e introduzca un nombre de organización para crear una organización. Personalice el nombre de la organización. Sustituya el nombre de la organización deep-learning en comandos posteriores con el nombre real de la organización.
   Figura 3 Creación de una organización
   
3. Haga clic en Generate Login Command en la esquina superior derecha para obtener un comando de acceso.
   Figura 4 Comando de acceso
   
4. Inicie sesión en el entorno local como usuario root e ingrese el comando de inicio de sesión.
5. Cargue la imagen en SWR.
   1. Ejecute el siguiente comando para etiquetar la imagen cargada:

      #Replace the region and domain information with the actual values, and replace the organization name deep-learning with your custom value.
      sudo docker tag pytorch:1.8.1-cuda11.1 swr.{region-id}.{domain}/deep-learning/pytorch:1.8.1-cuda11.1

   2. Ejecute el siguiente comando para subir la imagen:

      #Replace the region and domain information with the actual values, and replace the organization name deep-learning with your custom value.
      sudo docker push swr.{region-id}.{domain}/deep-learning/pytorch:1.8.1-cuda11.1

6. Después de cargar la imagen, elija My Images en el panel de navegación a la izquierda de la consola de SWR para ver las imágenes personalizadas cargadas.

Paso 6 Crear un trabajo de entrenamiento en ModelArts

1. Inicie sesión en la consola de gestión de ModelArts y compruebe si se ha configurado la autorización de acceso para su cuenta. Para obtener más detalles, consulte Configuración de autorización de delegación. Si se le ha autorizado mediante claves de acceso, borre la autorización y configure la autorización de delegación.
2. En el panel de navegación, seleccione Training Management > Training Jobs. La lista de trabajos de entrenamiento se muestra de forma predeterminada.
3. En la página Create Training Job, configure los parámetros necesarios y haga clic en Submit.
   • Created By: Custom algorithms
   • Boot Mode: Custom images
   • Ruta de la imagen: imagen creada en Paso 5 Cargar una imagen en SWR.
   • Code Directory: directorio donde se almacena el archivo de script de arranque en OBS. Por ejemplo, obs://test-modelarts/pytorch/demo-code/. El código de entrenamiento se descarga automáticamente en el directorio ${MA_JOB_DIR}/demo-code del contenedor de entrenamiento. demo-code (personalizable) es el directorio de último nivel de la ruta del OBS.
   • Boot Command: /home/ma-user/miniconda3/bin/python ${MA_JOB_DIR}/demo-code/pytorch-verification.py. demo-code (personalizable) es el directorio de último nivel de la ruta del OBS.
   • Resource Pool: Public resource pools
   • Resource Type: seleccione CPU o GPU.
   • Persistent Log Saving: habilitado
   • Job Log Path: Establezca este parámetro en la ruta de OBS para almacenar logs de entrenamiento, por ejemplo, obs://test-modelarts/pytorch/log/.
4. Verifique los parámetros del trabajo de entrenamiento y haga clic en Submit.
5. Espere hasta que finalice el trabajo de entrenamiento.

   Después de crear un trabajo de entrenamiento, las operaciones como la descarga de imágenes de contenedor, la descarga de directorios de código y la ejecución de comandos de arranque se realizan automáticamente en el backend. Por lo general, la duración del entrenamiento oscila entre decenas de minutos y varias horas, dependiendo del procedimiento de entrenamiento y de los recursos seleccionados. Una vez ejecutado el trabajo de entrenamiento, se muestra un log similar al siguiente.

   Figura 5 Ejecutar logs de trabajos de entrenamiento con especificaciones de GPU
   
   Figura 6 Run logs of training jobs with CPU specifications