Ejemplo: creación de una imagen personalizada para entrenamiento (MindSpore 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.1
• python-3.7.13
• mlnx ofed-5.4
• mindspore gpu-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.

• Requisitos previos
• Paso 1 Crear un bucket de OBS y una carpeta
• Paso 2 Crear un conjunto de datos y cargarlo en OBS
• Paso 3 Preparar el script de entrenamiento y cargarlo en OBS
• Paso 4 Preparar un servidor
• Paso 5 Crear una imagen personalizada
• Paso 6 Cargar la imagen en SWR
• 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 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, véase Creación de un bucket y Creación de una carpeta.

Asegúrese de que OBS y ModelArts se encuentren en la misma región.

Paso 2 Crear un conjunto de datos y cargarlo en OBS

Vaya a http://www.cs.toronto.edu/~kriz/cifar.html, descargue el paquete CIFAR-10 binary version (suitable for C programs), descomprímalo y cargue los datos de decomposición en el directorio obs://test-modelarts/mindspore-gpu/cifar-10-batches-bin/ del bucket del OBS.

Paso 3 Preparar el script de entrenamiento y cargarlo en OBS

Obtenga el archivo de ResNet y el script run_mpi.sh y cárguelos en obs://test-modelarts/mindspore-gpu/ResNet/ en el bucket de OBS.

Descargue el archivo de ResNet desde https://gitee.com/mindspore/models/tree/r1.8/official/cv/resnet.

run_mpi.sh es el siguiente:

#!/bin/bash
MY_HOME=/home/ma-user

MY_SSHD_PORT=${MY_SSHD_PORT:-"36666"}

MY_MPI_BTL_TCP_IF=${MY_MPI_BTL_TCP_IF:-"eth0,bond0"}

MY_TASK_INDEX=${MA_TASK_INDEX:-${VC_TASK_INDEX:-${VK_TASK_INDEX}}}

MY_MPI_SLOTS=${MY_MPI_SLOTS:-"${MA_NUM_GPUS}"}

MY_MPI_TUNE_FILE="${MY_HOME}/env_for_user_process"

if [ -z ${MY_MPI_SLOTS} ]; then
    echo "[run_mpi] MY_MPI_SLOTS is empty, set it be 1"
    MY_MPI_SLOTS="1"
fi

printf "MY_HOME: ${MY_HOME}\nMY_SSHD_PORT: ${MY_SSHD_PORT}\nMY_MPI_BTL_TCP_IF: ${MY_MPI_BTL_TCP_IF}\nMY_TASK_INDEX: ${MY_TASK_INDEX}\nMY_MPI_SLOTS: ${MY_MPI_SLOTS}\n"

env | grep -E '^MA_|^SHARED_|^S3_|^PATH|^VC_WORKER_|^SCC|^CRED' | grep -v '=$' > ${MY_MPI_TUNE_FILE}
# add -x to each line
sed -i 's/^/-x /' ${MY_MPI_TUNE_FILE}

sed -i "s|{{MY_SSHD_PORT}}|${MY_SSHD_PORT}|g" ${MY_HOME}/etc/ssh/sshd_config

# start sshd service
bash -c "$(which sshd) -f ${MY_HOME}/etc/ssh/sshd_config"

# confirm the sshd is up
netstat -anp | grep LIS | grep ${MY_SSHD_PORT}

if [ $MY_TASK_INDEX -eq 0 ]; then
    # generate the hostfile of mpi
    for ((i=0; i<$MA_NUM_HOSTS; i++))
    do
        eval hostname=${MA_VJ_NAME}-${MA_TASK_NAME}-${i}.${MA_VJ_NAME}
        echo "[run_mpi] hostname: ${hostname}"

        ip=""
        while [ -z "$ip" ]; do
            ip=$(ping -c 1 ${hostname} | grep "PING" | sed -E 's/PING .* .([0-9.]+). .*/\1/g')
            sleep 1
        done
        echo "[run_mpi] resolved ip: ${ip}"

        # test the sshd is up
        while :
        do
            if [ cat < /dev/null >/dev/tcp/${ip}/${MY_SSHD_PORT} ]; then
                break
            fi
            sleep 1
        done

        echo "[run_mpi] the sshd of ip ${ip} is up"

        echo "${ip} slots=$MY_MPI_SLOTS" >> ${MY_HOME}/hostfile
    done

    printf "[run_mpi] hostfile:\n`cat ${MY_HOME}/hostfile`\n"
fi

RET_CODE=0

if [ $MY_TASK_INDEX -eq 0 ]; then

    echo "[run_mpi] start exec command time: "$(date +"%Y-%m-%d-%H:%M:%S")

    np=$(( ${MA_NUM_HOSTS} * ${MY_MPI_SLOTS} ))

    echo "[run_mpi] command: mpirun -np ${np} -hostfile ${MY_HOME}/hostfile -mca plm_rsh_args \"-p ${MY_SSHD_PORT}\" -tune ${MY_MPI_TUNE_FILE} ... $@"

    # execute mpirun at worker-0
    # mpirun
    mpirun \
        -np ${np} \
        -hostfile ${MY_HOME}/hostfile \
        -mca plm_rsh_args "-p ${MY_SSHD_PORT}" \
        -tune ${MY_MPI_TUNE_FILE} \
        -bind-to none -map-by slot \
        -x NCCL_DEBUG=INFO -x NCCL_SOCKET_IFNAME=${MY_MPI_BTL_TCP_IF} -x NCCL_SOCKET_FAMILY=AF_INET \
        -x HOROVOD_MPI_THREADS_DISABLE=1 \
        -x LD_LIBRARY_PATH \
        -mca pml ob1 -mca btl ^openib -mca plm_rsh_no_tree_spawn true \
        "$@"

    RET_CODE=$?

    if [ $RET_CODE -ne 0 ]; then
        echo "[run_mpi] exec command failed, exited with $RET_CODE"
    else
        echo "[run_mpi] exec command successfully, exited with $RET_CODE"
    fi

    # stop 1...N worker by killing the sleep proc
    sed -i '1d' ${MY_HOME}/hostfile
    if [ `cat ${MY_HOME}/hostfile | wc -l` -ne 0 ]; then
        echo "[run_mpi] stop 1 to (N - 1) worker by killing the sleep proc"

        sed -i 's/${MY_MPI_SLOTS}/1/g' ${MY_HOME}/hostfile
        printf "[run_mpi] hostfile:\n`cat ${MY_HOME}/hostfile`\n"

        mpirun \
        --hostfile ${MY_HOME}/hostfile \
        --mca btl_tcp_if_include ${MY_MPI_BTL_TCP_IF} \
        --mca plm_rsh_args "-p ${MY_SSHD_PORT}" \
        -x PATH -x LD_LIBRARY_PATH \
        pkill sleep \
        > /dev/null 2>&1
    fi

    echo "[run_mpi] exit time: "$(date +"%Y-%m-%d-%H:%M:%S")
else
    echo "[run_mpi] the training log is in worker-0"
    sleep 365d
    echo "[run_mpi] exit time: "$(date +"%Y-%m-%d-%H:%M:%S")
fi

exit $RET_CODE

La carpeta obs://test-modelarts/mindspore-gpu/resnet/ contiene los archivos resnet y run_mpi.sh.

Paso 4 Preparar un servidor

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

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 como ejemplo para describir cómo obtener un paquete de instalación de Docker. Para obtener más detalles sobre cómo instalar Docker, consulte los documentos oficiales de Docker. Ejecute el siguiente comando para instalar Docker:

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

   Si se puede ejecutar 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, pase a Huawei Mirrors https://mirrors.huaweicloud.com/home y busque pypi.

5. Descargue mindspore_gpu-1.8.1-cp37-cp37m-linux_x86_64.whl desde https://ms-release.obs.cn-north-4.myhuaweicloud.com/1.8.1/MindSpore/gpu/x86_64/cuda-11.1/mindspore_gpu-1.8.1-cp37-cp37m-linux_x86_64.whl.
6. Descargue el archivo de instalación de Miniconda3.

   Descargue Miniconda3-py37_4.12.0-Linux-x86_64.sh desde https://repo.anaconda.com/miniconda/Miniconda3-py37_4.12.0-Linux-x86_64.sh.

7. 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 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.1.1-devel-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 mindspore_gpu-1.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 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 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/mindspore_gpu-1.8.1-cp37-cp37m-linux_x86_64.whl \
       easydict PyYAML
   
   # Create the container image.
   FROM nvidia/cuda:11.1.1-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, MLNX_OFED, and SSH 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 libfile-find-rule-perl-perl \
       openssh-client openssh-server && \
       ssh -V && \
       mkdir -p /run/sshd && \
       # 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
   
   # Install the Open MPI 3.0.0 file obtained from Horovod v0.22.1.
   # https://github.com/horovod/horovod/blob/v0.22.1/docker/horovod/Dockerfile
   # https://github.com/horovod/horovod/files/1596799/openmpi-3.0.0-bin.tar.gz
   COPY openmpi-3.0.0-bin.tar.gz /tmp
   RUN cd /usr/local && \
       tar -zxf /tmp/openmpi-3.0.0-bin.tar.gz && \
       ldconfig && \
       mpirun --version
   
   # Add user ma-user (UID = 1000, GID = 100).
   # A user group whose GID is 100 exists in the basic 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 sshd to support SSH password-free login.
   RUN MA_HOME=/home/ma-user && \
       # setup sshd dir
       mkdir -p ${MA_HOME}/etc && \
       ssh-keygen -f ${MA_HOME}/etc/ssh_host_rsa_key -N '' -t rsa  && \
       mkdir -p ${MA_HOME}/etc/ssh ${MA_HOME}/var/run  && \
       # setup sshd config (listen at {{MY_SSHD_PORT}} port)
       echo "Port {{MY_SSHD_PORT}}\n\
   HostKey ${MA_HOME}/etc/ssh_host_rsa_key\n\
   AuthorizedKeysFile ${MA_HOME}/.ssh/authorized_keys\n\
   PidFile ${MA_HOME}/var/run/sshd.pid\n\
   StrictModes no\n\
   UsePAM no" > ${MA_HOME}/etc/ssh/sshd_config && \
       # generate ssh key
       ssh-keygen -t rsa -f ${MA_HOME}/.ssh/id_rsa -P '' && \
       cat ${MA_HOME}/.ssh/id_rsa.pub >> ${MA_HOME}/.ssh/authorized_keys && \
       # disable ssh host key checking for all hosts
       echo "Host *\n\
     StrictHostKeyChecking no" > ${MA_HOME}/.ssh/config
   
   # 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 https://network.nvidia.com/products/infiniband-drivers/linux/mlnx_ofed/ y haga clic en Download, configure Version en 5.4-3.5.8.0-LTS, OSDistributionVersion en Ubuntu 18.04 y Architecture en x86_64 y descargue MLNX_OFED_LINUX-5.4-3.5.8.0-ubuntu18.04-x86_64.tgz.

9. Descarga de openmpi-3.0.0-bin.tar.gz.

   Descargue openmpi-3.0.0-bin.tar.gz desde https://github.com/horovod/horovod/files/1596799/openmpi-3.0.0-bin.tar.gz.

10. 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
    ├── mindspore_gpu-1.8.1-cp37-cp37m-linux_x86_64.whl
    ├── openmpi-3.0.0-bin.tar.gz
    └── pip.conf

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

    1	docker build . -t mindspore:1.8.1-ofed-cuda11.1

    El siguiente log muestra que se ha creado la imagen.

    Successfully tagged mindspore:1.8.1-ofed-cuda11.1

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 mindspore:1.8.1-ofed-cuda11.1 swr.{region-id}.{domain}/deep-learning/mindspore:1.8.1-ofed-cuda11.1

   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/mindspore:1.8.1-ofed-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 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 información, véase Configuración de la autorización de la delegación. Si ha sido autorizado mediante claves de acceso, borre la autorización y configure la autorización de la 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: Algoritmos personalizados
   • Boot Mode: Imágenes personalizadas
   • Image path: imagen creada en Paso 6 Cargar la imagen en SWR.
   • Code Directory: directorio donde se almacena el archivo de script de arranque en OBS, por ejemplo, obs://test-modelarts/mindspore-gpu/resnet/. El código de entrenamiento se descarga automáticamente en el directorio ${MA_JOB_DIR}/resnet del contenedor de entrenamiento. resnet (personalizable) es el directorio de último nivel de la ruta de OBS.
   • Boot Command: bash ${MA_JOB_DIR}/resnet/run_mpi.sh python ${MA_JOB_DIR}/resnet/train.py. resnet (personalizable) es el directorio de último nivel de la ruta de OBS.
   • Training Input: haga clic en Add Training Input. Escriba data_path como nombre, seleccione la ruta de OBS al conjunto de datos de destino, por ejemplo, obs://test-modelarts/mindspore-gpu/cifar-10-batches-bin/ y configure Obtained from como Hyperparameters.
   • Training Output: haga clic en Add Training Output. Escriba output_path como nombre, seleccione una ruta de OBS para almacenar salidas de entrenamiento, por ejemplo obs://test-modelarts/mindspore-gpu/output/ y configure Obtained from como Hyperparameters y Predownload como No.
   • Hyperparameters: haga clic en Add Hyperparameter y agregue los siguientes hiperparámetros:
     • run_distribute=True
     • device_num=1 (Set this parameter based on the number of GPUs in the instance flavors.)
     • device_target=GPU
     • epoch_size=2
   • Environment Variable: Haga clic en Add Environment Variable y agregue la variable de entorno MY_SSHD_PORT=38888.
   • Resource Pool: seleccione Public resource pools.
   • Resource Type: seleccione GPU.
   • Compute Nodes: 1 o 2
   • 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 (un nodo de cómputo)
   
   Figura 6 Ejecutar logs de trabajos de entrenamiento con especificaciones de GPU (dos nodos de cómputo)