Ejemplo: creación de una imagen personalizada para entrenamiento (TensorFlow y GPU)

Escenario

En este ejemplo, escriba un Dockerfile para crear una imagen personalizada en un servidor Linux x86_64 que ejecute Ubuntu 18.04.

Cree una imagen contenedora con las siguientes configuraciones y utilícela para crear un trabajo de entrenamiento basado en GPU en ModelArts:

• ubuntu-18.04
• cuda-11.2
• python-3.7.13
• mlnx ofed-5.4
• tensorflow gpu-2.10.0

Procedimiento

Antes de utilizar una imagen personalizada para crear un trabajo de entrenamiento, debe estar familiarizado con Docker y tener experiencia en desarrollo.

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

Requisitos previos

Ha creado una cuenta en Huawei Cloud. 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 Crear un conjunto de datos y cargarlo en OBS

Descargue mnist.npz desde https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz y cárguelo en obs://test-modelarts/tensorflow/data/ en el bucket de OBS.

Paso 3 Preparar el script de entrenamiento y cargarlo en OBS

Obtenga el script de entrenamiento mnist.py y cárguelo en obs://test-modelarts/tensorflow/code/ en el bucket de OBS.

mnist.py es el siguiente:

import argparse
import tensorflow as tf

parser = argparse.ArgumentParser(description='TensorFlow quick start')
parser.add_argument('--data_url', type=str, default="./Data", help='path where the dataset is saved')
args = parser.parse_args()

mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data(args.data_url)
x_train, x_test = x_train / 255.0, x_test / 255.0

model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10)
])

loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

model.compile(optimizer='adam',
              loss=loss_fn,
              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=5)

Paso 4 Preparar un servidor

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 5 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
• mlnx ofed-5.4
• mindspore gpu-1.8.1

A continuación se describe cómo crear una imagen personalizada escribiendo un Dockerfile.

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 detalles sobre cómo instalar Docker, consulte los documentos oficiales de Docker. Ejecute los siguientes comandos para instalar 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. Verifique la versión del motor de Docker. Ejecute el siguiente comando:

   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

   

   Para obtener pip.conf, acceda a Huawei Mirrors en https://mirrors.huaweicloud.com/home y busque pypi.

5. Descargue tensorflow_gpu-2.10.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.

   Descargue tensorflow_gpu-2.10.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl desde https://pypi.org/project/tensorflow-gpu/2.10.0/#files.

6. Descargue el archivo de instalación de Miniconda3.

   Descargue el archivo de instalación de Miniconda3 py37 4.12.0 (Python 3.7.13) desde https://repo.anaconda.com/miniconda/Miniconda3-py37_4.12.0-Linux-x86_64.sh.

