Petits modèles de langage : quand le compact bat le géant

Pendant des années, une équation simple a résumé le progrès de l'intelligence artificielle : plus de paramètres, plus de données, plus de puissance de calcul. Les modèles se comptaient en centaines de milliards de paramètres, tournaient dans des centres de données géants, et l'idée même d'exécuter une IA de bon niveau sur un téléphone relevait de la science-fiction. Puis, discrètement, une autre histoire s'est écrite. En avril 2024, Microsoft publiait Phi-3-mini, un modèle de 3,8 milliards de paramètres capable de rivaliser avec des modèles largement plus grands — et assez léger pour fonctionner sur un smartphone. Depuis, la famille des petits modèles de langage n'a cessé de s'enrichir. Bienvenue dans le monde des SLM, où le compact bat parfois le géant.

Cet article propose un tour d'horizon des petits modèles de langage (Small Language Models, ou SLM) tels qu'ils existent à l'été 2025. Nous verrons ce qui définit un « petit » modèle, pourquoi la taille n'est pas toujours synonyme de qualité, quelles familles de modèles dominent le paysage, et surtout dans quels cas d'usage la frugalité, la vitesse et la confidentialité l'emportent sur la puissance brute. L'objectif est pratique : vous donner une grille de lecture pour choisir, sans survente ni fascination pour le gigantisme, l'outil adapté à votre besoin réel.

Un mot de méthode d'abord. Le champ des SLM évolue vite et la définition même du « petit » se déplace au fil des mois. Nous nous appuierons sur des rapports techniques publics, des cartes de modèles vérifiables et des annonces officielles. Chaque chiffre cité est sourcé. Et si un fait n'est pas vérifiable, il n'apparaît pas dans ces lignes — c'est la règle de cette chronique.

Qu'est-ce qu'un petit modèle de langage, au juste ?

Commençons par le commencement. Il n'existe pas de frontière officielle et universelle entre « petit » et « grand » modèle. La communauté s'accorde toutefois sur un ordre de grandeur : on parle généralement de petit modèle de langage lorsque le nombre de paramètres se situe entre quelques centaines de millions et environ 7 milliards. En dessous, on trouve les modèles miniatures — quelques centaines de millions de paramètres, voire moins. Au-dessus, on entre dans le territoire des modèles moyens puis des grands modèles, qui se comptent en dizaines ou centaines de milliards de paramètres.

Cette borne haute autour de 7 milliards n'est pas arbitraire. Elle correspond au seuil en deçà duquel un modèle peut, moyennant quelques optimisations, tenir dans la mémoire d'un ordinateur portable récent, d'un smartphone haut de gamme ou d'un petit serveur équipé d'une seule carte graphique grand public. C'est cette faisabilité matérielle — faire tourner l'IA sans centre de données ni dépendance au cloud — qui donne tout leur sens aux SLM.

Techniquement, un petit modèle de langage reste un réseau de neurones de type transformer, entraîné à comprendre et à générer du langage naturel, exactement comme ses grands cousins. La différence n'est pas de nature, mais d'échelle. Et cette échelle réduite change tout, non seulement en matière de coût, mais aussi de possibilités de déploiement.

Trois catégories de taille pour se repérer

Pour clarifier le vocabulaire, on peut distinguer trois familles au sein de l'univers compact :

• Les modèles miniatures (de 100 millions à 1 milliard de paramètres environ) : conçus pour l'embarqué le plus contraint, l'Internet des objets, ou des tâches très spécialisées. Rapides et légers, mais aux capacités volontairement bornées.
• Les modèles compacts (de 1 à 4 milliards de paramètres environ) : le cœur de la catégorie SLM. Ce sont eux qui offrent le meilleur rapport entre polyvalence et frugalité, et qui tournent confortablement sur un téléphone ou un ordinateur portable.
• Les modèles légers de milieu de gamme (de 4 à 7 milliards de paramètres) : à la frontière entre SLM et modèles moyens. Plus capables, mais exigeant un peu plus de mémoire.

