Prendre RDV
Lexique · Frameworks / outils IA

Unsloth : définition, fonctionnement et exemple LoRA

La bibliothèque open source qui accélère le fine-tuning LoRA et QLoRA des LLM sur un seul GPU en réduisant la mémoire consommée : fonctionnement, exemple de code et comparaison avec TRL, PEFT et Axolotl.

Par Équipe Blent· Mis à jour le · 13 min de lecture· Niveau intermédiaire

Unsloth en bref

Type
Bibliothèque de fine-tuning de LLM
Créateurs
Daniel et Michael Han
Licence
Apache 2.0 pour le cœur
Langage
Python, noyaux GPU optimisés

Définition : Unsloth

Unsloth est une bibliothèque open source de fine-tuning de grands modèles de langage, créée par Daniel et Michael Han. Elle réécrit en noyaux GPU optimisés les opérations les plus coûteuses de l'entraînement, notamment l'attention, les couches linéaires et le calcul de la perte, pour accélérer les méthodes LoRA et QLoRA tout en réduisant fortement la mémoire utilisée. Un modèle de plusieurs milliards de paramètres peut ainsi être adapté sur un seul GPU de taille modeste, par exemple celui d'un notebook gratuit. Unsloth s'intègre à l'écosystème Hugging Face et exporte les modèles obtenus, notamment au format GGUF.

En une phrase : Unsloth permet de fine-tuner un LLM ouvert sur un seul GPU en consommant bien moins de mémoire, avec une API proche de celle de Hugging Face.

Dans cette définition

Qu'est-ce qu'Unsloth ?

Unsloth est une bibliothèque Python qui rend le fine-tuning d'un LLM plus rapide et moins gourmand en mémoire. Elle cible les méthodes LoRA et QLoRA, qui n'entraînent qu'une petite fraction des paramètres du modèle, et permet de les exécuter sur un seul GPU, parfois celui d'un notebook gratuit.

Unsloth se situe au-dessus de l'écosystème Hugging Face et de PyTorch : il charge les mêmes modèles, accepte les mêmes jeux de données et s'utilise avec le trainer de TRL. Ce qu'il change, c'est l'implémentation interne : des noyaux GPU réécrits à la main pour l'attention, les couches linéaires, la fonction de perte et le gradient checkpointing, sans approximation du calcul.

Le projet est porté par Daniel et Michael Han et publié sur GitHub depuis 2023. Le cœur est sous licence Apache 2.0, et la bibliothèque prend en charge de nombreuses familles de modèles ouverts, ainsi que d'autres méthodes comme le fine-tuning complet, DPO ou GRPO. Il sert aussi de porte d'entrée à la notion de fine-tuning pour beaucoup d'équipes.

À retenir : Unsloth n'est ni un modèle ni une nouvelle méthode d'apprentissage. C'est une implémentation plus efficace de méthodes existantes, qui rend le fine-tuning accessible avec peu de matériel.

Comment fonctionne un fine-tuning avec Unsloth ?

Un entraînement avec Unsloth suit le schéma classique du fine-tuning par adaptateurs, avec des optimisations appliquées à chaque étape.

  1. Charger le modèle de base

    FastLanguageModel charge un modèle ouvert depuis le Hub de Hugging Face, le plus souvent quantifié en 4 bits pour tenir sur un GPU modeste.

  2. Ajouter les adaptateurs LoRA

    Seules de petites matrices additionnelles sont entraînées, tandis que les poids du modèle de base restent gelés. Le nombre de paramètres à mettre à jour chute fortement.

  3. Préparer le jeu de données

    Les exemples sont mis au format de conversation attendu par le modèle, avec son gabarit de chat, puis tokenisés.

  4. Entraîner avec un trainer

    Le SFTTrainer de TRL pilote la boucle d'entraînement, pendant que les noyaux d'Unsloth accélèrent l'attention, la perte et le gradient checkpointing.

  5. Évaluer et exporter

    Le modèle est testé sur des cas réels, puis sauvegardé en adaptateurs, fusionné avec le modèle de base ou converti en GGUF pour l'inférence.

Sous le capot : où Unsloth économise de la mémoire

