Wie lange dauert ein QLoRA-Fine-Tuning?

Der Lauf in dieser Anleitung – Llama 3.1 8B, 10.000 Instruktionspaare, 3 Epochen – dauert etwa 95 Minuten auf einer RTX 4090. Kosten zum unterbrechbaren Tarif: rund $0,28.

Verliere ich an Qualität, wenn ich QLoRA statt vollständigem Fine-Tuning verwende?

Bei Anpassungen an Anweisungen oder Stil meist ein Punkt oder weniger bei den Task-Metriken – das belegen die Forschungslinie seit dem LoRA-Paper und jahrelange Ergebnisse der Community. Große Domänenverschiebungen (neue Sprache, Code-Dialekte) sind die Fälle, in denen vollständiges Fine-Tuning seine 10-fachen Kosten noch rechtfertigt.

Kann ich fine-tunen und meine Daten dabei privat halten?

Ihr Datensatz liegt auf Ihrer Instanz und Ihrem Datenträger, wird gelöscht, sobald Sie beide löschen, und bezahlt wird in Krypto, ohne KYC. Nichts am Lauf wird geteilt – die Sicherheitsseite erklärt das Isolationsmodell.

Llama 3.1 8B mit QLoRA auf einer einzelnen GPU fine-tunen

TL;DR

Ein QLoRA-Fine-Tuning von Llama 3.1 8B auf 10.000 Instruktionspaaren, drei Epochen, dauert auf einer RTX 4090 etwa 95 Minuten.
Die Kosten auf LowCostGPU liegen bei etwa 1,6 Stunden zum unterbrechbaren Satz von $0,177 pro Stunde, zuzüglich eines 20-GB-Datenträgers.
24 GB reichen aus: Die 4-Bit-8B-Basis benötigt etwa 5,5 GB, und der VRAM-Spitzenwert liegt bei Batch 4, Sequenz 2048, nahe 14 GB.
Wichtige Konfiguration: lora_r 32, alpha 64, alle linearen Layer, Gradient Checkpointing und save_steps 100, damit eine Unterbrechung einen Wiederanlauf kostet.

Setup: eine Instanz, ein Datenträger

Alles Dauerhafte kommt auf einen Datenträger; die GPU-Instanz bleibt ephemer:

Infrastruktur, 2 Befehle

lowcostgpu volume create --name ft --size 20 --region eu-west-1
lowcostgpu launch --gpu rtx-4090 --type interruptible \
  --template axolotl --volume ft:/ft --disk 40
# ✓ i-c41b9a02 running · $0,177/hr

Warum unterbrechbar: axolotl schreibt Checkpoints nach /ft, sodass eine Unterbrechung nur einen Neustart kostet, nicht den ganzen Lauf. Warum 24 GB genug sind: QLoRA hält das 8B-Basismodell in 4-Bit (~5,5 GB) + Adapter + Optimizer (~3 GB) + Aktivierungen – Spitzenwert nahe 14 GB bei Batch 4, Sequenzlänge 2048. Eine RTX 3090 bei $0,074/Std. schafft das ebenfalls, ~35 % langsamer.

Das Datensatzformat

data.jsonl

// /ft/data.jsonl — one instruction pair per line
{"instruction": "Summarize this ticket for an engineer.",
 "input": "Customer reports…",
 "output": "P1 — checkout API 500s when…"}

Auf dieser Skala schlägt Qualität Menge deutlich: 2.000 saubere, konsistente Paare übertreffen 50.000 gescrapte. Deduplizieren Sie, entfernen Sie Formatierungsrauschen und halten Sie die Ausgaben exakt in der gewünschten Stimme.

Die axolotl-Konfiguration, kommentiert

qlora.yml – die gesamte Konfiguration

# /ft/qlora.yml
base_model: meta-llama/Llama-3.1-8B-Instruct
load_in_4bit: true            # the Q in QLoRA
adapter: qlora
lora_r: 32                    # capacity of the adapter; 16-64 is the sane band
lora_alpha: 64                # 2x r is the boring, correct default
lora_target_linear: true      # all linear layers — better than picking modules

datasets:
  - path: /ft/data.jsonl
    type: alpaca
val_set_size: 0.05

sequence_len: 2048
micro_batch_size: 4
gradient_accumulation_steps: 4   # effective batch 16
num_epochs: 3
learning_rate: 2e-4
lr_scheduler: cosine
warmup_ratio: 0.03

gradient_checkpointing: true  # ~30% VRAM back for ~20% speed
flash_attention: true
bf16: true

output_dir: /ft/out
save_steps: 100               # ← interruption insurance
logging_steps: 10

Starten und beobachten

the run

axolotl train /ft/qlora.yml
# step 10/561 · loss 1.842 · 14.1 GB VRAM · 3.4 it/s
# …
# step 561/561 · loss 0.914 · eval_loss 0.987 · 94 min

Lesen Sie die Kurven so: Der Trainingsverlust sollte schnell fallen und sich dann abflachen; folgt der Validierungsverlust ihm nach unten, bedeutet das Lernen, steigt er dagegen, während der Trainingsverlust weiter fällt, bedeutet das Auswendiglernen – stoppen Sie am Punkt der Divergenz (oder erhöhen Sie val_set_size und verringern Sie die Epochenzahl). Bei einem ersten Lauf führen 3 Epochen auf 10.000 Paaren so gut wie nie zu Overfitting bei einem 8B-Modell.

Merge, Test, Serving

von Adaptern zum Endpunkt

# merge adapters into standalone weights (on /ft, survives the instance)
axolotl merge-lora /ft/qlora.yml --lora-model-dir /ft/out

# smoke-test locally
python -m vllm.entrypoints.openai.api_server \
  --model /ft/out/merged --max-model-len 4096 &
curl localhost:8000/v1/chat/completions -d '{…}'

# then destroy the trainer and serve properly
lowcostgpu destroy i-c41b9a02 --yes
lowcostgpu launch --gpu rtx-5090 --template vllm \
  --volume ft:/ft:ro --env MODEL=/ft/out/merged

Die Wahl der Karte fürs Serving folgt einer anderen Logik als das Training – die vLLM-Anleitung zeigt, wie es richtig geht.

Die Endabrechnung

GPU, ~96 Min. unterbrechbar	$0,28
Datenträger 20 GB, 2 Tage	$0,107
Gesamt	≈ $0,39

Ein 8B-Modell mit angepasstem Verhalten für den Preis eines Sandwiches. Das gleiche Rezept skaliert: 14B auf derselben Karte, ~34B auf einer 32-GB-Karte, 70B über Nacht auf einer 80-GB-Karte – die VRAM-Anleitung nennt die Obergrenzen.

Zahlen nutzen

Jeder Preis in dieser Anleitung ist unser Live-Preis – festgelegt, ≥30 % unter dem Marktmedian, sekundengenau abgerechnet. Stellen Sie das exakte Setup oben über die Konsole in etwa 30 Sekunden bereit, bezahlt in Krypto, ohne Karte und ohne KYC.