Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Server modello per la distribuzione di modelli con Amazon SageMaker AI Puoi utilizzare i server modello più diffusi TorchServe, come DJL Serving e Triton Inference Server, per distribuire i tuoi modelli sull'intelligenza artificiale. SageMaker I seguenti argomenti spiegano come. **Topics** + [Distribuisci modelli con TorchServe](deploy-models-frameworks-torchserve.md) + [Implementa modelli con DJL Serving](deploy-models-frameworks-djl-serving.md) + [Implementazione di modelli con Triton Inference Server](deploy-models-frameworks-triton.md) # Distribuisci modelli con TorchServe TorchServe è il server modello consigliato per PyTorch, preinstallato nel AWS PyTorch Deep Learning Container (DLC). Questo potente strumento offre ai clienti un'esperienza coerente e intuitiva, offrendo prestazioni elevate nell'implementazione di più PyTorch modelli su varie AWS istanze, tra cui CPU, GPU, Neuron e Graviton, indipendentemente dalle dimensioni o dalla distribuzione del modello. TorchServe supporta un'ampia gamma di funzionalità avanzate, tra cui batching dinamico, microbatching, A/B test dei modelli, streaming, torch XLA, TensorRT, ONNX e IPEX. Inoltre, integra PyTorch perfettamente la soluzione per modelli di grandi dimensioni Pi, che consente una gestione efficiente di modelli di grandi dimensioni. PPy Inoltre, TorchServe estende il supporto alle librerie open source più diffuse come Accelerate DeepSpeed, Fast Transformers e altre, ampliandone ulteriormente le funzionalità. Con TorchServe, AWS gli utenti possono implementare e servire i propri PyTorch modelli in tutta sicurezza, sfruttando la sua versatilità e le prestazioni ottimizzate su varie configurazioni hardware e tipi di modelli. [https://pytorch.org/serve/](https://pytorch.org/serve/) Nella tabella seguente sono elencate le opzioni AWS PyTorch DLCs supportate da TorchServe. | Tipo di istanza | SageMaker Link PyTorch DLC AI | | --- | --- | | CPU e GPU | [SageMaker Contenitori AI PyTorch ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) | | Neuron | [PyTorch Contenitori Neuron](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) | | Graviton | [SageMaker Contenitori AI PyTorch Graviton](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-graviton-containers-sm-support-only) | Le seguenti sezioni descrivono la configurazione per creare e testare PyTorch DLCs su Amazon SageMaker AI. ## Nozioni di base Per iniziare, assicurati di rispettare i seguenti prerequisiti: 1. Assicurati di avere accesso a un AWS account. Configura il tuo ambiente in modo che AWS CLI possano accedere al tuo account tramite un utente AWS IAM o un ruolo IAM. Consigliamo di utilizzare un ruolo IAM. Ai fini del test nel tuo account personale, puoi collegare le seguenti policy di autorizzazione gestita al ruolo 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. Configurazione locale delle dipendenze, come indicato nell'esempio seguente: ``` 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. Recuperate l'immagine del PyTorch DLC, come mostrato nell'esempio seguente. SageMaker Le immagini PyTorch DLC AI sono disponibili in tutte le regioni. AWS Per ulteriori informazioni, consulta l'[elenco di immagini dei container 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. Creare un'area di lavoro locale ``` mkdir -p workspace/ ``` ## Aggiunta di un pacchetto Le sezioni seguenti descrivono come aggiungere e preinstallare pacchetti all'immagine PyTorch DLC. **Casi d'uso di BYOC** I passaggi seguenti descrivono come aggiungere un pacchetto all'immagine del DLC. PyTorch Per ulteriori informazioni sulla personalizzazione del contenitore, consulta [Creazione di immagini personalizzate dei AWS Deep Learning Containers](https://github.com/aws/deep-learning-containers/blob/master/custom_images.md). 1. Supponiamo di voler aggiungere un pacchetto all'immagine PyTorch docker del DLC. Crea un Dockerfile nella directory `docker`, come mostrato nell'esempio seguente: ``` 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. Crea e pubblica l'immagine docker personalizzata utilizzando il seguente 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 Casi d'uso della preinstallazione AI** L'esempio seguente mostra come preinstallare un pacchetto nel contenitore PyTorch DLC. È necessario creare un file `requirements.txt` localmente nella directory `workspace/code`. ``` mkdir -p workspace/code cat workspace/code/requirements.txt transformers==4.28.1 ``` ## Crea artefatti TorchServe del modello [Nel seguente esempio, utilizziamo il modello MNIST pre-addestrato.](https://github.com/pytorch/serve/tree/master/examples/image_classifier/mnist) [Creiamo una directory`workspace/mnist`, implementiamo [mnist\$1handler.py](https://github.com/pytorch/serve/blob/master/examples/image_classifier/mnist/mnist_handler.py) seguendo [le istruzioni di servizio TorchServe personalizzate](https://github.com/pytorch/serve/blob/master/docs/custom_service.md#custom-service) e [configuriamo i parametri del modello (come la](https://github.com/pytorch/serve/tree/master/model-archiver#config-file) dimensione del batch e i lavoratori) in model-config.yaml.](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/workspace/lama/model-config.yaml) Quindi, utilizziamo TorchServe lo strumento `torch-model-archiver` per creare gli artefatti del modello e caricarli su Amazon S3. 1. Configura i parametri del modello in `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. Costruisci gli artefatti del modello utilizzando. [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 si desidera preinstallare un pacchetto, è necessario includere la directory `code` nel file `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. Carica `mnist.tar.gz` 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 ``` ## Utilizzo di endpoint a modello singolo con cui eseguire la distribuzione TorchServe [L'esempio seguente mostra come creare un [endpoint di inferenza in tempo reale a modello singolo](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html), distribuire il modello sull'endpoint e testarlo utilizzando l'SDK Amazon Python. 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) ``` ## Utilizzo di endpoint multimodello con cui eseguire la distribuzione TorchServe Gli [endpoint multi-modello](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html) costituiscono una soluzione scalabile ed economica per l'hosting di un numero elevato di modelli dietro un unico endpoint. Migliorano l'utilizzo degli endpoint condividendo lo stesso parco di risorse e fornendo container per l'hosting di tutti i tuoi modelli. Riducono inoltre il sovraccarico di implementazione perché l' SageMaker intelligenza artificiale gestisce dinamicamente il caricamento e lo scaricamento dei modelli, oltre a scalare le risorse in base ai modelli di traffico. Gli endpoint multimodello sono particolarmente utili per i modelli di deep learning e di intelligenza artificiale generativa che richiedono una potenza di calcolo accelerata. Utilizzando endpoint multimodello SageMaker basati TorchServe sull'intelligenza artificiale, puoi velocizzare lo sviluppo utilizzando uno stack di servizi che conosci, sfruttando al contempo la condivisione delle risorse e la gestione semplificata dei modelli fornite dagli endpoint multimodello basati sull'intelligenza artificiale. SageMaker [L'esempio seguente mostra come creare un endpoint multimodello, distribuire il modello sull'endpoint e testarlo utilizzando l'SDK Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable/) Ulteriori informazioni sono disponibili in questo [esempio di notebook](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") ``` ## Metriche TorchServe supporta metriche sia a livello di sistema che a livello di modello. È possibile abilitare i parametri in modalità formato log o in modalità Prometheus tramite la variabile di ambiente `TS_METRICS_MODE`. Puoi utilizzare il file di configurazione delle metriche TorchServe centrali `metrics.yaml` per specificare i tipi di metriche da tracciare, come il conteggio delle richieste, la latenza, l'utilizzo della memoria, l'utilizzo della GPU e altro ancora. Facendo riferimento a questo file, è possibile ottenere informazioni sulle prestazioni e sullo stato dei modelli distribuiti e monitorare efficacemente il comportamento del server in tempo reale. TorchServe Per informazioni più dettagliate, consulta la documentazione sulle [TorchServe metriche](https://github.com/pytorch/serve/blob/master/docs/metrics.md#torchserve-metrics). Puoi accedere ai log TorchServe delle metriche simili al formato StatSD tramite il filtro Amazon log. CloudWatch Di seguito è riportato un esempio di registro delle metriche: TorchServe ``` CPUUtilization.Percent:0.0|#Level:Host|#hostname:my_machine_name,timestamp:1682098185 DiskAvailable.Gigabytes:318.0416717529297|#Level:Host|#hostname:my_machine_name,timestamp:1682098185 ``` # Implementa modelli con DJL Serving DJL Serving è una soluzione di distribuzione dei modelli universale autonoma ad alte prestazioni. Prende un modello di deep learning, diversi modelli o flussi di lavoro e li rende disponibili tramite un endpoint HTTP. Puoi utilizzare uno dei DJL Serving [Deep Learning Containers (DLCs)](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/what-is-dlc.html) per servire i tuoi modelli. AWS Per conoscere i tipi di modelli e i framework supportati, consulta il repository [DJL](https://github.com/deepjavalibrary/djl-serving) Serving. GitHub DJL Serving offre molte funzionalità che aiutano a implementare i propri modelli con prestazioni elevate: + Facilità d'uso: DJL Serving può servire con la maggior parte dei modelli senza alcuna modifica. Tu usi gli artefatti del modello e DJL Serving può ospitarli. + Supporto per più dispositivi e acceleratori: DJL Serving supporta l'implementazione di modelli su, e Inferentia. CPUs GPUs AWS + Prestazioni: DJL Serving esegue l'inferenza multithread in un'unica macchina virtuale Java (JVM) per aumentare il throughput. + Batching dinamico: DJL Serving supporta il batching dinamico per aumentare il throughput. + Dimensionamento automatico: DJL Serving aumenta o riduce automaticamente i worker in base al carico di traffico. + Supporto multimotore: DJL Serving può ospitare contemporaneamente modelli utilizzando framework diversi (ad esempio e). PyTorch TensorFlow + Modelli di ensemble e flussi di lavoro: DJL Serving supporta l'implementazione di flussi di lavoro complessi composti da più modelli e può eseguire parti del flusso di lavoro su e altre parti su. CPUs GPUs I modelli all'interno di un flusso di lavoro possono sfruttare diversi framework. Le sezioni seguenti descrivono come configurare un endpoint con DJL Serving on AI. SageMaker ## Nozioni di base Per iniziare, assicurati di rispettare i seguenti prerequisiti: 1. Assicurati di avere accesso a un AWS account. Configura il tuo ambiente in modo che AWS CLI possano accedere al tuo account tramite un utente AWS IAM o un ruolo IAM. Consigliamo di utilizzare un ruolo IAM. Ai fini del test nel tuo account personale, puoi collegare le seguenti policy di autorizzazione gestita al ruolo 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) + [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. Assicurati di avere il [docker](https://docs.docker.com/get-docker/) client configurato sul tuo sistema. 1. Accedi ad Amazon Elastic Container Registry e imposta le seguenti variabili di ambiente: ``` export ACCOUNT_ID= export REGION= aws ecr get-login-password --region $REGION | docker login --username AWS --password-stdin $ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com ``` 1. Estrai l'immagine docker. ``` docker pull 763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:0.22.1-deepspeed0.9.2-cu118 ``` Per tutte le immagini container di DJL Serving disponibili, consulta i [container di inferenza per modelli di grandi dimensioni](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#large-model-inference-containers) e i [container di inferenza per CPU di DJL Serving](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#djl-cpu-full-inference-containers). Quando scegli un'immagine dalle tabelle dei link precedenti, sostituisci la AWS regione nella colonna URL di esempio con la regione in cui ti trovi. DLCs Sono disponibili nelle regioni elencate nella tabella nella parte superiore della pagina Available [Deep Learning Containers Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). ## Personalizza il tuo container Puoi aggiungere pacchetti alle immagini DLC di base per personalizzare il container. Supponiamo di voler aggiungere un pacchetto all'immagine docker `763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:0.22.1-deepspeed0.9.2-cu118`. È necessario creare un dockerfile con l'immagine desiderata come immagine di base, aggiungere i pacchetti richiesti e inviare l'immagine ad Amazon ECR. Per creare un pacchetto, completa la seguente procedura: 1. Specifica le istruzioni per eseguire le librerie o i pacchetti desiderati nel dockerfile dell'immagine di base. ``` FROM 763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:0.22.1-deepspeed0.9.2-cu118 ## add custom packages/libraries RUN git clone https://github.com/awslabs/amazon-sagemaker-examples ``` 1. Crea l'immagine Docker dal tuo dockerfile. Specifica il tuo repository di Amazon ECR, il nome dell'immagine di base e un tag per l'immagine. Se non disponi di un repository di Amazon ECR, consulta [Utilizzare Amazon ECR con AWS CLI](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html) nella *Guida per l'utente di Amazon ECR* per istruzioni su come crearne uno. ``` docker build -f Dockerfile -t /: ``` 1. Invia l'immagine Docker al tuo repository di Amazon ECR. ``` docker push $ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com/: ``` Ora dovresti avere un'immagine del container personalizzata da poter utilizzare per la distribuzione dei modelli. Per altri esempi di personalizzazione del contenitore, consulta [Creazione di immagini personalizzate dei AWS Deep Learning Containers](https://github.com/aws/deep-learning-containers/blob/master/custom_images.md). ## Preparazione degli artefatti di un modello Prima di distribuire il modello sull' SageMaker intelligenza artificiale, è necessario impacchettare gli artefatti del modello in un file. `.tar.gz` DJL Serving accetta i seguenti artefatti nel tuo archivio: + Checkpoint del modello: file che memorizzano le ponderazioni del modello. + `serving.properties`: un file di configurazione che è possibile aggiungere per ogni modello. Inserisci `serving.properties` nella stessa directory del file del tuo modello. + `model.py`: codice del gestore di inferenza. È applicabile solo quando si utilizza la modalità Python. Se non specifichi `model.py`, djl-serving utilizza uno dei gestori predefiniti. Di seguito è riportato un esempio di struttura `model.tar.gz`: ``` - model_root_dir # root directory - serving.properties - model.py # your custom handler file for Python, if you choose not to use the default handlers provided by DJL Serving - model binary files # used for Java mode, or if you don't want to use option.model_id and option.s3_url for Python mode ``` DJL Serving supporta i motori Java alimentati da motori DJL o Python. Non tutti gli artefatti precedenti sono obbligatori. Gli artefatti obbligatori variano in base alla modalità scelta. Ad esempio, in modalità Python, è sufficiente specificare `option.model_id` nel file `serving.properties`. Non è necessario specificare il checkpoint del modello all'interno dei container LMI. In modalità Java, è necessario inserire il checkpoint del modello nel pacchetto. Per maggiori dettagli sul modo per configurare `serving.properties` e utilizzare motori diversi, consulta [Modalità di gestione di DJL Serving](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/modes.md). ## Utilizza endpoint a modello singolo per l'implementazione con DJL Serving Dopo aver preparato gli artefatti del modello, puoi distribuirlo su un endpoint di intelligenza artificiale. SageMaker Questa sezione descrive come implementare un modello unico su un endpoint con DJL Serving. Se stai implementando più modelli, salta questa sezione e vai a [Usa endpoint multimodello per implementazioni con DJL Serving](#deploy-models-frameworks-djl-mme). L'esempio seguente mostra un metodo per creare un oggetto modello utilizzando l'SDK Amazon SageMaker Python. Sarà necessario specificare i seguenti campi: + `image_uri`: puoi recuperare una delle immagini di base di DJL Serving come mostrato in questo esempio, oppure puoi specificare un'immagine Docker personalizzata dal tuo repository di Amazon ECR, se hai seguito le istruzioni in [Personalizza il tuo container](#deploy-models-frameworks-djl-byoc). + `model_s3_url`: dovrebbe essere un URI Amazon S3 che punta al tuo file `.tar.gz`. + `model_name`: specificate un nome per l'oggetto modello. ``` import boto3 import sagemaker from sagemaker.model import Model from sagemaker import image_uris, get_execution_role aws_region = "aws-region" sagemaker_session = sagemaker.Session(boto_session=boto3.Session(region_name=aws_region)) role = get_execution_role() def create_model(model_name, model_s3_url): # Get the DJL DeepSpeed image uri image_uri = image_uris.retrieve( framework="djl-deepspeed", region=sagemaker_session.boto_session.region_name, version="0.20.0" ) model = Model( image_uri=image_uri, model_data=model_s3_url, role=role, name=model_name, sagemaker_session=sagemaker_session, ) return model ``` ## Usa endpoint multimodello per implementazioni con DJL Serving Se desideri distribuire più modelli su un endpoint, l' SageMaker intelligenza artificiale offre endpoint multimodello, che rappresentano una soluzione scalabile ed economica per implementare un gran numero di modelli. DJL Serving supporta anche il caricamento di più modelli contemporaneamente e l'esecuzione di inferenze su ciascuno dei modelli contemporaneamente. I contenitori DJL Serving aderiscono ai contratti di endpoint multimodello SageMaker AI e possono essere utilizzati per implementare endpoint multimodello. Ogni singolo artefatto del modello deve essere inserito in pacchetti nello stesso modo descritto nella sezione precedente [Preparazione degli artefatti di un modello](#deploy-models-frameworks-djl-artifacts). È possibile impostare configurazioni specifiche del modello nel file `serving.properties` e il codice del gestore di inferenza specifico del modello in `model.py`. Per un endpoint multimodello, i modelli devono essere disposti nel modo seguente: ``` root_dir |-- model_1.tar.gz |-- model_2.tar.gz |-- model_3.tar.gz . . . ``` L'SDK Amazon SageMaker Python utilizza l'[MultiDataModel](https://sagemaker.readthedocs.io/en/stable/api/inference/multi_data_model.html)oggetto per creare un'istanza di un endpoint multimodello. L'URI Amazon S3 per la directory root deve essere passato come argomento `model_data_prefix` al costruttore `MultiDataModel`. DJL Serving fornisce anche diversi parametri di configurazione per gestire i requisiti di memoria del modello, come `required_memory_mb` e `reserved_memory_mb`, che possono essere configurati per ciascun modello nel file [serving.properties](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/modes.md#servingproperties). Questi parametri sono utili per gestire gli errori per memoria insufficiente in modo più efficiente. [Per tutti i parametri configurabili, consulta la sezione handling in djl-serving. OutofMemory ](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/out_of_memory_management.md) La funzione di dimensionamento automatico di DJL Serving rende più facile garantire che i modelli siano dimensionati in modo appropriato per il traffico in entrata. Per impostazione predefinita, DJL Serving determina il numero massimo di worker per un modello che può essere supportato in base all'hardware disponibile (ad esempio i core CPU o i dispositivi GPU). È possibile impostare limiti inferiori e superiori per ogni modello per garantire che sia sempre possibile fornire un livello di traffico minimo e che un singolo modello non consumi tutte le risorse disponibili. È possibile impostare le seguenti proprietà nel file [serving.properties](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/modes.md#servingproperties): + `gpu.minWorkers`: Numero minimo di lavoratori per. GPUs + `gpu.maxWorkers`: Numero massimo di lavoratori per GPUs. + `cpu.minWorkers`: Numero minimo di lavoratori per CPUs. + `cpu.maxWorkers`: Numero massimo di lavoratori per CPUs. [Per un end-to-end esempio di come implementare un endpoint multimodello sull' SageMaker intelligenza artificiale utilizzando un contenitore DJL Serving, vedi l'esempio notebook Multi-model-Inference-Demo.ipynb.](https://github.com/deepjavalibrary/djl-demo/blob/master/aws/sagemaker/Multi-Model-Inference-Demo.ipynb) # Implementazione di modelli con Triton Inference Server [Triton Inference Server](https://github.com/triton-inference-server/server) è un software di distribuzione delle inferenze open source che semplifica l'inferenza dell'intelligenza artificiale. Con Triton, puoi implementare qualsiasi modello costruito con più framework di deep learning e machine learning, tra cui TensorRT,, ONNX, OpenVINO, Python TensorFlow PyTorch, RAPIDS FIL e altri. I contenitori SageMaker AI Triton ti aiutano a implementare Triton Inference Server sulla piattaforma di hosting AI per servire modelli addestrati in produzione. SageMaker Supporta le diverse modalità in cui opera l'IA. SageMaker Per un elenco dei contenitori Triton Inference Server disponibili su SageMaker AI, consulta [NVIDIA Triton Inference Containers (](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only)solo supporto SM). [Per esempi di end-to-end notebook, consigliamo di dare un'occhiata al repository. amazon-sagemaker-examples ](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-triton) ## Modalità di hosting Le seguenti modalità di hosting SageMaker AI sono supportate dai contenitori Triton: + Endpoint per modelli singoli + Questa è la modalità operativa predefinita di SageMaker AI. In questa modalità, il container Triton può caricare un modello singolo o un modello di ensemble singolo. + Il nome del modello deve essere passato come proprietà dell'ambiente contenitore, che fa parte della chiamata API `CreateModel` SageMaker AI. La variabile di ambiente utilizzata da inserire nel nome del modello è `SAGEMAKER_TRITON_DEFAULT_MODEL_NAME`. + Endpoint di modello singoli con ensemble + Triton Inference Server supporta l'*ensemble*, che è una pipeline, o un DAG (grafico aciclico diretto) di modelli. Sebbene un insieme sia tecnicamente composto da più modelli, nella modalità endpoint a modello singolo predefinita, l' SageMaker intelligenza artificiale può considerare l'*insieme vero e proprio* (il metamodello che rappresenta la pipeline) come modello principale da caricare e può successivamente caricare i modelli associati. + Il nome del modello dell'ensemble vero e proprio deve essere utilizzato per caricare il modello. Deve essere passato come proprietà dell'ambiente contenitore, che fa parte della chiamata API. `CreateModel` SageMaker La variabile di ambiente utilizzata da inserire nel nome del modello è `SAGEMAKER_TRITON_DEFAULT_MODEL_NAME`. + Endpoint multimodello + In questa modalità, l' SageMaker intelligenza artificiale può servire più modelli su un singolo endpoint. È possibile utilizzare questa modalità specificando la variabile di ambiente `‘MultiModel’: true` come proprietà dell'ambiente contenitore, che fa parte della chiamata `CreateModel` SageMaker API. + Per impostazione predefinita, nessun modello viene caricato all'avvio dell'istanza. Per eseguire una richiesta di inferenza su un particolare modello, specificate il `*.tar.gz` file del modello corrispondente come argomento della `TargetModel` proprietà della chiamata `InvokeEndpoint` SageMaker API. + Endpoint multimodello con ensemble + In questa modalità, l' SageMaker intelligenza artificiale funziona come descritto per gli endpoint multimodello. Tuttavia, il contenitore SageMaker AI Triton può caricare più modelli di ensemble, il che significa che più pipeline di modelli possono essere eseguite sulla stessa istanza. SageMaker L'intelligenza artificiale tratta ogni ensemble come un unico modello e l'insieme vero e proprio di ogni modello può essere richiamato specificando l'archivio corrispondente come. `*.tar.gz` `TargetModel` + Per una migliore gestione della memoria durante la memoria dinamica `LOAD` e `UNLOAD`, si consiglia di mantenere un ensemble di piccole dimensioni. ## Tipi di payload di inferenza Triton supporta due metodi per inviare un payload di inferenza sulla rete: `json` e `binary+json` (o json con codifica binaria). Il payload JSON in entrambi i casi include il tipo di dati, la forma e l'effettivo tensore di richiesta di inferenza. Il tensore di richiesta deve essere un tensore binario. Con il formato `binary+json`, è necessario specificare la lunghezza dei metadati della richiesta nell'intestazione per consentire a Triton di analizzare correttamente il payload binario. Nel contenitore SageMaker AI Triton, questa operazione viene eseguita utilizzando un'intestazione personalizzata:. `Content-Type` `application/vnd.sagemaker-triton.binary+json;json-header-size={}` Questo è diverso dall'utilizzo dell'`Inference-Header-Content-Length`intestazione su un Triton Inference Server autonomo perché le intestazioni personalizzate non sono consentite nell'intelligenza artificiale. SageMaker ## Utilizzo di config.pbtxt per impostare la configurazione dei modelli Per Triton Inference Servers on SageMaker AI, ogni modello deve includere un `config.pbtxt` file che specifichi, come minimo, le seguenti configurazioni per il modello: + `name`: Sebbene questo sia facoltativo per i modelli che funzionano al di fuori dell' SageMaker IA, ti consigliamo di fornire sempre un nome per i modelli da eseguire in Triton on AI. SageMaker + [`platform` e/o `backend`](https://github.com/triton-inference-server/backend/blob/main/README.md#backends): l'impostazione di un backend è essenziale per specificare il tipo di modello. Alcuni backend hanno un'ulteriore classificazione, come `tensorflow_savedmodel` o ` tensorflow_graphdef`. Tali opzioni possono essere specificate come parte della chiave `platform` oltre alla chiave `backend`. I backend più diffusi sono `tensorrt`, `onnxruntime`, `tensorflow`, `pytorch`, `python`, `dali`, `fil` e `openvino`. + `input`: specifica tre attributi per l'input: `name`, `data_type` e `dims` (la forma). + `output`: specifica tre attributi per l'output: `name`, `data_type` e `dims` (la forma). + `max_batch_size`: imposta la dimensione del batch su un valore maggiore o uguale a 1 che indichi la dimensione massima del batch che Triton dovrebbe utilizzare con il modello. [Per maggiori dettagli sulla configurazione`config.pbtxt`, consulta il repository di Triton. GitHub ](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md) Triton fornisce diverse configurazioni per modificare il comportamento dei modelli. Alcune delle opzioni di configurazione più comuni e importanti sono: + [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#instance-groups](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#instance-groups): i gruppi di istanze contribuiscono a specificare il numero e la posizione di un determinato modello. Hanno gli attributi `count`, `kind` e `gpus` (usati quando `kind` è `KIND_GPU`). L'attributo `count` è equivalente al numero di worker. Per la distribuzione di modelli ordinari, ogni worker dispone di una propria copia del modello. Analogamente, in Triton, `count` specifica il numero di copie del modello per dispositivo. Ad esempio, se il tipo `instance_group` è `KIND_CPU`, la CPU ha un numero di copie del modello pari a `count`. **Nota** In un'istanza GPU, la configurazione `instance_group` si applica a ciascun dispositivo GPU. Ad esempio, il numero `count` di copie del modello viene inserito su ciascun dispositivo GPU a meno che non si specifichi esplicitamente quali dispositivi GPU dovrebbero caricare il modello. + [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#dynamic-batcher](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#dynamic-batcher) e [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#stateful-models](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#stateful-models): il batching dinamico viene utilizzato per i modelli stateless e il batching in sequenza viene utilizzato per i modelli stateful (in cui si desidera instradare ogni volta una richiesta alla stessa istanza del modello). I pianificatori di batch abilitano una coda per modello, che aiuta ad aumentare il throughput, a seconda della configurazione di batching. + [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#ensemble-models](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#ensemble-models): un modello ensemble rappresenta una *pipeline* di uno o più modelli e la connessione dei tensori di input e output tra tali modelli. Può essere configurato specificando `platform` come `ensemble`. La configurazione dell'ensemble è solo una rappresentazione della pipeline del modello. Per quanto riguarda l' SageMaker intelligenza artificiale, tutti i modelli di un insieme vengono trattati come dipendenti del modello di insieme e contati come un unico modello per SageMaker le metriche di intelligenza artificiale, ad esempio. `LoadedModelCount` ## Pubblicazione dei parametri Triton predefiniti su Amazon CloudWatch NVIDIA Triton Inference Container espone i parametri sulla porta 8002 (configurabile) per i diversi modelli e GPUs che vengono utilizzati nel Triton Inference Server. [Per tutti i dettagli sulle metriche predefinite disponibili, consulta la pagina relativa alle metriche del Triton Inference Server. GitHub ](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/metrics.md) Questi parametri sono in formato Prometheus e possono essere sottoposti a scraping utilizzando una configurazione dello scraper Prometheus. A partire dalla versione v23.07 in poi, il contenitore SageMaker AI Triton supporta la pubblicazione di queste metriche su Amazon CloudWatch specificando alcune variabili di ambiente. Per analizzare i parametri di Prometheus, il container SageMaker AI Triton sfrutta l'agente Amazon. CloudWatch Le variabili di ambiente obbligatorio che è necessario specificare per raccogliere i parametri sono le seguenti: | Variabile di ambiente | Description | Valore di esempio | | --- | --- | --- | | `SAGEMAKER_TRITON_ALLOW_METRICS` | Specifica questa opzione per consentire a Triton di pubblicare i parametri sul suo endpoint Prometheus. | "true" | | `SAGEMAKER_TRITON_PUBLISH_METRICS_TO_CLOUDWATCH` | Specificate questa opzione per avviare i controlli preliminari necessari per pubblicare le metriche su Amazon. CloudWatch | "true" | | `SAGEMAKER_TRITON_CLOUDWATCH_LOG_GROUP` | Specifica questa opzione per puntare al gruppo di log in cui vengono scritti i parametri. | "/aws/SageMaker AI/Endpoints/TritonMetrics/SageMakerTwoEnsemblesTest" | | `SAGEMAKER_TRITON_CLOUDWATCH_METRIC_NAMESPACE` | Specifica questa opzione per puntare allo spazio dei nomi del parametro in cui desideri visualizzare e tracciare i parametri. | "/aws/SageMaker AI/Endpoints/TritonMetrics/SageMakerTwoEnsemblesPublicTest" | | `SAGEMAKER_TRITON_METRICS_PORT` | Indica 8002 o qualsiasi altra porta. Se l' SageMaker IA non ha bloccato la porta specificata, viene utilizzata. Altrimenti, viene scelta automaticamente un'altra porta non bloccata. | "8002" | Quando pubblichi metriche con Triton on SageMaker AI, tieni presente le seguenti limitazioni: + Sebbene sia possibile generare metriche personalizzate tramite il backend C-API e Python (dalla versione 23.05 in poi), al momento non sono supportate per la pubblicazione su Amazon. CloudWatch + In modalità SageMaker AI multimodel endpoint (MME), Triton viene eseguito in un ambiente che richiede l'abilitazione del namespace dei modelli perché ogni modello (eccetto i modelli ensemble) viene trattato come se si trovasse nel proprio repository di modelli. Attualmente, ciò crea una limitazione per i Parametri. Quando lo spazio dei nomi dei modelli è abilitato, Triton non distingue i parametri tra due modelli con lo stesso nome appartenenti a ensemble diversi. Come soluzione alternativa, assicurati che ogni modello implementato abbia un nome univoco. Ciò semplifica anche la ricerca delle metriche. CloudWatch ## Variabili di ambiente La tabella seguente elenca le variabili di ambiente supportate per Triton on SageMaker AI. | Variabile di ambiente | Description | Tipo | Valori possibili | | --- | --- | --- | --- | | `SAGEMAKER_MULTI_MODEL` | Consente a Triton di operare in modalità endpoint multimodello SageMaker AI. | Booleano | `true`, `false` | | `SAGEMAKER_TRITON_DEFAULT_MODEL_NAME` | Specificate il modello da caricare nella modalità SageMaker AI modello singolo (predefinita). Per la modalità ensemble, specifica il nome dell'ensemble vero e proprio. | Stringa | **come specificato in config.pbtxt | | `SAGEMAKER_TRITON_PING_MODE` | `'ready'`è la modalità predefinita nella modalità modello singolo di SageMaker AI ed `'live'` è l'impostazione predefinita nella modalità endpoint multimodello di SageMaker AI. | Stringa | `ready`, `live` | | `SAGEMAKER_TRITON_DISABLE_MODEL_NAMESPACING` | Nel contenitore SageMaker AI Triton, questa opzione è impostata per `true` impostazione predefinita. | Booleano | `true`, `false` | | `SAGEMAKER_BIND_TO_PORT` | In SageMaker AI, la porta predefinita è 8080. È possibile eseguire la personalizzazione utilizzando una porta diversa in scenari con più container. | Stringa | ** | | `SAGEMAKER_SAFE_PORT_RANGE` | Questo è impostato dalla piattaforma SageMaker AI quando si utilizza la modalità multi-contenitore. | Stringa | **–** | | `SAGEMAKER_TRITON_ALLOW_GRPC` | Sebbene l' SageMaker IA non supporti attualmente GRPC, se utilizzi Triton davanti a un reverse proxy personalizzato, puoi scegliere di abilitare GRPC. | Booleano | `true`, `false` | | `SAGEMAKER_TRITON_GRPC_PORT` | La porta predefinita per GRPC è 8001, ma è possibile modificarla. | Stringa | ** | | `SAGEMAKER_TRITON_THREAD_COUNT` | È possibile impostare il numero di thread predefiniti del gestore di richieste HTTP. | Stringa | ** | | `SAGEMAKER_TRITON_LOG_VERBOSE` | `true`per impostazione predefinita su SageMaker AI, ma puoi disattivare selettivamente questa opzione. | Booleano | `true`, `false` | | `SAGEMAKER_TRITON_LOG_INFO` | `false`per impostazione predefinita su SageMaker AI. | Booleano | `true`, `false` | | `SAGEMAKER_TRITON_LOG_WARNING` | `false`per impostazione predefinita su SageMaker AI. | Booleano | `true`, `false` | | `SAGEMAKER_TRITON_LOG_ERROR` | `false`per impostazione predefinita su SageMaker AI. | Booleano | `true`, `false` | | `SAGEMAKER_TRITON_SHM_DEFAULT_BYTE_SIZE` | Specifica la dimensione shm per il backend Python, in byte. Il valore predefinito è 16 MB ma può essere aumentato. | Stringa | ** | | `SAGEMAKER_TRITON_SHM_GROWTH_BYTE_SIZE` | Specifica la dimensione di aumento di shm per il backend Python, in byte. Il valore predefinito è 1 MB, ma può essere aumentato per consentire incrementi maggiori. | Stringa | ** | | `SAGEMAKER_TRITON_TENSORFLOW_VERSION` | Il valore predefinito è `2`. Triton non supporta più Tensorflow 2 di Triton v23.04. Puoi configurare questa variabile per le versioni precedenti. | Stringa | ** | | `SAGEMAKER_TRITON_MODEL_LOAD_GPU_LIMIT` | Limita la percentuale massima di memoria della GPU utilizzata per il caricamento dei modelli, permettendo di utilizzare il resto per le richieste di inferenza. | Stringa | ** | | `SAGEMAKER_TRITON_ALLOW_METRICS` | `false`per impostazione predefinita su SageMaker AI. | Booleano | `true`, `false` | | `SAGEMAKER_TRITON_METRICS_PORT` | La porta predefinita è 8002. | Stringa | ** | | `SAGEMAKER_TRITON_PUBLISH_METRICS_TO_CLOUDWATCH` | `false`per impostazione predefinita su SageMaker AI. Imposta questa variabile `true` per consentire l'invio delle metriche predefinite di Triton ad Amazon. CloudWatch Se questa opzione è abilitata, sei responsabile dei CloudWatch costi quando le metriche vengono pubblicate sul tuo account. | Booleano | `true`, `false` | | `SAGEMAKER_TRITON_CLOUDWATCH_LOG_GROUP` | Obbligatorio se hai abilitato la pubblicazione delle metriche su. CloudWatch | Stringa | ** | | `SAGEMAKER_TRITON_CLOUDWATCH_METRIC_NAMESPACE` | Obbligatorio se hai abilitato la pubblicazione delle metriche su. CloudWatch | Stringa | ** | | `SAGEMAKER_TRITON_ADDITIONAL_ARGS` | Aggiunge eventuali argomenti aggiuntivi all'avvio del server Triton. | Stringa | ** |