Petits modèles, gros effets : l’IA qui tourne sur votre machine

L’IA générative évoque d’abord des centres de données et des grappes de GPU. C’est vrai pour les plus gros modèles. Mais une partie du travail utile se fait très bien avec des modèles beaucoup plus petits, de quelques milliards de paramètres, qui tournent sur un ordinateur portable, sans connexion et sans facture au jeton. Les comprendre permet de choisir le bon outil au lieu d’utiliser par défaut le plus gros.

Pourquoi la taille se compte en mémoire

Un modèle est un très grand tableau de nombres, les paramètres ou poids. Pour le faire tourner, il faut le charger en mémoire. Un calcul simple donne l’ordre de grandeur : un modèle de sept milliards de paramètres stocké avec deux octets par paramètre, ce qui est courant en demi-précision (seize bits), occupe environ quatorze gigaoctets. C’est trop pour la plupart des ordinateurs portables.

À cela s’ajoute la mémoire du contexte (ce qu’on appelle le KV cache), qui grandit avec la longueur de la conversation. Sur un long document, elle peut devenir significative, et c’est souvent elle qui limite en pratique la taille du texte qu’on peut traiter.

La quantification, ou comment faire tenir un modèle

La quantification consiste à stocker chaque paramètre avec moins de précision : huit bits, quatre bits, parfois moins, au lieu de seize. Le même modèle de sept milliards de paramètres, à quatre bits par paramètre, tient dans un peu plus de trois gigaoctets et demi, plus la mémoire de contexte. Cela le met à la portée de beaucoup de machines.

La qualité s’en ressent, mais moins qu’on ne l’imagine, jusqu’à un certain seuil. À huit bits, la perte est le plus souvent négligeable. À quatre bits, elle est modeste sur beaucoup de tâches. En dessous, elle devient nette. Ce n’est pas une règle uniforme : tout dépend du modèle et de la tâche, et la seule façon de le savoir est d’essayer sur vos propres cas. Les modèles quantifiés sont distribués dans des formats adaptés, dont le plus répandu pour l’inférence locale est GGUF.

La vitesse dépend de la bande passante

Pour produire un mot, le processeur doit relire l’essentiel des paramètres du modèle. La vitesse de génération est donc limitée moins par la puissance de calcul que par la vitesse à laquelle la mémoire peut fournir ces données. Une règle empirique utile : plus le modèle est gros et plus la mémoire est lente, plus la génération est lente.

C’est ce qui explique que les ordinateurs à mémoire unifiée rapide, comme les Mac à puce Apple, se comportent bien avec ces modèles, et qu’un petit modèle quantifié soit souvent plus agréable à utiliser qu’un grand modèle qui sature la machine.

Les outils pour essayer

On n’a plus besoin de compiler quoi que ce soit à la main. Quelques outils couramment utilisés :

• llama.cpp, le moteur d’inférence de référence en C++, qui a popularisé le format GGUF et qui fonctionne sur processeur comme sur GPU ;
• Ollama, qui télécharge, gère et sert les modèles avec une interface en ligne de commande et une API locale ;
• LM Studio, une application avec interface graphique ;
• MLX, la bibliothèque d’Apple pour ses puces, qui tire parti de leur architecture.

Plusieurs de ces outils exposent une API compatible avec celle des services en ligne les plus connus. Concrètement, une application écrite pour appeler un fournisseur distant peut souvent être redirigée vers le modèle local en changeant une adresse, ce qui facilite beaucoup les comparaisons.

Ce que les petits modèles font bien

Un petit modèle n’est pas un grand modèle en miniature, il a des points forts nets.

• Classer : trier des messages, détecter un sujet, une langue, un ton.
• Extraire : sortir des champs structurés d’un texte, comme une date, un montant ou un nom.
• Reformuler et résumer des textes courts.
• Router : décider quelle étape d’un traitement doit s’exécuter, ou quel modèle plus gros solliciter.
• Calculer des embeddings, pour la recherche sémantique, ce qui se fait très bien avec des modèles spécialisés de petite taille.
• Compléter du code simple à l’intérieur d’un éditeur.

Ce qu’ils font mal

Les mêmes modèles décrochent sur d’autres terrains : raisonnement en plusieurs étapes, consignes longues avec beaucoup de contraintes, connaissances factuelles rares, où ils inventent plus volontiers qu’un grand modèle. Un petit modèle qui répond avec aplomb sur un sujet pointu a de bonnes chances de se tromper, et rien ne l’indique dans le ton de sa réponse.

La conséquence pratique est de lui confier des tâches bornées et vérifiables, où l’on peut contrôler la sortie par du code ou la comparer à une liste de valeurs permises, plutôt que des questions ouvertes.

La spécialisation, la carte cachée

Un petit modèle peut être affiné sur une tâche étroite, par exemple avec la technique LoRA, qui n’entraîne qu’un petit nombre de paramètres supplémentaires. Sur une tâche précise et bien délimitée, comme classer vos tickets selon votre propre grille, un petit modèle spécialisé peut égaler un modèle bien plus gros utilisé tel quel, pour une fraction du coût. Cela demande des exemples de qualité, quelques centaines au moins, et un jeu de test séparé pour vérifier le résultat.

Pourquoi s’en préoccuper

Les raisons de faire tourner un modèle chez soi ne tiennent pas qu’à la mode.

• Confidentialité : les données ne quittent pas la machine.
• Disponibilité : cela marche sans réseau, dans un train, sur un site isolé.
• Coût marginal nul : une fois le modèle en place, chaque requête supplémentaire ne coûte que de l’électricité.
• Stabilité : le modèle ne change que lorsque vous le décidez, ce qui rend les résultats reproductibles.
• Latence prévisible, sans dépendre de la charge d’un service tiers.

Comment commencer, concrètement

1. Choisissez une tâche précise et répétitive de votre travail : classer, extraire ou reformuler.
2. Rassemblez vingt à cinquante exemples réels, avec la réponse que vous attendez.
3. Installez un des outils ci-dessus et téléchargez un modèle de trois à huit milliards de paramètres, en quantification à quatre ou huit bits.
4. Faites-le passer sur vos exemples et regardez les erreurs, pas seulement le taux de réussite.
5. Si cela ne suffit pas, essayez un modèle plus grand, ou un autre de même taille : l’écart entre modèles de taille comparable est parfois considérable.

Le bon modèle est le plus petit qui réussit votre tâche, mesuré sur vos données.

Ce qu’on gagne à cet exercice dépasse la question de l’IA locale. On apprend à écrire une tâche de façon vérifiable, à constituer un jeu d’exemples et à mesurer. C’est exactement la discipline qui sert aussi quand on revient ensuite à un grand modèle distant, parce qu’on sait alors ce qu’on lui demande et ce qu’on en attend.