Comparaison des outils de fine-tuning

Choisissez le bon cadre de fine-tuning pour entraîner des LLM sur les serveurs GPU de Clore.ai.

Fine-tuning Le fine-tuning adapte un LLM pré-entraîné à votre tâche ou domaine spécifique. Ce guide compare les quatre principaux outils open source : Unsloth, Axolotl, LLaMA-Factory et TRL — en couvrant la vitesse, l'efficacité mémoire, les modèles pris en charge et la facilité d'utilisation.

---

Matrice de décision rapide

	Unsloth	Axolotl	LLaMA-Factory	TRL
Idéal pour	Vitesse + mémoire	Entraînement piloté par la configuration	Adapté aux débutants	Recherche + RLHF
Vitesse vs référence	2 à 5× plus rapide	~1× (standard)	~1× (standard)	~1× (standard)
Réduction de mémoire	70 à 80 % de moins	QLoRA standard	QLoRA standard	Standard
RLHF/DPO/PPO	Basique	✅	✅	✅ (natif)
WebUI	❌	❌	✅	❌
Étoiles GitHub	23K+	9K+	37K+	10K+
Licence	LGPL (gratuit pour un usage non commercial)	Apache 2.0	Apache 2.0	Apache 2.0

---

Aperçu

Unsloth

Unsloth est entièrement focalisé sur une seule chose : rendre le fine-tuning aussi rapide et économe en mémoire que possible. Il réécrit les opérations clés en Triton et optimise les kernels CUDA.

Philosophie: Vitesse maximale, VRAM minimale — aucun compromis.

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,  # quantification 4 bits
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,              # rang LoRA
    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 % de batch en plus
    random_state=42,
)

Axolotl

Axolotl enveloppe HuggingFace Transformers avec un système de configuration basé sur YAML. Il gère la complexité de la configuration d'entraînement pour que vous puissiez vous concentrer sur les données et les hyperparamètres.

Philosophie: Tout en YAML, flexibilité totale sous le capot.

# 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 prend en charge la plus large gamme de modèles (100+) et de méthodes d'entraînement, avec une interface Web pour la configuration. C'est l'option la plus accessible pour les non-chercheurs.

Philosophie: Tout fonctionne, pour tout le monde.

# Entraînement via la ligne de commande
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

# Ou utilisez WebUI
llamafactory-cli webui

TRL (apprentissage par renforcement des transformeurs)

TRL est la bibliothèque officielle de RLHF de HuggingFace. C'est la référence pour PPO, DPO, ORPO et d'autres méthodes d'entraînement d'alignement.

Philosophie: Priorité à la recherche, entraînement d'alignement natif.

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()

---

Benchmarks de vitesse

Comparaison de la vitesse d'entraînement (tokens/seconde)

Configuration de test : LLaMA 3.1 8B, LoRA r=16, quantification 4 bits, taille de lot 4, A100 80 Go

Outil	Jetons/s	vs référence	Mémoire (VRAM)
Unsloth (4-bit)	~4,200	2.8×	~8 Go
Axolotl (QLoRA)	~1,500	1.0×	~16 Go
LLaMA-Factory (QLoRA)	~1,480	~1.0×	~16 Go
TRL (QLoRA)	~1,450	~0.97×	~18 Go
Unsloth (16 bits complet)	~2,800	1.9×	~22 Go

L'avantage d'Unsloth est réel: Le gain de vitesse de 2 à 5× vient de kernels Triton personnalisés pour l'attention, l'entropie croisée, RoPE et LoRA. Pas seulement du marketing.

Comparaison de l'utilisation de la VRAM

Entraînement de LLaMA 3.1 8B, longueur de séquence 2048 :

Méthode	Unsloth	Axolotl	LLaMA-Factory	TRL
Fine-tuning complet (bf16)	60 Go	70GB	72GB	74 Go
LoRA (bf16)	18 Go	24GB	25 Go	26GB
QLoRA (4 bits)	8 Go	16 Go	16 Go	18 Go
QLoRA (4 bits, contexte long)	12 Go	24GB	24GB	26GB

