← retour
Ne ratez plus rien.
Un email à chaque nouvel article, les annonces des formations à venir, rien d'autre. Les news complètes de la veille, les chiffres et les cadeaux sont réservés aux inscrits à l'Espace Abonnés.

Cet article existe aussi en anglais : lire la version anglaise.

Discutez de cet article avec votre IA
Le bouton copie l'article avec une courte introduction pour le modèle. Collez le tout dans Claude, ChatGPT, Le Chat ou une autre IA, puis posez-lui vos questions.

On descend d'un cran : #006 J'ai commencé à porter Olala, le modèle d'OVH

J'ai commencé à porter Olala, le modèle d'OVH, sur Herbert, mon moteur d'inférence. Les 36 couches d'Olala, annotées.

En bref

Le 19 novembre 2026, OVHcloud a publié Olala-v1.0-mini, un modèle de langage. Un modèle conçu en France, entraîné sur des supercalculateurs européens, avec ses poids ouverts sous licence open source Apache 2.0. Il est composé de 6,8 milliards de paramètres et il n'en utilise qu'un milliard environ pour écrire chaque token.

Et il a une particularité : aucun des moteurs habituels ne sait le faire tourner dans sa version officielle. OVH a donc publié ses propres moteurs pour son modèle : une version modifiée de Llama.cpp, une version de vLLM pour les serveurs et un portage pour MLX, le framework d'Apple.

Le soir même, j'ai commencé à le porter dans Herbert, mon moteur d'inférence. Il le fait tourner maintenant. Mais avant de vous montrer comment il se compare aux moteurs d'OVH, ce sera le prochain numéro, je voulais m'arrêter sur le modèle lui-même. On a un modèle français et franchement, le travail incroyable que font nos équipes en France vaut qu'on y passe du temps. D'autant que la technologie qu'ils ont employée est différente.

Le schéma d'Olala

Pour comprendre ce modèle, il faut regarder comment il est construit. Je vous ai fait un schéma, avec des numéros, pour s'y retrouver.

Olala-v1.0-mini-7A1B (OVHcloud) : 6,8 milliards de paramètres, environ 1 milliard actif par token IDs des tokens 1 Embedding 151 936 × 1536, normalisé : h part sur la sphère unité Bloc × 36 2 Mixeur Mamba-3 (M) : 29 blocs 3 ou attention (V) : 7 blocs 4 Résidu géodésique 5 MoE latent 256 experts, 6 actifs, + 1 partagé 4 Résidu géodésique aucune norme avant le mixeur ni avant le MoE pas de norme finale 6 Tête (lm_head) 1536 → 151 936, non liée à l'embedding logits 4 Résidu géodésique (deux par bloc) θ h h' La branche ne s'ajoute pas à h : elle le fait tourner sur la sphère. partie tangente θ ≤ π/4, divisé par (numéro du bloc + 1) la norme de h est conservée 2 Mixeur Mamba-3 MIMO (M) 48 têtes de 64, état 128, rang MIMO 4, pas de convolution 2.1 in_proj 1536 → 6288, par tête : z[64] x[64] dt A trap 2.2 in_proj_dyn 1536 → 1056 : B[4×128] C[4×128] angles[32] 2.3 Norme et rotation de B, C RMSNorm, puis 32 paires tournées d'un angle cumulé 2.4 État S par tête 64 × 128 en f32, mise à jour trapézoïdale : α·S + β·(token précédent) + γ·(token courant) 2.5 Lecture et porte o = S·q + D·v, puis × silu(z) 2.6 mixer_proj 3072 → 1536 3 Mixeur attention TPA différentielle (V) blocs 4, 9, 14, 19, 24, 29, 34 ; 48 têtes de 128 ; pas de RoPE ; fenêtre 32 768 3.1 Requêtes c_q : 1536 → 48 × 128 3.2 Clés et valeurs TPA produit de rang 4 : 12 têtes de 128 3.3 Décalage de token k et v mélangés à ceux du token précédent 3.4 Normes et softmax extensible RMSNorm de q et k ; q × ln(position + 1) 3.5 Scores ÷ 128, softcap 150, softmax 3.6 Différentiel par groupe de 4 : 3 têtes signal − λ × 1 tête bruit 3.7 Porte et mixer_proj × silu(gate_proj·h + 1,15), puis 4608 → 1536 5 MoE latent (dans chacun des 36 blocs) h 5.2 down_proj 1536 → 384 : l'espace latent 5.1 Routeur (f32) sigmoïde, top-6 sur 256 (+ biais pour le choix) 5.3 6 experts 384 → 768 → 384, ReLU² choix des 6 et leurs poids 5.4 Somme pondérée poids renormalisés × 2,45 5.5 up_proj 384 → 1536 5.6 Expert partagé fc_1 puis fc_2 : 1536 → 1536 → 1536, ReLU² + Les 36 blocs M 0 M 1 M 2 M 3 V 4 M 5 M 6 M 7 M 8 V 9 M 10 M 11 M 12 M 13 V 14 M 15 M 16 M 17 M 18 V 19 M 20 M 21 M 22 M 23 V 24 M 25 M 26 M 27 M 28 V 29 M 30 M 31 M 32 M 33 V 34 M 35 Mamba-3 (M) attention (V) matrice qui lit les valeurs aberrantes (jusqu'à ~1e14) : gardée en bf16 dans le --q4 d'Herbert (les quatre sur GPU, deux sur CPU) D'après config.json et modeling_olala.py, OVHaiLLM/Olala-v1.0-mini-7A1B sur Hugging Face (révision b40f816)

