Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Tutoriels
Vous trouverez ci-dessous des didacticiels sur l'utilisation de l'AMI Deep Learning avec le logiciel Conda.
**Topics**
+ [Activation des infrastructures](activating.md)
+ [Formation distribuée à l'aide d'Elastic Fabric Adapter](tutorial-efa.md)
+ [Optimisation et surveillance des GPU](tutorial-gpu.md)
+ [La puce AWS Inferentia avec DLAMI](tutorial-inferentia.md)
+ [Le ARM64 DLAMI](tutorial-arm64.md)
+ [Inférence](tutorial-inference.md)
+ [Service de modèle](model-serving.md)
# Activation des infrastructures
Les frameworks d'apprentissage profond installés sur l'AMI Deep Learning avec Conda sont les suivants. Cliquez sur une infrastructure pour découvrir comment l'activer.
**Topics**
+ [PyTorch](tutorial-pytorch.md)
+ [TensorFlow 2](tutorial-tensorflow-2.md)
# PyTorch
## Activation PyTorch
Lorsqu'un package Conda stable d'un framework est publié, il est testé et préinstallé sur le DLAMI. Si vous voulez exécuter la dernière génération nocturne non testée, vous pouvez [PyTorchInstall's Nightly Build (expérimental)](#tutorial-pytorch-install) manuellement.
Pour activer le framework actuellement installé, suivez ces instructions sur votre AMI Deep Learning avec Conda.
Pour PyTorch Python 3 avec CUDA et MKL-DNN, exécutez cette commande :
```
$ source activate pytorch_p310
```
Démarrez le terminal iPython.
```
(pytorch_p310)$ ipython
```
Lancez un PyTorch programme rapide.
```
import torch
x = torch.rand(5, 3)
print(x)
print(x.size())
y = torch.rand(5, 3)
print(torch.add(x, y))
```
Vous devriez voir le tableau aléatoire initial imprimé, puis sa taille, puis l'ajout d'un autre tableau aléatoire.
## PyTorchInstall's Nightly Build (expérimental)
**Comment procéder à l'installation PyTorch à partir d'une version nocturne**
Vous pouvez installer la dernière PyTorch version dans l'un des environnements PyTorch Conda ou dans les deux sur votre AMI Deep Learning avec Conda.
1.
+ (Option pour Python 3) - Activez l' PyTorch environnement Python 3 :
```
$ source activate pytorch_p310
```
1. Les étapes restantes partent du principe que vous utilisez l'environnement `pytorch_p310`. Supprimez le fichier actuellement installé PyTorch :
```
(pytorch_p310)$ pip uninstall torch
```
1.
+ (Option pour les instances GPU) - Installez la dernière version nocturne de PyTorch CUDA.0 :
```
(pytorch_p310)$ pip install torch_nightly -f https://download.pytorch.org/whl/nightly/cu100/torch_nightly.html
```
+ (Option pour les instances de processeur) - Installez la dernière version nocturne de PyTorch pour les instances sans GPUs :
```
(pytorch_p310)$ pip install torch_nightly -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html
```
1. Pour vérifier que vous avez correctement installé la dernière version nocturne, démarrez le IPython terminal et vérifiez la version de PyTorch.
```
(pytorch_p310)$ ipython
```
```
import torch
print (torch.__version__)
```
Vous devez obtenir une sortie imprimée similaire à `1.0.0.dev20180922`
1. Pour vérifier que la version PyTorch nocturne fonctionne correctement avec l'exemple MNIST, vous pouvez exécuter un script de test à partir PyTorch du référentiel d'exemples :
```
(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
```
## Autres didacticiels
Pour d'autres didacticiels et exemples, reportez-vous à la documentation officielle du framework, à la [PyTorch documentation](http://pytorch.org/docs/master/) et au [PyTorch](http://pytorch.org)site Web.
# TensorFlow 2
Ce didacticiel explique comment activer TensorFlow 2 sur une instance exécutant l'AMI Deep Learning avec Conda (DLAMI sur Conda) et exécuter un programme 2. TensorFlow
Lorsqu'un package Conda stable d'un framework est publié, il est testé et préinstallé sur le DLAMI.
## Activation de TensorFlow 2
**Pour utiliser TensorFlow le DLAMI avec Conda**
1. Pour activer TensorFlow 2, ouvrez une instance Amazon Elastic Compute Cloud (Amazon EC2) du DLAMI avec Conda.
1. Pour TensorFlow 2 et Keras 2 sur Python 3 avec CUDA 10.1 et MKL-DNN, exécutez cette commande :
```
$ source activate tensorflow2_p310
```
1. Démarrez le terminal iPython:
```
(tensorflow2_p310)$ ipython
```
1. Exécutez un programme TensorFlow 2 pour vérifier qu'il fonctionne correctement :
```
import tensorflow as tf
hello = tf.constant('Hello, TensorFlow!')
tf.print(hello)
```
`Hello, TensorFlow!` doit apparaître sur votre écran.
## Autres didacticiels
Pour plus de didacticiels et d'exemples, consultez la TensorFlow documentation de l'[API TensorFlow Python](https://www.tensorflow.org/api_docs/python/) ou consultez le [TensorFlow](https://www.tensorflow.org)site Web.
# Formation distribuée à l'aide d'Elastic Fabric Adapter
Un [adaptateur Elastic Fabric](https://aws.amazon.com/hpc/efa/) (EFA) est un périphérique réseau que vous pouvez connecter à votre instance DLAMI pour accélérer les applications de calcul haute performance (HPC). EFA vous permet d'atteindre les performances applicatives d'un cluster HPC sur site, grâce à l'évolutivité, à la flexibilité et à l'élasticité offertes par le cloud. AWS
Les rubriques suivantes expliquent comment commencer à utiliser l'EFA avec le DLAMI.
**Note**
Choisissez votre DLAMI dans cette liste de DLAMI pour GPU de [base](appendix-ami-release-notes.md#appendix-ami-release-notes-base)
**Topics**
+ [Lancement d'une AWS Apprentissage profond (deep learning) AMIs instance avec EFA](tutorial-efa-launching.md)
+ [Utilisation de l'EFA sur le DLAMI](tutorial-efa-using.md)
# Lancement d'une AWS Apprentissage profond (deep learning) AMIs instance avec EFA
Le dernier DLAMI de base est prêt à être utilisé avec EFA et est fourni avec les pilotes requis, les modules de noyau, libfabric, openmpi et le plugin NCCL OFI pour [les](https://github.com/aws/aws-ofi-nccl/tree/aws) instances GPU.
[Vous trouverez les versions CUDA prises en charge d'un DLAMI de base dans les notes de publication.](appendix-ami-release-notes.md#appendix-ami-release-notes-base)
Remarque :
+ Lorsque vous exécutez une application NCCL sous `mpirun` EFA, vous devez spécifier le chemin complet vers l'installation prise en charge par EFA comme suit :
```
/opt/amazon/openmpi/bin/mpirun
```
+ Pour permettre à votre application d'utiliser EFA, ajoutez `FI_PROVIDER="efa"` à la commande `mpirun` comme indiqué dans [Utilisation de l'EFA sur le DLAMI](tutorial-efa-using.md).
**Topics**
+ [Préparer un groupe de sécurité compatible EFA](#tutorial-efa-security-group)
+ [Lancer votre instance](#tutorial-efa-launch)
+ [Vérifiez la pièce jointe EFA](#tutorial-efa-verify-attachment)
## Préparer un groupe de sécurité compatible EFA
L'EFA nécessite un groupe de sécurité qui autorise tout le trafic entrant et sortant à destination et en provenance du groupe de sécurité lui-même. Pour plus d'informations, consultez la [documentation EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security).
1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Dans le panneau de navigation, choisissez **Groupes de sécurité**, puis **Créer un groupe de sécurité**.
1. Dans la fenêtre **Créer un groupe de sécurité**, procédez comme suit :
+ Pour **Nom du groupe de sécurité**, saisissez un nom descriptif pour le groupe de sécurité, tel que `EFA-enabled security group`.
+ (Facultatif) Pour **Description**, saisissez une brève description du groupe de sécurité.
+ Pour **VPC**, sélectionnez le VPC dans lequel vous prévoyez de lancer vos instances activées pour EFA.
+ Choisissez **Créer**.
1. Sélectionnez le groupe de sécurité que vous avez créé et dans l'onglet **Description**, copiez l'**ID du groupe**.
1. **Dans les onglets Entrant** et **Sortant**, procédez comme suit :
+ Choisissez **Modifier**.
+ Pour **Type**, sélectionnez **Tout le trafic**.
+ Pour **Source**, choisissez **Personnalisé**.
+ Collez l'ID de groupe de sécurité que vous avez copié dans le champ.
+ Choisissez **Enregistrer**.
1. Activez le trafic entrant en vous référant à [Autorisation du trafic entrant pour vos instances Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html). Si vous ignorez cette étape, vous ne pourrez pas communiquer avec votre instance DLAMI.
## Lancer votre instance
L'EFA sur le AWS Apprentissage profond (deep learning) AMIs est actuellement pris en charge avec les types d'instances et systèmes d'exploitation suivants :
+ 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 section suivante explique comment lancer une instance DLAMI compatible EFA. Pour plus d'informations sur le lancement d'une instance compatible EFA, voir [Lancer des instances compatibles EFA dans un groupe de placement de clusters](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-instances).
1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Choisissez **Launch Instances** (Lancer les instances).
1. Sur la page **Choisir une AMI**, sélectionnez une DLAMI prise en charge sur la page des notes de mise à jour de la [DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/appendix-ami-release-notes).
1. Sur la page **Choisir un type d'instance**, sélectionnez l'un des types d'instance pris en charge suivants, puis choisissez **Suivant : Configurer les détails de l'instance.** Consultez ce lien pour obtenir la liste des instances prises en charge : [Commencez avec EFA et MPI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html)
1. Sur la page **Configurer les détails de l’instance**, procédez de la façon suivante :
+ Pour **Nombre d’instances**, entrez le nombre d’instances activées pour EFA que vous voulez lancer.
+ Pour **Réseau** et **Sous-réseau**, sélectionnez le VPC et le sous-réseau dans lesquels lancer les instances.
+ [Facultatif] Pour **Groupe de placement**, sélectionnez **Ajouter une instance au groupe de placement**. Pour de meilleures performances, lancez les instances au sein d'un groupe de placement.
+ [Facultatif] Pour le **nom du groupe de placement**, sélectionnez **Ajouter à un nouveau groupe de placement**, entrez un nom descriptif pour le groupe de placement, puis pour **Stratégie du groupe de placement**, sélectionnez **cluster**.
+ Assurez-vous d'activer le **« Elastic Fabric Adapter »** sur cette page. Si cette option est désactivée, remplacez le sous-réseau par un sous-réseau qui prend en charge le type d'instance sélectionné.
+ Dans la section **Interfaces réseau**, pour l’appareil **eth0**, choisissez **Nouvelle interface réseau**. Vous pouvez éventuellement spécifier une IPv4 adresse principale et une ou plusieurs IPv4 adresses secondaires. Si vous lancez l'instance dans un sous-réseau auquel est associé un bloc IPv6 CIDR, vous pouvez éventuellement spécifier une IPv6 adresse principale et une ou plusieurs adresses secondaires IPv6 .
+ Choisissez **Suivant : Ajouter un stockage**.
1. Sur la page **Ajouter un stockage**, spécifiez les volumes à attacher aux instances, outre ceux spécifiés par l’AMI (par exemple, le volume du périphérique racine), puis sélectionner **Suivant : Ajouter des balises**.
1. Sur la page **Ajouter des balises**, spécifiez des balises pour l’instance, par exemple un nom évocateur, puis sélectionnez **Suivant : Configurer le groupe de sécurité**.
1. Sur la page **Configurer le groupe de sécurité**, pour **Attribuer un groupe de sécurité**, **sélectionnez Sélectionner un groupe de sécurité existant**, puis sélectionnez le groupe de sécurité que vous avez créé précédemment**.**
1. Choisissez **Vérifier et lancer**.
1. Sur la page **Examiner le lancement de l’instance**, vérifiez les paramètres, puis choisissez **Lancer** pour sélectionner une paire de clés et lancer votre instance.
## Vérifiez la pièce jointe EFA
### À partir de la console
Après avoir lancé l'instance, vérifiez les détails de l'instance dans la AWS console. Pour ce faire, sélectionnez l'instance dans la console EC2 et consultez l'onglet Description dans le volet inférieur de la page. Recherchez le paramètre « Interfaces réseau : eth0 » et cliquez sur eth0 pour ouvrir une fenêtre contextuelle. Assurez-vous que « Elastic Fabric Adapter » est activé.
Si EFA n'est pas activé, vous pouvez résoudre ce problème soit en :
+ Mettez fin à l'instance EC2 et lancez une nouvelle instance en suivant la même procédure. Assurez-vous que l'EFA est joint.
+ Attachez EFA à une instance existante.
1. Dans la console EC2, accédez à Interfaces réseau.
1. Cliquez sur Create a Network Interface (Créer une interface réseau).
1. Sélectionnez le sous-réseau dans lequel se trouve votre instance.
1. Assurez-vous d'activer « Elastic Fabric Adapter » et de cliquer sur Créer.
1. Retournez à l'onglet EC2 Instances (Instances EC2) et sélectionnez votre instance.
1. Accédez à Actions : État de l'instance et arrêtez l'instance avant d'attacher EFA.
1. Dans Actions, sélectionnez Mise en réseau : Attacher l'interface réseau.
1. Sélectionnez l'interface que vous venez de créer et cliquez sur Attacher.
1. Redémarrez votre instance.
### À partir de l'instance
Le script de test suivant est déjà présent sur le DLAMI. Exécutez-le pour vous assurer que les modules de noyau sont correctement chargés.
```
$ fi_info -p efa
```
Votre sortie doit ressembler à ce qui suit :
```
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
```
### Vérifier la configuration du groupe de sécurité
Le script de test suivant est déjà présent sur le DLAMI. Exécutez-le pour vérifier que le groupe de sécurité que vous avez créé est correctement configuré.
```
$ cd /opt/amazon/efa/test/
$ ./efa_test.sh
```
Votre sortie doit ressembler à ce qui suit :
```
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
```
S'il cesse de répondre ou s'il ne se termine pas, assurez-vous que votre groupe de sécurité dispose des inbound/outbound règles correctes.
# Utilisation de l'EFA sur le DLAMI
La section suivante décrit comment utiliser EFA pour exécuter des applications à nœuds multiples sur le AWS Apprentissage profond (deep learning) AMIs.
## Exécution d'applications multi-nœuds avec EFA
Pour exécuter une application sur un cluster de nœuds, la configuration suivante est requise
**Topics**
+ [Activer SSH sans mot de passe](#tutorial-efa-using-multi-node-ssh)
+ [Créer un fichier hosts.](#tutorial-efa-using-multi-node-hosts)
+ [Tests NCCL](#tutorial-efa-using-2node)
### Activer SSH sans mot de passe
Sélectionnez un nœud de votre cluster comme nœud principal. Les autres nœuds sont appelés nœuds de membre.
1. Sur le nœud principal, générez la paire de clés RSA.
```
ssh-keygen -t rsa -N "" -f ~/.ssh/id_rsa
```
1. Modifiez les autorisations de la clé privée sur le nœud principal.
```
chmod 600 ~/.ssh/id_rsa
```
1. Copiez la clé `~/.ssh/id_rsa.pub` publique et ajoutez-la à l'`~/.ssh/authorized_keys`un des nœuds membres du cluster.
1. Vous devriez maintenant pouvoir vous connecter directement aux nœuds de membre du nœud principal en utilisant l'adresse IP privée.
```
ssh
```
1. Désactivez la strictHostKey vérification et activez le transfert d'agent sur le nœud principal en ajoutant ce qui suit au fichier \$1/.ssh/config sur le nœud principal :
```
Host *
ForwardAgent yes
Host *
StrictHostKeyChecking no
```
1. Sur les instances Amazon Linux 2, exécutez la commande suivante sur le nœud principal pour fournir les autorisations correctes au fichier de configuration :
```
chmod 600 ~/.ssh/config
```
### Créer un fichier hosts.
Sur le nœud principal, créez un fichier hosts pour identifier les nœuds du cluster. Le fichier hosts doit avoir une entrée pour chaque nœud du cluster. Créez un fichier \$1/hosts et ajoutez chaque nœud en utilisant l'adresse IP privée comme suit :
```
localhost slots=8
slots=8
slots=8
```
### Tests NCCL
**Note**
Ces tests ont été exécutés à l'aide de la version 1.38.0 d'EFA et du plugin OFI NCCL 1.13.2.
Vous trouverez ci-dessous un sous-ensemble de tests NCCL fournis par Nvidia pour tester à la fois les fonctionnalités et les performances sur plusieurs nœuds de calcul
**Instances prises en charge : P3dn, P4, P5, P5e, P5en**
#### Tests de performance
##### Test de performance NCCL à nœuds multiples sur P4D.24xlarge
[Pour vérifier les performances NCCL avec EFA, exécutez le test de performance NCCL standard disponible sur le référentiel officiel des tests NCCL.](https://github.com/NVIDIA/nccl-tests.git) Le DLAMI est fourni avec ce test déjà conçu pour CUDA XX.X. Vous pouvez également exécuter votre propre script avec EFA.
Lors de la construction de votre propre script, suivez les instructions suivantes :
+ Utilisez le chemin complet vers mpirun comme indiqué dans l'exemple lors de l'exécution d'applications NCCL avec EFA.
+ Modifiez les paramètres np et N en fonction du nombre d'instances et GPUs de votre cluster.
+ Ajoutez l'indicateur NCCL\$1DEBUG=INFO et assurez-vous que les journaux indiquent l'utilisation de l'EFA sous la forme « Le fournisseur sélectionné est EFA ».
+ Définissez l'emplacement du journal d'entraînement à analyser pour validation
```
TRAINING_LOG="testEFA_$(date +"%N").log"
```
Utilisez la commande `watch nvidia-smi` sur n'importe quel nœud de membre pour surveiller l'utilisation des GPU. Les `watch nvidia-smi` commandes suivantes concernent une version générique de CUDA xx.x et dépendent du système d'exploitation de votre instance. Vous pouvez exécuter les commandes pour n'importe quelle version CUDA disponible dans votre instance Amazon EC2 en remplaçant la version CUDA dans le 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}
```
Le résultat doit être similaire à ce qui suit :
```
# 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
```
#### Tests de validation
Pour vérifier que les tests EFA ont renvoyé un résultat valide, veuillez utiliser les tests suivants pour confirmer :
+ Obtenez le type d'instance à l'aide des métadonnées d'instance 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)
```
+ Exécutez le [Tests de performance](#tutorial-efa-using-multinode)
+ Définissez les paramètres suivants
```
CUDA_VERSION
CUDA_RUNTIME_VERSION
NCCL_VERSION
```
+ Validez les résultats comme indiqué :
```
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
```
+ Pour accéder aux données de référence, nous pouvons analyser la dernière ligne du résultat du tableau issu du test all\$1reduce à nœuds multiples :
```
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}"
```
# Optimisation et surveillance des GPU
La section suivante vous guide à travers les options d'optimisation et de surveillance des GPU. Cette section est conçue comme un flux de travail classique, la surveillance supervisant le prétraitement et la formation.
+ [Contrôle](tutorial-gpu-monitoring.md)
+ [Moniteur GPUs avec CloudWatch](tutorial-gpu-monitoring-gpumon.md)
+ [Optimisation](tutorial-gpu-opt.md)
+ [Prétraitement](tutorial-gpu-opt-preprocessing.md)
+ [Entraînement](tutorial-gpu-opt-training.md)
# Contrôle
Votre DLAMI est préinstallé avec plusieurs outils de surveillance du GPU. Ce manuel indique également les outils disponibles afin d'être téléchargés et installés.
+ [Moniteur GPUs avec CloudWatch](tutorial-gpu-monitoring-gpumon.md)- un utilitaire préinstallé qui communique les statistiques d'utilisation du GPU à Amazon CloudWatch.
+ [Interface de ligne de commande nvidia-smi](https://developer.nvidia.com/nvidia-system-management-interface) - utilitaire permettant de l'utilisation globale de mémoire et des fonctions de calcul des GPU. Il est préinstallé sur votre AWS Apprentissage profond (deep learning) AMIs (DLAMI).
+ [Bibliothèque C NVML](https://developer.nvidia.com/nvidia-management-library-nvml) - API basée sur C permettant d'accéder directement aux fonctions de surveillance et de gestion des GPU. Elle est utilisée par l'interface de ligne de commande nvidia-smi en arrière-plan et est préinstallée sur vos DLAMI. Elle comporte également les liaisons Perl et Python pour faciliter le développement dans ces langages. L'utilitaire gpumon.py préinstallé sur votre DLAMI utilise le package pynvml de. [nvidia-ml-py](https://pypi.org/project/nvidia-ml-py/)
+ [NVIDIA DCGM](https://developer.nvidia.com/data-center-gpu-manager-dcgm) - outil de gestion des clusters. Visitez la page destinée aux développeurs pour apprendre à installer et à configurer cet outil.
**Astuce**
Consultez le blog des développeurs de NVIDIA pour obtenir les dernières informations sur l'utilisation des outils CUDA installés sur votre DLAMI :
[Surveillance de TensorCore l'utilisation à l'aide de Nsight IDE et de nvprof](https://devblogs.nvidia.com/using-nsight-compute-nvprof-mixed-precision-deep-learning-models/).
# Moniteur GPUs avec CloudWatch
Lorsque vous utilisez vos DLAMI avec un GPU, vous pouvez avoir envie d'effectuer le suivi de l'utilisation lors de la formation ou de l'inférence. Cela peut s'avérer utile pour optimiser votre pipeline de données et régler votre réseau de deep learning.
Il existe deux manières de configurer les métriques du GPU avec CloudWatch :
+ [Configurer les métriques avec l' AWS CloudWatch agent (recommandé)](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-guide)
+ [Configurer les métriques avec le script préinstallé `gpumon.py`](#tutorial-gpu-monitoring-gpumon-script)
## Configurer les métriques avec l' AWS CloudWatch agent (recommandé)
Intégrez votre DLAMI à l'agent [ CloudWatch unifié pour configurer les](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html) métriques du GPU et surveiller l'utilisation des coprocessus du GPU dans les instances accélérées Amazon EC2.
Il existe quatre méthodes pour configurer les [métriques du GPU](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Agent-NVIDIA-GPU.html) avec votre DLAMI :
+ [Configurer des métriques GPU minimales](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-minimal)
+ [Configurer des métriques partielles du GPU](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-partial)
+ [Configurer toutes les métriques GPU disponibles](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-all)
+ [Configurer des métriques GPU personnalisées](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-custom)
Pour plus d'informations sur les mises à jour et les correctifs de sécurité, voir [Correctifs de sécurité pour l'agent AWS CloudWatch](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-security)
### Conditions préalables
Pour commencer, vous devez configurer les autorisations IAM de l'instance Amazon EC2 qui permettent à votre instance d'envoyer des métriques. CloudWatch Pour connaître les étapes détaillées, voir [Création de rôles et d'utilisateurs IAM à utiliser avec l' CloudWatch agent](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/create-iam-roles-for-cloudwatch-agent.html).
### Configurer des métriques GPU minimales
Configurez des métriques GPU minimales à l'aide du `dlami-cloudwatch-agent@minimal` `systemd` service. Ce service configure les métriques suivantes :
+ `utilization_gpu`
+ `utilization_memory`
Vous pouvez trouver le `systemd` service pour les métriques GPU préconfigurées minimales à l'emplacement suivant :
```
/opt/aws/amazon-cloudwatch-agent/etc/dlami-amazon-cloudwatch-agent-minimal.json
```
Activez et démarrez le `systemd` service à l'aide des commandes suivantes :
```
sudo systemctl enable dlami-cloudwatch-agent@minimal
sudo systemctl start dlami-cloudwatch-agent@minimal
```
### Configurer des métriques partielles du GPU
Configurez des métriques partielles du GPU à l'aide du `dlami-cloudwatch-agent@partial` `systemd` service. Ce service configure les métriques suivantes :
+ `utilization_gpu`
+ `utilization_memory`
+ `memory_total`
+ `memory_used`
+ `memory_free`
Vous pouvez trouver le `systemd` service pour les métriques GPU partiellement préconfigurées à l'emplacement suivant :
```
/opt/aws/amazon-cloudwatch-agent/etc/dlami-amazon-cloudwatch-agent-partial.json
```
Activez et démarrez le `systemd` service à l'aide des commandes suivantes :
```
sudo systemctl enable dlami-cloudwatch-agent@partial
sudo systemctl start dlami-cloudwatch-agent@partial
```
### Configurer toutes les métriques GPU disponibles
Configurez toutes les métriques GPU disponibles à l'aide du `dlami-cloudwatch-agent@all` `systemd` service. Ce service configure les métriques suivantes :
+ `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`
Vous trouverez le `systemd` service pour toutes les métriques GPU préconfigurées disponibles à l'emplacement suivant :
```
/opt/aws/amazon-cloudwatch-agent/etc/dlami-amazon-cloudwatch-agent-all.json
```
Activez et démarrez le `systemd` service à l'aide des commandes suivantes :
```
sudo systemctl enable dlami-cloudwatch-agent@all
sudo systemctl start dlami-cloudwatch-agent@all
```
### Configurer des métriques GPU personnalisées
Si les métriques préconfigurées ne répondent pas à vos exigences, vous pouvez créer un fichier de configuration d' CloudWatch agent personnalisé.
#### Création d'un fichier de configuration personnalisé
Pour créer un fichier de configuration personnalisé, reportez-vous aux étapes détaillées de la section [Création ou modification manuelle du fichier de configuration de l' CloudWatch agent](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Agent-Configuration-File-Details.html).
Pour cet exemple, supposons que la définition du schéma se trouve à`/opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json`.
#### Configurez les métriques avec votre fichier personnalisé
Exécutez la commande suivante pour configurer l' CloudWatch agent en fonction de votre fichier personnalisé :
```
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
```
### Correctifs de sécurité pour l'agent AWS CloudWatch
Les nouvelles versions DLAMIs sont configurées avec les derniers correctifs de sécurité des AWS CloudWatch agents disponibles. Reportez-vous aux sections suivantes pour mettre à jour votre DLAMI actuel avec les derniers correctifs de sécurité en fonction du système d'exploitation de votre choix.
#### Amazon Linux 2
`yum`À utiliser pour obtenir les derniers correctifs de sécurité des AWS CloudWatch agents pour un DLAMI Amazon Linux 2.
```
sudo yum update
```
#### Ubuntu
Pour obtenir les derniers correctifs AWS CloudWatch de sécurité pour un DLAMI avec Ubuntu, il est nécessaire de réinstaller l'agent à AWS CloudWatch l'aide d'un lien de téléchargement Amazon S3.
```
wget https://s3.region.amazonaws.com/amazoncloudwatch-agent-region/ubuntu/arm64/latest/amazon-cloudwatch-agent.deb
```
Pour plus d'informations sur l'installation de l' AWS CloudWatch agent à l'aide des liens de téléchargement Amazon S3, consultez [Installation et exécution de l' CloudWatch agent sur vos serveurs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/install-CloudWatch-Agent-commandline-fleet.html).
## Configurer les métriques avec le script préinstallé `gpumon.py`
Un utilitaire appelée gpumon.py est préinstallé sur vos DLAMI. Il s'intègre CloudWatch et prend en charge la surveillance de l'utilisation par processeur graphique : mémoire du processeur graphique, température du processeur graphique et puissance du processeur graphique. Le script envoie régulièrement les données surveillées à CloudWatch. Vous pouvez configurer le niveau de granularité des données envoyées CloudWatch en modifiant quelques paramètres dans le script. Avant de démarrer le script, vous devez toutefois vous configurer CloudWatch pour recevoir les métriques.
**Comment configurer et exécuter la surveillance du GPU avec CloudWatch**
1. Créez un utilisateur IAM ou modifiez un utilisateur existant pour disposer d'une politique de publication de la métrique sur. CloudWatch Si vous créez un nouvel utilisateur, notez les informations d'identification. Vous en aurez besoin à l'étape suivante.
La politique IAM à rechercher est « cloudwatch : PutMetricData ». La stratégie qui est ajoutée est la suivante :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"cloudwatch:PutMetricData"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
**Astuce**
Pour plus d'informations sur la création d'un utilisateur IAM et l'ajout de politiques pour CloudWatch, consultez la [ CloudWatch documentation](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/create-iam-roles-for-cloudwatch-agent.html).
1. Sur votre DLAMI, [AWS exécutez](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html#cli-quick-configuration) configure et spécifiez les informations d'identification de l'utilisateur IAM.
```
$ aws configure
```
1. Vous devrez peut-être modifier l'utilitaire gpumon avant de l'exécuter. Vous trouverez l'utilitaire gpumon et le fichier README à l'emplacement défini dans le bloc de code suivant. Pour plus d'informations sur le `gpumon.py` script, consultez [l'emplacement du script sur Amazon S3.](https://s3.amazonaws.com/aws-bigdata-blog/artifacts/GPUMonitoring/gpumon.py)
```
Folder: ~/tools/GPUCloudWatchMonitor
Files: ~/tools/GPUCloudWatchMonitor/gpumon.py
~/tools/GPUCloudWatchMonitor/README
```
Options :
+ Si votre instance N'est PAS située dans la région us-east-1, modifiez la région dans gpumon.py.
+ Modifiez d'autres paramètres tels que le CloudWatch `namespace` ou la période de référence avec`store_reso`.
1. Actuellement, le script prend uniquement en charge Python 3. Activez l'environnement Python 3 de votre framework préféré ou activez l'environnement Python 3 général DLAMI.
```
$ source activate python3
```
1. Exécutez l'utilitaire gpumon en arrière-plan.
```
(python3)$ python gpumon.py &
```
1. Ouvrez votre navigateur à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/), puis sélectionnez la métrique. Il aura un espace de noms « DeepLearningTrain ».
**Astuce**
Vous pouvez modifier l'espace de noms en modifiant gpumon.py. Vous pouvez également modifier l'intervalle de création des rapports en ajustant `store_reso`.
Voici un exemple de CloudWatch graphique illustrant une exécution de gpumon.py surveillant une tâche de formation sur une instance p2.8xlarge.
![\[Surveillance du GPU activée CloudWatch\]](http://docs.aws.amazon.com/fr_fr/dlami/latest/devguide/images/gpumon.png)
Les rubriques suivantes relatives à la surveillance et l'optimisation des GPU peuvent vous intéresser :
+ [Contrôle](tutorial-gpu-monitoring.md)
+ [Moniteur GPUs avec CloudWatch](#tutorial-gpu-monitoring-gpumon)
+ [Optimisation](tutorial-gpu-opt.md)
+ [Prétraitement](tutorial-gpu-opt-preprocessing.md)
+ [Entraînement](tutorial-gpu-opt-training.md)
# Optimisation
Pour en tirer le meilleur parti GPUs, vous pouvez optimiser votre pipeline de données et ajuster votre réseau de deep learning. Comme décrit dans le graphique suivant, une implémentation naïve ou élémentaire d'un réseau neuronal risque d'utiliser le GPU de manière incohérente, et ne pas exploiter pleinement son potentiel. Lorsque vous optimisez le prétraitement et le chargement des données, vous pouvez réduire le goulot d'étranglement de votre CPU à votre GPU. Vous pouvez ajuster le réseau neuronal lui-même, en utilisant un réseau hybride (lorsqu'il est pris en charge par l'infrastructure), en ajustant la taille des lots et en synchronisant les appels. Vous pouvez également utiliser la formation avec précision multiple (float16 ou int8) dans la plupart des infrastructures, ce qui peut améliorer considérablement le débit.
Le graphique suivant illustre les gains de performance cumulés lorsque différentes optimisations sont appliquées. Vos résultats dépendront des données vous traitez et du réseau que vous optimisez.
![\[Améliorations des performances pour GPUs\]](http://docs.aws.amazon.com/fr_fr/dlami/latest/devguide/images/performance-enhancements.png)
Les guides suivants présentent les options qui fonctionneront avec votre DLAMI et vous aideront à améliorer les performances du GPU.
**Topics**
+ [Prétraitement](tutorial-gpu-opt-preprocessing.md)
+ [Entraînement](tutorial-gpu-opt-training.md)
# Prétraitement
Le processus de prétraitement des données via des transformations ou des augmentations peut souvent être lié AU CPU. Il peut donc constituer le goulot d'étranglement dans votre pipeline. Les infrastructures comportent des opérateurs pour le traitement des images, mais la bibliothèque DALI (Data Augmentation Library) affiche de meilleures performances que les options intégrées aux infrastructures.
+ Bibliothèque NVIDIA Data Augmentation Library (DALI) : DALI décharge l'augmentation de données dans le GPU. Il n'est pas préinstallé sur le DLAMI, mais vous pouvez y accéder en l'installant ou en chargeant un conteneur de framework pris en charge sur votre DLAMI ou sur une autre instance Amazon Elastic Compute Cloud. Reportez-vous à la [page de projet DALI](https://docs.nvidia.com/deeplearning/sdk/dali-install-guide/index.html) sur le site web NVIDIA pour plus de détails. Pour un exemple de cas d'utilisation et pour télécharger des exemples de code, consultez l'exemple de performance d'[entraînement en matière de SageMaker prétraitement](https://github.com/aws-samples/sagemaker-cv-preprocessing-training-performance).
+ nvJPEG : bibliothèque de décodage JPEG avec accélération GPU pour les programmeurs C. Elle prend en charge le décodage d'images uniques ou de lots, ainsi que les opérations de transformation suivantes qui sont communes dans le deep learning. nvJPEG est intégré à DALI. Vous pouvez également le télécharger à partir de la [page nvjpeg du site web NVIDIA](https://developer.nvidia.com/nvjpeg) et l'utiliser séparément.
Les rubriques suivantes relatives à la surveillance et l'optimisation des GPU peuvent vous intéresser :
+ [Contrôle](tutorial-gpu-monitoring.md)
+ [Moniteur GPUs avec CloudWatch](tutorial-gpu-monitoring-gpumon.md)
+ [Optimisation](tutorial-gpu-opt.md)
+ [Prétraitement](#tutorial-gpu-opt-preprocessing)
+ [Entraînement](tutorial-gpu-opt-training.md)
# Entraînement
Avec la formation avec précision mixte, vous pouvez déployer de plus grands réseaux avec la même quantité de mémoire, ou réduire l'utilisation de la mémoire par rapport à votre réseau simple ou double précision. Vous obtiendrez aussi de meilleures performances de calcul. Vous pouvez également tirer parti de transferts de données plus petits et plus rapides, qui est un facteur important dans la formation distribuée à plusieurs nœuds. Pour profiter de la formation avec précision mixte, vous devez ajuster la conversion et la mise à l'échelle de la perte des données. Les guides suivants décrivent la procédure pour les infrastructures qui prennent en charge la précision mixte.
+ [SDK NVIDIA Deep Learning](https://docs.nvidia.com/deeplearning/sdk/mixed-precision-training/) : documentation disponible sur le site Web de NVIDIA décrivant l'implémentation en précision mixte pour MXNet, et PyTorch. TensorFlow
**Astuce**
Recherchez l'infrastructure de votre choix sur le site web, puis recherchez « précision mixte » ou « fp16 » pour obtenir les dernières techniques d'optimisation. Voici quelques guides relatifs à la précision mixte qui peuvent vous être utiles :
[Entraînement de précision mixte avec TensorFlow (vidéo)](https://devblogs.nvidia.com/mixed-precision-resnet-50-tensor-cores/) - sur le site du blog NVIDIA.
[Entraînement à précision mixte avec float16 avec MXNet](https://mxnet.apache.org/api/faq/float16) - un article de FAQ sur le site Web. MXNet
[NVIDIA Apex : un outil pour un entraînement facile à précision mixte grâce PyTorch](https://devblogs.nvidia.com/apex-pytorch-easy-mixed-precision-training/) à un article de blog sur le site Web de NVIDIA.
Les rubriques suivantes relatives à la surveillance et l'optimisation des GPU peuvent vous intéresser :
+ [Contrôle](tutorial-gpu-monitoring.md)
+ [Moniteur GPUs avec CloudWatch](tutorial-gpu-monitoring-gpumon.md)
+ [Optimisation](tutorial-gpu-opt.md)
+ [Prétraitement](tutorial-gpu-opt-preprocessing.md)
+ [Entraînement](#tutorial-gpu-opt-training)
# La puce AWS Inferentia avec DLAMI
AWS Inferentia est une puce d'apprentissage automatique personnalisée conçue pour AWS que vous puissiez l'utiliser pour des prédictions d'inférence de haute performance. Pour utiliser la puce, configurez une instance Amazon Elastic Compute Cloud et utilisez le kit de développement logiciel (SDK) AWS Neuron pour appeler la puce Inferentia. Pour offrir aux clients la meilleure expérience Inferentia, Neuron a été intégré au ( AWS Apprentissage profond (deep learning) AMIs DLAMI).
Les rubriques suivantes vous montrent comment commencer à utiliser Inferentia avec le DLAMI.
**Topics**
+ [Lancement d'une instance DLAMI avec Neuron AWS](tutorial-inferentia-launching.md)
+ [Utilisation du DLAMI avec Neuron AWS](tutorial-inferentia-using.md)
# Lancement d'une instance DLAMI avec Neuron AWS
Le dernier DLAMI est prêt à être utilisé AWS avec Inferentia et est fourni avec AWS le package Neuron API. Pour lancer une instance DLAMI, [reportez-vous à la section Lancement et configuration](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html) d'une instance DLAMI. Une fois que vous avez un DLAMI, suivez les étapes décrites ici pour vous assurer que AWS votre puce Inferentia AWS et vos ressources Neuron sont actives.
**Topics**
+ [Vérification de votre instance](#tutorial-inferentia-launching-verify)
+ [Identification des AWS dispositifs d'inférence](#tutorial-inferentia-launching-identify)
+ [Affichage de l'utilisation des ressources](#tutorial-inferentia-launching-resource-usage)
+ [Utilisation de Neuron Monitor (neuron-monitor)](#tutorial-inferentia-launching-neuron-monitor)
+ [Mise à niveau du logiciel Neuron](#tutorial-inferentia-launching-upgrade)
## Vérification de votre instance
Avant d'utiliser votre instance, vérifiez qu'elle est correctement configurée et configurée avec Neuron.
## Identification des AWS dispositifs d'inférence
Pour identifier le nombre d'appareils Inferentia sur votre instance, utilisez la commande suivante :
```
neuron-ls
```
Si des périphériques Inferentia sont attachés à votre instance, votre sortie ressemblera à ce qui suit :
```
+--------+--------+--------+-----------+--------------+
| 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 |
+--------+--------+--------+-----------+--------------+
```
La sortie fournie provient d'une instance INF1.6xLarge et inclut les colonnes suivantes :
+ DISPOSITIF NEURONAL : ID logique attribué au NeuronDevice. Cet ID est utilisé lors de la configuration de plusieurs environnements d'exécution pour en utiliser différents. NeuronDevices
+ NOYAUX NEURONAUX : Le nombre de personnes NeuronCores présentes dans le NeuronDevice.
+ MÉMOIRE NEURONALE : quantité de mémoire DRAM contenue dans le. NeuronDevice
+ APPAREILS CONNECTÉS : Autres appareils NeuronDevices connectés au NeuronDevice.
+ PCI BDF : ID de fonction du périphérique de bus PCI (BDF) du. NeuronDevice
## Affichage de l'utilisation des ressources
Affichez des informations utiles sur l'utilisation NeuronCore des vCPU, l'utilisation de la mémoire, les modèles chargés et les applications Neuron à l'aide de la commande. `neuron-top` Le lancement `neuron-top` sans arguments affichera les données de toutes les applications d'apprentissage automatique qui les utilisent NeuronCores.
```
neuron-top
```
Lorsqu'une application en utilise quatre NeuronCores, le résultat doit ressembler à l'image suivante :
![\[Le résultat de la neuron-top commande, avec les informations relatives à l'une des quatre commandes NeuronCores mises en évidence.\]](http://docs.aws.amazon.com/fr_fr/dlami/latest/devguide/images/neuron-top-output.png)
[Pour plus d'informations sur les ressources permettant de surveiller et d'optimiser les applications d'inférence basées sur les neurones, consultez Neuron Tools.](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/index.html)
## Utilisation de Neuron Monitor (neuron-monitor)
Neuron Monitor collecte des métriques à partir des environnements d'exécution Neuron exécutés sur le système et diffuse les données collectées vers stdout au format JSON. Ces métriques sont organisées en groupes de métriques que vous configurez en fournissant un fichier de configuration. Pour plus d'informations sur Neuron Monitor, consultez le [guide de l'utilisateur de Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/neuron-monitor-user-guide.html) Monitor.
## Mise à niveau du logiciel Neuron
[Pour plus d'informations sur la mise à jour du logiciel Neuron SDK dans DLAMI, consultez le guide de configuration de Neuron. AWS](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-intro/neuron-install-guide.html)
**Étape suivante**
[Utilisation du DLAMI avec Neuron AWS](tutorial-inferentia-using.md)
# Utilisation du DLAMI avec Neuron AWS
Un flux de travail typique avec le SDK AWS Neuron consiste à compiler un modèle d'apprentissage automatique préalablement entraîné sur un serveur de compilation. Ensuite, distribuez les artefacts aux instances Inf1 pour exécution. AWS Apprentissage profond (deep learning) AMIs (DLAMI) est préinstallé avec tout ce dont vous avez besoin pour compiler et exécuter l'inférence dans une instance Inf1 qui utilise Inferentia.
Les sections suivantes décrivent comment utiliser le DLAMI avec Inferentia.
**Topics**
+ [Utilisation de TensorFlow -Neuron et du compilateur Neuron AWS](tutorial-inferentia-tf-neuron.md)
+ [Utilisation de AWS Neuron Serving TensorFlow](tutorial-inferentia-tf-neuron-serving.md)
+ [Utilisation de MXNet -Neuron et du compilateur Neuron AWS](tutorial-inferentia-mxnet-neuron.md)
+ [Utilisation de MXNet -Neuron Model Serving](tutorial-inferentia-mxnet-neuron-serving.md)
+ [Utilisation de PyTorch -Neuron et du compilateur Neuron AWS](tutorial-inferentia-pytorch-neuron.md)
# Utilisation de TensorFlow -Neuron et du compilateur Neuron AWS
Ce didacticiel montre comment utiliser le compilateur AWS Neuron pour compiler le modèle Keras ResNet -50 et l'exporter en tant que modèle enregistré au format. SavedModel Ce format est un format interchangeable typique des TensorFlow modèles. Vous apprendrez également à exécuter l'inférence sur une instance Inf1 avec un exemple d'entrée.
Pour plus d'informations sur le SDK Neuron, consultez la documentation du SDK [AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html).
**Topics**
+ [Conditions préalables](#tutorial-inferentia-tf-neuron-prerequisites)
+ [Activation de l'environnement Conda](#tutorial-inferentia-tf-neuron-activate)
+ [Compilation Resnet50](#tutorial-inferentia-tf-neuron-compilation)
+ [ResNet50 Inférence](#tutorial-inferentia-tf-neuron-inference)
## Conditions préalables
Avant d'utiliser ce didacticiel, vous devez avoir terminé les étapes de configuration figurant dans [Lancement d'une instance DLAMI avec Neuron AWS](tutorial-inferentia-launching.md). Vous devez également être familiarisé avec le deep learning et l'utilisation du DLAMI.
## Activation de l'environnement Conda
Activez l'environnement TensorFlow -Neuron conda à l'aide de la commande suivante :
```
source activate aws_neuron_tensorflow_p36
```
Pour quitter l'environnement Conda actuel, exécutez la commande suivante :
```
source deactivate
```
## Compilation Resnet50
Créez un script Python appelé **tensorflow\$1compile\$1resnet50.py** ayant le contenu suivant. Ce script Python compile le modèle Keras ResNet 50 et l'exporte en tant que modèle enregistré.
```
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')
```
Compilez le modèle à l'aide de la commande suivante :
```
python tensorflow_compile_resnet50.py
```
Le processus de compilation prendra quelques minutes. Une fois celui-ci terminée, votre sortie devrait ressembler à ce qui suit :
```
...
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
...
```
Après la compilation, le modèle enregistré est compressé dans **ws\$1resnet50/resnet50\$1neuron.zip**. Décompressez le modèle et téléchargez l'exemple d'image pour l'inférence à l'aide des commandes suivantes :
```
unzip ws_resnet50/resnet50_neuron.zip -d .
curl -O https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg
```
## ResNet50 Inférence
Créez un script Python appelé **tensorflow\$1infer\$1resnet50.py** ayant le contenu suivant. Ce script exécute l'inférence sur le modèle téléchargé à l'aide d'un modèle d'inférence compilé précédemment.
```
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])
```
Exécutez l'inférence sur le modèle à l'aide de la commande suivante :
```
python tensorflow_infer_resnet50.py
```
Le résultat doit être similaire à ce qui suit :
```
...
[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]
```
**Étape suivante**
[Utilisation de AWS Neuron Serving TensorFlow](tutorial-inferentia-tf-neuron-serving.md)
# Utilisation de AWS Neuron Serving TensorFlow
Ce didacticiel montre comment construire un graphe et ajouter une étape de compilation AWS Neuron avant d'exporter le modèle enregistré pour l'utiliser avec TensorFlow Serving. TensorFlow Le service est un système de service qui vous permet d'étendre l'inférence sur un réseau. Neuron TensorFlow Serving utilise la même API que le TensorFlow Serving normal. La seule différence est qu'un modèle enregistré doit être compilé pour AWS Inferentia et que le point d'entrée est un nom `tensorflow_model_server_neuron` binaire différent. Le binaire se trouve dans le `/usr/local/bin/tensorflow_model_server_neuron` DLAMI et y est préinstallé.
Pour plus d'informations sur le SDK Neuron, consultez la documentation du SDK [AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html).
**Topics**
+ [Conditions préalables](#tutorial-inferentia-tf-neuron--serving-prerequisites)
+ [Activation de l'environnement Conda](#tutorial-inferentia-tf-neuron-serving-activate)
+ [Compilation et exportation du modèle enregistré](#tutorial-inferentia-tf-neuron-serving-compile)
+ [Servir le modèle enregistré](#tutorial-inferentia-tf-neuron-serving-serving)
+ [Génération de demandes d'inférence au serveur de modèle](#tutorial-inferentia-tf-neuron-serving-inference)
## Conditions préalables
Avant d'utiliser ce didacticiel, vous devez avoir terminé les étapes de configuration figurant dans [Lancement d'une instance DLAMI avec Neuron AWS](tutorial-inferentia-launching.md). Vous devez également être familiarisé avec le deep learning et l'utilisation du DLAMI.
## Activation de l'environnement Conda
Activez l'environnement TensorFlow -Neuron conda à l'aide de la commande suivante :
```
source activate aws_neuron_tensorflow_p36
```
Si vous devez quitter l'environnement Conda actuel, exécutez :
```
source deactivate
```
## Compilation et exportation du modèle enregistré
Créez un script Python appelé `tensorflow-model-server-compile.py` avec le contenu suivant. Ce script construit un graphe et le compile à l'aide de Neuron. Il exporte ensuite le graphe compilé en tant que modèle enregistré.
```
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)
```
Compilez le modèle à l'aide de la commande suivante :
```
python tensorflow-model-server-compile.py
```
Le résultat doit être similaire à ce qui suit :
```
...
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
```
## Servir le modèle enregistré
Une fois le modèle compilé, vous pouvez utiliser la commande suivante pour servir le modèle enregistré avec le binaire tensorflow\$1model\$1server\$1neuron :
```
tensorflow_model_server_neuron --model_name=resnet50_inf1 \
--model_base_path=$HOME/resnet50_inf1/ --port=8500 &
```
Le résultat doit être similaire à ce qui suit. Le modèle compilé est installé dans la DRAM du dispositif Inferentia par le serveur pour préparer l'inférence.
```
...
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 ...
```
## Génération de demandes d'inférence au serveur de modèle
Créez un script Python appelé `tensorflow-model-server-infer.py` avec le contenu suivant. Ce script exécute l'inférence via gRPC, qui est une infrastructure de service.
```
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))
```
Exécutez l'inférence sur le modèle à l'aide de gRPC avec la commande suivante :
```
python tensorflow-model-server-infer.py
```
Le résultat doit être similaire à ce qui suit :
```
[[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]]
```
# Utilisation de MXNet -Neuron et du compilateur Neuron AWS
L'API de compilation MXNet -Neuron fournit une méthode pour compiler un modèle de graphe que vous pouvez exécuter sur un appareil AWS Inferentia.
Dans cet exemple, vous utilisez l'API pour compiler un modèle ResNet -50 et l'utiliser pour exécuter l'inférence.
Pour plus d'informations sur le SDK Neuron, consultez la documentation du SDK [AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html).
**Topics**
+ [Conditions préalables](#tutorial-inferentia-mxnet-neuron-prerequisites)
+ [Activation de l'environnement Conda](#tutorial-inferentia-mxnet-neuron-activate)
+ [Compilation Resnet50](#tutorial-inferentia-mxnet-neuron-compilation)
+ [ResNet50 Inférence](#tutorial-inferentia-mxnet-neuron-inference)
## Conditions préalables
Avant d'utiliser ce didacticiel, vous devez avoir terminé les étapes de configuration figurant dans [Lancement d'une instance DLAMI avec Neuron AWS](tutorial-inferentia-launching.md). Vous devez également être familiarisé avec le deep learning et l'utilisation du DLAMI.
## Activation de l'environnement Conda
Activez l'environnement MXNet -Neuron conda à l'aide de la commande suivante :
```
source activate aws_neuron_mxnet_p36
```
Pour quitter l'environnement Conda actuel, exécutez :
```
source deactivate
```
## Compilation Resnet50
Créez un script Python appelé **mxnet\$1compile\$1resnet50.py** avec le contenu suivant. Ce script utilise l'API Python de compilation MXNet -Neuron pour compiler un modèle 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)
```
Compilez le modèle à l'aide de la commande suivante :
```
python mxnet_compile_resnet50.py
```
La compilation prendra quelques minutes. Une fois la compilation terminée, les fichiers suivants se trouveront dans votre répertoire actuel :
```
resnet-50-0000.params
resnet-50-symbol.json
compiled_resnet50-0000.params
compiled_resnet50-symbol.json
```
## ResNet50 Inférence
Créez un script Python appelé **mxnet\$1infer\$1resnet50.py** avec le contenu suivant. Ce script télécharge un exemple d'image qu’il utilise pour exécuter l'inférence avec le modèle compilé.
```
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]))
```
Exécutez l'inférence avec le modèle compilé à l'aide de la commande suivante :
```
python mxnet_infer_resnet50.py
```
Le résultat doit être similaire à ce qui suit :
```
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
```
**Étape suivante**
[Utilisation de MXNet -Neuron Model Serving](tutorial-inferentia-mxnet-neuron-serving.md)
# Utilisation de MXNet -Neuron Model Serving
Dans ce didacticiel, vous apprendrez à utiliser un MXNet modèle préentraîné pour effectuer une classification d'images en temps réel avec Multi Model Server (MMS). Le MMS est un easy-to-use outil flexible destiné à servir des modèles d'apprentissage profond entraînés à l'aide de n'importe quel framework d'apprentissage automatique ou d'apprentissage profond. Ce tutoriel inclut une étape de compilation à l'aide de AWS Neuron et une implémentation du MMS à l'aide de. MXNet
Pour plus d'informations sur le SDK Neuron, consultez la documentation du SDK [AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html).
**Topics**
+ [Conditions préalables](#tutorial-inferentia-mxnet-neuron-serving-prerequisites)
+ [Activation de l'environnement Conda](#tutorial-inferentia-mxnet-neuron-serving-activate)
+ [Téléchargement de l'exemple de code](#tutorial-inferentia-mxnet-neuron-serving-download)
+ [Compilation du modèle.](#tutorial-inferentia-mxnet-neuron-serving-compile)
+ [Exécution de l'inférence](#tutorial-inferentia-mxnet-neuron-serving-inference)
## Conditions préalables
Avant d'utiliser ce didacticiel, vous devez avoir terminé les étapes de configuration figurant dans [Lancement d'une instance DLAMI avec Neuron AWS](tutorial-inferentia-launching.md). Vous devez également être familiarisé avec le deep learning et l'utilisation du DLAMI.
## Activation de l'environnement Conda
Activez l'environnement MXNet -Neuron conda à l'aide de la commande suivante :
```
source activate aws_neuron_mxnet_p36
```
Pour quitter l'environnement Conda actuel, exécutez :
```
source deactivate
```
## Téléchargement de l'exemple de code
Pour exécuter cet exemple, téléchargez l'exemple de code à l'aide des commandes suivantes :
```
git clone https://github.com/awslabs/multi-model-server
cd multi-model-server/examples/mxnet_vision
```
## Compilation du modèle.
Créez un script Python appelé `multi-model-server-compile.py` avec le contenu suivant. Ce script compile le modèle ResNet 50 sur la cible de l'appareil 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)
```
Pour compiler le modèle, utilisez la commande suivante :
```
python multi-model-server-compile.py
```
Le résultat doit être similaire à ce qui suit :
```
...
[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!
```
Créez un fichier nommé `signature.json` avec le contenu suivant pour configurer le nom et la forme de l'entrée :
```
{
"inputs": [
{
"data_name": "data",
"data_shape": [
1,
3,
224,
224
]
}
]
}
```
Téléchargez le fichier `synset.txt` à l'aide de la commande suivante. Ce fichier est une liste de noms pour les classes de ImageNet prédiction.
```
curl -O https://s3.amazonaws.com/model-server/model_archive_1.0/examples/squeezenet_v1.1/synset.txt
```
Créez une classe de service personnalisée en suivant le modèle figurant dans le dossier `model_server_template`. Copiez le modèle dans votre répertoire de travail actuel à l'aide de la commande suivante :
```
cp -r ../model_service_template/* .
```
Modifiez le module `mxnet_model_service.py` pour remplacer le contexte `mx.cpu()` par le contexte `mx.neuron()` comme suit. Vous devez également commenter la copie de données inutile `model_input` car MXNet -Neuron ne prend pas en charge le NDArray et 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]
```
Empaquetez le modèle avec l'archiveur de modèle à l'aide des commandes suivantes :
```
cd ~/multi-model-server/examples
model-archiver --force --model-name resnet-50_compiled --model-path mxnet_vision --handler mxnet_vision_service:handle
```
## Exécution de l'inférence
Démarrez le serveur multimodèle et chargez le modèle qui utilise l' RESTful API à l'aide des commandes suivantes. Assurez-vous que **neuron-rtd** s'exécute avec les paramètres par défaut.
```
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
```
Exécutez l'inférence à l'aide d'un exemple d'image avec les commandes suivantes :
```
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
```
Le résultat doit être similaire à ce qui suit :
```
[
{
"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"
}
]
```
Pour effectuer un nettoyage après le test, émettez une commande de suppression via l' RESTful API et arrêtez le serveur de modèles à l'aide des commandes suivantes :
```
curl -X DELETE http://127.0.0.1:8081/models/resnet-50_compiled
multi-model-server --stop
```
Vous devriez voir la sortie suivante :
```
{
"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
```
# Utilisation de PyTorch -Neuron et du compilateur Neuron AWS
L'API de compilation PyTorch -Neuron fournit une méthode pour compiler un modèle de graphe que vous pouvez exécuter sur un appareil AWS Inferentia.
Un modèle formé doit être compilé sur une cible Inferentia avant de pouvoir être déployé sur des instances Inf1. Le didacticiel suivant compile le modèle torchvision ResNet 50 et l'exporte en tant que module enregistré. TorchScript Ce modèle est ensuite utilisé pour exécuter l'inférence.
Pour plus de commodité, ce didacticiel utilise une instance Inf1 pour la compilation et l'inférence. En pratique, vous pouvez compiler votre modèle à l'aide d'un autre type d'instance, par exemple la famille d'instances c5. Vous devez ensuite déployer votre modèle compilé sur le serveur d'inférence Inf1. Pour plus d'informations, consultez la documentation du [ PyTorch SDK AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/pytorch-neuron/index.html).
**Topics**
+ [Conditions préalables](#tutorial-inferentia-pytorch-neuron-prerequisites)
+ [Activation de l'environnement Conda](#tutorial-inferentia-pytorch-neuron-activate)
+ [Compilation Resnet50](#tutorial-inferentia-pytorch-neuron-compilation)
+ [ResNet50 Inférence](#tutorial-inferentia-pytorch-neuron-inference)
## Conditions préalables
Avant d'utiliser ce didacticiel, vous devez avoir terminé les étapes de configuration figurant dans [Lancement d'une instance DLAMI avec Neuron AWS](tutorial-inferentia-launching.md). Vous devez également être familiarisé avec le deep learning et l'utilisation du DLAMI.
## Activation de l'environnement Conda
Activez l'environnement PyTorch -Neuron conda à l'aide de la commande suivante :
```
source activate aws_neuron_pytorch_p36
```
Pour quitter l'environnement Conda actuel, exécutez :
```
source deactivate
```
## Compilation Resnet50
Créez un script Python appelé **pytorch\$1trace\$1resnet50.py** avec le contenu suivant. Ce script utilise l'API Python de compilation PyTorch -Neuron pour compiler un modèle ResNet -50.
**Note**
Il existe une dépendance entre les versions de Torchvision et le package Torch dont vous devez tenir compte lorsque vous compilez des modèles Torchvision. Ces règles de dépendance peuvent être gérées via pip. Torchvision==0.6.1 correspond à la version torch==1.5.1, tandis que torchvision==0.8.2 correspond à la version 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")
```
Exécutez le script de compilation.
```
python pytorch_trace_resnet50.py
```
La compilation prendra quelques minutes. Lorsque la compilation est terminée, le modèle compilé est enregistré `resnet50_neuron.pt` dans le répertoire local.
## ResNet50 Inférence
Créez un script Python appelé **pytorch\$1infer\$1resnet50.py** avec le contenu suivant. Ce script télécharge un exemple d'image qu’il utilise pour exécuter l'inférence avec le modèle compilé.
```
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) )
```
Exécutez l'inférence avec le modèle compilé à l'aide de la commande suivante :
```
python pytorch_infer_resnet50.py
```
Le résultat doit être similaire à ce qui suit :
```
Top 5 labels:
['tiger', 'lynx', 'tiger_cat', 'Egyptian_cat', 'tabby']
```
# Le ARM64 DLAMI
AWS ARM64 DLAMIs Les GPU sont conçus pour fournir des performances élevées et une rentabilité élevées pour les charges de travail liées au deep learning. Plus précisément, le type d'instance G5g intègre le [processeur AWS Graviton2](https://aws.amazon.com/ec2/graviton/) basé sur ARM64, qui a été entièrement conçu AWS et optimisé pour la façon dont les clients exécutent leurs charges de travail dans le cloud. AWS ARM64 DLAMIs Les GPU sont préconfigurés avec Docker, NVIDIA Docker, NVIDIA Driver, CUDA, cuDNN, NCCL, ainsi que des frameworks d'apprentissage automatique populaires tels que et. TensorFlow PyTorch
Avec le type d'instance G5g, vous pouvez tirer parti des avantages en termes de prix et de performances de Graviton2 pour déployer des modèles d'apprentissage profond accélérés par GPU à un coût nettement inférieur à celui des instances x86 avec accélération GPU.
## Sélectionnez un ARM64 DLAMI
Lancez une [instance G5g](https://aws.amazon.com/ec2/instance-types/g5g/) avec le ARM64 DLAMI de votre choix.
Pour step-by-step obtenir des instructions sur le lancement d'un DLAMI, [reportez-vous à la section Lancement et configuration](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html) d'un DLAMI.
Pour obtenir la liste des versions les plus récentes ARM64 DLAMIs, consultez les [notes de mise à jour relatives au DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/appendix-ami-release-notes.html).
## Démarrer
Les rubriques suivantes expliquent comment commencer à utiliser le ARM64 DLAMI.
**Topics**
+ [Sélectionnez un ARM64 DLAMI](#tutorial-arm64-select-dlami)
+ [Démarrer](#tutorial-arm64-get-started)
+ [Utilisation du ARM64 PyTorch DLAMI du GPU](tutorial-arm64-pytorch.md)
# Utilisation du ARM64 PyTorch DLAMI du GPU
AWS Apprentissage profond (deep learning) AMIs Il est prêt à être utilisé avec le processeur Arm64 et est GPUs optimisé pour. PyTorch Le ARM64 PyTorch DLAMI GPU inclut un environnement Python préconfiguré [PyTorch](https://aws.amazon.com/pytorch)avec [TorchVision](https://pytorch.org/vision/stable/index.html), et pour les cas d'utilisation de l'apprentissage profond, de la formation [TorchServe](https://pytorch.org/serve/)et de l'inférence.
**Topics**
+ [Vérifier l'environnement PyTorch Python](#tutorial-arm64-pytorch-environment)
+ [Exécutez un exemple d'entraînement avec PyTorch](#tutorial-arm64-pytorch-training)
+ [Exécutez un échantillon d'inférence avec PyTorch](#tutorial-arm64-pytorch-inference)
## Vérifier l'environnement PyTorch Python
Connectez-vous à votre instance G5g et activez l'environnement Conda de base à l'aide de la commande suivante :
```
source activate base
```
Votre invite de commande doit indiquer que vous travaillez dans l'environnement Conda de base, qui contient PyTorch TorchVision, et d'autres bibliothèques.
```
(base) $
```
Vérifiez les trajectoires d'outils par défaut de l' PyTorch environnement :
```
(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)
```
## Exécutez un exemple d'entraînement avec PyTorch
Exécutez un exemple de tâche de formation MNIST :
```
git clone https://github.com/pytorch/examples.git
cd examples/mnist
python main.py
```
Votre sortie doit ressembler à ce qui suit :
```
...
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%)
```
## Exécutez un échantillon d'inférence avec PyTorch
Utilisez les commandes suivantes pour télécharger un modèle densenet161 préentraîné et exécuter l'inférence en utilisant : 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
```
Votre sortie doit ressembler à ce qui suit :
```
{
"tiger_cat": 0.4693363308906555,
"tabby": 0.4633873701095581,
"Egyptian_cat": 0.06456123292446136,
"lynx": 0.0012828150065615773,
"plastic_bag": 0.00023322898778133094
}
```
Utilisez les commandes suivantes pour annuler l'enregistrement du modèle densenet161 et arrêter le serveur :
```
curl -X DELETE http://localhost:8081/models/densenet161/1.0
torchserve --stop
```
Votre sortie doit ressembler à ce qui suit :
```
{
"status": "Model \"densenet161\" unregistered"
}
TorchServe has stopped.
```
# Inférence
Cette section propose des didacticiels sur la façon d'exécuter l'inférence à l'aide des frameworks et des outils du DLAMI.
## Outils d'inférence
+ [TensorFlow Servir](tutorial-tfserving.md)
# Service de modèle
Les options de service de modèles installées sur l'AMI Deep Learning avec Conda sont les suivantes. Cliquez sur une option pour savoir comment l'utiliser.
**Topics**
+ [TensorFlow Servir](tutorial-tfserving.md)
+ [TorchServe](tutorial-torchserve.md)
# TensorFlow Servir
[TensorFlow Serving](https://www.tensorflow.org/tfx/guide/serving) est un système de service flexible et performant pour les modèles d'apprentissage automatique.
Le `tensorflow-serving-api` DLAMI est préinstallé avec un seul cadre DLAMI. Pour utiliser le service Tensorflow, activez d'abord l' TensorFlow environnement.
```
$ source /opt/tensorflow/bin/activate
```
Utilisez ensuite votre éditeur de texte préféré pour créer un script avec le contenu suivant. Nommez-la `test_train_mnist.py`. Ce script est référencé à partir du [TensorFlow didacticiel](https://github.com/tensorflow/docs/blob/master/site/en/tutorials/quickstart/beginner.ipynb) qui formera et évaluera un modèle d'apprentissage automatique par réseau neuronal qui classifie les images.
```
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)
```
À présent, exécutez le script en transmettant en paramètres l'emplacement et le port du serveur ainsi que le nom de fichier de la photo du husky.
```
$ /opt/tensorflow/bin/python3 test_train_mnist.py
```
Soyez patient, car le script peut prendre un certain temps avant de fournir une sortie. Une fois la formation terminée, vous devriez voir ce qui suit :
```
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
```
## Autres exemples et fonctions
Si vous souhaitez en savoir plus sur TensorFlow Serving, consultez le [TensorFlow site Web](https://www.tensorflow.org/serving/).
# TorchServe
TorchServe est un outil flexible destiné à servir des modèles de deep learning exportés depuis PyTorch. TorchServe est préinstallé avec l'AMI Deep Learning avec Conda.
Pour plus d'informations sur l'utilisation TorchServe, consultez la [ PyTorchdocumentation de Model Server](https://github.com/pytorch/serve/blob/master/docs/README.md).
**Rubriques**
## Servir un modèle de classification d'images sur TorchServe
Ce didacticiel montre comment utiliser un modèle de classification d'images avec TorchServe. Il utilise un modèle DenseNet -161 fourni par PyTorch. Une fois que le serveur est en cours d'exécution, il écoute les demandes de prédiction. Lorsque vous téléchargez une image, dans ce cas, l'image d'un chaton, le serveur renvoie une prédiction des 5 meilleures classes correspondantes parmi les classes sur lesquelles le modèle a été entraîné.
**Pour servir un exemple de modèle de classification d'images sur TorchServe**
1. Connectez-vous à une instance Amazon Elastic Compute Cloud (Amazon EC2) avec l'AMI Deep Learning avec Conda v34 ou version ultérieure.
1. Activez l'`pytorch_p310`environnement.
```
source activate pytorch_p310
```
1. Clonez le TorchServe référentiel, puis créez un répertoire pour stocker vos modèles.
```
git clone https://github.com/pytorch/serve.git
mkdir model_store
```
1. Archivez le modèle à l'aide de l'archiveur de modèles. Le `extra-files` paramètre utilise un fichier du `TorchServe` dépôt, donc mettez à jour le chemin si nécessaire. Pour plus d'informations sur l'archiveur de modèles, consultez la section [Archiveur de modèles Torch pour](https://github.com/pytorch/serve/blob/master/model-archiver/README.md). 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. Exécutez TorchServe pour démarrer un point de terminaison. L'ajout `> /dev/null` atténue la sortie du journal.
```
torchserve --start --ncs --model-store model_store --models densenet161.mar > /dev/null
```
1. Téléchargez l'image d'un chaton et envoyez-la au terminal de TorchServe prédiction :
```
curl -O https://s3.amazonaws.com/model-server/inputs/kitten.jpg
curl http://127.0.0.1:8080/predictions/densenet161 -T kitten.jpg
```
Le point de terminaison de prédiction renvoie une prédiction au format JSON similaire aux cinq principales prédictions suivantes, où l'image a une probabilité de 47 % de contenir un chat égyptien, suivie d'une probabilité de 46 % qu'elle ait un chat tigré.
```
{
"tiger_cat": 0.46933576464653015,
"tabby": 0.463387668132782,
"Egyptian_cat": 0.0645613968372345,
"lynx": 0.0012828196631744504,
"plastic_bag": 0.00023323058849200606
}
```
1. Lorsque vous avez terminé le test, arrêtez le serveur :
```
torchserve --stop
```
**Autres exemples**
TorchServe contient de nombreux exemples que vous pouvez exécuter sur votre instance DLAMI. Vous pouvez les consulter sur [la page d'exemples du référentiel de TorchServe projets](https://github.com/pytorch/serve/tree/master/examples).
**Plus d'info**
Pour plus de TorchServe documentation, notamment sur la configuration TorchServe avec Docker et les dernières TorchServe fonctionnalités, consultez [la page du TorchServe projet](https://github.com/pytorch/serve) sur GitHub.