title: Unsloth Studio created: 2026-06-07 updated: 2026-06-07 type: app tags: [catalogue, artificial-intelligence, llm, fine-tuning, training, python, pytorch, studio, auto-hebergement] confidence: medium contested: false sources: [https://selfh.st/apps/?tag=Artificial+Intelligence, https://github.com/unslothai/unsloth]

🎯 Unsloth Studio

Studio web pour le fine-tuning de LLMs — interface visuelle pour entraîner, évaluer et déployer vos propres modèles (texte, vision, audio, embedding) sur GPU, basé sur le moteur d'optimisation Unsloth (2-5x plus rapide que Hugging Face, -40% de VRAM).

Métadonnée	Valeur
Site web	unsloth.ai
GitHub	unslothai/unsloth
License	Apache-2.0
Langage	Python, PyTorch
Étoiles	5 905 ⭐
Dernière MAJ	2026-06-01
Catégorie	cat-artificial-intelligence

Description

Unsloth est un projet qui a révolutionné le fine-tuning de LLMs sur GPU grand public. La librairie Python unsloth applique des optimisations manuelles de kernels CUDA (calculs en précision mixte, attention flash, gradients fusionnés) qui permettent de fine-tuner des modèles de plusieurs milliards de paramètres sur des cartes uniques (RTX 3090, 4090, A100, H100) avec 2 à 5x plus de vitesse et 40% de VRAM en moins qu'avec Hugging Face Transformers standard.

Unsloth Studio est la surcouche web de la librairie : une interface visuelle qui guide l'utilisateur à travers toutes les étapes du fine-tuning — du choix du modèle de base (Llama, Qwen, Mistral, Gemma, Phi, et des dizaines d'autres), à la préparation du dataset (CSV, JSON, conversations Alpaca/ShareGPT), en passant par la configuration de l'entraînement (LoRA, QLoRA, full fine-tuning, DPO, GRPO pour RL), jusqu'au déploiement et à l'évaluation.

Le positionnement est unique : face à des solutions comme Axolotl, LLaMA-Factory ou Hugging Face TRL (qui sont des CLI/notebooks), Unsloth Studio vise l'accessibilité — quelqu'un qui n'a jamais fait de ML peut fine-tuner un modèle en suivant les étapes dans l'UI, sans écrire une seule ligne de Python (même si c'est possible). Le mode Code Interpreter permet aussi aux LLMs d'exécuter du Bash et du Python pendant l'inférence.

Modèles supportés : Llama 3.x, Qwen 2.5/3, Mistral, Gemma 2/3, Phi-4, DeepSeek, et la plupart des modèles populaires sortis récemment. Support de text, vision, audio, embeddings en fine-tuning.

Installation

Option 1 : Docker (GPU)

# docker-compose.yml
version: '3.8'

services:
  unsloth-studio:
    image: unslothai/studio:latest
    container_name: unsloth-studio
    restart: unless-stopped
    ports:
      - "8888:8888"    # Jupyter
      - "3000:3000"    # Studio UI
    volumes:
      - unsloth_data:/workspace
      - unsloth_models:/models
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    environment:
      - NVIDIA_VISIBLE_DEVICES=all

volumes:
  unsloth_data:
  unsloth_models:

Prérequis : driver NVIDIA + nvidia-container-toolkit installés sur l'hôte, GPU avec au moins 8 Go de VRAM (16+ recommandé pour les modèles 7B+).

Option 2 : Installation manuelle (Python)

# Prérequis : Python 3.10+, CUDA 12.1+, PyTorch 2.x
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes

# Lancer le Studio
unsloth-studio
# ou via Jupyter :
jupyter lab

Configuration

Configuration typique d'un job de fine-tuning :

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/llama-3-8b-bnb-4bit",
    max_seq_length=2048,
    load_in_4bit=True,
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,                  # rang LoRA
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_alpha=16,
    use_gradient_checkpointing="unsloth",
)

# Puis entraînement standard via TRL/SFTTrainer

Variables d'environnement utiles :

UNSLOTH_DISABLE_AUTO_UPDATES=1 : empêche les mises à jour auto en plein training
CUDA_VISIBLE_DEVICES=0,1 : sélection des GPUs
HF_TOKEN : token Hugging Face pour télécharger les modèles gated (Llama, Gemma)

Alternatives

Open Source

LLaMA-Factory — projet chinois, support de plus de 100 modèles, UI web, LoRA/full
Axolotl — référence "code-first", très flexible
Hugging Face TRL + PEFT — combo standard, plus verbeux
MS-Swift (ModelScope) — autre framework chinois, multi-modal
LitGPT (Lightning AI) — implémentation propre pour les chercheurs

Propriétaires (ce que cette app remplace)

OpenAI Fine-Tuning API — cher, modèles propriétaires uniquement
Google Vertex AI Custom Training — cher, vendor lock-in
AWS SageMaker JumpStart — complexe, cher
Azure OpenAI Fine-Tuning — modèles Azure uniquement
Together AI — cloud, pas de self-host

Sécurité

Code Interpreter : le Studio permet aux LLMs d'exécuter du Bash/Python — exécuter dans un container ou une VM isolée, jamais sur l'host de prod
Modèles et datasets : les modèles fine-tunés peuvent contenir des biazes ou des vulnérabilités héritées des données — évaluer avant déploiement
Données d'entraînement : ne jamais fine-tuner sur des données sensibles (PII, secrets) sans anonymisation préalable
GPU : un GPU surchauffé pendant un fine-tuning long = risque d'incendie (matériel). Surveiller nvidia-smi et ventiler
Exfiltration : un modèle fine-tunonné peut "mémoriser" des données d'entraînement et les recracher — ne pas mettre de secrets en dataset
Docker socket : si on monte /var/run/docker.sock, le container a les pleins pouvoirs sur l'hôte — éviter

Ressources

Pages Liées

cat-artificial-intelligence — Catégorie parente
recettes-docker-compose — Templates Docker Compose
Ollama — Pour servir le modèle fine-tuné après entraînement (fiche à créer)
app-localai — Alternative pour l'inférence
app-open-webui — Frontend pour tester le modèle

6.6 KiB Raw Blame History