> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/loslegen/fine-tuning-llms-guide/tutorial-how-to-finetune-llama-3-and-use-in-ollama.md).
# Tutorial: Wie man Llama-3 feinabstimmt und in Ollama verwendet
Bis zum Ende dieses Tutorials wirst du einen benutzerdefinierten Chatbot erstellen, indem du **Llama-3 feinabstimmst** mit [**Unsloth**](https://github.com/unslothai/unsloth) kostenlos. Er kann lokal über [**Ollama**](https://github.com/ollama/ollama) auf deinem PC ausgeführt werden oder in einer kostenlosen GPU-Instanz über [**Google Colab**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3_\(8B\)-Ollama.ipynb). Du wirst mit dem Chatbot interaktiv wie unten interagieren können:
**Unsloth** macht die Feinabstimmung viel einfacher und kann das feinabgestimmte Modell automatisch nach **Ollama** mit integrierter automatischer `Modelfile` Erstellung exportieren! Wenn du Hilfe brauchst, kannst du unserem Discord-Server beitreten:
{% hint style="warning" %}
**Wenn du den Code kopieren oder speichern möchtest, ist alles in unserem** [**Ollama-Colab-Notebook**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3_\(8B\)-Ollama.ipynb)**verfügbar. Du kannst es dort direkt verwenden oder für dein lokales Setup anpassen:** [**https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3\_(8B)-Ollama.ipynb**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3_\(8B\)-Ollama.ipynb)
{% endhint %}
## 1. Was ist Unsloth?
[Unsloth](https://github.com/unslothai/unsloth) macht das Feinabstimmen von LLMs wie Llama-3, Mistral, Phi-3 und Gemma 2x schneller, benötigt 70 % weniger Speicher und ohne Genauigkeitsverlust! Wir werden während dieses Tutorials Google Colab verwenden, das eine kostenlose GPU bereitstellt. Du kannst unten auf unsere kostenlosen Notebooks zugreifen:
* [Ollama Llama-3 Alpaca](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3_\(8B\)-Ollama.ipynb) (Notebook, das wir verwenden werden)
* [CSV/Excel Ollama-Anleitung](https://colab.research.google.com/drive/1VYkncZMfGFkeCEgN2IzbZIKEDkyQuJAS?usp=sharing)
#### ***Du musst dich außerdem bei deinem Google-Konto anmelden!***
## 2. Was ist Ollama?
[Ollama ](https://github.com/ollama/ollama)ermöglicht es dir, Sprachmodelle auf deinem eigenen Computer schnell und einfach auszuführen! Es startet im Hintergrund unauffällig ein Programm, das ein Sprachmodell wie Llama-3 ausführen kann. Wenn du das Sprachmodell plötzlich etwas fragen möchtest, kannst du einfach eine Anfrage an Ollama senden, und es gibt dir die Ergebnisse schnell zurück! Wir werden Ollama als unsere Inferenz-Engine verwenden!
## 3. Unsloth installieren
Wenn du noch nie ein Colab-Notebook verwendet hast, hier eine kurze Einführung ins Notebook selbst:
1. **Play-Button bei jeder „Zelle“.** Klicke darauf, um den Code dieser Zelle auszuführen. Du darfst keine Zellen überspringen und musst jede Zelle in chronologischer Reihenfolge ausführen. Wenn du auf Fehler stößt, führe einfach die Zelle erneut aus, die du vorher nicht ausgeführt hast. Eine andere Möglichkeit ist, STRG + ENTER zu drücken, wenn du nicht auf den Play-Button klicken möchtest.
2. **Runtime-Button in der oberen Symbolleiste.** Du kannst auch diesen Button verwenden und auf „Run all“ klicken, um das gesamte Notebook in einem Durchgang auszuführen. Dadurch werden alle Anpassungsschritte übersprungen, und es kann ein guter erster Versuch sein.
3. **Verbinden / Erneut verbinden-T4-Button.** Hier kannst du für fortgeschrittenere Systemstatistiken klicken.
Die erste Installationszelle sieht wie unten aus: Vergiss nicht, auf den PLAY-Button in den Klammern \[ ] zu klicken. Wir holen uns unser Open-Source-Github-Paket und installieren einige andere Pakete.
## 4. Ein Modell für die Feinabstimmung auswählen
Lass uns jetzt ein Modell für die Feinabstimmung auswählen! Standardmäßig haben wir Llama-3 von Meta / Facebook gewählt, das mit unglaublichen 15 Billionen „Tokens“ trainiert wurde. Nimm an, ein Token ist ungefähr wie ein englisches Wort. Das entspricht etwa 350.000 dicken Enzyklopädien! Andere beliebte Modelle sind Mistral, Phi-3 (trainiert mit GPT-4-Ausgaben) und Gemma von Google (13 Billionen Tokens!).
Unsloth unterstützt diese Modelle und mehr! Gib einfach ein Modell aus dem Hugging-Face-Model-Hub ein, um zu sehen, ob es funktioniert! Wir geben einen Fehler aus, wenn es nicht funktioniert.
Es gibt 3 weitere Einstellungen, die du umschalten kannst:
1. ```python
max_seq_length = 2048
```
Dies bestimmt die Kontextlänge des Modells. Gemini hat zum Beispiel über 1 Million Kontextlänge, während Llama-3 eine Kontextlänge von 8192 hat. Wir erlauben dir, JEDE Zahl auszuwählen – empfehlen aber, sie für Testzwecke auf 2048 zu setzen. Unsloth unterstützt auch die Feinabstimmung mit sehr langem Kontext, und wir zeigen, dass wir 4x längere Kontextlängen als die besten bieten können.
2. ```python
dtype = None
```
Lass dies auf None, aber du kannst für neuere GPUs torch.float16 oder torch.bfloat16 auswählen.
3. ```python
load_in_4bit = True
```
Wir führen die Feinabstimmung in 4-Bit-Quantisierung durch. Dadurch wird der Speicherverbrauch um das 4-Fache reduziert, sodass wir die Feinabstimmung tatsächlich auf einer kostenlosen GPU mit 16 GB Speicher durchführen können. 4-Bit-Quantisierung wandelt Gewichte im Wesentlichen in eine begrenzte Zahlmenge um, um den Speicherverbrauch zu verringern. Ein Nachteil davon ist eine Genauigkeitsminderung von 1–2 %. Setze dies auf False bei größeren GPUs wie H100s, wenn du diese winzige zusätzliche Genauigkeit möchtest.
Wenn du die Zelle ausführst, erhältst du einige Ausgaben zur Unsloth-Version, zum verwendeten Modell, dazu wie viel Speicher deine GPU hat, und einige andere Statistiken. Ignoriere dies vorerst.
## 5. Parameter für die Feinabstimmung
Um deine Feinabstimmung anzupassen, kannst du jetzt die Zahlen oben bearbeiten, aber du kannst es auch ignorieren, da wir bereits ziemlich vernünftige Zahlen ausgewählt haben.
Das Ziel ist, diese Zahlen zu ändern, um die Genauigkeit zu erhöhen, aber auch **Überanpassung entgegenzuwirken**. Überanpassung bedeutet, dass du das Sprachmodell ein Datenset auswendig lernen lässt und es dadurch nicht mehr in der Lage ist, neue Fragen zu beantworten. Wir wollen, dass ein finales Modell unbekannte Fragen beantwortet und nicht auswendig lernt.
1. ```python
r = 16, # Wähle irgendeine Zahl > 0 ! Empfohlen: 8, 16, 32, 64, 128
```
Der Rang des Feinabstimmungsprozesses. Eine größere Zahl benötigt mehr Speicher und ist langsamer, kann aber die Genauigkeit bei schwierigeren Aufgaben erhöhen. Wir empfehlen normalerweise Zahlen wie 8 (für schnelle Feinabstimmungen) und bis zu 128. Zu große Zahlen können Überanpassung verursachen und die Qualität deines Modells beeinträchtigen.
2. ```python
target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj",],
```
Wir wählen alle Module für die Feinabstimmung aus. Du kannst einige entfernen, um den Speicherverbrauch zu senken und das Training zu beschleunigen, aber wir raten davon dringend ab. Trainiere einfach auf allen Modulen!
3. ```python
lora_alpha = 16,
```
Der Skalierungsfaktor für die Feinabstimmung. Eine größere Zahl lässt die Feinabstimmung mehr über dein Datenset lernen, kann aber Überanpassung fördern. Wir empfehlen, dass dies dem Rang `r`entspricht oder doppelt so groß ist.
4. ```python
lora_dropout = 0, # Unterstützt beliebige Werte, aber = 0 ist optimiert
```
Lass dies auf 0 für schnelleres Training! Kann Überanpassung verringern, aber nicht sehr stark.
5. ```python
bias = "none", # Unterstützt beliebige Werte, aber = "none" ist optimiert
```
Lass dies auf 0 für schnelleres und weniger überangepasstes Training!
6. ```python
use_gradient_checkpointing = "unsloth", # True oder "unsloth" für sehr langen Kontext
```
Zu den Optionen gehören `True`, `False` und `"unsloth"`. Wir empfehlen `"unsloth"` da wir den Speicherverbrauch um weitere 30 % reduzieren und extrem lange Kontext-Finetunes unterstützen. Du kannst hier mehr dazu lesen: für weitere Details.
7. ```python
random_state = 3407,
```
Die Zahl zur Bestimmung deterministischer Läufe. Training und Feinabstimmung benötigen Zufallszahlen, daher macht das Setzen dieser Zahl Experimente reproduzierbar.
8. ```python
use_rslora = False, # Wir unterstützen rank-stabilisiertes LoRA
```
Erweiterte Funktion, um das `lora_alpha = 16` automatisch festzulegen. Du kannst dies verwenden, wenn du möchtest!
9. ```python
loftq_config = None, # Und LoftQ
```
Erweiterte Funktion zum Initialisieren der LoRA-Matrizen auf die obersten r Singulärvektoren der Gewichte. Kann die Genauigkeit etwas verbessern, kann aber den Speicherverbrauch zu Beginn explodieren lassen.
## 6. Alpaca-Datensatz
Wir werden jetzt den Alpaca-Datensatz verwenden, der durch Aufruf von GPT-4 selbst erstellt wurde. Es ist eine Liste von 52.000 Anweisungen und Ausgaben, die sehr beliebt war, als Llama-1 veröffentlicht wurde, da sie die Feinabstimmung eines Basismodells so gut machte, dass es mit ChatGPT selbst konkurrieren konnte.
Du kannst hier auf die GPT-4-Version des Alpaca-Datensatzes zugreifen: . Eine ältere erste Version des Datensatzes ist hier: . Unten sind einige Beispiele des Datensatzes zu sehen:
Du kannst sehen, dass es in jeder Zeile 3 Spalten gibt – eine Anweisung sowie Eingabe und Ausgabe. Wir kombinieren im Wesentlichen jede Zeile zu einem großen Prompt wie unten. Dies verwenden wir dann, um das Sprachmodell feinabzustimmen, und das machte es ChatGPT sehr ähnlich. Wir nennen diesen Prozess **überwachtes Instruction-Finetuning**.
## 7. Mehrere Spalten für die Feinabstimmung
Ein großes Problem ist jedoch, dass wir bei ChatGPT-ähnlichen Assistenten nur 1 Anweisung / 1 Prompt erlauben und nicht mehrere Spalten / Eingaben. In ChatGPT zum Beispiel kannst du sehen, dass wir 1 Prompt und nicht mehrere Prompts übermitteln müssen.
Das bedeutet im Wesentlichen, dass wir für eine funktionierende Feinabstimmung mehrere Spalten zu 1 großen Prompt „zusammenführen“ müssen!
Zum Beispiel hat der sehr berühmte Titanic-Datensatz viele, viele Spalten. Deine Aufgabe war es, vorherzusagen, ob ein Passagier überlebt oder gestorben ist, basierend auf seinem Alter, der Passagierklasse, dem Fahrpreis usw. Wir können das nicht einfach in ChatGPT eingeben, sondern müssen diese Informationen zu 1 großen Prompt „zusammenführen“.
Wenn wir ChatGPT beispielsweise mit unserem „zusammengeführten“ einzelnen Prompt fragen, der alle Informationen für diesen Passagier enthält, können wir es dann bitten zu raten oder vorherzusagen, ob der Passagier gestorben oder überlebt hat.
Andere Feinabstimmungsbibliotheken verlangen, dass du dein Datenset für die Feinabstimmung manuell vorbereitest, indem du alle deine Spalten zu 1 Prompt zusammenführst. In Unsloth stellen wir einfach die Funktion namens `to_sharegpt` bereit, die dies in einem Schritt erledigt!
Um auf das Titanic-Feinabstimmungs-Notebook zuzugreifen oder wenn du eine CSV- oder Excel-Datei hochladen möchtest, gehe hierhin:
Jetzt ist das etwas komplizierter, da wir viele Anpassungen erlauben, aber es gibt einige Punkte:
* Du musst alle Spalten in geschweifte Klammern einschließen `{}`. Dies sind die Spaltennamen in der eigentlichen CSV-/Excel-Datei.
* Optionale Textbestandteile müssen in `[[]]`eingeschlossen werden. Wenn beispielsweise die Spalte „input“ leer ist, wird die Zusammenführungsfunktion den Text nicht anzeigen und diesen überspringen. Das ist nützlich für Datensätze mit fehlenden Werten.
* Wähle die Ausgabe- oder Ziel-/Vorhersagespalte in `output_column_name`. Für den Alpaca-Datensatz wird dies `output`.
Zum Beispiel können wir für den Titanic-Datensatz ein großes zusammengeführtes Prompt-Format wie unten erstellen, bei dem jede Spalte / jeder Textbestandteil optional wird.
Zum Beispiel stelle dir vor, der Datensatz sieht mit vielen fehlenden Daten so aus:
| Eingeschifft | Alter | Fahrpreis |
| ------------ | ----- | --------- |
| S | 23 | |
| | 18 | 7.25 |
Dann möchten wir nicht, dass das Ergebnis so lautet:
1. Der Passagier ist in S eingeschifft. Sein Alter ist 23. Sein Fahrpreis beträgt **LEER**.
2. Der Passagier ist eingeschifft von **LEER**. Sein Alter ist 18. Sein Fahrpreis beträgt 7,25 $.
Stattdessen können wir durch das optionale Einschließen von Spalten mit `[[]]`diese Informationen vollständig ausschließen.
1. \[\[Der Passagier ist in S eingeschifft.]] \[\[Sein Alter ist 23.]] \[\[Sein Fahrpreis beträgt **LEER**.]]
2. \[\[Der Passagier ist eingeschifft von **LEER**.]] \[\[Sein Alter ist 18.]] \[\[Sein Fahrpreis beträgt 7,25 $.]]
wird zu:
1. Der Passagier ist in S eingeschifft. Sein Alter ist 23.
2. Sein Alter ist 18. Sein Fahrpreis beträgt 7,25 $.
## 8. Mehrere Gesprächsrunden
Ein Problem, falls du es nicht bemerkt hast, ist, dass der Alpaca-Datensatz nur eine einzelne Gesprächsrunde hat, während die Verwendung von ChatGPT interaktiv war und du in mehreren Runden mit ihm sprechen kannst. Zum Beispiel ist links das, was wir wollen, aber rechts, der Alpaca-Datensatz, bietet nur einzelne Gespräche. Wir wollen, dass das feinabgestimmte Sprachmodell irgendwie lernt, wie man mehrrundige Gespräche führt, genau wie ChatGPT.
Also haben wir den `conversation_extension` Parameter eingeführt, der im Wesentlichen einige zufällige Zeilen in deinem Ein-Runden-Datensatz auswählt und sie zu 1 Gespräch zusammenführt! Wenn du ihn zum Beispiel auf 3 setzt, wählen wir zufällig 3 Zeilen aus und führen sie zu 1 zusammen! Wenn du ihn zu lang setzt, kann das Training langsamer machen, aber deinen Chatbot und die finale Feinabstimmung deutlich verbessern!
Dann setze `output_column_name` auf die Vorhersage-/Ausgabespalte. Für den Alpaca-Datensatz wäre das die Ausgabespalte.
Dann verwenden wir die `standardize_sharegpt` Funktion, um das Datenset einfach in ein korrektes Format für die Feinabstimmung zu bringen! Immer aufrufen!
## 9. Anpassbare Chat-Vorlagen
Wir können nun die Chat-Vorlage für die Feinabstimmung selbst festlegen. Das sehr berühmte Alpaca-Format ist unten:
Aber erinnere dich, wir sagten, das sei eine schlechte Idee, weil ChatGPT-ähnliche Feinabstimmungen nur 1 Prompt erfordern? Da wir mit Unsloth erfolgreich alle Datensatzspalten in 1 zusammengeführt haben, können wir im Wesentlichen die unten stehende Chat-Vorlage mit 1 Eingabespalte (Anweisung) und 1 Ausgabe erstellen:
Wir verlangen lediglich, dass du ein `{INPUT}` Feld für die Anweisung und ein `{OUTPUT}` Feld für das Ausgabefeld des Modells einfügst. Wir erlauben tatsächlich auch ein optionales `{SYSTEM}` Feld, das nützlich ist, um einen System-Prompt ähnlich wie in ChatGPT anzupassen. Unten sind zum Beispiel einige coole Beispiele, wie du die Chat-Vorlage anpassen kannst:
Für das in OpenAI-Modellen verwendete ChatML-Format:
Oder du kannst die Llama-3-Vorlage selbst verwenden (die nur mit der Instruct-Version von Llama-3 funktioniert): Wir erlauben tatsächlich auch ein optionales `{SYSTEM}` Feld, das nützlich ist, um einen System-Prompt ähnlich wie in ChatGPT anzupassen.
Oder in der Titanic-Vorhersageaufgabe, bei der du in diesem Colab-Notebook mit CSV- und Excel-Upload vorhersagen musstest, ob ein Passagier gestorben oder überlebt hat:
## 10. Das Modell trainieren
Lass uns jetzt das Modell trainieren! Wir empfehlen normalerweise, das Folgende nicht zu bearbeiten, es sei denn, du möchtest länger feinabstimmen oder mit großen Batchgrößen trainieren.
Wir empfehlen normalerweise nicht, die oben genannten Parameter zu ändern, aber um einige davon zu erläutern:
1. ```python
per_device_train_batch_size = 2,
```
Erhöhe die Batchgröße, wenn du den Speicher deiner GPU stärker ausnutzen möchtest. Erhöhe dies auch, um das Training flüssiger zu machen und zu verhindern, dass der Prozess überanpasst. Wir empfehlen dies normalerweise nicht, da das Training dadurch aufgrund von Padding-Problemen tatsächlich langsamer werden könnte. Stattdessen bitten wir dich normalerweise, `gradient_accumulation_steps` zu erhöhen, was einfach mehr Durchläufe über das Datenset macht.
2. ```python
gradient_accumulation_steps = 4,
```
Entspricht einer Erhöhung der Batchgröße selbst, beeinflusst aber den Speicherverbrauch nicht! Wir empfehlen normalerweise, dies zu erhöhen, wenn du glattere Trainingsverlustkurven möchtest.
3. ```python
max_steps = 60, # num_train_epochs = 1,
```
Wir setzen die Schritte auf 60 für schnelleres Training. Für vollständige Trainingsläufe, die Stunden dauern können, kommentiere stattdessen `max_steps`aus und ersetze es durch `num_train_epochs = 1`. Das auf 1 zu setzen bedeutet 1 vollständigen Durchlauf über dein Datenset. Wir empfehlen normalerweise 1 bis 3 Durchläufe und nicht mehr, sonst überanpasst du deine Feinabstimmung.
4. ```python
learning_rate = 2e-4,
```
Verringere die Lernrate, wenn du den Feinabstimmungsprozess langsamer machen möchtest, aber auch wahrscheinlich zu einem Ergebnis mit höherer Genauigkeit konvergieren willst. Wir empfehlen normalerweise 2e-4, 1e-4, 5e-5, 2e-5 als Zahlen zum Ausprobieren.
Während des Trainings wirst du ein Protokoll mit Zahlen sehen. Das ist der Trainingsverlust, der zeigt, wie gut das Modell aus deinem Datenset lernt. In vielen Fällen ist ein Verlust von etwa 0,5 bis 1,0 ein gutes Zeichen, aber das hängt von deinem Datenset und deiner Aufgabe ab. Wenn der Verlust nicht sinkt, musst du möglicherweise deine Einstellungen anpassen. Wenn der Verlust auf 0 geht, könnte das Überanpassung bedeuten, daher ist es wichtig, auch die Validierung zu prüfen.
## 11. Inferenz / Ausführen des Modells
Lass uns jetzt das Modell ausführen, nachdem wir den Trainingsprozess abgeschlossen haben! Du kannst den gelb unterstrichenen Teil bearbeiten! Tatsächlich können wir, weil wir einen Chatbot mit mehreren Gesprächsrunden erstellt haben, das Modell nun auch so aufrufen, als hätte es einige Gespräche in der Vergangenheit gesehen, wie unten:
Zur Erinnerung: Unsloth selbst bietet **2x schnellere Inferenz** nativ ebenfalls an, also vergiss nie, `FastLanguageModel.for_inference(model)`aufzurufen. Wenn du möchtest, dass das Modell längere Antworten ausgibt, setze `max_new_tokens = 128` auf eine größere Zahl wie 256 oder 1024. Beachte, dass du dann auch länger auf das Ergebnis warten musst!
## 12. Das Modell speichern
Wir können das feinabgestimmte Modell jetzt als kleine 100-MB-Datei speichern, die unten LoRA-Adapter genannt wird. Du kannst es stattdessen auch in den Hugging-Face-Hub hochladen, wenn du dein Modell hochladen möchtest! Vergiss nicht, dir ein Hugging-Face-Token zu besorgen über und fügen Sie Ihr Token hinzu!
Nachdem wir das Modell gespeichert haben, können wir erneut Unsloth verwenden, um das Modell selbst auszuführen! Verwenden Sie `FastLanguageModel` erneut, um es für die Inferenz aufzurufen!
## 13. Nach Ollama exportieren
Schließlich können wir unser feinabgestimmtes Modell direkt nach Ollama exportieren! Zuerst müssen wir Ollama im Colab-Notebook installieren:
Dann exportieren wir das feinabgestimmte Modell in die GGUF-Formate von llama.cpp, wie unten gezeigt:
Hinweis zum Umwandeln `False` zu `True` für 1 Zeile, und nicht jede Zeile zu ändern in `True`, sonst werden Sie sehr lange warten! Normalerweise empfehlen wir, die erste Zeile auf `True`zu setzen, damit wir das feinabgestimmte Modell schnell in `Q8_0` Format (8-Bit-Quantisierung) exportieren können. Wir erlauben Ihnen außerdem, in eine ganze Liste von Quantisierungsmethoden zu exportieren, wobei eine beliebte `q4_k_m`.
Gehen Sie zu um mehr über GGUF zu erfahren. Wir haben hier auch einige manuelle Anweisungen, wie man in GGUF exportiert, falls Sie das möchten:
Sie werden eine lange Textliste wie unten sehen – bitte 5 bis 10 Minuten warten!!
Und ganz am Ende wird es dann so aussehen wie unten:
Dann müssen wir Ollama selbst im Hintergrund ausführen. Wir verwenden `subprocess` weil Colab asynchrone Aufrufe nicht mag, aber normalerweise führt man einfach `ollama serve` im Terminal / in der Eingabeaufforderung aus.
## 14. Automatisch `Modelfile` Erstellung
Der Trick, den Unsloth bietet, ist, dass wir automatisch eine `Modelfile` erstellen, die Ollama benötigt! Das ist nur eine Liste von Einstellungen und enthält die Chat-Vorlage, die wir für den Finetuning-Prozess verwendet haben! Sie können auch die `Modelfile` wie unten gezeigt ausgeben:
Dann bitten wir Ollama, ein mit Ollama kompatibles Modell zu erstellen, indem wir die `Modelfile`
## 15. Ollama-Inferenz
verwenden. Und nun können wir das Modell für die Inferenz aufrufen, wenn Sie den Ollama-Server selbst auf Ihrer eigenen lokalen Maschine / im kostenlosen Colab-Notebook im Hintergrund ausführen möchten. Denken Sie daran, dass Sie den gelb unterstrichenen Teil bearbeiten können.
## 16. Interaktiver ChatGPT-Stil
Aber um das feinabgestimmte Modell tatsächlich wie ein ChatGPT auszuführen, müssen wir noch etwas mehr tun! Klicke zuerst auf das Terminal-Symbol und ein Terminal wird erscheinen. Es befindet sich in der linken Seitenleiste.
Dann musst du möglicherweise zweimal ENTER drücken, um einige seltsame Ausgaben im Terminalfenster zu entfernen. Warte ein paar Sekunden und gib `ollama run unsloth_model` ein und drücke dann ENTER.
Und schließlich kannst du mit dem feinabgestimmten Modell genau wie mit einem echten ChatGPT interagieren! Drücke STRG + D, um das System zu verlassen, und drücke ENTER, um mit dem Chatbot zu sprechen!
## Geschafft!
Du hast erfolgreich ein Sprachmodell feinabgestimmt und es mit Unsloth 2x schneller und mit 70 % weniger VRAM nach Ollama exportiert! Und das alles kostenlos in einem Google-Colab-Notebook!
Wenn du lernen möchtest, wie man Reward Modeling macht, Continued Pretraining durchführt, nach vLLM oder GGUF exportiert, Text Completion macht oder mehr über Tipps und Tricks zur Feinabstimmung erfahren möchtest, gehe zu unserem [Github](https://github.com/unslothai/unsloth#-finetune-for-free).
Wenn du Hilfe bei der Feinabstimmung brauchst, kannst du auch unserem Discord-Server beitreten [hier](https://discord.gg/unsloth). Wenn du Hilfe mit Ollama möchtest, kannst du auch ihrem Server beitreten [hier](https://discord.gg/ollama).
Und zum Schluss möchten wir dir dafür danken, dass du bis hierher gelesen und mitgemacht hast! Wir hoffen, dass dies dir geholfen hat, einige der Grundlagen hinter der Feinabstimmung von Sprachmodellen zu verstehen, und wir hoffen, dass es nützlich war!
Um auf unser Alpaca-Datensatzbeispiel zuzugreifen, klicke [hier](https://colab.research.google.com/drive/1WZDi7APtQ9VsvOrQSSC5DDtxq159j8iZ?usp=sharing), und unsere CSV-/Excel-Feinabstimmungsanleitung ist [hier](https://colab.research.google.com/drive/1VYkncZMfGFkeCEgN2IzbZIKEDkyQuJAS?usp=sharing).
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://unsloth.ai/docs/de/loslegen/fine-tuning-llms-guide/tutorial-how-to-finetune-llama-3-and-use-in-ollama.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.