deep learning ami › pt_br › dlami › latest › devguide › ... · 2020-06-10 · deep...

Deep Learning AMIGuia do desenvolvedor

Deep Learning AMI Guia do desenvolvedor

Deep Learning AMI: Guia do desenvolvedorCopyright © 2020 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's,in any manner that is likely to cause confusion among customers, or in any manner that disparages or discreditsAmazon. All other trademarks not owned by Amazon are the property of their respective owners, who may or may notbe affiliated with, connected to, or sponsored by Amazon.


Table of ContentsO que é a AWS Deep Learning AMI? .................................................................................................... 1

Sobre este guia .......................................................................................................................... 1Pré-requisitos ............................................................................................................................. 1Exemplo usa .............................................................................................................................. 1Recursos ................................................................................................................................... 2

Estruturas pré-instaladas ..................................................................................................... 2Software de GPU pré-instalado ............................................................................................ 2Suporte ao Elastic Inference ................................................................................................ 3Fornecimento e visualização do modelo ................................................................................. 2

Conceitos básicos ............................................................................................................................... 4Como começar a usar a DLAMI ................................................................................................... 4Seleção de DLAMI ...................................................................................................................... 4

Conda ............................................................................................................................... 5Base ................................................................................................................................. 6CUDA ............................................................................................................................... 7SO ................................................................................................................................... 8

Opções do AMI .......................................................................................................................... 8Conda ............................................................................................................................... 8Base ................................................................................................................................. 9CUDA 10.1 ...................................................................................................................... 10CUDA 10 ......................................................................................................................... 11CUDA 9 .......................................................................................................................... 11CUDA 8 .......................................................................................................................... 11Ubuntu 18.04 ................................................................................................................... 12Ubuntu 16.04 ................................................................................................................... 13Amazon Linux .................................................................................................................. 14Amazon Linux 2 ............................................................................................................... 14Windows .......................................................................................................................... 15

Seleção de instância ................................................................................................................. 16GPU ............................................................................................................................... 17CPU ................................................................................................................................ 17Definição de preço ............................................................................................................ 18

Lançando uma DLAMI ....................................................................................................................... 19Etapa 1: Iniciar uma DLAMI ....................................................................................................... 19Console do EC2 ....................................................................................................................... 20Pesquisa no Marketplace ........................................................................................................... 20Etapa 2: Conectar-se à DLAMI ................................................................................................... 21Etapa 3: Proteger sua instância de DLAMI ................................................................................... 21Etapa 4: Testar a DLAMI ........................................................................................................... 21Limpar ..................................................................................................................................... 21Configuração do Jupyter ............................................................................................................ 22

Proteja o Jupyter .............................................................................................................. 22Iniciar o servidor ............................................................................................................... 23Configurar o cliente. .......................................................................................................... 23Testar fazendo login no servidor de notebook Jupyter ............................................................ 24

Usando uma DLAMI .......................................................................................................................... 28Conda DLAMI .......................................................................................................................... 28

Introdução ao Deep Learning AMI com Conda ...................................................................... 28Etapa 1: Fazer login na DLAMI ........................................................................................... 28Etapa 2: Iniciar o ambiente do MXNet Python 3 .................................................................... 30Etapa 3: Testar um código do MXNet .................................................................................. 30Etapa 4: Alternar para o ambiente do TensorFlow ................................................................. 30Remoção de ambientes ..................................................................................................... 31

Base DLAMI ............................................................................................................................. 31

iii


Uso da Deep Learning Base AMI ........................................................................................ 31Configurar as versões do CUDA ......................................................................................... 31

Notebooks Jupyter .................................................................................................................... 32Navegar pelos tutoriais instalados ....................................................................................... 33Alternar ambientes com o Jupyter ....................................................................................... 33

Tutoriais .................................................................................................................................. 33Tutoriais de 10 minutos ..................................................................................................... 34Ativar estruturas ............................................................................................................... 34Depuração e visualização .................................................................................................. 48Treinamento distribuído ...................................................................................................... 51Adaptador de malha elástica .............................................................................................. 68Monitoramento e otimização de GPU ................................................................................... 77AWS Inferentia ................................................................................................................. 82Inferência ......................................................................................................................... 99Como usar Estruturas de acesso com ONNX ...................................................................... 103Fornecimento de modelos ................................................................................................ 112

Atualizando seu DLAMI .................................................................................................................... 117Atualização da DLAMI ............................................................................................................. 117Atualizações de software .......................................................................................................... 117

Segurança ...................................................................................................................................... 119Proteção de dados .................................................................................................................. 119Identity and Access Management .............................................................................................. 120

Autenticação com identidades ........................................................................................... 120Gerenciamento do acesso usando políticas ......................................................................... 122IAM por Amazon EMR ..................................................................................................... 124

Registro e monitoramento ........................................................................................................ 124Validação de conformidade ....................................................................................................... 124Resiliência .............................................................................................................................. 125Segurança da infraestrutura ...................................................................................................... 125

Informações relacionadas ................................................................................................................. 126Fóruns ................................................................................................................................... 126Blogs ..................................................................................................................................... 126Perguntas frequentes ............................................................................................................... 126

Notas de release do DLAMI ............................................................................................................. 129Notas de release anteriores do DLAMI ....................................................................................... 129

Defasagens de DLAMI ..................................................................................................................... 131Histórico de documentos .................................................................................................................. 133AWS Glossary ................................................................................................................................ 136

iv

Deep Learning AMI Guia do desenvolvedorSobre este guia

O que é a AWS Deep Learning AMI?Bem-vindo ao Guia do usuário da AWS Deep Learning AMI.

A AWS Deep Learning AMI (DLAMI) é o único local para deep learning na nuvem. Essa instância demáquina personalizada está disponível na maioria das regiões do Amazon EC2 para vários tipos deinstância, de uma instância pequena de apenas CPU até instâncias de várias GPUs com alta potência.Ela é fornecida pré-configurada com o NVIDIA CUDA e o NVIDIA cuDNN, bem como com as versões maisrecentes das estruturas de deep learning mais populares.

Sobre este guiaEste guia ajudará você a iniciar e usar a DLAMI. Ele abrange vários casos de uso que são comunsem deep learning, para treinamento e inferência. A escolha da AMI correta para o objetivo e o tipo deinstâncias de sua preferência também é abordada. A DLAMI é fornecida com vários tutoriais para cadauma das estruturas. Ele também tem tutoriais sobre treinamento distribuído, depuração, uso do AWSInferentia e outros conceitos-chave. Você encontrará instruções sobre como configurar o Jupyter paraexecutar os tutoriais em seu navegador.

Pré-requisitosVocê deve estar familiarizado com ferramentas de linha de comando e o Python básico para executar aDLAMI com êxito. Tutoriais sobre como usar cada estrutura são fornecidos pelas próprias estruturas, noentanto, este guia pode mostrar como ativar cada uma delas e encontrar os tutoriais apropriados paracomeçar a usar.

Exemplo DLAMI usaAprender sobre deep learning: a DLAMI é uma ótima escolha para o aprendizado ou o ensino de estruturasde Machine Learning e deep learning. Ela acaba com a dor de cabeça de solucionar problemas dasinstalações de cada estrutura e de fazê-las funcionar em conjunto no mesmo computador. A DLAMI éfornecida com um Jupyter notebook e facilita a execução dos tutoriais fornecidos pelas estruturas parapessoas não familiarizadas com Machine Learning e deep learning.

Desenvolvimento de aplicativos: se você for um desenvolvedor de aplicativos e estiver interessado emusar deep learning para fazer com que seus aplicativos usem os últimos avanços de AI, a DLAMI é ocampo de teste perfeito para você. Cada estrutura é fornecida com tutoriais sobre como começar a usaro deep learning, e muitas têm vários modelos que facilitam testar o deep learning sem precisar criar asredes neurais você mesmo ou fazer qualquer treinamento de modelo. Alguns exemplos mostram comocriar um aplicativo de detecção de imagem em apenas alguns minutos, ou como criar um aplicativo dereconhecimento de voz para seu próprio chatbot.

Machine Learning e análise de dados: se você for um cientista de dados ou estiver interessado emprocessar seus dados com deep learning, descobrirá que muitas das estruturas são compatíveis com Re Spark. Você encontrará tutoriais sobre como fazer regressões simples, até a criação de sistemas deprocessamento de dados escaláveis para sistemas de personalização e previsões.

Pesquisa: se você for um pesquisador e quiser experimentar uma nova estrutura, testar um novo modeloou treinar novos modelos, a DLAMI e os recursos da AWS para escala podem aliviar o problema de

1

https://developer.nvidia.com/cuda-zone

https://developer.nvidia.com/cudnn

Deep Learning AMI Guia do desenvolvedorRecursos

instalações tediosas e o gerenciamento de vários nós de treinamento. Você pode usar os modelos do EMRe do AWS CloudFormation para lançar facilmente um cluster repleto de instâncias prontas para uso paratreinamento escalável.

Note

Embora a escolha inicial possa ser atualizar seu tipo de instância para um tipo de instânciamaior com mais GPUs (até 8), você também pode escalar horizontalmente criando um clusterde instâncias de DLAMI. Para configurar rapidamente um cluster, você pode usar o modelopredefinido do AWS CloudFormation. Confira Informações relacionadas (p. 126) para obter maisinformações sobre criações de clusters.

Recursos da DLAMIEstruturas pré-instaladasNo momento, há dois tipos principais da DLAMI com outras variações relacionadas ao sistema operacional(SO) e às versões de software:

• Deep Learning AMI com Conda (p. 5) – estruturas instaladas separadamente usando pacotes doconda e ambientes separados do Python

• Deep Learning Base AMI (p. 6) - sem estruturas instaladas; apenas NVIDIA CUDA e outrasdependências

A Deep Learning AMI com Conda usa ambientes Anaconda para isolar cada estrutura de trabalho, paraque você possa alternar entre eles conforme sua necessidade e para que não se preocupe com suasdependências conflitantes.

Para obter mais informações sobre como selecionar a melhor DLAMI para você, visite Conceitosbásicos (p. 4).

Esta é a lista completa de estruturas compatíveis com o Deep Learning AMI com Conda:

• Apache MXNet• Chainer• Keras• PyTorch• TensorFlow• TensorFlow 2

Note

Não incluímos mais os ambientes CNTK, Caffe, Caffe2 e Theano Conda no AWS Deep LearningAMI desde a versão v28. As versões anteriores do AWS Deep Learning AMI que contêm essesambientes continuarão disponíveis. No entanto, só forneceremos atualizações para essesambientes se houver correções de segurança publicadas pela comunidade de código abertodessas estruturas de trabalho.

Software de GPU pré-instaladoMesmo se você usar uma instância apenas para CPU, o DLAMI terá NVIDIA CUDA e NVIDIA cuDNN. Osoftware instalado é o mesmo, independentemente do tipo de instância. Lembre-se de que as ferramentas

2




Deep Learning AMI Guia do desenvolvedorSuporte ao Elastic Inference

específicas à GPU só funcionam em uma instância que tenha pelo menos uma GPU. Mais informaçõessobre isso são fornecidas em Seleção do tipo de instância para DLAMI (p. 16).

• Versão mais recente do NVIDIA CUDA• Versão mais recente do NVIDIA cuDNN• Versões mais antigas do CUDA também estão disponíveis. Consulte Instalações do CUDA e

associações da estrutura (p. 7) para obter mais informações.

Suporte ao Elastic InferenceA Deep Learning AMI com Conda vem com ambientes compatíveis com o Elastic Inference para AWSDeep Learning AMI, opções do Ubuntu 16.04 (p. 13) e Opções do AWS Deep Learning AMI AmazonLinux (p. 14). Os ambientes do Elastic Inference não são atualmente compatíveis com AWS DeepLearning AMI, opções do Ubuntu 18.04 (p. 12) e Opções do AWS Deep Learning AMI Amazon Linux2 (p. 14). Para obter tutoriais e mais informações sobre o Elastic Inference, consulte a Documentaçãodo Elastic Inference.

Fornecimento e visualização do modeloA Deep Learning AMI com Conda vem pré-instalada com dois tipos de servidores modelo, um para MXNete um para TensorFlow, bem como TensorBoard, para visualizações de modelos.

• Model Server para Apache MXNet (MMS) (p. 112)• TensorFlow Serving (p. 114)• TensorBoard (p. 50)

3



https://docs.aws.amazon.com/elastic-inference/latest/developerguide/what-is-ei.html


Deep Learning AMI Guia do desenvolvedorComo começar a usar a DLAMI

Conceitos básicos

Como começar a usar a DLAMIÉ fácil começar. Neste guia, estão incluídas dicas de como selecionar a DLAMI correta para você coma seleção de um tipo de instância que se adequa a seu caso de uso e a seu orçamento, e Informaçõesrelacionadas (p. 126) que descreve configurações personalizadas que podem ser de seu interesse.

Se você não estiver familiarizado com o uso da AWS ou do Amazon EC2, comece com a Deep LearningAMI com Conda (p. 5). Se estiver familiarizado com o Amazon EC2 e outros serviços da AWS, comoo Amazon EMR, o Amazon EFS ou o Amazon S3, e estiver interessado em integrar esses serviços paraprojetos que precisam de treinamento distribuído ou inferência, confira Informações relacionadas (p. 126)para ver o que se adequa a seu caso de uso.

Recomendamos que você confira Escolhendo sua DLAMI (p. 4) para ter uma ideia do tipo de instânciaque pode ser melhor para seu aplicativo.

Outra opção é esse tutorial rápido: Executar um AWS Deep Learning AMI (em 10 minutos).

Próxima etapa

Escolhendo sua DLAMI (p. 4)

Escolhendo sua DLAMILá, você pode encontrar muitas opções para sua DLAMI, e não está claro qual é a mais adequada paraseu caso de uso. Esta seção ajuda você a decidir. Quando nos referimos a uma DLAMI, muitas vezesestamos nos referindo a um grupo de AMIs centralizadas em torno de um tipo ou de uma funcionalidadecomum. Há três variáveis que definem esses tipos e/ou funcionalidade:

• Conda versus Base• CUDA 8 versus CUDA 9 versus CUDA 10• Amazon Linux versus Ubuntu versus Windows

O restante dos tópicos deste guia ajuda você a obter mais informações e mais detalhes.

Tópicos• Deep Learning AMI com Conda (p. 5)• Deep Learning Base AMI (p. 6)• Instalações do CUDA e associações da estrutura (p. 7)• Opções do sistema operacional da DLAMI (p. 8)

A seguir

Deep Learning AMI com Conda (p. 5)

4

https://aws.amazon.com/getting-started/tutorials/get-started-dlami/

Deep Learning AMI Guia do desenvolvedorConda

Deep Learning AMI com CondaO Conda DLAMI usa ambientes virtuais de Anaconda. Esses ambientes são configurados para manter asinstalações de estruturas diferentes separadas. Também facilita a alternância entre estruturas. Isso é ótimopara aprendizado e testes com todas as estruturas que a DLAMI tem para oferecer. A maioria dos usuáriosacreditam que a nova Deep Learning AMI com Conda é perfeita para eles.

Essas AMIs "Conda" serão as DLAMI principais. Elas serão atualizadas frequentemente com as versõesmais recentes das estruturas, e terão o software e os drivers de GPU mais recentes. Geralmente, ela éreferenciada como a AWS Deep Learning AMI na maioria dos documentos.

• A DLAMI do Ubuntu 18.04 tem as seguintes estruturas: Apache MXNet, Chainer, PyTorch, TensorFlow eTensorFlow 2.

• A DLAMI do Ubuntu 16.04 e do Amazon Linux tem as seguintes estruturas de trabalho: Apache MXNet,Chainer, Keras, PyTorch, TensorFlow e TensorFlow 2

• A DLAMI do Amazon Linux 2 tem as seguintes estruturas: Apache MXNet, Chainer, PyTorch,TensorFlow, TensorFlow 2, e Keras.

Note


Estabilidade versus Release CandidatesAs AMIs do Conda usam binários otimizados dos lançamentos formais mais recentes de cada estrutura.Versões "release candidate" e recursos experimentais não devem ser esperados. As otimizaçõesdependem do suporte que a estrutura oferece para tecnologias de aceleração como a DNN MKL da Intel,que acelera o treinamento e a inferência em tipos de instância de CPU C4 e C5. Os binários tambémestão compilados para oferecer suporte aos conjuntos de instrução Intel avançados, incluindo, entreoutros, AVX, AVX-2, SSE4.1 e SSE4.2. Essas operações de vetor de aceleração e de ponto de flutuaçãonas arquiteturas de Intel CPU. Além disso, para tipos de instância de GPU, o CUDA e o cuDNN serãoatualizados com qualquer versão compatível com o release oficial mais recente.

A Deep Learning AMI com Conda instala automaticamente a versão mais otimizada da estrutura para suainstância do EC2 após a primeira ativação da estrutura. Para obter mais informações, consulte Uso daDeep Learning AMI com Conda (p. 28).

Se você deseja realizar a instalação da origem usando opções de compilação personalizadas ouotimizadas, a de Deep Learning Base AMI (p. 6) pode ser a melhor opção para você.

Defasagem do Python 2A comunidade de código aberto Python encerrou oficialmente o suporte para Python 2 em 1 de janeiro de2020. As comunidades TensorFlow e PyTorch anunciaram que as versões TensorFlow 2.1 e PyTorch 1.4serão as últimas compatíveis com Python 2. As versões anteriores da DLAMI (v26, v25 etc.) que contêmambientes Python 2 Conda continuarão disponíveis. No entanto, forneceremos atualizações para osambientes Python 2 Conda nas versões da DLAMI publicadas anteriormente somente se houver correçõesde segurança publicadas pela comunidade de código aberto para essas versões. As versões da DLAMIcom as próximas versões das estruturas TensorFlow e PyTorch não conterão os ambientes Python 2Conda.

5

Deep Learning AMI Guia do desenvolvedorBase

Suporte ao Elastic InferenceA Deep Learning AMI com Conda vem com ambientes compatíveis com o Elastic Inference para AWSDeep Learning AMI, opções do Ubuntu 16.04 (p. 13) e Opções do AWS Deep Learning AMI AmazonLinux (p. 14). Os ambientes do Elastic Inference não são atualmente compatíveis com AWS DeepLearning AMI, opções do Ubuntu 18.04 (p. 12) e Opções do AWS Deep Learning AMI Amazon Linux2 (p. 14). Para obter tutoriais e mais informações sobre o Elastic Inference, consulte a Documentaçãodo Elastic Inference.

CUDA SupportA versão CUDA da Deep Learning AMI com Conda e as estruturas compatíveis com cada uma:

• CUDA 10.1 com cuDNN 7: Apache MXNet• CUDA 10 com cuDNN 7: PyTorch, TensorFlow, TensorFlow 2, Apache MXNet, Chainer

Os números de versões de uma estrutura em específico podem ser encontrados no Notas de release doDLAMI (p. 129)

Escolha este tipo de DLAMI ou saiba mais sobre as diferentes DLAMI com a opção a seguir.

• Opções da Deep Learning AMI com Conda (p. 8)

A seguir

Deep Learning Base AMI (p. 6)

Tópicos relacionados• Para obter um tutorial sobre como usar uma Deep Learning AMI com Conda, consulte o tutorial Uso da

Deep Learning AMI com Conda (p. 28).

Deep Learning Base AMIA Deep Learning Base AMI é como uma tela vazia para deep learning. Ela vem com tudo o que vocêprecisa até o ponto da instalação de uma determinada estrutura. Ela terá sua opção de versões de CUDA.

Por que optar pela DLAMI Base?Esse grupo de AMIs é útil para colaboradores de projeto que desejam usar um projeto de deep learning ecriar o mais recente. É para alguém que deseja implementar seu próprio ambiente com a confiança de queo software NVIDIA mais recente está instalado e funcionando para que possa concentrar-se em escolheras estruturas e versões que deseja instalar.


• Opções da Deep Learning Base AMI (p. 9)

A seguir

Instalações do CUDA e associações da estrutura (p. 7)

Tópicos relacionados• Uso da Deep Learning Base AMI (p. 31)

6



Deep Learning AMI Guia do desenvolvedorCUDA

Instalações do CUDA e associações da estruturaO deep learning é todo de última geração, no entanto, cada estrutura oferece versões "estáveis". Essasversões estáveis podem não funcionar com a implementação e os recursos mais recentes do CUDA oudo cuDNN. Como você decide? Em última análise, isso vai depender do seu caso de uso e os recursos deque você precisa. Se você não tem certeza, use a Deep Learning AMI com Conda mais recente. Ela tembinários de PIP oficiais de todas as estruturas com CUDA 8, CUDA 9, CUDA 10 e CUDA 10.1, usando aversão mais recente que for compatível com cada estrutura. Se você quiser as versões mais recentes epersonalizar seu ambiente de aprendizado profundo, opte pela Deep Learning Base AMI.

Consulte o nosso guia em Estabilidade versus Release Candidates (p. 5) para obter mais orientações.

Escolher uma DLAMI com CUDAA Deep Learning Base AMI (p. 6) tem o CUDA 8, 9, 10 e 10.1.

A Deep Learning AMI com Conda (p. 5) tem o CUDA 8 e 9, 10 e 10.1.

• CUDA 10.1 com cuDNN 7: Apache MXNet• CUDA 10 com cuDNN 7: PyTorch, TensorFlow, TensorFlow 2, Apache MXNet, Chainer

Note


Para opções de instalação de tipos de DLAMI e sistemas operacionais, consulte cada uma versões doCUDA e as páginas de opções de :

• Opções da AMI do Deep Learning com CUDA 10.1. (p. 10)• Opções da Deep Learning AMI com CUDA 10 (p. 11)• Opções da Deep Learning AMI com CUDA 9 (p. 11)• Opções da Deep Learning AMI com CUDA 8 (p. 11)• Opções da Deep Learning AMI com Conda (p. 8)• Opções da Deep Learning Base AMI (p. 9)

Os números de versões de uma estrutura em específico podem ser encontrados no Notas de release doDLAMI (p. 129)


Escolha uma das versões do CUDA e analise a lista completa das DLAMI que têm essa versão noApêndice, ou saiba mais sobre as diferentes DLAMI com a opção a seguir.

A seguir

Opções do sistema operacional da DLAMI (p. 8)

Tópicos relacionados• Para obter instruções sobre como alternar entre as versões do CUDA, consulte o tutorial Uso da Deep

Learning Base AMI (p. 31).

7

Deep Learning AMI Guia do desenvolvedorSO

Opções do sistema operacional da DLAMIAs DLAMI são oferecidas nos sistemas operacionais listados abaixo. Se estiver mais familiarizado como CentOS ou o RedHat, você ficará mais confortável com Opções do AWS Deep Learning AMI AmazonLinux (p. 14) ou Opções do AWS Deep Learning AMI Amazon Linux 2 (p. 14). Caso contrário, vocêpoderá achar a AWS Deep Learning AMI, opções do Ubuntu 18.04 (p. 12) ou a AWS Deep LearningAMI, opções do Ubuntu 16.04 (p. 13) mais adequada para você.

Se você precisar do Windows como seu sistema operacional, terá duas opções encontradas aqui: AWSDeep Learning AMI, opções do Windows (p. 15).

Escolha um dos sistemas operacionais e analise a lista completa no Apêndice ou vá para as próximasetapas para escolher sua AMI e tipo de instância.

• Opções do AWS Deep Learning AMI Amazon Linux (p. 14)• Opções do AWS Deep Learning AMI Amazon Linux 2 (p. 14)• AWS Deep Learning AMI, opções do Ubuntu 18.04 (p. 12)• AWS Deep Learning AMI, opções do Ubuntu 16.04 (p. 13)• AWS Deep Learning AMI, opções do Windows (p. 15)

Conforme mencionado na visão geral de Conceitos básicos, você tem algumas opções para acessaruma DLAMI, mas primeiro você deve avaliar o tipo de instância de que você precisa. Você também deveidentificar a região da AWS que usará.

A seguir

Seleção do tipo de instância para DLAMI (p. 16)

Opções do AMIOs tópicos a seguir descrevem as categorias das AWS Deep Learning AMI.

Tópicos• Opções da Deep Learning AMI com Conda (p. 8)• Opções da Deep Learning Base AMI (p. 9)• Opções da AMI do Deep Learning com CUDA 10.1. (p. 10)• Opções da Deep Learning AMI com CUDA 10 (p. 11)• Opções da Deep Learning AMI com CUDA 9 (p. 11)• Opções da Deep Learning AMI com CUDA 8 (p. 11)• AWS Deep Learning AMI, opções do Ubuntu 18.04 (p. 12)• AWS Deep Learning AMI, opções do Ubuntu 16.04 (p. 13)• Opções do AWS Deep Learning AMI Amazon Linux (p. 14)• Opções do AWS Deep Learning AMI Amazon Linux 2 (p. 14)• AWS Deep Learning AMI, opções do Windows (p. 15)

Opções da Deep Learning AMI com CondaUse o guia Iniciar e configurar uma DLAMI (p. 19) para continuar com uma dessas DLAMI.

8

Deep Learning AMI Guia do desenvolvedorBase

• Deep Learning AMI (Ubuntu 18.04) no AWS Marketplace• Deep Learning AMI (Ubuntu 16.04) no AWS Marketplace• Deep Learning AMI (Amazon Linux) no AWS Marketplace• Deep Learning AMI (Amazon Linux 2) no AWS Marketplace

Essas DLAMIs estão disponíveis nas seguintes regiões:

Região Código

Leste dos EUA (Ohio) us-east-2

Leste dos EUA (Norte da Virgínia) us-east-1

GovCloud us-gov-west-1

Oeste dos EUA (Norte daCalifórnia)

us-west-1

Oeste dos EUA (Oregon) us-west-2

Pequim (China) cn-north-1

Ningxia (China) cn-northwest-1

Ásia-Pacífico (Mumbai) ap-south-1

Ásia-Pacífico (Seul) ap-northeast-2

Ásia-Pacífico (Cingapura) ap-southeast-1

Ásia-Pacífico (Sydney) ap-southeast-2

Ásia-Pacífico (Tóquio) ap-northeast-1

Canadá (Central) ca-central-1

UE (Frankfurt) eu-central-1

UE (Irlanda) eu-west-1

UE (Londres) eu-west-2

UE (Paris) eu-west-3

AS (São Paulo) sa-east-1

Opções da Deep Learning Base AMIUse o guia Iniciar e configurar uma DLAMI (p. 19) para continuar com uma dessas DLAMI.

• Deep Learning Base AMI (Ubuntu 18.04) no AWS Marketplace• Deep Learning Base AMI (Ubuntu 16.04) no AWS Marketplace• Deep Learning Base AMI (Amazon Linux) on the AWS Marketplace• Deep Learning Base AMI (Amazon Linux 2) no AWS Marketplace


9

https://aws.amazon.com/marketplace/pp/B07Y43P7X5

https://aws.amazon.com/marketplace/pp/B077GCH38C

https://aws.amazon.com/marketplace/pp/B077GF11NF

https://aws.amazon.com/marketplace/pp/B07NMRZ36T

https://aws.amazon.com/marketplace/pp/B07Y3VDBNS

https://aws.amazon.com/marketplace/pp/B077GCZ4GR

https://aws.amazon.com/marketplace/pp/B077GFM7L7

https://aws.amazon.com/marketplace/pp/B07NMRZ463

Deep Learning AMI Guia do desenvolvedorCUDA 10.1

Região Código





us-west-1















Opções da AMI do Deep Learning com CUDA 10.1.Use o guia Iniciar e configurar uma DLAMI (p. 19) para continuar com uma dessas DLAMI.

• Deep Learning AMI (Ubuntu 18.04) no AWS Marketplace• Deep Learning Base AMI (Ubuntu 18.04) no AWS Marketplace• Deep Learning AMI (Ubuntu 16.04) no AWS Marketplace• Deep Learning Base AMI (Ubuntu 16.04) no AWS Marketplace• Deep Learning AMI (Amazon Linux) no AWS Marketplace• Deep Learning Base AMI (Amazon Linux) on the AWS Marketplace• Deep Learning AMI (Amazon Linux 2) no AWS Marketplace• Deep Learning Base AMI (Amazon Linux 2) no AWS Marketplace

Note

A Deep Learning AMI com Conda tem o CUDA 8, o CUDA 9, o CUDA 10 e o CUDA 10.1. Aestruturas usarão o CUDA mais recente para o qual oferecem suporte.

10









Deep Learning AMI Guia do desenvolvedorCUDA 10

A Deep Learning Base AMI também tem o CUDA 8, o CUDA 9, o CUDA 10 e o CUDA 10.1. Paraalternar entre eles, siga as instruções em Uso da Deep Learning Base AMI (p. 31).

Opções da Deep Learning AMI com CUDA 10Use o guia Iniciar e configurar uma DLAMI (p. 19) para continuar com uma dessas DLAMI.

• Deep Learning AMI (Ubuntu 18.04) no AWS Marketplace• Deep Learning AMI (Ubuntu 16.04) no AWS Marketplace• Deep Learning AMI (Amazon Linux) no AWS Marketplace• Deep Learning AMI (Amazon Linux 2) no AWS Marketplace• Deep Learning Base AMI (Ubuntu 18.04) no AWS Marketplace• Deep Learning Base AMI (Ubuntu 16.04) no AWS Marketplace• Deep Learning Base AMI (Amazon Linux) on the AWS Marketplace• Deep Learning Base AMI (Amazon Linux 2) no AWS Marketplace

Note

A Deep Learning AMI com Conda tem o CUDA 8, o CUDA 9 e o CUDA 10. A estruturas usarão oCUDA mais recente para o qual oferecem suporte.A Deep Learning Base AMI também tem o CUDA 8, o CUDA 9 e o CUDA 10. Para alternar entreeles, siga as instruções em Uso da Deep Learning Base AMI (p. 31).


• Deep Learning AMI (Ubuntu 16.04) no AWS Marketplace• Deep Learning AMI (Amazon Linux) no AWS Marketplace• Deep Learning AMI (Amazon Linux 2) no AWS Marketplace• Deep Learning Base AMI (Ubuntu 18.04) no AWS Marketplace• Deep Learning Base AMI (Ubuntu 16.04) no AWS Marketplace• Deep Learning Base AMI (Amazon Linux) on the AWS Marketplace• Deep Learning Base AMI (Amazon Linux 2) no AWS Marketplace• Deep Learning AMI (Windows 2012 R2) no AWS Marketplace• Deep Learning AMI (Windows 2016) on the AWS Marketplace

Note



• Deep Learning AMI (Ubuntu 16.04) no AWS Marketplace• Deep Learning AMI (Amazon Linux) no AWS Marketplace• Deep Learning AMI (Amazon Linux 2) no AWS Marketplace

11
















https://aws.amazon.com/marketplace/pp/B0785ML9TV

https://aws.amazon.com/marketplace/pp/B077Y5DJ8H




Deep Learning AMI Guia do desenvolvedorUbuntu 18.04

• Deep Learning Base AMI (Ubuntu 18.04) no AWS Marketplace• Deep Learning Base AMI (Ubuntu 16.04) no AWS Marketplace• Deep Learning Base AMI (Amazon Linux) on the AWS Marketplace• Deep Learning Base AMI (Amazon Linux 2) no AWS Marketplace• Deep Learning AMI (Windows 2012 R2) no AWS Marketplace• Deep Learning AMI (Windows 2016) on the AWS Marketplace

Note


AWS Deep Learning AMI, opções do Ubuntu 18.04Use o guia Iniciar e configurar uma DLAMI (p. 19) para continuar com uma dessas DLAMI. A DeepLearning AMI com Conda não é compatível com o Elastic Inference para Ubuntu 18.04.

• Deep Learning AMI (Ubuntu 18.04) no AWS Marketplace• Deep Learning Base AMI (Ubuntu 18.04) no AWS Marketplace


Região Código





us-west-1












12









Deep Learning AMI Guia do desenvolvedorUbuntu 16.04

Região Código




AWS Deep Learning AMI, opções do Ubuntu 16.04Use o guia Iniciar e configurar uma DLAMI (p. 19) para continuar com uma dessas DLAMI. A DeepLearning AMI com Conda vem com ambientes compatíveis com o Elastic Inference para Ubuntu 16.04.Para obter tutoriais e mais informações sobre o Elastic Inference, consulte a Documentação do ElasticInference.

• Deep Learning AMI (Ubuntu 16.04) no AWS Marketplace• Deep Learning Base AMI (Ubuntu 16.04) no AWS Marketplace


Região Código





us-west-1















13





Deep Learning AMI Guia do desenvolvedorAmazon Linux

Opções do AWS Deep Learning AMI Amazon LinuxUse o guia Iniciar e configurar uma DLAMI (p. 19) para continuar com uma dessas DLAMI. A DeepLearning AMI com Conda vem com ambientes compatíveis com o Elastic Inference para Amazon Linux.Para obter tutoriais e mais informações sobre o Elastic Inference, consulte a Documentação do ElasticInference.

• Deep Learning AMI (Amazon Linux) no AWS Marketplace• Deep Learning Base AMI (Amazon Linux) on the AWS Marketplace


Região Código





us-west-1















Opções do AWS Deep Learning AMI Amazon Linux 2Use o guia Iniciar e configurar uma DLAMI (p. 19) para continuar com uma dessas DLAMI. A DeepLearning AMI com Conda não é compatível com o Elastic Inference para Amazon Linux 2.

