Hugging Face and smolLM3: Revolutionizing Small Language Models

Hugging Face et smolLM3 : Révolution des petits modèles de langage

Petit mais puissant

Faire fonctionner un modèle de 70 milliards de paramètres en production peut être coûteux, lent et, pour de nombreuses tâches, inutile. Si vous construisez un pipeline ciblé comme un classificateur de documents ou un répondant au support multilingue, un modèle bien entraîné de 3 milliards de paramètres sera à la hauteur, voire surpassera le modèle de 70 milliards pour votre tâche spécifique, et ce, à une fraction du coût. Le modèle de 3 milliards s'intègre entièrement dans un seul GPU grand public. Il se charge en quelques secondes. Il ne coûte rien par token. Et sur du matériel contraint, c'est la seule option qui fonctionne.

C'est le véritable atout des petits modèles de langage (SLMs). Cet article utilise SmolLM3, le modèle phare de Hugging Face de 3 milliards de paramètres publié le 8 juillet 2025, comme modèle de référence tout au long de l'article. C'est le SLM le plus techniquement intéressant disponible à l'échelle de 3 milliards, entraîné sur 11,2 trillions de tokens, prenant en charge une fenêtre de contexte de 128k, un raisonnement en mode double, un appel d'outils natif, six langues, et une licence Apache 2.0 avec le plan de formation complet publié en même temps que les poids.

Le fil conducteur du projet tissé à travers chaque section : un routeur de tickets de support client multilingue qui classe les tickets entrants par catégorie, détecte la langue du ticket, génère une réponse dans cette même langue et signale les sorties à faible confiance pour une escalade humaine. À la fin, vous aurez un pipeline fonctionnel que vous pourrez adapter à votre propre domaine.

Pourquoi les petits modèles de langage méritent plus d'attention

La fixation sur le nombre de paramètres en IA est compréhensible mais trompeuse. L'échelle brute compte, jusqu'à un certain point. Après ce point, la qualité des données, le curriculum d'entraînement et les choix architecturaux comptent davantage.

Des recherches issues du document SmolLM2 (arxiv, février 2025) ont montré qu'à l'échelle de 1 à 3 milliards, des données d'entraînement soigneusement sélectionnées surpassent systématiquement une simple augmentation des paramètres. SmolLM3 va encore plus loin : 11,2 trillions de tokens d'entraînement à travers un curriculum échelonné — données web, code, mathématiques et raisonnement — plus 140 milliards de tokens de raisonnement en post-formation. Le résultat est un modèle qui, sur des benchmarks en zéro-shot, surpasse à la fois Llama-3.2-3B et Qwen2.5-3B et rivalise avec Qwen3-4B sur plusieurs tâches.

