Comparaison des outils de fine-tuning

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

Fine-tuning adapte un LLM pré-entraîné à votre tâche ou domaine spécifique. Ce guide compare les quatre outils open-source majeurs : Unsloth, Axolotl, LLaMA-Factory et TRL — 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

Meilleur pour

Vitesse + mémoire

Entraînement piloté par configuration

Convient aux débutants

Recherche + RLHF

Vitesse vs baseline

2-5× plus rapide

~1× (standard)

Réduction de la mémoire

70-80% de moins

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

Aperçu

Unsloth

Unsloth est entièrement concentré sur une 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 noyaux CUDA.

Philosophie: Vitesse maximale, VRAM minimale — sans 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 size 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 en dessous.

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

Philosophie: Tout fonctionne, pour tout le monde.

# Entraîner 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 utiliser WebUI
llamafactory-cli webui

TRL (Transformer Reinforcement Learning)

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

Philosophie: Recherche d'abord, 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, batch size 4, A100 80GB

Outil

Tokens/sec

vs Baseline

Mémoire (VRAM)

Unsloth (4-bit)

~4,200

2.8×

~8GB

Axolotl (QLoRA)

~1,500

1.0×

~16GB

LLaMA-Factory (QLoRA)

~1,480

~1.0×

~16GB

TRL (QLoRA)

~1,450

~0.97×

~18GB

Unsloth (full 16-bit)

~2,800

1.9×

~22GB

L'avantage d'Unsloth est réel: 2-5× de vitesse provient de noyaux 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 LLaMA 3.1 8B, longueur de séquence 2048 :

Méthode

Unsloth

Axolotl

LLaMA-Factory

TRL

Fine-tune complet (bf16)

60GB

70GB

72GB

74GB

LoRA (bf16)

18GB

24GB

25GB

26GB

QLoRA (4 bits)

8 Go

16GB

18GB

QLoRA (4-bit, long ctx)

12GB

24GB

26GB

GPU minimum pour modèle 8B:

Unsloth : RTX 3080 (10GB) ✅
Autres : RTX 3090 (24GB) requis

Modèles pris en charge

Matrice de support 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

❌

✅

Vision LLMs

Partiel

✅

Support des méthodes d'entraînement

Méthode

Unsloth

Axolotl

LLaMA-Factory

TRL

Fine-tune complet

✅

LoRA

✅

QLoRA

✅

DoRA

✅

❌

PEFT

✅

SFT

✅

✅ (natif)

DPO

✅

✅ (natif)

PPO

❌

✅

✅ (natif)

ORPO

✅

KTO

❌

✅

✅ (natif)

GRPO

✅

❌

✅

CPT (pretraining continu)

✅

Unsloth : Approfondissement

Ce qui le rend rapide

Noyaux Triton: Réécrit Flash Attention, la perte d'entropie croisée et LoRA en Triton
Opérations fusionnées: Combine plusieurs opérations CUDA en un seul noyau
Smart gradient checkpointing: Le mode "unsloth" économise ~30% de mémoire supplémentaire
Rétropropagation efficace: Évite la matérialisation de grands tenseurs intermédiaires

Installation sur Clore.ai

# CUDA 12.1
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 un 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### Response:\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. Sauvegarder
model.save_pretrained("lora_model")
model.save_pretrained_gguf("model_gguf", tokenizer, quantization_method="q4_k_m")

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

Axolotl : Approfondissement

Approche axée sur 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  # Regroupe les courtes séquences pour l'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

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

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

LLaMA-Factory : Approfondissement

Visite de la WebUI

# Installer
pip install llamafactory

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

Onglets de la WebUI :

Train — configurer le modèle de base, le jeu de données, la méthode
Évaluer — exécuter les benchmarks MMLU, CMMLU
Chat — inférence interactive
Exporter — fusionner LoRA, quantifier en GGUF

Exemple d'entraînement CLI

# Supervised Fine-Tuning
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

Meilleur pour: Débutants, équipes voulant une WebUI, DPO/RLHF sans connaissances de recherche approfondies

