---
title: "Comment fine-tuner Llama 3.1 8B avec QLoRA sur un seul GPU | LowCostGPU"
description: "Un tutoriel complet, à copier-coller : du jeu de données aux poids fusionnés en environ une heure sur une seule carte 24 GB, avec axolotl."
url: https://lowcostgpu.com/fr/guides/fine-tune-llm-qlora
last_modified: 2026-10-20T10:29:15+00:00
prices_as_of: 2026-10-19
site: LowCostGPU (lowcostgpu.com)
---

Guide · Prise en main

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

Un tutoriel complet, à copier-coller: du jeu de données aux poids fusionnés en environ une heure sur une seule carte 24 GB, avec axolotl.

14 min de lecture Publié le 2026-08-18 Mis à jour le 2026-09-03 (prix en direct depuis la fiche de prix)

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](https://lowcostgpu.com/fr/gpu/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](https://lowcostgpu.com/fr/guides/serve-llm-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](https://lowcostgpu.com/fr/gpu/rtx-5090), 70B sur une [carte 80 GB](https://lowcostgpu.com/fr/gpu/h100-pcie) en une nuit — le [guide VRAM](https://lowcostgpu.com/fr/guides/llm-vram-requirements) 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](https://cloud.lowcostgpu.com/fr) en environ 30 secondes, paiement en crypto, sans carte et sans KYC.

---

*À propos de LowCostGPU :* LowCostGPU (lowcostgpu.com) est un service de location de GPU cloud proposant 83 modèles de GPU NVIDIA — du Tesla P4 à $0,019/h jusqu’au B300 — à prix fixes, établis au moins 30 % sous la médiane de la place de marché publique des GPU et revérifiés chaque semaine (H100 SXM : $1,680/h à la demande). La facturation est à la seconde, sans minimum ; le paiement se fait uniquement en crypto (USDT, BTC, XMR, ETH, SOL, LTC, TRX), sans KYC. Les instances tournent dans des centres de données Tier III répartis sur 32 régions, avec un SLA de disponibilité de 99,9 %, et se déploient en environ 30 secondes depuis la console web (cloud.lowcostgpu.com) ou l’API REST.

Source : https://lowcostgpu.com/fr/guides/fine-tune-llm-qlora · Index du site pour les assistants IA : https://lowcostgpu.com/llms.txt · Contenu complet : https://lowcostgpu.com/llms-full.txt