Pratique guide · 10 min de lecture

# Fine-tuning d’un modèle 70B sur une seule carte.

QLoRA transforme un entraînement qui nécessite une baie en un entraînement qui ne nécessite qu’un seul GPU de 48 GB. Voici ce qui tient, ce que cela coûte pour un mois, et où la technique cesse de fonctionner.

En bref

- **QLoRA sur un 70B:** ~61 GB — tient sur une carte de 48 GB à des longueurs de séquence courtes, confortablement sur une de 80 GB
- **Fine-tuning complet d’un 70B:** ~1,232 GB — un cluster multi-nœuds, que nous ne louons pas
- **Le ratio:** Environ **20×** moins de mémoire, pour une technique qui atteint la majeure partie de la qualité sur la plupart des tâches
- **Ce que cela coûte ici:** À partir de $286/mois, la carte étant à vous pour tout le mois plutôt que pour la durée du run

## Ce qui tient réellement

LoRA gèle le modèle et entraîne une petite paire de matrices de rang faible à côté de chaque matrice de poids. QLoRA va plus loin et conserve les poids gelés en 4 bits. Ce que vous devez garder en mémoire change complètement en conséquence.

Poids gelés 4 bits par paramètre 35 GB pour un modèle 70B. Lus à chaque étape, jamais mis à jour, ils n’ont donc jamais besoin de gradient.

Adaptateurs Environ 1–2 % des paramètres Un gigaoctet ou deux en BF16. Ce sont les seuls poids qui changent, et la seule chose que vous conservez à la fin.

État de l’optimiseur Adam, uniquement sur les adaptateurs Deux moments par paramètre entraîné. C’est le terme qui domine le fine-tuning complet et qui disparaît presque ici.

Activations La part variable Évolue avec la taille de lot et la longueur de séquence. Le gradient checkpointing échange environ 30 % de calcul supplémentaire contre une forte réduction — le levier habituel quand un run ne tient pas.

## Pourquoi ce n’est pas le cas pour le fine-tuning complet

Le fine-tuning complet en BF16 nécessite environ 16 octets par paramètre : 2 pour le poids, 2 pour son gradient, et 8 pour les deux moments d’Adam en FP32, plus la copie maîtresse. C’est un multiplicateur fixe, et c’est brutal.

**Mémoire d’entraînement : QLoRA comparé au fine-tuning complet**

| Modèle | QLoRA | Fine-tuning complet | Ratio | Ce que cela signifie |
|---|---|---|---|---|
| Llama 3.1 8B 8B de paramètres | 13 GB | 141 GB | 11× | Une carte de 24 GB Complet : un nœud à 8 GPU |
| Gemma 3 27B 27B de paramètres | 27 GB | 475 GB | 17× | Une carte de 48 GB Complet : un nœud à 8 GPU |
| Qwen 3 32B 32B de paramètres | 31 GB | 563 GB | 18× | Une carte de 48 GB Complet : un nœud à 8 GPU |
| Llama 3.3 70B 70B de paramètres | 61 GB | 1,232 GB | 20× | Une carte de 80 GB Complet : plus d’un nœud |

Ce sont des ordres de grandeur avec une marge modeste pour les activations — suffisant pour choisir une machine, pas pour garantir un run précis. La longueur de séquence et la taille de lot font bouger sensiblement la colonne QLoRA ; la colonne fine-tuning complet bouge à peine, car elle est dominée par les 16 octets fixes par paramètre.

## Modèle par modèle

Le nœud le moins cher de notre catalogue capable d’entraîner chaque modèle avec QLoRA, ainsi que la machine dont vous auriez besoin pour servir le résultat.

**Nœud le moins cher pour l’entraînement QLoRA, et pour servir le résultat**

