🧠LoRA-Finetuning Hyperparameter-Anleitung

Optimaler LoRA-Rang, Alpha, Anzahl der Epochen, Batch-Größe & Gradient Accumulation, QLoRA vs LoRA, Zielmodule und mehr!

LoRA-Hyperparameter sind anpassbare Parameter, die steuern, wie Low-Rank Adaptation (LoRA) LLMs feinabstimmt. Bei vielen Optionen (wie Lernrate und Epochen) und Millionen möglicher Kombinationen ist die Auswahl der richtigen Werte entscheidend, um Genauigkeit, Stabilität, Qualität und weniger Halluzinationen während des Fine-Tunings zu erreichen.

Sie lernen die Best Practices für diese Parameter, basierend auf Erkenntnissen aus Hunderten von Forschungsarbeiten und Experimenten, und sehen, wie sie das Modell beeinflussen. Während wir empfehlen, Unsloths Standardwerte zu verwenden, wird Ihnen das Verständnis dieser Konzepte volle Kontrolle geben. Das Ziel ist, Hyperparameterzahlen zu ändern, um die Genauigkeit zu erhöhen und gleichzeitig Overfitting oder Underfitting. Overfitting tritt auf, wenn das Modell die Trainingsdaten auswendig lernt, was seine Fähigkeit beeinträchtigt, auf neue, ungesehene Eingaben zu verallgemeinern. Das Ziel ist ein Modell, das gut verallgemeinert, nicht eines, das einfach nur auswendig lernt.

❓Aber was ist LoRA?

In LLMs haben wir Modellgewichte. Llama 70B hat 70 Milliarden Zahlen. Anstatt alle 70 Milliarden Zahlen zu ändern, fügen wir jeder Gewichtsmatrix dünne Matrizen A und B hinzu und optimieren diese. Das bedeutet, dass wir nur 1 % der Gewichte optimieren.

Anstatt Modellgewichte (gelb) zu optimieren, optimieren wir 2 dünne Matrizen A und B.

🔢 Wichtige Fine-Tuning-Hyperparameter

Lernrate

Definiert, wie stark die Gewichte des Modells bei jedem Trainingsschritt angepasst werden.

• Höhere Lernraten: Führen zu schnellerer anfänglicher Konvergenz, können das Training jedoch instabil machen oder verhindern, dass ein optimales Minimum gefunden wird, wenn sie zu hoch eingestellt sind.

• Niedrigere Lernraten: Führen zu stabilerem und präziserem Training, können aber mehr Epochen zur Konvergenz erfordern und damit die gesamte Trainingszeit erhöhen. Obwohl häufig angenommen wird, dass niedrige Lernraten zu Underfitting führen, können sie tatsächlich Overfitting oder sogar verhindern, dass das Modell lernt.

• Typischer Bereich: 2e-4 (0,0002) bis 5e-6 (0.000005). 🟩 Für normales LoRA/QLoRA-Fine-Tuning, empfehlen wir 2e-4 als Ausgangspunkt. 🟦 Für Reinforcement Learning (DPO, GRPO etc.) empfehlen wir 5e-6 . ⬜ Für vollständiges Fine-Tuning sind im Allgemeinen niedrigere Lernraten angemessener.

Epochen

Die Anzahl der Male, die das Modell den gesamten Trainingsdatensatz sieht.

• Mehr Epochen: Können dem Modell helfen, besser zu lernen, aber eine hohe Anzahl kann dazu führen, dass es die Trainingsdaten auswendig lernt, was seine Leistung bei neuen Aufgaben beeinträchtigt.

• Weniger Epochen: Reduziert die Trainingszeit und kann Overfitting verhindern, kann aber zu einem untertrainierten Modell führen, wenn die Anzahl nicht ausreicht, damit das Modell die zugrunde liegenden Muster des Datensatzes erlernt.

• Empfohlen: 1–3 Epochen. Für die meisten instruktionalen Datensätze bringt Training für mehr als 3 Epochen abnehmende Erträge und erhöht das Risiko von Overfitting.

