Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Implemente modelos con TorchServe
TorchServe es el modelo de servidor recomendado PyTorch, ya que viene preinstalado en el contenedor de aprendizaje AWS PyTorch profundo (DLC). Esta poderosa herramienta ofrece a los clientes una experiencia uniforme y fácil de usar, y ofrece un alto rendimiento al implementar varios PyTorch modelos en varias AWS instancias, incluidas la CPU, la GPU, Neuron y Graviton, independientemente del tamaño o la distribución del modelo.
TorchServe admite una amplia gama de funciones avanzadas, como el procesamiento dinámico por lotes, el microprocesamiento, las A/B pruebas de modelos, la transmisión, el torch XLA, TensorRT, ONNX e IPEX. Además, integra a la perfección la solución para modelos grandes, Pi, lo PyTorch que permite un manejo eficiente de modelos grandes. PPy Además, TorchServe amplía su soporte a bibliotecas populares de código abierto DeepSpeed, como Accelerate y Fast Transformers, entre otras, lo que amplía aún más sus capacidades. Con TorchServe ella, AWS los usuarios pueden implementar y utilizar sus PyTorch modelos con confianza, aprovechando su versatilidad y rendimiento optimizado en diversas configuraciones de hardware y tipos de modelos. [Para obtener información más detallada, puede consultar la [PyTorchdocumentación](https://pytorch.org/serve/) y demásTorchServe. GitHub](https://github.com/pytorch/serve)
En la siguiente tabla se enumeran las AWS PyTorch DLCs compatibles con TorchServe.
| Tipo de instancia | SageMaker Enlace PyTorch DLC de AI |
| --- | --- |
| CPU y GPU | [SageMaker Contenedores de IA PyTorch ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) |
| Neuron | [PyTorch Contenedores Neuron](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) |
| Graviton | [SageMaker Contenedores AI PyTorch Graviton](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-graviton-containers-sm-support-only) |
En las siguientes secciones se describe la configuración para compilar y probar PyTorch DLCs en Amazon SageMaker AI.
## Introducción
Antes de comenzar, compruebe que cumple los siguientes requisitos previos:
1. Asegúrese de tener acceso a una AWS cuenta. Configure su entorno para que AWS CLI pueda acceder a su cuenta a través de un usuario de AWS IAM o un rol de IAM. Recomendamos utilizar un rol de IAM. Para realizar pruebas en su cuenta personal, puede asociar las siguientes políticas de permisos gestionados al rol de 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 sus dependencias de forma local, como se muestra en el siguiente ejemplo.
```
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. Recupera la imagen del PyTorch DLC, como se muestra en el siguiente ejemplo.
SageMaker Las imágenes del PyTorch DLC de IA están disponibles en todas las AWS regiones. Para obtener más información, consulte la [lista de imágenes de contenedores de 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. Crear un espacio de trabajo local.
```
mkdir -p workspace/
```
## Añadir un paquete
En las siguientes secciones se describe cómo añadir y preinstalar paquetes a una imagen de PyTorch DLC.
**Casos de uso de BYOC**
En los pasos siguientes se describe cómo añadir un paquete a la imagen de PyTorch DLC. Para obtener más información sobre la personalización del contenedor, consulte [Creación de imágenes personalizadas de AWS Deep Learning Containers](https://github.com/aws/deep-learning-containers/blob/master/custom_images.md).
1. Supongamos que quieres añadir un paquete a la imagen del docker del PyTorch DLC. Cree un Dockerfile en el directorio de `docker`, como se muestra en el siguiente ejemplo:
```
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. Cree y publique la imagen de Docker personalizada mediante el siguiente 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 Casos de uso de preinstalación de IA**
En el siguiente ejemplo, se muestra cómo preinstalar un paquete en el contenedor de contenido PyTorch descargable. Debe crear un archivo `requirements.txt` localmente en el directorio `workspace/code`.
```
mkdir -p workspace/code
cat workspace/code/requirements.txt
transformers==4.28.1
```
## Crea artefactos modelo TorchServe
En el siguiente ejemplo, utilizamos el modelo MNIST [ previamente entrenado](https://github.com/pytorch/serve/tree/master/examples/image_classifier/mnist). Creamos un directorio`workspace/mnist`, implementamos [mnist\$1handler.py](https://github.com/pytorch/serve/blob/master/examples/image_classifier/mnist/mnist_handler.py) siguiendo las [instrucciones de servicio TorchServe personalizadas](https://github.com/pytorch/serve/blob/master/docs/custom_service.md#custom-service) y [configuramos los parámetros del modelo (como el](https://github.com/pytorch/serve/tree/master/model-archiver#config-file) tamaño del lote y los trabajadores) en [model-config.yaml](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/workspace/lama/model-config.yaml). A continuación, utilizamos la TorchServe herramienta `torch-model-archiver` para crear los artefactos del modelo y subirlos a Amazon S3.
1. Configure los parámetros del modelo en `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. Cree los artefactos del modelo utilizando [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 desea preinstalar un paquete, debe incluir el directorio `code` en el archivo `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. Suba `mnist.tar.gz` a 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
```
## Uso de puntos finales de un solo modelo para realizar la implementación TorchServe
El siguiente ejemplo muestra cómo crear un [punto final de inferencia en tiempo real de un solo modelo](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html), implementar el modelo en el punto final y probar el punto final mediante el [SDK de 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)
```
## Uso de puntos de enlace multimodelo con los que realizar la implementación TorchServe
Los [puntos de conexión multimodelo](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html) son una solución escalable y rentable para alojar una gran cantidad de modelos detrás de un punto de conexión. Mejoran la utilización de los puntos de conexión al compartir la misma flota de recursos y servir contenedores para alojar todos sus modelos. También reducen la sobrecarga de despliegue, ya que la SageMaker IA gestiona de forma dinámica los modelos de carga y descarga, además de escalar los recursos en función de los patrones de tráfico. Los puntos de conexión multimodelo son especialmente útiles para el aprendizaje profundo y los modelos de IA generativa que requieren una potencia de cálculo acelerada.
Al utilizarlos TorchServe en terminales multimodelo de SageMaker IA, puede acelerar su desarrollo utilizando una pila de servidores con la que esté familiarizado y, al mismo tiempo, aprovechar el intercambio de recursos y la gestión simplificada de modelos que ofrecen los puntos finales multimodelo de SageMaker IA.
El siguiente ejemplo muestra cómo crear un punto final multimodelo, implementar el modelo en el punto final y probar el punto final mediante el [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable/). Puede encontrar más detalles en este [ejemplo de cuaderno](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étricas
TorchServe admite métricas tanto a nivel de sistema como a nivel de modelo. Puede habilitar las métricas en el modo de formato de registro o en el modo Prometheus a través de la variable de entorno `TS_METRICS_MODE`. Puede usar el archivo de configuración de métricas TorchServe central `metrics.yaml` para especificar los tipos de métricas que se van a rastrear, como el recuento de solicitudes, la latencia, el uso de la memoria, el uso de la GPU, etc. Al consultar este archivo, puede obtener información sobre el rendimiento y el estado de los modelos implementados y supervisar de forma eficaz el comportamiento del TorchServe servidor en tiempo real. Para obtener información más detallada, consulte la [documentación sobre TorchServe métricas](https://github.com/pytorch/serve/blob/master/docs/metrics.md#torchserve-metrics).
Puedes acceder a los registros de TorchServe métricas similares al formato StatsD a través del filtro de CloudWatch registros de Amazon. El siguiente es un ejemplo de 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
```