7. 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 server on which the container image is created must access the Internet.
   
   # 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.2.2-cudnn8-runtime-ubuntu18.04 AS builder
   
   # The default user of the base container image is root.
   # USER root
   
   # Use the PyPI configuration obtained from 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 tensorflow_gpu-2.10.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl /tmp
   
   # https://conda.io/projects/conda/en/latest/user-guide/install/linux.html#installing-on-linux
   # Install Miniconda3 in 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 the TensorFlow .whl file using default Miniconda3 Python environment /home/ma-user/miniconda3/bin/pip.
   RUN cd /tmp && \
       /home/ma-user/miniconda3/bin/pip install --no-cache-dir \
       /tmp/tensorflow_gpu-2.10.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
   
   RUN cd /tmp && \
       /home/ma-user/miniconda3/bin/pip install --no-cache-dir keras==2.10.0
   
   # Create the container image.
   FROM nvidia/cuda:11.2.2-cudnn8-runtime-ubuntu18.04
   
   COPY MLNX_OFED_LINUX-5.4-3.5.8.0-ubuntu18.04-x86_64.tgz /tmp
   
   # Install the vim, cURL, net-tools, and MLNX_OFED tools obtained from 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 && \
       echo > /etc/apt/apt.conf.d/00skip-verify-peer.conf "Acquire { https::Verify-Peer false }" && \
       apt-get update && \
       apt-get install -y vim curl net-tools iputils-ping && \
       # mlnx ofed
       apt-get install -y python libfuse2 dpatch libnl-3-dev autoconf libnl-route-3-dev pciutils libnuma1 libpci3 m4 libelf1 debhelper automake graphviz bison lsof kmod libusb-1.0-0 swig libmnl0 autotools-dev flex chrpath libltdl-dev && \
       cd /tmp && \
       tar -xvf MLNX_OFED_LINUX-5.4-3.5.8.0-ubuntu18.04-x86_64.tgz && \
       MLNX_OFED_LINUX-5.4-3.5.8.0-ubuntu18.04-x86_64/mlnxofedinstall --user-space-only --basic --without-fw-update -q && \
       cd - && \
       rm -rf /tmp/* && \
       apt-get clean && \
       mv /etc/apt/sources.list.bak /etc/apt/sources.list && \
       rm /etc/apt/apt.conf.d/00skip-verify-peer.conf
   
   # Add user ma-user (UID = 1000, GID = 100).
   # A user group whose GID is 100 exists in the base container image. User ma-user can directly run the following command:
   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 default user and working directory of the container image.
   USER ma-user
   WORKDIR /home/ma-user
   
   # Configure the preset environment variables of the container image.
   # Set PYTHONUNBUFFERED to 1 to prevent log loss.
   ENV PATH=/home/ma-user/miniconda3/bin:$PATH \
       LD_LIBRARY_PATH=/usr/local/cuda/lib64:/usr/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH \
       PYTHONUNBUFFERED=1

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

8. Descargue MLNX_OFED_LINUX-5.4-3.5.8.0-ubuntu18.04-x86_64.tgz.

   Vaya a Linux Drivers. En la ficha Download, configure Version en 5.4-3.5.8.0-LTS, OS Distribution Version en Ubuntu 18.04, Architecture en x86_64 y descargue MLNX_OFED_LINUX-5.4-3.5.8.0-ubuntu18.04-x86_64.tgz.

9. Almacene el archivo de instalación de Dockerfile y de Miniconda3 en la carpeta context, que es la siguiente:

   context
   ├── Dockerfile
   ├── MLNX_OFED_LINUX-5.4-3.5.8.0-ubuntu18.04-x86_64.tgz
   ├── Miniconda3-py37_4.12.0-Linux-x86_64.sh
   ├── pip.conf
   └── tensorflow_gpu-2.10.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_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 tensorflow:2.10.0-ofed-cuda11.2:

    1	docker build . -t tensorflow:2.10.0-ofed-cuda11.2

    El siguiente log muestra que se ha creado la imagen.

    Successfully tagged tensorflow:2.10.0-ofed-cuda11.2

Paso 6 Cargar la 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. Etiquete la imagen cargada.

      # Replace the region, domain, as well as organization name deep-learning with the actual values.
      sudo docker tag tensorflow:2.10.0-ofed-cuda11.2 swr.{region-id}.{domain}/deep-learning/tensorflow:2.10.0-ofed-cuda11.2

   2. Ejecute el siguiente comando para subir la imagen:

      # Replace the region, domain, as well as organization name deep-learning with the actual values.
      sudo docker push swr.{region-id}.{domain}/deep-learning/tensorflow:2.10.0-ofed-cuda11.2

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 7 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. Haga clic en Create Training Job. En la página que aparece en pantalla, configure los parámetros y haga clic en Next.
   • Created By: Custom algorithms
   • Boot Mode: Custom images
   • Ruta de la imagen: imagen creada en Paso 5 Crear una imagen personalizada.
   • Code Directory: directorio donde se almacena el archivo de script de inicio en OBS, por ejemplo, obs://test-modelarts/tensorflow/code/. El código de entrenamiento se descarga automáticamente en el directorio ${MA_JOB_DIR}/code del contenedor de entrenamiento. code (personalizable) es el directorio de último nivel de la ruta del OBS.
   • Boot Command: python ${MA_JOB_DIR}/code/mnist.py. code (personalizable) es el directorio de último nivel de la ruta del OBS.
   • Training Input: haga clic en Add Training Input. Escriba data_path como nombre, seleccione la ruta del OBS a mnist.npz. Por ejemplo, obs://test-modelarts/tensorflow/data/mnist.npz y configure Obtained from como Hyperparameters.
   • Resource Pool: seleccione Public resource pools.
   • Resource Type: seleccione GPU.
   • Compute Nodes: Ingrese 1.
   • Persistent Log Saving: habilitado
   • Job Log Path: ruta de OBS a los logs de entrenamiento almacenados, por ejemplo, obs://test-modelarts/mindspore-gpu/log/
4. Confirme las configuraciones del trabajo de entrenamiento y haga clic en Submit.
5. Espere hasta que se cree el trabajo de entrenamiento.

   Después de enviar la solicitud de creación de trabajo, el sistema realizará automáticamente operaciones en el backend, como descargar la imagen del contenedor y el directorio de código y ejecutar el comando de arranque. Un trabajo de entrenamiento requiere un cierto período de tiempo para ejecutarse. La duración oscila entre decenas de minutos y varias horas, dependiendo de la lógica del servicio 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