Déployez BLOOM-176B et OPT-30B sur Amazon SageMaker avec de grands modèles d'inférence Deep Learning Containers et DeepSpeed

Ces dernières années ont été marquées par un développement rapide dans le domaine du deep learning. Bien que le matériel se soit amélioré, comme avec la dernière génération d'accélérateurs de NVIDIA et d'Amazon, les praticiens avancés de l'apprentissage automatique (ML) rencontrent encore régulièrement des problèmes lors du déploiement de leurs grands modèles d'apprentissage profond pour des applications telles que le traitement du langage naturel (NLP).

Dans un article précédent, nous avons discuté capacités et paramètres configurables in Déploiement du modèle Amazon SageMaker cela peut faciliter l'inférence avec ces grands modèles. Aujourd'hui, nous annonçons un nouveau Amazon Sage Maker Conteneur de Deep Learning (DLC) que vous pouvez utiliser pour démarrer avec l'inférence de grands modèles en quelques minutes. Ce DLC regroupe certaines des bibliothèques open source les plus populaires pour l'inférence parallèle de modèles, telles que DeepSpeed ​​et Hugging Face Accelerate.

Dans cet article, nous utilisons un nouveau DLC d'inférence de grands modèles SageMaker pour déployer deux des grands modèles NLP les plus populaires : celui de BigScience. FLEUR-176B et Meta OPT-30B du référentiel Hugging Face. En particulier, nous utilisons les techniques de service Deep Java Library (DJL) et de parallélisme tenseur de DeepSpeed ​​pour atteindre une latence de 0.1 seconde par jeton dans un cas d'utilisation de génération de texte.

Vous pouvez trouver nos exemples complets de cahiers dans notre GitHub référentiel.

Techniques d'inférence de grands modèles

Les modèles linguistiques ont récemment explosé en taille et en popularité. Avec un accès facile aux zoos modèles tels que Hugging Face et une précision et des performances améliorées dans les tâches de PNL telles que la classification et la génération de texte, les praticiens se tournent de plus en plus vers ces grands modèles. Cependant, les grands modèles sont souvent trop gros pour tenir dans la mémoire d’un seul accélérateur. Par exemple, le modèle BLOOM-176B peut nécessiter plus de 350 Go de mémoire d'accélérateur, ce qui dépasse de loin la capacité des accélérateurs matériels disponibles aujourd'hui. Cela nécessite l'utilisation de techniques de modèles parallèles provenant de bibliothèques telles que DeepSpeed ​​et Hugging Face Accelerate pour distribuer un modèle sur plusieurs accélérateurs à des fins d'inférence. Dans cet article, nous utilisons le Conteneur d'inférence grand modèle SageMaker pour générer et comparer les performances de latence et de débit à l'aide de ces deux bibliothèques open source.

DeepSpeed ​​et Accelerate utilisent différentes techniques pour optimiser les grands modèles de langage à des fins d'inférence. La principale différence est celle de DeepSpeed. utilisation de noyaux optimisés. Ces noyaux peuvent améliorer considérablement la latence d'inférence en réduisant les goulots d'étranglement dans le graphe de calcul du modèle. Les noyaux optimisés peuvent être difficiles à développer et sont généralement spécifiques à une architecture de modèle particulière ; DeepSpeed ​​prend en charge les grands modèles populaires tels que OPT et BLOOM avec ces noyaux optimisés. En revanche, la bibliothèque Accelerate de Hugging Face n'inclut pas de noyaux optimisés au moment de la rédaction. Comme nous l'expliquons dans notre section sur les résultats, cette différence est responsable d'une grande partie de l'avantage en termes de performances de DeepSpeed ​​par rapport à Accelerate.

Une deuxième différence entre DeepSpeed ​​et Accelerate réside dans le type de parallélisme des modèles. Accelerate utilise le parallélisme de pipeline pour partitionner un modèle entre les couches cachées d'un modèle, tandis que DeepSpeed ​​utilise le parallélisme tensoriel pour partitionner les couches elles-mêmes. Le parallélisme des pipelines est une approche flexible qui prend en charge davantage de types de modèles et peut améliorer le débit lorsque des lots de plus grande taille sont utilisés. Le parallélisme tensoriel nécessite davantage de communication entre les GPU, car les couches de modèles peuvent être réparties sur plusieurs appareils, mais peut améliorer la latence d'inférence en engageant plusieurs GPU simultanément. Vous pouvez en apprendre davantage sur les techniques de parallélisme dans Introduction au parallélisme des modèles ainsi que Parallélisme du modèle.

