AWS Documentation - Deep Learning AMI€¦ · usuarios que no están familiarizados con el aprendizaje automático y el aprendizaje profundo. Desarrollo de aplicaciones: si es un

Deep Learning AMIGuía para desarrolladores

Deep Learning AMI Guía para desarrolladores

Deep Learning AMI: Guía para desarrolladoresCopyright © 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 Contents¿Qué es la AWS Deep Learning AMI? .................................................................................................. 1

Acerca de esta guía ................................................................................................................... 1Requisitos previos ...................................................................................................................... 1Usos de ejemplo ........................................................................................................................ 1Características ........................................................................................................................... 2

Marcos de trabajo preinstalados ........................................................................................... 2Software de GPU preinstalado ............................................................................................. 3Compatibilidad con Elastic Inference ..................................................................................... 3Distribución y visualización de modelos ................................................................................. 3

Introducción ....................................................................................................................................... 4Primeros pasos con la DLAMI ...................................................................................................... 4Selección de DLAMI ................................................................................................................... 4

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

Opciones de AMI ........................................................................................................................ 8Conda ............................................................................................................................... 9Base ............................................................................................................................... 10CUDA 10.1 ...................................................................................................................... 10CUDA 10 ......................................................................................................................... 11CUDA 9 .......................................................................................................................... 11CUDA 8 .......................................................................................................................... 12Ubuntu 18.04 ................................................................................................................... 12Ubuntu 16.04 ................................................................................................................... 13Amazon Linux .................................................................................................................. 14Amazon Linux 2 ............................................................................................................... 15Windows .......................................................................................................................... 16

Selección de una instancia ......................................................................................................... 17GPU ............................................................................................................................... 18CPU ................................................................................................................................ 18Precios ............................................................................................................................ 19

Lanzamiento de una DLAMI ............................................................................................................... 20Paso 1: Lanzamiento de una DLAMI ........................................................................................... 20Consola de EC2 ....................................................................................................................... 21Búsqueda en Marketplace .......................................................................................................... 21Paso 2: Conexión a la DLAMI .................................................................................................... 22Paso 3: Protección de la instancia de DLAMI ................................................................................ 22Paso 4: Comprobación de la DLAMI ............................................................................................ 22Eliminación .............................................................................................................................. 22Configuración de Jupyter ........................................................................................................... 23

Protección de Jupyter ........................................................................................................ 23Inicio del servidor .............................................................................................................. 24Configuración del cliente .................................................................................................... 24Inicio de sesión en el servidor de cuadernos de Jupyter ......................................................... 25

Uso de una DLAMI ........................................................................................................................... 29DLAMI Conda .......................................................................................................................... 29

Introducción a la AMI de Deep Learning con Conda. .............................................................. 29Paso 1: Inicie sesión en la DLAMI ....................................................................................... 29Paso 2: Inicie el entorno de MXNet para Python 3 ................................................................. 31Paso 3: Pruebe el código de MXNet .................................................................................... 31Paso 4: Cambie al entorno de TensorFlow ........................................................................... 32Eliminación de entornos ..................................................................................................... 32

DLAMI base ............................................................................................................................. 33

iii


Uso de la Deep Learning Base AMI .................................................................................... 33Configuración de las versiones de CUDA ............................................................................. 33

Blocs de notas de Jupyter .......................................................................................................... 34Navegación por los tutoriales instalados ............................................................................... 34Cambio de entorno con Jupyter .......................................................................................... 34

Tutoriales ................................................................................................................................. 35Tutoriales de 10 minutos .................................................................................................... 35Activación de los marcos de trabajo .................................................................................... 35Depuración y visualización ................................................................................................. 49Entrenamiento distribuido ................................................................................................... 53Elastic Fabric Adapter ....................................................................................................... 70Monitorización y optimización de GPU ................................................................................. 78AWS Inferentia ................................................................................................................. 84Inferencia ....................................................................................................................... 102Uso de marcos de trabajo con ONNX ................................................................................ 106Distribución de modelos ................................................................................................... 114

Actualización de la DLAMI ................................................................................................................ 119Actualización de la DLAMI ........................................................................................................ 119Actualizaciones de software ...................................................................................................... 119

Seguridad ...................................................................................................................................... 121Protección de los datos ............................................................................................................ 121Identity and Access Management .............................................................................................. 122

Autenticación con identidades ........................................................................................... 122Administración de acceso mediante políticas ....................................................................... 124IAM por Amazon EMR ..................................................................................................... 126

Registro y monitorización ......................................................................................................... 126Validación de la conformidad .................................................................................................... 126Resiliencia .............................................................................................................................. 127Seguridad de la infraestructura .................................................................................................. 127

Información relacionada ................................................................................................................... 128Foros ..................................................................................................................................... 128Blogs ..................................................................................................................................... 128Preguntas frecuentes ............................................................................................................... 128

Notas de la versión de la DLAMI ....................................................................................................... 131Historial de revisión ......................................................................................................................... 132AWS glossary ................................................................................................................................. 135

iv

Deep Learning AMI Guía para desarrolladoresAcerca de esta guía

¿Qué es la AWS Deep LearningAMI?

Bienvenido a la Guía del usuario de la AWS Deep Learning AMI.

La AWS Deep Learning AMI (DLAMI) es lo único que necesita para el aprendizaje profundo en la nube.Esta instancia de máquina personalizada está disponible en la mayoría de las regiones de Amazon EC2para una amplia variedad de tipos de instancias, desde una pequeña instancia que solo tiene CPU hastalas instancias de gran potencia más recientes que disponen de varias GPU. Viene preconfigurada conNVIDIA CUDA y NVIDIA cuDNN, así como con las versiones más recientes de los marcos de trabajo deaprendizaje profundo más populares.

Acerca de esta guíaEsta guía le ayudará a lanzar y utilizar la DLAMI. Abarca varios casos de uso comunes para el aprendizajeprofundo, tanto para el entrenamiento como para la inferencia. También se explica cómo elegir la AMI másadecuada y el tipo de instancias que le pueden interesar. La DLAMI incluye varios tutoriales para cada unode los marcos de trabajo. También cuenta con tutoriales sobre entrenamiento distribuido, depuración, usode AWS Inferentia y otros conceptos clave. Encontrará instrucciones sobre cómo configurar Jupyter paraejecutar los tutoriales en el navegador.

Requisitos previosDebe estar familiarizado con las herramientas de línea de comandos y tener conocimientos básicos dePython para ejecutar correctamente la DLAMI. Los propios marcos de trabajo incluyen tutoriales sobresu utilización; sin embargo, esta guía puede mostrarle cómo activar cada uno de ellos y encontrar lostutoriales apropiados para empezar.

Usos de DLAMI de ejemploObtención de conocimientos sobre el aprendizaje profundo: la DLAMI es una gran elección para conocero enseñar el aprendizaje automático y los marcos de trabajo de aprendizaje profundo. Elimina losquebraderos de cabeza asociados a la solución de problemas de las instalaciones de los marcos detrabajo para conseguir que funcionen correctamente en el mismo equipo. La DLAMI incluye un bloc denotas de Jupyter y facilita la ejecución de los tutoriales proporcionados por los marcos de trabajo a losusuarios que no están familiarizados con el aprendizaje automático y el aprendizaje profundo.

Desarrollo de aplicaciones: si es un desarrollador de aplicaciones y está interesado en el uso delaprendizaje profundo para conseguir que sus aplicaciones utilicen los avances más recientes en IA, laDLAMI es el banco de pruebas perfecto. Cada marco de trabajo incluye tutoriales sobre cómo empezar autilizar el aprendizaje profundo, y muchos de ellos tienen colecciones de modelos que permiten probarlosin necesidad de crear redes neuronales ni de llevar a cabo el entrenamiento de modelos. Algunosejemplos le muestran cómo crear una aplicación de detección de imágenes en tan solo unos minutos, ocómo crear una aplicación de reconocimiento de voz para su propio chatbot.

Aprendizaje automático y análisis de datos: si es un científico de datos o está interesado en procesar datoscon el aprendizaje profundo, comprobará que muchos de los marcos de trabajo son compatibles con R y

1

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

https://developer.nvidia.com/cudnn

Deep Learning AMI Guía para desarrolladoresCaracterísticas

Spark. Encontrará tutoriales sobre cómo crear desde regresiones sencillas hasta sistemas escalables deprocesamiento de datos para sistemas de predicción y personalización.

Investigación: si es un investigador y desea probar un marco de trabajo o un nuevo modelo, o entrenarmodelos nuevos, las características de escalado de la DLAMI y AWS pueden aliviar la carga que suponenlas instalaciones tediosas y la administración de varios nodos de entrenamiento. Puede utilizar plantillas deEMR y AWS CloudFormation para lanzar con facilidad un clúster completo de instancias preparadas parael aprendizaje escalable.

Note

Aunque la elección inicial puede ser actualizar el tipo de instancia a una instancia más grandecon más GPU (hasta 8), también es posible escalar de forma horizontal creando un clústerde instancias de DLAMI. Puede utilizar la plantilla de AWS CloudFormation predefinida paraconfigurar rápidamente un clúster. Consulte Información relacionada (p. 128) para obtener másinformación sobre las compilaciones de clústeres.

Características de la DLAMIMarcos de trabajo preinstaladosActualmente, hay tres tipos principales de la DLAMI con otras variaciones relacionadas con el sistemaoperativo y las versiones de software:

• AMI de Deep Learning con Conda (p. 4): marcos de trabajo instalados por separado utilizandopaquetes conda y distintos entornos de Python

• Deep Learning Base AMI (p. 6): sin marcos de trabajo instalados; solo NVIDIA CUDA y otrasdependencias

La nueva AMI de Deep Learning con Conda utiliza entornos de Anaconda para aislar cada marco detrabajo, de forma que pueda alternar entre ellos cuando desee sin preocuparse por posibles conflictos consus dependencias.

Para obtener más información sobre cómo seleccionar las mejores DLAMI, consulteIntroducción (p. 4).

Esta es la lista completa de plataformas compatibles con AMI de Deep Learning con Conda:

• Apache MXNet• Caffe• Caffe2• Chainer• CNTK• Keras• PyTorch• TensorFlow• TensorFlow 2• Theano

Note

Ya no incluimos los entornos CNTK, Caffe, Caffe 2 y Theano Conda en la AWS Deep LearningAMI a partir de la versión v28. Las versiones anteriores de la AWS Deep Learning AMI que

2


Deep Learning AMI Guía para desarrolladoresSoftware de GPU preinstalado

contienen estos entornos seguirán estando disponibles. Sin embargo, solo proporcionaremosactualizaciones a estos entornos si la comunidad de código abierto publica correcciones deseguridad para estos marcos.

Software de GPU preinstaladoIncluso si utiliza una instancia que solo tiene CPU, la DLAMI tendrá NVIDIA CUDA y NVIDIA cuDNN.El software instalado es el mismo, independientemente del tipo de instancia. Tenga en cuenta que lasherramientas específicas de GPU solo funcionan en una instancia que tenga al menos una GPU. Puedeencontrar más información sobre este tema en la Selección del tipo de instancia para DLAMI (p. 17).

• Última versión de NVIDIA CUDA• Última versión de NVIDIA cuDNN• Las versiones anteriores de CUDA también están disponibles. Consulte Instalaciones de CUDA y

enlaces de marco de trabajo (p. 7) para obtener más información.

Compatibilidad con Elastic InferenceLa AMI de Deep Learning con Conda se suministra con entornos compatibles con Elastic Inference tantopara Opciones de Ubuntu 16.04 para AWS Deep Learning AMI (p. 13) como para Opciones de AmazonLinux para AWS Deep Learning AMI (p. 14). Los entornos de Elastic Inference no son compatiblesactualmente con Opciones de Ubuntu 18.04 para AWS Deep Learning AMI (p. 12) y Opciones deAmazon Linux 2 para AWS Deep Learning AMI (p. 15). Para ver tutoriales y obtener más informaciónsobre Elastic Inference, consulte la documentación de Elastic Inference.

Distribución y visualización de modelosAMI de Deep Learning con Conda viene preinstalado con dos tipos de servidores de modelos, uno paraMXNet y otro para TensorFlow, así como TensorBoard, para las visualizaciones de los modelos.

• Model Server for Apache MXNet (MMS) (p. 114)• TensorFlow Serving (p. 116)• TensorBoard (p. 51)

3





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

Deep Learning AMI Guía para desarrolladoresPrimeros pasos con la DLAMI

IntroducciónPrimeros pasos con la DLAMI

Ponerse en marcha es muy sencillo. Esta guía incluye consejos sobre cómo elegir la DLAMI másadecuada, seleccionar el tipo de instancia apropiada para su caso de uso y presupuesto, y Informaciónrelacionada (p. 128) que describen configuraciones personalizadas que pueden resultar interesantes.

Si es la primera vez que utiliza AWS o Amazon EC2, empiece con la AMI de Deep Learning conConda (p. 4). Si ya conoce Amazon EC2 y otros servicios de AWS como Amazon EMR, Amazon EFSo Amazon S3 y está interesado en integrar dichos servicios en proyectos que necesiten entrenamiento oinferencias distribuidas, consulte Información relacionada (p. 128) para ver si hay alguno que se adapte asu caso de uso.

Le recomendamos que consulte Elección de su DLAMI (p. 4) para que se haga una idea del tipo deinstancia que mejor se adapta a su aplicación.

Otra opción es este tutorial rápido: Lanzamiento de AWS Deep Learning AMI (en 10 minutos).

Paso siguiente

Elección de su DLAMI (p. 4)

Elección de su DLAMIEs posible que descubra que hay muchas opciones para su DLAMI y no tenga claro cuál es la másadecuada para su caso de uso. Esta sección le ayudará a tomar una decisión. Cuando nos referimos a unaDLAMI, a menudo se trata en realidad de un grupo de AMI centradas en torno a un tipo o una funcionalidadcomún. Existen tres variables que definen estos tipos y/o esta funcionalidad:

• Comparación de Conda y Base• CUDA 8 frente a CUDA 9 frente a CUDA 10• Amazon Linux frente a Ubuntu frente a Windows

En el resto de los temas de esta guía encontrará información más detallada.

Temas• AMI de Deep Learning con Conda (p. 4)• Deep Learning Base AMI (p. 6)• Instalaciones de CUDA y enlaces de marco de trabajo (p. 7)• Opciones de sistema operativo para DLAMI (p. 8)

Tema siguiente

AMI de Deep Learning con Conda (p. 4)

AMI de Deep Learning con CondaLa DLAMI utiliza entornos virtuales de Anaconda. Estos entornos están configurados para mantenerseparadas las instalaciones de los distintos marcos de trabajo. También facilita la tarea de cambiar entre

4

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

Deep Learning AMI Guía para desarrolladoresConda

marcos de trabajo. Esto resulta ideal para aprender y experimentar con todos los marcos de trabajo queofrece la DLAMI. La mayoría de los usuarios descubrirán que la nueva AMI de Deep Learning con Condaes perfecta para ellos.

Estas AMI "Conda" serán las DLAMI principales. Se actualizarán a menudo con las versiones másrecientes de los marcos de trabajo, y disponen del software y los controladores de GPU más recientes. Porlo general, se las denominará la AWS Deep Learning AMI en la mayoría de los documentos.

• La DLAMI de Ubuntu 18.04 tiene los siguientes marcos de trabajo: Apache MXNet, Chainer, PyTorch yTensorFlow y TensorFlow 2.

• La DLAMI de Ubuntu 16.04 y Amazon Linux tiene los siguientes marcos de trabajo: Apache MXNet,Caffe, Caffe2, Chainer, CNTK, Keras, PyTorch, TensorFlow, TensorFlow 2 y Theano.

• La DLAMI de Amazon Linux 2 tiene los siguientes marcos de trabajo: Apache MXNet, Chainer, PyTorch,TensorFlow, TensorFlow 2 y Keras.

Note

Ya no incluimos los entornos CNTK, Caffe, Caffe 2 y Theano Conda en la AWS Deep LearningAMI a partir de la versión v28. Las versiones anteriores de la AWS Deep Learning AMI quecontienen estos entornos seguirán estando disponibles. Sin embargo, solo proporcionaremosactualizaciones a estos entornos si la comunidad de código abierto publica correcciones deseguridad para estos marcos.

Comparación de Stable y Release CandidatesLas AMI de Conda utilizan archivos binarios optimizados para las versiones formales más recientesde cada marco de trabajo. No se esperan "release candidates" ni funciones experimentales. Lasoptimizaciones dependen de la compatibilidad del marco de trabajo para tecnologías de aceleración comoMKL DNN de Intel, que acelerarán el entrenamiento y la inferencia en los tipos de instancias de CPU C5 yC4. Los archivos binarios también se compilan para permitir conjuntos de instrucciones de Intel avanzados,incluidos, entre otros, AVX, AVX-2, SSE4.1 y SSE4.2. Estas instrucciones aceleran las operaciones convectores y puntos flotantes en las arquitecturas de CPU de Intel. Además, para los tipos de instancias deGPU, se actualizarán la CUDA y cuDNN con la versión que sea compatible con la última versión oficial.

La AMI de Deep Learning con Conda instala automáticamente la versión más optimizada del marcode trabajo para su instancia EC2 tras la primera activación del marco de trabajo. Para obtener másinformación, consulte Uso de la AMI de Deep Learning con Conda (p. 29).

Si desea instalar desde el código fuente mediante opciones de compilación personalizadas u optimizadas,la Deep Learning Base AMI (p. 6) podría ser una opción más adecuada para usted.

Retirada de Python 2La comunidad de código abierto de Python finalizó oficialmente la compatibilidad con Python 2 el1 de enero de 2020. Las comunidades de TensorFlow y PyTorch han anunciado que las versionesTensorFlow 2.1 y PyTorch 1.4 serán las últimas compatibles con Python 2. Las versiones anterioresde DLAMI (v26, v25, etc.) que contienen Python 2 Conda seguirán estando disponibles. Sin embargo,proporcionaremos actualizaciones a los entornos de Python 2 Conda para las versiones de DLAMIpublicadas anteriormente solo si la comunidad de código abierto ha publicado correcciones de seguridadpara esas versiones. Las versiones de DLAMI con las próximas versiones de los marcos TensorFlow yPyTorch no contendrán los entornos Python 2 Conda.

Compatibilidad con Elastic InferenceLa AMI de Deep Learning con Conda se suministra con entornos compatibles con Elastic Inference tantopara Opciones de Ubuntu 16.04 para AWS Deep Learning AMI (p. 13) como para Opciones de Amazon

5

Deep Learning AMI Guía para desarrolladoresBase

Linux para AWS Deep Learning AMI (p. 14). Los entornos de Elastic Inference no son compatiblesactualmente con Opciones de Ubuntu 18.04 para AWS Deep Learning AMI (p. 12) y Opciones deAmazon Linux 2 para AWS Deep Learning AMI (p. 15). Para ver tutoriales y obtener más informaciónsobre Elastic Inference, consulte la documentación de Elastic Inference.

Compatibilidad con CUDAVersión de CUDA de la AMI de Deep Learning con Conda y los marcos de trabajo compatibles con cadauna de ellas:

• CUDA 10.1 con CUDNN 7: Apache MXNet• CUDA 10 con CUDNN 7: PyTorch, TensorFlow, TensorFlow 2, Apache MXNet, Caffe2 y Chainer• CUDA 9 con CUDNN 7: CNTK, Keras y Theano• CUDA 8 con cuDNN 6: Caffe

Los números de versión del marco de trabajo específico se pueden encontrar en las Notas de la versión dela DLAMI (p. 131)

Elija este tipo de DLAMI u obtenga más información sobre las distintas DLAMI mediante la opción Temasiguiente.

• Opciones de AMI de Deep Learning con Conda (p. 9)

Tema siguiente

Deep Learning Base AMI (p. 6)

Temas relacionados• Para ver un tutorial sobre el uso de una AMI de Deep Learning con Conda consulte el tutorial Uso de la

AMI de Deep Learning con Conda (p. 29).

Deep Learning Base AMIDeep Learning Base AMI es como un lienzo vacío para el aprendizaje profundo. Incluye todo lo quese necesita hasta el momento de la instalación de un marco de trabajo determinado. Puede incluir lasversiones de CUDA que elija.

¿Por qué elegir la DLAMI Base?Este grupo de AMI es útil para los colaboradores de proyectos que desean adaptar un proyecto deaprendizaje profundo y compilar la versión más reciente. Está pensado para quienes desean actualizar supropio entorno con la confianza de que tienen instalado y en funcionamiento el software más reciente deNVIDIA, y desean centrarse en seleccionar los marcos de trabajo y las versiones que quieren instalar.


• Opciones de Deep Learning Base AMI (p. 10)

Tema siguiente

Instalaciones de CUDA y enlaces de marco de trabajo (p. 7)

6


Deep Learning AMI Guía para desarrolladoresCUDA

Temas relacionados• Uso de la Deep Learning Base AMI (p. 33)

Instalaciones de CUDA y enlaces de marco de trabajoEl aprendizaje profundo es algo bastante novedoso; sin embargo, todos los marcos de trabajo ofrecenversiones "estables". Es posible que estas versiones estables no funcionen con las implementaciones ycaracterísticas más recientes de CUDA o cuDNN. ¿Qué decisión tomar? Esto en última instancia dependede su caso de uso y de las características que necesite. Si no está seguro, utilice la versión con la AMIde Deep Learning con Conda más reciente. Tiene binarios pip oficiales de todos los marcos con CUDA8, CUDA 9, CUDA 10 y CUDA 10.1 que utilizan la versión más reciente compatible con cada marco. Sidesea obtener las versiones más recientes y personalizar su entorno de aprendizaje profundo, elija laDeep Learning Base AMI.

Eche un vistazo a nuestra guía sobre Comparación de Stable y Release Candidates (p. 5) paraobtener más información.

Elección de una DLAMI con CUDALa Deep Learning Base AMI (p. 6) incluye CUDA 8, 9, 10 y 10.1.

La AMI de Deep Learning con Conda (p. 4) incluye CUDA 8, 9, 10 y 10.1.

• CUDA 10.1 con CUDNN 7: Apache MXNet• CUDA 10 con CUDNN 7: PyTorch, TensorFlow, TensorFlow 2, Apache MXNet, Caffe2 y Chainer• CUDA 9 con CUDNN 7: CNTK, Keras y Theano• CUDA 8 con cuDNN 6: Caffe

Note


Para conocer las opciones de instalación para los distintos sistemas operativos y tipos de DLAMI, consultelas páginas de opciones cada versión de CUDA y :

• Opciones de AMI de Deep Learning con CUDA 10.1 (p. 10)• Opciones de AMI de Deep Learning con CUDA 10 (p. 11)• Opciones de AMI de Deep Learning con CUDA 9 (p. 11)• Opciones de AMI de Deep Learning con CUDA 8 (p. 12)• Opciones de AMI de Deep Learning con Conda (p. 9)• Opciones de Deep Learning Base AMI (p. 10)

Los números de versión del marco de trabajo específico se pueden encontrar en las Notas de la versión dela DLAMI (p. 131)


7

Deep Learning AMI Guía para desarrolladoresSO

Elija una de las versiones de CUDA y consulte en el Apéndice la lista completa de DLAMI que tengan esaversión, u obtenga más información sobre las distintas DLAMI en el tema indicado en la sección Temasiguiente.

Tema siguiente

Opciones de sistema operativo para DLAMI (p. 8)

Temas relacionados• Para obtener instrucciones sobre cómo cambiar de versión de CUDA, consulte el tutorial Uso de la Deep

Learning Base AMI (p. 33).

Opciones de sistema operativo para DLAMILas DLAMI se ofrecen en los sistemas operativos que se indican a continuación. Si está más familiarizadocon CentOS o RedHat, se sentirá más cómodo con Opciones de Amazon Linux para AWS Deep LearningAMI (p. 14) o con Opciones de Amazon Linux 2 para AWS Deep Learning AMI (p. 15). En casocontrario, puede que Opciones de Ubuntu 18.04 para AWS Deep Learning AMI (p. 12) o Opciones deUbuntu 16.04 para AWS Deep Learning AMI (p. 13) sean más de su gusto.

Si utiliza Windows como sistema operativo, dispone de un par de opciones que encontrará aquí: Opcionesde Windows para AWS Deep Learning AMI (p. 16).

Elija uno de los sistemas operativos y revise la lista completa en el Apéndice, o continúe con los pasossiguientes para elegir la AMI y el tipo de instancia.

• Opciones de Amazon Linux para AWS Deep Learning AMI (p. 14)• Opciones de Amazon Linux 2 para AWS Deep Learning AMI (p. 15)• Opciones de Ubuntu 18.04 para AWS Deep Learning AMI (p. 12)• Opciones de Ubuntu 16.04 para AWS Deep Learning AMI (p. 13)• Opciones de Windows para AWS Deep Learning AMI (p. 16)

Como se mencionó en la información general de introducción, dispone de algunas opciones para obteneracceso a la DLAMI, pero primero debe evaluar qué tipo de instancia necesita. También debería identificarla región de AWS que va a utilizar.

Tema siguiente

Selección del tipo de instancia para DLAMI (p. 17)

Opciones de AMILos siguientes temas describen los tipos de instancias de AWS Deep Learning AMI.

Temas• Opciones de AMI de Deep Learning con Conda (p. 9)• Opciones de Deep Learning Base AMI (p. 10)• Opciones de AMI de Deep Learning con CUDA 10.1 (p. 10)• Opciones de AMI de Deep Learning con CUDA 10 (p. 11)• Opciones de AMI de Deep Learning con CUDA 9 (p. 11)• Opciones de AMI de Deep Learning con CUDA 8 (p. 12)

8

Deep Learning AMI Guía para desarrolladoresConda

• Opciones de Ubuntu 18.04 para AWS Deep Learning AMI (p. 12)• Opciones de Ubuntu 16.04 para AWS Deep Learning AMI (p. 13)• Opciones de Amazon Linux para AWS Deep Learning AMI (p. 14)• Opciones de Amazon Linux 2 para AWS Deep Learning AMI (p. 15)• Opciones de Windows para AWS Deep Learning AMI (p. 16)

Opciones de AMI de Deep Learning con CondaUtilice la guía Lanzamiento y configuración de una DLAMI (p. 20) para continuar con una de estasDLAMI.

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

Estas DLAMI están disponibles en estas regiones:

Región Code

EE.UU. Este (Ohio) us-east-2

EE.UU. Este (Norte de Virginia) us-east-1

GovCloud us-gov-west-1

EE.UU. Oeste (Norte deCalifornia)

us-west-1

EE.UU. Oeste (Oregón) us-west-2

Pekín (China) cn-north-1

Ningxia (China) cn-northwest-1

Asia Pacífico (Mumbai) ap-south-1

Asia Pacífico (Seúl) ap-northeast-2

Asia Pacífico (Singapur) ap-southeast-1

Asia Pacífico (Sídney) ap-southeast-2

Asia Pacífico (Tokio) ap-northeast-1

Canadá (Central) ca-central-1

UE (Fráncfort) eu-central-1

UE (Irlanda) eu-west-1

UE (Londres) eu-west-2

UE (París) eu-west-3

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

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

Deep Learning AMI Guía para desarrolladoresBase

Opciones de Deep Learning Base AMIUtilice la guía Lanzamiento y configuración de una DLAMI (p. 20) para continuar con una de estasDLAMI.

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


Región Code





us-west-1















Opciones de AMI de Deep Learning con CUDA 10.1Utilice la guía Lanzamiento y configuración de una DLAMI (p. 20) para continuar con una de estasDLAMI.

