Prompt engineering
Accélérer l’inférence des modèles de langage à grande échelle : techniques pour un déploiement efficace
Ajouter Unite.AI à vos sources préférées sur Google
Les modèles de langage à grande échelle (LLM) comme GPT-4, LLaMA, et PaLM sont en train de repousser les limites de ce qui est possible avec le traitement automatique des langues. Cependant, le déploiement de ces modèles massifs dans des environnements de production présente des défis importants en termes d’exigences computationnelles, d’utilisation de la mémoire, de latence et de coût. Alors que les LLM continuent de grandir en taille et en capacité, l’optimisation de leur performance d’inférence est cruciale pour les applications du monde réel.
Dans cette plongée technique, nous allons explorer les techniques de pointe pour accélérer l’inférence des LLM, permettant des temps de réponse plus rapides, un débit plus élevé et une utilisation plus efficace des ressources matérielles. Nous allons aborder des méthodes allant des techniques de précision numérique et des mécanismes d’attention novateurs aux innovations architecturales conçues spécifiquement pour la génération de texte efficace.
Commençons par comprendre pourquoi l’inférence des LLM est si difficile par rapport aux modèles de traitement automatique des langues traditionnels.
Le défi de l’inférence avec les modèles de langage à grande échelle
Avant l’avènement des LLM, le traitement automatique des langues reposait sur des modèles plus petits axés sur des tâches spécifiques comme la classification de texte, la reconnaissance d’entités nommées et l’analyse des sentiments. Même si ces modèles étaient déjà intensifs en termes de calcul, ils pouvaient être déployés sur du matériel modeste et suivaient des processus d’inférence relativement simples.
Les LLM, en revanche, représentent un changement de paradigme. Ces modèles sont formés sur des ensembles de données massifs en utilisant des milliards de paramètres, leur permettant d’effectuer une large gamme de tâches de langage avec une remarquable efficacité. Cependant, cette puissance a un coût – des exigences computationnelles dramatiquement accrues pendant à la fois l’entraînement et l’inférence.
Un des défis clés est la nature autorégressive de la génération de texte avec les LLM. Pour produire du texte ressemblant à celui des humains, ces modèles prédisent un jeton (mot ou sous-mot) à la fois, avec 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 aboutit à des exigences computationnelles qui augmentent de manière polynomiale avec la longueur de la séquence.
En outre, les LLM nécessitent souvent de longues séquences d’entrée (prompts) pour établir le contexte nécessaire à une génération de texte de haute qualité. Des longueurs d’entrée plus longues exigent plus de mémoire pour stocker les états intermédiaires et les matrices d’attention, ce qui sollicite encore plus les ressources matérielles.
Avec ces défis uniques, les techniques d’optimisation traditionnelles comme la quantification et les graphiques de calcul statiques peuvent être insuffisantes, luttant pour maintenir les performances des LLM tout en offrant des accélérations significatives. Plongeons dans certaines des stratégies clés conçues spécifiquement pour accélérer l’inférence des LLM.
Techniques de précision numérique
De la précision 32 bits à 16 bits
Une voie pour accélérer l’inférence des LLM est d’utiliser une précision numérique réduite pour les poids et les activations du modèle. Les cadres de deep learning modernes comme PyTorch et TensorFlow emploient généralement une précision à virgule flottante de 32 bits (FP32) par défaut. Cependant, la recherche a montré que les LLM peuvent souvent maintenir une grande précision même lorsqu’ils fonctionnent à des précisions plus basses, telles que 16 bits (FP16), 8 bits entiers (INT8) ou même 4 bits entiers (INT4).
La réduction de la précision numérique offre plusieurs avantages:
- Empreinte mémoire réduite: Les représentations à plus basse précision nécessitent moins de mémoire, permettant ainsi à des modèles plus grands ou à des lots plus importants de rentrer dans les mêmes contraintes matérielles.
- Calcul plus rapide: De nombreux processeurs et GPU modernes fournissent des instructions spécialisées et un matériel accéléré pour l’arithmétique à plus basse précision, permettant ainsi des accélérations significatives.
- Meilleure efficacité énergétique: Avec des exigences de mémoire plus faibles et des calculs plus rapides, l’inférence à plus basse précision peut se traduire par une consommation d’énergie réduite – un avantage crucial pour les déploiements sur le bord et les appareils mobiles.
Bien que puissantes, les techniques de précision numérique introduisent une certaine perte de précision par rapport à l’opération FP32. La clé est d’évaluer soigneusement ce compromis entre les gains computationnels et la dégradation potentielle des performances pour votre cas d’utilisation spécifique.
Il existe deux approches principales de quantification pour les LLM:
Quantification après l’entraînement (PTQ): Dans cette méthode, un LLM est d’abord entraîné en utilisant la précision FP32 standard. Après l’entraînement, les poids du modèle sont quantifiés (convertis) en un format de précision plus bas comme INT8 ou INT4. La PTQ est simple à mettre en œuvre mais peut entraîner de plus grandes pertes de précision.
Entraînement avec prise en compte de la quantification (QAT): Avec la 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é. La QAT est plus complexe mais donne souvent de meilleurs résultats par rapport à la PTQ.
Pour une application pratique, on pourrait utiliser des modèles pré-quantifiés disponibles sur des plateformes comme Hugging Face, qui héberge une variété de modèles optimisés à l’aide de différentes méthodes de quantification. Par exemple, si un modèle quantifié en utilisant Auto-GPTQ est souhaité, les utilisateurs peuvent facilement le charger en utilisant la bibliothèque de transformateurs de Hugging Face. De plus, pour quantifier un modèle, des outils comme AutoGPTQ peuvent être utilisés, qui s’intègrent parfaitement aux bibliothèques existantes pour compresser le modèle de manière efficace.
Voici un exemple de chargement d’un modèle Llama-2-7b pré-quantifié en utilisant la bibliothèque de transformateurs de Hugging Face:
from transformers import AutoModelForCausalLM, AutoTokenizer <p>model_id = "TheBloke/Llama-2-7b-Chat-GPTQ" tokenizer = AutoTokenizer.from_pretrained(model_id) model = AutoModelForCausalLM.from_pretrained(model_id) Et pour une quantification personnalisée, on pourrait suivre ces étapes en utilisant l'outil AutoGPTQ:</p> <p>from transformers import AutoModelForCausalLM, AutoTokenizer, GPTQConfig</p> <p>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)</p>
Rappelez-vous que la quantification peut nécessiter un affinage post-quantification ou une ingénierie de prompt pour maintenir la qualité du modèle. Pour une nouvelle quantification, vous pouvez contribuer à la communauté en poussant vos modèles quantifiés sur des plateformes comme Hugging Face.
Assurez-vous toujours de trouver un équilibre entre la taille du modèle, les exigences computationnelles 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ête est un composant clé des LLM basés sur les transformateurs, permettant au modèle de capturer les dépendances à longue portée et les représentations contextualisées. Cependant, cette opération d’attention est computationnellement inefficace pour la génération de texte autorégressive, car elle nécessite de recalculer de nombreuses valeurs pour chaque nouveau jeton.
L’algorithme d’attention Flash, introduit dans le document FlashAttention, fournit une approche plus efficace en termes de mémoire et plus favorable à la parallélisation pour l’opération d’attention. Au lieu de recalculer les valeurs d’attention pour chaque jeton, l’algorithme d’attention Flash met en cache et réutilise les matrices clé/valeur intermédiaires, évitant ainsi les calculs redondants.
Cette optimisation réduit non seulement la charge computationnelle mais améliore également les modèles d’accès à la mémoire, conduisant à une meilleure utilisation de la bande passante de la mémoire GPU et du parallélisme.
Bien que les détails de l’algorithme d’attention Flash soient assez complexes, l’idée de base est de décomposer l’opération d’attention en deux phases:
- Intégration de l’embedding de préfixe: Cette phase calcule et met en cache les embeddings de clé/valeur pour tous les jetons d’entrée, permettant ainsi une réutilisation efficace pendant la génération.
- Attention causale: L’opération d’attention réelle, maintenant optimisée pour exploiter les embeddings de clé/valeur mis en cache de la première phase.
En séparant ces phases, l’algorithme d’attention Flash peut tirer parti des opérations parallèles hautement parallèles des GPU, accélérant ainsi de manière significative le goulet d’étranglement de l’attention dans l’inférence des LLM.
Voici une brève illustration conceptuelle de la mise en œuvre de l’algorithme d’attention Flash avec un LLM:
from transformers import AutoModelForCausalLM
import torch
from flash_attention import flash_attention
<p># Charger un LLM comme OctoCoder
model = AutoModelForCausalLM.from_pretrained("bigcode/octocoder")</p>
<p># Exemple de prompt système qui guide le modèle pour qu'il soit un meilleur assistant de codage
system_prompt = """... (détails du prompt système) ..."""</p>
<p># Préparation d'une entrée plus longue avec le prompt système
long_prompt = system_prompt + "Question: Écrivez une fonction en Python qui transforme les octets en gigaoctets."</p>
<p># Conversion du modèle pour l'optimisation de l'algorithme d'attention Flash
model.to_bettertransformer()</p>
<p># Exécution du modèle avec l'algorithme d'attention Flash
start_time = time.time()
with torch.backends.cuda.sdp_kernel(enable_flash=True):
result = model.generate(long_prompt, max_new_tokens=60)
print(f"Généré en {time.time() - start_time} secondes.")
Bien que l’algorithme d’attention Flash offre des gains de performance impressionnants, il fonctionne dans l’architecture de transformateur existante. Pour libérer pleinement le potentiel de l’inférence accélérée des LLM, nous devons explorer les innovations architecturales conçues spécifiquement pour cette tâche.
Élagage des LLM
L’élagage des LLM est une technique pour réduire la taille du modèle tout en maintenant sa fonctionnalité. Elle utilise un estimateur de l’importance des poids basé sur des approximations de la matrice de Hessian. Dans l’élagage, les groupes de poids moins importants sont supprimés, puis le modèle est affiné pour récupérer la précision. Le package LLM-Pruner propose des scripts pour l’élagage avec différentes stratégies prises en charge. L’élagage comprend la découverte des dépendances, l’estimation des contributions des groupes et une phase de récupération impliquant un court affinage post-formation.
Voici un exemple de code Python simplifié démontrant l’utilisation de LLM-Pruner pour un modèle LLaMa:
from transformers import AutoModelForSequenceClassification from pruning import LLMPruner <p># Charger le modèle LLaMa pré-entraîné model = AutoModelForSequenceClassification.from_pretrained("llama-base")</p> <p># Initialiser l'élagueur avec la configuration souhaitée pruner = LLMPruner( model, pruning_ratio=0.25, block_mlp_layers=(4, 30), block_attention_layers=(4, 30), pruner_type='taylor' )</p> <p># Exécuter l'élagage pruned_model = pruner.prune()</p> <p># Affiner le modèle élagué pruned_model.fine_tune(training_data)
Ce code représente le chargement d’un modèle LLaMa pré-entraîné, la configuration de l’élagueur avec des paramètres spécifiques (comme les couches à élaguer et le type d’élagueur), l’exécution du processus d’élagage et enfin l’affinage du modèle élagué.
Notez que pour une mise en œuvre réelle, vous devriez remplir les détails tels que le nom spécifique du modèle, les chemins d’accès aux données et les paramètres supplémentaires pour le processus d’affinage. De plus, soyez conscient 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 la génération de texte efficace
L’architecture de transformateur, bien qu’extrêmement efficace pour les tâches de modélisation de langage, a été conçue comme un modèle de séquence à séquence généraliste. Lors du déploiement des LLM pour les tâches de génération de texte avec des contextes d’entrée longs, les chercheurs ont constaté que des architectures plus spécialisées peuvent améliorer considérablement l’efficacité de l’inférence sans sacrifier la qualité.
Voici certaines des innovations architecturales clés permettant une inférence des LLM plus rapide:
Alibi: L’architecture Alibi, introduite dans le document PAL-Instruction, sépare la modélisation du contexte d’entrée long de la génération de texte elle-même. Elle utilise une représentation compressée du contexte d’entrée (l'”alibi”) pour initialiser le processus de génération, évitant ainsi de traiter à nouveau la séquence d’entrée complète pendant la génération autorégressive.
Embeddings rotatifs: Au lieu d’utiliser des embeddings positionnels standard, la technique d’embeddings rotatifs utilise des matrices de rotation pour encoder l’information positionnelle de manière plus efficace. Cette approche a été montrée pour améliorer les performances et permettre le traitement de séquences d’entrée plus longues.
Attention multi-requête (MQA): Dans l’attention traditionnelle, chaque jeton de sortie fait attention à la séquence d’entrée complète, aboutissant à des calculs redondants. La MQA reformule l’opération d’attention pour partager les calculs entre plusieurs jetons de sortie, réduisant ainsi la complexité globale.
Attention multi-requête
Attention à requête groupée (GQA): En s’appuyant sur la MQA, la GQA regroupe les jetons de sortie en clusters et calcule l’attention conjointement pour chaque cluster. Cette approche réduit encore les exigences computationnelles tout en maintenant une génération de texte de haute qualité.
Bien que ces innovations architecturales soient encore en cours de recherche et de développement, elles ont déjà démontré des accélérations impressionnantes pour les tâches d’inférence des LLM, en particulier lorsqu’elles sont combinées avec des techniques comme l’algorithme d’attention Flash et l’optimisation de la précision numérique.
Considérations pour le déploiement dans le monde réel
Au-delà des algorithmes et des architectures de base, il existe plusieurs considérations pratiques et compromis à naviguer lors du déploiement des LLM dans des environnements de production:
Accélération matérielle: Bien que les CPU puissent gérer l’inférence des LLM, les GPU et d’autres accélérateurs comme les TPUs de Google sont essentiels pour atteindre un débit élevé et une faible latence. Le choix du matériel approprié et l’optimisation de l’utilisation de la mémoire sont cruciaux.
Batching et parallélisme: Pour exploiter pleinement le parallélisme matériel, des stratégies comme l’inférence par lots (traitement de plusieurs entrées simultanément) et le parallélisme de modèle (distribution d’un LLM sur plusieurs appareils) peuvent considérablement augmenter 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 également sur la qualité de sortie. Ce compromis doit être soigneusement évalué pour chaque cas d’utilisation.
Distillation de modèle: Une alternative à la quantification, les techniques de distillation de modèle peuvent compresser de grands LLM en modèles étudiants plus petits et plus efficaces tout en conservant une grande précision.
Mise en cache et exécution optimisée: Des exécutions de deep learning optimisées comme TensorRT de NVIDIA et des cadres conçus pour le service des LLM (par exemple, MosaicML’s Composable Inference Suite) peuvent offrir des gains de performance significatifs grâce à des techniques comme la fusion d’opérateurs, l’optimisation de noyau et des stratégies de mise en cache intelligentes.
Le chemin vers un déploiement optimal des LLM implique souvent de combiner plusieurs techniques tout en considérant soigneusement les exigences spécifiques de votre application, les contraintes d’infrastructure et les objectifs de performance.
Conclusion
Alors que les modèles de langage à grande échelle continuent d’évoluer rapidement, accélérer leur performance d’inférence devient de plus en plus crucial 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 allant de l’optimisation de la précision numérique et des algorithmes d’attention novateurs comme l’algorithme d’attention Flash aux innovations architecturales conçues pour la 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 les compromis complexes entre vitesse, utilisation de la mémoire et qualité de sortie.
En regardant vers l’avenir, nous pouvons nous attendre à une poursuite de la recherche et du développement dans ce domaine, alimentée par la demande insatiable de modèles de langage plus capables et plus accessibles. Des accélérateurs matériels et de la compression de modèle à de nouvelles architectures, la quête de l’inférence efficace des LLM reste un domaine passionnant dans le monde du traitement automatique des langues et de l’intelligence artificielle.