Cette taxonomie n'a rien d'officiel, mais elle aide à situer chaque annonce. Quand un laboratoire présente « un modèle de 3 milliards de paramètres qui tourne sur mobile », vous savez immédiatement dans quelle case le ranger et à quoi vous attendre.

Pourquoi la taille n'est plus le seul critère

L'intuition la plus répandue est que plus un modèle est gros, meilleur il est. Cette intuition a longtemps été juste, à l'époque où la principale façon de progresser consistait à empiler des paramètres. Mais les petits modèles récents ont démontré une chose importante : à taille donnée, la qualité des données d'entraînement et le raffinement de la méthode comptent au moins autant que le nombre de paramètres.

La leçon de Phi-3 : la qualité des données prime

Le cas Phi-3 de Microsoft est emblématique. Publié en avril 2024, Phi-3-mini affiche 3,8 milliards de paramètres et obtient 69 % au test MMLU — un score qui, selon la carte du modèle, rivalise avec celui de modèles bien plus imposants comme Mixtral 8x7B ou GPT-3.5. Le rapport technique de Microsoft est explicite sur l'origine de cette performance : l'innovation réside presque entièrement dans le jeu de données d'entraînement. Phi-3-mini a été entraîné sur 3 300 milliards de tokens, composés de données web fortement filtrées et de données synthétiques soigneusement construites.

Autrement dit, l'équipe n'a pas cherché à faire plus gros, mais à faire mieux : nourrir un modèle modeste avec des données de très haute qualité, à la manière d'un manuel scolaire bien conçu plutôt que d'un déversement indifférencié du web. Le titre du rapport technique résume l'ambition — « un modèle de langage très capable, en local sur votre téléphone ». Ce déplacement de la course à la taille vers la course à la qualité des données constitue l'un des enseignements majeurs de la vague SLM.

La performance d'un petit modèle ne se lit pas d'abord dans son nombre de paramètres, mais dans la qualité de ce qu'on lui a donné à apprendre.

Le rôle des techniques d'optimisation

Au-delà des données, plusieurs techniques permettent de tirer beaucoup d'un budget de paramètres réduit. La distillation consiste à faire apprendre à un petit modèle en imitant les productions d'un grand modèle « professeur » : le compact hérite d'une partie du savoir-faire du géant, pour une fraction du coût d'exécution. La quantification, elle, réduit la précision numérique des poids du modèle — par exemple de 16 bits à 4 bits — pour diviser l'empreinte mémoire et accélérer le calcul, avec une perte de qualité souvent minime lorsque c'est bien fait. Ces deux leviers, que nous détaillerons plus loin, expliquent en grande partie pourquoi les SLM actuels rendent des services qui auraient semblé hors de portée il y a peu.

Panorama des grandes familles de petits modèles

Le paysage des SLM s'est considérablement densifié en un peu plus d'un an. Passons en revue les principales familles disponibles à l'été 2025, avec leurs caractéristiques vérifiables. Toutes sont diffusées en poids ouverts, ce qui autorise leur usage local et leur adaptation.

Phi-3 et Phi-3.5 (Microsoft)

La famille Phi est la vitrine de l'approche « données de qualité ». Après Phi-3-mini (3,8 milliards de paramètres, avril 2024), Microsoft a enrichi la lignée en août 2024 avec Phi-3.5-mini-instruct. Ce dernier conserve les 3,8 milliards de paramètres mais gagne une fenêtre de contexte de 128 000 tokens et de nettes améliorations multilingues, couvrant une vingtaine de langues dont le français. Selon la carte du modèle, il a été entraîné sur 3 400 milliards de tokens à l'aide de 512 GPU H100 sur une dizaine de jours, entre juin et août 2024. Le tout est diffusé sous licence MIT, l'une des plus permissives pour un usage commercial.

Le contexte long de 128 000 tokens mérite d'être souligné : il rend Phi-3.5-mini apte à des tâches de résumé de longs documents, de questions-réponses sur des dossiers volumineux ou de récupération d'information dans de longs textes — le tout avec un modèle assez petit pour tourner localement.

Llama 3.2 1B et 3B (Meta)

