# Les petits modèles de langage expliqués

> Ce qui rend un modèle de langage petit, ce que signifient les paramètres et les paramètres effectifs, pourquoi les petits modèles tiennent sur les téléphones et ce qu’ils sacrifient en capacités.

Source: https://ailoot.ai/blog/fr/small-language-models-explained/
Canonical: https://ailoot.ai/blog/fr/small-language-models-explained/
Language: fr
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-100072
Revision: sha256-6b67749526bfb03ac872b43fe5bb8f4b8f18a5335b7a50471c0df0cf278650b4


## Qu’est-ce qu’un petit modèle de langage ?

Un petit modèle de langage (SLM) est un modèle de langage suffisamment compact pour fonctionner sur du matériel courant, comme un téléphone ou un ordinateur portable, plutôt que dans un centre de données. Il n’existe pas de seuil convenu : les modèles qui comptent quelques milliards de paramètres ou moins sont généralement qualifiés de petits, et une étude de 2024 utilise une plage allant de 100 millions à 5 milliards.

Les petits et les grands modèles de langage fonctionnent de la même façon. Ce sont tous deux des réseaux neuronaux, presque toujours des transformeurs, entraînés à prédire le prochain jeton de texte. Tous deux sont adaptés après le préentraînement pour suivre des instructions ; l’étude mentionnée ci-dessus porte sur des transformeurs uniquement décodeurs de ce type précis. La différence tient à l’échelle. Un modèle assez petit pour un téléphone compte quelques milliards de paramètres, tandis que les modèles cloud de pointe sont bien plus grands. Un petit modèle contient donc moins de connaissances et dispose de capacités de raisonnement moindres (voir « Où les petits modèles atteignent-ils leurs limites ? »). Les petits modèles rendent l’IA sur l’appareil pratique.

La taille n’est pas le seul facteur qui influe sur la qualité. Celle d’un petit modèle dépend donc autant de son entraînement que de sa taille. Il peut apprendre d’un modèle plus grand par distillation, méthode qui consiste à l’entraîner à reproduire les sorties du grand modèle, et tirer profit de données soigneusement choisies : phi-1, un modèle de code de 1,3 milliard de paramètres entraîné en grande partie sur des données de « qualité manuelle », a obtenu 50.6% en pass@1 sur le benchmark de programmation HumanEval.

## Que signifient « paramètres » et « paramètres effectifs » ?

Les paramètres sont les nombres qu’un modèle apprend pendant l’entraînement, et leur nombre est la mesure habituelle de sa taille : « 1.7B » dans Qwen3 1.7B signifie environ 1,7 milliard. Les « paramètres effectifs », le « E » de Gemma 4 E2B et E4B de Google, désignent les paramètres utilisés dans les calculs du modèle et excluent les grandes tables d’embeddings, auxquelles le modèle accède uniquement par consultation.

La plupart des paramètres se trouvent dans les matrices de poids des couches d’attention et feed-forward d’un transformeur, que traverse chaque jeton. Un bloc distinct, les embeddings, associe à chaque jeton du vocabulaire un vecteur ; dans un petit modèle, il peut représenter une grande part du total. La table d’embeddings de Qwen3 1.7B compte 151,936 lignes (le vocabulaire configuré, complété au-delà des 151,669 entrées du tokenizer) de 2,048 dimensions, soit environ 311 millions de paramètres d’embedding. Ce chiffre concorde avec la fiche du modèle, qui indique 1,7 milliard de paramètres au total et 1,4 milliard hors embeddings 7. Les études de mise à l’échelle ne comptent souvent que les paramètres hors embeddings.

La série E de Gemma 4 pousse cette idée plus loin. La fiche du modèle de Google explique que « le “E” de E2B et E4B signifie “effective” » : les modèles utilisent les Per-Layer Embeddings (PLE), qui donnent « à chaque couche décodeur son propre petit embedding pour chaque jeton », et « ces tables d’embeddings sont volumineuses, mais ne servent qu’à des consultations rapides ; c’est pourquoi le nombre de paramètres effectifs est bien inférieur au total » 8. La fiche indique que Gemma 4 E2B compte 2,3 milliards de paramètres effectifs, ou 5,1 milliards avec les embeddings, et E4B respectivement 4,5 milliards de paramètres effectifs et 8 milliards avec les embeddings.

Cette distinction compte sur un téléphone, car les consultations nécessitent de la mémoire, mais peu de calcul, et l’environnement d’exécution peut laisser les tables dans le stockage. « Effectif » se distingue aussi de « actif » : Gemma 4 26B A4B est un modèle à mélange d’experts qui compte 25,2 milliards de paramètres, dont 3,8 milliards sont actifs pendant l’inférence 8.

## Pourquoi les petits modèles tiennent-ils sur les téléphones ?

