Vergleich von Fine-Tuning-Tools

Wählen Sie das richtige Fine-Tuning-Framework für das Training von LLMs auf Clore.ai-GPU-Servern.

Feinabstimmung passt ein vortrainiertes LLM an Ihre spezifische Aufgabe oder Domäne an. Dieser Leitfaden vergleicht die vier führenden Open-Source-Tools: Unsloth, Axolotl, LLaMA-Factory und TRL — und behandelt Geschwindigkeit, Speichereffizienz, unterstützte Modelle und Benutzerfreundlichkeit.

---

Schnelle Entscheidungsübersicht

	Unsloth	Axolotl	LLaMA-Factory	TRL
Am besten für	Geschwindigkeit + Speicher	Konfigurationsgesteuertes Training	Anfängerfreundlich	Forschung + RLHF
Geschwindigkeit vs. Baseline	2–5× schneller	~1× (Standard)	~1× (Standard)	~1× (Standard)
Speicherreduzierung	70–80 % weniger	QLoRA-Standard	QLoRA-Standard	Standard
RLHF/DPO/PPO	Einfach	✅	✅	✅ (nativ)
WebUI	❌	❌	✅	❌
GitHub-Stars	23K+	9K+	37K+	10K+
Lizenz	LGPL (kostenlos für nicht-kommerzielle Nutzung)	Apache 2.0	Apache 2.0	Apache 2.0

---

Überblick

Unsloth

Unsloth konzentriert sich laserfokussiert auf eines: Fine-Tuning so schnell und speichereffizient wie möglich zu machen. Es schreibt zentrale Operationen in Triton neu und optimiert CUDA-Kerne.

Philosophie: Maximale Geschwindigkeit, minimale VRAM-Nutzung — keine Kompromisse.

from unsloth import FastLanguageModel
import torch

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Llama-3.2-8B-Instruct",
    max_seq_length=2048,
    load_in_4bit=True,  # 4-Bit-Quantisierung
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,              # LoRA-Rang
    target_modules=["q_proj", "k_proj", "v_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",  # ~30 % größere Batchgröße
    random_state=42,
)

Axolotl

Axolotl verpackt Hugging Face Transformers mit einem YAML-basierten Konfigurationssystem. Es übernimmt die Komplexität des Trainings-Setups, damit Sie sich auf Daten und Hyperparameter konzentrieren können.

Philosophie: Alles in YAML, darunter volle Flexibilität.

# config.yml
base_model: meta-llama/Meta-Llama-3-8B
model_type: LlamaForCausalLM
tokenizer_type: AutoTokenizer

datasets:
  - path: mhenrichsen/alpaca_data_cleaned
    type: alpaca

load_in_4bit: true
adapter: qlora

lora_r: 32
lora_alpha: 16
lora_target_modules:
  - q_proj
  - k_proj
  - v_proj
  - o_proj

num_epochs: 3
micro_batch_size: 2
gradient_accumulation_steps: 4
learning_rate: 2e-4

LLaMA-Factory

LLaMA-Factory unterstützt die größte Bandbreite an Modellen (100+) und Trainingsmethoden, mit einer WebUI zur Konfiguration. Es ist die zugänglichste Option für Nicht-Forschende.

Philosophie: Alles funktioniert, für alle.

# Training über die Kommandozeile
llamafactory-cli train \
  --model_name_or_path meta-llama/Meta-Llama-3-8B \
  --stage sft \
  --do_train \
  --dataset alpaca_gpt4_en \
  --template llama3 \
  --finetuning_type lora \\
  --lora_rank 8 \
  --output_dir saves/llama3-8b-lora \
  --num_train_epochs 3.0 \
  --per_device_train_batch_size 2

# Oder WebUI verwenden
llamafactory-cli webui

TRL (Transformer Reinforcement Learning)

TRL ist Hugging Faces offizielle RLHF-Bibliothek. Sie ist der Standard für PPO, DPO, ORPO und andere Alignment-Trainingsmethoden.

Philosophie: Forschungsorientiert, Alignment-Training nativ.

from trl import SFTTrainer, SFTConfig
from transformers import AutoModelForCausalLM, AutoTokenizer
from datasets import load_dataset

model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-8B")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B")