Vue d'ensemble de la solution

Pour héberger efficacement de grands modèles de langage, nous avons besoin de fonctionnalités et de support dans les domaines clés suivants :

• Création et test de solutions – Compte tenu de la nature itérative du développement du ML, nous avons besoin de la capacité de créer, d'itérer rapidement et de tester le comportement du point de terminaison d'inférence lorsque ces modèles sont hébergés, y compris la capacité d'échouer rapidement. Ces modèles ne peuvent généralement être hébergés que sur des instances plus grandes comme p4dn ou g5, et étant donné la taille des modèles, le démarrage d'une instance d'inférence et l'exécution d'une itération de test peuvent prendre un certain temps. Les tests locaux comportent généralement des contraintes, car vous avez besoin d'une instance de taille similaire à tester, et ces modèles ne sont pas faciles à obtenir.
• Déployer et exécuter à grande échelle – Les fichiers modèles doivent être chargés sur les instances d'inférence, ce qui présente un défi en soi étant donné leur taille. Tar / Un-Tar, par exemple pour le Bloom-176B, prend environ 1 heure à créer et encore une heure à charger. Nous avons besoin d'un mécanisme alternatif pour permettre un accès facile aux fichiers de modèle.
• Chargement du modèle en tant que singleton – Pour un processus multi-travailleurs, nous devons nous assurer que le modèle n'est chargé qu'une seule fois afin de ne pas nous retrouver dans des conditions de concurrence et de dépenser davantage de ressources inutiles. Dans cet article, nous montrons un moyen de charger directement depuis Service de stockage simple Amazon (Amazon S3). Cependant, cela ne fonctionne que si nous utilisons les paramètres par défaut du DJL. De plus, toute mise à l’échelle des points de terminaison doit pouvoir démarrer en quelques minutes, ce qui nécessite de reconsidérer la manière dont les modèles peuvent être chargés et distribués.
• Cadres de partage – Ces modèles doivent généralement être utilisés, généralement par un mécanisme de parallélisme tensoriel ou par partitionnement de pipeline comme techniques de partitionnement typiques, et nous avons des concepts avancés comme le partitionnement ZeRO construits sur le partitionnement tensoriel. Pour plus d'informations sur les techniques de partitionnement, reportez-vous à Parallélisme du modèle. Pour y parvenir, nous pouvons avoir diverses combinaisons et utiliser des frameworks de NIVIDIA, DeepSpeed ​​et autres. Cela nécessite la capacité de tester BYOC ou d'utiliser des conteneurs 1P, de parcourir les solutions et d'exécuter des tests d'analyse comparative. Vous souhaiterez peut-être également tester diverses options d'hébergement telles que l'asynchrone, le sans serveur et autres.
• Sélection du matériel – Votre choix de matériel est déterminé par tous les points susmentionnés et par d’autres modèles de trafic, les besoins des cas d’utilisation et les tailles de modèle.

Dans cet article, nous utilisons les noyaux optimisés et les techniques de parallélisme tensoriel de DeepSpeed ​​pour héberger BLOOM-176B et OPT-30B sur SageMaker. Nous comparons également les résultats d'Accelerate pour démontrer les avantages en termes de performances des noyaux optimisés et du parallélisme tensoriel. Pour plus d'informations sur DeepSpeed ​​et Accelerate, reportez-vous à Inférence DeepSpeed : permettre une inférence efficace des modèles de transformateurs à une échelle sans précédent ainsi que Inférence BLOOM incroyablement rapide avec DeepSpeed ​​et Accelerate.

Nous utilisons DJLServing comme solution de diffusion de modèles dans cet exemple. DJLServing est une solution de service de modèles universels hautes performances optimisée par la bibliothèque Deep Java (DJL) qui est indépendante du langage de programmation. Pour en savoir plus sur DJL et DJLServing, reportez-vous à Déployez de grands modèles sur Amazon SageMaker à l'aide de DJLServing et de l'inférence parallèle de modèle DeepSpeed.

