LLaMA Factory auf Gigabyte AI TOP ATOM installieren: Sprachmodelle mit LoRA und QLoRA fine-tunen

Nachdem ich in meinen vorherigen Beiträgen gezeigt habe, wie ihr Ollama, Open WebUI und ComfyUI auf dem Gigabyte AI TOP ATOM installiert, kommt jetzt etwas für alle, die ihre eigenen Sprachmodelle anpassen also individuelle gestalten möchten: LLaMA Factory – ein Open-Source-Framework, das das Fine-Tuning von Large Language Models vereinfacht und Methoden wie LoRA, QLoRA und Full Fine-Tuning unterstützt. Ich habe den  für meine Erfahrungsberichte von der Firma MIFCOM einen Spezialisten für Hochleistungs- und Gaming-Rechner aus München ausgeliehen bekommen.

In diesem Beitrag zeige ich euch, wie ich LLaMA Factory auf meinem Gigabyte AI TOP ATOM installiert und konfiguriert habe, um Sprachmodelle wie LLaMA, Mistral oder Qwen für spezielle Aufgaben anzupassen. LLaMA Factory nutzt die volle GPU-Performance der Blackwell-Architektur und ermöglicht es euch, Modelle mit verschiedenen Fine-Tuning-Methoden zu trainieren. Wohlgemerkt soll alles lokal auf eurem eigenen AI TOP ATOM oder eurer eigenen NVIDIA DGX Spark laufen. Da das System AI TOP ATOM von Gigabyte auf der gleichen Plattform wie die NVIDIA DGX Spark basiert, funktionieren die offiziellen NVIDIA Playbooks hier genauso zuverlässig.

Die Grundidee: Eigene Sprachmodelle für spezielle Aufgaben anpassen

Bevor ich in die technischen Details einsteige, ein wichtiger Punkt: LLaMA Factory ist ein Framework, dass das Fine-Tuning von Large Language Models deutlich vereinfacht. Im Gegensatz zu komplexen manuellen Setups bietet LLaMA Factory eine einheitliche Oberfläche für verschiedene Fine-Tuning-Methoden wie Supervised Fine-Tuning (SFT), Reinforcement Learning from Human Feedback (RLHF) und Quantized LoRA (QLoRA).

Das Besondere daran: LLaMA Factory unterstützt eine große Auswahl an LLM-Architekturen wie LLaMA, Mistral, Qwen und viele mehr. Ihr könnt eure Modelle für spezielle Domänen anpassen – sei es für Code-Generierung, medizinische Anwendungen oder spezielle Unternehmensanforderungen. Die Installation erfolgt über Docker mit dem NVIDIA PyTorch Container, der bereits CUDA-Unterstützung und alle notwendigen Bibliotheken enthält.

Was ihr dafür braucht:

• Einen Gigabyte AI TOP ATOM, ASUS Ascent, MSI EdgeXpert (oder NVIDIA DGX Spark) der mit dem Netzwerk verbunden ist

• Einen angeschlossenen Monitor oder Terminal-Zugriff auf den AI TOP ATOM

• Docker installiert und für GPU-Zugriff konfiguriert

• Grundkenntnisse in Terminal-Befehlen, Docker und Python

• Mindestens 50 GB freien Speicherplatz für Modelle, Checkpoints und Trainingsdaten

• Eine Internetverbindung zum Download von Modellen vom Hugging Face Hub

• Optional: Ein Hugging Face Account für gated Models (Modelle mit Zugriffsbeschränkungen)

Phase 1: System-Voraussetzungen prüfen

Ich gehe jetzt bei meiner weiteren Anleitung davon aus, dass ihr direkt vor dem AI TOP ATOM oder der NVIDIA DGX Spark sitzt und einen Monitor, Keyboard und Maus angeschlossen habt. Zuerst prüfe ich, ob alle notwendigen System-Voraussetzungen erfüllt sind. Dazu öffne ich ein Terminal auf meinem AI TOP ATOM und führe die folgenden Befehle aus.

Der nachfolgende Befehl zeigt euch, ob das CUDA Toolkit installiert ist:

Befehl: nvcc --version

Ihr solltet CUDA 12.9 oder höher sehen. Als nächstes prüfe ich, ob Docker installiert ist:

Befehl: docker --version

