Premiers pas Ajout d'un package Création d'artefacts TorchServe de modèle Utilisation de points de terminaison à modèle unique pour le déploiement TorchServe Utilisation de points de terminaison multimodèles pour le déploiement avec TorchServe Métriques

Déployez des modèles avec TorchServe

TorchServe est le modèle de serveur recommandé pour PyTorch, préinstallé dans le AWS PyTorch Deep Learning Container (DLC). Ce puissant outil offre aux clients une expérience cohérente et conviviale, offrant des performances élevées lors du déploiement de plusieurs PyTorch modèles sur différentes AWS instances, notamment le processeur, le GPU, le Neuron et le Graviton, quelle que soit la taille ou la distribution du modèle.

TorchServe prend en charge un large éventail de fonctionnalités avancées, notamment le traitement par lots dynamiques, le microtraitement, les tests A/B de modèles, le streaming, Torch XLA, TensorRT, ONNX et IPEX. De plus, il intègre parfaitement PyTorch la solution PiPPY pour les grands modèles, permettant une gestion efficace des grands modèles. En outre, il TorchServe étend son support aux bibliothèques open source populaires telles que Accelerate DeepSpeed, Fast Transformers, etc., élargissant ainsi encore ses capacités. AWS Les utilisateurs peuvent ainsi déployer et servir leurs PyTorch modèles en toute confiance, en tirant parti de sa polyvalence et de ses performances optimisées pour différentes configurations matérielles et types de modèles. TorchServe Pour des informations plus détaillées, vous pouvez consulter la PyTorchdocumentation et TorchServe plus encore GitHub.

Le tableau suivant répertorie les AWS PyTorch DLC pris en charge par TorchServe.

Type d’instance	SageMaker PyTorch Lien vers le DLC
CPU et GPU	SageMaker PyTorch conteneurs
Neuron	PyTorch Conteneurs Neuron
Graviton	SageMaker PyTorch Conteneurs Graviton

Les sections suivantes décrivent la configuration pour créer et tester des PyTorch DLC sur Amazon SageMaker.

Premiers pas

Avant de démarrer, vérifiez que les conditions préalables suivantes sont respectées :

Assurez-vous d'avoir accès à un AWS compte. Configurez votre environnement afin qu'ils AWS CLI puissent accéder à votre compte via un utilisateur AWS IAM ou un rôle IAM. Nous vous recommandons d'utiliser un rôle IAM. À des fins de test dans votre compte personnel, vous pouvez associer les politiques d'autorisations gérées suivantes au rôle IAM :

Configurez vos dépendances de façon locale, comme indiqué dans l'exemple suivant :


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

Récupérez l'image du PyTorch DLC, comme indiqué dans l'exemple suivant.

SageMaker PyTorch Les images du DLC sont disponibles dans toutes les AWS régions. Pour plus d'informations, consultez la liste des images des conteneurs 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",
    )
```
Créez un espace de travail local.
```
mkdir -p workspace/
```

Ajout d'un package

Les sections suivantes décrivent comment ajouter et préinstaller des packages à l'image de votre PyTorch DLC.

Cas d'utilisation BYOC

Les étapes suivantes expliquent comment ajouter un package à l'image de votre PyTorch DLC. Pour plus d'informations sur la personnalisation de votre conteneur, consultez la section Création d'images personnalisées pour les AWS Deep Learning Containers.

Supposons que vous souhaitiez ajouter un package à l'image du docker du PyTorch DLC. Créez un Dockerfile dans le répertoire docker, comme indiqué dans l'exemple suivant :


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

Créez et publiez l'image Docker personnalisée à l'aide du script build_and_push.sh suivant.


# 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 cas d'utilisation liés à la préinstallation

L'exemple suivant montre comment préinstaller un package dans votre conteneur de PyTorch DLC. Vous devez créer un fichier requirements.txt localement dans le répertoire workspace/code.


mkdir -p workspace/code
    cat workspace/code/requirements.txt
    
    transformers==4.28.1

Création d'artefacts TorchServe de modèle

Dans l'exemple suivant, nous utilisons le modèle MNIST pré-entraîné. Nous créons un répertoireworkspace/mnist, implémentons mnist_handler.py en suivant les instructions de service TorchServe personnalisées et configurons les paramètres du modèle (tels que la taille du lot et les travailleurs) dans model-config.yaml. Ensuite, nous utilisons l' TorchServe outil torch-model-archiver pour créer les artefacts du modèle et les télécharger sur Amazon S3.

Configurez les paramètres du modèle dans 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

Créez les artefacts du modèle en utilisant 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 vous souhaitez préinstaller un package, vous devez inclure le répertoire code dans le fichier 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 .

Charger mnist.tar.gz dans 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

Utilisation de points de terminaison à modèle unique pour le déploiement TorchServe

L'exemple suivant vous montre comment créer un point de terminaison d'inférence en temps réel à modèle unique, déployer le modèle sur le point de terminaison et tester le point de terminaison à l'aide du SDK 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)

Utilisation de points de terminaison multimodèles pour le déploiement avec TorchServe

Les points de terminaison multimodèles offrent une solution évolutive et économique pour l'hébergement d'un grand nombre de modèles au-delà d'un point de terminaison. Ils améliorent l'utilisation des points de terminaison en partageant la même flotte de ressources et un conteneur de service pour héberger tous vos modèles. Ils réduisent également les frais de déploiement car ils SageMaker gèrent les modèles de chargement et de déchargement dynamiques, ainsi que le dimensionnement des ressources en fonction des modèles de trafic. Les points de terminaison multimodèles sont particulièrement utiles pour le deep learning et les modèles d'IA générative qui nécessitent une puissance de calcul accélérée.

En l'utilisant TorchServe sur des points de terminaison SageMaker multimodèles, vous pouvez accélérer votre développement en utilisant une pile de serveurs que vous connaissez bien, tout en tirant parti du partage des ressources et de la gestion simplifiée des modèles fournis par les points de terminaison SageMaker multimodèles.

L'exemple suivant vous montre comment créer un point de terminaison multimodèle, déployer le modèle sur le point de terminaison et tester le point de terminaison à l'aide du SDK Amazon SageMaker Python. Vous trouverez des informations supplémentaires dans cet exemple de bloc-notes.


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étriques

TorchServe prend en charge les métriques au niveau du système et au niveau du modèle. Vous pouvez activer les métriques en mode journal ou en mode Prometheus via la variable d'environnement TS_METRICS_MODE. Vous pouvez utiliser le fichier de configuration TorchServe central des métriques metrics.yaml pour spécifier les types de métriques à suivre, tels que le nombre de demandes, la latence, l'utilisation de la mémoire, l'utilisation du GPU, etc. En consultant ce fichier, vous pouvez obtenir des informations sur les performances et l'état des modèles déployés et surveiller efficacement le comportement TorchServe du serveur en temps réel. Pour des informations plus détaillées, consultez la documentation sur TorchServe les métriques.

Vous pouvez accéder aux journaux de TorchServe mesures similaires au format StatsD via le filtre de CloudWatch journal Amazon. Voici un exemple de journal de TorchServe mesures :


CPUUtilization.Percent:0.0|#Level:Host|#hostname:my_machine_name,timestamp:1682098185
    DiskAvailable.Gigabytes:318.0416717529297|#Level:Host|#hostname:my_machine_name,timestamp:1682098185

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Déploiement de modèles avec des serveurs de modèles

Déploiement de modèles avec DJL Serving