Estos contenidos se han traducido de forma automática para su comodidad, pero Huawei Cloud no garantiza la exactitud de estos. Para consultar los contenidos originales, acceda a la versión en inglés.
Centro de ayuda/
ModelArts/
Contenedores de Docker con ModelArts/
Uso de una imagen personalizada para entrenar modelos (entrenamiento de modelos)/
Ejemplo: creación de una imagen personalizada para entrenamiento/
Ejemplo: creación de una imagen personalizada para entrenamiento (Horovod-PyTorch y GPU)
Actualización más reciente 2024-09-14 GMT+08:00
Ejemplo: creación de una imagen personalizada para entrenamiento (Horovod-PyTorch y GPU)
En esta sección se describe cómo crear una imagen y utilizarla para los entrenamientos en ModelArts. El motor de IA utilizado en la imagen es Horovod 0.22.1 + PyTorch 1.8.1 y los recursos utilizados para el entrenamiento son GPU.
Esta sección solo se aplica a los trabajos de entrenamiento de la nueva versión.
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.
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 sobre cómo crear un bucket de OBS y una carpeta, véase 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 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 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.
- 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, se ha instalado Docker. Si es así, omita este paso.
- 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.
- Cree una carpeta denominada context.
mkdir -p context
- 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.
- 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.
- 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.
- 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.
- 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 # 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=1Para obtener detalles sobre cómo escribir un Dockerfile, consulte los documentos oficiales de Docker.
- 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.
- 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.
- 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
- 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:
1docker 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
- Inicie sesión en la consola de SWR y seleccione la región de destino.
Figura 2 Consola de SWR
- 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
- Haga clic en Generate Login Command en la esquina superior derecha para obtener un comando de acceso.
Figura 4 Comando de acceso
- Inicie sesión en el entorno local como usuario root e ingrese el comando de inicio de sesión.
- Cargue la imagen en SWR.
- 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 - 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
- Etiquete la imagen cargada.
- 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
- 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.
- En el panel de navegación, seleccione Training Management > Training Jobs. La lista de trabajos de entrenamiento se muestra de forma predeterminada.
- 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 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/
- Confirme las configuraciones del trabajo de entrenamiento y haga clic en Submit.
- 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)
Tema principal: Ejemplo: creación de una imagen personalizada para entrenamiento
Comentarios
¿Le pareció útil esta página?
Deje algún comentario
Muchas gracias por sus comentarios. Seguiremos trabajando para mejorar la documentación.
El sistema está ocupado. Vuelva a intentarlo más tarde.
