As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Implemente modelos com TorchServe
TorchServe é o servidor modelo recomendado para PyTorch, pré-instalado no AWS PyTorch Deep Learning Container (DLC). Essa ferramenta poderosa oferece aos clientes uma experiência consistente e fácil de usar, oferecendo alto desempenho na implantação de vários PyTorch modelos em várias AWS instâncias, incluindo CPU, GPU, Neuron e Graviton, independentemente do tamanho ou da distribuição do modelo.
TorchServe suporta uma ampla variedade de recursos avançados, incluindo batching dinâmico, microbatching, A/B teste de modelo, streaming, torch XLA, TensorRT, ONNX e IPEX. Além disso, ele integra perfeitamente a solução PyTorch de modelos grandes da PiPPy, permitindo o manuseio eficiente de modelos grandes. Além disso, TorchServe estende seu suporte a bibliotecas populares de código aberto DeepSpeed, como Accelerate, Fast Transformers e muito mais, expandindo ainda mais seus recursos. Com TorchServe, AWS os usuários podem implantar e servir seus PyTorch modelos com confiança, aproveitando sua versatilidade e desempenho otimizado em várias configurações de hardware e tipos de modelos. Para obter informações mais detalhadas, você pode consultar a [PyTorchdocumentação e assim TorchServe](https://pytorch.org/serve/) [por diante GitHub](https://github.com/pytorch/serve).
A tabela a seguir lista os AWS PyTorch DLCs suportados pelo TorchServe.
| Tipo de instância | SageMaker Link do PyTorch DLC AI |
| --- | --- |
| CPU e GPU | [SageMaker PyTorch Contêineres AI](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) |
| Neuron | [PyTorch Recipientes de neurônios](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) |
| Graviton | [SageMaker Contêineres AI PyTorch Graviton](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-graviton-containers-sm-support-only) |
As seções a seguir descrevem a configuração para criar e testar PyTorch DLCs na Amazon SageMaker AI.
## Introdução
Para começar, verifique se você tem os seguintes pré-requisitos:
1. Certifique-se de ter acesso a uma AWS conta. Configure seu ambiente para que eles AWS CLI possam acessar sua conta por meio de um usuário AWS do IAM ou de uma função do IAM. Recomendamos usar uma perfil do IAM. Para fins de teste em sua conta pessoal, você pode anexar as seguintes políticas de permissões gerenciadas à perfil do 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. Configure localmente suas dependências, conforme mostrado no seguinte exemplo:
```
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. Recupere a imagem do PyTorch DLC, conforme mostrado no exemplo a seguir.
SageMaker As imagens de PyTorch DLC AI estão disponíveis em todas as AWS regiões. Para obter mais informações, consulte a [lista de imagens de contêineres do 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. Crie um espaço de trabalho local.
```
mkdir -p workspace/
```
## Adição de um pacote
As seções a seguir descrevem como adicionar e pré-instalar pacotes em sua imagem de PyTorch DLC.
**Casos de uso do BYOC**
As etapas a seguir descrevem como adicionar um pacote à sua imagem de PyTorch DLC. Para obter mais informações sobre como personalizar seu contêiner, consulte [Criação de imagens personalizadas de contêineres de AWS Deep Learning](https://github.com/aws/deep-learning-containers/blob/master/custom_images.md).
1. Suponha que você queira adicionar um pacote à imagem docker do PyTorch DLC. Crie um Dockerfile no diretório `docker`, conforme mostrado no seguinte exemplo:
```
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. Crie e publique a imagem do docker personalizada usando o script [ build\$1and\$1push.sh](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/workspace/docker/build_and_push.sh) a seguir.
```
# 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 Casos de uso de pré-instalação de IA**
O exemplo a seguir mostra como pré-instalar um pacote em seu contêiner de PyTorch DLC. Você deve criar um arquivo `requirements.txt` localmente no diretório `workspace/code`.
```
mkdir -p workspace/code
cat workspace/code/requirements.txt
transformers==4.28.1
```
## Crie artefatos de TorchServe modelo
No exemplo a seguir, usamos o [ modelo MNIST](https://github.com/pytorch/serve/tree/master/examples/image_classifier/mnist) pré-treinado. Criamos um diretório`workspace/mnist`, implementamos o [mnist\$1handler.py](https://github.com/pytorch/serve/blob/master/examples/image_classifier/mnist/mnist_handler.py) seguindo as [instruções de serviço TorchServe personalizadas](https://github.com/pytorch/serve/blob/master/docs/custom_service.md#custom-service) e [configuramos os parâmetros do modelo](https://github.com/pytorch/serve/tree/master/model-archiver#config-file) (como tamanho do lote e trabalhadores) em [model-config.yaml](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/workspace/lama/model-config.yaml). Em seguida, usamos a TorchServe ferramenta `torch-model-archiver` para criar os artefatos do modelo e fazer o upload para o Amazon S3.
1. Configure os parâmetros do modelo em `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. Crie os artefatos do modelo usando o. [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 quiser pré-instalar um pacote, você deve incluir o diretório `code` no arquivo `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. Carregue `mnist.tar.gz` no 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
```
## Usando endpoints de modelo único para implantar com TorchServe
[O exemplo a seguir mostra como criar um [único modelo de endpoint de inferência em tempo real](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html), implantar o modelo no endpoint e testar o endpoint usando o Amazon Python SDK. 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)
```
## Usando endpoints de vários modelos para implantar com TorchServe
Os [endpoints multimodelo](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html) são uma solução escalável e econômica para a hospedagem de um grande número de modelos atrás de um endpoint. Eles melhoram a utilização do endpoint compartilhando a mesma frota de recursos e contêiner de serviço para hospedar todos os seus modelos. Eles também reduzem a sobrecarga de implantação porque a SageMaker IA gerencia dinamicamente o carregamento e o descarregamento de modelos, além de escalar os recursos com base nos padrões de tráfego. Os endpoints multimodelo são particularmente úteis para modelos de aprendizado profundo e IA generativa que exigem poder computacional acelerado.
Ao usar TorchServe endpoints multimodelo de SageMaker IA, você pode acelerar seu desenvolvimento usando uma pilha de serviços com a qual está familiarizado e, ao mesmo tempo, aproveitando o compartilhamento de recursos e o gerenciamento simplificado de modelos que os endpoints multimodelo de SageMaker IA fornecem.
[O exemplo a seguir mostra como criar um endpoint multimodelo, implantar o modelo no endpoint e testar o endpoint usando o SDK do Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable/) Detalhes adicionais podem ser encontrados neste [exemplo de caderno](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")
```
## Metrics
TorchServe suporta métricas no nível do sistema e no nível do modelo. Você pode ativar métricas no modo de formato de log ou no modo do Prometheus por meio da variável de ambiente `TS_METRICS_MODE`. Você pode usar o arquivo TorchServe central de configuração de métricas `metrics.yaml` para especificar os tipos de métricas a serem rastreadas, como contagem de solicitações, latência, uso de memória, utilização de GPU e muito mais. Ao consultar esse arquivo, você pode obter informações sobre o desempenho e a integridade dos modelos implantados e monitorar com eficácia o comportamento do TorchServe servidor em tempo real. Para obter informações mais detalhadas, consulte a [documentação de TorchServe métricas](https://github.com/pytorch/serve/blob/master/docs/metrics.md#torchserve-metrics).
Você pode acessar registros de TorchServe métricas semelhantes ao formato StatsD por meio do filtro de CloudWatch registros da Amazon. Veja a seguir um exemplo de um registro de TorchServe métricas:
```
CPUUtilization.Percent:0.0|#Level:Host|#hostname:my_machine_name,timestamp:1682098185
DiskAvailable.Gigabytes:318.0416717529297|#Level:Host|#hostname:my_machine_name,timestamp:1682098185
```