Combien de temps prend un fine-tune QLoRA ?

Le run de ce guide — Llama 3.1 8B, 10 000 paires d’instructions, 3 epochs — prend environ 95 minutes sur une RTX 4090. Coût au tarif interruptible : environ $0,28.

Est-ce que je perds en qualité en utilisant QLoRA plutôt qu’un fine-tune complet ?

Pour une adaptation d’instruction ou de style, généralement un point ou moins sur les métriques de tâche — la lignée des articles LoRA et des années de résultats communautaires le confirment. Les grands changements de domaine (nouvelle langue, dialectes de code) restent le terrain où le fine-tune complet justifie encore son coût 10×.

Puis-je faire un fine-tune en gardant mes données privées ?

Votre jeu de données vit sur votre instance et votre volume, il est supprimé quand vous les supprimez, et le paiement se fait en crypto, sans KYC. Aucun élément de votre run n’est partagé — consultez la page de sécurité pour le modèle d’isolation.

Comment fine-tuner Llama 3.1 8B avec QLoRA sur un seul GPU

TL;DR

Un fine-tune QLoRA de Llama 3.1 8B sur 10 000 paires d’instructions, trois epochs, prend environ 95 minutes sur une RTX 4090.
Le coût sur LowCostGPU est d’environ 1,6 heure au tarif interruptible de $0,177 par heure, plus un volume de 20 GB.
24 GB suffisent : le modèle de base 8B en 4 bits prend environ 5,5 GB, et la VRAM de pointe avoisine 14 GB à un batch de 4, séquence de 2048.
Configuration clé : lora_r 32, alpha 64, toutes les couches linéaires, gradient checkpointing, et save_steps 100, pour qu’une interruption ne coûte qu’une reprise.

Configuration : une instance, un volume

Tout ce qui est durable va sur un volume ; l’instance GPU reste jetable :

infrastructure, 2 commandes

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

Pourquoi interruptible : axolotl écrit ses checkpoints dans /ft, donc une interruption coûte une reprise, pas le run. Pourquoi 24 GB suffisent : QLoRA garde la base 8B en 4-bit (~5,5 GB) + adaptateurs + optimiseur (~3 GB) + activations — pic autour de 14 GB en batch 4, séquence 2048. Une RTX 3090 à $0,074/h fait aussi l’affaire, ~35 % plus lente.

Le format du jeu de données

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…"}

À cette échelle, la qualité l’emporte nettement sur le volume : 2 000 paires propres et cohérentes surpassent 50k paires récupérées en vrac. Dédupliquez, retirez le bruit de mise en forme, gardez des sorties qui restent exactement dans la voix que vous voulez retrouver.

La configuration axolotl, annotée

qlora.yml — la configuration complète

# /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

Lancer et observer

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

Lisez les courbes ainsi : la loss d’entraînement doit chuter vite puis s’aplatir ; la loss d’évaluation qui suit la baisse signifie un apprentissage, la loss d’évaluation qui remonte alors que la loss d’entraînement baisse signifie une mémorisation — arrêtez à la divergence (ou augmentez val_set_size et réduisez les epochs). Pour un premier essai, 3 epochs sur 10 000 paires ne provoquent presque jamais de surapprentissage sur un 8B.

Fusionner, tester, servir

des adaptateurs à l’endpoint

# 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

Le choix de carte pour le serving est une optimisation différente de celle de l’entraînement — le guide vLLM la choisit correctement.

La facture finale

GPU, ~96 min, interruptible	$0,28
Volume 20 GB, 2 jours	$0,107
Total	≈ $0,39

Un 8B à comportement personnalisé pour le prix d’un sandwich. La même recette passe à l’échelle : 14B sur la même carte, ~34B sur une carte 32 GB, 70B sur une carte 80 GB en une nuit — le guide VRAM donne les plafonds.

Faites travailler ces chiffres

Chaque prix de ce guide est notre tarif en direct — fixe, ≥30 % sous la médiane du marché, facturé à la seconde. Déployez exactement la configuration ci-dessus depuis la console en environ 30 secondes, paiement en crypto, sans carte et sans KYC.