LLaMA-Factory

Feinabstimme 100+ LLMs mit LoRA/QLoRA und einer Web-UI auf Clore.ai-GPUs mit LLaMA-Factory

LLaMA-Factory ist das umfassendste Open-Source-Fine-Tuning-Framework und unterstützt über 100 Sprachmodelle, darunter alle LLaMA-Varianten, Qwen, Mistral, Phi, Falcon, ChatGLM und mehr. Es bietet LoRA, QLoRA, vollständiges Fine-Tuning, RLHF, DPO und PPO — alles über eine intuitive Weboberfläche (LLaMA Board) oder die CLI. Die On-Demand-GPU-Server von CLORE.AI machen es zur perfekten Plattform, um Fine-Tuning-Jobs zu einem Bruchteil der Kosten von Cloud-Anbietern zu starten.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

Serveranforderungen

Parameter	Minimum	Empfohlen
RAM	16 GB	32 GB+
VRAM	8 GB (QLoRA)	24 GB+
Festplatte	50 GB	200 GB+
GPU	NVIDIA RTX 2080+	A100, RTX 4090

Die Trainingsmethode bestimmt die GPU-Anforderungen:

• QLoRA (4-Bit): 8 GB VRAM für 7B-Modelle, 16 GB für 13B

• LoRA (float16): 16 GB VRAM für 7B-Modelle, 40 GB für 13B

• Vollständiges Fine-Tuning: ~14 GB VRAM pro 7B-Parameter (+ Optimizer-Zustände)

• Multi-GPU (DeepSpeed/FSDP) skaliert über jede beliebige Anzahl von GPUs

Schnellbereitstellung auf CLORE.AI

Docker-Image: hiyouga/llamafactory:latest

Ports: 22/tcp, 7860/http

Umgebungsvariablen:

Variable	Beispiel	Beschreibung
HF_TOKEN	hf_xxx...	HuggingFace-Token für geschützte Modelle
WANDB_API_KEY	xxx...	Weights & Biases zur Nachverfolgung von Experimenten
CUDA_VISIBLE_DEVICES	0,1	Zu verwendende GPUs

Schritt-für-Schritt-Einrichtung

1. Mieten Sie einen GPU-Server auf CLORE.AI

Besuchen CLORE.AI-Marktplatz und wählen Sie basierend auf Ihrer Aufgabe:

Aufgabe	VRAM	Empfohlene GPU
QLoRA 7B	8 GB	RTX 3070/2080
QLoRA 13B	16 GB	RTX 3090/A4000
LoRA 7B	16 GB	RTX 3090/A4000
LoRA 13B	40 GB	A6000/A100 40GB
Vollständiges FT 7B	80 GB	A100 80GB
Multi-GPU	Variiert	2-8× jede GPU

2. Verbinden Sie sich per SSH mit Ihrem Server

ssh -p <PORT> root@<SERVER_IP>

3. Arbeitsverzeichnisse erstellen

mkdir -p /root/llamafactory/{data,models,output,saves}

4. Docker-Image herunterladen

docker pull hiyouga/llamafactory:latest

5. LLaMA-Factory starten

Starten mit der Web-UI (LLaMA Board):

docker run -d \
  --name llamafactory \\
  --gpus all \
  -p 7860:7860 \
  -v /root/llamafactory/data:/app/LLaMA-Factory/data \\
  -v /root/llamafactory/models:/root/.cache/huggingface \\
  -v /root/llamafactory/output:/app/LLaMA-Factory/output \\
  -v /root/llamafactory/saves:/app/LLaMA-Factory/saves \\
  -e HF_TOKEN=hf_your_token_here \
  hiyouga/llamafactory:latest \\
  llamafactory-cli webui

Mit Weights-&-Biases-Tracking:

docker run -d \
  --name llamafactory \\
  --gpus all \
  -p 7860:7860 \
  -v /root/llamafactory/data:/app/LLaMA-Factory/data \\
  -v /root/llamafactory/models:/root/.cache/huggingface \\
  -v /root/llamafactory/output:/app/LLaMA-Factory/output \\
  -v /root/llamafactory/saves:/app/LLaMA-Factory/saves \\
  -e HF_TOKEN=hf_your_token_here \
  -e WANDB_API_KEY=your_wandb_key \\
  hiyouga/llamafactory:latest \\
  llamafactory-cli webui

Multi-GPU mit DeepSpeed (4 GPUs):

docker run -d \
  --name llamafactory \\
  --gpus all \
  --shm-size 16g \
  --ipc host \
  -p 7860:7860 \
  -v /root/llamafactory/data:/app/LLaMA-Factory/data \\
  -v /root/llamafactory/models:/root/.cache/huggingface \\
  -v /root/llamafactory/output:/app/LLaMA-Factory/output \\
  -e CUDA_VISIBLE_DEVICES=0,1,2,3 \\
  hiyouga/llamafactory:latest \\
  bash -c "llamafactory-cli webui"