• Deep Learning AMI (Ubuntu 18.04) en AWS Marketplace

10

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 Guía para desarrolladoresCUDA 10

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

Note

Las AMI de Deep Learning con Conda incluyen CUDA 8, CUDA 9, CUDA 10 y CUDA 10.1. Losmarcos de trabajo utilizarán la CUDA más reciente que admitan.Las Deep Learning Base AMI también incluyen CUDA 8, CUDA 9, CUDA 10 y CUDA 10.1. Paracambiar entre ellas, siga las instrucciones de Uso de la Deep Learning Base AMI (p. 33).

Opciones de AMI de Deep Learning con CUDA 10Utilice la guía Lanzamiento y configuración de una DLAMI (p. 20) para continuar con una de estasDLAMI.

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

Note

Las AMI de Deep Learning con Conda incluyen CUDA 8, CUDA 9 y CUDA 10. Los marcos detrabajo utilizarán la CUDA más reciente que admitan.Las Deep Learning Base AMI también incluyen CUDA 8, CUDA 9 y CUDA 10. Para cambiar entreellas, siga las instrucciones de Uso de la Deep Learning Base AMI (p. 33).


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

11























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

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

Deep Learning AMI Guía para desarrolladoresCUDA 8

Note



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

Note


Opciones de Ubuntu 18.04 para AWS Deep LearningAMIUtilice la guía Lanzamiento y configuración de una DLAMI (p. 20) para continuar con una de estasDLAMI. La AMI de Deep Learning con Conda no es compatible con Elastic Inference para Ubuntu 18.04.

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


Región Code





us-west-1

12












Deep Learning AMI Guía para desarrolladoresUbuntu 16.04

Región Code















Opciones de Ubuntu 16.04 para AWS Deep LearningAMIUtilice la guía Lanzamiento y configuración de una DLAMI (p. 20) para continuar con una de estasDLAMI. La AMI de Deep Learning con Conda se suministra con entornos compatibles con Elastic Inferencepara Ubuntu 16.04. Para ver tutoriales y obtener más información sobre Elastic Inference, consulte ladocumentación de Elastic Inference.

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


Región Code





us-west-1



13




Deep Learning AMI Guía para desarrolladoresAmazon Linux

Región Code













Opciones de Amazon Linux para AWS Deep LearningAMIUtilice la guía Lanzamiento y configuración de una DLAMI (p. 20) para continuar con una de estasDLAMI. La AMI de Deep Learning con Conda se suministra con entornos compatibles con Elastic Inferencepara Amazon Linux. Para ver tutoriales y obtener más información sobre Elastic Inference, consulte ladocumentación de Elastic Inference.

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


Región Code





us-west-1





14




Deep Learning AMI Guía para desarrolladoresAmazon Linux 2

Región Code











Opciones de Amazon Linux 2 para AWS DeepLearning AMIUtilice la guía Lanzamiento y configuración de una DLAMI (p. 20) para continuar con una de estasDLAMI. La AMI de Deep Learning con Conda no es compatible con Elastic Inference para Amazon Linux 2.

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


Región Code




us-west-1




Asia Pacífico (Osaka-local) ap-northeast-3





15



Deep Learning AMI Guía para desarrolladoresWindows

Región Code






Notas de la versión de Amazon Linux 2

Opciones de Windows para AWS Deep Learning AMIUtilice la guía Lanzamiento y configuración de una DLAMI (p. 20) para continuar con una de estasDLAMI.

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

Las DLAMI para Windows están disponibles en estas regiones:

Región Code





us-west-1













16

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



Deep Learning AMI Guía para desarrolladoresSelección de una instancia

Región Code


Selección del tipo de instancia para DLAMISeleccionar el tipo de instancia puede ser un reto, pero vamos a darle unos cuantos consejos para quele resulte más fácil elegir la mejor. Recuerde que la DLAMI es gratuita, pero no los recursos informáticossubyacentes.

• Si es la primera vez que utiliza el aprendizaje profundo, lo más probable es que desee una instancia “denivel básico” con una única GPU.

• Si tiene un presupuesto ajustado, tendrá que conformarse con las instancias que solo tienen CPU.• Si está interesado en ejecutar un modelo entrenado para realizar inferencias y predicciones (y no para el

entrenamiento), puede que le convenga ejecutar Amazon Elastic Inference. De este modo, dispondrá deacceso a una fracción de una GPU, por lo que puede escalar de una forma asequible. Para los serviciosde inferencia de gran volumen de datos, es posible que una instancia de CPU con una gran cantidad dememoria, o incluso un clúster de estas instancias, sea una solución más adecuada para usted.

• Si está utilizando un modelo de gran tamaño con muchos datos o un tamaño de lote elevado, necesitaráuna instancia más grande con más memoria. También puede distribuir su modelo a un clúster deGPU. El uso de una instancia con menos memoria puede ser una solución más adecuada parausted si disminuye el tamaño del lote. Sin embargo, puede afectar a la precisión y a la velocidad deentrenamiento.

• Si desea ejecutar aplicaciones de Machine Learning con la Biblioteca de comunicaciones colectivasde NVIDIA (NCCL) que requieran un alto nivel de comunicaciones entre nodos a escala, puede utilizarElastic Fabric Adapter (EFA).

Las DLAMI no están disponibles en todas las regiones, pero es posible copiar las DLAMI de una regióna otra. Consulte Copiar una AMI para obtener más información. Cada región admite tipos de instanciasdistintos y, a menudo, un tipo de instancia tiene un costo ligeramente distinto en diferentes regiones.En la página principal de cada DLAMI, verá una lista de precios de las instancias. Fíjese en la lista deselección de regiones y asegúrese de que elige una región que esté cerca de usted o de sus clientes. Sitiene previsto utilizar más de una DLAMI y posiblemente crear un clúster, asegúrese de utilizar la mismaregión para todos los nodos del clúster.

• Para obtener más información sobre las instancias, consulte Tipos de instancias EC2.• Para obtener más información sobre las regiones, visite Regiones de EC2.

Teniendo en cuenta todos estos datos, tome nota del tipo de instancia más adecuado para su caso de usoy su presupuesto. En el resto de los temas de esta guía encontrará información más detallada.

Important

Las AMI de Deep Learning incluyen controladores, software o conjuntos de herramientasdesarrollados, propiedad o facilitados por NVIDIA Corporation. Acepta utilizar estos controladoresNVIDIA, software o conjuntos de herramientas solo en instancias de Amazon EC2 que incluyanhardware de NVIDIA.

Temas• Instancias de GPU recomendadas (p. 18)• Instancias de CPU recomendadas (p. 18)• Precios de la DLAMI (p. 19)

17


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

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

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

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

Deep Learning AMI Guía para desarrolladoresGPU

Tema siguiente

Instancias de GPU recomendadas (p. 18)

Instancias de GPU recomendadasSe recomienda una instancia de GPU para la mayoría de los casos de uso de aprendizaje profundo.El entrenamiento de modelos nuevos será más rápido en una instancia de GPU que en una instanciade CPU. Puede escalar de forma sublineal cuando tenga varias instancias de GPU o si utiliza elentrenamiento distribuido en muchas instancias con GPU.

Note

El tamaño del modelo debe ser un factor a tener en cuenta para la selección de una instancia.Si su modelo supera la RAM disponible de una instancia, seleccione otro tipo de instancia conmemoria suficiente para la aplicación.

• Instancias P3 de Amazon EC2 tiene hasta 8 GPU V100 de NVIDIA Tesla.• Instancias P2 de Amazon EC2 tiene hasta 16 GPU NVIDIA NVIDIA K80.• Instancias G3 de Amazon EC2 tiene hasta 4 GPU NVIDIA Tesla M60.• Instancias G4 de Amazon EC2 tienen hasta 4 GPU NVIDIA T4.• Consulte Tipos de instancias EC2 y elija “Informática acelerada” para ver las distintas opciones de

instancias de GPU.

Tema siguiente

Instancias de CPU recomendadas (p. 18)

Instancias de CPU recomendadasDispone de muchas opciones asequibles en la categoría de CPU, tanto si cuenta con un presupuestoajustado, quiere aprender sobre el aprendizaje profundo o desea ejecutar una servicio de predicción.Algunos marcos de trabajo aprovechan los MKL DNN de Intel, que acelerarán el entrenamiento y lainferencia en los tipos de instancias de CPU C5 (no disponibles en todas las regiones), C3 y C4. Asimismo,acelerarán las inferencias en los tipos de instancias de GPU.

• Instancias C5 de Amazon EC2 tiene hasta 72 CPU virtuales Intel.• Las instancias C4 de Amazon EC2 tienen hasta 36 vCPU Intel.• Consulte Tipos de instancias EC2 y busque Compute Optimized (Optimizadas para computación) para

ver las distintas opciones de instancias de CPU.

Note

Las instancias C5 (no disponibles en todas las regiones) son idóneas para el modelado científico,el procesamiento por lotes, los análisis distribuidos, la informática de alto desempeño (HPC) y lainferencia de aprendizaje automático o aprendizaje profundo.Note

El tamaño del modelo debe ser un factor a tener en cuenta para la selección de una instancia.Si su modelo supera la RAM disponible de una instancia, seleccione otro tipo de instancia conmemoria suficiente para la aplicación.Important

Si tiene previsto utilizar Caffe, debería elegir una instancia de GPU en su lugar. En la DLAMI,Caffe solo funciona con la compatibilidad con GPU y no se puede ejecutar en modo de CPU.

18

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/


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


Deep Learning AMI Guía para desarrolladoresPrecios

Tema siguiente

Precios de la DLAMI (p. 19)

Precios de la DLAMILa DLAMI es gratuita, pero tendrá que afrontar los costos de Amazon EC2 u otros servicios de AWS. Losmarcos de trabajo de aprendizaje profundo incluidos son gratuitos, y cada uno tiene sus propias licenciasde código abierto. El software de GPU de NVIDIA es gratuito, y también tiene sus propias licencias.

¿Cómo es que es gratis, pero no es gratis? ¿Cuáles son los “costos de Amazon EC2 u otros servicios deAWS”?

Esta pregunta surge a menudo. Algunos tipos de instancias de Amazon EC2 se ofrecen de forma gratuita.Estas suelen ser las instancias más pequeñas, y es posible ejecutar la DLAMI en una de estas instanciasgratuitas. Esto significa que es totalmente gratis cuando solo se usa la capacidad de dicha instancia. Sidecide que desea una instancia más potente, con más núcleos de CPU, más espacio en disco, más RAMy una o varias GPU, lo más probable es que esta instancia no pertenezca a la capa gratuita. Esto significaque tendrá que pagar por los costos. Considere que el software sigue siendo gratis, pero que tiene quepagar por el hardware subyacente que está utilizando.

Consulte Selección del tipo de instancia para DLAMI (p. 17) para obtener más información sobre eltamaño de instancia que debe elegir y lo que puede esperar de cada tipo.

Paso siguiente

Lanzamiento y configuración de una DLAMI (p. 20)

19

Deep Learning AMI Guía para desarrolladoresPaso 1: Lanzamiento de una DLAMI

Lanzamiento y configuración de unaDLAMI

Si ha llegado hasta aquí, ya debería tener una buena idea de qué AMI desea lanzar. Si no es así, elijauna DLAMI mediante las directrices de selección de AMI de la sección Introducción (p. 4) o utilice la listacompleta de AMI del apéndice, Opciones de AMI (p. 8).

También debe saber el tipo de instancia y la región que va a elegir. En caso contrario, consulte Seleccióndel tipo de instancia para DLAMI (p. 17).

Note

Usaremos p2.xlarge como el tipo de instancia predeterminado en los ejemplos. Sustitúyalo por eltipo de instancia que tenga pensado.Important

Si tiene previsto utilizar Elastic Inference, debe completar la configuración de Elastic Inferenceantes de lanzar su DLAMI.

Temas• Paso 1: Lanzamiento de una DLAMI (p. 20)• Consola de EC2 (p. 21)• Búsqueda en Marketplace (p. 21)• Paso 2: Conexión a la DLAMI (p. 22)• Paso 3: Protección de la instancia de DLAMI (p. 22)• Paso 4: Comprobación de la DLAMI (p. 22)• Eliminación (p. 22)• Configuración de un servidor de cuadernos de Jupyter (p. 23)

Paso 1: Lanzamiento de una DLAMINote

En este tutorial, puede que hagamos referencias específicas a la Deep Learning AMI (Ubuntu16.04). Incluso si selecciona otra DLAMI, debería ser capaz de seguir esta guía.

Lanzamiento de la instancia

1. Dispone de un par de rutas para lanzar una DLAMI. Elija una:

• Consola de EC2 (p. 21)• Búsqueda en Marketplace (p. 21)

Tip

Opción de la CLI: si decide implementar una DLAMI mediante la CLI de AWS, necesitará elID de la AMI, la región y el tipo de instancia, y la información sobre el token de seguridad.Asegúrese de que tiene preparado el ID de la AMI y el de la instancia. Si todavía no haconfigurado la CLI de AWS, hágalo primero utilizando la guía de Instalación de la interfaz delínea de comandos de AWS.

20

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

Deep Learning AMI Guía para desarrolladoresConsola de EC2

2. Una vez que haya finalizado los pasos de una de estas opciones, espere a que la instancia esté lista.Este proceso suele tardar unos minutos. Puede comprobar el estado de la instancia en Consola deEC2.

Consola de EC2Note

Para iniciar una instancia con Elastic Fabric Adapter (EFA), siga estos pasos.

1. Abra Consola de EC2.2. Tome nota de la región actual en la parte superior del panel de navegación. Si no es la región de AWS

que desea, cambie esta opción antes de continuar. Para obtener más información, consulte Regionesde EC2.

3. Elija Launch Instance.4. Busque la instancia que desee por su nombre:

1. Elija AWS Marketplace o...2. Elija QuickStart. Aquí se muestra únicamente un subconjunto de las DLAMI disponibles.3. Busque Deep Learning AMI. Busque también por subtipo, como el sistema operativo que desee y

si quiere usar Base, Conda, Source, etc.4. Examine las opciones y haga clic en Select para la que desee.

5. Revise los detalles y, a continuación, elija Continue.6. Elija un tipo de instancia.

Note

Si desea utilizar Elastic Inference (EI), haga clic en Configure Instance Details (Configurardetalles de instancia), seleccione Add an Amazon EI accelerator (Añadir un acelerador deAmazon EI) y, a continuación, seleccione el tamaño del acelerador de Amazon EI.

7. Elija Review and Launch.8. Revise los detalles y los precios. Elija Launch.

Tip

Consulte Introducción al aprendizaje profundo con la AMI de AWS Deep Learning para ver untutorial con capturas de pantalla.

Paso siguiente

Paso 2: Conexión a la DLAMI (p. 22)

Búsqueda en Marketplace1. Examine AWS Marketplace y busque AWS Deep Learning AMI.2. Examine las opciones y haga clic en Select para la que desee.3. Revise los detalles y, a continuación, elija Continue.4. Revise los detalles y tome nota de la Región. Si no es la región de AWS que desea, cambie esta

opción antes de continuar. Para obtener más información, consulte Regiones de EC2.5. Elija un tipo de instancia.6. Elija un par de claves, utilice la predeterminada o cree una nueva.7. Revise los detalles y los precios.

21

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


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 Guía para desarrolladoresPaso 2: Conexión a la DLAMI

8. Elija Launch with 1-Click.

Paso siguiente

Paso 2: Conexión a la DLAMI (p. 22)

Paso 2: Conexión a la DLAMIConéctese a la DLAMI que ha lanzado desde un cliente (Windows, MacOS o Linux). Para obtener másinformación, consulte Conexión con la instancia de Linux en la Guía del usuario de Amazon EC2 parainstancias de Linux.

Tenga a mano una copia del comando de inicio de sesión de SSH si desea realizar la configuración deJupyter tras iniciar sesión. Utilizará una variante del comando para conectarse a la página web de Jupyter.

Paso siguiente

Paso 3: Protección de la instancia de DLAMI (p. 22)

Paso 3: Protección de la instancia de DLAMIMantenga siempre actualizado su sistema operativo y otro software instalado y aplique los parches yactualizaciones en cuanto estén disponibles.

Si utiliza Amazon Linux o Ubuntu, cuando inicie sesión en su DLAMI, se le notificará cuando hayaactualizaciones disponibles y verá las instrucciones de actualización. Para obtener más información sobreel mantenimiento de Amazon Linux, consulte Actualización del software de instancia. Para las instanciasde Ubuntu, consulte la documentación oficial de Ubuntu.

En Windows, compruebe Windows Update con regularidad para ver si hay actualizaciones de seguridad yde software. Si lo prefiere, aplique las actualizaciones automáticamente.

Important

Para obtener información sobre las vulnerabilidades de Meltdown y Spectre y cómo aplicarparches a su sistema operativo para abordarlas, consulte Security Bulletin AWS-2018-013.

Paso 4: Comprobación de la DLAMIEn función de la versión de la DLAMI, dispone de diferentes opciones de prueba:

• AMI de Deep Learning con Conda (p. 4) – vaya a Uso de la AMI de Deep Learning con Conda (p. 29).• Deep Learning Base AMI (p. 6) – consulte la documentación de instalación del marco de trabajo que

desee.

También puede crear un bloc de notas de Jupyter, probar los tutoriales o comenzar a escribir códigoen Python. Para obtener más información, consulte Configuración de un servidor de cuadernos deJupyter (p. 23).

EliminaciónCuando no necesite la DLAMI, puede detenerla o terminarla para evitar gastos. Si se detiene una instancia,se conservará para que pueda reanudarla más adelante. Las configuraciones, los archivos y demás

22

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 Guía para desarrolladoresConfiguración de Jupyter

información no volátil se almacenan en un volumen en Amazon S3. Se le cobrará una pequeña cuota deS3 por conservar el volumen mientras la instancia esté detenida, pero no se le cobrará por los recursosinformáticos mientras se encuentre en ese estado. Cuando inicie la instancia de nuevo, se montará esevolumen y sus datos estarán disponibles. Si termina una instancia, se borrará y no podrá volver a iniciarla.En realidad, los datos todavía se encuentran en S3, por lo que, para evitar nuevos cargos, debe eliminartambién el volumen. Para obtener instrucciones adicionales, consulte Terminar una instancia en Guía delusuario de Amazon EC2 para instancias de Linux.

Configuración de un servidor de cuadernos deJupyter

Jupyter Notebook es una aplicación web que le permite administrar documentos de cuadernos medianteun navegador web.

Para configurar un cuaderno de Jupyter:

• Configure el servidor de cuadernos de Jupyter en la instancia Amazon EC2.• Configure el cliente para poder conectarse al servidor de cuadernos de Jupyter. Dispone de

instrucciones de configuración para clientes Windows, macOS y Linux.• Pruebe la configuración iniciando sesión en el servidor de cuadernos de Jupyter.

Para obtener más información sobre los cuadernos de Jupyter, consulte Jupyter.

Temas• Protección del servidor de Jupyter (p. 23)• Inicio del servidor de cuadernos de Jupyter (p. 24)• Configuración del cliente para conectarse con el servidor de Jupyter (p. 24)• Prueba de la conexión iniciando sesión en el servidor de cuadernos de Jupyter (p. 25)

Protección del servidor de JupyterAquí configuraremos Jupyter con SSL y una contraseña personalizada.

Conéctese a la instancia Amazon EC2 y, a continuación, realice el siguiente procedimiento.

Configuración del servidor de Jupyter

1. Jupyter proporciona una utilidad de contraseñas. Ejecute el siguiente comando y escriba la contraseñaque desee en el símbolo del sistema.

$ jupyter notebook password

El resultado tendrá un aspecto similar a este:

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

2. Cree un certificado SSL autofirmado. Siga las instrucciones para especificar la configuración regionalmás adecuada para sus necesidades. Sus respuestas no afectarán a la funcionalidad del certificado.

23

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

http://jupyter.org/

Deep Learning AMI Guía para desarrolladoresInicio del servidor

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

Note

Tal vez le convenga crear un certificado normal que esté firmado por un tercero y que no hagaque el navegador muestre una advertencia de seguridad. Este proceso es mucho más complejo.Consulte la documentación de Jupyter para obtener más información.

Paso siguiente

Inicio del servidor de cuadernos de Jupyter (p. 24)

Inicio del servidor de cuadernos de JupyterAhora puede iniciar el servidor de Jupyter iniciando sesión en la instancia y ejecutando el siguientecomando que utiliza el certificado SSL que ha creado en el paso anterior.

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

Con el servidor iniciado, puede conectarse a él desde el equipo cliente través de un túnel SSH. Cuando seejecute el servidor, verá un resultado de Jupyter que confirma que el servidor está en ejecución. En estepunto, no tenga en cuenta el aviso de que puede obtener acceso al servidor a través de una dirección URLde localhost, ya que eso no funcionará hasta que cree el túnel.

Note

Jupyter se encargará de cambiar de entorno por usted cuando cambie de plataforma con lainterfaz web de Jupyter. Puede encontrar más información al respecto en Cambio de entorno conJupyter (p. 34).

Paso siguiente

Configuración del cliente para conectarse con el servidor de Jupyter (p. 24)

Configuración del cliente para conectarse con elservidor de JupyterDespués de configurar el cliente para que se conecte con el servidor de cuadernos de Jupyter, puede crearcuadernos en el servidor y obtener acceso a ellos desde su espacio de trabajo, así como ejecutar códigode aprendizaje profundo en el servidor.

Para obtener información sobre la configuración, elija uno de los siguientes enlaces.

Temas• Configuración de un cliente Windows (p. 24)• Configurar un cliente Linux o macOS (p. 25)

Configuración de un cliente WindowsPreparativosAsegúrese de tener la siguiente información, ya que la necesitará para configurar el túnel de SSH:

24

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

Deep Learning AMI Guía para desarrolladoresInicio de sesión en el servidor de cuadernos de Jupyter

• El nombre DNS público de la instancia Amazon EC2. Puede encontrar el nombre DNS público en laconsola de EC2.

• El par de claves del archivo de clave privada. Para obtener más información sobre el acceso al parde claves, consulte Pares de claves de Amazon EC2 en la Guía del usuario de Amazon EC2 parainstancias de Linux.

Uso de cuadernos de Jupyter desde un cliente Windows

Consulte estas guías sobre cómo conectarse a la instancia Amazon EC2 desde un cliente de Windows.

1. Solucionar el problema de conectar la instancia2. Conexión a la instancia Linux desde Windows utilizando PuTTY

Para crear un túnel con un servidor de Jupyter en ejecución, el enfoque recomendado es instalar Git Bashen su cliente Windows y seguir después las instrucciones del cliente Linux/macOS. Sin embargo, puedeutilizar el enfoque que desee para abrir un túnel SSH con mapeo de puertos. Consulte la documentaciónde Jupyter para obtener más información.

Paso siguiente

Configurar un cliente Linux o macOS (p. 25)

Configurar un cliente Linux o macOS1. Abra un terminal.2. Ejecute el siguiente comando para reenviar todas las solicitudes del puerto local 8888 al puerto 8888

de la instancia remota Amazon EC2. Actualice el comando sustituyendo la ubicación de la clave paraobtener acceso a la instancia Amazon EC2 y al nombre DNS público de la instancia Amazon EC2.Tenga en cuenta que para una AMI de Amazon Linux el nombre de usuario es ec2-user en lugar deubuntu.

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

Este comando abre un túnel entre el cliente y la instancia remota Amazon EC2 que está ejecutando elservidor de cuadernos de Jupyter.

Paso siguiente

Prueba de la conexión iniciando sesión en el servidor de cuadernos de Jupyter (p. 25)

Prueba de la conexión iniciando sesión en el servidorde cuadernos de JupyterAhora ya puede iniciar sesión en el servidor de cuadernos de Jupyter.

El siguiente paso consiste en probar la conexión con el servidor a través del navegador.

1. Escriba la siguiente dirección URL en la barra de direcciones del navegador o haga clic en esteenlace: https://localhost:8888

2. Con un certificado SSL autofirmado, el navegador emitirá un aviso y le recomendará que abandone elsitio web.

25

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://jupyter-notebook.readthedocs.io/en/stable/public_server.html

https://localhost:8888


Como lo ha configurado usted, puede continuar sin problema. Dependiendo del navegador, apareceun botón "avanzadas", "mostrar detalles" o similar.

26


27


Haga clic en este botón y, a continuación, haga clic en el enlace "ir a localhost". Si la conexión serealiza correctamente, aparecerá la página web del servidor de cuadernos de Jupyter. En estemomento, se le pedirá la contraseña que configuró anteriormente.

Ahora ya dispone de acceso al servidor de cuadernos de Jupyter que se ejecuta en la DLAMI. Puedecrear cuadernos nuevos o ejecutar los Tutoriales (p. 35) proporcionados.

28

Deep Learning AMI Guía para desarrolladoresDLAMI Conda

Uso de una DLAMITemas

• Uso de la AMI de Deep Learning con Conda (p. 29)• Uso de la Deep Learning Base AMI (p. 33)• Ejecución de los tutoriales del bloc de notas de Jupyter (p. 34)• Tutoriales (p. 35)

En las secciones siguientes se describe cómo se puede utilizar la AMI de Deep Learning con Conda paracambiar de entorno y ejecutar código de muestra desde cada uno de los marcos de trabajo y ejecutarJupyter para poder probar distintos tutoriales de bloc de notas.

Uso de la AMI de Deep Learning con CondaTemas

• Introducción a la AMI de Deep Learning con Conda. (p. 29)• Paso 1: Inicie sesión en la DLAMI (p. 29)• Paso 2: Inicie el entorno de MXNet para Python 3 (p. 31)• Paso 3: Pruebe el código de MXNet (p. 31)• Paso 4: Cambie al entorno de TensorFlow (p. 32)• Eliminación de entornos (p. 32)

Introducción a la AMI de Deep Learning con Conda.Conda es un sistema de código abierto para la administración de paquetes y del entorno que se ejecuta enWindows, macOS y Linux. Conda instala, ejecuta y actualiza rápidamente paquetes y sus dependencias.Conda le permite crear, guardar y cargar entornos en el equipo local, así como alternar entre ellos, consuma facilidad.

La AMI de Deep Learning con Conda se ha configurado de forma que se pueda alternar fácilmenteentre los entornos de aprendizaje profundo. Las siguientes instrucciones le orientan acerca de algunoscomandos básicos con conda. También le ayudan a verificar que la importación básica del marcode trabajo funciona correctamente, y que puede ejecutar un par de operaciones sencillas con este. Acontinuación, puede pasar a tutoriales más exhaustivos incluidos con la DLAMI o a los ejemplos de marcosde trabajo que puede encontrar en el sitio del proyecto de cada uno de los marcos de trabajo.

Paso 1: Inicie sesión en la DLAMIDespués de iniciar sesión en el servidor, verá un “mensaje del día” (MOTD) del servidor que describevarios comandos de Conda que puede utilizar para alternar entre los distintos marcos de trabajo deaprendizaje profundo. A continuación se muestra un MOTD de ejemplo. Su MOTD específico puede variara medida que se publican nuevas versiones de la DLAMI.

29

Deep Learning AMI Guía para desarrolladoresPaso 1: Inicie sesión en la DLAMI

Note