Les poids d’un modèle occupent environ autant de mémoire que leur nombre de paramètres multiplié par le nombre de bits stockés par paramètre, puis divisé par huit. À 4 bits, 1,7 milliard de paramètres nécessitent environ 0,85 GB, ce qui laisse de la place pour Android et d’autres applications sur un téléphone doté de 4 GB de RAM.

Le nombre de paramètres et la précision sont les deux leviers. La figure 1 détaille le calcul pour Qwen3 1.7B, des nombres à virgule flottante sur 32 bits jusqu’au fichier de modèle sur 4 bits.

<figure id="la-fit">
<ol>
<li><strong>Stockés sous forme de nombres à virgule flottante sur 32 bits, 1,7 milliard de paramètres occupent 6,8 GB.</strong></li>
<li><strong>À 16 bits, ils occupent 3,4 GB.</strong></li>
<li><strong>À 8 bits, ils occupent 1,7 GB.</strong> Chaque division par deux du nombre de bits par poids divise par deux la mémoire nécessaire aux poids.</li>
<li><strong>À 4 bits, ils occupent environ 0,85 GB.</strong> Un demi-octet par poids rend un modèle de cette taille pratique sur un téléphone doté de 4 GB.</li>
<li><strong>Un fichier de modèle sur 4 bits peut être plus volumineux que les poids bruts.</strong> Les échelles de blocs et d’autres données stockées en augmentent la taille.</li>
</ol>
<figcaption>Figure 1. Mémoire nécessaire pour stocker les poids de Qwen3 1.7B en gigaoctets décimaux. Les barres bleues sont calculées comme suit : paramètres × bits ÷ 8 pour 1,7 milliard de paramètres, et ne comptent que les poids ; un modèle en cours d’exécution a également besoin de mémoire pour son cache clé-valeur et son environnement d’exécution. La barre orange représente le fichier du modèle téléchargé.</figcaption>
</figure>

| Précision | Bits par paramètre | Mémoire approximative des poids |
|---|---:|---:|
| Nombre à virgule flottante sur 32 bits | 32 | 6,8 GB |
| Nombre à virgule flottante sur 16 bits | 16 | 3,4 GB |
| Entier sur 8 bits | 8 | 1,7 GB |
| Entier sur 4 bits | 4 | 0,85 GB |

C’est pourquoi les modèles adaptés aux téléphones combinent quelques milliards de paramètres avec des poids sur 4 bits ou en précision mixte ; la quantification réduit l’espace de stockage nécessaire aux poids.

Les poids ne représentent pas toute l’empreinte mémoire. Un modèle en cours d’exécution a aussi besoin de mémoire pour son cache clé-valeur, qui augmente avec la longueur de la fenêtre de contexte, et pour son environnement d’exécution. La vitesse suit le même principe : chaque nouveau jeton nécessite de lire les poids du modèle depuis la mémoire. Avec moins de poids et des poids plus petits, les réponses sont donc plus rapides sur le même téléphone.

## Que font bien les petits modèles ?

Les petits modèles sont efficaces pour les tâches dont les informations nécessaires figurent dans l’invite ou relèvent de connaissances courantes : reformuler, résumer, rédiger des brouillons, expliquer et répondre à partir de passages fournis. Comme ils fonctionnent sur l’appareil, ils peuvent aussi répondre sans connexion réseau et sans envoyer l’invite à un serveur.

La fiche du modèle de Google décrit la famille Gemma 4 comme « bien adaptée au raisonnement, aux flux de travail agentiques, au codage et à la compréhension multimodale » ; E2B et E4B acceptent des entrées textuelles, visuelles et audio 8. Il s’agit des descriptions et des résultats de benchmark des développeurs eux-mêmes ; il reste à tester le fonctionnement d’une tâche donnée sur un téléphone donné.

Fournir les bons textes aide le modèle à répondre sur ce qu’il ne connaît pas. La génération augmentée par récupération ajoute des passages récupérés au moment de la question, afin que le modèle s’appuie sur des sources plutôt que sur sa mémoire. Les petits modèles sont aussi prévisibles à l’usage : aucun coût serveur par question, aucune file d’attente et aucune dépendance à une connexion après le téléchargement.

## Où les petits modèles atteignent-ils leurs limites ?

Les petits modèles contiennent moins de connaissances, sont moins performants pour les raisonnements longs ou en plusieurs étapes et gèrent moins bien les contextes longs que les modèles plus grands. Comme tous les modèles de langage, ils peuvent aussi énoncer des choses fausses avec aisance.

Cette tendance se retrouve au sein d’une même famille. Selon la fiche du modèle de Google, Gemma 4 E2B obtient 60.0% au benchmark de connaissances et de raisonnement MMLU Pro, et E4B 69.4%, contre 85.2% pour le modèle Gemma 4 de 31 milliards de paramètres. Au GPQA Diamond, un ensemble de questions de sciences de niveau universitaire supérieur, les scores sont de 43.4%, 58.6% et 84.3% 8. Ce sont les résultats de Google pour ses modèles.

