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

Implementazione di modelli di grandi dimensioni per l’inferenza con TorchServe

Questo tutorial dimostra come implementare modelli di grandi dimensioni e fornire inferenza in Amazon SageMaker AI con TorchServe su GPU. Questo esempio distribuisce il modello OPT-30b su un’istanza ml.g5. È possibile modificarlo per utilizzarlo con altri modelli e tipi di istanze. Negli esempi, sostituire italicized placeholder text con le tue informazioni.

TorchServe è una potente piattaforma aperta per l'inferenza di modelli distribuiti di grandi dimensioni. Supportando librerie popolari come PyTorch, PipPy native, DeepSpeed e HuggingFace Accelerate, offre API di gestione uniformi che rimangono coerenti tra scenari di inferenza distribuiti di modelli di grandi dimensioni e modelli non distribuiti. Per ulteriori informazioni, consulta la documentazione TorchServe’s large model inference.

Container di deep learning con TorchServe

Per implementare un modello di grandi dimensioni con TorchServe su SageMaker AI, puoi utilizzare uno dei relativi container di deep learning (DLC). Per impostazione predefinita, TorchServe è installato in tutti i DLC PyTorch AWS. Durante il caricamento del modello, TorchServe è in grado di installare librerie specializzate su misura per modelli di grandi dimensioni come PiPPy, Deepspeed e Accelerate.

La tabella seguente elenca tutti i DLC SageMaker AI con TorchServe.

Nozioni di base

Prima di distribuire il modello, completa i prerequisiti. È inoltre possibile configurare i parametri del modello e personalizzare il codice del gestore.

Prerequisiti

Per iniziare, assicurati di rispettare le seguenti condizioni fondamentali:

Configurazione delle impostazioni e dei parametri del modello

TorchServe utilizza torchrun per configurare l’ambiente distribuito per l’elaborazione parallela dei modelli. TorchServe ha la capacità di supportare più worker per un modello di grandi dimensioni. Per impostazione predefinita, TorchServe utilizza un algoritmo round-robin per assegnare GPU a un worker su un host. Nel caso di inferenza di modelli di grandi dimensioni, il numero di GPU assegnate a ciascun worker viene calcolato automaticamente in base al numero di GPU specificato nel file model_config.yaml. La variabile di ambiente CUDA_VISIBLE_DEVICES, che specifica gli ID dei dispositivi GPU visibili in un determinato momento, viene impostata in base a questo numero.