training_args = SFTConfig(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    logging_steps=10,
)

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    args=training_args,
    train_dataset=load_dataset("tatsu-lab/alpaca", split="train"),
)

trainer.train()

---

Geschwindigkeits-Benchmarks

Trainingsgeschwindigkeitsvergleich (Token/Sekunde)

Testaufbau: LLaMA 3.1 8B, LoRA r=16, 4-Bit-Quantisierung, Batchgröße 4, A100 80 GB

Werkzeug	Tokens/Sek.	vs. Baseline	Speicher (VRAM)
Unsloth (4-Bit)	~4,200	2,8×	~8 GB
Axolotl (QLoRA)	~1,500	1,0×	~16GB
LLaMA-Factory (QLoRA)	~1,480	~1,0×	~16GB
TRL (QLoRA)	~1,450	~0,97×	~18 GB
Unsloth (vollständiges 16-Bit)	~2,800	1,9×	~22GB

Der Vorteil von Unsloth ist real: Die 2–5×-Geschwindigkeit kommt von benutzerdefinierten Triton-Kernels für Attention, Cross-Entropy, RoPE und LoRA. Nicht nur Marketing.

Vergleich der VRAM-Nutzung

Training von LLaMA 3.1 8B, Sequenzlänge 2048:

Methode	Unsloth	Axolotl	LLaMA-Factory	TRL
Vollständiges Fine-Tuning (bf16)	60 GB	70GB	72GB	74 GB
LoRA (bf16)	18 GB	24 GB	25 GB	26GB
QLoRA (4-Bit)	8 GB	16 GB	16 GB	18 GB
QLoRA (4-Bit, langer Kontext)	12 GB	24 GB	24 GB	26GB

Minimale GPU für 8B-Modell:

• Unsloth: RTX 3080 (10 GB) ✅

• Andere: RTX 3090 (24 GB) erforderlich

---

Unterstützte Modelle

Modell-Unterstützungsmatrix

Modellfamilie	Unsloth	Axolotl	LLaMA-Factory	TRL
LLaMA 3.x	✅	✅	✅	✅
LLaMA 2	✅	✅	✅	✅
Mistral	✅	✅	✅	✅
Mixtral MoE	✅	✅	✅	✅
Gemma 2	✅	✅	✅	✅
Phi-3/3.5	✅	✅	✅	✅
Qwen 2.5	✅	✅	✅	✅
DeepSeek	✅	✅	✅	✅
Falcon	✅	✅	✅	✅
GPT-NeoX	Teilweise	✅	✅	✅
T5/FLAN	❌	✅	✅	✅
BERT/RoBERTa	❌	✅	✅	✅
Vision-LLMs	Teilweise	Teilweise	✅	✅

Unterstützung für Trainingsmethoden

Methode	Unsloth	Axolotl	LLaMA-Factory	TRL
Vollständige Feinabstimmung	✅	✅	✅	✅
LoRA	✅	✅	✅	✅
QLoRA	✅	✅	✅	✅
DoRA	✅	✅	✅	❌
PEFT	✅	✅	✅	✅
SFT	✅	✅	✅	✅ (nativ)
DPO	✅	✅	✅	✅ (nativ)
PPO	❌	✅	✅	✅ (nativ)
ORPO	✅	✅	✅	✅
KTO	❌	✅	✅	✅ (nativ)
GRPO	✅	❌	✅	✅
CPT (fortgesetztes Pretraining)	✅	✅	✅	✅

---

Unsloth: Tiefer Einblick

Was es schnell macht

1. Triton-Kerne: Schreibt Flash Attention, Cross-Entropy-Loss und LoRA in Triton neu

2. Verschmolzene Operationen: Kombiniert mehrere CUDA-Operationen zu einem Kernel

3. Intelligentes Gradient Checkpointing: Der Modus "unsloth" spart ~30 % mehr Speicher

4. Effiziente Backprop: Vermeidet das Materialisieren großer Zwischen-Tensoren

Installation auf Clore.ai

# CUDA 12.8
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes

# Oder mit conda
conda create --name unsloth_env python=3.11
conda activate unsloth_env
conda install pytorch-cuda=12.1 pytorch cudatoolkit xformers -c pytorch -c nvidia -c xformers -y
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes

Vollständiges Trainingsskript

from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import load_dataset
import torch