Un fine-tuning classique consomme de la mémoire à trois endroits : les poids, les états de l'optimiseur et les activations. Unsloth agit sur chacun.

  • QLoRA : les poids du modèle de base sont stockés en 4 bits, ce qui divise leur taille par environ quatre par rapport au 16 bits. Les adaptateurs LoRA, eux, restent en précision plus élevée.
  • Noyaux optimisés : les opérations critiques sont réécrites pour limiter les copies mémoire et les calculs redondants, ce qui accélère l'entraînement.
  • Gradient checkpointing : au lieu de stocker toutes les activations, on en recalcule une partie pendant la rétropropagation. Unsloth propose sa propre variante, activée par use_gradient_checkpointing="unsloth".
  • Contextes longs : ces économies permettent aussi d'augmenter la longueur de séquence à mémoire égale.

Pour comprendre la réduction à 4 bits, voir l'article sur la quantization.

Exemple : fine-tuner un modèle avec QLoRA

L'exemple suivant charge un modèle en 4 bits, ajoute des adaptateurs LoRA et lance un entraînement supervisé. Les paramètres exacts évoluent selon les versions : la documentation officielle fait foi.

python
from unsloth import FastLanguageModel
from trl import SFTTrainer, SFTConfig

# Chargement du modèle de base quantifié en 4 bits
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/llama-3-8b-bnb-4bit",
    max_seq_length=2048,
    load_in_4bit=True,
)

# Ajout des adaptateurs LoRA (rang 16)
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,
    use_gradient_checkpointing="unsloth",
)

# Entraînement supervisé avec le trainer de TRL
trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,  # dataset préparé avec une colonne "text"
    args=SFTConfig(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        learning_rate=2e-4,
        max_steps=100,
        output_dir="outputs",
    ),
)
trainer.train()

Le modèle est chargé par FastLanguageModel, qui remplace le chargement standard de Transformers. get_peft_model ajoute les adaptateurs, puis le SFTTrainer mène l'entraînement. Une fois terminé, on exporte le résultat :

python
# Sauvegarde des seuls adaptateurs LoRA
model.save_pretrained("lora_model")

# Export en GGUF pour Ollama ou llama.cpp
model.save_pretrained_gguf("model_gguf", tokenizer, quantization_method="q4_k_m")

Les principaux cas d'usage d'Unsloth

Unsloth s'adresse aux équipes qui veulent adapter un modèle ouvert sans cluster de GPU.

  • Prototypage rapide

    Tester un fine-tuning en quelques minutes sur un notebook ou un GPU grand public.

  • Adaptation à un domaine

    Spécialiser un modèle sur un vocabulaire juridique, médical ou technique.

  • Style et format de sortie

    Imposer un ton, un gabarit de réponse ou une sortie JSON stable.

  • Petits modèles spécialisés

    Entraîner un modèle compact pour une tâche précise, à moindre coût d'inférence.

  • Alignement et raisonnement

    Appliquer des méthodes comme DPO ou GRPO pour améliorer les réponses d'un modèle.

  • Déploiement local

    Exporter en GGUF pour servir le modèle avec Ollama ou llama.cpp.

Quels sont les avantages d'Unsloth ?

Unsloth vaut surtout par ce qu'il permet de faire avec peu de matériel.

  • Une consommation de mémoire GPU nettement réduite, ce qui rend le fine-tuning possible sur un seul GPU.
  • Un entraînement plus rapide qu'avec une implémentation standard, grâce à des noyaux écrits à la main.
  • Une API proche de celle de Hugging Face, qui réutilise les jeux de données et le trainer de TRL.
  • Une qualité d'entraînement visée identique à celle des méthodes classiques, sans approximation de l'attention.
  • Une prise en charge de nombreuses familles de modèles ouverts, comme Llama, Qwen, Gemma ou Mistral.
  • Des exports pratiques, dont le format GGUF, et de nombreux notebooks prêts à l'emploi.

Quelles sont les limites d'Unsloth ?

Les gains dépendent du matériel et du modèle, et l'outil reste plus spécialisé que les bibliothèques généralistes.

  • Les optimisations ciblent des architectures précises : un modèle récent peut ne pas être pris en charge tout de suite.
  • Le support multi-GPU et les gros entraînements distribués sont moins mûrs que dans des outils conçus pour eux.
  • Les chiffres d'accélération annoncés varient selon le modèle, la longueur de séquence et le GPU, et sont à mesurer chez soi.
  • Le fine-tuning n'apporte pas de connaissances fiables et à jour : pour cela, un RAG reste préférable.
  • La qualité du résultat dépend avant tout du jeu de données, que l'outil ne peut pas corriger.
  • Les versions évoluent vite, ce qui impose de figer les dépendances pour reproduire un entraînement.