LoRA oder QLoRA

LoRA verwendet 16-Bit-Präzision, während QLoRA eine 4-Bit-Fine-Tuning-Methode ist.

• LoRA: 16-Bit-Fine-Tuning. Es ist etwas schneller und etwas genauer, verbraucht jedoch deutlich mehr VRAM (4× mehr als QLoRA). Empfohlen für 16-Bit-Umgebungen und Szenarien, in denen maximale Genauigkeit erforderlich ist.

• QLoRA: 4-Bit-Fine-Tuning. Etwas langsamer und marginal weniger genau, verwendet aber deutlich weniger VRAM (4× weniger). 🦥 70B LLaMA passt mit QLoRA in Unsloth in <48 GB VRAM - weitere Details hier.

Hyperparameter & Empfehlungen:

Hyperparameter	Funktion	Empfohlene Einstellungen
LoRA-Rang (r)	Steuert die Anzahl der trainierbaren Parameter in den LoRA-Adaptermatrizen. Ein höherer Rang erhöht die Modellkapazität, aber auch den Speicherverbrauch.	8, 16, 32, 64, 128 Wählen Sie 16 oder 32
LoRA-Alpha (lora_alpha)	Skaliert die Stärke der feinabgestimmten Anpassungen in Beziehung zum Rang (r).	r (Standard) oder r * 2 (gängige Heuristik). Mehr Details hier.
LoRA-Dropout	Eine Regularisierungstechnik, die zufällig einen Bruchteil der LoRA-Aktivierungen während des Trainings auf null setzt, um Overfitting zu verhindern. Nicht so nützlich, daher setzen wir standardmäßig 0.	0 (Standard) bis 0,1
Gewichtszerfall	Ein Regularisierungsterm, der große Gewichte bestraft, um Overfitting zu verhindern und die Generalisierung zu verbessern. Verwenden Sie nicht zu große Werte!	0,01 (empfohlen) - 0,1
Warmup-Schritte	Erhöht die Lernrate zu Beginn des Trainings schrittweise.	5–10 % der Gesamtzahl der Schritte
Scheduler-Typ	Passt die Lernrate dynamisch während des Trainings an.	linear oder cosine
Seed (random_state)	Eine feste Zahl zur Sicherstellung der Reproduzierbarkeit der Ergebnisse.	Jede ganze Zahl (z. B. 42, 3407)
Zielmodule	Geben Sie an, auf welche Teile des Modells Sie LoRA-Adapter anwenden möchten — entweder auf die Attention, das MLP oder beide. Attention: q_proj, k_proj, v_proj, o_proj MLP: gate_proj, up_proj, down_proj	Empfohlen, alle wichtigen linearen Schichten zu adressieren: q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj.

🌳 Gradientenakkumulation und Batch-Size-Äquivalenz

Effektive Batch-Größe

Die richtige Konfiguration Ihrer Batch-Größe ist entscheidend, um die Trainingsstabilität mit den VRAM-Beschränkungen Ihrer GPU in Einklang zu bringen. Dies wird durch zwei Parameter gesteuert, deren Produkt die Effektive Batch-Größe. Effektive Batch-Größe = batch_size * gradient_accumulation_steps

• Eine größere effektive Batch-Größe führt in der Regel zu glatterem, stabilerem Training.

• Eine kleinere effektive Batch-Größe kann mehr Varianz einführen.

Obwohl jede Aufgabe anders ist, bietet die folgende Konfiguration einen guten Ausgangspunkt, um eine stabile Effektive Batch-Größe von 16, die für die meisten Fine-Tuning-Aufgaben auf modernen GPUs gut funktioniert.