Meta a rejoint la course au compact le 25 septembre 2024 avec Llama 3.2, dont les variantes légères 1B et 3B (uniquement textuelles) sont explicitement conçues pour l'embarqué et le mobile. Ces deux modèles supportent une fenêtre de contexte de 128 000 tokens et, selon l'annonce officielle de Meta, atteignent l'état de l'art dans leur catégorie pour des usages sur appareil comme le résumé, le suivi d'instructions et la reformulation, exécutés localement.

Meta précise que le modèle 3B surpasse les modèles Gemma 2 2,6B et Phi-3.5-mini sur des tâches comme le suivi d'instructions, le résumé, la reformulation de requêtes et l'usage d'outils, tandis que le 1B se montre compétitif avec Gemma. Détail industriel notable : ces modèles ont été activés dès le premier jour pour le matériel Qualcomm et MediaTek, et optimisés pour les processeurs Arm — le signe d'une volonté claire de déploiement sur téléphone.

Meta a également publié des versions quantifiées de ces modèles : selon le laboratoire, elles réduisent la taille du modèle de 56 % en moyenne par rapport au format d'origine, avec une accélération de deux à quatre fois à l'inférence. C'est une illustration parfaite de l'effet de la quantification, sur laquelle nous reviendrons.

Gemma 2 (Google)

Google décline sa famille de modèles ouverts Gemma, dérivée de la recherche à l'origine des modèles Gemini. Gemma 2, publié à la mi-2024, propose des variantes de 2, 9 et 27 milliards de paramètres. La plus petite, Gemma 2 2B, se destine explicitement aux environnements aux ressources limitées — ordinateur portable, poste de bureau ou infrastructure cloud modeste. Selon la carte du modèle, elle a été entraînée sur 2 000 milliards de tokens et utilise un vocabulaire de 256 000 entrées. Comme ses cousins, Gemma se prête bien aux tâches de génération de texte : questions-réponses, résumé, raisonnement léger.

Qwen2.5 (Alibaba)

La famille Qwen2.5, annoncée par Alibaba Cloud en septembre 2024, se distingue par son ampleur : plus d'une centaine de modèles publiés d'un coup, en variantes de base et instruites, sur sept tailles de paramètres — 0,5, 1,5, 3, 7, 14, 32 et 72 milliards — auxquelles s'ajoutent des variantes spécialisées pour le code et les mathématiques, ainsi que des versions quantifiées. L'ensemble a été pré-entraîné sur 18 000 milliards de tokens.

Pour ce qui concerne le compact, les modèles Qwen2.5 de 0,5B, 1,5B et 3B maintiennent de solides performances sur la quasi-totalité des tests. Fait remarquable relevé dans le rapport technique : le modèle Qwen2.5-0,5B dépasse Gemma 2 2,6B sur plusieurs tests de mathématiques — une démonstration que, à conception soignée, un modèle deux fois plus petit peut battre un concurrent sur un domaine donné. Les modèles jusqu'à 3 milliards de paramètres traitent des contextes de 32 000 tokens. La plupart sont disponibles sous licence Apache 2.0 pour un usage commercial.

SmolLM (Hugging Face)

À l'autre extrémité du spectre, Hugging Face a publié en juillet 2024 la série SmolLM, en trois tailles miniatures : 135, 360 millions et 1,7 milliard de paramètres. Ces modèles visent explicitement l'IA sur appareil, avec de faibles coûts de calcul et une meilleure confidentialité. Leur intérêt tient à leur jeu de données, baptisé SmolLM-Corpus : un mélange soigneusement curé de manuels et d'histoires synthétiques, d'exemples de code Python éducatif et de contenu web éducatif filtré. Le modèle 1,7B a été entraîné sur 1 000 milliards de tokens, les plus petits sur 600 milliards. C'est une nouvelle confirmation, à très petite échelle cette fois, que la qualité du corpus fait la différence.