Le modèle se lit de haut en bas. Les tokens entrent dans l'embedding (repère 1), qui place le flux sur une sphère de rayon 1. Puis 36 blocs se suivent. Chacun a un mixeur, soit une couche Mamba-3 (repère 2, 29 blocs), soit une couche d'attention (repère 3, les blocs 4, 9, 14, 19, 24, 29 et 34), puis un mélange d'experts (repère 5). Après le mixeur et après les experts, le résultat ne s'ajoute pas au flux : il le fait tourner (repère 4). Les numéros d'étape du schéma (2.4, 3.6, 5.1, etc.) sont ceux que j'utilise dans la suite.

Un résumé au lieu d'une mémoire complète

Un modèle de langage classique écrit chaque token en regardant tous les tokens précédents. Il garde une trace de chacun d'eux, c'est ce qu'on appelle le cache. Plus le texte est long, plus ce cache grossit et plus chaque nouveau token coûte cher.

Olala fait autrement. Sur ses 36 couches, 29 sont des couches Mamba-3. Au lieu de tout garder, elles tiennent un résumé de taille fixe, mis à jour à chaque token.

Cette technologie est issue des travaux de deux chercheurs américains : Albert Gu, de l'université Carnegie Mellon, avec Tri Dao, de l'université de Princeton. Tri Dao, c'est aussi l'auteur de FlashAttention, une façon de calculer l'attention que presque tous les moteurs d'inférence utilisent. Leur premier Mamba date de fin 2023.

Mamba-3, publié en mars 2026, y ajoute trois choses.

La première : une mise à jour plus fine (étape 2.4). À chaque token, le résumé ne tient plus compte seulement du token qui arrive mais aussi de celui d'avant. C'est la différence entre mesurer une pente en un point et la mesurer entre deux points : le résumé suit le texte de plus près.

La deuxième : un état qui peut tourner (étape 2.3). Une partie des nombres du résumé sont rangés par paires et chaque paire pivote d'un petit angle à chaque token, comme l'aiguille d'une montre. Ça permet au modèle de suivre quelque chose qui change au fil du texte, une tâche où les modèles de ce type échouaient jusque-là.

La troisième : au lieu de lire et d'écrire son résumé une fois par token, chaque partie du modèle le fait 4 fois. Ce point compte pour un moteur : au décodage, le moteur passe son temps à attendre la mémoire. On peut donc calculer plus sur les mêmes octets, sans ralentir.

Dans Olala, chaque couche Mamba-3 a 48 têtes et le résumé d'une tête fait 64 × 128 valeurs.

Une couche sur cinq garde tout

Mais un résumé ne garde pas tout mot pour mot. Alors une couche sur cinq reste une couche d'attention classique, qui elle garde le passé exact. Et OVH y a empilé plusieurs idées récentes.