Parameter	Beschreibung	Empfohlene Einstellung
Batch-Größe (batch_size)	Die Anzahl der Proben, die in einem einzelnen Vorwärts-/Rückwärtsdurchlauf auf einer GPU verarbeitet werden. Haupttreiber des VRAM-Verbrauchs. Höhere Werte können die Hardwareauslastung verbessern und das Training beschleunigen, jedoch nur, wenn sie in den Speicher passen.	2
Gradientenakkumulation (gradient_accumulation_steps)	Die Anzahl der Mikro-Batches, die verarbeitet werden, bevor ein einzelnes Modellgewichts-Update durchgeführt wird. Haupttreiber der Trainingszeit. Ermöglicht die Simulation einer größeren batch_size zur Einsparung von VRAM. Höhere Werte erhöhen die Trainingszeit pro Epoche.	8
Effektive Batch-Größe (Berechnet)	Die tatsächliche Batch-Größe, die für jedes Gradientenupdate verwendet wird. Sie beeinflusst direkt Trainingsstabilität, Qualität und die endgültige Modellleistung.	4 bis 16 Empfohlen: 16 (aus 2 * 8)

Der VRAM- & Performance-Trade-off

Angenommen, Sie möchten 32 Proben Daten pro Trainingsschritt. Dann können Sie eine der folgenden Konfigurationen verwenden:

• batch_size = 32, gradient_accumulation_steps = 1

• batch_size = 16, gradient_accumulation_steps = 2

• batch_size = 8, gradient_accumulation_steps = 4

• batch_size = 4, gradient_accumulation_steps = 8

• batch_size = 2, gradient_accumulation_steps = 16

• batch_size = 1, gradient_accumulation_steps = 32

Obwohl all diese Konfigurationen für die Gewichtsaktualisierungen des Modells äquivalent sind, haben sie sehr unterschiedliche Hardwareanforderungen.

Die erste Konfiguration (batch_size = 32) verwendet den meisten VRAM und wird auf den meisten GPUs wahrscheinlich fehlschlagen. Die letzte Konfiguration (batch_size = 1) verwendet den verwendet am wenigsten VRAM, aber auf Kosten eines etwas langsameren Trainings. Um OOM-Fehler (Out of Memory) zu vermeiden, ziehen Sie immer vor, eine kleinere batch_size einzustellen und gradient_accumulation_steps zu erhöhen, um Ihre Ziel- Effektive Batch-Größe.

🦥 zu erreichen

Unsloth-Gradientenakkumulations-Fix Gradientenakkumulation und Batch-Größen sind jetzt in Unsloth vollständig äquivalent

aufgrund unserer Bugfixes für die Gradientenakkumulation. Wir haben spezifische Fehlerbehebungen für die Gradientenakkumulation implementiert, die ein häufiges Problem beheben, bei dem die beiden Methoden nicht die gleichen Ergebnisse lieferten. Dies war eine bekannte Herausforderung in der breiteren Community, aber für Unsloth-Nutzer sind die beiden Methoden jetzt austauschbar. für weitere Details.

Lesen Sie unseren Blogpost batch_size und gradient_accumulation_steps Vor unseren Fixes führten Kombinationen von Effektive Batch-Größe die das gleiche ergaben (d. h.batch_size × gradient_accumulation_steps = 16 ) nicht zu äquivalentem Trainingsverhalten. Zum Beispiel führten Konfigurationen wie, b1/g16, b2/g8, b4/g4, und b8/g2 b16/g1 Effektive Batch-Größe alle zu einer

von 16, aber wie im Diagramm gezeigt, stimmten die Verlustkurven bei Verwendung der standardmäßigen Gradientenakkumulation nicht überein:

(Vorher - Standardmäßige Gradientenakkumulation) Effektive Batch-Größe Nach Anwendung unserer Fixes stimmen die Verlustkurven nun korrekt überein, unabhängig davon, wie die

von 16 erreicht wird: (Nachher - 🦥)

🦥 Unsloth-Gradientenakkumulation

LoRA-Hyperparameter in Unsloth Das Folgende zeigt eine Standardkonfiguration.Während Unsloth optimierte Voreinstellungen bereitstellt

