Vergleich von Fine‑Tuning‑Tools

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

Fine-Tuning 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 Bedienkomfort.

Schnelle Entscheidungsübersicht

Unsloth

Axolotl

LLaMA-Factory

TRL

Am besten für

Geschwindigkeit + Speicher

Konfigurationsgesteuertes Training

Einsteigerfreundlich

Forschung + RLHF

Geschwindigkeit vs. Basislinie

2–5× schneller

~1× (Standard)

Speicherreduzierung

70–80% weniger

QLoRA-Standard

Standard

RLHF/DPO/PPO

Grundlegend

✅

✅ (nativ)

WebUI

❌

✅

❌

GitHub-Sterne

23K+

9K+

37K+

10K+

Lizenz

LGPL (kostenlos für nicht-kommerzielle Nutzung)

Apache 2.0

Übersicht

Unsloth

Unsloth konzentriert sich laserartig auf eine Sache: Fine-Tuning so schnell und speichereffizient wie möglich zu machen. Es schreibt Schlüsseloperationen in Triton neu und optimiert CUDA-Kerne.

Philosophie: Maximale Geschwindigkeit, minimaler VRAM — 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% mehr Batch-Größe
    random_state=42,
)

Axolotl

Axolotl wickelt HuggingFace Transformers mit einem YAML-basierten Konfigurationssystem ein. Es übernimmt die Komplexität der Trainingseinrichtung, sodass Sie sich auf Daten und Hyperparameter konzentrieren können.

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

# 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 und bietet eine Web-UI für die Konfiguration. Es ist die zugänglichste Option für Nicht-Forscher.

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 HuggingFaces offizielle RLHF-Bibliothek. Sie ist der Standard für PPO, DPO, ORPO und andere Alignment-Trainingsmethoden.

Philosophie: Forschung zuerst, 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()

Geschwindigkeitsbenchmarks

Vergleich der Trainingsgeschwindigkeit (Tokens/Sekunde)

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

Tool

Tokens/Sek

vs. Basislinie

Speicher (VRAM)

Unsloth (4-Bit)

~4,200

2,8×

~8GB

Axolotl (QLoRA)

~1,500

1,0×

~16GB

LLaMA-Factory (QLoRA)

~1,480

~1,0×

~16GB

TRL (QLoRA)

~1,450

~0,97×

~18GB

Unsloth (vollständig 16-Bit)

~2,800

1,9×

~22GB

Unsloth-Vorteil ist real: 2–5× Geschwindigkeit ergibt sich aus kundenspezifischen Triton-Kernen für Attention, Kreuzentropie, RoPE und LoRA. Nicht nur Marketing.

VRAM-Nutzungsvergleich

Training LLaMA 3.1 8B, Sequenzlänge 2048:

Methode

Unsloth

Axolotl

LLaMA-Factory

TRL

Vollständiges Fine-Tune (bf16)

60GB

70GB

72GB

74GB

LoRA (bf16)

18GB

24GB

25GB

26GB

QLoRA (4-bit)

8GB

16GB

18GB

QLoRA (4-Bit, langer Kontext)

12GB

24GB

26GB

Minimaler GPU für 8B-Modell:

Unsloth: RTX 3080 (10GB) ✅
Andere: RTX 3090 (24GB) erforderlich

Unterstützte Modelle

Modellunterstützungs-Matrix

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

✅

Unterstützte Trainingsmethoden

Methode

Unsloth

Axolotl

LLaMA-Factory

TRL

Vollständiges Fine-Tune

✅

LoRA

✅

QLoRA

✅

DoRA

✅

❌

PEFT

✅

SFT

✅

✅ (nativ)

DPO

✅

✅ (nativ)

PPO

❌

✅

✅ (nativ)

ORPO

✅

KTO

❌

✅

✅ (nativ)

GRPO

✅

❌

✅

CPT (fortgesetztes Pretraining)

✅

Unsloth: Tiefer Einblick

Was es schnell macht

Triton-Kerne: Schreibt Flash Attention, Kreuzentropie-Loss und LoRA in Triton neu
Fusionierte Operationen: Kombiniert mehrere CUDA-Operationen in einem Kernel
Smartes Gradient Checkpointing: Der "unsloth"-Modus spart ~30% mehr Speicher
Effiziente Backpropagation: Vermeidet die Materialisierung großer Zwischen-Tensoren

Installation auf Clore.ai

# CUDA 12.1
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,        # Automatische Erkennung
    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"### Instruction:\n{example['instruction']}\n\n### Response:\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, auf die unterstützte Modellliste beschränkt, LGPL-Lizenz (auf kommerzielle Nutzung prüfen)

Axolotl: Tiefer Einblick

Konfigurations-erste Vorgehensweise

Axolotl glänzt, wenn Sie reproduzierbare, versionskontrollierte Trainingskonfigurationen möchten:

# 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

# Logging
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 wünschen

LLaMA-Factory: Tiefer Einblick

WebUI-Anleitung

# Installieren
pip install llamafactory

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