D'abord une attention dite différentielle, une idée de chercheurs de Microsoft publiée en 2024 (étape 3.6). Dans une attention classique, chaque token distribue son attention sur tous les tokens précédents et chacun en reçoit au moins un peu, même ceux qui n'ont rien à voir. Sur un long texte, ces miettes s'additionnent et finissent par noyer l'information utile. L'attention différentielle calcule deux répartitions et retire la seconde de la première, comme un casque qui annule le bruit ambiant. Dans Olala, les têtes d'attention travaillent par groupes de 4 : 3 têtes captent le signal et 1 tête capte le bruit qu'on soustrait.

Ensuite, des clés et des valeurs fabriquées à partir de petits vecteurs, une technique appelée TPA (étape 3.2).

Et aucune information de position. Une attention, par elle-même, ne sait pas dans quel ordre sont les tokens : pour elle, le texte est un sac de mots. Dans un transformer classique, on ajoute donc la position à la main : on fait tourner chaque clé et chaque requête d'un angle qui dépend de sa place dans le texte, c'est ce qu'on appelle RoPE. Olala n'en a pas. C'est Mamba, qui lit les tokens dans l'ordre, qui porte l'ordre du texte.

Enfin, sur un long texte, l'attention a tendance à se diluer sur trop de tokens. Olala multiplie donc la requête par le logarithme de la position du token, pour que l'attention reste aussi nette sur un long texte que sur un court (étape 3.4).

256 experts et un flux qui tourne

Après chaque couche, il y a 256 petits réseaux, les experts. Pour chaque token, une petite couche de neurones, le routeur, en choisit 6 (étape 5.1). Un 7e expert, dit partagé, travaille pour tous les tokens. C'est pour ça que le modèle ne relit qu'un milliard de poids par token au lieu de presque 7.

Et dernière particularité : dans la plupart des modèles, chaque couche ajoute son résultat au flux qui traverse le modèle. Ici, le flux reste toujours de la même longueur. Chaque couche le fait seulement tourner d'un petit angle.

D'où viennent ces idées

OVH le dit dans son rapport technique : l'équipe est partie d'un squelette hybride du type de Qwen3.5, puis a repris chaque élément du bloc (le mixeur, le réseau des experts, la normalisation) en testant les améliorations publiées sur un banc réduit, un modèle de 750 millions de paramètres entraîné sur 10 milliards de tokens. La nouveauté qu'ils revendiquent, c'est la combinaison. Les briques, elles, viennent toutes de papiers publics.

Mamba-3 (repère 2). Mamba (Gu et Dao, décembre 2023) remplace le cache qui grandit par un état de taille fixe : à chaque token, la couche décide ce qu'elle oublie et ce qu'elle écrit. Mamba-2 (mai 2024) montre que ce calcul peut s'écrire comme une forme d'attention, ce qui le rend rapide sur un GPU pendant le prefill. Mamba-3 (mars 2026) ajoute la mise à jour trapézoïdale, l'état qui tourne et la forme dite MIMO, de rang 4 dans Olala. Avant Mamba-3, la génération précédente d'OVH utilisait Gated DeltaNet (Yang, Kautz et Hatamizadeh, décembre 2024).