1. r = 16, # Wählen Sie eine beliebige Zahl > 0 ! Vorgeschlagen: 8, 16, 32, 64, 128

   , ist das Verständnis dieser Parameter der Schlüssel zur manuellen Feinabstimmung.rDer Rang (

2. target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                     "gate_proj", "up_proj", "down_proj",],

   ) des Feinabstimmungsprozesses. Ein größerer Rang verbraucht mehr Speicher und ist langsamer, kann aber die Genauigkeit bei komplexen Aufgaben erhöhen. Wir schlagen Ränge wie 8 oder 16 (für schnelle Fine-Tunes) und bis zu 128 vor. Die Verwendung eines zu großen Rangs kann Overfitting verursachen und die Qualität Ihres Modells schädigen.\ Für optimale Leistung. sollte LoRA auf alle wichtigen linearen Schichten angewendet werden Forschung hat gezeigt

3. lora_alpha = 16,

   , dass die Ausrichtung auf alle Hauptschichten entscheidend ist, um die Leistung des vollständigen Fine-Tunings zu erreichen. Obwohl es möglich ist, Module zu entfernen, um Speicher zu sparen, raten wir dringend davon ab, um die maximale Qualität zu erhalten, da die Einsparungen minimal sind.\rEin Skalierungsfaktor, der die Stärke der feinabgestimmten Anpassungen steuert. Ihn gleich dem Rang zu setzen (r * 2) ist eine verlässliche Basislinie. Eine populäre und effektive Heuristik ist, ihn auf das Doppelte des Rangs zu setzen ( Mehr Details hier), wodurch das Modell aggressiver lernt, indem den LoRA-Updates mehr Gewicht gegeben wird.

4. lora_dropout = 0, # Unterstützt beliebige Werte, aber = 0 ist optimiert

   .\ Eine Regularisierungstechnik, die hilft, Overfitting zu verhindern , indem bei jedem Trainingsschritt zufällig ein Bruchteil der LoRA-Aktivierungen auf Null gesetzt wird. Jüngste Forschung legt nahe , dass für die kurzen Trainingsläufe , die beim Fine-Tuning üblich sind, lora_dropout ein unzuverlässiger Regularisator sein kann. 🦥 Unsloths interner Code kann das Training optimieren, wennlora_dropout = 0\

5. bias = "none",    # Unterstützt beliebige Werte, aber = "none" ist optimiert

   , wodurch es etwas schneller wird, aber wir empfehlen einen von Null verschiedenen Wert, wenn Sie Overfitting vermuten. "none" Lassen Sie dies als

6. use_gradient_checkpointing = "unsloth", # True oder "unsloth" für sehr langen Kontext

   für schnelleres Training und reduzierten Speicherverbrauch. Diese Einstellung vermeidet das Trainieren der Bias-Terme in den linearen Schichten, was trainierbare Parameter hinzufügt, aber praktisch kaum Vorteile bringt.\ Wahr, Falsch, und "unsloth"Optionen sind . 🦥 "unsloth" Wir empfehlen , da es den Speicherverbrauch um zusätzliche 30 % reduziert und extrem lange Kontext-Fine-Tunes unterstützt. Sie können mehr in.\

7. random_state = 3407,

   unserem Blogpost über Long-Context-Training

8. use_rslora = False,  # Wir unterstützen rank-stabilisiertes LoRA

   lesen. Der Seed stellt deterministische, reproduzierbare Läufe sicher. Das Training beinhaltet Zufallszahlen, daher ist das Setzen eines festen Seeds für konsistente Experimente unerlässlich.\ Ein fortgeschrittenes Feature, dasRank-Stabilized LoRA Wahrimplementiert. Wenn auf gesetzt, wird die effektive Skalierung lora_alpha / sqrt(r) statt der standardmäßigenlora_alpha / r Mehr Details hier), wodurch das Modell aggressiver lernt, indem den LoRA-Updates mehr Gewicht gegeben wird.