Il convient de noter que les noyaux optimisés peuvent entraîner des changements de précision et un graphe de calcul modifié, ce qui pourrait théoriquement entraîner une modification du comportement du modèle. Bien que cela puisse occasionnellement modifier le résultat de l’inférence, nous ne nous attendons pas à ce que ces différences aient un impact significatif sur les paramètres d’évaluation de base d’un modèle. Néanmoins, il est conseillé aux praticiens de confirmer que les résultats du modèle sont conformes aux attentes lors de l'utilisation de ces noyaux.

Les étapes suivantes montrent comment déployer un modèle BLOOM-176B dans SageMaker à l'aide de DJLServing et d'un conteneur d'inférence de grand modèle SageMaker. L'exemple complet est également disponible dans notre GitHub référentiel.

Utilisation de l'image DLC DJLServing SageMaker

Utilisez le code suivant pour utiliser l'image DLC DJLServing SageMaker après avoir remplacé la région par la région spécifique dans laquelle vous exécutez le notebook :

763104351884.dkr.ecr..amazonaws.com/djl-inference:0.19.0-deepspeed0.7.3-cu113
# example uri might be like 763104351884.dkr.ecr.us-east-1.amazonaws.com/djl-inference:0.19.0-deepspeed0.7.3-cu113

Créer notre fichier modèle

Tout d'abord, nous créons un fichier appelé serving.properties qui ne contient qu'une seule ligne de code. Cela indique au serveur de modèles DJL d'utiliser le moteur DeepSpeed. Le fichier contient le code suivant :

engine=DeepSpeed

serving.properties est un fichier défini par DJLServing qui est utilisé pour configurer la configuration par modèle.

Ensuite, nous créons notre model.py fichier, qui définit le code nécessaire pour charger puis servir le modèle. Dans notre code, nous lisons dans le TENSOR_PARALLEL_DEGREE variable d'environnement (la valeur par défaut est 1). Ceci définit le nombre d'appareils sur lesquels les modules tenseurs parallèles sont distribués. Notez que DeepSpeed ​​fournit quelques définitions de partition intégrées, dont une pour les modèles BLOOM. Nous l'utilisons en spécifiant replace_method ainsi que relpace_with_kernel_inject. Si vous disposez d'un modèle personnalisé et avez besoin de DeepSpeed ​​pour partitionner efficacement, vous devez modifier relpace_with_kernel_inject à false et ajouter injection_policy pour faire fonctionner la partition d'exécution. Pour plus d'informations, reportez-vous à Initialisation pour l'inférence. Pour notre exemple, nous avons utilisé le modèle BLOOM pré-partitionné sur DeepSpeed.

Deuxièmement, dans le model.py , nous chargeons également le modèle depuis Amazon S3 une fois le point de terminaison lancé. Le modèle est chargé dans le /tmp espace sur le conteneur car SageMaker mappe le /tmp à la Boutique de blocs élastiques Amazon (Amazon EBS) volume monté lorsque nous spécifions le paramètre de création de point de terminaison VolumeSizeInGB. Pour des instances comme p4dn, qui sont prédéfinies avec l'instance de volume, nous pouvons continuer à tirer parti de /tmp sur le conteneur. Voir le code suivant :

from djl_python import Input, Output
import os
import deepspeed
import torch
import torch.distributed as dist
import sys
import subprocess
import time
from glob import glob
from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
from transformers.models.opt.modeling_opt import OPTDecoderLayer

predictor = None

def check_config():
    local_rank = os.getenv('LOCAL_RANK')
    
    if not local_rank:
        return False
    return True
    
