Fallstudien oder Referenzen, die Leistungssteigerungen mit Seil und Alibi zeigen
Einbettung von Rotary Position (Seil):
- Fallstudie 1: In der Arbeit „Roformer: Rotary-Position für Transformatormodelle“ zeigten die Autoren, dass das Seil die Leistung bei Langzeitaufgaben wie Sprachmodellierung signifikant verbesserte. Die Fähigkeit des Seils, über lange Sequenzen besser zu verallgemeinern, ohne zusätzliche Rechenressourcen zu erfordern, machte es zu einer effizienteren Wahl über herkömmliche Einbettungen.
- Leistungsverstärkung: Seil, das bis zu 4-6% eine bessere Genauigkeit bei der Handhabung von Sequenzen länger als 512 Token lieferte, im Vergleich zu Modellen unter Verwendung herkömmlicher Positionscodierungen.
Alibi (Aufmerksamkeit mit linearen Verzerrungen):
- Fallstudie 2: In „Alibi: Aufmerksamkeit mit linearen Verzerrungen für eine effiziente Langstreckensequenzmodellierung“ ermöglichte die Einführung linearer Verzerrungen im Aufmerksamkeitsmechanismus das Modell, Sequenzen effizient zu verarbeiten, ohne sich auf die Positionscodierung zu verlassen. Alibi reduzierte den Speicheraufwand und verbesserte die Skalierbarkeit des Modells für Aufgaben wie maschinelle Übersetzung und Zusammenfassung.
- Leistungsverstärkung: Alibi zeigte bis zu 8% schnellere Trainingszeiten und signifikante Verringerung des Gedächtnisverbrauchs, während die Modellleistung bei Langzeitbenchmarks aufrechterhalten oder verbessert wurde.
Diese Fortschritte zeigen, wie moderne positionale Einbettungstechniken wie Rope und Alibi nicht nur die Einschränkungen herkömmlicher Methoden angehen, sondern auch die Skalierbarkeit und Effizienz von Großsprachmodellen verbessern, insbesondere wenn es sich um lange Eingaben handelt.
Nutzung der Kraft niedrigerer Präzision
LLMs bestehen aus riesigen Matrizen und Vektoren, die ihre Gewichte darstellen. Diese Gewichte werden typischerweise in Float32, Bfloat16 oder Float16 -Präzision gespeichert. Speicheranforderungen können wie folgt geschätzt werden:
- Float32 Präzision: Speicher erforderlich = 4 * x GB, wobei x die Anzahl der Modellparameter (in Milliarden) ist.
- Bfloat16/Float16 Präzision: Speicher erforderlich = 2 * x Gb.
Beispiele für den Speicherverbrauch in Bfloat16 Präzision:
- GPT-3: 175 Milliarden Parameter, ~ 350 GB VRAM.
- Blüte: 176 Milliarden Parameter, ~ 352 GB VRAM.
- LAMA-2-70B: 70 Milliarden Parameter, ~ 140 GB VRAM.
- Falcon-40b: 40 Milliarden Parameter, ~ 80 GB VRAM.
- MPT-30B: 30 Milliarden Parameter, ~ 60 GB VRAM.
- StarCoder: 15,5 Milliarden Parameter, ~ 31 GB VRAM.
Angesichts der Tatsache, dass die NVIDIA A100 GPU maximal 80 GB VRAM aufweist, benötigen größere Modelle eine Parallelität oder Pipeline -Parallelität mit Tensor, um effizient zu arbeiten.
Praktisches Beispiel
Laden Sie die Blüte auf einen 8 x 80 GB A100 -Knoten:
!
# aus Transformatoren importieren AutomodelforcausAllm
# model = automodelforcausAllm.from_prisined ("BigScience/Bloom", Device_map = "Autoo")
Aus Transformatoren importieren AutomodelforcausAllm, Autotokenizer, Pipeline
Taschenlampe importieren
model = automodelforcausAllm.from_pretraed ("bigCode/octocoder", folch_dtype = t Torch.bfloat16, Device_map = "auto", pad_token_id = 0)
tokenizer = autotokenizer.from_prasidled ("bigcode/octocoder")
Pipe = Pipeline ("Text-Generation", Modell = Modell, Tokenizer = Tokenizer)
prompt = "Frage: Bitte schreiben Sie eine Funktion in Python, die Bytes in Giga -Bytes verwandelt. \ n \ nanswer:"
result = pipe (Eingabeaufforderung, max_new_tokens = 60) [0] ["generated_text"] [len (Eingabeaufforderung):]
Ergebnis
def bytes_to_giga_bytes (bytes):
Rückgabe von Bytes / 1024 /1024 /1024
bytes_to_giga_bytes (fackel.cuda.max_memory_allocated ())
Modell.TO ("CPU")
Del Rohr
Del Modell
GC importieren
Taschenlampe importieren
Def Flush ():
gc.collect ()
fackler.cuda.emppty_cache ())
fackler.cuda.reset_peak_memory_stats ()
spülen()
Es gibt verschiedene Quantisierungstechniken, die wir hier nicht im Detail diskutieren, aber im Allgemeinen funktionieren alle Quantisierungstechniken wie folgt:
- Quantisieren Sie alle Gewichte an die Zielgenauigkeit.
- Laden Sie die quantisierten Gewichte und geben Sie die Eingangssequenz von Vektoren in Bfloat16 -Präzision weiter.
- Dynamisch die Gewichte nach Bfloat16 dequantisieren, um die Berechnung mit ihren Eingangsvektoren in Bfloat16 -Präzision durchzuführen.
- Quantisieren Sie die Gewichte nach der Berechnung mit ihren Eingaben erneut an die Zielgenauigkeit.
Kurz gesagt, dies bedeutet, dass die Matrixiplikationen mit Gewichtsgewicht mit den Eingaben mit einer Gewichtsmatrix mit dem Ausgang withe.
Y = x ∗ w werden in y = x ∗ dequantisieren (w); quantisieren (w) für jede Matrixmultiplikation. Die Dequantisierung und Wiederquantisierung wird nacheinander für alle Gewichtsmatrizen durchgeführt, wenn die Eingänge durch das Netzwerkdiagramm laufen.
#! PIP Installieren Sie BitsandBytes
Modell = AutomodelforcausAllm.from_Pretraination ("BigCode/Octocoder", load_in_8bit = true, low_cpu_mem_usage = true, pad_token_id = 0)
Pipe = Pipeline ("Text-Generation", Modell = Modell, Tokenizer = Tokenizer)
result = pipe (Eingabeaufforderung, max_new_tokens = 60) [0] ["generated_text"] [len (Eingabeaufforderung):]
Ergebnis
bytes_to_giga_bytes (fackel.cuda.max_memory_allocated ())
model.cpu ()
Del Modell
Del Rohr
spülen()
model = automodelforcausAllm.from_pretraed ("bigcode/octocoder", load_in_4bit = true, low_cpu_mem_usage = true, pad_token_id = 0)
Pipe = Pipeline ("Text-Generation", Modell = Modell, Tokenizer = Tokenizer)
result = pipe (Eingabeaufforderung, max_new_tokens = 60) [0] ["generated_text"] [len (Eingabeaufforderung):]
Ergebnis
bytes_to_giga_bytes (fackel.cuda.max_memory_allocated ())
model.cpu ()
Del Modell
Del Rohr
model.cpu ()
Del Modell
Del Rohr
spülen()
model = automodelforcausAllm.from_pretraed ("bigcode/octocoder", load_in_4bit = true, low_cpu_mem_usage = true, pad_token_id = 0)
Pipe = Pipeline ("Text-Generation", Modell = Modell, Tokenizer = Tokenizer)
result = pipe (Eingabeaufforderung, max_new_tokens = 60) [0] ["generated_text"] [len (Eingabeaufforderung):]
Ergebnis
bytes_to_giga_bytes (fackel.cuda.max_memory_allocated ())
model.cpu ()
Del Modell
Del Rohr
spülen()
Flash -Aufmerksamkeitsmechanismus
Die Aufmerksamkeitsmechanismus von Flash optimiert den Aufmerksamkeitsmechanismus, indem er die Gedächtniseffizienz verbessert und eine bessere GPU -Speicherauslastung nutzt. Dieser Ansatz ermöglicht:
- Reduzierter Speicherausdruck: Minimiert drastisch den Speicheraufwand, indem Sie die Aufmerksamkeitsberechnung effizienter behandeln.
- Höhere Leistung: signifikante Geschwindigkeitsverbesserungen während der Inferenz.
system_prompt = "" unten finden Sie eine Reihe von Dialogen zwischen verschiedenen Personen und einem technischen Assistenten der KI.
Der Assistent versucht hilfreich, höflich, ehrlich, raffiniert, emotional bewusst und bescheiden, aber kenntnisreich.
Der Assistent hilft gerne bei Codefragen und wird sein Bestes tun, um genau zu verstehen, was benötigt wird.
Es versucht auch zu vermeiden, falsche oder irreführende Informationen zu geben, und es ist einzudämmen, wenn die richtige Antwort nicht ganz sicher ist.
Trotzdem ist der Assistent praktisch sein Bestes und lässt die Vorsicht nicht zu sehr, nützlich zu sein.
Die StarCoder-Modelle sind eine Reihe von 15,5B-Parametermodellen, die auf 80 Programmiersprachen aus dem Stack (V1.2) trainiert wurden (ohne Opt-out-Anforderungen).
Das Modell verwendet Multi-Abfrage-Aufmerksamkeit, wurde unter Verwendung des Einfüllungsziels und mit 8.192-Token-Kontextfenster für eine Billion-Token von stark deduplizierten Daten trainiert.
-----
FRAGE: Schreiben Sie eine Funktion, die zwei Listen aufnimmt und eine Liste zurückgibt, die wechselnde Elemente aus jeder Eingabeliste enthält.
Antwort: Sicher. Hier ist eine Funktion, die das tut.
Def Alternating (List1, List2):
Ergebnisse = []
für i in Reichweite (Len (List1)):
results.append (list1 [i])
results.append (list2 [i])
Rückgabeergebnisse
Frage: Können Sie einige Testfälle für diese Funktion schreiben?
Antwort: Sicher, hier sind einige Tests.
Asssert abwechselnd ([10, 20, 30], [1, 2, 3]) == [10, 1, 20, 2, 30, 3]
Asssert abwechseln ([wahr, falsch], [4, 5]) == [True, 4, False, 5]
Asssert abwechseln ([], []) == []
Frage: Ändern Sie die Funktion so, dass sie alle Eingabelemente zurückgibt, wenn die Listen eine ungleiche Länge haben. Die Elemente aus der längeren Liste sollten am Ende sein.
Antwort: Hier ist die geänderte Funktion.
Def Alternating (List1, List2):
Ergebnisse = []
für i in Reichweite (min (len (list1), len (list2))):
results.append (list1 [i])
results.append (list2 [i])
Wenn Len (LIST1)> LEN (LIST2):
results.extend (list1 [i 1:])
anders:
results.extend (list2 [i 1:])
Rückgabeergebnisse
-----
"" "
long_prompt = 10 * system_prompt Eingabeaufforderung
model = automodelforcausAllm.from_Pretrained ("BigCode/Octocoder", folch_dtype = t Torch.bfloat16, Device_Map = "AutoMA"))
tokenizer = autotokenizer.from_prasidled ("bigcode/octocoder")
Pipe = Pipeline ("Text-Generation", Modell = Modell, Tokenizer = Tokenizer)
Importzeit
start_time = time.time ()
result = pipe (long_prompt, max_new_tokens = 60) [0] ["generated_text"] [len (long_prompt):]
print (f "generiert in {time.time () - start_time} Sekunden.")
Ergebnis
bytes_to_giga_bytes (fackel.cuda.max_memory_allocated ())
Ausgabe:
spülen()
model = model.to_betterTransformer ())
start_time = time.time ()
result = pipe (long_prompt, max_new_tokens = 60) [0] ["generated_text"] [len (long_prompt):]
print (f "generiert in {time.time () - start_time} Sekunden.")
Ergebnis
bytes_to_giga_bytes (fackel.cuda.max_memory_allocated ())
spülen()
Ausgabe:
Wissenschaft hinter LLM -Architekturen
Bisher haben wir Strategien zur Verbesserung der Rechen- und Gedächtniseffizienz untersucht, einschließlich:
- Gewichte in ein niedrigeres Präzisionsformat gießen.
- Implementierung einer effizienteren Version des Selbstbekämpfungsalgorithmus.
Jetzt richten wir unsere Aufmerksamkeit darauf ab, wie wir die Architektur großer Sprachmodelle (LLMs) ändern können, um sie für Aufgaben zu optimieren, bei denen lange Texteingaben erforderlich sind, z. B.:
- Abruffragestagende Beantwortung,
- Zusammenfassung,
- CHAT -Anwendungen.
Bemerkenswerterweise erfordern die Chat-Interaktionen, dass LLMs nicht nur lange Texteingaben verarbeiten, sondern auch effizient den dynamischen, Hin- und Her-Dialog zwischen dem Benutzer und dem Modell verarbeiten, ähnlich wie Chatgpt.
Da es schwierig ist, die grundlegende Architektur eines LLM nach der Ausbildung zu ändern, ist es wichtig, gut überlegte Designentscheidungen im Voraus zu treffen. Zwei Hauptkomponenten in LLM -Architekturen, die häufig zu Leistungsgpass für große Eingangssequenzen werden, sind:
- Positionsbettdings
- Schlüsselwertcache
Lassen Sie uns tiefer in diese Komponenten eintauchen.
Verbesserung der Positionseinbettungen in LLMs
Der Selbstbekämpfungsmechanismus bezieht jedes Token auf andere in einer Textsequenz. Zum Beispiel könnte die Softmax (QKT) -Matrix für die Eingabesequenz "Hallo", "Ich", "Liebe", "Sie" wie folgt erscheinen:
|
Hallo |
ICH |
Liebe |
Du |
| Hallo |
0,2 |
0,4 |
0,3 |
0,1 |
| ICH |
0,1 |
0,5 |
0,2 |
0,2 |
| Liebe |
0,05 |
0,3 |
0,65 |
0,0 |
| Du |
0,15 |
0,25 |
0,35 |
0,25 |
Jedes Word -Token hat eine Wahrscheinlichkeitsverteilung, die angibt, wie sehr es andere Token bewirkt. Zum Beispiel kümmert sich das Wort „Liebe“ mit einer Wahrscheinlichkeit von 0,05, „I“ mit 0,3 und selbst mit 0,65.
Ohne positionelle Einbettungen bemüht sich ein LLM jedoch darum, die relativen Positionen von Token zu verstehen und es schwierig zu machen, Sequenzen wie „Hallo, ich liebe dich“ von „You Love I Hello“ zu unterscheiden. Die QKT -Berechnung bezieht sich auf Token, ohne den Positionsabstand zu berücksichtigen und jeweils als äquidistisch zu behandeln.
Um dies zu lösen, werden Positionscodierungen eingeführt, die numerische Hinweise bereitstellen, die dem Modell helfen, die Reihenfolge der Token zu verstehen.
Traditionelle Positionseinbettungen
In der ursprünglichen Aufmerksamkeit ist alles, was Sie brauchen, wenn Sie Papier benötigen. Sinusoidale Positionseinbettungen wurden vorgeschlagen, wobei jeder Vektor als sinusförmige Funktion seiner Position definiert wird. Diese Einbettungen werden zu Eingabesequenzvektoren hinzugefügt wie:
Einige Modelle wie Bert haben gelernte Positionseinbettungen eingeführt, die während des Trainings gelernt werden.
Herausforderungen mit absoluten Positionseinbettungen
Sinusoide und gelernte Positionseinbettungen sind absolut und kodieren einzigartige Positionen. Wie von Huang et al. und Su et al., absolute Einbettungen können die Leistung für lange Sequenzen behindern. Wichtige Probleme umfassen:
- Lange Eingangsbeschränkung: Absolute Einbettungen sind beim Umgang mit langen Sequenzen schlecht ab, da sie sich auf feste Positionen anstelle von relativen Entfernungen konzentrieren.
- Feste Trainingslänge: Die erlernten Einbettungen binden das Modell mit einer maximalen Trainingslänge und begrenzen seine Fähigkeit, auf längere Eingaben zu verallgemeinern.
Fortschritte: Relative Positionseinbettungen
Um diese Herausforderungen zu bewältigen, haben relative Positionseinbettungen an Traktion gewonnen. Zwei bemerkenswerte Methoden sind:
- Einbettung der Rotationsposition (Seil)
- Alibi (Aufmerksamkeit mit linearen Verzerrungen)
Beide Methoden modifizieren die QKT-Berechnung, um die Satzreihenfolge direkt in den Selbstbekämpfungsmechanismus einzubeziehen, wodurch der Umgang mit langen Texteingaben verbessert wird.
Die ROPE -Einbettung (ROPE) codiert Positionsinformationen durch Drehen von Abfragen und Schlüsselvektoren nach Winkeln bzw. wo die Positionen bezeichnen:
Hier ist eine Rotationsmatrix und wird auf der Grundlage der maximalen Eingangslänge des Trainings vordefiniert.
Diese Ansätze ermöglichen es LLMs, sich auf relative Entfernungen zu konzentrieren, die Generalisierung für längere Sequenzen zu verbessern und effiziente aufgabenspezifische Optimierungen zu erleichtern.
input_ids = tokenizer (Eingabeaufforderung, return_tensors = "pt") ["input_ids"]. TO ("CUDA")
für _ im Bereich (5):
Next_logits = Modell (input_ids) ["logits"] [:, -1:]
next_token_id = t Torch.argmax (next_logits, dim = -1)
input_ids = t Torch.cat ([input_ids, next_token_id], dim = -1)
print ("Form der Input_ids", input_ids.shape)
generated_text = tokenizer.batch_decode (input_ids [:, -5:])
generated_text
past_key_values = Keine # Past_key_values ist der Schlüsselwert-Cache
generated_tokens = []
Next_token_id = Tokenizer (Eingabeaufforderung, return_tensors = "pt") ["input_ids"]. TO ("CUDA"))
für _ im Bereich (5):
NEXT_LOGITS, PAST_KEY_VALUES = Modell (next_token_id, past_key_values = past_key_values, use_cache = true) .to_tuple ()
Next_logits = Next_logits [:, -1:]
next_token_id = t Torch.argmax (next_logits, dim = -1)
print ("Form der Input_ids", Next_token_id.shape)
print ("Länge des Schlüsselwerts-Cache", Len (Past_key_values [0] [0])) # Past_key_values sind von Form [num_layers, 0 für k, 1 für v, batch_size, Länge, Hidden_dim]
generated_tokens.append (next_token_id.item ())
generated_text = tokenizer.batch_decode (generated_tokens)
generated_text
config = model.config
2 * 16_000 * config.n_layer * config.n_head * config.n_embd // config.n_head
Ausgabe
7864320000
Abschluss
Die Optimierung von LLM-Architekturen für lange Texteingaben und dynamische Chat-Anwendungen ist entscheidend, um ihre reale Anwendbarkeit voranzutreiben. Die Herausforderungen bei der Verwaltung umfangreicher Inputkontexte, der Aufrechterhaltung der Recheneffizienz und der Bereitstellung sinnvoller Konversationsinteraktionen erfordern innovative Lösungen auf architektonischer Ebene. Techniken wie die Einbettung von Rotary Position (Seil), Alibi und Flash-Aufmerksamkeit veranschaulichen das transformative Potenzial von Feinabstimmungskomponenten wie Positionseinbettungen und Selbstbeziehung.
Wenn das Feld voranschreitet, wird ein Zentrum zum Mischen von Recheneffektivität mit technischer Erfindungsreichtum die folgende Welle von Durchbrüchen treiben. Durch das Verständnis und die Aktualisierung dieser Verfahren können Designer die Gesamtkontrolle von LLMs bewältigen und garantieren, dass sie für verschiedene reale Anwendungen nicht fair, aber zu anpassungsfähig, reaktionsschnell und üblich sind.
Key Takeaways
- Techniken wie Seil und Alibi verbessern die Fähigkeit von LLMs, längere Texte zu verarbeiten, ohne die Leistung zu beeinträchtigen.
- Innovationen wie Flash-Aufmerksamkeit und Aufmerksamkeit des Schiebens reduzieren die Speicherverwendung und machen große Modelle für reale Anwendungen praktisch.
- Die Optimierung von LLMs für lange Texteingaben verbessert ihre Fähigkeit, den Kontext und die Kohärenz in erweiterten Gesprächen und komplexen Aufgaben aufrechtzuerhalten.
- LLMs entwickeln sich weiter, um Aufgaben wie Summarisierung, Abruf und Mehrkreisdialoge mit besserer Skalierbarkeit und Reaktionsfähigkeit zu unterstützen.
- Die Reduzierung der Modellgenauigkeit verbessert die Recheneffizienz bei der Aufrechterhaltung der Genauigkeit und ermöglicht eine breitere Einführung.
- Das Ausgleich von Architekturdesign und Ressourcenoptimierung stellt sicher, dass LLMs für vielfältige und wachsende Anwendungsfälle wirksam bleiben.
Häufig gestellte Fragen
Q1. 1. Was sind LLMs und warum sind sie von Bedeutung? A. Große Sprachmodelle (LLMs) sind KI-Modelle, um sie zu erhalten und menschliche Inhalte zu erstellen. Sie sind aufgrund ihrer Fähigkeit, eine breite Ausdehnung der Aufträge durchzuführen, von entscheidender Bedeutung, von der Beantwortung von Fragen bis zum fantasievollen Komponieren, wodurch sie flexible Geräte für verschiedene Unternehmen machen.
Q2. Wie verbessern Seil und Alibi LLMs? A. Seil (Rotationspositionskodierung) und Alibi (Aufmerksamkeit mit linearen Verzerrungen) verbessern die LLMs, indem sie ihre Fähigkeit verbessert, lange Kontexte zu verarbeiten, und die effiziente Verarbeitung des erweiterten Textes sicherstellen, ohne Kohärenz zu verlieren.
Q3. Was ist die Aufmerksamkeit von Flash und wie optimiert es die Speicherverwendung? A. Die Aufmerksamkeit der Flash ist ein Algorithmus, der die Aufmerksamkeit effizienter berechnet und den Speicherverbrauch erheblich verringert und die Verarbeitung für groß angelegte Modelle beschleunigt.
Q4. Warum ist die Quantisierung für LLMs wichtig? A. Die Quantisierung verringert die Genauigkeit der nachgewiesenen Gewichte (z. B. von 32-Bit bis 8-Bit), was die Rechenbedürfnisse und die Speicherauslastung verringert, während die Aufrechterhaltung der Ausführung zeigt und die Anordnung zu kleineren Geräten ermöglicht.
Q5. Welche Herausforderungen bleiben für die Skalierung von LLMs weiter? A. Zu den größten Herausforderungen gehören die Verwaltung von Rechen- und Speicherkosten, die Bewältigung ethischer Bedenken wie Voreingenommenheit und Missbrauch sowie die Sicherstellung, dass Modelle über verschiedene Aufgaben und Sprachen hinweg effektiv verallgemeinert werden können.
Q6. Wie können LLMs für die effektive Verarbeitung langer Texteingaben optimiert werden? A. Optimierung von LLMs für lange Texteingaben umfasst Techniken wie Kontextfensterexpansion, Speichermechanismen und effiziente Token -Verarbeitung, um sicherzustellen, dass sie Kohärenz und Leistung während erweiterter Gespräche oder Dokumentenanalysen beibehalten.