9. loftq_config = None, # Und LoftQ

   . Dies kann die Stabilität verbessern, insbesondere bei höheren Rängen. Eine fortgeschrittene Technik, wie inLoftQ

vorgeschlagen, initialisiert LoRA-Matrizen mit den oberen 'r' Singularvektoren aus den vortrainierten Gewichten. Dies kann die Genauigkeit verbessern, aber zu Beginn des Trainings einen signifikanten Speicheranstieg verursachen.

Überprüfung von LoRA-Gewichtsaktualisierungen: LoRA Beim Prüfen, ob Adapter-Gewichte nach dem Fine-Tuning aktualisiert wurden, vermeiden Sie den Einsatz von np.allclose() für den Vergleich. Diese Methode kann subtile, aber bedeutende Änderungen übersehen, insbesondere inLoRA A , das mit kleinen Gaußschen Werten initialisiert wird. Diese Änderungen könnten unter lockeren numerischen Toleranzen nicht als signifikant erkannt werden. Dank an Mitwirkende

für diesen Abschnitt.

• Die Verwendung von Um Gewichtsaktualisierungen zuverlässig zu bestätigen, empfehlen wir: Prüfsummen- oder Hash-Vergleiche

• (z. B. MD5) Berechnung der Summe der absoluten Differenzen

• zwischen TensorenInspektion von Tensorstatistiken (z. B. Mittelwert, Varianz) manuell

• Oder die Verwendung von np.array_equal() wenn exakte Gleichheit erwartet wird

📐Beziehung zwischen LoRA-Alpha und Rang

Es ist am besten, lora_alpha = 2 * lora_rank oder lora_alpha = lora_rank

$$\hat{W} = W + \frac{\alpha}{\text{rank}} \times AB$$

rsLoRA andere Skalierungsoptionen. sqrt(r) ist die beste.

$$\hat{W}_{\text{rslora}} = W + \frac{\alpha}{\sqrt{\text{rank}}} \times AB$$

Die Formel für LoRA ist links. Wir müssen die dünnen Matrizen A und B mit alpha geteilt durch den Rang skalieren. Das bedeutet, wir sollten alpha/rang mindestens = 1 halten.

Laut dem rsLoRA (rank stabilized lora) Papersollten wir alpha stattdessen mit der Quadratwurzel des Rangs skalieren. Es gibt andere Optionen, aber theoretisch ist dies optimal. Das linke Diagramm zeigt andere Ränge und deren Perplexitäten (niedriger ist besser). Um dies zu aktivieren, setzen Sie use_rslora = True in Unsloth.

Unsere Empfehlung ist, das Alpha gleich dem Rang zu setzen oder mindestens 2× den Rang. Das bedeutet alpha/rang = 1 oder 2.

🎯 LoRA-Zielmodule und QLoRA vs LoRA

Verwenden Sie: target_modules = ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj",] um sowohl MLP- und als auch Attention- Schichten zu adressieren, um die Genauigkeit zu erhöhen.

QLoRA verwendet 4-Bit-Präzision, was den VRAM-Verbrauch um über 75 % reduziert.

LoRA (16-Bit) ist etwas genauer und schneller.

Laut empirischen Experimenten und Forschungsarbeiten wie dem ursprünglichen QLoRA-Paperist es am besten, LoRA sowohl auf Attention- als auch auf MLP-Schichten anzuwenden.

Das Diagramm zeigt RougeL-Werte (höher ist besser) für verschiedene Zielmodulkonfigurationen und vergleicht LoRA vs QLoRA.

Die ersten 3 Punkte zeigen:

1. QLoRA-All: LoRA angewendet auf alle FFN/MLP- und Attention-Schichten. 🔥 Dies liefert insgesamt die beste Leistung.

2. QLoRA-FFN: LoRA nur auf FFN. Äquivalent zu: gate_proj, up_proj, down_proj.