Les petits modèles peuvent aussi se bloquer et se répéter. La fiche du modèle de Qwen avertit que le décodage glouton « peut entraîner une baisse des performances et des répétitions sans fin » 7.

## Pourquoi les petits modèles reprennent-ils la forme de leurs instructions ?

Les petits modèles ont tendance à imiter la forme d’une invite autant qu’à en suivre le contenu. Une invite système longue et structurée peut donc se retrouver sous forme de structure dans chaque réponse.

Une invite demandant au modèle de « commencer par la réponse directe, puis d’ajouter des détails utiles » a donné des réponses comportant des libellés en gras : « Réponse directe : » et « Détails utiles : ». L’instruction visait à donner un conseil sur le contenu ; le modèle l’a traitée comme un modèle de réponse.

## Comment fonctionnent les modes de réflexion dans les petits modèles ?

Un mode de réflexion fait écrire au modèle un raisonnement intermédiaire avant sa réponse finale. Il demande plus de temps et de jetons pour produire des résultats plus réfléchis sur les problèmes en plusieurs étapes. Qwen3 et Gemma 4 proposent tous deux cette fonction sous la forme d’un commutateur intégré à un même modèle, plutôt que d’un modèle de raisonnement distinct.

L’idée vient du prompting par chaîne de pensée. Les petits modèles récents sont entraînés à raisonner ; dans le cas de Qwen3, cet apprentissage repose en partie sur ses modèles plus grands.

Le commutateur fait partie de l’invite. Qwen3 1.7B réfléchit par défaut et écrit son raisonnement dans un bloc `<think>…</think>` ; les développeurs désactivent la réflexion à l’aide du paramètre `enable_thinking`, et les utilisateurs peuvent ajouter `/think` ou `/no_think` à un message pour changer de mode d’un tour à l’autre 7. Gemma 4 active la réflexion lorsque son invite système commence par un jeton `<|think|>` 8.

La réflexion consomme du temps et du contexte, car les jetons de raisonnement font partie de la sortie du modèle et occupent sa fenêtre. Lorsque le modèle est configuré pour l’exposer, le raisonnement apparaît avant la réponse, mais le comportement dépend du modèle et de l’application.

## Quelles différences entre Qwen3 1.7B, Gemma 4 E2B et Gemma 4 E4B ?

Ces trois modèles diffèrent par leur taille, leurs entrées et la longueur de leur contexte. Qwen3 1.7B compte 1,7 milliard de paramètres et n’accepte que du texte ; Google indique que Gemma 4 E2B et E4B comptent respectivement 2,3 et 4,5 milliards de paramètres effectifs et acceptent du texte, des images et de l’audio. Tous trois sont publiés sous licence Apache 2.0.

|  | Qwen3 1.7B | Gemma 4 E2B | Gemma 4 E4B |
|---|---|---|---|
| Développeur | Alibaba (équipe Qwen) | Google DeepMind | Google DeepMind |
| Paramètres | 1.7B, dont 1,4 milliard hors embeddings | 2,3B effectifs, 5,1B avec les embeddings | 4,5B effectifs, 8B avec les embeddings |
| Couches | 28 | 35 | 42 |
| Longueur du contexte | 32,768 jetons | 128K jetons | 128K jetons |
| Entrée | Texte | Texte, image, audio | Texte, image, audio |
| Mode de réflexion | Oui, activé par défaut | Oui | Oui |
| Licence | Apache 2.0 | Apache 2.0 | Apache 2.0 |

Tableau 1. Spécifications publiées dans la fiche du modèle Qwen3-1.7B de Qwen et la fiche du modèle Gemma 4 de Google, consultées le 5 octobre 2026 7 8.



## Références

7. Qwen. « Qwen3-1.7B. » Fiche du modèle et configuration, Hugging Face. Consultée le 5 octobre 2026. [huggingface.co/Qwen/Qwen3-1.7B](https://huggingface.co/Qwen/Qwen3-1.7B)
8. Google DeepMind. « Fiche du modèle Gemma 4. » Google AI for Developers. Consultée le 5 octobre 2026. [ai.google.dev/gemma/docs/core/model_card_4](https://ai.google.dev/gemma/docs/core/model_card_4)

## Mettez ce guide en pratique avec Ailoot

Connectez des modèles d’IA à vos applications, agents et automatisations via une seule API Ailoot. Choisissez le modèle adapté à votre tâche et suivez la [documentation Ailoot](https://ailoot.ai/docs/) pour commencer.

## Ailoot · L’entreprise et son portefeuille de projets

Ailoot s’appuie sur une expérience opérationnelle éprouvée, une large clientèle, un service stable et un suivi continu des KPI.

L’entreprise et son portefeuille de projets : des millions de clients ; des ventes qui se chiffrent en milliards chaque mois.

Ailoot met cette expérience opérationnelle au service de l’accès API aux fonctions d’IA dans les produits des clients, leurs agents, applications et automatisations.
