Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Implementación de modelos grandes para la inferencia con TorchServe

En este tutorial se muestra cómo implementar modelos grandes y realizar inferencias en Amazon SageMaker AI con TorchServe en las GPU. En este ejemplo, se implementa el modelo OPT-30b en una instancia ml.g5. Puede modificarlo para que funcione con otros modelos y tipos de instancias. En el ejemplo, sustituya italicized placeholder text por su propia información.

TorchServe es una potente plataforma abierta para la inferencia de modelos distribuidos de gran tamaño. Al ser compatible con bibliotecas generales como PyTorch, PiPPY nativo, DeepSpeed y HuggingFace Accelerate, ofrece API de controladores uniformes que siguen siendo coherentes en todos los escenarios de inferencia de modelos distribuidos de gran tamaño y no distribuidos. Para obtener más información, consulte la documentación de inferencia de modelos grandes de TorchServe.

Contenedores de aprendizaje profundo con TorchServe

Para implementar un modelo grande con TorchServe en SageMaker AI, puede utilizar uno de los contenedores de aprendizaje profundo (DLC) de SageMaker AI. De forma predeterminada, TorchServe está instalado en todos los DLC de AWS PyTorch. Durante la carga de modelos, TorchServe puede instalar bibliotecas especializadas diseñadas para modelos grandes, como PiPPy, Deepspeed y Accelerate.

En la siguiente tabla se enumeran todos los DLC de SageMaker AI con TorchServe.

Introducción

Antes de implementar el modelo, complete los requisitos previos. También se pueden configurar los parámetros del modelo y personalizar el código del controlador.

Requisitos previos

Antes de comenzar, compruebe que cumple los siguientes requisitos previos:

Configure los ajustes y los parámetros del modelo

TorchServe usa torchrun para configurar el entorno distribuido para el procesamiento paralelo de modelos. TorchServe tiene la capacidad de admitir a varios trabajadores en un modelo grande. De forma predeterminada, TorchServe utiliza un algoritmo por turnos para asignar las GPU a un trabajador en un host. En el caso de inferencias de modelos grandes, la cantidad de GPU asignadas a cada trabajador se calcula automáticamente en función de la cantidad de GPU especificada en el archivo model_config.yaml. La variable de entorno CUDA_VISIBLE_DEVICES, que especifica los ID de los dispositivos de GPU que están visibles en un momento específico, se establece en función de este número.

Por ejemplo, supongamos que hay 8 GPU en un nodo y un trabajador necesita 4 GPU en un nodo (nproc_per_node=4). En este caso, TorchServe asigna cuatro GPU al primer trabajador (CUDA_VISIBLE_DEVICES="0,1,2,3") y cuatro GPU al segundo trabajador (CUDA_VISIBLE_DEVICES="4,5,6,7”).

Además de este comportamiento predeterminado, TorchServe ofrece a los usuarios la flexibilidad de especificar las GPU para un trabajador. Por ejemplo, si establece la variable deviceIds: [2,3,4,5] en el archivo model config YAML y establece nproc_per_node=2, TorchServe asigna CUDA_VISIBLE_DEVICES=”2,3” al primer trabajador CUDA_VISIBLE_DEVICES="4,5” al segundo trabajador.

En el siguiente model_config.yaml ejemplo, configuramos tanto los parámetros de front-end como de back-end correspondientes al modelo OPT-30b . Los parámetros de front-end configurados son parallelType, deviceType, deviceIds y torchrun. Para obtener información más detallada sobre los parámetros de front-end que puede configurar, consulte la documentación de PyTorch GitHub. La configuración de back-end se basa en un mapa YAML que permite una personalización de estilo libre. Para los parámetros de back-end, definimos la configuración de DeepSpeed y los parámetros adicionales que utiliza el código de controlador personalizado.

# 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

Personalización de controladores

TorchServe ofrece controladores básicos y utilidades de controlador para la inferencia de modelos grandes creados con bibliotecas populares. El siguiente ejemplo muestra cómo la clase de controlador personalizado TransformersSeqClassifierHandler amplía BaseDeepSpeedHandler y utiliza las utilidades de controlador. Para ver un ejemplo de código completo, consulte el custom_handler.py código en la documentación de 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.
        """

Preparación de los artefactos de su modelo

Antes de implementar el modelo en SageMaker AI, debe empaquetar los artefactos del modelo. Para modelos grandes, le recomendamos que utilice la herramienta torch-model-archiver de PyTorch con el argumento --archive-format no-archive, que omite la compresión de los artefactos del modelo. El siguiente ejemplo guarda todos los artefactos del modelo en una nueva carpeta denominada 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 vez creada la opt/ carpeta, descargue el modelo OPT-30b a la carpeta mediante la herramienta Download_model de PyTorch.

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

Por último, cargue los artefactos del modelo en un bucket de Amazon S3.

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

Ahora debe tener los artefactos del modelo almacenados en Amazon S3 y listos para implementarse en un punto de conexión de SageMaker AI.

Implemente el modelo mediante el SDK de SageMaker

Tras preparar los artefactos del modelo, puede implementarlo en un punto de conexión de alojamiento de SageMaker AI. En esta sección se describe cómo implementar un único modelo grande en un punto de conexión y realizar predicciones de respuesta en transmisión. Para obtener más información sobre la transmisión de las respuestas desde los puntos de conexión, consulte Invocar puntos de conexión en tiempo real.

Para implementar el modelo, siga los pasos que se describen a continuación:

Ya ha implementado su modelo en un punto de conexión de SageMaker AI y debería poder invocarlo para obtener respuestas. Para obtener más información sobre los puntos de conexión en tiempo real de SageMaker AI, consulte Puntos de conexión de modelo único.