Exemplo: criar uma imagem personalizada para treinamento (TensorFlow 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.2
• python-3.7.13
• mlnx ofed-5.4
• tensorflow gpu-2.10.0

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 Criar um conjunto de dados e carregá-lo para o OBS
4. Etapa 3 Preparar o script de treinamento e carregá-lo no OBS
5. Etapa 4 Preparar um servidor
6. Etapa 5 Criar uma imagem personalizada
7. Etapa 6 Carregar a imagem para o SWR
8. 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 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 Criar um conjunto de dados e carregá-lo para o OBS

Faça o download do mnist.npz do https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz e faça o upload para obs://test-modelarts/tensorflow/data/ no bucket do OBS.

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

Obtenha o script de treinamento mnist.py e envie-o para obs://test-modelarts/tensorflow/code/ no bucket do OBS.

mnist.py é o seguinte:

import argparse
import tensorflow as tf

parser = argparse.ArgumentParser(description='TensorFlow quick start')
parser.add_argument('--data_url', type=str, default="./Data", help='path where the dataset is saved')
args = parser.parse_args()

mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data(args.data_url)
x_train, x_test = x_train / 255.0, x_test / 255.0

model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10)
])

loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

model.compile(optimizer='adam',
              loss=loss_fn,
              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=5)

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

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 tensorflow_gpu-2.10.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.

   Baixe tensorflow_gpu-2.10.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl de https://pypi.org/project/tensorflow-gpu/2.10.0/#files.

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

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.2.2-cudnn8-runtime-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 tensorflow_gpu-2.10.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_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 TensorFlow .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/tensorflow_gpu-2.10.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
   
   RUN cd /tmp && \
       /home/ma-user/miniconda3/bin/pip install --no-cache-dir keras==2.10.0
   
   # Create the container image.
   FROM nvidia/cuda:11.2.2-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, and MLNX_OFED 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 && \
       # 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
   
   # Add user ma-user (UID = 1000, GID = 100).
   # A user group whose GID is 100 exists in the base 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 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 Linux Drivers. Na guia Download, defina Version para 5.4-3.5.8.0-LTS, OS Distribution Version para Ubuntu 18.04, Architecture para x86_64 e baixe MLNX_OFED_LINUX-5.4-3.5.8.0-ubuntu18.04-x86_64.tgz.

9. 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
   ├── pip.conf
   └── tensorflow_gpu-2.10.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

10. 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 tensorflow:2.10.0-ofed-cuda11.2:

    1	docker build . -t tensorflow:2.10.0-ofed-cuda11.2

    O log a seguir mostra que a imagem foi criada.

    Successfully tagged tensorflow:2.10.0-ofed-cuda11.2

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 tensorflow:2.10.0-ofed-cuda11.2 swr.{region-id}.{domain}/deep-learning/tensorflow:2.10.0-ofed-cuda11.2

   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/tensorflow:2.10.0-ofed-cuda11.2

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 5 Criar uma imagem personalizada.
   • Code Directory: diretório onde o arquivo de script de inicialização é armazenado no OBS, por exemplo, obs://test-modelarts/tensorflow/code/. O código de treinamento é baixado automaticamente para o diretório ${MA_JOB_DIR}/code do contêiner de treinamento. code (personalizável) é o diretório de último nível do caminho do OBS.
   • Boot Command: python ${MA_JOB_DIR}/code/mnist.py. code (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 mnist.npz, por exemplo, obs://test-modelarts/tensorflow/data/mnist.npz e defina Obtained from para Hyperparameters.
   • Resource Pool: selecione Public resource pools.
   • Resource Type: selecione GPU.
   • Compute Nodes: Digite 1.
   • 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