GPU minimum pour un modèle 8B:

• Unsloth : RTX 3080 (10 Go) ✅

• Autres : RTX 3090 (24 Go) requis

---

Modèles pris en charge

Matrice de prise en charge des modèles

Famille de modèles	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	Partiel	✅	✅	✅
T5/FLAN	❌	✅	✅	✅
BERT/RoBERTa	❌	✅	✅	✅
LLM vision	Partiel	Partiel	✅	✅

Prise en charge des méthodes d'entraînement

Méthode	Unsloth	Axolotl	LLaMA-Factory	TRL
Ajustement fin complet	✅	✅	✅	✅
LoRA	✅	✅	✅	✅
QLoRA	✅	✅	✅	✅
DoRA	✅	✅	✅	❌
PEFT	✅	✅	✅	✅
SFT	✅	✅	✅	✅ (natif)
DPO	✅	✅	✅	✅ (natif)
PPO	❌	✅	✅	✅ (natif)
ORPO	✅	✅	✅	✅
KTO	❌	✅	✅	✅ (natif)
GRPO	✅	❌	✅	✅
CPT (pré-entraînement continu)	✅	✅	✅	✅

---

Unsloth : plongée approfondie

Ce qui le rend rapide

1. Kernels Triton: Réécrit Flash Attention, la perte d'entropie croisée et LoRA dans Triton

2. Opérations fusionnées: Combine plusieurs opérations CUDA en un seul kernel

3. Checkpointing de gradient intelligent: Le mode "unsloth" économise ~30 % de mémoire supplémentaire

4. Rétropropagation efficace: Évite de matérialiser de grands tenseurs intermédiaires

Installation sur Clore.ai

# CUDA 12.8
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes

# Ou avec 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

Script d'entraînement complet

from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import load_dataset
import torch

# 1. Charger le modèle avec l'optimisation Unsloth
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Meta-Llama-3.1-8B-Instruct",
    max_seq_length=2048,
    dtype=None,        # Détection automatique
    load_in_4bit=True,
)

# 2. Ajouter l'adaptateur LoRA
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. Charger et formater le jeu de données
dataset = load_dataset("tatsu-lab/alpaca", split="train")

def format_prompt(example):
    return {"text": f"### Instruction :\n{example['instruction']}\n\n### Réponse :\n{example['output']}"}

dataset = dataset.map(format_prompt)

# 4. Entraîner
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. Enregistrer
model.save_pretrained("lora_model")
model.save_pretrained_gguf("model_gguf", tokenizer, quantization_method="q4_k_m")

Faiblesses: Pas de PPO, limité à la liste des modèles pris en charge, licence LGPL (vérifier l'usage commercial)

---

Axolotl : plongée approfondie

Approche d'abord par la configuration

Axolotl brille lorsque vous voulez des configurations d'entraînement reproductibles et versionnées :

# axolotl_config.yml — exemple complet
base_model: meta-llama/Meta-Llama-3-8B-Instruct
model_type: LlamaForCausalLM
tokenizer_type: AutoTokenizer

# Données
datasets:
  - path: tatsu-lab/alpaca
    type: alpaca
  - path: ./my_custom_data.jsonl
    type: sharegpt
dataset_prepared_path: ./prepared_data
val_set_size: 0.01

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

# Entraînement
sequence_len: 4096
sample_packing: true  # Empaquette les séquences courtes pour plus d'efficacité
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

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

# Installer et exécuter
pip install axolotl[flash-attn,deepspeed]
axolotl train axolotl_config.yml

Idéal pour: Équipes qui veulent des exécutions d'entraînement reproductibles, versionnées par configuration

---

LLaMA-Factory : plongée approfondie

Présentation de WebUI

# Installation
pip install llamafactory

# Lancer WebUI
llamafactory-cli webui
# Ouvrir http://localhost:7860

Onglets de WebUI :

1. Entraîner — configurer le modèle de base, le jeu de données et la méthode

2. Évaluer — exécuter les benchmarks MMLU, CMMLU

3. Chat — inférence interactive

4. Exporter — fusionner LoRA, quantifier en GGUF

Exemple d'entraînement en CLI

# Fine-tuning supervisé
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

# Entraînement DPO
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

Idéal pour: Débutants, équipes qui veulent WebUI, DPO/RLHF sans connaissances approfondies en recherche

---

TRL : plongée approfondie

Exemple de pipeline RLHF

TRL est la référence pour l'entraînement d'alignement :

from trl import PPOTrainer, PPOConfig, AutoModelForCausalLMWithValueHead
from trl import DPOTrainer, DPOConfig
from datasets import load_dataset

# DPO (Optimisation directe des préférences) — méthode d'alignement la plus courante
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,             # coefficient de pénalité KL
    loss_type="sigmoid",  # ou "hinge", "ipo", "kto_pair"
    learning_rate=5e-7,
)

