As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Tutoriais Veja a seguir os tutoriais sobre como usar o software da AMI de deep learning com Conda. **Topics** + [ # Ativar estruturas ](activating.md) + [ # Treinamento distribuído usando o Elastic Fabric Adapter ](tutorial-efa.md) + [ # Monitoramento e otimização de GPU ](tutorial-gpu.md) + [ # O chip de AWS inferência com DLAMI ](tutorial-inferentia.md) + [ # O ARM64 DLAMI ](tutorial-arm64.md) + [ # Inferência ](tutorial-inference.md) + [ # Fornecimento de modelos ](model-serving.md) # Ativar estruturas Veja a seguir as estruturas de deep learning instaladas na AMI de deep learning com Conda. Clique em uma estrutura para saber como ativá-la. **Topics** + [ # PyTorch ](tutorial-pytorch.md) + [ # TensorFlow 2 ](tutorial-tensorflow-2.md) # PyTorch ## Ativando PyTorch Quando um pacote Conda estável de uma estrutura é lançada, ele é testado e pré-instalado na DLAMI. Se desejar executar as mais recentes compilações noturnas não testadas, você pode [PyTorchInstall's Nightly Build (experimental)](#tutorial-pytorch-install) manualmente. Para ativar a estrutura instalada no momento, siga estas instruções sobre a AMI de deep learning com Conda. Para o PyTorch Python 3 com CUDA e MKL-DNN, execute este comando: ``` $ source activate pytorch_p310 ``` Inicie o terminal iPython. ``` (pytorch_p310)$ ipython ``` Execute um PyTorch programa rápido. ``` import torch x = torch.rand(5, 3) print(x) print(x.size()) y = torch.rand(5, 3) print(torch.add(x, y)) ``` Você deve ver a matriz aleatória inicial impressa, seu tamanho e a adição de outra matriz aleatória. ## PyTorchInstall's Nightly Build (experimental) **Como instalar a PyTorch partir de uma compilação noturna** Você pode instalar a PyTorch versão mais recente em um ou em ambos os ambientes PyTorch Conda em sua AMI de aprendizado profundo com o Conda. 1. + (Opção para Python 3) - Ative o ambiente Python 3: PyTorch ``` $ source activate pytorch_p310 ``` 1. As etapas restantes assumem que você está usando o ambiente do `pytorch_p310`. Remova o atualmente instalado PyTorch: ``` (pytorch_p310)$ pip uninstall torch ``` 1. + (Opção para instâncias de GPU) - Instale a versão noturna mais recente do com CUDA.0: PyTorch ``` (pytorch_p310)$ pip install torch_nightly -f https://download.pytorch.org/whl/nightly/cu100/torch_nightly.html ``` + (Opção para instâncias de CPU) - Instale a versão noturna mais recente de PyTorch for instâncias sem: GPUs ``` (pytorch_p310)$ pip install torch_nightly -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html ``` 1. Para verificar se você instalou com sucesso a última compilação noturna, inicie o IPython terminal e verifique a versão do. PyTorch ``` (pytorch_p310)$ ipython ``` ``` import torch print (torch.__version__) ``` A saída deve imprimir algo semelhante a `1.0.0.dev20180922` 1. Para verificar se a compilação PyTorch noturna funciona bem com o exemplo do MNIST, você pode executar um script de teste no repositório de exemplos PyTorch da: ``` (pytorch_p310)$ cd ~ (pytorch_p310)$ git clone https://github.com/pytorch/examples.git pytorch_examples (pytorch_p310)$ cd pytorch_examples/mnist (pytorch_p310)$ python main.py || exit 1 ``` ## Mais tutoriais Para mais tutoriais e exemplos, consulte os documentos oficiais, a [PyTorch documentação](http://pytorch.org/docs/master/) e o site da estrutura. [PyTorch](http://pytorch.org) # TensorFlow 2 Este tutorial mostra como ativar TensorFlow 2 em uma instância executando a AMI de aprendizado profundo com o Conda (DLAMI no Conda) e executar um programa 2. TensorFlow Quando um pacote Conda estável de uma estrutura é lançada, ele é testado e pré-instalado na DLAMI. ## Ativando 2 TensorFlow **Para rodar TensorFlow no DLAMI com Conda** 1. Para ativar TensorFlow 2, abra uma instância do Amazon Elastic Compute Cloud (Amazon EC2) do DLAMI com o Conda. 1. Para TensorFlow 2 e Keras 2 em Python 3 com CUDA 10.1 e MKL-DNN, execute este comando: ``` $ source activate tensorflow2_p310 ``` 1. Inicie o terminal iPython: ``` (tensorflow2_p310)$ ipython ``` 1. Execute um programa TensorFlow 2 para verificar se ele está funcionando corretamente: ``` import tensorflow as tf hello = tf.constant('Hello, TensorFlow!') tf.print(hello) ``` `Hello, TensorFlow!` deve aparecer na tela. ## Mais tutoriais Para ver mais tutoriais e exemplos, consulte a TensorFlow documentação da [API TensorFlow Python](https://www.tensorflow.org/api_docs/python/) ou acesse o site. [TensorFlow](https://www.tensorflow.org) # Treinamento distribuído usando o Elastic Fabric Adapter O [Elastic Fabric Adapter (EFA)](https://aws.amazon.com/hpc/efa/) é um dispositivo de rede que é possível anexar à instância da DLAMI para acelerar as aplicações de Computação de Alta Performance (HPC). O EFA permite que você alcance o desempenho do aplicativo de um cluster de HPC local, com a escalabilidade, a flexibilidade e a elasticidade fornecidas pela nuvem. AWS Os tópicos a seguir mostram como começar a usar o EFA com a DLAMI. **nota** Escolha sua DLAMI nesta [lista de DLAMI de GPU base](appendix-ami-release-notes.md#appendix-ami-release-notes-base) **Topics** + [ # Executando uma AMIs de deep learning da AWS instância com o EFA ](tutorial-efa-launching.md) + [ # Uso do EFA na DLAMI ](tutorial-efa-using.md) # Executando uma AMIs de deep learning da AWS instância com o EFA A DLAMI base mais recente está pronta para usar o EFA e vem com os drivers, os módulos do kernel, libfabric, openmpi e o [plug-in OFI NCCL](https://github.com/aws/aws-ofi-nccl/tree/aws) necessários para instâncias de GPU. Você pode encontrar as versões do CUDA compatíveis de uma DLAMI base nas [notas de versão.](appendix-ami-release-notes.md#appendix-ami-release-notes-base) Observação: + Ao executar um aplicativo NCCL usando `mpirun` no EFA, será necessário especificar o caminho completo para as instalações do EFA com suporte como: ``` /opt/amazon/openmpi/bin/mpirun ``` + Para habilitar seu aplicativo para usar o EFA, adicione `FI_PROVIDER="efa"` ao comando `mpirun` como mostrado em [Uso do EFA na DLAMI](tutorial-efa-using.md). **Topics** + [ ## Preparar um grupo de segurança habilitado para o EFA ](#tutorial-efa-security-group) + [ ## Executar sua instância ](#tutorial-efa-launch) + [ ## Verificar anexo do EFA ](#tutorial-efa-verify-attachment) ## Preparar um grupo de segurança habilitado para o EFA O EFA requer um grupo de segurança que permita todo o tráfego recebido do grupo de segurança e enviado para ele. Para ter mais informações, consulte a [Documentação do EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security). 1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/). 1. No painel de navegação, escolha **Security Groups (Grupos de segurança)** e, em seguida, **Create Security Group (Criar grupo de segurança)**. 1. Na janela **Security group**, faça o seguinte: + Em **Security group name** (Nome do grupo de segurança), insira um nome descritivo para o grupo de segurança, como `EFA-enabled security group`. + (Opcional) Em **Description** (Descrição), insira uma breve descrição do grupo de segurança. + Em **VPC**, selecione a VPC na qual você pretende executar suas instâncias habilitadas para EFA. + Escolha **Criar**. 1. Selecione o grupo de segurança que você criou e, na guia **Description** (Descrição), copie o **Group ID** (ID do grupo). 1. Nas guias **Entrada** e **Saída**, faça o seguinte: + Selecione **Edit**. + Para **Type (Tipo)**, escolha **All traffic (Todo o tráfego)**. + Em **Source**, escolha **Custom**. + Cole o ID do grupo de segurança que você copiou no campo. + Escolha **Salvar**. 1. Habilite o tráfego de entrada fazendo referência a [Autorizar tráfego de entrada para as instâncias do Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html). Se ignorar esta etapa, você não poderá se comunicar com sua instância da DLAMI. ## Executar sua instância Atualmente, o EFA no AMIs de deep learning da AWS é compatível com os seguintes tipos de instância e sistemas operacionais: + P3dn: Amazon Linux 2, Ubuntu 20.04 + P4d, P4de: Amazon Linux 2, Amazon Linux 2023, Ubuntu 20.04, Ubuntu 22.04 + P5, P5e, P5en: Amazon Linux 2, Amazon Linux 2023, Ubuntu 20.04, Ubuntu 22.04 A seção a seguir mostra como iniciar uma instância da DLAMI habilitada para EFA. Para obter mais informações sobre executar uma instância habilitada para EFA, consulte [Executar instâncias habilitadas para EFA em um grupo com posicionamento em cluster](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-instances). 1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/). 1. Escolha **Executar instância**. 1. Na página **Escolha uma AMI**, selecione uma DLAMI compatível encontrada na [página de notas de versão de DLAMIs](https://docs.aws.amazon.com/dlami/latest/devguide/appendix-ami-release-notes). 1. Na página **Escolher um tipo de instância**, selecione um dos seguintes tipos de instância com suporte e escolha **Próximo: Configurar os detalhes da instância**. Consulte este link para acessar a lista de instâncias compatíveis: [Conceitos básicos do EFA e MPI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html). 1. Na página **Configurar detalhes da instância**, faça o seguinte: + Em **Number of instances (Número de instâncias)**, insira o número de instâncias habilitadas para EFA que você deseja executar. + Em **Rede** e **Sub-rede**, selecione a VPC e a sub-rede na qual executar as instâncias. + [Opcional] Em **Grupo de posicionamento**, selecione **Adicionar instância ao grupo de posicionamento**. Para obter o melhor desempenho, execute as instâncias dentro de um placement group. + [Opcional] Em **Nome do grupo de posicionamento**, selecione **Adicionar a um novo grupo de posicionamento**, insira um nome descritivo para o grupo de posicionamento e, em **Estratégia de grupo de posicionamento**, selecione **cluster**. + Habilite o **“Elastic Fabric Adapter”** nesta página. Se esta opção estiver desabilitada, altere a sub-rede para uma que ofereça suporte ao tipo de instância selecionado. + Na seção **Interfaces de rede**, para dispositivo **eth0**, escolha **Nova interface de rede**. Opcionalmente, você pode especificar um IPv4 endereço principal e um ou mais IPv4 endereços secundários. Se você estiver iniciando a instância em uma sub-rede que tenha um bloco IPv6 CIDR associado, você pode especificar opcionalmente um IPv6 endereço primário e um ou mais endereços secundários. IPv6 + Escolha **Next: Add Storage**. 1. Na página **Add Storage (Adicionar armazenamento)**, especifique os volumes para anexar às instâncias em associação aos volumes especificados pela AMI (como o volume do dispositivo raiz) e escolha **Next: Add Tags (Próximo: adicionar tags)**. 1. Na página **Adicionar tags**, especifique tags para as instâncias, como nome amigável, e selecione **Próximo: Configurar grupo de segurança**. 1. Na página **Configurar grupo de segurança**, em **Atribuir um grupo de segurança**, escolha **Selecionar um grupo de segurança existente** e selecione o grupo de segurança que você criou anteriormente**.** 1. Escolha **revisar e iniciar**. 1. Na página **Revisar execução da instância**, reveja as configurações, e escolha **Executar** para escolher um par de chaves e executar a instâncias. ## Verificar anexo do EFA ### No console Depois de iniciar a instância, verifique os detalhes da instância no AWS console. Para fazer isso, selecione a instância no console do EC2 e observe a guia "Descrição" no painel inferior da página. Encontre o parâmetro "Network Interfaces: eth0" e clique em eth0 e um pop-up será aberto. O “Elastic Fabric Adapter” deve estar habilitado. Se o EFA não estiver habilitado, você poderá corrigir isso da seguinte forma: + Encerre a instância do EC2 e execute uma nova com as mesmas etapas. Verifique se o EFA está associado. + Associe o EFA a uma instância existente. 1. No console do EC2, acesse "Interfaces de rede". 1. Clique em "Criar uma interface de rede". 1. Selecione a mesma sub-rede na qual está sua instância. 1. Habilite o "Elastic Fabric Adapter" e clique em Criar. 1. Volte para a guia "Instâncias do EC2" e selecione sua instância. 1. Acesse Ações: estado da instância e interrompa a instância antes de anexar o EFA. 1. Em "Ações", selecione "Rede: Anexar Interface de Rede". 1. Selecione a interface que você acabou de criar e clique em associar. 1. Reinicie sua instância. ### Na instância O script de teste a seguir já está presente na DLAMI. Execute-o para garantir que os módulos do kernel sejam carregados corretamente. ``` $ fi_info -p efa ``` O resultado deve ser semelhante ao seguinte: ``` provider: efa fabric: EFA-fe80::e5:56ff:fe34:56a8 domain: efa_0-rdm version: 2.0 type: FI_EP_RDM protocol: FI_PROTO_EFA provider: efa fabric: EFA-fe80::e5:56ff:fe34:56a8 domain: efa_0-dgrm version: 2.0 type: FI_EP_DGRAM protocol: FI_PROTO_EFA provider: efa;ofi_rxd fabric: EFA-fe80::e5:56ff:fe34:56a8 domain: efa_0-dgrm version: 1.0 type: FI_EP_RDM protocol: FI_PROTO_RXD ``` ### Verificar a configuração do grupo de segurança O script de teste a seguir já está presente na DLAMI. Execute-o para garantir que o grupo de segurança criado esteja configurado corretamente. ``` $ cd /opt/amazon/efa/test/ $ ./efa_test.sh ``` O resultado deve ser semelhante ao seguinte: ``` Starting server... Starting client... bytes #sent #ack total time MB/sec usec/xfer Mxfers/sec 64 10 =10 1.2k 0.02s 0.06 1123.55 0.00 256 10 =10 5k 0.00s 17.66 14.50 0.07 1k 10 =10 20k 0.00s 67.81 15.10 0.07 4k 10 =10 80k 0.00s 237.45 17.25 0.06 64k 10 =10 1.2m 0.00s 921.10 71.15 0.01 1m 10 =10 20m 0.01s 2122.41 494.05 0.00 ``` Se ele parar de responder ou não for concluído, certifique-se de que seu grupo de segurança tenha as inbound/outbound regras corretas. # Uso do EFA na DLAMI A seção a seguir descreve como usar o EFA para executar aplicativos de vários nós na AMIs de deep learning da AWS. ## Como executar aplicativos de vários nós com o EFA Para executar uma aplicação em um cluster de nós, é necessária a configuração a seguir. **Topics** + [ ### Permitir SSH sem senha ](#tutorial-efa-using-multi-node-ssh) + [ ### Criar arquivo de hosts ](#tutorial-efa-using-multi-node-hosts) + [ ### Testes NCCL ](#tutorial-efa-using-2node) ### Permitir SSH sem senha Selecione um nó no cluster como o nó líder. Os nós restantes são referidos como nós membros. 1. No nó líder, gere o par de chaves RSA. ``` ssh-keygen -t rsa -N "" -f ~/.ssh/id_rsa ``` 1. Altere as permissões da chave privada no nó líder. ``` chmod 600 ~/.ssh/id_rsa ``` 1. Copie a chave pública `~/.ssh/id_rsa.pub` e a anexe a `~/.ssh/authorized_keys` dos nós membros no cluster. 1. Agora, você poderá fazer login diretamente nos nós membros a partir do nó líder usando o ip privado. ``` ssh ``` 1. Desative a strictHostKey verificação e habilite o encaminhamento de agentes no nó principal adicionando o seguinte ao arquivo \$1/.ssh/config no nó líder: ``` Host * ForwardAgent yes Host * StrictHostKeyChecking no ``` 1. Nas instâncias do Amazon Linux 2, execute o seguinte comando no nó líder para fornecer as permissões corretas ao arquivo de configuração: ``` chmod 600 ~/.ssh/config ``` ### Criar arquivo de hosts No nó líder, crie um arquivo de hosts para identificar os nós no cluster. O arquivo de hosts deve ter uma entrada para cada nó no cluster. Crie um arquivo \$1/hosts e adicione cada nó usando o ip privado da seguinte forma: ``` localhost slots=8 slots=8 slots=8 ``` ### Testes NCCL **nota** Esses testes foram executados usando o EFA versão 1.38.0 e o OFI NCCL Plugin 1.13.2. Abaixo está listado um subconjunto de testes NCCL fornecidos pela NVIDIA para testar a funcionalidade e o desempenho em vários nós de computação. **Instâncias compatíveis: P3dn, P4, P5, P5e e P5en** #### Testes de desempenho ##### Teste de desempenho de vários nós do NCCL em P4d.24xlarge Para verificar o desempenho do NCCL com o EFA, execute o teste de desempenho do NCCL padrão que está disponível no [NCCL-Tests Repo](https://github.com/NVIDIA/nccl-tests.git). A DLAMI vem com esse teste já criado para CUDA XX.X. Também é possível executar um script próprio com o EFA. Ao criar seu próprio script, consulte as seguintes orientações: + Use o caminho completo para mpirun como mostrado no exemplo ao executar aplicativos NCCL com o EFA. + Altere os parâmetros np e N com base no número de instâncias e GPUs no seu cluster. + Adicione o sinalizador NCCL\$1DEBUG=INFO e verifique se os logs indicam o uso do EFA como “O provedor selecionado é EFA”. + Defina o local do log de treinamento a ser analisado para validação. ``` TRAINING_LOG="testEFA_$(date +"%N").log" ``` Use o comando `watch nvidia-smi` em qualquer um dos nós membros para monitorar o uso da GPU. Os comandos `watch nvidia-smi` a seguir são para o CUDA versão xx.x e dependem do sistema operacional da instância. Você pode executar os comandos para qualquer versão do CUDA disponível em sua instância do Amazon EC2 substituindo a versão do CUDA no script. + Amazon Linux 2, Amazon Linux 2023: ``` $ /opt/amazon/openmpi/bin/mpirun -n 16 -N 8 \ -x NCCL_DEBUG=INFO --mca pml ^cm \ -x LD_LIBRARY_PATH=/usr/local/cuda-xx.x/efa/lib:/usr/local/cuda-xx.x/lib:/usr/local/cuda-xx.x/lib64:/usr/local/cuda-xx.x:/opt/amazon/efa/lib64:/opt/amazon/openmpi/lib64:$LD_LIBRARY_PATH \ --hostfile hosts --mca btl tcp,self --mca btl_tcp_if_exclude lo,docker0 --bind-to none \ /usr/local/cuda-xx.x/efa/test-cuda-xx.x/all_reduce_perf -b 8 -e 1G -f 2 -g 1 -c 1 -n 100 | tee ${TRAINING_LOG} ``` + Ubuntu 20.04, Ubuntu 20.04: ``` $ /opt/amazon/openmpi/bin/mpirun -n 16 -N 8 \ -x NCCL_DEBUG=INFO --mca pml ^cm \ -x LD_LIBRARY_PATH=/usr/local/cuda-xx.x/efa/lib:/usr/local/cuda-xx.x/lib:/usr/local/cuda-xx.x/lib64:/usr/local/cuda-xx.x:/opt/amazon/efa/lib:/opt/amazon/openmpi/lib:$LD_LIBRARY_PATH \ --hostfile hosts --mca btl tcp,self --mca btl_tcp_if_exclude lo,docker0 --bind-to none \ /usr/local/cuda-xx.x/efa/test-cuda-xx.x/all_reduce_perf -b 8 -e 1G -f 2 -g 1 -c 1 -n 100 | tee ${TRAINING_LOG} ``` A saída será semelhante a: ``` # nThread 1 nGpus 1 minBytes 8 maxBytes 1073741824 step: 2(factor) warmup iters: 5 iters: 100 agg iters: 1 validation: 1 graph: 0 # # Using devices # Rank 0 Group 0 Pid 33378 on ip-172-31-42-25 device 0 [0x10] NVIDIA A100-SXM4-40GB # Rank 1 Group 0 Pid 33379 on ip-172-31-42-25 device 1 [0x10] NVIDIA A100-SXM4-40GB # Rank 2 Group 0 Pid 33380 on ip-172-31-42-25 device 2 [0x20] NVIDIA A100-SXM4-40GB # Rank 3 Group 0 Pid 33381 on ip-172-31-42-25 device 3 [0x20] NVIDIA A100-SXM4-40GB # Rank 4 Group 0 Pid 33382 on ip-172-31-42-25 device 4 [0x90] NVIDIA A100-SXM4-40GB # Rank 5 Group 0 Pid 33383 on ip-172-31-42-25 device 5 [0x90] NVIDIA A100-SXM4-40GB # Rank 6 Group 0 Pid 33384 on ip-172-31-42-25 device 6 [0xa0] NVIDIA A100-SXM4-40GB # Rank 7 Group 0 Pid 33385 on ip-172-31-42-25 device 7 [0xa0] NVIDIA A100-SXM4-40GB # Rank 8 Group 0 Pid 30378 on ip-172-31-43-8 device 0 [0x10] NVIDIA A100-SXM4-40GB # Rank 9 Group 0 Pid 30379 on ip-172-31-43-8 device 1 [0x10] NVIDIA A100-SXM4-40GB # Rank 10 Group 0 Pid 30380 on ip-172-31-43-8 device 2 [0x20] NVIDIA A100-SXM4-40GB # Rank 11 Group 0 Pid 30381 on ip-172-31-43-8 device 3 [0x20] NVIDIA A100-SXM4-40GB # Rank 12 Group 0 Pid 30382 on ip-172-31-43-8 device 4 [0x90] NVIDIA A100-SXM4-40GB # Rank 13 Group 0 Pid 30383 on ip-172-31-43-8 device 5 [0x90] NVIDIA A100-SXM4-40GB # Rank 14 Group 0 Pid 30384 on ip-172-31-43-8 device 6 [0xa0] NVIDIA A100-SXM4-40GB # Rank 15 Group 0 Pid 30385 on ip-172-31-43-8 device 7 [0xa0] NVIDIA A100-SXM4-40GB ip-172-31-42-25:33385:33385 [7] NCCL INFO cudaDriverVersion 12060 ip-172-31-43-8:30383:30383 [5] NCCL INFO Bootstrap : Using ens32:172.31.43.8 ip-172-31-43-8:30383:30383 [5] NCCL INFO NCCL version 2.23.4+cuda12.5 ... ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Initializing aws-ofi-nccl 1.13.2-aws ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Using Libfabric version 1.22 ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Using CUDA driver version 12060 with runtime 12050 ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Configuring AWS-specific options ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Setting provider_filter to efa ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Setting FI_EFA_FORK_SAFE environment variable to 1 ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Setting NCCL_NVLSTREE_MAX_CHUNKSIZE to 512KiB ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Setting NCCL_NVLS_CHUNKSIZE to 512KiB ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Running on p4d.24xlarge platform, Setting NCCL_TOPO_FILE environment variable to /opt/amazon/ofi-nccl/share/aws-ofi-nccl/xml/p4d-24xl-topo.xml ... -----------------------------some output truncated----------------------------------- # out-of-place in-place # size count type redop root time algbw busbw #wrong time algbw busbw #wrong # (B) (elements) (us) (GB/s) (GB/s) (us) (GB/s) (GB/s) 8 2 float sum -1 180.3 0.00 0.00 0 179.3 0.00 0.00 0 16 4 float sum -1 178.1 0.00 0.00 0 177.6 0.00 0.00 0 32 8 float sum -1 178.5 0.00 0.00 0 177.9 0.00 0.00 0 64 16 float sum -1 178.8 0.00 0.00 0 178.7 0.00 0.00 0 128 32 float sum -1 178.2 0.00 0.00 0 177.8 0.00 0.00 0 256 64 float sum -1 178.6 0.00 0.00 0 178.8 0.00 0.00 0 512 128 float sum -1 177.2 0.00 0.01 0 177.1 0.00 0.01 0 1024 256 float sum -1 179.2 0.01 0.01 0 179.3 0.01 0.01 0 2048 512 float sum -1 181.3 0.01 0.02 0 181.2 0.01 0.02 0 4096 1024 float sum -1 184.2 0.02 0.04 0 183.9 0.02 0.04 0 8192 2048 float sum -1 191.2 0.04 0.08 0 190.6 0.04 0.08 0 16384 4096 float sum -1 202.5 0.08 0.15 0 202.3 0.08 0.15 0 32768 8192 float sum -1 233.0 0.14 0.26 0 232.1 0.14 0.26 0 65536 16384 float sum -1 238.6 0.27 0.51 0 235.1 0.28 0.52 0 131072 32768 float sum -1 237.2 0.55 1.04 0 236.8 0.55 1.04 0 262144 65536 float sum -1 248.3 1.06 1.98 0 247.0 1.06 1.99 0 524288 131072 float sum -1 309.2 1.70 3.18 0 307.7 1.70 3.20 0 1048576 262144 float sum -1 408.7 2.57 4.81 0 404.3 2.59 4.86 0 2097152 524288 float sum -1 613.5 3.42 6.41 0 607.9 3.45 6.47 0 4194304 1048576 float sum -1 924.5 4.54 8.51 0 914.8 4.58 8.60 0 8388608 2097152 float sum -1 1059.5 7.92 14.85 0 1054.3 7.96 14.92 0 16777216 4194304 float sum -1 1269.9 13.21 24.77 0 1272.0 13.19 24.73 0 33554432 8388608 float sum -1 1642.7 20.43 38.30 0 1636.7 20.50 38.44 0 67108864 16777216 float sum -1 2446.7 27.43 51.43 0 2445.8 27.44 51.45 0 134217728 33554432 float sum -1 4143.6 32.39 60.73 0 4142.4 32.40 60.75 0 268435456 67108864 float sum -1 7351.9 36.51 68.46 0 7346.7 36.54 68.51 0 536870912 134217728 float sum -1 13717 39.14 73.39 0 13703 39.18 73.46 0 1073741824 268435456 float sum -1 26416 40.65 76.21 0 26420 40.64 76.20 0 ... # Out of bounds values : 0 OK # Avg bus bandwidth : 15.5514 ``` #### Testes de validação Para validar se os testes do EFA retornaram um resultado válido, use os seguintes testes: + Obtenha o tipo de instância usando os metadados de instância do EC2: ``` TOKEN=$(curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600") INSTANCE_TYPE=$(curl -H "X-aws-ec2-metadata-token: $TOKEN" -v http://169.254.169.254/latest/meta-data/instance-type) ``` + Execute a [Testes de desempenho](#tutorial-efa-using-multinode) + Defina os seguintes parâmetros: ``` CUDA_VERSION CUDA_RUNTIME_VERSION NCCL_VERSION ``` + Valide os resultados conforme mostrado: ``` RETURN_VAL=`echo $?` if [ ${RETURN_VAL} -eq 0 ]; then # [0] NCCL INFO NET/OFI Initializing aws-ofi-nccl 1.13.2-aws # [0] NCCL INFO NET/OFI Using CUDA driver version 12060 with runtime 12010 # cudaDriverVersion 12060 --> This is max supported cuda version by nvidia driver # NCCL version 2.23.4+cuda12.5 --> This is NCCL version compiled with cuda version # Validation of logs grep "NET/OFI Configuring AWS-specific options" ${TRAINING_LOG} || { echo "AWS-specific options text not found"; exit 1; } grep "busbw" ${TRAINING_LOG} || { echo "busbw text not found"; exit 1; } grep "Avg bus bandwidth " ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; } grep "NCCL version $NCCL_VERSION" ${TRAINING_LOG} || { echo "Text not found: NCCL version $NCCL_VERSION"; exit 1; } if [[ ${INSTANCE_TYPE} == "p4d.24xlarge" ]]; then grep "NET/Libfabric/0/GDRDMA" ${TRAINING_LOG} || { echo "Text not found: NET/Libfabric/0/GDRDMA"; exit 1; } grep "NET/OFI Selected Provider is efa (found 4 nics)" ${TRAINING_LOG} || { echo "Selected Provider is efa text not found"; exit 1; } elif [[ ${INSTANCE_TYPE} == "p4de.24xlarge" ]]; then grep "NET/Libfabric/0/GDRDMA" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; } grep "NET/OFI Selected Provider is efa (found 4 nics)" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; } elif [[ ${INSTANCE_TYPE} == "p5.48xlarge" ]]; then grep "NET/Libfabric/0/GDRDMA" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; } grep "NET/OFI Selected Provider is efa (found 32 nics)" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; } elif [[ ${INSTANCE_TYPE} == "p5e.48xlarge" ]]; then grep "NET/Libfabric/0/GDRDMA" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; } grep "NET/OFI Selected Provider is efa (found 32 nics)" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; } elif [[ ${INSTANCE_TYPE} == "p5en.48xlarge" ]]; then grep "NET/Libfabric/0/GDRDMA" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; } grep "NET/OFI Selected Provider is efa (found 16 nics)" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; } elif [[ ${INSTANCE_TYPE} == "p3dn.24xlarge" ]]; then grep "NET/OFI Selected Provider is efa (found 4 nics)" ${TRAINING_LOG} || { echo "Selected Provider is efa text not found"; exit 1; } fi echo "***************************** check_efa_nccl_all_reduce passed for cuda version ${CUDA_VERSION} *****************************" else echo "***************************** check_efa_nccl_all_reduce failed for cuda version ${CUDA_VERSION} *****************************" fi ``` + Para acessar os dados de referência, podemos analisar a linha final da saída da tabela do teste all\$1reduce de vários nós: ``` benchmark=$(sudo cat ${TRAINING_LOG} | grep '1073741824' | tail -n1 | awk -F " " '{{print $12}}' | sed 's/ //' | sed 's/ 5e-07//') if [[ -z "${benchmark}" ]]; then echo "benchmark variable is empty" exit 1 fi echo "Benchmark throughput: ${benchmark}" ``` # Monitoramento e otimização de GPU A seção a seguir orientará você durante a otimização de GPU e opções de monitoramento. Esta seção é organizada como um fluxo de trabalho típico com monitoramento, supervisão, pré-processamento e treinamento. + [Monitoramento](tutorial-gpu-monitoring.md) + [Monitor GPUs com CloudWatch](tutorial-gpu-monitoring-gpumon.md) + [Otimização](tutorial-gpu-opt.md) + [Pré-processamento](tutorial-gpu-opt-preprocessing.md) + [Treinamento](tutorial-gpu-opt-training.md) # Monitoramento A DLAMI vem pré-instalada com várias ferramentas de monitoramento de GPU. Este guia menciona também ferramentas que estão disponíveis para download e instalação. + [Monitor GPUs com CloudWatch](tutorial-gpu-monitoring-gpumon.md)- um utilitário pré-instalado que reporta estatísticas de uso da GPU para a Amazon. CloudWatch + [CLI nvidia-smi](https://developer.nvidia.com/nvidia-system-management-interface) – um utilitário para monitorar a utilização geral de computação e memória de GPU. Isso está pré-instalado no seu AMIs de deep learning da AWS (DLAMI). + [Biblioteca NVML C](https://developer.nvidia.com/nvidia-management-library-nvml) – uma API baseada em C para acessar diretamente funções de monitoramento e gerenciamento de GPU. Isso é usado pela CLI nvidia-smi nos bastidores e é pré-instalado na DLAMI. Também tem associações Python e Perl para facilitar o desenvolvimento nessas linguagens. O utilitário gpumon.py pré-instalado em seu DLAMI usa o pacote pynvml do. [nvidia-ml-py](https://pypi.org/project/nvidia-ml-py/) + [NVIDIA DCGM](https://developer.nvidia.com/data-center-gpu-manager-dcgm) – uma ferramenta de gerenciamento de cluster. Visite a página do desenvolvedor para saber como instalar e configurar essa ferramenta. **dica** Confira o blog do desenvolvedor de NVIDIA para obter as informações mais recentes sobre como usar as ferramentas do CUDA instaladas na DLAMI: [Monitorando TensorCore a utilização usando o Nsight IDE e o nvprof](https://devblogs.nvidia.com/using-nsight-compute-nvprof-mixed-precision-deep-learning-models/). # Monitor GPUs com CloudWatch Ao usar a DLAMI com uma GPU, talvez você descubra que está procurando maneiras de controlar o uso durante o treinamento ou a inferência. Isso pode ser útil para otimizar o pipeline de dados e ajustar sua rede de aprendizado profundo. Há duas maneiras de configurar as métricas da GPU com CloudWatch: + [Configurar métricas com o AWS CloudWatch agente (recomendado)](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-guide) + [Configurar métricas com o script `gpumon.py` pré-instalado](#tutorial-gpu-monitoring-gpumon-script) ## Configurar métricas com o AWS CloudWatch agente (recomendado) Integre seu DLAMI com [o agente CloudWatch unificado](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html) para configurar métricas de GPU e monitorar a utilização de coprocessos de GPU em instâncias aceleradas do Amazon EC2. Há quatro maneiras de configurar [métricas de GPU](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Agent-NVIDIA-GPU.html) com a DLAMI: + [Configurar métricas de GPU mínimas](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-minimal) + [Configurar métricas de GPU parciais](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-partial) + [Configurar todas as métricas de GPU disponíveis](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-all) + [Configurar métricas de GPU personalizadas](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-custom) Para obter mais informações sobre atualizações e patches de segurança, consulte [Patches de segurança para o agente AWS CloudWatch](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-security) ### Pré-requisitos Para começar, você deve configurar as permissões IAM da instância do Amazon EC2 que permitam que sua instância envie métricas para. CloudWatch Para ver etapas detalhadas, consulte [Criar funções e usuários do IAM para uso com o CloudWatch agente](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/create-iam-roles-for-cloudwatch-agent.html). ### Configurar métricas de GPU mínimas Configure métricas mínimas de GPU usando o serviço `dlami-cloudwatch-agent@minimal` `systemd`. Esse serviço configura as seguintes métricas: + `utilization_gpu` + `utilization_memory` Você pode encontrar o serviço `systemd` para métricas mínimas de GPU pré-configuradas no seguinte local: ``` /opt/aws/amazon-cloudwatch-agent/etc/dlami-amazon-cloudwatch-agent-minimal.json ``` Habilite e inicie o serviço `systemd` com os seguintes comandos: ``` sudo systemctl enable dlami-cloudwatch-agent@minimal sudo systemctl start dlami-cloudwatch-agent@minimal ``` ### Configurar métricas de GPU parciais Configure métricas de GPU parciais usando o serviço `dlami-cloudwatch-agent@partial` `systemd`. Esse serviço configura as seguintes métricas: + `utilization_gpu` + `utilization_memory` + `memory_total` + `memory_used` + `memory_free` Você pode encontrar o serviço `systemd` para métricas parciais de GPU pré-configuradas no seguinte local: ``` /opt/aws/amazon-cloudwatch-agent/etc/dlami-amazon-cloudwatch-agent-partial.json ``` Habilite e inicie o serviço `systemd` com os seguintes comandos: ``` sudo systemctl enable dlami-cloudwatch-agent@partial sudo systemctl start dlami-cloudwatch-agent@partial ``` ### Configurar todas as métricas de GPU disponíveis Configure todas as métricas de GPU disponíveis usando o serviço `dlami-cloudwatch-agent@all` `systemd`. Esse serviço configura as seguintes métricas: + `utilization_gpu` + `utilization_memory` + `memory_total` + `memory_used` + `memory_free` + `temperature_gpu` + `power_draw` + `fan_speed` + `pcie_link_gen_current` + `pcie_link_width_current` + `encoder_stats_session_count` + `encoder_stats_average_fps` + `encoder_stats_average_latency` + `clocks_current_graphics` + `clocks_current_sm` + `clocks_current_memory` + `clocks_current_video` Você pode encontrar o serviço `systemd` para todas as métricas disponíveis de GPU pré-configuradas no seguinte local: ``` /opt/aws/amazon-cloudwatch-agent/etc/dlami-amazon-cloudwatch-agent-all.json ``` Habilite e inicie o serviço `systemd` com os seguintes comandos: ``` sudo systemctl enable dlami-cloudwatch-agent@all sudo systemctl start dlami-cloudwatch-agent@all ``` ### Configurar métricas de GPU personalizadas Se as métricas pré-configuradas não atenderem aos seus requisitos, você poderá criar um arquivo personalizado de configuração do CloudWatch agente. #### Criar um arquivo de configuração personalizada Para criar um arquivo de configuração personalizado, consulte as etapas detalhadas em [Criar ou editar manualmente o arquivo de configuração do CloudWatch agente](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Agent-Configuration-File-Details.html). Neste exemplo, suponha que a definição do esquema esteja localizada em `/opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json`. #### Configurar métricas com seu arquivo personalizado Execute o comando a seguir para configurar o CloudWatch agente de acordo com seu arquivo personalizado: ``` sudo /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl \ -a fetch-config -m ec2 -s -c \ file:/opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json ``` ### Patches de segurança para o agente AWS CloudWatch Os recém-lançados DLAMIs são configurados com os patches de segurança de AWS CloudWatch agentes mais recentes disponíveis. Consulte as seções a seguir para atualizar a DLAMI atual com os patches de segurança mais recentes, dependendo do sistema operacional escolhido. #### Amazon Linux 2 Use `yum` para obter os patches de segurança de AWS CloudWatch agentes mais recentes para um Amazon Linux 2 DLAMI. ``` sudo yum update ``` #### Ubuntu Para obter os patches de AWS CloudWatch segurança mais recentes para um DLAMI com Ubuntu, é necessário reinstalar o agente usando um link de download AWS CloudWatch do Amazon S3. ``` wget https://s3.region.amazonaws.com/amazoncloudwatch-agent-region/ubuntu/arm64/latest/amazon-cloudwatch-agent.deb ``` Para obter mais informações sobre como instalar o AWS CloudWatch agente usando os links de download do Amazon S3, consulte [Instalando e executando o CloudWatch agente em seus servidores](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/install-CloudWatch-Agent-commandline-fleet.html). ## Configurar métricas com o script `gpumon.py` pré-instalado Um utilitário chamado gpumon.py é pré-instalado na DLAMI. Ele se integra CloudWatch e oferece suporte ao monitoramento do uso por GPU: memória da GPU, temperatura da GPU e potência da GPU. O script envia periodicamente os dados monitorados para CloudWatch o. Você pode configurar o nível de granularidade dos dados enviados CloudWatch alterando algumas configurações no script. Antes de iniciar o script, no entanto, você precisará configurar CloudWatch para receber as métricas. **Como configurar e executar o monitoramento de GPU com CloudWatch** 1. Crie um usuário do IAM ou modifique um existente para ter uma política para publicar a métrica CloudWatch. Se você criar um novo usuário, anote as credenciais, pois elas serão necessárias na próxima etapa. A política do IAM a ser pesquisada é “cloudwatch:PutMetricData”. A política que é adicionada é a seguinte: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Action": [ "cloudwatch:PutMetricData" ], "Effect": "Allow", "Resource": "*" } ] } ``` ------ **dica** Para obter mais informações sobre como criar um usuário do IAM e adicionar políticas para CloudWatch, consulte a [ CloudWatch documentação](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/create-iam-roles-for-cloudwatch-agent.html). 1. Em sua DLAMI, execute [AWS configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html#cli-quick-configuration) e especifique as credenciais de usuário do IAM. ``` $ aws configure ``` 1. Talvez você precise fazer algumas modificações no utilitário gpumon antes de executá-lo. Você pode encontrar o utilitário gpumon e o README no seguinte local definido no seguinte bloco de código. Para obter mais informações sobre o script `gpumon.py`, consulte a [localização do script no Amazon S3](https://s3.amazonaws.com/aws-bigdata-blog/artifacts/GPUMonitoring/gpumon.py). ``` Folder: ~/tools/GPUCloudWatchMonitor Files: ~/tools/GPUCloudWatchMonitor/gpumon.py ~/tools/GPUCloudWatchMonitor/README ``` Opções: + Altere a região no gpumon.py se sua instância NÃO estiver em us-east-1. + Altere outros parâmetros, como o período do relatório CloudWatch `namespace` ou o período do relatório, com`store_reso`. 1. No momento, o script oferece suporte apenas ao Python 3. Ative o ambiente do Python 3 da estrutura de trabalho preferencial ou ative o ambiente geral do Python 3 da DLAMI. ``` $ source activate python3 ``` 1. Execute o utilitário gpumon em segundo plano. ``` (python3)$ python gpumon.py & ``` 1. Abra seu navegador para [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) e, depois, selecione a métrica. Ele terá um namespace ''. DeepLearningTrain **dica** Você pode alterar o namespace modificando o gpumon.py. Você também pode modificar o intervalo de relatório ajustando `store_reso`. Veja a seguir um exemplo de CloudWatch gráfico relatando uma execução do gpumon.py monitorando um trabalho de treinamento na instância p2.8xlarge. ![\[Monitoramento de GPU ativado CloudWatch\]](http://docs.aws.amazon.com/pt_br/dlami/latest/devguide/images/gpumon.png) Você pode estar interessado nesses outros tópicos sobre monitoramento e otimização de GPU: + [Monitoramento](tutorial-gpu-monitoring.md) + [Monitor GPUs com CloudWatch](#tutorial-gpu-monitoring-gpumon) + [Otimização](tutorial-gpu-opt.md) + [Pré-processamento](tutorial-gpu-opt-preprocessing.md) + [Treinamento](tutorial-gpu-opt-training.md) # Otimização Para aproveitar ao máximo GPUs, você pode otimizar seu pipeline de dados e ajustar sua rede de aprendizado profundo. Como o gráfico a seguir descreve, uma implementação simples ou básica de uma rede neural pode usar a GPU de maneira inconsistente e não aproveitar o potencial máximo. Ao otimizar o pré-processamento e o carregamento de dados, você pode reduzir o gargalo da CPU para a GPU. Você pode ajustar a rede neural em si usando hibridização (quando compatível com a estrutura), ajustando o tamanho do lote e sincronizando as chamadas. Você também pode usar treinamento de precisão múltipla (float16 ou int8) na maioria das estruturas, o que pode causar um efeito enorme na melhoria da taxa de transferência. A tabela a seguir mostra os ganhos de desempenho cumulativos ao aplicar otimizações diferentes. Seus resultados dependerão dos dados que você está processando e da rede que está otimizando. ![\[Aprimoramentos de desempenho para GPUs\]](http://docs.aws.amazon.com/pt_br/dlami/latest/devguide/images/performance-enhancements.png) Os seguintes guias apresentam opções que funcionarão com a DLAMI e ajudarão a aumentar o desempenho da GPU. **Topics** + [ # Pré-processamento ](tutorial-gpu-opt-preprocessing.md) + [ # Treinamento ](tutorial-gpu-opt-training.md) # Pré-processamento O pré-processamento de dados durante transformações ou aumento muitas vezes pode ser um processo vinculado à CPU e isso pode ser o gargalo em todo o seu pipeline. Estruturas têm operadores integrados para processamento de imagens, mas a DALI (Data Augmentation Library) demonstra um melhor desempenho em relação às opções integradas das estruturas. + NVIDIA Data Augmentation Library (DALI): a DALI minimiza o aumento dos dados para a GPU. Não é pré-instalada na DLAMI, mas você pode ter acesso instalando-a ou carregando um contêiner de estrutura compatível na sua DLAMI ou em outra instância do Amazon Elastic Compute Cloud. Consulte a [página do projeto DALI](https://docs.nvidia.com/deeplearning/sdk/dali-install-guide/index.html) no site do NVIDIA para obter detalhes. Para ver um exemplo de caso de uso e baixar amostras de código, consulte a amostra de desempenho do [treinamento SageMaker de pré-processamento](https://github.com/aws-samples/sagemaker-cv-preprocessing-training-performance). + nvJPEG: uma biblioteca de decodificadores JPEG acelerados para GPU para programadores de C. Ela oferece suporte à decodificação de imagens ou lotes únicos, bem como operações de transformação subsequentes que são comuns em aprendizado profundo. A nvJPEG vem integrada à DALI, ou você pode fazer download da [página nvjpeg do site da NVIDIA](https://developer.nvidia.com/nvjpeg) e usá-la separadamente. Você pode estar interessado nesses outros tópicos sobre monitoramento e otimização de GPU: + [Monitoramento](tutorial-gpu-monitoring.md) + [Monitor GPUs com CloudWatch](tutorial-gpu-monitoring-gpumon.md) + [Otimização](tutorial-gpu-opt.md) + [Pré-processamento](#tutorial-gpu-opt-preprocessing) + [Treinamento](tutorial-gpu-opt-training.md) # Treinamento Com treinamento de precisão mista, você pode implantar redes maiores com a mesma quantidade de memória ou reduzir o uso de memória em comparação com sua rede de precisão única ou dupla, e você verá aumentos de desempenho de computação. Você também pode obter o benefício de transferências de dados menores e mais rápidas, um fator importante em um treinamento distribuído em vários nós. Para aproveitar o treinamento de precisão mista, você precisa ajustar a conversão de dados e a escalabilidade de perdas. Veja a seguir os guias que descrevem como fazer isso para as estruturas que oferecem suporte à precisão mista. + [SDK de aprendizado profundo da NVIDIA](https://docs.nvidia.com/deeplearning/sdk/mixed-precision-training/) - documentos no site da NVIDIA descrevendo a implementação de precisão mista para, e. MXNet PyTorch TensorFlow **dica** Verifique se o site oferece a estrutura de sua preferência e procure por "precisão mista" ou "fp16" para encontrar as técnicas de otimização mais recentes. Veja a seguir alguns guias sobre precisão mista que podem ser úteis: [Treinamento de precisão mista com TensorFlow (vídeo)](https://devblogs.nvidia.com/mixed-precision-resnet-50-tensor-cores/) - no site do blog da NVIDIA. [Treinamento de precisão mista usando float16 com MXNet](https://mxnet.apache.org/api/faq/float16) - um artigo de perguntas frequentes no site. MXNet [NVIDIA Apex: uma ferramenta para treinamento fácil de precisão mista com PyTorch](https://devblogs.nvidia.com/apex-pytorch-easy-mixed-precision-training/) - um artigo de blog no site da NVIDIA. Você pode estar interessado nesses outros tópicos sobre monitoramento e otimização de GPU: + [Monitoramento](tutorial-gpu-monitoring.md) + [Monitor GPUs com CloudWatch](tutorial-gpu-monitoring-gpumon.md) + [Otimização](tutorial-gpu-opt.md) + [Pré-processamento](tutorial-gpu-opt-preprocessing.md) + [Treinamento](#tutorial-gpu-opt-training) # O chip de AWS inferência com DLAMI AWS O Inferentia é um chip de aprendizado de máquina personalizado projetado por AWS ele que você pode usar para previsões de inferência de alto desempenho. Para usar o chip, configure uma instância Amazon Elastic Compute Cloud e use o kit de desenvolvimento de software (SDK) AWS Neuron para invocar o chip Inferentia. Para fornecer aos clientes a melhor experiência no Inferentia, o Neuron foi integrado à AMIs de deep learning da AWS (DLAMI). Os tópicos a seguir mostram como começar a usar o Inferentia com a DLAMI. **Topics** + [ # Lançamento de uma instância DLAMI com Neuron AWS ](tutorial-inferentia-launching.md) + [ # Usando o DLAMI com Neuron AWS ](tutorial-inferentia-using.md) # Lançamento de uma instância DLAMI com Neuron AWS O DLAMI mais recente está pronto para uso AWS com o Inferentia e vem com AWS o pacote Neuron API. Para iniciar uma instância da DLAMI, consulte [Iniciar e configurar uma DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html). Depois de ter um DLAMI, use as etapas aqui para garantir que AWS seu chip de inferência AWS e os recursos do Neuron estejam ativos. **Topics** + [ ## Verifique a instância ](#tutorial-inferentia-launching-verify) + [ ## Identificação de AWS dispositivos de inferência ](#tutorial-inferentia-launching-identify) + [ ## Exibir o uso de recursos ](#tutorial-inferentia-launching-resource-usage) + [ ## Como usar o Monitor do Neuron ](#tutorial-inferentia-launching-neuron-monitor) + [ ## Atualização do software Neuron ](#tutorial-inferentia-launching-upgrade) ## Verifique a instância Antes de usar a instância, verifique se ela está corretamente definida e configurada com o Neuron. ## Identificação de AWS dispositivos de inferência Para identificar o número de dispositivos do Inferentia na sua instância, use o seguinte comando: ``` neuron-ls ``` Se a instância tiver dispositivos do Inferentia conectados a ela, a saída será semelhante à seguinte: ``` +--------+--------+--------+-----------+--------------+ | NEURON | NEURON | NEURON | CONNECTED | PCI | | DEVICE | CORES | MEMORY | DEVICES | BDF | +--------+--------+--------+-----------+--------------+ | 0 | 4 | 8 GB | 1 | 0000:00:1c.0 | | 1 | 4 | 8 GB | 2, 0 | 0000:00:1d.0 | | 2 | 4 | 8 GB | 3, 1 | 0000:00:1e.0 | | 3 | 4 | 8 GB | 2 | 0000:00:1f.0 | +--------+--------+--------+-----------+--------------+ ``` O resultado fornecido é obtido de uma instância Inf1.6xlarge e inclui as seguintes colunas: + DISPOSITIVO NEURONAL: O ID lógico atribuído ao NeuronDevice. Esse ID é usado ao configurar vários tempos de execução para usar diferentes. NeuronDevices + NÚCLEOS DE NEURÔNIOS: O número de NeuronCores presentes no NeuronDevice. + MEMÓRIA NEURONAL: A quantidade de memória DRAM no. NeuronDevice + DISPOSITIVOS CONECTADOS: Outros NeuronDevices conectados ao NeuronDevice. + PCI BDF: O ID da função de dispositivo de barramento PCI (BDF) do. NeuronDevice ## Exibir o uso de recursos Visualize informações úteis sobre a NeuronCore utilização da vCPU, o uso da memória, os modelos carregados e os aplicativos Neuron com o comando. `neuron-top` O lançamento `neuron-top` sem argumentos mostrará os dados de todos os aplicativos de aprendizado de máquina que utilizam NeuronCores. ``` neuron-top ``` Quando um aplicativo está usando quatro NeuronCores, a saída deve ser semelhante à imagem a seguir: ![\[A saída do neuron-top comando, com as informações de um dos quatro NeuronCores destacadas.\]](http://docs.aws.amazon.com/pt_br/dlami/latest/devguide/images/neuron-top-output.png) Para obter mais informações sobre recursos para monitorar e otimizar aplicações de inferência que usam como base o Neuron, consulte [Ferramentas do Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/index.html). ## Como usar o Monitor do Neuron O Monitor do Neuron coleta métricas dos runtimes do Neuron em execução no sistema e transmite os dados coletados para stdout no formato JSON. Elas são organizadas em grupos de métricas que você configura fornecendo um arquivo de configuração. Para obter mais informações sobre o Monitor do Neuron, consulte o [Guia do usuário do monitor do Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/neuron-monitor-user-guide.html). ## Atualização do software Neuron [Para obter informações sobre como atualizar o software Neuron SDK no DLAMI, consulte o Guia de configuração do Neuron. AWS](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-intro/neuron-install-guide.html) **Próxima etapa** [Usando o DLAMI com Neuron AWS](tutorial-inferentia-using.md) # Usando o DLAMI com Neuron AWS Um fluxo de trabalho típico com o AWS Neuron SDK é compilar um modelo de aprendizado de máquina previamente treinado em um servidor de compilação. Depois disso, distribua os artefatos para as instâncias Inf1 para execução. AMIs de deep learning da AWS (DLAMI) vem pré-instalado com tudo o que você precisa para compilar e executar inferência em uma instância Inf1 que usa Inferentia. As seções a seguir descrevem como usar a DLAMI com o Inferentia. **Topics** + [ # Usando TensorFlow -Neuron e o compilador Neuron AWS ](tutorial-inferentia-tf-neuron.md) + [ # Usando AWS Neuron Serving TensorFlow ](tutorial-inferentia-tf-neuron-serving.md) + [ # Usando MXNet -Neuron e o compilador Neuron AWS ](tutorial-inferentia-mxnet-neuron.md) + [ # Usando o MXNet -Neuron Model Serving ](tutorial-inferentia-mxnet-neuron-serving.md) + [ # Usando PyTorch -Neuron e o compilador Neuron AWS ](tutorial-inferentia-pytorch-neuron.md) # Usando TensorFlow -Neuron e o compilador Neuron AWS Este tutorial mostra como usar o compilador AWS Neuron para compilar o modelo Keras ResNet -50 e exportá-lo como um modelo salvo em formato. SavedModel Esse formato é um formato típico de TensorFlow modelo intercambiável. Você também aprenderá a executar a inferência em uma instância do Inf1 com exemplo de entrada.  Para obter mais informações sobre o SDK do Neuron, consulte a [Documentação do SDK do AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html). **Topics** + [ ## Pré-requisitos ](#tutorial-inferentia-tf-neuron-prerequisites) + [ ## Ative o ambiente Conda ](#tutorial-inferentia-tf-neuron-activate) + [ ## Compilação ResNet50 ](#tutorial-inferentia-tf-neuron-compilation) + [ ## ResNet50 Inferência ](#tutorial-inferentia-tf-neuron-inference) ## Pré-requisitos Antes de usar este tutorial, você precisa ter concluído os passos da configuração em [Lançamento de uma instância DLAMI com Neuron AWS](tutorial-inferentia-launching.md). Também é necessário conhecer a aprendizagem profunda e o uso da DLAMI. ## Ative o ambiente Conda Ative o ambiente TensorFlow -Neuron conda usando o seguinte comando: ``` source activate aws_neuron_tensorflow_p36 ``` Para sair do ambiente Conda atual, execute o seguinte comando: ``` source deactivate ``` ## Compilação ResNet50 Crie um script Python chamado **tensorflow\$1compile\$1resnet50.py** com o seguinte conteúdo. Esse script Python compila o modelo Keras ResNet 50 e o exporta como um modelo salvo. ``` import os import time import shutil import tensorflow as tf import tensorflow.neuron as tfn import tensorflow.compat.v1.keras as keras from tensorflow.keras.applications.resnet50 import ResNet50 from tensorflow.keras.applications.resnet50 import preprocess_input # Create a workspace WORKSPACE = './ws_resnet50' os.makedirs(WORKSPACE, exist_ok=True) # Prepare export directory (old one removed) model_dir = os.path.join(WORKSPACE, 'resnet50') compiled_model_dir = os.path.join(WORKSPACE, 'resnet50_neuron') shutil.rmtree(model_dir, ignore_errors=True) shutil.rmtree(compiled_model_dir, ignore_errors=True) # Instantiate Keras ResNet50 model keras.backend.set_learning_phase(0) model = ResNet50(weights='imagenet') # Export SavedModel tf.saved_model.simple_save(  session            = keras.backend.get_session(),  export_dir         = model_dir,  inputs             = {'input': model.inputs[0]},  outputs            = {'output': model.outputs[0]}) # Compile using Neuron tfn.saved_model.compile(model_dir, compiled_model_dir) # Prepare SavedModel for uploading to Inf1 instance shutil.make_archive(compiled_model_dir, 'zip', WORKSPACE, 'resnet50_neuron') ``` Compile o modelo usando o seguinte comando: ``` python tensorflow_compile_resnet50.py ``` O processo de compilação leva alguns minutos. Quando concluído, sua saída será semelhante a: ``` ... INFO:tensorflow:fusing subgraph neuron_op_d6f098c01c780733 with neuron-cc INFO:tensorflow:Number of operations in TensorFlow session: 4638 INFO:tensorflow:Number of operations after tf.neuron optimizations: 556 INFO:tensorflow:Number of operations placed on Neuron runtime: 554 INFO:tensorflow:Successfully converted ./ws_resnet50/resnet50 to ./ws_resnet50/resnet50_neuron ... ``` ​ Após a compilação, o modelo salvo será compactado em **ws\$1resnet50/resnet50\$1neuron.zip**. Descompacte o modelo e faça download da imagem de exemplo para a inferência, usando os seguintes comandos: ``` unzip ws_resnet50/resnet50_neuron.zip -d . curl -O https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg ``` ## ResNet50 Inferência Crie um script Python chamado **tensorflow\$1infer\$1resnet50.py** com o seguinte conteúdo. Esse script executa a inferência no modelo obtido por download usando um modelo de inferência previamente compilado. ``` import os import numpy as np import tensorflow as tf from tensorflow.keras.preprocessing import image from tensorflow.keras.applications import resnet50 # Create input from image img_sgl = image.load_img('kitten_small.jpg', target_size=(224, 224)) img_arr = image.img_to_array(img_sgl) img_arr2 = np.expand_dims(img_arr, axis=0) img_arr3 = resnet50.preprocess_input(img_arr2) # Load model COMPILED_MODEL_DIR = './ws_resnet50/resnet50_neuron/' predictor_inferentia = tf.contrib.predictor.from_saved_model(COMPILED_MODEL_DIR) # Run inference model_feed_dict={'input': img_arr3} infa_rslts = predictor_inferentia(model_feed_dict); # Display results print(resnet50.decode_predictions(infa_rslts["output"], top=5)[0]) ``` Execute a inferência no modelo usando o seguinte comando: ``` python tensorflow_infer_resnet50.py ``` A saída será semelhante a: ``` ... [('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)] ``` **Próxima etapa** [Usando AWS Neuron Serving TensorFlow](tutorial-inferentia-tf-neuron-serving.md) # Usando AWS Neuron Serving TensorFlow Este tutorial mostra como construir um gráfico e adicionar uma etapa de compilação do AWS Neuron antes de exportar o modelo salvo para uso com o Serving. TensorFlow TensorFlow Serving é um sistema de atendimento que permite ampliar a inferência em uma rede. O Neuron TensorFlow Serving usa a mesma API do TensorFlow Serving normal. A única diferença é que um modelo salvo deve ser compilado para AWS Inferentia e o ponto de entrada é um binário diferente chamado`tensorflow_model_server_neuron`. O binário é encontrado em `/usr/local/bin/tensorflow_model_server_neuron` e é pré-instalado na DLAMI. Para obter mais informações sobre o SDK do Neuron, consulte a [Documentação do SDK do AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html). **Topics** + [ ## Pré-requisitos ](#tutorial-inferentia-tf-neuron--serving-prerequisites) + [ ## Ative o ambiente Conda ](#tutorial-inferentia-tf-neuron-serving-activate) + [ ## Compile e exporte o modelo salvo ](#tutorial-inferentia-tf-neuron-serving-compile) + [ ## Fornecer o modelo salvo ](#tutorial-inferentia-tf-neuron-serving-serving) + [ ## Gerar solicitações de inferência para o modelo de servidor ](#tutorial-inferentia-tf-neuron-serving-inference) ## Pré-requisitos Antes de usar este tutorial, você precisa ter concluído os passos da configuração em [Lançamento de uma instância DLAMI com Neuron AWS](tutorial-inferentia-launching.md). Também é necessário conhecer a aprendizagem profunda e o uso da DLAMI. ## Ative o ambiente Conda Ative o ambiente TensorFlow -Neuron conda usando o seguinte comando: ``` source activate aws_neuron_tensorflow_p36 ``` Se você precisar sair do ambiente Conda atual, execute: ``` source deactivate ``` ## Compile e exporte o modelo salvo Crie um script Python chamado `tensorflow-model-server-compile.py` com o conteúdo a seguir. Ele constrói um gráfico e o compila usando o Neuron. Depois, exporta o gráfico compilado como modelo salvo.  ``` import tensorflow as tf import tensorflow.neuron import os tf.keras.backend.set_learning_phase(0) model = tf.keras.applications.ResNet50(weights='imagenet') sess = tf.keras.backend.get_session() inputs = {'input': model.inputs[0]} outputs = {'output': model.outputs[0]} # save the model using tf.saved_model.simple_save modeldir = "./resnet50/1" tf.saved_model.simple_save(sess, modeldir, inputs, outputs) # compile the model for Inferentia neuron_modeldir = os.path.join(os.path.expanduser('~'), 'resnet50_inf1', '1') tf.neuron.saved_model.compile(modeldir, neuron_modeldir, batch_size=1) ``` Compile o modelo usando o seguinte comando: ``` python tensorflow-model-server-compile.py ``` A saída será semelhante a: ``` ... INFO:tensorflow:fusing subgraph neuron_op_d6f098c01c780733 with neuron-cc INFO:tensorflow:Number of operations in TensorFlow session: 4638 INFO:tensorflow:Number of operations after tf.neuron optimizations: 556 INFO:tensorflow:Number of operations placed on Neuron runtime: 554 INFO:tensorflow:Successfully converted ./resnet50/1 to /home/ubuntu/resnet50_inf1/1 ``` ## Fornecer o modelo salvo Depois que o modelo foi compilado, você pode usar o seguinte comando para fornecer o modelo salvo com o binário tensorflow\$1model\$1server\$1neuron: ``` tensorflow_model_server_neuron --model_name=resnet50_inf1 \     --model_base_path=$HOME/resnet50_inf1/ --port=8500 & ``` A saída será semelhante à seguinte: O modelo compilado é preparado na DRAM do dispositivo do Inferentia, pelo servidor, para preparar para a inferência. ``` ... 2019-11-22 01:20:32.075856: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:311] SavedModel load for tags { serve }; Status: success. Took 40764 microseconds. 2019-11-22 01:20:32.075888: I tensorflow_serving/servables/tensorflow/saved_model_warmup.cc:105] No warmup data file found at /home/ubuntu/resnet50_inf1/1/assets.extra/tf_serving_warmup_requests 2019-11-22 01:20:32.075950: I tensorflow_serving/core/loader_harness.cc:87] Successfully loaded servable version {name: resnet50_inf1 version: 1} 2019-11-22 01:20:32.077859: I tensorflow_serving/model_servers/server.cc:353] Running gRPC ModelServer at 0.0.0.0:8500 ... ``` ## Gerar solicitações de inferência para o modelo de servidor Crie um script Python chamado `tensorflow-model-server-infer.py` com o conteúdo a seguir. Esse script executa a inferência via gRPC, que é um framework de serviço. ``` import numpy as np import grpc import tensorflow as tf from tensorflow.keras.preprocessing import image from tensorflow.keras.applications.resnet50 import preprocess_input from tensorflow_serving.apis import predict_pb2 from tensorflow_serving.apis import prediction_service_pb2_grpc from tensorflow.keras.applications.resnet50 import decode_predictions if __name__ == '__main__':     channel = grpc.insecure_channel('localhost:8500')     stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)     img_file = tf.keras.utils.get_file(         "./kitten_small.jpg",         "https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg")     img = image.load_img(img_file, target_size=(224, 224))     img_array = preprocess_input(image.img_to_array(img)[None, ...])     request = predict_pb2.PredictRequest()     request.model_spec.name = 'resnet50_inf1'     request.inputs['input'].CopyFrom(         tf.contrib.util.make_tensor_proto(img_array, shape=img_array.shape))     result = stub.Predict(request)     prediction = tf.make_ndarray(result.outputs['output'])     print(decode_predictions(prediction)) ``` Execute a inferência no modelo usando gRPC com o seguinte comando: ``` python tensorflow-model-server-infer.py ``` A saída será semelhante a: ``` [[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]] ``` # Usando MXNet -Neuron e o compilador Neuron AWS A API de compilação MXNet -Neuron fornece um método para compilar um gráfico de modelo que você pode executar em um dispositivo Inferentia. AWS Neste exemplo, você usa a API para compilar um modelo ResNet -50 e usá-lo para executar inferência. Para obter mais informações sobre o SDK do Neuron, consulte a [Documentação do SDK do AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html). **Topics** + [ ## Pré-requisitos ](#tutorial-inferentia-mxnet-neuron-prerequisites) + [ ## Ative o ambiente Conda ](#tutorial-inferentia-mxnet-neuron-activate) + [ ## Compilação ResNet50 ](#tutorial-inferentia-mxnet-neuron-compilation) + [ ## ResNet50 Inferência ](#tutorial-inferentia-mxnet-neuron-inference) ## Pré-requisitos Antes de usar este tutorial, você precisa ter concluído os passos da configuração em [Lançamento de uma instância DLAMI com Neuron AWS](tutorial-inferentia-launching.md). Também é necessário conhecer a aprendizagem profunda e o uso da DLAMI. ## Ative o ambiente Conda Ative o ambiente MXNet -Neuron conda usando o seguinte comando: ``` source activate aws_neuron_mxnet_p36 ``` Para sair do ambiente Conda atual, execute: ``` source deactivate ``` ## Compilação ResNet50 Crie um script Python chamado **mxnet\$1compile\$1resnet50.py** com o conteúdo a seguir. Esse script usa a API Python de compilação MXNet -Neuron para compilar um modelo -50. ResNet ``` import mxnet as mx import numpy as np print("downloading...") path='http://data.mxnet.io/models/imagenet/' mx.test_utils.download(path+'resnet/50-layers/resnet-50-0000.params') mx.test_utils.download(path+'resnet/50-layers/resnet-50-symbol.json') print("download finished.") sym, args, aux = mx.model.load_checkpoint('resnet-50', 0) print("compile for inferentia using neuron... this will take a few minutes...") inputs = { "data" : mx.nd.ones([1,3,224,224], name='data', dtype='float32') } sym, args, aux = mx.contrib.neuron.compile(sym, args, aux, inputs) print("save compiled model...") mx.model.save_checkpoint("compiled_resnet50", 0, sym, args, aux) ``` Compile o modelo usando o seguinte comando: ``` python mxnet_compile_resnet50.py ``` A compilação demora alguns minutos. Quando ela terminar, os seguintes arquivos estarão no diretório atual: ``` resnet-50-0000.params resnet-50-symbol.json compiled_resnet50-0000.params compiled_resnet50-symbol.json ``` ## ResNet50 Inferência Crie um script Python chamado **mxnet\$1infer\$1resnet50.py** com o conteúdo a seguir. Esse script faz download de uma imagem de amostra e a usa para executar a inferência com o modelo compilado. ``` import mxnet as mx import numpy as np path='http://data.mxnet.io/models/imagenet/' mx.test_utils.download(path+'synset.txt') fname = mx.test_utils.download('https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg') img = mx.image.imread(fname) # convert into format (batch, RGB, width, height) img = mx.image.imresize(img, 224, 224)  # resize img = img.transpose((2, 0, 1))  # Channel first img = img.expand_dims(axis=0)  # batchify img = img.astype(dtype='float32') sym, args, aux = mx.model.load_checkpoint('compiled_resnet50', 0) softmax = mx.nd.random_normal(shape=(1,)) args['softmax_label'] = softmax args['data'] = img # Inferentia context ctx = mx.neuron() exe = sym.bind(ctx=ctx, args=args, aux_states=aux, grad_req='null') with open('synset.txt', 'r') as f:     labels = [l.rstrip() for l in f] exe.forward(data=img) prob = exe.outputs[0].asnumpy() # print the top-5 prob = np.squeeze(prob) a = np.argsort(prob)[::-1]  for i in a[0:5]:     print('probability=%f, class=%s' %(prob[i], labels[i])) ``` Execute a inferência com o modelo compilado usando o seguinte comando: ``` python mxnet_infer_resnet50.py ``` A saída será semelhante a: ``` probability=0.642454, class=n02123045 tabby, tabby cat probability=0.189407, class=n02123159 tiger cat probability=0.100798, class=n02124075 Egyptian cat probability=0.030649, class=n02127052 lynx, catamount probability=0.016278, class=n02129604 tiger, Panthera tigris ``` **Próxima etapa** [Usando o MXNet -Neuron Model Serving](tutorial-inferentia-mxnet-neuron-serving.md) # Usando o MXNet -Neuron Model Serving Neste tutorial, você aprende a usar um MXNet modelo pré-treinado para realizar a classificação de imagens em tempo real com o Multi Model Server (MMS). O MMS é uma easy-to-use ferramenta flexível para servir modelos de aprendizado profundo que são treinados usando qualquer estrutura de aprendizado de máquina ou aprendizado profundo. Este tutorial inclui uma etapa de compilação usando o AWS Neuron e uma implementação do MMS usando. MXNet Para obter mais informações sobre o SDK do Neuron, consulte a [Documentação do SDK do AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html). **Topics** + [ ## Pré-requisitos ](#tutorial-inferentia-mxnet-neuron-serving-prerequisites) + [ ## Ative o ambiente Conda ](#tutorial-inferentia-mxnet-neuron-serving-activate) + [ ## Faça download do código de exemplo ](#tutorial-inferentia-mxnet-neuron-serving-download) + [ ## Compile o modelo. ](#tutorial-inferentia-mxnet-neuron-serving-compile) + [ ## Execute a inferência ](#tutorial-inferentia-mxnet-neuron-serving-inference) ## Pré-requisitos Antes de usar este tutorial, você precisa ter concluído os passos da configuração em [Lançamento de uma instância DLAMI com Neuron AWS](tutorial-inferentia-launching.md). Também é necessário conhecer a aprendizagem profunda e o uso da DLAMI. ## Ative o ambiente Conda Ative o ambiente MXNet -Neuron conda usando o seguinte comando: ``` source activate aws_neuron_mxnet_p36 ``` Para sair do ambiente Conda atual, execute: ``` source deactivate ``` ## Faça download do código de exemplo Para executar o exemplo, faça download do código de exemplo usando os seguintes comandos: ``` git clone https://github.com/awslabs/multi-model-server cd multi-model-server/examples/mxnet_vision ``` ## Compile o modelo. Crie um script Python chamado `multi-model-server-compile.py` com o conteúdo a seguir. Esse script compila o modelo ResNet 50 para o alvo do dispositivo Inferentia. ``` import mxnet as mx from mxnet.contrib import neuron import numpy as np path='http://data.mxnet.io/models/imagenet/' mx.test_utils.download(path+'resnet/50-layers/resnet-50-0000.params') mx.test_utils.download(path+'resnet/50-layers/resnet-50-symbol.json') mx.test_utils.download(path+'synset.txt') nn_name = "resnet-50" #Load a model sym, args, auxs = mx.model.load_checkpoint(nn_name, 0) #Define compilation parameters#  - input shape and dtype inputs = {'data' : mx.nd.zeros([1,3,224,224], dtype='float32') } # compile graph to inferentia target csym, cargs, cauxs = neuron.compile(sym, args, auxs, inputs) # save compiled model mx.model.save_checkpoint(nn_name + "_compiled", 0, csym, cargs, cauxs) ``` Para compilar o modelo, use o seguinte comando: ``` python multi-model-server-compile.py ``` A saída será semelhante a: ``` ... [21:18:40] src/nnvm/legacy_json_util.cc:209: Loading symbol saved by previous version v0.8.0. Attempting to upgrade... [21:18:40] src/nnvm/legacy_json_util.cc:217: Symbol successfully upgraded! [21:19:00] src/operator/subgraph/build_subgraph.cc:698: start to execute partition graph. [21:19:00] src/nnvm/legacy_json_util.cc:209: Loading symbol saved by previous version v0.8.0. Attempting to upgrade... [21:19:00] src/nnvm/legacy_json_util.cc:217: Symbol successfully upgraded! ``` Crie um arquivo chamado `signature.json` com o seguinte conteúdo para configurar o nome e a forma de entrada: ``` {   "inputs": [     {       "data_name": "data",       "data_shape": [         1,         3,         224,         224       ]     }   ] } ``` Faça download do arquivo `synset.txt` usando o seguinte comando: Esse arquivo é uma lista de nomes para classes de ImageNet predição. ``` curl -O https://s3.amazonaws.com/model-server/model_archive_1.0/examples/squeezenet_v1.1/synset.txt ``` Crie uma classe de serviço personalizada seguindo o modelo na pasta `model_server_template`. Copie o modelo para o diretório de trabalho atual usando o seguinte comando: ``` cp -r ../model_service_template/* . ``` Edite o módulo `mxnet_model_service.py` para substituir o contexto `mx.cpu()` pelo contexto `mx.neuron()`, da seguinte forma. Você também precisa comentar a cópia de dados desnecessária `model_input` porque MXNet -Neuron não suporta o NDArray e o Gluon. APIs ``` ... self.mxnet_ctx = mx.neuron() if gpu_id is None else mx.gpu(gpu_id) ... #model_input = [item.as_in_context(self.mxnet_ctx) for item in model_input] ``` Empacote o modelo com arquivador de modelos, usando os seguintes comandos: ``` cd ~/multi-model-server/examples model-archiver --force --model-name resnet-50_compiled --model-path mxnet_vision --handler mxnet_vision_service:handle ``` ## Execute a inferência Inicie o Multi Model Server e carregue o modelo que usa a RESTful API usando os comandos a seguir. Certifique-se de que o **neuron-rtd** está sendo executado com as configurações padrão. ``` cd ~/multi-model-server/ multi-model-server --start --model-store examples > /dev/null # Pipe to log file if you want to keep a log of MMS curl -v -X POST "http://localhost:8081/models?initial_workers=1&max_workers=4&synchronous=true&url=resnet-50_compiled.mar" sleep 10 # allow sufficient time to load model ``` Execute a inferência usando uma imagem de exemplo com os seguintes comandos: ``` curl -O https://raw.githubusercontent.com/awslabs/multi-model-server/master/docs/images/kitten_small.jpg curl -X POST http://127.0.0.1:8080/predictions/resnet-50_compiled -T kitten_small.jpg ``` A saída será semelhante a: ``` [   {     "probability": 0.6388034820556641,     "class": "n02123045 tabby, tabby cat"   },   {     "probability": 0.16900072991847992,     "class": "n02123159 tiger cat"   },   {     "probability": 0.12221276015043259,     "class": "n02124075 Egyptian cat"   },   {     "probability": 0.028706775978207588,     "class": "n02127052 lynx, catamount"   },   {     "probability": 0.01915954425930977,     "class": "n02129604 tiger, Panthera tigris"   } ] ``` Para limpar após o teste, emita um comando delete por meio da RESTful API e interrompa o servidor de modelos usando os seguintes comandos: ``` curl -X DELETE http://127.0.0.1:8081/models/resnet-50_compiled multi-model-server --stop ``` A seguinte saída deverá ser mostrada: ``` {   "status": "Model \"resnet-50_compiled\" unregistered" } Model server stopped. Found 1 models and 1 NCGs. Unloading 10001 (MODEL_STATUS_STARTED) :: success Destroying NCG 1 :: success ``` # Usando PyTorch -Neuron e o compilador Neuron AWS A API de compilação PyTorch -Neuron fornece um método para compilar um gráfico de modelo que você pode executar em um dispositivo Inferentia. AWS Um modelo treinado deve ser compilado para um destino Inferentia antes que ele possa ser implantado em instâncias Inf1. O tutorial a seguir compila o modelo torchvision ResNet 50 e o exporta como um módulo salvo. TorchScript Esse modelo é, assim sendo, usado para executar inferência. Por conveniência, este tutorial usa uma instância Inf1 para compilação e inferência. Na prática, você pode compilar o modelo usando outro tipo de instância, como a família de instâncias c5. Depois, você deve implantar o modelo compilado no servidor de inferência Inf1. Para obter mais informações, consulte a documentação do [AWS Neuron PyTorch SDK.](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/pytorch-neuron/index.html) **Topics** + [ ## Pré-requisitos ](#tutorial-inferentia-pytorch-neuron-prerequisites) + [ ## Ative o ambiente Conda ](#tutorial-inferentia-pytorch-neuron-activate) + [ ## Compilação ResNet50 ](#tutorial-inferentia-pytorch-neuron-compilation) + [ ## ResNet50 Inferência ](#tutorial-inferentia-pytorch-neuron-inference) ## Pré-requisitos Antes de usar este tutorial, você precisa ter concluído os passos da configuração em [Lançamento de uma instância DLAMI com Neuron AWS](tutorial-inferentia-launching.md). Também é necessário conhecer a aprendizagem profunda e o uso da DLAMI. ## Ative o ambiente Conda Ative o ambiente PyTorch -Neuron conda usando o seguinte comando: ``` source activate aws_neuron_pytorch_p36 ``` Para sair do ambiente Conda atual, execute: ``` source deactivate ``` ## Compilação ResNet50 Crie um script Python chamado **pytorch\$1trace\$1resnet50.py** com o conteúdo a seguir. Esse script usa a API Python de compilação PyTorch -Neuron para compilar um modelo -50. ResNet **nota** Há uma dependência entre as versões do torchvision e do pacote torch que você deve conhecer ao compilar os modelos do torchvision. Essas regras de dependência podem ser gerenciadas por meio do pip. Torchvision==0.6.1 corresponde à versão torch==1.5.1, enquanto torchvision==0.8.2 corresponde à versão torch==1.7.1. ``` import torch import numpy as np import os import torch_neuron from torchvision import models image = torch.zeros([1, 3, 224, 224], dtype=torch.float32) ## Load a pretrained ResNet50 model model = models.resnet50(pretrained=True) ## Tell the model we are using it for evaluation (not training) model.eval() model_neuron = torch.neuron.trace(model, example_inputs=[image]) ## Export to saved model model_neuron.save("resnet50_neuron.pt") ``` Execute o script de compilação. ``` python pytorch_trace_resnet50.py ``` A compilação demora alguns minutos. Quando terminar, o modelo compilado será salvo como `resnet50_neuron.pt` no diretório local. ## ResNet50 Inferência Crie um script Python chamado **pytorch\$1infer\$1resnet50.py** com o conteúdo a seguir. Esse script faz download de uma imagem de amostra e a usa para executar a inferência com o modelo compilado. ``` import os import time import torch import torch_neuron import json import numpy as np from urllib import request from torchvision import models, transforms, datasets ## Create an image directory containing a small kitten os.makedirs("./torch_neuron_test/images", exist_ok=True) request.urlretrieve("https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg", "./torch_neuron_test/images/kitten_small.jpg") ## Fetch labels to output the top classifications request.urlretrieve("https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json","imagenet_class_index.json") idx2label = [] with open("imagenet_class_index.json", "r") as read_file: class_idx = json.load(read_file) idx2label = [class_idx[str(k)][1] for k in range(len(class_idx))] ## Import a sample image and normalize it into a tensor normalize = transforms.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) eval_dataset = datasets.ImageFolder( os.path.dirname("./torch_neuron_test/"), transforms.Compose([ transforms.Resize([224, 224]), transforms.ToTensor(), normalize, ]) ) image, _ = eval_dataset[0] image = torch.tensor(image.numpy()[np.newaxis, ...]) ## Load model model_neuron = torch.jit.load( 'resnet50_neuron.pt' ) ## Predict results = model_neuron( image ) # Get the top 5 results top5_idx = results[0].sort()[1][-5:] # Lookup and print the top 5 labels top5_labels = [idx2label[idx] for idx in top5_idx] print("Top 5 labels:\n {}".format(top5_labels) ) ``` Execute a inferência com o modelo compilado usando o seguinte comando: ``` python pytorch_infer_resnet50.py ``` A saída será semelhante a: ``` Top 5 labels: ['tiger', 'lynx', 'tiger_cat', 'Egyptian_cat', 'tabby'] ``` # O ARM64 DLAMI AWS ARM64 As GPUs DLAMIs são projetadas para fornecer alto desempenho e economia para cargas de trabalho de aprendizado profundo. Especificamente, o tipo de instância G5g apresenta o [processador AWS Graviton2](https://aws.amazon.com/ec2/graviton/) baseado em ARM64, que foi desenvolvido do zero AWS e otimizado para a forma como os clientes executam suas cargas de trabalho na nuvem. AWS ARM64 As GPUs DLAMIs são pré-configuradas com Docker, NVIDIA Docker, NVIDIA Driver, CUDA, cuDNN, NCCL, além de estruturas populares de aprendizado de máquina, como e. TensorFlow PyTorch Com o tipo de instância G5g, você pode aproveitar os benefícios de preço e desempenho do Graviton2 para implantar modelos de aprendizado profundo acelerados por GPU a um custo significativamente menor em comparação com instâncias que usam como base x86 com aceleração de GPU. ## Selecione um ARM64 DLAMI Execute uma [instância G5g](https://aws.amazon.com/ec2/instance-types/g5g/) com o ARM64 DLAMI de sua escolha. Para step-by-step obter instruções sobre como iniciar uma DLAMI, [consulte Iniciando e configurando](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html) uma DLAMI. Para obter uma lista das mais recentes ARM64 DLAMIs, consulte as [notas de lançamento do DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/appendix-ami-release-notes.html). ## Conceitos básicos Os tópicos a seguir mostram como começar a usar o ARM64 DLAMI. **Topics** + [ ## Selecione um ARM64 DLAMI ](#tutorial-arm64-select-dlami) + [ ## Conceitos básicos ](#tutorial-arm64-get-started) + [ # Usando a ARM64 GPU DLAMI PyTorch ](tutorial-arm64-pytorch.md) # Usando a ARM64 GPU DLAMI PyTorch O AMIs de deep learning da AWS está pronto para uso com processador Arm64 baseado em processador e vem GPUs otimizado para. PyTorch O ARM64 GPU PyTorch DLAMI inclui um ambiente Python [PyTorch](https://aws.amazon.com/pytorch)pré-configurado [TorchVision](https://pytorch.org/vision/stable/index.html)com, [TorchServe](https://pytorch.org/serve/)e para casos de uso de treinamento e inferência de aprendizado profundo. **Topics** + [ ## Verifique o PyTorch ambiente Python ](#tutorial-arm64-pytorch-environment) + [ ## Execute uma amostra de treinamento com PyTorch ](#tutorial-arm64-pytorch-training) + [ ## Execute uma amostra de inferência com PyTorch ](#tutorial-arm64-pytorch-inference) ## Verifique o PyTorch ambiente Python Conecte-se à sua instância G5g e ative o ambiente básico do Conda com o seguinte comando: ``` source activate base ``` Seu prompt de comando deve indicar que você está trabalhando no ambiente básico do Conda, que contém PyTorch TorchVision, e outras bibliotecas. ``` (base) $ ``` Verifique os caminhos de ferramentas padrão do PyTorch ambiente: ``` (base) $ which python (base) $ which pip (base) $ which conda (base) $ which mamba >>> import torch, torchvision >>> torch.__version__ >>> torchvision.__version__ >>> v = torch.autograd.Variable(torch.randn(10, 3, 224, 224)) >>> v = torch.autograd.Variable(torch.randn(10, 3, 224, 224)).cuda() >>> assert isinstance(v, torch.Tensor) ``` ## Execute uma amostra de treinamento com PyTorch Execute uma amostra de trabalho de treinamento do MNIST: ``` git clone https://github.com/pytorch/examples.git cd examples/mnist python main.py ``` O resultado deve ser semelhante ao seguinte: ``` ... Train Epoch: 14 [56320/60000 (94%)] Loss: 0.021424 Train Epoch: 14 [56960/60000 (95%)] Loss: 0.023695 Train Epoch: 14 [57600/60000 (96%)] Loss: 0.001973 Train Epoch: 14 [58240/60000 (97%)] Loss: 0.007121 Train Epoch: 14 [58880/60000 (98%)] Loss: 0.003717 Train Epoch: 14 [59520/60000 (99%)] Loss: 0.001729 Test set: Average loss: 0.0275, Accuracy: 9916/10000 (99%) ``` ## Execute uma amostra de inferência com PyTorch Use os comandos a seguir para baixar um modelo densenet161 pré-treinado e executar a inferência usando: TorchServe ``` # Set up TorchServe cd $HOME git clone https://github.com/pytorch/serve.git mkdir -p serve/model_store cd serve # Download a pre-trained densenet161 model wget https://download.pytorch.org/models/densenet161-8d451a50.pth >/dev/null # Save the model using torch-model-archiver torch-model-archiver --model-name densenet161 \ --version 1.0 \ --model-file examples/image_classifier/densenet_161/model.py \ --serialized-file densenet161-8d451a50.pth \ --handler image_classifier \ --extra-files examples/image_classifier/index_to_name.json \ --export-path model_store # Start the model server torchserve --start --no-config-snapshots \ --model-store model_store \ --models densenet161=densenet161.mar &> torchserve.log # Wait for the model server to start sleep 30 # Run a prediction request curl http://127.0.0.1:8080/predictions/densenet161 -T examples/image_classifier/kitten.jpg ``` O resultado deve ser semelhante ao seguinte: ``` { "tiger_cat": 0.4693363308906555, "tabby": 0.4633873701095581, "Egyptian_cat": 0.06456123292446136, "lynx": 0.0012828150065615773, "plastic_bag": 0.00023322898778133094 } ``` Use os comandos a seguir para cancelar o registro do modelo densenet161 e parar o servidor: ``` curl -X DELETE http://localhost:8081/models/densenet161/1.0 torchserve --stop ``` O resultado deve ser semelhante ao seguinte: ``` { "status": "Model \"densenet161\" unregistered" } TorchServe has stopped. ``` # Inferência Nesta seção você encontra tutoriais sobre como executar inferências usando as estruturas e ferramentas da DLAMI. ## Ferramentas de inferência + [TensorFlow Servindo](tutorial-tfserving.md) # Fornecimento de modelos Veja a seguir as opções de fornecimento de modelos instaladas na AMI de deep learning com Conda. Clique em uma das opções para saber como usá-la. **Topics** + [ # TensorFlow Servindo ](tutorial-tfserving.md) + [ # TorchServe ](tutorial-torchserve.md) # TensorFlow Servindo TensorFlow O [Serving](https://www.tensorflow.org/tfx/guide/serving) é um sistema de atendimento flexível e de alto desempenho para modelos de aprendizado de máquina. O `tensorflow-serving-api` vem pré-instalado com a DLAMI de framework único. Para usar o serviço tensorflow, primeiro ative o TensorFlow ambiente. ``` $ source /opt/tensorflow/bin/activate ``` Em seguida, use um editor de texto de sua preferência para criar um script com o conteúdo a seguir. Chame-o de `test_train_mnist.py`. Esse script é referenciado no [TensorFlow Tutorial](https://github.com/tensorflow/docs/blob/master/site/en/tutorials/quickstart/beginner.ipynb), que treinará e avaliará um modelo de aprendizado de máquina de rede neural que classifica imagens. ``` import tensorflow as tf mnist = tf.keras.datasets.mnist (x_train, y_train),(x_test, y_test) = mnist.load_data() 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, activation='softmax') ]) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) model.fit(x_train, y_train, epochs=5) model.evaluate(x_test, y_test) ``` Agora execute o script passando o local do servidor, a porta e o nome do arquivo da fotografia do husky como parâmetros. ``` $ /opt/tensorflow/bin/python3 test_train_mnist.py ``` Aguarde. Este script pode demorar um pouco antes de fornecer resultados. Quando o treinamento for concluído, você deverá ver o seguinte: ``` I0000 00:00:1739482012.389276 4284 device_compiler.h:188] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process. 1875/1875 [==============================] - 24s 2ms/step - loss: 0.2973 - accuracy: 0.9134 Epoch 2/5 1875/1875 [==============================] - 3s 2ms/step - loss: 0.1422 - accuracy: 0.9582 Epoch 3/5 1875/1875 [==============================] - 3s 1ms/step - loss: 0.1076 - accuracy: 0.9687 Epoch 4/5 1875/1875 [==============================] - 3s 2ms/step - loss: 0.0872 - accuracy: 0.9731 Epoch 5/5 1875/1875 [==============================] - 3s 1ms/step - loss: 0.0731 - accuracy: 0.9771 313/313 [==============================] - 0s 1ms/step - loss: 0.0749 - accuracy: 0.9780 ``` ## Outros recursos e exemplos Se você estiver interessado em saber mais sobre o TensorFlow Serving, confira o [TensorFlow site](https://www.tensorflow.org/serving/). # TorchServe TorchServe é uma ferramenta flexível para servir modelos de aprendizado profundo que foram exportados do PyTorch. TorchServe vem pré-instalado com a AMI de aprendizado profundo com Conda. Para obter mais informações sobre o uso TorchServe, consulte [Model Server for PyTorch Documentation](https://github.com/pytorch/serve/blob/master/docs/README.md). **Tópicos** ## Ofereça um modelo de classificação de imagens em TorchServe Este tutorial mostra como servir um modelo de classificação de imagens com TorchServe o. Ele usa um modelo DenseNet -161 fornecido pela. PyTorch Quando o servidor está em execução, ele escuta as solicitações de previsão. Quando você carrega uma imagem, neste caso, uma imagem de um gatinho, o servidor retorna uma estimativa das cinco principais classes correspondentes das classes em que o modelo foi treinado. **Para fornecer um exemplo de modelo de classificação de imagens em TorchServe** 1. Conecte-se a uma instância do Amazon Elastic Compute Cloud (Amazon EC2) da AMI de deep learning com o Conda v34 ou posterior. 1. Ative o ambiente `pytorch_p310`. ``` source activate pytorch_p310 ``` 1. Clone o TorchServe repositório e crie um diretório para armazenar seus modelos.  ``` git clone https://github.com/pytorch/serve.git mkdir model_store ``` 1. Arquive o modelo usando o arquivador de modelos. O `extra-files` parâmetro usa um arquivo do `TorchServe` repositório, portanto, atualize o caminho, se necessário. Para obter mais informações sobre o arquivador de modelos, consulte [Torch Model archiver](https://github.com/pytorch/serve/blob/master/model-archiver/README.md) for. TorchServe ``` wget https://download.pytorch.org/models/densenet161-8d451a50.pth torch-model-archiver --model-name densenet161 --version 1.0 --model-file ./serve/examples/image_classifier/densenet_161/model.py --serialized-file densenet161-8d451a50.pth --export-path model_store --extra-files ./serve/examples/image_classifier/index_to_name.json --handler image_classifier ``` 1. Execute TorchServe para iniciar um endpoint. A adição de `> /dev/null` silencia a saída do log. ``` torchserve --start --ncs --model-store model_store --models densenet161.mar > /dev/null ``` 1. Baixe uma imagem de um gatinho e envie-a para o endpoint de TorchServe previsão: ``` curl -O https://s3.amazonaws.com/model-server/inputs/kitten.jpg curl http://127.0.0.1:8080/predictions/densenet161 -T kitten.jpg ``` O endpoint de previsão retorna uma previsão em JSON semelhante às cinco principais previsões a seguir, em que a imagem tem uma probabilidade de 47% de conter um gato egípcio, seguida por uma chance de 46% de ter um gato malhado. ``` { "tiger_cat": 0.46933576464653015, "tabby": 0.463387668132782, "Egyptian_cat": 0.0645613968372345, "lynx": 0.0012828196631744504, "plastic_bag": 0.00023323058849200606 } ``` 1. Ao terminar o teste, interrompa o servidor. ``` torchserve --stop ``` **Outros exemplos** TorchServe tem vários exemplos que você pode executar em sua instância DLAMI. Você pode visualizá-los na [página de exemplos TorchServe do repositório do projeto](https://github.com/pytorch/serve/tree/master/examples). **Mais informações** Para obter mais TorchServe documentação, incluindo como configurar TorchServe o Docker e os TorchServe recursos mais recentes, consulte [a página do TorchServe projeto](https://github.com/pytorch/serve) em GitHub.