Exemplo: criar uma imagem personalizada para treinamento (Horovod-PyTorch 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.

Objetivo: crie e instale imagens de contêiner dos seguintes softwares e use as imagens e CPUs/GPUs para treinamento no ModelArts.

• ubuntu-18.04
• cuda-11.1
• python-3.7.13
• mlnx ofed-5.4
• pytorch-1.8.1
• horovod-0.22.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.

1. Pré-requisitos
2. Etapa 1 Criar um bucket e uma pasta do OBS
3. Etapa 2 Preparar o script de treinamento e carregá-lo no OBS
4. Etapa 3 Preparar um servidor
5. Etapa 4 Criar uma imagem personalizada
6. Etapa 5 Carregar a imagem para o SWR
7. Etapa 6 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 sobre como criar um bucket e uma pasta do OBS, consulte Criação de um bucket e Criação de uma pasta.

Verifique se o diretório do OBS que você usa e o ModelArts estão na mesma região.

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

Obtenha scripts de treinamento pytorch_synthetic_benchmark.py e run_mpi.sh e carregue para obs://test-modelarts/horovod/demo-code/ no bucket do OBS.

pytorch_synthetic_benchmark.py é o seguinte:

import argparse
import torch.backends.cudnn as cudnn
import torch.nn.functional as F
import torch.optim as optim
import torch.utils.data.distributed
from torchvision import models
import horovod.torch as hvd
import timeit
import numpy as np

# Benchmark settings
parser = argparse.ArgumentParser(description='PyTorch Synthetic Benchmark',
                                 formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--fp16-allreduce', action='store_true', default=False,
                    help='use fp16 compression during allreduce')

parser.add_argument('--model', type=str, default='resnet50',
                    help='model to benchmark')
parser.add_argument('--batch-size', type=int, default=32,
                    help='input batch size')

parser.add_argument('--num-warmup-batches', type=int, default=10,
                    help='number of warm-up batches that don\'t count towards benchmark')
parser.add_argument('--num-batches-per-iter', type=int, default=10,
                    help='number of batches per benchmark iteration')
parser.add_argument('--num-iters', type=int, default=10,
                    help='number of benchmark iterations')

parser.add_argument('--no-cuda', action='store_true', default=False,
                    help='disables CUDA training')

parser.add_argument('--use-adasum', action='store_true', default=False,
                    help='use adasum algorithm to do reduction')

args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()

hvd.init()

if args.cuda:
    # Horovod: pin GPU to local rank.
    torch.cuda.set_device(hvd.local_rank())

cudnn.benchmark = True

# Set up standard model.
model = getattr(models, args.model)()

# By default, Adasum doesn't need scaling up learning rate.
lr_scaler = hvd.size() if not args.use_adasum else 1

if args.cuda:
    # Move model to GPU.
    model.cuda()
    # If using GPU Adasum allreduce, scale learning rate by local_size.
    if args.use_adasum and hvd.nccl_built():
        lr_scaler = hvd.local_size()

optimizer = optim.SGD(model.parameters(), lr=0.01 * lr_scaler)

# Horovod: (optional) compression algorithm.
compression = hvd.Compression.fp16 if args.fp16_allreduce else hvd.Compression.none

# Horovod: wrap optimizer with DistributedOptimizer.
optimizer = hvd.DistributedOptimizer(optimizer,
                                     named_parameters=model.named_parameters(),
                                     compression=compression,
                                     op=hvd.Adasum if args.use_adasum else hvd.Average)

# Horovod: broadcast parameters & optimizer state.
hvd.broadcast_parameters(model.state_dict(), root_rank=0)
hvd.broadcast_optimizer_state(optimizer, root_rank=0)

# Set up fixed fake data
data = torch.randn(args.batch_size, 3, 224, 224)
target = torch.LongTensor(args.batch_size).random_() % 1000
if args.cuda:
    data, target = data.cuda(), target.cuda()


def benchmark_step():
    optimizer.zero_grad()
    output = model(data)
    loss = F.cross_entropy(output, target)
    loss.backward()
    optimizer.step()


def log(s, nl=True):
    if hvd.rank() != 0:
        return
    print(s, end='\n' if nl else '')


log('Model: %s' % args.model)
log('Batch size: %d' % args.batch_size)
device = 'GPU' if args.cuda else 'CPU'
log('Number of %ss: %d' % (device, hvd.size()))

# Warm-up
log('Running warmup...')
timeit.timeit(benchmark_step, number=args.num_warmup_batches)

# Benchmark
log('Running benchmark...')
img_secs = []
for x in range(args.num_iters):
    time = timeit.timeit(benchmark_step, number=args.num_batches_per_iter)
    img_sec = args.batch_size * args.num_batches_per_iter / time
    log('Iter #%d: %.1f img/sec per %s' % (x, img_sec, device))
    img_secs.append(img_sec)

# Results
img_sec_mean = np.mean(img_secs)
img_sec_conf = 1.96 * np.std(img_secs)
log('Img/sec per %s: %.1f +-%.1f' % (device, img_sec_mean, img_sec_conf))
log('Total img/sec on %d %s(s): %.1f +-%.1f' %
    (hvd.size(), device, hvd.size() * img_sec_mean, hvd.size() * img_sec_conf))

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

Etapa 3 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 4 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
• pytorch-1.8.1
• horovod-0.22.1

A seguir, descrevemos como criar uma imagem personalizada gravando um Dockerfile.

1. Instale o Docker.

   O seguinte usa o sistema operacional 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 os seguintes comandos para instalar o Docker:

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

   Se o comando docker images é 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, vá para Huawei Mirrors em https://mirrors.huaweicloud.com/home e procure pypi.

5. Baixe o arquivo de código-fonte do Horovod.

   Baixe horovod-0.22.1.tar.gz de https://pypi.org/project/horovod/0.22.1/#files.

6. Baixe os arquivos torch*.whl.

   Baixe os seguintes arquivos .whl de: 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
   

   O código de URL do sinal de mais (+) é %2B. Ao pesquisar arquivos nos sites anteriores, substitua o sinal de mais (+) no nome do arquivo por %2B, por exemplo, torch-1.8.1%2Bcu111-cp37-cp37m-linux_x86_64.whl.

7. Baixe o arquivo de instalação do Miniconda3.

   Baixe o arquivo de instalação do Miniconda3 py37 4.12.0 (Python 3.7.13) de https://repo.anaconda.com/miniconda/Miniconda3-py37_4.12.0-Linux-x86_64.sh.

8. 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
   
   # Install CMake 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 build-essential cmake g++-7 && \
       apt-get clean && \
       mv /etc/apt/sources.list.bak /etc/apt/sources.list && \
       rm /etc/apt/apt.conf.d/00skip-verify-peer.conf
   
   # 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 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
   COPY openmpi-3.0.0-bin.tar.gz /tmp
   COPY horovod-0.22.1.tar.gz /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 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
   RUN cd /usr/local && \
       tar -zxf /tmp/openmpi-3.0.0-bin.tar.gz && \
       ldconfig && \
       mpirun --version
   
   # Environment variables required for building Horovod with PyTorch
   ENV HOROVOD_NCCL_INCLUDE=/usr/include \
       HOROVOD_NCCL_LIB=/usr/lib/x86_64-linux-gnu \
       HOROVOD_MPICXX_SHOW="/usr/local/openmpi/bin/mpicxx -show" \
       HOROVOD_GPU_OPERATIONS=NCCL \
       HOROVOD_WITH_PYTORCH=1
   
   # Install the .whl files 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/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
   
   # Build and install horovod-0.22.1.tar.gz 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/horovod-0.22.1.tar.gz
   
   # Create the container image.
   FROM nvidia/cuda:11.1.1-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 \
       PYTHONUNBUFFERED=1

   Para obter detalhes sobre como gravar um Dockerfile, consulte os documentos oficiais do Docker.

9. Baixe o pacote de instalação do MLNX_OFED.

   Vá para Linux Drivers. Na guia Download, escolha os pacotes de instalação em Current Versions e Archive Versions. Neste exemplo, escolha Archive Versions, defina Version como 5.4-3.5.8.0-LTS, OS Distribution para Ubuntu, OS Distribution Version para Ubuntu 18.04, Architecture como x86_64 e baixe o pacote de instalação MLNX_OFED_LINUX-5.4-3.5.8.0-ubuntu18.04-x86_64.tgz.

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

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

11. Armazene o arquivo de fonte pip, o arquivo torch*.whl e o arquivo de instalação 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
    ├── horovod-0.22.1.tar.gz
    ├── openmpi-3.0.0-bin.tar.gz
    ├── 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

12. 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 horovod-pytorch:0.22.1-1.8.1-ofed-cuda11.1:

    1	docker build . -t horovod-pytorch:0.22.1-1.8.1-ofed-cuda11.1

    O log a seguir mostra que a imagem foi criada.

    Successfully tagged horovod-pytorch:0.22.1-1.8.1-ofed-cuda11.1

Etapa 5 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 horovod-pytorch:0.22.1-1.8.1-ofed-cuda11.1 swr.{region-id}.{domain}/deep-learning/horovod-pytorch:0.22.1-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/horovod-pytorch:0.22.1-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 6 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 5 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/pytorch/demo-code/. O código de treinamento é baixado automaticamente para o diretório ${MA_JOB_DIR}/demo-code do contêiner de treinamento. demo-code (personalizável) é o diretório de último nível do caminho do OBS.
   • Boot Command: bash ${MA_JOB_DIR}/demo-code/run_mpi.sh python ${MA_JOB_DIR}/demo-code/pytorch_synthetic_benchmark.py. demo-code (personalizável) é o diretório de último nível do caminho do OBS.
   • 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/pytorch/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)