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.
# Stellen Sie Modelle bereit mit TorchServe
TorchServe ist der empfohlene Modellserver für PyTorch, der im AWS PyTorch Deep Learning Container (DLC) vorinstalliert ist. Dieses leistungsstarke Tool bietet Kunden eine konsistente und benutzerfreundliche Erfahrung und bietet eine hohe Leistung bei der Bereitstellung mehrerer PyTorch Modelle in verschiedenen AWS Instanzen, einschließlich CPU, GPU, Neuron und Graviton, unabhängig von der Modellgröße oder Verteilung.
TorchServe unterstützt eine Vielzahl fortschrittlicher Funktionen, darunter dynamisches Batching, Microbatching, A/B Modelltests, Streaming, Torch XLA, TensorRT, ONNX und IPEX. Darüber hinaus integriert es die Lösung für große Modelle, PiPPy, nahtlos und ermöglicht PyTorch so die effiziente Handhabung großer Modelle. Darüber hinaus TorchServe erweitert es die Unterstützung auf beliebte Open-Source-Bibliotheken wie Accelerate DeepSpeed, Fast Transformers und mehr und erweitert so seine Funktionen noch weiter. Mit TorchServe können AWS Benutzer ihre PyTorch Modelle vertrauensvoll einsetzen und bereitstellen und dabei die Vorteile der Vielseitigkeit und optimierten Leistung für verschiedene Hardwarekonfigurationen und Modelltypen nutzen. Ausführlichere Informationen finden Sie in der [PyTorchDokumentation](https://pytorch.org/serve/) und [TorchServeauf GitHub](https://github.com/pytorch/serve).
In der folgenden Tabelle sind die AWS PyTorch DLCs unterstützten von aufgeführt TorchServe.
| Instance-Typ | SageMaker AI PyTorch DLC-Link |
| --- | --- |
| CPU und GPU | [SageMaker KI-Container PyTorch ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) |
| Neuron | [PyTorch Behälter für Neuronen](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) |
| Graviton | [SageMaker PyTorch KI-Graviton-Behälter](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-graviton-containers-sm-support-only) |
In den folgenden Abschnitten wird die Einrichtung zum Erstellen und Testen PyTorch DLCs auf Amazon SageMaker AI beschrieben.
## Erste Schritte
Stellen Sie vor Beginn sicher, dass die folgenden Voraussetzungen erfüllt sind:
1. Stellen Sie sicher, dass Sie Zugriff auf ein AWS Konto haben. Richten Sie Ihre Umgebung so ein, dass sie entweder über einen AWS IAM-Benutzer oder eine IAM-Rolle auf Ihr Konto zugreifen AWS CLI können. Wir empfehlen die Verwendung einer IAM-Rolle. Zu Testzwecken in Ihrem persönlichen Konto können Sie der IAM-Rolle die folgenden Richtlinien für verwaltete Berechtigungen hinzufügen:
+ [AmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess)
+ [AmazonEC2FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2FullAccess)
+ [AWS ServiceRoleForAmazonEKSNodegroup](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AWSServiceRoleForAmazonEKSNodegroup)
+ [AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)
+ [Amazon S3 FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonS3FullAccess)
1. Konfigurieren Sie Ihre Abhängigkeiten lokal wie im folgenden Beispiel gezeigt:
```
from datetime import datetime
import os
import json
import logging
import time
# External Dependencies:
import boto3
from botocore.exceptions import ClientError
import sagemaker
sess = boto3.Session()
sm = sess.client("sagemaker")
region = sess.region_name
account = boto3.client("sts").get_caller_identity().get("Account")
smsess = sagemaker.Session(boto_session=sess)
role = sagemaker.get_execution_role()
# Configuration:
bucket_name = smsess.default_bucket()
prefix = "torchserve"
output_path = f"s3://{bucket_name}/{prefix}/models"
print(f"account={account}, region={region}, role={role}")
```
1. Rufen Sie das PyTorch DLC-Image ab, wie im folgenden Beispiel gezeigt.
SageMaker PyTorch AI-DLC-Images sind in allen AWS Regionen verfügbar. Weitere Informationen finden Sie in der [Liste der DLC-Container-Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only).
```
baseimage = sagemaker.image_uris.retrieve(
framework="pytorch",
region="",
py_version="py310",
image_scope="inference",
version="2.0.1",
instance_type="ml.g4dn.16xlarge",
)
```
1. Einen lokalen Workspace erstellen.
```
mkdir -p workspace/
```
## Hinzufügen eines Pakets
In den folgenden Abschnitten wird beschrieben, wie Sie Ihrem PyTorch DLC-Image Pakete hinzufügen und vorinstallieren.
**BYOC-Anwendungsfälle**
In den folgenden Schritten wird beschrieben, wie Sie Ihrem PyTorch DLC-Image ein Paket hinzufügen. Weitere Informationen zum Anpassen Ihres Containers finden Sie unter [Benutzerdefinierte Images für AWS Deep Learning Containers erstellen](https://github.com/aws/deep-learning-containers/blob/master/custom_images.md).
1. Angenommen, Sie möchten dem PyTorch DLC-Docker-Image ein Paket hinzufügen. Erstellen Sie ein Dockerfile unter dem `docker` Verzeichnis, wie im folgenden Beispiel gezeigt:
```
mkdir -p workspace/docker
cat workspace/docker/Dockerfile
ARG BASE_IMAGE
FROM $BASE_IMAGE
#Install any additional libraries
RUN pip install transformers==4.28.1
```
1. Erstellen und veröffentlichen Sie das benutzerdefinierte Docker-Image mithilfe des folgenden Skripts [build\$1and\$1push.sh](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/workspace/docker/build_and_push.sh).
```
# Download script build_and_push.sh to workspace/docker
ls workspace/docker
build_and_push.sh Dockerfile
# Build and publish your docker image
reponame = "torchserve"
versiontag = "demo-0.1"
./build_and_push.sh {reponame} {versiontag} {baseimage} {region} {account}
```
**SageMaker Anwendungsfälle für KI-Vorinstallationen**
Das folgende Beispiel zeigt Ihnen, wie Sie ein Paket in Ihrem PyTorch DLC-Container vorinstallieren. Sie müssen lokal im Verzeichnis `workspace/code` eine `requirements.txt` Datei erstellen.
```
mkdir -p workspace/code
cat workspace/code/requirements.txt
transformers==4.28.1
```
## Modellartefakte erstellen TorchServe
Im folgenden Beispiel verwenden wir das vortrainierte [ MNIST-Modell](https://github.com/pytorch/serve/tree/master/examples/image_classifier/mnist). Wir erstellen ein Verzeichnis`workspace/mnist`, implementieren [mnist\$1handler.py](https://github.com/pytorch/serve/blob/master/examples/image_classifier/mnist/mnist_handler.py), indem wir den [TorchServe benutzerdefinierten Serviceanweisungen](https://github.com/pytorch/serve/blob/master/docs/custom_service.md#custom-service) folgen, und [konfigurieren die Modellparameter](https://github.com/pytorch/serve/tree/master/model-archiver#config-file) (wie Batchgröße und Worker) in [model-config.yaml](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/workspace/lama/model-config.yaml). Anschließend verwenden wir das TorchServe Tool, `torch-model-archiver` um die Modellartefakte zu erstellen und auf Amazon S3 hochzuladen.
1. Konfigurieren Sie die Modellparameter in `model-config.yaml`.
```
ls -al workspace/mnist-dev
mnist.py
mnist_handler.py
mnist_cnn.pt
model-config.yaml
# config the model
cat workspace/mnist-dev/model-config.yaml
minWorkers: 1
maxWorkers: 1
batchSize: 4
maxBatchDelay: 200
responseTimeout: 300
```
1. Erstellen Sie die Modellartefakte mithilfe von [torch-model-archiver ](https://github.com/pytorch/serve/tree/master/model-archiver#torch-model-archiver-for-torchserve).
```
torch-model-archiver --model-name mnist --version 1.0 --model-file workspace/mnist-dev/mnist.py --serialized-file workspace/mnist-dev/mnist_cnn.pt --handler workspace/mnist-dev/mnist_handler.py --config-file workspace/mnist-dev/model-config.yaml --archive-format tgz
```
Wenn Sie ein Paket vorinstallieren möchten, müssen Sie das `code` Verzeichnis in die Datei `tar.gz` aufnehmen.
```
cd workspace
torch-model-archiver --model-name mnist --version 1.0 --model-file mnist-dev/mnist.py --serialized-file mnist-dev/mnist_cnn.pt --handler mnist-dev/mnist_handler.py --config-file mnist-dev/model-config.yaml --archive-format no-archive
cd mnist
mv ../code .
tar cvzf mnist.tar.gz .
```
1. Laden Sie `mnist.tar.gz` auf Amazon S3 hoch.
```
# upload mnist.tar.gz to S3
output_path = f"s3://{bucket_name}/{prefix}/models"
aws s3 cp mnist.tar.gz {output_path}/mnist.tar.gz
```
## Verwenden von Endpunkten mit einem einzigen Modell für die Bereitstellung mit TorchServe
Das folgende Beispiel zeigt Ihnen, wie Sie einen [Echtzeit-Inferenzendpunkt für ein einzelnes Modell](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html) erstellen, das Modell auf dem Endpunkt bereitstellen und den Endpunkt mithilfe des [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/) testen.
```
from sagemaker.model import Model
from sagemaker.predictor import Predictor
# create the single model endpoint and deploy it on SageMaker AI
model = Model(model_data = f'{output_path}/mnist.tar.gz',
image_uri = baseimage,
role = role,
predictor_cls = Predictor,
name = "mnist",
sagemaker_session = smsess)
endpoint_name = 'torchserve-endpoint-' + time.strftime("%Y-%m-%d-%H-%M-%S", time.gmtime())
predictor = model.deploy(instance_type='ml.g4dn.xlarge',
initial_instance_count=1,
endpoint_name = endpoint_name,
serializer=JSONSerializer(),
deserializer=JSONDeserializer())
# test the endpoint
import random
import numpy as np
dummy_data = {"inputs": np.random.rand(16, 1, 28, 28).tolist()}
res = predictor.predict(dummy_data)
```
## Verwendung von Endpunkten mit mehreren Modellen für die Bereitstellung TorchServe
[Multi-Modell-Endpunkte](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html) sind eine skalierbare und kostengünstige Lösung für das Hosting einer großen Anzahl von Modellen hinter einem Endpunkt. Sie verbessern die Nutzung der Endgeräte, indem sie dieselbe Ressourcenflotte gemeinsam nutzen und Container zum Hosten all Ihrer Modelle bereitstellen. Sie reduzieren auch den Bereitstellungsaufwand, da SageMaker KI das dynamische Laden und Entladen von Modellen sowie die Skalierung von Ressourcen auf der Grundlage von Verkehrsmustern verwaltet. Endgeräte mit mehreren Modellen eignen sich besonders für Deep-Learning- und generative KI-Modelle, die eine beschleunigte Rechenleistung erfordern.
Durch den Einsatz TorchServe von SageMaker KI-Endpunkten mit mehreren Modellen können Sie Ihre Entwicklung beschleunigen, indem Sie einen Serving-Stack verwenden, mit dem Sie vertraut sind, und gleichzeitig die gemeinsame Nutzung von Ressourcen und das vereinfachte Modellmanagement nutzen, die SageMaker KI-Endgeräte mit mehreren Modellen bieten.
Das folgende Beispiel zeigt Ihnen, wie Sie einen Endpunkt mit mehreren Modellen erstellen, das Modell auf dem Endpunkt bereitstellen und den Endpunkt mithilfe des [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/) testen. Weitere Details finden Sie in diesem [Notebook-Beispiel](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/torchserve_multi_model_endpoint.ipynb).
```
from sagemaker.multidatamodel import MultiDataModel
from sagemaker.model import Model
from sagemaker.predictor import Predictor
# create the single model endpoint and deploy it on SageMaker AI
model = Model(model_data = f'{output_path}/mnist.tar.gz',
image_uri = baseimage,
role = role,
sagemaker_session = smsess)
endpoint_name = 'torchserve-endpoint-' + time.strftime("%Y-%m-%d-%H-%M-%S", time.gmtime())
mme = MultiDataModel(
name = endpoint_name,
model_data_prefix = output_path,
model = model,
sagemaker_session = smsess)
mme.deploy(
initial_instance_count = 1,
instance_type = "ml.g4dn.xlarge",
serializer=sagemaker.serializers.JSONSerializer(),
deserializer=sagemaker.deserializers.JSONDeserializer())
# list models
list(mme.list_models())
# create mnist v2 model artifacts
cp mnist.tar.gz mnistv2.tar.gz
# add mnistv2
mme.add_model(mnistv2.tar.gz)
# list models
list(mme.list_models())
predictor = Predictor(endpoint_name=mme.endpoint_name, sagemaker_session=smsess)
# test the endpoint
import random
import numpy as np
dummy_data = {"inputs": np.random.rand(16, 1, 28, 28).tolist()}
res = predictor.predict(date=dummy_data, target_model="mnist.tar.gz")
```
## Kennzahlen
TorchServe unterstützt sowohl Metriken auf System- als auch auf Modellebene. Sie können Metriken entweder im Protokollformatmodus oder im Prometheus-Modus über die Umgebungsvariable `TS_METRICS_MODE` aktivieren. Sie können die TorchServe zentrale Metrik-Konfigurationsdatei verwenden`metrics.yaml`, um die Arten von Metriken anzugeben, die verfolgt werden sollen, z. B. Anzahl der Anfragen, Latenz, Speichernutzung, GPU-Auslastung und mehr. Mithilfe dieser Datei können Sie Einblicke in die Leistung und den Zustand der bereitgestellten Modelle gewinnen und das TorchServe Serververhalten effektiv in Echtzeit überwachen. Ausführlichere Informationen finden Sie in der [Dokumentation zu den TorchServe Metriken](https://github.com/pytorch/serve/blob/master/docs/metrics.md#torchserve-metrics).
Sie können über den CloudWatch Amazon-Protokollfilter auf TorchServe Metrikprotokolle zugreifen, die dem StatsD-Format ähneln. Im Folgenden finden Sie ein Beispiel für ein TorchServe Metrikprotokoll:
```
CPUUtilization.Percent:0.0|#Level:Host|#hostname:my_machine_name,timestamp:1682098185
DiskAvailable.Gigabytes:318.0416717529297|#Level:Host|#hostname:my_machine_name,timestamp:1682098185
```