Es gibt in der Regel drei verschiedene Trainingsstufen für große Sprachmodelle:

1. Vortraining: In dieser Phase wird das Modell auf einem großen Korpus von Rohtext-Daten trainiert, um zu lernen, wie das nächste Token oder Wort vorherzusagen ist. Das Ergebnis ist ein Basismodell, das viel allgemeines Wissen aus dem Text erworben hat, aber für spezifische Aufgaben noch nicht sehr nützlich ist.

2. Überwachtes Feintuning: Um das Basismodell nützlicher zu machen, ist das zweite Stadium das überwachte Feintuning. In dieser Phase wird das Modell auf Frage-Antwort-Paaren oder Anweisungs-Antwort-Paaren trainiert. Die Eingabe ist eine Frage oder Anweisung und die Ausgabe ist die gewünschte Antwort. Dieser Schritt ermöglicht es dem Modell, aufgabenspezifisches Wissen und Fähigkeiten zu erlernen.

3. Präferenzausrichtung: Die optionale dritte Phase ist die Präferenzausrichtung, bei der das Modell trainiert wird, um zu lernen, was der Benutzer in Bezug auf Antworten bevorzugt, oder um das Modell an bestimmte Prinzipien anzupassen. Dies wird oft mit Techniken wie Reinforcement Learning from Human Feedback (RLHF) oder Debate Policy Optimization (DPO) durchgeführt.

Das Ziel dieses Videos ist es, sich auf die Phase des überwachten Feintunens zu konzentrieren, insbesondere darauf, wie man das Llama 3.1-Modell mit der Unsloth-Bibliothek feintunen kann. Das Video wird verschiedene Feintuning-Techniken wie Full Fine-Tuning, LoRA und QLoRA behandeln und die Abwägungen zwischen ihnen in Bezug auf Leistung und Speicheranforderungen erörtern.

Es gibt drei beliebte Optionen für das überwachte Feintuning:

1. Full Fine-Tuning: Bei diesem Ansatz nehmen Sie das Originalmodell und aktualisieren die Gewichte mit dem Instruct-Feintuning-Datensatz. Dies wird die beste Leistung bringen, aber der VRAM-Bedarf wird hoch sein.

2. LoRA (Low-Rank Adaptation): Anstatt die Gewichte direkt zu aktualisieren, fügen Sie dem Modell externe Adapter hinzu. Die Anzahl der Parameter in diesen externen Adaptern kann kontrolliert werden. Die Gewichtsaktualisierungen für diese Adapter erfolgen mit 16-Bit-Genauigkeit und werden dann wieder in die ursprünglichen Modellgewichte integriert. Dieser Ansatz bietet ein schnelles Training, ist aber aufgrund der 16-Bit-Operationen immer noch kostspielig.

3. QLoRA (Quantized LoRA): Dies ist ähnlich wie LoRA, aber die Gewichtsaktualisierungen erfolgen mit 4-Bit-Genauigkeit, und die Modellgewichte werden auch in 4-Bit gehalten. Dies erfordert weniger VRAM, aber die Leistung ist möglicherweise nicht so gut wie bei LoRA oder Full Fine-Tuning.

Um die LoRA-Adapter einzurichten, gibt es einige wichtige Parameter zu berücksichtigen:

1. Rang: Der Rang der LoRA-Adapter steuert die Anzahl der Parameter, die während des Feintunens aktualisiert werden. Ein niedrigerer Rang bedeutet weniger Parameter, was den VRAM-Bedarf reduziert, aber auch die Fähigkeit des Modells, sich anzupassen, einschränken kann. Umgekehrt ermöglicht ein höherer Rang mehr Flexibilität, erfordert aber mehr VRAM.

2. LoRA Alpha: Dieser Parameter steuert den Beitrag der LoRA-Adapter zu den endgültigen Modellgewichten. Ein höherer LoRA-Alpha-Wert bedeutet, dass die LoRA-Adapter einen stärkeren Einfluss haben, während ein niedrigerer Wert bedeutet, dass sie einen schwächeren Einfluss haben.