# 1. Modell mit Unsloth-Optimierung laden
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Meta-Llama-3.1-8B-Instruct",
    max_seq_length=2048,
    dtype=None,        # Automatisch erkennen
    load_in_4bit=True,
)

# 2. LoRA-Adapter hinzufügen
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",
    random_state=3407,
)

# 3. Datensatz laden und formatieren
dataset = load_dataset("tatsu-lab/alpaca", split="train")

def format_prompt(example):
    return {"text": f"### Anweisung:\n{example['instruction']}\n\n### Antwort:\n{example['output']}"}

dataset = dataset.map(format_prompt)

# 4. Trainieren
trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=5,
        num_train_epochs=1,
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=1,
        optim="adamw_8bit",
        weight_decay=0.01,
        lr_scheduler_type="linear",
        seed=3407,
        output_dir="outputs",
    ),
)
trainer.train()

# 5. Speichern
model.save_pretrained("lora_model")
model.save_pretrained_gguf("model_gguf", tokenizer, quantization_method="q4_k_m")

Schwächen: Kein PPO, beschränkt auf unterstützte Modellliste, LGPL-Lizenz (für kommerzielle Nutzung prüfen)

---

Axolotl: Tiefer Einblick

Konfigurations-First-Ansatz

Axolotl glänzt, wenn Sie reproduzierbare, versionskontrollierte Trainingskonfigurationen wünschen:

# axolotl_config.yml — vollständiges Beispiel
base_model: meta-llama/Meta-Llama-3-8B-Instruct
model_type: LlamaForCausalLM
tokenizer_type: AutoTokenizer

# Daten
datasets:
  - path: tatsu-lab/alpaca
    type: alpaca
  - path: ./my_custom_data.jsonl
    type: sharegpt
dataset_prepared_path: ./prepared_data
val_set_size: 0.01

# Quantisierung
load_in_4bit: true
adapter: qlora
bf16: true
tf32: true

# LoRA
lora_r: 32
lora_alpha: 16
lora_dropout: 0.05
lora_target_modules:
  - q_proj
  - v_proj
  - k_proj
  - o_proj
  - gate_proj
  - up_proj
  - down_proj

# Training
sequence_len: 4096
sample_packing: true  # Packt kurze Sequenzen zur Effizienz
pad_to_sequence_len: true
micro_batch_size: 2
gradient_accumulation_steps: 4
num_epochs: 3
learning_rate: 0.0002
optimizer: adamw_bnb_8bit
lr_scheduler: cosine

# Protokollierung
logging_steps: 10
eval_steps: 100
save_steps: 100
output_dir: ./outputs/my-model

# wandb
wandb_project: my-fine-tune
wandb_run_id: run-001

# Installieren und ausführen
pip install axolotl[flash-attn,deepspeed]
axolotl train axolotl_config.yml

Am besten für: Teams, die reproduzierbare, konfigurationsversionierte Trainingsläufe wollen

---

LLaMA-Factory: Tiefer Einblick

WebUI-Rundgang

# Installieren
pip install llamafactory

# WebUI starten
llamafactory-cli webui
# http://localhost:7860 öffnen

WebUI-Tabs:

1. Train — Basis-Modell, Datensatz, Methode konfigurieren

2. Auswerten — MMLU-, CMMLU-Benchmarks ausführen

3. Chat — interaktive Inferenz

4. Exportieren — LoRA zusammenführen, zu GGUF quantisieren

CLI-Trainingsbeispiel

# Überwachtes Fine-Tuning
llamafactory-cli train \
  --stage sft \
  --model_name_or_path meta-llama/Meta-Llama-3-8B \
  --dataset alpaca_gpt4_en,glaive_toolcall_en \
  --template llama3 \
  --finetuning_type lora \\
  --lora_rank 8 \
  --lora_alpha 16 \
  --lora_target all \
  --output_dir saves/llama3-lora \
  --num_train_epochs 3 \
  --per_device_train_batch_size 2 \
  --gradient_accumulation_steps 4 \
  --learning_rate 2e-4 \
  --quantization_bit 4 \
  --flash_attn fa2

# DPO-Training
llamafactory-cli train \
  --stage dpo \
  --model_name_or_path meta-llama/Meta-Llama-3-8B \
  --dataset dpo_mix_en \
  --template llama3 \
  --finetuning_type lora \\
  --output_dir saves/llama3-dpo

