Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Lernprogramme
Im Folgenden finden Sie Tutorials zur Verwendung des Deep Learning AMI mit der Software von Conda.
**Topics**
+ [
# Aktivieren von Frameworks
](activating.md)
+ [
# Verteiltes Training mit Elastic Fabric Adapter
](tutorial-efa.md)
+ [
# GPU-Überwachung und -Optimierung
](tutorial-gpu.md)
+ [
# Der AWS Inferentia-Chip mit DLAMI
](tutorial-inferentia.md)
+ [
# Das ARM64 DLAMI
](tutorial-arm64.md)
+ [
# Inferenz
](tutorial-inference.md)
+ [
# Modellbereitstellung
](model-serving.md)
# Aktivieren von Frameworks
Im Folgenden sind die Deep-Learning-Frameworks aufgeführt, die auf dem Deep Learning-AMI mit Conda installiert sind. Klicken Sie auf ein Framework, um zu erfahren, wie Sie es aktivieren.
**Topics**
+ [
# PyTorch
](tutorial-pytorch.md)
+ [
# TensorFlow 2
](tutorial-tensorflow-2.md)
# PyTorch
## Wird aktiviert PyTorch
Wenn ein stabiles Conda-Paket eines Frameworks veröffentlicht wird, wird es getestet und auf dem DLAMI vorinstalliert. Wenn Sie den neuesten, nicht getesteten Nightly Build ausführen möchten, können Sie [PyTorchInstall's Nightly Build (experimentell)](#tutorial-pytorch-install) manuell ausführen.
Um das aktuell installierte Framework zu aktivieren, folgen Sie diesen Anweisungen auf Ihrem Deep Learning AMI mit Conda.
Führen PyTorch Sie für Python 3 mit CUDA und MKL-DNN diesen Befehl aus:
```
$ source activate pytorch_p310
```
Starten Sie das iPython-Terminal.
```
(pytorch_p310)$ ipython
```
Führen Sie ein schnelles Programm aus. PyTorch
```
import torch
x = torch.rand(5, 3)
print(x)
print(x.size())
y = torch.rand(5, 3)
print(torch.add(x, y))
```
Das anfängliche zufällige Array sollte angezeigt werden. Danach wird seine Größe angezeigt und dann ein weiteres zufälliges Array.
## PyTorchInstall's Nightly Build (experimentell)
**Wie installiert man PyTorch von einem Nightly-Build**
Sie können den neuesten PyTorch Build in einer oder beiden PyTorch Conda-Umgebungen auf Ihrem Deep Learning-AMI mit Conda installieren.
1.
+ (Option für Python 3) — Aktiviere die PyTorch Python-3-Umgebung:
```
$ source activate pytorch_p310
```
1. Für die restlichen Schritte wird davon ausgegangen, dass Sie die `pytorch_p310`-Umgebung verwenden. Entfernen Sie das aktuell installierte PyTorch:
```
(pytorch_p310)$ pip uninstall torch
```
1.
+ (Option für GPU-Instanzen) — Installieren Sie den neuesten nächtlichen Build von PyTorch mit CUDA.0:
```
(pytorch_p310)$ pip install torch_nightly -f https://download.pytorch.org/whl/nightly/cu100/torch_nightly.html
```
+ (Option für CPU-Instanzen) — Installieren Sie den neuesten nächtlichen Build von PyTorch für Instances ohne: GPUs
```
(pytorch_p310)$ pip install torch_nightly -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html
```
1. Um zu überprüfen, ob Sie den neuesten Nightly Build erfolgreich installiert haben, starten Sie das IPython Terminal und überprüfen Sie die Version von. PyTorch
```
(pytorch_p310)$ ipython
```
```
import torch
print (torch.__version__)
```
Die Druckausgabe sollte in etwa wie folgt aussehen: `1.0.0.dev20180922`
1. Um zu überprüfen, ob der PyTorch Nightly-Build gut mit dem MNIST-Beispiel funktioniert, können Sie ein Testskript aus dem PyTorch Beispiel-Repository ausführen:
```
(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
```
## Weitere Tutorials
Weitere Tutorials und Beispiele finden Sie in den offiziellen Dokumenten, der [PyTorch Dokumentation](http://pytorch.org/docs/master/) und auf der Website des [PyTorch](http://pytorch.org)Frameworks.
# TensorFlow 2
Dieses Tutorial zeigt, wie Sie TensorFlow 2 auf einer Instance aktivieren, auf der das Deep Learning AMI mit Conda (DLAMI on Conda) ausgeführt wird, und ein 2-Programm ausführen. TensorFlow
Wenn ein stabiles Conda-Paket eines Frameworks veröffentlicht wird, wird es getestet und auf dem DLAMI vorinstalliert.
## Aktiviert 2 TensorFlow
**Um mit TensorFlow Conda auf dem DLAMI zu laufen**
1. Um TensorFlow 2 zu aktivieren, öffnen Sie eine Amazon Elastic Compute Cloud (Amazon EC2) -Instanz des DLAMI mit Conda.
1. Führen Sie für TensorFlow 2 und Keras 2 auf Python 3 mit CUDA 10.1 und MKL-DNN diesen Befehl aus:
```
$ source activate tensorflow2_p310
```
1. Starten Sie das iPython-Terminal:
```
(tensorflow2_p310)$ ipython
```
1. Führen Sie ein TensorFlow 2-Programm aus, um zu überprüfen, ob es ordnungsgemäß funktioniert:
```
import tensorflow as tf
hello = tf.constant('Hello, TensorFlow!')
tf.print(hello)
```
Auf Ihrem Bildschirm sollte `Hello, TensorFlow!` angezeigt werden.
## Weitere Tutorials
Weitere Tutorials und Beispiele finden Sie in der TensorFlow Dokumentation zur [TensorFlow Python-API](https://www.tensorflow.org/api_docs/python/) oder [TensorFlow](https://www.tensorflow.org)auf der Website.
# Verteiltes Training mit Elastic Fabric Adapter
Ein [Elastic Fabric Adapter](https://aws.amazon.com/hpc/efa/) (EFA) ist ein Netzwerkgerät, das Sie an Ihre DLAMI-Instanz anschließen können, um High Performance Computing (HPC) -Anwendungen zu beschleunigen. EFA ermöglicht es Ihnen, die Anwendungsleistung eines lokalen HPC-Clusters mit der Skalierbarkeit, Flexibilität und Elastizität der Cloud zu erreichen. AWS
Die folgenden Themen zeigen Ihnen, wie Sie mit der Verwendung von EFA mit dem DLAMI beginnen können.
**Anmerkung**
Wählen Sie Ihr DLAMI aus dieser [Base-GPU-DLAMI-Liste](appendix-ami-release-notes.md#appendix-ami-release-notes-base)
**Topics**
+ [
# Starten einer Instance mit EFA AWS Deep Learning AMIs
](tutorial-efa-launching.md)
+ [
# EFA auf dem DLAMI verwenden
](tutorial-efa-using.md)
# Starten einer Instance mit EFA AWS Deep Learning AMIs
Das neueste Base DLAMI ist sofort mit EFA einsatzbereit und wird mit den erforderlichen Treibern, Kernelmodulen, libfabric, openmpi und dem [NCCL](https://github.com/aws/aws-ofi-nccl/tree/aws) OFI-Plugin für GPU-Instanzen geliefert.
[Die unterstützten CUDA-Versionen eines Basis-DLAMI finden Sie in den Versionshinweisen.](appendix-ami-release-notes.md#appendix-ami-release-notes-base)
Hinweis:
+ Wenn Sie eine NCCL-Anwendung `mpirun` auf EFA ausführen, müssen Sie den vollständigen Pfad zu der von EFA unterstützten Installation wie folgt angeben:
```
/opt/amazon/openmpi/bin/mpirun
```
+ Damit Ihre Anwendung EFA verwenden kann, fügen Sie `FI_PROVIDER="efa"` dem `mpirun`-Befehl hinzu, wie unter [EFA auf dem DLAMI verwenden](tutorial-efa-using.md) gezeigt.
**Topics**
+ [
## Bereiten Sie eine EFA-fähige Sicherheitsgruppe vor
](#tutorial-efa-security-group)
+ [
## Starten Ihrer Instance
](#tutorial-efa-launch)
+ [
## Überprüfen Sie den EFA-Anhang
](#tutorial-efa-verify-attachment)
## Bereiten Sie eine EFA-fähige Sicherheitsgruppe vor
EFA benötigt eine Sicherheitsgruppe, die den gesamten eingehenden und ausgehenden Datenverkehr zur und von der Sicherheitsgruppe selbst zulässt. [Weitere Informationen finden Sie in der EFA-Dokumentation.](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security)
1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie im Navigationsbereich **Security Groups** (Sicherheitsgruppen) und anschließend **Create Security Group** (Sicherheitsgruppe erstellen) aus.
1. Führen Sie im Fenster **Create Security Group** Folgendes aus:
+ Geben Sie für **Security group name** (Name der Sicherheitsgruppe) einen beschreibenden Namen für die Sicherheitsgruppe ein, wie etwa `EFA-enabled security group`.
+ (Optional:) Geben Sie unter **Description** (Beschreibung) eine kurze Beschreibung der Sicherheitsgruppe ein.
+ Wählen Sie bei **VPC** die VPC aus, in der Sie Ihre EFA-fähigen Instances starten möchten.
+ Wählen Sie **Create (Erstellen)** aus.
1. Wählen Sie die von Ihnen erstellte Sicherheitsgruppe aus und kopieren Sie dann auf der Registerkarte **Description** (Beschreibung) die **Group ID** (Gruppen-ID).
1. Gehen Sie auf den Registerkarten **Eingehend** und **Ausgehend** wie folgt vor:
+ Wählen Sie **Edit** aus.
+ Wählen Sie für **Type (Typ)** die Option **All traffic (Gesamter Datenverkehr)** aus.
+ Wählen Sie für **Source (Quelle)** die Option **Custom (Benutzerdefiniert)** aus.
+ Fügen Sie die Sicherheitsgruppen-ID, die Sie kopiert haben, in das Feld ein.
+ Wählen Sie **Speichern**.
1. Aktivieren Sie eingehenden Datenverkehr, indem Sie entsprechend der Informationen unter [Autorisieren von eingehendem Datenverkehr für Linux-Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html) vorgehen. Wenn Sie diesen Schritt überspringen, können Sie nicht mit Ihrer DLAMI-Instanz kommunizieren.
## Starten Ihrer Instance
EFA on the AWS Deep Learning AMIs wird derzeit von den folgenden Instance-Typen und Betriebssystemen unterstützt:
+ 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
Der folgende Abschnitt zeigt, wie eine EFA-fähige DLAMI-Instanz gestartet wird. Weitere Informationen zum Starten einer EFA-fähigen Instance finden Sie unter [Starten von EFA-fähigen Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-instances) in einer Cluster Placement-Gruppe.
1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie **Launch Instance** aus.
1. Wählen Sie auf der Seite „**AMI auswählen“ ein** unterstütztes DLAMI aus, das Sie auf der Seite mit den [DLAMI-Versionshinweisen](https://docs.aws.amazon.com/dlami/latest/devguide/appendix-ami-release-notes) finden
1. **Wählen Sie auf der Seite „Instance-Typ** auswählen“ einen der folgenden unterstützten Instance-Typen aus und klicken Sie dann auf **Weiter:** Instance-Details konfigurieren. Unter diesem Link finden Sie eine Liste der unterstützten Instances: [Erste Schritte mit EFA und MPI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html)
1. Führen Sie auf der Seite **Configure Instance Details (Instance-Details konfigurieren)** die folgenden Schritte aus:
+ Geben Sie für **Number of instances (Anzahl der Instances)** die Anzahl der EFA-aktivierten Instances ein, die gestartet werden sollen.
+ Wählen Sie für **Network (Netzwerk)** und **Subnet (Subnetz)** die VPC und das Subnetz an, in das Sie die Instances starten möchten.
+ [Optional] Wählen Sie für **Placement-Gruppe** die Option **Instance zur Placement-Gruppe hinzufügen** aus. Um eine optimale Leistung zu erzielen, starten Sie die Instances innerhalb einer Platzierungsgruppe.
+ [Optional] Wählen Sie für **Placement-Gruppenname** die Option **Zu einer neuen Placement-Gruppe hinzufügen** aus, geben Sie einen aussagekräftigen Namen für die Placement-Gruppe ein und wählen Sie dann für **Placement-Gruppenstrategie** die Option **Cluster** aus.
+ Achten Sie darauf, den **„Elastic Fabric Adapter“** auf dieser Seite zu aktivieren. Wenn diese Option deaktiviert ist, ändern Sie das Subnetz in ein Subnetz, das den ausgewählten Instance-Typ unterstützt.
+ Wählen Sie im Abschnitt **Network Interfaces (Netzwerkschnittstellen** für das Gerät **eth0** die Option **New network interface (Neue Netzwerkschnittstelle)** aus. Sie können optional eine primäre IPv4 Adresse und eine oder mehrere sekundäre IPv4 Adressen angeben. Wenn Sie die Instance in einem Subnetz starten, dem ein IPv6 CIDR-Block zugeordnet ist, können Sie optional eine primäre IPv6 Adresse und eine oder mehrere sekundäre IPv6 Adressen angeben.
+ Wählen Sie **Next: Add Storage** aus.
1. Auf der Seite **Add Storage (Speicher hinzufügen)** können Sie neben den durch das AMI festgelegten Volumes (wie z. B. dem Root-Gerät-Volume) auch Datenträger angeben, die an die Instance angefügt werden sollen. Wählen Sie anschließend **Next: Add Tags (Weiter: Tags (Markierungen) hinzufügen)** aus.
1. Geben Sie auf der Seite **Add Tags (Tags (Markierungen) hinzufügen)** Tags (Markierungen) für die Instances an, z. B. einen benutzerfreundlichen Namen, und wählen Sie anschließend **Next: Configure Security Group (Weiter: Sicherheitsgruppe konfigurieren)**.
1. **Wählen Sie auf der Seite **Sicherheitsgruppe konfigurieren** für **Sicherheitsgruppe zuweisen die Option Eine** **bestehende Sicherheitsgruppe auswählen und wählen Sie dann die Sicherheitsgruppe** aus, die Sie zuvor erstellt haben.**
1. Klicken Sie auf **Review and Launch**.
1. Überprüfen Sie auf der Seite **Review Instance Launch (Instance-Start überprüfen)** Ihre Einstellungen und wählen Sie anschließend **Launch (Starten)** aus, um ein Schlüsselpaar auszuwählen und Ihre Instance zu starten.
## Überprüfen Sie den EFA-Anhang
### Über die Konsole
Überprüfen Sie nach dem Start der Instance die Instance-Details in der AWS Konsole. Wählen Sie dazu die Instance in der EC2-Konsole aus und sehen Sie sich die Registerkarte "Description (Beschreibung)" im unteren Bereich auf der Seite an. Suchen Sie den Parameter "Network Interfaces: eth0" und klicken Sie auf "eth0", wodurch ein Pop-up geöffnet wird. Stellen Sie sicher, dass der 'Elastic Fabric Adapter' aktiviert ist.
Wenn EFA nicht aktiviert ist, können Sie dies wie folgt beheben:
+ Beenden der EC2-Instance und Starten einer neuen Instance mit den gleichen Schritten. Stellen Sie sicher, dass die EFA angeschlossen ist.
+ Hängen Sie EFA an eine bestehende Instanz an.
1. Wechseln Sie in der EC2-Konsole zu "Network Interfaces (Netzwerkschnittstellen)".
1. Klicken Sie auf "Create a Network Interface (Netzwerkschnittstelle erstellen)".
1. Wählen Sie dasselbe Subnetz aus, in dem sich Ihre Instance befindet.
1. Stellen Sie sicher, dass der 'Elastic Fabric Adapter' aktiviert ist, und klicken Sie auf Erstellen.
1. Wechseln Sie zurück zur Registerkarte "EC2 Instances (EC-Instances)" und wählen Sie Ihre Instance aus.
1. Gehen Sie zu Aktionen: Instanzstatus und beenden Sie die Instance, bevor Sie EFA anhängen.
1. Wählen Sie unter "Actions (Aktionen)" die Option "Networking: Attach Network Interface (Netzwerk: Netzwerkschnittstelle anfügen)" aus.
1. Wählen Sie die soeben erstellte Schnittstelle aus und klicken Sie auf "Attach (Anfügen)".
1. Starten Sie Ihre Instance neu.
### Über die Instance
Das folgende Testskript ist bereits auf dem DLAMI vorhanden. Führen Sie es aus, um sicherzustellen, dass die Kernel-Module ordnungsgemäß geladen sind.
```
$ fi_info -p efa
```
Ihre Ausgabe sollte in etwa wie folgt aussehen.
```
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
```
### Überprüfen der Sicherheitsgruppenkonfiguration
Das folgende Testskript ist bereits auf dem DLAMI vorhanden. Führen Sie es aus, um sicherzustellen, dass die von Ihnen erstellte Sicherheitsgruppe ordnungsgemäß konfiguriert ist.
```
$ cd /opt/amazon/efa/test/
$ ./efa_test.sh
```
Ihre Ausgabe sollte in etwa wie folgt aussehen.
```
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
```
Wenn es nicht mehr reagiert oder nicht vollständig ausgeführt wird, stellen Sie sicher, dass Ihre Sicherheitsgruppe über die richtigen inbound/outbound Regeln verfügt.
# EFA auf dem DLAMI verwenden
Im folgenden Abschnitt wird beschrieben, wie EFA verwendet wird, um Anwendungen mit mehreren Knoten auf dem auszuführen. AWS Deep Learning AMIs
## Ausführen von Anwendungen mit mehreren Knoten mit EFA
Um eine Anwendung auf einem Knotencluster auszuführen, ist die folgende Konfiguration erforderlich
**Topics**
+ [
### Aktivieren von passwortloser SSH
](#tutorial-efa-using-multi-node-ssh)
+ [
### Erstellen einer Hosts-Datei
](#tutorial-efa-using-multi-node-hosts)
+ [
### NCCL-Tests
](#tutorial-efa-using-2node)
### Aktivieren von passwortloser SSH
Wählen Sie einen Knoten im Cluster als Führungsknoten aus. Die verbleibenden Knoten werden als Mitgliedsknoten bezeichnet.
1. Generieren Sie auf dem Führungsknoten das RSA-Tastenpaar.
```
ssh-keygen -t rsa -N "" -f ~/.ssh/id_rsa
```
1. Ändern Sie die Berechtigungen des privaten Schlüssels auf dem Führungsknoten.
```
chmod 600 ~/.ssh/id_rsa
```
1. Kopieren Sie den öffentlichen Schlüssel `~/.ssh/id_rsa.pub` auf die Mitgliedsknoten im Cluster und hängen Sie ihn an. `~/.ssh/authorized_keys`
1. Sie sollten nun in der Lage sein, sich direkt mithilfe der privaten IP bei den Mitgliedsknoten über den Führungsknoten anzumelden.
```
ssh
```
1. Deaktivieren Sie die strictHostKey Überprüfung und aktivieren Sie die Agentenweiterleitung auf dem Leader-Knoten, indem Sie der Datei \$1/.ssh/config auf dem Leader-Knoten Folgendes hinzufügen:
```
Host *
ForwardAgent yes
Host *
StrictHostKeyChecking no
```
1. Führen Sie auf Amazon Linux 2-Instances den folgenden Befehl auf dem Leader-Knoten aus, um die richtigen Berechtigungen für die Konfigurationsdatei bereitzustellen:
```
chmod 600 ~/.ssh/config
```
### Erstellen einer Hosts-Datei
Erstellen Sie auf dem Führungsknoten eine Hosts-Datei, um die Knoten im Cluster zu identifizieren. Die Hosts-Datei muss für jeden Knoten im Cluster einen Eintrag aufweisen. Erstellen Sie eine Datei "\$1/hosts" und fügen Sie jeden Knoten mithilfe der privaten IP wie folgt hinzu:
```
localhost slots=8
slots=8
slots=8
```
### NCCL-Tests
**Anmerkung**
Diese Tests wurden mit der EFA-Version 1.38.0 und dem OFI NCCL Plugin 1.13.2 ausgeführt.
Im Folgenden ist eine Teilmenge der von Nvidia bereitgestellten NCCL-Tests aufgeführt, mit denen sowohl Funktionalität als auch Leistung über mehrere Rechenknoten hinweg getestet werden können
**Unterstützte Instanzen: P3dn, P4, P5, P5e, P5en**
#### Leistungstests
##### NCCL-Leistungstest mit mehreren Knoten auf P4D.24xlarge
[Um die NCCL-Leistung mit EFA zu überprüfen, führen Sie den standardmäßigen NCCL-Leistungstest aus, der im offiziellen NCCL-Tests Repo verfügbar ist.](https://github.com/NVIDIA/nccl-tests.git) Das DLAMI enthält diesen Test, der bereits für CUDA XX.X erstellt wurde. Sie können auf ähnliche Weise Ihr eigenes Skript mit EFA ausführen.
Wenn Sie Ihr eigenes Skript erstellen, beachten Sie dabei die folgenden Anweisungen:
+ Verwenden Sie den vollständigen Pfad zu mpirun, wie im Beispiel gezeigt, während Sie NCCL-Anwendungen mit EFA ausführen.
+ Ändern Sie die Parameter np und N basierend auf der Anzahl der Instanzen und in Ihrem Cluster. GPUs
+ Fügen Sie das Flag NCCL\$1DEBUG=INFO hinzu und stellen Sie sicher, dass in den Protokollen die EFA-Nutzung als „Ausgewählter Anbieter ist EFA“ angegeben ist.
+ Legen Sie den Speicherort des Trainingsprotokolls fest, der zur Validierung analysiert werden soll
```
TRAINING_LOG="testEFA_$(date +"%N").log"
```
Verwenden Sie den Befehl `watch nvidia-smi` auf einem der Mitgliedsknoten, um die GPU-Nutzung zu überwachen. Die folgenden `watch nvidia-smi` Befehle gelten für eine generische CUDA xx.x-Version und hängen vom Betriebssystem Ihrer Instanz ab. Sie können die Befehle für jede verfügbare CUDA-Version in Ihrer Amazon EC2 EC2-Instance ausführen, indem Sie die CUDA-Version im Skript ersetzen.
+ 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}
```
Die Ausgabe sollte folgendermaßen aussehen:
```
# 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
```
#### Validierungstests
Um zu überprüfen, ob die EFA-Tests ein gültiges Ergebnis geliefert haben, verwenden Sie bitte die folgenden Tests zur Bestätigung:
+ Rufen Sie den Instanztyp mithilfe der EC2-Instanz-Metadaten ab:
```
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)
```
+ Ausführen des [Leistungstests](#tutorial-efa-using-multinode)s
+ Stellen Sie die folgenden Parameter ein
```
CUDA_VERSION
CUDA_RUNTIME_VERSION
NCCL_VERSION
```
+ Validieren Sie die Ergebnisse wie gezeigt:
```
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
```
+ Um auf die Benchmark-Daten zuzugreifen, können wir die letzte Zeile der Tabellenausgabe aus dem All\$1Reduce-Test mit mehreren Knoten analysieren:
```
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}"
```
# GPU-Überwachung und -Optimierung
Der folgende Abschnitt führt Sie durch GPU-Optimierungs und -Überwachungsoptionen. Dieser Abschnitt ist wie ein typischer Workflow mit Überwachung, Beaufsichtigung, Vorverarbeitung und Schulung aufgebaut.
+ [Überwachen](tutorial-gpu-monitoring.md)
+ [Überwachen Sie mit GPUs CloudWatch](tutorial-gpu-monitoring-gpumon.md)
+ [Optimierung](tutorial-gpu-opt.md)
+ [Vorverarbeitung](tutorial-gpu-opt-preprocessing.md)
+ [Training](tutorial-gpu-opt-training.md)
# Überwachen
Auf Ihrem DLAMI sind mehrere GPU-Überwachungstools vorinstalliert. Diese Anleitung erwähnt auch Tools, die heruntergeladen und installiert werden können.
+ [Überwachen Sie mit GPUs CloudWatch](tutorial-gpu-monitoring-gpumon.md)- ein vorinstalliertes Hilfsprogramm, das Statistiken zur GPU-Nutzung an Amazon CloudWatch meldet.
+ [nvidia-CLI](https://developer.nvidia.com/nvidia-system-management-interface) – ein Dienstprogramm zur Überwachung der allgemeinen GPU-Rechenleistungs- und -Speichernutzung. Dies ist auf Ihrem AWS Deep Learning AMIs (DLAMI) vorinstalliert.
+ [NVML C-Bibliothek](https://developer.nvidia.com/nvidia-management-library-nvml) - eine auf C basierende API für den direkten Zugriff auf GPU-Überwachungs- und Verwaltungsfunktionen. Dies wird von der nvidia-smi-CLI intern verwendet und ist auf Ihrem DLAMI vorinstalliert. Dazu gehören weiterhin Python- und Perl-Anbindungen zur Unterstützung der Bereitstellung in diesen Sprachen. Das auf Ihrem DLAMI vorinstallierte Hilfsprogramm gpumon.py verwendet das Paket pynvml von. [nvidia-ml-py](https://pypi.org/project/nvidia-ml-py/)
+ [NVIDIA DCGM](https://developer.nvidia.com/data-center-gpu-manager-dcgm) - Ein Cluster-Management-Tool. Besuchen Sie die Entwicklerseite, um zu erfahren, wie Sie dieses Tool installieren und konfigurieren.
**Tipp**
Im Entwickler-Blog von NVIDIA finden Sie die neuesten Informationen zur Verwendung der auf Ihrem DLAMI installierten CUDA-Tools:
[Überwachung TensorCore der Auslastung mit Nsight](https://devblogs.nvidia.com/using-nsight-compute-nvprof-mixed-precision-deep-learning-models/) IDE und nvprof.
# Überwachen Sie mit GPUs CloudWatch
Wenn Sie Ihre DLAMI mit einem GPU verwenden, stellen Sie möglicherweise fest, dass Sie auf der Suche nach Möglichkeiten zur Nachverfolgung der Nutzung während der Schulung oder Inferenz sind. Dies kann nützlich sein, um Ihre Datenpipeline zu optimieren und Ihr Deep Learning-Netzwerk zu verfeinern.
Es gibt zwei Möglichkeiten, GPU-Metriken zu konfigurieren mit CloudWatch:
+ [Metriken mit dem AWS CloudWatch Agenten konfigurieren (empfohlen)](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-guide)
+ [Konfigurieren Sie Metriken mit dem vorinstallierten Skript `gpumon.py`](#tutorial-gpu-monitoring-gpumon-script)
## Metriken mit dem AWS CloudWatch Agenten konfigurieren (empfohlen)
Integrieren Sie Ihr DLAMI in den [Unified CloudWatch Agent](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html), um GPU-Metriken zu konfigurieren und die Nutzung von GPU-Koprozessen in Amazon EC2 EC2-beschleunigten Instances zu überwachen.
Es gibt vier Möglichkeiten, [GPU-Metriken](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Agent-NVIDIA-GPU.html) mit Ihrem DLAMI zu konfigurieren:
+ [Konfigurieren Sie minimale GPU-Metriken](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-minimal)
+ [Konfigurieren Sie partielle GPU-Metriken](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-partial)
+ [Konfigurieren Sie alle verfügbaren GPU-Metriken](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-all)
+ [Konfigurieren Sie benutzerdefinierte GPU-Metriken](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-custom)
Informationen zu Updates und Sicherheitspatches finden Sie unter [Sicherheitspatches für den Agenten AWS CloudWatch](#tutorial-gpu-monitoring-gpumon-cloudwatch-agent-security)
### Voraussetzungen
Zu Beginn müssen Sie IAM-Berechtigungen für Amazon EC2 EC2-Instances konfigurieren, an die Ihre Instance Metriken weiterleiten kann. CloudWatch Ausführliche Schritte finden Sie unter [IAM-Rollen und -Benutzer für die Verwendung mit dem Agenten erstellen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/create-iam-roles-for-cloudwatch-agent.html). CloudWatch
### Konfigurieren Sie minimale GPU-Metriken
Konfigurieren Sie minimale GPU-Metriken mithilfe des `dlami-cloudwatch-agent@minimal` `systemd` Dienstes. Dieser Dienst konfiguriert die folgenden Metriken:
+ `utilization_gpu`
+ `utilization_memory`
Sie finden den `systemd` Dienst für minimale vorkonfigurierte GPU-Metriken an der folgenden Stelle:
```
/opt/aws/amazon-cloudwatch-agent/etc/dlami-amazon-cloudwatch-agent-minimal.json
```
Aktivieren und starten Sie den `systemd` Dienst mit den folgenden Befehlen:
```
sudo systemctl enable dlami-cloudwatch-agent@minimal
sudo systemctl start dlami-cloudwatch-agent@minimal
```
### Konfigurieren Sie partielle GPU-Metriken
Konfigurieren Sie partielle GPU-Metriken mithilfe des `dlami-cloudwatch-agent@partial` `systemd` Dienstes. Dieser Dienst konfiguriert die folgenden Metriken:
+ `utilization_gpu`
+ `utilization_memory`
+ `memory_total`
+ `memory_used`
+ `memory_free`
Sie finden den `systemd` Dienst für teilweise vorkonfigurierte GPU-Metriken an der folgenden Stelle:
```
/opt/aws/amazon-cloudwatch-agent/etc/dlami-amazon-cloudwatch-agent-partial.json
```
Aktivieren und starten Sie den `systemd` Dienst mit den folgenden Befehlen:
```
sudo systemctl enable dlami-cloudwatch-agent@partial
sudo systemctl start dlami-cloudwatch-agent@partial
```
### Konfigurieren Sie alle verfügbaren GPU-Metriken
Konfigurieren Sie alle verfügbaren GPU-Metriken mithilfe des `dlami-cloudwatch-agent@all` `systemd` Dienstes. Dieser Dienst konfiguriert die folgenden Metriken:
+ `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`
Sie finden den `systemd` Dienst für alle verfügbaren vorkonfigurierten GPU-Metriken an der folgenden Stelle:
```
/opt/aws/amazon-cloudwatch-agent/etc/dlami-amazon-cloudwatch-agent-all.json
```
Aktivieren und starten Sie den `systemd` Dienst mit den folgenden Befehlen:
```
sudo systemctl enable dlami-cloudwatch-agent@all
sudo systemctl start dlami-cloudwatch-agent@all
```
### Konfigurieren Sie benutzerdefinierte GPU-Metriken
Wenn die vorkonfigurierten Metriken Ihren Anforderungen nicht entsprechen, können Sie eine benutzerdefinierte CloudWatch Agentenkonfigurationsdatei erstellen.
#### Erstellen Sie eine benutzerdefinierte Konfigurationsdatei
Informationen zum Erstellen einer benutzerdefinierten Konfigurationsdatei finden Sie in den detaillierten Schritten unter [Manuelles Erstellen oder Bearbeiten der CloudWatch Agentenkonfigurationsdatei](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Agent-Configuration-File-Details.html).
Gehen Sie für dieses Beispiel davon aus, dass sich die Schemadefinition unter befindet`/opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json`.
#### Konfigurieren Sie Metriken mit Ihrer benutzerdefinierten Datei
Führen Sie den folgenden Befehl aus, um den CloudWatch Agenten entsprechend Ihrer benutzerdefinierten Datei zu konfigurieren:
```
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
```
### Sicherheitspatches für den Agenten AWS CloudWatch
Neu veröffentlichte Versionen DLAMIs sind mit den neuesten verfügbaren AWS CloudWatch Agent-Sicherheitspatches konfiguriert. In den folgenden Abschnitten erfahren Sie, wie Sie Ihr aktuelles DLAMI je nach Betriebssystem Ihrer Wahl mit den neuesten Sicherheitspatches aktualisieren können.
#### Amazon Linux 2
Wird verwendet`yum`, um die neuesten AWS CloudWatch Agenten-Sicherheitspatches für ein Amazon Linux 2-DLAMI zu erhalten.
```
sudo yum update
```
#### Ubuntu
Um die neuesten AWS CloudWatch Sicherheitspatches für ein DLAMI mit Ubuntu zu erhalten, muss der AWS CloudWatch Agent über einen Amazon S3 S3-Download-Link neu installiert werden.
```
wget https://s3.region.amazonaws.com/amazoncloudwatch-agent-region/ubuntu/arm64/latest/amazon-cloudwatch-agent.deb
```
Weitere Informationen zur Installation des AWS CloudWatch Agenten mithilfe von Amazon S3 S3-Download-Links finden Sie unter [Installation und Ausführung des CloudWatch Agenten auf Ihren Servern](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/install-CloudWatch-Agent-commandline-fleet.html).
## Konfigurieren Sie Metriken mit dem vorinstallierten Skript `gpumon.py`
Das Dienstprogramm gpumon.py ist auf Ihrem DLAMI vorinstalliert. Es lässt sich in die Nutzung pro GPU integrieren CloudWatch und unterstützt deren Überwachung: GPU-Speicher, GPU-Temperatur und GPU-Leistung. Das Skript sendet die überwachten Daten regelmäßig an CloudWatch. Sie können die Granularität für die zu sendenden Daten konfigurieren, CloudWatch indem Sie einige Einstellungen im Skript ändern. Bevor Sie das Skript starten, müssen Sie jedoch einrichten, um die Metriken CloudWatch zu empfangen.
**Wie richte ich die GPU-Überwachung ein und führe sie aus CloudWatch**
1. Erstellen Sie einen IAM-Benutzer oder ändern Sie einen vorhandenen Benutzer, um eine Richtlinie für die Veröffentlichung der Metrik festzulegen CloudWatch. Wenn Sie einen neuen Benutzer erstellen, notieren Sie sich die Anmeldeinformationen, da Sie diese im nächsten Schritt benötigen.
Die IAM-Richtlinie, nach der gesucht werden soll, lautet „cloudwatch:“. PutMetricData Die Richtlinie, die hinzugefügt wird, lautet wie folgt:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"cloudwatch:PutMetricData"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
**Tipp**
[Weitere Informationen zum Erstellen eines IAM-Benutzers und zum Hinzufügen von Richtlinien für CloudWatch finden Sie in der Dokumentation. CloudWatch ](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/create-iam-roles-for-cloudwatch-agent.html)
1. Führen Sie auf Ihrem DLAMI [AWS configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html#cli-quick-configuration) aus und geben Sie die IAM-Benutzeranmeldedaten an.
```
$ aws configure
```
1. Möglicherweise müssen Sie einige Änderungen am gpumon-Dienstprogramm vornehmen, bevor Sie es ausführen können. Sie finden das Gpumon-Hilfsprogramm und die README-Datei an dem im folgenden Codeblock definierten Speicherort. Weitere Informationen zum `gpumon.py` Skript finden Sie [im Amazon S3 S3-Speicherort des Skripts.](https://s3.amazonaws.com/aws-bigdata-blog/artifacts/GPUMonitoring/gpumon.py)
```
Folder: ~/tools/GPUCloudWatchMonitor
Files: ~/tools/GPUCloudWatchMonitor/gpumon.py
~/tools/GPUCloudWatchMonitor/README
```
Optionen:
+ Ändern Sie die Region in gpumon.py, wenn sich Ihre Instance NICHT in us-east-1 befindet.
+ Ändern Sie andere Parameter wie den CloudWatch `namespace` oder den Berichtszeitraum mit`store_reso`.
1. Derzeit unterstützt das Skript nur Python 3. Aktivieren Sie die Python-3-Umgebung Ihres bevorzugten Frameworks oder aktivieren Sie die allgemeine Python-3-Umgebung von DLAMI.
```
$ source activate python3
```
1. Führen Sie das gpumon-Dienstprogramm im Hintergrund aus.
```
(python3)$ python gpumon.py &
```
1. Öffnen Sie Ihren Browser mit [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) und wählen Sie dann die Metrik. Sie wird einen Namespace '' haben. DeepLearningTrain
**Tipp**
Sie können den Namespace durch Modifizierung von gpumon.py ändern. Sie können auch das Berichtsintervall durch Anpassung von `store_reso` ändern.
Im Folgenden finden Sie ein CloudWatch Beispieldiagramm, das über einen Lauf von gpumon.py berichtet, der einen Trainingsjob auf der p2.8xlarge-Instance überwacht.
![\[GPU-Überwachung aktiviert CloudWatch\]](http://docs.aws.amazon.com/de_de/dlami/latest/devguide/images/gpumon.png)
Möglicherweise sind diese weiteren Themen zur GPU-Überwachung und -Optimierung für Sie interessant:
+ [Überwachen](tutorial-gpu-monitoring.md)
+ [Überwachen Sie mit GPUs CloudWatch](#tutorial-gpu-monitoring-gpumon)
+ [Optimierung](tutorial-gpu-opt.md)
+ [Vorverarbeitung](tutorial-gpu-opt-preprocessing.md)
+ [Training](tutorial-gpu-opt-training.md)
# Optimierung
Um das Beste aus Ihrem herauszuholen GPUs, können Sie Ihre Datenpipeline optimieren und Ihr Deep-Learning-Netzwerk optimieren. Wie das folgende Diagramm zeigt, nutzt eine „naive“ oder einfache Implementierung eines neuronalen Netzwerks die GPU möglicherweise inkonsistent und nicht mit ihrem vollen Potenzial. Wenn Sie Ihre Vorverarbeitung und das Laden der Daten optimieren, können Sie den Engpass von CPU zu GPU reduzieren. Sie können das neuronale Netzwerk selbst anpassen, indem Sie Hybridisierung (wenn vom Framework unterstützt) verwenden, die Stapelgröße anpassen sowie Aufrufe synchronisieren. Sie können in den meisten Frameworks auch Schulungen mit mehreren Präzisionen verwenden, was dramatische Verbesserungen des Durchsatzes mit sich bringen kann.
Das folgende Diagramm zeigt die kumulativen Leistungssteigerungen bei der Anwendung verschiedener Optimierungen. Ihre Ergebnisse hängen von den verarbeiteten Daten und dem optimierten Netzwerk ab.
![\[Leistungsverbesserungen für GPUs\]](http://docs.aws.amazon.com/de_de/dlami/latest/devguide/images/performance-enhancements.png)
In den folgenden Anleitungen werden Optionen vorgestellt, die mit Ihrem DLAMI funktionieren und Ihnen helfen, die GPU-Leistung zu steigern.
**Topics**
+ [
# Vorverarbeitung
](tutorial-gpu-opt-preprocessing.md)
+ [
# Training
](tutorial-gpu-opt-training.md)
# Vorverarbeitung
Die Vorverarbeitung von Daten durch Umwandlungen oder Erweiterungen ist oft ein CPU-gebundener Prozess, was zu einem Engpass in Ihrer allgemeinen Pipeline führen kann. Frameworks verfügen über integrierte Operatoren für die Abbildverarbeitung, DALI (Data Augmentation Library) zeigt jedoch eine verbesserte Leistung gegenüber den in Frameworks integrierten Optionen.
+ NVIDIA Data Augmentation Library (DALI): DALI übergibt die Datenerweiterung an die GPU. Es ist nicht auf dem DLAMI vorinstalliert, aber Sie können darauf zugreifen, indem Sie es installieren oder einen unterstützten Framework-Container auf Ihrem DLAMI oder einer anderen Amazon Elastic Compute Cloud-Instanz laden. Einzelheiten finden Sie auf der [DALI-Projektseite](https://docs.nvidia.com/deeplearning/sdk/dali-install-guide/index.html) auf der NVIDIA-Website. [Ein Anwendungsbeispiel und zum Herunterladen von Codebeispielen finden Sie im Beispiel Preprocessing Training Performance. SageMaker ](https://github.com/aws-samples/sagemaker-cv-preprocessing-training-performance)
+ nvJPEG: eine GPU-beschleunigte JPEG-Decoder-Bibliothek für C-Programmierer. Sie unterstützt die Decodierung einzelner Abbilder oder Stapel sowie Transformationsoperationen, die für Deep Learning verbreitet sind. nvJPEG ist mit DALI integriert. Alternativ können Sie es von der [nvjpeg-Seite der NVIDIA-Website](https://developer.nvidia.com/nvjpeg) herunterladen und separat verwenden.
Möglicherweise sind diese weiteren Themen zur GPU-Überwachung und -Optimierung für Sie interessant:
+ [Überwachen](tutorial-gpu-monitoring.md)
+ [Überwachen Sie mit GPUs CloudWatch](tutorial-gpu-monitoring-gpumon.md)
+ [Optimierung](tutorial-gpu-opt.md)
+ [Vorverarbeitung](#tutorial-gpu-opt-preprocessing)
+ [Training](tutorial-gpu-opt-training.md)
# Training
Mit Schulungen mit gemischter Präzision können Sie größere Netzwerke mit derselben Speichergröße bereitstellen oder die Speichernutzung gegenüber Ihrem Netzwerk mit einzelner oder doppelter Präzision reduzieren - die Rechenleistung wird dadurch sicher gesteigert. Dazu kommt der Vorteil kleinerer und schnellerer Datenübertragungen, ein wichtiger Faktor für verteilte Schulungen mit mehreren Knoten. Um die Schulung mit gemischter Präzision nutzen zu können, müssen Sie das Data Casting und die Verlustskalierung anpassen. Nachfolgend finden Sie Anleitungen dazu, wie Sie dies für Frameworks tun können, die gemischte Präzisionen unterstützen.
+ [NVIDIA Deep Learning SDK](https://docs.nvidia.com/deeplearning/sdk/mixed-precision-training/) — Dokumente auf der NVIDIA-Website, in denen die Implementierung mit gemischter Genauigkeit für, und beschrieben wird. MXNet PyTorch TensorFlow
**Tipp**
Konsultieren Sie die Website für das von Ihnen gewählte Framework und suchen Sie nach „gemischte Präzision“ oder „fp16“ für die jeweils neuesten Optimierungstechniken. Hier finden Sie einige Anleitungen für gemischte Präzisionen, die möglicherweise nützlich für Sie sind:
[Training mit gemischter Präzision mit TensorFlow (Video)](https://devblogs.nvidia.com/mixed-precision-resnet-50-tensor-cores/) — auf der NVIDIA-Blogseite.
[Training mit gemischter Präzision mit Float16 mit MXNet](https://mxnet.apache.org/api/faq/float16) - ein FAQ-Artikel auf der Website. MXNet
[NVIDIA Apex: ein Tool für einfaches Training mit gemischter Präzision mit PyTorch](https://devblogs.nvidia.com/apex-pytorch-easy-mixed-precision-training/) — einem Blogartikel auf der NVIDIA-Website.
Möglicherweise sind diese weiteren Themen zur GPU-Überwachung und -Optimierung für Sie interessant:
+ [Überwachen](tutorial-gpu-monitoring.md)
+ [Überwachen Sie mit GPUs CloudWatch](tutorial-gpu-monitoring-gpumon.md)
+ [Optimierung](tutorial-gpu-opt.md)
+ [Vorverarbeitung](tutorial-gpu-opt-preprocessing.md)
+ [Training](#tutorial-gpu-opt-training)
# Der AWS Inferentia-Chip mit DLAMI
AWS Inferentia ist ein maßgeschneiderter Chip für maschinelles Lernen, der speziell für leistungsstarke AWS Inferenzvorhersagen entwickelt wurde. Um den Chip zu verwenden, richten Sie eine Amazon Elastic Compute Cloud-Instanz ein und verwenden Sie das AWS Neuron Software Development Kit (SDK), um den Inferentia-Chip aufzurufen. Um Kunden das beste Inferentia-Erlebnis zu bieten, wurde Neuron in das AWS Deep Learning AMIs (DLAMI) integriert.
Die folgenden Themen zeigen Ihnen, wie Sie mit der Verwendung von Inferentia mit dem DLAMI beginnen können.
**Topics**
+ [
# Starten einer DLAMI-Instanz mit Neuron AWS
](tutorial-inferentia-launching.md)
+ [
# Verwendung des DLAMI mit Neuron AWS
](tutorial-inferentia-using.md)
# Starten einer DLAMI-Instanz mit Neuron AWS
Das neueste DLAMI ist sofort mit AWS Inferentia einsatzbereit und wird mit dem AWS Neuron API-Paket geliefert. Informationen zum Starten einer DLAMI-Instanz finden Sie unter [Starten und Konfigurieren einer](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html) DLAMI-Instanz. Nachdem Sie ein DLAMI haben, gehen Sie wie hier beschrieben vor, um sicherzustellen, dass Ihr AWS Inferentia-Chip und Ihre AWS Neuron-Ressourcen aktiv sind.
**Topics**
+ [
## Verifizieren der Instance
](#tutorial-inferentia-launching-verify)
+ [
## Identifizieren von AWS Inferentia-Geräten
](#tutorial-inferentia-launching-identify)
+ [
## Anzeigen des Ressourcenverbrauchs
](#tutorial-inferentia-launching-resource-usage)
+ [
## Verwendung von Neuron Monitor (Neuron-Monitor)
](#tutorial-inferentia-launching-neuron-monitor)
+ [
## Aktualisierung der Neuron-Software
](#tutorial-inferentia-launching-upgrade)
## Verifizieren der Instance
Bevor Sie Ihre Instance verwenden, stellen Sie sicher, dass sie ordnungsgemäß eingerichtet und mit Neuron konfiguriert ist.
## Identifizieren von AWS Inferentia-Geräten
Verwenden Sie den folgenden Befehl, um die Anzahl der Inferentia-Geräte auf Ihrer Instance zu ermitteln:
```
neuron-ls
```
Wenn an Ihre Instance Inferentia-Geräte angeschlossen sind, sieht Ihre Ausgabe in etwa wie folgt aus:
```
+--------+--------+--------+-----------+--------------+
| 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 |
+--------+--------+--------+-----------+--------------+
```
Die bereitgestellte Ausgabe stammt aus einer INF1.6XLarge-Instance und umfasst die folgenden Spalten:
+ NEURON DEVICE: Die logische ID, die dem zugewiesen ist. NeuronDevice Diese ID wird verwendet, wenn mehrere Laufzeiten für die Verwendung verschiedener Laufzeiten konfiguriert werden. NeuronDevices
+ NEURON-KERNE: Die Anzahl der NeuronCores vorhandenen Kerne in der. NeuronDevice
+ NEURONENSPEICHER: Die Menge an DRAM-Speicher im. NeuronDevice
+ ANGESCHLOSSENE GERÄTE: Andere, die NeuronDevices mit dem verbunden sind. NeuronDevice
+ PCI BDF: Die PCI-Bus-Gerätefunktions-ID (BDF) des. NeuronDevice
## Anzeigen des Ressourcenverbrauchs
Zeigen Sie mit dem Befehl nützliche Informationen NeuronCore zur vCPU-Auslastung, zur Speichernutzung, zu geladenen Modellen und Neuron-Anwendungen an`neuron-top`. Wenn Sie `neuron-top` ohne Argumente starten, werden Daten für alle maschinellen Lernanwendungen angezeigt, die dies verwenden. NeuronCores
```
neuron-top
```
Wenn eine Anwendung vier verwendet NeuronCores, sollte die Ausgabe der folgenden Abbildung ähneln:
![\[Die Ausgabe des neuron-top Befehls, wobei Informationen für eine von vier Optionen NeuronCores hervorgehoben sind.\]](http://docs.aws.amazon.com/de_de/dlami/latest/devguide/images/neuron-top-output.png)
[Weitere Informationen zu Ressourcen zur Überwachung und Optimierung neuronaler Inferenzanwendungen finden Sie unter Neuron Tools.](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/index.html)
## Verwendung von Neuron Monitor (Neuron-Monitor)
Neuron Monitor sammelt Metriken aus den Neuron-Laufzeiten, die auf dem System laufen, und streamt die gesammelten Daten im JSON-Format auf stdout. Diese Metriken sind in Metrikgruppen organisiert, die Sie konfigurieren, indem Sie eine Konfigurationsdatei bereitstellen. Weitere Informationen zu Neuron Monitor finden Sie im [Benutzerhandbuch für Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/neuron-monitor-user-guide.html) Monitor.
## Aktualisierung der Neuron-Software
[Informationen zum Aktualisieren der Neuron SDK-Software in DLAMI finden Sie im AWS Neuron Setup Guide.](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-intro/neuron-install-guide.html)
**Nächster Schritt**
[Verwendung des DLAMI mit Neuron AWS](tutorial-inferentia-using.md)
# Verwendung des DLAMI mit Neuron AWS
Ein typischer Arbeitsablauf mit dem AWS Neuron SDK besteht darin, ein zuvor trainiertes Modell für maschinelles Lernen auf einem Kompilierungsserver zu kompilieren. Verteilen Sie anschließend die Artefakte zur Ausführung an die Inf1-Instanzen. AWS Deep Learning AMIs (DLAMI) ist mit allem vorinstalliert, was Sie zum Kompilieren und Ausführen von Inferenzen in einer Inf1-Instanz benötigen, die Inferentia verwendet.
In den folgenden Abschnitten wird beschrieben, wie Sie das DLAMI mit Inferentia verwenden.
**Topics**
+ [
# Verwendung von TensorFlow -Neuron und dem Neuron Compiler AWS
](tutorial-inferentia-tf-neuron.md)
+ [
# Verwenden von AWS Neuron Serving TensorFlow
](tutorial-inferentia-tf-neuron-serving.md)
+ [
# Verwendung von -Neuron MXNet und dem Neuron Compiler AWS
](tutorial-inferentia-mxnet-neuron.md)
+ [
# Verwenden von MXNet -Neuron Model Serving
](tutorial-inferentia-mxnet-neuron-serving.md)
+ [
# Verwenden von PyTorch -Neuron und dem Neuron Compiler AWS
](tutorial-inferentia-pytorch-neuron.md)
# Verwendung von TensorFlow -Neuron und dem Neuron Compiler AWS
Dieses Tutorial zeigt, wie Sie mit dem AWS Neuron-Compiler das Keras ResNet -50-Modell kompilieren und als gespeichertes Modell im Format exportieren. SavedModel Dieses Format ist ein typisches TensorFlow austauschbares Modellformat. Sie lernen außerdem, wie die Inferenz für eine Inf1-Instance mit Beispieldaten ausgeführt wird.
Weitere Informationen zum Neuron SDK finden Sie in der [AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html) SDK-Dokumentation.
**Topics**
+ [
## Voraussetzungen
](#tutorial-inferentia-tf-neuron-prerequisites)
+ [
## Aktivieren der Conda-Umgebung
](#tutorial-inferentia-tf-neuron-activate)
+ [
## Resnet50-Kompilierung
](#tutorial-inferentia-tf-neuron-compilation)
+ [
## ResNet50 Inferenz
](#tutorial-inferentia-tf-neuron-inference)
## Voraussetzungen
Bevor Sie dieses Tutorial verwenden, müssen Sie die Einrichtungsschritte in [Starten einer DLAMI-Instanz mit Neuron AWS](tutorial-inferentia-launching.md) abgeschlossen haben. Sie sollten auch mit Deep Learning und der Verwendung des DLAMI vertraut sein.
## Aktivieren der Conda-Umgebung
Aktivieren Sie die TensorFlow -Neuron Conda-Umgebung mit dem folgenden Befehl:
```
source activate aws_neuron_tensorflow_p36
```
Führen Sie den folgenden Befehl aus, um die aktuelle Conda-Umgebung zu verlassen:
```
source deactivate
```
## Resnet50-Kompilierung
Erstellen Sie das Python-Skript **tensorflow\$1compile\$1resnet50.py** mit folgendem Inhalt. Dieses Python-Skript kompiliert das Keras ResNet 50-Modell und exportiert es als gespeichertes Modell.
```
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')
```
Kompilieren Sie das Modell mit dem folgenden Befehl:
```
python tensorflow_compile_resnet50.py
```
Der Kompilierungsprozess dauert einige Minuten. Nach Abschluss sollte die Ausgabe so aussehen:
```
...
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
...
```
Nach der Kompilierung wird das gespeicherte Modell gezippt: **ws\$1resnet50/resnet50\$1neuron.zip**. Entzippen Sie das Modell und laden Sie das Beispielbild mit den folgenden Befehlen herunter:
```
unzip ws_resnet50/resnet50_neuron.zip -d .
curl -O https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg
```
## ResNet50 Inferenz
Erstellen Sie das Python-Skript **tensorflow\$1infer\$1resnet50.py** mit dem folgenden Inhalt. Dieses Skript führt die Inferenz für das heruntergeladene Modell unter Verwendung eines zuvor kompilierten Inferenzmodells aus.
```
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])
```
Führen Sie die Inferenz für das Modell mit dem folgenden Befehl aus:
```
python tensorflow_infer_resnet50.py
```
Die Ausgabe sollte folgendermaßen aussehen:
```
...
[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]
```
**Nächster Schritt**
[Verwenden von AWS Neuron Serving TensorFlow](tutorial-inferentia-tf-neuron-serving.md)
# Verwenden von AWS Neuron Serving TensorFlow
Dieses Tutorial zeigt, wie Sie ein Diagramm erstellen und einen AWS Neuron-Kompilierungsschritt hinzufügen, bevor Sie das gespeicherte Modell zur Verwendung mit TensorFlow Serving exportieren. TensorFlow Serving ist ein Serversystem, mit dem Sie Inferenzen in einem Netzwerk skalieren können. Neuron TensorFlow Serving verwendet dieselbe API wie normales Serving. TensorFlow Der einzige Unterschied besteht darin, dass ein gespeichertes Modell für AWS Inferentia kompiliert werden muss und der Einstiegspunkt eine andere Binärdatei mit dem Namen ist. `tensorflow_model_server_neuron` Die Binärdatei befindet sich im DLAMI `/usr/local/bin/tensorflow_model_server_neuron` und ist dort vorinstalliert.
[Weitere Informationen zum Neuron SDK finden Sie in der Neuron SDK-Dokumentation.AWS](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html)
**Topics**
+ [
## Voraussetzungen
](#tutorial-inferentia-tf-neuron--serving-prerequisites)
+ [
## Aktivieren der Conda-Umgebung
](#tutorial-inferentia-tf-neuron-serving-activate)
+ [
## Kompilieren und Exportieren des gespeicherten Modells
](#tutorial-inferentia-tf-neuron-serving-compile)
+ [
## Bereitstellen des gespeicherten Modells
](#tutorial-inferentia-tf-neuron-serving-serving)
+ [
## Generieren von Inferenzanforderungen an den Modell-Server
](#tutorial-inferentia-tf-neuron-serving-inference)
## Voraussetzungen
Bevor Sie dieses Tutorial verwenden, müssen Sie die Einrichtungsschritte in [Starten einer DLAMI-Instanz mit Neuron AWS](tutorial-inferentia-launching.md) abgeschlossen haben. Sie sollten auch mit Deep Learning und der Verwendung des DLAMI vertraut sein.
## Aktivieren der Conda-Umgebung
Aktivieren Sie die TensorFlow -Neuron Conda-Umgebung mit dem folgenden Befehl:
```
source activate aws_neuron_tensorflow_p36
```
Wenn Sie die aktuelle Conda-Umgebung verlassen müssen, führen Sie Folgendes aus:
```
source deactivate
```
## Kompilieren und Exportieren des gespeicherten Modells
Erstellen Sie ein Python-Skript namens `tensorflow-model-server-compile.py` mit dem folgenden Inhalt. Dieses Skript erstellt ein Diagramm und kompiliert es mit Neuron. Anschließend wird das kompilierte Diagramm als gespeichertes Modell exportiert.
```
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)
```
Kompilieren Sie das Modell mit dem folgenden Befehl:
```
python tensorflow-model-server-compile.py
```
Die Ausgabe sollte folgendermaßen aussehen:
```
...
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
```
## Bereitstellen des gespeicherten Modells
Nachdem das Modell kompiliert wurde, können Sie den folgenden Befehl verwenden, um das gespeicherte Modell mit der Binärdatei tensorflow\$1model\$1server\$1neuron bereitzustellen:
```
tensorflow_model_server_neuron --model_name=resnet50_inf1 \
--model_base_path=$HOME/resnet50_inf1/ --port=8500 &
```
Die Ausgabe sollte wie folgt aussehen. Das kompilierte Modell wird vom Server im DRAM des Inferentia-Geräts gespeichert, um die Inferenz vorzubereiten.
```
...
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 ...
```
## Generieren von Inferenzanforderungen an den Modell-Server
Erstellen Sie das Python-Skript namens `tensorflow-model-server-infer.py` mit folgendem Inhalt. Dieses Skript führt die Inferenz über gRPC (Service-Framework) aus.
```
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))
```
Führen Sie die Inferenz für das Modell aus, indem Sie gRPC mit dem folgenden Befehl verwenden:
```
python tensorflow-model-server-infer.py
```
Die Ausgabe sollte folgendermaßen aussehen:
```
[[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]]
```
# Verwendung von -Neuron MXNet und dem Neuron Compiler AWS
Die MXNet -Neuron-Kompilierungs-API bietet eine Methode zum Kompilieren eines Modelldiagramms, das Sie auf einem Inferentia-Gerät ausführen können. AWS
In diesem Beispiel verwenden Sie die API, um ein ResNet -50-Modell zu kompilieren und damit Inferenzen auszuführen.
[Weitere Informationen zum Neuron SDK finden Sie in der Neuron SDK-Dokumentation AWS .](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html)
**Topics**
+ [
## Voraussetzungen
](#tutorial-inferentia-mxnet-neuron-prerequisites)
+ [
## Aktivieren der Conda-Umgebung
](#tutorial-inferentia-mxnet-neuron-activate)
+ [
## Resnet50-Kompilierung
](#tutorial-inferentia-mxnet-neuron-compilation)
+ [
## ResNet50 Folgerung
](#tutorial-inferentia-mxnet-neuron-inference)
## Voraussetzungen
Bevor Sie dieses Tutorial verwenden, müssen Sie die Einrichtungsschritte in [Starten einer DLAMI-Instanz mit Neuron AWS](tutorial-inferentia-launching.md) abgeschlossen haben. Sie sollten auch mit Deep Learning und der Verwendung des DLAMI vertraut sein.
## Aktivieren der Conda-Umgebung
Aktivieren Sie die MXNet -Neuron Conda-Umgebung mit dem folgenden Befehl:
```
source activate aws_neuron_mxnet_p36
```
Führen Sie Folgendes aus, um die aktuelle Conda-Umgebung zu verlassen:
```
source deactivate
```
## Resnet50-Kompilierung
Erstellen Sie das Python-Skript namens **mxnet\$1compile\$1resnet50.py** mit folgendem Inhalt. Dieses Skript verwendet die Python-API zur Kompilierung von MXNet -Neuron, um ein ResNet -50-Modell zu kompilieren.
```
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)
```
Kompilieren Sie das Modell mit dem folgenden Befehl:
```
python mxnet_compile_resnet50.py
```
Die Kompilierung dauert einige Minuten. Wenn die Kompilierung abgeschlossen ist, befinden sich die folgenden Dateien in Ihrem aktuellen Verzeichnis:
```
resnet-50-0000.params
resnet-50-symbol.json
compiled_resnet50-0000.params
compiled_resnet50-symbol.json
```
## ResNet50 Folgerung
Erstellen Sie das Python-Skript namens **mxnet\$1infer\$1resnet50.py** mit folgendem Inhalt. Mit diesem Skript wird ein Beispiel-Image heruntergeladen, das dazu verwendet wird, um die Inferenz für das kompilierte Modell auszuführen.
```
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]))
```
Führen Sie die Inferenz mit folgendem Befehl mit dem kompilierten Modell aus:
```
python mxnet_infer_resnet50.py
```
Die Ausgabe sollte folgendermaßen aussehen:
```
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
```
**Nächster Schritt**
[Verwenden von MXNet -Neuron Model Serving](tutorial-inferentia-mxnet-neuron-serving.md)
# Verwenden von MXNet -Neuron Model Serving
In diesem Tutorial lernen Sie, ein vortrainiertes MXNet Modell zu verwenden, um Bildklassifizierung in Echtzeit mit Multi Model Server (MMS) durchzuführen. MMS ist ein flexibles easy-to-use Tool zur Bereitstellung von Deep-Learning-Modellen, die mit einem beliebigen Framework für maschinelles Lernen oder Deep Learning trainiert wurden. Dieses Tutorial beinhaltet einen Kompilierungsschritt mit AWS Neuron und eine Implementierung von MMS mit. MXNet
[Weitere Informationen zum Neuron SDK finden Sie in der Neuron SDK-Dokumentation AWS .](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html)
**Topics**
+ [
## Voraussetzungen
](#tutorial-inferentia-mxnet-neuron-serving-prerequisites)
+ [
## Aktivieren der Conda-Umgebung
](#tutorial-inferentia-mxnet-neuron-serving-activate)
+ [
## Herunterladen des Beispielcodes
](#tutorial-inferentia-mxnet-neuron-serving-download)
+ [
## Kompilieren des Modells
](#tutorial-inferentia-mxnet-neuron-serving-compile)
+ [
## Ausführen der Inferenz
](#tutorial-inferentia-mxnet-neuron-serving-inference)
## Voraussetzungen
Bevor Sie dieses Tutorial verwenden, müssen Sie die Einrichtungsschritte in [Starten einer DLAMI-Instanz mit Neuron AWS](tutorial-inferentia-launching.md) abgeschlossen haben. Sie sollten auch mit Deep Learning und der Verwendung des DLAMI vertraut sein.
## Aktivieren der Conda-Umgebung
Aktivieren Sie die MXNet -Neuron Conda-Umgebung mit dem folgenden Befehl:
```
source activate aws_neuron_mxnet_p36
```
Führen Sie Folgendes aus, um die aktuelle Conda-Umgebung zu verlassen:
```
source deactivate
```
## Herunterladen des Beispielcodes
Um dieses Beispiel auszuführen, laden Sie den Beispielcode mit den folgenden Befehlen herunter:
```
git clone https://github.com/awslabs/multi-model-server
cd multi-model-server/examples/mxnet_vision
```
## Kompilieren des Modells
Erstellen Sie das Python-Skript namens `multi-model-server-compile.py` mit folgendem Inhalt. Dieses Skript kompiliert das Modell ResNet 50 für das Inferentia-Geräteziel.
```
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)
```
Verwenden Sie den folgenden Befehl, um das Modell zu kompilieren:
```
python multi-model-server-compile.py
```
Die Ausgabe sollte folgendermaßen aussehen:
```
...
[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!
```
Erstellen Sie eine Datei namens `signature.json` mit dem folgenden Inhalt, um den Eingabenamen und das Shape zu konfigurieren:
```
{
"inputs": [
{
"data_name": "data",
"data_shape": [
1,
3,
224,
224
]
}
]
}
```
Sie können die Datei `synset.txt` mit dem folgenden Befehl herunterladen. Diese Datei ist eine Liste mit Namen für ImageNet Vorhersageklassen.
```
curl -O https://s3.amazonaws.com/model-server/model_archive_1.0/examples/squeezenet_v1.1/synset.txt
```
Erstellen Sie eine benutzerdefinierte Service-Klasse unter Verwendung der Vorlage im Ordner `model_server_template`. Kopieren Sie die Vorlage mit dem folgenden Befehl in das aktuelle Arbeitsverzeichnis:
```
cp -r ../model_service_template/* .
```
Bearbeiten Sie das Modul `mxnet_model_service.py`, indem Sie den Kontext `mx.cpu()` wie folgt durch den Kontext `mx.neuron()` ersetzen. Sie müssen auch die überflüssige Datenkopie für auskommentieren`model_input`, weil MXNet -Neuron das NDArray und Gluon nicht unterstützt. 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]
```
Erstellen Sie mit den folgenden Befehlen ein Paket des Modells mit model-archiver:
```
cd ~/multi-model-server/examples
model-archiver --force --model-name resnet-50_compiled --model-path mxnet_vision --handler mxnet_vision_service:handle
```
## Ausführen der Inferenz
Starten Sie den Multi Model Server und laden Sie das Modell, das die RESTful API verwendet, mithilfe der folgenden Befehle. Stellen Sie sicher, dass **neuron-rtd** mit den Standardeinstellungen ausgeführt wird.
```
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
```
Führen Sie die Inferenz mit den folgenden Befehlen mit einem Beispielbild aus:
```
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
```
Die Ausgabe sollte folgendermaßen aussehen:
```
[
{
"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"
}
]
```
Um nach dem Test zu bereinigen, geben Sie über die RESTful API einen Löschbefehl aus und beenden Sie den Modellserver mit den folgenden Befehlen:
```
curl -X DELETE http://127.0.0.1:8081/models/resnet-50_compiled
multi-model-server --stop
```
Die Ausgabe sollte folgendermaßen aussehen:
```
{
"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
```
# Verwenden von PyTorch -Neuron und dem Neuron Compiler AWS
Die PyTorch -Neuron-Kompilierungs-API bietet eine Methode zum Kompilieren eines Modelldiagramms, das Sie auf einem Inferentia-Gerät ausführen können. AWS
Ein trainiertes Modell muss für ein Inferentia-Ziel kompiliert werden, bevor es auf Inf1-Instances bereitgestellt werden kann. Das folgende Tutorial kompiliert das Torchvision ResNet 50-Modell und exportiert es als gespeichertes Modul. TorchScript Dieses Modell wird dann zum Ausführen der Inferenz verwendet.
Der Einfachheit halber wird in diesem Tutorial eine Inf1-Instance sowohl für die Kompilierung als auch für die Inferenz verwendet. In der Praxis können Sie Ihr Modell mit einem anderen Instance-Typ kompilieren, z. B. mit der c5-Instance-Familie. Anschließend müssen Sie das kompilierte Modell auf dem Inf1-Inferenzserver bereitstellen. Weitere Informationen finden Sie in der [AWS Neuron PyTorch ](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/pytorch-neuron/index.html) SDK-Dokumentation.
**Topics**
+ [
## Voraussetzungen
](#tutorial-inferentia-pytorch-neuron-prerequisites)
+ [
## Aktivieren der Conda-Umgebung
](#tutorial-inferentia-pytorch-neuron-activate)
+ [
## Resnet50-Kompilierung
](#tutorial-inferentia-pytorch-neuron-compilation)
+ [
## ResNet50 Inferenz
](#tutorial-inferentia-pytorch-neuron-inference)
## Voraussetzungen
Bevor Sie dieses Tutorial verwenden, müssen Sie die Einrichtungsschritte in [Starten einer DLAMI-Instanz mit Neuron AWS](tutorial-inferentia-launching.md) abgeschlossen haben. Sie sollten auch mit Deep Learning und der Verwendung des DLAMI vertraut sein.
## Aktivieren der Conda-Umgebung
Aktivieren Sie die PyTorch -Neuron Conda-Umgebung mit dem folgenden Befehl:
```
source activate aws_neuron_pytorch_p36
```
Führen Sie Folgendes aus, um die aktuelle Conda-Umgebung zu verlassen:
```
source deactivate
```
## Resnet50-Kompilierung
Erstellen Sie das Python-Skript namens **pytorch\$1trace\$1resnet50.py** mit folgendem Inhalt. Dieses Skript verwendet die Python-API zur Kompilierung von PyTorch -Neuron, um ein ResNet -50-Modell zu kompilieren.
**Anmerkung**
Es besteht eine Abhängigkeit zwischen den Versionen von Torchvision und dem Torch-Paket, die Sie beim Kompilieren von Torchvision-Modellen beachten sollten. Diese Abhängigkeitsregeln können über Pip verwaltet werden. Torchvision==0.6.1 entspricht der Version Torch==1.5.1, während Torchvision==0.8.2 der Version Torch==1.7.1 entspricht.
```
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")
```
Führen Sie das Kompilierungsskript aus.
```
python pytorch_trace_resnet50.py
```
Die Kompilierung wird ein paar Minuten dauern. Nach Abschluss der Kompilierung wird das kompilierte Modell wie `resnet50_neuron.pt` im lokalen Verzeichnis gespeichert.
## ResNet50 Inferenz
Erstellen Sie das Python-Skript namens **pytorch\$1infer\$1resnet50.py** mit folgendem Inhalt. Mit diesem Skript wird ein Beispiel-Image heruntergeladen, das dazu verwendet wird, um die Inferenz für das kompilierte Modell auszuführen.
```
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) )
```
Führen Sie die Inferenz mit folgendem Befehl mit dem kompilierten Modell aus:
```
python pytorch_infer_resnet50.py
```
Die Ausgabe sollte folgendermaßen aussehen:
```
Top 5 labels:
['tiger', 'lynx', 'tiger_cat', 'Egyptian_cat', 'tabby']
```
# Das ARM64 DLAMI
AWS ARM64 GPUs DLAMIs sind so konzipiert, dass sie eine hohe Leistung und Kosteneffizienz für Deep-Learning-Workloads bieten. Insbesondere der G5G-Instanztyp verfügt über den ARM64-basierten [AWS Graviton2-Prozessor](https://aws.amazon.com/ec2/graviton/), der von Grund auf neu entwickelt AWS und dafür optimiert wurde, wie Kunden ihre Workloads in der Cloud ausführen. AWS ARM64 DLAMIs Die GPU ist mit Docker, NVIDIA Docker, NVIDIA Driver, CUDA, cuDNN, NCCL sowie beliebten Frameworks für maschinelles Lernen wie und vorkonfiguriert. TensorFlow PyTorch
Mit dem Instance-Typ G5G können Sie die Preis- und Leistungsvorteile von Graviton2 nutzen, um GPU-beschleunigte Deep-Learning-Modelle zu deutlich geringeren Kosten im Vergleich zu x86-basierten Instances mit GPU-Beschleunigung bereitzustellen.
## Wählen Sie ein ARM64 DLAMI
Starten Sie eine [G5g-Instance](https://aws.amazon.com/ec2/instance-types/g5g/) mit dem ARM64 DLAMI Ihrer Wahl.
step-by-stepAnweisungen zum Starten eines DLAMI finden Sie unter [Starten und Konfigurieren eines](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html) DLAMI.
Eine Liste der neuesten ARM64 DLAMIs Versionen finden Sie in den [Versionshinweisen für DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/appendix-ami-release-notes.html).
## Erste Schritte
Die folgenden Themen zeigen Ihnen, wie Sie mit der Verwendung des ARM64 DLAMI beginnen können.
**Topics**
+ [
## Wählen Sie ein ARM64 DLAMI
](#tutorial-arm64-select-dlami)
+ [
## Erste Schritte
](#tutorial-arm64-get-started)
+ [
# Verwenden der ARM64 GPU PyTorch DLAMI
](tutorial-arm64-pytorch.md)
# Verwenden der ARM64 GPU PyTorch DLAMI
Der AWS Deep Learning AMIs ist sofort einsatzbereit mit dem Arm64-Prozessor und ist optimiert für. GPUs PyTorch Die ARM64 GPU PyTorch DLAMI umfasst eine Python-Umgebung, die mit [PyTorch[TorchVision](https://pytorch.org/vision/stable/index.html)](https://aws.amazon.com/pytorch), und [TorchServe](https://pytorch.org/serve/)für Deep-Learning-Training und Inferenz-Anwendungsfälle vorkonfiguriert ist.
**Topics**
+ [
## PyTorch Python-Umgebung überprüfen
](#tutorial-arm64-pytorch-environment)
+ [
## Trainingsbeispiel ausführen mit PyTorch
](#tutorial-arm64-pytorch-training)
+ [
## Führen Sie ein Inferenzbeispiel aus mit PyTorch
](#tutorial-arm64-pytorch-inference)
## PyTorch Python-Umgebung überprüfen
Connect zu Ihrer G5g-Instance her und aktivieren Sie die Conda-Basisumgebung mit dem folgenden Befehl:
```
source activate base
```
Ihre Eingabeaufforderung sollte darauf hinweisen, dass Sie in der Conda-Basisumgebung arbeiten, die PyTorch TorchVision, und andere Bibliotheken enthält.
```
(base) $
```
Überprüfen Sie die Standard-Werkzeugpfade der PyTorch Umgebung:
```
(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)
```
## Trainingsbeispiel ausführen mit PyTorch
Führen Sie einen Beispiel-MNIST-Trainingsjob aus:
```
git clone https://github.com/pytorch/examples.git
cd examples/mnist
python main.py
```
Ihre Ausgabe sollte wie folgt aussehen:
```
...
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%)
```
## Führen Sie ein Inferenzbeispiel aus mit PyTorch
Verwenden Sie die folgenden Befehle, um ein vortrainiertes densenet161-Modell herunterzuladen und die Inferenz auszuführen mit: 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
```
Ihre Ausgabe sollte wie folgt aussehen:
```
{
"tiger_cat": 0.4693363308906555,
"tabby": 0.4633873701095581,
"Egyptian_cat": 0.06456123292446136,
"lynx": 0.0012828150065615773,
"plastic_bag": 0.00023322898778133094
}
```
Verwenden Sie die folgenden Befehle, um die Registrierung des densenet161-Modells aufzuheben und den Server anzuhalten:
```
curl -X DELETE http://localhost:8081/models/densenet161/1.0
torchserve --stop
```
Ihre Ausgabe sollte wie folgt aussehen:
```
{
"status": "Model \"densenet161\" unregistered"
}
TorchServe has stopped.
```
# Inferenz
Dieser Abschnitt enthält Tutorials zum Ausführen von Inferenzen mit den Frameworks und Tools des DLAMI.
## Inferenz-Tools
+ [TensorFlow Servieren](tutorial-tfserving.md)
# Modellbereitstellung
Im Folgenden sind die Modell-Serving-Optionen aufgeführt, die auf dem Deep Learning-AMI mit Conda installiert sind. Klicken Sie auf eine der Optionen, um zu erfahren, wie Sie diese verwenden.
**Topics**
+ [
# TensorFlow Servieren
](tutorial-tfserving.md)
+ [
# TorchServe
](tutorial-torchserve.md)
# TensorFlow Servieren
[TensorFlow Serving](https://www.tensorflow.org/tfx/guide/serving) ist ein flexibles, leistungsstarkes Serviersystem für Modelle des maschinellen Lernens.
Das `tensorflow-serving-api` ist mit einem einzigen Framework DLAMI vorinstalliert. Um Tensorflow Serving zu verwenden, aktivieren Sie zunächst die Umgebung. TensorFlow
```
$ source /opt/tensorflow/bin/activate
```
Verwenden Sie anschließend den von Ihnen bevorzugten Texteditor, um ein Skript mit folgendem Inhalt zu erstellen. Geben Sie ihr den Namen `test_train_mnist.py`. Auf dieses Skript wird im [TensorFlow Tutorial](https://github.com/tensorflow/docs/blob/master/site/en/tutorials/quickstart/beginner.ipynb) verwiesen, in dem ein maschinelles Lernmodell für neuronale Netzwerke trainiert und evaluiert wird, das Bilder klassifiziert.
```
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)
```
Führen Sie nun das Skript aus und geben Sie Server-Standort sowie Port und Dateinamen des Husky-Bilds als Parameter weiter.
```
$ /opt/tensorflow/bin/python3 test_train_mnist.py
```
Haben Sie Geduld, da dieses Skript kann eine Weile brauchen kann, bevor es etwas ausgibt. Wenn das Training abgeschlossen ist, sollten Sie Folgendes sehen:
```
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
```
## Weitere Funktionen und Beispiele
Wenn Sie mehr über TensorFlow Serving erfahren möchten, besuchen Sie die [TensorFlow Website](https://www.tensorflow.org/serving/).
# TorchServe
TorchServe ist ein flexibles Tool zur Bereitstellung von Deep-Learning-Modellen, aus denen exportiert wurden PyTorch. TorchServe ist mit dem Deep Learning AMI mit Conda vorinstalliert.
Weitere Informationen zur Verwendung TorchServe finden Sie in der Dokumentation zu [Model Server](https://github.com/pytorch/serve/blob/master/docs/README.md). PyTorch
**Topics**
## Stellen Sie ein Bildklassifizierungsmodell bereit auf TorchServe
Dieses Tutorial zeigt, wie Sie ein Bildklassifizierungsmodell mit bereitstellen TorchServe. Es verwendet ein DenseNet -161-Modell, das von bereitgestellt wird PyTorch. Sobald der Server läuft, wartet er auf Vorhersageanfragen. Wenn Sie ein Bild hochladen, in diesem Fall das Bild eines Kätzchens, gibt der Server eine Vorhersage der fünf am besten passenden Klassen aus den Klassen zurück, für die das Modell trainiert wurde.
**Um ein Beispiel für ein Bildklassifizierungsmodell bereitzustellen TorchServe**
1. Stellen Sie eine Connect zu einer Amazon Elastic Compute Cloud (Amazon EC2) -Instance mit Deep Learning AMI mit Conda v34 oder höher her.
1. Aktivieren Sie die Umgebung. `pytorch_p310`
```
source activate pytorch_p310
```
1. Klonen Sie das TorchServe Repository und erstellen Sie dann ein Verzeichnis zum Speichern Ihrer Modelle.
```
git clone https://github.com/pytorch/serve.git
mkdir model_store
```
1. Archivieren Sie das Modell mit dem Modellarchiver. Der `extra-files` Parameter verwendet eine Datei aus dem `TorchServe` Repo. Aktualisieren Sie daher den Pfad, falls erforderlich. Weitere Informationen zum Modellarchiver finden Sie unter [Torch Model](https://github.com/pytorch/serve/blob/master/model-archiver/README.md) 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. Ausführen TorchServe , um einen Endpunkt zu starten. Durch das `> /dev/null` Hinzufügen wird die Protokollausgabe gestoppt.
```
torchserve --start --ncs --model-store model_store --models densenet161.mar > /dev/null
```
1. Laden Sie ein Bild eines Kätzchens herunter und senden Sie es an den TorchServe Predict-Endpunkt:
```
curl -O https://s3.amazonaws.com/model-server/inputs/kitten.jpg
curl http://127.0.0.1:8080/predictions/densenet161 -T kitten.jpg
```
Der Vorhersage-Endpunkt gibt eine Vorhersage in JSON zurück, die den folgenden fünf wichtigsten Vorhersagen ähnelt, wobei das Bild mit einer Wahrscheinlichkeit von 47% eine ägyptische Katze enthält, gefolgt von einer Wahrscheinlichkeit von 46%, dass es sich um eine Tabbykatze handelt.
```
{
"tiger_cat": 0.46933576464653015,
"tabby": 0.463387668132782,
"Egyptian_cat": 0.0645613968372345,
"lynx": 0.0012828196631744504,
"plastic_bag": 0.00023323058849200606
}
```
1. Wenn Sie mit dem Testen fertig sind, beenden Sie den Server:
```
torchserve --stop
```
**Andere Beispiele**
TorchServe hat eine Vielzahl von Beispielen, die Sie auf Ihrer DLAMI-Instanz ausführen können. Sie können sie auf [der Seite mit den Beispielen für das TorchServe Projekt-Repository](https://github.com/pytorch/serve/tree/master/examples) einsehen.
**Mehr Informationen**
Weitere TorchServe Dokumentation, einschließlich der Einrichtung TorchServe mit Docker und der neuesten TorchServe Funktionen, finden Sie auf [ GitHubder TorchServe Projektseite](https://github.com/pytorch/serve) unter.