Ingénierie rapide
Accélération de l'inférence de grands modèles linguistiques : techniques pour un déploiement efficace
Grands modèles de langage (LLM) comme GPT-4, Lama, et PaLM repoussent les limites de ce qui est possible avec le traitement du langage naturel. Cependant, le déploiement de ces modèles massifs dans des environnements de production présente des défis importants en termes d'exigences informatiques, d'utilisation de la mémoire, de latence et de coût. À mesure que les LLM continuent de croître en taille et en capacités, l’optimisation de leurs performances d’inférence est essentielle pour les applications du monde réel.
Dans cette plongée technique approfondie, nous explorerons des techniques de pointe pour accélérer l'inférence LLM, permettant des temps de réponse plus rapides, un débit plus élevé et une utilisation plus efficace des ressources matérielles. Nous couvrirons des méthodes allant des techniques de précision numérique et de nouveaux mécanismes d'attention aux innovations architecturales conçues explicitement pour une génération de texte efficace.
Commençons par comprendre pourquoi l'inférence LLM est si difficile par rapport aux modèles PNL traditionnels.
Le défi de l'inférence avec les grands modèles de langage
Avant l'avènement des LLM, le traitement du langage naturel reposait sur des modèles plus petits axés sur des tâches spécifiques telles que la classification de texte, la reconnaissance d'entités nommées et l'analyse des sentiments. Bien qu’ils nécessitent encore beaucoup de calculs, ces modèles pourraient être déployés sur du matériel modeste et suivre des processus d’inférence relativement simples.
Les LLM, en revanche, représentent un changement de paradigme. Ces modèles sont formés sur de vastes ensembles de données utilisant des milliards de paramètres, ce qui leur permet d'effectuer un large éventail de tâches linguistiques avec une maîtrise remarquable. Cependant, cette puissance a un coût : des exigences de calcul considérablement accrues, tant lors de la formation que de l’inférence.
L'un des principaux défis est la nature autorégressive de la génération de texte avec les LLM. Pour produire un texte de type humain, ces modèles prédisent un jeton (mot ou sous-mot) à la fois, chaque nouveau jeton dépendant de la sortie générée précédemment. Cette dépendance séquentielle empêche une parallélisation efficace et entraîne des exigences de calcul qui évoluent de manière polynomiale avec la longueur de la séquence.
De plus, les LLM nécessitent souvent de longues séquences de saisie (invites) pour établir le contexte nécessaire à la génération de texte de haute qualité. Des longueurs d'entrée plus longues nécessitent plus de mémoire pour stocker les états intermédiaires et les matrices d'attention, ce qui met encore plus à rude épreuve les ressources matérielles.
Face à ces défis uniques, les techniques d'optimisation traditionnelles telles que la quantification et les graphiques de calcul statique peuvent échouer et avoir du mal à maintenir les performances LLM tout en offrant des accélérations significatives. Examinons certaines des stratégies clés conçues explicitement pour accélérer l'inférence LLM.
Techniques de précision numérique
De 32 bits à 16 bits de précision
Une piste pour accélérer LLM l’inférence consiste à tirer parti d’une précision numérique réduite pour les poids et les activations du modèle. Les frameworks d'apprentissage profond modernes tels que PyTorch et TensorFlow utilisent généralement par défaut une précision en virgule flottante de 32 bits (FP32). Cependant, des recherches ont montré que les LLM peuvent souvent maintenir une grande précision même lorsqu'ils fonctionnent avec des précisions inférieures, telles que des entiers de 16 bits (FP16), de 8 bits (INT8) ou même des entiers de 4 bits (INT4).
La réduction de la précision numérique offre plusieurs avantages :
- Empreinte mémoire réduite: Les représentations de plus faible précision nécessitent moins de mémoire, ce qui permet à des modèles ou à des tailles de lots plus grands de s'adapter aux mêmes contraintes matérielles.
- Calcul plus rapide: De nombreux processeurs et GPU modernes fournissent des instructions spécialisées et une accélération matérielle pour des calculs arithmétiques de moindre précision, permettant des accélérations significatives.
- Efficacité énergétique améliorée: Avec des besoins en mémoire réduits et des calculs plus rapides, une inférence de moindre précision peut se traduire par une consommation d’énergie réduite – un avantage crucial pour les déploiements en périphérie et mobiles.
Bien que puissantes, les techniques de précision numérique introduisent une certaine perte de précision par rapport au fonctionnement du FP32. La clé consiste à évaluer soigneusement ce compromis entre les gains de calcul et la dégradation potentielle des performances pour votre cas d'utilisation spécifique.
Il existe deux approches principales de quantification avec les LLM :
Quantification post-formation (PTQ): Dans cette méthode, un LLM est d'abord formé en utilisant la précision standard FP32. Après l'entraînement, les poids du modèle sont quantifiés (convertis) dans un format de précision inférieure comme INT8 ou INT4. Le PTQ est simple à mettre en œuvre mais peut entraîner des baisses de précision plus importantes.
Formation basée sur la quantification (QAT): Avec QAT, le processus de quantification est simulé pendant la phase d'entraînement elle-même. Cela permet au modèle d'apprendre à compenser les erreurs de quantification, minimisant ainsi la dégradation de la précision lorsque le modèle quantifié final est déployé. QAT est plus impliqué mais donne souvent de meilleurs résultats que PTQ.
Pour une application pratique, on pourrait exploiter les modèles pré-quantifiés disponibles sur des plateformes comme Étreindre le visage, qui héberge une variété de modèles optimisés grâce à différentes méthodes de quantification. Par exemple, si un modèle quantifié à l'aide d'Auto-GPTQ est souhaité, les utilisateurs peuvent facilement le charger à l'aide de la bibliothèque de transformateurs de Hugging Face. De plus, pour quantifier un modèle, des outils tels qu'AutoGPTQ peuvent être utilisés, qui s'intègrent de manière transparente aux bibliothèques existantes pour compresser efficacement le modèle.
Voici un exemple de chargement d'un modèle Llama-2-7b pré-quantifié à l'aide de la bibliothèque de transformateurs Hugging Face :
from transformers import AutoModelForCausalLM, AutoTokenizer model_id = "TheBloke/Llama-2-7b-Chat-GPTQ" tokenizer = AutoTokenizer.from_pretrained(model_id) model = AutoModelForCausalLM.from_pretrained(model_id) And for custom quantization, one might follow these steps using the AutoGPTQ toolkit: from transformers import AutoModelForCausalLM, AutoTokenizer, GPTQConfig model_id = "llama-2-7b-original" tokenizer = AutoTokenizer.from_pretrained(model_id) quantization_config = GPTQConfig(bits=4, dataset="your-dataset", tokenizer=tokenizer) model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=quantization_config)
N'oubliez pas que la quantification peut nécessiter un réglage fin post-quantification ou une ingénierie rapide pour maintenir la qualité du modèle. Pour une nouvelle quantification, vous pouvez contribuer à la communauté en poussant vos modèles quantifiés vers des plateformes comme Hugging Face.
Assurez-vous toujours d'équilibrer la taille du modèle, les exigences de calcul et les performances lors de la sélection de la stratégie de quantification pour votre cas d'utilisation spécifique.
L'algorithme d'attention flash
Le mécanisme d'attention multi-têtes est un composant essentiel des LLM basés sur des transformateurs, permettant au modèle de capturer des dépendances à longue portée et des représentations contextualisées. Cependant, cette opération d'attention est inefficace sur le plan informatique pour la génération de texte autorégressive, car elle nécessite de recalculer bon nombre des mêmes valeurs pour chaque nouveau jeton.
Les Algorithme Flash Attention, présenté dans l'article FlashAttention, offre une approche plus efficace en mémoire et plus conviviale pour la parallélisation de l'opération d'attention. Au lieu de recalculer les valeurs d'attention pour chaque jeton, Flash Attention met en cache et réutilise les matrices clé/valeur intermédiaires, évitant ainsi les calculs redondants.
Cette optimisation réduit non seulement la surcharge de calcul, mais améliore également les modèles d'accès à la mémoire, conduisant à une meilleure utilisation de la bande passante mémoire du GPU et du parallélisme.
Bien que les détails de Flash Attention soient assez complexes, l'idée de haut niveau est de décomposer l'opération d'attention en deux phases :
- Incorporation de la somme des préfixes: Cette phase calcule et met en cache les intégrations clé/valeur pour tous les jetons d'entrée, permettant une réutilisation efficace lors de la génération.
- Attention causale: L'opération d'attention réelle, désormais optimisée pour exploiter les intégrations clé/valeur mises en cache de la première phase.
En séparant ces phases, Flash Attention peut tirer parti des opérations GPU hautement parallèles, accélérant considérablement le goulot d'étranglement de l'attention dans l'inférence LLM.
Voici une brève illustration conceptuelle de la mise en œuvre de Flash Attention avec un LLM :
from transformers import AutoModelForCausalLM
import torch
from flash_attention import flash_attention
# Load an LLM like OctoCoder
model = AutoModelForCausalLM.from_pretrained("bigcode/octocoder")
# Sample system prompt that guides the model towards being a better coding assistant
system_prompt = """... (system prompt details) ..."""
# Preparing a longer input with the system prompt
long_prompt = system_prompt + "Question: Please write a function in Python that transforms bytes to Gigabytes."
# Converting the model for Flash Attention optimization
model.to_bettertransformer()
# Running the model with Flash Attention
start_time = time.time()
with torch.backends.cuda.sdp_kernel(enable_flash=True):
result = model.generate(long_prompt, max_new_tokens=60)
print(f"Generated in {time.time() - start_time} seconds.")
Bien que Flash Attention offre des gains de performances impressionnants, il fonctionne au sein de l'architecture de transformateur existante. Pour libérer pleinement le potentiel de l’inférence LLM accélérée, nous devons explorer des innovations architecturales spécifiquement adaptées à cette tâche.
Élagage des LLM
L'élagage des LLM est une technique permettant de réduire la taille du modèle tout en conservant la fonctionnalité. Il utilise un estimateur dépendant des données pour l'importance du poids basé sur des approximations de la matrice de Hesse. Lors de l'élagage, les groupes de poids moins importants sont supprimés, puis le modèle est affiné pour retrouver la précision. Le package LLM-Pruner propose des scripts d’élagage avec diverses stratégies prises en charge. L'élagage comprend la découverte des dépendances, l'estimation des contributions du groupe et une étape de récupération impliquant un bref post-entraînement.
Voici un exemple de code Python simplifié démontrant l'utilisation de LLM-Sécateur pour un modèle LLaMa :
from transformers import AutoModelForSequenceClassification
from pruning import LLMPruner
# Load pre-trained LLaMa model
model = AutoModelForSequenceClassification.from_pretrained("llama-base")
# Initialize the pruner with desired configuration
pruner = LLMPruner(
model,
pruning_ratio=0.25,
block_mlp_layers=(4, 30),
block_attention_layers=(4, 30),
pruner_type='taylor'
)
# Execute pruning
pruned_model = pruner.prune()
# Fine-tune the pruned model
pruned_model.fine_tune(training_data)
Cette esquisse de code représente le chargement d'un modèle LLaMa pré-entraîné, la configuration du sécateur avec des configurations spécifiques (comme les couches à élaguer et le type de sécateur), l'exécution du processus d'élagage et enfin, le réglage fin du modèle élagué.
Notez que pour une implémentation réelle, vous devrez fournir des détails tels que le nom du modèle spécifique, les chemins d'accès aux données et des paramètres supplémentaires pour le processus de réglage fin. Sachez également que ce code est une représentation conceptuelle et que la syntaxe réelle peut varier en fonction de la bibliothèque et des versions utilisées.
Innovations architecturales pour une génération de texte efficace
L'architecture du transformateur, bien que très efficace pour les tâches de modélisation du langage, a été conçue comme un modèle séquence à séquence à usage général. Lors du déploiement de LLM pour des tâches de génération de texte avec des contextes de saisie longs, les chercheurs ont découvert que des architectures plus spécialisées peuvent améliorer considérablement l'efficacité de l'inférence sans sacrifier la qualité.
Voici quelques-unes des innovations architecturales clés permettant une inférence LLM plus rapide :
Alibi: L'architecture Alibi, introduite dans l'article PAL-Instruction, sépare la modélisation du contexte d'entrée long du processus de génération de texte lui-même. Il utilise une représentation compressée du contexte d'entrée (l'« alibi ») pour initialiser le processus de génération, évitant ainsi d'avoir à traiter la séquence d'entrée complète à plusieurs reprises pendant la génération autorégressive.
Encastrements rotatifs: Au lieu d'utiliser des intégrations positionnelles standard, la technique d'intégration rotative utilise des matrices de rotation pour coder plus efficacement les informations de position. Il a été démontré que cette approche améliore les performances et permet le traitement de séquences d'entrée plus longues.
Attention multi-requêtes (MQA): Dans l'attention traditionnelle, chaque jeton de sortie s'occupe de l'intégralité de la séquence d'entrée, ce qui entraîne un calcul redondant. MQA reformule l'opération d'attention pour partager les calculs sur plusieurs jetons de sortie, réduisant ainsi la complexité globale.
Attention aux requêtes multiples
Attention aux requêtes groupées (GQA): S'appuyant sur MQA, GQA regroupe les jetons de sortie en clusters et calcule l'attention conjointement pour chaque cluster. Cette approche réduit encore les exigences de calcul tout en conservant une génération de texte de haute qualité.
Bien qu'elles soient encore en recherche et développement actif, ces innovations architecturales ont démontré des accélérations impressionnantes pour les tâches d'inférence LLM, en particulier lorsqu'elles sont combinées avec des techniques telles que Flash Attention et l'optimisation de la précision numérique.
Considérations relatives au déploiement dans le monde réel
Au-delà des algorithmes et des architectures de base, il existe plusieurs considérations et compromis pratiques à prendre en compte lors du déploiement de LLM dans des environnements de production :
Accélération matérielle: Bien que les processeurs puissent gérer l'inférence LLM, les GPU et autres accélérateurs comme les TPU de Google sont essentiels pour atteindre un débit élevé et une faible latence. Choisir le bon matériel et optimiser l’utilisation de la mémoire est crucial.
Traitement par lots et parallélisme: Pour exploiter pleinement le parallélisme matériel, des stratégies telles que l'inférence par lots (traitement de plusieurs entrées simultanément) et le parallélisme de modèles (distribution d'un LLM sur plusieurs appareils) peuvent augmenter considérablement le débit.
Compromis entre quantification et qualité: Le degré de quantification (8 bits, 4 bits, etc.) aura un impact direct sur la vitesse d'inférence et l'utilisation de la mémoire, mais affectera également la qualité de sortie. Ce compromis doit être soigneusement évalué pour chaque cas d’utilisation.
Distillation modèle: Alternative à la quantification, les techniques de distillation de modèles peuvent compresser de grands LLM en modèles d'étudiant plus petits et plus efficaces tout en conservant une grande précision.
Mise en cache et temps d'exécution optimisés: Les environnements d'exécution d'apprentissage en profondeur optimisés comme TensorRT de NVIDIA et les frameworks conçus pour le service LLM (par exemple, Composable Inference Suite de MosaicML) peuvent fournir des améliorations significatives des performances grâce à des techniques telles que la fusion d'opérateurs, l'optimisation du noyau et des stratégies de mise en cache intelligentes.
Le chemin vers un déploiement LLM optimal implique souvent de combiner plusieurs techniques tout en tenant soigneusement compte des exigences spécifiques de votre application, des contraintes d'infrastructure et des objectifs de performances.
Conclusion
Alors que les grands modèles de langage poursuivent leur évolution rapide, l’accélération de leurs performances d’inférence devient de plus en plus cruciale pour permettre des applications du monde réel et démocratiser l’accès à ces puissantes capacités d’IA.
Dans ce guide technique, nous avons exploré des techniques de pointe couvrant l'optimisation de la précision numérique, de nouveaux algorithmes d'attention comme Flash Attention et des innovations architecturales conçues pour une génération de texte efficace. Bien que chaque approche offre ses propres avantages, le véritable pouvoir réside souvent dans la combinaison de plusieurs stratégies tout en naviguant dans les compromis complexes entre vitesse, utilisation de la mémoire et qualité de sortie.
Pour l’avenir, nous pouvons nous attendre à une recherche et un développement continus dans ce domaine, alimentés par la demande insatiable de LLM plus performants et plus accessibles. De l'accélération matérielle et de la compression de modèles aux architectures entièrement nouvelles, la quête d'une inférence LLM efficace reste une frontière passionnante dans le monde du traitement du langage naturel et de l'intelligence artificielle.
