Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Esercitazioni
Di seguito sono riportati dei tutorial su come utilizzare l'AMI Deep Learning con il software di Conda.
**Topics**
+ [
# Attivazione di framework
](activating.md)
+ [
# Formazione distribuita con Elastic Fabric Adapter
](tutorial-efa.md)
+ [
# Monitoraggio e ottimizzazione GPU
](tutorial-gpu.md)
+ [
# Il chip AWS Inferentia con DLAMI
](tutorial-inferentia.md)
+ [
# Il ARM64 DLAMI
](tutorial-arm64.md)
+ [
# Inferenza
](tutorial-inference.md)
+ [
# Model serving
](model-serving.md)
# Attivazione di framework
Di seguito sono riportati i framework di deep learning installati sull'AMI Deep Learning con Conda. Fai clic su un framework per informazioni su come attivarlo.
**Topics**
+ [
# PyTorch
](tutorial-pytorch.md)
+ [
# TensorFlow 2
](tutorial-tensorflow-2.md)
# PyTorch
## Attivazione PyTorch
Quando viene rilasciato un pacchetto Conda stabile di un framework, viene testato e preinstallato sul DLAMI. Se desideri eseguire la build notturna più recente non testata, puoi eseguire l'[Installa PyTorch Nightly Build (sperimentale)](#tutorial-pytorch-install) manualmente.
Per attivare il framework attualmente installato, segui queste istruzioni sulla tua AMI Deep Learning con Conda.
Per PyTorch Python 3 con CUDA e MKL-DNN, esegui questo comando:
```
$ source activate pytorch_p310
```
Avviare il terminale iPython.
```
(pytorch_p310)$ ipython
```
Esegui un programma rapido. PyTorch
```
import torch
x = torch.rand(5, 3)
print(x)
print(x.size())
y = torch.rand(5, 3)
print(torch.add(x, y))
```
Dovrebbe essere visualizzata la matrice random iniziale stampata, quindi le dimensioni della stessa e infine l'aggiunta di un'altra matrice random.
## Installa PyTorch Nightly Build (sperimentale)
**Come eseguire l'installazione PyTorch da una build notturna**
Puoi installare la PyTorch build più recente in uno o entrambi gli ambienti PyTorch Conda sulla tua AMI Deep Learning con Conda.
1.
+ (Opzione per Python 3) - Attiva l'ambiente Python 3: PyTorch
```
$ source activate pytorch_p310
```
1. Per gli altri passaggi, si presuppone che venga utilizzato l'ambiente `pytorch_p310`. Rimuovi il file attualmente installato: PyTorch
```
(pytorch_p310)$ pip uninstall torch
```
1.
+ (Opzione per istanze GPU) - Installa l'ultima build notturna di CUDA.0: PyTorch
```
(pytorch_p310)$ pip install torch_nightly -f https://download.pytorch.org/whl/nightly/cu100/torch_nightly.html
```
+ (Opzione per istanze CPU): installa l'ultima build notturna per le istanze senza: PyTorch GPUs
```
(pytorch_p310)$ pip install torch_nightly -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html
```
1. Per verificare di aver installato correttamente l'ultima nightly build, avvia il IPython terminale e controlla la versione di. PyTorch
```
(pytorch_p310)$ ipython
```
```
import torch
print (torch.__version__)
```
L'output dovrebbe essere simile a `1.0.0.dev20180922`
1. Per verificare che la PyTorch nightly build funzioni bene con l'esempio MNIST, puoi eseguire uno script di test dal repository degli esempi: PyTorch
```
(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
```
## Altri tutorial
[Per ulteriori tutorial ed esempi, fate riferimento ai documenti ufficiali, alla documentazione e al sito Web del framework. PyTorch [PyTorch](http://pytorch.org)](http://pytorch.org/docs/master/)
# TensorFlow 2
Questo tutorial mostra come attivare TensorFlow 2 su un'istanza che esegue l'AMI Deep Learning con Conda (DLAMI su Conda) ed eseguire un programma TensorFlow 2.
Quando viene rilasciato un pacchetto Conda stabile di un framework, viene testato e preinstallato sul DLAMI.
## Attivazione 2 TensorFlow
**Per funzionare TensorFlow su DLAMI con Conda**
1. Per attivare TensorFlow 2, apri un'istanza Amazon Elastic Compute Cloud (Amazon EC2) di DLAMI con Conda.
1. Per TensorFlow 2 e Keras 2 su Python 3 con CUDA 10.1 e MKL-DNN, esegui questo comando:
```
$ source activate tensorflow2_p310
```
1. Avviare il terminale iPython:
```
(tensorflow2_p310)$ ipython
```
1. Esegui un programma TensorFlow 2 per verificare che funzioni correttamente:
```
import tensorflow as tf
hello = tf.constant('Hello, TensorFlow!')
tf.print(hello)
```
Viene visualizzato `Hello, TensorFlow!`.
## Altri tutorial
Per altri tutorial ed esempi, consulta la TensorFlow documentazione per l'[API TensorFlow Python](https://www.tensorflow.org/api_docs/python/) o visita il sito Web. [TensorFlow](https://www.tensorflow.org)
# Formazione distribuita con Elastic Fabric Adapter
Un [Elastic Fabric Adapter](https://aws.amazon.com/hpc/efa/) (EFA) è un dispositivo di rete che è possibile collegare all'istanza DLAMI per accelerare le applicazioni HPC (High Performance Computing). EFA consente di ottenere le prestazioni applicative di un cluster HPC locale, con la scalabilità, la flessibilità e l'elasticità fornite dal cloud. AWS
I seguenti argomenti mostrano come iniziare a utilizzare EFA con DLAMI.
**Nota**
Scegliete il vostro DLAMI da questo elenco DLAMI di [GPU di base](appendix-ami-release-notes.md#appendix-ami-release-notes-base)
**Topics**
+ [
# Avvio di un'istanza con EFA AWS Deep Learning AMIs
](tutorial-efa-launching.md)
+ [
# Utilizzo di EFA su DLAMI
](tutorial-efa-using.md)
# Avvio di un'istanza con EFA AWS Deep Learning AMIs
[La versione più recente di Base DLAMI è pronta per l'uso con EFA e viene fornita con i driver necessari, i moduli kernel, libfabric, openmpi e il plug-in NCCL OFI per le istanze GPU.](https://github.com/aws/aws-ofi-nccl/tree/aws)
[È possibile trovare le versioni CUDA supportate di un DLAMI di base nelle note di rilascio.](appendix-ami-release-notes.md#appendix-ami-release-notes-base)
Nota:
+ Quando si esegue un'applicazione NCCL utilizzando `mpirun` EFA, è necessario specificare il percorso completo dell'installazione supportata da EFA come:
```
/opt/amazon/openmpi/bin/mpirun
```
+ Per consentire all'applicazione di utilizzare EFA, aggiungere `FI_PROVIDER="efa"` al comando `mpirun` come mostrato in [Utilizzo di EFA su DLAMI](tutorial-efa-using.md).
**Topics**
+ [
## Preparare un gruppo di sicurezza abilitato all'EFA
](#tutorial-efa-security-group)
+ [
## Avvio dell'istanza
](#tutorial-efa-launch)
+ [
## Verifica l'allegato EFA
](#tutorial-efa-verify-attachment)
## Preparare un gruppo di sicurezza abilitato all'EFA
L'EFA richiede un gruppo di sicurezza che consenta tutto il traffico in entrata e in uscita da e verso il gruppo di sicurezza stesso. [Per ulteriori informazioni, consulta la documentazione EFA.](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security)
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nel riquadro di navigazione, scegliere **Security Groups (Gruppi di sicurezza)** e quindi **Create Security Group (Crea gruppo di sicurezza)**.
1. Nella finestra **Create Security Group (Crea gruppo di sicurezza)** effettuare le operazioni seguenti:
+ In **Nome gruppo di sicurezza**, immettere un nome descrittivo per il gruppo di sicurezza, ad esempio `EFA-enabled security group`.
+ (Facoltativo) In **Description (Descrizione)**, inserire una breve descrizione del gruppo di sicurezza.
+ In **VPC**, selezionare il VPC in cui avviare le istanze abilitate per EFA.
+ Scegli **Create** (Crea).
1. Selezionare il gruppo di sicurezza creato e, nella scheda **Description (Descrizione)**, copiare il valore **Group ID (ID gruppo)**.
1. Nelle schede **In entrata** e In **uscita**, effettuate le seguenti operazioni:
+ Seleziona **Edit** (Modifica).
+ In **Type (Tipo)**, selezionare **All traffic (Tutto il traffico)**.
+ In **Source (Origine)**, scegliere **Custom (Personalizzata)**.
+ Incollare nel campo l'ID del gruppo di sicurezza copiato in precedenza.
+ Scegli **Save** (Salva).
1. Abilitare il traffico in entrata facente riferimento a [Autorizzazione del traffico in entrata per le istanze Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html). Se salti questo passaggio, non sarai in grado di comunicare con l'istanza DLAMI.
## Avvio dell'istanza
EFA on the AWS Deep Learning AMIs è attualmente supportato con i seguenti tipi di istanze e sistemi operativi:
+ P3dn: Amazon Linux 2, Ubuntu 20.04
+ P4d, P4de: Amazon Linux 2, Amazon Linux 2023, Ubuntu 20.04, Ubuntu 22.04
+ P5, P5e, P5en: Amazon Linux 2, Amazon Linux 2023, Ubuntu 20.04, Ubuntu 22.04
La sezione seguente mostra come avviare un'istanza DLAMI abilitata per EFA. Per ulteriori informazioni sul lancio di un'istanza abilitata per EFA, consulta [Launch Enabled Instances into a Cluster Placement](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-instances) Group.
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Scegliere **Launch Instance (Avvia istanza)**.
1. Nella pagina **Scegli un AMI**, seleziona un DLAMI supportato che si trova nella pagina delle note di rilascio di [DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/appendix-ami-release-notes)
1. Nella pagina **Scegli un tipo di istanza**, seleziona uno dei seguenti tipi di istanza supportati, quindi scegli **Avanti: Configura i dettagli dell'istanza**. Fai riferimento a questo link per l'elenco delle istanze supportate: Guida [introduttiva a EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html) e MPI
1. Nella pagina **Configure Instance Details (Configura i dettagli dell'istanza)**, procedere come segue:
+ In **Number of instances (Numero di istanze)**, immettere il numero di istanze abilitate per EFA che si desidera avviare.
+ In **Network (Rete)** e **Subnet (Sottorete)**, selezionare il VPC e la sottorete in cui avviare le istanze.
+ [Facoltativo] Per il **gruppo di collocamento**, selezionate **Aggiungi istanza al** gruppo di collocamento. Per ottenere prestazioni ottimali, avviare le istanze all'interno di un gruppo di collocazione.
+ [Facoltativo] Per **il nome del gruppo di collocamento**, selezionate **Aggiungi a un nuovo gruppo di collocamento**, inserite un nome descrittivo per il gruppo di collocamento, quindi per la **strategia del gruppo di collocamento**, selezionate **cluster**.
+ Assicurati di abilitare **«Elastic Fabric Adapter»** in questa pagina. Se questa opzione è disabilitata, modificare la subnet in una che supporta il tipo di istanza selezionato.
+ Nella sezione **Network Interfaces (Interfacce di rete)**, per il dispositivo **eth0** scegliere **New network interface (Nuova interfaccia di rete)**. Facoltativamente, puoi specificare un IPv4 indirizzo principale e uno o più IPv4 indirizzi secondari. Se stai avviando l'istanza in una sottorete a cui è associato un blocco IPv6 CIDR, puoi facoltativamente specificare un IPv6 indirizzo primario e uno o più indirizzi secondari. IPv6
+ Scegliere **Next: Add Storage (Successivo: aggiungi storage)**.
1. Nella pagina **Add archiviazione (Aggiungi archiviazione)**, specificare i volumi da collegare all'istanza, oltre a quelli specificati dall'AMI (ad esempio il volume dispositivo root), quindi selezionare **Next: Add Tags (Successivo: aggiungi tag)**.
1. Nella pagina **Add Tags (Aggiungi tag)** specificare i tag per l'istanza, ad esempio un nome intuitivo, quindi selezionare **Next: Configure Security Group (Successivo: configurazione del gruppo di sicurezza)**.
1. **Nella pagina **Configura gruppo di sicurezza**, per **Assegna un gruppo di sicurezza**, seleziona **Seleziona un gruppo di sicurezza esistente, quindi seleziona il gruppo** di sicurezza creato in precedenza.**
1. Scegliere **Review and Launch (Analizza e avvia)**.
1. Nella pagina **Review Instance Launch (Verifica avvio istanza)** controllare le impostazioni e selezionare **Launch (Avvia)** per scegliere una coppia di chiavi e avviare l'istanza.
## Verifica l'allegato EFA
### Dalla console
Dopo aver avviato l'istanza, controlla i dettagli dell'istanza nella AWS console. A tale scopo, seleziona l'istanza nella console EC2 ed esamina la scheda Descrizione nel riquadro inferiore della pagina. Trova il parametro 'Interfacce di rete: eth0' e fai clic su eth0 che apre un pop-up. Assicurati che «Elastic Fabric Adapter» sia abilitato.
Se EFA non è abilitato, puoi risolvere il problema in uno dei seguenti modi:
+ Terminando l'istanza EC2 e avviandone una nuova con le stesse fasi. Assicurati che l'EFA sia collegato.
+ Collega EFA a un'istanza esistente.
1. Nella console EC2, passa a Network Interfaces (Interfacce di rete).
1. Fai clic su Create a Network Interface (Crea un'interfaccia di rete).
1. Seleziona la stessa subnet in cui si trova l'istanza.
1. Assicurati di abilitare «Elastic Fabric Adapter» e fai clic su Crea.
1. Torna alla scheda EC2 Instances (Istanze EC2) e seleziona l'istanza.
1. Vai a Azioni: Stato dell'istanza e interrompi l'istanza prima di collegare EFA.
1. Da Actions (Operazioni), seleziona Networking: Attach Network Interface (Rete: Collega interfaccia di rete).
1. Seleziona l'interfaccia appena creata e clicca su attach (collega).
1. Riavviare l'istanza.
### Dall'istanza
Il seguente script di test è già presente sul DLAMI. Eseguilo per assicurarti che i moduli del kernel siano caricati correttamente.
```
$ fi_info -p efa
```
L'aspetto dell'output sarà simile al seguente.
```
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
```
### Verifica della configurazione del gruppo di sicurezza
Il seguente script di test è già presente sul DLAMI. Eseguilo per assicurarti che il gruppo di sicurezza creato sia configurato correttamente.
```
$ cd /opt/amazon/efa/test/
$ ./efa_test.sh
```
L'aspetto dell'output sarà simile al seguente.
```
Starting server...
Starting client...
bytes #sent #ack total time MB/sec usec/xfer Mxfers/sec
64 10 =10 1.2k 0.02s 0.06 1123.55 0.00
256 10 =10 5k 0.00s 17.66 14.50 0.07
1k 10 =10 20k 0.00s 67.81 15.10 0.07
4k 10 =10 80k 0.00s 237.45 17.25 0.06
64k 10 =10 1.2m 0.00s 921.10 71.15 0.01
1m 10 =10 20m 0.01s 2122.41 494.05 0.00
```
Se smette di rispondere o non viene completato, assicurati che il tuo gruppo di sicurezza abbia le regole corrette inbound/outbound .
# Utilizzo di EFA su DLAMI
La sezione seguente descrive come utilizzare EFA per eseguire applicazioni multinodo su. AWS Deep Learning AMIs
## Esecuzione di applicazioni multinodo con EFA
Per eseguire un'applicazione su un cluster di nodi è richiesta la seguente configurazione
**Topics**
+ [
### Abilitazione di SSH senza password
](#tutorial-efa-using-multi-node-ssh)
+ [
### Creazione di file hosts
](#tutorial-efa-using-multi-node-hosts)
+ [
### Test NCCL
](#tutorial-efa-using-2node)
### Abilitazione di SSH senza password
Seleziona un nodo nel cluster come il nodo principale. I nodi rimanenti sono indicati come nodi membro.
1. Nel nodo principale, genera la coppia di chiavi RSA.
```
ssh-keygen -t rsa -N "" -f ~/.ssh/id_rsa
```
1. Modifica le autorizzazioni della chiave privata sul nodo principale.
```
chmod 600 ~/.ssh/id_rsa
```
1. Copia la chiave `~/.ssh/id_rsa.pub` pubblica e aggiungila a uno `~/.ssh/authorized_keys` dei nodi membri del cluster.
1. Puoi ora accedere direttamente ai nodi membro dal nodo principale utilizzando l'IP privato.
```
ssh
```
1. Disabilita strictHostKey Checking e abilita l'inoltro degli agenti sul nodo leader aggiungendo quanto segue al file \$1/.ssh/config sul nodo leader:
```
Host *
ForwardAgent yes
Host *
StrictHostKeyChecking no
```
1. Nelle istanze Amazon Linux 2, esegui il seguente comando sul nodo leader per fornire le autorizzazioni corrette al file di configurazione:
```
chmod 600 ~/.ssh/config
```
### Creazione di file hosts
Nel nodo principale, creare un file hosts per identificare i nodi nel cluster. Il file hosts deve contenere una voce per ogni nodo del cluster. Crea un file \$1/hosts e aggiungi ogni nodo utilizzando l'IP privato come riportato di seguito:
```
localhost slots=8
slots=8
slots=8
```
### Test NCCL
**Nota**
Questi test sono stati eseguiti utilizzando la versione EFA 1.38.0 e il plugin OFI NCCL 1.13.2.
Di seguito sono elencati un sottoinsieme di test NCCL forniti da Nvidia per testare funzionalità e prestazioni su più nodi di elaborazione
**Istanze supportate: P3dn, P4, P5, P5e, P5en**
#### Test delle prestazioni
##### Test delle prestazioni NCCL multinodo su P4D.24XLarge
[Per verificare le prestazioni NCCL con EFA, esegui il test NCCL Performance standard disponibile sul Repo ufficiale di NCCL-Tests.](https://github.com/NVIDIA/nccl-tests.git) Il DLAMI viene fornito con questo test già creato per CUDA XX.X. Allo stesso modo è possibile eseguire il proprio script con EFA.
Quando costruisci il tuo script, fai riferimento alla seguente guida:
+ Utilizzate il percorso completo di mpirun come mostrato nell'esempio durante l'esecuzione di applicazioni NCCL con EFA.
+ Modifica i parametri np e N in base al numero di istanze e al tuo cluster. GPUs
+ Aggiungi il flag NCCL\$1DEBUG=INFO e assicurati che i log indichino l'utilizzo di EFA come «Il provider selezionato è EFA».
+ Imposta la posizione del registro di formazione da analizzare per la convalida
```
TRAINING_LOG="testEFA_$(date +"%N").log"
```
Utilizza il comando `watch nvidia-smi` su uno qualsiasi dei nodi membri per monitorare l'utilizzo di GPU. I `watch nvidia-smi` comandi seguenti si riferiscono a una versione generica di CUDA xx.x e dipendono dal sistema operativo dell'istanza. Puoi eseguire i comandi per qualsiasi versione CUDA disponibile nella tua istanza Amazon EC2 sostituendo la versione CUDA nello 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}
```
L'aspetto dell'output deve essere simile al seguente:
```
# 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
```
#### Test di convalida
Per verificare che i test EFA abbiano restituito un risultato valido, utilizza i seguenti test per confermare:
+ Ottieni il tipo di istanza utilizzando EC2 Instance Metadata:
```
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)
```
+ Eseguire [Test delle prestazioni](#tutorial-efa-using-multinode)
+ Imposta i seguenti parametri
```
CUDA_VERSION
CUDA_RUNTIME_VERSION
NCCL_VERSION
```
+ Convalida i risultati come mostrato:
```
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
```
+ Per accedere ai dati del benchmark, possiamo analizzare l'ultima riga della tabella in uscita dal test Multi Node all\$1reduce:
```
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}"
```
# Monitoraggio e ottimizzazione GPU
La sezione seguente descrive le opzioni di ottimizzazione e monitoraggio della GPU. Questa sezione è organizzata come un flusso di lavoro tipico in cui il monitoraggio supervisiona la pre-elaborazione e il training.
+ [Monitoraggio](tutorial-gpu-monitoring.md)
+ [GPUs Monitora con CloudWatch](tutorial-gpu-monitoring-gpumon.md)
+ [Ottimizzazione](tutorial-gpu-opt.md)
+ [Pre-elaborazione](tutorial-gpu-opt-preprocessing.md)
+ [Addestramento](tutorial-gpu-opt-training.md)
# Monitoraggio
Il tuo DLAMI è preinstallato con diversi strumenti di monitoraggio della GPU. Questa guida fa anche riferimento a strumenti disponibili per scaricare e installare.
+ [GPUs Monitora con CloudWatch](tutorial-gpu-monitoring-gpumon.md)- un'utilità preinstallata che riporta le statistiche sull'utilizzo della GPU ad Amazon. CloudWatch
+ [nvidia-smi CLI](https://developer.nvidia.com/nvidia-system-management-interface) - un'utilità per il monitoraggio di calcolo e utilizzo di memoria della GPU. È preinstallato sul tuo AWS Deep Learning AMIs (DLAMI).
+ [NVML libreria C](https://developer.nvidia.com/nvidia-management-library-nvml): un'API basata sul C per accedere direttamente alle funzioni di monitoraggio e gestione della GPU. Viene utilizzata dall'interfaccia a riga di comando nvidia-smi dietro le quinte ed è preinstallata sulla DLAMI. Dispone anche di associazioni Python e Perl per facilitare lo sviluppo in tali lingue. L'utilità gpumon.py preinstallata sul DLAMI utilizza il pacchetto pynvml di. [nvidia-ml-py](https://pypi.org/project/nvidia-ml-py/)
+ [NVIDIA DCGM](https://developer.nvidia.com/data-center-gpu-manager-dcgm): uno strumento di gestione cluster. Per informazioni su come installare e configurare questo strumento, visita la pagina per gli sviluppatori.
**Suggerimento**
Dai un'occhiata al blog degli sviluppatori di NVIDIA per le ultime informazioni sull'utilizzo degli strumenti CUDA per installare il tuo DLAMI:
[Monitoraggio dell' TensorCore utilizzo tramite Nsight IDE e nvprof](https://devblogs.nvidia.com/using-nsight-compute-nvprof-mixed-precision-deep-learning-models/).
# GPUs Monitora con CloudWatch
Quando si utilizza la DLAMI con una GPU, è possibile che si stiano cercando modi per tenere traccia del suo utilizzo durante il training o l'inferenza. Questo può essere utile per ottimizzare la data pipeline e regolare la rete di deep learning.
Esistono due modi per configurare le metriche della GPU con: CloudWatch
+ [Configura le metriche con l' AWS CloudWatch agente (consigliato)](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-guide)
+ [Configura le metriche con lo script preinstallato `gpumon.py`](#tutorial-gpu-monitoring-gpumon-script)
## Configura le metriche con l' AWS CloudWatch agente (consigliato)
Integra il tuo DLAMI con l'[ CloudWatch agente unificato](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html) per configurare i parametri della GPU e monitorare l'utilizzo dei coprocessi GPU nelle istanze accelerate di Amazon EC2.
Esistono quattro modi per configurare le [metriche della GPU](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Agent-NVIDIA-GPU.html) con DLAMI:
+ [Configura metriche minime per la GPU](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-minimal)
+ [Configura le metriche parziali della GPU](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-partial)
+ [Configura tutte le metriche GPU disponibili](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-all)
+ [Configura metriche GPU personalizzate](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-custom)
Per informazioni sugli aggiornamenti e le patch di sicurezza, consulta [Applicazione di patch di sicurezza per l'agente AWS CloudWatch](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-security)
### Prerequisiti
Per iniziare, devi configurare le autorizzazioni IAM dell'istanza Amazon EC2 che consentano all'istanza di inviare parametri a. CloudWatch Per i passaggi dettagliati, consulta [Creare ruoli e utenti IAM da utilizzare con l'agente](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/create-iam-roles-for-cloudwatch-agent.html). CloudWatch
### Configura metriche minime per la GPU
Configura metriche minime per la GPU utilizzando il servizio. `dlami-cloudwatch-agent@minimal` `systemd` Questo servizio configura le seguenti metriche:
+ `utilization_gpu`
+ `utilization_memory`
Puoi trovare il `systemd` servizio per le metriche minime preconfigurate della GPU nella seguente posizione:
```
/opt/aws/amazon-cloudwatch-agent/etc/dlami-amazon-cloudwatch-agent-minimal.json
```
Abilita e avvia il `systemd` servizio con i seguenti comandi:
```
sudo systemctl enable dlami-cloudwatch-agent@minimal
sudo systemctl start dlami-cloudwatch-agent@minimal
```
### Configura le metriche parziali della GPU
Configura le metriche parziali della GPU utilizzando il servizio. `dlami-cloudwatch-agent@partial` `systemd` Questo servizio configura le seguenti metriche:
+ `utilization_gpu`
+ `utilization_memory`
+ `memory_total`
+ `memory_used`
+ `memory_free`
Puoi trovare il `systemd` servizio per le metriche parziali preconfigurate della GPU nella seguente posizione:
```
/opt/aws/amazon-cloudwatch-agent/etc/dlami-amazon-cloudwatch-agent-partial.json
```
Abilita e avvia il `systemd` servizio con i seguenti comandi:
```
sudo systemctl enable dlami-cloudwatch-agent@partial
sudo systemctl start dlami-cloudwatch-agent@partial
```
### Configura tutte le metriche GPU disponibili
Configura tutte le metriche GPU disponibili utilizzando il servizio. `dlami-cloudwatch-agent@all` `systemd` Questo servizio configura le seguenti metriche:
+ `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`
Puoi trovare il `systemd` servizio per tutte le metriche GPU preconfigurate disponibili nella seguente posizione:
```
/opt/aws/amazon-cloudwatch-agent/etc/dlami-amazon-cloudwatch-agent-all.json
```
Abilita e avvia il `systemd` servizio con i seguenti comandi:
```
sudo systemctl enable dlami-cloudwatch-agent@all
sudo systemctl start dlami-cloudwatch-agent@all
```
### Configura metriche GPU personalizzate
Se le metriche preconfigurate non soddisfano i tuoi requisiti, puoi creare un file di configurazione dell'agente personalizzato CloudWatch .
#### Crea un file di configurazione personalizzato
Per creare un file di configurazione personalizzato, consulta i passaggi dettagliati in [Creare o modificare manualmente il file di configurazione dell' CloudWatch agente](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Agent-Configuration-File-Details.html).
Per questo esempio, supponiamo che la definizione dello schema si trovi in`/opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json`.
#### Configura le metriche con il tuo file personalizzato
Esegui il comando seguente per configurare l' CloudWatch agente in base al tuo file personalizzato:
```
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
```
### Applicazione di patch di sicurezza per l'agente AWS CloudWatch
Le nuove versioni DLAMIs sono configurate con le ultime patch di sicurezza disponibili per gli AWS CloudWatch agenti. Consultate le seguenti sezioni per aggiornare il vostro attuale DLAMI con le patch di sicurezza più recenti a seconda del sistema operativo scelto.
#### Amazon Linux 2
`yum`Usalo per ottenere le patch di sicurezza degli AWS CloudWatch agenti più recenti per un DLAMI Amazon Linux 2.
```
sudo yum update
```
#### Ubuntu
Per ottenere le patch AWS CloudWatch di sicurezza più recenti per un DLAMI con Ubuntu, è necessario reinstallare AWS CloudWatch l'agente utilizzando un link per il download di Amazon S3.
```
wget https://s3.region.amazonaws.com/amazoncloudwatch-agent-region/ubuntu/arm64/latest/amazon-cloudwatch-agent.deb
```
Per ulteriori informazioni sull'installazione dell' AWS CloudWatch agente utilizzando i link per il download di Amazon S3, consulta [Installazione ed esecuzione dell' CloudWatch agente sui server](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/install-CloudWatch-Agent-commandline-fleet.html).
## Configura le metriche con lo script preinstallato `gpumon.py`
Un'utilità denominata gpumon.py è preinstallata sulla DLAMI. Si integra CloudWatch e supporta il monitoraggio dell'utilizzo per GPU: memoria GPU, temperatura della GPU e potenza della GPU. Lo script invia periodicamente i dati monitorati a. CloudWatch È possibile configurare il livello di granularità dei dati a cui vengono inviati CloudWatch modificando alcune impostazioni nello script. Prima di avviare lo script, tuttavia, è necessario configurarlo per CloudWatch ricevere le metriche.
**Come configurare ed eseguire il monitoraggio della GPU con CloudWatch**
1. Crea un utente IAM o modificane uno esistente per disporre di una policy su cui pubblicare la metrica. CloudWatch Se crei un nuovo utente, prendi nota delle credenziali poiché saranno necessarie nella fase successiva.
La policy IAM da cercare è «cloudwatch:». PutMetricData La policy che viene aggiunta è la seguente:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"cloudwatch:PutMetricData"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
**Suggerimento**
[Per ulteriori informazioni sulla creazione di un utente IAM e sull'aggiunta di policy per CloudWatch, consulta la CloudWatch documentazione.](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/create-iam-roles-for-cloudwatch-agent.html)
1. Sul tuo DLAMI, esegui [AWS configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html#cli-quick-configuration) e specifica le credenziali utente IAM.
```
$ aws configure
```
1. Potrebbe essere necessario apportare alcune modifiche all'utilità gpumon prima di eseguirla. È possibile trovare l'utilità gpumon e README nella posizione definita nel seguente blocco di codice. Per ulteriori informazioni sullo `gpumon.py` script, consulta [la posizione dello script in Amazon S3](https://s3.amazonaws.com/aws-bigdata-blog/artifacts/GPUMonitoring/gpumon.py).
```
Folder: ~/tools/GPUCloudWatchMonitor
Files: ~/tools/GPUCloudWatchMonitor/gpumon.py
~/tools/GPUCloudWatchMonitor/README
```
Opzioni:
+ Cambia la regione in gpumon.py se l'istanza NON è in us-east-1.
+ Modifica altri parametri, ad esempio CloudWatch `namespace` il periodo di riferimento con`store_reso`.
1. Attualmente lo script supporta solo Python 3. Attiva l'ambiente Python 3 del tuo framework preferito o attiva l'ambiente Python 3 generale DLAMI.
```
$ source activate python3
```
1. Esegui l'utilità gpumon in background.
```
(python3)$ python gpumon.py &
```
1. Apri il browser nella [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) quindi seleziona il parametro. Avrà uno spazio dei nomi ''. DeepLearningTrain
**Suggerimento**
Puoi cambiare lo spazio dei nomi modificando gpumon.py. Puoi anche modificare l'intervallo di reporting regolando `store_reso`.
Di seguito è riportato un esempio di CloudWatch grafico che riporta un'esecuzione di gpumon.py che monitora un processo di formazione sull'istanza p2.8xlarge.
![\[Monitoraggio della GPU attivo CloudWatch\]](http://docs.aws.amazon.com/it_it/dlami/latest/devguide/images/gpumon.png)
Questi altri argomenti sul monitoraggio e l'ottimizzazione GPU potrebbero essere interessanti:
+ [Monitoraggio](tutorial-gpu-monitoring.md)
+ [GPUs Monitora con CloudWatch](#tutorial-gpu-monitoring-gpumon)
+ [Ottimizzazione](tutorial-gpu-opt.md)
+ [Pre-elaborazione](tutorial-gpu-opt-preprocessing.md)
+ [Addestramento](tutorial-gpu-opt-training.md)
# Ottimizzazione
Per sfruttare al meglio le tue potenzialità GPUs, puoi ottimizzare la pipeline di dati e ottimizzare la tua rete di deep learning. Come descritto nel grafico seguente, un'implementazione nativa o di base di una rete neurale potrebbe utilizzare la GPU in maniera non omogenea e non a pieno potenziale. Quando ottimizzi la pre-elaborazione e il caricamento dei dati, puoi ridurre il collo di bottiglia dalla CPU alla GPU. Puoi regolare la rete neurale stessa, utilizzando l'ibridazione (quando supportata dal framework), modificando le dimensioni batch e sincronizzando le chiamate. Puoi anche utilizzare training a precisione multipla (float16 o int8) nella maggior parte dei framework, che può avere un effetto significativo sul miglioramento del throughput.
Il grafico seguente mostra i miglioramenti delle prestazioni cumulativi quando si applicano ottimizzazioni differenti. I risultati dipenderanno dai dati in corso di elaborazione e dalla rete che si sta ottimizzando.
![\[Miglioramenti delle prestazioni per GPUs\]](http://docs.aws.amazon.com/it_it/dlami/latest/devguide/images/performance-enhancements.png)
Le seguenti guide introducono le opzioni che funzionano con il tuo DLAMI e ti aiutano a migliorare le prestazioni della GPU.
**Topics**
+ [
# Pre-elaborazione
](tutorial-gpu-opt-preprocessing.md)
+ [
# Addestramento
](tutorial-gpu-opt-training.md)
# Pre-elaborazione
La pre-elaborazione dei dati tramite trasformazioni o ottimizzazioni può essere spesso un processo basato sulla CPU e questo può essere il collo di bottiglia nella pipeline complessiva. I framework dispongono di operatori integrati per l'elaborazione di immagini, ma DALI (Data augmentation Library) mostra prestazioni migliorate rispetto a opzioni integrate dei framework.
+ NVIDIA Data augmentation Library (DALI): DALI esegue l'offload dell'ottimizzazione dei dati nella GPU. Non è preinstallato su DLAMI, ma puoi accedervi installandolo o caricando un contenitore di framework supportato sul tuo DLAMI o su un'altra istanza Amazon Elastic Compute Cloud. Per informazioni dettagliate, consulta la [pagina di progetto DALI](https://docs.nvidia.com/deeplearning/sdk/dali-install-guide/index.html) sul sito Web NVIDIA. [Per un caso d'uso di esempio e per scaricare esempi di codice, consulta l'esempio Preprocessing Training Performance. SageMaker ](https://github.com/aws-samples/sagemaker-cv-preprocessing-training-performance)
+ nvJPEG: una libreria di decoder JPEG con accelerazione GPU per programmatori C. Supporta la decodifica di immagini singole o batch, nonché operazioni di trasformazione successive che sono comuni in deep learning. nvJPEG è integrato con DALI, oppure è possibile scaricarlo dalla [pagina nvjpeg del sito Web NVIDIA](https://developer.nvidia.com/nvjpeg) e utilizzarlo separatamente.
Questi altri argomenti sul monitoraggio e l'ottimizzazione GPU potrebbero essere interessanti:
+ [Monitoraggio](tutorial-gpu-monitoring.md)
+ [GPUs Monitora con CloudWatch](tutorial-gpu-monitoring-gpumon.md)
+ [Ottimizzazione](tutorial-gpu-opt.md)
+ [Pre-elaborazione](#tutorial-gpu-opt-preprocessing)
+ [Addestramento](tutorial-gpu-opt-training.md)
# Addestramento
Grazie al training a precisione mista puoi distribuire reti più grandi con la stessa quantità di memoria o ridurre l'utilizzo della memoria rispetto alla rete a precisione singola o doppia, registrando al contempo un incremento delle prestazioni di calcolo. Hai anche il vantaggio di trasferimenti dati più piccoli e rapidi, un fattore importante nel training distribuito a più nodi. Per sfruttare il training a precisione mista occorre regolare casting dei dati e perdita di scaling. Le guide seguenti descrivono come eseguire questa operazione per i framework che supportano la precisione mista.
+ [NVIDIA Deep Learning SDK](https://docs.nvidia.com/deeplearning/sdk/mixed-precision-training/): documenti sul sito Web di NVIDIA che descrivono l'implementazione a precisione mista per, e. MXNet PyTorch TensorFlow
**Suggerimento**
Assicurati di controllare il sito Web per il framework scelto e cerca "mixed precision" o "fp16" per le tecniche di ottimizzazione più recenti. Di seguito sono elencate alcune guide a precisione mista che possono essere utili:
[Formazione a precisione mista con TensorFlow (](https://devblogs.nvidia.com/mixed-precision-resnet-50-tensor-cores/)video) - sul sito del blog NVIDIA.
[Allenamento a precisione mista con float16 con MXNet](https://mxnet.apache.org/api/faq/float16) - un articolo di domande frequenti sul sito Web. MXNet
[NVIDIA Apex: uno strumento per un facile allenamento a precisione mista con PyTorch](https://devblogs.nvidia.com/apex-pytorch-easy-mixed-precision-training/) - un articolo di blog sul sito Web di NVIDIA.
Questi altri argomenti sul monitoraggio e l'ottimizzazione GPU potrebbero essere interessanti:
+ [Monitoraggio](tutorial-gpu-monitoring.md)
+ [GPUs Monitora con CloudWatch](tutorial-gpu-monitoring-gpumon.md)
+ [Ottimizzazione](tutorial-gpu-opt.md)
+ [Pre-elaborazione](tutorial-gpu-opt-preprocessing.md)
+ [Addestramento](#tutorial-gpu-opt-training)
# Il chip AWS Inferentia con DLAMI
AWS Inferentia è un chip di machine learning personalizzato progettato da AWS cui è possibile utilizzare per previsioni di inferenza ad alte prestazioni. Per utilizzare il chip, configura un'istanza Amazon Elastic Compute Cloud e utilizza il kit di sviluppo software (SDK) AWS Neuron per richiamare il chip Inferentia. Per offrire ai clienti la migliore esperienza con Inferentia, Neuron è stato integrato in ( AWS Deep Learning AMIs DLAMI).
I seguenti argomenti mostrano come iniziare a usare Inferentia con DLAMI.
**Topics**
+ [
# Avvio di un'istanza DLAMI con Neuron AWS
](tutorial-inferentia-launching.md)
+ [
# Usare il DLAMI con Neuron AWS
](tutorial-inferentia-using.md)
# Avvio di un'istanza DLAMI con Neuron AWS
L'ultimo DLAMI è pronto per l'uso con AWS Inferentia e viene fornito con il AWS pacchetto API Neuron. Per avviare un'istanza DLAMI, vedere [Avvio e configurazione](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html) di un DLAMI. Dopo aver installato un DLAMI, segui questi passaggi per assicurarti che il tuo chip AWS Inferentia e le risorse AWS Neuron siano attivi.
**Topics**
+ [
## Verifica la tua istanza
](#tutorial-inferentia-launching-verify)
+ [
## Identificazione dei dispositivi AWS Inferentia
](#tutorial-inferentia-launching-identify)
+ [
## Visualizza l'utilizzo delle risorse
](#tutorial-inferentia-launching-resource-usage)
+ [
## Utilizzo di Neuron Monitor (neuron-monitor)
](#tutorial-inferentia-launching-neuron-monitor)
+ [
## Aggiornamento del software Neuron
](#tutorial-inferentia-launching-upgrade)
## Verifica la tua istanza
Prima di usare l'istanza, verifica che sia correttamente configurata e configurata con Neuron.
## Identificazione dei dispositivi AWS Inferentia
Per identificare il numero di dispositivi Inferentia sulla tua istanza, usa il seguente comando:
```
neuron-ls
```
Se all'istanza sono collegati dispositivi Inferentia, l'output sarà simile al seguente:
```
+--------+--------+--------+-----------+--------------+
| 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 |
+--------+--------+--------+-----------+--------------+
```
L'output fornito è tratto da un'istanza INF1.6xLarge e include le seguenti colonne:
+ NEURON DEVICE: L'ID logico assegnato a. NeuronDevice Questo ID viene utilizzato quando si configurano più runtime per utilizzarne diversi. NeuronDevices
+ NEURON CORES: Il numero di NeuronCores core presenti in. NeuronDevice
+ NEURON MEMORY: La quantità di memoria DRAM contenuta in. NeuronDevice
+ DISPOSITIVI COLLEGATI: Altri NeuronDevices collegati a. NeuronDevice
+ PCI BDF: L'ID PCI Bus Device Function (BDF) di. NeuronDevice
## Visualizza l'utilizzo delle risorse
Visualizza informazioni utili sull' NeuronCore utilizzo della vCPU, sull'utilizzo della memoria, sui modelli caricati e sulle applicazioni Neuron con il comando. `neuron-top` L'avvio `neuron-top` senza argomenti mostrerà i dati per tutte le applicazioni di machine learning che utilizzano. NeuronCores
```
neuron-top
```
Quando un'applicazione ne utilizza quattro NeuronCores, l'output dovrebbe essere simile all'immagine seguente:
![\[L'output del neuron-top comando, con le informazioni relative a una delle quattro NeuronCores evidenziate.\]](http://docs.aws.amazon.com/it_it/dlami/latest/devguide/images/neuron-top-output.png)
[Per ulteriori informazioni sulle risorse per monitorare e ottimizzare le applicazioni di inferenza basate su Neuron, consulta Neuron Tools.](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/index.html)
## Utilizzo di Neuron Monitor (neuron-monitor)
Neuron Monitor raccoglie le metriche dai runtime Neuron in esecuzione sul sistema e trasmette i dati raccolti a stdout in formato JSON. Queste metriche sono organizzate in gruppi di metriche che puoi configurare fornendo un file di configurazione. Per ulteriori informazioni su Neuron Monitor, consulta la [Guida per l'utente](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/neuron-monitor-user-guide.html) di Neuron Monitor.
## Aggiornamento del software Neuron
[Per informazioni su come aggiornare il software Neuron SDK all'interno di DLAMI, consultate la Neuron Setup Guide. AWS](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-intro/neuron-install-guide.html)
**Fase succcessiva**
[Usare il DLAMI con Neuron AWS](tutorial-inferentia-using.md)
# Usare il DLAMI con Neuron AWS
Un tipico flusso di lavoro con AWS Neuron SDK consiste nel compilare un modello di machine learning precedentemente addestrato su un server di compilazione. Successivamente, distribuisci gli artefatti alle istanze Inf1 per l'esecuzione. AWS Deep Learning AMIs (DLAMI) è preinstallato con tutto il necessario per compilare ed eseguire l'inferenza in un'istanza Inf1 che utilizza Inferentia.
Le seguenti sezioni descrivono come usare DLAMI con Inferentia.
**Topics**
+ [
# Utilizzo di TensorFlow -Neuron e del Neuron Compiler AWS
](tutorial-inferentia-tf-neuron.md)
+ [
# Utilizzo di AWS Neuron Serving TensorFlow
](tutorial-inferentia-tf-neuron-serving.md)
+ [
# Utilizzo di MXNet -Neuron e del Neuron Compiler AWS
](tutorial-inferentia-mxnet-neuron.md)
+ [
# Utilizzo di MXNet -Neuron Model Serving
](tutorial-inferentia-mxnet-neuron-serving.md)
+ [
# Utilizzo di PyTorch -Neuron e del Neuron Compiler AWS
](tutorial-inferentia-pytorch-neuron.md)
# Utilizzo di TensorFlow -Neuron e del Neuron Compiler AWS
Questo tutorial mostra come utilizzare il compilatore AWS Neuron per compilare il modello Keras ResNet -50 ed esportarlo come modello salvato in formato. SavedModel Questo formato è un tipico formato intercambiabile del modello. TensorFlow Il tutorial illustra anche come eseguire l'inferenza su un'istanza di Inf1 con input di esempio.
[Per ulteriori informazioni su Neuron SDK, consulta la documentazione di Neuron SDK.AWS](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html)
**Topics**
+ [
## Prerequisiti
](#tutorial-inferentia-tf-neuron-prerequisites)
+ [
## Attivare l'ambiente Conda
](#tutorial-inferentia-tf-neuron-activate)
+ [
## Compilazione Resnet50
](#tutorial-inferentia-tf-neuron-compilation)
+ [
## ResNet50 Inferenza
](#tutorial-inferentia-tf-neuron-inference)
## Prerequisiti
Prima di utilizzare questo tutorial, è necessario aver completato la procedura di configurazione in [Avvio di un'istanza DLAMI con Neuron AWS](tutorial-inferentia-launching.md). È inoltre necessario avere dimestichezza con il deep learning e l'uso del DLAMI.
## Attivare l'ambiente Conda
Attiva l'ambiente TensorFlow -Neuron conda usando il seguente comando:
```
source activate aws_neuron_tensorflow_p36
```
Per uscire dall'ambiente Conda corrente, eseguire il comando seguente:
```
source deactivate
```
## Compilazione Resnet50
Creare uno script Python chiamato **tensorflow\$1compile\$1resnet50.py** che abbia il seguente contenuto. Questo script Python compila il modello Keras ResNet 50 e lo esporta come modello salvato.
```
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')
```
Compilare il modello utilizzando il seguente comando:
```
python tensorflow_compile_resnet50.py
```
Il processo di compilazione richiederà alcuni minuti. Al termine, l'output dovrebbe essere simile al seguente:
```
...
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
...
```
Dopo la compilazione, il modello salvato viene compresso a **ws\$1resnet50/resnet50\$1neuron.zip**. Decomprimere il modello e scaricare l'immagine di esempio per l'inferenza utilizzando i seguenti comandi:
```
unzip ws_resnet50/resnet50_neuron.zip -d .
curl -O https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg
```
## ResNet50 Inferenza
Creare uno script Python chiamato **tensorflow\$1infer\$1resnet50.py** che abbia il seguente contenuto. Questo script esegue l'inferenza sul modello scaricato utilizzando un modello di inferenza precedentemente compilato.
```
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])
```
Eseguire l'inferenza sul modello utilizzando il seguente comando:
```
python tensorflow_infer_resnet50.py
```
L'aspetto dell'output deve essere simile al seguente:
```
...
[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]
```
**Fase succcessiva**
[Utilizzo di AWS Neuron Serving TensorFlow](tutorial-inferentia-tf-neuron-serving.md)
# Utilizzo di AWS Neuron Serving TensorFlow
Questo tutorial mostra come costruire un grafico e aggiungere una fase di compilazione di AWS Neuron prima di esportare il modello salvato da utilizzare con Serving. TensorFlow TensorFlow Serving è un sistema di servizio che consente di aumentare l'inferenza su una rete. Neuron TensorFlow Serving utilizza la stessa API del normale Serving. TensorFlow L'unica differenza è che un modello salvato deve essere compilato per AWS Inferentia e il punto di ingresso è un nome binario diverso. `tensorflow_model_server_neuron` Il file binario si trova in `/usr/local/bin/tensorflow_model_server_neuron` ed è preinstallato nel DLAMI.
[Per ulteriori informazioni su Neuron SDK, consulta la documentazione di Neuron SDK.AWS](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html)
**Topics**
+ [
## Prerequisiti
](#tutorial-inferentia-tf-neuron--serving-prerequisites)
+ [
## Attivare l'ambiente Conda
](#tutorial-inferentia-tf-neuron-serving-activate)
+ [
## Compilare ed esportare il modello salvato
](#tutorial-inferentia-tf-neuron-serving-compile)
+ [
## Servire il modello salvato
](#tutorial-inferentia-tf-neuron-serving-serving)
+ [
## Generare richieste di inferenza al server del modello
](#tutorial-inferentia-tf-neuron-serving-inference)
## Prerequisiti
Prima di utilizzare questo tutorial, è necessario aver completato la procedura di configurazione in [Avvio di un'istanza DLAMI con Neuron AWS](tutorial-inferentia-launching.md). È inoltre necessario avere dimestichezza con il deep learning e l'uso del DLAMI.
## Attivare l'ambiente Conda
Attiva l'ambiente TensorFlow -Neuron conda usando il seguente comando:
```
source activate aws_neuron_tensorflow_p36
```
Se è necessario uscire dall'ambiente Conda corrente, eseguire:
```
source deactivate
```
## Compilare ed esportare il modello salvato
Crea uno script Python chiamato `tensorflow-model-server-compile.py` con il seguente contenuto. Questo script costruisce un grafico e lo compila usando Neuron. Esporta quindi il grafico compilato come modello salvato.
```
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)
```
Compilare il modello utilizzando il seguente comando:
```
python tensorflow-model-server-compile.py
```
L'aspetto dell'output deve essere simile al seguente:
```
...
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
```
## Servire il modello salvato
Una volta compilato il modello, è possibile utilizzare il seguente comando per servire il modello salvato con il binario tensorflow\$1model\$1server\$1neuron:
```
tensorflow_model_server_neuron --model_name=resnet50_inf1 \
--model_base_path=$HOME/resnet50_inf1/ --port=8500 &
```
L'aspetto dell'output sarà simile al seguente. Il modello compilato viene inserito nella DRAM del dispositivo Inferentia dal server per prepararsi all'inferenza.
```
...
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 ...
```
## Generare richieste di inferenza al server del modello
Creare uno script Python chiamato `tensorflow-model-server-infer.py` con il seguente contenuto. Questo script esegue inferenza tramite gRPC, che è framework di servizio.
```
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))
```
Eseguire l'inferenza sul modello utilizzando gRPC con il seguente comando:
```
python tensorflow-model-server-infer.py
```
L'aspetto dell'output deve essere simile al seguente:
```
[[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]]
```
# Utilizzo di MXNet -Neuron e del Neuron Compiler AWS
L'API di compilazione MXNet -Neuron fornisce un metodo per compilare un grafico modello che è possibile eseguire su un dispositivo Inferentia. AWS
In questo esempio, si utilizza l'API per compilare un modello ResNet -50 e utilizzarlo per eseguire l'inferenza.
[Per ulteriori informazioni su Neuron SDK, consulta la documentazione di Neuron SDK.AWS](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html)
**Topics**
+ [
## Prerequisiti
](#tutorial-inferentia-mxnet-neuron-prerequisites)
+ [
## Attivare l'ambiente Conda
](#tutorial-inferentia-mxnet-neuron-activate)
+ [
## Compilazione Resnet50
](#tutorial-inferentia-mxnet-neuron-compilation)
+ [
## ResNet50 Inferenza
](#tutorial-inferentia-mxnet-neuron-inference)
## Prerequisiti
Prima di utilizzare questo tutorial, è necessario aver completato la procedura di configurazione in [Avvio di un'istanza DLAMI con Neuron AWS](tutorial-inferentia-launching.md). È inoltre necessario avere dimestichezza con il deep learning e l'uso del DLAMI.
## Attivare l'ambiente Conda
Attiva l'ambiente MXNet -Neuron conda usando il seguente comando:
```
source activate aws_neuron_mxnet_p36
```
Per uscire dall'ambiente conda corrente, eseguire:
```
source deactivate
```
## Compilazione Resnet50
Creare uno script Python chiamato **mxnet\$1compile\$1resnet50.py** con il seguente contenuto. Questo script utilizza l'API Python di compilazione MXNet -Neuron per compilare un modello -50. ResNet
```
import mxnet as mx
import numpy as np
print("downloading...")
path='http://data.mxnet.io/models/imagenet/'
mx.test_utils.download(path+'resnet/50-layers/resnet-50-0000.params')
mx.test_utils.download(path+'resnet/50-layers/resnet-50-symbol.json')
print("download finished.")
sym, args, aux = mx.model.load_checkpoint('resnet-50', 0)
print("compile for inferentia using neuron... this will take a few minutes...")
inputs = { "data" : mx.nd.ones([1,3,224,224], name='data', dtype='float32') }
sym, args, aux = mx.contrib.neuron.compile(sym, args, aux, inputs)
print("save compiled model...")
mx.model.save_checkpoint("compiled_resnet50", 0, sym, args, aux)
```
Compilare il modello utilizzando il seguente comando:
```
python mxnet_compile_resnet50.py
```
La compilazione richiederà alcuni minuti. Al termine della compilazione, i seguenti file si troveranno nella directory corrente:
```
resnet-50-0000.params
resnet-50-symbol.json
compiled_resnet50-0000.params
compiled_resnet50-symbol.json
```
## ResNet50 Inferenza
Creare uno script Python chiamato **mxnet\$1infer\$1resnet50.py** con il seguente contenuto. Questo script scarica un'immagine di esempio e la usa per eseguire l'inferenza con il modello compilato.
```
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]))
```
Eseguire l'inferenza con il modello compilato utilizzando il seguente comando:
```
python mxnet_infer_resnet50.py
```
L'aspetto dell'output deve essere simile al seguente:
```
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
```
**Fase succcessiva**
[Utilizzo di MXNet -Neuron Model Serving](tutorial-inferentia-mxnet-neuron-serving.md)
# Utilizzo di MXNet -Neuron Model Serving
In questo tutorial imparerai a utilizzare un MXNet modello pre-addestrato per eseguire la classificazione delle immagini in tempo reale con Multi Model Server (MMS). MMS è uno easy-to-use strumento flessibile per fornire modelli di deep learning addestrati utilizzando qualsiasi framework di machine learning o deep learning. Questo tutorial include una fase di compilazione utilizzando AWS Neuron e un'implementazione dell'utilizzo di MMS. MXNet
[Per ulteriori informazioni su Neuron SDK, consulta la documentazione di Neuron SDK.AWS](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html)
**Topics**
+ [
## Prerequisiti
](#tutorial-inferentia-mxnet-neuron-serving-prerequisites)
+ [
## Attivare l'ambiente Conda
](#tutorial-inferentia-mxnet-neuron-serving-activate)
+ [
## Scarica il codice di esempio
](#tutorial-inferentia-mxnet-neuron-serving-download)
+ [
## Compila il modello
](#tutorial-inferentia-mxnet-neuron-serving-compile)
+ [
## Eseguire l’inferenza
](#tutorial-inferentia-mxnet-neuron-serving-inference)
## Prerequisiti
Prima di utilizzare questo tutorial, è necessario aver completato la procedura di configurazione in [Avvio di un'istanza DLAMI con Neuron AWS](tutorial-inferentia-launching.md). È inoltre necessario avere dimestichezza con il deep learning e l'uso del DLAMI.
## Attivare l'ambiente Conda
Attiva l'ambiente MXNet -Neuron conda usando il seguente comando:
```
source activate aws_neuron_mxnet_p36
```
Per uscire dall'ambiente conda corrente, eseguire:
```
source deactivate
```
## Scarica il codice di esempio
Per eseguire questo esempio, scaricare il codice di esempio utilizzando i seguenti comandi:
```
git clone https://github.com/awslabs/multi-model-server
cd multi-model-server/examples/mxnet_vision
```
## Compila il modello
Creare uno script Python chiamato `multi-model-server-compile.py` con il seguente contenuto. Questo script compila il modello ResNet 50 nella destinazione 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)
```
Per compilare il modello, utilizzare il seguente comando:
```
python multi-model-server-compile.py
```
L'aspetto dell'output deve essere simile al seguente:
```
...
[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!
```
Creare un file denominato `signature.json` con il seguente contenuto per configurare il nome e la forma di input:
```
{
"inputs": [
{
"data_name": "data",
"data_shape": [
1,
3,
224,
224
]
}
]
}
```
Scaricare il file `synset.txt` utilizzando il comando seguente: Questo file è un elenco di nomi per ImageNet le classi di previsione.
```
curl -O https://s3.amazonaws.com/model-server/model_archive_1.0/examples/squeezenet_v1.1/synset.txt
```
Creare una classe di servizio personalizzata seguendo il modello nella cartella `model_server_template`. Copiare il modello nella directory di lavoro corrente utilizzando il seguente comando:
```
cp -r ../model_service_template/* .
```
Modificare il modulo `mxnet_model_service.py` per sostituire il contesto `mx.cpu()` con il contesto `mx.neuron()` come segue. È inoltre necessario commentare la copia dei dati non necessaria `model_input` perché MXNet -Neuron non supporta and Gluon. NDArray 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]
```
Comprimere il modello con model-archiver utilizzando i seguenti comandi:
```
cd ~/multi-model-server/examples
model-archiver --force --model-name resnet-50_compiled --model-path mxnet_vision --handler mxnet_vision_service:handle
```
## Eseguire l’inferenza
Avvia il Multi Model Server e carica il modello che utilizza l' RESTful API utilizzando i seguenti comandi. Assicurarsi che **neuron-rtd** sia in esecuzione con le impostazioni predefinite.
```
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
```
Eseguire l'inferenza utilizzando un'immagine di esempio con i seguenti comandi:
```
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
```
L'aspetto dell'output deve essere simile al seguente:
```
[
{
"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"
}
]
```
Per eseguire la pulizia dopo il test, emettete un comando di eliminazione tramite l' RESTful API e arrestate il server del modello utilizzando i seguenti comandi:
```
curl -X DELETE http://127.0.0.1:8081/models/resnet-50_compiled
multi-model-server --stop
```
Verrà visualizzato l’output seguente:
```
{
"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
```
# Utilizzo di PyTorch -Neuron e del Neuron Compiler AWS
L'API di compilazione PyTorch -Neuron fornisce un metodo per compilare un grafico modello che è possibile eseguire su un dispositivo Inferentia. AWS
Un modello addestrato deve essere compilato in un target Inferentia prima di poter essere distribuito nelle istanze di Inf1. Il seguente tutorial compila il modello torchvision ResNet 50 e lo esporta come modulo salvato. TorchScript Questo modello viene quindi utilizzato per eseguire l'inferenza.
Per comodità, questa esercitazione utilizza un'istanza di Inf1 sia per la compilazione sia per l'inferenza. In pratica, è possibile compilare il modello utilizzando un altro tipo di istanza, ad esempio la famiglia di istanze c5. È quindi necessario distribuire il modello compilato al server di inferenza Inf1. Per ulteriori informazioni, consulta la documentazione di [AWS Neuron SDK PyTorch ](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/pytorch-neuron/index.html).
**Topics**
+ [
## Prerequisiti
](#tutorial-inferentia-pytorch-neuron-prerequisites)
+ [
## Attivare l'ambiente Conda
](#tutorial-inferentia-pytorch-neuron-activate)
+ [
## Compilazione Resnet50
](#tutorial-inferentia-pytorch-neuron-compilation)
+ [
## ResNet50 Inferenza
](#tutorial-inferentia-pytorch-neuron-inference)
## Prerequisiti
Prima di utilizzare questo tutorial, è necessario aver completato la procedura di configurazione in [Avvio di un'istanza DLAMI con Neuron AWS](tutorial-inferentia-launching.md). È inoltre necessario avere dimestichezza con il deep learning e l'uso del DLAMI.
## Attivare l'ambiente Conda
Attiva l'ambiente PyTorch -Neuron conda usando il seguente comando:
```
source activate aws_neuron_pytorch_p36
```
Per uscire dall'ambiente conda corrente, eseguire:
```
source deactivate
```
## Compilazione Resnet50
Creare uno script Python chiamato **pytorch\$1trace\$1resnet50.py** con il seguente contenuto. Questo script utilizza l'API Python di compilazione PyTorch -Neuron per compilare un modello -50. ResNet
**Nota**
Esiste una dipendenza tra le versioni di torchvision e il pacchetto torch di cui dovresti essere a conoscenza durante la compilazione dei modelli torchvision. Queste regole di dipendenza possono essere gestite tramite pip. Torchvision==0.6.1 corrisponde alla versione torch==1.5.1, mentre torchvision==0.8.2 corrisponde alla versione 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")
```
Eseguire lo script di compilazione.
```
python pytorch_trace_resnet50.py
```
La compilazione richiederà alcuni minuti. Al termine della compilazione, il modello compilato viene salvato come `resnet50_neuron.pt` nella directory locale.
## ResNet50 Inferenza
Creare uno script Python chiamato **pytorch\$1infer\$1resnet50.py** con il seguente contenuto. Questo script scarica un'immagine di esempio e la usa per eseguire l'inferenza con il modello compilato.
```
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) )
```
Eseguire l'inferenza con il modello compilato utilizzando il seguente comando:
```
python pytorch_infer_resnet50.py
```
L'aspetto dell'output deve essere simile al seguente:
```
Top 5 labels:
['tiger', 'lynx', 'tiger_cat', 'Egyptian_cat', 'tabby']
```
# Il ARM64 DLAMI
AWS ARM64 DLAMIs Le GPU sono progettate per fornire prestazioni elevate ed efficienza in termini di costi per carichi di lavoro di deep learning. In particolare, il tipo di istanza G5G presenta il [processore AWS Graviton2](https://aws.amazon.com/ec2/graviton/) basato su ARM64, che è stato costruito da zero AWS e ottimizzato per il modo in cui i clienti eseguono i propri carichi di lavoro nel cloud. AWS ARM64 DLAMIs Le GPU sono preconfigurate con Docker, NVIDIA Docker, NVIDIA Driver, CUDA, cuDNN, NCCL, oltre ai più diffusi framework di machine learning come e. TensorFlow PyTorch
Con il tipo di istanza g5G, puoi sfruttare i vantaggi in termini di prezzo e prestazioni di Graviton2 per implementare modelli di deep learning accelerati da GPU a un costo notevolmente inferiore rispetto alle istanze basate su x86 con accelerazione GPU.
## Seleziona un ARM64 DLAMI
Avvia un'[istanza g5G](https://aws.amazon.com/ec2/instance-types/g5g/) con il ARM64 DLAMI che preferisci.
Per step-by-step istruzioni sull'avvio di un DLAMI, [vedere Avvio e configurazione](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html) di un DLAMI.
Per un elenco delle più recenti ARM64 DLAMIs, consultate le [Note di rilascio per DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/appendix-ami-release-notes.html).
## Nozioni di base
I seguenti argomenti mostrano come iniziare a utilizzare ARM64 DLAMI.
**Topics**
+ [
## Seleziona un ARM64 DLAMI
](#tutorial-arm64-select-dlami)
+ [
## Nozioni di base
](#tutorial-arm64-get-started)
+ [
# Utilizzo della ARM64 GPU DLAMI PyTorch
](tutorial-arm64-pytorch.md)
# Utilizzo della ARM64 GPU DLAMI PyTorch
AWS Deep Learning AMIs È pronto per l'uso con processori GPUs Arm64 ed è ottimizzato per. PyTorch La ARM64 GPU PyTorch DLAMI include un ambiente Python preconfigurato [PyTorch](https://aws.amazon.com/pytorch)con [TorchVision[TorchServe](https://pytorch.org/serve/)](https://pytorch.org/vision/stable/index.html)e per casi d'uso di deep learning e inferenza.
**Topics**
+ [
## Verifica dell' PyTorch ambiente Python
](#tutorial-arm64-pytorch-environment)
+ [
## Esegui Training Sample con PyTorch
](#tutorial-arm64-pytorch-training)
+ [
## Esegui Inference Sample con PyTorch
](#tutorial-arm64-pytorch-inference)
## Verifica dell' PyTorch ambiente Python
Connettiti alla tua istanza G5g e attiva l'ambiente Conda di base con il seguente comando:
```
source activate base
```
Il prompt dei comandi dovrebbe indicare che stai lavorando nell'ambiente Conda di base, che contiene e altre PyTorch librerie TorchVision.
```
(base) $
```
Verificate i percorsi utensile predefiniti dell' PyTorch ambiente:
```
(base) $ which python
(base) $ which pip
(base) $ which conda
(base) $ which mamba
>>> import torch, torchvision
>>> torch.__version__
>>> torchvision.__version__
>>> v = torch.autograd.Variable(torch.randn(10, 3, 224, 224))
>>> v = torch.autograd.Variable(torch.randn(10, 3, 224, 224)).cuda()
>>> assert isinstance(v, torch.Tensor)
```
## Esegui Training Sample con PyTorch
Esegui un esempio di lavoro di formazione MNIST:
```
git clone https://github.com/pytorch/examples.git
cd examples/mnist
python main.py
```
L'aspetto dell'output sarà simile al seguente:
```
...
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%)
```
## Esegui Inference Sample con PyTorch
Usa i seguenti comandi per scaricare un modello densenet161 pre-addestrato ed eseguire l'inferenza utilizzando: 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
```
L'aspetto dell'output sarà simile al seguente:
```
{
"tiger_cat": 0.4693363308906555,
"tabby": 0.4633873701095581,
"Egyptian_cat": 0.06456123292446136,
"lynx": 0.0012828150065615773,
"plastic_bag": 0.00023322898778133094
}
```
Utilizzate i seguenti comandi per annullare la registrazione del modello densenet161 e arrestare il server:
```
curl -X DELETE http://localhost:8081/models/densenet161/1.0
torchserve --stop
```
L'aspetto dell'output sarà simile al seguente:
```
{
"status": "Model \"densenet161\" unregistered"
}
TorchServe has stopped.
```
# Inferenza
Questa sezione fornisce tutorial su come eseguire l'inferenza utilizzando i framework e gli strumenti di DLAMI.
## Strumenti di inferenza
+ [TensorFlow Servire](tutorial-tfserving.md)
# Model serving
Di seguito sono riportate le opzioni di model serving installate sull'AMI Deep Learning con Conda. Fai clic su quella desiderata per informazioni su come utilizzarla.
**Topics**
+ [
# TensorFlow Servire
](tutorial-tfserving.md)
+ [
# TorchServe
](tutorial-torchserve.md)
# TensorFlow Servire
[TensorFlow Serving](https://www.tensorflow.org/tfx/guide/serving) è un sistema di servizio flessibile e ad alte prestazioni per modelli di apprendimento automatico.
`tensorflow-serving-api`È preinstallato con DLAMI a framework singolo. Per utilizzare tensorflow serving, attiva prima l'ambiente. TensorFlow
```
$ source /opt/tensorflow/bin/activate
```
Quindi utilizza l'editor di testo preferito per creare uno script che ha i seguenti contenuti. Denominalo `test_train_mnist.py`. Questo script è citato in [TensorFlow Tutorial](https://github.com/tensorflow/docs/blob/master/site/en/tutorials/quickstart/beginner.ipynb) che addestrerà e valuterà un modello di apprendimento automatico di rete neurale che classifica le immagini.
```
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)
```
Ora esegui lo script fornendo la posizione e la porta del server e il nome della foto dell'husky come parametri.
```
$ /opt/tensorflow/bin/python3 test_train_mnist.py
```
L'esecuzione dello script può durare alcuni minuti. Una volta completato l'addestramento, dovresti vedere quanto segue:
```
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
```
## Ulteriori funzionalità ed esempi
Se sei interessato a saperne di più su TensorFlow Serving, consulta il [TensorFlow sito web](https://www.tensorflow.org/serving/).
# TorchServe
TorchServe è uno strumento flessibile per servire modelli di deep learning che sono stati esportati da PyTorch. TorchServe viene preinstallato con l'AMI Deep Learning con Conda.
Per ulteriori informazioni sull'utilizzo TorchServe, consulta [Model Server for PyTorch](https://github.com/pytorch/serve/blob/master/docs/README.md) Documentation.
**Argomenti**
## Offri un modello di classificazione delle immagini su TorchServe
Questo tutorial mostra come utilizzare un modello di classificazione delle immagini con TorchServe. Utilizza un modello DenseNet -161 fornito da PyTorch. Una volta che il server è in esecuzione, ascolta le richieste di previsione. Quando carichi un'immagine, in questo caso l'immagine di un gattino, il server restituisce una previsione delle 5 migliori classi corrispondenti tra le classi su cui è stato addestrato il modello.
**Per fornire un esempio di modello di classificazione delle immagini su TorchServe**
1. Connettiti a un'istanza Amazon Elastic Compute Cloud (Amazon EC2) con Deep Learning AMI con Conda v34 o versione successiva.
1. Attiva l'ambiente. `pytorch_p310`
```
source activate pytorch_p310
```
1. Clona il TorchServe repository, quindi crea una directory per archiviare i tuoi modelli.
```
git clone https://github.com/pytorch/serve.git
mkdir model_store
```
1. Archivia il modello utilizzando il model archiver. Il `extra-files` parametro utilizza un file del `TorchServe` repository, quindi aggiorna il percorso se necessario. Per ulteriori informazioni sul model archiver, vedere [Torch](https://github.com/pytorch/serve/blob/master/model-archiver/README.md) Model archiver for. TorchServe
```
wget https://download.pytorch.org/models/densenet161-8d451a50.pth
torch-model-archiver --model-name densenet161 --version 1.0 --model-file ./serve/examples/image_classifier/densenet_161/model.py --serialized-file densenet161-8d451a50.pth --export-path model_store --extra-files ./serve/examples/image_classifier/index_to_name.json --handler image_classifier
```
1. Esegui TorchServe per avviare un endpoint. L'aggiunta `> /dev/null` disattiva l'output del registro.
```
torchserve --start --ncs --model-store model_store --models densenet161.mar > /dev/null
```
1. Scaricate l'immagine di un gattino e inviatela all'endpoint TorchServe previsto:
```
curl -O https://s3.amazonaws.com/model-server/inputs/kitten.jpg
curl http://127.0.0.1:8080/predictions/densenet161 -T kitten.jpg
```
L'endpoint di previsione restituisce una previsione in JSON simile alle prime cinque previsioni seguenti, in cui l'immagine ha una probabilità del 47% di contenere un gatto egiziano, seguita da una probabilità del 46% che abbia un gatto soriano.
```
{
"tiger_cat": 0.46933576464653015,
"tabby": 0.463387668132782,
"Egyptian_cat": 0.0645613968372345,
"lynx": 0.0012828196631744504,
"plastic_bag": 0.00023323058849200606
}
```
1. Al termine del test, ferma il server:
```
torchserve --stop
```
**Altri esempi**
TorchServe contiene una serie di esempi che è possibile eseguire sulla propria istanza DLAMI. È possibile visualizzarli nella pagina [degli esempi del repository TorchServe del progetto](https://github.com/pytorch/serve/tree/master/examples).
**Maggiori informazioni**
Per ulteriore TorchServe documentazione, incluso come configurare Docker e TorchServe le TorchServe funzionalità più recenti, consulta [la pagina del TorchServe progetto](https://github.com/pytorch/serve) su GitHub.