Jetzt prüfe ich mit dem nachfolgenden Befehl, ob Docker GPU-Zugriff hat. Es werden ein paar GB herunter geladen aber die Zeit spart ihr euch dann später wieder denn es wird der gleiche Docker Container für LLaMA Factory benötigt.

Befehl: docker run --gpus all nvcr.io/nvidia/pytorch:25.11-py3 nvidia-smi

Dieser Befehl startet einen Test-Container und zeigt die GPU-Informationen an. Falls Docker noch nicht für GPU-Zugriff konfiguriert ist, müsst ihr das zuerst einrichten. Prüft auch Python und Git:

GIGABYTE AI TOP ATOM – LLaMA Factory Docker Container test

Befehl: python3 --version

Befehl: git --version

Und schließlich prüfe ich, ob die GPU erkannt wird:

Befehl: nvidia-smi

Ihr solltet jetzt die GPU-Informationen sehen. Falls einer dieser Befehle fehlschlägt, müsst ihr die entsprechenden Komponenten zuerst installieren.

GIGABYTE AI TOP ATOM – NVIDIA-SMI

Phase 2: NVIDIA PyTorch Container mit GPU-Unterstützung starten

LLaMA Factory läuft in einem Docker-Container, der bereits PyTorch mit CUDA-Unterstützung enthält. Das macht die Installation deutlich einfacher, da wir uns nicht um Python-Dependencies kümmern müssen. Zuerst erstelle ich ein Arbeitsverzeichnis:

Befehl: mkdir -p ~/llama-factory-workspace

Befehl: cd ~/llama-factory-workspace

NVIDIA PyTorch Container:

Als nächstest kommt der spannende Teil des Projektes. Jetzt starte ich den NVIDIA PyTorch Container mit GPU-Zugriff und mounte das Arbeitsverzeichnis. Wichtig: Ich verwende einen Namen für den Container (--name llama-factory) und lasse --rm weg, damit der Container auch nach einem Neustart erhalten bleibt:

Befehl: docker run --gpus all --ipc=host --ulimit memlock=-1 -it --ulimit stack=67108864 --name llama-factory -p 7862:7860 -v "$PWD":/workspace nvcr.io/nvidia/pytorch:25.11-py3 bash

Dieser Befehl startet den Container und öffnet eine interaktive Bash-Session. Der Container unterstützt CUDA 13 und ist speziell für die Blackwell-Architektur optimiert. Die Parameter --ipc=host und --ulimit sind wichtig für die GPU-Performance und Speicherverwaltung.

Nach dem Start seht ihr einen neuen Prompt, der zeigt, dass ihr jetzt im Container seid. Alle folgenden Befehle werden innerhalb des Containers ausgeführt.

Wichtiger Hinweis: Falls der Container bereits existiert (z.B. nach einem Neustart), startet ihn mit: docker start -ai llama-factory. Um wieder in einen laufenden Container zu kommen: docker exec -it llama-factory bash.

GIGABYTE AI TOP ATOM – LLaMA Factory Docker Container CLI

Phase 3: LLaMA Factory Repository klonen

Jetzt lade ich den LLaMA Factory Quellcode vom offiziellen GitHub Repository herunter. Da wir im Container sind, wird alles im gemounteten Workspace-Verzeichnis gespeichert:

Befehl: git clone --depth 1 https://github.com/hiyouga/LLaMA-Factory.git

Der Parameter --depth 1 lädt nur die neueste Version herunter, was schneller geht. Nach dem Klonen wechsle ich in das LLaMA Factory Verzeichnis:

Befehl: cd LLaMA-Factory

Das Repository enthält alle notwendigen Dateien für LLaMA Factory, einschließlich Beispiel-Konfigurationen und Trainingsskripte.

Phase 4: LLaMA Factory mit Dependencies installieren

Jetzt installiere ich LLaMA Factory im editable Modus mit Metrics-Unterstützung für die Trainingsauswertung:

Befehl: pip install -e ".[metrics]"

Diese Installation kann einige Minuten dauern, da viele Pakete heruntergeladen werden müssen. Der Parameter -e installiert LLaMA Factory im editable Modus, sodass Änderungen am Code sofort wirksam werden. Die Option [metrics] installiert zusätzliche Pakete für die Trainingsmetriken.

Hier habe ich nichts interessantes im Terminal-Fenster gesehen außer „Successfully installed….“ und habe daher kein Bild hier eingefügt.

Phase 5: PyTorch CUDA-Unterstützung prüfen