6. Zugriff auf die Weboberfläche

Prüfen Sie die Logs und holen Sie die URL:

docker logs -f llamafactory

Ihre CLORE.AI http_pub-URL für Port 7860:

https://<order-id>-7860.clore.ai/

---

Anwendungsbeispiele

Beispiel 1: LoRA-Fine-Tuning über die Web-UI (LLaMA Board)

1. Öffnen Sie das LLaMA Board unter Ihrer CLORE.AI-URL

2. Gehen Sie zu Train Tab

3. Konfigurieren:

   • Modellname: LLaMA-3 → Meta-Llama-3-8B-Instruct

   • Trainingsphase: Überwachtes Fine-Tuning

   • Datensatz: Wählen Sie Ihren Datensatz aus (oder laden Sie einen eigenen hoch)

   • Fine-Tuning-Methode: lora

   • LoRA-Rang: 8 (höher = mehr trainierte Parameter)

   • Lernrate: 1e-4

   • Epochen: 3

   • Ausgabeverzeichnis: llama3-finetuned

4. Klicken Sie auf Start um das Training zu starten

5. Überwachen Sie die Loss-Kurven im Loss Diagramm

Beispiel 2: QLoRA-Fine-Tuning über die CLI

Bereiten Sie eine Trainingskonfigurations-YAML vor:

docker exec -it llamafactory bash

cat > /app/LLaMA-Factory/configs/qlora_mistral.yaml << 'EOF'
### Modell
model_name_or_path: mistralai/Mistral-7B-Instruct-v0.3

### Methode
stage: sft
do_train: true
finetuning_type: lora
lora_target: all
lora_rank: 16
lora_alpha: 32
lora_dropout: 0.05

### Datensatz
dataset: alpaca_en
template: mistral
cutoff_len: 2048
max_samples: 1000
overwrite_cache: true
preprocessing_num_workers: 16

### Ausgabe
output_dir: saves/mistral-qlora
logging_steps: 10
save_steps: 500
plot_loss: true
overwrite_output_dir: true

### Train
per_device_train_batch_size: 2
gradient_accumulation_steps: 8
learning_rate: 0.0001
num_train_epochs: 3.0
lr_scheduler_type: cosine
warmup_ratio: 0.1
fp16: true

### Quantisierung
quantization_method: bitsandbytes
quantization_bit: 4
EOF

# Training ausführen
llamafactory-cli train /app/LLaMA-Factory/configs/qlora_mistral.yaml

Beispiel 3: Eigenen Datensatz hochladen

Erstellen Sie einen benutzerdefinierten Datensatz im Alpaca-Format:

# Datensatzdatei erstellen
cat > /root/llamafactory/data/my_dataset.json << 'EOF'
[
  {
    "instruction": "Sie sind ein Kundendienstmitarbeiter für ein Technologieunternehmen. Antworten Sie hilfsbereit.",
    "input": "Mein Laptop lässt sich nach dem Update nicht einschalten. Was soll ich tun?",
    "output": "Ich verstehe, wie frustrierend das sein kann. Lassen Sie uns Schritt für Schritt vorgehen:\n\n1. **Halten Sie den Netzschalter 10 Sekunden lang gedrückt**, um das Gerät zwangsweise auszuschalten\n2. **Entfernen Sie das Netzkabel** und den Akku, falls er herausnehmbar ist, und warten Sie 30 Sekunden\n3. **Schließen Sie die Stromversorgung wieder an** und versuchen Sie erneut, das Gerät einzuschalten\n4. Falls weiterhin keine Reaktion erfolgt, drücken Sie während des Startvorgangs **F8/F11**, um den Wiederherstellungsmodus aufzurufen\n\nMöchten Sie, dass ich Sie bei einem dieser Schritte im Detail anleite?"
  },
  {
    "instruction": "Sie sind ein Kundendienstmitarbeiter für ein Technologieunternehmen.",
    "input": "Wie setze ich mein Passwort zurück?",
    "output": "Das Zurücksetzen Ihres Passworts ist ganz einfach! So geht's:\n\n1. Gehen Sie zur Anmeldeseite und klicken Sie auf **'Passwort vergessen'**\n2. Geben Sie Ihre **registrierte E-Mail-Adresse** ein\n3. Prüfen Sie Ihre E-Mails auf einen Link zum Zurücksetzen (sehen Sie auch im Spam-Ordner nach)\n4. Klicken Sie auf den Link und **erstellen Sie ein neues Passwort**\n\nDer Zurücksetzungslink läuft in 24 Stunden ab. Wenn Sie die E-Mail nicht innerhalb von 5 Minuten erhalten, wenden Sie sich an unser Support-Team."
  }
]
EOF