| Modèle | Mémoire d’entraînement | Nœud le moins cher pour entraîner | Nœud le moins cher pour servir |
|---|---|---|---|
| Llama 3.1 8B | 13 GB | [NVIDIA L4](https://gpuserver.io/fr/gpu/nvidia-l4) 24 GB par carte · $125/mois | [NVIDIA L4](https://gpuserver.io/fr/gpu/nvidia-l4) $125/mois |
| Mistral Small 24B | 25 GB | [NVIDIA RTX A6000](https://gpuserver.io/fr/gpu/rtx-a6000) 48 GB par carte · $286/mois | [NVIDIA L4](https://gpuserver.io/fr/gpu/nvidia-l4) $125/mois |
| Gemma 3 27B | 27 GB | [NVIDIA RTX A6000](https://gpuserver.io/fr/gpu/rtx-a6000) 48 GB par carte · $286/mois | [NVIDIA L4](https://gpuserver.io/fr/gpu/nvidia-l4) $125/mois |
| Qwen 3 32B | 31 GB | [NVIDIA RTX A6000](https://gpuserver.io/fr/gpu/rtx-a6000) 48 GB par carte · $286/mois | [NVIDIA L4](https://gpuserver.io/fr/gpu/nvidia-l4) $125/mois |
| Llama 3.3 70B | 61 GB | [NVIDIA A100 PCIe](https://gpuserver.io/fr/gpu/a100-80gb) 80 GB par carte · $1,091/mois | [2 × NVIDIA L4](https://gpuserver.io/fr/gpu/nvidia-l4) $285/mois |

L’entraînement veut de la mémoire ; l’inférence veut de la mémoire *et* de la bande passante. Il est courant que la bonne carte pour l’entraînement soit une carte bon marché à grande mémoire, et que la bonne carte pour l’inférence soit une carte rapide et coûteuse — et comme les deux sont mensuelles ici, faire tourner les deux sur des machines différentes est souvent moins cher que de faire un compromis sur une seule.

## Son exécution

Axolotl est préinstallé comme l’une des images du configurateur. Voici un run complet sur une seule carte, depuis une machine vierge.

Un run QLoRA sur une carte

```
$ mkdir -p /scratch/ft && cd /scratch/ft
$ cat > qlora.yml <<'YAML'
base_model: meta-llama/Llama-3.3-70B-Instruct
load_in_4bit: true
adapter: qlora
lora_r: 16
lora_alpha: 32
lora_dropout: 0.05
lora_target_linear: true

sequence_len: 2048
sample_packing: true
gradient_checkpointing: true
micro_batch_size: 1
gradient_accumulation_steps: 16
num_epochs: 2
learning_rate: 0.0001
optimizer: paged_adamw_8bit
bf16: true

datasets:
  - path: /scratch/ft/data.jsonl
    type: chat_template
output_dir: /scratch/ft/out
YAML

$ docker run --rm --gpus all --ipc=host --shm-size=16g \
    -v /scratch/ft:/workspace -v /scratch/models:/root/.cache/huggingface \
    -e HF_TOKEN="$HF_TOKEN" \
    axolotlai/axolotl:main-latest \
    axolotl train /workspace/qlora.yml
```

Surveillez la mémoire, pas la loss, pendant les deux premières minutes

```
$ nvidia-smi dmon -s um

# If memory sits just under the card's total, you are one long batch
# away from an out-of-memory error four hours into the run.
# Lower sequence_len or micro_batch_size now, not then.
```

## Les réglages qui comptent

lora_r 16 à 64 Le rang, et le principal curseur qualité/mémoire. 16 est une valeur par défaut raisonnable ; dépasser 64 est rarement rentable, sauf si vous enseignez une connaissance véritablement nouvelle plutôt qu’un format ou un style.

lora_target_linear true Adapte chaque couche linéaire plutôt que l’attention seule. Coûte peu et surpasse systématiquement le réglage par défaut limité à l’attention.

sequence_len Le plus grand levier de mémoire Les activations évoluent avec elle. La diviser par deux divise à peu près par deux la part variable de votre mémoire. Réglez-la sur la longueur réelle de vos données, pas sur le maximum du modèle.

gradient_checkpointing true, presque toujours Environ 30 % plus lent, et c’est ce qui permet à un run de 70B de tenir sur une seule carte. Ne le désactivez que si vous avez de la mémoire à revendre.

micro_batch_size & accumulation Arbitrer l’un contre l’autre Le lot effectif est leur produit. Gardez le micro-lot à 1 et augmentez l’accumulation quand la mémoire est limitée — même gradient, moins de mémoire de pointe, légèrement plus lent.

optimizer paged_adamw_8bit États de l’optimiseur en 8 bits avec pagination CPU comme soupape de sécurité. Cela absorbe les pics qui, sinon, mettraient fin à un run à la quatrième heure.

## Ce que coûte un mois

La raison pour laquelle le mensuel compte plus pour l’entraînement que pour l’inférence : un projet de fine-tuning n’est pas un seul run. C’est un premier run qui échoue à cause d’un bug de données, un deuxième qui surapprend, un troisième qui fonctionne, puis cinq autres avec des rangs différents.

**Coût d’un projet de fine-tuning, par machine**

| Machine | Mémoire de la carte | Par mois | Convient à |
|---|---|---|---|
| [NVIDIA L4](https://gpuserver.io/fr/gpu/nvidia-l4) 300 GB/s | 24 GB | $125/mois | QLoRA jusqu’à 8B |
| [NVIDIA RTX 5090](https://gpuserver.io/fr/gpu/rtx-5090) 1,792 GB/s | 32 GB | $335/mois | QLoRA jusqu’à 32B |
| [NVIDIA A100 PCIe](https://gpuserver.io/fr/gpu/a100-40gb) 1,555 GB/s | 40 GB | $392/mois | QLoRA jusqu’à 32B |
| [NVIDIA RTX A6000](https://gpuserver.io/fr/gpu/rtx-a6000) 768 GB/s | 48 GB | $286/mois | QLoRA jusqu’à 32B |
| [NVIDIA A100 PCIe](https://gpuserver.io/fr/gpu/a100-80gb) 1,935 GB/s | 80 GB | $1,091/mois | QLoRA jusqu’à 70B |

Comparez cela à une tarification à l’heure sur la durée d’un projet plutôt que d’un run : le [guide du seuil de rentabilité](https://gpuserver.io/fr/guides/monthly-vs-hourly) fait le calcul. Une machine qui existe pendant trois semaines pendant que vous itérez est exactement le cas où un compteur coûte plus cher qu’une durée d’engagement.

## Où LoRA cesse de fonctionner

C’est une très bonne technique avec une limite réelle, et il vaut la peine de savoir de quel côté de cette limite vous vous trouvez avant de louer quoi que ce soit.

**Enseigner un domaine véritablement nouveau.** LoRA adapte bien le comportement et ajoute mal la connaissance. Un modèle qui n’a jamais vu votre domaine ne l’apprendra pas à partir d’un adaptateur de rang faible.

**Changer le vocabulaire ou le tokenizer.** Les nouveaux tokens ont besoin d’embeddings entraînés, ce qui dépasse ce qu’un adaptateur peut toucher.

**Poursuivre le pré-entraînement sur des milliards de tokens.** C’est du fine-tuning complet, et cela nécessite la machine indiquée dans la colonne de droite du tableau ci-dessus — soit plus d’un nœud, et plus que ce que nous louons.

**Gagner les deux derniers points d’un benchmark.** Le fine-tuning complet l’emporte encore à la marge. Si c’est cette marge qui vous est payée, LoRA n’est pas le bon outil.

Pour tout le reste — un ton, un format, un schéma, un domaine que le modèle de base connaît déjà à moitié — QLoRA sur une seule carte atteint l’essentiel de la qualité pour une fraction de la machine. C’est le compromis, et pour les modèles sur lesquels la plupart des gens font réellement du fine-tuning, c’est un bon compromis.

## Choisissez la carte, gardez-la pour tout le projet.

Chaque configuration est mensuelle, avec accès root et sans compteur — ce dont on a réellement besoin pour itérer sur un fine-tuning.

[Parcourir le catalogue](https://gpuserver.io/fr/#catalog) [Lire les guides](https://gpuserver.io/fr/guides)

## Autres guides

- [Paiement · 8 min Payer un serveur en crypto Ce qui se passe entre le clic sur payer et l’obtention du root, quelle monnaie choisir, et les quatre erreurs qui font perdre de l’argent sur un premier paiement. Lire le guide](https://gpuserver.io/fr/guides/pay-in-crypto)
- [Dimensionnement · 9 min Combien de VRAM un modèle utilise réellement L’arithmétique derrière « est-ce que ça tient » : poids, cache clef/valeur, et les deux endroits où une règle empirique se trompe d’un facteur trois. Lire le guide](https://gpuserver.io/fr/guides/vram-sizing)
- [Dimensionnement · 7 min NVLink ou PCIe : lequel exige votre tâche Quand le lien entre les cartes détermine votre débit, quand cela ne change rien, et comment savoir dans quel cas vous êtes avant de payer pour le mauvais nœud. Lire le guide](https://gpuserver.io/fr/guides/nvlink-vs-pcie)

---

Source : https://gpuserver.io/fr/guides/lora-finetune/. Ce fichier est généré à partir des mêmes données que le site ; si un chiffre ici diffère d’une page, la page fait foi et ce fichier est obsolète — la source canonique est https://gpuserver.io/.