WebUI-Tabs:

Train — Basis-Modell, Datensatz, Methode konfigurieren
Evaluieren — MMLU-, CMMLU-Benchmarks ausführen
Chat — interaktive Inferenz
Export — LoRA zusammenführen, nach GGUF quantisieren

CLI-Trainingsbeispiel

# Supervised 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 eine WebUI und DPO/RLHF ohne tiefgehendes Forschungsvorwissen wollen

TRL: Tiefer Einblick

RLHF-Pipeline-Beispiel

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 + gewä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: Alignment-Forschung, RLHF, DPO, PPO, ORPO-Implementierungen

Die richtige Werkzeugwahl

Entscheidungsfluss

Brauchen Sie maximale Geschwindigkeit/minimalen VRAM?
  → JA → Unsloth (2–5× schneller, passt auf kleinere GPUs)

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

Brauchen Sie reproduzierbare, konfigurations-first Workflows?
  → JA → Axolotl

Nicht-technisches Team oder wollen Sie eine WebUI?
  → JA → LLaMA-Factory

Wollen Sie einfach schnell starten?
  → LLaMA-Factory oder Unsloth

Nach Teamtyp

Team

Empfehlung

Grund

Einzelner Forscher

Unsloth

Geschwindigkeit + Jupyter-Notebooks

ML-Ingenieur

Axolotl

Konfigurationsgesteuert, reproduzierbar

Produktteam

LLaMA-Factory

WebUI, breite Modellunterstützung

Alignment-Team

TRL

Native RLHF-Primitiven

Startup

Unsloth + TRL

Geschwindigkeit + Alignment bei Bedarf

Clore.ai GPU-Empfehlungen

Aufgabe

Min. GPU

Nützliche Links

Unsloth GitHub — 23K+ Sterne
Axolotl GitHub — 9K+ Sterne
LLaMA-Factory GitHub — 37K+ Sterne
TRL GitHub — 10K+ Sterne
HuggingFace PEFT-Dokumentation

Zusammenfassung

Tool

Am besten für

Hauptvorteil

Unsloth

Geschwindigkeitskritisches Training, kleine GPUs

2–5× schneller, 70% weniger VRAM

Axolotl

Konfigurationsgesteuerte, reproduzierbare Läufe

YAML-first, viele Datenformate

LLaMA-Factory

100+ Modelle, WebUI, Einsteiger

Größte Modellunterstützung, GUI

TRL

RLHF, DPO, Alignmentsforschung

Natives Alignment-Training

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

VorherigeVergleich von Vektor-Datenbanken NächsteVergleich der Videogenerierung

Zuletzt aktualisiert vor 1 Tag

War das hilfreich?

hashtagSchnelle Entscheidungsübersicht

hashtagÜbersicht

hashtagUnsloth

hashtagAxolotl

hashtagLLaMA-Factory

hashtagTRL (Transformer Reinforcement Learning)

hashtagGeschwindigkeitsbenchmarks

hashtagVergleich der Trainingsgeschwindigkeit (Tokens/Sekunde)

hashtagVRAM-Nutzungsvergleich

hashtagUnterstützte Modelle

hashtagModellunterstützungs-Matrix

hashtagUnterstützte Trainingsmethoden

hashtagUnsloth: Tiefer Einblick

hashtagWas es schnell macht

hashtagInstallation auf Clore.ai

hashtagVollständiges Trainingsskript

hashtagAxolotl: Tiefer Einblick

hashtagKonfigurations-erste Vorgehensweise

hashtagLLaMA-Factory: Tiefer Einblick

hashtagWebUI-Anleitung

hashtagCLI-Trainingsbeispiel

hashtagTRL: Tiefer Einblick

hashtagRLHF-Pipeline-Beispiel

hashtagDie richtige Werkzeugwahl

hashtagEntscheidungsfluss

hashtagNach Teamtyp

hashtagClore.ai GPU-Empfehlungen

hashtagNützliche Links

hashtagZusammenfassung

Schnelle Entscheidungsübersicht

Übersicht

Unsloth

Axolotl

LLaMA-Factory

TRL (Transformer Reinforcement Learning)

Geschwindigkeitsbenchmarks

Vergleich der Trainingsgeschwindigkeit (Tokens/Sekunde)

VRAM-Nutzungsvergleich

Unterstützte Modelle

Modellunterstützungs-Matrix

Unterstützte Trainingsmethoden

Unsloth: Tiefer Einblick

Was es schnell macht

Installation auf Clore.ai

Vollständiges Trainingsskript

Axolotl: Tiefer Einblick

Konfigurations-erste Vorgehensweise

LLaMA-Factory: Tiefer Einblick

WebUI-Anleitung

CLI-Trainingsbeispiel

TRL: Tiefer Einblick

RLHF-Pipeline-Beispiel

Die richtige Werkzeugwahl

Entscheidungsfluss

Nach Teamtyp

Clore.ai GPU-Empfehlungen

Nützliche Links

Zusammenfassung