L'attention (repère 3). L'attention différentielle (Microsoft Research, octobre 2024) soustrait une répartition « bruit » d'une répartition « signal » ; Olala en prend la variante groupée (Lim et al., octobre 2025), 3 têtes signal pour 1 tête bruit. TPA (Zhang et al., janvier 2025) fabrique les clés et les valeurs comme des produits de rang 4. NoPE (Yang et al., janvier 2025) retire tout encodage de position. La softmax extensible (Nakanishi, janvier 2025) multiplie la requête par ln(position + 1) ; c'est le seul papier cité dans le code d'OVH. Avant l'attention, la clé et la valeur de chaque token sont mélangées à celles du token précédent (étape 3.3, d'après le Forgetting Transformer de Lin et al., mars 2025). Après, une porte peut presque couper la sortie d'une tête (étape 3.7, Qiu et al., mai 2025).

Les experts (repère 5). Le choix des 6 experts suit la recette de DeepSeek-V3 (décembre 2024) : un score par expert entre 0 et 1 et un petit biais par expert, appris pour répartir la charge, qui sert au choix sans changer les poids. Les experts sont dits latents, une idée de Nemotron 3 (NVIDIA, décembre 2025) : ils travaillent sur une version du flux réduite de 1 536 à 384 valeurs (étapes 5.2 et 5.5). Dans chaque expert, la fonction est un ReLU au carré (Primer, Google, septembre 2021).

La sphère (repères 1 et 4). nGPT (NVIDIA, octobre 2024) garde le flux sur la sphère de rayon 1. GeoNorm (Zheng et al., janvier 2026) remplace l'addition par une rotation le long de la sphère ; dans Olala, l'angle est borné à pi/4 et divisé par le numéro du bloc plus un.

Ce que ça demande à un moteur

Ce qui m'intéresse, moi, c'est ce que tout ça demande à un moteur pour le faire fonctionner. Et ça n'est pas trivial.

D'abord, deux sortes de couches à écrire au lieu d'une. Et aucune des deux n'est une couche qu'on trouve dans les moteurs habituels.

Ensuite, de la précision là où on ne l'attend pas. OVH le dit dans sa documentation : le résumé de Mamba doit rester en 32 bits. Le routeur aussi calcule en 32 bits. Quand il choisit ses 6 experts parmi 256, le 6e et le 7e sont parfois presque à égalité et du coup, l'ordre dans lequel on additionne les nombres peut suffire à faire basculer le choix.

Puis il y a ce logarithme de la position dans l'attention. Le modèle n'a pas de position, sauf là. Le moteur doit donc faire arriver la position du token jusqu'au calcul, à chaque token. S'il l'oublie, le résultat est faux.

Et ces rotations, celle du résumé de Mamba-3 comme celle du flux, il faut les calculer avec des sinus et des cosinus. Elles ont eu une incidence plutôt inattendue sur Herbert, à cause d'une facétie des cartes graphiques Intel que je n'avais pas vue venir. Je vous la raconte plus bas.

Et pour finir, OVH explique dans son rapport technique que pendant l'entraînement, trois couches Mamba-3 se sont emballées, avec des valeurs jusqu'à 10 puissance 16. Et c'est la rotation du flux qui a tout caché : au-delà d'un certain point, que la valeur soit 10 ou 10 puissance 16, la rotation est la même. Le modèle s'en moque.

Par contre, un moteur qui veut le compresser en 4 bits, non. C'est pour ça que j'en ai bavé et c'est sans doute aussi pour ça qu'OVH ne propose pas de version 4 bits pour Llama.cpp.

Ce que j'ai rencontré en le portant

Le token 18

Pour vérifier qu'Herbert calcule juste, je le compare à la référence, le code d'OVH exécuté dans transformers 5.8.1. Très vite, quelque chose clochait au 18e token de ma première question de test. Sauf que c'était la référence qui hésitait. Transformers a deux chemins pour ce modèle : sans cache, tout en 32 bits ; avec cache, où une partie de l'état de Mamba est gardée en 16 bits (bf16).

Au token 18, les deux chemins n'écrivent pas le même mot. J'ai pris le chemin tout en 32 bits comme référence et gardé l'état de Mamba en 32 bits dans Herbert, comme OVH le demande. Pas d'optimisation possible là : OVH prévient qu'avec un état en 16 bits, les longues générations finissent par tourner en boucle.

Ensuite, j'ai porté Olala sur mes moteurs CUDA et Vulkan. OVH ne propose pas de version Vulkan : avec ce portage, Olala tourne aussi sur les cartes graphiques AMD et Intel.

Et là, sur la carte NVIDIA comme avec Vulkan, au même token 18, Herbert n'écrivait plus le mot de ma référence. J'ai cherché un bogue. Sur la RTX 4080, j'ai regardé le routeur de l'avant-dernière couche, celui qui choisit les 6 experts. Il donne une note de 0,246511 à un expert et de 0,244879 à un autre : ce sont le 6e et le 7e, à 0,0016 l'un de l'autre. Herbert les voyait dans l'autre ordre, donc il ne choisissait pas le même 6e expert. Il n'y avait pas de bogue. Les deux experts sont presque à égalité et un écart d'arrondi sur la carte graphique suffit à faire basculer le choix. Je n'ai fait cette vérification que sur la carte NVIDIA. Avec Vulkan, Herbert écrit le même mot au même endroit, mais je ne suis pas allé regarder le routeur.

Des valeurs jusqu'à 3 × 10^16

J'ai voulu passer le modèle en 4 bits, comme je l'ai fait pour les autres. Sur Metal, le texte devenait faux dès le deuxième token. En testant les familles de matrices une par une, j'en ai trouvé quatre qui cassent le texte en 4 bits : mixer_proj, fc_2, output_experts et up_proj. Ensuite, en regardant les valeurs qui circulent dans le modèle, j'ai trouvé des nombres énormes. Je les ai mesurés en 16 bits sur deux questions de test, par deux chemins indépendants, le moteur processeur d'Herbert et le code d'OVH dans transformers, qui concordent à 6 % près au plus :

EndroitCoucheValeur maximale (Herbert / référence)
entrée de mixer_proj (sortie de Mamba-3)12,94e16 / 2,93e16
entrée de mixer_proj74,75e15 / 4,71e15
entrée de mixer_proj231,41e12 / 1,33e12
sortie d'up_proj des experts03,04e8 / 3,04e8
flux qui traverse le modèletoutes0,67 au plus

Les couches sont numérotées à partir de 0. Aucune valeur infinie. Le bf16 les représente toutes ; le f16, dont le maximum est 65 504, ne représente aucune des quatre premières. Ce sont les couches que cite le rapport d'OVH dans son annexe C. OVH l'explique avec beaucoup d'honnêteté : certaines têtes de Mamba-3 se sont collées à la borne de leur oubli et n'oublient plus rien. Leur lecture devient une somme sur tout le texte, qui grandit avec la position. La rotation du flux fait le reste, comme je l'expliquais plus haut : la valeur ne coûte rien à l'entraînement et ne se résorbe pas.

Pour Llama.cpp, OVH a d'ailleurs retiré sa version 4 bits : la fiche de son fichier pour Llama.cpp dit qu'un fichier Q4_K_M a été fabriqué, testé, puis retiré. Côté MLX, il y a bien un 4 bits. Les valeurs énormes n'expliquent pas tout : fc_2, qui sert l'expert partagé, ne reçoit que des valeurs sous 2,4 et casse le texte quand même. J'ai gardé ces quatre familles plus larges, en 16 ou en 8 bits selon le moteur. Le reste est quantifié. Ce n'est pas un modèle simple à quantifier. OVH le dit lui-même dans la fiche du modèle : les recettes de quantification génériques produisent des NaN, des valeurs qui ne sont plus des nombres, sur des entrées réalistes. Il conseille de prendre ses fichiers ou de suivre sa recette.

Le sinus du pilote Intel

Sur l'Arc 140V d'un portable Intel, sous Linux, un seul de mes tests échouait, de très peu. Il compare le calcul de l'état de Mamba-3 par morceaux au calcul token par token. L'écart était de 1,13e-3 pour une borne de 1e-3. Partout ailleurs, il passait avec de la marge.

J'ai sondé le sinus et le cosinus du pilote sur 65 536 points entre −pi et pi, contre un calcul en 64 bits sur le processeur. L'erreur maximale est de 3,40e-5 sur l'Arc, contre 3,3e-7 à 3,8e-7 sur la RTX 4080. C'est cent fois moins précis, mais ça reste dans la tolérance que la norme Vulkan autorise. Avec un sinus calculé par Herbert lui-même, le test passe sur l'Arc avec un écart de 1,14e-4. La borne n'était donc pas trop serrée.

Maintenant, au chargement, Herbert mesure la précision du sinus et du cosinus de la carte. Si l'erreur dépasse 1e-6, il les calcule lui-même. L'Arc prend ce chemin ; les autres cartes gardent celui du pilote et donnent les mêmes résultats qu'avant.

Un premier duel perdu

Quand tout a enfin tourné juste, j'ai fait un premier duel contre les moteurs d'OVH. Ils étaient plus rapides presque partout. C'est normal : ils travaillent sur leur modèle depuis bien plus longtemps que moi. Alors j'ai optimisé, moteur par moteur, en mesurant chaque essai. Herbert s'en sort plutôt bien, même s'il n'est pas devant partout. Les chiffres, ce sera pour le prochain numéro.

Ce qu'il sait faire : premiers tests

J'ai aussi commencé à regarder ce qu'il vaut sur deux tests publics. BFCL, le banc de Berkeley, mesure les appels d'outils : appeler la bonne fonction avec les bons arguments. IFEval, de Google, mesure le suivi d'instructions : écrire en moins de 100 mots, sans virgule, avec un titre, etc.

OVH présente Olala comme un petit modèle de raisonnement fait pour la conversation, le suivi d'instructions et les appels d'outils, entraîné spécialement à appeler des outils. Je voulais donc voir ce qu'il donne face à d'autres modèles de sa taille. C'est aussi une façon de vérifier mon implémentation sur de vraies tâches, au-delà de mes comparaisons avec la référence. OVH publie d'ailleurs ses propres scores sur BFCL, sur les 23 catégories (4 981 questions), avec un effort de raisonnement élevé : 59,6 pour Olala et 69,7 pour LFM2.5-8B-A1B. Mes 20 premiers tests par catégorie ne sont pas comparables à ces chiffres, mais l'écart va dans le même sens.

Je l'ai mis face à deux modèles de taille voisine : Gemma 4 E4B de Google et LFM2.5-8B-A1B de Liquid AI, un mélange d'experts comme Olala (8 milliards de paramètres, environ 1 milliard actifs).

Pour avancer vite, je me suis concentré sur les 20 premiers tests de chaque catégorie, les mêmes pour les trois modèles. Chaque modèle est dans ses meilleures conditions : en 16 bits (bf16), avec les réglages recommandés par son fabricant, 3 tirages différents par test et assez de place pour finir de raisonner (16 384 tokens). Aucune réponse n'a atteint cette limite. Les trois tournent sur le même Mac Studio (M3 Ultra), avec Herbert, le 22 novembre 2026 : le serveur d'Olala d'un côté, celui des deux autres modèles de l'autre.

En pourcentage de réponses justes, moyenne des 3 tirages :

OlalaGemma 4 E4BLFM2.5-8B-A1B
Appeler le bon outil avec les bons arguments (4 catégories de BFCL)749192
Ne pas appeler d'outil quand aucun ne convient10010097
Requêtes réelles envoyées par des utilisateurs (2 catégories « live »)717881
Suivre des consignes (IFEval, strict)978892

Le détail, en réponses justes sur 20, moyenne des 3 tirages :

CatégorieOlalaGemma 4 E4BLFM2.5-8B-A1B
un appel simple (simple_python)16,319,017,3
choisir parmi plusieurs outils (multiple)16,318,319,0
plusieurs appels à la fois (parallel)14,018,318,3
plusieurs appels parmi plusieurs outils (parallel_multiple)12,717,319,0
aucun outil ne convient (irrelevance)20,020,019,3
requête réelle, un outil (live_simple)17,016,017,7
requête réelle, plusieurs outils (live_multiple)11,315,314,7
IFEval19,317,718,3

Olala suit très bien les consignes et sait dire non quand aucun outil ne convient. Par contre, il décroche quand il faut appeler plusieurs outils à la fois : c'est là qu'il réfléchit le plus longtemps, 1 671 tokens par réponse en moyenne sur parallel et 1 429 sur parallel_multiple, contre 341 à 590 pour les deux autres. Sur ses 420 réponses à BFCL, 22 n'ont pas pu être lues comme un appel d'outil : 18 sont des réponses en texte, où il résout le problème lui-même ou repose une question. Les 4 autres sont des appels dont les arguments ne sont pas du JSON valide.

Et la vitesse ? Ce modèle est difficile à faire tourner, alors ça compte. Pour celui qui attend, le temps d'une réponse, c'est le nombre de tokens écrits multiplié par le temps de chacun :

OlalaGemma 4 E4BLFM2.5-8B-A1B
Tokens écrits par réponse, raisonnement compris993397551
Décodage, en tokens par seconde158 à 16353 à 57110 à 148
Temps moyen par réponse6,5 s7,4 s4,9 s

Olala écrit 2,5 fois plus de tokens que Gemma 4 E4B, mais Herbert le décode environ 3 fois plus vite. Ses questions sont aussi plus longues, de 1,6 à 7 fois selon la catégorie : son gabarit de conversation ajoute beaucoup de texte autour de la question, encore plus quand il décrit des outils. Il les lit à environ 3 700 tokens par seconde, ce qui garde le premier token entre 0,1 et 0,4 seconde. Ce sont les vitesses de mon moteur sur cette machine, pas celles des modèles en général.

Avant ce passage, j'en avais fait un premier sur les mêmes questions, avec Olala en 4 bits, en génération déterministe et une limite de 2 048 tokens (4 096 pour IFEval). 25 réponses sur 160 étaient coupées à la limite. Dans le passage ci-dessus, aucune. Olala y gagne dans toutes les catégories sauf irrelevance, déjà à 20. Sur ces 25 questions, 16 à 18 passent maintenant selon le tirage. Mais j'ai changé trois choses à la fois (le 16 bits, les réglages du fabricant et la place laissée au raisonnement) : je ne sais pas encore laquelle compte. Gemma 4 E4B et LFM2.5 bougent, eux, d'une ou deux réponses par catégorie.

Les limites

20 tests par catégorie, c'est peu : un test vaut 5 points. Sur IFEval et sur live_simple, les écarts entre tirages se chevauchent d'un modèle à l'autre : ce ne sont pas des différences.

Je n'applique pas la pénalité de répétition recommandée pour LFM2.5 (1,05) : Herbert ne l'a pas encore. Ses 5 réponses de plus de 4 096 tokens seraient peut-être plus courtes avec elle.

Le Gemma 4 E4B testé est le point de contrôle publié par Google en bf16 après un entraînement prévu pour le 4 bits (QAT), avec la réflexion activée. LFM2.5 raisonne toujours, son gabarit n'a pas d'interrupteur.

Le serveur d'Herbert réutilise le début des questions d'une requête à l'autre pour Gemma 4 E4B et LFM2.5, pas pour Olala. Les vitesses de lecture laissent de côté ces réponses ; le temps par réponse, lui, en profite.

Les scores viennent des correcteurs publics : bfcl-eval 2026.3.23 pour BFCL et celui de Google Research pour IFEval, sur le texte de la réponse seulement. Le moteur d'Herbert pour Olala n'est pas public pour l'instant.

Les papiers

Le point de départ est le rapport technique d'OVH, publié avec le modèle : Olala v1.0 mini Technical Report (OVHai LLM Research Team, 2026). C'est passionnant et un pari pour le moins audacieux de la part des équipes d'OVH. Moi j'adore et j'aimerais avoir plus de temps pour examiner tout ça au scalpel.

Mamba-3 (repère 2) :

L'attention (repère 3) :

Les experts (repère 5) :

La sphère (repères 1 et 4) :

Hors architecture : Bruno Mlodozeniec, Pierre Ablin, Louis Béthune et al., Completed Hyperparameter Transfer across Modules, Width, Depth, Batch and Duration, 26 décembre 2025, pour le passage des réglages du petit banc au modèle complet.

Les bancs : BFCL (Berkeley) et IFEval (Google, 2023).

La suite

Dans le prochain numéro, Herbert face aux moteurs d'OVH, sur leur propre modèle. Les mesures moteur par moteur et le code.

Et en parallèle, les tests continuent : les 100 premiers tests de chaque catégorie, avec LFM2 et LFM2.5 de Liquid AI et Gemma 4 E4B, sur plusieurs processeurs et cartes graphiques.

On descend d'un cran, ou plusieurs...

  1. On descend d'un cran : #000 un moteur d'inférence qui écrit son propre code · 03-oct-2026
  2. On descend d'un cran : #001 un compilateur pour moteur de LLM · 11-oct-2026
  3. On descend d'un cran : #002 le même compilateur sur un GPU · 18-oct-2026
    1. On descend d'un cran : #002.1 complément, l'Arc en f16 · 02-nov-2026
  4. On descend d'un cran : #003 ce que CUDA a et que Vulkan n'a pas · 25-oct-2026
  5. On descend d'un cran : #004 le même compilateur sur les puces d'Apple · 01-nov-2026
  6. On descend d'un cran : #005 Herbert meilleur que Llama.cpp ? · 15-nov-2026
  7. On descend d'un cran : #006 J'ai commencé à porter Olala, le modèle d'OVH · 22-nov-2026