# 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. Es 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)ausgeführt werden. Du wirst in der Lage sein, mit dem Chatbot interaktiv wie unten zu interagieren:
**Unsloth** macht das Feintuning viel einfacher und kann das feinabgestimmte Modell automatisch nach **Ollama** mit integrierter automatischer `Modelfile` erstellen 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 es 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 Feintuning von LLMs wie Llama-3, Mistral, Phi-3 und Gemma 2x schneller, verwendet 70 % weniger Speicher und ohne Genauigkeitsverlust! Wir werden während dieses Tutorials Google Colab verwenden, das eine kostenlose GPU bereitstellt. Unten kannst du 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 in deinem Google-Konto anmelden!***
## 2. Was ist Ollama?
[Ollama ](https://github.com/ollama/ollama)ermöglicht dir, Sprachmodelle schnell und einfach auf deinem eigenen Computer auszuführen! Es startet unauffällig ein Programm, das im Hintergrund 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 schnell die Ergebnisse zurück! Wir werden Ollama als unsere Inferenz-Engine verwenden!
## 3. Unsloth installieren
Falls du noch nie ein Colab-Notebook verwendet hast, hier eine kurze Einführung in das Notebook selbst:
1. **Play-Schaltfläche bei jeder "Zelle".** Klicke hierauf, um den Code dieser Zelle auszuführen. Du darfst keine Zellen überspringen und musst jede Zelle in chronologischer Reihenfolge ausführen. Wenn Fehler auftreten, führe einfach die Zelle erneut aus, die du zuvor nicht ausgeführt hast. Eine andere Möglichkeit ist, STRG + ENTER zu drücken, wenn du nicht auf die Play-Schaltfläche klicken möchtest.
2. **Runtime-Schaltfläche in der oberen Symbolleiste.** Du kannst diese Schaltfläche auch 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. **Connect / Reconnect T4-Schaltfläche.** Hier kannst du weitere erweiterte Systemstatistiken ansehen.
Die erste Installationszelle sieht wie unten aus: Denk daran, auf die PLAY-Schaltfläche in den Klammern \[ ] zu klicken. Wir holen unser Open-Source-GitHub-Paket und installieren einige andere Pakete.
## 4. Ein Modell zum Feintuning auswählen
Lass uns nun ein Modell für das Feintuning auswählen! Standardmäßig haben wir Llama-3 von Meta / Facebook verwendet, das mit satten 15 Billionen "Tokens" trainiert wurde. Nimm an, ein Token sei etwa ein englisches Wort. Das entspricht ungefähr 350.000 dicken Enzyklopädien! Weitere 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 melden einen Fehler, wenn es nicht funktioniert.
Es gibt 3 weitere Einstellungen, die du umschalten kannst:
1. ```
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, 2048 für Testzwecke einzustellen. Unsloth unterstützt auch Feintuning mit sehr langem Kontext, und wir zeigen, dass wir 4x längere Kontextlängen als die besten bieten können.
2. ```
dtype = None
```
Lass dies auf None, aber du kannst für neuere GPUs torch.float16 oder torch.bfloat16 auswählen.
3. ```
load_in_4bit = True
```
Wir führen das Feintuning in 4-Bit-Quantisierung durch. Dadurch wird der Speicherverbrauch um das 4-Fache reduziert, sodass wir tatsächlich Feintuning auf einer kostenlosen GPU mit 16 GB Speicher durchführen können. 4-Bit-Quantisierung wandelt Gewichte im Wesentlichen in eine begrenzte Menge von Zahlen um, um den Speicherverbrauch zu reduzieren. Ein Nachteil davon ist eine Genauigkeitsminderung von 1–2 %. Setze dies auf False auf größeren GPUs wie H100s, wenn du diese kleine zusätzliche Genauigkeit möchtest.
Wenn du die Zelle ausführst, werden einige Ausgaben zur Unsloth-Version, zum verwendeten Modell, dazu, wie viel Speicher deine GPU hat, und zu einigen anderen Statistiken angezeigt. Ignoriere das vorerst.
## 5. Parameter für das Feintuning
Um dein Feintuning anzupassen, kannst du nun die Zahlen oben bearbeiten, aber du kannst es auch ignorieren, da wir bereits ziemlich vernünftige Werte ausgewählt haben.
Das Ziel ist es, diese Zahlen zu ändern, um die Genauigkeit zu erhöhen, aber auch **Überanpassung entgegenzuwirken**. Überanpassung bedeutet, dass du das Sprachmodell ein Dataset auswendig lernen lässt und es dann nicht mehr in der Lage ist, neue Fragen zu beantworten. Wir wollen, dass ein finales Modell unbekannte Fragen beantwortet und nicht bloß auswendig lernt.
1. ```
r = 16, # Wähle eine beliebige Zahl > 0 ! Vorgeschlagen: 8, 16, 32, 64, 128
```
Der Rang des Feintuning-Prozesses. Eine größere Zahl verbraucht mehr Speicher und ist langsamer, kann aber die Genauigkeit bei schwierigeren Aufgaben erhöhen. Wir empfehlen normalerweise Werte wie 8 (für schnelle Feintunings) bis hin zu 128. Zu große Werte können Überanpassung verursachen und die Qualität deines Modells beeinträchtigen.
2. ```
target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj",],
```
Wir wählen alle Module für das Feintuning aus. Du kannst einige entfernen, um den Speicherverbrauch zu reduzieren und das Training zu beschleunigen, aber wir raten davon dringend ab. Trainiere einfach auf allen Modulen!
3. ```
lora_alpha = 16,
```
Der Skalierungsfaktor für das Feintuning. Eine größere Zahl lässt das Feintuning mehr über dein Dataset lernen, kann aber Überanpassung fördern. Wir empfehlen, dass dies gleich dem Rang `r`ist oder doppelt so groß.
4. ```notebook-python
lora_dropout = 0, # Unterstützt jeden Wert, aber = 0 ist optimiert
```
Lass dies für schnelleres Training auf 0! Kann Überanpassung verringern, aber nicht sehr stark.
5. ```
bias = "none", # Unterstützt jeden Wert, aber = "none" ist optimiert
```
Lass dies für schnelleres und weniger überangepasstes Training auf 0!
6. ```
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 langes Kontext-Feintuning unterstützen. Du kannst hier mehr dazu lesen: für weitere Details.
7. ```
random_state = 3407,
```
Die Zahl zur Bestimmung deterministischer Läufe. Training und Feintuning benötigen Zufallszahlen, daher macht das Setzen dieser Zahl Experimente reproduzierbar.
8. ```
use_rslora = False, # Wir unterstützen rank-stabilisiertes LoRA
```
Erweiterte Funktion, um `lora_alpha = 16` automatisch festzulegen. Du kannst das verwenden, wenn du möchtest!
9. ```
loftq_config = None, # Und LoftQ
```
Erweiterte Funktion, um die LoRA-Matrizen mit den obersten r Singulärvektoren der Gewichte zu initialisieren. Kann die Genauigkeit etwas verbessern, kann aber den Speicherverbrauch zu Beginn explodieren lassen.
## 6. Alpaca-Dataset
Wir werden nun das Alpaca-Dataset verwenden, das durch Aufruf von GPT-4 selbst erstellt wurde. Es ist eine Liste von 52.000 Anweisungen und Ausgaben, die sehr populär war, als Llama-1 veröffentlicht wurde, da sie das Feintuning eines Basis-LLM mit ChatGPT selbst konkurrenzfähig machte.
Du kannst hier auf die GPT-4-Version des Alpaca-Datasets zugreifen: . Eine ältere erste Version des Datasets findest du hier: . Unten sind einige Beispiele des Datasets zu sehen:
Du kannst sehen, dass es in jeder Zeile 3 Spalten gibt – eine Anweisung sowie einen Input und einen Output. Wir kombinieren jede Zeile im Wesentlichen zu einem großen Prompt wie unten. Dann verwenden wir das, um das Sprachmodell feinabzustimmen, und das machte es ChatGPT sehr ähnlich. Wir nennen diesen Prozess **überwachtes Instruction-Feintuning**.
## 7. Mehrere Spalten für das Feintuning
Ein großes Problem ist jedoch, dass wir bei Assistenten im ChatGPT-Stil nur 1 Anweisung / 1 Prompt zulassen und nicht mehrere Spalten / Eingaben. In ChatGPT zum Beispiel musst du 1 Prompt senden und nicht mehrere Prompts.
Das bedeutet im Wesentlichen, dass wir mehrere Spalten zu einem großen Prompt "zusammenführen" müssen, damit das Feintuning überhaupt funktioniert!
Zum Beispiel hat das sehr berühmte Titanic-Dataset viele, viele Spalten. Deine Aufgabe war es, anhand von Alter, Passagierklasse, Fahrpreis usw. vorherzusagen, ob ein Passagier überlebt hat oder gestorben ist. Wir können das nicht einfach in ChatGPT eingeben, sondern müssen diese Informationen in einen großen Prompt "zusammenführen".
Wenn wir ChatGPT beispielsweise mit unserem "zusammengeführten" einzelnen Prompt fragen, der alle Informationen zu diesem Passagier enthält, können wir es dann bitten zu raten oder vorherzusagen, ob der Passagier gestorben oder überlebt hat.
Andere Feintuning-Bibliotheken verlangen, dass du dein Dataset manuell für das Feintuning vorbereitest, indem du alle Spalten zu einem Prompt zusammenführst. In Unsloth stellen wir einfach die Funktion namens `to_sharegpt` bereit, die das alles in einem Schritt erledigt!
Um auf das Titanic-Feintuning-Notebook zuzugreifen oder wenn du eine CSV- oder Excel-Datei hochladen möchtest, gehe hierhin:
Nun, das ist etwas komplizierter, da wir viele Anpassungsmöglichkeiten bieten, aber es gibt ein paar Punkte:
* Du musst alle Spalten in geschweifte Klammern einschließen `{}`. Das sind die Spaltennamen in der tatsächlichen CSV-/Excel-Datei.
* Optionale Textbestandteile müssen in `[[]]`eingeschlossen werden. Wenn zum Beispiel die Spalte "input" leer ist, zeigt die Zusammenführungsfunktion den Text nicht an und überspringt ihn. Das ist nützlich für Datensätze mit fehlenden Werten.
* Wähle die Ausgabe- oder Ziel-/Vorhersagespalte in `output_column_name`. Für das Alpaca-Dataset wäre das `output`.
Zum Beispiel können wir im Titanic-Dataset ein großes zusammengeführtes Prompt-Format wie unten erstellen, bei dem jede Spalte / jeder Textabschnitt optional wird.
Stell dir zum Beispiel vor, das Dataset sähe so aus, mit vielen fehlenden Daten:
| Eingeschifft in | Alter | Fahrpreis |
| --------------- | ----- | --------- |
| S | 23 | |
| | 18 | 7.25 |
Dann möchten wir nicht, dass das Ergebnis so lautet:
1. Der Passagier ist in S eingeschifft worden. Sein Alter beträgt 23. Sein Fahrpreis beträgt **LEER**.
2. Der Passagier ist eingeschifft von **LEER**. Sein Alter beträgt 18. Sein Fahrpreis beträgt 7,25 $.
Stattdessen können wir durch optionales Einschließen von Spalten mit `[[]]`diese Informationen vollständig ausschließen.
1. \[\[Der Passagier ist in S eingeschifft worden.]] \[\[Sein Alter beträgt 23.]] \[\[Sein Fahrpreis beträgt **LEER**.]]
2. \[\[Der Passagier ist eingeschifft von **LEER**.]] \[\[Sein Alter beträgt 18.]] \[\[Sein Fahrpreis beträgt 7,25 $.]]
wird zu:
1. Der Passagier ist in S eingeschifft worden. Sein Alter beträgt 23.
2. Sein Alter beträgt 18. Sein Fahrpreis beträgt 7,25 $.
## 8. Mehrstufige Unterhaltungen
Ein Problem, falls du es nicht bemerkt hast: Das Alpaca-Dataset ist ein einzelner Gesprächsverlauf, während du dich bei ChatGPT interaktiv unterhalten und in mehreren Runden mit ihm sprechen kannst. Zum Beispiel ist links das, was wir wollen, aber rechts liefert das Alpaca-Dataset nur einzelne Unterhaltungen. Wir möchten, dass das feinabgestimmte Sprachmodell irgendwie lernt, mehrstufige Unterhaltungen so zu führen wie ChatGPT.
Also haben wir den `conversation_extension` Parameter eingeführt, der im Wesentlichen einige zufällige Zeilen in deinem Single-Turn-Dataset auswählt und sie zu einer Unterhaltung zusammenführt! Wenn du ihn beispielsweise auf 3 setzt, wählen wir zufällig 3 Zeilen aus und führen sie zu einer zusammen! Wenn du sie zu lang machst, kann das Training langsamer werden, aber es könnte deinen Chatbot und das finale Feintuning deutlich verbessern!
Dann setze `output_column_name` auf die Vorhersage-/Ausgabespalte. Für das Alpaca-Dataset wäre das die Ausgabespalte.
Dann verwenden wir die `standardize_sharegpt` Funktion, um das Dataset einfach in ein korrektes Format für das Feintuning zu bringen! Immer aufrufen!
## 9. Anpassbare Chat-Vorlagen
Wir können nun die Chat-Vorlage für das Feintuning selbst festlegen. Das sehr berühmte Alpaca-Format ist unten zu sehen:
Aber erinnere dich: Wir hatten gesagt, dass das eine schlechte Idee sei, weil Feintunings im ChatGPT-Stil nur 1 Prompt benötigen? Da wir mit Unsloth erfolgreich alle Dataset-Spalten zu 1 zusammengeführt haben, können wir im Wesentlichen die folgende Chat-Vorlage mit 1 Input-Spalte (Anweisung) und 1 Output erstellen:
Wir verlangen nur, dass du ein `{INPUT}` Feld für die Anweisung und ein `{OUTPUT}` Feld für das Ausgabefeld des Modells einfügst. Tatsächlich erlauben wir auch ein optionales `{SYSTEM}` Feld, das nützlich ist, um eine Systemanweisung ähnlich wie in ChatGPT anzupassen. Unten sind zum Beispiel einige coole Beispiele, wie du die Chat-Vorlage anpassen kannst:
Für das von OpenAI-Modellen verwendete ChatML-Format:
Oder du kannst die Llama-3-Vorlage selbst verwenden (die nur mit der Instruct-Version von Llama-3 funktioniert): Tatsächlich erlauben wir auch ein optionales `{SYSTEM}` Feld, das nützlich ist, um eine Systemanweisung ähnlich wie in ChatGPT anzupassen.
Oder bei der Titanic-Vorhersageaufgabe, bei der du in diesem Colab-Notebook vorhersagen musstest, ob ein Passagier gestorben oder überlebt hat, und das CSV- und Excel-Uploads enthält:
## 10. Das Modell trainieren
Lass uns jetzt das Modell trainieren! Wir empfehlen normalerweise, das Folgende nicht zu bearbeiten, es sei denn, du möchtest für mehr Schritte feinabstimmen oder auf großen Batchgrößen trainieren.
Wir empfehlen normalerweise nicht, die oben genannten Parameter zu ändern, aber um einige davon zu erläutern:
1. ```
per_device_train_batch_size = 2,
```
Erhöhe die Batchgröße, wenn du den Speicher deiner GPU stärker ausnutzen möchtest. Erhöhe sie auch, um das Training gleichmäßiger zu machen und den Prozess weniger überangepasst werden zu lassen. Wir empfehlen das normalerweise nicht, da das Training dadurch aufgrund von Padding-Problemen tatsächlich langsamer werden könnte. Stattdessen empfehlen wir normalerweise, `gradient_accumulation_steps` zu erhöhen,
2. ```
gradient_accumulation_steps = 4,
```
Entspricht einer Erhöhung der oben genannten Batchgröße, hat aber keinen Einfluss auf den Speicherverbrauch! Wir empfehlen normalerweise, dies zu erhöhen, wenn du glattere Kurven für den Trainingsverlust möchtest.
3. ```
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 einen vollständigen Durchgang über dein Dataset. Wir empfehlen normalerweise 1 bis 3 Durchgänge und nicht mehr, sonst überanpasst du dein Feintuning.
4. ```
learning_rate = 2e-4,
```
Verringere die Lernrate, wenn du den Feintuning-Prozess 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 auszuprobierende Werte.
Du wirst während des Trainings ein Protokoll mit Zahlen sehen. Das ist der Trainingsverlust, der zeigt, wie gut das Modell aus deinem Dataset lernt. In vielen Fällen ist ein Verlust um 0,5 bis 1,0 ein gutes Zeichen, aber das hängt von deinem Dataset 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 jetzt auch so aufrufen, als hätte es einige Unterhaltungen in der Vergangenheit gesehen, wie unten:
Zur Erinnerung: Unsloth selbst bietet **2x schnellere Inferenz** auch nativ an, also vergiss nicht, `FastLanguageModel.for_inference(model)`aufzurufen. Wenn das Modell längere Antworten ausgeben soll, setze `max_new_tokens = 128` auf eine größere Zahl wie 256 oder 1024. Beachte, dass du auch länger auf das Ergebnis warten musst!
## 12. Das Modell speichern
Wir können das feinabgestimmte Modell nun als kleine 100-MB-Datei speichern, die wie unten ein LoRA-Adapter genannt wird. Wenn du möchtest, kannst du das Modell stattdessen auch auf den Hugging-Face-Hub hochladen! Denk daran, dir über einen Hugging-Face-Token zu besorgen und deinen Token hinzuzufügen!
Nachdem wir das Modell gespeichert haben, können wir Unsloth erneut verwenden, um das Modell selbst auszuführen! Verwende `FastLanguageModel` nochmals, um es für die Inferenz aufzurufen!
## 13. Export nach Ollama
Schließlich können wir unser feinabgestimmtes Modell nach Ollama selbst exportieren! Zuerst müssen wir Ollama im Colab-Notebook installieren:
Dann exportieren wir das feinabgestimmte Modell in llama.cpps GGUF-Formate wie unten:
Hinweis: Konvertiere `False` zu `True` für 1 Zeile und ändere nicht jede Zeile auf `True`oder du wirst sehr lange warten! Wir empfehlen normalerweise, die erste Zeile auf `True`zu setzen, damit wir das feinabgestimmte Modell schnell in das `Q8_0` Format (8-Bit-Quantisierung) exportieren können. Wir erlauben dir außerdem, in eine ganze Liste von Quantisierungsmethoden zu exportieren, wobei eine beliebte davon `q4_k_m`.
Gehe zu um mehr über GGUF zu erfahren. Wir haben auch einige manuelle Anweisungen, wie du nach GGUF exportieren kannst, falls du das hier möchtest:
Du wirst unten eine lange Liste von Text sehen – bitte warte 5 bis 10 Minuten!!
Und schließlich wird es ganz am Ende so aussehen:
Dann müssen wir Ollama selbst im Hintergrund ausführen. Wir verwenden `subprocess` weil Colab keine asynchronen Aufrufe mag, aber normalerweise führt man einfach `ollama serve` im Terminal / in der Eingabeaufforderung aus.
## 14. Automatische `Modelfile` Erstellung
Der Trick, den Unsloth bereitstellt, ist, dass wir automatisch ein `Modelfile` erstellen, das Ollama benötigt! Dies ist einfach eine Liste von Einstellungen und enthält die Chat-Vorlage, die wir für den Feintuning-Prozess verwendet haben! Du kannst außerdem das `Modelfile` wie unten generiert ausgeben:
Dann bitten wir Ollama, mithilfe des `Modelfile`
## 15. Ollama-Inferenz
Und wir können das Modell nun für Inferenz aufrufen, wenn du den Ollama-Server selbst verwenden möchtest, der auf deinem eigenen lokalen Rechner / im kostenlosen Colab-Notebook im Hintergrund läuft. Denk daran, dass du den gelb unterstrichenen Teil bearbeiten kannst.
## 16. Interaktiver ChatGPT-Stil
Aber um das feinabgestimmte Modell tatsächlich wie ChatGPT auszuführen, müssen wir noch ein wenig mehr tun! Klicke zuerst auf das Terminal-Symbol und ein Terminal wird geöffnet. 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 tippe `ollama run unsloth_model` und drücke dann ENTER.
Und schließlich kannst du mit dem feinabgestimmten Modell genauso interagieren wie mit einem echten ChatGPT! Drücke STRG + D, um das System zu verlassen, und drücke ENTER, um mit dem Chatbot zu unterhalten!
## Du hast es geschafft!
Du hast erfolgreich ein Sprachmodell feinabgestimmt und 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, Textvollendung macht oder mehr über Tipps und Tricks zum Feintuning erfahren willst, besuche unser [Github](https://github.com/unslothai/unsloth#-finetune-for-free).
Wenn du Hilfe beim Feintuning 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 schließlich möchten wir dir dafür danken, dass du bis hierhin gelesen und mitgemacht hast! Wir hoffen, dass du dadurch einige der Grundlagen hinter dem Feintuning von Sprachmodellen verstanden hast, und wir hoffen, dass dies nützlich war!
Um auf unser Alpaca-Dataset-Beispiel zuzugreifen, klicke [hier](https://colab.research.google.com/drive/1WZDi7APtQ9VsvOrQSSC5DDtxq159j8iZ?usp=sharing), und unsere CSV-/Excel-Feintuning-Anleitung ist [hier](https://colab.research.google.com/drive/1VYkncZMfGFkeCEgN2IzbZIKEDkyQuJAS?usp=sharing).
---
# Agent Instructions: 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.