def get_model():

    if not check_config():
        raise Exception("DJL:DeepSpeed configurations are not default. This code does not support non default configurations") 
    
    tensor_parallel = int(os.getenv('TENSOR_PARALLEL_DEGREE', '1'))
    local_rank = int(os.getenv('LOCAL_RANK', '0'))
    model_dir = "/tmp/model"
    bucket = os.environ.get("MODEL_S3_BUCKET")
    key_prefix = os.environ.get("MODEL_S3_PREFIX")
    print(f"rank: {local_rank}")
    if local_rank == 0:
        if f"{model_dir}/DONE" not in glob(f"{model_dir}/*"):
            print("Starting Model downloading files")
            try:
                proc_run = subprocess.run(
                    ["aws", "s3", "cp", "--recursive", f"s3://{bucket}/{key_prefix}", model_dir]
                )
                print("Model downloading finished")
                # write file when download complete. Could use dist.barrier() but this makes it easier to check if model is downloaded in case of retry
                with open(f"{model_dir}/DONE", "w") as f:
                    f.write("download_complete")
                    
                proc_run.check_returncode() # to throw the error in case there was one
                
            except subprocess.CalledProcessError as e:
                print ( "Model download failed: Error:nreturn code: ", e.returncode, "nOutput: ", e.stderr )
                raise # FAIL FAST  
                               
    dist.barrier()
                
    
    tokenizer = AutoTokenizer.from_pretrained(model_dir)
    
    # has to be FP16 as Int8 model loading not yet supported
    with deepspeed.OnDevice(dtype=torch.float16, device="meta"):
        model = AutoModelForCausalLM.from_config(
            AutoConfig.from_pretrained(model_dir), torch_dtype=torch.bfloat16
        )
    model = model.eval()
    
    model = deepspeed.init_inference(
        model,
        mp_size=tensor_parallel,
        dtype=torch.int8,
        base_dir = model_dir,
        checkpoint=os.path.join(model_dir, "ds_inference_config.json"),
        replace_method='auto',
        replace_with_kernel_inject=True
    )

    model = model.module
    dist.barrier()
    return model, tokenizer

DJLServing gère l'installation du runtime sur tous les packages pip définis dans requirement.txt. Ce fichier aura :

awscli
boto3

Nous avons créé un répertoire appelé code et par model.py, serving.propertieset requirements.txt les fichiers sont déjà créés dans ce répertoire. Pour afficher les fichiers, vous pouvez exécuter le code suivant depuis le terminal :

mkdir -p code
cat code/model.py 
cat code/serving.properties 
cat code/requirements.txt 

La figure suivante montre la structure du model.tar.gz.

Enfin, nous créons le fichier modèle et le téléchargeons sur Amazon S3 :

tar cvfz model.tar.gz code
s3_code_artifact = sess.upload_data("model.tar.gz", bucket, s3_code_prefix)

Téléchargez et stockez le modèle de Hugging Face (facultatif)

Nous avons fourni les étapes dans cette section au cas où vous souhaiteriez télécharger le modèle sur Amazon S3 et l'utiliser à partir de là. Les étapes sont fournies dans le fichier Jupyter sur GitHub. La capture d'écran suivante montre un instantané des étapes.

Créer un modèle SageMaker

Nous créons maintenant un Modèle SageMaker. Nous utilisons le Registre des conteneurs élastiques Amazon (Amazon ECR) fournie par et l'artefact de modèle de l'étape précédente pour créer le modèle SageMaker. Dans la configuration du modèle, nous configurons TENSOR_PARALLEL_DEGREE=8, ce qui signifie que le modèle est partitionné sur 8 GPU. Voir le code suivant :

