Implemente modelos con TorchServe - Amazon SageMaker
IntroducciónAñadir un paqueteCrea artefactos modelo TorchServeUso de puntos finales de un solo modelo para realizar la implementación TorchServeUso de puntos de enlace multimodelo con los que realizar la implementación TorchServeMétricas

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 pruebas A/B de modelos, el streaming, el torch XLA, TensorRT, ONNX e IPEX. Además, integra a la perfección la solución para modelos grandes, PiPPY, lo que permite un manejo eficiente PyTorch de modelos grandes. Además, TorchServe amplía su soporte a bibliotecas populares de código abierto DeepSpeed, como Accelerate, Fast Transformers y más, ampliando 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 y demásTorchServe. GitHub

En la siguiente tabla se enumeran los AWS PyTorch DLC compatibles TorchServe con.

Tipo de instancia SageMaker PyTorch Enlace al DLC

CPU y GPU

SageMaker PyTorch contenedores

Neuron

PyTorch contenedores Neuron

Graviton

SageMaker PyTorch Contenedores Graviton

En las siguientes secciones se describe la configuración para crear y probar PyTorch los DLC en Amazon SageMaker.

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:

  2. 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}")

  3. Recupera la imagen del PyTorch DLC, como se muestra en el siguiente ejemplo.

    SageMaker PyTorch Las imágenes del DLC están disponibles en todas las AWS regiones. Para obtener más información, consulte la lista de imágenes de contenedores de DLC.

    baseimage = sagemaker.image_uris.retrieve(
        framework="pytorch",
        region="<region>",
        py_version="py310",
        image_scope="inference",
        version="2.0.1",
        instance_type="ml.g4dn.16xlarge",
    )

  4. 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.

  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

  2. Cree y publique la imagen de Docker personalizada mediante el siguiente script: 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 preinstalados

En el siguiente ejemplo, se muestra cómo preinstalar un paquete en el contenedor de PyTorch DLC. 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. Creamos un directorioworkspace/mnist, implementamos mnist_handler.py siguiendo las instrucciones de servicio TorchServe personalizadas y configuramos los parámetros del modelo (como el tamaño del lote y los trabajadores) en 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

  2. Cree los artefactos del modelo utilizando torch-model-archiver .

    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 .

  3. 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, implementar el modelo en el punto final y probar el punto final mediante el SDK de Amazon SageMaker Python.

from sagemaker.model import Model
    from sagemaker.predictor import Predictor
    
    # create the single model endpoint and deploy it on SageMaker
    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 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 implementación porque SageMaker administran los modelos de carga y descarga de forma dinámica, 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 SageMaker multimodelo, puede acelerar el desarrollo utilizando una pila de servidores con la que esté familiarizado y, al mismo tiempo, aprovechar el intercambio de recursos y la administración simplificada de modelos que SageMaker ofrecen los puntos finales multimodelo.

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. Puede encontrar más detalles en este ejemplo de cuaderno.

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
    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 eficazmente el comportamiento TorchServe del servidor en tiempo real. Para obtener información más detallada, consulte la documentación sobre TorchServe métricas.

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