Modèle	Paramètres	Éditeur	Sortie	Contexte
SmolLM	135M – 1,7B	Hugging Face	Juil. 2024	2K
Gemma 2 2B	2,6B	Google	Mi-2024	8K
Llama 3.2	1B / 3B	Meta	Sept. 2024	128K
Phi-3.5-mini	3,8B	Microsoft	Août 2024	128K
Qwen2.5	0,5B – 3B	Alibaba	Sept. 2024	32K

Les quatre atouts concrets des petits modèles

Pourquoi choisir un petit modèle plutôt qu'un géant accessible en un appel d'API ? La réponse tient en quatre bénéfices tangibles, régulièrement mis en avant dans la littérature technique.

Le coût

C'est souvent l'argument décisif. La tarification des API de grands modèles s'établissait, à l'été 2025, dans une fourchette de l'ordre de 0,01 à 0,10 dollar pour 1 000 tokens (chiffre indicatif à cette date, susceptible d'évoluer rapidement). À l'échelle, l'addition grimpe vite : un système de support client traitant 100 000 requêtes par jour peut atteindre plusieurs dizaines de milliers de dollars mensuels de coûts d'API. À l'inverse, un SLM exécuté sur un unique serveur GPU coûte le même prix matériel qu'il traite 10 000 ou 10 millions de requêtes. Le modèle économique bascule : d'un coût variable qui croît avec l'usage, on passe à un coût fixe amorti sur le volume. Pour une application à fort trafic et à tâche bien cadrée, l'écart peut être considérable.

La latence

Un modèle qui tourne localement n'a pas à envoyer la requête vers un serveur distant, attendre le traitement, puis recevoir la réponse. Les SLM exécutés en local répondent typiquement en 50 à 200 millisecondes, selon les analyses de déploiement sur appareil. Cette réactivité en temps réel change la nature de l'expérience : autocomplétion fluide, assistance conversationnelle instantanée, traitement à la volée sans dépendance au réseau. Pour tout usage interactif, la latence perçue fait souvent plus pour la satisfaction que le dernier point de score sur un test.

La confidentialité

C'est un atout majeur à l'heure du RGPD et de la souveraineté des données. Exécuter un modèle sur appareil ou sur une infrastructure interne signifie que les données sensibles ne quittent jamais l'environnement sécurisé de l'organisation. Pour un cabinet médical, un service juridique ou toute structure manipulant des informations personnelles, cette garantie n'est pas un détail : elle peut conditionner la faisabilité même du projet. Les petits modèles rendent cette approche « sur site » réaliste, là où un grand modèle imposerait le recours au cloud.

La frugalité énergétique et matérielle

Moins de paramètres, c'est moins de calcul, donc moins d'énergie consommée par requête et une empreinte matérielle réduite. Les entreprises déploient déjà des SLM sur smartphones, objets connectés, drones et systèmes embarqués pour réduire la latence, garder la maîtrise des données et abaisser la consommation d'énergie. Dans un contexte où la sobriété devient un critère de conception à part entière, cette frugalité constitue un argument qui dépasse la seule question du coût.

La bonne question n'est pas « quel est le modèle le plus puissant ? » mais « quel est le plus petit modèle qui résout mon problème ? » — et l'éventail des réponses n'a jamais été aussi large.

Les techniques qui rendent le compact possible

Si les petits modèles rendent aujourd'hui de tels services, c'est aussi grâce à un ensemble de techniques d'optimisation qui maximisent chaque paramètre. Trois d'entre elles méritent qu'on s'y arrête.

La distillation de connaissances

La distillation consiste à transférer le savoir-faire d'un grand modèle « professeur » vers un petit modèle « élève ». En pratique, on fait produire au grand modèle un grand nombre d'exemples — réponses, raisonnements, formulations — puis on entraîne le petit modèle à imiter ces productions. Le petit n'égale pas le professeur sur tout, mais il en hérite l'essentiel du comportement pour les tâches visées, à une fraction du coût d'exécution. Cette approche est devenue une brique standard de la fabrication des SLM performants : elle explique pourquoi un modèle compact bien distillé peut se comporter très au-dessus de ce que sa taille laisserait attendre.

La quantification