============================================================================= __| __|_ ) _| ( / 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 Theano(+Keras2) with Python3 (CUDA 9.0) _____________________________________________________ source activate theano_p36for Theano(+Keras2) with Python2 (CUDA 9.0) _____________________________________________________ source activate theano_p27for 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 CNTK(+Keras2) with Python3 (CUDA 9.0 and Intel MKL-DNN) _______________________________________ source activate cntk_p36for CNTK(+Keras2) with Python2 (CUDA 9.0 and Intel MKL-DNN) _______________________________________ source activate cntk_p27for Caffe2 with Python2 (CUDA 9.0) ______________________________________________________________ source activate caffe2_p27for Caffe with Python2 (CUDA 8.0) ________________________________________________________________ source activate caffe_p27for Caffe with Python3 (CUDA 8.0) ________________________________________________________________ source activate caffe_p35for 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_p36

30

Deep Learning AMI Guía para desarrolladoresPaso 2: Inicie el entorno de MXNet para Python 3

for base Python2 (CUDA 10.0) _______________________________________________________________________ source activate python2for base Python3 (CUDA 10.0) _______________________________________________________________________ source activate python3

Cada uno de los comandos de Conda tiene el siguiente formato:

source activate framework_python-version

Por ejemplo, es posible que vea for MXNet(+Keras1) with Python3 (CUDA 9)_____________________ source activate mxnet_p36, lo que significa que el entorno tieneMXNet, Keras 1, Python 3 y CUDA 9. Para activar este entorno, el comando que utilizaría es:

$ source activate mxnet_p36

La otra variación de esto sería:


Esto significa que el entorno tendrá MXNet y Python 2 (con Keras 1 y CUDA 9).

Paso 2: Inicie el entorno de MXNet para Python 3Probaremos primero MXNet para darle una idea general de lo fácil que es.

Note

Cuando lance su primer entorno Conda, tenga paciencia mientras se carga. La AMI de DeepLearning con Conda instala automáticamente la versión más optimizada del marco de trabajopara su instancia EC2 tras la primera activación del marco de trabajo. No debe esperar retrasosposteriores.

• Active el entorno virtual de MXNet para Python 3.


Esto activa el entorno para MXNet con Python 3. También podría haber activado mxnet_p27 para obtenerun entorno con Python 2.

Paso 3: Pruebe el código de MXNetPara probar la instalación, utilice Python para escribir código de MXNet que cree e imprima una matrizmediante la API de NDArray. Para obtener más información, consulte NDArray API.

1. Inicie el terminal de iPython.

(mxnet_p36)$ ipython

2. Importe MXNet.

import mxnet as mx

31

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

Deep Learning AMI Guía para desarrolladoresPaso 4: Cambie al entorno de TensorFlow

Es posible que vea un mensaje de advertencia sobre un paquete de terceros. Puede omitirla.3. Cree una matriz de 5x5, una instancia de la clase NDArray, con los elementos inicializados a 0.

Imprima la matriz.

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

Verifique el 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)

Puede encontrar más ejemplos de MXNet en la sección de tutoriales de MXNet.

Paso 4: Cambie al entorno de TensorFlowAhora cambiaremos a TensorFlow. Si sigue en la consola de iPython, utilice quit() y prepárese paracambiar de entorno.

1. Active el entorno virtual de TensorFlow para Python 3.

$ source activate tensorflow_p36


(tensorflow_36)$ ipython

3. Ejecute un programa rápido en TensorFlow.

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

Debería aparecer "Hello, Tensorflow!" Ahora ya ha probado dos marcos de trabajo de aprendizaje profundodistintos y ha aprendido a alternar entre ellos.

Tema siguiente

Ejecución de los tutoriales del bloc de notas de Jupyter (p. 34)

Eliminación de entornosNota: si se queda sin espacio en la DLAMI, puede desinstalar los paquetes de Conda que no utilice:

conda env listconda env remove –-name <env_name>

32

Deep Learning AMI Guía para desarrolladoresDLAMI base

Uso de la Deep Learning Base AMIUso de la Deep Learning Base AMILa AMI base incluye una plataforma básica de controladores de GPU y bibliotecas de aceleración que lepermiten implementar su propio entorno de aprendizaje profundo personalizado. De forma predeterminada,la AMI está configurada con el entorno NVIDIA CUDA 10. Sin embargo, también puede cambiar a unentorno CUDA 9 o CUDA 8. Consulte las siguientes instrucciones para saber cómo hacerlo.

Configuración de las versiones de CUDAPuede seleccionar y verificar una versión determinada de CUDA con los siguientes comandos bash.

• CUDA 10.2:

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

• CUDA 10.1:


• CUDA 10:


• CUDA 9.2:


• CUDA 9:


• CUDA 8:


Tip

A continuación, puede verificar la versión de CUDA ejecutando el programa deviceQuery deNVIDIA.

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

33

Deep Learning AMI Guía para desarrolladoresBlocs de notas de Jupyter

Ejecución de los tutoriales del bloc de notas deJupyter

Con el código fuente de cada uno de los proyectos de aprendizaje profundo se incluyen tutoriales yejemplos que, en la mayoría de los casos, se ejecutarán en cualquier DLAMI. Si eligió la AMI de DeepLearning con Conda (p. 4), obtendrá la ventaja añadida de unos tutoriales seleccionados específicamente,preconfigurados y listos para probarlos.

Important

Para ejecutar los tutoriales del bloc de notas de Jupyter instalados en la DLAMI, consulteConfiguración de un servidor de cuadernos de Jupyter (p. 23).

Cuando el servidor de Jupyter esté en funcionamiento, puede ejecutar los tutoriales a través de unnavegador web. Si está ejecutando la AMI de Deep Learning con Conda o si ha configurado entornosde Python, puede cambiar el kernel de Python desde la interfaz del bloc de notas de Jupyter. Seleccioneel kernel adecuado antes de ejecutar un tutorial específico para un marco de trabajo. Se proporcionarejemplos adicionales para los usuarios de la AMI de Deep Learning con Conda.

Note

Muchos tutoriales requieren módulos de Python adicionales que puede que no estén configuradosen su DLAMI. Si obtiene un error como "xyz module not found", inicie sesión en la DLAMI,active el entorno tal como se ha descrito anteriormente y, a continuación, instale los módulosnecesarios.Tip

Los tutoriales y los ejemplos de aprendizaje profundo suelen utilizar una o varias GPU. Si su tipode instancia no cuenta con una GPU, puede que necesite cambiar el código de algunos de losejemplos para que se ejecuten.

Navegación por los tutoriales instaladosUna vez que haya iniciado sesión en el servidor de Jupyter y tenga acceso al directorio de los tutoriales(solo en AMI de Deep Learning con Conda), verá carpetas de tutoriales para cada nombre de marco detrabajo. Si no ve un marco de trabajo en la lista, significa que no hay tutoriales para ese marco de trabajoen la DLAMI actual. Haga clic en el nombre del marco de trabajo para ver los tutoriales de la lista y, acontinuación, haga clic en un tutorial para lanzarlo.

La primera vez que ejecute un bloc de notas en la AMI de Deep Learning con Conda, deberá indicar elentorno que desea utilizar. Se le pedirá que lo seleccione en una lista. El nombre de cada entorno sigueeste patrón:

Environment (conda_framework_python-version)

Por ejemplo, es posible que vea Environment (conda_mxnet_p36), lo que significa que el entornotiene MXNet y Python 3. Otra variante sería Environment (conda_mxnet_p27), que significa que elentorno tiene MXNet y Python 2.

Tip

Si desea saber qué versión de CUDA está activa, puede verla en el “mensaje del día” (MOTD)que aparece la primera vez que se inicia sesión en la DLAMI.

Cambio de entorno con JupyterSi decide probar un tutorial para otro marco de trabajo, asegúrese de comprobar cuál es el kernel quese está ejecutando actualmente. Esta información se puede ver en la esquina superior derecha de la

34

Deep Learning AMI Guía para desarrolladoresTutoriales

interfaz de Jupyter, justo debajo del botón de cerrar sesión. Puede cambiar el kernel en cualquier blocde notas abierto haciendo clic en la opción Kernel del menú de Jupyter, seguido de Change Kernel y, acontinuación, haciendo clic en el entorno correspondiente al bloc de notas que esté ejecutando.

En este punto, tendrá que volver a ejecutar todas las celdas, debido a que un cambio en el kernel borraráel estado de cualquier elemento que se haya ejecutado anteriormente.

Tip

Cambiar de marco de trabajo puede ser divertido y educativo, pero puede hacer que se agotela memoria. Si comienzan a aparecer errores, examine la ventana de terminal en la que se estáejecutando el servidor de Jupyter. Contiene mensajes y registros de errores útiles, y es posibleque vea un error de memoria insuficiente. Para solucionar este problema, vaya a la página deinicio del servidor de Jupyter, haga clic en la pestaña Running y, a continuación, haga clic enShutdown para cada uno de los tutoriales que probablemente sigan ejecutándose en segundoplano y estén consumiendo toda la memoria.

Tema siguiente

Para obtener más ejemplos y código de muestra para cada marco de trabajo, haga clic en Next o continúeen Apache MXNet (p. 36).

TutorialesLos siguientes tutoriales muestran cómo utilizar el software de AMI de Deep Learning con Conda.

Temas• Tutoriales de 10 minutos (p. 35)• Activación de los marcos de trabajo (p. 35)• Depuración y visualización (p. 49)• Entrenamiento distribuido (p. 53)• Elastic Fabric Adapter (p. 70)• Monitorización y optimización de GPU (p. 78)• El chip de AWS Inferentia con DLAMI (p. 84)• Inferencia (p. 102)• Uso de marcos de trabajo con ONNX (p. 106)• Distribución de modelos (p. 114)

Tutoriales de 10 minutos• Lanzamiento de AWS Deep Learning AMI (en 10 minutos)• Entrenamiento de un modelo de aprendizaje profundo con AWS Deep Learning Containers en Amazon

EC2 (en 10 minutos)

Activación de los marcos de trabajoA continuación, se muestran los marcos de trabajo de aprendizaje profundo instalados en la AMI de DeepLearning con Conda. Haga clic en un marco de trabajo para obtener información acerca de cómo activarlo.

Temas

35


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 Guía para desarrolladoresActivación de los marcos de trabajo

• Apache MXNet (p. 36)• Caffe2 (p. 37)• Chainer (p. 38)• CNTK (p. 39)• Keras (p. 41)• PyTorch (p. 42)• TensorFlow (p. 43)• TensorFlow 2 (p. 45)• TensorFlow con Horovod (p. 47)• TensorFlow 2 con Horovod (p. 48)• Theano (p. 49)

Apache MXNetActivación de MXNet

En este tutorial, se muestra cómo activar MXNet en una instancia que ejecuta la AMI de Deep Learningcon Conda (DLAMI en Conda) y ejecutar un programa de MXNet.

Cuando se lanza un paquete Conda estable de un marco de trabajo, se prueba y preinstala en la DLAMI.Si desea ejecutar la última compilación nocturna sin probar, puede Instalación de una compilación nocturnade MXNet (experimental) (p. 37) manualmente.

Para ejecutar MXNet en la DLAMI con Conda

1. Para activar el marco de trabajo, abra una instancia Amazon Elastic Compute Cloud (Amazon EC2) dela DLAMI con Conda.• Para MXNet y Keras 2 en Python 3 con CUDA 9.0 y MKL-DNN, ejecute este comando:


• Para MXNet y Keras 2 en Python 2 con CUDA 9.0 y MKL-DNN, ejecute este comando:




3. Ejecute un programa rápido en MXNet. Cree una matriz de 5x5, una instancia de la clase NDArray,con los elementos inicializados a 0. Imprima la matriz.

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

4. Verifique el 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)

36


Instalación de una compilación nocturna de MXNet (experimental)

Puede instalar la última compilación de MXNet en uno o en ambos entornos MXNet Conda en su AMI deDeep Learning con Conda.

Para instalar MXNet desde una compilación nocturna

1. • Para el entorno de MXNet para Python 3, ejecute este comando:


• Para el entorno de MXNet para Python 2, ejecute este comando:


2. Elimine el entorno de MXNet instalado actualmente.

Note

En los pasos restantes se supone que está utilizando el entorno mxnet_p36.

(mxnet_p36)$ pip uninstall mxnet-cu90mkl

3. Instale la compilación nocturna más reciente de MXNet.

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

4. Para verificar que ha instalado correctamente la compilación nocturna más reciente, inicie el terminalde IPython y compruebe la versión de MXNet.


import mxnetprint (mxnet.__version__)

El resultado debería mostrar la última versión estable de MXNet.

Más tutoriales

Puede encontrar más tutoriales en la carpeta de tutoriales de la AMI de Deep Learning con Conda que seencuentra en el directorio principal de la DLAMI.

1. Uso de Apache MXNet para inferencia con un modelo de ResNet-50 (p. 103)2. Uso de Apache MXNet para inferencia con un modelo ONNX (p. 102)3. Model Server for Apache MXNet (MMS) (p. 114)

Si desea ver más tutoriales y ejemplos, consulte la documentación oficial de Python del marco de trabajo,la API de Python para MXNet o el sitio web de Apache MXNet.

Caffe2Note

Ya no incluimos los entornos CNTK, Caffe, Caffe 2 y Theano Conda en la AWS Deep LearningAMI a partir de la versión v28. Las versiones anteriores de la AWS Deep Learning AMI que

37

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

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


contienen estos entornos seguirán estando disponibles. Sin embargo, solo proporcionaremosactualizaciones a estos entornos si la comunidad de código abierto publica correcciones deseguridad para estos marcos.

Tutorial de Caffe2

Para activar el marco de trabajo, siga estas instrucciones en la AMI de Deep Learning con Conda.

Solo existe la opción de Python 2 con CUDA 9 con cuDNN 7:

$ source activate caffe2_p27

Inicie el terminal de iPython.

(caffe2_p27)$ ipython

Ejecute un programa Caffe2 rápido.

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)

Debería ver las matrices aleatorias iniciales de numpy impresas y a continuación, cargadas en un blob deCaffe2. Observe que después de la carga son las mismas.

Más tutoriales

Si desea ver más tutoriales y ejemplos, consulte la documentación oficial de Python del marco de trabajo,la API de Python para Caffe2 y el sitio web de Caffe2.

ChainerChainer es un marco de trabajo flexible basado en Python para escribir de forma sencilla e intuitivaarquitecturas de red neuronal complejas. Chainer facilita la utilización de instancias de varias GPU paraentrenamiento. Chainer además registra automáticamente los resultados, representa gráficamentepérdidas y precisión y produce una salida para visualizar la red neuronal con un grafo computacional. Seincluye con la AMI de Deep Learning con Conda (DLAMI con Conda).

Activar Chainer

1. Conéctese a la instancia que está ejecutando AMI de Deep Learning con Conda. Consulte la thesection called “Selección de una instancia” (p. 17) o la documentación de Amazon EC2 acerca decómo seleccionar una instancia o conectarse a una instancia.

2. • Active el entorno de Chainer de Python 3:

$ source activate chainer_p36

• Active el entorno de Chainer de Python 2:

38

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



3. Inicie el terminal de iPython:

(chainer_p36)$ ipython

4. Pruebe la importación de Chainer para comprobar que está funcionando correctamente:

import chainer

Es posible que vea algunos mensajes de advertencia, pero ningún error.

Más información

• Pruebe los tutoriales para Chainer (p. 53).• La carpeta de ejemplos de Chainer dentro del origen que ha descargado anteriormente contiene más

ejemplos. Pruébelos para comprobar su desempeño.• Para obtener más información sobre Chainer, consulte el sitio web de documentación de Chainer.

CNTKNote


Activación de CNTKEn este tutorial, se muestra cómo activar CNTK en una instancia que ejecuta la AMI de Deep Learning conConda (DLAMI en Conda) y ejecutar un programa de CNTK.

Cuando se lanza un paquete Conda estable de un marco de trabajo, se prueba y preinstala en la DLAMI.Si desea ejecutar la última compilación nocturna sin probar, puede Instalar una compilación nocturna deCNTK (experimental) (p. 40) manualmente.

Para ejecutar CNTK en la DLAMI con Conda

1. Para activar CNTK, abra una instancia Amazon Elastic Compute Cloud (Amazon EC2) de la DLAMIcon Conda.• Para Python 3 con CUDA 9 con cuDNN 7:

$ source activate cntk_p36

• Para Python 2 con CUDA 9 con cuDNN 7:



(cntk_p36)$ ipython

39

https://docs.chainer.org/


3. • Si tiene una instancia de CPU, ejecute este programa rápido de CNTK.

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

Debería ver la versión de CNTK y, a continuación, la salida de una matriz de treses de 2x3.• Si tiene una instancia de GPU, puede probarla con el siguiente ejemplo de código. Si CNTK

puede acceder a la GPU, el resultado debería ser True.

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

Instalar una compilación nocturna de CNTK (experimental)

Puede instalar la última compilación de CNTK en uno o en ambos entornos de CNTK Conda en la AMI deDeep Learning con Conda.

Para instalar CNTK desde una compilación nocturna

1. • Para CNTK y Keras 2 en Python 3 con CUDA 9.0 y MKL-DNN, ejecute este comando:


• Para CNTK y Keras 2 en Python 2 con CUDA 9.0 y MKL-DNN, ejecute este comando:


2. En los pasos restantes se supone que está utilizando el entorno cntk_p36. Elimine el entorno deCNTK instalado actualmente:

(cntk_p36)$ pip uninstall cntk

3. Para instalar la compilación nocturna de CNTK, primero debe encontrar la versión que desea instalaren el sitio web de compilaciones nocturnas de CNTK.

4. • (Opción para instancias de GPU): para instalar la compilación, usaría lo siguiente, sustituyendo lacompilación deseada:

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

Sustituya la URL del comando anterior por la versión de la GPU de su entorno de Python actual.• (Opción para instancias de CPU): para instalar la compilación, usaría lo siguiente, sustituyendo la

compilación deseada:

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

Sustituya la URL del comando anterior por la versión de la CPU de su entorno de Python actual.5. Para verificar que ha instalado correctamente la última compilación nocturna, inicie el terminal de

IPython y compruebe la versión de CNTK.

(cntk_p36)$ ipython

40

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


import cntkprint (cntk.__version__)

El resultado debería ser similar a 2.6-rc0.dev20181015

Más tutoriales

Si desea ver más tutoriales y ejemplos, consulte la documentación oficial de Python del marco de trabajo,la API de Python para CNTK o el sitio web de CNTK.

Keras

Tutorial de Keras

1. Para activar el marco de trabajo, utilice estos comandos en su interfaz de línea de comandos de thesection called “DLAMI Conda” (p. 29).• Para Keras 2 con un backend MXNet en Python 3 con CUDA 9 con cuDNN 7:


• Para Keras 2 con un backend MXNet en Python 2 con CUDA 9 con cuDNN 7:


• Para Keras 2 con un backend TensorFlow en Python 3 con CUDA 9 con cuDNN 7:


• Para Keras 2 con un backend TensorFlow en Python 2 con CUDA 9 con cuDNN 7:


2. Para probar la importación de Keras para verificar el backend que está activado, utilice estoscomandos:

$ ipythonimport keras as k

En la pantalla debería aparecer lo siguiente:

Using MXNet backend

Si Keras utiliza TensorFlow, se muestra lo siguiente:

Using TensorFlow backend

Note

Si recibe un error o si se sigue utilizando un backend incorrecto, puede actualizar suconfiguración de Keras manualmente. Edite el archivo ~/.keras/keras.json y cambie laconfiguración del backend a mxnet o tensorflow.

41

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

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


Más tutoriales

• Para ver un tutorial en modo de varias GPU con Keras con un backend MXNet, consulte Tutorial deentrenamiento en varias GPU de Keras-MXNet (p. 63).

• Puede encontrar ejemplos para Keras con un backend MXNet en el directorio ~/examples/keras-mxnet de la AMI de Deep Learning con Conda.

• Puede encontrar ejemplos para Keras con un backend TensorFlow en el directorio ~/examples/kerasde la AMI de Deep Learning con Conda.

• Para obtener más tutoriales y ejemplos, consulte el sitio web de Keras.

PyTorchActivación de PyTorchCuando se lanza un paquete Conda estable de un marco de trabajo, se prueba y preinstala en la DLAMI.Si desea ejecutar la última compilación nocturna sin probar, puede Instalación de una compilación nocturnade PyTorch (experimental) (p. 42) manualmente.

Para activar el marco de trabajo instalado actualmente, siga estas instrucciones en la AMI de DeepLearning con Conda.

Para PyTorch en Python 3 con CUDA 10 y MKL-DNN, ejecute este comando:

$ source activate pytorch_p36

Para PyTorch en Python 2 con CUDA 10 y MKL-DNN, ejecute este comando:



(pytorch_p36)$ ipython

Ejecute un programa rápido en PyTorch.

import torchx = torch.rand(5, 3)print(x)print(x.size())y = torch.rand(5, 3)print(torch.add(x, y))

Debería ver la matriz aleatoria inicial, a continuación su tamaño y, por último, la adición de otra matrizaleatoria.

Instalación de una compilación nocturna de PyTorch (experimental)

Cómo instalar PyTorch desde una compilación nocturna

Puede instalar la última compilación de PyTorch en uno o en ambos entornos Conda de PyTorch en suAMI de Deep Learning con Conda.

1. • (Opción para Python 3) - Active el entorno PyTorch de Python 3:


42

https://keras.io/


• (Opción para Python 2) - Active el entorno PyTorch de Python 2:


2. En los pasos restantes se supone que está utilizando el entorno pytorch_p36. Elimine el entorno dePyTorch instalado actualmente:

(pytorch_p36)$ pip uninstall torch

3. • (Opción para las instancias de GPU) - Instale la última compilación nocturna de PyTorch conCUDA 10.0:

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

• (Opción para las instancias de CPU) - Instale la última compilación nocturna de PyTorch para lasinstancias que no tienen ninguna GPU:

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

4. Para verificar que ha instalado correctamente la última compilación nocturna, inicie el terminal deIPython y compruebe la versión de PyTorch.

(pytorch_p36)$ ipython

import torchprint (torch.__version__)

El resultado debería ser similar a 1.0.0.dev201809225. Para verificar que la compilación nocturna de PyTorch funciona bien con el ejemplo de MNIST, puede

ejecutar un script de prueba del repositorio de ejemplos de PyTorch:

