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

Implementa modelli di grandi dimensioni per l'inferenza con TorchServe

Questo tutorial dimostra come distribuire modelli di grandi dimensioni e fornire inferenza in Amazon SageMaker con on. TorchServe GPUs 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 native P e HuggingFace Accelerate iPPy DeepSpeed, offre un gestore uniforme APIs che rimane coerente tra scenari di inferenza distribuiti di modelli di grandi dimensioni e modelli non distribuiti. Per ulteriori informazioni, consulta la documentazione sull'inferenza TorchServedi modelli di grandi dimensioni.

Contenitori di deep learning con TorchServe

Per distribuire un modello di grandi dimensioni con TorchServe on SageMaker, puoi utilizzare uno dei contenitori di SageMaker deep learning (DLCs). Per impostazione predefinita, TorchServe è installato in tutti AWS PyTorchDLCs. Durante il caricamento del modello, TorchServe può installare librerie specializzate su misura per modelli di grandi dimensioni come PiPPy, Deepspeed e Accelerate.

La tabella seguente elenca tutti i SageMaker DLCscon 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:

Configura le impostazioni e i parametri del modello

TorchServe utilizza torchrunper configurare l'ambiente distribuito per l'elaborazione parallela dei modelli. TorchServe ha la capacità di supportare più lavoratori per un modello di grandi dimensioni. Per impostazione predefinita, TorchServe utilizza un algoritmo round-robin da assegnare a un lavoratore GPUs su un host. Nel caso di un'inferenza di modelli di grandi dimensioni, il numero GPUs assegnato a ciascun lavoratore viene calcolato automaticamente in base al numero specificato nel file. GPUs model_config.yaml La variabile di ambienteCUDA_VISIBLE_DEVICES, che specifica i GPU dispositivi IDs visibili in un determinato momento, viene impostata in base a questo numero.

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

Oltre a questo comportamento predefinito, TorchServe offre agli utenti la flessibilità di specificare GPUs un lavoratore. Ad esempio, se impostate la variabile deviceIds: [2,3,4,5] nel YAMLfile di configurazione del modello e impostatenproc_per_node=2, la TorchServe assegnate CUDA_VISIBLE_DEVICES=”2,3” al primo lavoratore e CUDA_VISIBLE_DEVICES="4,5” al secondo lavoratore.

Nell'model_config.yamlesempio seguente, configuriamo i parametri front-end e back-end per il modello -30b. OPT I parametri di front-end configurati sono parallelType, deviceType, deviceIds e torchrun. Per informazioni più dettagliate sui parametri di front-end che è possibile configurare, consulta la documentazione. PyTorch GitHub La configurazione del back-end si basa su una YAML mappa che consente la personalizzazione in stile libero. Per i parametri di back-end, definiamo la DeepSpeed configurazione 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 mostra come la classe TransformersSeqClassifierHandlerCustom Handler estende e utilizza le utilità handler. BaseDeepSpeedHandler Per un esempio completo di codice, consultate il custom_handler.pycodice nella documentazione. PyTorch 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 distribuire il modello su SageMaker, è necessario impacchettare gli artefatti del modello. Per i modelli di grandi dimensioni, ti consigliamo di utilizzare PyTorch torch-model-archiverlo strumento con l'argomento--archive-format no-archive, 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 opt/ cartella, scaricate il modello OPT -30b nella cartella utilizzando lo strumento Download_model. PyTorch

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 dovresti avere artefatti del modello archiviati in Amazon S3 pronti per la distribuzione su un endpoint. SageMaker

Implementa il modello usando Python SageMaker SDK

Dopo aver preparato gli artefatti del modello, puoi distribuirlo su un endpoint di hosting. SageMaker Questa sezione descrive come implementare 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 distribuito il tuo modello su un SageMaker endpoint e dovresti essere in grado di richiamarlo per le risposte. Per ulteriori informazioni sugli endpoint SageMaker in tempo reale, consulta. Endpoint a modello singolo