TRL : Approfondissement

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 (Direct Preference Optimization) — 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 dataset 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()

Meilleur pour: Recherche d'alignement, RLHF, implémentations DPO, PPO, ORPO

Choisir le bon outil

Flux de décision

Besoin de vitesse maximale / VRAM minimale ?
  → OUI → Unsloth (2-5× plus rapide, tient sur des GPU plus petits)

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

Besoin de reproductibilité axée sur la configuration ?
  → OUI → Axolotl

Équipe non technique ou voulez une 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 support de modèles

Équipe d'alignement

TRL

Primitives RLHF natives

Startup

Unsloth + TRL

Vitesse + alignement quand nécessaire

Recommandations GPU Clore.ai

Tâche

GPU min

Recommandé

Outil

LoRA 7-8B (QLoRA)

RTX 3080 (10GB)

RTX 3090

Unsloth

LoRA 13B

RTX 3090 (24GB)

A6000 (48GB)

Unsloth/Axolotl

LoRA 70B

A100 (80GB)

2×A100

Axolotl/TRL

8B Full FT

A100 (40GB)

A100 (80GB)

N'importe lequel

DPO/PPO 7B

RTX 4090 (24GB)

A6000 (48GB)

TRL

Liens utiles

Unsloth GitHub — 23K+ étoiles
Axolotl GitHub — 9K+ étoiles
LLaMA-Factory GitHub — 37K+ étoiles
TRL GitHub — 10K+ étoiles
Docs HuggingFace PEFT

Résumé

Outil

Meilleur pour

Avantage clé

Unsloth

Entraînement critique en vitesse, petits GPU

2-5× plus rapide, 70% de VRAM en moins

Axolotl

Exécutions reproductibles pilotées par configuration

YAML-first, de nombreux formats de données

LLaMA-Factory

100+ modèles, WebUI, pour débutants

Plus grand support de modèles, GUI

TRL

RLHF, DPO, recherche d'alignement

Entraînement d'alignement natif

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

PrécédentComparaison des bases de données vectorielles SuivantComparaison de génération vidéo

Mis à jour il y a 4 jours

Ce contenu vous a-t-il été utile ?

hashtagMatrice de décision rapide

hashtagAperçu

hashtagUnsloth

hashtagAxolotl

hashtagLLaMA-Factory

hashtagTRL (Transformer Reinforcement Learning)

hashtagBenchmarks de vitesse

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

hashtagComparaison de l'utilisation de la VRAM

hashtagModèles pris en charge

hashtagMatrice de support des modèles

hashtagSupport des méthodes d'entraînement

hashtagUnsloth : Approfondissement

hashtagCe qui le rend rapide

hashtagInstallation sur Clore.ai

hashtagScript d'entraînement complet

hashtagAxolotl : Approfondissement

hashtagApproche axée sur la configuration

hashtagLLaMA-Factory : Approfondissement

hashtagVisite de la WebUI

hashtagExemple d'entraînement CLI

hashtagTRL : Approfondissement

hashtagExemple de pipeline RLHF

hashtagChoisir le bon outil

hashtagFlux de décision

hashtagPar type d'équipe

hashtagRecommandations GPU Clore.ai

hashtagLiens utiles

hashtagRésumé

Matrice de décision rapide

Aperçu

Unsloth

Axolotl

LLaMA-Factory

TRL (Transformer Reinforcement Learning)

Benchmarks de vitesse

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

Comparaison de l'utilisation de la VRAM

Modèles pris en charge

Matrice de support des modèles

Support des méthodes d'entraînement

Unsloth : Approfondissement

Ce qui le rend rapide

Installation sur Clore.ai

Script d'entraînement complet

Axolotl : Approfondissement

Approche axée sur la configuration

LLaMA-Factory : Approfondissement

Visite de la WebUI

Exemple d'entraînement CLI

TRL : Approfondissement

Exemple de pipeline RLHF

Choisir le bon outil

Flux de décision

Par type d'équipe

Recommandations GPU Clore.ai

Liens utiles

Résumé