(pytorch_p36)$ cd ~(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

Más tutoriales

Puede encontrar más tutoriales en la carpeta de tutoriales de la AMI de Deep Learning con Conda en eldirectorio principal de la DLAMI. Si desea ver más tutoriales y ejemplos, consulte la documentación oficialdel marco de trabajo, la documentación de PyTorch y el sitio web de PyTorch.

• Tutorial de PyTorch a ONNX a MXNet (p. 112)• Tutorial de PyTorch a ONNX a CNTK (p. 111)

TensorFlowActivación de TensorFlow

En este tutorial se muestra cómo activar TensorFlow en una instancia que ejecuta la AMI de DeepLearning con Conda (DLAMI en Conda) y ejecutar un programa de TensorFlow.

43

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

http://pytorch.org


Cuando se lanza un paquete Conda estable de un marco de trabajo, se prueba y preinstala en la DLAMI.Si desea ejecutar la última compilación nocturna sin probar, puede Instalación de una compilación nocturnade TensorFlow (experimental) (p. 44) manualmente.

Para ejecutar TensorFlow en la DLAMI con Conda

1. Para activar TensorFlow, abra una instancia Amazon Elastic Compute Cloud (Amazon EC2) de laDLAMI con Conda.• Para TensorFlow y Keras 2 en Python 3 con CUDA 9.0 y MKL-DNN, ejecute este comando:


• Para TensorFlow y Keras 2 en Python 2 con CUDA 9.0 y MKL-DNN, ejecute este comando:



(tensorflow_p36)$ ipython

3. Ejecute un programa en TensorFlow para verificar que funciona correctamente:

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

Hello, TensorFlow! debe aparecer en la pantalla.

Instalación de una compilación nocturna de TensorFlow (experimental)

Puede instalar la última compilación de TensorFlow en uno o en ambos entornos TensorFlow Conda en suAMI de Deep Learning con Conda.

Para instalar TensorFlow desde una compilación nocturna

1. • Para el entorno de TensorFlow para Python 3, ejecute el comando siguiente:


• Para el entorno de TensorFlow para Python 2, ejecute el comando siguiente:


2. Elimine el entorno de TensorFlow instalado actualmente.

Note

En los pasos restantes se supone que está utilizando el entorno tensorflow_p36.

(tensorflow_p36)$ pip uninstall tensorflow

3. Instale la compilación nocturna más reciente de TensorFlow.

44


(tensorflow_p36)$ pip install tf-nightly

4. Para verificar que ha instalado correctamente la última compilación nocturna, inicie el terminal deIPython y compruebe la versión de TensorFlow.


import tensorflowprint (tensorflow.__version__)

El resultado debería ser similar a 1.12.0-dev20181012

Más tutoriales

TensorFlow con Horovod (p. 63)

TensorBoard (p. 51)

TensorFlow Serving (p. 116)

Para ver tutoriales, consulte la carpeta denominada AMI de Deep Learning con Conda tutorialsen el directorio de inicio de la DLAMI.

Para ver más tutoriales y ejemplos, consulte la documentación de TensorFlow para la API de Python paraTensorFlow o visite el sitio web de TensorFlow.

TensorFlow 2En este tutorial se muestra cómo activar TensorFlow 2 en una instancia que ejecuta la AMI de DeepLearning con Conda (DLAMI en Conda) y ejecuta un programa de TensorFlow 2.

Cuando se lanza un paquete Conda estable de un marco de trabajo, se prueba y preinstala en la DLAMI.Si desea ejecutar la última compilación nocturna sin probar, puede Instalación de una compilación nocturnade TensorFlow 2 (experimental) (p. 46) manualmente.

Activación de TensorFlow 2

Para ejecutar TensorFlow en la DLAMI con Conda

1. Para activar TensorFlow 2, abra una instancia Amazon Elastic Compute Cloud (Amazon EC2) de laDLAMI con Conda.• Para TensorFlow 2 y Keras 2 en Python 3 con CUDA 10.0 y MKL-DNN, ejecute este comando:

$ source activate tensorflow2_p36

• Para TensorFlow 2 y Keras 2 en Python 2 con CUDA 10.0 y MKL-DNN, ejecute este comando:



(tensorflow2_p36)$ ipython

45

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


https://www.tensorflow.org


3. Ejecute un programa en TensorFlow 2 para verificar que funciona correctamente:

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

Hello, TensorFlow! debe aparecer en la pantalla.

Instalación de una compilación nocturna de TensorFlow 2 (experimental)

Puede instalar la última compilación de TensorFlow 2 en uno o en ambos entornos TensorFlow 2 Conda ensu AMI de Deep Learning con Conda.

Para instalar TensorFlow desde una compilación nocturna

1. • Para el entorno de TensorFlow 2 para Python 3, ejecute el comando siguiente:


• Para el entorno de TensorFlow 2 para Python 2, ejecute el comando siguiente:


2. Elimine el entorno de TensorFlow instalado actualmente.

Note

En los pasos restantes se supone que está utilizando el entorno tensorflow2_p36.

(tensorflow2_p36)$ pip uninstall tensorflow

3. Instale la compilación nocturna más reciente de TensorFlow.

(tensorflow2_p36)$ pip install tf-nightly

4. Para verificar que ha instalado correctamente la última compilación nocturna, inicie el terminal deIPython y compruebe la versión de TensorFlow.


import tensorflowprint (tensorflow.__version__)

El resultado debería ser similar a 2.1.0-dev20191122.

Más tutoriales

Para ver tutoriales, consulte la carpeta denominada AMI de Deep Learning con Conda tutorialsen el directorio de inicio de la DLAMI.

Para ver más tutoriales y ejemplos, consulte la documentación de TensorFlow para la API de Python paraTensorFlow o visite el sitio web de TensorFlow.

46



https://www.tensorflow.org


TensorFlow con HorovodEn este tutorial se muestra cómo activar TensorFlow con Horovod en una AWS Deep Learning AMI(DLAMI) con Conda. Horovod está preinstalado en los entornos Conda para TensorFlow. Se recomienda elentorno Python3.

Note

Solo se admiten los tipos de instancias P3.*, P2.* y G3.*.

Para activar TensorFlow y probar Horovod en la DLAMI con Conda

1. Abra una instancia Amazon Elastic Compute Cloud (Amazon EC2) de la DLAMI con Conda. Paraobtener ayuda para empezar a trabajar con una DLAMI, consulte the section called “Primeros pasoscon la DLAMI” (p. 4).• (Recomendado) Para TensorFlow con Horovod en Python 3 con CUDA 9, ejecute este comando:


• Para TensorFlow con Horovod en Python 2 con CUDA 9, ejecute este comando:




3. Pruebe la importación de TensorFlow con Horovod para comprobar que está funcionandocorrectamente:

import horovod.tensorflow as hvdhvd.init()

En la pantalla podría aparecer lo siguiente (puede pasar por alto los mensajes de advertencia).

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

Más información

• TensorFlow con Horovod (p. 63)• Para ver tutoriales, consulte la carpeta examples/horovod en el directorio de inicio de la DLAMI.• Para ver más tutoriales y ejemplos, consulte Horovod GitHub project.

47

https://github.com/uber/horovod


TensorFlow 2 con HorovodEn este tutorial se muestra cómo activar TensorFlow 2 con Horovod en una AWS Deep Learning AMI(DLAMI) con Conda. Horovod está preinstalado en los entornos Conda para TensorFlow 2. Se recomiendael entorno Python3.

Note


Para activar TensorFlow 2 y probar Horovod en la DLAMI con Conda

1. Abra una instancia Amazon Elastic Compute Cloud (Amazon EC2) de la DLAMI con Conda. Paraobtener ayuda para empezar a trabajar con una DLAMI, consulte the section called “Primeros pasoscon la DLAMI” (p. 4).• (Recomendado) Para TensorFlow 2 con Horovod en Python 3 con CUDA 10, ejecute este

comando:


• Para TensorFlow 2 con Horovod en Python 2 con CUDA 10, ejecute este comando:




3. Pruebe la importación de TensorFlow 2 con Horovod para comprobar que está funcionandocorrectamente:


Si no recibe ninguna salida, Horovod está funcionando correctamente. En la pantalla podría aparecerlo siguiente (puede pasar por alto los mensajes de advertencia).




Más información

• Para ver tutoriales, consulte la carpeta examples/horovod en el directorio de inicio de la DLAMI.• Para ver más tutoriales y ejemplos, consulte Horovod GitHub project.

48


Deep Learning AMI Guía para desarrolladoresDepuración y visualización

TheanoTutorial de Theano

Note


Para activar el marco de trabajo, siga estas instrucciones en la AMI de Deep Learning con Conda.

Para Theano + Keras en Python 3 con CUDA 9 con cuDNN 7:

$ source activate theano_p36

Para Theano + Keras en Python 2 con CUDA 9 con cuDNN 7:

$ source activate theano_p27


(theano_p36)$ ipython

Ejecute un programa rápido en Theano.

import numpyimport theanoimport theano.tensor as Tfrom theano import ppx = T.dscalar('x')y = x ** 2gy = T.grad(y, x)pp(gy)

Debería ver cómo Theano calcula un gradiente simbólico.

Más tutoriales

Si desea ver más tutoriales y ejemplos, consulte la documentación oficial del marco de trabajo, la API dePython para Theano y el sitio web de Theano.

Depuración y visualizaciónObtenga más información acerca de las opciones de visualización y depuración para la DLAMI. Haga clicen una de las opciones para obtener información acerca de cómo utilizarla.

Temas• MXBoard (p. 50)

49

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

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

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


• TensorBoard (p. 51)

MXBoardMXBoard le permite inspeccionar visualmente e interpretar sus ejecuciones y gráficos MXNet con elsoftware TensorBoard. Ejecuta un servidor web que sirve una página web para visualizar e interaccionarcon las visualizaciones de MXBoard.

MXNet, TensorBoard y MXBoard ya vienen instalados con la AMI de Deep Learning con Conda(DLAMI con Conda). En este tutorial, utilizaremos una función MXBoard para generar registros que soncompatibles con TensorBoard.

Temas• Uso de MXNet con MXBoard (p. 50)• Más información (p. 51)

Uso de MXNet con MXBoard

Generar datos de registro MXBoard compatibles con TensorBoard

1. Conéctese a su instancia Amazon Elastic Compute Cloud (Amazon EC2) de la DLAMI con Conda.2. Active el entorno MXNet de Python 3.


3. Prepare un script de Python para escribir los datos generados por el operador normal a un archivode eventos. Los datos se genera diez veces con desviación estándar decreciente y, a continuación,se escriben en el archivo de eventos cada vez. Verá cómo la distribución de datos gradualmente secentra más en torno a un valor medio. Tenga en cuenta que especificará el archivo de eventos en lacarpeta de registros. Puede transferir esta ruta de carpeta al binario TensorBoard.

$ vi mxboard_normal.py

4. Pegue lo siguiente en el archivo y guárdelo:

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. Ejecute el script. Esto generará registros en una carpeta logs que puede utilizar para visualizaciones.

$ python mxboard_normal.py

6. Ahora debe cambiar al entorno TensorFlow para usar TensorBoard y MXBoard para visualizar losregistros. Se trata de una dependencia necesaria para MXBoard y TensorBoard.


50

https://github.com/awslabs/mxboard


7. Transfiera la ubicación de los registros a tensorboard:

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

TensorBoard lanza el servidor web de visualización en el puerto 8888.8. Para facilitar el acceso desde su navegador local, puede cambiar el puerto del servidor web al

puerto 80 o a otro puerto. Con independencia del puerto que utilice, tendrá que abrir este puertoen el grupo de seguridad de EC2 para su DLAMI. También puede usar el redireccionamiento depuertos. Para obtener instrucciones acerca del cambio de la configuración de su grupo de seguridad yredireccionamiento de puertos, consulte Configuración de un servidor de cuadernos de Jupyter (p. 23).La configuración predeterminada se describe en el siguiente paso.

Note

Si tiene que ejecutar el servidor Jupyter y un servidor MXBoard, utilice un puerto diferentepara cada uno de ellos.

9. Abra el puerto 8888 (o el puerto asignado al servidor web de visualización) en la instancia EC2.

a. Abra la instancia EC2 en la consola de Amazon EC2 en https://console.aws.amazon.com/ec2/.b. En la consola de Amazon EC2, elija Network & Security (Red y seguridad) y, a continuación, elija

Security Groups (Grupos de seguridad).c. Para Security Group (Grupo de seguridad), elija el que se creó más recientemente (consulte la

marca de tiempo en la descripción).d. Elija la pestaña Inbound (Entrada) y elija Edit (Editar).e. Seleccione Add Rule.f. En la nueva fila, escriba lo siguiente:

Tipo: TCP Rule personalizada

Protocolo: TCP

Intervalo de puertos: 8888 (o el puerto que haya asignado al servidor de visualización)

Origen: Anywhere (0.0.0.0/0,::/0)10. Si desea visualizar los datos del navegador local, escriba el siguiente comando para reenviar los datos

que está representando en la instancia EC2 al equipo local.

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

11. Abra la página web para las visualizaciones de MXBoard mediante la dirección DNS o IP pública de lainstancia EC2 que ejecuta la DLAMI con Conda y el puerto que abrió para MXBoard:

http://127.0.0.1:8888

Más informaciónPara obtener más información sobre MXBoard, consulte el sitio web de MXBoard.

TensorBoardTensorBoard le permite inspeccionar visualmente e interpretar sus ejecuciones y gráficos de TensorFlow.Ejecuta un servidor web que sirve una página web para visualizar e interaccionar con las visualizacionesde TensorBoard.

TensorFlow y TensorBoard ya vienen preinstalados con la AMI de Deep Learning con Conda (DLAMI conConda). La DLAMI con Conda también incluye un script de ejemplo que utiliza TensorFlow para entrenar

51

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

https://github.com/awslabs/mxboard

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


un modelo de MNIST con características de registro adicionales habilitadas. MNIST es una base de datosde números escritos a mano que se utiliza generalmente para entrenar modelos de reconocimiento deimágenes. En este tutorial, utilizaremos el script para entrenar un modelo de MNIST y TensorBoard y losregistros para crear visualizaciones.

Temas• Entrenar un modelo de MNIST y visualizar el entrenamiento con TensorBoard (p. 52)• Más información (p. 53)

Entrenar un modelo de MNIST y visualizar el entrenamiento con TensorBoard

Visualizar el entrenamiento de modelo de MNIST con TensorBoard

1. Conéctese a su instancia Amazon Elastic Compute Cloud (Amazon EC2) de la DLAMI con Conda.2. Active el entorno de TensorFlow de Python 2.7 y acceda al directorio que contiene la carpeta con los

scripts de ejemplo de TensorBoard:

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

3. Ejecute el script que entrena un modelo de MNIST con el registro extendido habilitado:

$ python mnist_with_summaries.py

El script escribe los registros en /tmp/tensorflow/mnist.4. Transfiera la ubicación de los registros a tensorboard:

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

TensorBoard lanza el servidor web de visualización en el puerto 6006.5. Para facilitar el acceso desde su navegador local, puede cambiar el puerto del servidor web al

puerto 80 o a otro puerto. Con independencia del puerto que utilice, tendrá que abrir este puertoen el grupo de seguridad de EC2 para su DLAMI. También puede usar el redireccionamiento depuertos. Para obtener instrucciones acerca del cambio de la configuración de su grupo de seguridad yredireccionamiento de puertos, consulte Configuración de un servidor de cuadernos de Jupyter (p. 23).La configuración predeterminada se describe en el siguiente paso.

Note

Si tiene que ejecutar el servidor Jupyter y un servidor TensorBoard, utilice un puerto diferentepara cada uno de ellos.

6. Abra el puerto 6006 (o el puerto asignado al servidor web de visualización) en la instancia EC2.

a. Abra la instancia EC2 en la consola de Amazon EC2 en https://console.aws.amazon.com/ec2/.b. En la consola de Amazon EC2, elija Network & Security (Red y seguridad) y, a continuación, elija

Security Groups (Grupos de seguridad).c. Para Security Group (Grupo de seguridad), elija el que se creó más recientemente (consulte la

marca de tiempo en la descripción).d. Elija la pestaña Inbound (Entrada) y elija Edit (Editar).e. Seleccione Add Rule.f. En la nueva fila, escriba lo siguiente:

Tipo: TCP Rule personalizada

52


Deep Learning AMI Guía para desarrolladoresEntrenamiento distribuido

Protocolo: TCP

Intervalo de puertos: 6006 (o el puerto que haya asignado al servidor de visualización)

Origen: Anywhere (0.0.0.0/0,::/0)7. Abra la página web para las visualizaciones de TensorBoard mediante la dirección DNS o IP pública

de la instancia EC2 que ejecuta la DLAMI con Conda y el puerto que abrió para TensorBoard:

http:// YourInstancePublicDNS:6006

Más información

Para obtener más información sobre TensorBoard, consulte el sitio web de TensorBoard.

Entrenamiento distribuidoObtenga más información acerca de las opciones que tiene la DLAMI para el entrenamiento con variasGPU. Para lograr el mejor rendimiento, consulte Elastic Fabric Adapter (p. 70) Haga clic en una de lasopciones para obtener información acerca de cómo utilizarlo.

Temas• Chainer (p. 53)• Keras con MXNet (p. 62)• TensorFlow con Horovod (p. 63)

ChainerChainer es un marco de trabajo flexible basado en Python para escribir de forma sencilla e intuitivaarquitecturas de red neuronal complejas. Chainer facilita la utilización de instancias de varias GPU paraentrenamiento. Chainer además registra automáticamente los resultados, representa gráficamentepérdidas y precisión y produce una salida para visualizar la red neuronal con un grafo computacional. Seincluye con la AMI de Deep Learning con Conda (DLAMI con Conda).

Los temas siguientes le muestran cómo entrenar varias GPU, una única GPU y una CPU, crearvisualizaciones y probar su instalación de Chainer.

Temas• Entrenamiento de un modelo con Chainer (p. 53)• Utilizar Chainer para entrenar en varias GPU (p. 54)• Utilizar Chainer para entrenar en una única GPU (p. 56)• Utilice Chainer para entrenar con CPU (p. 57)• Representación gráfica de resultados (p. 58)• Prueba de Chainer (p. 62)• Más información (p. 62)

Entrenamiento de un modelo con Chainer

En este tutorial se muestra cómo utilizar scripts de Chainer de ejemplo para entrenar un modelo conel conjunto de datos MNIST. MNIST es una base de datos de números escritos a mano que se utiliza

53

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

https://chainer.org/

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


generalmente para entrenar modelos de reconocimiento de imágenes. El tutorial también muestra ladiferencia en la velocidad de entrenamiento entre el entrenamiento en una CPU y en una o varias GPU.

Utilizar Chainer para entrenar en varias GPU

Para entrenar en varias GPU

1. Conéctese a la instancia que está ejecutando AMI de Deep Learning con Conda. Consulte la thesection called “Selección de una instancia” (p. 17) o la documentación de Amazon EC2 acerca decómo seleccionar una instancia o conectarse a una instancia. Para ejecutar este tutorial, deberáutilizar una instancia con al menos dos GPU.

2. Active el entorno de Chainer de Python 3:


3. Para obtener los tutoriales más recientes, clone el repositorio de Chainer y acceda a la carpeta deejemplos:

(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. Ejecute el ejemplo en el script train_mnist_data_parallel.py. De forma predeterminada, elscript utiliza las GPU que se ejecutan en su instancia de AMI de Deep Learning con Conda. El scriptse puede ejecutar en un máximo de dos GPU. Se hará caso omiso de cualquier GPU después de lasdos primeras. Detecta una o ambas de forma automática. Si ejecuta una instancia sin GPU, vaya aUtilice Chainer para entrenar con CPU (p. 57), más adelante en este tutorial.

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

Note

Este ejemplo devolverá el siguiente error debido a la inclusión de una característica beta noincluida en la DLAMI.chainerx ModuleNotFoundError: No module named 'chainerx'

Aunque el script de Chainer entrena un modelo utilizando la base de datos MNIST, verá los resultadospara cada fecha de inicio.

A continuación, verá un resultado de ejemplo a medida que se ejecuta el script. El siguiente resultadode ejemplo se ejecutó en una instancia p3.8xlarge. El resultado del script muestra "GPU: 0, 1", queindica que está utilizando las dos primeras de las cuatro GPU disponibles. Los scripts suelen utilizarun índice de GPU que empieza en cero, en lugar de un recuento 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

54

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


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. Aunque su entrenamiento se esté ejecutando, es útil echar un vistazo a su utilización de GPU. Puedecomprobar qué GPU están activas y ver su carga. NVIDIA proporciona una herramienta para este fin,que se puede ejecutar con el comando nvidia-smi. Sin embargo, solo le mostrará una instantáneade la utilización, por lo que resulta más informativo combinarla con el comando de Linux watch. Elsiguiente comando utilizará watch con nvidia-smi para actualizar la utilización de GPU actual cadadécima de segundo. Abra otra sesión de terminal en su DLAMI y ejecute el siguiente comando:

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

Verá una salida similar al siguiente resultado. Utilice ctrl-c para cerrar la herramienta o manténgalaen ejecución mientras prueba otros ejemplos en su primera sesión de terminal.

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

55


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

En este ejemplo, GPU 0 y GPU 1 están activas y GPU 2 y 3 no lo están. También puede ver lautilización de memoria por GPU.

6. Cuando se complete el entrenamiento, anote el tiempo transcurrido en su primera sesión de terminal.En el ejemplo, el tiempo transcurrido es 38,1389 segundos.

Utilizar Chainer para entrenar en una única GPU

Este ejemplo muestra cómo entrenar en una única GPU. Podría hacerlo si tiene solo una única GPUdisponible o simplemente para ver cómo podría escalarse el entrenamiento en varias GPU con Chainer.

Para utilizar Chainer para entrenar en una única GPU

• En este ejemplo, utiliza otro script, train_mnist.py, y le indica que utilice solo GPU 0 con elargumento --gpu=0. Para ver como distintas GPU se activan en la consola de nvidia-smi, puedeindicarle al script que utilice la GPU número 1 utilizando --gpu=1.

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

GPU: 0# unit: 1000# Minibatch-size: 100# epoch: 20

epoch main/loss validation/main/loss main/accuracy validation/main/accuracy elapsed_time1 0.192348 0.0909235 0.940934 0.9719 5.3861 2 0.0746767 0.069854 0.976566 0.9785 8.97146 3 0.0477152 0.0780836 0.984982 0.976 12.5596 4 0.0347092 0.0701098 0.988498 0.9783 16.1577 5 0.0263807 0.08851 0.991515 0.9793 19.7939 6 0.0253418 0.0945821 0.991599 0.9761 23.4643 7 0.0209954 0.0683193 0.993398 0.981 27.0317 8 0.0179036 0.080285 0.994149 0.9819 30.6325

56


9 0.0183184 0.0690474 0.994198 0.9823 34.2469 10 0.0127616 0.0776328 0.996165 0.9814 37.8693 11 0.0145421 0.0970157 0.995365 0.9801 41.4629 12 0.0129053 0.0922671 0.995899 0.981 45.0233 13 0.0135988 0.0717195 0.995749 0.9857 48.6271 14 0.00898215 0.0840777 0.997216 0.9839 52.2269 15 0.0103909 0.123506 0.996832 0.9771 55.8667 16 0.012099 0.0826434 0.996616 0.9847 59.5001 17 0.0066183 0.101969 0.997999 0.9826 63.1294 18 0.00989864 0.0877713 0.997116 0.9829 66.7449 19 0.0101816 0.0972672 0.996966 0.9822 70.3686 20 0.00833862 0.0899327 0.997649 0.9835 74.0063

En este ejemplo, la ejecución en una única GPU requirió casi el doble de tiempo. El entrenamiento demodelos más grandes o de conjuntos de datos de mayor tamaño dará un resultado distinto de esteejemplo, por tanto experimente para evaluar mejor el desempeño de GPU.

Utilice Chainer para entrenar con CPU

Ahora, pruebe a entrenar en un modo de solo CPU. Ejecute el mismo script, python train_mnist.py,sin argumentos:

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

En el resultado, GPU: -1 indica que no se ha utilizado ninguna GPU:

GPU: -1# unit: 1000# Minibatch-size: 100# epoch: 20

epoch main/loss validation/main/loss main/accuracy validation/main/accuracy elapsed_time1 0.192083 0.0918663 0.94195 0.9712 11.2661 2 0.0732366 0.0790055 0.977267 0.9747 23.9823 3 0.0485948 0.0723766 0.9844 0.9787 37.5275 4 0.0352731 0.0817955 0.987967 0.9772 51.6394 5 0.029566 0.0807774 0.990217 0.9764 65.2657 6 0.025517 0.0678703 0.9915 0.9814 79.1276 7 0.0194185 0.0716576 0.99355 0.9808 93.8085 8 0.0174553 0.0786768 0.994217 0.9809 108.648

57


9 0.0148924 0.0923396 0.994983 0.9791 123.737 10 0.018051 0.099924 0.99445 0.9791 139.483 11 0.014241 0.0860133 0.995783 0.9806 156.132 12 0.0124222 0.0829303 0.995967 0.9822 173.173 13 0.00846336 0.122346 0.997133 0.9769 190.365 14 0.011392 0.0982324 0.996383 0.9803 207.746 15 0.0113111 0.0985907 0.996533 0.9813 225.764 16 0.0114328 0.0905778 0.996483 0.9811 244.258 17 0.00900945 0.0907504 0.9974 0.9825 263.379 18 0.0130028 0.0917099 0.996217 0.9831 282.887 19 0.00950412 0.0850664 0.997133 0.9839 303.113 20 0.00808573 0.112367 0.998067 0.9778 323.852

En este ejemplo, MNIST se entrenó en 323 segundos, lo que supone un entrenamiento 11 veces másprolongado que con dos GPU. Si ha dudado alguna vez de la potencia de las GPU, este ejemplo muestrahasta qué punto son más eficientes.

Representación gráfica de resultadosChainer además registra automáticamente los resultados, representa gráficamente pérdidas y precisión ygenera salida para trazar el grafo computacional.

Para generar el grafo computacional

1. Una vez que una ejecución de entrenamiento finaliza, puede acceder al directorio result y ver laprecisión y pérdida de la ejecución en forma de dos imágenes generadas automáticamente. Accedaallí ahora y enumere el contenido:

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

El directorio result contiene dos archivos en formato .png: accuracy.png y loss.png.2. Para ver los gráficos, use el comando scp para copiarlos en su equipo local.

En un terminal macOS, la ejecución del siguiente comando scp descarga los tres archivos en lacarpeta Downloads. Sustituya los marcadores de posición para la ubicación del archivo de claves yde la dirección del servidor con su información. Para otros sistemas operativos, utilice el formato decomando scp adecuado. Tenga en cuenta que, para una AMI de Amazon Linux, el nombre de usuarioes ec2-user.

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

Las siguientes imágenes son ejemplos de grafos de precisión, pérdidas y computacionales,respectivamente.

58


59


60


61


Prueba de Chainer

Para probar Chainer y verificar la compatibilidad de GPU con un script de prueba preinstalado, ejecute elsiguiente comando:

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

Esto descarga el código fuente de Chainer y ejecuta el ejemplo MNIST con varias GPU de Chainer.

Más información

Para obtener más información sobre Chainer, consulte el sitio web de documentación de Chainer. Lacarpeta de ejemplos de Chainer contiene más ejemplos. Pruébelos para comprobar su desempeño.

Keras con MXNetEn este tutorial se muestra cómo activar y utilizar Keras 2 con el backend MXNet en una AMI de DeepLearning con Conda.

Activar Keras con el backend MXNet y probarlo en la DLAMI con Conda

1. Para activar Keras con el backend MXNet, abra una instancia Amazon Elastic Compute Cloud(Amazon EC2) de la DLAMI con Conda.• Para Python 3, ejecute este comando:


• Para Python 2, ejecute este comando:




3. Pruebe a importar Keras con MXNet para verificar que funciona correctamente:

import keras as k

En la pantalla debería aparecer lo siguiente (posiblemente tras algunos mensajes de advertencia).

Using MXNet backend

Note

Si recibe un error o si se sigue utilizando un backend TensorFlow, tiene que actualizar suconfiguración de Keras manualmente. Edite el archivo ~/.keras/keras.json y cambie laconfiguración del backend a mxnet.

62

https://docs.chainer.org/


Tutorial de entrenamiento en varias GPU de Keras-MXNet

Entrenar una red neuronal convolucional (CNN)

1. Abra un terminal y SSH en su DLAMI.2. Vaya a la carpeta ~/examples/keras-mxnet/.3. Ejecute nvidia-smi en su ventana de terminal para determinar el número de GPU disponibles en su

DLAMI. En el paso siguiente, ejecutará el script tal y como está si tiene cuatro GPU.4. De manera opcional, ejecute el siguiente comando para abrir el script para editarlo.

(mxnet_p36)$ vi cifar10_resnet_multi_gpu.py

5. De manera opcional, el script tiene la siguiente línea que define el número de GPU. Actualícelo si esnecesario.

model = multi_gpu_model(model, gpus=4)

6. Ahora, ejecute el entrenamiento.

(mxnet_p36)$ python cifar10_resnet_multi_gpu.py

Note

Keras-MXNet se ejecuta hasta dos veces más rápido con el conjunto channels_firstimage_data_format. Para cambiar a channels_first, edite el archivo de configuraciónde Keras (~/.keras/keras.json) y defina lo siguiente: "image_data_format":"channels_first".Para obtener más técnicas de ajuste del rendimiento, consulte la Guía para ajustar el rendimientode Keras-MXNet.

Más información

• Puede encontrar ejemplos para Keras con un backend MXNet en el directorio ~/examples/keras-mxnet de la AMI de Deep Learning con Conda.

• Para ver más tutoriales y ejemplos, consulte el proyecto de GitHub de Keras-MXNet.

TensorFlow con HorovodEn este tutorial se muestra cómo usar TensorFlow con Horovod en una AMI de Deep Learning con Conda.Horovod está preinstalado en los entornos Conda para TensorFlow. Se recomienda el entorno Python 3.Las instrucciones siguientes presuponen que tiene una instancia de DLAMI en funcionamiento con una ovarias GPU. Para obtener más información, consulte Primeros pasos con la DLAMI (p. 4).

Note


Note

Hay dos ubicaciones donde está disponible mpirun (a través de OpenMPI). Está disponible en /usr/bin y /home/ubuntu/anaconda3/envs/<env>/bin. env es un entorno correspondienteal marco, como Tensorflow y Apache MXNet. La finalidad del binario mpirun en /usr/bin fuera

63

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


del entorno conda es mantener la compatibilidad con el marco CNTK. Este marco espera laversión 1.10 en esa ubicación. Las versiones más recientes de OpenMPI están disponibles en losentornos conda. Recomendamos utilizar la ruta absoluta del binario mpirun o el indicador --prefixpara ejecutar cargas de trabajo de mpi. Por ejemplo, con el entorno python36 de Tensorflow,utilice cualquiera de estas dos opciones:

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

or

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

Activación y prueba de TensorFlow con Horovod

1. Verifique que la instancia tiene GPU activas. NVIDIA proporciona una herramienta para hacerlo:

$ nvidia-smi

2. Active el entorno de TensorFlow de Python 3:




4. Pruebe la importación de TensorFlow con Horovod para comprobar que está funcionandocorrectamente:


En la pantalla podría aparecer lo siguiente (posiblemente tras algunos mensajes de advertencia).




Configurar el archivo de hosts de Horovod

Puede utilizar Horovod para realizar un entrenamiento de un solo nodo con varias GPU o un entrenamientode varios nodos con varias GPU. Si tiene previsto utilizar varios nodos para el entrenamiento distribuido,debe añadir la dirección IP privada de cada DLAMI a un archivo de hosts. La DLAMI en la que se hainiciado sesión se conoce como el líder. Las demás instancias de la DLAMI que forman parte del clúster sedenominan miembros.

Antes de comenzar con esta sección, lance una o varias DLAMI y espere a que estén en el estado Ready(Lista). Los scripts de ejemplo esperan un archivo de hosts, por lo que, incluso si pretende utilizar una

64

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


única DLAMI, debe crear un archivo de hosts con una sola entrada. Si edita el archivo de hosts despuésde que comience el entrenamiento, debe reiniciar el entrenamiento para que los hosts que ha añadido oeliminado surtan efecto.

Para configurar Horovod para el entrenamiento

1. Cambie al directorio en el que residen los scripts de entrenamiento.

cd ~/examples/horovod/tensorflow

2. Utilice vim para editar un archivo en el directorio principal del líder.

vim hosts

3. Seleccione uno de los miembros en la consola de Amazon Elastic Compute Cloud y aparecerá elpanel de descripción de la consola. Busque el campo Private IPs (Direcciones IP privadas) y copiela dirección IP y péguela en un archivo de texto. Copie la dirección IP privada de cada miembroen una línea nueva. A continuación, junto a cada dirección IP, añada un espacio y, después, eltexto slots=8, tal y como se muestra a continuación. Esto representa el número de GPU de cadainstancia. Las instancias p3.16xlarge tienen 8 GPU, por lo que si elige otro tipo de instancia, deberíaintroducir el número real de GPU de cada instancia. Para el líder puede utilizar localhost. Con unclúster de 4 nodos, debe tener un aspecto similar al siguiente:

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

Guarde el archivo y vuelva al terminal del líder.4. Ahora, el líder sabe cómo llegar a cada miembro. Todo esto va a suceder en las interfaces de red

privadas. A continuación, utilice una corta función de bash para ayudar a enviar comandos a cadamiembro.

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

5. La primera orden del día es para indicar a los demás miembros que no hagan"StrickHostKeyChecking" ya que esto puede provocar el entrenamiento se bloquee.

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

Entrenamiento con datos sintéticos

La DLAMI se suministra con un script de ejemplo para entrenar un modelo con datos sintético. Sirve paraprobar si el líder puede comunicarse con los miembros del clúster. Se necesita un archivo de hosts. Paraobtener instrucciones, consulte Configurar el archivo de hosts de Horovod (p. 64).

Para probar el entrenamiento de Horovod mediante con datos de ejemplo.

1. De forma predeterminada, ~/examples/horovod/tensorflow/train_synthetic.sh funcionacon 8 GPU, pero puede indicar el número de GPU que desee ejecutar. En el ejemplo siguiente, seejecuta el script, y se pasa 4 como parámetro para 4 GPU.

$ ./train_synthetic.sh 4

65


Después de algunos mensajes de advertencia, verá el siguiente resultado que confirma que Horovodutiliza 4 GPU.

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

A continuación, después de otras advertencias, verá el inicio de una tabla y algunos puntos de datos.Si no desea ver 1000 lotes, interrumpa el entrenamiento.

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. Horovod utiliza todas las GPU locales antes de intentar utilizar las GPU de los miembros del clúster.Por lo tanto, para asegurarse de que funciona el entrenamiento distribuido en el clúster, pruebe contodas las GPU que tenga previsto utilizar. Si, por ejemplo, tiene 4 miembros con el tipo de instanciap3.16xlarge, tiene 32 GPU en todo el clúster. En este caso, podría probar a usar todas las 32 GPUjuntas.

./train_synthetic.sh 32

El resultado es similar al de la prueba anterior. El tamaño de Horovod es de 32 y aproximadamentecuatro veces la velocidad. Una vez finalizadas estas pruebas, ya ha probado el nodo principal y sucapacidad para comunicarse con los miembros. Si tiene algún problema, consulte la sección Soluciónde problemas (p. 69).

Preparación del conjunto de datos de ImageNet

En esta sección, se descarga el conjunto de datos de ImageNet y, a continuación, se genera un conjuntode datos en formato TFRecord a partir del conjunto de datos sin procesar. En la DLAMI se proporcionaun conjunto de scripts de preprocesamiento para el conjunto de datos de ImageNet que puede utilizarpara ImageNet o como plantilla para otro conjunto de datos. También se proporcionan los scripts deentrenamiento principales que están configurados para ImageNet. En la sección siguiente, se suponeque ha lanzado una DLAMI con una instancia EC2 con 8 GPU. Recomendamos el tipo de instanciap3.16xlarge.

En el directorio ~/examples/horovod/tensorflow/utils de la DLAMI, se encuentran los siguientesscripts:

• utils/preprocess_imagenet.py: utilice esta opción para convertir el conjunto de datos deImageNet sin procesar al formato TFRecord.

• utils/tensorflow_image_resizer.py: utilice esta opción para cambiar el tamaño del conjunto dedatos TFRecord tal y como se recomienda para el entrenamiento de ImageNet.

Preparación del conjunto de datos de ImageNet

1. Visite image-net.org, cree una cuenta, adquiera una clave de acceso y descargue el conjunto dedatos. image-net.org aloja el conjunto de datos sin procesar. Para descargarlo, debe tener una cuentade ImageNet y una clave de acceso. La cuenta es gratuita y, para obtener la clave de acceso gratuita,deben aceptar la licencia de ImageNet.

66

http://image-net.org

http://image-net.org


2. Utilice el script de preprocesamiento de imagen para generar un conjunto de datos de formatoTFRecord desde el conjunto de datos de ImageNet sin procesar. Desde el directorio ~/examples/horovod/tensorflow/utils:

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

3. Utilice el script de cambio de tamaño de imagen. Si cambia el tamaño de las imágenes, elentrenamiento se ejecuta con mayor rapidez y se adapta mejor al documento de referencia de ResNet.Desde el directorio ~/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

Entrenamiento de un modelo de ImageNet de ResNet-50 en una única DLAMINote

• El script de este tutorial espera que los datos de entrenamiento preprocesados se encuentrenen la carpeta ~/data/tf-imagenet/. Para obtener instrucciones, consulte Preparación delconjunto de datos de ImageNet (p. 66).

• Se necesita un archivo de hosts. Para obtener instrucciones, consulte Configurar el archivo dehosts de Horovod (p. 64).

Utilice Horovod para realizar el entrenamiento de una CNN de ResNet50 con el conjunto de datosde ImageNet

1. Vaya a la carpeta ~/examples/horovod/tensorflow.

cd ~/examples/horovod/tensorflow

2. Compruebe la configuración y defina el número de GPU que va a utilizar en el entrenamiento. Enprimer lugar, revise el hosts que se encuentra en la misma carpeta que los scripts. Este archivodebe actualizarse si utiliza una instancia con menos de 8 GPU. De forma predeterminada indicalocalhost slots=8. Actualice el número 8 al número de GPU que desea utilizar.

3. Se proporciona un script de shell que toma como único parámetro el número de GPU que se debenutilizar. Ejecute este script para iniciar el entrenamiento. El ejemplo siguiente utiliza 4 para cuatroGPU.

./train.sh 4

4. Tarda varias horas en terminar. Utiliza mpirun para distribuir el entrenamiento en las GPU.

67

https://arxiv.org/abs/1512.03385


Entrenamiento de un modelo de ImageNet de ResNet-50 en un clúster de DLAMINote

• El script de este tutorial espera que los datos de entrenamiento preprocesados se encuentrenen la carpeta ~/data/tf-imagenet/. Para obtener instrucciones, consulte Preparación delconjunto de datos de ImageNet (p. 66).

• Se necesita un archivo de hosts. Para obtener instrucciones, consulte Configurar el archivo dehosts de Horovod (p. 64).

En este ejemplo, se entrena un modelo de ResNet-50 con un conjunto de datos preparado entre variosnodos de un clúster de DLAMI.

• Para mejorar el rendimiento, recomendamos que tenga el conjunto de datos localmente en cadamiembro del clúster.

Utilice esta función copyclust para copiar datos a otros miembros.

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

O bien, si tiene los archivos en un bucket de S3, utilice la función runclust para descargar directamentelos archivos en cada miembro.

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/\""

El uso de herramientas que le permiten administrar varios nodos a la vez proporciona un ahorro de tiempoconsiderable. Puede esperar a que finalice cada paso y administrar cada instancia por separado o utilizarherramientas como tmux o screen que le permiten desconectar y reanudar sesiones.

Cuando finalice la copia, estará listo para comenzar el entrenamiento. Ejecute el script, pasando 32 comoparámetro para las 32 GPU que estamos utilizando para esta ejecución. Utilice tmux o una herramientasimilar si le preocupa que se produzca una desconexión y termine la sesión, lo que finalizaría la sesión deentrenamiento.

./train.sh 32

El siguiente resultado es lo que aparece cuando se ejecuta el entrenamiento sobre ImageNet con 32 GPU.Treinta y dos GPU tardan unos 90–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

68


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

Cuando finaliza la sesión de entrenamiento, el script continúa con una sesión de evaluación. Se ejecutaen el líder, ya es lo suficientemente rápida como para no tener que distribuir el trabajo entre los demásmiembros. A continuación, se muestra el resultado de la sesión de evaluación.

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

A continuación, se muestra un ejemplo del resultado obtenido al ejecutar este script con 256 GPU, dondeel tiempo de ejecución fue de entre 14 y 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

Solución de problemasEl comando siguiente puede ayudar a superar los errores que surgen cuando se experimenta conHorovod.

• Si el entrenamiento se bloquea por algún motivo, es posible que mpirun no sea capaz de limpiar todoslos procesos de python de cada máquina. En ese caso, antes de iniciar el siguiente trabajo, finalice losprocesos de python en todas las máquinas como se indica a continuación:

runclust hosts "pkill -9 python"

• Si el proceso termina bruscamente sin errores, intente eliminar carpeta de registro.

runclust hosts "rm -rf ~/imagenet_resnet/"

• Si se presentan otros problemas inexplicables, compruebe el espacio en disco. Si se ha agotado, pruebea borrar la carpeta de registros, ya que está llena de datos y puntos de comprobación. También puedeaumentar el tamaño de los volúmenes de cada miembro.

runclust hosts "df /"

69

Deep Learning AMI Guía para desarrolladoresElastic Fabric Adapter

• En última instancia también puede probar a reiniciar.

runclust hosts "sudo reboot"

Es posible que aparezca el siguiente código de error si intenta utilizar TensorFlow con Horovod en un tipode instancia no compatible:

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

Más información

Para obtener las utilidades y los ejemplos, consulte la carpeta ~/examples/horovod en el directorioprincipal de la DLAMI.

Para ver más tutoriales y ejemplos, consulte Horovod GitHub project.

Elastic Fabric AdapterUn Elastic Fabric Adapter (EFA) es un dispositivo de red que puede asociar a su instancia DLAMIpara acelerar las aplicaciones de informática de alto rendimiento (HPC). EFA le permite conseguir el

70


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


rendimiento de aplicación de un clúster de HPC en las instalaciones, con la escalabilidad, la flexibilidad y laelasticidad que proporciona la nube de AWS.

En los siguientes temas se muestra cómo comenzar a usar EFA con la DLAMI.

Temas• Lanzamiento de una instancia AWS Deep Learning AMI con EFA (p. 71)• Uso de EFA en la DLAMI (p. 74)

Lanzamiento de una instancia AWS Deep Learning AMI con EFALa DLAMI más reciente está lista para utilizarse con EFA y viene con los controladores, módulos de kernel,libfabric, openmpi y el complemento de NCCL OFI necesarios para instancias de GPU.

Versiones de CUDA compatibles: las aplicaciones de NCCL con EFA son solo compatibles con CUDA-10.0y CUDA-10.1, ya que el complemento de NCCL OFI requiere NCCL versión > 2.4.2.

Nota:

• Al ejecutar una aplicación de NCCL mediante mpirun en EFA, tendrá que especificar la ruta completa ala instalación compatible con EFA como:

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

• Para permitir que la aplicación utilice EFA, añada FI_PROVIDER="efa" al comando mpirun, tal ycomo se muestra en Uso de EFA en la DLAMI (p. 74).

Temas• Preparación de un grupo de seguridad habilitado para EFA (p. 71)• Lanzar la instancia (p. 72)• Verificación de una asociación de EFA (p. 73)

Preparación de un grupo de seguridad habilitado para EFA

EFA requiere un grupo de seguridad que permita todo el tráfico entrante y saliente hacia y desde el propiogrupo de seguridad. Para obtener más información, consulte la documentación de EFA.

1. Abra la consola de Amazon EC2 en https://console.aws.amazon.com/ec2/.2. En el panel de navegación, elija Security Groups (Grupos de seguridad) y, a continuación, elija Create

Security Group (Crear grupo de seguridad).3. En la ventana Create Security Group (Crear grupo de seguridad), haga lo siguiente:

• En Security group name (Nombre del grupo de seguridad), introduzca un nombre descriptivo para elgrupo de seguridad, como, por ejemplo, EFA-enabled security group.

• (Opcional) En Description (Descripción), introduzca una breve descripción del grupo de seguridad.• En VPC, seleccione la VPC en la que desea lanzar sus instancias habilitadas para EFA.• Seleccione Create (Crear).

4. Seleccione el grupo de seguridad que ha creado y en la pestaña Description (Descripción), copie elGroup ID (ID de grupo).

5. En las pestañas Inbound (Entrante) y Outbound (Saliente), haga lo siguiente:

• Elija Edit (Editar).

71

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

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



• En Type (Tipo), seleccione All traffic (Todo el tráfico).• En Source (Origen), seleccione Custom (Personalizado).• Pegue el ID del grupo de seguridad que copió en el campo.• Seleccione Save (Guardar).

6. Habilite el tráfico de entrada que hace referencia a Autorización del tráfico de entrada para susinstancias de Linux. Si omite este paso, no podrá comunicarse con su instancia DLAMI.

Lanzar la instanciaPara obtener más información, consulte Lanzar instancias habilitadas para EFA en un grupo de ubicaciónen clúster.

1. Abra la consola de Amazon EC2 en https://console.aws.amazon.com/ec2/.2. Elija Launch Instance (Lanzar instancia).3. En la página Choose an AMI (Elegir una AMI), seleccione Deep Learning AMI (Ubuntu 18.04), versión

25.0.4. En la página Choose an Instance Type (Elegir un tipo de instancia), seleccione uno de los tipos de

instancias admitidos y, a continuación, elija Next: Configure Instance Details (Siguiente: Configurardetalles de instancia). Consulte este enlace para ver la lista de instancias admitidas: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html

5. En la página Configure Instance Details (Configurar detalles de instancia), haga lo siguiente:

• En Number of instances (Número de instancias), introduzca el número de instancias habilitadas paraEFA que desea lanzar.

• En Network (Red) y Subnet (Subred), seleccione la VPC y la subred en la que lanzar las instancias.• [Opcional] En Placement group (Grupo de ubicación), seleccione Add instance to placement group

(Añadir instancia a grupo de ubicación). Para lograr el mejor rendimiento, lance las instancias dentrode un grupo de ubicación.

• [Opcional] En Placement group name (Nombre de grupo de ubicación), seleccione Add to a newplacement group (Añadir a un nuevo grupo de ubicación), introduzca un nombre descriptivo parael grupo de ubicación y, a continuación, en Placement group strategy (Estrategia de grupo deubicación), seleccione cluster (clúster).

• Asegúrese de habilitar “Elastic Fabric Adapter” en esta página. Si esta opción está deshabilitada,cambie la subred por una que admita el tipo de instancia seleccionado.

• En la sección Network Interfaces (Interfaces de red) del dispositivo eth0, seleccione New networkinterface (Nueva interfaz de red). Como opción, puede especificar una dirección IPv4 principal y unao varias direcciones IPv4 secundarias. Si está lanzando la instancia en una subred que tenga unbloque de CIDR de IPv6 asociado, como opción puede especificar una dirección IPv6 principal y unao varias direcciones IPv6 secundarias.

• Elija Next: Add Storage (Siguiente: Añadir almacenamiento).6. En la página Add Storage (Añadir almacenamiento), especifique los volúmenes que desea asociar

a las instancias además de los volúmenes especificados por la AMI (como el volumen de dispositivoraíz) y, a continuación, elija Next: Add Tags (Siguiente: Añadir etiquetas).

7. En la página Add Tags (Añadir etiquetas), especifique etiquetas para las instancias, como, porejemplo, un nombre fácil de recordar y, a continuación, elija Next: Configure Security Group (Siguiente:Configurar grupo de seguridad).

8. En la página Configure Security Group (Configurar grupo de seguridad), en Assign a security group(Asignar un grupo de seguridad), seleccione Select an existing security group (Seleccionar un grupode seguridad existente) y, a continuación, seleccione el grupo de seguridad que creó anteriormente.

9. Elija Review and Launch (Revisar y lanzar).10. En la página Review Instance Launch (Revisar lanzamiento de instancia), revise la configuración y, a

continuación, elija Launch (Lanzar) para elegir un par de claves y lanzar las instancias.

72

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

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


Verificación de una asociación de EFA

En la consola

Después de lanzar la instancia, compruebe los detalles de la instancia en la consola de AWS. Para ello,seleccione la instancia en la consola de EC2 y revise la pestaña Description (Descripción) en el panelinferior de la página. Busque el parámetro “Network Interfaces: eth0” y haga clic en eth0 para que aparezcauna ventana emergente. Asegúrese de que “Elastic Fabric Adapter” esté habilitado.

Si EFA no está habilitado, puede solucionarlo mediante las siguientes dos opciones:

• Finalizar la instancia EC2 y lanzar una nueva con los mismos pasos. Asegúrese de que EFA estéasociado.

• Asocie EFA a una instancia existente.

1. En la consola EC2, diríjase a Network Interfaces (Interfaces de red).2. Haga clic en Create a Network Interface (Crear una interfaz de red).3. Seleccione la misma subred en la que se encuentra la instancia.4. Asegúrese de habilitar “Elastic Fabric Adapter” y haga clic en Create (Crear).5. Vuelva a la pestaña EC2 Instances (Instancias EC2) y seleccione su instancia.6. Diríjase a Actions: Instance State (Acciones: Estado de instancia) y detenga la instancia antes de

asociar EFA.7. En Actions (Acciones), seleccione Networking: Attach Network Interface (Redes: Asociar interfaz de

red).8. Seleccione la interfaz que acaba de crear y haga clic en Attach (Asociar).9. Reinicie la instancia.

En la instancia

El siguiente script de prueba ya está presente en la DLAMI. Ejecútelo para asegurarse de que los módulosde kernel estén cargados correctamente.

$ fi_info -p efa

El resultado debería tener un aspecto similar al siguiente.

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

73


Verificación de la configuración del grupo de seguridad

El siguiente script de prueba ya está presente en la DLAMI. Ejecútelo para asegurarse de que el grupo deseguridad que creó esté configurado correctamente.

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

El resultado debería tener un aspecto similar al siguiente.

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

Si se bloquea o no se completa, asegúrese de que el grupo de seguridad tenga las reglas de entrada/salida correctas.

Uso de EFA en la DLAMIEn la siguiente sección se describe cómo utilizar EFA para ejecutar aplicaciones de varios nodos en AWSDeep Learning AMI.

Temas• Ejecución de aplicaciones de varios nodos con EFA (p. 74)

Ejecución de aplicaciones de varios nodos con EFA

Para ejecutar una aplicación a través de un clúster de nodos, es necesario realizar ciertos ajustes.

Habilitar SSH sin contraseña

Seleccione un nodo del clúster como nodo principal. Los nodos restantes se denominan nodos miembro.

1. En el nodo principal, genere el par de claves RSA.

ssh-keygen -t rsa -N "" -f ~/.ssh/id_rsa

2. Cambie los permisos de la clave privada en el nodo principal.

chmod 600 ~/.ssh/id_rsa

3. Copie la clave pública en ~/.ssh/id_rsa.pub y añádala a ~/.ssh/authorized_keys para losnodos miembro del clúster.

4. Ahora debe poder iniciar sesión directamente en los nodos miembro desde el nodo principal mediantela ip privada.

ssh <member private ip>

5. Añada lo siguiente al archivo ~/.ssh/config del nodo principal para deshabilitar strictHostKeyChecking yhabilitar el reenvío del agente en el nodo principal:

74


Host * ForwardAgent yesHost * StrictHostKeyChecking no

6. En las instancias de Amazon Linux y Amazon Linux 2, ejecute el siguiente comando en el nodoprincipal para proporcionar los permisos correctos al archivo de configuración:

chmod 600 ~/.ssh/config

Creación de archivo de hosts

En el nodo principal, cree un archivo de hosts para identificar los nodos del clúster. El archivo de hostsdebe tener una entrada para cada nodo del clúster. Cree un archivo ~/hosts y añada cada nodo mediantela ip privada de la siguiente manera:

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

Comprobación del complemento NCCL de 2 nodos en P3dn.24xlarge

La opción nccl_message_transfer es una prueba sencilla para garantizar que el complemento de NCCLOFI funciona según lo esperado. La prueba valida la funcionalidad de las API de transferencia de datos yde establecimiento de conexiones de NCCL. Asegúrese de utilizar la ruta completa a mpirun, tal y comose muestra en el ejemplo, mientras ejecuta aplicaciones de NCCL con EFA. Cambie los parámetros npy N en función del número de instancias y GPU del clúster. Para obtener más información, consulte ladocumentación de AWS OFI NCCL.

/opt/amazon/openmpi/bin/mpirun -n 2 -N 1 --hostfile hosts ~/src/bin/efa-tests/efa-cuda-10.0/nccl_message_transfer

El resultado debería tener el siguiente aspecto. Puede comprobar la salida para ver si EFA se estáutilizando como proveedor 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 0

75

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


INFO: Function: main Line: 131: NET/OFI Got completions for 255 requests for rank 1

Prueba de rendimiento NCCL de varios nodos en P3dn.24xlarge

Para comprobar el rendimiento de NCCL con EFA, ejecute la prueba de rendimiento de NCCL estándarque está disponible en el repositorio oficial de pruebas de NCCL. La DLAMI incluye ya esta prueba paraCUDA 10 y CUDA 10.1. También puede ejecutar su propio script con EFA.

Cuando cree su propio script, siga estas directrices:

• Indique la marca FI_PROVIDER="efa" para habilitar el uso de EFA.• Utilice la ruta completa a mpirun, tal y como se muestra en el ejemplo, mientras ejecuta aplicaciones

NCCL con EFA.• Cambie los parámetros np y N en función del número de instancias y GPU del clúster.• Añada la marca NCCL_DEBUG=INFO y asegúrese de que los registros indiquen el uso de EFA como

“Selected Provider is EFA” (El proveedor seleccionado es EFA).• Utilice el comando watch nvidia-smi en cualquiera de los nodos miembro para monitorizar el uso de

la GPU.

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

El resultado debería tener el siguiente aspecto.

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

76

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


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

77

Deep Learning AMI Guía para desarrolladoresMonitorización y optimización de GPU

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

Monitorización y optimización de GPULa siguiente sección le guiará en el proceso de configurar las opciones de optimización y monitorizaciónde GPU. Esta sección está organizada como un flujo de trabajo típico en la que se monitoriza elprocesamiento previo y el entrenamiento.

• Monitorización (p. 79)• Monitorización de GPU con CloudWatch (p. 79)

• Optimización (p. 81)

78


• Procesamiento previo (p. 82)• Entrenamiento (p. 83)

MonitorizaciónLa DLAMI viene preinstalada con varias herramientas de monitorización de GPU. Esta guía tambiénmenciona las herramientas que están disponibles para su descarga e instalación.

• Monitorización de GPU con CloudWatch (p. 79): una utilidad preinstalada que notifica las estadísticasde uso de GPU a Amazon CloudWatch.

• CLI de nvidia-smi: una utilidad para monitorizar el uso general de memoria y computación de GPU. Estautilidad viene preinstalada en la AWS Deep Learning AMI (DLAMI).

• Biblioteca de C de NVML: una API basada en C para obtener acceso directo a las funciones deadministración y monitorización de GPU. Esta API la utiliza internamente la CLI de nvidia-smi y vienepreinstalada en la DLAMI. También tiene enlaces a Python y Perl para facilitar el desarrollo en dichoslenguajes. La utilidad gpumon.py preinstalada en la DLAMI utiliza el paquete pynvml package de nvidia-ml-py.

• NVIDIA DCGM: una herramienta de administración de clústeres. Visite la página del desarrollador paraobtener información sobre cómo instalar y configurar esta herramienta.

Tip

Consulte el blog de desarrolladores de NVIDIA para obtener la información más reciente sobre eluso de las herramientas de CUDA instaladas en la DLAMI:

• Monitoring TensorCore utilization using Nsight IDE and nvprof.

Monitorización de GPU con CloudWatch

Cuando utilice la DLAMI con una GPU, es probable que sienta la necesidad de realizar un seguimiento desu uso durante el entrenamiento o la inferencia. Esto puede resultar útil para optimizar la canalización dedatos y ajustar la red de aprendizaje profundo.

Una utilidad denominada gpumon.py viene preinstalada en la DLAMI. Se integra con CloudWatch y escompatible con la monitorización del uso por GPU: memoria de GPU, temperatura de GPU y potencia deGPU. El script envía periódicamente los datos monitorizados a CloudWatch. Puede configurar el grado dedetalle de los datos que se envían a CloudWatch cambiando unos pocos ajustes en el script. Sin embargo,antes de ejecutar el script tendrá que configurar CloudWatch para recibir las métricas.

Cómo configurar y ejecutar la monitorización de GPU con CloudWatch

1. Cree un usuario de IAM o modifique uno existente con objeto de tener una política para publicar lamétrica en CloudWatch. Si crea un usuario nuevo, anote las credenciales, ya que las necesitará en elsiguiente paso.

La política de IAM que se va a buscar es "cloudwatch:PutMetricData". La política que se añade es lasiguiente:

{ "Version": "2012-10-17", "Statement": [ { "Action": [ "cloudwatch:PutMetricData",

79

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

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

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

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/


], "Effect": "Allow", "Resource": "*" } ]}

Tip

Para obtener más información sobre cómo crear un usuario de IAM y añadir políticas paraCloudWatch, consulte la documentación de CloudWatch.

2. En la DLAMI, ejecute AWS configure y especifique las credenciales de usuario de IAM.

$ aws configure

3. Es posible que tenga que realizar algunas modificaciones en la utilidad gpumon antes de ejecutarla.Puede encontrar la utilidad gpumon y el archivo README en la siguiente ubicación.

Folder: ~/tools/GPUCloudWatchMonitorFiles: ~/tools/GPUCloudWatchMonitor/gpumon.py ~/tools/GPUCloudWatchMonitor/README

Opciones:

• Cambie la región en gpumon.py si la instancia NO está en us-east-1.• Cambie otros parámetros como el namespace de CloudWatch o el periodo de notificación constore_resolution.

4. Actualmente, el script solo es compatible con Python 2.7. Active el entorno de Python 2.7 de su marcode trabajo preferido o active el entorno general de Python 2.7 de la DLAMI.

$ source activate python2

5. Ejecute la utilidad gpumon en segundo plano.

(python2)$ gpumon.py &

6. Abra https://console.aws.amazon.com/cloudwatch/ en el navegador y seleccione la métrica. Tendrá unespacio de nombres denominado "'DeepLearningTrain".

Tip

Puede cambiar el espacio de nombres modificando gpumon.py. También puede modificar elintervalo de notificación ajustando store_resolution.

A continuación, se muestra un gráfico de CloudWatch de ejemplo con información sobre una ejecución degpumon.py para monitorizar un trabajo de entrenamiento en una instancia p2.8xlarge.

80

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/


Es posible que le interesen estos otros temas sobre la monitorización y optimización de GPU:


• Optimización (p. 81)• Procesamiento previo (p. 82)• Entrenamiento (p. 83)

OptimizaciónPara sacar el máximo partido de las GPU, puede optimizar la canalización de datos y ajustar la red deaprendizaje profundo. Tal como se describe en el siguiente gráfico, una implementación ingenua o básicade una red neuronal podría utilizar la GPU de un modo incoherente y no aprovechar todo su potencial. Aloptimizar el procesamiento previo y la carga de datos, es posible reducir el cuello de botella de la CPU a

81


la GPU. Puede ajustar la propia red neuronal mediante la hibridación (si el marco de trabajo la admite),ajustando el tamaño del lote y sincronizando las llamadas. También puede utilizar entrenamiento deprecisión múltiple (float16 o int8) en la mayoría de los marcos de trabajo, lo que puede tener un efectodrástico en la mejora del rendimiento.

El gráfico siguiente muestra la mejora acumulativa del rendimiento que se obtiene cuando se aplicandistintas optimizaciones. Los resultados dependerán de los datos que esté procesando y de la red que estéoptimizando.

Ejemplo de optimizaciones del rendimiento de la GPU. Fuente del gráfico: Performance Tricks with MXNetGluon

Las siguientes guías introducen opciones que funcionarán con la DLAMI y que le ayudarán a aumentar elrendimiento de la GPU.

Temas• Procesamiento previo (p. 82)• Entrenamiento (p. 83)

Procesamiento previoEl procesamiento previo de los datos a través de transformaciones o aumentos es con frecuencia unproceso asociado a la CPU y puede ser el cuello de botella en la canalización general. Los marcos de

82

https://github.com/ThomasDelteil/PerformanceTricksMXNetGluon

https://github.com/ThomasDelteil/PerformanceTricksMXNetGluon


trabajo tienen operadores integrados para el procesamiento de imágenes, pero DALI (Data AugmentationLibrary) demuestra un rendimiento mejorado sobre las opciones integradas de los marcos de trabajo.

• Biblioteca de aumento de datos de NVIDIA (DALI): DALI descarga el aumento de datos a la GPU. Noestá preinstalada en la DLAMI, pero puede obtener acceso a ella instalando o cargando un contenedorde marcos de trabajo compatible en la DLAMI o en otra instancia Amazon Elastic Compute Cloud.Consulte la página del proyecto DALI en el sitio web de NVIDIA para obtener más información.

Tip

Vea este interesante vídeo en el sitio web GPU Tech Conference sobre la optimización decanalizaciones de datos. Incluye ejemplos de MXNet, TensorFlow y Caffe2 que utiliza uncomplemento de DALI.

• nvJPEG: una biblioteca de decodificadores JPEG acelerada por GPU para programadores de C.Admite la decodificación de imágenes únicas o de lotes de imágenes, así como las operaciones detransformación subsiguientes tan frecuentes en el aprendizaje profundo. nvJPEG viene integrada enDALI, pero puede descargarla en la página de nvjpeg del sitio web de NVIDIA y utilizarla de formaindependiente.




Entrenamiento

El entrenamiento de precisión mixta permite implementar redes de mayor tamaño con la misma cantidadde memoria, o reducir el uso de esta en comparación con las redes de precisión única o doble, lo quese traduce en un aumento del rendimiento informático. También ofrece el beneficio de transferencias dedatos más pequeñas y rápidas, un factor importante en el entrenamiento distribuido con varios nodos.Para utilizar el entrenamiento de precisión mixta es necesario ajustar el envío de datos y el escaladode pérdidas. Las siguientes guías describen cómo realizar esta operación en los marcos de trabajocompatibles con la precisión mixta.

• SDK de aprendizaje profundo de NVIDIA: documentos disponibles en el sitio web de NVIDIA quedescriben la implementación de la precisión mixta en NVCaffe, Caffe2, CNTK, MXNet, PyTorch,TensorFlow y Theano.

Tip

Asegúrese de consultar el sitio web de su marco de trabajo preferido y busque "mixed precision"o "fp16" para conocer las técnicas de optimización más recientes. A continuación se muestranalgunas guías de precisión mixta que pueden resultarle de utilidad:

• Mixed-precision training with TensorFlow (vídeo): en el sitio de blog de NVIDIA.• Mixed-precision training using float16 with MXNet: un artículo con preguntas frecuentes del sitio

web de MXNet.• NVIDIA Apex: a tool for easy mixed-precision training with PyTorch: un artículo de blog del sitio

web de NVIDIA.


83

https://docs.nvidia.com/deeplearning/sdk/dali-install-guide/index.html

http://on-demand.gputechconf.com/gtc/2018/video/S8906/

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 Guía para desarrolladoresAWS Inferentia



El chip de AWS Inferentia con DLAMIAWS Inferentia es un chip de aprendizaje automático personalizado diseñado por AWS que puede utilizarpara predicciones de inferencia de alto rendimiento. Para utilizar el chip, configure una instancia AmazonElastic Compute Cloud y use el kit de desarrollo de software (SDK) de AWS Neuron para invocar el chipInferentia. Para proporcionar a los clientes la mejor experiencia de Inferentia, Neuron está incorporado enla AWS Deep Learning AMI (DLAMI).

En los siguientes temas se muestra cómo comenzar a usar Inferentia con la DLAMI.

Contenido• Lanzamiento de una instancia de DLAMI con AWS Neuron (p. 84)• Uso de DLAMI con AWS Neuron (p. 88)

Lanzamiento de una instancia de DLAMI con AWS NeuronLa DLAMI más reciente ya está lista para usarla con AWS Inferentia y se suministra con el paquete de laAPI de AWS Neuron. Para iniciar una instancia de la DLAMI, consulte Lanzamiento y configuración de unaDLAMI. Una vez que tenga una DLAMI, siga estos pasos para asegurarse de que el chip AWS Inferentia ylos recursos de AWS Neuron están activos.

Contenido• Actualización del paquete de Neuron (p. 84)• Comprobación de la instancia (p. 85)• Identificación de dispositivos de AWS Inferentia (p. 85)• nr_hugepages (p. 85)• Demonio de tiempo de ejecución de Neuron (neuron-rtd) (p. 85)• Grupos de NeuronCores (p. 86)• Listado de modelos (p. 87)• Visualización del uso de recursos (p. 87)

Actualización del paquete de Neuron

Después de conectarse a la instancia Inf1, utilice los siguientes comandos para actualizar el paquete deNeuron.

Para Amazon Linux 2, ejecute:

sudo yum install aws-neuron-runtime-basesudo yum install aws-neuron-runtimesudo yum install aws-neuron-toolssudo yum install tensorflow-model-server-neuron

Para Ubuntu Linux, ejecute:

84

https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html

https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html


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

Comprobación de la instancia

Antes de usar la instancia, compruebe que esté correctamente instalada y configurada con Neuron.

Identificación de dispositivos de AWS Inferentia

Para identificar el número de dispositivos Inferentia de la instancia, utilice el siguiente comando:

neuron-ls

Si su instancia tiene dispositivos Inferentia asociados a ella, la salida tendrá un aspecto similar al siguiente:

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

La salida suministrada se toma de una instancia inf1.2xlarge. La primera columna muestra el ID de funcióndel dispositivo del bus PCI. La segunda columna muestra el ID lógico asignado al dispositivo. Este IDlógico se usa durante la configuración del demonio de tiempo de ejecución de Neuron (neuron-rtd). Latercera columna muestra el número de NeuronCores disponibles. Las dos últimas columnas muestran laconexión a cualquier otro dispositivo Inferentia. Debido a que esta es una sola instancia Inferentia, estas seencuentran vacías.

nr_hugepages

vm.nr_hugepages es una configuración de todo el sistema para administrar páginas de gran tamaño enmemoria, además del tamaño de página estándar de 4 KB. Esta configuración es importante para la APIde Neuron, porque utiliza páginas enormes. Ejecute el siguiente comando para ver la configuración devm.nr_hugepages para esta instancia:

grep HugePages_Total /proc/meminfo | awk {'print $2'}

El requisito mínimo de vm.nr_hugepages es de 128 por dispositivo AWS Inferentia.

Demonio de tiempo de ejecución de Neuron (neuron-rtd)

Al iniciar cualquier instancia Inf1, el demonio de tiempo de ejecución de Neuron (neuron-rtd) deberíainiciarse automáticamente. Puede comprobar que neuron-rtd se encuentra activo mediante el siguientecomando:

sudo systemctl status neuron-rtd

85


El resultado debería tener un aspecto similar al siguiente:

# 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

Puede haber situaciones en las que deba iniciar y detener neuron-rtd.

Para iniciar neuron-rtd, utilice el siguiente comando:

sudo systemctl restart neuron-rtd

Para detener neuron-rtd, utilice el siguiente comando:

sudo systemctl stop neuron-rtd

Grupos de NeuronCores

Una NeuronCore (NC) es cada una de las cuatro unidades de ejecución contenidas en los dispositivosInferentia. Se pueden combinar varios NC se para formar un grupo de NeuronCores (NCG). La capa delmarco de trabajo de Neuron crea automáticamente un grupo de NeuronCores predeterminado. Para veruna lista de NCG disponibles, utilice el siguiente comando:

neuron-cli list-ncg

Sus NCG activos se mostrarán en la salida de la siguiente manera:

Device 1 NC count 4+-------+----------+--------------------+----------------+| NCG ID| NC COUNT | DEVICE START INDEX | NC START INDEX |+-------+----------+--------------------+----------------+| 1 | 1 | 0 | 0 || 2 | 1 | 0 | 1 |

86


| 3 | 2 | 0 | 2 |+-------+----------+--------------------+----------------+

Si no ha configurado un NCG, el comando devolverá el siguiente resultado:

No NCG Found

Si necesita descargar todos los modelos y eliminar todos los NCG creados por el marco de trabajo, utiliceel siguiente comando:

neuron-cli reset

Listado de modelos

Los modelos se pueden cargar en un NCG. Se pueden cargar varios modelos en un mismo NCG, perosolo puede haber un modelo en el estado STARTED (Iniciado). Solo se puede ejecutar la inferencia en losmodelos cuyo estado sea STARTED (Iniciado).

Para ver todos los modelos cargados en el NCG, utilice el siguiente comando:

$ neuron-cli list-model

Los modelos cargados en el NCG se mostrarán en la salida de la siguiente manera:

Found 3 model10003 MODEL_STATUS_LOADED 110001 MODEL_STATUS_STARTED 110002 MODEL_STATUS_STARTED 1

En la salida, 10001 y 10002 son identificadores únicos para los modelos cargados en el NCG. Si no hacargado ningún modelo en el NCG, verá el siguiente resultado:

Found 0 models

Visualización del uso de recursos

Cada modelo cargado en el NCG consume una cantidad de memoria en el host y el dispositivo y unporcentaje del NeuronCore. El uso del NGC se puede ver ejecutando el siguiente comando:

neuron-top

El uso del NGC se mostrará en la salida de la siguiente manera:

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 %

87


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

Si no ha cargado ningún modelo, su salida tendrá el siguiente aspecto:

NN Models: 0 total, 0 runningNumber of VNCs tracked: 0DLR Model Node ID Subgraph Exec. Unit Host Mem MLA Mem Neuron core %

Paso siguiente

Uso de DLAMI con AWS Neuron (p. 88)

Uso de DLAMI con AWS NeuronUn flujo de trabajo típico con el AWS Neuron SDK consiste en compilar un modelo de aprendizajeautomático previamente entrenado en un servidor de compilación. Después de esto, distribuya losartefactos a las instancias Inf1 para su ejecución. AWS Deep Learning AMI (DLAMI) viene preinstalado contodo lo que se necesita para compilar y ejecutar inferencias en una instancia Inf1 que usa Inferentia.

En las siguientes secciones se describe cómo utilizar la DLAMI con Inferentia.

Contenido• Uso de TensorFlow-Neuron y el compilador AWS Neuron (p. 88)• Uso de TensorFlow Serving de AWS Neuron (p. 91)• Uso de MXNet-Neuron y el compilador de AWS Neuron (p. 93)• Uso de la distribución de modelos de MXNet-Neuron (p. 96)• Uso de PyTorch-Neuron y el compilador de AWS Neuron (p. 99)

Uso de TensorFlow-Neuron y el compilador AWS Neuron

Este tutorial muestra cómo utilizar el compilador AWS Neuron para compilar el modelo de KerasResNet-50 y exportarlo como modelo guardado en formato SavedModel. Este formato es un formatointercambiable típico del modelo de TensorFlow. También aprenderá a ejecutar la inferencia en unainstancia Inf1 con entrada de ejemplo.

Para obtener más información sobre el SDK de Neuron, consulte la documentación del SDK de Neuronpara AWS.

Contenido• Requisitos previos (p. 88)• Activación del entorno Conda (p. 89)• Compilación de Resnet50 (p. 89)• Inferencia ResNet50 (p. 90)

Requisitos previos

Antes de utilizar este tutorial, debería haber completado los pasos de configuración de Uso de DLAMI conAWS Neuron (p. 88). También debe estar familiarizado con el aprendizaje profundo y con el uso de laDLAMI.

88

https://github.com/aws/aws-neuron-sdk



Activación del entorno Conda

Active el entorno Conda de TensorFlow-Neuron mediante el siguiente comando:

source activate aws_neuron_tensorflow_p36

Actualice el paquete Neuron mediante el siguiente comando:

conda update tensorflow-neuron

Para salir del entorno Conda actual, ejecute el siguiente comando:

source deactivate

Compilación de Resnet50

Cree un script de Python llamada denominado tensorflow_compile_resnet50.py que tenga elsiguiente contenido. Este script de Python compila el modelo Keras ResNet50 y lo exporta como unmodelo guardado.

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

89


Compile el modelo con el siguiente comando:

python tensorflow_compile_resnet50.py

El proceso de compilación tardará unos minutos. Cuando concluya, la salida debe tener el siguienteaspecto:

...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 ./ws_resnet50/resnet50 to ./ws_resnet50/resnet50_neuron...

Después de la compilación, el modelo guardado se comprime en ws_resnet50/resnet50_neuron.zip. Descomprima el modelo y descargue la imagen de muestra para la inferenciamediante los siguientes comandos:

unzip ws_resnet50/resnet50_neuron.zip -d .curl -O https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg

Inferencia ResNet50

Cree un script de Python llamada denominado tensorflow_infer_resnet50.py que tenga elsiguiente contenido. Este script ejecuta la inferencia en el modelo descargado utilizando un modelo deinferencia compilado previamente.

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 = './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])

Ejecute la inferencia en el modelo mediante el siguiente comando:

python tensorflow_infer_resnet50.py

90


El resultado debería tener el siguiente aspecto:

...[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]

Paso siguiente

Uso de TensorFlow Serving de AWS Neuron (p. 91)

Uso de TensorFlow Serving de AWS Neuron

En este tutorial se muestra cómo construir un gráfico y añadir un paso de compilación de AWS Neuronantes de exportar el modelo guardado para utilizarlo con TensorFlow Serving. TensorFlow Serving esun sistema de servicio que le permite escalar la inferencia a través de una red. TensorFlow Servingde Neuron utiliza la misma API que TensorFlow Serving normal. La única diferencia es que se debecompilar un modelo guardado para AWS Inferentia y el punto de entrada es un binario diferentedenominado tensorflow_model_server_neuron. El binario se encuentra en /usr/local/bin/tensorflow_model_server_neuron y está preinstalado en la DLAMI.


Contenido• Requisitos previos (p. 91)• Activación del entorno Conda (p. 91)• Compilación y exportación del modelo guardado (p. 92)• Distribución del modelo guardado (p. 92)• Generación de solicitudes de inferencia al servidor de modelos (p. 93)

Requisitos previos



Active el entorno Conda de TensorFlow-Neuron mediante el siguiente comando:

source activate aws_neuron_tensorflow_p36


conda update tensorflow-neuron

Si necesita salir del entorno Conda actual, ejecute:

source deactivate

91




Compilación y exportación del modelo guardado

Cree un script de Python denominado tensorflow-model-server-compile.py con el siguientecontenido. Este script construye un gráfico y lo compila usando Neuron. A continuación, exporta el gráficocompilado como un modelo guardado.

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

Distribución del modelo guardado

Una vez compilado el modelo, puede usar el siguiente comando para distribuir el modelo guardado con elbinario tensorflow_model_server_neuron:

tensorflow_model_server_neuron --model_name=resnet50_inf1 \ --model_base_path=$HOME/resnet50_inf1/ --port=8500 &

El resultado debería tener el siguiente aspecto. El servidor almacena el modelo compilado de maneraprovisional en la DRAM del dispositivo Inferentia para preparar la inferencia.

...2019-11-22 01:20:32.075856: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:311] SavedModel load for tags { serve }; Status: success. Took 40764 microseconds.2019-11-22 01:20:32.075888: I tensorflow_serving/servables/tensorflow/saved_model_warmup.cc:105] No warmup data file found at /home/ubuntu/resnet50_inf1/1/assets.extra/tf_serving_warmup_requests