• Deep Learning AMI (Amazon Linux 2) no AWS Marketplace

14






Deep Learning AMI Guia do desenvolvedorWindows

• Deep Learning Base AMI (Amazon Linux 2) no AWS Marketplace


Região Código




us-west-1


Ásia Pacífico (Mumbai) ap-south-1


Ásia-Pacífico (Osaka – Local) ap-northeast-3










Notas de release do Amazon Linux 2

AWS Deep Learning AMI, opções do WindowsUse o guia Iniciar e configurar uma DLAMI (p. 19) para continuar com uma dessas DLAMI.

• Deep Learning AMI (Windows 2016) on the AWS Marketplace• Deep Learning AMI (Windows 2012 R2) no AWS Marketplace

As DLAMIs do Windows estão disponíveis nas seguintes regiões:

Região Código




15


https://aws.amazon.com/amazon-linux-2/release-notes/



Deep Learning AMI Guia do desenvolvedorSeleção de instância

Região Código


us-west-1














Seleção do tipo de instância para DLAMIA seleção do tipo de instância pode ser outro desafio, mas facilitaremos isso para você com algumasdicas sobre como escolher o melhor. Lembre-se de que a DLAMI é gratuita, mas que os recursos decomputação subjacentes não são.

• Se você não estiver familiarizado com o deep learning, provavelmente desejará uma instância de "nívelbásico" com uma única GPU.

• Se você tiver um orçamento limitado, precisará começar de forma mais econômica e examinar asinstâncias de CPU apenas.

• Se você estiver interessado em executar um modelo treinado para inferência e previsões (e nãotreinamento), convém executar o Amazon Elastic Inference. Com ele, você terá acesso a uma fraçãode um GPU. Portanto, você pode dimensionar de maneira econômica. Para serviços de inferência dealto volume, você pode descobrir que uma instância de CPU com muita memória (ou até um cluster deinstâncias) é uma solução melhor para você.

• Se estiver usando um modelo grande com muitos dados ou um tamanho de lote amplo, você precisaráde uma instância maior com mais memória. Você também pode distribuir seu modelo para um clusterde GPUs. Usar uma instância com menos memória talvez seja a melhor solução se você diminuir otamanho do lote. Isso pode afetar sua precisão e velocidade de treinamento.

• Se você estiver interessado em executar aplicativos de Machine Learning usando NVIDIA CollectiveCommunications Library (NCCL) que exigem altos níveis de comunicação entre nós em escala, talvezvocê queira usar o Elastic Fabric Adapter (EFA).

Os DLAMI não estão disponíveis em todas as regiões, mas é possível copiar DLAMI para a região de suaescolha. Consulte Cópia de uma AMI para obter mais informações. Cada região oferece suporte a uma

16


https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-efa-launching.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/CopyingAMIs.html

Deep Learning AMI Guia do desenvolvedorGPU

diferente variedade de tipos de instância e, muitas vezes, um tipo de instância tem um custo um poucodiferente em regiões diferentes. Em cada página principal da DLAMI, você verá uma lista de custos deinstâncias. Observe a lista de seleções de regiões e escolha uma região que esteja próxima de você ou deseus clientes. Se você planeja usar mais de uma DLAMI e potencialmente criar um cluster, certifique-se deusar a mesma região para todos os nós do cluster.

• Para obter mais detalhes sobre as instâncias, consulte Tipos de instância do EC2.• Para obter mais informações sobre regiões, visite Regiões do EC2.

Portanto, com todos esses pontos em mente, anote o tipo de instância que melhor se aplique a seu casode uso e orçamento. O restante dos tópicos deste guia ajudam você a obter mais informações e detalhes.

Important

As Deep Learning AMIs incluem drivers, softwares ou toolkits desenvolvidos, propriedades daNVIDIA Corporation ou fornecidos por ela. Você concorda em usar esses drivers, softwares outoolkits NVIDIA apenas em instâncias do Amazon EC2 que incluam hardware NVIDIA.

Tópicos• Instâncias de GPU recomendadas (p. 17)• Instâncias de CPU recomendadas (p. 17)• Definição de preço para a DLAMI (p. 18)

A seguir

Instâncias de GPU recomendadas (p. 17)

Instâncias de GPU recomendadasUma instância de GPU é recomendada para a maioria dos objetivos de deep learning. O treinamento denovos modelos será mais rápido em uma instância de GPU do que em uma instância de CPU. Você podedimensionar de forma sublinear quando tem instâncias de várias GPUs ou usa treinamento distribuído emmuitas instâncias com GPUs.

Note

O tamanho do seu modelo deve ser um fator ao selecionar uma instância. Se o modelo excedera RAM disponível de uma instância, selecione um tipo de instância diferente com memóriasuficiente para o aplicativo.

• Instâncias P3 do Amazon EC2 tem até 8 GPUs NVIDIA Tesla V100.• Instâncias P2 do Amazon EC2 tem até 16 GPUs NVIDIA NVIDIA K80.• Instâncias G3 do Amazon EC2 tem até 4 GPUs NVIDIA Tesla M60.• Instâncias G4 do Amazon EC2 têm até 4 GPUs NVIDIA T4.• Confira os Tipos de instância do EC2 e escolha Computação acelerada para ver as diferentes opções de

instâncias de GPU.

A seguir

Instâncias de CPU recomendadas (p. 17)

Instâncias de CPU recomendadasIndependentemente de você ter um orçamento, estar aprendendo sobre o deep learning ou apenas quererexecutar um serviço de previsão, você tem muitas opções acessíveis na categoria de CPU. Algumas

17

https://aws.amazon.com/ec2/instance-types/

https://docs.aws.amazon.com/general/latest/gr/rande.html#ec2_region

https://aws.amazon.com/ec2/instance-types/p3/

https://aws.amazon.com/ec2/instance-types/p2/

https://aws.amazon.com/ec2/instance-types/g3/

https://aws.amazon.com/ec2/instance-types/g4/


Deep Learning AMI Guia do desenvolvedorDefinição de preço

estruturas usam a DNN MKL da Intel, o que acelera o treinamento e a inferência em tipos de instância deCPU C3, C4 e C5 (esta não disponível em todas as regiões). Ele também acelerará a inferência em tiposde instância de GPU.

• Instâncias C5 do Amazon EC2 tem até 72 vCPUs Intel.• As instâncias C4 do Amazon EC2 têm até 36 vCPUs Intel.• Confira os Tipos de instância do EC2 e procure Compute Optimized (Otimizado para computador) para

ver as diferentes opções de instâncias de CPU.

Note

As instâncias C5 (não disponíveis em todas as regiões) são excelentes para modelagemcientífica, processamento em lotes, análise distribuída, computação de alto desempenho (HPC) einferência de machine/deep learning.

Note

O tamanho do seu modelo deve ser um fator ao selecionar uma instância. Se o modelo excedera RAM disponível de uma instância, selecione um tipo de instância diferente com memóriasuficiente para o aplicativo.

A seguir

Definição de preço para a DLAMI (p. 18)

Definição de preço para a DLAMIA DLAMI é gratuita, no entanto, você ainda é responsável pelos custos do Amazon EC2 ou de outrosserviços da AWS. As estruturas de deep learning incluídas são gratuitas, e cada uma tem suas própriaslicenças de código aberto. O software de GPU da NVIDIA é gratuito e também tem licenças próprias.

Como isso é gratuito, mas não gratuito? Quais são os "custos do Amazon EC2 ou de outros serviços daAWS"?

Essa é uma pergunta comum. Alguns tipos de instância no Amazon EC2 são identificados como gratuitos.Essas normalmente são instâncias menores, e é possível executar a DLAMI em uma dessas instânciasgratuitas. Isso significa que isso é totalmente gratuito quando você usa essa capacidade de instância. Sevocê decidir que deseja uma instância mais robusta, com mais núcleos de CPU, mais espaço em disco,mais RAM e uma ou mais GPUs, esses requisitos provavelmente não estarão na classe de instâncias dacamada gratuita. Isso significa que você precisará pagar por esses custos. Uma maneira fácil de ver isso éque o software ainda é gratuito, mas você precisa pagar pelo hardware subjacente que está usando.

Consulte Seleção do tipo de instância para DLAMI (p. 16) para obter mais informações sobre qualtamanho de instância escolher e quais tipos de coisas você pode esperar de cada tipo.

Próxima etapa

Iniciar e configurar uma DLAMI (p. 19)

18

https://aws.amazon.com/ec2/instance-types/c5/


Deep Learning AMI Guia do desenvolvedorEtapa 1: Iniciar uma DLAMI

Iniciar e configurar uma DLAMISe você está aqui, você já deve ter uma boa ideia de qual AMI deseja iniciar. Caso contrário, escolha umaDLAMI usando as diretrizes de seleção de AMI encontradas em todo o Conceitos básicos (p. 4) ou use alista completa de AMIs na seção Apêndice, Opções do AMI (p. 8).

Você também deve saber qual tipo de instância e região escolherá. Caso contrário, navegue em Seleçãodo tipo de instância para DLAMI (p. 16).

Note

Usaremos p2.xlarge como tipo de instância padrão nos exemplos. Basta substituir por qualquertipo de instância que você tenha em mente.Important

Se você planeja usar o Elastic Inference, é necessário concluir a Configuração do ElasticInference antes de iniciar sua DLAMI.

Tópicos• Etapa 1: Iniciar uma DLAMI (p. 19)• Console do EC2 (p. 20)• Pesquisa no Marketplace (p. 20)• Etapa 2: Conectar-se à DLAMI (p. 21)• Etapa 3: Proteger sua instância de DLAMI (p. 21)• Etapa 4: Testar a DLAMI (p. 21)• Limpar (p. 21)• Configurar um servidor de notebook Jupyter (p. 22)

Etapa 1: Iniciar uma DLAMINote

Para esta demonstração, podemos fazer referências específicas à Deep Learning AMI (Ubuntu16.04). Mesmo que selecione outra DLAMI, você deve ser capaz de seguir este guia.

Iniciar a instância

1. Você tem algumas rotas para iniciar uma DLAMI. Escolha uma:

• Console do EC2 (p. 20)• Pesquisa no Marketplace (p. 20)

Tip

Opção da CLI: se você optar por ativar uma DLAMI usando a AWS ILC, precisará do ID daAMI, da região e do tipo de instância e das informações do token de segurança. Verifiquese você tem a AMI e os IDs de instância prontos. Se você ainda não tiver configurado a ILCda AWS, faça isso primeiro usando o guia para Instalar a interface de linha de comando daAWS.

2. Depois de concluir as etapas de uma dessas opções, aguarde até que a instância esteja pronta. Issonormalmente leva apenas alguns minutos. Você pode verificar o status da instância no Console doEC2.

19

https://docs.aws.amazon.com/elastic-inference/latest/developerguide/setting-up-ei.html

https://docs.aws.amazon.com/elastic-inference/latest/developerguide/setting-up-ei.html

https://docs.aws.amazon.com/cli/latest/userguide/installing.html

https://docs.aws.amazon.com/cli/latest/userguide/installing.html

https://console.aws.amazon.com/ec2


Deep Learning AMI Guia do desenvolvedorConsole do EC2

Console do EC2Note

Para executar uma instância com o Elastic Fabric Adapter (EFA), consulte estas etapas.

1. Abra as Console do EC2.2. Observe sua região atual na navegação superior. Se essa não for a região da AWS desejada, altere

essa opção antes de continuar. Para obter mais informações, consulte Regiões do EC2.3. Escolha Executar instância.4. Procure a instância desejada por nome:

1. Escolha AWS Marketplace ou...2. Escolha QuickStart. Apenas um subconjunto das DLAMI disponíveis estará listado aqui.3. Procure por Deep Learning AMI. Além disso, procure o subtipo, como o sistema operacional

desejado, e se você deseja de base, Conda, de origem etc.4. Navegue pelas opções e clique em Select na sua escolha.

5. Reveja os detalhes e escolha Continue.6. Escolha um tipo de instância.

Note

Se você quiser usar o Elastic Inference (EI), clique em Configure Instance Details (Configurardetalhes da instância), selecione Add an Amazon EI accelerator (Adicionar um aceleradorAmazon EI) e selecione o tamanho do acelerador.

7. Escolha Review and Launch.8. Reveja os detalhes e a definição de preço. Escolha Executar.

Tip

Confira Conceitos básicos do deep learning com a Deep Learning AMI da AWS para umademonstração com capturas de tela!

Próxima etapa

Etapa 2: Conectar-se à DLAMI (p. 21)

Pesquisa no Marketplace1. Navegue pelo AWS Marketplace e pesquise AWS Deep Learning AMI.2. Navegue pelas opções e clique em Select na sua escolha.3. Reveja os detalhes e escolha Continue.4. Reveja os detalhes e anote a Region. Se essa não for a região da AWS desejada, altere essa opção

antes de continuar. Para obter mais informações, consulte Regiões do EC2.5. Escolha um tipo de instância.6. Escolha um par de chaves, use o seu padrão ou crie um novo.7. Reveja os detalhes e a definição de preço.8. Escolha Launch with 1-Click.

Próxima etapa

20

https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-efa-launching.html



https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-inference.html

https://aws.amazon.com/blogs/ai/get-started-with-deep-learning-using-the-aws-deep-learning-ami/


Deep Learning AMI Guia do desenvolvedorEtapa 2: Conectar-se à DLAMI

Etapa 2: Conectar-se à DLAMI (p. 21)

Etapa 2: Conectar-se à DLAMIConecte-se à DLAMI que você iniciou em um cliente (Windows, MacOS ou Linux). Para obter maisinformações, consulte Conectar-se à instância do Linux no Guia do usuário do Amazon EC2 parainstâncias do Linux.

Mantenha uma cópia do comando login do SSH à mão se desejar configurar o Jupyter depois de fazerlogin. Você usará uma variação dele para conectar-se à página da web do Jupyter.

Próxima etapa

Etapa 3: Proteger sua instância de DLAMI (p. 21)

Etapa 3: Proteger sua instância de DLAMISempre mantenha o sistema operacional e outros softwares instalados atualizados executando patches eatualizações assim que forem disponibilizados.

Se você está usando o Amazon Linux ou Ubuntu, ao efetuar login na DLAMI, você será notificado sehouver atualizações disponíveis e verá as instruções para atualização. Para obter mais informaçõessobre a manutenção do Amazon Linux, consulte Atualização de software de instância. Para instâncias doUbuntu, consulte a Documentação oficial do Ubuntu.

No Windows, verifique o Windows Update regularmente para instalar atualizações de software e desegurança. Se você preferir, as atualizações podem ser instaladas automaticamente.

Important

Para obter mais informações sobre as vulnerabilidades Spectre e Meltdown e como corrigir seusistema operacional para lidar com elas, consulte o Boletim de segurança da AWS-2018-013.

Etapa 4: Testar a DLAMIDependendo da sua versão de DLAMI, você terá diferentes opções de teste:

• Deep Learning AMI com Conda (p. 5) – acesse Uso da Deep Learning AMI com Conda (p. 28).• Deep Learning Base AMI (p. 6) – consulte a documentação de instalação da estrutura desejada.

Você também pode criar um notebook Jupyter, experimentar tutoriais ou começar a codificação em Python.Para obter mais informações, consulte Configurar um servidor de notebook Jupyter (p. 22).

LimparQuando não precisar mais da DLAMI, você poderá interrompê-la ou fechá-la para evitar cobrançascontínuas. A interrupção de uma instância a manterá disponível para que você possa retomá-la posteriormente. Suas configurações, arquivos e outras informações não voláteis estão sendoarmazenados em um volume no Amazon S3. Será cobrada uma pequena taxa do S3 para reter o volume

21

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-updates.html

https://help.ubuntu.com/

https://aws.amazon.com/security/security-bulletins/AWS-2018-013/

Deep Learning AMI Guia do desenvolvedorConfiguração do Jupyter

enquanto a instância estiver interrompida, mas os recursos de computação não serão cobrados enquantoela estiver no estado interrompido. Quando você iniciar a instância novamente, ela montará esse volumee seus dados estarão disponíveis. Se você encerrar uma instância, ela será perdida e você não poderáiniciá-la novamente. Seus dados ainda residirão no S3, portanto, para evitar cobranças adicionais vocêprecisará excluir o volume também. Para obter mais instruções, consulte Encerre sua instância em Guia dousuário do Amazon EC2 para instâncias do Linux.

Configurar um servidor de notebook JupyterO Jupyter Notebook é um aplicativo Web que permite gerenciar documentos de bloco de notas usando umnavegador da web.

Para configurar um notebook Jupyter, você:

• Configura o servidor de notebook Jupyter em sua instância do Amazon EC2.• Configura o cliente para que possa conectar-se ao servidor de notebook Jupyter. Fornecemos instruções

de configuração para Windows, macOS e clientes Linux.• Testa a configuração fazendo login no servidor de notebook Jupyter.

Para obter mais informações sobre notebooks Jupyter, consulte Jupyter.

Tópicos• Proteja seu servidor do Jupyter (p. 22)• Inicie o servidor de notebook Jupyter (p. 23)• Configurar o cliente para se conectar ao servidor do Jupyter (p. 23)• Teste fazendo login no servidor de notebook Jupyter (p. 24)

Proteja seu servidor do JupyterAqui, configuramos o Jupyter com SSL e uma senha personalizada.

Conecte-se à instância do Amazon EC2 e, em seguida, conclua o procedimento a seguir.

Configurar o servidor do Jupyter

1. O Jupyter fornece um utilitário de senha. Execute o comando a seguir e insira sua senha preferencialno prompt.

$ jupyter notebook password

O resultado será semelhante ao seguinte:

Enter password:Verify password:[NotebookPasswordApp] Wrote hashed password to /home/ubuntu/.jupyter/jupyter_notebook_config.json

2. Crie um certificado SSL autoassinado. Siga os prompts para preencher sua localidade, conformejulgar necessário. É necessário inserir . se deseja deixar um prompt em branco. Suas respostas nãoafetarão a funcionalidade do certificado.

$ cd ~

22

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html

http://jupyter.org/

Deep Learning AMI Guia do desenvolvedorIniciar o servidor

$ mkdir ssl$ cd ssl$ openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout mykey.key -out mycert.pem

Note

Você poderá estar interessado em criar um certificado SSL regular assinado por terceiros que nãofaz com que o navegador forneça um aviso de segurança. Esse processo é muito mais complexo.Acesse a documentação do Jupyter para obter mais informações.

Próxima etapa

Inicie o servidor de notebook Jupyter (p. 23)

Inicie o servidor de notebook JupyterAgora, é possível acionar o servidor do Jupyter fazendo login na instância e executando o seguintecomando que usa o certificado SSL criado na etapa anterior.

$ jupyter notebook --certfile=~/ssl/mycert.pem --keyfile ~/ssl/mykey.key

Com o servidor iniciado, agora você pode se conectar a ele por meio de um túnel SSH em seu computadorcliente. Quando o servidor for executado, você verá alguma saída do Jupyter confirmando que o servidorestá em execução. Nesse ponto, ignore o texto informando que você pode acessar o servidor por meio deum URL do host local, pois isso não funcionará até criar o túnel.

Note

O Jupyter resolverá a troca de ambientes para você ao alternar as estruturas usando a interfaceda web do Jupyter. Você pode encontrar mais informações sobre este assunto em Alternarambientes com o Jupyter (p. 33).

Próxima etapa

Configurar o cliente para se conectar ao servidor do Jupyter (p. 23)

Configurar o cliente para se conectar ao servidor doJupyterDepois de configurar o cliente para se conectar ao servidor de notebook Jupyter, você pode criar e acessarnotebooks no servidor em sua área de trabalho e executar o código de deep learning no servidor.

Para obter informações de configuração, escolha um dos links a seguir.

Tópicos• Configurar um cliente Windows (p. 23)• Configurar um cliente Linux ou macOS (p. 24)

Configurar um cliente WindowsPreparação

Certifique-se de que você tem as seguintes informações, que são necessárias para configurar o túnel SSH:

23

https://jupyter-notebook.readthedocs.io/en/stable/public_server.html#using-let-s-encrypt

Deep Learning AMI Guia do desenvolvedorTestar fazendo login no servidor de notebook Jupyter

• O nome DNS público de sua instância do Amazon EC2. Você pode localizar o nome DNS público noconsole do EC2.

• O par de chaves do arquivo de chave privada. Para obter mais informações sobre como acessar seupar de chaves, consulte Pares de chaves do Amazon EC2 no Guia do usuário do Amazon EC2 parainstâncias do Linux.

Uso de notebooks Jupyter a partir de um cliente Windows

Consulte estes guias sobre como se conectar à sua instância do Amazon EC2 a partir de um clienteWindows.

1. Resolução de problemas para se conectar à sua instância2. Conectar à instância Linux no Windows utilizando PuTTY

Para criar um túnel para um servidor do Jupyter em execução, uma abordagem recomendada é instalaro Git Bash em seu cliente Windows e seguir as instruções do cliente Linux/macOS. No entanto, vocêpode usar qualquer abordagem desejada para abrir um túnel SSH com mapeamento de porta. Consulte adocumentação do Jupyter para obter informações adicionais.

Próxima etapa

Configurar um cliente Linux ou macOS (p. 24)

Configurar um cliente Linux ou macOS1. Abra um terminal.2. Execute o comando a seguir para encaminhar todas as solicitações da porta local 8888 para a porta

8888 em sua instância do Amazon EC2 remota. Atualize o comando substituindo a localização desua chave para acessar a instância do Amazon EC2 e o nome DNS público de sua instância doAmazon EC2. Observe que, para uma AMI do Amazon Linux, o nome do usuário ec2-user em vezde ubuntu.

$ ssh -i ~/mykeypair.pem -N -f -L 8888:localhost:8888 ubuntu@ec2-###-##-##-###.compute-1.amazonaws.com

Esse comando abre um túnel entre o cliente e a instância do Amazon EC2 remota que estáexecutando o servidor de notebook Jupyter.

Próxima etapa

Teste fazendo login no servidor de notebook Jupyter (p. 24)

Teste fazendo login no servidor de notebook JupyterAgora, você está pronto para fazer login no servidor de notebook Jupyter.

A próxima etapa é testar a conexão ao servidor por meio de seu navegador.

1. Na barra de endereço do navegador, digite o seguinte URL ou clique neste link: https://localhost:88882. Com um certificado SSL autoassinado, navegador avisará você e solicitará que não continue com o

acesso ao site.

24

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesConnecting.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html

https://jupyter-notebook.readthedocs.io/en/stable/public_server.html

https://localhost:8888


Como você mesmo configurou isso, é seguro continuar. Seu navegador receberá um botão"avançado", "mostrar detalhes" ou algo semelhante.

25


26


Clique nele e depois clique no link "prosseguir para localhost". Se a conexão for bem-sucedida, vocêverá a página da web do servidor de notebook Jupyter. Nesse ponto, será solicitada a senha definidaanteriormente.

Agora você tem acesso ao servidor de notebook Jupyter que está em execução na DLAMI. Você podecriar novos notebooks ou executar os Tutoriais (p. 33) fornecidos.

27

Deep Learning AMI Guia do desenvolvedorConda DLAMI

Usando uma DLAMITópicos

• Uso da Deep Learning AMI com Conda (p. 28)• Uso da Deep Learning Base AMI (p. 31)• Executar os tutoriais do notebook Jupyter (p. 32)• Tutoriais (p. 33)

As seções a seguir descrevem como a Deep Learning AMI com Conda pode ser usada para alternarambientes, executar o código de exemplo para cada uma das estruturas e executar o Jupyter para quevocê possa testar diferentes tutoriais de notebook.

Uso da Deep Learning AMI com CondaTópicos

• Introdução ao Deep Learning AMI com Conda (p. 28)• Etapa 1: Fazer login na DLAMI (p. 28)• Etapa 2: Iniciar o ambiente do MXNet Python 3 (p. 30)• Etapa 3: Testar um código do MXNet (p. 30)• Etapa 4: Alternar para o ambiente do TensorFlow (p. 30)• Remoção de ambientes (p. 31)

Introdução ao Deep Learning AMI com CondaO Conda é um sistema de gerenciamento de pacotes e de ambientes de código aberto que é executado noWindows, macOS e Linux. O Conda instala, executa e atualiza pacotes e suas dependências rapidamente.O Conda cria, salva, carrega e alterna facilmente entre ambientes em seu computador local.

A Deep Learning AMI com Conda foi configurada para que você alterne facilmente entre ambientes dedeep learning. As instruções a seguir orientam você na execução de alguns comandos básicos comconda. Elas também ajudam você a verificar se a importação básica da estrutura está funcionando e sevocê pode executar algumas operações simples com a estrutura. Em seguida, você pode continuar comtutoriais mais completos fornecidos com a DLAMI ou os exemplos de estruturas encontrados em cada sitede projeto das estruturas.

Etapa 1: Fazer login na DLAMIApós fazer login em seu servidor, você verá uma "mensagem do dia" (MOTD) do servidor que descrevevários comandos do Conda que você pode usar para alternar entre as diferentes estruturas de deeplearning. Abaixo está um exemplo de MOTD. Seu MOTD específico pode variar conforme novas versõesda DLAMI são lançadas.

Note


28

Deep Learning AMI Guia do desenvolvedorEtapa 1: Fazer login na DLAMI