3. QLoRA-Attention: LoRA angewendet nur auf Attention-Schichten. Äquivalent zu: q_proj, k_proj, v_proj, o_proj.

😎 Training nur auf Completion-Daten, Eingaben maskieren

Der QLoRA-Paper zeigt, dass das Maskieren der Eingaben und Training nur auf Completions (Ausgaben oder Assistenten-Nachrichten) die Genauigkeit weiter steigern kann um einige Prozentpunkte (1%). Unten wird gezeigt, wie dies in Unsloth gemacht wird:

NICHT Training nur auf Completions:

USER: Hallo, was ist 2+2? ASSISTANT: Die Antwort ist 4. USER: Hallo, was ist 3+3? ASSISTANT: ASSISTANT:

Die Antwort ist 6. Training

USER: Hallo, was ist 2+2? ASSISTANT: Die Antwort ist 4. USER: Hallo, was ist 3+3? ASSISTANT: nur auf Completions:.

Die Antwort ist 6 Das QLoRA-Paper stellt fest, dass Training nur auf Completions die Genauigkeit deutlich erhöht, insbesondere bei Multi-Turn-Unterhaltungs-Finetunes! Wir machen dies in unseren.

nn.Linear konversationellen Notebooks hier Training auf Completions 🦥 in Unsloth müssen Sie die Instruktions- und Assistenten-Teile definieren.

Wir planen, dies in Zukunft weiter für Sie zu automatisieren!

Für Llama 3, 3.1, 3.2, 3.3 und 4-Modelle definieren Sie die Teile wie folgt:
from unsloth.chat_templates import train_on_responses_only
    trainer = train_on_responses_only(
    trainer,
    instruction_part = "<|start_header_id|>user<|end_header_id|>\n\n",
)

response_part = "<|start_header_id|>assistant<|end_header_id|>\n\n",

Für Llama 3, 3.1, 3.2, 3.3 und 4-Modelle definieren Sie die Teile wie folgt:
from unsloth.chat_templates import train_on_responses_only
    trainer = train_on_responses_only(
    Für Gemma 2, 3, 3n-Modelle definieren Sie die Teile wie folgt:
    instruction_part = "<start_of_turn>user\n",
)

🔎response_part = "<start_of_turn>model\n",

Training nur auf Assistentenantworten für Vision-Modelle, VLMs Für Llama 3, 3.1, 3.2, 3.3 und 4-Modelle definieren Sie die Teile wie folgt: Für Sprachmodelle können wir wie zuvor beschrieben verwenden. Für Vision-Modelle verwenden Sie die zusätzlichen Argumente als Teil von UnslothVisionDataCollator

genau wie zuvor!
class UnslothVisionDataCollator:
    def __init__(
    ...
    self,
    # from unsloth.chat_templates import train_on_responses_only
    # trainer = train_on_responses_only(
    #     trainer,
    #     instruction_part = "<|start_header_id|>user<|end_header_id|>\n\n",
    # )
    #     response_part = "<|start_header_id|>assistant<|end_header_id|>\n\n",
    train_on_responses_only = False, # ÄQUIVALENT zu train_on_responses_only für LLMs
    instruction_part = None, # ÄQUIVALENT zu train_on_responses_only(instruction_part = ...)
    response_part    = None, # ÄQUIVALENT zu train_on_responses_only(response_part = ...)
)

force_match = True, # Übereinstimmung von Newlines ebenfalls!

Zum Beispiel für Llama 3.2 Vision:
    UnslothVisionDataCollator(
    ...
    model, tokenizer,
    trainer,
    instruction_part = "<|start_header_id|>user<|end_header_id|>\n\n",
    ...
)

🔑 train_on_responses_only = True,

Vermeidung von Overfitting & Underfitting Overfitting

(Schlechte Generalisierung/Zuviel Spezialisierung)

Das Modell merkt sich die Trainingsdaten einschließlich ihres statistischen Rauschens und versagt folglich darin, auf ungesehene Daten zu verallgemeinern. Overfitting Wenn Ihr Trainingsverlust unter 0,2 fällt, ist Ihr Modell wahrscheinlich

