LongRoPE
1.0.0
| balises | ensembles de données | métrique | ||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
|
|
L'article présente LongRoPE, une méthode permettant d'étendre la fenêtre contextuelle des grands modèles de langage (LLM) au-delà de 2 millions de jetons.
Les idées clés sont les suivantes :
Identifiez et exploitez deux formes de non-uniformités dans les intégrations positionnelles pour minimiser la perte d'informations lors de l'interpolation. Cela permet une extension de contexte 8x sans réglage fin.
Utilisez une stratégie d'extension progressive efficace avec un réglage fin de 256 000 pour atteindre un contexte de 2 048 000, au lieu d'affiner directement un contexte extrêmement volumineux.
Ajustez les intégrations pour des contextes plus courts afin de récupérer les performances dans la taille d'origine de la fenêtre.
La méthode est appliquée à LLaMA2 et Mistral. Des expériences sur diverses tâches démontrent l'efficacité de LongRoPE à maintenir les performances de 4 000 à 2 048 000 longueurs de contexte.
L'architecture Transformer est aux prises avec la complexité informatique quadratique de l'auto-attention et son manque de généralisation à des positions symboliques invisibles au moment de la formation. Pour adapter le calcul de l'auto-attention à un contexte plus large, diverses méthodes ont été proposées, telles que RoPE, AliBi, les puits d'attention, etc. Néanmoins, aucune de ces solutions ne peut s'adapter efficacement au contexte avec des millions de jetons tout en préservant la précision du modèle. .
Cet article présente une nouvelle technique, LongRoPE, qui étend la fenêtre contextuelle des LLM à plus de 2 millions de jetons.
LongRoPE utilise une stratégie d'extension progressive pour atteindre une fenêtre contextuelle de 2 048 Ko sans nécessiter un réglage direct sur des textes extrêmement longs, qui sont à la fois rares et difficiles à se procurer. Cette stratégie commence par une extension de 256 000 sur un LLM pré-entraîné, suivie d'un réglage fin à cette longueur.
Pour faire face aux baisses de performances potentielles dans la fenêtre contextuelle d'origine (plus courte), LongRoPE ajuste davantage les facteurs de redimensionnement RoPE sur le LLM étendu, en les réduisant à des fenêtres contextuelles de 4 000 et 8 000 sur le LLM affiné de 256 000 à l'aide de son algorithme de recherche pour minimiser l'interpolation positionnelle. Lors de l'inférence pour des séquences d'une longueur inférieure à 8 Ko, RoPE est mis à jour avec ces facteurs de redimensionnement méticuleusement recherchés.
Les tests sur divers LLM et tâches nécessitant des contextes longs ont validé l'efficacité de LongRoPE. La méthode maintient considérablement une faible perplexité sur des longueurs d'évaluation allant de 4 000 à 2 048 000 jetons, atteint une précision supérieure à 90 % dans la récupération du mot de passe et offre une précision comparable aux références standard dans une fenêtre contextuelle de 4 096
Un examen approfondi des modifications structurelles et de leurs implications sur les performances du modèle.
L'architecture du modèle LongRoPE est conçue pour étendre la fenêtre contextuelle des grands modèles de langage (LLM) à plus de 2 millions de jetons, répondant ainsi aux limites des architectures Transformer traditionnelles. L'innovation clé réside dans la stratégie d'extension progressive et l'ajustement des plongements positionnels.
Les composants clés comprennent :
class RoPEPositionalEncoding ( nn . Module ):
def __init__ ( self , d_model , max_len = 1000000 , base = 10000 ):
super (). __init__ ()
self . d_model = d_model
self . max_len = max_len
self . base = base
self . theta = torch . tensor ([ base ** ( - 2 * ( i // 2 ) / d_model ) for i in range ( d_model )])
def forward ( self , positions ):
angles = positions . unsqueeze ( - 1 ) * self . theta
sin_cos = torch . stack ([ angles . cos (), angles . sin ()], dim = - 1 )
return sin_cos . view ( * sin_cos . shape [: - 2 ], - 1 ) def non_uniform_interpolation ( pos_embed , extension_ratio , lambda_factors , n_hat ):
d_model = pos_embed . shape [ - 1 ]
interpolated_pos = pos_embed . clone ()
for i in range ( d_model // 2 ):
mask = torch . arange ( pos_embed . shape [ - 2 ], device = pos_embed . device ) < n_hat
scale = torch . where ( mask , torch . ones_like ( pos_embed [..., 0 ], device = pos_embed . device ),
1 / ( lambda_factors [ i ] * extension_ratio ))
interpolated_pos [..., 2 * i ] *= scale
interpolated_pos [..., 2 * i + 1 ] *= scale
return interpolated_pos def progressive_extension ( model , data , base_length , target_length , population_size , num_mutations , num_crossovers , max_iterations ):
# Extend to 128k
lambda_factors_128k , n_hat_128k = search_lambda_factors ( model , data , 128000 / base_length , population_size , num_mutations , num_crossovers , max_iterations )
model = fine_tune ( model , data , 128000 , lambda_factors_128k , n_hat_128k , steps = 400 )
# Extend to 256k
lambda_factors_256k , n_hat_256k = search_lambda_factors ( model , data , 256000 / base_length , population_size , num_mutations , num_crossovers , max_iterations )
model = fine_tune ( model , data , 256000 , lambda_factors_256k , n_hat_256k , steps = 600 )
# Extend to target length
if target_length > 256000 :
final_lambda_factors , final_n_hat = search_lambda_factors ( model , data , target_length / base_length , population_size // 2 , num_mutations // 2 , num_crossovers // 2 , max_iterations // 2 )
model . lambda_factors [ "2048k" ] = final_lambda_factors
model . n_hat [ "2048k" ] = final_n_hat
return model , final_lambda_factors , final_n_hat , lambda_factors_256k , n_hat_256kL'architecture commence par un LLM pré-entraîné et étend progressivement sa fenêtre contextuelle. Initialement, le modèle est affiné pour gérer une longueur de contexte de 256 000 jetons. Cette approche progressive évite le besoin d'un réglage fin direct sur des textes extrêmement longs, qui sont rares et coûteux en termes de calcul à traiter. En augmentant progressivement la longueur du contexte, le modèle peut s'adapter plus efficacement à des séquences plus longues.
Pour maintenir les performances sur différentes longueurs de contexte, LongRoPE ajuste les intégrations positionnelles rotatives (RoPE). Le modèle identifie et exploite les non-uniformités dans les intégrations positionnelles pour minimiser la perte d'informations lors de l'interpolation. Cela permet une extension de contexte 8x sans avoir besoin d'un réglage fin. De plus, le modèle utilise un algorithme de recherche pour trouver les facteurs de redimensionnement optimaux pour des contextes plus courts (par exemple, jetons 4k et 8k) sur le LLM affiné de 256k. Ces ajustements garantissent que le modèle conserve des performances élevées même dans la taille de la fenêtre contextuelle d'origine.
L'architecture intègre plusieurs modifications structurelles pour gérer efficacement la longueur accrue du contexte :
Mise à l'échelle des couches : des ajustements sont apportés à la mise à l'échelle des couches pour garantir la stabilité et les performances à mesure que la fenêtre contextuelle s'agrandit.
Gestion de la mémoire : des techniques efficaces de gestion de la mémoire sont utilisées pour gérer les grandes tailles de contexte sans surcharger les ressources du système.
Mécanismes d'attention : des mécanismes d'attention améliorés sont intégrés pour garantir que le modèle peut se concentrer sur les parties pertinentes de la séquence d'entrée, même avec le contexte étendu.
Attention par jeton : des mécanismes d'attention par jeton sont introduits pour capturer les relations contextuelles entre les jetons, permettant au modèle de mieux comprendre la signification sémantique de l'entrée.
Les expériences démontrent que LongRoPE maintient une faible perplexité sur des longueurs d'évaluation allant de 4 000 à 2 048 000 jetons et atteint une grande précision dans les tâches nécessitant des contextes longs. Cela le rend adapté à diverses applications, notamment l'apprentissage en contexte, le résumé de documents longs et l'apprentissage en quelques étapes.
Pour des informations plus détaillées, veuillez vous référer au document complet ici.
Informations sur le codage et les spécificités opérationnelles qui permettent les fonctionnalités de LongRoPE. Cela peut inclure des extraits ou un pseudocode illustrant les composants clés.
Pour des informations plus détaillées, veuillez vous référer au document.
Exemples complets démontrant comment tirer parti de LongRoPE pour diverses applications, de l'analyse de texte à la génération de documents détaillés.
# Example usage
data_path = "path/to/your/dataset"
d_model = 512
n_heads = 8
num_layers = 6
base_length = 4096
target_length = 2048 * 1024
data = load_data ( data_path )
model = LongRoPEModel ( d_model , n_heads , num_layers , base_length )
model = model . extend_context ( data , target_length )
input_ids = torch . randn ( 2 , target_length , d_model )
output = model ( input_ids )
print ( output . shape ) # Expected shape: (batch_size, target_length, d_model) Formation sur les ensembles de données personnalisés
Pour effectuer un entraînement sur un ensemble de données personnalisé :
Réglage des hyperparamètres Les performances de LongRoPE peuvent être sensibles aux hyperparamètres. Les paramètres clés à régler incluent :
population_size , num_mutations et num_crossovers dans la recherche de facteurs lambda Taux d'apprentissage et paramètres du planificateur pour affiner gradient_accumulation_steps pour la stabilité de l'entraînement
Mon implémentation de LongRoPE permet d'obtenir les résultats suivants :
Perplexité:
Précision de récupération du mot de passe :
Précision:
Comparaison avec les modèles de référence :
@article { ding2024longrope ,
title = { LongRoPE: Extending LLM Context Window Beyond 2 Million Tokens } ,
author = { Ding, Yiran and Zhang, Li Lyna and Zhang, Chengruidong and Xu, Yuanyuan and Shang, Ning and Xu, Jiahang and Yang, Fan and Yang, Mao } ,
journal = { arXiv preprint arXiv:2402.13753 } ,
year = { 2024 }
}Remarque : Ce référentiel est un travail en cours et n'est pas encore prêt pour une utilisation en production. Veuillez vous référer au document pour plus de détails.