============================================================================= __| __|_ ) _| ( / Deep Learning AMI (Ubuntu 16.04) Version 26.0 ___|\___|___|=============================================================================

Welcome to Ubuntu 16.04.6 LTS (GNU/Linux 4.4.0-1098-aws x86_64v)

Please use one of the following commands to start the required environment with the framework of your choice:for MXNet(+Keras2) with Python3 (CUDA 10.1 and Intel MKL-DNN) ____________________________________ source activate mxnet_p36for MXNet(+Keras2) with Python2 (CUDA 10.1 and Intel MKL-DNN) ____________________________________ source activate mxnet_p27for MXNet(+Amazon Elastic Inference) with Python3 _______________________________________ source activate amazonei_mxnet_p36for MXNet(+Amazon Elastic Inference) with Python2 _______________________________________ source activate amazonei_mxnet_p27for MXNet(+AWS Neuron) with Python3 ___________________________________________________ source activate aws_neuron_mxnet_p36for TensorFlow(+Keras2) with Python3 (CUDA 10.0 and Intel MKL-DNN) __________________________ source activate tensorflow_p36for TensorFlow(+Keras2) with Python2 (CUDA 10.0 and Intel MKL-DNN) __________________________ source activate tensorflow_p27for TensorFlow 2(+Keras2) with Python3 (CUDA 10.0 and Intel MKL-DNN) _______________________ source activate tensorflow2_p36for TensorFlow 2(+Keras2) with Python2 (CUDA 10.0 and Intel MKL-DNN) _______________________ source activate tensorflow2_p27for Tensorflow(+Amazon Elastic Inference) with Python2 _____________________________ source activate amazonei_tensorflow_p27for Tensorflow(+Amazon Elastic Inference) with Python3 _____________________________ source activate amazonei_tensorflow_p36for Tensorflow(+AWS Neuron) with Python3 _________________________________________ source activate aws_neuron_tensorflow_p36for PyTorch with Python3 (CUDA 10.1 and Intel MKL) _____________________________________________ source activate pytorch_p36for PyTorch with Python2 (CUDA 10.1 and Intel MKL) _____________________________________________ source activate pytorch_p27for Chainer with Python2 (CUDA 10.0 and Intel iDeep) ___________________________________________ source activate chainer_p27for Chainer with Python3 (CUDA 10.0 and Intel iDeep) ___________________________________________ source activate chainer_p36for base Python2 (CUDA 10.0) _______________________________________________________________________ source activate python2for base Python3 (CUDA 10.0) _______________________________________________________________________ source activate python3

Cada comando do Conda tem o seguinte padrão:

source activate framework_python-version

Por exemplo, você pode ver for MXNet(+Keras1) with Python3 (CUDA 9)_____________________ source activate mxnet_p36, o que significa que o ambiente tem oMXNet, o Keras 1, o Python 3 e o CUDA 9. E para ativar esse ambiente, o comando que você deve usar é:

$ source activate mxnet_p36

A outra variação desse comando seria:


29

Deep Learning AMI Guia do desenvolvedorEtapa 2: Iniciar o ambiente do MXNet Python 3

Isso significa que o ambiente terá o MXNet e o Python 2 (com o Keras 1 e o CUDA 9).

Etapa 2: Iniciar o ambiente do MXNet Python 3Vamos testar o MXNet primeiro para que você tenha uma ideia geral de como ele é fácil.

Note

Quando iniciar seu primeiro ambiente Conda, aguarde enquanto ele carrega. A Deep LearningAMI com Conda instala automaticamente a versão mais otimizada da estrutura para sua instânciado EC2 após a primeira ativação da estrutura. Não deve haver atrasos subsequentes.

• Ative o ambiente virtual do MXNet para Python 3.


Isso ativa o ambiente para MXNet com Python 3. Como alternativa, você pode ativar o mxnet_p27 paraobter um ambiente com Python 2.

Etapa 3: Testar um código do MXNetPara testar a instalação, use o Python para gravar código do MXNet que cria e imprime uma matriz usandoa API NDArray. Para obter mais informações, consulte a API NDArray.

1. Inicie o terminal iPython.

(mxnet_p36)$ ipython

2. Importe o MXNet.

import mxnet as mx

Você pode ver uma mensagem de aviso sobre um pacote de terceiros. Você pode ignorá-la.3. Crie uma matriz 5x5, uma instância do NDArray com elementos inicializados como 0. Imprima a

matriz.

mx.ndarray.zeros((5,5)).asnumpy()

Verifique o resultado.

array([[ 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0.]], dtype=float32)

Você pode localizar mais exemplos do MXNet na seção de tutoriais do MXNet.

Etapa 4: Alternar para o ambiente do TensorFlowAgora vamos alternar para o TensorFlow! Se você ainda estiver no console do iPython, use quit() e, emseguida, prepare-se para alternar os ambientes.

30

https://mxnet.incubator.apache.org/api/python/ndarray/ndarray.html

Deep Learning AMI Guia do desenvolvedorRemoção de ambientes

1. Ative o ambiente virtual do TensorFlow para Python 3,

$ source activate tensorflow_p36


(tensorflow_36)$ ipython

3. Execute um programa rápido do TensorFlow.

import tensorflow as tfhello = tf.constant('Hello, TensorFlow!')sess = tf.Session()print(sess.run(hello))

Você deve ver "Hello, Tensorflow!" Você testou duas estruturas de deep learning diferentes e viu comoalternar entre as estruturas.

A seguir

Executar os tutoriais do notebook Jupyter (p. 32)

Remoção de ambientesSe você ficar sem espaço no DLAMI, poderá optar por desinstalar pacotes do Conda que não estiverusando:

conda env listconda env remove –-name <env_name>

Uso da Deep Learning Base AMIUso da Deep Learning Base AMIA AMI Base é fornecida com uma plataforma base de drivers de GPU e bibliotecas de aceleração paraimplantar seu próprio ambiente personalizado de deep learning. Por padrão, a AMI é configurada com oambiente NVIDIA CUDA 10. No entanto, você também pode alternar para um ambiente CUDA 9 ou CUDA8. Consulte as seguintes instruções para saber como fazer isso.

Configurar as versões do CUDAVocê pode selecionar e verificar uma determinada versão do CUDA com os comandos bash a seguir.

• CUDA 10.2:

$ sudo rm /usr/local/cudasudo ln -s /usr/local/cuda-10.2 /usr/local/cuda

• CUDA 10.1:


31

Deep Learning AMI Guia do desenvolvedorNotebooks Jupyter

• CUDA 10:


• CUDA 9.2:


• CUDA 9:


• CUDA 8:


Tip

Em seguida, você pode verificar a versão do CUDA ao executar o programa deviceQuery doNVIDIA.

$ cd /usr/local/cuda/samples/1_Utilities/deviceQuerysudo make./deviceQuery

Executar os tutoriais do notebook JupyterTutoriais e exemplos são fornecidos com cada origem dos projetos de deep learning e, na maioriados casos, eles são executados em qualquer DLAMI. Se você escolher a Deep Learning AMI comConda (p. 5), obterá o benefício adicional de alguns tutoriais escolhidos a dedo já configurados e prontospara serem testados.

Important

Para executar os tutoriais instalados no notebook Jupyter na DLAMI, você precisará Configurarum servidor de notebook Jupyter (p. 22).

Assim que o servidor do Jupyter estiver em execução, você poderá executar os tutoriais por meio deseu navegador da web. Se estiver executando a Deep Learning AMI com Conda ou se tiver configuradoambientes do Python, você poderá alternar os kernels do Python na interface do notebook Jupyter.Selecione o kernel apropriado antes de tentar executar um tutorial específico à estrutura. Exemplosadicionais são fornecidos para os usuários da Deep Learning AMI com Conda.

Note

Muitos tutoriais exigem módulos adicionais do Python que podem não estar configurados naDLAMI. Se você receber um erro, como "xyz module not found", faça login na DLAMI, ativeo ambiente conforme descrito acima e, em seguida, instale os módulos necessários.Tip

Com frequência, os tutoriais e exemplos de deep learning dependem de uma ou mais GPUs. Seseu tipo de instância não tiver uma GPU, talvez seja necessário alterar um pouco o código deexemplo para que ele seja executado.

32

Deep Learning AMI Guia do desenvolvedorNavegar pelos tutoriais instalados

Navegar pelos tutoriais instaladosDepois de fazer login no servidor do Jupyter e poder ver o diretório dos tutoriais (somente no DeepLearning AMI com Conda), serão apresentadas pastas de tutoriais para cada nome de estrutura. Se vocênão vir uma estrutura listada, os tutoriais não estarão disponíveis para essa estrutura em sua DLAMI atual.Clique no nome da estrutura para ver os tutoriais listados e, em seguida, clique em um tutorial para iniciá-lo.

Na primeira vez que executa um notebook na Deep Learning AMI com Conda, você precisará informar qualambiente deseja usar. Você poderá selecionar de uma lista. Cada ambiente é denominado de acordo comeste padrão:

Environment (conda_framework_python-version)

Por exemplo, você pode ver Environment (conda_mxnet_p36), o que significa que o ambiente tem oMXNet e o Python 3. A outra variação disso seria Environment (conda_mxnet_p27), o que significaque o ambiente tem o MXNet e o Python 2.

Tip

Se você está preocupado sobre qual versão do CUDA está ativa, uma maneira de ver isso é noMOTD, quando você faz login pela primeira vez na DLAMI.

Alternar ambientes com o JupyterSe você decidir experimentar um tutorial para uma estrutura diferente, certifique-se de verificar o kernelem execução. Essas informações podem ser vistas no canto superior direito da interface do Jupyter, logoabaixo do botão de logout. Você pode alterar o kernel em qualquer notebook clicando no item de menuKernel do Jupyter, em seguida, em Change Kernel e, em seguida, clicando no ambiente que atende aonotebook que você está executando.

Neste ponto, você precisará executar novamente todas as células porque uma alteração no kernel apagaráo estado de qualquer coisa que tenha executado anteriormente.

Tip

Alternar entre as estruturas pode ser divertido e instrutivo, no entanto, você pode esgotar amemória. Se você começar a receber erros, examine a janela de terminal que tem o servidordo Jupyter em execução. Há mensagens úteis e um log de erros aqui, e você poderá ver umerro de falta de memória. Para corrigir isso, você pode ir para a página inicial do servidor doJupyter, clicar na guia Running e, em seguida, em Shutdown para cada um dos tutoriais queprovavelmente ainda estão em execução em segundo plano e consumindo toda a sua memória.

A seguir

Para obter mais exemplos e código de exemplo de cada estrutura, clique em Next ou continue paraApache MXNet (p. 34).

TutoriaisVeja a seguir os tutoriais sobre como usar o software da Deep Learning AMI com Conda.

Tópicos• Tutoriais de 10 minutos (p. 34)• Ativar estruturas (p. 34)• Depuração e visualização (p. 48)

33

Deep Learning AMI Guia do desenvolvedorTutoriais de 10 minutos

• Treinamento distribuído (p. 51)• Adaptador de malha elástica (p. 68)• Monitoramento e otimização de GPU (p. 77)• O chip AWS Inferentia com DLAMI (p. 82)• Inferência (p. 99)• Como usar Estruturas de acesso com ONNX (p. 103)• Fornecimento de modelos (p. 112)

Tutoriais de 10 minutos• Executar um AWS Deep Learning AMI (em 10 minutos)• Teste um modelo de deep learning com o AWS Deep Learning Containers no Amazon EC2 (em 10

minutos)

Ativar estruturasVeja a seguir as estruturas de deep learning instaladas na Deep Learning AMI com Conda. Clique em umaestrutura para saber como ativá-la.

Tópicos• Apache MXNet (p. 34)• Caffe2 (p. 36)• Chainer (p. 37)• CNTK (p. 37)• Keras (p. 39)• PyTorch (p. 40)• TensorFlow (p. 42)• TensorFlow 2 (p. 43)• TensorFlow com Horovod (p. 45)• TensorFlow 2 com Horovod (p. 46)• Theano (p. 47)

Apache MXNetComo ativar o MXNet

Este tutorial mostra como ativar o MXNet em uma instância executando o Deep Learning AMI com Conda(DLAMI no Conda) e executando um programa do MXNet.

Quando um pacote Conda estável de uma estrutura é lançada, ele é testado e pré-instalado no DLAMI.Se desejar executar as mais recentes compilações noturnas não testadas, você pode Como instalar acompilação noturna do MXNet (experimental) (p. 35) manualmente.

Para executar o MXNet no DLAMI com Conda

1. Para ativar a estrutura, abra uma instância do Amazon Elastic Compute Cloud (Amazon EC2) doDLAMI com Conda.• Para MXNet e Keras 2 no Python 3 com CUDA 9.0 e MKL-DNN, execute este comando:

34


https://aws.amazon.com/getting-started/tutorials/train-deep-learning-model-aws-ec2-containers/

https://aws.amazon.com/getting-started/tutorials/train-deep-learning-model-aws-ec2-containers/

Deep Learning AMI Guia do desenvolvedorAtivar estruturas


• Para MXNet e Keras 2 no Python 2 com CUDA 9.0 e MKL-DNN, execute este comando:




3. Execute um programa rápido do MXNet. Crie uma matriz 5x5, uma instância do NDArray comelementos inicializados como 0. Imprima a matriz.

import mxnet as mxmx.ndarray.zeros((5,5)).asnumpy()

4. Verifique o resultado.

array([[ 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0.]], dtype=float32)

Como instalar a compilação noturna do MXNet (experimental)

Você pode instalar a versão mais recente do MXNet construída em um ou ambos os ambientes MXNetConda no seu Deep Learning AMI com Conda.

Para Instalar o MXNet a partir de uma compilação noturna

1. • Para o ambiente Pyhton 3 do MXNet, execute este comando:


• Para o ambiente Pyhton 2 do MXNet, execute este comando:


2. Remova o MXNet instalado.

Note

As etapas restantes assumem que você está usando o ambiente do mxnet_p36.

(mxnet_p36)$ pip uninstall mxnet-cu90mkl

3. Instale a última compilação noturna do MXNet.

(mxnet_p36)$ pip install --pre mxnet-cu90mkl

4. Para verificar se você instalou com sucesso a versão mais recente da compilação noturna, inicie oterminal IPython e verifique a versão do MXNet.


35


import mxnetprint (mxnet.__version__)

A saída deve imprimir a versão estável mais recente do MXNet.

Mais tutoriaisVocê pode localizar mais tutoriais na respectiva pasta da Deep Learning AMI com Conda, localizada nodiretório inicial da DLAMI.

1. Use o Apache MXNet para inferência com um modelo ResNet 50 (p. 101)2. Usar o Apache MXNet para inferência com um modelo ONNX (p. 100)3. Model Server para Apache MXNet (MMS) (p. 112)

Para ver mais tutoriais e exemplos, consulte a documentação oficial do Python referentes à estrutura, APIPython para MXNet, ou acesse o site Apache MXNet.

Caffe2Note


Tutorial do Caffe2Para ativar a estrutura, siga estas instruções sobre sua Deep Learning AMI com Conda.

Há apenas o Python 2 com as opções CUDA 9 e cuDNN 7:

$ source activate caffe2_p27

Inicie o terminal iPython.

(caffe2_p27)$ ipython

Execute um programa rápido do Caffe2.

from caffe2.python import workspace, model_helperimport numpy as np# Create random tensor of three dimensionsx = np.random.rand(4, 3, 2)print(x)print(x.shape)workspace.FeedBlob("my_x", x)x2 = workspace.FetchBlob("my_x")print(x2)

Você deve ver as matrizes aleatórias iniciais do numpy impressas e as carregadas em um blob do Caffe2.Observe que, após o carregamento, elas são iguais.

36

https://mxnet.apache.org/api/python.html

https://mxnet.apache.org/api/python.html

https://mxnet.incubator.apache.org/


Mais tutoriais

Para obter mais tutoriais e exemplos, consulte os documentos oficiais do Python referentes à estrutura,API Python para Caffe2 e o site Caffe2.

ChainerO Chainer é uma estrutura flexível baseada em Python para gravar arquiteturas de rede neurais complexasde maneira fácil e intuitiva. O Chainer facilita o uso de instâncias de várias GPUs para treinamento. OChainer também registra automaticamente os resultados, a perda e a precisão do gráfico e produz umasaída para visualizar a rede neural com um gráfico computacional. Ele é incluído com a Deep Learning AMIcom Conda (DLAMI com Conda).

Ativar o Chainer

1. Conecte-se à instância executando Deep Learning AMI com Conda. Consulte a the section called“Seleção de instância” (p. 16) ou a Amazon EC2 documentação do sobre como selecionar ou seconectar a uma instância.

2. • Ative o ambiente do Chainer Python 3:

$ source activate chainer_p36

• Ative o ambiente do Chainer Python 2:


3. Inicie o terminal iPython:

(chainer_p36)$ ipython

4. Teste a importação do Chainer a fim de verificar se ele está funcionando corretamente:

import chainer

Talvez você veja algumas mensagens de aviso, mas nenhum erro.

Mais informações

• Experimente os tutoriais para o Chainer (p. 51).• A pasta de exemplos do Chainer que você obteve por download anteriormente contém mais exemplos.

Teste-os para ver como eles são executados.• Para saber mais sobre o Chainer, consulte o Site de documentação do Chainer.

CNTKNote


37

https://caffe2.ai/doxygen-python/html/annotated.html

https://caffe2.ai

https://chainer.org/

https://docs.chainer.org/en/stable/reference/graph.html

http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html

https://docs.chainer.org/


Ativação do CNTKEste tutorial mostra como ativar o CNTK em uma instância executando o Deep Learning AMI com Conda(DLAMI no Conda) e executando um programa do CNTK.

Quando um pacote Conda estável de uma estrutura é lançada, ele é testado e pré-instalado no DLAMI. Sedesejar executar as mais recentes compilações noturnas não testadas, você pode Instale a compilaçãonoturna do CNTK (experimental) (p. 38) manualmente.

Para executar o CNTK no DLAMI com Conda

1. Para ativar o CNTK, abra uma instância do Amazon Elastic Compute Cloud (Amazon EC2) do DLAMIcom Conda.• Para o Python 3 com CUDA 9 e cuDNN 7:

$ source activate cntk_p36

• Para o Python 2 com CUDA 9 e cuDNN 7:



(cntk_p36)$ ipython

3. • Se você tiver uma instância de CPU, execute esse programa CNTK rápido.

import cntk as CC.__version__c = C.constant(3, shape=(2,3))c.asarray()

Você deve ver a versão do CNTK e, em seguida, a saída de uma matriz 2x3 de 3s.• Se você tiver uma instância de GPU, poderá testá-la com o seguinte código de exemplo. Um

resultado de True é o que você deve esperar se o CNTK puder acessar a GPU.

from cntk.device import try_set_default_device, gputry_set_default_device(gpu(0))

Instale a compilação noturna do CNTK (experimental)Você pode instalar a versão mais recente do CNTK criada em um ou ambos os ambientes CNTK Conda noseu Deep Learning AMI com Conda.

Para instalar o CTNK a partir de uma compilação noturna

1. • Para CNTK e Keras 2 no Python 3 com o CUDA 9.0 e o MKL-DNN, execute este comando:


• Para CNTK e Keras 2 no Python 2 com o CUDA 9.0 e o MKL-DNN, execute este comando:


2. As etapas restantes assumem que você está usando o ambiente do cntk_p36. Remova o CNTKatualmente instalado:

38


(cntk_p36)$ pip uninstall cntk

3. Para instalar a compilação noturna do CNTK, primeiro é preciso encontrar a versão que você querinstalar no site do CNTK.

4. • (Opção para instâncias de GPU) — Para instalar a compilação noturna, você pode usar oseguinte, substituindo a compilação desejada:

(cntk_p36)$ pip install https://cntk.ai/PythonWheel/GPU/latest-nightly-build

Substitua o URL no comando anterior pela versão de GPU para o seu ambiente Python atual.• (Opção para instâncias de CPU) — Para instalar a compilação noturna, você pode usar o

seguinte, substituindo a compilação desejada:

(cntk_p36)$ pip install https://cntk.ai/PythonWheel/CPU-Only/latest-nightly-build

Substitua o URL no comando anterior pela versão de CPU para o seu ambiente Python atual.5. Para verificar se você instalou com sucesso a versão mais recente da compilação noturna, inicie o

terminal IPython e verifique a versão do CNTK.

(cntk_p36)$ ipython

import cntkprint (cntk.__version__)

A saída deve imprimir algo semelhante a 2.6-rc0.dev20181015

Mais tutoriaisPara obter mais tutoriais e exemplos, consulte os documentos oficiais do Python referentes à estrutura,API Python para CNTK ou acesse o site CNTK.

KerasTutorial do Keras

1. Para ativar o framework, use estes comandos na CLI the section called “Conda DLAMI” (p. 28).• Para o Keras 2 com um back-end do MXNet no Python 3 com CUDA 9 e cuDNN 7:


• Para o Keras 2 com um back-end do MXNet no Python 2 com CUDA 9 e cuDNN 7:


• Para o Keras 2 com um back-end do TensorFlow no Python 3 com CUDA 9 e cuDNN 7:


• Para o Keras 2 com um back-end do TensorFlow no Python 2 com CUDA 9 e cuDNN 7:


39

https://cntk.ai/nightly-linux.html

https://cntk.ai/pythondocs/gettingstarted.html

https://www.microsoft.com/en-us/cognitive-toolkit/


2. Para testar a importação do Keras a fim de verificar qual back-end está ativado, use estes comandos:

$ ipythonimport keras as k

O seguinte deve ser exibido na tela:

Using MXNet backend

Se o Keras estiver usando o TensorFlow, o seguinte será exibido:

Using TensorFlow backend

Note

Se você receber um erro ou se o back-end errado ainda estiver sendo usado, você poderáatualizar a configuração do Keras manualmente. Edite o arquivo ~/.keras/keras.json ealtere a configuração do back-end para mxnet ou tensorflow.

Mais tutoriais

• Para obter um tutorial de várias GPUs usando o Keras com um back-end do MXNet, tente o Tutorial detreinamento do Keras-MXNet com várias GPUs (p. 61).

• Você pode encontrar exemplos para Keras com um back-end do MXNet no diretório Deep Learning AMIcom Conda do ~/examples/keras-mxnet.

• Você pode encontrar exemplos para Keras com um back-end do TensorFlow no diretório Deep LearningAMI com Conda do ~/examples/keras.

• Para obter mais tutoriais e exemplos, consulte o site do Keras.

PyTorchComo ativar o PyTorchQuando um pacote Conda estável de uma estrutura é lançada, ele é testado e pré-instalado no DLAMI. Sedesejar executar as mais recentes compilações noturnas não testadas, você pode Instale a compilaçãonoturna do PyTorch (experimental) (p. 41) manualmente.

Para ativar a estrutura atualmente instalada, siga estas instruções sobre sua Deep Learning AMI comConda.

Para o PyTorch no Python 3 com o CUDA 10 e MKL-DNN, execute este comando:

$ source activate pytorch_p36

Para o PyTorch no Python 2 com o CUDA 10 e MKL-DNN, execute este comando:



(pytorch_p36)$ ipython

40

https://keras.io/


Execute um programa rápido do PyTorch.

import torchx = 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.

Instale a compilação noturna do PyTorch (experimental)

Como instalar o PyTorch a partir de uma compilação noturna

Você pode instalar a versão mais recente do PyTorch construída em um ou ambos os ambientes PyTorchConda no seu Deep Learning AMI com Conda.

1. • (Opção para Python 3) - ative o ambiente Python 3 PyTorch:


• (Opção para Python 2) - ative o ambiente Python 2 PyTorch:


2. As etapas restantes assumem que você está usando o ambiente do pytorch_p36. Remova oPyTorch atualmente instalado:

(pytorch_p36)$ pip uninstall torch

3. • (Opção para instâncias de GPU) – Instale a versão mais recente da compilação noturna doPyTorch com CUDA 10.0:

(pytorch_p36)$ pip install torch_nightly -f https://download.pytorch.org/whl/nightly/cu100/torch_nightly.html

• (Opção para instâncias CPU) - Instale a versão mais recente da compilação noturna do PyTorchpara instâncias sem GPUs:

(pytorch_p36)$ pip install torch_nightly -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html

4. Para verificar se você instalou com sucesso a versão mais recente da compilação noturna, inicie oterminal IPython e verifique a versão do PyTorch.

(pytorch_p36)$ ipython

import torchprint (torch.__version__)

A saída deve imprimir algo semelhante a 1.0.0.dev201809225. Para verificar que a compilação noturna do PyTorch funcione bem com o MNIST de exemplo, você

pode executar um script de teste do repositório de exemplos do PyTorch:

(pytorch_p36)$ cd ~

41


(pytorch_p36)$ git clone https://github.com/pytorch/examples.git pytorch_examples(pytorch_p36)$ cd pytorch_examples/mnist(pytorch_p36)$ python main.py || exit 1

Mais tutoriaisVocê pode localizar mais tutoriais na pasta de tutoriais Deep Learning AMI com Conda no diretórioinicial da DLAMI. Para obter mais tutoriais e exemplos, consulte os documentos oficiais da estrutura,Documentação do PyTorch e o site do PyTorch.

• Tutorial do PyTorch para ONNX para MXNet (p. 110)• Tutorial do PyTorch para ONNX para CNTK (p. 108)

TensorFlowComo ativar o TensorFlowEste tutorial mostra como ativar o TensorFlow em uma instância executando a Deep Learning AMI comConda (DLAMI no Conda) e executando um programa do TensorFlow.

Quando um pacote Conda estável de uma estrutura é lançada, ele é testado e pré-instalado no DLAMI. Sedesejar executar as mais recentes compilações noturnas não testadas, você pode Instale a compilaçãonoturna do TensorFlow (experimental) (p. 42) manualmente.

Para executar o TensorFlow na DLAMI com Conda

1. Para ativar o TensorFlow, abra uma instância do Amazon Elastic Compute Cloud (Amazon EC2) daDLAMI com Conda.• Para TensorFlow e Keras 2 no Python 3 com CUDA 9.0 e MKL-DNN, execute este comando:


• Para TensorFlow e Keras 2 no Python 2 com CUDA 9.0 e MKL-DNN, execute este comando:



(tensorflow_p36)$ ipython

3. Execute um programa do TensorFlow para verificar se ele está funcionando corretamente:

import tensorflow as tfhello = tf.constant('Hello, TensorFlow!')sess = tf.Session()print(sess.run(hello))

Hello, TensorFlow! deve aparecer na tela.

Instale a compilação noturna do TensorFlow (experimental)Você pode instalar a versão mais recente do TensorFlow criada em um ou ambos os ambientesTensorFlow Conda no seu Deep Learning AMI com Conda.

42

http://pytorch.org/docs/master/

http://pytorch.org


Para instalar o TensorFlow a partir de uma compilação noturna

1. • Para o ambiente Pyhton 3 do TensorFlow, execute este comando:


• Para o ambiente Pyhton 2 do TensorFlow, execute este comando:


2. Remova o TensorFlow instalado:

Note

As etapas restantes supõem que você esteja usando o ambiente do tensorflow_p36.

(tensorflow_p36)$ pip uninstall tensorflow

3. Instale a última compilação noturna do TensorFlow.

(tensorflow_p36)$ pip install tf-nightly

4. Para verificar se você instalou com sucesso a versão mais recente da compilação noturna, inicie oterminal IPython e verifique a versão do TensorFlow.


import tensorflowprint (tensorflow.__version__)

A saída deve imprimir algo semelhante a 1.12.0-dev20181012

Mais tutoriais

TensorFlow com Horovod (p. 61)

TensorBoard (p. 50)

TensorFlow Serving (p. 114)

Para tutoriais, consulte a pasta denominada Deep Learning AMI com Conda tutorials no diretórioinicial da DLAMI.

Para obter mais tutoriais e exemplos, consulte a documentação do TensorFlow para a API do PythonTensorFlow ou acesse o site do TensorFlow.

TensorFlow 2Este tutorial mostra como ativar o TensorFlow 2 em uma instância executando a Deep Learning AMI comConda (DLAMI com Conda) e um programa do TensorFlow 2.

Quando um pacote Conda estável de uma estrutura é lançada, ele é testado e pré-instalado no DLAMI. Sedesejar executar as mais recentes compilações noturnas não testadas, você pode Instale a compilaçãonoturna do TensorFlow 2 (experimental) (p. 44) manualmente.

43

https://www.tensorflow.org/api_docs/python/


https://www.tensorflow.org


Como ativar o TensorFlow 2

Para executar o TensorFlow na DLAMI com Conda

1. Para ativar o TensorFlow 2, abra uma instância do Amazon Elastic Compute Cloud (Amazon EC2) daDLAMI com Conda.• Para TensorFlow 2 e Keras 2 no Python 3 com CUDA 10.0 e MKL-DNN, execute este comando:

$ source activate tensorflow2_p36

• Para TensorFlow 2 e Keras 2 no Python 2 com CUDA 10.0 e MKL-DNN, execute este comando:



(tensorflow2_p36)$ ipython

3. Execute um programa do TensorFlow 2 para verificar se ele está funcionando corretamente:

import tensorflow as tfhello = tf.constant('Hello, TensorFlow!')tf.print(hello)

Hello, TensorFlow! deve aparecer na tela.

Instale a compilação noturna do TensorFlow 2 (experimental)Você pode instalar a compilação mais recente do TensorFlow 2 criada em um ou ambos os ambientesConda do TensorFlow 2 na sua Deep Learning AMI com Conda.

Para instalar o TensorFlow a partir de uma compilação noturna

1. • Para o ambiente Python 3 do TensorFlow 2, execute este comando:


• Para o ambiente Python 2 do TensorFlow 2, execute este comando:


2. Remova o TensorFlow instalado:Note

As etapas restantes supõem que você esteja usando o ambiente do tensorflow2_p36.

(tensorflow2_p36)$ pip uninstall tensorflow

3. Instale a última compilação noturna do TensorFlow.

(tensorflow2_p36)$ pip install tf-nightly

4. Para verificar se você instalou com sucesso a versão mais recente da compilação noturna, inicie oterminal IPython e verifique a versão do TensorFlow.

44



import tensorflowprint (tensorflow.__version__)

A saída deve imprimir algo semelhante a 2.1.0-dev20191122

Mais tutoriais

Para tutoriais, consulte a pasta denominada Deep Learning AMI com Conda tutorials no diretórioinicial da DLAMI.

Para obter mais tutoriais e exemplos, consulte a documentação do TensorFlow para a API do PythonTensorFlow ou acesse o site do TensorFlow.

TensorFlow com HorovodEste tutorial mostra como ativar o TensorFlow com Horovod em uma AWS Deep Learning AMI (DLAMI)com Conda. O Horovod é pré-instalado nos ambientes Conda para TensorFlow. O ambiente Python3 érecomendado.

Note

Apenas os tipos de instância P3.*, P2.* e G3.* são compatíveis.

Para ativar o TensorFlow e testar o Horovod na DLAMI com Conda

1. Abra uma instância do Amazon Elastic Compute Cloud (Amazon EC2) da DLAMI com Conda. Paraobter ajuda sobre os conceitos básicos com uma DLAMI, consulte the section called “Como começar ausar a DLAMI” (p. 4).• (Recomendado) Para o TensorFlow com Horovod no Python 3 com CUDA 9, execute o seguinte

comando:


• Para o TensorFlow com Horovod no Python 2 com CUDA 9, execute o seguinte comando:




3. Teste a importação do TensorFlow com Horovod a fim de verificar se ele está funcionandocorretamente:

import horovod.tensorflow as hvdhvd.init()

O seguinte pode ser exibido na tela (você pode ignorar todas as mensagens de aviso).

45



https://www.tensorflow.org


--------------------------------------------------------------------------[[55425,1],0]: A high-performance Open MPI point-to-point messaging modulewas unable to find any relevant network interfaces:

Module: OpenFabrics (openib) Host: ip-172-31-72-4

Another transport will be used instead, although this may result inlower performance.--------------------------------------------------------------------------

Mais informações

• TensorFlow com Horovod (p. 61)• Para tutoriais, consulte a pasta examples/horovod no diretório inicial da DLAMI.• Para obter ainda mais tutoriais e exemplos, consulte o projeto Horovod GitHub.

TensorFlow 2 com HorovodEste tutorial mostra como ativar o TensorFlow 2 com Horovod em uma AWS Deep Learning AMI (DLAMI)com Conda. O Horovod é pré-instalado nos ambientes Conda para TensorFlow 2. O ambiente Python3 érecomendado.

Note


Como ativar o TensorFlow 2 e testar o Horovod na DLAMI com Conda

1. Abra uma instância do Amazon Elastic Compute Cloud (Amazon EC2) da DLAMI com Conda. Paraobter ajuda sobre os conceitos básicos com uma DLAMI, consulte the section called “Como começar ausar a DLAMI” (p. 4).• (Recomendado) Para o TensorFlow 2 com Horovod no Python 3 com CUDA 10, execute o

seguinte comando:


• Para o TensorFlow 2 com Horovod no Python 2 com CUDA 10, execute o seguinte comando:




3. Teste a importação do TensorFlow 2 com Horovod a fim de verificar se ele está funcionandocorretamente:


46

https://github.com/uber/horovod


Se não há nenhuma saída, então, o Horovod está funcionando corretamente. O seguinte pode serexibido na tela (você pode ignorar todas as mensagens de aviso).




Mais informações

• Para tutoriais, consulte a pasta examples/horovod no diretório inicial da DLAMI.• Para obter ainda mais tutoriais e exemplos, consulte o projeto Horovod GitHub.

TheanoTutorial do Theano

Note


Para ativar a estrutura, siga estas instruções sobre sua Deep Learning AMI com Conda.

Para o Theano + Keras no Python 3 com CUDA 9 e cuDNN 7:

$ source activate theano_p36

Para o Theano + Keras no Python 2 com CUDA 9 e cuDNN 7:

$ source activate theano_p27


(theano_p36)$ ipython

Execute um programa rápido do Theano.

import numpyimport theanoimport theano.tensor as T

47


Deep Learning AMI Guia do desenvolvedorDepuração e visualização

from theano import ppx = T.dscalar('x')y = x ** 2gy = T.grad(y, x)pp(gy)

Você deve ver um Theano calculando um gradiente simbólico.

Mais tutoriais

Para obter mais tutoriais e exemplos, consulte os documentos oficiais da estrutura API do Python Theanoe o site do Theano.

Depuração e visualizaçãoConheça as opções de visualização e depuração para a DLAMI. Clique em uma das opções para sabercomo usá-la.

Tópicos• MXBoard (p. 48)• TensorBoard (p. 50)

MXBoardO MXBoard permite inspecionar e interpretar visualmente as execuções e gráficos do MXNet usando osoftware do TensorBoard. Ele executa um servidor web que fornece uma página da web para exibir einteragir com as visualizações do MXBoard.

MXNet, TensorBoard e MXBoard são pré-instalados com a Deep Learning AMI com Conda; (DLAMIcom Conda). Neste tutorial, você usa uma função MXBoard para gerar logs que são compatíveis comTensorBoard.

Tópicos• Como usar o MXNet com MXBoard (p. 48)• Mais informações (p. 50)

Como usar o MXNet com MXBoard

Gerar dados de log MXBoard compatíveis com TensorBoard

1. Conecte-se à instância do Amazon Elastic Compute Cloud (Amazon EC2) da DLAMI com Conda.2. Ative o ambiente do MXNet Python 3.


3. Prepare um script Python para gravar dados gerados pelo operador para um evento de arquivonormal. Os dados são gerados dez vezes com desvio padrão decrescente, depois gravados para oarquivo de evento um por vez. Você verá a distribuição de dados se tornarem gradualmente maiscentralizadas em torno do valor médio. Observe que você especificará o arquivo de evento na pastade logs. Você passa esse caminho de pasta para o binário TensorBoard.

$ vi mxboard_normal.py

4. Cole o seguinte código no arquivo e salve-o:

48

http://deeplearning.net/software/theano/library/index.html

http://deeplearning.net/software/theano/

https://github.com/awslabs/mxboard


import mxnet as mxfrom mxboard import SummaryWriter

with SummaryWriter(logdir='./logs') as sw: for i in range(10): # create a normal distribution with fixed mean and decreasing std data = mx.nd.normal(loc=0, scale=10.0/(i+1), shape=(10, 3, 8, 8)) sw.add_histogram(tag='norml_dist', values=data, bins=200, global_step=i)

5. Execute o script. Isso irá gerar logs em uma pasta logs que você pode usar para visualizações.

$ python mxboard_normal.py

6. Agora você deve alternar para o ambiente TensorFlow para usar TensorBoard e MXBoard paravisualizar os logs. Esta é uma dependência obrigatória para MXBoard e TensorBoard.


7. Passe a localização dos logs para o tensorboard:

$ tensorboard --logdir=./logs --host=127.0.0.1 --port=8888

O TensorBoard inicia o servidor web de visualização na porta 8888.8. Para facilitar o acesso do navegador local, você pode alterar a porta do servidor web para a porta 80

ou outra. Qualquer que seja a porta usada, você precisará abrir essa porta no grupo de segurançado EC2 para a DLAMI. Você também pode usar o encaminhamento de porta. Para instruções sobrealterar suas configurações do grupo de segurança e encaminhamento de porta, consulte Configurarum servidor de notebook Jupyter (p. 22). As configurações padrão são descritas na próxima etapa.

Note

Se deseja executar o servidor Jupyter e um servidor MXBoard, use uma porta diferente paracada um deles.

9. Abra a porta 8888 (ou a porta atribuída ao servidor web de visualização) na instância do EC2.

a. Abra a instância do EC2 no console do Amazon EC2 em https://console.aws.amazon.com/ec2/.b. No console do Amazon EC2, escolha Network & Security (Rede e segurança) e, em seguida,

escolha Security Groups (Grupos de segurança).c. Para Security Group (Grupo de segurança), escolha o que foi criado mais recentemente, consulte

a data e a hora na descrição.d. Escolha a guia Inbound (Entrada) e Edit (Editar).e. Escolha Adicionar regra.f. Na nova linha, digite o seguinte:

Tipo : Personalizado TCP Rule

Protocolo: TCP

Port Range (Intervalo de portas): 8888 (ou a porta que você atribuiu ao servidor de visualização)

Origem: Anywhere (0.0.0.0/0,::/0)10. Se você deseja visualizar os dados do navegador local, digite o comando a seguir para encaminhar os

dados que são renderizados na instância do EC2 para sua máquina local.

49

https://console.aws.amazon.com/ec2/


$ ssh -Y -L localhost:8888:localhost:8888 user_id@ec2_instance_ip

11. Abra a página da web para as visualizações do MXBoard usando o endereço IP ou DNS público dainstância do EC2 que está executando a DLAMI com Conda e a porta que você abriu para o MXBoard:

http://127.0.0.1:8888

Mais informaçõesPara saber mais sobre o MXBoard, consulte site do MXBoard.

TensorBoardO TensorBoard permite inspecionar e interpretar visualmente as execuções e gráficos do TensorFlow. Eleexecuta um servidor web que fornece uma página da web para exibir e interagir com as visualizações doTensorBoard.

TensorFlow e TensorBoard são pré-instalados com a Deep Learning AMI com Conda; (DLAMI comConda). A DLAMI com Conda também inclui um exemplo de script que usa o TensorFlow para treinarum modelo MNIST com recursos de log extras ativados. O MNIST é um banco de dados de númerosmanuscritos que é comumente usado para treinar modelos de reconhecimento de imagem. Neste tutorial,você usa o script para treinar um modelo MNIST, e o TensorBoard e os logs para criar visualizações.

Tópicos• Treinar um modelo MNIST e visualizar o treinamento com o TensorBoard (p. 50)• Mais informações (p. 51)

Treinar um modelo MNIST e visualizar o treinamento com o TensorBoard

Visualizar o modelo MNIST e treiná-lo com o TensorBoard

1. Conecte-se à instância do Amazon Elastic Compute Cloud (Amazon EC2) da DLAMI com Conda.2. Ative o ambiente de TensorFlow Python 2.7 e navegue até o diretório que contém a pasta com os

exemplos de scripts do TensorBoard:

$ source activate tensorflow_p27$ cd ~/examples/tensorboard/

3. Execute o script que treina um modelo MNIST com o log expandido habilitado:

$ python mnist_with_summaries.py

O script grava os logs em /tmp/tensorflow/mnist.4. Passe a localização dos logs para o tensorboard:

$ tensorboard --logdir=/tmp/tensorflow/mnist

O TensorBoard inicia o servidor web de visualização na porta 6006.5. Para facilitar o acesso do navegador local, você pode alterar a porta do servidor web para a porta 80

ou outra. Qualquer que seja a porta usada, você precisará abrir essa porta no grupo de segurançado EC2 para a DLAMI. Você também pode usar o encaminhamento de porta. Para instruções sobrealterar suas configurações do grupo de segurança e encaminhamento de porta, consulte Configurarum servidor de notebook Jupyter (p. 22). As configurações padrão são descritas na próxima etapa.

50

https://github.com/awslabs/mxboard

https://www.tensorflow.org/get_started/summaries_and_tensorboard

Deep Learning AMI Guia do desenvolvedorTreinamento distribuído

Note

Se deseja executar o servidor Jupyter e um servidor TensorBoard, use uma porta diferentepara cada um deles.

6. Abra a porta 6006 (ou a porta atribuída ao servidor web de visualização) na instância do EC2.

a. Abra a instância do EC2 no console do Amazon EC2 em https://console.aws.amazon.com/ec2/.b. No console do Amazon EC2, escolha Network & Security (Rede e segurança) e, em seguida,

escolha Security Groups (Grupos de segurança).c. Em Security Group, escolha o que foi criado mais recentemente (consulte o time stamp na

descrição).d. Escolha a guia Inbound (Entrada) e Edit (Editar).e. Escolha Adicionar regra.f. Na nova linha, digite o seguinte:

Tipo : Personalizado TCP Rule

Protocolo: TCP

Port Range (Intervalo de portas): 6006 (ou a porta que você atribuiu ao servidor de visualização)

Origem: Custom IP (specify address/range)7. Abra a página da web para as visualizações do TensorBoard usando o endereço IP ou DNS público

da instância do EC2 que está executando a DLAMI com Conda e a porta que você abriu para oTensorBoard:

http:// YourInstancePublicDNS:6006

Mais informações

Para saber mais sobre o TensorBoard, consulte site do TensorBoard.

Treinamento distribuídoConheça as opções que a DLAMI tem para treinamento com várias GPUs. Para obter mais desempenho,consulte Adaptador de malha elástica (p. 68) Clique em uma das opções para saber como usá-la.

Tópicos• Chainer (p. 51)• Keras com MXNet (p. 60)• TensorFlow com Horovod (p. 61)

ChainerO Chainer é uma estrutura flexível baseada em Python para gravar arquiteturas de rede neurais complexasde maneira fácil e intuitiva. O Chainer facilita o uso de instâncias de várias GPUs para treinamento. OChainer também registra automaticamente os resultados, a perda e a precisão do gráfico e produz umasaída para visualizar a rede neural com um gráfico computacional. Ele é incluído com a Deep Learning AMIcom Conda (DLAMI com Conda).

Os tópicos a seguir mostram como treinar em várias GPUs, uma única GPU e uma CPU, criarvisualizações e testar a instalação do Chainer.

51


https://www.tensorflow.org/get_started/summaries_and_tensorboard

https://chainer.org/

https://docs.chainer.org/en/stable/reference/graph.html


Tópicos• Treinar um modelo com o Chainer (p. 52)• Use o Chainer para treinar em várias GPUs (p. 52)• Use o Chainer para treinar em uma única GPU (p. 54)• Usar o Chainer para treinar com CPUs (p. 55)• Resultados de gráficos (p. 56)• Testar o Chainer (p. 60)• Mais informações (p. 60)

Treinar um modelo com o Chainer

Este tutorial mostra como usar scripts de exemplo do Chainer para treinar um modelo com o conjunto dedados do MNIST. O MNIST é um banco de dados de números manuscritos que é comumente usado paratreinar modelos de reconhecimento de imagem. O tutorial também mostra a diferença na velocidade detreinamento entre o treinamento em uma CPU e em uma ou mais GPUs.

Use o Chainer para treinar em várias GPUs

Para treinar em várias GPUs

1. Conecte-se à instância executando Deep Learning AMI com Conda. Consulte a the section called“Seleção de instância” (p. 16) ou a Amazon EC2 documentação do sobre como selecionar ou seconectar a uma instância. Para executar este tutorial, você desejará usar uma instância com, pelomenos, duas GPUs.

2. Ative o ambiente do Chainer Python 3:


3. Para obter os tutoriais mais recentes, clone o repositório do Chainer, e navegue até a pasta deexemplos:

(chainer_p36) :~$ cd ~/src(chainer_p36) :~/src$ CHAINER_VERSION=v$(python -c "import chainer; print(chainer.__version__)")(chainer_p36) :~/src$ git clone -b $CHAINER_VERSION https://github.com/chainer/chainer.git(chainer_p36) :~/src$ cd chainer/examples/mnist

4. Execute o exemplo no script train_mnist_data_parallel.py. Por padrão, o script usa as GPUsem execução na instância da Deep Learning AMI com Conda. O script pode ser executado em duasGPUs no máximo. Ele ignora qualquer GPU após as duas primeiras. Ele detecta uma ou as duasautomaticamente. Se você estiver executando uma instância sem GPUs, vá para Usar o Chainer paratreinar com CPUs (p. 55), mais adiante neste tutorial.

(chainer_p36) :~/src/chainer/examples/mnist$ python train_mnist_data_parallel.py

Note

Este exemplo retornará o seguinte erro devido à inclusão de um recurso beta não incluído naDLAMI.chainerx ModuleNotFoundError: No module named 'chainerx'

Enquanto o script do Chainer treina um modelo usando o banco de dados do MNIST, você verá osresultados para cada epoch.

52

http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html


Em seguida, você verá o exemplo de saída enquanto o script é executado. O exemplo de saída aseguir foi executado em uma instância p3.8xlarge. A saída do script mostra "GPU: 0, 1", que indicaque está usando as duas primeiras das quatro GPUs disponíveis. Normalmente, os scripts usam umíndice de GPUs começando com zero, em vez de uma contagem total.

GPU: 0, 1

# unit: 1000# Minibatch-size: 400# epoch: 20

epoch main/loss validation/main/loss main/accuracy validation/main/accuracy elapsed_time1 0.277561 0.114709 0.919933 0.9654 6.59261 2 0.0882352 0.0799204 0.973334 0.9752 8.25162 3 0.0520674 0.0697055 0.983967 0.9786 9.91661 4 0.0326329 0.0638036 0.989834 0.9805 11.5767 5 0.0272191 0.0671859 0.9917 0.9796 13.2341 6 0.0151008 0.0663898 0.9953 0.9813 14.9068 7 0.0137765 0.0664415 0.995434 0.982 16.5649 8 0.0116909 0.0737597 0.996 0.9801 18.2176 9 0.00773858 0.0795216 0.997367 0.979 19.8797 10 0.00705076 0.0825639 0.997634 0.9785 21.5388 11 0.00773019 0.0858256 0.9978 0.9787 23.2003 12 0.0120371 0.0940225 0.996034 0.9776 24.8587 13 0.00906567 0.0753452 0.997033 0.9824 26.5167 14 0.00852253 0.082996 0.996967 0.9812 28.1777 15 0.00670928 0.102362 0.997867 0.9774 29.8308 16 0.00873565 0.0691577 0.996867 0.9832 31.498 17 0.00717177 0.094268 0.997767 0.9802 33.152 18 0.00585393 0.0778739 0.998267 0.9827 34.8268 19 0.00764773 0.107757 0.9975 0.9773 36.4819 20 0.00620508 0.0834309 0.998167 0.9834 38.1389

5. Enquanto o treinamento está sendo executado, é útil examinar a utilização da GPU. Você podeverificar quais GPUs estão ativas e visualizar suas cargas. O NVIDIA fornece uma ferramenta paraisso, que pode ser executada com o comando nvidia-smi. No entanto, ela apenas mostra umsnapshot da utilização, portanto, é mais informativo combiná-la com o comando watch do Linux.O comando a seguir usa watch com nvidia-smi para atualizar a utilização da GPU atual a cadadécimo de segundo. Abra uma sessão de terminal para a DLAMI e execute o comando a seguir:

53


(chainer_p36) :~$ watch -n0.1 nvidia-smi

Você verá uma saída semelhante ao resultado a seguir. Use ctrl-c para fechar a ferramenta ouapenas para mantê-la em execução enquanto você testa outros exemplos na primeira sessão determinal.

Every 0.1s: nvidia-smi Wed Feb 28 00:28:50 2018

Wed Feb 28 00:28:50 2018+-----------------------------------------------------------------------------+| NVIDIA-SMI 384.111 Driver Version: 384.111 ||-------------------------------+----------------------+----------------------+| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC || Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. ||===============================+======================+======================|| 0 Tesla V100-SXM2... On | 00000000:00:1B.0 Off | 0 || N/A 46C P0 56W / 300W | 728MiB / 16152MiB | 10% Default |+-------------------------------+----------------------+----------------------+| 1 Tesla V100-SXM2... On | 00000000:00:1C.0 Off | 0 || N/A 44C P0 53W / 300W | 696MiB / 16152MiB | 4% Default |+-------------------------------+----------------------+----------------------+| 2 Tesla V100-SXM2... On | 00000000:00:1D.0 Off | 0 || N/A 42C P0 38W / 300W | 10MiB / 16152MiB | 0% Default |+-------------------------------+----------------------+----------------------+| 3 Tesla V100-SXM2... On | 00000000:00:1E.0 Off | 0 || N/A 46C P0 40W / 300W | 10MiB / 16152MiB | 0% Default |+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+| Processes: GPU Memory || GPU PID Type Process name Usage ||=============================================================================|| 0 54418 C python 718MiB || 1 54418 C python 686MiB |+-----------------------------------------------------------------------------+

Neste exemplo, a GPU 0 e a GPU 1 estão ativas e a GPU 2 e 3 não estão. Também é possível ver autilização da memória por GPU.

6. Conforme o treinamento é concluído, observe o tempo decorrido na primeira sessão de terminal. Noexemplo, o tempo decorrido é de 38,1389 segundos.

Use o Chainer para treinar em uma única GPU

Este exemplo mostra como treinar em uma única GPU. Você pode fazer isso se tiver apenas uma GPUdisponível ou apenas para ver como o treinamento de várias GPUs pode ser escalado com o Chainer.

Para usar o Chainer para treinar em uma única GPU

• Para este exemplo, você usa outro script, train_mnist.py, e indica que ele use apenas a GPU 0com o argumento --gpu=0. Para ver como GPUs diferentes são ativadas no console nvidia-smi,você pode indicar que o script use a GPU número 1 usando --gpu=1.

(chainer_p36) :~/src/chainer/examples/mnist$ python train_mnist.py --gpu=0

GPU: 0# unit: 1000

54


# Minibatch-size: 100# epoch: 20


Neste exemplo, a execução em uma única GPU levou quase o dobro do tempo! Treinar modelosmaiores ou conjuntos de dados maiores produz resultados diferentes deste exemplo, portanto, façatestes para avaliar melhor o desempenho da GPU.

Usar o Chainer para treinar com CPUs

Agora, tente o treinamento em um modo somente CPU. Execute o mesmo script, pythontrain_mnist.py, sem argumentos:

(chainer_p36) :~/src/chainer/examples/mnist$ python train_mnist.py

Na saída, GPU: -1 indica que nenhuma GPU está sendo usada:

GPU: -1# unit: 1000

55


# Minibatch-size: 100# epoch: 20


Neste exemplo, o MNIST foi treinado em 323 segundos, que é um tempo mais de 11x maior que o tempodo treinamento com duas GPUs. Se você alguma vez duvidou do poder das GPUs, este exemplo mostra oquanto elas são mais eficientes.

Resultados de gráficos

O Chainer também registra automaticamente os resultados, a perda e a precisão do gráfico e produz umasaída para plotar o gráfico computacional.

Para gerar o gráfico computacional

1. Depois que a execução de qualquer treinamento for concluída, você pode navegar até o diretórioresult e visualizar a precisão e a perda da execução na forma de duas imagens geradasautomaticamente. Navegue até lá agora e liste o conteúdo:

(chainer_p36) :~/src/chainer/examples/mnist$ cd result

56


(chainer_p36) :~/src/chainer/examples/mnist/result$ ls

O diretório result contém dois arquivos em formato .png: accuracy.png e loss.png.2. Para visualizar os gráficos, use o comando scp para copiá-los para o computador local.

Em um terminal macOS, a execução do seguinte comando scp faz download de todos os trêsarquivos na pasta Downloads. Substitua os espaços reservados do local do arquivo principal e doendereço do servidor com suas informações. Para outros sistemas operacionais, use o formato decomando scp adequado. Observe que, para uma AMI do Amazon Linux, o nome do usuário é ec2-user.

(chainer_p36) :~/src/chainer/examples/mnist/result$ scp -i "your-key-file.pem" [email protected]:~/src/chainer/examples/mnist/result/*.png ~/Downloads

As imagens a seguir são exemplos de precisão, perda e gráficos computacionais, respectivamente.

57


58


59


Testar o Chainer

Para testar o Chainer e verificar a GPU compatível com um script de teste pré-instalado, execute ocomando a seguir:

(chainer_p36) :~/src/chainer/examples/mnist/result$ cd ~/src/bin(chainer_p36) :~/src/bin$ ./testChainer

Isso faz download do código-fonte do Chainer e executa o MNIST de exemplo nas várias GPUs doChainer.

Mais informações

Para saber mais sobre o Chainer, consulte o Site de documentação do Chainer. A pasta de exemplosChainer contém mais exemplos. Teste-os para ver como eles são executados.

Keras com MXNetEste tutorial mostra como ativar e usar o Keras 2 com o back-end do MXNet em uma Deep Learning AMIcom Conda.

Ative o Keras com o back-end do MXNet e teste-o na DLAMI com Conda

1. Para ativar o Keras com o back-end do MXNet, abra uma instância do Amazon Elastic Compute Cloud(Amazon EC2) da DLAMI com Conda.• Para Python 3, execute este comando:


• Para Python 2, execute este comando:




3. Teste a importação do Keras com MXNet a fim de verificar se ela está funcionando corretamente:

import keras as k

O seguinte deve ser exibido na tela (possivelmente após algumas mensagens de aviso).

Using MXNet backend

Note

Se você receber um erro ou se o back-end de TensorFlow ainda estiver sendo usado,você precisa atualizar a configuração do Keras manualmente. Edite o arquivo ~/.keras/keras.json e altere a configuração do back-end para mxnet.

60

https://docs.chainer.org/


Tutorial de treinamento do Keras-MXNet com várias GPUs

Treinar uma rede neural convolucional (CNN)

1. Abra um terminal e SSH em sua DLAMI.2. Navegue para a pasta ~/examples/keras-mxnet/.3. Execute nvidia-smi na janela do terminal para determinar o número de GPUs disponíveis no seu

DLAMI. Na próxima etapa, você irá executar o script no estado em que se encontra se tiver quatroGPUs.

4. (Opcional) Execute o seguinte comando para abrir o script para edição.

(mxnet_p36)$ vi cifar10_resnet_multi_gpu.py

5. (Opcional) O script tem a seguinte linha que define o número de GPUs. Atualize-o, se necessário.

model = multi_gpu_model(model, gpus=4)

6. Agora, rode o treinamento.

(mxnet_p36)$ python cifar10_resnet_multi_gpu.py

Note

Keras-MXNet é executado até duas vezes mais rápido com a definição channels_firstimage_data_format. Para alterar a channels_first, edite o arquivo de configuração(Keras~/.keras/keras.json) e defina o seguinte: "image_data_format":"channels_first".Para obter mais técnicas de ajuste de desempenho, consulte Guia de ajuste de desempenho doKeras-MXNet.

Mais informações

• Você pode encontrar exemplos para Keras com um back-end do MXNet no diretório Deep Learning AMIcom Conda do ~/examples/keras-mxnet.

• Para obter ainda mais tutoriais e exemplos, consulte o projeto Keras-MXNet GitHub.

TensorFlow com HorovodEste tutorial mostra como usar o TensorFlow com Horovod em uma Deep Learning AMI com Conda. OHorovod é pré-instalado nos ambientes Conda para TensorFlow. O ambiente Python 3 é recomendado.Para seguir estas instruções, é necessário conhecer a instância DLAMI com um ou mais GPUs. Para obtermais informações, consulte Como começar a usar a DLAMI (p. 4).

Note


Note

Há dois locais onde o mpirun (via OpenMPI) está disponível. Ele está disponível em /usr/bine /home/ubuntu/anaconda3/envs/<env>/bin. env é um ambiente que corresponde àestrutura, como o Tensorflow e o Apache MXNet. As versões mais recentes do OpenMPI estão

61

https://github.com/awslabs/keras-apache-mxnet/blob/master/docs/mxnet_backend/performance_guide.md

https://github.com/awslabs/keras-apache-mxnet/blob/master/docs/mxnet_backend/performance_guide.md

https://github.com/awslabs/keras-apache-mxnet


disponíveis nos ambientes conda. Recomendamos usar o caminho absoluto do binário mpirunou o sinalizador --prefix para executar cargas de trabalho mpi. Por exemplo, com o ambientepython36 do Tensorflow, use:

/home/ubuntu/anaconda3/envs/tensorflow_p36/bin/mpirun <args>

or

mpirun --prefix /home/ubuntu/anaconda3/envs/tensorflow_p36/bin <args>

Ativar e testar o TensorFlow com Horovod

1. Verifique se sua instância tem GPUs ativas. O NVIDIA fornece uma ferramenta para isso:

$ nvidia-smi

2. Ative o ambiente Python 3 TensorFlow:




4. Teste a importação do TensorFlow com Horovod a fim de verificar se ele está funcionandocorretamente:


O seguinte pode ser exibido na tela (possivelmente após algumas mensagens de aviso).




Configure o arquivo de hosts do Horovod

Você pode usar o Horovod para o treinamento de vários GPUs e um único nó, ou várias GPUs e váriosnós. Se você planeja usar vários nós para treinamento distribuído, adicione cada endereço IP privado daDLAMI a um arquivo de hosts. O DLAMI ao qual você está conectado no momento é chamado de líder.Outras instâncias do DLAMI que fazem parte do cluster são chamadas de membros.

Antes de começar esta seção, inicie uma ou mais DLAMI e aguarde até que todas estejam no estadoReady (Pronta). Os scripts de exemplo esperam um arquivo de hosts. Portanto, mesmo que você planejeusar apenas um DLAMI, crie um arquivo de hosts com apenas uma entrada. Se você editar o arquivo dehosts após o início do treinamento, será necessário reiniciar o treinamento para que tenha efeito a adiçãoou remoção de hosts.

62

https://www.open-mpi.org/faq/?category=running#mpirun-prefix


Para configurar o Horovod para treinamento

1. Altere os diretórios para os locais em que os scripts de treinamento estão.

cd ~/examples/horovod/tensorflow

2. Use o vim para editar um arquivo no diretório inicial do líder.

vim hosts

3. Selecione um dos membros no console do Amazon Elastic Compute Cloud, e o painel de descrição doconsole será exibido. Encontre o campo Private IPs (IPs privados), copie o IP e cole-o em um arquivode texto. Copie o IP privado de cada membro em uma nova linha. Em seguida, ao lado de cada IP,adicione um espaço e, em seguida, o texto slots=8 conforme mostrado abaixo. Isso representaquantas GPUs há em cada instância. As instâncias p3.16xlarge têm 8 GPUs. Se você escolher umtipo de instância diferente, deverá fornecer o número real de GPUs para cada instância. Para o líder,você pode usar localhost. Com um cluster de 4 nós, ele deve ser semelhante ao seguinte:

172.100.1.200 slots=8172.200.8.99 slots=8172.48.3.124 slots=8localhost slots=8

Salve o arquivo e volte para o terminal do líder.4. Agora o líder sabe como alcançar cada membro. Isso tudo acontecerá nas interfaces de rede privada.

Em seguida, use uma função bash curta para ajudar a enviar comandos a cada membro.

function runclust(){ while read -u 10 host; do host=${host%% slots*}; ssh -o "StrictHostKeyChecking no" $host ""$2""; done 10<$1; };

5. A primeira ordem do dia é para informar outros membros para não fazer "StrickHostKeyChecking",pois isso pode causar travamento do treinamento.

runclust hosts "echo \"StrictHostKeyChecking no\" >> ~/.ssh/config"

Treinamento com dados sintéticos

Seu DLAMI é fornecido com um script de exemplo para treinar um modelo com dados sintéticos. Ele testase o líder pode se comunicar com os membros do cluster. Um arquivo de hosts é necessário. ConsulteConfigure o arquivo de hosts do Horovod (p. 62) para ver as instruções.

Para testar o treinamento do Horovod com dados de exemplo.

1. O ~/examples/horovod/tensorflow/train_synthetic.sh tem como padrão 8 GPUs, masvocê pode fornecer o número de GPUs que quiser executar. O exemplo a seguir executa o script,transmitindo 4 como um parâmetro para 4 GPUs.

$ ./train_synthetic.sh 4

Após algumas mensagens de aviso, você verá a saída a seguir que verifica se o Horovod está usando4 GPUs.

PY3.6.5 |Anaconda custom (64-bit)| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0]TF1.11.0Horovod size: 4

63


Em seguida, depois de alguns outros avisos, você verá o início de uma tabela e alguns pontos dedados. Se você não quiser ver os 1.000 lotes, saia do treinamento.

Step Epoch Speed Loss FinLoss LR 0 0.0 105.6 6.794 7.708 6.40000 1 0.0 311.7 0.000 4.315 6.38721 100 0.1 3010.2 0.000 34.446 5.18400 200 0.2 3013.6 0.000 13.077 4.09600 300 0.2 3012.8 0.000 6.196 3.13600 400 0.3 3012.5 0.000 3.551 2.30401

2. O Horovod usa todos os GPUs locais antes de tentar usar os GPUs dos membros do cluster. Portanto,para se certificar de que o treinamento distribuído no cluster esteja funcionando, teste todos os GPUsque você pretende usar. Se, por exemplo, você tiver 4 membros do tipo de instância p3.16xlarge, vocêterá 32 GPUs no cluster. Este é o local em que você deseja testar os 32 GPUs.

./train_synthetic.sh 32

O resultado será semelhante ao do teste anterior. O tamanho do Horovod é 32 e cerca de quatrovezes a velocidade. Com essa experimentação concluída, você testou o seu líder e a capacidadedele de se comunicar com os membros. Se tiver problemas, consulte a seção Solução deproblemas (p. 67).

Preparar o conjunto de dados ImageNet

Nesta seção, você fará download do conjunto de dados ImageNet e, em seguida, gerará um conjuntode dados no formato TFRecord a partir do conjunto de dados brutos. Um conjunto de scripts de pré-processamento é fornecido na DLAMI para o conjunto de dados ImageNet que você pode usar paraImageNet ou como um modelo para outro conjunto de dados. Os scripts de treinamento principais quesão configurados para ImageNet também são fornecidos. Para acompanhar a seção a seguir, é precisojá ter executado um DLAMI com uma instância do EC2 com 8 GPUs. Recomendamos o tipo de instânciap3.16xlarge.

No diretório ~/examples/horovod/tensorflow/utils no seu DLAMI, você encontra os seguintesscripts:

• utils/preprocess_imagenet.py – Use para converter o conjunto de dados ImageNet no formatoTFRecord.

• utils/tensorflow_image_resizer.py – Use para redimensionar o conjunto de dados TFRecordconforme recomendado para o treinamento do ImageNet.

Preparar o conjunto de dados ImageNet

1. Visite image-net.org, crie uma conta, adquira uma chave de acesso e faça download do conjunto dedados. image-net.org hospeda o conjunto de dados bruto. Para fazer download dele, você precisa teruma conta do ImageNet e uma chave de acesso. A conta é gratuita, e para obter a chave de acessogratuita você precisa aceitar a licença do ImageNet.

2. Use o script de pré-processamento de imagem para gerar um conjunto de dados no formato TFRecorddo conjunto de dados ImageNet bruto. No diretório ~/examples/horovod/tensorflow/utils:

python preprocess_imagenet.py \ --local_scratch_dir=[YOUR DIRECTORY] \ --imagenet_username=[imagenet account] \

64

http://image-net.org

http://image-net.org


--imagenet_access_key=[imagenet access key]

3. Use o script de redimensionamento de imagem. Se você redimensionar as imagens, o treinamentoserá executado com mais rapidez e se alinhará melhor com o papel de referência ResNet. No diretório~/examples/horovod/utils/preprocess:

python tensorflow_image_resizer.py \ -d imagenet \ -i [PATH TO TFRECORD TRAINING DATASET] \ -o [PATH TO RESIZED TFRECORD TRAINING DATASET] \ --subset_name train \ --num_preprocess_threads 60 \ --num_intra_threads 2 \ --num_inter_threads 2

Treinar um modelo ResNet-50 ImageNet em um DLAMI únicoNote

• O script neste tutorial espera que os dados de treinamento pré-processados estejam na pasta~/data/tf-imagenet/. Consulte Preparar o conjunto de dados ImageNet (p. 64) para veras instruções.

• Um arquivo de hosts é necessário. Consulte Configure o arquivo de hosts do Horovod (p. 62)para ver as instruções.

Usar o Horovod para treinar um ResNet50 CNN no conjunto de dados ImageNet

1. Navegue para a pasta ~/examples/horovod/tensorflow.

cd ~/examples/horovod/tensorflow

2. Verifique sua configuração e defina o número de GPUs para uso no treinamento. Primeiro, revise ohosts que está na mesma pasta que os scripts. Esse arquivo deverá ser atualizado se você usar umainstância com menos de 8 GPUs. Por padrão, ele diz localhost slots=8. Atualize o número 8para o número de GPUs que você deseja usar.

3. É fornecido um script de shell que considera o número de GPUs que você planeja usar como o únicoparâmetro. Execute esse script para iniciar o treinamento. O exemplo a seguir usa 4 para quatroGPUs.

./train.sh 4

4. Pode levar algumas horas para ser concluído. Ele usa mpirun para distribuir o treinamento por suasGPUs.

Treinar um modelo ResNet-50 ImageNet em um cluster do DLAMINote

• O script neste tutorial espera que os dados de treinamento pré-processados estejam na pasta~/data/tf-imagenet/. Consulte Preparar o conjunto de dados ImageNet (p. 64) para veras instruções.

• Um arquivo de hosts é necessário. Consulte Configure o arquivo de hosts do Horovod (p. 62)para ver as instruções.

65

https://arxiv.org/abs/1512.03385


Este exemplo mostra um modelo de treinamento ResNet-50 em um conjunto de dados preparado emvários nós em um cluster do DLAMI.

• Para um desempenho mais rápido, recomendamos que você tenha o conjunto de dados localmenteem cada membro do cluster.

Use a função copyclust para copiar os dados para outros membros.

function copyclust(){ while read -u 10 host; do host=${host%% slots*}; rsync -azv "$2" $host:"$3"; done 10<$1; };

Ou, se os arquivos estiverem em um bucket do S3, use a função runclust para fazer download dosarquivos para cada membro diretamente.

runclust hosts "tmux new-session -d \"export AWS_ACCESS_KEY_ID=YOUR_ACCESS_KEY && export AWS_SECRET_ACCESS_KEY=YOUR_SECRET && aws s3 sync s3://your-imagenet-bucket ~/data/tf-imagenet/ && aws s3 sync s3://your-imagenet-validation-bucket ~/data/tf-imagenet/\""

Com as ferramentas para gerenciar vários nós de uma só vez, a economia de tempo é enorme. Você podeaguardar cada etapa e gerenciar cada instância separadamente ou usar ferramentas como tmux ou screenpara poder desconectar e retomar sessões.

Depois que a cópia for concluída, você está pronto para iniciar o treinamento. Execute o script,transmitindo 32 como um parâmetro para os 32 GPUs que estamos usando nesta execução. Use o tmuxou uma ferramenta similar se você estiver preocupado com a desconexão e encerramento da sua sessão,que deve encerrar a execução do treinamento.

./train.sh 32

O resultado a seguir é o que você verá ao executar o treinamento em ImageNet com 32 GPUs. 32 GPUsdemoram entre 90 e 110 minutos.

Step Epoch Speed Loss FinLoss LR 0 0.0 440.6 6.935 7.850 0.00100 1 0.0 2215.4 6.923 7.837 0.00305 50 0.3 19347.5 6.515 7.425 0.10353 100 0.6 18631.7 6.275 7.173 0.20606 150 1.0 19742.0 6.043 6.922 0.30860 200 1.3 19790.7 5.730 6.586 0.41113 250 1.6 20309.4 5.631 6.458 0.51366 300 1.9 19943.9 5.233 6.027 0.61619 350 2.2 19329.8 5.101 5.864 0.71872 400 2.6 19605.4 4.787 5.519 0.82126 ... 13750 87.9 19398.8 0.676 1.082 0.00217 13800 88.2 19827.5 0.662 1.067 0.00156 13850 88.6 19986.7 0.591 0.997 0.00104 13900 88.9 19595.1 0.598 1.003 0.00064 13950 89.2 19721.8 0.633 1.039 0.00033 14000 89.5 19567.8 0.567 0.973 0.00012 14050 89.8 20902.4 0.803 1.209 0.00002 Finished in 6004.354426383972

Após concluída uma execução do treinamento, o script prosseguirá com uma execução de avaliação. Ele éexecutado no líder, pois é executado de maneira tão veloz que não precisa distribuir o trabalho para outrosmembros. Veja a seguir o resultado da execução de avaliação.

66


Horovod size: 32EvaluatingValidation dataset size: 50000[ip-172-31-36-75:54959] 7 more processes have sent help message help-btl-vader.txt / cma-permission-denied[ip-172-31-36-75:54959] Set MCA parameter "orte_base_help_aggregate" to 0 to see all help / error messages step epoch top1 top5 loss checkpoint_time(UTC) 14075 90.0 75.716 92.91 0.97 2018-11-14 08:38:28

Veja a seguir um exemplo de resultado retornado quando o script é executado com 256 GPUs onde otempo de execução foi entre 14 e 15 minutos.

Step Epoch Speed Loss FinLoss LR 1400 71.6 143451.0 1.189 1.720 0.14850 1450 74.2 142679.2 0.897 1.402 0.10283 1500 76.7 143268.6 1.326 1.809 0.06719 1550 79.3 142660.9 1.002 1.470 0.04059 1600 81.8 143302.2 0.981 1.439 0.02190 1650 84.4 144808.2 0.740 1.192 0.00987 1700 87.0 144790.6 0.909 1.359 0.00313 1750 89.5 143499.8 0.844 1.293 0.00026Finished in 860.5105031204224

Finished evaluation1759 90.0 75.086 92.47 0.99 2018-11-20 07:18:18

Solução de problemas

O comando a seguir pode ajudar a identificar erros passados que surgem quando você testa o Horovod.

• Se o treinamento falhar por algum motivo, o mpirun pode falhar para limpar todos os processos dopython em cada máquina. Nesse caso, antes de iniciar a próxima tarefa, elimine os processos do pythonem todas as máquinas da seguinte forma:

runclust hosts "pkill -9 python"

• Se o processo encerrar abruptamente sem erros, exclua a pasta de registros.

runclust hosts "rm -rf ~/imagenet_resnet/"

• Se ocorrerem outros problemas inexplicáveis, verifique o espaço em disco. Se você estiver fora, removaa pasta de registros, pois ela está cheia de pontos de verificação e de dados. Você também podeaumentar o tamanho do volume para cada membro.

runclust hosts "df /"

• Como último recurso, você também pode reinicializar.

runclust hosts "sudo reboot"

Você pode receber o seguinte código de erro se você tentar usar o TensorFlow com Horovod em um tipode instância não compatível:

---------------------------------------------------------------------------

67

Deep Learning AMI Guia do desenvolvedorAdaptador de malha elástica

NotFoundError Traceback (most recent call last)<ipython-input-3-e90ed6cabab4> in <module>()----> 1 import horovod.tensorflow as hvd

~/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/horovod/tensorflow/__init__.py in <module>()** *34* check_extension('horovod.tensorflow', 'HOROVOD_WITH_TENSORFLOW', __file__, 'mpi_lib')** *35* ---> 36 from horovod.tensorflow.mpi_ops import allgather, broadcast, _allreduce** *37* from horovod.tensorflow.mpi_ops import init, shutdown** *38* from horovod.tensorflow.mpi_ops import size, local_size, rank, local_rank

~/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/horovod/tensorflow/mpi_ops.py in <module>()** *56* ** *57* MPI_LIB = _load_library('mpi_lib' + get_ext_suffix(),---> 58 ['HorovodAllgather', 'HorovodAllreduce'])** *59* ** *60* _basics = _HorovodBasics(__file__, 'mpi_lib')

~/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/horovod/tensorflow/mpi_ops.py in _load_library(name, op_list)** *43* """** *44* filename = resource_loader.get_path_to_datafile(name)---> 45 library = load_library.load_op_library(filename)** *46* for expected_op in (op_list or []):** *47* for lib_op in library.OP_LIST.op:

~/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tensorflow/python/framework/load_library.py in load_op_library(library_filename)** *59* RuntimeError: when unable to load the library or get the python wrappers.** *60* """---> 61 lib_handle = py_tf.TF_LoadLibrary(library_filename)** *62* ** *63* op_list_str = py_tf.TF_GetOpList(lib_handle)

NotFoundError: /home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/horovod/tensorflow/mpi_lib.cpython-36m-x86_64-linux-gnu.so: undefined symbol: _ZN10tensorflow14kernel_factory17OpKernelRegistrar12InitInternalEPKNS_9KernelDefEN4absl11string_viewEPFPNS_8OpKernelEPNS_20OpKernelConstructionEE

Mais informações

Para utilitários e exemplos, consulte a pasta ~/examples/horovod no diretório inicial do DLAMI.

Para obter ainda mais tutoriais e exemplos, consulte o projeto Horovod GitHub.

Adaptador de malha elásticaO Adaptador de malha elástica (EFA) é um dispositivo de rede que pode ser anexado à sua instância doDLAMI para acelerar os aplicativos de Computação de Alto Desempenho (HPC). O EFA permite que vocêatinja o desempenho do aplicativo de um cluster HPC no local, com a escalabilidade, a flexibilidade e aelasticidade fornecidas pela Nuvem AWS.

Os tópicos a seguir mostram como começar a usar o EFA com a DLAMI.

Tópicos• Executar uma instância do AWS Deep Learning AMI com o EFA (p. 69)• Usar o EFA na DLAMI (p. 72)

68


https://aws.amazon.com/hpc/efa/


Executar uma instância do AWS Deep Learning AMI com o EFAA DLAMI 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 necessários para instâncias de GPU.

Versões do CUDA com suporte: aplicativos NCCL com o EFA têm suporte apenas em CUDA-10.0,CUDA-10.1 e CUDA-10.2 porque o plug-in OFI NCCL requer uma versão de NCCL posterior à 2.4.2.

Observações:

• Ao executar um aplicativo NCCL usando mpirun no EFA, será necessário especificar o caminhocompleto para as instalações do EFA com suporte como:

/opt/amazon/openmpi/bin/mpirun <command>

• Para ativar o aplicativo a fim de usar o EFA, adicione FI_PROVIDER="efa" ao comando mpirun,conforme mostrado em Usar o EFA na DLAMI (p. 72).

Tópicos• Preparar um grupo de segurança habilitado para o EFA (p. 69)• Executar sua instância (p. 70)• Verificar anexo do EFA (p. 70)

Preparar um grupo de segurança habilitado para o EFA

O EFA requer um grupo de segurança que permita todo o tráfego de entrada e saída do grupo desegurança e para ele próprio. Para obter mais informações, consulte a documentação do EFA.

1. Abra o console do Amazon EC2 em https://console.aws.amazon.com/ec2/.2. No painel de navegação, escolha Security Groups (Grupos de segurança) e Create Security Group

(Criar grupo de segurança).3. Na janela Create Security group (Criar grupo de segurança), faça o seguinte:

• Em Nome do grupo de segurança, insira um nome descritivo para o grupo de segurança, comoEFA-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 Create (Criar).

4. Selecione o grupo de segurança que você criou e, na guia Description (Descrição), copie o Group ID(ID do grupo).

5. Nas guias Inbound (Entrada) e Outbound (Saída), faça o seguinte:

• Selecione Edit (Editar).• Em Type (Tipo), escolha All traffic (Todo o tráfego).• Em Source (Origem), escolha Custom (Personalizar).• Cole o ID do grupo de segurança que você copiou no campo.• Escolha Save (Salvar).

6. Habilite o tráfego de entrada fazendo referência a Autorizar tráfego de entrada para as instâncias doLinux. Se ignorar esta etapa, você não poderá se comunicar com sua instância da DLAMI.

69

https://github.com/aws/aws-ofi-nccl/tree/aws

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security


https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html


Executar sua instância

Para obter mais informações, consulte Executar instâncias habilitadas para EFA em um placement groupde cluster.

1. Abra o console do Amazon EC2 em https://console.aws.amazon.com/ec2/.2. Escolha Launch Instance (Executar instância).3. Na página Choose an AMI (Escolher uma AMI), selecione "Deep Learning AMI (Ubuntu 18.04) versão

25.0"4. Na página Choose an Instance Type (Escolher um tipo de instância), selecione um dos seguintes

tipos de instância com suporte e escolha Next: Configure Instance Details (Próximo: Configuraros detalhes da instância). Consulte este link para obter a lista de instâncias com suporte: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html

5. Na página Configure Instance Details (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 paraEFA que você deseja executar.

• Em Network (Rede) e Subnet (Sub-rede), selecione a VPC e a sub-rede na qual executar asinstâncias.

• Em Placement group, selecione Add instance to placement group (Adicionar instância ao placementgroup). Para obter o melhor desempenho, execute as instâncias dentro de um placement group.

• Em Placement group name (Nome do placement group), selecione Add to a new placement group(Adicionar a um novo placement group), insira um nome descritivo para o placement group e, emPlacement group strategy (Estratégia de placement group), selecione cluster.

• Certifique-se de habilitar o "Adaptador de malha elástica" nesta página. Se esta opção estiverdesabilitada, altere a sub-rede para uma que ofereça suporte ao tipo de instância selecionado.

• Na seção Network Interfaces (Interfaces de rede), para o dispositivo eth0, escolha New networkinterface (Nova interface de rede). Como opção, você pode especificar um endereço IPv4 principale um ou mais endereços IPv4 secundários. Se estiver executando a instância em uma sub-rede quetenha um bloco CIDR IPv6 associado, você poderá especificar opcionalmente um endereço IPv6principal e um ou mais endereços IPv6 secundários.

• Escolha Next: Add Storage (Próximo: Adicionar armazenamento).6. Na página Add Storage (Adicionar armazenamento), especifique os volumes a serem anexados às

instâncias em associação aos volumes especificados pela AMI (como o volume do dispositivo raiz) eescolha Next: Add Tags (Próximo: Adicionar tags).

7. Na página Add Tags (Adicionar tags), especifique tags para as instâncias, como um nome amigável, eselecione Next: Configure Security Group (Próximo: Configurar grupo de segurança).

8. Na página Configure Security Group (Configurar grupo de segurança), em Assign a security group(Atribuir um grupo de segurança), selecione Select an existing security group (Selecionar um grupo desegurança existente) e selecione o grupo de segurança que você criou anteriormente.

9. Escolha Review and Launch (Revisar e iniciar).10. Na página Review Instance Launch (Revisar execução da instância), reveja as configurações e

escolha Launch (Executar) para escolher um par de chaves e executar a instâncias.

Verificar anexo do EFA

No console

Depois de executar a instância, verifique os detalhes da instância no Console AWS. Para fazer isso,selecione a instância no console do EC2 e observe a guia "Description (Descrição)" no painel inferior dapágina. Encontre o parâmetro "Network Interfaces: eth0 (Interfaces de rede: eth0)" e clique em eth0 e umpop-up será aberto. Certifique-se de que o "Adaptador de malha elástica" esteja habilitado.

70

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-instances

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-instances


https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html


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. Certifique-se de que o EFAesteja anexado.

• Anexe o EFA a uma instância existente.

1. No console do EC2, acesse "Network Interfaces (Interfaces de rede)".2. Clique em "Create a Network Interface (Criar uma interface de rede)".3. Selecione a mesma sub-rede na qual está sua instância.4. Certifique-se de habilitar o "Adaptador de malha elástica" e clique em "Create (Criar)".5. Volte para a guia "EC2 Instances (Instâncias do EC2)" e selecione sua instância.6. Acesse "Actions: Instance State (Ações: Estado da instância)" e interrompa a instância antes de

anexar o EFA.7. Em "Actions (Ações)", selecione "Networking: Attach Network Interface (Rede: Anexar Interface de

Rede)".8. Selecione a interface que você acabou de criar e clique em "Attach (Anexar)".9. 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 kernelsejam carregados corretamente.

$ fi_info -p efa

Sua saída deve ser semelhante à seguinte:

provider: efa fabric: EFA-fe80::e5:56ff:fe34:56a8 domain: efa_0-rdm version: 2.0 type: FI_EP_RDM protocol: FI_PROTO_EFAprovider: efa fabric: EFA-fe80::e5:56ff:fe34:56a8 domain: efa_0-dgrm version: 2.0 type: FI_EP_DGRAM protocol: FI_PROTO_EFAprovider: 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çacriado esteja configurado corretamente.

$ cd ~/src/bin/efa-tests/$ ./efa_test.sh


71


Starting server...Starting client...bytes #sent #ack total time MB/sec usec/xfer Mxfers/sec64 10 =10 1.2k 0.02s 0.06 1123.55 0.00256 10 =10 5k 0.00s 17.66 14.50 0.071k 10 =10 20k 0.00s 67.81 15.10 0.074k 10 =10 80k 0.00s 237.45 17.25 0.0664k 10 =10 1.2m 0.00s 921.10 71.15 0.011m 10 =10 20m 0.01s 2122.41 494.05 0.00

Se ele trava ou não for concluído, verifique se o grupo de segurança tem as regras corretas de entrada/saída.

Usar o EFA na DLAMIA seção a seguir descreve como usar o EFA para executar aplicativos de vários nós na AWS DeepLearning AMI.

Tópicos• Executar aplicativos de vários nós com o EFA (p. 72)

Executar aplicativos de vários nós com o EFA

Para executar um aplicativo em um cluster de nós, é necessária alguma configuração.

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

2. Altere as permissões da chave privada no nó líder.

chmod 600 ~/.ssh/id_rsa

3. Copie a chave pública ~/.ssh/id_rsa.pub e anexe-a às ~/.ssh/authorized_keys dos nósmembros no cluster.

4. Agora, você poderá fazer login diretamente nos nós membros a partir do nó líder usando o ip privado.

ssh <member private ip>

5. Desative strictHostKeyChecking e habilite o encaminhamento de agente no nó líder adicionando oseguinte ao arquivo ~/.ssh/config no nó líder:

Host * ForwardAgent yesHost * StrictHostKeyChecking no

6. Nas instâncias do Amazon Linux e do Amazon Linux 2, execute o seguinte comando no nó líder parafornecer as permissões corretas ao arquivo de configuração:

chmod 600 ~/.ssh/config

72


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 umaentrada para cada nó no cluster. Crie um arquivo ~/hosts e adicione cada nó usando o ip privado daseguinte forma:

localhost slots=8<private ip of node 1> slots=8<private ip of node 2> slots=8

Verificar plug-in NCCL de 2 nós em P3dn.24xlarge

O nccl_message_transfer é um teste simples para garantir que o plug-in OFI NCCL esteja funcionandocomo esperado. O teste valida a funcionalidade das APIs de estabelecimento de conexão e transferênciade dados do NCCL. Certifique-se de usar o caminho completo para mpirun como mostrado no exemplo aoexecutar aplicativos NCCL com o EFA. Altere os parâmetros np e N com base no número de instâncias eGPUs em seu cluster. Para obter mais informações, consulte a Documentação do AWS OFI NCCL.

O seguinte teste nccl_message_transfer é para CUDA 10.0. Você pode executar os comandos para CUDA10.1 e 10.2 substituindo a versão do CUDA.

$/opt/amazon/openmpi/bin/mpirun \ -n 2 -N 1 --hostfile hosts \ -x LD_LIBRARY_PATH=/usr/local/cuda-10.0/efa/lib:/usr/local/cuda-10.0/lib:/usr/local/cuda-10.0/lib64:/usr/local/cuda-10.0:$LD_LIBRARY_PATH \ ~/src/bin/efa-tests/efa-cuda-10.0/nccl_message_transfer

A saída deve ser semelhante ao seguinte: É possível verificar a saída para ver se o EFA está sendo usadocomo o provedor de OFI.

INFO: Function: ofi_init Line: 702: NET/OFI Forcing AWS OFI ndev 4INFO: Function: ofi_init Line: 714: NET/OFI Selected Provider is efaINFO: Function: main Line: 49: NET/OFI Process rank 1 started. NCCLNet device used on ip-172-31-15-30 is AWS Libfabric.INFO: Function: main Line: 53: NET/OFI Received 4 network devicesINFO: Function: main Line: 57: NET/OFI Server: Listening on dev 0INFO: Function: ofi_init Line: 702: NET/OFI Forcing AWS OFI ndev 4INFO: Function: ofi_init Line: 714: NET/OFI Selected Provider is efaINFO: Function: main Line: 49: NET/OFI Process rank 0 started. NCCLNet device used on ip-172-31-15-30 is AWS Libfabric.INFO: Function: main Line: 53: NET/OFI Received 4 network devicesINFO: Function: main Line: 57: NET/OFI Server: Listening on dev 0INFO: Function: main Line: 96: NET/OFI Send connection request to rank 0INFO: Function: main Line: 69: NET/OFI Send connection request to rank 1INFO: Function: main Line: 100: NET/OFI Server: Start accepting requestsINFO: Function: main Line: 73: NET/OFI Server: Start accepting requestsINFO: Function: main Line: 103: NET/OFI Successfully accepted connection from rank 0INFO: Function: main Line: 107: NET/OFI Rank 1 posting 255 receive buffersINFO: Function: main Line: 76: NET/OFI Successfully accepted connection from rank 1INFO: Function: main Line: 80: NET/OFI Sent 255 requests to rank 1INFO: Function: main Line: 131: NET/OFI Got completions for 255 requests for rank 0INFO: Function: main Line: 131: NET/OFI Got completions for 255 requests for rank 1

Teste de desempenho de vários nós do NCCL em P3dn.24xlarge

Para verificar o desempenho do NCCL com o EFA, execute o teste de desempenho do NCCL padrão queestá disponível no NCCL-Tests Repo. A DLAMI vem com esse teste já criado para CUDA 10.0, 10.1 e10.2. Também é possível executar seu próprio script com o EFA.

73

https://github.com/aws/aws-ofi-nccl/tree/master/tests

https://github.com/NVIDIA/nccl-tests.git


Ao criar seu próprio script, consulte as seguintes orientações:

• Forneça o sinalizador FI_PROVIDER="efa" para habilitar o uso do EFA.• 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 em seu cluster.• Adicione o sinalizador NCCL_DEBUG=INFO e certifique-se de que os logs indicam o uso do EFA como

"Selected Provider is EFA (O provedor selecionado é o EFA)".

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 CUDA 10.0 e dependem do sistema operacional dasua instância. Você pode executar os comandos para CUDA 10.1 e 10.2 substituindo a versão do CUDA.

• Amazon Linux e Amazon Linux 2:

$ /opt/amazon/openmpi/bin/mpirun \ -x FI_PROVIDER="efa" -n 16 -N 8 \ -x NCCL_DEBUG=INFO \ -x FI_EFA_TX_MIN_CREDITS=64 \ -x NCCL_TREE_THRESHOLD=0 \ -x LD_LIBRARY_PATH=/usr/local/cuda-10.0/efa/lib:/usr/local/cuda-10.0/lib:/usr/local/cuda-10.0/lib64:/usr/local/cuda-10.0:/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 \ $HOME/src/bin/efa-tests/efa-cuda-10.0/all_reduce_perf -b 8 -e 1G -f 2 -g 1 -c 1 -n 100

• Ubuntu 16.04 e Ubuntu 18.04:

$ /opt/amazon/openmpi/bin/mpirun \ -x FI_PROVIDER="efa" -n 16 -N 8 \ -x NCCL_DEBUG=INFO \ -x FI_EFA_TX_MIN_CREDITS=64 \ -x NCCL_TREE_THRESHOLD=0 \ -x LD_LIBRARY_PATH=/usr/local/cuda-10.0/efa/lib:/usr/local/cuda-10.0/lib:/usr/local/cuda-10.0/lib64:/usr/local/cuda-10.0:/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 \ $HOME/src/bin/efa-tests/efa-cuda-10.0/all_reduce_perf -b 8 -e 1G -f 2 -g 1 -c 1 -n 100

A saída deve ser semelhante ao seguinte:

# nThread 1 nGpus 1 minBytes 8 maxBytes 1073741824 step: 2(factor) warmup iters: 5 iters: 100 validation: 1## Using devices# Rank 0 Pid 3801 on ip-172-31-41-105 device 0 [0x00] Tesla V100-SXM2-32GB# Rank 1 Pid 3802 on ip-172-31-41-105 device 1 [0x00] Tesla V100-SXM2-32GB# Rank 2 Pid 3803 on ip-172-31-41-105 device 2 [0x00] Tesla V100-SXM2-32GB# Rank 3 Pid 3804 on ip-172-31-41-105 device 3 [0x00] Tesla V100-SXM2-32GB# Rank 4 Pid 3805 on ip-172-31-41-105 device 4 [0x00] Tesla V100-SXM2-32GB# Rank 5 Pid 3807 on ip-172-31-41-105 device 5 [0x00] Tesla V100-SXM2-32GB# Rank 6 Pid 3810 on ip-172-31-41-105 device 6 [0x00] Tesla V100-SXM2-32GB# Rank 7 Pid 3813 on ip-172-31-41-105 device 7 [0x00] Tesla V100-SXM2-32GB# Rank 8 Pid 4124 on ip-172-31-41-36 device 0 [0x00] Tesla V100-SXM2-32GB# Rank 9 Pid 4125 on ip-172-31-41-36 device 1 [0x00] Tesla V100-SXM2-32GB

74


# Rank 10 Pid 4126 on ip-172-31-41-36 device 2 [0x00] Tesla V100-SXM2-32GB# Rank 11 Pid 4127 on ip-172-31-41-36 device 3 [0x00] Tesla V100-SXM2-32GB# Rank 12 Pid 4128 on ip-172-31-41-36 device 4 [0x00] Tesla V100-SXM2-32GB# Rank 13 Pid 4130 on ip-172-31-41-36 device 5 [0x00] Tesla V100-SXM2-32GB# Rank 14 Pid 4132 on ip-172-31-41-36 device 6 [0x00] Tesla V100-SXM2-32GB# Rank 15 Pid 4134 on ip-172-31-41-36 device 7 [0x00] Tesla V100-SXM2-32GBip-172-31-41-105:3801:3801 [0] NCCL INFO Bootstrap : Using [0]ens5:172.31.41.105<0>ip-172-31-41-105:3801:3801 [0] NCCL INFO NET/OFI Forcing AWS OFI ndev 4ip-172-31-41-105:3801:3801 [0] NCCL INFO NET/OFI Selected Provider is efaNCCL version 2.4.8+cuda10.0ip-172-31-41-105:3810:3810 [6] NCCL INFO Bootstrap : Using [0]ens5:172.31.41.105<0>ip-172-31-41-105:3810:3810 [6] NCCL INFO NET/OFI Forcing AWS OFI ndev 4ip-172-31-41-105:3810:3810 [6] NCCL INFO NET/OFI Selected Provider is efaip-172-31-41-105:3805:3805 [4] NCCL INFO Bootstrap : Using [0]ens5:172.31.41.105<0>ip-172-31-41-105:3805:3805 [4] NCCL INFO NET/OFI Forcing AWS OFI ndev 4ip-172-31-41-105:3805:3805 [4] NCCL INFO NET/OFI Selected Provider is efaip-172-31-41-105:3807:3807 [5] NCCL INFO Bootstrap : Using [0]ens5:172.31.41.105<0>ip-172-31-41-105:3807:3807 [5] NCCL INFO NET/OFI Forcing AWS OFI ndev 4ip-172-31-41-105:3807:3807 [5] NCCL INFO NET/OFI Selected Provider is efaip-172-31-41-105:3803:3803 [2] NCCL INFO Bootstrap : Using [0]ens5:172.31.41.105<0>ip-172-31-41-105:3803:3803 [2] NCCL INFO NET/OFI Forcing AWS OFI ndev 4ip-172-31-41-105:3803:3803 [2] NCCL INFO NET/OFI Selected Provider is efaip-172-31-41-105:3813:3813 [7] NCCL INFO Bootstrap : Using [0]ens5:172.31.41.105<0>ip-172-31-41-105:3802:3802 [1] NCCL INFO Bootstrap : Using [0]ens5:172.31.41.105<0>ip-172-31-41-105:3813:3813 [7] NCCL INFO NET/OFI Forcing AWS OFI ndev 4ip-172-31-41-105:3813:3813 [7] NCCL INFO NET/OFI Selected Provider is efaip-172-31-41-105:3802:3802 [1] NCCL INFO NET/OFI Forcing AWS OFI ndev 4ip-172-31-41-105:3802:3802 [1] NCCL INFO NET/OFI Selected Provider is efaip-172-31-41-105:3804:3804 [3] NCCL INFO Bootstrap : Using [0]ens5:172.31.41.105<0>ip-172-31-41-105:3804:3804 [3] NCCL INFO NET/OFI Forcing AWS OFI ndev 4ip-172-31-41-105:3804:3804 [3] NCCL INFO NET/OFI Selected Provider is efaip-172-31-41-105:3801:3862 [0] NCCL INFO Setting affinity for GPU 0 to ffffffff,ffffffff,ffffffffip-172-31-41-105:3801:3862 [0] NCCL INFO NCCL_TREE_THRESHOLD set by environment to 0.ip-172-31-41-36:4128:4128 [4] NCCL INFO Bootstrap : Using [0]ens5:172.31.41.36<0>ip-172-31-41-36:4128:4128 [4] NCCL INFO NET/OFI Forcing AWS OFI ndev 4ip-172-31-41-36:4128:4128 [4] NCCL INFO NET/OFI Selected Provider is efa

-----------------------------some output truncated-----------------------------------

ip-172-31-41-105:3804:3869 [3] NCCL INFO comm 0x7f8c5c0025b0 rank 3 nranks 16 cudaDev 3 nvmlDev 3 - Init COMPLETE## out-of-place in-place# size count type redop time algbw busbw error time algbw busbw error# (B) (elements) (us) (GB/s) (GB/s) (us) (GB/s) (GB/s)ip-172-31-41-105:3801:3801 [0] NCCL INFO Launch mode Parallelip-172-31-41-36:4124:4191 [0] NCCL INFO comm 0x7f28400025b0 rank 8 nranks 16 cudaDev 0 nvmlDev 0 - Init COMPLETEip-172-31-41-36:4126:4192 [2] NCCL INFO comm 0x7f62240025b0 rank 10 nranks 16 cudaDev 2 nvmlDev 2 - Init COMPLETEip-172-31-41-105:3802:3867 [1] NCCL INFO comm 0x7f5ff00025b0 rank 1 nranks 16 cudaDev 1 nvmlDev 1 - Init COMPLETEip-172-31-41-36:4132:4193 [6] NCCL INFO comm 0x7ffa0c0025b0 rank 14 nranks 16 cudaDev 6 nvmlDev 6 - Init COMPLETEip-172-31-41-105:3803:3866 [2] NCCL INFO comm 0x7fe9600025b0 rank 2 nranks 16 cudaDev 2 nvmlDev 2 - Init COMPLETEip-172-31-41-36:4127:4188 [3] NCCL INFO comm 0x7f6ad00025b0 rank 11 nranks 16 cudaDev 3 nvmlDev 3 - Init COMPLETEip-172-31-41-105:3813:3868 [7] NCCL INFO comm 0x7f341c0025b0 rank 7 nranks 16 cudaDev 7 nvmlDev 7 - Init COMPLETEip-172-31-41-105:3810:3864 [6] NCCL INFO comm 0x7f5f980025b0 rank 6 nranks 16 cudaDev 6 nvmlDev 6 - Init COMPLETE

75


ip-172-31-41-36:4128:4187 [4] NCCL INFO comm 0x7f234c0025b0 rank 12 nranks 16 cudaDev 4 nvmlDev 4 - Init COMPLETEip-172-31-41-36:4125:4194 [1] NCCL INFO comm 0x7f2ca00025b0 rank 9 nranks 16 cudaDev 1 nvmlDev 1 - Init COMPLETEip-172-31-41-36:4134:4190 [7] NCCL INFO comm 0x7f0ca40025b0 rank 15 nranks 16 cudaDev 7 nvmlDev 7 - Init COMPLETEip-172-31-41-105:3807:3865 [5] NCCL INFO comm 0x7f3b280025b0 rank 5 nranks 16 cudaDev 5 nvmlDev 5 - Init COMPLETEip-172-31-41-36:4130:4189 [5] NCCL INFO comm 0x7f62080025b0 rank 13 nranks 16 cudaDev 5 nvmlDev 5 - Init COMPLETEip-172-31-41-105:3805:3863 [4] NCCL INFO comm 0x7fec100025b0 rank 4 nranks 16 cudaDev 4 nvmlDev 4 - Init COMPLETE 8 2 float sum 145.4 0.00 0.00 2e-07 152.8 0.00 0.00 1e-07 16 4 float sum 137.3 0.00 0.00 1e-07 137.2 0.00 0.00 1e-07 32 8 float sum 137.0 0.00 0.00 1e-07 137.4 0.00 0.00 1e-07 64 16 float sum 137.7 0.00 0.00 1e-07 137.5 0.00 0.00 1e-07 128 32 float sum 136.2 0.00 0.00 1e-07 135.3 0.00 0.00 1e-07 256 64 float sum 136.4 0.00 0.00 1e-07 137.4 0.00 0.00 1e-07 512 128 float sum 135.5 0.00 0.01 1e-07 151.0 0.00 0.01 1e-07 1024 256 float sum 151.0 0.01 0.01 2e-07 137.7 0.01 0.01 2e-07 2048 512 float sum 138.1 0.01 0.03 5e-07 138.1 0.01 0.03 5e-07 4096 1024 float sum 140.5 0.03 0.05 5e-07 140.3 0.03 0.05 5e-07 8192 2048 float sum 144.6 0.06 0.11 5e-07 144.7 0.06 0.11 5e-07 16384 4096 float sum 149.4 0.11 0.21 5e-07 149.3 0.11 0.21 5e-07 32768 8192 float sum 156.7 0.21 0.39 5e-07 183.9 0.18 0.33 5e-07 65536 16384 float sum 167.7 0.39 0.73 5e-07 183.6 0.36 0.67 5e-07 131072 32768 float sum 193.8 0.68 1.27 5e-07 193.0 0.68 1.27 5e-07 262144 65536 float sum 243.9 1.07 2.02 5e-07 258.3 1.02 1.90 5e-07 524288 131072 float sum 309.0 1.70 3.18 5e-07 309.0 1.70 3.18 5e-07 1048576 262144 float sum 709.3 1.48 2.77 5e-07 693.2 1.51 2.84 5e-07 2097152 524288 float sum 1116.4 1.88 3.52 5e-07 1105.7 1.90 3.56 5e-07 4194304 1048576 float sum 2088.9 2.01 3.76 5e-07 2157.3 1.94 3.65 5e-07 8388608 2097152 float sum 2869.7 2.92 5.48 5e-07 2847.2 2.95 5.52 5e-07 16777216 4194304 float sum 4631.7 3.62 6.79 5e-07 4643.9 3.61 6.77 5e-07 33554432 8388608 float sum 8769.2 3.83 7.17 5e-07 8743.5 3.84 7.20 5e-07 67108864 16777216 float sum 16964 3.96 7.42 5e-07 16846 3.98 7.47 5e-07 134217728 33554432 float sum 33403 4.02 7.53 5e-07 33058 4.06 7.61 5e-07 268435456 67108864 float sum 59045 4.55 8.52 5e-07 58625 4.58 8.59 5e-07 536870912 134217728 float sum 115842 4.63 8.69 5e-07 115590 4.64 8.71 5e-07

76

Deep Learning AMI Guia do desenvolvedorMonitoramento e otimização de GPU

1073741824 268435456 float sum 228178 4.71 8.82 5e-07 224997 4.77 8.95 5e-07# Out of bounds values : 0 OK# Avg bus bandwidth : 2.80613#

Monitoramento e otimização de GPUA 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 etreinamento.

• Monitoramento (p. 77)• Monitorar GPUs com o CloudWatch (p. 77)

• Otimização (p. 79)• Reprocessamento (p. 81)• Treinamento (p. 81)

MonitoramentoSeu DLAMI vem pré-instalado com várias ferramentas de monitoramento de GPU. Este guia mencionatambém ferramentas que estão disponíveis para download e instalação.

• Monitorar GPUs com o CloudWatch (p. 77) – um utilitário pré-instalado que relata estatísticas de usode GPU para o Amazon CloudWatch.

• CLI nvidia-smi – um utilitário para monitorar a utilização geral de computação e memória de GPU. Já épré-instalado na AWS Deep Learning AMI (DLAMI).

• Biblioteca NVML C – uma API baseada em C para acessar diretamente funções de monitoramento egerenciamento de GPU. É usada pela CLI do nvidia-smi nos detalhes internos e é pré-instalada na suaDLAMI. Também tem associações Python e Perl para facilitar o desenvolvimento nessas linguagens. Outilitário gpumon.py pré-instalado na sua DLAMI usa o pacote pynvml de nvidia-ml-py.

• NVIDIA DCGM – uma ferramenta de gerenciamento de cluster. Visite a página do desenvolvedor parasaber como instalar e configurar essa ferramenta.

Tip

Confira o blog do desenvolvedor de NVIDIA para obter as informações mais recentes sobre comousar as ferramentas do CUDA instaladas no DLAMI:

• Monitoramento da utilização do TensorCore usando Nsight IDE e nvprof.

Monitorar GPUs com o CloudWatch

Ao usar a DLAMI com uma GPU, talvez você descubra que está procurando maneiras de controlar o usodurante o treinamento ou a inferência. Isso pode ser útil para otimizar o pipeline de dados e ajustar suarede de deep learning.

Um utilitário chamado gpumon.py é pré-instalado na DLAMI. Ele se integra com o CloudWatch e oferecesuporte para monitoramento de uso por GPU: memória, temperatura e energia de GPU. O script enviaperiodicamente os dados monitorados para o CloudWatch. Você pode configurar o nível de granularidadede dados que estão sendo enviados para o CloudWatch alterando algumas configurações no script. Noentanto, antes de iniciar o script, você precisará configurar o CloudWatch para receber as métricas.

77

https://developer.nvidia.com/nvidia-system-management-interface

https://developer.nvidia.com/nvidia-management-library-nvml

https://pypi.org/project/nvidia-ml-py/

https://developer.nvidia.com/data-center-gpu-manager-dcgm

https://devblogs.nvidia.com/using-nsight-compute-nvprof-mixed-precision-deep-learning-models/


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 noCloudWatch. Se você criar um novo usuário, anote as credenciais, pois elas serão necessárias napróxima etapa.

A política do IAM a ser pesquisada é "cloudwatch:PutMetricData". A política que é adicionada é aseguinte:

{ "Version": "2012-10-17", "Statement": [ { "Action": [ "cloudwatch:PutMetricData" ], "Effect": "Allow", "Resource": "*" } ]}

Tip

Para obter mais informações sobre como criar um usuário do IAM e adicionar políticas aoCloudWatch, consulte a documentação do CloudWatch.

2. Na sua DLAMI, execute AWS configure e especifique as credenciais de usuário do IAM.

$ aws configure

3. Talvez você precise fazer algumas modificações no utilitário gpumon antes de executá-lo. Você podeencontrar o utilitário gpumon e o README no seguinte local.

Folder: ~/tools/GPUCloudWatchMonitorFiles: ~/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 CloudWatch namespace ou o período de relatório comstore_resolution.

4. No momento, o script oferece suporte apenas ao Python 3. Ative o ambiente do Python 3 da estruturade trabalho preferencial ou ative o ambiente geral do Python 3 da DLAMI.

$ source activate python3

5. Execute o utilitário gpumon em segundo plano.

(python3)$ python gpumon.py &

6. Abra seu navegador para https://console.aws.amazon.com/cloudwatch/ e, depois, selecione a métrica.Ela terá um namespace "DeepLearningTrain".

Tip

Você pode alterar o namespace modificando o gpumon.py. Você também pode modificar ointervalo de relatório ajustando store_resolution.

78

https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/create-iam-roles-for-cloudwatch-agent.html

https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html#cli-quick-configuration

https://console.aws.amazon.com/cloudwatch/


Veja a seguir um exemplo de gráfico do CloudWatch relatando uma execução do gpumon.py monitorandoum trabalho de treinamento na instância p2.8xlarge.

Você pode estar interessado nesses outros tópicos sobre monitoramento e otimização de GPU:



OtimizaçãoPara obter o máximo de suas GPUs, você pode otimizar seu pipeline de dados e ajustar a rede de deeplearning. Como o gráfico a seguir descreve, uma implementação simples ou básica de uma rede neural

79


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 otamanho 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 detransferência.

A tabela a seguir mostra os ganhos de desempenho cumulativos ao aplicar otimizações diferentes. Seusresultados dependerão dos dados que você está processando e da rede que está otimizando.

Exemplos de otimização de desempenho de GPUs. Origem do gráfico: Truques de desempenho com oMXNet Gluon

Os seguintes guias apresentam opções que funcionarão com o DLAMI e ajudarão a aumentar odesempenho da GPU.

Tópicos• Reprocessamento (p. 81)• Treinamento (p. 81)

80

https://github.com/ThomasDelteil/PerformanceTricksMXNetGluon

https://github.com/ThomasDelteil/PerformanceTricksMXNetGluon


Reprocessamento

O pré-processamento de dados durante transformações ou aumento muitas vezes pode ser um processovinculado à CPU e isso pode ser o gargalo em todo o seu pipeline. Estruturas têm operadores integradospara processamento de imagens, mas a DALI (Data Augmentation Library) demonstra um melhordesempenho 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 acessá-la instalando-a ou carregando um contêiner de estruturacompatível na sua DLAMI ou em outra instância do Amazon Elastic Compute Cloud. Consulte a páginado projeto DALI no site do NVIDIA para obter detalhes.

Tip

Assista a este vídeo útil no site GPU Tech Conference sobre otimização de pipelines de dados.Ele inclui exemplos de MXNet e TensorFlow usando um plug-in DALI.

• nvJPEG: uma biblioteca de decodificadores JPEG acelerados para GPU para programadores de C. Elaoferece suporte à decodificação de imagens ou lotes únicos, bem como operações de transformaçãosubsequentes que são comuns em deep learning. A nvJPEG vem integrada à DALI, ou você pode fazerdownload da página nvjpeg do site da NVIDIA e usá-la separadamente.




Treinamento

Com treinamento de precisão mista, você pode implantar redes maiores com a mesma quantidade dememó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ênciasde dados menores e mais rápidas, um fator importante em um treinamento distribuído em vários nós. Paraaproveitar o treinamento de precisão mista, você precisa ajustar a conversão de dados e a escalabilidadede perdas. Veja a seguir os guias que descrevem como fazer isso para as estruturas que oferecem suporteà precisão mista.

• NVIDIA Deep Learning SDK – documentos no site da NVIDIA descrevendo a implementação de precisãomista para MXNet, PyTorch e TensorFlow.

Tip

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 sobreprecisão mista que podem ser úteis:

• Treinamento de precisão mista com o TensorFlow (vídeo) - no site do blog da NVIDIA.• Treinamento de precisão mista usando float16 com MXNet - um artigo de perguntas frequentes

no site do MXNet.• NVIDIA Apex: uma ferramenta para treinamento fácil com precisão mista com PyTorch - um

artigo de blog no site da NVIDIA.

81

https://docs.nvidia.com/deeplearning/sdk/dali-install-guide/index.html

https://docs.nvidia.com/deeplearning/sdk/dali-install-guide/index.html

http://on-demand.gputechconf.com/gtc/2018/video/S8906/

https://developer.nvidia.com/nvjpeg

https://docs.nvidia.com/deeplearning/sdk/mixed-precision-training/

https://devblogs.nvidia.com/mixed-precision-resnet-50-tensor-cores/

https://mxnet.apache.org/api/faq/float16

https://devblogs.nvidia.com/apex-pytorch-easy-mixed-precision-training/

Deep Learning AMI Guia do desenvolvedorAWS Inferentia




O chip AWS Inferentia com DLAMIO AWS Inferentia é um chip machine learning personalizado projetado pela AWS que você pode usarpara previsões de inferência de alto desempenho. Para usá-lo, configure uma instância do Amazon ElasticCompute Cloud e use o kit de desenvolvimento de software (SDK) do AWS Neuron para invocar o chip doInferentia. Para fornecer aos clientes a melhor experiência no Inferentia, o Neuron foi criado na AWS DeepLearning AMI (DLAMI).

Os tópicos a seguir mostram como começar a usar o Inferentia com a DLAMI.

Tópicos• Iniciar uma instância da DLAMI com o AWS Neuron (p. 82)• Uso da DLAMI com o AWS Neuron (p. 86)

Iniciar uma instância da DLAMI com o AWS NeuronA DLAMI mais recente está pronta para ser usada com o AWS Inferentia e vem com o pacote de API doAWS Neuron. Para iniciar uma instância da DLAMI, consulte Iniciar e configurar uma DLAMI. Quando vocêtiver uma DLAMI, siga estas instruções para garantir que o chip do AWS Inferentia e os recursos do AWSNeuron fiquem ativos.

Tópicos• Atualização do pacote do Neuron (p. 82)• Verifique a instância (p. 83)• Identificação de dispositivos do AWS Inferentia (p. 83)• nr_hugepages (p. 83)• Daemon do tempo de execução do Neuron (neuron-rtd) (p. 83)• Grupos NeuronCore (p. 84)• Modelos de listagem (p. 85)• Exibir o uso de recursos (p. 85)

Atualização do pacote do Neuron

Depois de se conectar à instância do Inf1, use os seguintes comandos para atualizar seu pacote doNeuron.

Para o Amazon Linux 2, execute:

sudo yum install aws-neuron-runtime-basesudo yum install aws-neuron-runtimesudo yum install aws-neuron-toolssudo yum install tensorflow-model-server-neuron

82

https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html


Para o Ubuntu Linux, execute:

sudo apt-get updatesudo apt-get install aws-neuron-runtime-basesudo apt-get install aws-neuron-runtimesudo apt-get install aws-neuron-toolssudo apt-get install tensorflow-model-server-neuron

Verifique a instânciaAntes de usar a instância, verifique se ela está corretamente definida e configurada com o Neuron.

Identificação de dispositivos do AWS InferentiaPara 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:

...+--------------+---------+--------+-----------+-----------+------+------+| PCI BDF | LOGICAL | NEURON | MEMORY | MEMORY | EAST | WEST || | ID | CORES | CHANNEL 0 | CHANNEL 1 | | |+--------------+---------+--------+-----------+-----------+------+------+| 0000:00:1f.0 | 0 | 4 | 4096 MB | 4096 MB | 0 | 0 |+--------------+---------+--------+-----------+-----------+------+------+

A saída fornecida é obtida de uma instância inf1.2xlarge. A primeira coluna mostra o ID da função dodispositivo de barramento PCI. A segunda coluna mostra o ID lógico atribuído ao dispositivo. Esse lógicoé usado durante a configuração do Daemon do tempo de execução do Neuron (neuron-rtd). A terceiracoluna mostra o número de NeuronCores disponíveis. As duas últimas colunas mostram a conexão comqualquer outro dispositivo do Inferentia. Como é uma instância única do Inferentia, elas ficam vazias.

nr_hugepagesvm.nr_hugepages é uma configuração ampla do sistema para gerenciar páginas enormes namemória, além do tamanho de página padrão de 4 KB. Essa configuração é importante para a APIdo Neuron, porque ele usa páginas enormes. Execute o seguinte comando para ver a configuraçãovm.nr_hugepages dessa instância:

grep HugePages_Total /proc/meminfo | awk {'print $2'}

O requisito mínimo da configuração vm.nr_hugepages é 128 por dispositivo do AWS Inferentia.

Daemon do tempo de execução do Neuron (neuron-rtd)Quando você inicia qualquer instância do Inf1, o daemon do tempo de execução do Neuron (neuron-rtd)inicia automaticamente. Para verificar se o neuron-rtd está ativo, use o seguinte comando:

sudo systemctl status neuron-rtd


83


# neuron-rtd.service - Neuron Runtime Daemon Loaded: loaded (/usr/lib/systemd/system/neuron-rtd.service; enabled; vendor preset: disabled) Active: active (running) since Thu 2019-11-14 09:53:47 UTC; 3min 0s ago Main PID: 3351 (neuron-rtd) Tasks: 14 Memory: 11.6M CGroup: /system.slice/neuron-rtd.service ##3351 /opt/aws/neuron/bin/neuron-rtd -c /opt/aws/neuron/config/neuron-rtd.config

Nov 14 09:53:16 ip-172-31-23-213.ec2.internal systemd[1]: Starting Neuron Runtime Daemon...Nov 14 09:53:18 ip-172-31-23-213.ec2.internal neuron-rtd[3351]: [NRTD:ParseArguments] Using all the BDFs in the ...on!Nov 14 09:53:18 ip-172-31-23-213.ec2.internal nrtd[3351]: [NRTD:krtd_main] krt build using:1.0.3952.0Nov 14 09:53:18 ip-172-31-23-213.ec2.internal nrtd[3351]: [TDRV:reset_mla] Resetting 0000:00:1f.0Nov 14 09:53:47 ip-172-31-16-98.ec2.internal nrtd[3351]: [TDRV:tdrv_init_one_mla_phase2] Initialized Inferentia...1f.0Nov 14 09:53:47 ip-172-31-16-98.ec2.internal neuron-rtd[3351]: E1114 09:53:47.511852663 3351 socket_utils_com...65}Nov 14 09:53:47 ip-172-31-16-98.ec2.internal systemd[1]: Started Neuron Runtime Daemon.Nov 14 09:53:47 ip-172-31-16-98.ec2.internal nrtd[3351]: [NRTD:RunServer] Server listening on unix:/run/neuron.sock

Pode haver situações em que você irá começar e parar o neuron-rtd.

Para iniciar o neuron-rtd, use o seguinte comando:

sudo systemctl restart neuron-rtd

Para parar o neuron-rtd, use o seguinte comando:

sudo systemctl stop neuron-rtd

Grupos NeuronCore

Os NeuronCores (NC) são as quatro unidades de execução dentro dos dispositivos do Inferentia. VáriosNCs podem ser combinados para formar um NeuronCore Group (NCG). A camada de estrutura do Neuroncria automaticamente um NeuronCore Group padrão. Para ver uma lista de NCGs disponíveis, use oseguinte comando:

neuron-cli list-ncg

Seus NCGs ativos serão exibidos da seguinte forma na saída:

Device 1 NC count 4+-------+----------+--------------------+----------------+| NCG ID| NC COUNT | DEVICE START INDEX | NC START INDEX |+-------+----------+--------------------+----------------+| 1 | 1 | 0 | 0 || 2 | 1 | 0 | 1 || 3 | 2 | 0 | 2 |+-------+----------+--------------------+----------------+

84


Se você não configurou um NCG, o comando retornará a seguinte saída:

No NCG Found

Se você precisar descarregar todos os modelos e excluir todos os NCGs criados pela estrutura, use oseguinte comando:

neuron-cli reset

Modelos de listagemOs modelos podem ser carregados em um NCG. Vários modelos podem ser carregados em um únicoNCG, mas apenas um modelo pode estar no estado STARTED. Só é possível executar a inferência emmodelos no estado STARTED.

Para exibir todos os modelos carregados no NCG, use o seguinte comando:

$ neuron-cli list-model

Os modelos carregados no NCG serão exibidos da seguinte forma na saída:

Found 3 model10003 MODEL_STATUS_LOADED 110001 MODEL_STATUS_STARTED 110002 MODEL_STATUS_STARTED 1

Na saída, 10001 e 10002 são identificadores exclusivos para modelos carregados no NCG. Se você nãotiver carregado nenhum modelo no NCG, você verá a seguinte saída:

Found 0 models

Exibir o uso de recursosCada modelo carregado no NCG consome uma quantidade de memória no host e dispositivo e umaporcentagem do NeuronCore. O uso do NGC pode ser visualizado executando o seguinte comando:

neuron-top

O uso do NGC será exibido da seguinte forma na saída:

neuron-top - 2019-11-13 23:57:08NN Models: 3 total, 2 runningNumber of VNCs tracked: 20000:00:1f.0 Utilizations: Neuron core0 0.00, Neuron core1 0.00, Neuron core2 0, Neuron core3 0,DLR Model Node ID Subgraph Exec. Unit Host Mem MLA Mem Neuron core %10003 1 0 0000:00:1f.0:0 384 135660544 0.0010001 3 0 0000:00:1f.0:0 384 67633152 0.0010002 1 0 0000:00:1f.0:1 384 135660544 0.00

Se você não tiver carregado nenhum modelo, sua saída será semelhante à seguinte:

85


NN Models: 0 total, 0 runningNumber of VNCs tracked: 0DLR Model Node ID Subgraph Exec. Unit Host Mem MLA Mem Neuron core %

Próxima etapa

Uso da DLAMI com o AWS Neuron (p. 86)

Uso da DLAMI com o AWS NeuronUm fluxo de trabalho comum com o SDK do AWS Neuron é compilar um modelo de machine learningpreviamente treinado em um servidor de compilação. Depois, distribua os artefatos nas instâncias do Inf1para execução. A AWS Deep Learning AMI (DLAMI) vem pré-instalada com tudo de que você precisa paracompilar e executar a inferência em uma instância do Inf1 que usa o Inferentia.

As seções a seguir descrevem como usar a DLAMI com o Inferentia.

Tópicos• Uso do TensorFlow-Neuron e do compilador do AWS Neuron (p. 86)• Uso do TensorFlow Serving do AWS Neuron (p. 89)• Uso do MXNet-Neuron e do compilador do AWS Neuron (p. 91)• Uso do fornecimento de modelos MXNet-Neuron (p. 93)• Uso do PyTorch-Neuron e do compilador do AWS Neuron (p. 97)

Uso do TensorFlow-Neuron e do compilador do AWS Neuron

Este tutorial mostra como usar o compilador do AWS Neuron para compilar o modelo Keras ResNet-50 eexportá-lo como um modelo salvo no formato SavedModel. Esse é um formato comum intercambiável demodelo do TensorFlow. Você também aprenderá a executar a inferência em uma instância do Inf1 comexemplo de entrada.

Para obter mais informações sobre o SDK do Neuron, consulte a Documentação do SDK do AWS Neuron.

Tópicos• Pré-requisitos (p. 86)• Ative o ambiente Conda (p. 86)• Compilação ResNet50 (p. 87)• Inferência da ResNet50 (p. 88)

Pré-requisitos

Antes de usar este tutorial, você precisa ter concluído os passos da configuração em Uso da DLAMI com oAWS Neuron (p. 86). Também é necessário conhecer a aprendizagem profunda e o uso da DLAMI.

Ative o ambiente Conda

Ative o ambiente Conda do TensorFlow-Neuron usando o seguinte comando:

source activate aws_neuron_tensorflow_p36

Faça a atualização do pacote do Neuron usando o comando a seguir:

86

https://github.com/aws/aws-neuron-sdk


conda update tensorflow-neuron

Para sair do ambiente Conda atual, execute o seguinte comando:

source deactivate

Compilação ResNet50

Crie um script Python chamado tensorflow_compile_resnet50.py com o seguinte conteúdo. Essescript Python compila o modelo Keras ResNet50 e o exporta como modelo salvo.

import osimport timeimport shutilimport tensorflow as tfimport tensorflow.neuron as tfnimport tensorflow.compat.v1.keras as kerasfrom tensorflow.keras.applications.resnet50 import ResNet50from tensorflow.keras.applications.resnet50 import preprocess_input

# Create a workspaceWORKSPACE = './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 modelkeras.backend.set_learning_phase(0)model = ResNet50(weights='imagenet')

# Export SavedModeltf.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 Neurontfn.saved_model.compile(model_dir, compiled_model_dir)

# Prepare SavedModel for uploading to Inf1 instanceshutil.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

87


INFO:tensorflow:Number of operations in TensorFlow session: 4638INFO:tensorflow:Number of operations after tf.neuron optimizations: 556INFO:tensorflow:Number of operations placed on Neuron runtime: 554INFO:tensorflow:Successfully converted ./ws_resnet50/resnet50 to ./ws_resnet50/resnet50_neuron...

Após a compilação, o modelo salvo será compactado em ws_resnet50/resnet50_neuron.zip.Descompacte o modelo e faça download da imagem de exemplo para a inferência, usando os seguintescomandos:

unzip ws_resnet50/resnet50_neuron.zip -d .curl -O https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg

Inferência da ResNet50

Crie um script Python chamado tensorflow_infer_resnet50.py com o seguinte conteúdo. Essescript executa a inferência no modelo obtido por download usando um modelo de inferência previamentecompilado.

import osimport numpy as npimport tensorflow as tffrom tensorflow.keras.preprocessing import imagefrom tensorflow.keras.applications import resnet50

# Create input from imageimg_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 modelCOMPILED_MODEL_DIR = './ws_resnet50/resnet50_neuron/'predictor_inferentia = tf.contrib.predictor.from_saved_model(COMPILED_MODEL_DIR)# Run inferencemodel_feed_dict={'input': img_arr3}infa_rslts = predictor_inferentia(model_feed_dict);# Display resultsprint(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

Uso do TensorFlow Serving do AWS Neuron (p. 89)

88


Uso do TensorFlow Serving do AWS Neuron

Este tutorial mostra como construir um gráfico e adicionar um passo de compilação do AWS Neuronantes de exportar o modelo salvo para usar com o TensorFlow Serving. O TensorFlow Serving éum sistema de serviço que permite dimensionar a inferência em uma rede. O TensorFlow Servingdo Neuron usa a mesma API que o TensorFlow Serving comum. A única diferença é que ummodelo salvo deve ser compilado para o AWS Inferentia e o ponto de entrada é um binário diferentechamado tensorflow_model_server_neuron. O binário é encontrado em /usr/local/bin/tensorflow_model_server_neuron e é pré-instalado na DLAMI.


Tópicos• Pré-requisitos (p. 89)• Ative o ambiente Conda (p. 89)• Compile e exporte o modelo salvo (p. 89)• Fornecer o modelo salvo (p. 90)• Gerar solicitações de inferência para o modelo de servidor (p. 90)

Pré-requisitos



Ative o ambiente Conda do TensorFlow-Neuron usando o seguinte comando:

source activate aws_neuron_tensorflow_p36


conda update tensorflow-neuron

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 seguinteconteúdo. Esse script constrói um gráfico e o compila usando o Neuron. Depois, exporta o gráficocompilado como modelo salvo.

import tensorflow as tfimport 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]}

89



outputs = {'output': model.outputs[0]}

# save the model using tf.saved_model.simple_savemodeldir = "./resnet50/1"tf.saved_model.simple_save(sess, modeldir, inputs, outputs)

# compile the model for Inferentianeuron_modeldir = os.path.join(os.path.expanduser('~'), 'resnet50_inf1', '1')tf.neuron.saved_model.compile(modeldir, neuron_modeldir, batch_size=1)


python tensorflow-model-server-compile.py


...INFO:tensorflow:fusing subgraph neuron_op_d6f098c01c780733 with neuron-ccINFO:tensorflow:Number of operations in TensorFlow session: 4638INFO:tensorflow:Number of operations after tf.neuron optimizations: 556INFO:tensorflow:Number of operations placed on Neuron runtime: 554INFO: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 salvocom o binário tensorflow_model_server_neuron:

tensorflow_model_server_neuron --model_name=resnet50_inf1 \ --model_base_path=$HOME/resnet50_inf1/ --port=8500 &

A saída será semelhante a: O modelo compilado é preparado na DRAM do dispositivo do Inferentia, peloservidor, 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_requests2019-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 seguinte conteúdo. Essescript executa a inferência via gRPC, que é uma estrutura de serviço.

import numpy as npimport grpcimport tensorflow as tf

90


from tensorflow.keras.preprocessing import imagefrom tensorflow.keras.applications.resnet50 import preprocess_inputfrom tensorflow_serving.apis import predict_pb2from tensorflow_serving.apis import prediction_service_pb2_grpcfrom 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


[[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]]

Uso do MXNet-Neuron e do compilador do AWS Neuron

A API de compilação do MXNet-Neuron fornece um método para compilar um gráfico de modelo que vocêpode executar em um dispositivo do AWS Inferentia.

Neste exemplo, você usa a API para compilar um modelo ResNet-50 e o usa para executar inferência.



Pré-requisitos



Ative o ambiente Conda do MXNet-Neuron usando o seguinte comando:

91



source activate aws_neuron_mxnet_p36


conda update mxnet-neuron

Para sair do ambiente Conda atual, execute:

source deactivate


Crie um script Python chamado mxnet_compile_resnet50.py com o seguinte conteúdo. Esse scriptusa a API Python de compilação do MXNet-Neuron para compilar um modelo ResNet-50.

import mxnet as mximport 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)


python mxnet_compile_resnet50.py

A compilação leva alguns minutos. Quando ela terminar, os seguintes arquivos estarão no diretório atual:

resnet-50-0000.paramsresnet-50-symbol.jsoncompiled_resnet50-0000.paramscompiled_resnet50-symbol.json


Crie um script Python chamado mxnet_infer_resnet50.py com o seguinte conteúdo. Esse script fazdownload de uma imagem de amostra e a usa para executar a inferência com o modelo compilado.

import mxnet as mx

92


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) # resizeimg = img.transpose((2, 0, 1)) # Channel firstimg = img.expand_dims(axis=0) # batchifyimg = img.astype(dtype='float32')

sym, args, aux = mx.model.load_checkpoint('compiled_resnet50', 0)softmax = mx.nd.random_normal(shape=(1,))args['softmax_label'] = softmaxargs['data'] = img# Inferentia contextctx = 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-5prob = 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


probability=0.642454, class=n02123045 tabby, tabby catprobability=0.189407, class=n02123159 tiger catprobability=0.100798, class=n02124075 Egyptian catprobability=0.030649, class=n02127052 lynx, catamountprobability=0.016278, class=n02129604 tiger, Panthera tigris

Próxima etapa

Uso do fornecimento de modelos MXNet-Neuron (p. 93)

Uso do fornecimento de modelos MXNet-NeuronNeste tutorial, você aprenderá a usar um modelo MXNet pré-treinado para executar a classificação deimagens em tempo real com o Multi Model Server (MMS). O MMS é uma ferramenta flexível e fácil de usarpara servir modelos de aprendizagem profunda treinados usando qualquer estrutura de machine learningou de aprendizagem profunda. Este tutorial inclui uma etapa de compilação que usa o AWS Neuron e umaimplementação do MMS usando o MXNet.

93



Tópicos• Pré-requisitos (p. 94)• Ative o ambiente Conda (p. 94)• Faça download do código de exemplo (p. 94)• Compile o modelo. (p. 94)• Execute a inferência (p. 96)

Pré-requisitos



Para ativar o ambiente Conda do MXNet-Neuron, use o seguinte comando:

source activate aws_neuron_mxnet_p36


conda update mxnet-neuron


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-servercd multi-model-server/examples/mxnet_vision

Compile o modelo.

Crie um script Python chamado multi-model-server-compile.py com o seguinte conteúdo. Estescript compila o modelo ResNet50 para o destino do dispositivo do Inferentia.

import mxnet as mxfrom mxnet.contrib import neuronimport 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

94



sym, args, auxs = mx.model.load_checkpoint(nn_name, 0)

#Define compilation parameters# - input shape and dtypeinputs = {'data' : mx.nd.zeros([1,3,224,224], dtype='float32') }

# compile graph to inferentia targetcsym, cargs, cauxs = neuron.compile(sym, args, auxs, inputs)

# save compiled modelmx.model.save_checkpoint(nn_name + "_compiled", 0, csym, cargs, cauxs)

Para compilar o modelo, use o seguinte comando:

python multi-model-server-compile.py


...[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 formade 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 nomespara classes de previsão ImageNet.

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. Copieo modelo para o diretório de trabalho atual usando o seguinte comando:

cp -r ../model_service_template/* .

95


Edite o módulo mxnet_model_service.py para substituir o contexto mx.cpu() pelo contextomx.neuron(), da seguinte forma. Também é preciso comentar a cópia de dados desnecessária para omodel_input, porque o MXNet-Neuron não é compatível com as APIs NDArray e Gluon.

...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/examplesmodel-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 API RESTful, usando os seguintes comandos.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 MMScurl -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.jpgcurl -X POST http://127.0.0.1:8080/predictions/resnet-50_compiled -T kitten_small.jpg


[ { "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"

96


}]

Para fazer a limpeza após o teste, dê um comando "delete" por meio da API RESTful e pare o servidormodelo usando os seguintes comandos:

curl -X DELETE http://127.0.0.1:8081/models/resnet-50_compiled

multi-model-server --stop

neuron-cli reset

Você deve ver a saída a seguir:

{ "status": "Model \"resnet-50_compiled\" unregistered"}Model server stopped.Found 1 models and 1 NCGs.Unloading 10001 (MODEL_STATUS_STARTED) :: successDestroying NCG 1 :: success

Uso do PyTorch-Neuron e do compilador do AWS Neuron

A API de compilação do PyTorch-Neuron fornece um método para compilar um gráfico de modelo quevocê pode executar em um dispositivo do AWS Inferentia.

Um modelo treinado deve ser compilado para um destino Inferentia antes que ele possa ser implantado eminstâncias Inf1. O tutorial a seguir compila o modelo torchvision ResNet50 e o exporta como um móduloTorchScript salvo. 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ê podecompilar o modelo usando outro tipo de instância, como a família de instâncias c5. Depois, você deveimplantar o modelo compilado no servidor de inferência Inf1. Para obter mais informações, consulte aDocumentação do AWS Neuron PyTorch SDK.


Pré-requisitos



Ative o ambiente Conda do PyTorch-Neuron usando o seguinte comando:

source activate aws_neuron_pytorch_p36


97

https://github.com/aws/aws-neuron-sdk/blob/master/docs/pytorch-neuron/tutorial-compile-infer.md


source deactivate


Crie um script Python chamado pytorch_trace_resnet50.py com o seguinte conteúdo. Esse scriptusa a API Python de compilação do PyTorch-Neuron para compilar um modelo ResNet-50.

import torchimport numpy as npimport osimport torch_neuronfrom torchvision import models

image = torch.zeros([1, 3, 224, 224], dtype=torch.float32)

## Load a pretrained ResNet50 modelmodel = 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 modelmodel_neuron.save("resnet50_neuron.pt")

Execute o script de compilação.

python pytorch_trace_resnet50.py

A compilação leva alguns minutos. Quando a compilação terminar, o modelo compilado será salvo comoresnet50_neuron.pt no diretório local.


Crie um script Python chamado pytorch_infer_resnet50.py com o seguinte conteúdo. Esse scriptfaz download de uma imagem de amostra e a usa para executar a inferência com o modelo compilado.

import osimport timeimport torchimport torch_neuronimport jsonimport numpy as np

from urllib import request

from torchvision import models, transforms, datasets

## Create an image directory containing a small kittenos.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 classificationsrequest.urlretrieve("https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json","imagenet_class_index.json")idx2label = []

98

Deep Learning AMI Guia do desenvolvedorInferência

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 tensornormalize = 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 modelmodel_neuron = torch.jit.load( 'resnet50_neuron.pt' )

## Predictresults = model_neuron( image )

# Get the top 5 resultstop5_idx = results[0].sort()[1][-5:]

# Lookup and print the top 5 labelstop5_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


Top 5 labels: ['tiger', 'lynx', 'tiger_cat', 'Egyptian_cat', 'tabby']

InferênciaNesta seção você encontra tutoriais sobre como executar inferências usando as estruturas e ferramentasdo DLAMI

Para ver tutoriais sobre o uso do Elastic Inference, consulte Como trabalhar com o Amazon ElasticInference

Inferências com estruturas• Usar o Apache MXNet para inferência com um modelo ONNX (p. 100)• Use o Apache MXNet para inferência com um modelo ResNet 50 (p. 101)• Usar o CNTK para inferência com um modelo ONNX (p. 102)

99

https://docs.aws.amazon.com/elastic-inference/latest/developerguide/working-with-ei.html

https://docs.aws.amazon.com/elastic-inference/latest/developerguide/working-with-ei.html


Ferramentas de inferência• Model Server para Apache MXNet (MMS) (p. 112)• TensorFlow Serving (p. 114)

Usar o Apache MXNet para inferência com um modelo ONNXComo usar um modelo ONNX para inferência de imagem com MXNet

1. • (Opção para Python 3) - ative o ambiente Python 3 MXNet:


• (Opção para Python 2) - ative o ambiente Python 2 MXNet:


2. As etapas restantes assumem que você está usando o ambiente do mxnet_p36.3. Faça download de uma imagem de um husky.

$ curl -O https://upload.wikimedia.org/wikipedia/commons/b/b5/Siberian_Husky_bi-eyed_Flickr.jpg

4. Faça download de uma lista de classes que funcionarão com esse modelo.

$ curl -O https://gist.githubusercontent.com/yrevar/6135f1bd8dcf2e0cc683/raw/d133d61a09d7e5a3b36b8c111a8dd5c4b5d560ee/imagenet1000_clsid_to_human.pkl

5. Faça download do modelo VGG 16 pré-treinado no formato ONNX.

$ wget -O vgg16.onnx https://github.com/onnx/models/raw/master/vision/classification/vgg/model/vgg16-7.onnx

6. Use um editor de texto de sua preferência para criar um script com o conteúdo a seguir. Esse scriptusará a imagem do husky, obterá um resultado de previsão do modelo pré-treinado e o analisará noarquivo de classes, retornando um resultado de classificação de imagem.

import mxnet as mximport mxnet.contrib.onnx as onnx_mxnetimport numpy as npfrom collections import namedtuplefrom PIL import Imageimport pickle

# Preprocess the imageimg = Image.open("Siberian_Husky_bi-eyed_Flickr.jpg")img = img.resize((224,224))rgb_img = np.asarray(img, dtype=np.float32) - 128bgr_img = rgb_img[..., [2,1,0]]img_data = np.ascontiguousarray(np.rollaxis(bgr_img,2))img_data = img_data[np.newaxis, :, :, :].astype(np.float32)

# Define the model's inputdata_names = ['data']Batch = namedtuple('Batch', data_names)

# Set the context to cpu or gpuctx = mx.cpu()

100


# Load the modelsym, arg, aux = onnx_mxnet.import_model("vgg16.onnx")mod = mx.mod.Module(symbol=sym, data_names=data_names, context=ctx, label_names=None)mod.bind(for_training=False, data_shapes=[(data_names[0],img_data.shape)], label_shapes=None)mod.set_params(arg_params=arg, aux_params=aux, allow_missing=True, allow_extra=True)

# Run inference on the imagemod.forward(Batch([mx.nd.array(img_data)]))predictions = mod.get_outputs()[0].asnumpy()top_class = np.argmax(predictions)print(top_class)labels_dict = pickle.load(open("imagenet1000_clsid_to_human.pkl", "rb"))print(labels_dict[top_class])

7. Em seguida, execute o script e você deve ver um resultado da seguinte forma:

248Eskimo dog, husky

Use o Apache MXNet para inferência com um modelo ResNet 50Como usar um modelo MXNet pré-treinado com a API Symbol para inferência de imagem comMXNet





2. As etapas restantes assumem que você está usando o ambiente do mxnet_p36.3. Use um editor de texto de sua preferência para criar um script com o conteúdo a seguir. Esse

script fará download dos arquivos de modelo do ResNet-50 (resnet-50-0000.params and resnet-50-symbol.json) e da lista de rótulos (synset.txt), fará download de uma imagem de um gato para obteruma previsão de resultado do modelo pré-treinado e, em seguida, analisará esses parâmetros noresultado na lista de rótulos, retornando uma previsão de resultado.

import mxnet as mximport 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')]

ctx = mx.cpu()

with open('synset.txt', 'r') as f: labels = [l.rstrip() for l in f]

sym, args, aux = mx.model.load_checkpoint('resnet-50', 0)

fname = mx.test_utils.download('https://github.com/dmlc/web-data/blob/master/mxnet/doc/tutorials/python/predict_image/cat.jpg?raw=true')img = mx.image.imread(fname)

101


# convert into format (batch, RGB, width, height)img = mx.image.imresize(img, 224, 224) # resizeimg = img.transpose((2, 0, 1)) # Channel firstimg = img.expand_dims(axis=0) # batchifyimg = img.astype(dtype='float32')args['data'] = img

softmax = mx.nd.random_normal(shape=(1,))args['softmax_label'] = softmax

exe = sym.bind(ctx=ctx, args=args, aux_states=aux, grad_req='null')

exe.forward()prob = exe.outputs[0].asnumpy()# print the top-5prob = np.squeeze(prob)a = np.argsort(prob)[::-1]for i in a[0:5]: print('probability=%f, class=%s' %(prob[i], labels[i]))


probability=0.418679, class=n02119789 kit fox, Vulpes macrotisprobability=0.293495, class=n02119022 red fox, Vulpes vulpesprobability=0.029321, class=n02120505 grey fox, gray fox, Urocyon cinereoargenteusprobability=0.026230, class=n02124075 Egyptian catprobability=0.022557, class=n02085620 Chihuahua

Usar o CNTK para inferência com um modelo ONNXNote


Note

O modelo VGG-16 usado neste tutorial consome uma grande quantidade de memória. Aoselecionar sua instância da , talvez você precise de uma instância com mais de 30 GB de RAM.

Como usar um modelo ONNX para inferência com CNTK

1. • (Opção para Python 3) - ative o ambiente Python 3 CNTK:


• (Opção para Python 2) - ative o ambiente Python 2 CNTK:


2. As etapas restantes assumem que você está usando o ambiente do cntk_p36.3. Crie um novo arquivo com o editor de texto e use o programa a seguir em um script para abrir o

arquivo no formato ONNX no CNTK.

import cntk as C# Import the Chainer model into CNTK via the CNTK import API

102

Deep Learning AMI Guia do desenvolvedorComo usar Estruturas de acesso com ONNX

z = C.Function.load("vgg16.onnx", device=C.device.cpu(), format=C.ModelFormat.ONNX)print("Loaded vgg16.onnx!")

Depois de executar esse script, CNTK terá carregado o modelo.4. Você também pode experimentar a execução de inferência com CNTK. Primeiro, faça download de

uma imagem de um husky.


5. Em seguida, faça download de uma lista de classes que funcionarão com esse modelo.

$ curl -O https://gist.githubusercontent.com/yrevar/6135f1bd8dcf2e0cc683/raw/d133d61a09d7e5a3b36b8c111a8dd5c4b5d560ee/imagenet1000_clsid_to_human.pkl

6. Edite o script criado anteriormente para ter o seguinte conteúdo. Esta nova versão usará a imagemdo husky, obtenha um resultado de previsão e, em seguida, procure isso no arquivo de classes,retornando um resultado de previsão.

import cntk as Cimport numpy as npfrom PIL import Imagefrom IPython.core.display import displayimport pickle

# Import the model into CNTK via the CNTK import APIz = C.Function.load("vgg16.onnx", device=C.device.cpu(), format=C.ModelFormat.ONNX)print("Loaded vgg16.onnx!")img = Image.open("Siberian_Husky_bi-eyed_Flickr.jpg")img = img.resize((224,224))rgb_img = np.asarray(img, dtype=np.float32) - 128bgr_img = rgb_img[..., [2,1,0]]img_data = np.ascontiguousarray(np.rollaxis(bgr_img,2))predictions = np.squeeze(z.eval({z.arguments[0]:[img_data]}))top_class = np.argmax(predictions)print(top_class)labels_dict = pickle.load(open("imagenet1000_clsid_to_human.pkl", "rb"))print(labels_dict[top_class])


248Eskimo dog, husky

Como usar Estruturas de acesso com ONNXA Deep Learning AMI com Conda agora oferece suporte a modelos Open Neural Network Exchange(ONNX) para algumas estruturas de acesso. Escolha um dos tópicos listados abaixo para saber como usarONNX em sua Deep Learning AMI com Conda.

Sobre as ONNXO Open Neural Network Exchange (ONNX) é um formato aberto usado para representar modelos deaprendizado profundo. ONNX é suportado pela Amazon Web Services, Microsoft, Facebook e váriosoutros parceiros. Você pode projetar, treinar e implantar modelos de aprendizado profundo com qualquerestrutura que você escolher. O benefício de modelos ONNX é que eles podem ser movidos entre asestruturas com facilidade.

103

http://onnx.ai/

http://onnx.ai/


A Deep Learning AMI com Conda atualmente destaca alguns do recursos de ONNX na seguinte coleçãode tutoriais.

• Tutorial do Apache MXNet para ONNX para CNTK (p. 104)• Tutorial do Chainer para ONNX para CNTK (p. 105)• Tutorial do Chainer para ONNX para MXNet (p. 107)• Tutorial do PyTorch para ONNX para CNTK (p. 108)• Tutorial do PyTorch para ONNX para MXNet (p. 110)

Você também pode consultar a documentação e tutoriais do projeto ONNX:

• Projeto ONNX no GitHub• Tutoriais do ONNX

Tutorial do Apache MXNet para ONNX para CNTKNote


Visão geral da ONNX

O Open Neural Network Exchange (ONNX) é um formato aberto usado para representar modelos deaprendizado profundo. ONNX é suportado pela Amazon Web Services, Microsoft, Facebook e váriosoutros parceiros. Você pode projetar, treinar e implantar modelos de aprendizado profundo com qualquerestrutura que você escolher. O benefício de modelos ONNX é que eles podem ser movidos entre asestruturas com facilidade.

Este tutorial mostra como usar a Deep Learning AMI com Conda com ONNX. Ao seguir essas etapas, vocêpoderá treinar um modelo ou carregar um modelo pré-treinado de um framework, exportar esse modelopara ONNX e, em seguida, importar o modelo em outro framework.

Pré-requisitos do ONNX

Para usar esse tutorial de ONNX, você deve ter acesso a uma Deep Learning AMI com Conda versão12 ou posterior. Para obter mais informações sobre como começar a usar a Deep Learning AMI comConda (p. 5), consulte Deep Learning AMI com Conda.

Important

Esses exemplos usam funções que podem exigir até 8 GB de memória (ou mais). Certifique-se deescolher um tipo de instância com memória suficiente.

Inicie uma sessão de terminal com sua Deep Learning AMI com Conda para iniciar o tutorial a seguir.

Converta um modelo Apache MXNet (em incubação) para ONNX, em seguidacarregue o modelo no CNTK

Como exportar um modelo do Apache MXNet (em incubação)

Você pode instalar a versão mais recente do MXNet construída em um ou ambos os ambientes MXNetConda no seu Deep Learning AMI com Conda.

104

https://github.com/onnx/onnx

https://github.com/onnx/tutorials

http://onnx.ai/






2. As etapas restantes assumem que você está usando o ambiente do mxnet_p36.3. Fazer download dos arquivos de modelo.

curl -O https://s3.amazonaws.com/onnx-mxnet/model-zoo/vgg16/vgg16-symbol.jsoncurl -O https://s3.amazonaws.com/onnx-mxnet/model-zoo/vgg16/vgg16-0000.params

4. Para exportar os arquivos de modelo do MXNet para o formato ONNX, crie um novo arquivo com oeditor de texto e use o programa a seguir em um script.

import numpy as npimport mxnet as mxfrom mxnet.contrib import onnx as onnx_mxnetconverted_onnx_filename='vgg16.onnx'

# Export MXNet model to ONNX format via MXNet's export_model APIconverted_onnx_filename=onnx_mxnet.export_model('vgg16-symbol.json', 'vgg16-0000.params', [(1,3,224,224)], np.float32, converted_onnx_filename)

# Check that the newly created model is valid and meets ONNX specification.import onnxmodel_proto = onnx.load(converted_onnx_filename)onnx.checker.check_model(model_proto)

Algumas mensagens de aviso podem ser exibidas, mas você pode ignorá-las por enquanto. Depois deexecutar esse script, você verá o arquivo .onnx recém-criado no mesmo diretório.

5. Agora que você tem um arquivo ONNX, execute a inferência com ele usando o seguinte exemplo:

• Usar o CNTK para inferência com um modelo ONNX (p. 102)

Tutoriais do ONNX

• Tutorial do Apache MXNet para ONNX para CNTK (p. 104)• Tutorial do Chainer para ONNX para CNTK (p. 105)• Tutorial do Chainer para ONNX para MXNet (p. 107)• Tutorial do PyTorch para ONNX para MXNet (p. 110)• Tutorial do PyTorch para ONNX para CNTK (p. 108)

Tutorial do Chainer para ONNX para CNTKNote


105







Important



Converta um Modelo Chainer para ONNX, depois carregue o modelo no CNTK

Primeiro, ative o ambiente Chainer:


Crie um novo arquivo com o editor de texto e use o programa a seguir em um script para obter um modelode Zoo do modelo Chainer e, em seguida, exporte para o formato ONNX.

import numpy as npimport chainerimport chainercv.links as Limport onnx_chainer

# Fetch a vgg16 modelmodel = L.VGG16(pretrained_model='imagenet')

# Prepare an input tensorx = np.random.rand(1, 3, 224, 224).astype(np.float32) * 255

# Run the model on the datawith chainer.using_config('train', False): chainer_out = model(x).array

# Export the model to a .onnx fileout = onnx_chainer.export(model, x, filename='vgg16.onnx')

# Check that the newly created model is valid and meets ONNX specification.import onnxmodel_proto = onnx.load("vgg16.onnx")onnx.checker.check_model(model_proto)

Depois de executar esse script, você verá o arquivo .onnx recém-criado no mesmo diretório.

106

http://onnx.ai/


Agora que você tem um arquivo ONNX, execute a inferência com ele usando o seguinte exemplo:

• Usar o CNTK para inferência com um modelo ONNX (p. 102)

Tutoriais do ONNX


Tutorial do Chainer para ONNX para MXNetVisão geral da ONNXO Open Neural Network Exchange (ONNX) é um formato aberto usado para representar modelos deaprendizado profundo. ONNX é suportado pela Amazon Web Services, Microsoft, Facebook e váriosoutros parceiros. Você pode projetar, treinar e implantar modelos de aprendizado profundo com qualquerestrutura que você escolher. O benefício de modelos ONNX é que eles podem ser movidos entre asestruturas com facilidade.


Pré-requisitos do ONNXPara usar esse tutorial de ONNX, você deve ter acesso a uma Deep Learning AMI com Conda versão12 ou posterior. Para obter mais informações sobre como começar a usar a Deep Learning AMI comConda (p. 5), consulte Deep Learning AMI com Conda.

Important



Converta um Modelo Chainer para ONNX, depois carregue o modelo no MXNetPrimeiro, ative o ambiente Chainer:


Crie um novo arquivo com o editor de texto e use o programa a seguir em um script para obter um modelode Zoo do modelo Chainer e, em seguida, exporte para o formato ONNX.

import numpy as npimport chainerimport chainercv.links as Limport onnx_chainer

# Fetch a vgg16 modelmodel = L.VGG16(pretrained_model='imagenet')

107

http://onnx.ai/


# Prepare an input tensorx = np.random.rand(1, 3, 224, 224).astype(np.float32) * 255

# Run the model on the datawith chainer.using_config('train', False): chainer_out = model(x).array

# Export the model to a .onnx fileout = onnx_chainer.export(model, x, filename='vgg16.onnx')

# Check that the newly created model is valid and meets ONNX specification.import onnxmodel_proto = onnx.load("vgg16.onnx")onnx.checker.check_model(model_proto)

Depois de executar esse script, você verá o arquivo .onnx recém-criado no mesmo diretório.

Agora que você tem um arquivo ONNX, execute a inferência com ele usando o seguinte exemplo:

• Usar o Apache MXNet para inferência com um modelo ONNX (p. 100)

Tutoriais do ONNX


Tutorial do PyTorch para ONNX para CNTKNote







108

http://onnx.ai/


Important



Converta um Modelo PyTorch para ONNX, depois carregue o modelo no CNTK

Primeiro, ative o ambiente PyTorch:


Crie um novo arquivo com o editor de texto e use o programa a seguir em um script para treinar ummodelo de simulação no PyTorch e, em seguida, exporte para o formato ONNX.

# Build a Mock Model in Pytorch with a convolution and a reduceMean layer\import torchimport torch.nn as nnimport torch.nn.functional as Fimport torch.optim as optimfrom torchvision import datasets, transformsfrom torch.autograd import Variableimport torch.onnx as torch_onnx

class Model(nn.Module): def __init__(self): super(Model, self).__init__() self.conv = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=(3,3), stride=1, padding=0, bias=False)

def forward(self, inputs): x = self.conv(inputs) #x = x.view(x.size()[0], x.size()[1], -1) return torch.mean(x, dim=2)

# Use this an input trace to serialize the modelinput_shape = (3, 100, 100)model_onnx_path = "torch_model.onnx"model = Model()model.train(False)

# Export the model to an ONNX filedummy_input = Variable(torch.randn(1, *input_shape))output = torch_onnx.export(model, dummy_input, model_onnx_path, verbose=False)

Depois de executar esse script, você verá o arquivo .onnx recém-criado no mesmo diretório. Agora, alternepara o ambiente Conda CNTK para carregar o modelo com CNTK.

Depois, ative o ambiente CNTK:

$ source deactivate$ source activate cntk_p36

Crie um novo arquivo com o editor de texto e use o programa a seguir em um script para abrir o arquivo noformato ONNX no CNTK.

109


import cntk as C# Import the PyTorch model into CNTK via the CNTK import APIz = C.Function.load("torch_model.onnx", device=C.device.cpu(), format=C.ModelFormat.ONNX)

Depois de executar esse script, CNTK terá carregado o modelo.

Você também pode exportar para ONNX usando CNTK anexando o seguinte ao script anterior e, emseguida, executando-o.

# Export the model to ONNX via the CNTK export APIz.save("cntk_model.onnx", format=C.ModelFormat.ONNX)

Tutoriais do ONNX


Tutorial do PyTorch para ONNX para MXNetVisão geral da ONNXO Open Neural Network Exchange (ONNX) é um formato aberto usado para representar modelos deaprendizado profundo. ONNX é suportado pela Amazon Web Services, Microsoft, Facebook e váriosoutros parceiros. Você pode projetar, treinar e implantar modelos de aprendizado profundo com qualquerestrutura que você escolher. O benefício de modelos ONNX é que eles podem ser movidos entre asestruturas com facilidade.


Pré-requisitos do ONNXPara usar esse tutorial de ONNX, você deve ter acesso a uma Deep Learning AMI com Conda versão12 ou posterior. Para obter mais informações sobre como começar a usar a Deep Learning AMI comConda (p. 5), consulte Deep Learning AMI com Conda.

Important



Converta um Modelo PyTorch para ONNX, depois carregue o modelo no MXNetPrimeiro, ative o ambiente PyTorch:


Crie um novo arquivo com o editor de texto e use o programa a seguir em um script para treinar ummodelo de simulação no PyTorch e, em seguida, exporte para o formato ONNX.

110

http://onnx.ai/


# Build a Mock Model in PyTorch with a convolution and a reduceMean layerimport torchimport torch.nn as nnimport torch.nn.functional as Fimport torch.optim as optimfrom torchvision import datasets, transformsfrom torch.autograd import Variableimport torch.onnx as torch_onnx

class Model(nn.Module): def __init__(self): super(Model, self).__init__() self.conv = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=(3,3), stride=1, padding=0, bias=False)

def forward(self, inputs): x = self.conv(inputs) #x = x.view(x.size()[0], x.size()[1], -1) return torch.mean(x, dim=2)

# Use this an input trace to serialize the modelinput_shape = (3, 100, 100)model_onnx_path = "torch_model.onnx"model = Model()model.train(False)

# Export the model to an ONNX filedummy_input = Variable(torch.randn(1, *input_shape))output = torch_onnx.export(model, dummy_input, model_onnx_path, verbose=False)print("Export of torch_model.onnx complete!")

Depois de executar esse script, você verá o arquivo .onnx recém-criado no mesmo diretório. Agora, alternepara o ambiente Conda MXNet para carregar o modelo com MXNet.

Depois, ative o ambiente MXNet:

$ source deactivate$ source activate mxnet_p36

Crie um novo arquivo com o editor de texto e use o programa a seguir em um script para abrir o arquivo noformato ONNX no MXNet.

import mxnet as mxfrom mxnet.contrib import onnx as onnx_mxnetimport numpy as np

# Import the ONNX model into MXNet's symbolic interfacesym, arg, aux = onnx_mxnet.import_model("torch_model.onnx")print("Loaded torch_model.onnx!")print(sym.get_internals())

Depois de executar esse script, o MXNet terá carregado o modelo e imprimirá algumas informaçõesbásicas de modelo.

Tutoriais do ONNX

• Tutorial do Apache MXNet para ONNX para CNTK (p. 104)

111

Deep Learning AMI Guia do desenvolvedorFornecimento de modelos

• Tutorial do Chainer para ONNX para CNTK (p. 105)• Tutorial do Chainer para ONNX para MXNet (p. 107)• Tutorial do PyTorch para ONNX para MXNet (p. 110)• Tutorial do PyTorch para ONNX para CNTK (p. 108)

Fornecimento de modelosVeja a seguir as opções de fornecimento de modelos instaladas na Deep Learning AMI com Conda. Cliqueem uma das opções para saber como usá-la.

Tópicos• Model Server para Apache MXNet (MMS) (p. 112)• TensorFlow Serving (p. 114)

Model Server para Apache MXNet (MMS)O Model Server for Apache MXNet (MMS) é uma ferramenta flexível que fornece modelos de aprendizadoprofundos exportados do Apache MXNet (incubadora) ou exportados para um formato de modelo OpenNeural Network Exchange (ONNX) O MMS vem pré-instalado com a DLAMI com Conda. Este tutorial paraMMS demonstrará como fornecer um modelo de classificação de imagem.

Tópicos• Fornecer um modelo de classificação de imagem no MMS (p. 112)• Outros Exemplos (p. 114)• Mais informações (p. 114)

Fornecer um modelo de classificação de imagem no MMS

Este tutorial mostra como fornecer um modelo de classificação de imagem com o MMS. O modelo éfornecido por meio do MMS Model Zoo e é baixado automaticamente quando você inicia o MMS. Quandoo servidor está em execução, ele recebe 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 classescorrespondentes das 1.000 classes em que o modelo foi treinado. Mais informações sobre os modelos,como eles foram treinados e como testá-los podem ser encontradas no MMS Model Zoo.

Para fornecer um exemplo de modelo de classificação de imagem no MMS

1. Conecte-se à instância Amazon Elastic Compute Cloud (Amazon EC2) do Deep Learning AMI comConda.

2. Ative um ambiente do MXNet:• Para MXNet e Keras 2 no Python 3 com CUDA 9.0 e MKL-DNN, execute este comando:


• Para MXNet e Keras 2 no Python 2 com CUDA 9.0 e MKL-DNN, execute este comando:


3. Execute o MMS com o comando a seguir. Adicione > /dev/null para silenciar a saída de registroenquanto você executa outros testes.

112

https://github.com/awslabs/mxnet-model-server/

http://mxnet.io/

https://github.com/awslabs/mxnet-model-server/blob/master/docs/model_zoo.md

https://github.com/awslabs/mxnet-model-server/blob/master/docs/model_zoo.md


$ mxnet-model-server --start > /dev/null

Agora, o MMS está em execução no host e está recebendo solicitações de inferência.4. Em seguida, use um comando curl para administrar endpoints de gerenciamento do MMS e informe ao

comando qual modelo você quer que ele forneça.

$ curl -X POST "http://localhost:8081/models?url=https%3A%2F%2Fs3.amazonaws.com%2Fmodel-server%2Fmodels%2Fsqueezenet_v1.1%2Fsqueezenet_v1.1.model"

5. O MMS precisa saber o número de operadores que você pretende usar. Para este teste, use 3.

$ curl -v -X PUT "http://localhost:8081/models/squeezenet_v1.1?min_worker=3"

6. Faça download de uma imagem de um gatinho e a envie para o endpoint de previsão MMS:

$ curl -O https://s3.amazonaws.com/model-server/inputs/kitten.jpg$ curl -X POST http://127.0.0.1:8080/predictions/squeezenet_v1.1 -T kitten.jpg

O endpoint de previsão retorna uma previsão em JSON semelhante às cinco principais previsões aseguir, em que a imagem tem uma probabilidade de 94% de conter um gato egípcio, seguida por umachance de 5,5% de ter um lince ou uma onça-parda:

{ "prediction": [ [{ "class": "n02124075 Egyptian cat", "probability": 0.940 }, { "class": "n02127052 lynx, catamount", "probability": 0.055 }, { "class": "n02123045 tabby, tabby cat", "probability": 0.002 }, { "class": "n02123159 tiger cat", "probability": 0.0003 }, { "class": "n02123394 Persian cat", "probability": 0.0002 } ] ]}

7. Teste algumas outras imagens ou, se você tiver concluído o teste, interrompa o servidor:

$ mxnet-model-server --stop

Este tutorial foca no fornecimento do modelo básico. O MMS também é compatível usando inferênciaelástica com fornecimento do modelo. Para obter mais informações, consulte Fornecimento do modelocom o Amazon Elastic Inference

113

https://github.com/awslabs/mxnet-model-server/blob/master/docs/elastic_inference.md

https://github.com/awslabs/mxnet-model-server/blob/master/docs/elastic_inference.md


Para saber mais sobre outros recursos do MMS, consulte a documentação do MMS no GitHub.

Outros ExemplosO MMS tem uma variedade de exemplos que você pode executar no seu DLAMI. Você pode visualizá-losno repositório do projeto do MMS.

Mais informaçõesPara ver outras documentações do MMS, incluindo como configurar o MMS com o Docker ou paraaproveitar os recursos mais recentes do MMS, acesse a página do projeto do MMS no GitHub.

TensorFlow ServingO TensorFlow Serving é um sistema de fornecimento flexível de alto desempenho para modelos deMachine Learning.

O tensorflow-serving-api é pré-instalado com Deep Learning AMI com Conda! Você encontraráscripts de exemplo para treinar, exportar e fornecer um modelo MNIST em ~/examples/tensorflow-serving/.

Para executar qualquer um destes exemplos, primeiro conecte seu Deep Learning AMI com Conda e ativeo ambiente TensorFlow do Python 2.7. Os scripts de exemplo não são compatíveis com Python 3.x.


Agora, altere os diretórios para a pasta de scripts de exemplo de fornecimento.

$ cd ~/examples/tensorflow-serving/

Fornecer um modelo de origem pré-treinadoVeja a seguir um exemplo que você pode seguir para fornecer diferentes modelos como origem. Comoregra geral, você precisa de um script de modelo e cliente que pode ser fornecido que já possa ser obtidopor download no seu DLAMI.

Forneça e teste a inferência com um modelo de início

1. Faça download do modelo.

$ curl -O https://s3-us-west-2.amazonaws.com/aws-tf-serving-ei-example/inception.zip

2. Descompacte o modelo.

$ unzip inception.zip

3. Faça download de uma imagem de um husky.


4. Inicie o servidor. Observe que, para o Amazon Linux, você deve alterar o diretório usado paramodel_base_path, de /home/ubuntu para /home/ec2-user.

$ tensorflow_model_server --model_name=inception --model_base_path=/home/ubuntu/examples/tensorflow-serving/SERVING_INCEPTION --port=9000

114

https://github.com/awslabs/mxnet-model-server/blob/master/docs/README.md

https://github.com/awslabs/mxnet-model-server/tree/master/examples

https://github.com/awslabs/mxnet-model-server

https://www.tensorflow.org/serving/



5. Com o servidor em execução em primeiro plano, será necessário iniciar outra sessão de terminal paracontinuar. Abra um novo terminal e ative o TensorFlow com source activate tensorflow_p27.Em seguida, use um editor de texto de sua preferência para criar um script com o conteúdo a seguir.Chame-o de inception_client.py. Esse script usará um nome de arquivo de imagem como umparâmetro e obterá o resultado da previsão do modelo pré-treinado.

from __future__ import print_function

import grpcimport tensorflow as tf

from tensorflow_serving.apis import predict_pb2from tensorflow_serving.apis import prediction_service_pb2_grpc

tf.app.flags.DEFINE_string('server', 'localhost:9000', 'PredictionService host:port')tf.app.flags.DEFINE_string('image', '', 'path to image in JPEG format')FLAGS = tf.app.flags.FLAGS

def main(_): channel = grpc.insecure_channel(FLAGS.server) stub = prediction_service_pb2_grpc.PredictionServiceStub(channel) # Send request with open(FLAGS.image, 'rb') as f: # See prediction_service.proto for gRPC request/response details. data = f.read() request = predict_pb2.PredictRequest() request.model_spec.name = 'inception' request.model_spec.signature_name = 'predict_images' request.inputs['images'].CopyFrom( tf.contrib.util.make_tensor_proto(data, shape=[1])) result = stub.Predict(request, 10.0) # 10 secs timeout print(result) print("Inception Client Passed")

if __name__ == '__main__': tf.app.run()

6. Agora execute o script passando o local do servidor, a porta e o nome do arquivo da fotografia dohusky como parâmetros.

$ python inception_client.py --server=localhost:9000 --image Siberian_Husky_bi-eyed_Flickr.jpg

Treinar e fornecer um modelo do MNISTNeste tutorial, vamos exportar um modelo e, em seguida, fornecê-lo com o aplicativotensorflow_model_server. Finalmente, você pode testar o servidor modelo com um exemplo de scriptdo cliente.

Execute o script que treina e exporta um modelo MNIST. Como único argumento do script, você precisafornecer uma pasta local para salvar o modelo. Por enquanto, podemos colocá-lo em mnist_model. Oscript criará a pasta para você.

$ python mnist_saved_model.py /tmp/mnist_model

Aguarde. Este script pode demorar um pouco antes de fornecer resultados. Ao concluir o treinamento e,por fim, exportar o modelo, você verá o seguinte:

115


Done training!Exporting trained model to mnist_model/1Done exporting!

A próxima etapa é executar o tensorflow_model_server para fornecer o modelo exportado.

$ tensorflow_model_server --port=9000 --model_name=mnist --model_base_path=/tmp/mnist_model

Um script de cliente é disponibilizado para testar o servidor.

Para testá-lo, você precisa abrir uma nova janela no terminal.

$ python mnist_client.py --num_tests=1000 --server=localhost:9000

Outros recursos e exemplos

Se você quiser saber mais sobre o TensorFlow Serving, acesse o site do TensorFlow Serving.

Você também pode usar o TensorFlow Serving com o Amazon Elastic Inference. Para obter maisinformações, confira o guia sobre como Usar o Elastic Inference com o TensorFlow Serving.

116



https://docs.aws.amazon.com/elastic-inference/latest/developerguide/ei-tensorflow-python.html

Deep Learning AMI Guia do desenvolvedorAtualização da DLAMI

Atualizando seu DLAMIAqui você encontrará informações sobre como atualizar a DLAMI e dicas sobre como atualizar o softwarena DLAMI.

Tópicos• Atualizando para a nova versão da DLAMI (p. 117)• Dicas para as atualizações de software (p. 117)

Atualizando para a nova versão da DLAMIAs imagens do sistema da DLAMI são atualizadas regularmente para aproveitar as novas versões daestrutura de deep learning, CUDA e outras atualizações de softwares e ajustes de performance. Se vocêestá usando uma DLAMI há um certo tempo e deseja aproveitar uma atualização, você precisaria executaruma nova instância. Você também precisaria transferir manualmente todos os conjuntos de dados, pontosde verificação ou outros dados importantes. Em vez disso, você pode usar o Amazon EBS para reter seusdados e associá-los a uma nova DLAMI. Dessa forma, você pode fazer atualizações com frequência e, aomesmo tempo, minimizar o tempo necessário para transferir os dados.

Note

Ao associar e mover volumes do Amazon EBS entre DLAMI você deve ter as DLAMI e o novovolume na mesma zona de disponibilidade.

1. Use o console do Amazon EC2 para criar um novo volume do Amazon EBS. Para obter instruçõesdetalhadas, consulte Criar um volume do EBS da Amazon.

2. Associe o volume do Amazon EBS recém-criado à sua DLAMI existente. Para obter instruçõesdetalhadas, consulte Anexar um volume do EBS da Amazon.

3. Transfira seus dados, como conjuntos de dados, pontos de verificação e arquivos de configuração.4. Lançar uma DLAMI. Para obter instruções detalhadas, consulte Iniciar e configurar uma DLAMI (p. 19).5. Desassocie o volume do Amazon EBS da sua antiga DLAMI. Para obter instruções detalhadas,

consulte Retirar um volume do EBS da Amazon.6. Associe o volume do Amazon EBS à sua nova DLAMI. Siga as instruções da etapa 2 para associar o

volume.7. Após verificar se seus dados estão disponíveis na nova DLAMI, interrompa e encerre a antiga DLAMI.

Para obter instruções detalhadas para limpeza, consulte Limpar (p. 21).

Dicas para as atualizações de softwarePeriodicamente, você pode atualizar manualmente o software em sua DLAMI. É recomendável usar pippara atualizar pacotes Python. Você também deve usar pip para atualizar pacotes em um ambienteConda na Deep Learning AMI com Conda. Consulte o site do software ou do framework específico paraobter instruções de atualização e instalação.

Se tiver interesse em executar a ramificação master mais recente de um determinado pacote, ative oambiente apropriado e, em seguida, adicione --pre ao final do comando pip install --upgrade. Porexemplo:

117

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-creating-volume.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-attaching-volume.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-detaching-volume.html

Deep Learning AMI Guia do desenvolvedorAtualizações de software

source activate mxnet_p36pip install --upgrade mxnet --pre

118

Deep Learning AMI Guia do desenvolvedorProteção de dados

Segurança no AWS Deep LearningAMI

A segurança da nuvem na AWS é a nossa maior prioridade. Como cliente da AWS, você se beneficiaráde um datacenter e de uma arquitetura de rede criados para atender aos requisitos das empresas com asmaiores exigências de segurança.

A segurança é uma responsabilidade compartilhada entre a AWS e você. O modelo de responsabilidadecompartilhada descreve isso como segurança da nuvem e segurança na nuvem:

• Segurança da nuvem – A AWS é responsável pela proteção da infraestrutura que executa serviçosda AWS na nuvem da AWS. A AWS também fornece serviços que você pode usar com segurança.Auditores de terceiros testam e verificam regularmente a eficácia da nossa segurança como parte dosProgramas de conformidade da AWS. Para saber mais sobre os programas de conformidade que seaplicam ao DLAMI, consulte Serviços da AWS no escopo por programa de conformidade.

• Segurança na nuvem – Sua responsabilidade é determinada pelo serviço da AWS que você usa. Vocêtambém é responsável por outros fatores, incluindo a confidencialidade de seus dados, os requisitos dasua empresa e as leis e regulamentos aplicáveis.

Esta documentação ajuda a entender como aplicar o modelo de responsabilidade compartilhada ao usaro DLAMI. Os tópicos a seguir mostram como configurar o DLAMI para atender aos seus objetivos desegurança e de conformidade. Você também aprenderá a usar outros serviços da AWS que ajudam amonitorar e proteger seus recursos do DLAMI.

Para obter mais informações, consulte Segurança no Amazon EC2.

Tópicos• Proteção de dados no AWS Deep Learning AMI (p. 119)• Identity and Access Management no AWS Deep Learning AMI (p. 120)• Registro em log e monitoramento no AWS Deep Learning AMI (p. 124)• Validação de conformidade do AWS Deep Learning AMI (p. 124)• Resiliência no AWS Deep Learning AMI (p. 125)• Segurança da infraestrutura no AWS Deep Learning AMI (p. 125)

Proteção de dados no AWS Deep Learning AMIO AWS Deep Learning AMI está em conformidade com o modelo de responsabilidade compartilhadada AWS, que inclui regulamentos e diretrizes de proteção de dados. A AWS é responsável por protegera infraestrutura global que executa todos os serviços da AWS. A AWS mantém controle dos dadoshospedados nessa infraestrutura, incluindo os controles de configuração de segurança para lidar com oconteúdo e com os dados pessoais do cliente. Os clientes da AWS e os parceiros do APN, atuando comocontroladores ou processadores de dados, são responsáveis por todos os dados pessoais que colocam naNuvem AWS.

Para fins de proteção de dados, recomendamos que você proteja as credenciais da sua conta da AWSe configure contas de usuário individuais com o AWS Identity and Access Management (IAM), de modoque cada usuário receba somente as permissões necessárias para cumprir suas funções. Recomendamostambém que você proteja seus dados das seguintes formas:

119

http://aws.amazon.com/compliance/shared-responsibility-model/


http://aws.amazon.com/compliance/programs/

http://aws.amazon.com/compliance/services-in-scope/

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security.html


Deep Learning AMI Guia do desenvolvedorIdentity and Access Management

• Use uma autenticação multifator (MFA) com cada conta.• Use SSL/TLS para se comunicar com os recursos da AWS.• Configure a API e o registro em log das atividades do usuário com o AWS CloudTrail.• Use as soluções de criptografia da AWS, juntamente com todos os controles de segurança padrão nos

serviços da AWS.• Use serviços gerenciados de segurança avançada, como o Amazon Macie, que ajuda a localizar e

proteger dados pessoais que são armazenados no Amazon S3.

É altamente recomendável que você nunca coloque informações de identificação confidenciais, comonúmeros de conta dos seus clientes, em campos de formato livre, como um campo Name (Nome). Issotambém vale para quando você trabalha com o DLAMI ou com outros serviços da AWS usando o console,a API, a AWS CLI ou os AWS SDKs. Todos os dados que você insere no DLAMI ou em outros serviçospodem ser selecionados para inclusão em logs de diagnóstico. Ao fornecer um URL para um servidorexterno, não inclua informações de credenciais no URL para validar a solicitação a esse servidor.

Para obter mais informações sobre proteção de dados, consulte Proteção de dados no Amazon EC2 e apostagem AWS Shared Responsibility Model and GDPR (Modelo de responsabilidade compartilhada daAWS e GDPR) no Blog de segurança da AWS.

Identity and Access Management no AWS DeepLearning AMI

O AWS Identity and Access Management (IAM) é um serviço da AWS que ajuda um administrador acontrolar com segurança o acesso aos recursos da AWS. Os administradores do IAM controlam quempode ser autenticado (conectado) e autorizado (ter permissões) para usar os recursos do DLAMI. O IAM éum serviço da AWS que pode ser usado sem custo adicional.

Para obter mais informações sobre Identity and Access Management, consulte Identity and AccessManagement para o Amazon EC2.

Tópicos• Autenticação com identidades (p. 120)• Gerenciamento do acesso usando políticas (p. 122)• IAM por Amazon EMR (p. 124)

Autenticação com identidadesA autenticação é a forma como você faz login na AWS usando suas credenciais de identidade. Para obtermais informações sobre como fazer login usando o Console de gerenciamento da AWS, consulte A páginade login e do console do IAM no Guia do usuário do IAM.

Você deve ser autenticado (fazer login na AWS) como o Usuário raiz da conta da AWS, um usuário doIAM, ou assumindo uma função do IAM. Também é possível usar a autenticação de logon único da suaempresa, ou até mesmo fazer login usando o Google ou o Facebook. Nesses casos, seu administradorconfigurou anteriormente a federação de identidades usando funções do IAM. Ao acessar a AWS usandocredenciais de outra empresa, você estará assumindo uma função indiretamente.

Para fazer login diretamente no Console de gerenciamento da AWS, use sua senha com o e-mail dousuário raiz ou seu nome de usuário do IAM. É possível acessar a AWS de maneira programática usandoseu usuário raiz ou as chaves de acesso do usuário do IAM. A AWS fornece ferramentas do SDK ou da

120

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/data-protection.html

http://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/

http://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-iam.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-iam.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/console.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/console.html

https://console.aws.amazon.com/

Deep Learning AMI Guia do desenvolvedorAutenticação com identidades

linha de comando para assinar sua solicitação de forma criptográfica usando suas credenciais. Se vocênão utilizar ferramentas da AWS, cadastre a solicitação você mesmo. Faça isso usando o Signature versão4, um protocolo para autenticação de solicitações de API de entrada. Para obter mais informações sobre aautenticação de solicitações, consulte Processo de cadastramento do Signature versão 4 na AWS GeneralReference.

Independentemente do método de autenticação usado, também pode ser exigido que você forneçainformações adicionais de segurança. Por exemplo, a AWS recomenda o uso da autenticação multifator(MFA) para aumentar a segurança de sua conta. Para saber mais, consulte Usar a autenticação multifator(MFA) na AWS no Guia do usuário do IAM.

Usuário raiz da conta da AWSAo criar uma conta da AWS, você começa com uma única identidade de login que tenha acesso total atodos os recursos e serviços da AWS na conta. Essa identidade é chamada de AWS da conta da usuárioraiz e é acessada pelo login com o endereço de e-mail e a senha que você usou para criar a conta.Recomendamos que não use o usuário raiz para suas tarefas diárias, nem mesmo as administrativas.Em vez disso, siga as melhores práticas de uso do usuário raiz somente para criar seu primeiro usuáriodo IAM. Depois, armazene as credenciais usuário raiz com segurança e use-as para executar apenasalgumas tarefas de gerenciamento de contas e de serviços.

Grupos e usuários do IAMUm usuário do IAM é uma identidade em sua conta da AWS que tem permissões específicas para umaúnica pessoa ou um único aplicativo. Um usuário do IAM pode ter credenciais de longo prazo, como umnome de usuário e uma senha ou um conjunto de chaves de acesso. Para saber como gerar chaves deacesso, consulte Gerenciar chaves de acesso para usuários do IAM no Guia do usuário do IAM. Ao gerarchaves de acesso para um usuário do IAM, visualize e salve o par de chaves de maneira segura. Não serápossível recuperar a chave de acesso secreta futuramente. Em vez disso, você deverá gerar outro par dechaves de acesso.

Um grupo do IAM é uma identidade que especifica uma coleção de usuários do IAM. Não é possívelfazer login como um grupo. É possível usar grupos para especificar permissões para vários usuários deuma vez. Os grupos facilitam o gerenciamento de permissões para grandes conjuntos de usuários. Porexemplo, você pode ter um grupo chamado Administradores do IAM e atribuir a esse grupo permissõespara administrar recursos do IAM.

Usuários são diferentes de funções. Um usuário é exclusivamente associado a uma pessoa ou a umaplicativo, mas uma função pode ser assumida por qualquer pessoa que precisar dela. Os usuários têmcredenciais permanentes de longo prazo, mas as funções fornecem credenciais temporárias. Para sabermais, consulte Quando criar um usuário do IAM (em vez de uma função) no Guia do usuário do IAM.

Funções do IAMUma função do IAM é uma identidade dentro de sua conta da AWS que tem permissões específicas.Ela é semelhante a um usuário do IAM, mas não está associada a uma pessoa específica. É possívelassumir temporariamente uma função do IAM no Console de gerenciamento da AWS alternando funções.É possível assumir uma função chamando uma operação de API da AWS CLI ou da AWS, ou usando umURL personalizado. Para obter mais informações sobre os métodos para o uso de funções, consulte Usarfunções do IAM no Guia do usuário do IAM.

As funções do IAM com credenciais temporária são úteis nas seguintes situações:

• Permissões temporárias para usuários do IAM – um usuário do IAM pode assumir uma função do IAMpara obter temporariamente permissões diferentes para uma tarefa específica.

• Acesso de usuário federado – Em vez de criar um usuário do IAM, você pode usar identidadesexistentes do AWS Directory Service, do diretório de usuário da sua empresa ou de um provedor de

121

https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users

https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html#id_which-to-choose

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html

Deep Learning AMI Guia do desenvolvedorGerenciamento do acesso usando políticas

identidades da Web. Estes são conhecidos como usuários federados. A AWS atribui uma função a umusuário federado quando o acesso é solicitado por meio de um provedor de identidades. Para obter maisinformações sobre usuários federados, consulte Usuários federados e funções no Guia do usuário doIAM.

• Acesso entre contas – é possível usar uma função do IAM para permitir que alguém (um principalconfiável) em outra conta acesse recursos em sua conta. As funções são a principal forma de concederacesso entre contas. No entanto, alguns serviços da AWS permitem que você anexe uma políticadiretamente a um recurso (em vez de usar uma função como proxy). Para saber a diferença entrefunções e políticas baseadas em recurso para acesso entre contas, consulte Como as funções do IAMdiferem das políticas baseadas em recurso no Guia do usuário do IAM.

• Acesso a serviços da AWS – Uma função de serviço é uma função do IAM que um serviço assumepara realizar ações em seu nome na sua conta. Ao configurar alguns ambientes de serviço da AWS,você deve definir uma função a ser assumida pelo serviço. Essa função de serviço deve incluir todasas permissões necessárias para o serviço acessar os recursos da AWS de que precisa. As funções deserviço variam de acordo com o serviço, mas muitas permitem que você escolha as permissões, desdeque atenda aos requisitos documentados para esse serviço. As funções de serviço fornecem acessoapenas dentro de sua conta e não podem ser usadas para conceder acesso a serviços em outrascontas. Você pode criar, modificar e excluir uma função de serviço no IAM. Por exemplo, você podecriar uma função que permita que Amazon Redshift acesse um bucket do Amazon S3 em seu nome ecarregue dados desse bucket em um cluster Amazon Redshift. Para obter mais informações, consulteCriar uma função para delegar permissões a um serviço da AWS no Guia do usuário do IAM.

• Aplicativos em execução no Amazon EC2 –Você pode usar uma função do IAM para gerenciarcredenciais temporárias para aplicativos que estão sendo executados em uma instância do EC2 e quefazem solicitações de API da AWS CLI ou AWS. É preferível fazer isso do que armazenar chaves deacesso na instância do EC2. Para atribuir uma função da AWS a uma instância do EC2 e disponibilizá-la para todos os seus aplicativos, crie um perfil de instância que esteja anexado à instância. Um perfilde instância contém a função e permite que programas que estão em execução na instância do EC2obtenham credenciais temporárias. Para mais informações, consulte Uso de uma função do IAM paraconceder permissões aos aplicativos em execução nas instâncias do Amazon EC2 no Guia do usuáriodo IAM.

Para saber se você deve usar funções do IAM, consulte Quando criar uma função do IAM (em vez de umusuário) no Guia do usuário do IAM.

Gerenciamento do acesso usando políticasVocê controla o acesso na AWS criando políticas e anexando-as às identidades do IAM ou aos recursosda AWS. Uma política é um objeto na AWS que, quando associado a uma identidade ou a um recurso,define suas permissões. A AWS avalia essas políticas quando uma entidade (usuário raiz, usuário doIAM ou função do IAM) faz uma solicitação. As permissões nas políticas determinam se a solicitação serápermitida ou negada. A maioria das políticas são armazenadas na AWS como documentos JSON. Paraobter mais informações sobre a estrutura e o conteúdo de documentos de políticas JSON, consulte Visãogeral de políticas JSON no Guia do usuário do IAM.

Um administrador do IAM pode usar políticas para especificar quem tem acesso aos recursos da AWS equais ações essas pessoas podem executar nesses recursos. Cada entidade do IAM (usuário ou função)começa sem permissões. Em outras palavras, por padrão, os usuários não podem fazer nada, nem mesmoalterar sua própria senha. Para dar permissão a um usuário para fazer algo, um administrador deve anexaruma política de permissões ao usuário. Ou o administrador pode adicionar o usuário a um grupo que tenhaas permissões pretendidas. Quando um administrador concede permissões a um grupo, todos os usuáriosdesse grupo recebem essas permissões.

As políticas do IAM definem permissões para uma ação, independentemente do método usadopara executar a operação. Por exemplo, suponha que você tenha uma política que permite a açãoiam:GetRole. Um usuário com essa política pode obter informações de funções do Console degerenciamento da AWS, da AWS CLI ou da API da AWS.

122

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_access-management.html#intro-access-roles

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_compare-resource-policies.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_compare-resource-policies.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html#id_which-to-choose_role

https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html#id_which-to-choose_role

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json

Deep Learning AMI Guia do desenvolvedorGerenciamento do acesso usando políticas

Políticas baseadas em identidadeAs políticas baseadas em identidade são documentos JSON de políticas de permissões que você podeanexar a uma entidade, como um usuário, função ou grupo do IAM. Essas políticas controlam quais açõescada identidade pode realizar, em quais recursos e em que condições. Para saber como criar uma políticabaseada em identidade, consulte Criar políticas do IAM no Guia do usuário do IAM.

As políticas baseadas em identidade podem ser categorizadas ainda mais como políticas em linha oupolíticas gerenciadas. As políticas em linha são anexadas diretamente a um único usuário, grupo oufunção. As políticas gerenciadas são políticas independentes que podem ser anexadas a vários usuários,grupos e funções em sua conta da AWS. As políticas gerenciadas incluem políticas gerenciadas pela AWSe políticas gerenciadas pelo cliente. Para saber como escolher entre uma política gerenciada ou umapolítica em linha, consulte Escolher entre políticas gerenciadas e políticas em linha no Guia do usuário doIAM.

Políticas com base em recursoPolíticas baseadas em recursos são documentos de política JSON que você anexa a um recurso, comoum bucket do Amazon S3. Os administradores do serviço podem usar essas políticas para definir quaisações um principal especificado (função, usuário ou membro da conta) pode executar nesse recurso e sobquais condições. As políticas baseadas em recurso são políticas em linha. Não há políticas baseadas emrecurso gerenciadas.

Listas de controle de acesso (ACLs)As listas de controle de acesso (ACLs) são um tipo de política que controla quais principais (membros,usuários ou funções da conta) têm permissões para acessar um recurso. As ACLs são semelhantes àspolíticas baseadas em recurso, embora não usem o formato de documento de política JSON. O AmazonS3, o AWS WAF e a Amazon VPC são exemplos de serviços que oferecem suporte a ACLs. Para sabermais sobre as ACLs, consulte Visão geral da lista de controle de acesso (ACL) no Guia do desenvolvedordo Amazon Simple Storage Service.

Outros tipos de políticaA AWS oferece suporte a tipos de política menos comuns. Esses tipos de política podem definir o máximode permissões concedidas a você pelos tipos de política mais comuns.

• Limites de permissões – um limite de permissões é um recurso avançado no qual você define omáximo de permissões que uma política baseada em identidade pode conceder a uma entidade doIAM (usuário ou função do IAM). É possível definir um limite de permissões para uma entidade. Aspermissões resultantes são a interseção das políticas baseadas em identidade da entidade e seuslimites de permissões. As políticas baseadas em recurso que especificam o usuário ou a função nocampo Principal não são limitadas pelo limite de permissões. Uma negação explícita em qualqueruma dessas políticas substitui a permissão. Para obter mais informações sobre limites de permissões,consulte Limites de permissões para entidades do IAM no Guia do usuário do IAM.

• Políticas de controle de serviço (SCPs – Service control policies) – SCPs são políticas JSON queespecificam o máximo de permissões para uma organização ou unidade organizacional (UO) noAWS Organizations. O AWS Organizations é um serviço para agrupamento e gerenciamento centraldas várias contas da AWS que sua empresa possui. Se você habilitar todos os recursos em umaorganização, poderá aplicar políticas de controle de serviço (SCPs) a qualquer uma ou a todas ascontas. O SCP limita as permissões para entidades em contas-membro, incluindo cada Usuário raizda conta da AWS. Para obter mais informações sobre Organizações e SCPs, consulte Como SCPsfuncionam no Guia do usuário do AWS Organizations.

• Políticas de sessão – as políticas de sessão são políticas avançadas que você transmite como umparâmetro quando cria de forma programática uma sessão temporária para uma função ou um usuáriofederado. As permissões da sessão resultante são a interseção das políticas baseadas em identidade

123

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#choosing-managed-or-inline

https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html

https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_about-scps.html

https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_about-scps.html

Deep Learning AMI Guia do desenvolvedorIAM por Amazon EMR

do usuário ou da função e das políticas de sessão. As permissões também podem ser provenientes deuma política baseada em recurso. Uma negação explícita em qualquer uma dessas políticas substitui apermissão. Para obter mais informações, consulte Políticas de sessão no Guia do usuário do IAM.

Vários tipos de políticaQuando vários tipos de política são aplicáveis a uma solicitação, é mais complicado compreender aspermissões resultantes. Para saber como a AWS determina se deve permitir uma solicitação quandovários tipos de política estão envolvidos, consulte Lógica de avaliação de políticas no Guia do usuário doIAM.

IAM por Amazon EMRVocê pode usar o AWS Identity and Access Management com o Amazon EMR para definir usuários,recursos da AWS, grupos, funções e políticas. Você também pode controlar quais serviços da AWS essesusuários e funções podem acessar.

Para obter mais informações sobre como usar o IAM com o Amazon EMR, consulte AWS Identity andAccess Management para Amazon EMR.

Registro em log e monitoramento no AWS DeepLearning AMI

A instância do AWS Deep Learning AMI vem com várias ferramentas de monitoramento de GPU, incluindoum utilitário que relata estatísticas de uso da GPU ao Amazon CloudWatch. Para obter mais informações,consulte Monitoramento e otimização de GPU e Monitoramento do Amazon EC2.

Validação de conformidade do AWS Deep LearningAMI

Auditores externos avaliam a segurança e a conformidade do AWS Deep Learning AMI como parte devários programas de conformidade da AWS. Para obter informações sobre os programas de conformidadecompatíveis, consulte Validação de conformidade para o Amazon EC2.

Para obter uma lista de produtos da AWS no escopo de programas de conformidade específicos, consulteProdutos da AWS no escopo por programa de conformidade. Para obter informações gerais, consulteProgramas de conformidade da AWS.

Você pode fazer download de relatórios de auditoria de terceiros usando o AWS Artifact. Para obter maisinformações, consulte Fazer download de relatórios no AWS Artifact.

Sua responsabilidade em relação à conformidade ao usar o DLAMI é determinada pela confidencialidadedos dados, pelos objetivos de conformidade da empresa e pelos regulamentos e leis aplicáveis. A AWSfornece os seguintes recursos para ajudar com a conformidade:

• Guias Quick Start de segurança e conformidade – esses guias de implantação abordam asconsiderações de arquitetura e fornecem etapas para implantação de ambientes de linha de basefocados em conformidade e segurança na AWS.

• Recursos de conformidade da AWS – esta coleção de manuais e guias pode ser aplicada ao seu setor elocal.

124

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html

https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-access-iam.html

https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-access-iam.html

https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-gpu.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring_ec2.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/compliance-validation.html

http://aws.amazon.com/compliance/services-in-scope/

http://aws.amazon.com/compliance/programs/

https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html

http://aws.amazon.com/quickstart/?awsf.quickstart-homepage-filter=categories%23security-identity-compliance

http://aws.amazon.com/compliance/resources/

Deep Learning AMI Guia do desenvolvedorResiliência

• Avaliar recursos com regras no Guia do desenvolvedor do AWS Config – o serviço do AWS Config avaliacomo suas configurações de recursos estão em conformidade com práticas internas, diretrizes do setore regulamentos.

• AWS Security Hub – esse serviço da AWS fornece uma visão abrangente do estado da segurança naAWS que ajuda você a verificar sua conformidade com padrões e melhores práticas de segurança dosetor.

Resiliência no AWS Deep Learning AMIA infraestrutura global da AWS é criada com base em regiões e zonas de disponibilidade da AWS. Asregiões da AWS fornecem várias zonas de disponibilidade separadas e isoladas fisicamente, que sãoconectadas com baixa latência, altas taxas de transferência e redes altamente redundantes. Com aszonas de disponibilidade, você pode projetar e operar aplicativos e bancos de dados que automaticamenteexecutam o failover entre as zonas sem interrupção. As zonas de disponibilidade são mais altamentedisponíveis, tolerantes a falhas e escaláveis que uma ou várias infraestruturas de data center tradicionais.

Para obter mais informações sobre regiões e zonas de disponibilidade da AWS, consulte Infraestruturaglobal da AWS.

Para obter informações sobre recursos para ajudar a satisfazer suas necessidades de resiliência e backupde dados, consulte Resiliência no Amazon EC2.

Segurança da infraestrutura no AWS DeepLearning AMI

A segurança da infraestrutura do AWS Deep Learning AMI tem suporte do Amazon EC2. Para obter maisinformações, consulte Segurança da infraestrutura no Amazon EC2.

125

https://docs.aws.amazon.com/config/latest/developerguide/evaluate-config.html

https://docs.aws.amazon.com/securityhub/latest/userguide/what-is-securityhub.html

http://aws.amazon.com/about-aws/global-infrastructure/

http://aws.amazon.com/about-aws/global-infrastructure/

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/disaster-recovery-resiliency.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/infrastructure-security.html

Deep Learning AMI Guia do desenvolvedorFóruns

Informações relacionadasTópicos

• Fóruns (p. 126)• Postagens de blogs relacionadas (p. 126)• Perguntas frequentes (p. 126)

Fóruns• Fórum: Deep Learning AMIs da AWS

Postagens de blogs relacionadas• Lista atualizada de artigos relacionados às Deep Learning AMIs• Executar um AWS Deep Learning AMI (em 10 minutos)• Treinamento mais rápido com TensorFlow 1.6 otimizado em instâncias C5 e P3 do Amazon EC2• Novas Deep Learning AMIs da AWS para profissionais de aprendizagem de máquina• Novos treinamentos técnicos disponíveis: introdução à aprendizagem de máquina e ao deep learning na

AWS• Jornada para o Deep Learning com a AWS

Perguntas frequentes• Q. Como controlo os anúncios de produtos relacionados à DLAMI?

Aqui estão duas sugestões para isso:• Marque esta categoria do blog, "AWS Deep Learning AMIs" encontrada aqui: Lista atualizada de

artigos relacionados às Deep Learning AMIs.• "Assista" ao Fórum: Deep Learning AMIs da AWS

• Q. Os drivers NVIDIA e CUDA estão instalados?

Sim. Alguns DLAMI têm versões diferentes. O Deep Learning AMI com Conda (p. 5) tem as versõesmais recentes de qualquer DLAMI. Isso é abordado em mais detalhes em Instalações do CUDA eassociações da estrutura (p. 7). Você também pode consultar a página de detalhes da AMI específica naloja para confirmar o que está instalado.

• Q. O cuDNN está instalado?

Sim.• Q. Como faço para ver se as GPUs estão detectadas e seu status atual?

Executar nvidia-smi. Isso mostrará uma ou mais GPUs, dependendo do tipo de instância, juntamentecom o seu consumo de memória atual.

• Q. Há ambientes virtuais configurados para mim?

Sim, mas apenas o Deep Learning AMI com Conda (p. 5).• Q. Qual versão do Python está instalada?

126

https://forums.aws.amazon.com/forum.jspa?forumID=263

https://aws.amazon.com/blogs/ai/category/artificial-intelligence/aws-deep-learning-amis/


https://aws.amazon.com/blogs/machine-learning/faster-training-with-optimized-tensorflow-1-6-on-amazon-ec2-c5-and-p3-instances/

https://aws.amazon.com/blogs/ai/new-aws-deep-learning-amis-for-machine-learning-practitioners/

https://aws.amazon.com/blogs/apn/new-training-courses-available-introduction-to-machine-learning-deep-learning-on-aws/

https://aws.amazon.com/blogs/apn/new-training-courses-available-introduction-to-machine-learning-deep-learning-on-aws/

https://aws.amazon.com/blogs/aws/journey-into-deep-learning-with-aws/



https://forums.aws.amazon.com/forum.jspa?forumID=263

Deep Learning AMI Guia do desenvolvedorPerguntas frequentes

Cada DLAMI tem Python 2 e 3. A Deep Learning AMI com Conda (p. 5) tem ambientes para as duasversões de cada estrutura.

• Q. O Keras está instalado?

Isso depende da AMI. A Deep Learning AMI com Conda (p. 5) tem o Keras disponível como um front-end para cada estrutura. A versão do Keras depende do suporte que a estrutura oferece para ele.

• Q. É gratuito?

Todas as DLAMI são gratuitas. No entanto, dependendo do tipo de instância que você escolher, ainstância poderá não ser gratuita. Consulte Definição de preço para a DLAMI (p. 18) para obter maisinformações.

• Q. Estou recebendo erros do CUDA ou mensagens relacionadas à GPU em minha estrutura. O que estáerrado?

Verifique o tipo de instância que você usou. Para funcionar, ela precisa ter uma GPU para muitosexemplos e tutoriais. Se a execução do nvidia-smi não mostrar nenhuma GPU, você precisará criaroutra DLAMI usando uma instância com uma ou mais GPUs. Consulte Seleção do tipo de instância paraDLAMI (p. 16) para obter mais informações.

• Q. Posso usar o Docker?

O Docker foi pré-instalado desde a versão 14 do Deep Learning AMI com Conda. Observe que vocêdesejará usar o nvidia-docker em instâncias de GPU para fazer uso da GPU.

• Q. Em quais regiões as DLAMI do Linux estão disponíveis?

Região Código





us-west-1













127

https://github.com/NVIDIA/nvidia-docker

Deep Learning AMI Guia do desenvolvedorPerguntas frequentes

Região Código



• Q. Em quais regiões as DLAMI do Windows estão disponíveis?

Região Código





us-west-1














128

Deep Learning AMI Guia do desenvolvedorNotas de release anteriores do DLAMI

Notas de release do DLAMIPara obter as notas de release atuais do DLAMI, consulte:

• AMI do AWS Deep Learning (Amazon Linux 2) versão 30• AMI do AWS Deep Learning (Amazon Linux) versão 30• AMI do AWS Deep Learning (Ubuntu 18.04) versão 30• AMI do AWS Deep Learning (Ubuntu 16.04) versão 30• AMI base do AWS Deep Learning (Amazon Linux 2) versão 25• AMI base do AWS Deep Learning (Amazon Linux) versão 25• AMI base do AWS Deep Learning (Ubuntu 18.04) versão 25• AMI base do AWS Deep Learning (Ubuntu 16.04) versão 25

Notas de release anteriores do DLAMIPara obter as notas de release das versões anteriores, consulte:

AMI do AWS Deep Learning versão 29.1

• AMI do AWS Deep Learning (Amazon Linux 2) versão 29.1• AMI do AWS Deep Learning (Amazon Linux) versão 29.1• AMI do AWS Deep Learning (Ubuntu 18.04) versão 29.1• AMI do AWS Deep Learning (Ubuntu 16.04) versão 29.1

AMI base do AWS Deep Learning versão 24.1

• AMI base do AWS Deep Learning (Amazon Linux 2) versão 24.1• AMI base do AWS Deep Learning (Amazon Linux) versão 24.1• AMI base do AWS Deep Learning (Ubuntu 18.04) versão 24.1• AMI base do AWS Deep Learning (Ubuntu 16.04) versão 24.1

AMI do AWS Deep Learning versão 29




129

https://aws.amazon.com/releasenotes/aws-deep-learning-ami-amazon-linux-2-version-30/

https://aws.amazon.com/releasenotes/aws-deep-learning-ami-amazon-linux-version-30/

https://aws.amazon.com/releasenotes/aws-deep-learning-ami-ubuntu-18-04-version-30/

https://aws.amazon.com/releasenotes/aws-deep-learning-ami-ubuntu-16-04-version-30/

https://aws.amazon.com/releasenotes/aws-deep-learning-base-ami-amazon-linux-2-version-25/

https://aws.amazon.com/releasenotes/aws-deep-learning-base-ami-amazon-linux-version-25/

https://aws.amazon.com/releasenotes/aws-deep-learning-base-ami-ubuntu-18-04-version-25/

https://aws.amazon.com/releasenotes/aws-deep-learning-base-ami-ubuntu-16-04-version-25/

https://aws.amazon.com/releasenotes/aws-deep-learning-ami-amazon-linux-2-version-29-1/

https://aws.amazon.com/releasenotes/aws-deep-learning-ami-amazon-linux-version-29-1/

https://aws.amazon.com/releasenotes/aws-deep-learning-ami-ubuntu-18-04-version-29-1/


https://aws.amazon.com/releasenotes/aws-deep-learning-base-ami-amazon-linux-2-version-24-1

https://aws.amazon.com/releasenotes/aws-deep-learning-base-ami-amazon-linux-version-24-1/

https://aws.amazon.com/releasenotes/aws-deep-learning-base-ami-ubuntu-16-04-version-24-1/


https://aws.amazon.com/releasenotes/aws-deep-learning-ami-amazon-linux-2-version-29

https://aws.amazon.com/releasenotes/aws-deep-learning-ami-amazon-linux-version-29

https://aws.amazon.com/releasenotes/aws-deep-learning-ami-ubuntu-18-04-version-29

https://aws.amazon.com/releasenotes/aws-deep-learning-ami-ubuntu-16-04-version-29

https://aws.amazon.com/releasenotes/aws-deep-learning-base-ami-amazon-linux-2-version-24-0


https://aws.amazon.com/releasenotes/aws-deep-learning-base-ami-ubuntu-18-04-version-24-0

https://aws.amazon.com/releasenotes/aws-deep-learning-base-ami-ubuntu-16-04-version-24-0

Deep Learning AMI Guia do desenvolvedorNotas de release anteriores do DLAMI








• AMI base do AWS Deep Learning (Amazon Linux 2) versão 22.0• AMI base do AWS Deep Learning (Ubuntu 18.04) versão 22.0• AMI base do AWS Deep Learning (Amazon Linux) versão 22.0• AMI base do AWS Deep Learning (Ubuntu 16.04) versão 22.0



130





https://aws.amazon.com/releasenotes/aws-deep-learning-base-ami-amazon-linux-2-version-23-0/








https://aws.amazon.com/releasenotes/aws-deep-learning-base-ami-amazon-linux-2-version-22-0/









Defasagens de DLAMIA tabela a seguir lista informações sobre recursos defasados na AWS Deep Learning AMI.

Recurso defasado Data da defasagem Aviso de defasagem

Python 2 01/01/2020 A comunidade de códigoaberto Python encerrouoficialmente o suporte aPython 2.

As comunidades deTensorFlow, PyTorch e MXNettambém anunciaram que asversões TensorFlow 1.15,TensorFlow 2.1, PyTorch 1.4 eMXNet 1.6.0 serão as últimascom suporte ao Python 2.

Amazon Linux 31/12/2020 O Amazon Linux estará nofim de vida útil a partir dedezembro de 2020. Nãohaverá mais atualizaçõespara a Deep LearningAMI (Amazon Linux) nasnovas versões a partir dejaneiro de 2021, exceto paracorreções de patch na DeepLearning AMI (Amazon Linux)quando houver correções desegurança publicadas nosrepositórios do Amazon Linux.As versões anteriores da DeepLearning AMI (Amazon Linux)continuarão disponíveis.

Chainer 01/07/2020 A Chainer anunciou o fimdos grandes lançamentosa partir de dezembro de2019. Consequentemente,deixaremos de incluirambientes Chainer Condana DLAMI a partir dejulho de 2020. As versõesanteriores da DLAMI quecontêm esses ambientescontinuarão disponíveis. Nóssó forneceremos atualizaçõespara esses ambientesse houver correções desegurança publicadas pelacomunidade de código abertopara essas estruturas detrabalho.

131

https://aws.amazon.com/blogs/aws/update-on-amazon-linux-ami-end-of-life/

https://aws.amazon.com/blogs/aws/update-on-amazon-linux-ami-end-of-life/

https://chainer.org/announcement/2019/12/05/released-v7.html

https://chainer.org/announcement/2019/12/05/released-v7.html


Recurso defasado Data da defasagem Aviso de defasagem

Python 3.6 15/06/2020 Devido a solicitações dosclientes, estamos mudandopara o Python 3.7 para asnovas versões TF/MX/PT.

132


Histórico de documentos do Guiado desenvolvedor do AWS DeepLearning AMI

update-history-change update-history-description update-history-date

TensorFlow 2 (p. 43) A Deep Learning AMI com Condaagora vem com o TensorFlow 2com CUDA 10.

December 3, 2019

AWS Inferentia (p. 82) A Deep Learning AMI agoraoferece suporte ao hardwaredo AWS Inferentia e ao SDK doAWS Neuron.

December 3, 2019

PyTorch 1.0 com CUDA 10 (p. 6) A Deep Learning AMI com Condaagora é fornecida com PyTorch1.0 com o CUDA 10.

December 13, 2018

CUDA 10 disponível na DeepLearning Base AMI (p. 7)

O CUDA 10 foi adicionado comouma opção para a Deep LearningBase AMI. Instruções sobre comoalterar e testar versões do CUDA.

December 11, 2018

Usar o TensorFlow Serving comum modelo de início (p. 114)

Um exemplo para usar ainferência com um modelode início foi adicionado aoTensorFlow Serving, para com ousem inferência elástica.

November 28, 2018

Treinamento com 256 GPUs comTensorFlow e Horovod (p. 61)

O tutorial TensorFlow comHorovod foi atualizado paraadicionar um exemplo detreinamento de vários nós.

November 28, 2018

Elastic Inference (p. 19) Pré-requisitos de inferênciaelástica e informaçõesrelacionadas à inferênciaforam adicionadas ao guia deconfiguração.

November 28, 2018

MMS v1.0 liberado noDLAMI. (p. 112)

O tutorial do MMS foi atualizadopara usar o novo formato dearquivo de modelo (.mar) edemonstra os novos recursos deiniciar e interromper.

November 15, 2018

Instalar o TensorFlow a partir deuma compilação noturna (p. 42)

Um tutorial que abrangecomo você pode desinstalar

October 16, 2018

133


o TensorFlow e, em seguida,instalar uma compilação noturnado TensorFlow no seu DeepLearning AMI com Conda.

Instalar o MXNet a partir de umacompilação noturna (p. 34)

Um tutorial que abrange comovocê pode desinstalar o MXNetfoi adicionado e, em seguida,instalar uma compilação noturnado MXNet no seu Deep LearningAMI com Conda.

October 16, 2018

Instalar o CTNK a partir de umacompilação noturna (p. 37)

Um tutorial que abrange comovocê pode desinstalar o CNTKfoi adicionado e, em seguida,instale uma compilação noturnado CNTK no seu Deep LearningAMI com Conda.

October 16, 2018

Instalar o PyTorch a partir deuma compilação noturna (p. 40)

Um tutorial que abrange comovocê pode desinstalar o PyTorchfoi adicionado e, em seguida,instale uma compilação noturnado PyTorch no seu DeepLearning AMI com Conda.

September 25, 2018

Docker já está pré-instalado noseu DLAMI. (p. 126)

Desde v14 do Deep LearningAMI com Conda, o Docker e aversão do Docker para GPUs daNVIDIA foram pré-instaladas.

September 25, 2018

Tutorial do MXBoard (p. 48) Foi adicionado um tutorial sobrecomo usar o MXBoard para veros modelos MXNet.

July 23, 2018

Tutorial do Chainer (p. 52) O tutorial foi atualizado para usaros exemplos mais recentes dafonte Chainer.

July 23, 2018

Tutorial TensorBoard (p. 50) Exemplo foi movido para ~ /exemplos/tensorboard. Caminhosde tutorial atualizados.

July 23, 2018

Tutorial Conda (p. 28) O exemplo MOTD foi atualizadapara refletir uma versão maisrecente.

July 23, 2018

Tutoriais de treinamentodistribuído (p. 51)

Um tutorial sobre como usarKeras-MXNet para treinamentode várias GPUs foi adicionado. Otutorial de Chainer foi atualizadopara v4.2.0.

July 23, 2018

Atualizações anteriores:

A tabela a seguir descreve as alterações importantes em cada versão do AWS Deep Learning AMI antesde julho de 2018.

134


Alterar Descrição Data

TensorFlow com Horovod Adicionado um tutorial paratreinamento do ImageNet comTensorFlow e Horovod.

6 de junho de 2018

Guia de atualização Adicionado o guia de atualização. 15 de maio de 2018

Novas regiões e novo tutorial de10 minutos

Novas regiões adicionadas:Oeste dos EUA (Norte daCalifórnia), América do Sul,Canadá (Central), UE (Londres)e UE (Paris). Além disso, oprimeiro lançamento de umtutorial de 10 minutos chamado:"Conceitos básicos da DeepLearning AMI".

26 de abril de 2018

Tutorial do Chainer Um tutorial para usar o Chainernos modos várias GPUs, umaúnica GPU e CPU foi adicionado.A integração do CUDA foiatualizada do CUDA 8 para oCUDA 9 para várias estruturas.

28 de fevereiro de 2018

AMIs do Linux v3.0, além daapresentação do MXNet ModelServer, TensorFlow Serving eTensorBoard

Tutoriais para AMIs do Condacom novos recursos defornecimento e visualizaçãode modelos usando MXNetModel Server v0.1.5, TensorFlowServing v1.4.0 e TensorBoardv0.4.0. Funcionalidades de AMIe CUDA de estrutura descritasnas visões gerais de Conda eCUDA. Notas de release maisrecentes movidas para https://aws.amazon.com/releasenotes/

25 de janeiro de 2018

AMIs do Linux v2.0 Base, Fonte e AMIs de Condaatualizados com NCCL 2.1.Fonte e AMIs de Condaatualizados com MXNet v1.0,PyTorch 0.3.0 e Keras 2.0.9.

11 de dezembro de 2017

Duas opções de AMI doWindows adicionadas

AMIs do Windows 2012 R2 e2016 lançadas: adicionadasao guia de seleção de AMI eadicionadas às notas de release.

30 de novembro de 2017

Versão da documentação inicial Descrição detalhada da alteraçãocom o link para o tópico ou aseção que sofreu a alteração.

15 de novembro de 2017

135

https://aws.amazon.com/releasenotes/

https://aws.amazon.com/releasenotes/


AWS GlossaryFor the latest AWS terminology, see the AWS Glossary in the AWS General Reference.

136

https://docs.aws.amazon.com/general/latest/gr/glos-chap.html

deep learning ami › pt_br › dlami › latest › devguide › ... · 2020-06-10 · deep...

Documents