92


2019-11-22 01:20:32.075950: I tensorflow_serving/core/loader_harness.cc:87] Successfully loaded servable version {name: resnet50_inf1 version: 1}2019-11-22 01:20:32.077859: I tensorflow_serving/model_servers/server.cc:353] Running gRPC ModelServer at 0.0.0.0:8500 ...

Generación de solicitudes de inferencia al servidor de modelos

Cree un script de Python denominado tensorflow-model-server-infer.py con el siguientecontenido. Este script ejecuta la inferencia a través de gRPC, que es el marco de trabajo de servicio.

import numpy as npimport grpcimport tensorflow as tffrom 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))

Ejecute la inferencia en el modelo utilizando gRPC con el siguiente 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 de MXNet-Neuron y el compilador de AWS NeuronLa API de compilación de MXNet-Neuron proporciona un método para compilar un gráfico de modelo quese puede ejecutar en un dispositivo AWS Inferentia.

En este ejemplo, se utiliza la API para compilar un modelo ResNet-50 y usarlo para ejecutar la inferencia.


Contenido

93




• Requisitos previos (p. 94)• Activación del entorno Conda (p. 94)• Compilación de Resnet50 (p. 94)• Inferencia ResNet50 (p. 95)

Requisitos previos



Active el entorno Conda de MXNet-Neuron mediante el siguiente comando:

source activate aws_neuron_mxnet_p36


conda update mxnet-neuron

Para salir del entorno Conda actual, ejecute:

source deactivate


Cree un script de Python denominado mxnet_compile_resnet50.py con el siguiente contenido. Estescript usa la API de Python de compilación de MXNet-Neuron para compilar un 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)


94


python mxnet_compile_resnet50.py

La compilación tardará unos minutos. Cuando la compilación haya finalizado, los siguientes archivosestarán en su directorio actual:

resnet-50-0000.paramsresnet-50-symbol.jsoncompiled_resnet50-0000.paramscompiled_resnet50-symbol.json

Inferencia ResNet50

Cree un script de Python denominado mxnet_infer_resnet50.py con el siguiente contenido. Estescript descarga una imagen de muestra y la utiliza para ejecutar la inferencia con el modelo compilado.


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

Ejecute la inferencia con el modelo compilado mediante el siguiente comando:

python mxnet_infer_resnet50.py


95


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

Paso siguiente

Uso de la distribución de modelos de MXNet-Neuron (p. 96)

Uso de la distribución de modelos de MXNet-NeuronEn este tutorial, aprenderá a utilizar un modelo de MXNet previamente entrenado para realizar laclasificación de imágenes en tiempo real con Multi Model Server (MMS). MMS es una herramienta flexibley fácil de usar para distribuir modelos de aprendizaje profundo que se entrenan mediante cualquier marcode trabajo de aprendizaje automático o aprendizaje profundo. Este tutorial incluye un paso de compilaciónmediante AWS Neuron, así como una implementación de MMS utilizando MXNet.


Contenido• Requisitos previos (p. 96)• Activación del entorno Conda (p. 96)• Descarga del código de ejemplo (p. 96)• Compile el modelo. (p. 97)• Ejecutar inferencia (p. 98)

Requisitos previos



Active el entorno Conda de MXNet-Neuron mediante el siguiente comando:

source activate aws_neuron_mxnet_p36


conda update mxnet-neuron


source deactivate

Descarga del código de ejemplo

Para ejecutar este ejemplo, descargue el código de ejemplo mediante los siguientes comandos:

96




git clone https://github.com/awslabs/multi-model-servercd multi-model-server/examples/mxnet_vision

Compile el modelo.

Cree un script de Python denominado multi-model-server-compile.py con el siguiente contenido.Este script compila el modelo ResNet50 en el destino del dispositivo de 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 modelsym, 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 el modelo, utilice el siguiente 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!

Cree un archivo signature.json con el siguiente contenido para configurar el nombre y la forma deentrada:

{ "inputs": [ { "data_name": "data", "data_shape": [ 1,

97


3, 224, 224 ] } ]}

Descargue el archivo synset.txt con el siguiente comando. Este archivo es una lista de nombres paralas clases de predicción de ImageNet.

curl -O https://s3.amazonaws.com/model-server/model_archive_1.0/examples/squeezenet_v1.1/synset.txt

Cree una clase de servicio personalizada siguiendo la plantilla de la carpeta model_server_template.Copie la plantilla en su directorio de trabajo actual mediante el siguiente comando:

cp -r ../model_service_template/* .

Edite el módulo mxnet_model_service.py para reemplazar el contexto mx.cpu() por el contextomx.neuron() de la siguiente manera. También necesita comentar la copia de datos innecesaria paramodel_input, porque MXNet-Neuron no es compatible con las API NDArray y 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]

Empaquete el modelo con model-archiver utilizando los siguientes comandos:

cd ~/multi-model-server/examplesmodel-archiver --force --model-name resnet-50_compiled --model-path mxnet_vision --handler mxnet_vision_service:handle

Ejecutar inferencia

Inicie Multi Model Server y cargue el modelo que utiliza la API RESTful mediante los siguientes comandos.Asegúrese de que neuron-rtd se está ejecutando con la configuración predeterminada.

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

Ejecute la inferencia utilizando una imagen de ejemplo con los siguientes comandos:

curl -O https://raw.githubusercontent.com/awslabs/multi-model-server/master/docs/images/kitten_small.jpg

98


curl -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" }]

Para limpiar después de la prueba, ejecute un comando delete a través de la API RESTful y detenga elservidor modelo mediante los siguientes comandos:

curl -X DELETE http://127.0.0.1:8081/models/resnet-50_compiled

multi-model-server --stop

neuron-cli reset

Debería ver los siguientes datos de salida:

{ "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 de PyTorch-Neuron y el compilador de AWS NeuronLa API de compilación de PyTorch-Neuron proporciona un método para compilar un gráfico de modelo quese puede ejecutar en un dispositivo AWS Inferentia.

Un modelo entrenado debe compilarse en un destino de Inferentia antes de poder implementarlo eninstancias Inf1. El siguiente tutorial compila el modelo ResNet50 de torchvision y lo exporta como móduloTorchScript guardado. A continuación, el modelo se utiliza para ejecutar la inferencia.

Para mayor comodidad, el tutorial utiliza una instancia Inf1 tanto para la compilación como para lainferencia. En la práctica, puede compilar el modelo con otro tipo de instancia, como la familia de

99


instancias c5. A continuación, debe implementar el modelo compilado en el servidor de inferencia Inf1.Para obtener más información, consulte la documentación del SDK de AWS Neuron PyTorch.

Contenido• Requisitos previos (p. 100)• Activación del entorno Conda (p. 100)• Compilación de Resnet50 (p. 100)• Inferencia ResNet50 (p. 101)

Requisitos previos



Active el entorno Conda de PyTorch-Neuron mediante el siguiente comando:

source activate aws_neuron_pytorch_p36


source deactivate


Cree un script de Python denominado pytorch_trace_resnet50.py con el siguiente contenido. Estescript usa la API de Python de compilación de PyTorch-Neuron para compilar un 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")

Ejecute el script de compilación.

python pytorch_trace_resnet50.py

La compilación tardará unos minutos. Cuando la compilación haya finalizado, el modelo compilado seguarda como resnet50_neuron.pt en el directorio local.

100

https://github.com/aws/aws-neuron-sdk/blob/master/docs/pytorch-neuron/tutorial-compile-infer.md


Inferencia ResNet50

Cree un script de Python denominado pytorch_infer_resnet50.py con el siguiente contenido. Estescript descarga una imagen de muestra y la utiliza para ejecutar la inferencia con el 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 = []

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

Ejecute la inferencia con el modelo compilado mediante el siguiente comando:

101

Deep Learning AMI Guía para desarrolladoresInferencia

python pytorch_infer_resnet50.py


Top 5 labels: ['tiger', 'lynx', 'tiger_cat', 'Egyptian_cat', 'tabby']

InferenciaEn esta sección, se proporcionan tutoriales sobre cómo ejecutar la inferencia utilizando los marcos detrabajo y las herramientas de la DLAMI.

Si desea ver tutoriales sobre el uso de Elastic Inference, consulte Trabajar con Amazon Elastic Inference

Inferencia con marcos de inferencia• Uso de Apache MXNet para inferencia con un modelo ONNX (p. 102)• Uso de Apache MXNet para inferencia con un modelo de ResNet-50 (p. 103)• Cómo utilizar CNTK para las inferencias con un modelo ONNX (p. 104)

Herramientas de inferencia• Model Server for Apache MXNet (MMS) (p. 114)• TensorFlow Serving (p. 116)

Uso de Apache MXNet para inferencia con un modelo ONNXCómo utilizar un modelo ONNX para la inferencia de imágenes con MXNet

1. • (Opción para Python 3) - Active el entorno MXNet de Python 3:


• (Opción para Python 2) - Active el entorno MXNet de Python 2:


2. En los pasos restantes se supone que está utilizando el entorno mxnet_p36.3. Descargue una imagen de un perro esquimal.

$ curl -O https://upload.wikimedia.org/wikipedia/commons/b/b5/Siberian_Husky_bi-eyed_Flickr.jpg

4. Descargue una lista de clases para trabajar con este modelo.

$ curl -O https://gist.githubusercontent.com/yrevar/6135f1bd8dcf2e0cc683/raw/d133d61a09d7e5a3b36b8c111a8dd5c4b5d560ee/imagenet1000_clsid_to_human.pkl

5. Utilice su editor de texto preferido para crear un script que tenga el siguiente contenido. Este scriptutilizará la imagen del perro esquimal, obtendrá un resultado de predicción de un modelo entrenado

102

https://docs.aws.amazon.com/elastic-inference/latest/developerguide/working-with-ei.html


previamente y, a continuación, lo buscará en el archivo de clases para obtener un resultado depredicción.

import mxnet as mximport 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()

# 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])

6. A continuación, ejecute el script y debería ver un resultado tal y como se indica a continuación:

248Eskimo dog, husky

Uso de Apache MXNet para inferencia con un modelo deResNet-50Cómo utilizar un modelo de MXNet entrenado previamente con la API de símbolo para lainferencia de imágenes con MXNet





2. En los pasos restantes se supone que está utilizando el entorno mxnet_p36.

103


3. Utilice su editor de texto preferido para crear un script que tenga el siguiente contenido. Este scriptdescargará los archivos del modelo de ResNet-50 (resnet-50-0000.params y resnet-50-symbol.json)y la lista de etiquetas (synset.txt), descargará una imagen de un gato para obtener un resultado depredicción del modelo entrenado previamente y, a continuación, buscará el resultado en la lista deetiquetas para obtener un resultado de predicción.


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

Cómo utilizar CNTK para las inferencias con un modelo ONNXNote


104


Note

El modelo VGG-16 utilizado en este tutorial consume una gran cantidad de memoria. Alseleccionar la instancia de , puede que necesite una instancia con más de 30 GB de RAM.

Cómo utilizar un modelo ONNX para las inferencias con CNTK

1. • (Opción para Python 3) - Active el entorno CNTK de Python 3:


• (Opción para Python 2) - Active el entorno CNTK de Python 2:


2. En los pasos restantes se supone que está utilizando el entorno cntk_p36.3. Cree un nuevo archivo con el editor de texto y utilice el siguiente programa en un script para abrir el

archivo en formato ONNX en CNTK.

import cntk as C# Import the Chainer 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!")

Después de ejecutar este script, CNTK habrá cargado el modelo.4. También puede probar a ejecutar inferencias con CNTK. En primer lugar, descargue una imagen de

un perro esquimal.


5. A continuación, descargar una lista de clases que funcionarán con este modelo.

$ curl -O https://gist.githubusercontent.com/yrevar/6135f1bd8dcf2e0cc683/raw/d133d61a09d7e5a3b36b8c111a8dd5c4b5d560ee/imagenet1000_clsid_to_human.pkl

6. Edite el script creado anteriormente para que tenga el siguiente contenido. Esta nueva versión utilizarála imagen del perro esquimal, obtendrá un resultado de predicción y, a continuación, lo buscará en elarchivo de clases para obtener un resultado de predicción.

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

105

Deep Learning AMI Guía para desarrolladoresUso de marcos de trabajo con ONNX

print(labels_dict[top_class])


248Eskimo dog, husky

Uso de marcos de trabajo con ONNXLa AMI de Deep Learning con Conda ahora es compatible con modelos de intercambio de red neuronalabierta (ONNX) para algunos marcos de trabajo. Elija uno de los temas que se indican a continuación paraobtener información acerca de cómo utilizar ONNX en su AMI de Deep Learning con Conda.

Acerca de ONNXEl intercambio de red neuronal abierta (ONNX) es un formato abierto que se usa para representar modelosde aprendizaje profundo. ONNX es compatible con Amazon Web Services, Microsoft, Facebook y muchosotros socios. Puede diseñar, entrenar e implementar modelos de aprendizaje profundo con cualquiermarco de trabajo que elija. El beneficio de los modelos ONNX es que se pueden mover entre marcos detrabajo con facilidad.

La AMI de Deep Learning con Conda actualmente destaca algunas de las características de ONNX en lasiguiente colección de tutoriales.

• Tutorial de MXNet a ONNX a CNTK (p. 106)• Tutorial de Chainer a ONNX a CNTK (p. 108)• Tutorial de Chainer a ONNX a MXNet (p. 109)• Tutorial de PyTorch a ONNX a CNTK (p. 111)• Tutorial de PyTorch a ONNX a MXNet (p. 112)

También puede consultar la documentación y los tutoriales del proyecto ONNX:

• Proyecto ONNX en GitHub• Tutoriales de ONNX

Tutorial de MXNet a ONNX a CNTKNote


Información general de ONNX

El intercambio de red neuronal abierta (ONNX) es un formato abierto que se usa para representar modelosde aprendizaje profundo. ONNX es compatible con Amazon Web Services, Microsoft, Facebook y muchosotros socios. Puede diseñar, entrenar e implementar modelos de aprendizaje profundo con cualquiermarco de trabajo que elija. El beneficio de los modelos ONNX es que se pueden mover entre marcos detrabajo con facilidad.

106

http://onnx.ai/

http://onnx.ai/

http://onnx.ai/

https://github.com/onnx/onnx

https://github.com/onnx/tutorials

http://onnx.ai/


En este tutorial se muestra cómo utilizar la AMI de Deep Learning con Conda con ONNX. Si sigue estospasos, puede entrenar un modelo o cargar un modelo preentrenado desde un marco de trabajo, exportareste modelo a ONNX y, a continuación, importar el modelo en otro marco de trabajo.

Requisitos previos de ONNXPara utilizar este tutorial de ONNX, debe disponer de acceso a una AMI de Deep Learning con Condaversión 12 o posterior. Para obtener más información sobre cómo empezar a usar una AMI de DeepLearning con Conda, consulte AMI de Deep Learning con Conda (p. 4).

Important

Estos ejemplos utilizan funciones que pueden requerir hasta 8 GB de memoria (o más).Asegúrese de elegir un tipo de instancia con memoria suficiente.

Lance una sesión de terminal con su AMI de Deep Learning con Conda para comenzar el siguiente tutorial.

Conversión de un modelo Apache MXNet (incubating) a ONNX y carga posteriordel modelo en CNTK

Cómo exportar un modelo de Apache MXNet (incubating)

Puede instalar la última compilación de MXNet en uno o en ambos entornos MXNet Conda en su AMI deDeep Learning con Conda.





2. En los pasos restantes se supone que está utilizando el entorno mxnet_p36.3. Descargue los archivos del 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 los archivos del modelo del formato MXNet a ONNX, cree un nuevo archivo con el editorde texto y utilice el siguiente programa en un 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)

Si bien pueden aparecer algunos mensajes de advertencia, puede pasarlos por alto de forma segurapor ahora. Después de ejecutar este script, verá el archivo .onnx que acaba de crear en el mismodirectorio.

107


5. Ahora que tiene un archivo ONNX, puede probar a ejecutar la inferencia con él mediante el siguienteejemplo:

• Cómo utilizar CNTK para las inferencias con un modelo ONNX (p. 104)

Tutoriales de ONNX

• Tutorial de MXNet a ONNX a CNTK (p. 106)• Tutorial de Chainer a ONNX a CNTK (p. 108)• Tutorial de Chainer a ONNX a MXNet (p. 109)• Tutorial de PyTorch a ONNX a MXNet (p. 112)• Tutorial de PyTorch a ONNX a CNTK (p. 111)

Tutorial de Chainer a ONNX a CNTKNote


Información general de ONNX



Requisitos previos de ONNX

Para utilizar este tutorial de ONNX, debe disponer de acceso a una AMI de Deep Learning con Condaversión 12 o posterior. Para obtener más información sobre cómo empezar a usar una AMI de DeepLearning con Conda, consulte AMI de Deep Learning con Conda (p. 4).

Important



Convertir un modelo Chainer a ONNX y luego cargar el modelo en CNTK

En primer lugar, active el entorno Chainer:


108

http://onnx.ai/


Cree un nuevo archivo con el editor de texto y utilice el siguiente programa en un script para recuperar unmodelo de Model Zoo de Chainer, luego expórtelo al 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)

Después de ejecutar este script, verá el archivo .onnx que acaba de crear en el mismo directorio.

Ahora que tiene un archivo ONNX, puede probar a ejecutar la inferencia con él mediante el siguienteejemplo:

• Cómo utilizar CNTK para las inferencias con un modelo ONNX (p. 104)

Tutoriales de ONNX


Tutorial de Chainer a ONNX a MXNetInformación general de ONNX



109

http://onnx.ai/



Important



Convertir un modelo Chainer a ONNX y luego cargar el modelo en MXNetEn primer lugar, active el entorno Chainer:


Cree un nuevo archivo con el editor de texto y utilice el siguiente programa en un script para recuperar unmodelo de Model Zoo de Chainer, luego expórtelo al 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)

Después de ejecutar este script, verá el archivo .onnx que acaba de crear en el mismo directorio.

Ahora que tiene un archivo ONNX, puede probar a ejecutar la inferencia con él mediante el siguienteejemplo:

• Uso de Apache MXNet para inferencia con un modelo ONNX (p. 102)

Tutoriales de ONNX

• Tutorial de MXNet a ONNX a CNTK (p. 106)• Tutorial de Chainer a ONNX a CNTK (p. 108)• Tutorial de Chainer a ONNX a MXNet (p. 109)• Tutorial de PyTorch a ONNX a MXNet (p. 112)

110


• Tutorial de PyTorch a ONNX a CNTK (p. 111)

Tutorial de PyTorch a ONNX a CNTKNote


Información general de ONNXEl intercambio de red neuronal abierta (ONNX) es un formato abierto que se usa para representar modelosde aprendizaje profundo. ONNX es compatible con Amazon Web Services, Microsoft, Facebook y muchosotros socios. Puede diseñar, entrenar e implementar modelos de aprendizaje profundo con cualquiermarco de trabajo que elija. El beneficio de los modelos ONNX es que se pueden mover entre marcos detrabajo con facilidad.



Important



Convertir un modelo PyTorch a ONNX y luego cargar el modelo en CNTKEn primer lugar, active el entorno PyTorch:


Cree un nuevo archivo con el editor de texto y utilice el siguiente programa en un script para entrenar unmodelo simulado en PyTorch, luego expórtelo al 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)

111

http://onnx.ai/


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)

Después de ejecutar este script, verá el archivo .onnx que acaba de crear en el mismo directorio. Ahora,cambie al entorno CNTK Conda para cargar el modelo con CNTK.

A continuación, active el entorno CNTK:

$ source deactivate$ source activate cntk_p36

Cree un nuevo archivo con el editor de texto y utilice el siguiente programa en un script para abrir elarchivo en formato ONNX en CNTK.

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)

Después de ejecutar este script, CNTK habrá cargado el modelo.

También puede exportar a ONNX mediante CNTK añadiendo lo siguiente a su script anterior y, acontinuación, ejecutándolo.

# Export the model to ONNX via the CNTK export APIz.save("cntk_model.onnx", format=C.ModelFormat.ONNX)

Tutoriales de ONNX


Tutorial de PyTorch a ONNX a MXNetInformación general de ONNX

El intercambio de red neuronal abierta (ONNX) es un formato abierto que se usa para representar modelosde aprendizaje profundo. ONNX es compatible con Amazon Web Services, Microsoft, Facebook y muchos

112

http://onnx.ai/


otros socios. Puede diseñar, entrenar e implementar modelos de aprendizaje profundo con cualquiermarco de trabajo que elija. El beneficio de los modelos ONNX es que se pueden mover entre marcos detrabajo con facilidad.


Requisitos previos de ONNX

Para utilizar este tutorial de ONNX, debe disponer de acceso a una AMI de Deep Learning con Condaversión 12 o posterior. Para obtener más información sobre cómo empezar a usar una AMI de DeepLearning con Conda, consulte AMI de Deep Learning con Conda (p. 4).

Important



Convertir un modelo PyTorch a ONNX y luego cargar el modelo en MXNet

En primer lugar, active el entorno PyTorch:


Cree un nuevo archivo con el editor de texto y utilice el siguiente programa en un script para entrenar unmodelo simulado en PyTorch, luego expórtelo al formato ONNX.

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

113

Deep Learning AMI Guía para desarrolladoresDistribución de modelos

model_onnx_path, verbose=False)print("Export of torch_model.onnx complete!")

Después de ejecutar este script, verá el archivo .onnx que acaba de crear en el mismo directorio. Ahora,cambie al entorno MXNet Conda para cargar el modelo con MXNet.

A continuación, active el entorno MXNet:

$ source deactivate$ source activate mxnet_p36

Cree un nuevo archivo con el editor de texto y utilice el siguiente programa en un script para abrir elarchivo en formato ONNX en 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())

Después de ejecutar este script, MXNet habrá cargado el modelo e imprimirá información básica delmodelo.

Tutoriales de ONNX


Distribución de modelosA continuación, se indican las opciones de distribución de modelos instaladas en la AMI de Deep Learningcon Conda. Haga clic en una de las opciones para obtener información acerca de cómo utilizarla.

Temas• Model Server for Apache MXNet (MMS) (p. 114)• TensorFlow Serving (p. 116)

Model Server for Apache MXNet (MMS)Model Server for Apache MXNet (MMS) es una herramienta flexible para servir modelos de aprendizajeprofundo que se han exportado de Apache MXNet (incubating) o se han exportado al formato de modelode intercambio de red neuronal abierta (ONNX). MMS viene preinstalado con la DLAMI con Conda. En estetutorial de MMS, se muestra cómo servir un modelo de clasificación de imágenes.

Temas• Servir un modelo de clasificación de imágenes en MMS (p. 115)

114

https://github.com/awslabs/mxnet-model-server/

http://mxnet.io/


• Otros ejemplos (p. 116)• Más información (p. 116)

Servir un modelo de clasificación de imágenes en MMSEn este tutorial se muestra cómo servir un modelo de clasificación de imágenes con MMS. El modelo seproporciona a través del MMS Model Zoo y se descarga automáticamente al iniciar MMS. Una vez que elservidor se está ejecutando, escucha las solicitudes de predicción. Al cargar una imagen, en este caso,una imagen de un gatito, el servidor devuelve una predicción de las 5 principales clases coincidente de las1000 clases con las que se entrenó el modelo. Puede encontrar más información sobre los modelos, cómose han entrenado y cómo probarlos en el MMS Model Zoo.

Para servir un modelo de clasificación de imágenes de ejemplo en MMS

1. Conéctese a la instancia Amazon Elastic Compute Cloud (Amazon EC2) de la AMI de Deep Learningcon Conda.

2. Active un entorno de MXNet:• Para MXNet y Keras 2 en Python 3 con CUDA 9.0 y MKL-DNN, ejecute este comando:


• Para MXNet y Keras 2 en Python 2 con CUDA 9.0 y MKL-DNN, ejecute este comando:


3. Ejecute MMS con el siguiente comando. Si añade > /dev/null, se silenciará la salida de registromientras ejecuta otras pruebas.

$ mxnet-model-server --start > /dev/null

MMS ahora se está ejecutando en su host y está escuchando solicitudes de inferencia.4. A continuación, utilice un comando curl para administrar los puntos de enlace de administración de

MMS e indicarle cuál es el modelo que desea que sirva.

$ 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. MMS necesita saber cuál es el número de procesos de trabajo que desea utilizar. Para esta prueba,puede utilizar 3.

$ curl -v -X PUT "http://localhost:8081/models/squeezenet_v1.1?min_worker=3"

6. Descargue una imagen de un gatito y envíela al punto de enlace de predicción de 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

El punto de enlace de predicción devuelve una predicción en JSON similar a las siguientes cincopredicciones principales, donde la imagen tiene una probabilidad del 94% de contener un gato egipcio,seguida de una probabilidad del 5,5% de que sea un lince o gato montés:

{ "prediction": [ [{

115

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


"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. Pruebe algunos imágenes más o, si ya ha terminado de realizar pruebas, detenga el servidor:

$ mxnet-model-server --stop

Este tutorial se centra en el servicio de modelos básicos. MMS también admite el uso de Elastic Inferencecon la distribución de modelos. Para obtener más información, consulte Model Serving with Amazon ElasticInference.

Cuando desee obtener más información sobre otras características de MMS, consulte la documentación deMMS en GitHub.

Otros ejemplosMMS dispone de una serie de ejemplos que puede ejecutar en la DLAMI. Puede verlas en el repositorio delproyecto MMS.

Más informaciónPara obtener más documentación de MMS, incluido cómo configurar MMS con Docker, o para utilizar lascaracterísticas más recientes de MMS, utilice la página del proyecto de MMS en GitHub.

TensorFlow ServingTensorFlow Serving es un sistema flexible que ofrece un alto desempeño a los modelos de aprendizajeautomático.

La tensorflow-serving-api viene preinstalada con AMI de Deep Learning con Conda. Encontrará unscript de ejemplo para entrenar, exportar y distribuir un modelo MNIST en ~/examples/tensorflow-serving/.

Para ejecutar cualquiera de estos ejemplos, primero conéctese a su AMI de Deep Learning con Conda yactive el entorno de TensorFlow para Python 2.7. Los scripts de ejemplo no son compatibles con Python3.x.


116

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

https://github.com/awslabs/mxnet-model-server/blob/master/docs/README.md

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/tree/master/examples

https://github.com/awslabs/mxnet-model-server

https://www.tensorflow.org/serving/



Ahora, desplácese a los directorios que contienen la carpeta de scripts de ejemplo.

$ cd ~/examples/tensorflow-serving/

Cómo servir un modelo de incepciónA continuación, se muestra un ejemplo que puede probar para servir distintos modelos como Inception. Porregla general, necesita un modelo servible y scripts de cliente descargados previamente en la DLAMI.

Cómo servir y probar la inferencia con un modelo de incepción

1. Descargue el modelo.

$ curl -O https://s3-us-west-2.amazonaws.com/aws-tf-serving-ei-example/inception.zip

2. Descomprima el modelo.

$ unzip inception.zip

3. Descargue una imagen de un perro esquimal.


4. Lance el servidor. Tenga en cuenta que, para Amazon Linux, debe cambiar el directorio que se utilizapara model_base_path de /home/ubuntu a /home/ec2-user.

$ tensorflow_model_server --model_name=inception --model_base_path=/home/ubuntu/examples/tensorflow-serving/SERVING_INCEPTION --port=9000

5. Con el servidor ejecutándose en primer plano tendrá que lanzar otra sesión de terminal paracontinuar. Abra un terminal nuevo y active TensorFlow con source activate tensorflow_p27. Acontinuación, utilice su editor de texto preferido para crear un script que tenga el siguiente contenido.Denomínelo inception_client.py. Este script tomará un nombre de archivo de imagen comoparámetro y obtendrá un resultado de predicción a partir del modelo entrenado previamente.

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'

117


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. Ahora ejecute el script pasando la ubicación y el puerto del servidor y el nombre de archivo de la fotodel perro esquimal como parámetros.

$ python inception_client.py --server=localhost:9000 --image Siberian_Husky_bi-eyed_Flickr.jpg

Cómo entrenar y servir un modelo de MNIST

En este tutorial vamos a exportar un modelo y después lo distribuiremos con la aplicacióntensorflow_model_server. Por último, puede probar el servidor del modelo con un script del cliente deejemplo.

Ejecute el script que entrenará y exportará un modelo MNIST. Como único argumento del scriptdebe proporcionar una ubicación de carpeta para guardar el modelo. Por ahora, lo pondremos enmnist_model. El script creará la carpeta por usted.

$ python mnist_saved_model.py /tmp/mnist_model

Sea paciente, ya que el script puede tardar un rato en proporcionar resultados. Cuando se hayacompletado el entrenamiento y se haya exportado el modelo, debería ver lo siguiente:

Done training!Exporting trained model to mnist_model/1Done exporting!

El siguiente paso consiste en ejecutar tensorflow_model_server para distribuir el modelo exportado.

$ tensorflow_model_server --port=9000 --model_name=mnist --model_base_path=/tmp/mnist_model

Se proporciona un script del cliente para probar el servidor.

Para probarlo, tendrá que abrir una nueva ventana de la terminal.

$ python mnist_client.py --num_tests=1000 --server=localhost:9000

Más características y ejemplos

Si está interesado en obtener más información acerca de TensorFlow Serving, visite el sitio web deTensorFlow.

También peude utilizar TensorFlow Serving con Amazon Elastic Inference. Revise la guía sobre cómo usarElastic Inference con TensorFlow Serving para obtener más información.

118




https://docs.aws.amazon.com/elastic-inference/latest/developerguide/ei-tensorflow-python.html

https://docs.aws.amazon.com/elastic-inference/latest/developerguide/ei-tensorflow-python.html

Deep Learning AMI Guía para desarrolladoresActualización de la DLAMI

Actualización de la DLAMIAquí encontrará información sobre la actualización de la DLAMI y consejos sobre la actualización desoftware en la DLAMI.

Temas• Actualización a una nueva versión de la DLAMI (p. 119)• Sugerencias para actualizaciones de software (p. 119)

Actualización a una nueva versión de la DLAMILas imágenes del sistema de DLAMI se actualizan de forma periódica para aprovechar las nuevasversiones del marco de aprendizaje profundo, CUDA y otras actualizaciones de software, así como parael ajuste del desempeño. Si lleva un tiempo utilizando una DLAMI y desea aprovechar una actualización,tendrá que volver a lanzar una nueva instancia. Además, tendría que transferir manualmente cualquierconjunto de datos, puntos de comprobación u otros datos valiosos. En lugar de ello, puede utilizar AmazonEBS para conservar los datos y asociarlos a una nueva DLAMI. De esta forma, puede actualizar a menudo,además de reducir el tiempo que se tarda en realizar la transición de los datos.

Note

Al asociar y desplazar volúmenes de Amazon EBS entre DLAMI, debe tener tanto las DLAMIcomo el nuevo volumen en la misma zona de disponibilidad.

1. Utilice la consola de Amazon EC2 para crear un nuevo volumen de Amazon EBS. Para obtenerindicaciones detalladas, consulte Creación de un volumen de Amazon EBS.

2. Asocie el volumen de Amazon EBS recién creado a la DLAMI existente. Para obtener indicacionesdetalladas, consulte Asociación de un volumen de Amazon EBS.

3. Transfiera sus datos, como por ejemplo, conjuntos de datos, puntos de comprobación y archivos deconfiguración.

4. Lance una DLAMI. Para obtener indicaciones detalladas, consulte Lanzamiento y configuración de unaDLAMI (p. 20).

5. Desvincule el volumen de Amazon EBS de la DLAMI antigua. Para obtener indicaciones detalladas,consulte Separación de un volumen de Amazon EBS.

6. Asocie el volumen de Amazon EBS a la nueva DLAMI. Siga las instrucciones desde el Paso 2 paraadjuntar el volumen.

7. Después de verificar que los datos están disponibles en su nueva DLAMI, detenga y termine la DLAMIantigua. Para obtener instrucciones de limpieza detalladas, consulte Eliminación (p. 22).

Sugerencias para actualizaciones de softwareDe vez en cuando, es posible que desee actualizar manualmente el software en la DLAMI. En general,se recomienda que utilice pip para actualizar paquetes de Python. También debería utilizar pip paraactualizar paquetes dentro de un entorno de Conda en la AMI de Deep Learning con Conda. Consulteel sitio web del marco de trabajo o del software para obtener las instrucciones de actualización y deinstalación.

Si le interesa ejecutar la última ramificación maestra de un paquete determinado, active el entornoadecuado y, a continuación, añada --pre al final del comando pip install --upgrade. Por ejemplo:

119

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 Guía para desarrolladoresActualizaciones de software

source activate mxnet_p36pip install --upgrade mxnet --pre

120

Deep Learning AMI Guía para desarrolladoresProtección de los datos

Seguridad en AWS Deep LearningAMI

La seguridad en la nube de AWS es la mayor prioridad. Como cliente de AWS, se beneficiará de unaarquitectura de red y un centro de datos diseñados para satisfacer los requisitos de seguridad de lasorganizaciones más exigentes.

La seguridad es una responsabilidad compartida entre AWS y usted. El modelo de responsabilidadcompartida la describe como seguridad de la nube y seguridad en la nube:

• Seguridad de la nube – AWS es responsable de proteger la infraestructura que ejecuta servicios deAWS en la nube de AWS. AWS también proporciona servicios que puede utilizar de forma segura. Losauditores externos prueban y verifican periódicamente la eficacia de nuestra seguridad como parte delos Programas de conformidad de AWS . Para obtener información sobre los programas de conformidadque se aplican a DLAMI, consulte Servicios de AWS en el ámbito del programa de conformidad.

• Seguridad en la nube – su responsabilidad viene determinada por el servicio de AWS que utilice.También es responsable de otros factores, incluida la confidencialidad de los datos, los requisitos de laempresa y la legislación y los reglamentos aplicables.

Esta documentación le ayuda a comprender cómo puede aplicar el modelo de responsabilidad compartidacuando se utiliza DLAMI. En los siguientes temas, aprenderá a configurar DLAMI para satisfacer susobjetivos de seguridad y conformidad. También aprenderá a utilizar otros servicios de AWS que leayudarán a monitorizar y proteger sus recursos de DLAMI.

Para obtener más información, consulte Seguridad en Amazon EC2.

Temas• Protección de datos en AWS Deep Learning AMI (p. 121)• Identity and Access Management en AWS Deep Learning AMI (p. 122)• Registro y monitorización en AWS Deep Learning AMI (p. 126)• Validación de la conformidad para AWS Deep Learning AMI (p. 126)• Resiliencia en AWS Deep Learning AMI (p. 127)• Seguridad de la infraestructura en AWS Deep Learning AMI (p. 127)

Protección de datos en AWS Deep Learning AMICM de AWS Deep Learning AMI cumple los requisitos del modelo de responsabilidad compartida deAWS, que incluye reglamentos y directrices para la protección de los datos. AWS es responsable deproteger la infraestructura global que ejecuta todos los servicios de AWS. AWS mantiene el control delos datos alojados en esta infraestructura, incluidos los controles de configuración de la seguridad para eltratamiento del contenido y los datos personales de los clientes. Los clientes de AWS y los socios de APN,que actúan como controladores o procesadores de datos, son responsables de todos los datos personalesque colocan en la nube de AWS.

Para fines de protección de datos, le recomendamos proteger las credenciales de la cuenta de AWS yconfigurar cuentas de usuario individuales con AWS Identity and Access Management (IAM), de modo quea cada usuario se le concedan únicamente los permisos necesarios para llevar a cabo su trabajo. Tambiénle recomendamos proteger sus datos de las siguientes formas:

121

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 Guía para desarrolladoresIdentity and Access Management

• Utilice la autenticación multifactor (MFA) con cada cuenta.• Utilice SSL/TLS para comunicarse con los recursos de AWS.• Configure la API y el registro de actividad del usuario con AWS CloudTrail.• Utilice las soluciones de cifrado de AWS, junto con todos los controles de seguridad predeterminados

dentro de los servicios de AWS.• Utilice los servicios de seguridad administrados avanzados como, por ejemplo, Amazon Macie, que

ayudan a detectar y proteger los datos personales almacenados en Amazon S3.

Le recomendamos encarecidamente que nunca introduzca información de identificación confidencial,como, por ejemplo, números de cuenta de sus clientes, en los campos de formato libre, como el campoName (Nombre). No debe especificar esta información cuando trabaje con DLAMI u otros servicios deAWS a través de la consola, la API, la AWS CLI o los SDK de AWS. Cualquier dato que escriba en DLAMIo en otros servicios se puede incluir en los registros de diagnóstico. Cuando proporcione una URL aun servidor externo, no incluya información de credenciales en la URL para validar la solicitud para eseservidor.

Para obtener más información sobre la protección de datos, consulte Protección de datos en AmazonEC2 y la entrada de blog relativa al modelo de responsabilidad compartida de AWS y GDPR en el blog deseguridad de AWS.

Identity and Access Management en AWS DeepLearning AMI

AWS Identity and Access Management (IAM) es un servicio de AWS que ayuda a un administrador acontrolar de forma segura el acceso a los recursos de AWS. Los administradores de IAM controlan quiénpuede ser autenticado (iniciar sesión) y estar autorizado (tener permisos) para utilizar los recursos deDLAMI. IAM es un servicio de AWS que se puede utilizar sin costo adicional.

Para obtener más información sobre Identity and Access Management, consulte Identity and AccessManagement para Amazon EC2.

Temas• Autenticación con identidades (p. 122)• Administración de acceso mediante políticas (p. 124)• IAM por Amazon EMR (p. 126)

Autenticación con identidadesLa autenticación es la manera de iniciar sesión en AWS mediante credenciales de identidad. Para obtenermás información acerca del inicio de sesión con la Consola de administración de AWS, consulte Laconsola de IAM y la página de inicio de sesión en la Guía del usuario de IAM.

Debe estar autenticado (haber iniciado sesión en AWS) como Usuario de la cuenta raíz de AWS, usuariode IAM o asumiendo un rol de IAM. También puede utilizar la autenticación de inicio de sesión único desu empresa o incluso iniciar sesión con Google o Facebook. En estos casos, su administrador habráconfigurado previamente la federación de identidad mediante roles de IAM. Cuando obtiene acceso a AWSmediante credenciales de otra empresa, asume un rol indirectamente.

Para iniciar sesión directamente en la Consola de administración de AWS, use su contraseña con sucorreo electrónico usuario raíz o su nombre de usuario de IAM. Puede obtener acceso a AWS medianteprogramación utilizando sus claves de acceso usuario raíz o de usuario de IAM. AWS proporciona SDK y

122

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/data-protection.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/data-protection.html

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 Guía para desarrolladoresAutenticación con identidades

herramientas de línea de comandos para firmar criptográficamente su solicitud con sus credenciales. Si noutiliza las herramientas de AWS, debe firmar usted mismo la solicitud. Para ello, utilice Signature Version4, un protocolo para autenticar solicitudes de API de entrada. Para obtener más información acerca de laautenticación de solicitudes, consulte Proceso de firma Signature Version 4 en la AWS General Reference.

Independientemente del método de autenticación que utilice, es posible que también deba proporcionarinformación de seguridad adicional. Por ejemplo, AWS le recomienda el uso de la autenticación multifactor(MFA) para aumentar la seguridad de su cuenta. Para obtener más información, consulte Uso de Multi-Factor Authentication (MFA) en AWS en la Guía del usuario de IAM.

Usuario raíz de la cuenta de AWSCuando se crea por primera vez una cuenta de AWS, se comienza con una única identidad de inicio desesión que tiene acceso completo a todos los servicios y recursos de AWS de la cuenta. Esta identidadrecibe el nombre de AWS de la cuenta de usuario raíz y se obtiene acceso a ella iniciando sesión con ladirección de correo electrónico y la contraseña que utilizó para crear la cuenta. Le recomendamos queno utilice usuario raíz en sus tareas cotidianas, ni siquiera en las tareas administrativas. En lugar de ello,es mejor ceñirse a la práctica recomendada de utilizar exclusivamente usuario raíz para crear el primerusuario de IAM. A continuación, guarde las credenciales de usuario raíz en un lugar seguro y utilícelasúnicamente para algunas tareas de administración de cuentas y servicios.

Usuarios y grupos de IAMUn usuario de IAM es una entidad de la cuenta de AWS que dispone de permisos específicos para unasola persona o aplicación. Un usuario de IAM puede tener credenciales a largo plazo, como un nombrede usuario y una contraseña o un conjunto de claves de acceso. Para obtener más información acerca decómo generar claves de acceso, consulte Administración de las claves de acceso de los usuarios de IAMen la Guía del usuario de IAM. Al generar claves de acceso para un usuario de IAM, asegúrese de ver yguardar de forma segura el par de claves. No puede recuperar la clave de acceso secreta en el futuro. Ensu lugar, debe generar un nuevo par de claves de acceso.

Un grupo de IAM es una identidad que especifica un conjunto de usuarios de IAM. No puede iniciar sesióncomo grupo. Puede usar los grupos para especificar permisos para varios usuarios a la vez. Los gruposfacilitan la administración de los permisos de grandes conjuntos de usuarios. Por ejemplo, podría tener ungrupo cuyo nombre fuese Administradores de IAM y conceder permisos a dicho grupo para administrar losrecursos de IAM.

Los usuarios son diferentes de los roles. Un usuario se asocia exclusivamente a una persona o aplicación,pero la intención es que cualquier usuario pueda asumir un rol que necesite. Los usuarios tienencredenciales permanentes a largo plazo y los roles proporcionan credenciales temporales. Para obtenermás información, consulte Cuándo crear un usuario de IAM (en lugar de un rol) en la Guía del usuario deIAM.

Roles de IAMUn rol de IAM es una entidad de la cuenta de AWS que dispone de permisos específicos. Es similar aun usuario de IAM, pero no está asociado a una determinada persona. Puede asumir temporalmente unrol de IAM en la Consola de administración de AWS cambiando de roles. Puede asumir un rol llamandoa una operación de la AWS CLI o de la API de AWS, o utilizando una URL personalizada. Para obtenermás información acerca de los métodos para el uso de roles, consulte Uso de roles de IAM en la Guía delusuario de IAM.

Los roles de IAM con credenciales temporales son útiles en las siguientes situaciones:

• Permisos de usuario temporales de IAM: un usuario de IAM puede asumir un rol de IAM para recibirtemporalmente permisos distintos que le permitan realizar una tarea concreta.

• Acceso de usuario federado: En lugar de crear un usuario de IAM, puede utilizar identidades existentesde AWS Directory Service, del directorio de usuarios de la empresa o de un proveedor de identidades

123

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

Deep Learning AMI Guía para desarrolladoresAdministración de acceso mediante políticas

web. A estas identidades se les llama usuarios federados. AWS asigna una función a un usuariofederado cuando se solicita acceso a través de un proveedor de identidad. Para obtener másinformación acerca de los usuarios federados, consulte Usuarios federados y roles en la Guía delusuario de IAM.

• Acceso entre cuentas: puede utilizar un rol de IAM para permitir que alguien (una entidad principal deconfianza) de otra cuenta obtenga acceso a los recursos de su cuenta. Los roles son la forma principalde conceder acceso entre cuentas. Sin embargo, con algunos servicios de AWS, puede asociar unapolítica directamente a un recurso (en lugar de utilizar un rol como proxy). Para obtener informaciónacerca de la diferencia entre los roles y las políticas basadas en recursos para el acceso entre cuentas,consulte Cómo los roles de IAM difieren de las políticas basadas en recursos en la Guía del usuario deIAM.

• Acceso a servicios de AWS: Un rol de servicio es un rol de IAM que un servicio asume para realizaracciones en su cuenta en su nombre. Al configurar algunos de los entornos de los servicios de AWS,debe definir un rol que el servicio asumirá. Este rol de servicio debe incluir todos los permisos queson necesarios para que el servicio pueda acceder a los recursos de AWS que necesita. Los roles deservicio varían de servicio a servicio, pero muchos le permiten elegir sus permisos, siempre y cuandose cumplan los requisitos documentados para dicho servicio. Los roles de servicio ofrecen acceso solodentro de su cuenta y no se pueden utilizar para otorgar acceso a servicios en otras cuentas. Puedecrear, modificar y eliminar un rol de servicio desde IAM. Por ejemplo, puede crear un rol que permitaa Amazon Redshift tener acceso a un bucket de Amazon S3 en su nombre y, a continuación, cargarlos datos de ese bucket en un clúster de Amazon Redshift. Para obtener más información, consulteCreación de un rol para delegar permisos a un servicio de AWS en la Guía del usuario de IAM.

• Aplicaciones que se ejecutan en Amazon EC2: Puede utilizar un rol de IAM para administrarcredenciales temporales para las aplicaciones que se ejecutan en una instancia EC2 y realizansolicitudes de la AWS CLI o la API de AWS. Es preferible hacerlo de este modo a almacenar claves deacceso en la instancia EC2. Para asignar un rol de AWS a una instancia EC2 y ponerla a disposición detodas las aplicaciones, cree un perfil de instancia asociado a la misma. Un perfil de instancia contiene elrol y permite a los programas que se ejecutan en la instancia EC2 obtener credenciales temporales. Paraobtener más información, consulte Uso de un rol de IAM para conceder permisos a aplicaciones que seejecutan en instancias Amazon EC2 en la Guía del usuario de IAM.

Para obtener información acerca del uso de los roles de IAM, consulte Cuándo crear un rol de IAM (en vezde un usuario) en la Guía del usuario de IAM.

Administración de acceso mediante políticasPara controlar el acceso en AWS, se crean políticas y se asocian a identidades de IAM o recursos deAWS. Una política es un objeto de AWS que, cuando se asocia a una identidad o un recurso, definesus permisos. AWS evalúa estas políticas cuando una entidad principal (usuario raíz, usuario de IAM orol de IAM) realiza una solicitud. Los permisos en las políticas determinan si la solicitud se permite o sedeniega. Las mayoría de las políticas se almacenan en AWS como documentos JSON. Para obtenermás información acerca de la estructura y el contenido de los documentos de política JSON, consulteInformación general de las políticas de JSON en la Guía del usuario de IAM.

Un administrador de IAM puede utilizar las políticas para especificar quién tiene acceso a los recursos deAWS y qué acciones se pueden realizar en dichos recursos. Cada entidad de IAM (usuario o rol) comienzasin permisos. En otras palabras, de forma predeterminada, los usuarios no pueden hacer nada, ni siquieracambiar sus propias contraseñas. Para conceder permiso a un usuario para hacer algo, el administradordebe asociarle una política de permisos. O bien el administrador puede añadir al usuario a un grupo quetenga los permisos necesarios. Cuando el administrador concede permisos a un grupo, todos los usuariosde ese grupo obtienen los permisos.

Las políticas de IAM definen permisos para una acción independientemente del método que se utilicepara realizar la operación. Por ejemplo, suponga que dispone de una política que permite la accióniam:GetRole. Un usuario con dicha política puede obtener información del usuario de la Consola deadministración de AWS, la AWS CLI o la API de AWS.

124

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

Deep Learning AMI Guía para desarrolladoresAdministración de acceso mediante políticas

Políticas basadas en la identidadLas políticas basadas en identidad son documentos de políticas de permisos JSON que puede asociara una identidad, como por ejemplo un usuario, un rol o un grupo de IAM. Estas políticas controlan quéacciones puede realizar dicha identidad, en qué recursos y en qué condiciones. Para obtener másinformación acerca de cómo crear una política basada en identidad, consulte Creación de políticas de IAMen la Guía del usuario de IAM.

Las políticas basadas en identidad pueden clasificarse además como políticas insertadas o políticasadministradas. Las políticas insertadas se integran directamente en un único usuario, grupo o rol. Laspolíticas administradas son políticas independientes que puede asociar a varios usuarios, grupos y rolesde su cuenta de AWS. Las políticas administradas incluyen las políticas administradas por AWS y laspolíticas administradas por el cliente. Para obtener más información acerca de cómo elegir una políticaadministrada o una política insertada, consulte Elegir entre políticas administradas y políticas insertadas enla Guía del usuario de IAM.

Políticas basadas en recursosLas políticas basadas en recursos son documentos de política JSON que puede asociar a un recursocomo, por ejemplo, un bucket de Amazon S3. Los administradores de servicios pueden utilizar estaspolíticas para definir qué acciones puede realizar un principal especificado (miembro de cuenta, usuario orol) en dicho recurso y bajo qué condiciones. Las políticas basadas en recursos son políticas insertadas.No existen políticas basadas en recursos que sean administradas.

Listas de control de acceso (ACL)Las listas de control de acceso (ACL) son un tipo de política que controlan qué entidades principales(cuentas, miembros, usuarios o roles) tienen permisos para obtener acceso a un recurso. Las ACL sonsimilares a las políticas basadas en recursos, aunque no utilizan el formato de documento de políticaJSON. Amazon S3, AWS WAF y Amazon VPC son ejemplos de servicios que admiten ACL. Para obtenermás información sobre las ACL, consulte Información general de las Access Control Lists (ACL, Listas decontrol de acceso) en la Guía para desarrolladores de Amazon Simple Storage Service.

Otros tipos de políticasAWS admite otros tipos de políticas menos frecuentes. Estos tipos de políticas pueden establecer elmáximo de permisos que los tipos de políticas más frecuentes le otorgan.

• Límites de permisos: un límite de permisos es una característica avanzada que le permite definir lospermisos máximos que una política basada en identidad puede conceder a una entidad de IAM (usuarioo rol de IAM). Puede establecer un límite de permisos para una identidad. Los permisos resultantes sonla intersección de las políticas basadas en identidades de la entidad y los límites de sus permisos. Laspolíticas basadas en recursos que especifiquen el usuario o rol en el campo Principal no estaránrestringidas por el límite de permisos. Una denegación explícita en cualquiera de estas políticas anularáel permiso. Para obtener más información acerca de los límites de permisos, consulte see Límites depermisos para las entidades de IAM en la Guía del usuario de IAM.

• Políticas de control de servicios (SCP): las SCP son políticas de JSON que especifican los permisosmáximos para una organización o unidad organizativa (OU) en AWS Organizations. AWS Organizationses un servicio que le permite agrupar y administrar de forma centralizada varias cuentas de AWSque posee su negocio. Si habilita todas las funciones en una organización, entonces podrá aplicarpolíticas de control de servicio (SCP) a una o todas sus cuentas. Una SCP limita los permisos para lasentidades de las cuentas de miembros, incluido cada Usuario de la cuenta raíz de AWS. Para obtenermás información acerca de Organizaciones y las SCP, consulte Funcionamiento de las SCP en la Guíadel usuario de AWS Organizations.

• Políticas de sesión: las políticas de sesión son políticas avanzadas que se pasan como parámetrocuando se crea una sesión temporal mediante programación para un rol o un usuario federado. Los

125

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/AmazonS3/latest/dev/acl-overview.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.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

Deep Learning AMI Guía para desarrolladoresIAM por Amazon EMR

permisos de la sesión resultantes son la intersección de las políticas basadas en identidades del rol y laspolíticas de la sesión. Los permisos también pueden proceder de una política basada en recursos. Unadenegación explícita en cualquiera de estas políticas anulará el permiso. Para obtener más información,consulte Políticas de sesión en la Guía del usuario de IAM.

Varios tipos de políticasCuando se aplican varios tipos de políticas a una solicitud, los permisos resultantes son más complicadosde entender. Para obtener información acerca de cómo AWS determina si permitir una solicitud cuandohay varios tipos de políticas implicados, consulte Lógica de evaluación de políticas en la Guía del usuariode IAM.

IAM por Amazon EMRPuede utilizar AWS Identity and Access Management con Amazon EMR para definir usuarios, recursos deAWS, grupos, roles y políticas. También puede controlar los servicios de AWS a los que pueden obteneracceso estos usuarios y roles.

Para obtener más información sobre el uso de IAM con Amazon EMR, consulte AWS Identity and AccessManagement para Amazon EMR.

Registro y monitorización en AWS Deep LearningAMI

Su instancia de AWS Deep Learning AMI incluye varias herramientas de monitorización de GPU, incluidauna utilidad que informa de las estadísticas de uso de GPU a Amazon CloudWatch. Para obtener másinformación, consulte Monitorización y optimización de GPU y Monitorización de Amazon EC2.

Validación de la conformidad para AWS DeepLearning AMI

Los auditores externos evalúan la seguridad y la conformidad de AWS Deep Learning AMI en distintosprogramas de conformidad de AWS. Para obtener información sobre los programas de conformidadadmitidos, consulte Validación de conformidad para Amazon EC2.

Para obtener una lista de servicios de AWS en el ámbito de programas de conformidad específicos,consulte Servicios de AWS en el ámbito del programa de conformidad. Para obtener información general,consulte Programas de conformidad de AWS.

Puede descargar los informes de auditoría de terceros utilizando AWS Artifact. Para obtener másinformación, consulte Descarga de informes en AWS Artifact.

La responsabilidad respecto a la conformidad que recae en usted al utilizar DLAMI viene determinada porla confidencialidad de los datos, los objetivos de conformidad de su empresa y la legislación y normativasaplicables. AWS proporciona los siguientes recursos para ayudarle con los requisitos de conformidad:

• Guías de inicio rápido de seguridad y conformidad– estas guías de implementación tratanconsideraciones sobre arquitectura y ofrecen pasos para implementar los entornos de referenciacentrados en la seguridad y la conformidad en AWS.

126

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

Deep Learning AMI Guía para desarrolladoresResiliencia

• Recursos de conformidad de AWS – este conjunto de manuales y guías podría aplicarse a su sector yubicación.

• Evaluación de recursos con reglas en la Guía para desarrolladores de AWS Config – el servicio AWSConfig evalúa en qué medida las configuraciones de los recursos cumplen con las prácticas internas, lasdirectrices del sector y las normativas.

• AWS Security Hub: este servicio de AWS ofrece una vista integral de su estado de seguridad en AWSque le ayuda a comprobar la conformidad con las normas del sector de seguridad y las prácticasrecomendadas.

Resiliencia en AWS Deep Learning AMILa infraestructura global de AWS está conformada por regiones y zonas de disponibilidad de AWS. Lasregiones de AWS proporcionan varias zonas de disponibilidad físicamente independientes y aisladasque se encuentran conectadas mediante redes con un alto nivel de rendimiento y redundancia, ademásde baja latencia. Con las zonas de disponibilidad, puede diseñar y utilizar aplicaciones y bases de datosque realizan una conmutación por error automática entre las zonas sin interrupciones. Las zonas dedisponibilidad tienen una mayor disponibilidad, tolerancia a errores y escalabilidad que las infraestructurastradicionales de centros de datos únicos o múltiples.

Para obtener más información sobre zonas de disponibilidad y las regiones de AWS, consulteInfraestructura global de AWS.

Para obtener información sobre las características que ayudan a respaldar sus necesidades de resilienciade datos y de copia de seguridad, consulte Resiliencia en Amazon EC2.

Seguridad de la infraestructura en AWS DeepLearning AMI

La seguridad de la infraestructura de AWS Deep Learning AMI está respaldada por Amazon EC2. Paraobtener más información, consulte Seguridad de la infraestructura en Amazon EC2.

127

http://aws.amazon.com/compliance/resources/

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/

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 Guía para desarrolladoresForos

Información relacionadaTemas

• Foros (p. 128)• Entradas de blog relacionadas (p. 128)• Preguntas frecuentes (p. 128)

Foros• Foro: AMI de AWS Deep Learning

Entradas de blog relacionadas• Lista actualizada de artículos relacionados con las AMI de Deep Learning• Lanzamiento de AWS Deep Learning AMI (en 10 minutos)• Entrenamiento más rápido con TensorFlow 1.6 optimizado en instancias C5 y P3 de Amazon EC2• Nuevas AMI de aprendizaje profundo de AWS para usuarios de Machine Learning• Nuevos cursos de formación disponibles: Introducción al aprendizaje automático y aprendizaje profundo

en AWS• Journey into Deep Learning with AWS

Preguntas frecuentes• P. ¿Cómo puedo realizar un seguimiento de los anuncios de productos relacionados con DLAMI?

Puede hacerlo de dos formas distintas:• Añada un marcador para esta categoría de blog "AWS Deep Learning AMIs" que encontrará aquí:

Lista actualizada de artículos relacionados con las AMI de Deep Learning.• "Vea" el Foro: AMI de AWS Deep Learning

• P. ¿Están instalados los controladores de NVIDIA y CUDA?

Sí. Algunas DLAMI tienen versiones diferentes. La AMI de Deep Learning con Conda (p. 4) tiene laversión más reciente de cualquier DLAMI. Esto se explica de forma más detallada en Instalacionesde CUDA y enlaces de marco de trabajo (p. 7). También puede visitar la página de detalles de la AMIespecífica en Marketplace para confirmar lo que está instalado.

• P. ¿Está instalado cuDNN?

Sí.• P. ¿Cómo puedo saber si se han detectado las GPU y su estado actual?

Ejecute nvidia-smi. Esto mostrará una o varias GPU, dependiendo del tipo de instancia, junto con suconsumo de memoria actual.

• P. ¿Están ya configurados los entornos virtuales?

128

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://aws.amazon.com/blogs/ai/category/artificial-intelligence/aws-deep-learning-amis/

https://forums.aws.amazon.com/forum.jspa?forumID=263

Deep Learning AMI Guía para desarrolladoresPreguntas frecuentes

Sí, pero solo en la AMI de Deep Learning con Conda (p. 4).• P. ¿Qué versión de Python está instalada?

Cada DLAMI tiene Python 2 y 3. Las AMI de Deep Learning con Conda (p. 4) tienen entornos paraambas versiones y para cada marco de trabajo.

• P. ¿Está instalado Keras?

Esto depende de la AMI. La AMI de Deep Learning con Conda (p. 4) tiene Keras disponible como front-end para cada marco de trabajo. La versión de Keras depende de su compatibilidad con el marco detrabajo.

• P. ¿Es gratis?

Todas las DLAMI son gratuitas. Sin embargo, dependiendo del tipo de instancia que elija, es posible queesta no sea gratuita. Consulte Precios de la DLAMI (p. 19) para obtener más información.

• P. Aparecen errores de CUDA o mensajes relacionados con la GPU en mi marco de trabajo. ¿Por qué?

Compruebe el tipo de instancia que ha utilizado. Muchos de los ejemplos y tutoriales requieren que lainstancia tenga una GPU. Si la ejecución de nvidia-smi muestra que no hay ninguna GPU, deberáactivar otra DLAMI utilizando una instancia que tenga al menos una GPU. Consulte Selección del tipo deinstancia para DLAMI (p. 17) para obtener más información.

• P. ¿Puedo usar Docker?

Docker se ha preinstalado a partir de la versión 14 de la AMI de Deep Learning con Conda. Tenga encuenta que deberá utilizar nvidia-docker en instancias de GPU para hacer uso de la GPU.

• P. ¿En qué regiones están disponibles las DLAMI de Linux?

Región Code





us-west-1












129

https://github.com/NVIDIA/nvidia-docker

Deep Learning AMI Guía para desarrolladoresPreguntas frecuentes

Región Code




• P. ¿En qué regiones están disponibles las DLAMI de Windows?

Región Code





us-west-1














130


Notas de la versión de la DLAMIPara ver las notas de la versión de la DLAMI actual, consulte:

• AMI de base de AWS Deep Learning (Amazon Linux 2) versión 23.0• AMI de base de AWS Deep Learning (Amazon Linux) versión 23.0• AMI de base de AWS Deep Learning (Ubuntu 18.04) versión 23.0• AMI de base de AWS Deep Learning (Ubuntu 16.04) versión 23.0• AMI de base de AWS Deep Learning (Amazon Linux 2) versión 28.0• AMI de AWS Deep Learning (Amazon Linux) versión 28.0• AMI de AWS Deep Learning (Ubuntu 18.04) versión 28.0• AMI de AWS Deep Learning (Ubuntu 16.04) versión 28.0

131

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-version-23-0/

https://aws.amazon.com/releasenotes/aws-deep-learning-base-ami-ubuntu-18-04-version-23-0/

https://aws.amazon.com/releasenotes/aws-deep-learning-base-ami-ubuntu-16-04-version-23-0/

https://aws.amazon.com/releasenotes/aws-deep-learning-ami-amazon-linux-2-version-28-0/

https://aws.amazon.com/releasenotes/aws-deep-learning-ami-amazon-linux-version-28-0/

https://aws.amazon.com/releasenotes/aws-deep-learning-ami-ubuntu-18-04-version-28-0/

https://aws.amazon.com/releasenotes/aws-deep-learning-ami-ubuntu-16-04-version-28-0/


Historial de revisión de Guía paradesarrolladores de AWS DeepLearning AMI

update-history-change update-history-description update-history-date

TensorFlow 2 (p. 45) La Deep Learning AMI conConda se suministra ahora conTensorFlow 2 con CUDA 10.

December 3, 2019

AWS Inferentia (p. 84) La Deep Learning AMI ahoraadmite el hardware AWSInferentia y el AWS Neuron SDK.

December 3, 2019

PyTorch 1.0 con CUDA 10 (p. 6) La AMI de Deep Learning conConda ahora incluye PyTorch 1.0con CUDA 10.

December 13, 2018

CUDA 10 está disponible en laDeep Learning Base AMI (p. 7)

CUDA 10 se añadió como opciónpara la Deep Learning BaseAMI. Instrucciones sobre cómocambiar y probar las versiones deCUDA.

December 11, 2018

Uso de TensorFlow Serving conun modelo de incepción (p. 116)

Se ha añadido un ejemplopara utilizar la inferencia conun modelo de incepción paraTensorFlow Serving, con y sinElastic Inference.

November 28, 2018

Entrenamiento con 256 GPU conTensorFlow y Horovod (p. 63)

El tutorial de TensorFlow conHorovod se ha actualizadopara añadir un ejemplo deentrenamiento en varios nodos.

November 28, 2018

Elastic Inference (p. 20) Se han añadido los requisitosprevios e información relacionadacon Elastic Inference a la guía deconfiguración.

November 28, 2018

MMS v1.0 está disponible en laDLAMI. (p. 114)

El tutorial de MMS se haactualizado para utilizar el nuevomodelo formato de archivo paramodelos (.mar) y para mostrar lasnuevas características de iniciar ydetener.

November 15, 2018

Instalación de TensorFlow desdeuna compilación nocturna (p. 43)

Se ha añadido un tutorial queexplica cómo puede desinstalar

October 16, 2018

132


TensorFlow y después instalaruna compilación nocturna deTensorFlow en una AMI de DeepLearning con Conda.

Instalación de MXNet desde unacompilación nocturna (p. 36)

Se ha añadido un tutorial queexplica cómo puede desinstalarMXNet y después instalar unacompilación nocturna de MXNeten su AMI de Deep Learning conConda.

October 16, 2018

Instalación de CNTK desde unacompilación nocturna (p. 39)

Se ha añadido un tutorial queexplica cómo puede desinstalarCNTK y después instalar unacompilación nocturna de CNTKen su AMI de Deep Learning conConda.

October 16, 2018

Instalación de PyTorch desdeuna compilación nocturna (p. 42)

Se ha añadido un tutorial queexplica cómo puede desinstalarPyTorch y después instalar unacompilación nocturna de PyTorchen su AMI de Deep Learning conConda.

September 25, 2018

Ahora Docker está preinstaladoen su DLAMI (p. 128)

A partir de la versión 14 dela AMI de Deep Learning conConda, Docker y la versión deNVIDIA de Docker para las GPUse han preinstalado.

September 25, 2018

Tutoriales de entrenamientodistribuido (p. 53)

Se ha añadido un tutorial sobrecómo utilizar Keras-MXNet parael entrenamiento en varias GPU.Se ha actualizado el tutorial deChainer para v4.2.0.

July 23, 2018

Tutorial de TensorBoard (p. 52) El ejemplo se ha movido a ~/examples/tensorboard. Rutas deltutorial actualizadas.

July 23, 2018

Tutorial de MXBoard (p. 49) Se ha añadido un tutorial sobrecómo utilizar MXBoard para lavisualización de modelos MXNet.

July 23, 2018

Tutorial de Conda (p. 29) Se ha actualizado el ejemploMOTD para reflejar una versiónmás reciente.

July 23, 2018

Tutorial de Chainer (p. 54) Se ha actualizado el tutorial parautilizar los últimos ejemplos delorigen de Chainer.

July 23, 2018

Actualizaciones anteriores:

En la siguiente tabla se describen los cambios importantes de cada versión de la AWS Deep Learning AMIanteriores a julio de 2018.

133


Cambio Descripción Fecha

TensorFlow con Horovod Se ha añadido un tutorial paracapacitación de ImageNet conTensorFlow y Horovod.

6 de junio de 2018

Actualización de guía Se ha añadido la guía deactualización.

15 de mayo de 2018

Nueva regiones y nuevo tutorialde 10 minutos

Se han añadido más regiones:EE.UU. Oeste (Norte deCalifornia), América del Sur,Canadá (Central), UE (Londres)y UE (París). Además, la primeraversión de un tutorial de 10minutos titulado: "Introducción aDeep Learning AMI".

26 de abril de 2018

Tutorial de Chainer Se añadió un tutorial para utilizarChainer en modos de variasGPU, GPU única y CPU. Laintegración de CUDA se actualizóde CUDA 8 a CUDA 9 paravarios marcos de trabajo.

28 de febrero de 2018

AMI de Linux v3.0, además dela introducción de MXNet ModelServer, TensorFlow Serving yTensorBoard

Se han añadido tutoriales paralas AMI de Conda con nuevasfunciones de distribución demodelos y visualizaciones queutilizan MXNet Model Serverv0.1.5, TensorFlow Servingv1.4.0 y TensorBoard v0.4.0. Lasfunciones CUDA de las AMI y lasplataformas se describen en lainformación general sobre Conday CUDA. Las notas de la versiónmás recientes se han movidoa https://aws.amazon.com/releasenotes/

25 de enero de 2018

AMI de Linux v2.0 AMI Base, Source y Condaactualizadas con NCCL 2.1. AMISource y Conda actualizadascon MXNet v1.0, PyTorch 0.3.0 yKeras 2.0.9.

11 de diciembre de 2017

Se han añadido dos opciones deAMI de Windows

Se han publicado las AMI paraWindows 2012 R2 y 2016.Se han añadido a la guía deselección de AMI y a las notas dela versión.

30 de noviembre de 2017

Publicación inicial de ladocumentación

Descripción detallada del cambiocon un enlace al tema o lasección que se ha modificado.

15 de noviembre de 2017

134

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.

135

https://docs.aws.amazon.com/general/latest/gr/glos-chap.html

Documents

AWS Documentation - Deep Learning AMI€¦ · usuarios que no están familiarizados con el aprendizaje automático y el aprendizaje profundo. Desarrollo de aplicaciones: si es un