# Datensatz in dataset_info.json registrieren
docker exec -it llamafactory bash -c "
cat >> /app/LLaMA-Factory/data/dataset_info.json << 'EOF2'
,
\"my_dataset\": {
  \"file_name\": \"/root/llamafactory/data/my_dataset.json\"
}
EOF2
"

Dann wählen Sie my_dataset im Datensatz-Dropdown des LLaMA Board aus.

Beispiel 4: DPO (Direct Preference Optimization)

### configs/dpo_llama.yaml

model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct

### Methode - DPO
stage: dpo
do_train: true
finetuning_type: lora
lora_rank: 8

### DPO-spezifisch
pref_beta: 0.1
pref_loss: sigmoid  # sigmoid, hinge, ipo

### Datensatz (muss im Präferenzformat vorliegen)
dataset: dpo_en_demo
template: llama3
cutoff_len: 2048

### Ausgabe
output_dir: saves/llama3-dpo
logging_steps: 10
save_steps: 100

### Train
per_device_train_batch_size: 1
gradient_accumulation_steps: 8
learning_rate: 5e-5
num_train_epochs: 1.0
fp16: true

docker exec -it llamafactory bash -c "llamafactory-cli train /configs/dpo_llama.yaml"

Beispiel 5: Inferenz mit dem fein abgestimmten Modell

Testen Sie nach dem Training Ihr Modell:

docker exec -it llamafactory bash

# Interaktiver Chat
llamafactory-cli chat \\
  --model_name_or_path mistralai/Mistral-7B-Instruct-v0.3 \\
  --adapter_name_or_path /app/LLaMA-Factory/saves/mistral-qlora \\
  --template mistral \\
  --finetuning_type lora

Oder exportieren Sie das zusammengeführte Modell:

llamafactory-cli export \\
  --model_name_or_path mistralai/Mistral-7B-Instruct-v0.3 \\
  --adapter_name_or_path /app/LLaMA-Factory/saves/mistral-qlora \\
  --template mistral \\
  --finetuning_type lora \\
  --export_dir /app/LLaMA-Factory/output/mistral-merged \\
  --export_size 4 \\
  --export_legacy_format false

---

Konfiguration

Wichtige Trainingsparameter

Parameter	Typischer Wert	Beschreibung
lora_rank	8–64	LoRA-Rang (höher = ausdrucksstärker)
lora_alpha	2× Rang	LoRA-Alpha-Skalierung
lora_dropout	0.0–0.1	Dropout für LoRA-Schichten
lora_target	all	Auf welche Schichten LoRA angewendet wird
learning_rate	1e-4	Start-Lernrate
num_train_epochs	1–5	Trainingsepochen
per_device_train_batch_size	1–4	Batchgröße pro GPU
gradient_accumulation_steps	4–16	Effektiver Batch-Multiplikator
cutoff_len	1024–4096	Maximale Sequenzlänge
quantization_bit	4 oder 8	QLoRA-Quantisierungsbits
warmup_ratio	0.05–0.1	Anteil des LR-Warmups
lr_scheduler_type	cosine	LR-Zeitplan

Unterstützte Fine-Tuning-Methoden

Methode	Speicherverbrauch	Qualität	Wann verwenden
voll	Sehr hoch	Am besten	Unbegrenzter VRAM
freeze	Mittel	Gut	Basis-Schichten einfrieren
lora	Niedrig	Sehr gut	Standardauswahl
qlora (lora+quant)	Niedrigste	Gut	Begrenzter VRAM

Multi-GPU-DeepSpeed-Training

Für das Training auf mehreren GPUs starten Sie mit torchrun:

docker exec -it llamafactory bash -c "
FORCE_TORCHRUN=1 NNODES=1 RANK=0 MASTER_ADDR=127.0.0.1 MASTER_PORT=29500 \\
llamafactory-cli train configs/qlora_mistral.yaml \\
  --deepspeed examples/deepspeed/ds_z3_config.json
"

---

Leistungstipps

1. Optimale QLoRA-Einstellungen nach GPU

8 GB VRAM (RTX 3070):

quantization_bit: 4
per_device_train_batch_size: 1
gradient_accumulation_steps: 8
cutoff_len: 1024

24 GB VRAM (RTX 3090/4090):

quantization_bit: 4  # Verwenden Sie für eine größere Batchgröße weiterhin QLoRA
per_device_train_batch_size: 4
gradient_accumulation_steps: 4
cutoff_len: 2048

80 GB VRAM (A100):

# Keine Quantisierung nötig — LoRA direkt verwenden
finetuning_type: lora
per_device_train_batch_size: 8
gradient_accumulation_steps: 2
cutoff_len: 4096
fp16: true