La quantification réduit la précision numérique avec laquelle les poids du modèle sont stockés. Un modèle est habituellement entraîné en 16 ou 32 bits par paramètre ; on peut ensuite le convertir en 8, 4, voire 2 bits. À chaque division par deux de la précision, l'empreinte mémoire diminue d'autant et les calculs s'accélèrent. Le cas des versions quantifiées de Llama 3.2 est éclairant : Meta annonce une réduction de taille de 56 % en moyenne et une accélération de deux à quatre fois à l'inférence. Apple pousse la logique jusqu'à une quantification mixte 2 et 4 bits par poids (une moyenne de 3,7 bits par poids, selon sa documentation), obtenue par entraînement conscient de la quantification, pour son modèle embarqué, afin de faire tenir un modèle capable dans la mémoire d'un iPhone. Bien conduite, la quantification préserve l'essentiel de la qualité tout en rendant le modèle exécutable sur du matériel modeste.

Les adaptateurs légers

Plutôt que de spécialiser un modèle entier pour chaque tâche — ce qui multiplierait les copies volumineuses —, on peut lui greffer de petits modules d'adaptation. L'exemple d'Apple Intelligence est parlant : pour son modèle embarqué d'environ 3 milliards de paramètres, les adaptateurs de rang 16 ne pèsent que quelques dizaines de méga-octets et peuvent être chargés dynamiquement, mis en cache temporairement puis échangés. Le modèle se spécialise ainsi à la volée pour la tâche du moment — écrire, résumer, reformuler — tout en gérant efficacement sa mémoire. C'est une façon élégante de rendre un petit modèle polyvalent sans gonfler son empreinte.

Où le compact bat le géant : les bons cas d'usage

Un petit modèle ne remplace pas un grand sur toutes les tâches — et ce n'est pas son but. La sagesse consiste à identifier les situations où ses atouts (coût, latence, confidentialité, frugalité) l'emportent sur la puissance brute. En voici les principales.

Les tâches bien cadrées et répétitives

Résumé, reformulation, classification, extraction d'information, correction de texte, suivi d'instructions simples : sur ces tâches au périmètre défini, un modèle compact bien entraîné offre un rapport qualité-coût très favorable. C'est précisément le terrain que Meta revendique pour Llama 3.2 3B, présenté comme état de l'art dans sa catégorie pour le résumé, le suivi d'instructions et la reformulation sur appareil. Inutile de mobiliser un géant pour reformuler un courriel ou résumer une réunion.

Les applications sur appareil et hors ligne

Dès que l'application doit fonctionner sans connexion fiable, ou traiter des données qui ne doivent pas quitter l'appareil, le SLM devient la seule option raisonnable. Assistants de saisie, fonctions d'écriture intégrées au système d'exploitation, traitement embarqué dans un objet connecté : ces usages exigent un modèle local. Le déploiement d'Apple Intelligence sur iPhone, avec son modèle d'environ 3 milliards de paramètres dédié à l'écriture, au résumé de notifications et aux actions dans les applications, illustre parfaitement ce créneau.

Les déploiements à fort volume et coût maîtrisé

Quand une même tâche se répète des millions de fois — modération, tri de messages, étiquetage, première ligne de support —, le passage d'un coût variable par appel d'API à un coût fixe d'infrastructure change l'équation économique. Un SLM auto-hébergé, éventuellement spécialisé par fine-tuning sur le domaine, absorbe le volume sans que la facture n'explose. C'est l'un des arguments les plus solides en faveur du compact dès qu'on raisonne à l'échelle.

Les architectures collaboratives grand modèle plus petit modèle

La littérature récente explore des architectures où petits et grands modèles coopèrent plutôt que de s'opposer. Le petit modèle, rapide et local, traite la majorité des requêtes simples et ne fait appel au grand modèle, plus coûteux, que pour les cas difficiles. Cette répartition — le compact en première ligne, le géant en renfort — optimise à la fois le coût, la latence et la confidentialité, tout en préservant la qualité sur les cas complexes. C'est sans doute l'une des tendances de fond les plus prometteuses pour les déploiements d'envergure.

