> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/comparaisons/finetuning-comparison.md).

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

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

***

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{% hint style="warning" %}
**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](https://clore.ai/bare-metal) sur demande. Consultez [Tarifs et disponibilité des GPU](/guides/guides_v2-fr/premiers-pas/pricing.md) avant de dimensionner un déploiement.
{% endhint %}

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

***

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.