PyTorch ist bereits im Container vorinstalliert, aber ich prüfe trotzdem, ob CUDA-Unterstützung verfügbar ist:

Befehl: python -c "import torch; print(f'PyTorch: {torch.__version__}, CUDA: {torch.cuda.is_available()}')"

Ihr solltet eine Ausgabe sehen, die etwa so aussieht:

PyTorch: 2.10.0a0+b558c986e8.nv25.11, CUDA: True

Phase 6: Trainings-Konfiguration vorbereiten

LLaMA Factory verwendet YAML-Konfigurationsdateien für das Training. Ich schaue mir die Beispiel-Konfiguration für LoRA Fine-Tuning mit Llama-3 an:

Befehl: cat examples/train_lora/llama3_lora_sft.yaml

Diese Konfiguration enthält alle notwendigen Parameter für das Training: Modellname, Dataset, Batch-Größe, Learning Rate und vieles mehr. Ihr könnt diese Datei kopieren und für eure eigenen Anforderungen anpassen.

Wichtiger Hinweis: Für euer erstes Training empfehle ich, die Beispiel-Konfiguration zunächst unverändert zu verwenden, um sicherzustellen, dass alles funktioniert.

Phase 7: Fine-Tuning Training starten

Bevor ich das Training starte, muss ich möglicherweise beim Hugging Face Hub einloggen, falls das Modell gated ist (Zugriffsbeschränkungen hat). Für öffentliche Modelle ist das nicht notwendig:

Befehl: huggingface-cli login

Ihr werdet nach eurem Hugging Face Token gefragt. Diesen findet ihr in euren Hugging Face Account-Einstellungen unter https://huggingface.co/settings/tokens.

Hinweis:

Nach dem ich das hinterlegt hatte und den nachfolgenden Befehl für den Start des Trainings ausgeführt habe kam folgende Fehlermeldung:

Cannot access gated repo for url https://huggingface.co/meta-llama/Meta-Llama-3-8B-Instruct/resolve/main/config.json.
Access to model meta-llama/Meta-Llama-3-8B-Instruct is restricted and you are not in the authorized list. Visit https://huggingface.co/meta-llama/Meta-Llama-3-8B-Instruct to ask for access.

Ich bin dann für dieses Beispiel hier auf die folgende Seite gegangen und habe für das Modell Zugriff mit meinem User beantragt und auch direkt erhalten.

URL: https://huggingface.co/meta-llama/Meta-Llama-3-8B-Instruct

Jetzt musste ich mich zunächst einmal etwas in Geduld üben bis ich Zugriff auf das Modell erhalten hatte. Ohne dem Zugriff auf das Modell geht es nicht weiter.

META LLAMA 3 COMMUNITY LICENSE AGREEMENT

Auf der folgenden Seite könnt ihr den Status der Freigabe zu dem Modell für das ihr Zugriff beantragt habt einsehen.

URL: https://huggingface.co/settings/gated-repos

Für das Test-Training ob alles funktioniert werden die folgenden Datensätze als Trainingsdaten geladen:

Datensatz identity.json: https://github.com/hiyouga/LLaMA-Factory/blob/main/data/identity.json

Datensatz alpaca_en_demo.json: https://github.com/hiyouga/LLaMA-Factory/blob/main/data/alpaca_en_demo.json

Jetzt starte ich das Fine-Tuning Training mit der Beispiel-Konfiguration aus dem Repository. Hier geht es jetzt einfach einmal darum ob generell alles funktioniert.

Befehl: llamafactory-cli train examples/train_lora/llama3_lora_sft.yaml

Wenn ihr mehr über das Thema Datenaufbereitung für das Training erfahren möchtet dann besucht die folgende Seite.

URL: https://llamafactory.readthedocs.io/en/latest/getting_started/data_preparation.html

Das Training kann je nach Modellgröße und Dataset zwischen 1-7 Stunden dauern. Ihr seht den Fortschritt in Echtzeit, einschließlich der Trainingsmetriken wie Loss-Werte. Die Ausgabe sieht etwa so aus:

***** train metrics *****
  epoch                    =        3.0
  total_flos               = 22851591GF
  train_loss               =     0.9113
  train_runtime            = 0:22:21.99
  train_samples_per_second =      2.437
  train_steps_per_second   =      0.306
Figure saved at: saves/llama3-8b/lora/sft/training_loss.png

