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

{% hint style="info" %}
**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.
{% endhint %}

***

## 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)                       | \~1× (standard)        | \~1× (standard)  |
| **Réduction de la 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 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.

```python
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.

```yaml
# 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.

```bash
# 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.

```python
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         |

{% hint style="success" %}
**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.
{% endhint %}

### 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    | 16GB          | 18GB |
| QLoRA (4-bit, long ctx)  | 12GB     | 24GB    | 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 | 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

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

### Installation sur Clore.ai

```bash
# 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

```python
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 :

```yaml
# 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
```

```bash
# 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

```bash
# Installer
pip install llamafactory

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

Onglets de la WebUI :

1. **Train** — configurer le modèle de base, le jeu de données, 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 CLI

```bash
# 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 :

```python
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](https://github.com/unslothai/unsloth) — 23K+ étoiles
* [Axolotl GitHub](https://github.com/axolotl-ai-cloud/axolotl) — 9K+ étoiles
* [LLaMA-Factory GitHub](https://github.com/hiyouga/LLaMA-Factory) — 37K+ étoiles
* [TRL GitHub](https://github.com/huggingface/trl) — 10K+ étoiles
* [Docs HuggingFace PEFT](https://huggingface.co/docs/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.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/comparaisons/finetuning-comparison.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.