PrimaryContainer={
        "Image": inference_image_uri,
        "ModelDataUrl": s3_code_artifact,
        "Environment": {
            "MODEL_S3_BUCKET": bucket,
            "MODEL_S3_PREFIX": s3_model_prefix,
            "TENSOR_PARALLEL_DEGREE": "8",
},

Après avoir exécuté la cellule précédente dans le fichier Jupyter, vous voyez un résultat semblable à celui-ci :

{
    "ModelArn": "arn:aws:sagemaker:us-east-1::model/bloom-djl-ds-"
}

Créer un point de terminaison SageMaker

Vous pouvez utiliser n'importe quelle instance avec plusieurs GPU pour les tests. Dans cette démo, nous utilisons une instance p4d.24xlarge. Dans le code suivant, notez comment nous définissons le ModelDataDownloadTimeoutInSeconds, ContainerStartupHealthCheckTimeoutInSecondset VolumeSizeInGB paramètres pour s'adapter à la grande taille du modèle. La VolumeSizeInGB Le paramètre s'applique aux instances GPU prenant en charge l'attachement de volume EBS.

endpoint_config_response = sm_client.create_endpoint_config(
    EndpointConfigName=endpoint_config_name,
    ProductionVariants=[
        {
            "VariantName": "variant1",
            "ModelName": model_name,
            "InstanceType": "ml.p4d.24xlarge",
            "InitialInstanceCount": 1,
            #"VolumeSizeInGB" : 200,
            "ModelDataDownloadTimeoutInSeconds": 2400,
            "ContainerStartupHealthCheckTimeoutInSeconds": 2400,
        },
    ],
)'

Enfin, nous créons un point de terminaison SageMaker :

create_endpoint_response = sm_client.create_endpoint(
    EndpointName=f"{endpoint_name}", EndpointConfigName=endpoint_config_name
)

Vous le voyez imprimé dans le code suivant :

{
    "EndpointArn": "arn:aws:sagemaker:us-east-1::endpoint/bloom-djl-ds-"
}

Le démarrage du point de terminaison peut prendre un certain temps. Vous pouvez essayer plusieurs fois si vous rencontrez le InsufficientInstanceCapacity erreur, ou vous pouvez envoyer une demande à AWS pour augmenter la limite de votre compte.

L'optimisation des performances

Si vous avez l'intention d'utiliser cet article et le bloc-notes qui l'accompagne avec un modèle différent, vous souhaiterez peut-être explorer certains des paramètres réglables proposés par SageMaker, DeepSpeed ​​et DJL. L'expérimentation itérative de ces paramètres peut avoir un impact important sur la latence, le débit et le coût de votre grand modèle hébergé. Pour en savoir plus sur le réglage des paramètres tels que le nombre de nœuds de calcul, le degré de parallélisme du tenseur, la taille de la file d'attente des tâches, etc., reportez-vous à Configurations de diffusion DJL ainsi que Déployez de grands modèles sur Amazon SageMaker à l'aide de DJLServing et de l'inférence parallèle de modèle DeepSpeed.

Résultats

Dans cet article, nous avons utilisé DeepSpeed ​​pour héberger BLOOM-176B et OPT-30B sur des instances SageMaker ML. Le tableau suivant résume nos résultats de performances, y compris une comparaison avec Accelerate de Hugging Face. La latence reflète le nombre de millisecondes nécessaires pour produire quatre fois une chaîne de 256 jetons (batch_size=4) du modèle. Le débit reflète le nombre de jetons produits par seconde pour chaque test. Pour Hugging Face Accelerate, nous avons utilisé le chargement par défaut de la bibliothèque avec le mappage de la mémoire GPU. Pour DeepSpeed, nous avons utilisé son mécanisme de chargement de point de contrôle plus rapide.

Du point de vue de la latence, DeepSpeed ​​est environ 3.4 fois plus rapide pour BLOOM-176B et 5.6 fois plus rapide pour OPT-30B que Accelerate. Les noyaux optimisés de DeepSpeed ​​sont responsables d'une grande partie de cette différence de latence. Compte tenu de ces résultats, nous vous recommandons d'utiliser DeepSpeed ​​plutôt que Accelerate si le modèle de votre choix est pris en charge.

Il convient également de noter que les temps de chargement des modèles avec DeepSpeed ​​étaient beaucoup plus courts, ce qui en fait une meilleure option si vous prévoyez devoir augmenter rapidement votre nombre de points de terminaison. La technique de parallélisme de pipeline plus flexible d'Accelerate peut être une meilleure option si vous disposez de modèles ou de précisions de modèle qui ne sont pas pris en charge par DeepSpeed.

Ces résultats démontrent également la différence de latence et de débit selon les différentes tailles de modèles. Lors de nos tests, l'OPT-30B génère 2.4 fois plus de jetons par unité de temps que le BLOOM-176B sur un type d'instance plus de trois fois moins cher. Sur la base du prix par unité de débit, l'OPT-30B sur une instance g5.24xl est 8.9 fois meilleur que le BLOOM-176B sur une instance p4d.24xl. Si vous avez des limitations strictes en matière de latence, de débit ou de coût, envisagez d'utiliser le modèle le plus petit possible qui répondra toujours aux exigences fonctionnelles.

Nettoyer

Dans le cadre des bonnes pratiques, il est toujours recommandé de supprimer les instances inactives. Le code ci-dessous vous montre comment supprimer les instances.

# - Delete the end point
sm_client.delete_endpoint(EndpointName=endpoint_name)

# - In case the end point failed we still want to delete the model
sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
sm_client.delete_model(ModelName=model_name)

Supprimez éventuellement le point de contrôle du modèle de votre S3

!aws s3 rm --recursive s3:///{s3_model_prefix}

Conclusion

Dans cet article, nous avons montré comment utiliser les conteneurs d'inférence de grands modèles SageMaker pour héberger deux grands modèles de langage, BLOOM-176B et OPT-30B. Nous avons utilisé les techniques de modèle parallèle de DeepSpeed ​​avec plusieurs GPU sur une seule instance SageMaker ML.

Pour plus de détails sur Amazon SageMaker et ses capacités d'inférence de grands modèles, reportez-vous à Amazon SageMaker prend désormais en charge le déploiement de modèles volumineux via des quotas de taille de volume et de délai d'expiration configurables ainsi que Inférence en temps réel.

À propos des auteurs

Simon Zamarin est un architecte de solutions AI / ML dont l'objectif principal est d'aider les clients à extraire de la valeur de leurs actifs de données. Dans ses temps libres, Simon aime passer du temps avec sa famille, lire de la science-fiction et travailler sur divers projets de bricolage.

Rupinder Grewal est un architecte de solutions spécialisé Sr Ai/ML avec AWS. Il se concentre actuellement sur le service des modèles et des MLOps sur SageMaker. Avant d'occuper ce poste, il a travaillé en tant qu'ingénieur en apprentissage automatique pour créer et héberger des modèles. En dehors du travail, il aime jouer au tennis et faire du vélo sur les sentiers de montagne.

Franck Liu est ingénieur logiciel pour AWS Deep Learning. Il se concentre sur la création d'outils innovants d'apprentissage en profondeur pour les ingénieurs en logiciel et les scientifiques. Dans ses temps libres, il aime faire de la randonnée avec ses amis et sa famille.

Alan Tan est chef de produit senior chez SageMaker et dirige les efforts sur l'inférence de grands modèles. Il est passionné par l'application de l'apprentissage automatique au domaine de l'analyse. En dehors du travail, il aime le plein air.

Dhawal Patel est architecte principal en apprentissage machine chez AWS. Il a travaillé avec des organisations allant des grandes entreprises aux startups de taille moyenne sur des problèmes liés à l'informatique distribuée et à l'intelligence artificielle. Il se concentre sur l'apprentissage en profondeur, y compris les domaines de la PNL et de la vision par ordinateur. Il aide les clients à obtenir une inférence de modèle haute performance sur SageMaker.

Lan Qing est ingénieur en développement logiciel chez AWS. Il a travaillé sur plusieurs produits stimulants chez Amazon, notamment des solutions d'inférence ML hautes performances et un système de journalisation hautes performances. L'équipe de Qing a lancé avec succès le premier modèle de milliards de paramètres dans Amazon Advertising avec une très faible latence requise. Qing possède une connaissance approfondie de l'optimisation de l'infrastructure et de l'accélération du Deep Learning.

Qingwei Li est un spécialiste de l'apprentissage automatique chez Amazon Web Services. Il a obtenu son doctorat. en recherche opérationnelle après avoir cassé le compte de subvention de recherche de son conseiller et échoué à décerner le prix Nobel qu'il avait promis. Actuellement, il aide les clients du secteur des services financiers et de l'assurance à créer des solutions d'apprentissage automatique sur AWS. Dans ses temps libres, il aime lire et enseigner.

Robert Van Dussen est chef de produit senior chez Amazon SageMaker. Il dirige l'optimisation des modèles d'apprentissage en profondeur pour des applications telles que l'inférence de grands modèles.

Siddharth Venkatesan est ingénieur logiciel chez AWS Deep Learning. Il se concentre actuellement sur la création de solutions pour l'inférence de grands modèles. Avant AWS, il a travaillé au sein de l'organisation Amazon Grocery pour créer de nouvelles fonctionnalités de paiement pour les clients du monde entier. En dehors du travail, il aime le ski, le plein air et regarder des sports.