Conceitos básicos Adição de um pacote Crie artefatos de TorchServe modelo Usando endpoints de modelo único para implantar com TorchServe Usando endpoints de vários modelos para implantar com TorchServe Metrics

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 lotes dinâmicos, microlotes, testes de modelo A/B, streaming, torch XLA, TensorRT, ONNX e IPEX. Além disso, ele integra perfeitamente a solução de modelos grandes PyTorch 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 por diante GitHub.

A tabela a seguir lista os AWS PyTorch DLCs suportados pelo TorchServe.

Tipo de instância	SageMaker PyTorch Link do DLC
CPU e GPU	SageMaker PyTorch contêineres
Neuron	PyTorch Recipientes de neurônios
Graviton	SageMaker PyTorch Recipientes Graviton

As seções a seguir descrevem a configuração para criar e testar PyTorch DLCs na Amazon SageMaker.

Conceitos básicos

Para começar, verifique se você tem os seguintes pré-requisitos:

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 função do IAM. Para fins de teste em sua conta pessoal, você pode anexar as seguintes políticas de permissões gerenciadas à função do IAM:

Configure localmente suas dependências, conforme mostrado no exemplo a seguir:


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

Recupere a imagem do PyTorch DLC, conforme mostrado no exemplo a seguir.

SageMaker PyTorch As imagens DLC 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.
```
baseimage = sagemaker.image_uris.retrieve(
        framework="pytorch",
        region="<region>",
        py_version="py310",
        image_scope="inference",
        version="2.0.1",
        instance_type="ml.g4dn.16xlarge",
    )
```
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.

Suponha que você queira adicionar um pacote à imagem docker do PyTorch DLC. Crie um Dockerfile no diretório docker, conforme mostrado no exemplo a seguir:


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

Crie e publique a imagem do docker personalizada usando o script 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

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 pré-treinado. Criamos um diretórioworkspace/mnist, implementamos o mnist_handler.py seguindo as instruções de serviço TorchServe personalizadas e configuramos os parâmetros do modelo (como tamanho do lote e trabalhadores) em 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.

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

Crie os artefatos do modelo usando o. 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

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 .

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, implantar o modelo no endpoint e testar o endpoint usando o Amazon Python SDK. SageMaker


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)

Usando endpoints de vários modelos para implantar com TorchServe

Os endpoints multimodelo 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 SageMaker gerenciam 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 em endpoints de SageMaker vários modelos, 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 SageMaker os endpoints multimodelo 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 Detalhes adicionais podem ser encontrados neste exemplo de caderno.


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")

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 de configuração TorchServe central 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.

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

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Implante modelos com servidores modelo

Implante modelos com o DJL Serving