Exemplo: criar uma imagem personalizada para treinamento (MindSpore e GPUs)

Cenário

Neste exemplo, grave um Dockerfile para criar uma imagem personalizada em um servidor Linux x86_64 executando o Ubuntu 18.04.

Crie uma imagem de contêiner com as seguintes configurações e use a imagem para criar um trabalho de treinamento com GPU no ModelArts:

• ubuntu-18.04
• cuda-11.1
• python-3.7.13
• mlnx ofed-5.4
• mindspore gpu-1.8.1

Procedimento

Antes de usar uma imagem personalizada para criar um trabalho de treinamento, você precisa estar familiarizado com o Docker e ter experiência em desenvolvimento.

• Pré-requisitos
• Etapa 1 Criar um bucket e uma pasta do OBS
• Etapa 2 Criar um conjunto de dados e carregá-lo para o OBS
• Etapa 3 Preparar o script de treinamento e carregá-lo no OBS
• Etapa 4 Preparar um servidor
• Etapa 5 Criar uma imagem personalizada
• Etapa 6 Carregar a imagem para o SWR
• Etapa 7 Criar um trabalho de treinamento no ModelArts

Pré-requisitos

Você registrou uma conta da Huawei Cloud. A conta não pode estar em atraso ou congelada.

Etapa 1 Criar um bucket e uma pasta do OBS

Crie um bucket e pastas no OBS para armazenar o conjunto de dados de amostra e o código de treinamento. Tabela 1 lista as pastas a serem criadas. Substitua o nome do bucket e os nomes da pasta no exemplo por nomes reais.

Para obter detalhes, consulte Criação de um bucket e Criação de uma pasta.

Certifique-se de que o OBS e o ModelArts estejam na mesma região.

Etapa 2 Criar um conjunto de dados e carregá-lo para o OBS

Vá para http://www.cs.toronto.edu/~kriz/cifar.html, baixe o pacote CIFAR-10 da versão binária (adequado para programas em C), descomprima-o e faça o upload dos dados descompactados para o diretório obs://test-modelarts/mindspore-gpu/cifar-10-batches-bin/ no bucket do OBS.

Etapa 3 Preparar o script de treinamento e carregá-lo no OBS

Obtenha o arquivo ResNet e o script run_mpi.sh e faça o upload para obs://test-modelarts/mindspore-gpu/resnet/ no bucket do OBS.

Baixe o arquivo ResNet do https://gitee.com/mindspore/models/tree/r1.8/official/cv/resnet.

run_mpi.sh é o seguinte:

#!/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

A pasta obs://test-modelarts/mindspore-gpu/resnet/ contém os arquivos resnet e run_mpi.sh.

Etapa 4 Preparar um servidor

Obtenha um servidor Linux x86_64 executando o Ubuntu 18.04. Um ECS ou seu PC local servirão.

Para obter detalhes sobre como comprar um ECS, consulte Compra e logon em um ECS Linux. Selecione uma imagem pública. Uma imagem do Ubuntu 18.04 é recomendada.

Figura 1 Criar um ECS usando uma imagem pública (x86)

Etapa 5 Criar uma imagem personalizada

Crie uma imagem de contêiner com as seguintes configurações e use a imagem para criar um trabalho de treinamento no ModelArts:

• ubuntu-18.04
• cuda-11.1
• python-3.7.13
• mlnx ofed-5.4
• mindspore gpu-1.8.1

Esta seção descreve como gravar um Dockerfile para criar uma imagem personalizada.

1. Instale o Docker.

   O seguinte usa o Linux x86_64 como um exemplo para descrever como obter um pacote de instalação do Docker. Para obter mais detalhes sobre como instalar o Docker, consulte os documentos oficiais do Docker. Execute o seguinte comando para instalar o Docker:

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

   Se o comando docker images puder ser executado, o Docker foi instalado. Nesse caso, pule essa etapa.

2. Verifique a versão do mecanismo do Docker. Execute o seguinte comando:

   docker version | grep -A 1 Engine

   As seguintes informações são exibidas:

    Engine:
     Version:          18.09.0

   

   Use o mecanismo Docker da versão anterior ou posterior para criar uma imagem personalizada.

3. Crie uma pasta chamada context.

   mkdir -p context

4. Obtenha o arquivo pip.conf. Neste exemplo, a fonte pip fornecida pelo Huawei Mirrors é usada, que é a seguinte:

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

   

   Para obter pip.conf, mude para Huawei Mirrors https://mirrors.huaweicloud.com/home e procure pypi.

5. Baixe mindspore_gpu-1.8.1-cp37-cp37m-linux_x86_64.whl do 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. Baixe o arquivo de instalação do Miniconda3.

   Baixe Miniconda3-py37_4.12.0-Linux-x86_64.sh de https://repo.anaconda.com/miniconda/Miniconda3-py37_4.12.0-Linux-x86_64.sh.

7. Grave a imagem de contêiner de Dockerfile.
   Crie um arquivo vazio chamado Dockerfile na pasta context e copie o seguinte conteúdo para o arquivo:

   # 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 obter detalhes sobre como gravar um Dockerfile, consulte os documentos oficiais do Docker.

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

   Vá para https://network.nvidia.com/products/infiniband-drivers/linux/mlnx_ofed/, clique em Download, defina Version para 5.4-3.5.8.0-LTS, OSDistributionVersion para Ubuntu 18.04 e Architecture para x86_64 e baixe MLNX_OFED_LINUX-5.4-3.5.8.0-ubuntu18.04-x86_64.tgz.

