Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Tutoriales
Los siguientes tutoriales muestran cómo utilizar el software de la AMI de aprendizaje profundo con Conda.
**Topics**
+ [
# Activación de los marcos de trabajo
](activating.md)
+ [
# Entrenamiento distribuido con Elastic Fabric Adapter
](tutorial-efa.md)
+ [
# Monitorización y optimización de GPU
](tutorial-gpu.md)
+ [
# El chip AWS Inferentia con DLAMI
](tutorial-inferentia.md)
+ [
# El ARM64 DLAMI
](tutorial-arm64.md)
+ [
# Inferencia
](tutorial-inference.md)
+ [
# Distribución de modelos
](model-serving.md)
# Activación de los marcos de trabajo
A continuación, se muestran los marcos de trabajo de aprendizaje profundo instalados en la AMI de aprendizaje profundo con Conda. Haga clic en un marco de trabajo para obtener información acerca de cómo activarlo.
**Topics**
+ [
# PyTorch
](tutorial-pytorch.md)
+ [
# TensorFlow 2.
](tutorial-tensorflow-2.md)
# PyTorch
## ¿Activando PyTorch
Cuando se lanza un paquete Conda estable de un marco de trabajo, se prueba y se preinstala en la DLAMI. Si desea ejecutar la última compilación nocturna sin probar, puede [PyTorchInstall's Nightly Build (experimental)](#tutorial-pytorch-install) manualmente.
Para activar el marco de trabajo instalado actualmente, siga estas instrucciones en la AMI de aprendizaje profundo con Conda.
Para PyTorch Python 3 con CUDA y MKL-DNN, ejecute este comando:
```
$ source activate pytorch_p310
```
Inicie el terminal de iPython.
```
(pytorch_p310)$ ipython
```
Ejecute un programa rápido. PyTorch
```
import torch
x = 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 matriz aleatoria.
## PyTorchInstall's Nightly Build (experimental)
**¿Cómo realizar una instalación a PyTorch partir de una compilación nocturna**
Puede instalar la versión más reciente PyTorch en uno de los entornos de PyTorch Conda o en ambos de su AMI de aprendizaje profundo con Conda.
1.
+ (Opción para Python 3): active el PyTorch entorno Python 3:
```
$ source activate pytorch_p310
```
1. En los pasos restantes se da por hecho que está utilizando el entorno `pytorch_p310`. Elimine lo que está instalado actualmente PyTorch:
```
(pytorch_p310)$ pip uninstall torch
```
1.
+ (Opción para instancias de GPU): instala la última versión nocturna PyTorch con CUDA.0:
```
(pytorch_p310)$ pip install torch_nightly -f https://download.pytorch.org/whl/nightly/cu100/torch_nightly.html
```
+ (Opción para instancias de CPU): instala la última versión nocturna para las instancias que no tengan: PyTorch GPUs
```
(pytorch_p310)$ pip install torch_nightly -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html
```
1. Para comprobar que has instalado correctamente la última versión nocturna, inicia el IPython terminal y comprueba la versión de. PyTorch
```
(pytorch_p310)$ ipython
```
```
import torch
print (torch.__version__)
```
El resultado debería ser similar a `1.0.0.dev20180922`
1. Para comprobar que la compilación PyTorch nocturna funciona bien con el ejemplo del MNIST, puedes ejecutar un script de prueba desde el repositorio PyTorch de ejemplos:
```
(pytorch_p310)$ cd ~
(pytorch_p310)$ git clone https://github.com/pytorch/examples.git pytorch_examples
(pytorch_p310)$ cd pytorch_examples/mnist
(pytorch_p310)$ python main.py || exit 1
```
## Más tutoriales
Para obtener más tutoriales y ejemplos, consulta los documentos oficiales, la [PyTorch documentación](http://pytorch.org/docs/master/) y el sitio web del [PyTorch](http://pytorch.org)framework.
# TensorFlow 2.
En este tutorial, se muestra cómo activar TensorFlow 2 en una instancia que ejecuta la AMI de aprendizaje profundo con Conda (DLAMI en Conda) y cómo ejecutar un programa 2. TensorFlow
Cuando se lanza un paquete Conda estable de un marco de trabajo, se prueba y se preinstala en la DLAMI.
## Activando 2 TensorFlow
**Para ejecutar TensorFlow el DLAMI con Conda**
1. Para activar TensorFlow 2, abra una instancia de Amazon Elastic Compute Cloud (Amazon EC2) de la DLAMI con Conda.
1. Para TensorFlow 2 y Keras 2 en Python 3 con CUDA 10.1 y MKL-DNN, ejecute este comando:
```
$ source activate tensorflow2_p310
```
1. Inicie el terminal de iPython:
```
(tensorflow2_p310)$ ipython
```
1. Ejecute un programa TensorFlow 2 para comprobar que funciona correctamente:
```
import tensorflow as tf
hello = tf.constant('Hello, TensorFlow!')
tf.print(hello)
```
`Hello, TensorFlow!` debe aparecer en la pantalla.
## Más tutoriales
Para obtener más tutoriales y ejemplos, consulta la TensorFlow documentación de la [API de TensorFlow Python](https://www.tensorflow.org/api_docs/python/) o visita el [TensorFlow](https://www.tensorflow.org)sitio web.
# Entrenamiento distribuido con Elastic Fabric Adapter
Un [Elastic Fabric Adapter](https://aws.amazon.com/hpc/efa/) (EFA) es un dispositivo de red que puede adjuntar a su instancia de Amazon EC2 para acelerar las aplicaciones de computación de alto rendimiento (HPC). La EFA le permite lograr el rendimiento de las aplicaciones de un clúster de HPC local, con la escalabilidad, flexibilidad y elasticidad que ofrece la nube. AWS
En los siguientes temas se muestra cómo comenzar a usar EFA con la DLAMI.
**nota**
Elige tu DLAMI de esta lista de [DLAMI de GPU base](appendix-ami-release-notes.md#appendix-ami-release-notes-base)
**Topics**
+ [
# Lanzamiento de una instancia con EFA AWS Deep Learning AMIs
](tutorial-efa-launching.md)
+ [
# Uso del EFA en la DLAMI
](tutorial-efa-using.md)
# Lanzamiento de una instancia con EFA AWS Deep Learning AMIs
La DLAMI base 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](https://github.com/aws/aws-ofi-nccl/tree/aws) necesarios para instancias de GPU.
Puede encontrar las versiones CUDA compatibles de una DLAMI base en las [notas de la versión](appendix-ami-release-notes.md#appendix-ami-release-notes-base).
Nota:
+ Al ejecutar una aplicación de NCCL mediante `mpirun` en EFA, tendrá que especificar la ruta completa a la instalación compatible con EFA como:
```
/opt/amazon/openmpi/bin/mpirun
```
+ Para permitir que la aplicación utilice EFA, añada `FI_PROVIDER="efa"` al comando `mpirun`, tal y como se muestra en [Uso del EFA en la DLAMI](tutorial-efa-using.md).
**Topics**
+ [
## Preparación de un grupo de seguridad habilitado para EFA
](#tutorial-efa-security-group)
+ [
## Lanzar la instancia
](#tutorial-efa-launch)
+ [
## Verificación de una asociación de EFA
](#tutorial-efa-verify-attachment)
## Preparación de un grupo de seguridad habilitado para EFA
Un EFA requiere un grupo de seguridad que permita todo el tráfico entrante y saliente hacia y desde el propio grupo de seguridad. Para obtener más información, consulte la [documentación de EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security).
1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. En el panel de navegación, elija **Security Groups** (Grupos de seguridad) y, a continuación, elija **Create Security Group** (Crear grupo de seguridad).
1. En la ventana **Create Security Group**, haga lo siguiente:
+ En **Nombre del grupo de seguridad**, ingrese un nombre descriptivo para el grupo de seguridad, como, por ejemplo, `EFA-enabled security group`.
+ (Opcional) En **Descripción**, ingrese 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)**.
1. Seleccione el grupo de seguridad que ha creado y, en la pestaña **Description** (Descripción), copie el **Group ID** (ID de grupo).
1. En las pestañas **Entrante** y **Saliente**, haga lo siguiente:
+ Elija **Edit (Editar)**.
+ 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**.
1. Habilite el tráfico de entrada que hace referencia a [Autorización del tráfico de entrada para sus instancias de Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html). Si omite este paso, no podrá comunicarse con su instancia de DLAMI.
## Lanzar la instancia
Actualmente, EFA on the AWS Deep Learning AMIs es compatible con los siguientes tipos de instancias y sistemas operativos:
+ P3dn: Amazon Linux 2 y Ubuntu 20.04
+ P4d, P4de: Amazon Linux 2, Amazon Linux 2023, Ubuntu 20.04 y Ubuntu 22.04
+ P5, P5e, P5en: Amazon Linux 2, Amazon Linux 2023, Ubuntu 20.04, Ubuntu 22.04
En la siguiente sección se muestra cómo lanzar una instancia de DLAMI habilitada para EFA. Para obtener más información, consulte el paso [Lance instancias habilitadas para EFA en un grupo con ubicación en clúster](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-instances).
1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Elija **Iniciar instancia**.
1. En la página **Elección de una AMI**, seleccione una DLAMI compatible de las que aparecen en la [página de notas de la versión de DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/appendix-ami-release-notes)
1. En la página **Elegir un tipo de instancia** , seleccione uno de los tipos de instancias admitidos y, a continuación, elija **Next: Configure Instance Details**. Consulte este enlace para ver la lista de instancias compatibles: [Introducción a EFA y MPI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html)
1. En la página **Configure Instance Details (Siguiente: Configurar detalles de instancia)**, haga lo siguiente:
+ En **Number of instances (Número de instancias)**, introduzca el número de instancias habilitadas para EFA que desea lanzar.
+ En **Network (Red)** y **Subnet (Subred)**, seleccione la VPC y la subred en la que lanzar las instancias.
+ [Opcional] En **Grupo de ubicación**, seleccione **Añadir instancia a grupo de ubicación**. Para lograr el mejor rendimiento, lance las instancias dentro de un grupo de ubicación.
+ [Opcional] En **Nombre del grupo de ubicación**, seleccione **Añadir a un nuevo grupo de ubicación**, introduzca un nombre descriptivo para el grupo de ubicación y, a continuación, en **Estrategia de grupos de ubicación**, seleccione **clúster**.
+ Asegúrese de activar el **“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 **Interfaces de red**, para el dispositivo **eth0**, elija **Nueva interfaz de red**. Si lo desea, puede especificar una IPv4 dirección principal y una o más IPv4 direcciones secundarias. Si vas a lanzar la instancia en una subred que tiene un bloque IPv6 CIDR asociado, puedes especificar, si lo deseas, una IPv6 dirección principal y una o más direcciones secundarias IPv6 .
+ Elija **Next: Add Storage (Siguiente: Añadir almacenamiento)**.
1. En la página **Add Storage (Añadir almacenamiento)**, especifique los volúmenes que desea adjuntar a la instancia además de los volúmenes especificados por la AMI (como el volumen de dispositivo raíz) y, a continuación, elija **Next: Add Tags (Siguiente: Añadir etiquetas)**.
1. En la página **Add Tags (Añadir etiquetas)**, especifique etiquetas para las instancias, por ejemplo, un nombre fácil de recordar, y, a continuación, elija **Next: Configure Security Group (Siguiente: Configurar grupo de seguridad)**.
1. En la página **Configurar grupo de seguridad**, en **Asignar un grupo de seguridad**, seleccione **Seleccionar un grupo de seguridad existente** y, a continuación, seleccione el grupo de seguridad que creó anteriormente**.**
1. Elija **Review and Launch (Revisar y lanzar)**.
1. En la página **Revisar inicialización de instancia**, revise la configuración y, a continuación, elija **Iniciar** para elegir un par de claves e iniciar las instancias.
## Verificación de una asociación de EFA
### En la consola
Tras lanzar la instancia, comprueba los detalles de la instancia en la AWS consola. Para ello, seleccione la instancia en la consola de EC2 y revise la pestaña Description (Descripción) en el panel inferior de la página. Busque el parámetro “Network Interfaces: eth0” y haga clic en eth0 para que aparezca una ventana emergente. Asegúrese de que la opción “Elastic Fabric Adapter” esté habilitada.
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).
1. Haga clic en Create a Network Interface (Crear una interfaz de red).
1. Seleccione la misma subred en la que se encuentra la instancia.
1. Asegúrese de habilitar “Elastic Fabric Adapter” y haga clic en Crear.
1. Vuelva a la pestaña EC2 Instances (Instancias EC2) y seleccione su instancia.
1. Vaya a Actions: Instance State y detenga la instancia antes de asociar EFA.
1. En Actions (Acciones), seleccione Networking: Attach Network Interface (Redes: Asociar interfaz de red).
1. Seleccione la interfaz que acaba de crear y haga clic en Attach (Asociar).
1. 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ódulos de 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_EFA
provider: efa
fabric: EFA-fe80::e5:56ff:fe34:56a8
domain: efa_0-dgrm
version: 2.0
type: FI_EP_DGRAM
protocol: FI_PROTO_EFA
provider: efa;ofi_rxd
fabric: EFA-fe80::e5:56ff:fe34:56a8
domain: efa_0-dgrm
version: 1.0
type: FI_EP_RDM
protocol: FI_PROTO_RXD
```
### 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 de seguridad que creó esté configurado correctamente.
```
$ cd /opt/amazon/efa/test/
$ ./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/sec
64 10 =10 1.2k 0.02s 0.06 1123.55 0.00
256 10 =10 5k 0.00s 17.66 14.50 0.07
1k 10 =10 20k 0.00s 67.81 15.10 0.07
4k 10 =10 80k 0.00s 237.45 17.25 0.06
64k 10 =10 1.2m 0.00s 921.10 71.15 0.01
1m 10 =10 20m 0.01s 2122.41 494.05 0.00
```
Si deja de responder o no se completa, asegúrese de que su grupo de seguridad tenga las inbound/outbound reglas correctas.
# Uso del EFA en la DLAMI
En la siguiente sección se describe cómo utilizar EFA para ejecutar aplicaciones de varios nodos en AWS Deep Learning AMIs.
## 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 los siguientes ajustes.
**Topics**
+ [
### Habilitar SSH sin contraseña
](#tutorial-efa-using-multi-node-ssh)
+ [
### Creación de archivo de hosts
](#tutorial-efa-using-multi-node-hosts)
+ [
### Pruebas de NCCL
](#tutorial-efa-using-2node)
### 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
```
1. Cambie los permisos de la clave privada en el nodo principal.
```
chmod 600 ~/.ssh/id_rsa
```
1. Copie la clave pública `~/.ssh/id_rsa.pub` y añádala a `~/.ssh/authorized_keys` para los nodos miembro del clúster.
1. Ahora debe poder iniciar sesión directamente en los nodos miembro desde el nodo principal mediante la ip privada.
```
ssh
```
1. Desactive la strictHostKey comprobación y habilite el reenvío de agentes en el nodo principal añadiendo lo siguiente al archivo \$1/.ssh/config del nodo líder:
```
Host *
ForwardAgent yes
Host *
StrictHostKeyChecking no
```
1. En las instancias de Amazon Linux 2, ejecute el siguiente comando en el nodo principal 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 hosts debe tener una entrada para cada nodo del clúster. Cree un archivo \$1/hosts y añada cada nodo mediante la ip privada de la siguiente manera:
```
localhost slots=8
slots=8
slots=8
```
### Pruebas de NCCL
**nota**
Estas pruebas se han realizado con la versión 1.38.0 de EFA y el complemento OFI NCCL 1.13.2.
A continuación, se muestra un subconjunto de pruebas de NCCL realizadas por Nvidia para comprobar tanto la funcionalidad como el rendimiento en varios nodos de cómputo
**Instancias compatibles: P3dn, P4, P5, P5e y P5en**
#### Pruebas de rendimiento
##### Prueba de rendimiento NCCL de varios nodos en P4d.24xlarge
Para comprobar el rendimiento de NCCL con EFA, ejecute la prueba de rendimiento de NCCL estándar que está disponible en el [repositorio oficial de pruebas de NCCL](https://github.com/NVIDIA/nccl-tests.git). La DLAMI viene con esta prueba ya creada para la serie CUDA XX.X. También puede ejecutar su propio script con EFA.
Cuando cree su propio script, siga estas directrices:
+ 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 del clúster. GPUs
+ Añada el indicador NCCL\$1DEBUG=INFO y asegúrese de que los registros indiquen el uso del EFA como “El proveedor seleccionado es EFA”.
+ Defina la ubicación del registro de entrenamiento para analizarla para su validación.
```
TRAINING_LOG="testEFA_$(date +"%N").log"
```
Utilice el comando `watch nvidia-smi` en cualquiera de los nodos miembro para monitorizar el uso de la GPU. Los siguientes comandos `watch nvidia-smi` son para la versión xx.x de CUDA y dependen del sistema operativo de la instancia. Puede ejecutar los comandos para cualquier versión de CUDA disponible en su instancia de Amazon EC2 sustituyendo la versión de CUDA en el script.
+ Amazon Linux 2, Amazon Linux 2023:
```
$ /opt/amazon/openmpi/bin/mpirun -n 16 -N 8 \
-x NCCL_DEBUG=INFO --mca pml ^cm \
-x LD_LIBRARY_PATH=/usr/local/cuda-xx.x/efa/lib:/usr/local/cuda-xx.x/lib:/usr/local/cuda-xx.x/lib64:/usr/local/cuda-xx.x:/opt/amazon/efa/lib64:/opt/amazon/openmpi/lib64:$LD_LIBRARY_PATH \
--hostfile hosts --mca btl tcp,self --mca btl_tcp_if_exclude lo,docker0 --bind-to none \
/usr/local/cuda-xx.x/efa/test-cuda-xx.x/all_reduce_perf -b 8 -e 1G -f 2 -g 1 -c 1 -n 100 | tee ${TRAINING_LOG}
```
+ Ubuntu 20.04, Ubuntu 20.04:
```
$ /opt/amazon/openmpi/bin/mpirun -n 16 -N 8 \
-x NCCL_DEBUG=INFO --mca pml ^cm \
-x LD_LIBRARY_PATH=/usr/local/cuda-xx.x/efa/lib:/usr/local/cuda-xx.x/lib:/usr/local/cuda-xx.x/lib64:/usr/local/cuda-xx.x:/opt/amazon/efa/lib:/opt/amazon/openmpi/lib:$LD_LIBRARY_PATH \
--hostfile hosts --mca btl tcp,self --mca btl_tcp_if_exclude lo,docker0 --bind-to none \
/usr/local/cuda-xx.x/efa/test-cuda-xx.x/all_reduce_perf -b 8 -e 1G -f 2 -g 1 -c 1 -n 100 | tee ${TRAINING_LOG}
```
El resultado debería tener el siguiente aspecto:
```
# nThread 1 nGpus 1 minBytes 8 maxBytes 1073741824 step: 2(factor) warmup iters: 5 iters: 100 agg iters: 1 validation: 1 graph: 0
#
# Using devices
# Rank 0 Group 0 Pid 33378 on ip-172-31-42-25 device 0 [0x10] NVIDIA A100-SXM4-40GB
# Rank 1 Group 0 Pid 33379 on ip-172-31-42-25 device 1 [0x10] NVIDIA A100-SXM4-40GB
# Rank 2 Group 0 Pid 33380 on ip-172-31-42-25 device 2 [0x20] NVIDIA A100-SXM4-40GB
# Rank 3 Group 0 Pid 33381 on ip-172-31-42-25 device 3 [0x20] NVIDIA A100-SXM4-40GB
# Rank 4 Group 0 Pid 33382 on ip-172-31-42-25 device 4 [0x90] NVIDIA A100-SXM4-40GB
# Rank 5 Group 0 Pid 33383 on ip-172-31-42-25 device 5 [0x90] NVIDIA A100-SXM4-40GB
# Rank 6 Group 0 Pid 33384 on ip-172-31-42-25 device 6 [0xa0] NVIDIA A100-SXM4-40GB
# Rank 7 Group 0 Pid 33385 on ip-172-31-42-25 device 7 [0xa0] NVIDIA A100-SXM4-40GB
# Rank 8 Group 0 Pid 30378 on ip-172-31-43-8 device 0 [0x10] NVIDIA A100-SXM4-40GB
# Rank 9 Group 0 Pid 30379 on ip-172-31-43-8 device 1 [0x10] NVIDIA A100-SXM4-40GB
# Rank 10 Group 0 Pid 30380 on ip-172-31-43-8 device 2 [0x20] NVIDIA A100-SXM4-40GB
# Rank 11 Group 0 Pid 30381 on ip-172-31-43-8 device 3 [0x20] NVIDIA A100-SXM4-40GB
# Rank 12 Group 0 Pid 30382 on ip-172-31-43-8 device 4 [0x90] NVIDIA A100-SXM4-40GB
# Rank 13 Group 0 Pid 30383 on ip-172-31-43-8 device 5 [0x90] NVIDIA A100-SXM4-40GB
# Rank 14 Group 0 Pid 30384 on ip-172-31-43-8 device 6 [0xa0] NVIDIA A100-SXM4-40GB
# Rank 15 Group 0 Pid 30385 on ip-172-31-43-8 device 7 [0xa0] NVIDIA A100-SXM4-40GB
ip-172-31-42-25:33385:33385 [7] NCCL INFO cudaDriverVersion 12060
ip-172-31-43-8:30383:30383 [5] NCCL INFO Bootstrap : Using ens32:172.31.43.8
ip-172-31-43-8:30383:30383 [5] NCCL INFO NCCL version 2.23.4+cuda12.5
...
ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Initializing aws-ofi-nccl 1.13.2-aws
ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Using Libfabric version 1.22
ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Using CUDA driver version 12060 with runtime 12050
ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Configuring AWS-specific options
ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Setting provider_filter to efa
ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Setting FI_EFA_FORK_SAFE environment variable to 1
ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Setting NCCL_NVLSTREE_MAX_CHUNKSIZE to 512KiB
ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Setting NCCL_NVLS_CHUNKSIZE to 512KiB
ip-172-31-42-25:33384:33451 [6] NCCL INFO NET/OFI Running on p4d.24xlarge platform, Setting NCCL_TOPO_FILE environment variable to /opt/amazon/ofi-nccl/share/aws-ofi-nccl/xml/p4d-24xl-topo.xml
...
-----------------------------some output truncated-----------------------------------
# out-of-place in-place
# size count type redop root time algbw busbw #wrong time algbw busbw #wrong
# (B) (elements) (us) (GB/s) (GB/s) (us) (GB/s) (GB/s)
8 2 float sum -1 180.3 0.00 0.00 0 179.3 0.00 0.00 0
16 4 float sum -1 178.1 0.00 0.00 0 177.6 0.00 0.00 0
32 8 float sum -1 178.5 0.00 0.00 0 177.9 0.00 0.00 0
64 16 float sum -1 178.8 0.00 0.00 0 178.7 0.00 0.00 0
128 32 float sum -1 178.2 0.00 0.00 0 177.8 0.00 0.00 0
256 64 float sum -1 178.6 0.00 0.00 0 178.8 0.00 0.00 0
512 128 float sum -1 177.2 0.00 0.01 0 177.1 0.00 0.01 0
1024 256 float sum -1 179.2 0.01 0.01 0 179.3 0.01 0.01 0
2048 512 float sum -1 181.3 0.01 0.02 0 181.2 0.01 0.02 0
4096 1024 float sum -1 184.2 0.02 0.04 0 183.9 0.02 0.04 0
8192 2048 float sum -1 191.2 0.04 0.08 0 190.6 0.04 0.08 0
16384 4096 float sum -1 202.5 0.08 0.15 0 202.3 0.08 0.15 0
32768 8192 float sum -1 233.0 0.14 0.26 0 232.1 0.14 0.26 0
65536 16384 float sum -1 238.6 0.27 0.51 0 235.1 0.28 0.52 0
131072 32768 float sum -1 237.2 0.55 1.04 0 236.8 0.55 1.04 0
262144 65536 float sum -1 248.3 1.06 1.98 0 247.0 1.06 1.99 0
524288 131072 float sum -1 309.2 1.70 3.18 0 307.7 1.70 3.20 0
1048576 262144 float sum -1 408.7 2.57 4.81 0 404.3 2.59 4.86 0
2097152 524288 float sum -1 613.5 3.42 6.41 0 607.9 3.45 6.47 0
4194304 1048576 float sum -1 924.5 4.54 8.51 0 914.8 4.58 8.60 0
8388608 2097152 float sum -1 1059.5 7.92 14.85 0 1054.3 7.96 14.92 0
16777216 4194304 float sum -1 1269.9 13.21 24.77 0 1272.0 13.19 24.73 0
33554432 8388608 float sum -1 1642.7 20.43 38.30 0 1636.7 20.50 38.44 0
67108864 16777216 float sum -1 2446.7 27.43 51.43 0 2445.8 27.44 51.45 0
134217728 33554432 float sum -1 4143.6 32.39 60.73 0 4142.4 32.40 60.75 0
268435456 67108864 float sum -1 7351.9 36.51 68.46 0 7346.7 36.54 68.51 0
536870912 134217728 float sum -1 13717 39.14 73.39 0 13703 39.18 73.46 0
1073741824 268435456 float sum -1 26416 40.65 76.21 0 26420 40.64 76.20 0
...
# Out of bounds values : 0 OK
# Avg bus bandwidth : 15.5514
```
#### Pruebas de validación
Para validar que las pruebas de EFA han arrojado un resultado válido, utilice las siguientes pruebas para confirmarlo:
+ Obtenga el tipo de instancia mediante los metadatos de la instancia de EC2:
```
TOKEN=$(curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
INSTANCE_TYPE=$(curl -H "X-aws-ec2-metadata-token: $TOKEN" -v http://169.254.169.254/latest/meta-data/instance-type)
```
+ Ejecute la [Pruebas de rendimiento](#tutorial-efa-using-multinode)
+ Establezca los siguientes parámetros:
```
CUDA_VERSION
CUDA_RUNTIME_VERSION
NCCL_VERSION
```
+ Valide los resultados como se muestra:
```
RETURN_VAL=`echo $?`
if [ ${RETURN_VAL} -eq 0 ]; then
# [0] NCCL INFO NET/OFI Initializing aws-ofi-nccl 1.13.2-aws
# [0] NCCL INFO NET/OFI Using CUDA driver version 12060 with runtime 12010
# cudaDriverVersion 12060 --> This is max supported cuda version by nvidia driver
# NCCL version 2.23.4+cuda12.5 --> This is NCCL version compiled with cuda version
# Validation of logs
grep "NET/OFI Configuring AWS-specific options" ${TRAINING_LOG} || { echo "AWS-specific options text not found"; exit 1; }
grep "busbw" ${TRAINING_LOG} || { echo "busbw text not found"; exit 1; }
grep "Avg bus bandwidth " ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; }
grep "NCCL version $NCCL_VERSION" ${TRAINING_LOG} || { echo "Text not found: NCCL version $NCCL_VERSION"; exit 1; }
if [[ ${INSTANCE_TYPE} == "p4d.24xlarge" ]]; then
grep "NET/Libfabric/0/GDRDMA" ${TRAINING_LOG} || { echo "Text not found: NET/Libfabric/0/GDRDMA"; exit 1; }
grep "NET/OFI Selected Provider is efa (found 4 nics)" ${TRAINING_LOG} || { echo "Selected Provider is efa text not found"; exit 1; }
elif [[ ${INSTANCE_TYPE} == "p4de.24xlarge" ]]; then
grep "NET/Libfabric/0/GDRDMA" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; }
grep "NET/OFI Selected Provider is efa (found 4 nics)" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; }
elif [[ ${INSTANCE_TYPE} == "p5.48xlarge" ]]; then
grep "NET/Libfabric/0/GDRDMA" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; }
grep "NET/OFI Selected Provider is efa (found 32 nics)" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; }
elif [[ ${INSTANCE_TYPE} == "p5e.48xlarge" ]]; then
grep "NET/Libfabric/0/GDRDMA" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; }
grep "NET/OFI Selected Provider is efa (found 32 nics)" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; }
elif [[ ${INSTANCE_TYPE} == "p5en.48xlarge" ]]; then
grep "NET/Libfabric/0/GDRDMA" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; }
grep "NET/OFI Selected Provider is efa (found 16 nics)" ${TRAINING_LOG} || { echo "Avg bus bandwidth text not found"; exit 1; }
elif [[ ${INSTANCE_TYPE} == "p3dn.24xlarge" ]]; then
grep "NET/OFI Selected Provider is efa (found 4 nics)" ${TRAINING_LOG} || { echo "Selected Provider is efa text not found"; exit 1; }
fi
echo "***************************** check_efa_nccl_all_reduce passed for cuda version ${CUDA_VERSION} *****************************"
else
echo "***************************** check_efa_nccl_all_reduce failed for cuda version ${CUDA_VERSION} *****************************"
fi
```
+ Para acceder a los datos de referencia, podemos analizar la última fila del resultado de la tabla de la prueba all\$1reduce de varios nodos:
```
benchmark=$(sudo cat ${TRAINING_LOG} | grep '1073741824' | tail -n1 | awk -F " " '{{print $12}}' | sed 's/ //' | sed 's/ 5e-07//')
if [[ -z "${benchmark}" ]]; then
echo "benchmark variable is empty"
exit 1
fi
echo "Benchmark throughput: ${benchmark}"
```
# Monitorización y optimización de GPU
La siguiente sección le guiará en el proceso de configurar las opciones de optimización y monitorización de GPU. Esta sección está organizada como un flujo de trabajo típico en la que se monitoriza el procesamiento previo y el entrenamiento.
+ [Supervisión](tutorial-gpu-monitoring.md)
+ [GPUs Supervise con CloudWatch](tutorial-gpu-monitoring-gpumon.md)
+ [Optimización](tutorial-gpu-opt.md)
+ [Procesamiento previo](tutorial-gpu-opt-preprocessing.md)
+ [Formación](tutorial-gpu-opt-training.md)
# Supervisión
La DLAMI viene preinstalada con varias herramientas de supervisión de GPU. Esta guía también menciona las herramientas que están disponibles para su descarga e instalación.
+ [GPUs Supervise con CloudWatch](tutorial-gpu-monitoring-gpumon.md)- una utilidad preinstalada que informa a Amazon CloudWatch de las estadísticas de uso de la GPU.
+ [CLI de nvidia-smi](https://developer.nvidia.com/nvidia-system-management-interface): una utilidad para monitorizar el uso general de memoria y computación de GPU. Está preinstalado en su AWS Deep Learning AMIs (DLAMI).
+ [Biblioteca de C de NVML](https://developer.nvidia.com/nvidia-management-library-nvml): una API basada en C para obtener acceso directo a las funciones de administración y monitorización de GPU. Esta API la utiliza internamente la CLI de nvidia-smi y viene preinstalada en la DLAMI. También tiene enlaces a Python y Perl para facilitar el desarrollo en dichos lenguajes. La utilidad gpumon.py preinstalada en su DLAMI utiliza el paquete pynvml de. [nvidia-ml-py](https://pypi.org/project/nvidia-ml-py/)
+ [NVIDIA DCGM](https://developer.nvidia.com/data-center-gpu-manager-dcgm): una herramienta de administración de clústeres. Visite la página del desarrollador para obtener información sobre cómo instalar y configurar esta herramienta.
**sugerencia**
Consulte el blog de desarrolladores de NVIDIA para obtener la información más reciente sobre el uso de las herramientas de CUDA instaladas en la DLAMI:
[Supervisión de la TensorCore utilización mediante Nsight IDE y nvprof](https://devblogs.nvidia.com/using-nsight-compute-nvprof-mixed-precision-deep-learning-models/).
# GPUs Supervise con CloudWatch
Cuando utilice la DLAMI con una GPU, es probable que sienta la necesidad de realizar un seguimiento de su uso durante el entrenamiento o la inferencia. Esto puede resultar útil para optimizar la canalización de datos y ajustar la red de aprendizaje profundo.
Hay dos formas de configurar las métricas de la GPU con CloudWatch:
+ [Configure las métricas con el AWS CloudWatch agente (recomendado)](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-guide)
+ [Configure las métricas con el script preinstalado `gpumon.py`](#tutorial-gpu-monitoring-gpumon-script)
## Configure las métricas con el AWS CloudWatch agente (recomendado)
Integre su DLAMI con [el agente CloudWatch unificado para configurar las](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html) métricas de la GPU y supervisar la utilización de los coprocesos de la GPU en las instancias aceleradas de Amazon EC2.
Hay cuatro formas de configurar las [métricas de la GPU](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Agent-NVIDIA-GPU.html) con su DLAMI:
+ [Configuración de métricas de GPU mínimas](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-minimal)
+ [Configuración de métricas de GPU parciales](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-partial)
+ [Configure todas las métricas de GPU disponibles](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-all)
+ [Configuración de métricas de GPU personalizadas](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-custom)
Para obtener más información sobre actualizaciones y parches de seguridad, consulte [Parches de seguridad para el agente AWS CloudWatch](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-security).
### Requisitos previos
Para empezar, debe configurar los permisos de IAM de la instancia Amazon EC2 que permitan a la instancia enviar métricas a ella. CloudWatch Para ver los pasos detallados, consulte [Crear roles y usuarios de IAM para usarlos con el agente](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/create-iam-roles-for-cloudwatch-agent.html). CloudWatch
### Configuración de métricas de GPU mínimas
Configure las métricas mínimas de GPU mediante el servicio `systemd` de `dlami-cloudwatch-agent@minimal`. En este servicio se configuran las siguientes métricas:
+ `utilization_gpu`
+ `utilization_memory`
Puede encontrar el servicio `systemd` de métricas mínimas de GPU preconfiguradas en la siguiente ubicación:
```
/opt/aws/amazon-cloudwatch-agent/etc/dlami-amazon-cloudwatch-agent-minimal.json
```
Active e inicie el servicio `systemd` con los siguientes comandos:
```
sudo systemctl enable dlami-cloudwatch-agent@minimal
sudo systemctl start dlami-cloudwatch-agent@minimal
```
### Configuración de métricas de GPU parciales
Configure las métricas parciales de GPU mediante el servicio `systemd` de `dlami-cloudwatch-agent@partial`. En este servicio se configuran las siguientes métricas:
+ `utilization_gpu`
+ `utilization_memory`
+ `memory_total`
+ `memory_used`
+ `memory_free`
Puede encontrar el servicio `systemd` de métricas parciales de GPU preconfiguradas en la siguiente ubicación:
```
/opt/aws/amazon-cloudwatch-agent/etc/dlami-amazon-cloudwatch-agent-partial.json
```
Active e inicie el servicio `systemd` con los siguientes comandos:
```
sudo systemctl enable dlami-cloudwatch-agent@partial
sudo systemctl start dlami-cloudwatch-agent@partial
```
### Configure todas las métricas de GPU disponibles
Configure todas las métricas disponibles de GPU mediante el servicio `systemd` de `dlami-cloudwatch-agent@all`. En este servicio se configuran las siguientes métricas:
+ `utilization_gpu`
+ `utilization_memory`
+ `memory_total`
+ `memory_used`
+ `memory_free`
+ `temperature_gpu`
+ `power_draw`
+ `fan_speed`
+ `pcie_link_gen_current`
+ `pcie_link_width_current`
+ `encoder_stats_session_count`
+ `encoder_stats_average_fps`
+ `encoder_stats_average_latency`
+ `clocks_current_graphics`
+ `clocks_current_sm`
+ `clocks_current_memory`
+ `clocks_current_video`
Puede encontrar el servicio `systemd` de todas las métricas disponibles de GPU preconfiguradas en la siguiente ubicación:
```
/opt/aws/amazon-cloudwatch-agent/etc/dlami-amazon-cloudwatch-agent-all.json
```
Active e inicie el servicio `systemd` con los siguientes comandos:
```
sudo systemctl enable dlami-cloudwatch-agent@all
sudo systemctl start dlami-cloudwatch-agent@all
```
### Configuración de métricas de GPU personalizadas
Si las métricas preconfiguradas no cumplen sus requisitos, puede crear un archivo de configuración de CloudWatch agente personalizado.
#### Para crear un archivo de configuración personalizado
Para crear un archivo de configuración personalizado, consulte los pasos detallados en [Crear o editar manualmente el archivo de configuración del CloudWatch agente](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Agent-Configuration-File-Details.html).
Para este ejemplo, suponga que la definición del esquema se encuentra en `/opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json`.
#### Configure las métricas con su archivo personalizado
Ejecute el siguiente comando para configurar el CloudWatch agente según su archivo personalizado:
```
sudo /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl \
-a fetch-config -m ec2 -s -c \
file:/opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json
```
### Parches de seguridad para el agente AWS CloudWatch
Los recién lanzados DLAMIs están configurados con los últimos parches de seguridad AWS CloudWatch del agente disponibles. Consulte las siguientes secciones para actualizar su DLAMI actual con los últimos parches de seguridad en función del sistema operativo que elija.
#### Amazon Linux 2
Úselo `yum` para obtener los parches de seguridad de AWS CloudWatch agentes más recientes para una DLAMI de Amazon Linux 2.
```
sudo yum update
```
#### Ubuntu
Para obtener los últimos parches AWS CloudWatch de seguridad para una DLAMI con Ubuntu, es necesario volver a instalar AWS CloudWatch el agente mediante un enlace de descarga de Amazon S3.
```
wget https://s3.region.amazonaws.com/amazoncloudwatch-agent-region/ubuntu/arm64/latest/amazon-cloudwatch-agent.deb
```
Para obtener más información sobre la instalación del AWS CloudWatch agente mediante los enlaces de descarga de Amazon S3, consulte [Instalación y ejecución del CloudWatch agente en sus servidores](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/install-CloudWatch-Agent-commandline-fleet.html).
## Configure las métricas con el script preinstalado `gpumon.py`
Una utilidad denominada gpumon.py viene preinstalada en la DLAMI. Se integra CloudWatch y admite la supervisión del uso por GPU: memoria de la GPU, temperatura de la GPU y potencia de la GPU. El script envía periódicamente los datos monitorizados a CloudWatch. Puede configurar el nivel de granularidad de los datos a los que se envían CloudWatch cambiando algunos ajustes del script. Sin embargo, antes de iniciar el script, necesitará configurarlo CloudWatch para recibir las métricas.
**Cómo configurar y ejecutar la supervisión de la GPU con CloudWatch**
1. Cree un usuario de IAM o modifique uno existente para tener una política en la que publicar la métrica. CloudWatch Si crea un usuario nuevo, anote las credenciales, ya que las necesitará en el siguiente paso.
La política de IAM que hay que buscar es «cloudwatch:». PutMetricData La política que se añade es la siguiente:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"cloudwatch:PutMetricData"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
**sugerencia**
[Para obtener más información sobre cómo crear un usuario de IAM y añadir políticas CloudWatch, consulte la documentación. CloudWatch ](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/create-iam-roles-for-cloudwatch-agent.html)
1. En la DLAMI, ejecute el comando [AWS configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html#cli-quick-configuration) y especifique las credenciales de usuario de IAM.
```
$ aws configure
```
1. 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 ubicación definida en el siguiente bloque de código. Para obtener más información sobre el script `gpumon.py`, consulte [la ubicación del script en Amazon S3](https://s3.amazonaws.com/aws-bigdata-blog/artifacts/GPUMonitoring/gpumon.py).
```
Folder: ~/tools/GPUCloudWatchMonitor
Files: ~/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 período del informe CloudWatch `namespace` o el período del informe, con`store_reso`.
1. Actualmente, el script solo es compatible con Python 3. Active el entorno de Python 3 de su marco de trabajo preferido o active el entorno general de Python 3 de la DLAMI.
```
$ source activate python3
```
1. Ejecute la utilidad gpumon en segundo plano.
```
(python3)$ python gpumon.py &
```
1. Abra [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) en el navegador y seleccione la métrica. Tendrá un espacio de nombres ''. DeepLearningTrain
**sugerencia**
Puede cambiar el espacio de nombres modificando gpumon.py. También puede modificar el intervalo de notificación ajustando `store_reso`.
El siguiente es un ejemplo de CloudWatch gráfico que informa sobre una ejecución de gpumon.py supervisando un trabajo de entrenamiento en una instancia p2.8xlarge.
![\[Supervisión de GPU activada CloudWatch\]](http://docs.aws.amazon.com/es_es/dlami/latest/devguide/images/gpumon.png)
Es posible que le interesen estos otros temas sobre la monitorización y optimización de GPU:
+ [Supervisión](tutorial-gpu-monitoring.md)
+ [GPUs Supervise con CloudWatch](#tutorial-gpu-monitoring-gpumon)
+ [Optimización](tutorial-gpu-opt.md)
+ [Procesamiento previo](tutorial-gpu-opt-preprocessing.md)
+ [Formación](tutorial-gpu-opt-training.md)
# Optimización
Para sacarle el máximo partido GPUs, puede optimizar su canalización de datos y ajustar su red de aprendizaje profundo. Tal como se describe en el siguiente gráfico, una implementación ingenua o básica de una red neuronal podría utilizar la GPU de un modo incoherente y no aprovechar todo su potencial. Al optimizar el procesamiento previo y la carga de datos, es posible reducir el cuello de botella de la CPU a 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 de precisión múltiple (float16 o int8) en la mayoría de los marcos de trabajo, lo que puede tener un efecto drástico en la mejora del rendimiento.
El gráfico siguiente muestra la mejora acumulativa del rendimiento que se obtiene cuando se aplican distintas optimizaciones. Los resultados dependerán de los datos que esté procesando y de la red que esté optimizando.
![\[Mejoras de rendimiento para GPUs\]](http://docs.aws.amazon.com/es_es/dlami/latest/devguide/images/performance-enhancements.png)
Las siguientes guías introducen opciones que funcionarán con la DLAMI y que le ayudarán a aumentar el rendimiento de la GPU.
**Topics**
+ [
# Procesamiento previo
](tutorial-gpu-opt-preprocessing.md)
+ [
# Formación
](tutorial-gpu-opt-training.md)
# Procesamiento previo
El procesamiento previo de los datos a través de transformaciones o aumentos es con frecuencia un proceso asociado a la CPU y puede ser el cuello de botella en la canalización general. Los marcos de trabajo tienen operadores integrados para el procesamiento de imágenes, pero DALI (Data Augmentation Library) 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. No está preinstalada en la DLAMI, pero puede obtener acceso a ella instalando o cargando un contenedor de marcos de trabajo compatible en la DLAMI o en otra instancia de Amazon Elastic Compute Cloud. Consulte la [página del proyecto DALI](https://docs.nvidia.com/deeplearning/sdk/dali-install-guide/index.html) en el sitio web de NVIDIA para obtener más información. Para ver un ejemplo de caso de uso y descargar ejemplos de código, consulta el ejemplo sobre el rendimiento del entrenamiento [ SageMaker previo al procesamiento](https://github.com/aws-samples/sagemaker-cv-preprocessing-training-performance).
+ 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 de transformación subsiguientes tan frecuentes en el aprendizaje profundo. nvJPEG viene integrada en DALI, pero puede descargarla en la [página de nvjpeg del sitio web de NVIDIA](https://developer.nvidia.com/nvjpeg) y utilizarla de forma independiente.
Es posible que le interesen estos otros temas sobre la monitorización y optimización de GPU:
+ [Supervisión](tutorial-gpu-monitoring.md)
+ [GPUs Supervise con CloudWatch](tutorial-gpu-monitoring-gpumon.md)
+ [Optimización](tutorial-gpu-opt.md)
+ [Procesamiento previo](#tutorial-gpu-opt-preprocessing)
+ [Formación](tutorial-gpu-opt-training.md)
# Formación
El entrenamiento de precisión mixta permite implementar redes de mayor tamaño con la misma cantidad de memoria, o reducir el uso de esta en comparación con las redes de precisión única o doble, lo que se traduce en un aumento del rendimiento informático. También ofrece el beneficio de transferencias de datos 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 escalado de pérdidas. Las siguientes guías describen cómo realizar esta operación en los marcos de trabajo compatibles con la precisión mixta.
+ [SDK de aprendizaje profundo de NVIDIA](https://docs.nvidia.com/deeplearning/sdk/mixed-precision-training/): documentos en el sitio web de NVIDIA que describen la implementación de precisión mixta para, y. MXNet PyTorch TensorFlow
**sugerencia**
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 muestran algunas guías de precisión mixta que pueden resultarle de utilidad:
[Formación de precisión mixta con TensorFlow (vídeo)](https://devblogs.nvidia.com/mixed-precision-resnet-50-tensor-cores/): en el blog de NVIDIA.
[Entrenamiento de precisión mixta con float16 con](https://mxnet.apache.org/api/faq/float16) un artículo de preguntas frecuentes en el MXNet sitio web. MXNet
[NVIDIA Apex: una herramienta para un entrenamiento sencillo de precisión mixta con PyTorch](https://devblogs.nvidia.com/apex-pytorch-easy-mixed-precision-training/) un artículo de blog en el sitio web de NVIDIA.
Es posible que le interesen estos otros temas sobre la monitorización y optimización de GPU:
+ [Supervisión](tutorial-gpu-monitoring.md)
+ [GPUs Supervise con CloudWatch](tutorial-gpu-monitoring-gpumon.md)
+ [Optimización](tutorial-gpu-opt.md)
+ [Procesamiento previo](tutorial-gpu-opt-preprocessing.md)
+ [Formación](#tutorial-gpu-opt-training)
# El chip AWS Inferentia con DLAMI
AWS Inferentia es un chip de aprendizaje automático personalizado diseñado por AWS el usuario para realizar predicciones de inferencias de alto rendimiento. Para usar el chip, configure una instancia de Amazon Elastic Compute Cloud y use el kit de desarrollo de software (SDK) AWS Neuron para invocar el chip Inferentia. Para proporcionar a los clientes la mejor experiencia de Inferentia, Neuron está incorporado en la AWS Deep Learning AMIs (DLAMI).
En los siguientes temas se muestra cómo comenzar a usar Inferentia con la DLAMI.
**Topics**
+ [
# Lanzamiento de una instancia DLAMI con Neuron AWS
](tutorial-inferentia-launching.md)
+ [
# Uso del DLAMI con Neuron AWS
](tutorial-inferentia-using.md)
# Lanzamiento de una instancia DLAMI con Neuron AWS
La última versión de DLAMI está lista para usarse AWS con Inferentia e incluye el paquete de API Neuron. AWS Para iniciar una instancia de la DLAMI, consulte [Lanzamiento y configuración de una DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html). Una vez que tenga un DLAMI, siga los pasos que se indican a continuación para asegurarse de que AWS su chip AWS Inferentia y sus recursos de Neuron estén activos.
**Topics**
+ [
## Comprobación de la instancia
](#tutorial-inferentia-launching-verify)
+ [
## Identificación de los dispositivos de inferencia AWS
](#tutorial-inferentia-launching-identify)
+ [
## Visualización del uso de recursos
](#tutorial-inferentia-launching-resource-usage)
+ [
## Uso de Neuron Monitor (monitor de neuronas)
](#tutorial-inferentia-launching-neuron-monitor)
+ [
## Actualización del software Neuron
](#tutorial-inferentia-launching-upgrade)
## Comprobación de la instancia
Antes de usar la instancia, compruebe que esté correctamente instalada y configurada con Neuron.
## Identificación de los dispositivos de inferencia AWS
Para identificar el número de dispositivos de Inferencia de la instancia, utilice el siguiente comando:
```
neuron-ls
```
Si su instancia tiene dispositivos de Inferentia asociados a ella, la salida tendrá un aspecto similar al siguiente:
```
+--------+--------+--------+-----------+--------------+
| NEURON | NEURON | NEURON | CONNECTED | PCI |
| DEVICE | CORES | MEMORY | DEVICES | BDF |
+--------+--------+--------+-----------+--------------+
| 0 | 4 | 8 GB | 1 | 0000:00:1c.0 |
| 1 | 4 | 8 GB | 2, 0 | 0000:00:1d.0 |
| 2 | 4 | 8 GB | 3, 1 | 0000:00:1e.0 |
| 3 | 4 | 8 GB | 2 | 0000:00:1f.0 |
+--------+--------+--------+-----------+--------------+
```
El resultado suministrado se toma de una instancia INF1.6xLarge e incluye las siguientes columnas:
+ DISPOSITIVO NEURONAL: el identificador lógico asignado al. NeuronDevice Este ID se usa al configurar varios tiempos de ejecución para usar diferentes. NeuronDevices
+ NÚCLEOS NEURONALES: el número de núcleos NeuronCores presentes en. NeuronDevice
+ MEMORIA NEURONAL: La cantidad de memoria DRAM en el. NeuronDevice
+ DISPOSITIVOS CONECTADOS: Otros NeuronDevices conectados al. NeuronDevice
+ PCI BDF: El identificador de la función de dispositivo de bus PCI (BDF) del. NeuronDevice
## Visualización del uso de recursos
Vea información útil sobre NeuronCore el uso de la vCPU, el uso de la memoria, los modelos cargados y las aplicaciones de Neuron con el comando. `neuron-top` Si se inicia `neuron-top` sin argumentos, se mostrarán los datos de todas las aplicaciones de aprendizaje automático que se utilicen. NeuronCores
```
neuron-top
```
Cuando una aplicación utiliza cuatro NeuronCores, el resultado debe tener un aspecto similar al de la imagen siguiente:
![\[El resultado del neuron-top comando, con la información de uno de los cuatro NeuronCores resaltada.\]](http://docs.aws.amazon.com/es_es/dlami/latest/devguide/images/neuron-top-output.png)
Para obtener más información sobre los recursos para supervisar y optimizar las aplicaciones de inferencia basadas en Neuron, consulte [Neuron Tools](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/index.html).
## Uso de Neuron Monitor (monitor de neuronas)
Neuron Monitor recopila las métricas de los tiempos de ejecución de Neuron que se ejecutan en el sistema y transmite los datos recopilados a la salida estándar en formato JSON. Estas métricas se organizan en grupos de métricas que se configuran proporcionando un archivo de configuración. Para obtener más información sobre Neuron Monitor, consulte la [User Guide for Neuron Monitor](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/neuron-monitor-user-guide.html).
## Actualización del software Neuron
[Para obtener información sobre cómo actualizar el software Neuron SDK en DLAMI, consulte AWS la Guía de configuración de Neuron.](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-intro/neuron-install-guide.html)
**Paso siguiente**
[Uso del DLAMI con Neuron AWS](tutorial-inferentia-using.md)
# Uso del DLAMI con Neuron AWS
Un flujo de trabajo típico con el SDK de AWS Neuron consiste en compilar un modelo de aprendizaje automático previamente entrenado en un servidor de compilación. Después, distribuya los artefactos a las instancias de Inf1 para su ejecución. AWS Deep Learning AMIs (DLAMI) viene preinstalado con todo lo que necesita para compilar y ejecutar inferencias en una instancia de Inf1 que usa Inferentia.
En las siguientes secciones se describe cómo utilizar la DLAMI con Inferentia.
**Topics**
+ [
# TensorFlowUso de AWS -Neuron y el compilador Neuron
](tutorial-inferentia-tf-neuron.md)
+ [
# Uso de AWS Neuron Serving TensorFlow
](tutorial-inferentia-tf-neuron-serving.md)
+ [
# Uso de MXNet -Neuron y el compilador Neuron AWS
](tutorial-inferentia-mxnet-neuron.md)
+ [
# Uso del modelo MXNet -Neuron Serving
](tutorial-inferentia-mxnet-neuron-serving.md)
+ [
# Uso de PyTorch -Neuron y el compilador Neuron AWS
](tutorial-inferentia-pytorch-neuron.md)
# TensorFlowUso de AWS -Neuron y el compilador Neuron
Este tutorial muestra cómo usar el compilador AWS Neuron para compilar el modelo Keras ResNet -50 y exportarlo como un modelo guardado en formato. SavedModel Este formato es un formato típico TensorFlow de modelos intercambiables. También aprenderá a ejecutar la inferencia en una instancia Inf1 con entrada de ejemplo.
Para obtener más información sobre el SDK de Neuron, consulte la [documentación del SDK de AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html).
**Topics**
+ [
## Requisitos previos
](#tutorial-inferentia-tf-neuron-prerequisites)
+ [
## Activación del entorno Conda
](#tutorial-inferentia-tf-neuron-activate)
+ [
## Compilación de Resnet50
](#tutorial-inferentia-tf-neuron-compilation)
+ [
## ResNet50 Inferencia
](#tutorial-inferentia-tf-neuron-inference)
## Requisitos previos
Antes de utilizar este tutorial, debería haber completado los pasos de configuración de [Lanzamiento de una instancia DLAMI con Neuron AWS](tutorial-inferentia-launching.md). También debe estar familiarizado con el aprendizaje profundo y con el uso de la DLAMI.
## Activación del entorno Conda
Active el entorno conda TensorFlow -Neuron mediante el siguiente comando:
```
source activate aws_neuron_tensorflow_p36
```
Para salir del entorno Conda actual, ejecute el siguiente comando:
```
source deactivate
```
## Compilación de Resnet50
Cree un script de Python llamada denominado **tensorflow\$1compile\$1resnet50.py** que tenga el siguiente contenido. Este script de Python compila el modelo Keras ResNet 50 y lo exporta como un modelo guardado.
```
import os
import time
import shutil
import tensorflow as tf
import tensorflow.neuron as tfn
import tensorflow.compat.v1.keras as keras
from tensorflow.keras.applications.resnet50 import ResNet50
from tensorflow.keras.applications.resnet50 import preprocess_input
# Create a workspace
WORKSPACE = './ws_resnet50'
os.makedirs(WORKSPACE, exist_ok=True)
# Prepare export directory (old one removed)
model_dir = os.path.join(WORKSPACE, 'resnet50')
compiled_model_dir = os.path.join(WORKSPACE, 'resnet50_neuron')
shutil.rmtree(model_dir, ignore_errors=True)
shutil.rmtree(compiled_model_dir, ignore_errors=True)
# Instantiate Keras ResNet50 model
keras.backend.set_learning_phase(0)
model = ResNet50(weights='imagenet')
# Export SavedModel
tf.saved_model.simple_save(
session = keras.backend.get_session(),
export_dir = model_dir,
inputs = {'input': model.inputs[0]},
outputs = {'output': model.outputs[0]})
# Compile using Neuron
tfn.saved_model.compile(model_dir, compiled_model_dir)
# Prepare SavedModel for uploading to Inf1 instance
shutil.make_archive(compiled_model_dir, 'zip', WORKSPACE, 'resnet50_neuron')
```
Compile 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 siguiente aspecto:
```
...
INFO:tensorflow:fusing subgraph neuron_op_d6f098c01c780733 with neuron-cc
INFO:tensorflow:Number of operations in TensorFlow session: 4638
INFO:tensorflow:Number of operations after tf.neuron optimizations: 556
INFO:tensorflow:Number of operations placed on Neuron runtime: 554
INFO:tensorflow:Successfully converted ./ws_resnet50/resnet50 to ./ws_resnet50/resnet50_neuron
...
```
Después de la compilación, el modelo guardado se comprime en **ws\$1resnet50/resnet50\$1neuron.zip**. Descomprima el modelo y descargue la imagen de muestra para la inferencia mediante 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
```
## ResNet50 Inferencia
Cree un script de Python llamada denominado **tensorflow\$1infer\$1resnet50.py** que tenga el siguiente contenido. Este script ejecuta la inferencia en el modelo descargado utilizando un modelo de inferencia compilado previamente.
```
import os
import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications import resnet50
# Create input from image
img_sgl = image.load_img('kitten_small.jpg', target_size=(224, 224))
img_arr = image.img_to_array(img_sgl)
img_arr2 = np.expand_dims(img_arr, axis=0)
img_arr3 = resnet50.preprocess_input(img_arr2)
# Load model
COMPILED_MODEL_DIR = './ws_resnet50/resnet50_neuron/'
predictor_inferentia = tf.contrib.predictor.from_saved_model(COMPILED_MODEL_DIR)
# Run inference
model_feed_dict={'input': img_arr3}
infa_rslts = predictor_inferentia(model_feed_dict);
# Display results
print(resnet50.decode_predictions(infa_rslts["output"], top=5)[0])
```
Ejecute la inferencia en el modelo mediante el siguiente comando:
```
python tensorflow_infer_resnet50.py
```
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 AWS Neuron Serving TensorFlow](tutorial-inferentia-tf-neuron-serving.md)
# Uso de AWS Neuron Serving TensorFlow
Este tutorial muestra cómo construir un gráfico y añadir un paso de compilación de AWS Neuron antes de exportar el modelo guardado para usarlo con TensorFlow Serving. TensorFlow Serving es un sistema de servidor que permite ampliar las inferencias en una red. Neuron TensorFlow Serving utiliza la misma API que el Serving normal. TensorFlow La única diferencia es que se debe compilar un modelo guardado para AWS Inferentia y el punto de entrada es un nombre binario diferente. `tensorflow_model_server_neuron` El binario se encuentra en `/usr/local/bin/tensorflow_model_server_neuron` y está preinstalado en la DLAMI.
Para obtener más información sobre el SDK de Neuron, consulte la [documentación del SDK de AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html).
**Topics**
+ [
## Requisitos previos
](#tutorial-inferentia-tf-neuron--serving-prerequisites)
+ [
## Activación del entorno Conda
](#tutorial-inferentia-tf-neuron-serving-activate)
+ [
## Compilación y exportación del modelo guardado
](#tutorial-inferentia-tf-neuron-serving-compile)
+ [
## Distribución del modelo guardado
](#tutorial-inferentia-tf-neuron-serving-serving)
+ [
## Generación de solicitudes de inferencia al servidor de modelos
](#tutorial-inferentia-tf-neuron-serving-inference)
## Requisitos previos
Antes de utilizar este tutorial, debería haber completado los pasos de configuración de [Lanzamiento de una instancia DLAMI con Neuron AWS](tutorial-inferentia-launching.md). También debe estar familiarizado con el aprendizaje profundo y con el uso de la DLAMI.
## Activación del entorno Conda
Active el entorno conda TensorFlow -Neuron mediante el siguiente comando:
```
source activate aws_neuron_tensorflow_p36
```
Si necesita salir del entorno Conda actual, ejecute:
```
source deactivate
```
## Compilación y exportación del modelo guardado
Cree un script de Python denominado `tensorflow-model-server-compile.py` con el siguiente contenido. Este script construye un gráfico y lo compila con Neuron. A continuación, exporta el gráfico compilado como un modelo guardado.
```
import tensorflow as tf
import tensorflow.neuron
import os
tf.keras.backend.set_learning_phase(0)
model = tf.keras.applications.ResNet50(weights='imagenet')
sess = tf.keras.backend.get_session()
inputs = {'input': model.inputs[0]}
outputs = {'output': model.outputs[0]}
# save the model using tf.saved_model.simple_save
modeldir = "./resnet50/1"
tf.saved_model.simple_save(sess, modeldir, inputs, outputs)
# compile the model for Inferentia
neuron_modeldir = os.path.join(os.path.expanduser('~'), 'resnet50_inf1', '1')
tf.neuron.saved_model.compile(modeldir, neuron_modeldir, batch_size=1)
```
Compile el modelo con el siguiente comando:
```
python tensorflow-model-server-compile.py
```
El resultado debería tener el siguiente aspecto:
```
...
INFO:tensorflow:fusing subgraph neuron_op_d6f098c01c780733 with neuron-cc
INFO:tensorflow:Number of operations in TensorFlow session: 4638
INFO:tensorflow:Number of operations after tf.neuron optimizations: 556
INFO:tensorflow:Number of operations placed on Neuron runtime: 554
INFO:tensorflow:Successfully converted ./resnet50/1 to /home/ubuntu/resnet50_inf1/1
```
## Distribución del modelo guardado
Una vez compilado el modelo, puede usar el siguiente comando para distribuir el modelo guardado con el binario tensorflow\$1model\$1server\$1neuron:
```
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 manera provisional en la DRAM del dispositivo de 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
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 siguiente contenido. Este script ejecuta la inferencia a través de gRPC, que es el marco de trabajo de servicio.
```
import numpy as np
import grpc
import tensorflow as tf
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.resnet50 import preprocess_input
from tensorflow_serving.apis import predict_pb2
from tensorflow_serving.apis import prediction_service_pb2_grpc
from tensorflow.keras.applications.resnet50 import decode_predictions
if __name__ == '__main__':
channel = grpc.insecure_channel('localhost:8500')
stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)
img_file = tf.keras.utils.get_file(
"./kitten_small.jpg",
"https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg")
img = image.load_img(img_file, target_size=(224, 224))
img_array = preprocess_input(image.img_to_array(img)[None, ...])
request = predict_pb2.PredictRequest()
request.model_spec.name = 'resnet50_inf1'
request.inputs['input'].CopyFrom(
tf.contrib.util.make_tensor_proto(img_array, shape=img_array.shape))
result = stub.Predict(request)
prediction = tf.make_ndarray(result.outputs['output'])
print(decode_predictions(prediction))
```
Ejecute la inferencia en el modelo utilizando gRPC con el siguiente comando:
```
python tensorflow-model-server-infer.py
```
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)]]
```
# Uso de MXNet -Neuron y el compilador Neuron AWS
La API de compilación MXNet -Neuron proporciona un método para compilar un gráfico modelo que se puede ejecutar en un dispositivo de inferencia. AWS
En este ejemplo, usa la API para compilar un modelo ResNet -50 y usarlo para ejecutar inferencias.
Para obtener más información sobre el SDK de Neuron, consulte la [documentación del SDK de AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html).
**Topics**
+ [
## Requisitos previos
](#tutorial-inferentia-mxnet-neuron-prerequisites)
+ [
## Activación del entorno Conda
](#tutorial-inferentia-mxnet-neuron-activate)
+ [
## Compilación de Resnet50
](#tutorial-inferentia-mxnet-neuron-compilation)
+ [
## ResNetInferencia 5.0
](#tutorial-inferentia-mxnet-neuron-inference)
## Requisitos previos
Antes de utilizar este tutorial, debería haber completado los pasos de configuración de [Lanzamiento de una instancia DLAMI con Neuron AWS](tutorial-inferentia-launching.md). También debe estar familiarizado con el aprendizaje profundo y con el uso de la DLAMI.
## Activación del entorno Conda
Active el entorno conda MXNet -Neuron mediante el siguiente comando:
```
source activate aws_neuron_mxnet_p36
```
Para salir del entorno Conda actual, ejecute:
```
source deactivate
```
## Compilación de Resnet50
Cree un script de Python denominado **mxnet\$1compile\$1resnet50.py** con el siguiente contenido. Este script usa la API de Python de MXNet compilación -Neuron para compilar un modelo ResNet -50.
```
import mxnet as mx
import numpy as np
print("downloading...")
path='http://data.mxnet.io/models/imagenet/'
mx.test_utils.download(path+'resnet/50-layers/resnet-50-0000.params')
mx.test_utils.download(path+'resnet/50-layers/resnet-50-symbol.json')
print("download finished.")
sym, args, aux = mx.model.load_checkpoint('resnet-50', 0)
print("compile for inferentia using neuron... this will take a few minutes...")
inputs = { "data" : mx.nd.ones([1,3,224,224], name='data', dtype='float32') }
sym, args, aux = mx.contrib.neuron.compile(sym, args, aux, inputs)
print("save compiled model...")
mx.model.save_checkpoint("compiled_resnet50", 0, sym, args, aux)
```
Compile el modelo con el siguiente comando:
```
python mxnet_compile_resnet50.py
```
La compilación tardará unos minutos. Cuando haya finalizado, los siguientes archivos estarán en su directorio actual:
```
resnet-50-0000.params
resnet-50-symbol.json
compiled_resnet50-0000.params
compiled_resnet50-symbol.json
```
## ResNetInferencia 5.0
Cree un script de Python denominado **mxnet\$1infer\$1resnet50.py** con el siguiente contenido. Este script descarga una imagen de muestra y la utiliza para ejecutar la inferencia con el modelo compilado.
```
import mxnet as mx
import numpy as np
path='http://data.mxnet.io/models/imagenet/'
mx.test_utils.download(path+'synset.txt')
fname = mx.test_utils.download('https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg')
img = mx.image.imread(fname)
# convert into format (batch, RGB, width, height)
img = mx.image.imresize(img, 224, 224)
# resize
img = img.transpose((2, 0, 1))
# Channel first
img = img.expand_dims(axis=0)
# batchify
img = img.astype(dtype='float32')
sym, args, aux = mx.model.load_checkpoint('compiled_resnet50', 0)
softmax = mx.nd.random_normal(shape=(1,))
args['softmax_label'] = softmax
args['data'] = img
# Inferentia context
ctx = mx.neuron()
exe = sym.bind(ctx=ctx, args=args, aux_states=aux, grad_req='null')
with open('synset.txt', 'r') as f:
labels = [l.rstrip() for l in f]
exe.forward(data=img)
prob = exe.outputs[0].asnumpy()
# print the top-5
prob = np.squeeze(prob)
a = np.argsort(prob)[::-1]
for i in a[0:5]:
print('probability=%f, class=%s' %(prob[i], labels[i]))
```
Ejecute la inferencia con el modelo compilado mediante el siguiente comando:
```
python mxnet_infer_resnet50.py
```
El resultado debería tener el siguiente aspecto:
```
probability=0.642454, class=n02123045 tabby, tabby cat
probability=0.189407, class=n02123159 tiger cat
probability=0.100798, class=n02124075 Egyptian cat
probability=0.030649, class=n02127052 lynx, catamount
probability=0.016278, class=n02129604 tiger, Panthera tigris
```
**Paso siguiente**
[Uso del modelo MXNet -Neuron Serving](tutorial-inferentia-mxnet-neuron-serving.md)
# Uso del modelo MXNet -Neuron Serving
En este tutorial, aprenderá a utilizar un MXNet modelo previamente entrenado para realizar la clasificación de imágenes en tiempo real con Multi Model Server (MMS). El MMS es una easy-to-use herramienta flexible para utilizar modelos de aprendizaje profundo que se entrenan con cualquier marco de aprendizaje automático o aprendizaje profundo. Este tutorial incluye un paso de compilación con AWS Neuron y una implementación del MMS con. MXNet
Para obtener más información sobre el SDK de Neuron, consulte la [documentación del SDK de AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html).
**Topics**
+ [
## Requisitos previos
](#tutorial-inferentia-mxnet-neuron-serving-prerequisites)
+ [
## Activación del entorno Conda
](#tutorial-inferentia-mxnet-neuron-serving-activate)
+ [
## Descarga del código de ejemplo
](#tutorial-inferentia-mxnet-neuron-serving-download)
+ [
## Compile el modelo.
](#tutorial-inferentia-mxnet-neuron-serving-compile)
+ [
## Ejecutar inferencia
](#tutorial-inferentia-mxnet-neuron-serving-inference)
## Requisitos previos
Antes de utilizar este tutorial, debería haber completado los pasos de configuración de [Lanzamiento de una instancia DLAMI con Neuron AWS](tutorial-inferentia-launching.md). También debe estar familiarizado con el aprendizaje profundo y con el uso de la DLAMI.
## Activación del entorno Conda
Active el entorno conda MXNet -Neuron mediante el siguiente comando:
```
source activate aws_neuron_mxnet_p36
```
Para salir del entorno Conda actual, ejecute:
```
source deactivate
```
## Descarga del código de ejemplo
Para ejecutar este ejemplo, descargue el código de ejemplo mediante los siguientes comandos:
```
git clone https://github.com/awslabs/multi-model-server
cd 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 ResNet 50 con el objetivo del dispositivo Inferentia.
```
import mxnet as mx
from mxnet.contrib import neuron
import numpy as np
path='http://data.mxnet.io/models/imagenet/'
mx.test_utils.download(path+'resnet/50-layers/resnet-50-0000.params')
mx.test_utils.download(path+'resnet/50-layers/resnet-50-symbol.json')
mx.test_utils.download(path+'synset.txt')
nn_name = "resnet-50"
#Load a model
sym, args, auxs = mx.model.load_checkpoint(nn_name, 0)
#Define compilation parameters# - input shape and dtype
inputs = {'data' : mx.nd.zeros([1,3,224,224], dtype='float32') }
# compile graph to inferentia target
csym, cargs, cauxs = neuron.compile(sym, args, auxs, inputs)
# save compiled model
mx.model.save_checkpoint(nn_name + "_compiled", 0, csym, cargs, cauxs)
```
Para compilar el modelo, utilice el siguiente comando:
```
python multi-model-server-compile.py
```
El resultado debería tener el siguiente aspecto:
```
...
[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 de entrada:
```
{
"inputs": [
{
"data_name": "data",
"data_shape": [
1,
3,
224,
224
]
}
]
}
```
Descargue el archivo `synset.txt` con el siguiente comando. Este archivo es una lista de nombres para ImageNet las clases de predicción.
```
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 contexto `mx.neuron()` de la siguiente manera. También debe comentar la copia de datos innecesaria, `model_input` ya que MXNet -Neuron no es compatible con NDArray y Gluon. APIs
```
...
self.mxnet_ctx = mx.neuron() if gpu_id is None else mx.gpu(gpu_id)
...
#model_input = [item.as_in_context(self.mxnet_ctx) for item in model_input]
```
Empaquete el modelo con model-archiver utilizando los siguientes comandos:
```
cd ~/multi-model-server/examples
model-archiver --force --model-name resnet-50_compiled --model-path mxnet_vision --handler mxnet_vision_service:handle
```
## Ejecutar inferencia
Inicie el servidor multimodelo y cargue el modelo que usa la RESTful API 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 MMS
curl -v -X POST "http://localhost:8081/models?initial_workers=1&max_workers=4&synchronous=true&url=resnet-50_compiled.mar"
sleep 10 # allow sufficient time to load model
```
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
curl -X POST http://127.0.0.1:8080/predictions/resnet-50_compiled -T kitten_small.jpg
```
El resultado debería tener el siguiente aspecto:
```
[
{
"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 de eliminación a través de la RESTful API y detenga el servidor de modelos mediante los siguientes comandos:
```
curl -X DELETE http://127.0.0.1:8081/models/resnet-50_compiled
multi-model-server --stop
```
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) :: success
Destroying NCG 1 :: success
```
# Uso de PyTorch -Neuron y el compilador Neuron AWS
La API de compilación PyTorch -Neuron proporciona un método para compilar un gráfico modelo que se puede ejecutar en un dispositivo de inferencia. AWS
Un modelo entrenado debe compilarse en un destino de Inferentia antes de poder implementarlo en instancias Inf1. El siguiente tutorial compila el modelo torchvision ResNet 50 y lo exporta como un módulo guardado. TorchScript 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 la inferencia. En la práctica, puede compilar el modelo con otro tipo de instancia, como la familia de 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 ](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/pytorch-neuron/index.html).
**Topics**
+ [
## Requisitos previos
](#tutorial-inferentia-pytorch-neuron-prerequisites)
+ [
## Activación del entorno Conda
](#tutorial-inferentia-pytorch-neuron-activate)
+ [
## Compilación de Resnet50
](#tutorial-inferentia-pytorch-neuron-compilation)
+ [
## ResNetInferencia 5.0
](#tutorial-inferentia-pytorch-neuron-inference)
## Requisitos previos
Antes de utilizar este tutorial, debería haber completado los pasos de configuración de [Lanzamiento de una instancia DLAMI con Neuron AWS](tutorial-inferentia-launching.md). También debe estar familiarizado con el aprendizaje profundo y con el uso de la DLAMI.
## Activación del entorno Conda
Active el entorno conda PyTorch -Neuron mediante el siguiente comando:
```
source activate aws_neuron_pytorch_p36
```
Para salir del entorno Conda actual, ejecute:
```
source deactivate
```
## Compilación de Resnet50
Cree un script de Python denominado **pytorch\$1trace\$1resnet50.py** con el siguiente contenido. Este script usa la API de Python de PyTorch compilación -Neuron para compilar un modelo ResNet -50.
**nota**
Hay una dependencia entre las versiones de torchvision y el paquete de torch que debe tener en cuenta al compilar los modelos de torchvision. Estas reglas de dependencia se pueden gestionar a través de pip. Torchvision==0.6.1 coincide con la versión torch==1.5.1, mientras que torchvision==0.8.2 coincide con la versión torch==1.7.1.
```
import torch
import numpy as np
import os
import torch_neuron
from torchvision import models
image = torch.zeros([1, 3, 224, 224], dtype=torch.float32)
## Load a pretrained ResNet50 model
model = models.resnet50(pretrained=True)
## Tell the model we are using it for evaluation (not training)
model.eval()
model_neuron = torch.neuron.trace(model, example_inputs=[image])
## Export to saved model
model_neuron.save("resnet50_neuron.pt")
```
Ejecute el script de compilación.
```
python pytorch_trace_resnet50.py
```
La compilación tardará unos minutos. Cuando haya finalizado, el modelo compilado se guardará como `resnet50_neuron.pt` en el directorio local.
## ResNetInferencia 5.0
Cree un script de Python denominado **pytorch\$1infer\$1resnet50.py** con el siguiente contenido. Este script descarga una imagen de muestra y la utiliza para ejecutar la inferencia con el modelo compilado.
```
import os
import time
import torch
import torch_neuron
import json
import numpy as np
from urllib import request
from torchvision import models, transforms, datasets
## Create an image directory containing a small kitten
os.makedirs("./torch_neuron_test/images", exist_ok=True)
request.urlretrieve("https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg",
"./torch_neuron_test/images/kitten_small.jpg")
## Fetch labels to output the top classifications
request.urlretrieve("https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json","imagenet_class_index.json")
idx2label = []
with open("imagenet_class_index.json", "r") as read_file:
class_idx = json.load(read_file)
idx2label = [class_idx[str(k)][1] for k in range(len(class_idx))]
## Import a sample image and normalize it into a tensor
normalize = transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
eval_dataset = datasets.ImageFolder(
os.path.dirname("./torch_neuron_test/"),
transforms.Compose([
transforms.Resize([224, 224]),
transforms.ToTensor(),
normalize,
])
)
image, _ = eval_dataset[0]
image = torch.tensor(image.numpy()[np.newaxis, ...])
## Load model
model_neuron = torch.jit.load( 'resnet50_neuron.pt' )
## Predict
results = model_neuron( image )
# Get the top 5 results
top5_idx = results[0].sort()[1][-5:]
# Lookup and print the top 5 labels
top5_labels = [idx2label[idx] for idx in top5_idx]
print("Top 5 labels:\n {}".format(top5_labels) )
```
Ejecute la inferencia con el modelo compilado mediante el siguiente comando:
```
python pytorch_infer_resnet50.py
```
El resultado debería tener el siguiente aspecto:
```
Top 5 labels:
['tiger', 'lynx', 'tiger_cat', 'Egyptian_cat', 'tabby']
```
# El ARM64 DLAMI
AWS ARM64 DLAMIs Las GPU están diseñadas para proporcionar un alto rendimiento y rentabilidad para las cargas de trabajo de aprendizaje profundo. En concreto, el tipo de instancia G5G incluye el [procesador AWS Graviton2](https://aws.amazon.com/ec2/graviton/) basado en ARM64, que se creó desde cero AWS y se optimizó para la forma en que los clientes ejecutan sus cargas de trabajo en la nube. AWS ARM64 DLAMIs Las GPU están preconfiguradas con Docker, NVIDIA Docker, NVIDIA Driver, CUDA, cuDNN, NCCL, así como con marcos de aprendizaje automático populares como y. TensorFlow PyTorch
Con el tipo de instancia G5g, puede aprovechar las ventajas de precio y rendimiento de Graviton2 para implementar modelos de aprendizaje profundo acelerados por GPU a un costo significativamente menor en comparación con las instancias basadas en x86 con aceleración por GPU.
## Seleccione un ARM64 DLAMI
Lance una [instancia G5G](https://aws.amazon.com/ec2/instance-types/g5g/) con la ARM64 DLAMI de su elección.
Para step-by-step obtener instrucciones sobre el lanzamiento de una DLAMI, [consulte Lanzamiento y configuración](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html) de una DLAMI.
Para obtener una lista de las más recientes ARM64 DLAMIs, consulte las [notas de la versión de DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/appendix-ami-release-notes.html).
## Introducción
En los temas siguientes se muestra cómo empezar a utilizar la ARM64 DLAMI.
**Topics**
+ [
## Seleccione un ARM64 DLAMI
](#tutorial-arm64-select-dlami)
+ [
## Introducción
](#tutorial-arm64-get-started)
+ [
# Uso de la ARM64 GPU PyTorch DLAMI
](tutorial-arm64-pytorch.md)
# Uso de la ARM64 GPU PyTorch DLAMI
AWS Deep Learning AMIs Está lista para usarse con un procesador Arm64 y viene optimizada para ello. GPUs PyTorch La ARM64 GPU PyTorch DLAMI incluye un entorno Python preconfigurado [PyTorch](https://aws.amazon.com/pytorch)con y para casos de uso de [TorchVision](https://pytorch.org/vision/stable/index.html)inferencia [TorchServe](https://pytorch.org/serve/)y entrenamiento de aprendizaje profundo.
**Topics**
+ [
## Verificar el entorno de PyTorch Python
](#tutorial-arm64-pytorch-environment)
+ [
## Ejecute un ejemplo de entrenamiento con PyTorch
](#tutorial-arm64-pytorch-training)
+ [
## Ejecute un ejemplo de inferencia con PyTorch
](#tutorial-arm64-pytorch-inference)
## Verificar el entorno de PyTorch Python
Conéctese a su instancia de G5g y active el entorno base de Conda con el siguiente comando:
```
source activate base
```
La línea de comandos debe indicar que está trabajando en el entorno base de Conda, que contiene PyTorch TorchVision, y otras bibliotecas.
```
(base) $
```
Compruebe las rutas de herramientas predeterminadas del PyTorch entorno:
```
(base) $ which python
(base) $ which pip
(base) $ which conda
(base) $ which mamba
>>> import torch, torchvision
>>> torch.__version__
>>> torchvision.__version__
>>> v = torch.autograd.Variable(torch.randn(10, 3, 224, 224))
>>> v = torch.autograd.Variable(torch.randn(10, 3, 224, 224)).cuda()
>>> assert isinstance(v, torch.Tensor)
```
## Ejecute un ejemplo de entrenamiento con PyTorch
Ejecute un ejemplo de trabajo de entrenamiento sobre MNIST:
```
git clone https://github.com/pytorch/examples.git
cd examples/mnist
python main.py
```
El resultado debería tener un aspecto similar al siguiente:
```
...
Train Epoch: 14 [56320/60000 (94%)] Loss: 0.021424
Train Epoch: 14 [56960/60000 (95%)] Loss: 0.023695
Train Epoch: 14 [57600/60000 (96%)] Loss: 0.001973
Train Epoch: 14 [58240/60000 (97%)] Loss: 0.007121
Train Epoch: 14 [58880/60000 (98%)] Loss: 0.003717
Train Epoch: 14 [59520/60000 (99%)] Loss: 0.001729
Test set: Average loss: 0.0275, Accuracy: 9916/10000 (99%)
```
## Ejecute un ejemplo de inferencia con PyTorch
Utilice los siguientes comandos para descargar un modelo densenet161 previamente entrenado y ejecutar la inferencia mediante: TorchServe
```
# Set up TorchServe
cd $HOME
git clone https://github.com/pytorch/serve.git
mkdir -p serve/model_store
cd serve
# Download a pre-trained densenet161 model
wget https://download.pytorch.org/models/densenet161-8d451a50.pth >/dev/null
# Save the model using torch-model-archiver
torch-model-archiver --model-name densenet161 \
--version 1.0 \
--model-file examples/image_classifier/densenet_161/model.py \
--serialized-file densenet161-8d451a50.pth \
--handler image_classifier \
--extra-files examples/image_classifier/index_to_name.json \
--export-path model_store
# Start the model server
torchserve --start --no-config-snapshots \
--model-store model_store \
--models densenet161=densenet161.mar &> torchserve.log
# Wait for the model server to start
sleep 30
# Run a prediction request
curl http://127.0.0.1:8080/predictions/densenet161 -T examples/image_classifier/kitten.jpg
```
El resultado debería tener un aspecto similar al siguiente:
```
{
"tiger_cat": 0.4693363308906555,
"tabby": 0.4633873701095581,
"Egyptian_cat": 0.06456123292446136,
"lynx": 0.0012828150065615773,
"plastic_bag": 0.00023322898778133094
}
```
Utilice los siguientes comandos para anular el registro del modelo densenet161 y detener el servidor:
```
curl -X DELETE http://localhost:8081/models/densenet161/1.0
torchserve --stop
```
El resultado debería tener un aspecto similar al siguiente:
```
{
"status": "Model \"densenet161\" unregistered"
}
TorchServe has stopped.
```
# Inferencia
En esta sección, se proporcionan tutoriales sobre cómo ejecutar la inferencia utilizando los marcos de trabajo y las herramientas de la DLAMI.
## Herramientas de inferencia
+ [TensorFlow Sirviendo](tutorial-tfserving.md)
# Distribución de modelos
A continuación, se indican las opciones de distribución de modelos instaladas en la AMI de aprendizaje profundo con Conda. Haga clic en una de las opciones para obtener información acerca de cómo utilizarla.
**Topics**
+ [
# TensorFlow Sirviendo
](tutorial-tfserving.md)
+ [
# TorchServe
](tutorial-torchserve.md)
# TensorFlow Sirviendo
[TensorFlow Serving](https://www.tensorflow.org/tfx/guide/serving) es un sistema de servicio flexible y de alto rendimiento para modelos de aprendizaje automático.
La `tensorflow-serving-api` viene preinstalada con la DLAMI de un solo marco. Para usar el servicio de tensorflow, primero active el TensorFlow entorno.
```
$ source /opt/tensorflow/bin/activate
```
A continuación, utilice su editor de texto preferido para crear un script que tenga el siguiente contenido. Denomínelo `test_train_mnist.py`. Se hace referencia a este script en el [TensorFlow tutorial](https://github.com/tensorflow/docs/blob/master/site/en/tutorials/quickstart/beginner.ipynb), que entrenará y evaluará un modelo de aprendizaje automático de redes neuronales que clasifica imágenes.
```
import tensorflow as tf
mnist = tf.keras.datasets.mnist
(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(x_train, y_train, epochs=5)
model.evaluate(x_test, y_test)
```
Ahora ejecute el script pasando la ubicación y el puerto del servidor y el nombre de archivo de la foto del perro esquimal como parámetros.
```
$ /opt/tensorflow/bin/python3 test_train_mnist.py
```
Sea paciente, ya que el script puede tardar un rato en proporcionar resultados. Cuando se complete el entrenamiento, debería ver lo siguiente:
```
I0000 00:00:1739482012.389276 4284 device_compiler.h:188] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process.
1875/1875 [==============================] - 24s 2ms/step - loss: 0.2973 - accuracy: 0.9134
Epoch 2/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.1422 - accuracy: 0.9582
Epoch 3/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.1076 - accuracy: 0.9687
Epoch 4/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0872 - accuracy: 0.9731
Epoch 5/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.0731 - accuracy: 0.9771
313/313 [==============================] - 0s 1ms/step - loss: 0.0749 - accuracy: 0.9780
```
## Más características y ejemplos
Si está interesado en obtener más información sobre TensorFlow Serving, visite el [TensorFlow sitio web](https://www.tensorflow.org/serving/).
# TorchServe
TorchServe es una herramienta flexible para ofrecer modelos de aprendizaje profundo que se han exportado desde PyTorch. TorchServe viene preinstalada con la AMI de aprendizaje profundo con Conda.
Para obtener más información sobre su uso TorchServe, consulte [Model Server para PyTorch](https://github.com/pytorch/serve/blob/master/docs/README.md) ver la documentación.
**Temas**
## Sirva un modelo de clasificación de imágenes en TorchServe
En este tutorial se muestra cómo crear un modelo de clasificación de imágenes con TorchServe. Utiliza un modelo DenseNet -161 proporcionado por PyTorch. Una vez que el servidor está en funcionamiento, 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 coincidentes de entre las clases con las que se haya entrenado el modelo.
**A modo de ejemplo, un modelo de clasificación de imágenes en TorchServe**
1. Conéctese a una instancia de Amazon Elastic Compute Cloud (Amazon EC2) con el AMI de aprendizaje profundo con Conda, v34 o posterior.
1. Active el entorno de `pytorch_p310`.
```
source activate pytorch_p310
```
1. Clone el TorchServe repositorio y, a continuación, cree un directorio para almacenar sus modelos.
```
git clone https://github.com/pytorch/serve.git
mkdir model_store
```
1. Archive el modelo utilizando el archivador de modelos. El `extra-files` parámetro usa un archivo del `TorchServe` repositorio, así que actualiza la ruta si es necesario. Para obtener más información sobre el archivador de modelos, consulte el archivador de modelos [Torch](https://github.com/pytorch/serve/blob/master/model-archiver/README.md) para. TorchServe
```
wget https://download.pytorch.org/models/densenet161-8d451a50.pth
torch-model-archiver --model-name densenet161 --version 1.0 --model-file ./serve/examples/image_classifier/densenet_161/model.py --serialized-file densenet161-8d451a50.pth --export-path model_store --extra-files ./serve/examples/image_classifier/index_to_name.json --handler image_classifier
```
1. Ejecute TorchServe para iniciar un punto final. Al agregar `> /dev/null` se silencia la salida del registro.
```
torchserve --start --ncs --model-store model_store --models densenet161.mar > /dev/null
```
1. Descarga una imagen de un gatito y envíala al punto final de TorchServe predicción:
```
curl -O https://s3.amazonaws.com/model-server/inputs/kitten.jpg
curl http://127.0.0.1:8080/predictions/densenet161 -T kitten.jpg
```
El punto de conexión de predicción devuelve una predicción en JSON similar a las siguientes cinco predicciones principales, donde la imagen tiene una probabilidad del 47 % de contener un gato egipcio, seguida de una probabilidad del 46 % de que sea un lince o un gato montés:
```
{
"tiger_cat": 0.46933576464653015,
"tabby": 0.463387668132782,
"Egyptian_cat": 0.0645613968372345,
"lynx": 0.0012828196631744504,
"plastic_bag": 0.00023323058849200606
}
```
1. Cuando termine la prueba, detenga el servidor.
```
torchserve --stop
```
**Otros ejemplos**
TorchServe tiene varios ejemplos que puede ejecutar en su instancia de DLAMI. Puede verlos en la página de [ejemplos del repositorio de TorchServe proyectos](https://github.com/pytorch/serve/tree/master/examples).
**Más información**
Para obtener más TorchServe documentación, incluida la forma de configurar TorchServe con Docker y las TorchServe funciones más recientes, consulta [la página del TorchServe proyecto](https://github.com/pytorch/serve) en GitHub.