Ad esempio, supponiamo che ci siano otto GPU su un nodo e che un worker abbia bisogno di quattro GPU su un nodo (nproc_per_node=4). In questo caso, TorchServe assegna quattro GPU al primo worker (CUDA_VISIBLE_DEVICES="0,1,2,3") e quattro GPU al secondo worker (CUDA_VISIBLE_DEVICES="4,5,6,7”).

Oltre a questo comportamento predefinito, TorchServe offre agli utenti la flessibilità di specificare le GPU per un worker. Ad esempio, se imposti la variabile deviceIds: [2,3,4,5] nel file YAML di configurazione del modello e imposti nproc_per_node=2, TorchServe assegna CUDA_VISIBLE_DEVICES=”2,3” al primo worker e CUDA_VISIBLE_DEVICES="4,5” al secondo worker.

Nell'esempio model_config.yaml seguente, configuriamo i parametri front-end e back-end per il modello OPT-30b. I parametri di front-end configurati sono parallelType, deviceType, deviceIds e torchrun. Per informazioni più dettagliate sui parametri del front-end che puoi configurare, consulta la documentazione di PyTorch su GitHub. La configurazione del back-end si basa su una mappa YAML che consente la personalizzazione in stile libero. Per i parametri di back-end, definiamo la configurazione DeepSpeed e i parametri aggiuntivi utilizzati dal codice del gestore personalizzato.

# TorchServe front-end parameters
minWorkers: 1
maxWorkers: 1
maxBatchDelay: 100
responseTimeout: 1200
parallelType: "tp"
deviceType: "gpu"
# example of user specified GPU deviceIds
deviceIds: [0,1,2,3] # sets CUDA_VISIBLE_DEVICES

torchrun:
    nproc-per-node: 4

# TorchServe back-end parameters
deepspeed:
    config: ds-config.json
    checkpoint: checkpoints.json

handler: # parameters for custom handler code
    model_name: "facebook/opt-30b"
    model_path: "model/models--facebook--opt-30b/snapshots/ceea0a90ac0f6fae7c2c34bcb40477438c152546"
    max_length: 50
    max_new_tokens: 10
    manual_seed: 40

Personalizzazione di gestori

TorchServe offre gestori di base e utilità di gestione per l'inferenza di modelli di grandi dimensioni creati con le librerie più diffuse. L'esempio seguente dimostra come la classe di gestione personalizzata TransformersSeqClassifierHandler estende BaseDeepSpeedHandler e utilizza le utilità del gestore. Per un esempio completo di codice, consulta il codice custom_handler.py nella documentazione di PyTorch su GitHub.

class TransformersSeqClassifierHandler(BaseDeepSpeedHandler, ABC):
    """
    Transformers handler class for sequence, token classification and question answering.
    """

    def __init__(self):
        super(TransformersSeqClassifierHandler, self).__init__()
        self.max_length = None
        self.max_new_tokens = None
        self.tokenizer = None
        self.initialized = False

    def initialize(self, ctx: Context):
        """In this initialize function, the HF large model is loaded and
        partitioned using DeepSpeed.
        Args:
            ctx (context): It is a JSON Object containing information
            pertaining to the model artifacts parameters.
        """
        super().initialize(ctx)
        model_dir = ctx.system_properties.get("model_dir")
        self.max_length = int(ctx.model_yaml_config["handler"]["max_length"])
        self.max_new_tokens = int(ctx.model_yaml_config["handler"]["max_new_tokens"])
        model_name = ctx.model_yaml_config["handler"]["model_name"]
        model_path = ctx.model_yaml_config["handler"]["model_path"]
        seed = int(ctx.model_yaml_config["handler"]["manual_seed"])
        torch.manual_seed(seed)

        logger.info("Model %s loading tokenizer", ctx.model_name)

        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.tokenizer.pad_token = self.tokenizer.eos_token
        config = AutoConfig.from_pretrained(model_name)
        with torch.device("meta"):
            self.model = AutoModelForCausalLM.from_config(
                config, torch_dtype=torch.float16
            )
        self.model = self.model.eval()

        ds_engine = get_ds_engine(self.model, ctx)
        self.model = ds_engine.module
        logger.info("Model %s loaded successfully", ctx.model_name)
        self.initialized = True

    def preprocess(self, requests):
        """
        Basic text preprocessing, based on the user's choice of application mode.
        Args:
            requests (list): A list of dictionaries with a "data" or "body" field, each
                            containing the input text to be processed.
        Returns:
            tuple: A tuple with two tensors: the batch of input ids and the batch of
                attention masks.
        """

    def inference(self, input_batch):
        """
        Predicts the class (or classes) of the received text using the serialized transformers
        checkpoint.
        Args:
            input_batch (tuple): A tuple with two tensors: the batch of input ids and the batch
                                of attention masks, as returned by the preprocess function.
        Returns:
            list: A list of strings with the predicted values for each input text in the batch.
        """
        
    def postprocess(self, inference_output):
        """Post Process Function converts the predicted response into Torchserve readable format.
        Args:
            inference_output (list): It contains the predicted response of the input text.
        Returns:
            (list): Returns a list of the Predictions and Explanations.
        """

Preparazione degli artefatti di un modello

Prima di implementare il modello su SageMaker AI, è necessario creare pacchetti degli artefatti del modello. Per i modelli di grandi dimensioni, ti consigliamo di utilizzare lo strumento torch-model-archiver di PyTorch --archive-format no-archive con l’argomento, che salta la compressione degli artefatti del modello. L'esempio seguente salva tutti gli artefatti del modello in una nuova cartella denominata opt/.

torch-model-archiver --model-name opt --version 1.0 --handler custom_handler.py --extra-files ds-config.json -r requirements.txt --config-file opt/model-config.yaml --archive-format no-archive

Una volta creata la cartella opt/, scarica il modello opt-30b nella cartella utilizzando lo strumento PyTorch Download_model.

cd opt
python path_to/Download_model.py --model_path model --model_name facebook/opt-30b --revision main

Infine, puoi caricare gli artefatti del modello su un bucket Amazon S3.

aws s3 cp opt {your_s3_bucket}/opt --recursive

Ora in Amazon S3 dovrebbero essere archiviati artefatti del modello pronti per l’implementazione su un endpoint di SageMaker AI.

Implementazione del modello utilizzando SageMaker Python SDK

Dopo aver preparato gli artefatti del modello, è possibile implementarlo su un endpoint di hosting SageMaker AI. In questa sezione viene spiegato come distribuire un unico modello di grandi dimensioni su un endpoint ed effettuare previsioni di risposta in streaming. Per ulteriori informazioni sullo streaming delle risposte dagli endpoint, consulta Invoke real-time endpoints.

Per distribuire il modello, completa le seguenti fasi:

Ora hai implementato il tuo modello su un endpoint di SageMaker AI e dovresti essere in grado di invocarlo per le risposte. Per ulteriori informazioni sugli endpoint di SageMaker AI in tempo reale, consulta Endpoint per modelli singoli.