— das bedeutet, es kann bei ungesehenen Aufgaben schlecht abschneiden.

Ein einfacher Trick ist LoRA-Alpha-Skalierung — multiplizieren Sie einfach den Alpha-Wert jeder LoRA-Matrix mit 0,5. Dies verringert effektiv die Wirkung des Fine-Tunings. Dies hängt eng mit dem Mergen / Mittelwertbilden von Gewichten zusammen. Sie können das ursprüngliche Basis- (oder Instruct-)Modell nehmen, die LoRA-Gewichte hinzufügen und das Ergebnis dann durch 2 teilen. Dies ergibt ein gemitteltes Modell — das funktional äquivalent ist zur Halbierung des Alpha

.

• Lösung: Passen Sie die Lernrate an:

• Eine hohe Lernrate führt oft zu Overfitting, besonders bei kurzen Trainingsläufen. Bei längeren Trainings kann eine höhere Lernrate besser funktionieren. Am besten experimentiert man mit beiden, um zu sehen, welche Option am besten abschneidet.Reduzieren Sie die Anzahl der Trainingsepochen

• . Stoppen Sie das Training nach 1, 2 oder 3 Epochen. Erhöhen Sie denGewichtszerfall 0.01 oder 0.1 . Ein Wert von

• . Stoppen Sie das Training nach 1, 2 oder 3 Epochen. , die beim Fine-Tuning üblich sind,ist ein guter Ausgangspunkt. 0.1 . Verwenden Sie einen Wert wie

• , um Regularisierung hinzuzufügen..

• Erhöhen Sie die Batch-Größe oder die Gradient-Accumulation-Schritte Datensatzerweiterung

• - Vergrößern Sie Ihren Datensatz, indem Sie Open-Source-Datensätze mit Ihrem Datensatz kombinieren oder aneinanderhängen. Wählen Sie qualitativ hochwertigere. Evaluation Early Stopping

• - Aktivieren Sie Evaluation und stoppen Sie, wenn der Evaluationsverlust für einige Schritte ansteigt. LoRA-Alpha-Skalierung

• - Skalieren Sie das Alpha nach dem Training und während der Inferenz herunter – das macht das Finetune weniger ausgeprägt. Gewichtsmittelung

- Fügen Sie buchstäblich das ursprüngliche Instruct-Modell und das Finetune-Modell zusammen und teilen Sie die Gewichte durch 2. Underfitting

(Zu generisch)

.

• Das Modell erfasst die zugrunde liegenden Muster in den Trainingsdaten nicht, oft aufgrund unzureichender Komplexität oder Trainingsdauer. Passen Sie die Lernrate an:

• Wenn die aktuelle Rate zu niedrig ist, kann eine Erhöhung die Konvergenz beschleunigen, insbesondere bei kurzen Trainingsläufen. Für längere Läufe versuchen Sie stattdessen, die Lernrate zu senken. Testen Sie beide Ansätze, um zu sehen, welcher am besten funktioniert. Erhöhen Sie die Trainingsepochen:

• Trainieren Sie für mehr Epochen, überwachen Sie jedoch den Validierungsverlust, um Overfitting zu vermeiden. (rErhöhen Sie den LoRA-Rang

• ) und Alpha: Der Rang sollte mindestens dem Alpha-Wert entsprechen, und der Rang sollte für kleinere Modelle/komplexere Datensätze größer sein; üblicherweise liegt er zwischen 4 und 64.Verwenden Sie einen datendomänenspezifischeren Datensatz

• : Stellen Sie sicher, dass die Trainingsdaten von hoher Qualität und direkt relevant für die Zielaufgabe sind.Verringern Sie die Batch-Größe auf 1

. Dies lässt das Modell stärkere Updates durchführen.

Danksagungen: Ein großer Dank an Eyera für den Beitrag zu diesem Leitfaden!