Les limites à garder en tête

La rigueur impose de ne pas céder à l'enthousiasme aveugle. Les petits modèles ont de vraies limites, qu'il faut connaître pour les employer à bon escient.

D'abord, l'étendue des connaissances. Un modèle compact a mécaniquement mémorisé moins de faits qu'un géant : sur des questions de culture générale pointue ou de connaissances de niche, il se trompe plus souvent. La parade classique consiste à le coupler à une base documentaire via un système de récupération d'information, afin de compenser sa moindre mémoire par un accès à des sources externes.

Ensuite, le raisonnement complexe. Sur les enchaînements logiques longs, les problèmes mathématiques exigeants ou les tâches multi-étapes, les grands modèles conservent un avantage. Les petits progressent — la distillation leur transmet une partie du savoir-faire de raisonnement —, mais l'écart n'est pas nul. Il faut donc tester sur ses propres cas d'usage plutôt que de se fier à un score global de test.

Enfin, la subtilité et la nuance. Pour la rédaction créative de haut vol, les échanges conversationnels très ouverts ou la gestion de consignes ambiguës, un grand modèle offre généralement une finesse supérieure. Le choix d'un SLM doit donc s'accompagner d'une évaluation honnête : le gain en coût, latence et confidentialité justifie-t-il la légère baisse de capacité sur ma tâche précise ? Pour beaucoup d'applications, la réponse est oui. Pour d'autres, non — et c'est très bien ainsi.

Un petit modèle n'est pas un grand modèle au rabais : c'est un outil différent, taillé pour des contraintes différentes. Le bon réflexe est de choisir selon le besoin, pas selon la fascination pour la taille.

Comment choisir en pratique

Passons du panorama à la méthode. Face à un besoin concret, comment décider si un petit modèle convient, et lequel ? Voici une démarche pragmatique, applicable dès aujourd'hui.

Première étape : définir précisément la tâche. Plus le périmètre est étroit et bien spécifié — résumer des comptes rendus, classer des tickets, reformuler des messages —, plus un SLM a de chances de suffire. À l'inverse, un besoin ouvert et généraliste tirera vers un modèle plus grand.

Deuxième étape : identifier les contraintes dures. Les données doivent-elles rester sur site pour des raisons réglementaires ? L'application doit-elle fonctionner hors ligne ? Le volume est-il tel que le coût par appel d'API deviendrait prohibitif ? Chaque « oui » renforce la pertinence du compact.

Troisième étape : partir du plus petit modèle plausible. La bonne pratique consiste à tester d'abord le plus petit modèle capable de tenir la tâche, puis à monter en taille seulement si la qualité l'exige. On évite ainsi de surdimensionner — et de payer — pour une puissance inutile. Un Qwen2.5-1,5B ou un Llama 3.2 3B suffisent bien plus souvent qu'on ne le croit.

Quatrième étape : envisager la spécialisation. Un petit modèle affiné (fine-tuné) sur le domaine cible, ou couplé à une base documentaire, peut dépasser un grand modèle généraliste sur cette tâche précise, tout en restant frugal. La spécialisation est souvent le chemin le plus court vers la qualité à moindre coût.

Cinquième étape : mesurer sur ses propres données. Aucun classement public ne remplace un test sur vos cas réels. Constituez un petit jeu d'évaluation représentatif, comparez deux ou trois candidats, et laissez les résultats décider. C'est la seule façon fiable de trancher.

Un marché et une dynamique en pleine expansion

La montée des petits modèles n'est pas un phénomène anecdotique. Selon les projections de marché, le segment des SLM connaît une croissance vive, portée par la demande d'IA embarquée, frugale et respectueuse de la vie privée. Les analystes anticipent des modèles de plus en plus adaptatifs et économes en énergie, à mesure que progressent l'accélération matérielle et les architectures conçues nativement pour l'edge.