3. LoRA Dropout: Dieser Parameter steuert die Dropout-Rate, die während des Trainings auf die LoRA-Adapter angewendet wird. Durch Erhöhen der Dropout-Rate kann Überanpassung verhindert werden, aber es kann auch die Leistung des Modells beeinträchtigen.

Um die Daten für das Feintuning vorzubereiten, müssen wir die Prompt-Vorlage einrichten und das End-of-Sequence-Token angeben.

Die Prompt-Vorlage ist entscheidend, da sie das Format der Eingabedaten definiert, auf denen das Modell trainiert wird. Für die Llama 3.1-Familie werden wir die Alpaca-Prompt-Vorlage verwenden, die eine Anweisung und eine Eingabe enthält, die weitere Kontextinformationen liefert. Das Modell soll dann eine geeignete Antwort generieren.

# Alpaca-Prompt-Vorlage
prompt_template = "Nachfolgend finden Sie eine Anweisung, die eine Aufgabe beschreibt, zusammen mit einer Eingabe, die weitere Kontextinformationen liefert. Antworten Sie mit einer relevanten Ausgabe.\n\nAnweisung: {instruction}\nEingabe: {input}\nAusgabe:"

Zusätzlich müssen wir das End-of-Sequence-Token angeben, um zu verhindern, dass das Modell unbegrenzt Text generiert. Dies ist ein wichtiger Schritt, mit dem viele Menschen Probleme hatten, wenn sie die quantisierten Versionen der Modelle mit LamaCPP verwendet haben.

# End-of-Sequence-Token setzen
end_token = "</s>"

Durch das Einrichten der Prompt-Vorlage und des End-of-Sequence-Tokens stellen wir sicher, dass die Daten für den Feintuning-Prozess richtig formatiert sind, was ein entscheidender Schritt für gute Ergebnisse ist.

Um das Modell zu trainieren, werden wir den SFT (Supervised Fine-Tuning) Trainer aus dem TRL-Paket verwenden, das von Hugging Face erstellt und gepflegt wird.

Zuerst stellen wir unser Modell, unseren Tokenizer und den Datensatz dem SFT Trainer zur Verfügung. In diesem Fall verwenden wir die text-Spalte aus dem Datensatz, da wir unsere Prompt-Vorlage so eingerichtet haben, dass sie dieses Feld verwendet.

Wir legen auch die maximale Sequenzlänge fest, die auf den Beispielen in Ihren Trainingsdaten basieren sollte. Beachten Sie, dass eine höhere Sequenzlänge den VRAM-Bedarf erhöht.

Als Nächstes konfigurieren wir die Trainingsargumente, wie das Gerät (in diesem Fall eine T4-GPU auf Google Colab mit etwa 15 GB VRAM) und die Anzahl der Trainingsschritte.

Schließlich führen wir den Trainer aus, und Sie können den abnehmenden Verlust beobachten, was ein gutes Anzeichen für den Fortschritt des Trainings ist.

Das Training dauerte etwa 8 Minuten, und der maximale reservierte Speicher lag bei etwa 8 GB, was etwa 53% des verfügbaren VRAM auf der T4-GPU entspricht. Dies zeigt die Effizienz des Unsloth-Ansatzes, der ein Feintuning mit relativ geringem VRAM-Bedarf ermöglicht.

Um Inferenz durchzuführen, können wir die for_inference-Klasse oder -Methode der FastLanguageModel-Klasse verwenden. Wir müssen das trainierte Modell und die Eingabe-Prompt im Alpaca-Format bereitstellen. Wir können auch die maximale Anzahl der zu generierenden Token festlegen.

# Inferenz durchführen
input_prompt = alpaca_prompt(instruction, input)
output = model.for_inference(input_prompt, max_new_tokens=256)
print(output)

