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) per servire i tuoi modelli. AWS Per conoscere i tipi di modelli e i framework supportati, consulta il repository DJL 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

   • AmazonEC2FullAccess

   • AmazonSageMakerFullAccess

   • Amazon S3 FullAccess

2. Assicurati di avere il docker client configurato sul tuo sistema.

3. Accedi ad Amazon Elastic Container Registry e imposta le seguenti variabili di ambiente:

   export ACCOUNT_ID=<your_account_id>
   export REGION=<your_region>
   aws ecr get-login-password --region $REGION | docker login --username AWS --password-stdin $ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com

4. 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 e i container di inferenza per CPU di DJL Serving. 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.

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

2. 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 nella Guida per l'utente di Amazon ECR per istruzioni su come crearne uno.

   docker build -f Dockerfile -t <registry>/<image_name>:<image_tag>

3. Invia l'immagine Docker al tuo repository di Amazon ECR.

   docker push $ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com/<image_name>:<image_tag>

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.

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.

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.

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.

• 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. È 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'MultiDataModeloggetto 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. 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

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:

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