9. Baixe openmpi-3.0.0-bin.tar.gz.

   Baixe openmpi-3.0.0-bin.tar.gz do https://github.com/horovod/horovod/files/1596799/openmpi-3.0.0-bin.tar.gz.

10. Armazene o arquivo de instalação do Dockerfile e do Miniconda3 na pasta context, que é a seguinte:

    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. Crie a imagem do contêiner. Execute o comando a seguir no diretório em que o Dockerfile está armazenado para criar a imagem de contêiner mindspore:1.8.1-ofed-cuda11.1:

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

    O log a seguir mostra que a imagem foi criada.

    Successfully tagged mindspore:1.8.1-ofed-cuda11.1

Etapa 6 Carregar a imagem para o SWR

1. Faça logon no console do SWR e selecione a região de destino.
   Figura 2 Console do SWR
   
2. Clique em Create Organization no canto superior direito e insira um nome de organização para criar uma organização. Personalize o nome da organização. Substitua o nome da organização deep-learning nos comandos subsequentes pelo nome real da organização.
   Figura 3 Criar uma organização
   
3. Clique em Generate Login Command no canto superior direito para obter um comando de logon.
   Figura 4 Comando de logon
   
4. Efetue logon no ambiente local como o usuário root e digite o comando logon.
5. Carregue a imagem para o SWR.
   1. Marque a imagem carregada.

      # 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. Execute o seguinte comando para carregar a imagem:

      # 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. Depois que a imagem for carregada, escolha My Images no painel de navegação à esquerda do console do SWR para exibir as imagens personalizadas carregadas.

Etapa 7 Criar um trabalho de treinamento no ModelArts

1. Faça logon no console de gerenciamento do ModelArts, verifique se a autorização de acesso foi configurada para sua conta. Para obter detalhes, consulte Configuração da autorização da agência. Se você tiver sido autorizado usando chaves de acesso, limpe a autorização e configure a autorização da agência.
2. No painel de navegação, escolha Training Management > Training Jobs. A lista de trabalhos de treinamento é exibida por padrão.
3. Clique em Create Training Job. Na página exibida, configure os parâmetros e clique em Next.
   • Created By: Custom algorithms
   • Boot Mode: Custom images
   • Image path: imagem criada em Etapa 6 Carregar a imagem para o SWR.
   • Code Directory: diretório onde o arquivo de script de inicialização é armazenado no OBS, por exemplo, obs://test-modelarts/mindspore-gpu/resnet/. O código de treinamento é baixado automaticamente para o diretório ${MA_JOB_DIR}/resnet do contêiner de treinamento. resnet (personalizável) é o diretório de último nível do caminho do OBS.
   • Boot Command: bash ${MA_JOB_DIR}/resnet/run_mpi.sh python ${MA_JOB_DIR}/resnet/train.py. resnet (personalizável) é o diretório de último nível do caminho do OBS.
   • Training Input: clique em Add Training Input. Digite data_path para o nome, selecione o caminho do OBS para o conjunto de dados de destino, por exemplo, obs://test-modelarts/mindspore-gpu/cifar-10-batches-bin/, e defina Obtained from para Hyperparameters.
   • Training Output: clique em Add Training Output. Digite output_path para o nome, selecione um caminho OBS para armazenar saídas de treinamento, por exemplo, obs://test-modelarts/mindspore-gpu/output/, e defina Obtained from para Hyperparameters e Predownload para No.
   • Hyperparameters: clique em Add Hyperparameter e adicione os seguintes hiperparâmetros:
     • run_distribute=True
     • device_num=1 (Defina esse parâmetro com base no número de GPUs nos flavors de instância.)
     • device_target=GPU
     • epoch_size=2
   • Environment Variable: clique em Add Environment Variable e adicione a variável de ambiente MY_SSHD_PORT=38888.
   • Resource Pool: selecione Public resource pools.
   • Resource Type: selecione GPU.
   • Compute Nodes: 1 ou 2
   • Persistent Log Saving: ativado
   • Job Log Path: caminho do OBS para logs de treinamento armazenados, por exemplo, obs://test-modelarts/mindspore-gpu/log/
4. Confirme as configurações do trabalho de treinamento e clique em Submit.
5. Aguarde até que o trabalho de treinamento seja criado.

   Depois que você enviar a solicitação de criação de trabalho, o sistema executará automaticamente operações no back-end, como baixar a imagem do contêiner e o diretório de código e executar o comando de inicialização. Um trabalho de treinamento requer um certo período de tempo para a execução. A duração varia de dezenas de minutos a várias horas, variando dependendo da lógica do serviço e dos recursos selecionados. Depois que o trabalho de treinamento é executado, o log semelhante ao seguinte é emitido.

   Figura 5 Executar logs de trabalhos de treinamento com especificações de GPU (um nó de computação)
   
   Figura 6 Executar logs de trabalhos de treinamento com especificações de GPU (dois nós de computação)