Um Streaming zu aktivieren, können wir ein Streamer-Objekt erstellen und es an die for_inference-Methode übergeben. Dies wird die Antworten dann Schritt für Schritt anzeigen.

# Streaming aktivieren
streamer = Streamer()
output = model.for_inference(input_prompt, max_new_tokens=256, streamer=streamer)

Damit können Sie jetzt Inferenz auf Ihrem feingejusteten Modell durchführen und sogar Streaming für ein interaktiveres Erlebnis aktivieren.

Um das feinabgestimmte Modell und den Tokenizer zu speichern, können Sie die save_pretrained()-Funktion für das Modell und den Tokenizer verwenden:

model.save_pretrained("path/to/save/model")
tokenizer.save_pretrained("path/to/save/tokenizer")

Dies speichert die Modellgewichte und den Tokenizer als Satz von JSON-Dateien in den angegebenen Verzeichnissen.

Um das gespeicherte Modell und den Tokenizer zu laden, können Sie die gleiche FastLanguageModel-Klasse verwenden und die lokalen Verzeichnisse angeben:

model = FastLanguageModel.from_pretrained("path/to/save/model")
tokenizer = FastLanguageModel.from_pretrained("path/to/save/tokenizer")

Dies lädt das Modell und den Tokenizer aus den gespeicherten Dateien.

Ein weiteres großartiges Feature von Unsloth ist die Möglichkeit, die Modelle in verschiedenen Formaten zu speichern, wie z.B. 16-Bit-Gleitkomma-Genauigkeit für VLLM oder direkt im GGUF-Format für LamaCPP. Dies ermöglicht eine einfache Bereitstellung und Integration in verschiedene Plattformen und Frameworks.

Unsloth führt auch eine neue, auf Gradio basierende Benutzeroberfläche ein, mit der Sie die mit Unsloth trainierten Modelle ausführen und interaktive Chat-Sitzungen durchführen können. Sie können das Unsloth Studio-Repository klonen und das bereitgestellte Colab-Notebook ausführen, um diese Funktion zu erleben.

Unsloth hat eine neue Chat-Benutzeroberfläche auf Basis der Radish-Bibliothek eingeführt, die es Ihnen ermöglicht, einfach mit den mit Unsloth trainierten Sprachmodellen zu interagieren. Diese Chat-Benutzeroberfläche bietet eine benutzerfreundliche Schnittstelle zum Chatten mit den Modellen und zum Erkunden ihrer Fähigkeiten.

Um die Chat-Benutzeroberfläche zu nutzen, können Sie das Unsloth Studio-Repository klonen und das bereitgestellte Google Colab-Notebook ausführen. Dies richtet die erforderliche Umgebung ein und startet die Chat-Benutzeroberfläche, in der Sie mit dem Sprachmodell kommunizieren können.

Die Chat-Benutzeroberfläche unterstützt Funktionen wie Streaming-Antworten, so dass Sie die Ausgabe des Modells sehen können, während sie generiert wird. Dies kann nützlich sein, um den Denkprozess des Modells und die Art und Weise, wie es Antworten generiert, zu beobachten.

Darüber hinaus ermöglicht Unsloth's Chat-Benutzeroberfläche Ihnen, Ihre feingejusteten Modelle zu speichern und zu laden, was es einfach macht, weiter mit Ihren angepassten Sprachmodellen zu arbeiten. Sie können Ihre Modelle auch in verschiedenen Formaten exportieren, wie z.B. 16-Bit-Gleitkomma-Genauigkeit für VLLM oder GGUF-Format für LamaCPP, was Flexibilität bei der Verwendung und Bereitstellung Ihrer Modelle bietet.

Insgesamt ist Unsloth's neue Chat-Benutzeroberfläche ein wertvolles Werkzeug, um mit Sprachmodellen zu interagieren, die mit dem Unsloth-Framework trainiert wurden, und ihre Fähigkeiten zu erkunden.