Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Déployez des modèles avec TorchServe
TorchServe est le modèle de serveur recommandé pour PyTorch, préinstallé dans le AWS PyTorch Deep Learning Container (DLC). Ce puissant outil offre aux clients une expérience cohérente et conviviale, offrant des performances élevées lors du déploiement de plusieurs PyTorch modèles sur différentes AWS instances, notamment le processeur, le GPU, le Neuron et le Graviton, quelle que soit la taille ou la distribution du modèle.
TorchServe prend en charge un large éventail de fonctionnalités avancées, notamment le traitement par lots dynamiques, le microtraitement, les A/B tests de modèles, le streaming, Torch XLA, TensorRT, ONNX et IPEX. De plus, il intègre parfaitement PyTorch la solution Pi pour les grands modèlesPPy, permettant une manipulation efficace des grands modèles. En outre, il TorchServe étend son support aux bibliothèques open source populaires telles que Accelerate DeepSpeed, Fast Transformers, etc., étendant ainsi encore ses capacités. AWS Les utilisateurs peuvent ainsi déployer et servir leurs PyTorch modèles en toute confiance, en tirant parti de sa polyvalence et de ses performances optimisées pour différentes configurations matérielles et types de modèles. TorchServe [Pour des informations plus détaillées, vous pouvez consulter la [PyTorchdocumentation](https://pytorch.org/serve/) et TorchServe plus encore GitHub.](https://github.com/pytorch/serve)
Le tableau suivant répertorie les solutions AWS PyTorch DLCs prises en charge par TorchServe.
| Type d’instance | SageMaker Lien vers le PyTorch DLC AI |
| --- | --- |
| CPU et GPU | [SageMaker PyTorch Conteneurs AI](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) |
| Neuron | [PyTorch Conteneurs Neuron](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) |
| Graviton | [SageMaker PyTorch Conteneurs AI Graviton](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-graviton-containers-sm-support-only) |
Les sections suivantes décrivent la configuration pour créer et tester PyTorch DLCs sur Amazon SageMaker AI.
## Prise en main
Avant de démarrer, vérifiez que les conditions préalables suivantes sont respectées :
1. Assurez-vous d'avoir accès à un AWS compte. Configurez votre environnement de manière à ce qu'ils AWS CLI puissent accéder à votre compte via un utilisateur AWS IAM ou un rôle IAM. Nous vous recommandons d'utiliser un rôle IAM. À des fins de test dans votre compte personnel, vous pouvez associer les politiques d'autorisations gérées suivantes au rôle IAM :
+ [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. Configurez vos dépendances de façon locale, comme indiqué dans l'exemple suivant :
```
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. Récupérez l'image du PyTorch DLC, comme indiqué dans l'exemple suivant.
SageMaker Les images du PyTorch DLC AI sont disponibles dans toutes les AWS régions. Pour plus d'informations, consultez la [liste des images des conteneurs DLC](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. Créez un espace de travail local.
```
mkdir -p workspace/
```
## Ajout d'un package
Les sections suivantes décrivent comment ajouter et préinstaller des packages à l'image de votre PyTorch DLC.
**Cas d'utilisation BYOC**
Les étapes suivantes expliquent comment ajouter un package à l'image de votre PyTorch DLC. Pour plus d'informations sur la personnalisation de votre conteneur, consultez la section [Création d'images personnalisées pour les AWS Deep Learning Containers](https://github.com/aws/deep-learning-containers/blob/master/custom_images.md).
1. Supposons que vous souhaitiez ajouter un package à l'image du docker du PyTorch DLC. Créez un Dockerfile dans le répertoire `docker`, comme indiqué dans l'exemple suivant :
```
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. Créez et publiez l'image Docker personnalisée à l'aide du script [build\$1and\$1push.sh](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/workspace/docker/build_and_push.sh) suivant.
```
# 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 Cas d'utilisation de la préinstallation de l'IA**
L'exemple suivant montre comment préinstaller un package dans votre conteneur de PyTorch DLC. Vous devez créer un fichier `requirements.txt` localement dans le répertoire `workspace/code`.
```
mkdir -p workspace/code
cat workspace/code/requirements.txt
transformers==4.28.1
```
## Création d'artefacts TorchServe de modèle
Dans l'exemple suivant, nous utilisons le [modèle MNIST](https://github.com/pytorch/serve/tree/master/examples/image_classifier/mnist) pré-entraîné. Nous créons un répertoire`workspace/mnist`, implémentons [mnist\$1handler.py](https://github.com/pytorch/serve/blob/master/examples/image_classifier/mnist/mnist_handler.py) en suivant les [instructions de service TorchServe personnalisées](https://github.com/pytorch/serve/blob/master/docs/custom_service.md#custom-service) et [configurons les paramètres du modèle (tels que la](https://github.com/pytorch/serve/tree/master/model-archiver#config-file) taille du lot et les travailleurs) dans [model-config.yaml](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/workspace/lama/model-config.yaml). Ensuite, nous utilisons l' TorchServe outil `torch-model-archiver` pour créer les artefacts du modèle et les télécharger sur Amazon S3.
1. Configurez les paramètres du modèle dans `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. Créez les artefacts du modèle en utilisant [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
```
Si vous souhaitez préinstaller un package, vous devez inclure le répertoire `code` dans le fichier `tar.gz`.
```
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. Charger `mnist.tar.gz` dans Amazon S3.
```
# 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
```
## Utilisation de points de terminaison à modèle unique pour le déploiement avec TorchServe
L'exemple suivant vous montre comment créer un point de [terminaison d'inférence en temps réel à modèle unique](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html), déployer le modèle sur le point de terminaison et tester le point de terminaison à l'aide du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable/).
```
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)
```
## Utilisation de points de terminaison multimodèles pour le déploiement avec TorchServe
Les [points de terminaison multimodèles](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html) offrent une solution évolutive et économique pour l'hébergement d'un grand nombre de modèles au-delà d'un point de terminaison. Ils améliorent l'utilisation des points de terminaison en partageant la même flotte de ressources et un conteneur de service pour héberger tous vos modèles. Ils réduisent également les frais de déploiement, car l' SageMaker IA gère les modèles de chargement et de déchargement de manière dynamique, ainsi que le dimensionnement des ressources en fonction des modèles de trafic. Les points de terminaison multimodèles sont particulièrement utiles pour le deep learning et les modèles d'IA générative qui nécessitent une puissance de calcul accélérée.
En utilisant des points de terminaison multimodèles basés TorchServe sur l' SageMaker IA, vous pouvez accélérer votre développement en utilisant une pile de serveurs que vous connaissez bien, tout en tirant parti du partage des ressources et de la gestion simplifiée des modèles fournis par les points de terminaison multimodèles basés sur l' SageMaker IA.
L'exemple suivant vous montre comment créer un point de terminaison multimodèle, déployer le modèle sur le point de terminaison et tester le point de terminaison à l'aide du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable/). Vous trouverez des informations supplémentaires dans cet [exemple de bloc-notes](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")
```
## Métriques
TorchServe prend en charge les métriques au niveau du système et au niveau du modèle. Vous pouvez activer les métriques en mode journal ou en mode Prometheus via la variable d'environnement `TS_METRICS_MODE`. Vous pouvez utiliser le fichier de configuration TorchServe central des métriques `metrics.yaml` pour spécifier les types de métriques à suivre, tels que le nombre de demandes, la latence, l'utilisation de la mémoire, l'utilisation du GPU, etc. En consultant ce fichier, vous pouvez obtenir des informations sur les performances et l'état des modèles déployés et surveiller efficacement le comportement TorchServe du serveur en temps réel. Pour des informations plus détaillées, consultez la [documentation sur TorchServe les métriques](https://github.com/pytorch/serve/blob/master/docs/metrics.md#torchserve-metrics).
Vous pouvez accéder aux journaux de TorchServe mesures similaires au format StatsD via le filtre de CloudWatch journal Amazon. Voici un exemple de journal de TorchServe mesures :
```
CPUUtilization.Percent:0.0|#Level:Host|#hostname:my_machine_name,timestamp:1682098185
DiskAvailable.Gigabytes:318.0416717529297|#Level:Host|#hostname:my_machine_name,timestamp:1682098185
```