Während des Trainings werden regelmäßig Checkpoints gespeichert, sodass ihr das Training bei Bedarf unterbrechen und später fortsetzen könnt. Bei mir sah das laufende Training im Terminal-Fenster dann wie folgt zusammen mit dem DGX Dashboard dann wie im folgenden Bild gezeigt aus.

GIGABYTE AI TOP ATOM – LLaMA Factory Docker Container CLI running training

Das Training war nach ca. 40 Minuten erfolgreich beendet. Das ergenis sah dann wie folgt aus:

GIGABYTE AI TOP ATOM – LLaMA Factory Docker training completed

Hier in dem nachfolgenden Bild ist gut zu sehen wie das Training mit den Testdaten gelaufen ist.

GIGABYTE AI TOP ATOM – LLaMA Factory Docker training loss

Die erzeugten Trainingsdaten findet ihr auf eurem Rechner in dem folgenden Pfad wenn ihr der Anleitung soweit gefolgt seid.

Pfad: /home/<user>/LLaMA-Factory/saves/llama3-8b/lora/sft

Phase 8: Training-Ergebnisse validieren

Nach dem Training prüfe ich, ob alles erfolgreich war und die Checkpoints gespeichert wurden:

Befehl: ls -la saves/llama3-8b/lora/sft/

Ihr solltet sehen:

• Ein Checkpoint-Verzeichnis (z.B. checkpoint-21)

• Modell-Konfigurationsdateien (adapter_config.json)

• Trainingsmetriken mit abnehmenden Loss-Werten

• Ein Trainings-Loss-Diagramm als PNG-Datei

Die Checkpoints enthalten euer angepasstes Modell und können später für Inference oder Export verwendet werden.

Phase 9: Fine-Tuned Modell testen

Jetzt teste ich das angepasste Modell mit einem eigenen Prompt:

Befehl: llamafactory-cli chat examples/inference/llama3_lora_sft.yaml

Dieser Befehl startet einen interaktiven Chat mit eurem fine-tuned Modell. Ihr könnt jetzt Fragen stellen und seht, wie sich das Modell nach dem Training verhält. Zum Beispiel:

Eingabe: Hello, how can you help me today?

Hier das Ergebnis des kurzen Tests als Bild.

GIGABYTE AI TOP ATOM – LLaMA Factory checkpoint test

Das Modell sollte eine Antwort geben, die das angepasste Verhalten zeigt. Um den Chat zu beenden, drückt Ctrl+C.

Phase 10: LLaMA Factory Web-Interface starten

LLaMA Factory bietet auch ein benutzerfreundliches Web-Interface, das das Training und die Verwaltung von Modellen über den Browser ermöglicht. Um das Web-Interface zu starten:

Befehl: llamafactory-cli webui

Das Web-Interface startet und ist standardmäßig unter http://localhost:7860 erreichbar. Um es auch aus dem Netzwerk erreichbar zu machen, verwendet:

Befehl: llamafactory-cli webui --host 0.0.0.0 --port 7862

Hinweis: Achtet bitte darauf wie der Docker Container gestartet wurde und hier auf den Parameter -p 7862:7860 damit der richtige Port in den Container hinnein umgeleitet wird. In der Ausgabe im Terminal steht zwar noch der Port 7860 aber erreichbar ist LLaMA Factory über den Port 7862.

Jetzt könnt ihr von jedem Computer im Netzwerk auf das Web-Interface zugreifen. Öffnet in eurem Browser http://<IP-Adresse-AI-TOP-ATOM>:7862 (ersetzt dabei <IP-Adresse-AI-TOP-ATOM> mit der IP-Adresse eures AI TOP ATOM).

GIGABYTE AI TOP ATOM – LLaMA Factory Web-Interface

Falls eine Firewall aktiv ist, müsst ihr Port 7862 freigeben:

Befehl: sudo ufw allow 7862

Im Web-Interface könnt ihr:

• Modelle trainieren und fine-tunen

• Datasets hochladen und verwalten

• Training-Progress überwachen

• Modelle testen und exportieren

Phase 11: Automatischen Neustart des Web-UI konfigurieren (Reboot-fest machen)

Um sicherzustellen, dass LLaMA Factory nach einem Systemneustart automatisch und ohne manuelles Eingreifen startet, könnt ihr eine Docker Restart Policy konfigurieren und einen kombinierten Startbefehl verwenden. Dies macht euren AI TOP ATOM zu einem zuverlässigen Server. Zuerst stoppt und entfernt ihr den vorhandenen Container:

Befehl: docker stop llama-factory

Befehl: docker rm llama-factory

Startet den Container nun mit der Richtlinie --restart unless-stopped neu. Wir verwenden außerdem einen Bash-Befehl, um sicherzustellen, dass die LLaMA Factory-Abhängigkeiten registriert werden, bevor die Web-UI startet:

Befehl: docker run --gpus all --ipc=host --ulimit memlock=-1 -d --ulimit stack=67108864 --name llama-factory --restart unless-stopped -p 7862:7860 -v "$PWD":/workspace -w /workspace/LLaMA-Factory nvcr.io/nvidia/pytorch:25.11-py3 bash -c "pip install -e '.[metrics]' && llamafactory-cli webui --host 0.0.0.0 --port 7860"

Der Parameter -d (detached) lässt den Container im Hintergrund laufen. Ihr könnt die Logs jederzeit einsehen, um den Startvorgang oder den Trainingsfortschritt zu überwachen:

Befehl: docker logs -f llama-factory

Mit diesem Setup ist das Web-Interface bei jedem Einschalten eures Gigabyte AI TOP ATOM automatisch unter http://<IP-Adresse>:7862 erreichbar.

Phase 12: Modell für Production exportieren

Für den produktiven Einsatz könnt ihr euer fine-tuned Modell exportieren. Dieses kombiniert das Basis-Modell mit den LoRA-Adaptern zu einem einzigen Modell. Dazu führt ihr den folgenden Befehl im Docker Container aus.:

Befehl: llamafactory-cli export examples/merge_lora/llama3_lora_sft.yaml

Das exportierte Modell kann dann in anderen Anwendungen wie Ollama oder vLLM verwendet werden. Der Export-Prozess kann einige Minuten dauern, je nach Modellgröße.

Troubleshooting: Häufige Probleme und Lösungen

In meiner Zeit mit LLaMA Factory auf dem AI TOP ATOM bin ich auf einige typische Probleme gestoßen. Hier sind die häufigsten und wie ich sie gelöst habe:

• CUDA out of memory während des Trainings: Die Batch-Größe ist zu groß für den verfügbaren GPU-Speicher. Reduziert per_device_train_batch_size in der Konfigurationsdatei oder erhöht gradient_accumulation_steps.

• Zugriff auf gated Repository nicht möglich: Bestimmte Hugging Face Modelle haben Zugriffsbeschränkungen. Generiert euren Hugging Face Token neu und beantragt Zugriff auf das gated Modell im Browser.

• Modell-Download schlägt fehl oder ist langsam: Prüft die Internetverbindung. Falls ihr bereits gecachte Modelle habt, könnt ihr HF_HUB_OFFLINE=1 verwenden.

• Training Loss nimmt nicht ab: Die Learning Rate könnte zu hoch oder zu niedrig sein. Passt den learning_rate Parameter an oder prüft die Qualität eures Datasets.

• Docker Container startet nicht: Prüft, ob Docker korrekt installiert ist und ob --gpus all unterstützt wird. Bei manchen Systemen muss die Docker-Gruppe konfiguriert werden.

• Speicherprobleme trotz ausreichendem RAM: Bei der DGX Spark Plattform mit Unified Memory Architecture könnt ihr bei Speicherproblemen den Buffer-Cache manuell leeren:

sudo sh -c 'sync; echo 3 > /proc/sys/vm/drop_caches'

Container verlassen und wieder starten

Falls ihr den Container verlassen möchtet (z.B. um Ressourcen freizugeben), könnt ihr einfach exit eingeben. Der Container bleibt erhalten, da wir keinen --rm Parameter verwendet haben. Eure Daten im gemounteten Workspace-Verzeichnis bleiben ebenfalls erhalten.

Um später wieder in den Container zu kommen, gibt es mehrere Möglichkeiten:

• Container ist gestoppt: Startet ihn mit docker start -ai llama-factory. Das startet den Container und verbindet euch direkt mit der interaktiven Session.

• Container läuft bereits: Verbindet euch mit docker exec -it llama-factory bash. Das öffnet eine neue Bash-Session im laufenden Container.

• Nach einem Neustart: Prüft zuerst den Status mit docker ps -a | grep llama-factory. Falls der Container gestoppt ist, startet ihn mit docker start -ai llama-factory.