Prenez le benchmark IFEval pour le suivi des instructions, où SmolLM3 obtient un score de 76,7, supérieur à Qwen3-4B à 68,9. Sur BFCL (appel d'outils), il égalise le fine-tuning d'appel d'outils de Llama à 92,3. Sur Global MMLU (QA multilingue), il obtient 53,5 contre 46,8 pour Llama-3.1-3B.

Là où les SLMs sont réellement en difficulté : les tâches nécessitant une connaissance approfondie et large du monde, des trivia compétitifs, un raisonnement complexe multi-sauts sur de vastes graphes de connaissances, et une écriture créative très longue avec un contexte historique riche. Pour ces cas, vous aurez besoin du grand modèle. Pour tout ce qui est ciblé et spécifique à un domaine, le SLM avec un fine-tuning sur vos données sera à la hauteur à un dixième du coût opérationnel.

La collection de SLM de Hugging Face comprend actuellement SmolLM3-3B (tuned pour les instructions, celui utilisé dans cet article), SmolLM3-3B-Base (poids pré-entraînés non ajustés), SmolLM2-1.7B (prédécesseur plus léger), et SmolVLM (la variante vision-langage). SmolLM3 est le bon choix pour la plupart des nouveaux projets car le raisonnement en mode double, l'appel d'outils et la fenêtre de contexte de 128k sont rares à cette échelle de paramètres.

Comprendre l'architecture de SmolLM3

SmolLM3 est un transformateur uniquement décodeur, ce qui est standard. Trois décisions architecturales à l'intérieur de ce cadre standard sont moins courantes et valent la peine d'être comprises car elles affectent directement la manière dont vous déployez et ajustez le modèle.

• Attention par requête groupée : L'attention multi-tête standard maintient des projections de clé et de valeur séparées pour chacune des 16 têtes d'attention. SmolLM3 regroupe ces 16 têtes en 4 projections de requête partagées, réduisant la mémoire cache clé-valeur (KV) d'environ 25% sans perte de précision mesurable. Cela est important au moment de l'inférence : un cache KV plus petit signifie une VRAM de pointe plus basse, ce qui vous permet de traiter des contextes plus longs ou des lots plus importants sur le même matériel.

• NoPE (Pas d'encodage positionnel sur certaines couches) : SmolLM3 supprime l'encodage positionnel rotatif (RoPE) de chaque quatrième couche de transformateur, mettant en œuvre un ratio de 3:1 RoPE à NoPE. Cette approche provient du document de 2025 "RoPE to NoRoPE and Back Again" et aide le modèle à généraliser sur de longs contextes sans la dégradation de l'encodage positionnel qui affecte la plupart des autres petits modèles sur de longues séquences.

• Raisonnement en mode double : Un seul ensemble de poids gère deux modes : think et no_think. En mode think, le modèle génère une trace de raisonnement à l'intérieur des balises <think>...</think> avant la réponse finale, équivalent à ce que font des "modèles de raisonnement" séparés. En mode no_think, il répond directement. Vous contrôlez cela par requête via le prompt système ou le paramètre enable_thinking dans le modèle de chat. Pas de modèle supplémentaire, pas de point de contrôle supplémentaire.

Configuration de votre environnement

Matériel minimum :

• 8 Go+ (RTX 3060 ou mieux)
• M2 Pro / M3 16 Go
• Fonctionne uniquement sur CPU. Attendez-vous à environ 3x plus lent pour l'inférence pour la synthèse texte-voix (TTS) et 5-8 tokens/seconde pour les tâches de génération selon votre machine. Le fine-tuning sur CPU est impraticable ; utilisez le GPU T4 gratuit de Google Colab si vous n'avez pas de GPU local.

Python et packages :

• Python 3.10 ou plus récent requis

python --version

• Créez et activez un environnement virtuel

python -m venv smollm-env
source smollm-env/bin/activate       # macOS / Linux
smollm-env\Scripts\activate          # Windows

• Installez toutes les dépendances

"transformers>=4.53.0" \
"torch>=2.3.0" \
"accelerate>=0.30.0" \
"bitsandbytes>=0.43.0" \
"sentencepiece" \
"peft>=0.11.0" \
"datasets>=2.19.0"

Remarque : transformers>=4.53.0 est requis ; le code de modélisation de SmolLM3 a été expédié dans cette version. Les versions antérieures échoueront avec une erreur d'architecture non reconnue.

Assistant de détection de périphérique (exécutez ceci en premier) :

# device_check.py
def detect_device():
    # Détecte le meilleur périphérique de calcul disponible.
    # Renvoie (device_str, dtype_str, load_kwargs) à utiliser avec from_pretrained.
    except ImportError:
        raise RuntimeError("PyTorch non trouvé. Installez avec : pip install torch")
    if torch.cuda.is_available():
        vram_gb = torch.cuda.get_device_properties(0).total_memory / 1e9
        print(f"GPU CUDA détecté : {torch.cuda.get_device_name(0)} ({vram_gb:.1f} Go VRAM)")
        return "cuda", torch.bfloat16, {"device_map": "auto", "torch_dtype": torch.bfloat16}
    elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
        print("MPS Apple Silicon détecté")
        return "mps", torch.float16, {"device_map": "mps", "torch_dtype": torch.float16}
    print("Aucun GPU trouvé -- fonctionnement sur CPU (plus lent mais fonctionnel)")
    return "cpu", torch.float32, {"device_map": "cpu", "torch_dtype": torch.float32"}

if __name__ == "__main__":
    device, dtype, kwargs = detect_device()
    print(f"Device : {device}")
    print(f"Dtype  : {dtype}")
    print(f"Kwargs : {kwargs}")

Exécutez :

python device_check.py

Sortie attendue (exemple NVIDIA GPU) :

GPU CUDA détecté : NVIDIA GeForce RTX 3060 (12.0 Go VRAM)
Dtype  : torch.bfloat16
Kwargs : {'device_map': 'auto', 'torch_dtype': torch.bfloat16}

Chargement de SmolLM3 et exécution de votre première inférence

Avec l'environnement confirmé, voici le modèle complet de chargement et de génération. Cela couvre la sélection de dtype, device_map="auto" pour multi-GPU ou déchargement CPU, et les deux modes de pensée côte à côte.

# first_inference.py
from transformers import AutoTokenizer, AutoModelForCausalLM

MODEL_ID = "HuggingFaceTB/SmolLM3-3B"

# ── 1. Charger le tokenizer et le modèle ───────────────────────────────────────────────
print(f"Chargement de {MODEL_ID}...")
tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
model = AutoModelForCausalLM.from_pretrained(
    torch_dtype=torch.bfloat16,    # Correspond au dtype d'entraînement ; utilisez float16 sur Apple Silicon
    device_map="auto",             # Se répartit sur tous les GPU disponibles, ou CPU si aucun
)
print(f"Modèle chargé sur : {model.device}")

# ── 2. Aide à la génération ──────────────────────────────────────────────────────
def generate(messages: list[dict], max_new_tokens: int = 512) -> str:
    # Applique le modèle de chat SmolLM3, tokenise, génère et décode.
    text = tokenizer.apply_chat_template(
        add_generation_prompt=True,
        inputs=tokenizer(text, return_tensors="pt").to(model.device)
    )
    with torch.no_grad():
        output_ids = model.generate(
            max_new_tokens=max_new_tokens,
            temperature=0.6,   # Recommandé par l'équipe de SmolLM3 pour une sortie équilibrée
            top_p=0.95,        # Échantillonnage par noyau -- garde la sortie ciblée sans répétition
        )
    new_tokens = output_ids[0][inputs["input_ids"].shape[-1]:]
    raw = tokenizer.decode(new_tokens, skip_special_tokens=True)
    final = re.sub(r".*?", "", raw, flags=re.DOTALL).strip()
    return final

# ── 3. Comparer think vs no_think sur le même prompt ──────────────────────────
prompt = "Un client est facturé deux fois pour la même commande. Quelles sont trois étapes concrètes que le support devrait suivre ?"

# no_think : réponse rapide et directe -- bon pour la classification et les réponses à haut débit
no_think_messages = [
    {"role": "system", "content": "/no_think"},
    {"role": "user",   "content": prompt},
]

# think : trace de raisonnement avant la réponse -- bon pour des décisions complexes et des cas particuliers
think_messages = [
    {"role": "system", "content": "/think"},
    {"role": "user",   "content": prompt},
]

print("\n── mode no_think ──")
print(generate(no_think_messages, max_new_tokens=256))
print("\n── mode think ──")
print(generate(think_messages, max_new_tokens=512))

Exécutez :

python first_inference.py

Le modèle se télécharge dans ~/.cache/huggingface/hub/ lors de la première exécution (~6,7 Go). Lors des exécutions suivantes, il se charge depuis le cache en quelques secondes.

Lorsque vous comparez les deux sorties, le mode think produit une réponse visiblement plus structurée.