Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Déployez de grands modèles à des fins d'inférence avec TorchServe

Ce didacticiel explique comment déployer de grands modèles et effectuer des inférences dans Amazon SageMaker AI à l'aide de TorchServe GPU intégrés. Cet exemple déploie le OPT-30b modèle sur une ml.g5 instance. Vous pouvez le modifier pour l'adapter à d'autres modèles et types d'instance. Dans les exemples, remplacez italicized placeholder text par vos propres informations.

TorchServe est une puissante plateforme ouverte pour l'inférence de modèles distribués à grande échelle. En prenant en charge des bibliothèques populaires telles que PyTorch PippY native et HuggingFace Accelerate, il propose des API de gestion uniformes qui restent cohérentes dans les scénarios d'inférence de modèles distribués et non distribués. DeepSpeed Pour plus d'informations, consultez TorchServe la documentation sur l'inférence de grands modèles.

Conteneurs de deep learning avec TorchServe

Pour déployer un grand modèle sans TorchServe SageMaker IA, vous pouvez utiliser l'un des conteneurs d'apprentissage en profondeur (DLC) SageMaker AI. Par défaut, TorchServe il est installé dans tous les AWS PyTorch DLC. Pendant le chargement du modèle, TorchServe vous pouvez installer des bibliothèques spécialisées adaptées aux grands modèles tels que PippY, Deepspeed et Accelerate.

Le tableau suivant répertorie tous les DLC SageMaker AI avec TorchServe.

Prise en main

Avant de déployer votre modèle, respectez les prérequis. Vous pouvez également configurer les paramètres de votre modèle et personnaliser le code du gestionnaire.

Conditions préalables

Avant de démarrer, vérifiez que les conditions préalables suivantes sont respectées :

Configuration des paramètres et des réglages du modèle

TorchServe permet torchrun de configurer l'environnement distribué pour le traitement parallèle des modèles. TorchServe a la capacité de prendre en charge plusieurs travailleurs pour un grand modèle. Par défaut, TorchServe utilise un algorithme circulaire pour attribuer des GPU à un travailleur sur un hôte. Dans le cas d’une inférence de grands modèles, le nombre de GPU attribué à chaque application de travail est automatiquement calculé en fonction du nombre de GPU spécifié dans le fichier model_config.yaml. La variable d’environnement CUDA_VISIBLE_DEVICES, qui spécifie les ID des dispositifs GPU visibles à un moment donné, est définie en fonction de ce nombre.

Par exemple, supposons qu’il y ait 8 GPU sur un nœud et qu’une application de travail requiert 4 GPU sur un nœud (nproc_per_node=4). Dans ce cas, TorchServe affecte quatre GPU au premier travailleur (CUDA_VISIBLE_DEVICES="0,1,2,3") et quatre GPU au second travailleur (). CUDA_VISIBLE_DEVICES="4,5,6,7”

Outre ce comportement par défaut, TorchServe offre aux utilisateurs la possibilité de spécifier des GPU pour un travailleur. Par exemple, si vous définissez la variable deviceIds: [2,3,4,5] dans le fichier YAML de configuration du modèle et que vous la définisseznproc_per_node=2, puis que vous TorchServe l'CUDA_VISIBLE_DEVICES=”2,3”assignez au premier travailleur et CUDA_VISIBLE_DEVICES="4,5” au second.

Dans l'model_config.yamlexemple suivant, nous configurons à la fois les paramètres frontaux et principaux du OPT-30b modèle. Les paramètres frontaux configurés sont parallelType, deviceType, deviceIds et torchrun. Pour plus d'informations sur les paramètres frontaux que vous pouvez configurer, consultez la PyTorch GitHub documentation. La configuration dorsale est basée sur une carte YAML qui permet une personnalisation libre. Pour les paramètres principaux, nous définissons la DeepSpeed configuration et les paramètres supplémentaires utilisés par le code du gestionnaire personnalisé.

# 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

Personnalisation des gestionnaires

TorchServe propose des gestionnaires de base et des utilitaires de gestion pour l'inférence de grands modèles construits à l'aide de bibliothèques populaires. L'exemple suivant montre comment la classe de gestionnaire personnalisée TransformersSeqClassifierHandler étend BaseDeepSpeedHandler et utilise les utilitaires de gestion. Pour un exemple de code complet, consultez le custom_handler.py code dans la PyTorch GitHub documentation.

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

Préparation des artefacts de votre modèle

Avant de déployer votre modèle sur l' SageMaker IA, vous devez empaqueter les artefacts de votre modèle. Pour les grands modèles, nous vous recommandons d'utiliser l'outil PyTorch torch-model-archiver avec l'argument--archive-format no-archive, qui ignore la compression des artefacts du modèle. L’exemple suivant enregistre tous les artefacts du modèle dans un nouveau dossier nommé 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

Une fois le opt/ dossier créé, téléchargez le OPT-30b modèle dans le dossier à l'aide de l' PyTorch Download_modeloutil.

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

Enfin, chargez les artefacts du modèle sur un compartiment Amazon S3.

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

Vous devriez maintenant avoir des artefacts de modèle stockés dans Amazon S3, prêts à être déployés sur un point de terminaison SageMaker IA.

Déployez le modèle à l'aide du SDK SageMaker Python

Après avoir préparé les artefacts de votre modèle, vous pouvez déployer votre modèle sur un point de terminaison SageMaker AI Hosting. Cette section explique comment déployer un grand modèle sur un point de terminaison et effectuer des prédictions de réponse en streaming. Pour plus d’informations sur le streaming des réponses provenant des points de terminaison, consultez Invoquer des points de terminaison en temps réel.

Pour déployer votre modèle, procédez comme suit :

Vous avez maintenant déployé votre modèle sur un terminal d' SageMaker IA et vous devriez être en mesure de l'invoquer pour obtenir des réponses. Pour plus d'informations sur les points de terminaison en temps réel de l' SageMaker IA, consultezSingle-model points de terminaison.