Um den Status aller Container zu prüfen:

Befehl: docker ps -a

Um den Container zu stoppen (ohne ihn zu löschen):

Befehl: docker stop llama-factory

Um den Container komplett zu entfernen (alle Daten im Container gehen verloren, aber nicht im gemounteten Workspace):

Befehl: docker rm llama-factory

Falls ihr den Container nach dem Entfernen neu erstellen möchtet, verwendet einfach den Befehl aus Phase 2 erneut.

Rollback: LLaMA Factory wieder entfernen

Falls ihr LLaMA Factory komplett vom AI TOP ATOM entfernen möchtet, führt auf dem System folgende Befehle aus:

Zuerst verlasst ihr den Container (falls ihr noch drin seid):

Befehl: exit

Stoppt den Container (falls er noch läuft):

Befehl: docker stop llama-factory

Entfernt den Container:

Befehl: docker rm llama-factory

Dann entfernt ihr das Workspace-Verzeichnis:

Befehl: rm -rf ~/llama-factory-workspace

Um auch nicht verwendete Docker-Container und Images zu entfernen:

Befehl: docker system prune -f

Um nur Container zu entfernen (Images bleiben erhalten):

Befehl: docker container prune -f

Wichtiger Hinweis: Diese Befehle entfernen alle Trainingsdaten, Checkpoints und Modelle. Stellt sicher, dass ihr wirklich alles entfernen möchtet, bevor ihr diese Befehle ausführt. Die Checkpoints enthalten euer angepasstes Modell und können nicht einfach wiederhergestellt werden.

Zusammenfassung & Fazit

Die Installation von LLaMA Factory auf dem Gigabyte AI TOP ATOM ist dank der Kompatibilität mit den NVIDIA DGX Spark Playbooks erstaunlich unkompliziert. In etwa 30-60 Minuten habe ich LLaMA Factory eingerichtet und kann jetzt eigene Sprachmodelle für spezielle Aufgaben anpassen.

Was mich besonders begeistert: Die Performance der Blackwell-GPU wird voll ausgenutzt, und die Docker-basierte Installation macht das Setup deutlich einfacher als eine manuelle Installation. LLaMA Factory bietet eine einheitliche Oberfläche für verschiedene Fine-Tuning-Methoden, sodass ihr schnell zwischen LoRA, QLoRA und Full Fine-Tuning wechseln könnt.

Besonders praktisch finde ich auch, dass die Trainings-Checkpoints automatisch gespeichert werden. Das ermöglicht es, das Training bei Bedarf zu unterbrechen und später fortzusetzen. Die Trainingsmetriken werden ebenfalls gespeichert, sodass ihr den Fortschritt genau verfolgen könnt.

Für Teams oder Entwickler, die ihre eigenen Sprachmodelle anpassen möchten, ist das eine perfekte Lösung: Ein zentraler Server mit voller GPU-Power, auf dem ihr Modelle für spezielle Domänen trainieren könnt. Die exportierten Modelle können dann in anderen Anwendungen wie Ollama oder vLLM verwendet werden.

Falls ihr Fragen habt oder auf Probleme stoßt, schaut gerne in die offizielle NVIDIA DGX Spark Dokumentation, die LLaMA Factory Dokumentation oder in die LLaMA Factory ReadTheDocs. Die Community ist sehr hilfsbereit, und die meisten Probleme lassen sich schnell lösen.

Nächster Schritt: Eigene Datasets vorbereiten und Modelle anpassen

Ihr habt jetzt LLaMA Factory erfolgreich installiert und ein erstes Training durchgeführt. Die Grundinstallation funktioniert, aber das ist erst der Anfang. Der nächste Schritt ist die Vorbereitung eurer eigenen Datasets für spezielle Anwendungsfälle.

LLaMA Factory unterstützt verschiedene Dataset-Formate, einschließlich JSON-Dateien für Instruction Tuning. Ihr könnt eure Modelle für Code-Generierung, medizinische Anwendungen, Unternehmenswissen oder andere spezielle Domänen anpassen. Die Dokumentation zeigt euch, wie ihr eure Daten im richtigen Format vorbereitet.

Viel Erfolg beim Experimentieren mit LLaMA Factory auf eurem Gigabyte AI TOP ATOM. Ich bin gespannt, welche angepassten Modelle ihr damit entwickelt! Lasst es mich und meine Leser hier in den Kommentaren wissen.