Cette dynamique s'explique par une convergence d'intérêts. Les entreprises y voient une façon de maîtriser leurs coûts et de garder la main sur leurs données. Les fabricants de puces mobiles — Qualcomm, MediaTek, Apple, Arm — y trouvent un argument pour valoriser leurs processeurs. Les communautés open source, elles, apprécient des modèles assez légers pour être réutilisés, ajustés et améliorés sans infrastructure démesurée. Le fait que la plupart de ces modèles soient diffusés sous des licences permissives — MIT pour Phi, Apache 2.0 pour une large part de Qwen2.5 — nourrit encore cette diffusion.

On assiste ainsi à un rééquilibrage salutaire. Après des années dominées par la course au gigantisme, l'industrie redécouvre la valeur de l'efficacité : faire autant, sinon mieux, avec beaucoup moins. Ce déplacement du centre de gravité rouvre le jeu à des équipes qui n'ont pas les moyens des plus grands laboratoires, et rapproche l'IA du terrain — sur l'appareil, dans la poche, au plus près de l'usage.

Ce qu'il faut retenir

Que retenir de ce tour d'horizon ? D'abord, que le petit modèle de langage n'est pas une version dégradée du grand, mais un outil de plein droit, taillé pour des contraintes spécifiques. Sa raison d'être tient en quatre mots : coût, latence, confidentialité, frugalité. Là où ces critères pèsent, le compact l'emporte souvent sur le géant.

Ensuite, que la taille a cessé d'être le seul déterminant de la qualité. La leçon de Phi-3 — la qualité des données d'entraînement prime sur le nombre de paramètres — et celle de Qwen2.5 — un modèle deux fois plus petit peut battre un concurrent sur un domaine donné — invitent à juger un modèle sur ses résultats réels, pas sur sa fiche technique. Les techniques d'optimisation, distillation et quantification en tête, ont fait le reste : elles permettent aujourd'hui de faire tenir une IA capable dans un téléphone.

Enfin, que la bonne démarche est méthodique et sans dogme. Définir la tâche, cerner les contraintes, partir du plus petit modèle plausible, envisager la spécialisation, mesurer sur ses propres données : cette discipline vaut mieux que toute fascination pour le dernier géant à la mode. La question utile n'est pas « quel est le meilleur modèle du monde ? », mais « quel est le plus petit modèle qui résout mon problème ? ». À l'été 2025, avec les familles Phi, Llama 3.2, Gemma 2, Qwen2.5 ou SmolLM, l'éventail des réponses n'a jamais été aussi riche — ni aussi accessible. Le compact a gagné sa place, et il ne compte pas la céder.

Sources

Cet article s'appuie sur des sources techniques publiques et vérifiables :

• Microsoft Research, « Phi-3 Technical Report: A Highly Capable Language Model Locally on Your Phone » — arXiv 2404.14219 (Phi-3-mini, 3,8B, MMLU 69 %, données d'entraînement).
• Microsoft, carte du modèle Phi-3.5-mini-instruct — Hugging Face (128K de contexte, 3,4T tokens, licence MIT, multilingue).
• Meta AI, « Llama 3.2: Revolutionizing edge AI and vision with open, customizable models » — ai.meta.com (1B/3B, 128K, comparaison Gemma 2 et Phi-3.5).
• Meta AI, « Introducing quantized Llama models with increased speed and a reduced memory footprint » — ai.meta.com (réduction de taille 56 %, accélération 2 à 4x).
• Google, carte du modèle Gemma 2 2B — Hugging Face (2,6B, 2T tokens, environnements à ressources limitées).
• Alibaba Cloud, « Qwen2.5: A Party of Foundation Models! » — alibabacloud.com (tailles 0,5B à 72B, 18T tokens, Qwen2.5-0,5B vs Gemma 2).
• Hugging Face, « SmolLM: blazingly fast and remarkably powerful » — huggingface.co/blog/smollm (135M/360M/1,7B, SmolLM-Corpus).
• Apple Machine Learning Research, « Introducing Apple's On-Device and Server Foundation Models » — machinelearning.apple.com (modèle embarqué ~3B, quantification 2 bits, adaptateurs).
• MarketsandMarkets, « Small Language Model Market Report » — marketsandmarkets.com (croissance du marché SLM, edge, confidentialité).