Ejemplo: creación de una imagen personalizada para entrenamiento (Horovod-PyTorch 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.

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
• mlnx ofed-5.4
• pytorch-1.8.1
• horovod-0.22.1

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 Preparar el script de entrenamiento y cargarlo en OBS
4. Paso 3 Preparar un servidor
5. Paso 4 Crear una imagen personalizada
6. Paso 5 Cargar la imagen en SWR
7. Paso 6 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 Preparar el script de entrenamiento y cargarlo en OBS

Obtenga scripts de entrenamiento pytorch_synthetic_benchmark.py y run_mpi.sh y cárguelos a obs://test-modelarts/horovod/demo-code/ en el bucket de OBS.

pytorch_synthetic_benchmark.py es el siguiente:

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

Paso 3 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 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
• mlnx ofed-5.4
• pytorch-1.8.1
• horovod-0.22.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 el archivo de código de Horovod de fuente.

   Descargue horovod-0.22.1.tar.gz desde https://pypi.org/project/horovod/0.22.1/#files.

6. Descargue los archivos torch*.whl.

   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
   

   El código URL del signo más (+) es %2B. Cuando busque archivos en los sitios web anteriores, sustituya el signo más (+) del nombre del archivo por %2B. Por ejemplo, torch-1.8.1%2Bcu111-cp37-cp37m-linux_x86_64.whl.

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

8. 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.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 obtener detalles sobre cómo escribir un Dockerfile, consulte los documentos oficiales de Docker.

9. Descargue el paquete de instalación de MLNX_OFED.

   Vaya a Linux Drivers. En la ficha Download, seleccione los paquetes de instalación de Current Versions y Archive Versions. En este ejemplo, seleccione Archive Versions, configure Version en 5.4-3.5.8.0-LTS, OS Distribution en Ubuntu, OS Distribution Version en Ubuntu 18.04, Architecture en x86_64 y descargue el paquete de instalación MLNX_OFED_LINUX-5.4-3.5.8.0-ubuntu18.04-x86_64.tgz.

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

11. 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
    ├── 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. Cree la imagen de contenedor. Ejecute el siguiente comando en el directorio donde se almacena el Dockerfile para crear la imagen de contenedor 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

    El siguiente log muestra que se ha creado la imagen.

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

Paso 5 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 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. 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/horovod-pytorch:0.22.1-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 6 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 Cargar la imagen en SWR.
   • Code Directory: directorio donde se almacena el archivo de script de arranque en OBS. Por ejemplo, obs://test-modelarts/pytorch/demo-code/. El código de entrenamiento se descarga automáticamente en el directorio ${MA_JOB_DIR}/demo-code del contenedor de entrenamiento. demo-code (personalizable) es el directorio de último nivel de la ruta del OBS.
   • Boot Command: bash ${MA_JOB_DIR}/demo-code/run_mpi.sh python ${MA_JOB_DIR}/demo-code/pytorch_synthetic_benchmark.py. demo-code (personalizable) es el directorio de último nivel de la ruta del OBS.
   • 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 del OBS a los logs de entrenamiento almacenados, por ejemplo, obs://test-modelarts/pytorch/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)