# Charger le jeu de données de préférences (prompt + choisi + rejeté)
dataset = load_dataset("Anthropic/hh-rlhf", split="train")

trainer = DPOTrainer(
    model=model_name,
    args=dpo_config,
    train_dataset=dataset,
)
trainer.train()

Idéal pour: Recherche sur l'alignement, implémentations RLHF, DPO, PPO, ORPO

---

Choisir le bon outil

Arbre de décision

Besoin de vitesse maximale / mémoire minimale ?
  → OUI → Unsloth (2 à 5× plus rapide, tient sur des GPU plus petits)

Besoin d'un entraînement d'alignement (DPO/PPO/RLHF) ?
  → OUI → TRL ou LLaMA-Factory
  → Recherche/personnalisé → TRL
  → Production/facile → LLaMA-Factory

Besoin d'une reproductibilité axée sur la configuration ?
  → OUI → Axolotl

Équipe non technique ou envie de WebUI ?
  → OUI → LLaMA-Factory

Vous voulez juste démarrer rapidement ?
  → LLaMA-Factory ou Unsloth

Par type d'équipe

Équipe	Recommandation	Raison
Chercheur individuel	Unsloth	Vitesse + notebooks Jupyter
Ingénieur ML	Axolotl	Piloté par configuration, reproductible
Équipe produit	LLaMA-Factory	WebUI, large prise en charge des modèles
Équipe d'alignement	TRL	Primitives RLHF natives
Start-up	Unsloth + TRL	Vitesse + alignement si nécessaire

---

Recommandations GPU Clore.ai

Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai. Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez bare metal sur demande. Consultez Tarifs et disponibilité des GPU avant de dimensionner un déploiement.

Tâche	GPU minimal	Recommandé	Outil
7-8B LoRA (QLoRA)	RTX 3080 (10 Go)	RTX 3090	Unsloth
13B LoRA	RTX 3090 (24 Go)	A6000 (48 Go)	Unsloth/Axolotl
70B LoRA	A100 (80 Go)	2×A100	Axolotl/TRL
Fine-tuning complet 8B	A100 (40 Go)	A100 (80 Go)	N'importe lequel
DPO/PPO 7B	RTX 4090 (24 Go)	A6000 (48 Go)	TRL

---

Liens utiles

• GitHub d'Unsloth — 23K+ étoiles

• GitHub d’Axolotl — 9K+ étoiles

• GitHub de LLaMA-Factory — 37K+ étoiles

• GitHub de TRL — 10K+ étoiles

• Docs PEFT de HuggingFace

---

Résumé

Outil	Idéal pour	Avantage clé
Unsloth	Entraînement où la vitesse est critique, petits GPU	2 à 5× plus rapide, 70 % de VRAM en moins
Axolotl	Exécutions reproductibles et pilotées par la configuration	Priorité au YAML, nombreux formats de données
LLaMA-Factory	100+ modèles, WebUI, débutants	La plus large prise en charge des modèles, interface graphique
TRL	RLHF, DPO, recherche sur l'alignement	Entraînement d'alignement natif

Pour la plupart des cas d'utilisation de Clore.ai : commencez par Unsloth (vitesse + efficacité mémoire), ajoutez TRL si vous avez besoin d'un entraînement d'alignement DPO ou PPO.