2. Flash Attention 2 für längere Kontexte

flash_attn: fa2  # Erfordert Ampere+-GPU

Damit ist das Training mit 2× längeren Sequenzen bei derselben VRAM-Menge möglich.

3. Gradient Checkpointing

Spart VRAM auf Kosten von etwa 20 % langsamerem Training:

gradient_checkpointing: true

4. Wählen Sie das richtige LoRA-Ziel

lora_target: all  # Alle linearen Schichten (Standard, beste Qualität)
# oder
lora_target: q_proj,v_proj  # Minimal, am schnellsten, geringere Qualität

5. Obere Schichten für schnelle Anpassung einfrieren

finetuning_type: freeze
freeze_trainable_layers: 2   # Nur die obersten 2 Schichten trainieren
freeze_trainable_modules: all

Viel schneller als vollständiges LoRA für die Anpassung an einfache Aufgaben.

6. Mit TensorBoard überwachen

# In einem separaten Terminal
docker exec -it llamafactory bash -c "
tensorboard --logdir /app/LLaMA-Factory/saves --host 0.0.0.0 --port 6006
"

Fügen Sie Port 6006 zu Ihrer CLORE.AI-Bestellung hinzu, um auf TensorBoard zuzugreifen.

---

Fehlerbehebung

Problem: "CUDA out of memory" während des Trainings

1. Batchgröße reduzieren: per_device_train_batch_size: 1

2. Gradient Checkpointing aktivieren: gradient_checkpointing: true

3. Kontextlänge reduzieren: cutoff_len: 512

4. QLoRA (4-Bit) verwenden: quantization_bit: 4

5. LoRA-Rang reduzieren: lora_rank: 4

Problem: Der Trainingsverlust sinkt nicht

• Überprüfen Sie die Lernrate — versuchen Sie 5e-5 oder 2e-4

• Stellen Sie sicher, dass das Datensatzformat zur Vorlage passt

• Erhöhen Sie lora_rank (8→16→32)

• Überprüfen Sie, ob lora_target: all gesetzt ist

Problem: Langsame Trainingsgeschwindigkeit

# GPU-Auslastung im Container prüfen
docker exec -it llamafactory bash -c "watch -n 1 nvidia-smi"

Wenn die GPU zu weniger als 80 % ausgelastet ist:

• Batchgröße erhöhen

• Flash Attention verwenden: flash_attn: fa2

• Entfernen Sie gradient_checkpointing wenn der VRAM es zulässt

Problem: Modell in der Web-UI nicht gefunden

# Vorab in das Cache-Volume herunterladen
docker exec -it llamafactory bash -c "
huggingface-cli download mistralai/Mistral-7B-Instruct-v0.3
"

Dann die Modellliste im LLaMA Board aktualisieren.

Problem: Datensatzformatfehler

Alle Datensatzformate müssen übereinstimmen dataset_info.json Spezifikation:

# Datensatz validieren
docker exec -it llamafactory python3 -c "
import json
with open('/app/LLaMA-Factory/data/my_dataset.json') as f:
    data = json.load(f)
print(f'Datensatz hat {len(data)} Beispiele')
print('Schlüssel des ersten Beispiels:', list(data[0].keys()))
"

Problem: WebUI-Port nicht erreichbar

Stellen Sie sicher, dass LLaMA-Factory den Gradio-Server gestartet hat:

docker logs llamafactory 2>&1 | grep -E "Running on|Error|Traceback"

Fügen Sie --share als Alternative für eine öffentliche Gradio-URL.

---

Links

• GitHub

• Dokumentation

• Docker Hub (hiyouga)

• Unterstützte Modelle

• Datensatzformat

• CLORE.AI-Marktplatz

---

GPU-Empfehlungen für Clore.ai

Multi-GPU-Rigs der 80GB-Klasse sind auf dem Clore.ai-Marktplatz nicht gelistet. Die größten heute gelisteten Systeme sind 4× RTX PRO 6000 Blackwell (je 96 GB, 380 GB gesamt) und 8–11× RTX 5090 (je 32 GB). Kapazitäten für A100 / H200 / B200 werden als Bare Metal auf Anfrage verkauft. Prüfe GPU-Preise & Verfügbarkeit bevor du eine Bereitstellung dimensionierst.

Anwendungsfall	Empfohlene GPU	Geschätzte Kosten bei Clore.ai
Entwicklung/Testen	RTX 3090 (24 GB)	0,07–0,21 $/GPU/Stunde
Fine-Tuning (7B–13B)	RTX 4090 (24 GB)	0,14–0,42 $/GPU/Stunde
Große Modelle (70B+)	A100 80GB	Bare Metal
Multi-GPU-Training	2-4x A100 80GB	Bare Metal

💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf Clore.ai GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.