Unsloth vs Hugging Face TRL/PEFT vs Axolotl : quelles différences ?

Ces outils ne sont pas strictement concurrents. TRL et PEFT forment la base de référence de Hugging Face, Unsloth optimise leur exécution, et Axolotl propose une couche de configuration au-dessus de l'écosystème.

CritèreUnslothHugging Face TRL + PEFTAxolotl
ObjectifFine-tuning rapide et économe en mémoireBriques généralistes de référenceEntraînement piloté par configuration
InterfaceCode Python et notebooksCode PythonFichier YAML
Mémoire GPUTrès réduiteStandardStandard, avec options d'optimisation
Matériel viséUn seul GPU en prioritéDu GPU unique au clusterDu GPU unique au multi-GPU
MéthodesLoRA, QLoRA, complet, DPO, GRPOSFT, DPO, GRPO, LoRA et plusLoRA, QLoRA, complet, alignement
Prise en mainRapideModéréeModérée

Unsloth utilise TRL pour la boucle d'entraînement : on les combine plus qu'on ne les oppose. Le choix se fait sur le matériel disponible et la façon de travailler, et un test sur votre propre jeu de données reste la meilleure mesure.

Ce n'est pas un choix binaire. Un même projet peut prototyper avec Unsloth sur un GPU unique, puis passer à une configuration Axolotl ou TRL distribuée quand le volume l'exige.

Bonnes pratiques de fine-tuning

  • Commencer par le prompt et le RAG : le fine-tuning est utile pour le comportement, pas pour injecter des faits à jour.
  • Soigner le jeu de données : quelques centaines d'exemples propres valent mieux que des milliers d'exemples bruités.
  • Évaluer avant et après : mesurer le modèle de base et le modèle fine-tuné sur un jeu de test indépendant.
  • Figer les versions : conserver les versions d'Unsloth, de TRL et de PyTorch pour reproduire l'entraînement.
  • Servir ensuite : un modèle fine-tuné se déploie avec Ollama en local ou avec vLLM en production.

Le tutoriel Unsloth : fine-tuner des LLM détaille ces étapes avec un cas complet.

Quand utiliser Unsloth ?

Le critère principal est la contrainte matérielle, suivie du besoin réel de fine-tuning.

Pertinent si

Unsloth est adapté

  • Vous disposez d'un seul GPU ou d'un notebook gratuit.
  • Vous voulez un fine-tuning LoRA ou QLoRA rapide à itérer.
  • Vous restez dans l'écosystème Hugging Face.
  • Vous voulez exporter vers Ollama ou llama.cpp.
Moins adapté si

Un autre choix est préférable

  • Vous entraînez à grande échelle sur un cluster multi-nœuds.
  • Vous voulez piloter tout l'entraînement par un fichier de configuration : Axolotl convient mieux.
  • Un prompt bien conçu ou un RAG répond déjà au besoin.
  • Votre architecture de modèle n'est pas prise en charge.

Technologies et outils associés à Unsloth

Unsloth s'insère dans la chaîne du fine-tuning, entre le Hub de modèles, le trainer et l'inférence.

Les concepts à connaître autour d'Unsloth

Quelques notions suffisent pour comprendre ce que fait Unsloth.

Ressources pour approfondir Unsloth

Trois articles pour passer de la définition à un fine-tuning complet.

Questions fréquentes

Questions fréquentes

Oui. Le cœur d'Unsloth est publié sous licence Apache 2.0 et s'utilise gratuitement, y compris en entreprise. Certains composants optionnels, comme l'interface Studio, relèvent d'une licence différente (AGPL-3.0) : vérifiez-la avant tout usage commercial.

Expertise

À propos de l'auteur

Équipe Blent

Les ingénieurs et mentors Blent conçoivent, évaluent et mettent en production des applications LLM, et forment chaque année des centaines de professionnels à l'IA générative.

Sources et méthodologie

  • Documentation officielle d'Unsloth
  • Dépôt GitHub unslothai/unsloth
  • Hu et al., LoRA: Low-Rank Adaptation of Large Language Models, 2021
  • Dettmers et al., QLoRA: Efficient Finetuning of Quantized LLMs, NeurIPS 2023
  • Retours d'expérience des projets et formations Blent
Lexique

Explorer le lexique

Voir toutes les définitions