Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Distribuisci modelli con TorchServe
TorchServe è il server modello consigliato per PyTorch, preinstallato nel AWS PyTorch Deep Learning Container (DLC). Questo potente strumento offre ai clienti un'esperienza coerente e intuitiva, offrendo prestazioni elevate nell'implementazione di più PyTorch modelli su varie AWS istanze, tra cui CPU, GPU, Neuron e Graviton, indipendentemente dalle dimensioni o dalla distribuzione del modello.
TorchServe supporta un'ampia gamma di funzionalità avanzate, tra cui batching dinamico, microbatching, A/B test dei modelli, streaming, torch XLA, TensorRT, ONNX e IPEX. Inoltre, integra PyTorch perfettamente la soluzione per modelli di grandi dimensioni Pi, che consente una gestione efficiente di modelli di grandi dimensioni. PPy Inoltre, TorchServe estende il supporto alle librerie open source più diffuse come Accelerate DeepSpeed, Fast Transformers e altre, ampliandone ulteriormente le funzionalità. Con TorchServe, AWS gli utenti possono implementare e servire i propri PyTorch modelli in tutta sicurezza, sfruttando la sua versatilità e le prestazioni ottimizzate su varie configurazioni hardware e tipi di modelli. [https://pytorch.org/serve/](https://pytorch.org/serve/)
Nella tabella seguente sono elencate le opzioni AWS PyTorch DLCs supportate da TorchServe.
| Tipo di istanza | SageMaker Link PyTorch DLC AI |
| --- | --- |
| CPU e GPU | [SageMaker Contenitori AI PyTorch ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) |
| Neuron | [PyTorch Contenitori Neuron](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) |
| Graviton | [SageMaker Contenitori AI PyTorch Graviton](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-graviton-containers-sm-support-only) |
Le seguenti sezioni descrivono la configurazione per creare e testare PyTorch DLCs su Amazon SageMaker AI.
## Nozioni di base
Per iniziare, assicurati di rispettare i seguenti prerequisiti:
1. Assicurati di avere accesso a un AWS account. Configura il tuo ambiente in modo che AWS CLI possano accedere al tuo account tramite un utente AWS IAM o un ruolo IAM. Consigliamo di utilizzare un ruolo IAM. Ai fini del test nel tuo account personale, puoi collegare le seguenti policy di autorizzazione gestita al ruolo 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. Configurazione locale delle dipendenze, come indicato nell'esempio seguente:
```
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. Recuperate l'immagine del PyTorch DLC, come mostrato nell'esempio seguente.
SageMaker Le immagini PyTorch DLC AI sono disponibili in tutte le regioni. AWS Per ulteriori informazioni, consulta l'[elenco di immagini dei container 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. Creare un'area di lavoro locale
```
mkdir -p workspace/
```
## Aggiunta di un pacchetto
Le sezioni seguenti descrivono come aggiungere e preinstallare pacchetti all'immagine PyTorch DLC.
**Casi d'uso di BYOC**
I passaggi seguenti descrivono come aggiungere un pacchetto all'immagine del DLC. PyTorch Per ulteriori informazioni sulla personalizzazione del contenitore, consulta [Creazione di immagini personalizzate dei AWS Deep Learning Containers](https://github.com/aws/deep-learning-containers/blob/master/custom_images.md).
1. Supponiamo di voler aggiungere un pacchetto all'immagine PyTorch docker del DLC. Crea un Dockerfile nella directory `docker`, come mostrato nell'esempio seguente:
```
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. Crea e pubblica l'immagine docker personalizzata utilizzando il seguente script [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 Casi d'uso della preinstallazione AI**
L'esempio seguente mostra come preinstallare un pacchetto nel contenitore PyTorch DLC. È necessario creare un file `requirements.txt` localmente nella directory `workspace/code`.
```
mkdir -p workspace/code
cat workspace/code/requirements.txt
transformers==4.28.1
```
## Crea artefatti TorchServe del modello
[Nel seguente esempio, utilizziamo il modello MNIST pre-addestrato.](https://github.com/pytorch/serve/tree/master/examples/image_classifier/mnist) [Creiamo una directory`workspace/mnist`, implementiamo [mnist\$1handler.py](https://github.com/pytorch/serve/blob/master/examples/image_classifier/mnist/mnist_handler.py) seguendo [le istruzioni di servizio TorchServe personalizzate](https://github.com/pytorch/serve/blob/master/docs/custom_service.md#custom-service) e [configuriamo i parametri del modello (come la](https://github.com/pytorch/serve/tree/master/model-archiver#config-file) dimensione del batch e i lavoratori) in model-config.yaml.](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/workspace/lama/model-config.yaml) Quindi, utilizziamo TorchServe lo strumento `torch-model-archiver` per creare gli artefatti del modello e caricarli su Amazon S3.
1. Configura i parametri del modello 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. Costruisci gli artefatti del modello utilizzando. [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
```
Se si desidera preinstallare un pacchetto, è necessario includere la directory `code` nel file `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. Carica `mnist.tar.gz` 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
```
## Utilizzo di endpoint a modello singolo con cui eseguire la distribuzione TorchServe
[L'esempio seguente mostra come creare un [endpoint di inferenza in tempo reale a modello singolo](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html), distribuire il modello sull'endpoint e testarlo utilizzando l'SDK Amazon Python. SageMaker ](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)
```
## Utilizzo di endpoint multimodello con cui eseguire la distribuzione TorchServe
Gli [endpoint multi-modello](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html) costituiscono una soluzione scalabile ed economica per l'hosting di un numero elevato di modelli dietro un unico endpoint. Migliorano l'utilizzo degli endpoint condividendo lo stesso parco di risorse e fornendo container per l'hosting di tutti i tuoi modelli. Riducono inoltre il sovraccarico di implementazione perché l' SageMaker intelligenza artificiale gestisce dinamicamente il caricamento e lo scaricamento dei modelli, oltre a scalare le risorse in base ai modelli di traffico. Gli endpoint multimodello sono particolarmente utili per i modelli di deep learning e di intelligenza artificiale generativa che richiedono una potenza di calcolo accelerata.
Utilizzando endpoint multimodello SageMaker basati TorchServe sull'intelligenza artificiale, puoi velocizzare lo sviluppo utilizzando uno stack di servizi che conosci, sfruttando al contempo la condivisione delle risorse e la gestione semplificata dei modelli fornite dagli endpoint multimodello basati sull'intelligenza artificiale. SageMaker
[L'esempio seguente mostra come creare un endpoint multimodello, distribuire il modello sull'endpoint e testarlo utilizzando l'SDK Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable/) Ulteriori informazioni sono disponibili in questo [esempio di notebook](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")
```
## Metriche
TorchServe supporta metriche sia a livello di sistema che a livello di modello. È possibile abilitare i parametri in modalità formato log o in modalità Prometheus tramite la variabile di ambiente `TS_METRICS_MODE`. Puoi utilizzare il file di configurazione delle metriche TorchServe centrali `metrics.yaml` per specificare i tipi di metriche da tracciare, come il conteggio delle richieste, la latenza, l'utilizzo della memoria, l'utilizzo della GPU e altro ancora. Facendo riferimento a questo file, è possibile ottenere informazioni sulle prestazioni e sullo stato dei modelli distribuiti e monitorare efficacemente il comportamento del server in tempo reale. TorchServe Per informazioni più dettagliate, consulta la documentazione sulle [TorchServe metriche](https://github.com/pytorch/serve/blob/master/docs/metrics.md#torchserve-metrics).
Puoi accedere ai log TorchServe delle metriche simili al formato StatSD tramite il filtro Amazon log. CloudWatch Di seguito è riportato un esempio di registro delle metriche: TorchServe
```
CPUUtilization.Percent:0.0|#Level:Host|#hostname:my_machine_name,timestamp:1682098185
DiskAvailable.Gigabytes:318.0416717529297|#Level:Host|#hostname:my_machine_name,timestamp:1682098185
```