LongRoPE
1.0.0
| Tags | Datensätze | Metriken | ||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
|
|
Das Papier stellt LongRoPE vor, eine Methode zur Erweiterung des Kontextfensters großer Sprachmodelle (LLMs) über 2 Millionen Token hinaus.
Die Kernideen sind:
Identifizieren und nutzen Sie zwei Formen von Ungleichmäßigkeiten bei Positionseinbettungen, um Informationsverluste während der Interpolation zu minimieren. Dies ermöglicht eine 8-fache Kontexterweiterung ohne Feinabstimmung.
Verwenden Sie eine effiziente progressive Erweiterungsstrategie mit 256k-Feinabstimmung, um einen 2048k-Kontext zu erreichen, anstatt einen extrem großen Kontext direkt zu verfeinern.
Passen Sie Einbettungen für kürzere Kontexte an, um die Leistung innerhalb der ursprünglichen Fenstergröße wiederherzustellen.
Die Methode wird auf LLaMA2 und Mistral angewendet. Experimente über verschiedene Aufgaben hinweg zeigen die Wirksamkeit von LongRoPE bei der Aufrechterhaltung der Leistung von 4.000 bis 2.048.000 Kontextlängen.
Die Transformer-Architektur kämpft mit der quadratischen Rechenkomplexität der Selbstaufmerksamkeit und ihrer mangelnden Verallgemeinerung auf Token-Positionen, die zur Trainingszeit nicht sichtbar waren. Um die Selbstaufmerksamkeitsberechnung auf einen großen Kontext zu skalieren, wurden verschiedene Methoden vorgeschlagen, wie z. B. RoPE, AliBi, Aufmerksamkeitssenken usw. Dennoch kann keine dieser Lösungen effektiv auf den Kontext mit Millionen von Token skaliert werden und gleichzeitig die Genauigkeit des Modells beibehalten .
In diesem Artikel wird eine neue Technik, LongRoPE, vorgestellt, die das Kontextfenster von LLMs auf über 2 Millionen Token erweitert.
LongRoPE nutzt eine progressive Erweiterungsstrategie, um ein 2048k-Kontextfenster zu erreichen, ohne dass eine direkte Feinabstimmung übermäßig langer Texte erforderlich ist, die sowohl selten als auch schwer zu beschaffen sind. Diese Strategie beginnt mit einer 256.000-Erweiterung auf einem vorab trainierten LLM, gefolgt von einer Feinabstimmung auf dieser Länge.
Um möglichen Leistungseinbußen im ursprünglichen (kürzeren) Kontextfenster entgegenzuwirken, passt LongRoPE die RoPE-Neuskalierungsfaktoren auf dem erweiterten LLM weiter an und skaliert mithilfe seines Suchalgorithmus auf 4k- und 8k-Kontextfenster auf dem 256k-feinabgestimmten LLM herunter, um die Positionsinterpolation zu minimieren. Während der Inferenz für Sequenzen mit einer Länge von weniger als 8 KB wird RoPE mit diesen sorgfältig gesuchten Neuskalierungsfaktoren aktualisiert.
Tests über verschiedene LLMs und Aufgaben hinweg, die lange Kontexte erfordern, haben die Wirksamkeit von LongRoPE bestätigt. Die Methode sorgt für eine deutlich geringe Verwirrung über Auswertungslängen von 4.000 bis 2.048.000 Tokens, erreicht eine Genauigkeit von über 90 % bei der Passkey-Abfrage und liefert eine Genauigkeit, die mit Standard-Benchmarks innerhalb eines 4096-Kontextfensters vergleichbar ist
Ein detaillierter Blick auf die strukturellen Änderungen und ihre Auswirkungen auf die Modellleistung.
Die LongRoPE -Modellarchitektur ist darauf ausgelegt, das Kontextfenster großer Sprachmodelle (LLMs) auf über 2 Millionen Token zu erweitern und so die Einschränkungen traditioneller Transformer-Architekturen zu überwinden. Die wesentliche Neuerung liegt in der progressiven Erweiterungsstrategie und der Anpassung der Positionseinbettungen.
Zu den Schlüsselkomponenten gehören:
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_256kDie Architektur beginnt mit einem vorab trainierten LLM und erweitert sein Kontextfenster schrittweise. Zunächst ist das Modell so abgestimmt, dass es eine Kontextlänge von 256.000 Token verarbeiten kann. Dieser fortschrittliche Ansatz vermeidet die Notwendigkeit einer direkten Feinabstimmung extrem langer Texte, deren Verarbeitung selten und rechenintensiv ist. Durch schrittweises Erhöhen der Kontextlänge kann sich das Modell effektiver an längere Sequenzen anpassen.
Um die Leistung über unterschiedliche Kontextlängen hinweg aufrechtzuerhalten, passt LongRoPE die Rotary Positional Embeddings (RoPE) an. Das Modell identifiziert und nutzt Ungleichmäßigkeiten bei Positionseinbettungen, um Informationsverluste während der Interpolation zu minimieren. Dies ermöglicht eine 8-fache Kontexterweiterung, ohne dass eine Feinabstimmung erforderlich ist. Darüber hinaus verwendet das Modell einen Suchalgorithmus, um optimale Neuskalierungsfaktoren für kürzere Kontexte (z. B. 4k- und 8k-Tokens) auf dem 256k-feinabgestimmten LLM zu finden. Diese Anpassungen stellen sicher, dass das Modell auch innerhalb der ursprünglichen Kontextfenstergröße eine hohe Leistung beibehält.
Die Architektur umfasst mehrere strukturelle Änderungen, um die erhöhte Kontextlänge effizient zu bewältigen:
Ebenenskalierung : Es werden Anpassungen an der Skalierung der Ebenen vorgenommen, um Stabilität und Leistung sicherzustellen, wenn das Kontextfenster wächst.
Speicherverwaltung : Effiziente Speicherverwaltungstechniken werden eingesetzt, um die großen Kontextgrößen zu bewältigen, ohne die Systemressourcen zu überlasten.
Aufmerksamkeitsmechanismen : Es sind erweiterte Aufmerksamkeitsmechanismen integriert, um sicherzustellen, dass sich das Modell auch im erweiterten Kontext auf relevante Teile der Eingabesequenz konzentrieren kann.
Tokenweise Aufmerksamkeit : Tokenweise Aufmerksamkeitsmechanismen werden eingeführt, um die kontextuellen Beziehungen zwischen Token zu erfassen und es dem Modell zu ermöglichen, die semantische Bedeutung der Eingabe besser zu verstehen.
Experimente zeigen, dass LongRoPE über Auswertungslängen von 4.000 bis 2.048.000 Token eine geringe Verwirrung beibehält und eine hohe Genauigkeit bei Aufgaben erreicht, die lange Kontexte erfordern. Dadurch eignet es sich für verschiedene Anwendungen, einschließlich kontextbezogenes Lernen, Zusammenfassung langer Dokumente und Lernen mit wenigen Schüssen.
Ausführlichere Informationen finden Sie im vollständigen Dokument hier.
Einblicke in die Codierung und betrieblichen Besonderheiten, die die Funktionalität von LongRoPE ermöglichen. Dies kann Schnipsel oder Pseudocode umfassen, die Schlüsselkomponenten veranschaulichen.
Nähere Informationen entnehmen Sie bitte dem Papier.
Umfangreiche Beispiele zeigen, wie Sie LongRoPE für verschiedene Anwendungen nutzen können, von der Textanalyse bis zur Erstellung umfangreicher Dokumente.
# 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) Benutzerdefiniertes Datensatztraining
So trainieren Sie an einem benutzerdefinierten Datensatz:
Hyperparameter-Tuning Die Leistung von LongRoPE kann empfindlich auf Hyperparameter reagieren. Zu den wichtigsten zu optimierenden Parametern gehören:
population_size , num_mutations und num_crossovers in der Lambda-Faktor-Suche. Lernrate und Scheduler-Parameter zur Feinabstimmung von gradient_accumulation_steps für Trainingsstabilität
Meine Implementierung von LongRoPE erzielt folgende Ergebnisse:
Verwirrung:
Genauigkeit des Passkey-Abrufs:
Genauigkeit:
Vergleich mit Basismodellen:
@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 }
}Hinweis: Dieses Repository ist in Arbeit und noch nicht für den Produktionseinsatz bereit. Weitere Einzelheiten entnehmen Sie bitte dem Papier.
