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 unas carpetas en OBS para almacenar la muestra de conjunto de datos y el código de entrenamiento. Tabla 1 enumera las carpetas que se van a crear. En el ejemplo, el nombre del bucket y los nombres de las carpetas junto con los nombres reales.

Para obtener más información sobre cómo crear un bucket de OBS y una carpeta, véase 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 de Linux x86_64 que ejecute Ubuntu 18.04. Un ECS o su PC local servirán.

Para obtener más información sobre cómo comprar un ECS, véase 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, se ha instalado Docker. 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
   NOTA:

   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
   NOTA:

   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
   NOTA:

   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. Escriba 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