Am besten für: Anfänger, Teams, die WebUI wollen, DPO/RLHF ohne tiefes Forschungswissen

---

TRL: Tiefer Einblick

Beispiel einer RLHF-Pipeline

TRL ist die erste Wahl für Alignment-Training:

from trl import PPOTrainer, PPOConfig, AutoModelForCausalLMWithValueHead
from trl import DPOTrainer, DPOConfig
from datasets import load_dataset

# DPO (Direct Preference Optimization) — die gebräuchlichste Alignment-Methode
model_name = "meta-llama/Meta-Llama-3-8B-Instruct"

dpo_config = DPOConfig(
    model_name_or_path=model_name,
    output_dir="dpo_outputs",
    num_train_epochs=1,
    per_device_train_batch_size=2,
    beta=0.1,             # KL-Strafkoeffizient
    loss_type="sigmoid",  # oder "hinge", "ipo", "kto_pair"
    learning_rate=5e-7,
)

# Präferenzdatensatz laden (Prompt + ausgewählt + abgelehnt)
dataset = load_dataset("Anthropic/hh-rlhf", split="train")

trainer = DPOTrainer(
    model=model_name,
    args=dpo_config,
    train_dataset=dataset,
)
trainer.train()

Am besten für: Implementierungen für Alignment-Forschung, RLHF, DPO, PPO, ORPO

---

Das richtige Tool wählen

Entscheidungsfluss

Benötigen Sie maximale Geschwindigkeit/minimales VRAM?
  → JA → Unsloth (2–5× schneller, passt auf kleinere GPUs)

Benötigen Sie Alignment-Training (DPO/PPO/RLHF)?
  → JA → TRL oder LLaMA-Factory
  → Forschung/angepasst → TRL
  → Produktion/einfach → LLaMA-Factory

Benötigen Sie Konfigurationszuerst-Reproduzierbarkeit?
  → JA → Axolotl

Nicht-technisches Team oder WebUI gewünscht?
  → JA → LLaMA-Factory

Sie möchten einfach schnell anfangen?
  → LLaMA-Factory oder Unsloth

Nach Teamtyp

Team	Empfehlung	Grund
Einzelner Forscher	Unsloth	Geschwindigkeit + Jupyter-Notebooks
ML-Ingenieur	Axolotl	Konfigurationsgetrieben, reproduzierbar
Produktteam	LLaMA-Factory	WebUI, breite Modellunterstützung
Alignment-Team	TRL	Native RLHF-Primitiven
Startup	Unsloth + TRL	Geschwindigkeit + Alignment, wenn nötig

---

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.

Aufgabe	Min. GPU	Empfohlen	Werkzeug
7–8B LoRA (QLoRA)	RTX 3080 (10 GB)	RTX 3090	Unsloth
13B LoRA	RTX 3090 (24 GB)	A6000 (48 GB)	Unsloth/Axolotl
70B LoRA	A100 (80 GB)	2×A100	Axolotl/TRL
8B vollständiges FT	A100 (40 GB)	A100 (80 GB)	Beliebig
DPO/PPO 7B	RTX 4090 (24 GB)	A6000 (48 GB)	TRL

---

Nützliche Links

• Unsloth GitHub — 23K+ Sterne

• Axolotl GitHub — 9K+ Sterne

• LLaMA-Factory GitHub — 37K+ Sterne

• TRL GitHub — 10K+ Sterne

• Hugging Face PEFT-Dokumentation

---

Zusammenfassung

Werkzeug	Am besten für	Wichtigster Vorteil
Unsloth	Geschwindigkeitskritisches Training, kleine GPUs	2–5× schneller, 70 % weniger VRAM
Axolotl	Konfigurationsgesteuerte, reproduzierbare Läufe	YAML-zuerst, viele Datenformate
LLaMA-Factory	100+ Modelle, WebUI, Anfänger	Meiste Modellunterstützung, GUI
TRL	RLHF, DPO, Alignment-Forschung	Native Alignment-Trainings

Für die meisten Clore.ai-Anwendungsfälle: beginnen Sie mit Unsloth (Geschwindigkeit + Speichereffizienz), fügen Sie TRL hinzu, wenn Sie DPO- oder PPO-Alignment-Training benötigen.