Le son résiste

En 2025, la plupart des assistants vocaux ne comprennent pas vraiment la voix. Ils transcrivent, réfléchissent en texte, puis lisent leur réponse à voix haute. C’est efficace, mais c’est un emballage autour d’un modèle de texte, pas une écoute.

Volhejn propose un test cruel : parlez à un modèle nativement audio avec une voix très aiguë, et demandez-lui si votre voix est grave ou aiguë. Aucun ne sait répondre. L’information était pourtant dans le signal.

Du côté du texte, tout est réglé depuis longtemps. En 2015 déjà, Karpathy entraînait un réseau récurrent de trois couches sur un seul GPU et obtenait du code et du LaTeX plausibles, caractère par caractère.

Le son ne se laisse pas faire, et la raison tient en un nombre. Dix secondes d’audio, c’est 160 000 échantillons. WaveNet les prédit un par un : le résultat sonne comme une vraie voix humaine, avec le bon grain et la bonne respiration, mais ne produit presque jamais un mot correct.

Volhejn mène l’expérience naïve jusqu’au bout, en donnant du son brut à nanoGPT. Deux chiffres suffisent à expliquer l’échec : la fenêtre de contexte de 2 048 jetons représente 128 millisecondes — le modèle ne voit même pas un mot entier — et générer dix secondes demande trente minutes sur une H100.

Le texte, c’est une boîte de LEGO : les briques existent déjà, en nombre limité, on assemble. Le son, c’est du sable. Chaque grain ne veut rien dire tout seul, et pour écrire le mot bonjour il faut en placer seize mille par seconde.

La conclusion est immédiate : il faut réduire le nombre de décisions. Il faut compresser.

Comprimer avant de modéliser

L’outil qui comprime et décomprime s’appelle un codec audio neuronal. Le mot est emprunté au MP3, mais ici il désigne simplement un découpeur de son en jetons.

L’autoencodeur

Personne ne dit au modèle ce qu’il doit mettre dans son résumé. Il doit le découvrir seul, sous la contrainte que le résumé est trop petit pour tout contenir.

On vous demande de résumer un roman de trois cents pages sur une fiche bristol. Puis on donne votre fiche à quelqu’un qui doit réécrire le roman entier. Si le résultat ressemble à l’original, c’est que votre fiche contenait ce qui compte.

Pourquoi il faut quantifier

Un autoencodeur ordinaire produit des nombres à virgule, en quantité infinie. Un modèle de langage ne sait pas faire ça : il sait choisir un élément dans une liste finie. Il lui faut un vocabulaire.

On ne vous donne pas de la peinture liquide, mais une boîte de 1 024 crayons numérotés. Vous perdez un peu de fidélité, mais vous pouvez désormais décrire votre dessin entier au téléphone, en récitant une suite de numéros.

Les centres ne sont pas décidés à l’avance : ils sont appris, par une procédure proche des k-moyennes. Et il y a un détail malin — si un centre n’est utilisé par personne pendant un moment, on le téléporte à la position d’un vecteur pris au hasard. Sans cela, un centre mal placé au départ resterait mort à jamais.

L’estimateur direct, ou le mensonge assumé

Voici le vrai obstacle. On veut quantifier pendant l’entraînement, pour que l’encodeur apprenne à produire des vecteurs faciles à arrondir :

z = encoder(x)
z_quantized = to_nearest_cluster(z)          # on arrondit
loss = reconstruction_loss(x, decoder(z_quantized))

Mais prendre le centre le plus proche n’est pas dérivable. Aucun gradient ne remonte jusqu’à l’encodeur. La solution est d’une honnêteté rafraîchissante : on règle le problème en faisant comme s’il n’existait pas.

residual = z - to_nearest_cluster(z)
z_quantized = z - residual.detach()          # .detach() : oublie le gradient

À l’aller, la valeur transmise au décodeur est exactement la même. Au retour, le gradient traverse l’arrondi comme s’il n’était pas là. C’est l’estimateur direct.

Ce raisonnement ne tient que si les vecteurs restent proches de leur centre. On ajoute donc une pénalité proportionnelle à cette distance : la perte d’engagement. L’ensemble s’appelle un VQ-VAE — dont le variationnel est un vestige historique qui ne signifie plus rien.

Ce qui casse quand on retire chaque pièce

Voilà ma part du travail. J’ai entraîné un VQ-VAE en dimension latente 2 sur trois classes de Fashion MNIST, puis j’ai désactivé chaque mécanisme, un par un.

Trois lectures.

L’estimateur direct est le mécanisme indispensable. Sans lui, l’erreur est multipliée par 2,5. C’est cohérent : l’encodeur n’apprend plus que par la perte d’engagement, ce qui est un signal bien plus pauvre.

La téléportation ne change presque rien à l’erreur, mais tue un quart du codebook. Vingt-quatre centres sur trente-deux. C’est exactement le symptôme annoncé : un centre jamais choisi ne reçoit aucune mise à jour, donc ne bouge pas, donc ne sera jamais choisi. Le coût est invisible dans la MSE et bien réel dans le débit — on paie huit centres pour rien.

La perte d’engagement se voit surtout dans la perplexité, qui tombe de 25 à 16. L’erreur bouge peu, mais le codebook est nettement moins bien réparti.

La quantification résiduelle

Pour gagner en fidélité, on pourrait augmenter le nombre de centres. Mais il faut comparer chaque vecteur à chacun d’eux, et ça devient vite prohibitif.

L’astuce est combinatoire. Plutôt qu’un million de centres, on en crée deux ensembles de 1 024. Chaque vecteur est décrit par un couple d’entiers, ce qui donne plus d’un million de combinaisons pour seulement 2 048 centres stockés.

Pour identifier tous les élèves d’une école, on n’invente pas un identifiant par élève : on combine un prénom et un nom.

Reste à savoir comment répartir l’information. La réponse est déjà dans le code plus haut, sous le nom de résidu : l’écart entre le vecteur exact et sa version arrondie, c’est-à-dire ce que le premier arrondi n’a pas su capturer. On le quantifie à son tour, puis on quantifie le résidu du résidu.

Une balance à plateaux. Pour peser 780 g, vous posez le poids de 500 g, il manque 280 g ; celui de 200 g, il manque 80 g ; puis 50, puis 20, puis 10. Chaque poids ne corrige pas le total, il corrige l’erreur des précédents. Et vous vous arrêtez quand la précision vous suffit.

Sur mes images, quatre niveaux de 64 centres donnent ceci :

Le résidu est divisé par 700 entre le début et la fin, et chaque niveau rapporte environ la moitié du gain précédent. C’est la signature d’une RVQ en bonne santé — je vais y revenir longuement dans l’article suivant, parce que c’est précisément cette signature qui m’a manqué pendant des heures.

Une limite à garder en tête : la qualité maximale reste celle de la reconstruction sans quantification du tout. Si l’autoencodeur est mauvais, aucune quantification ne le sauvera. On améliore d’abord l’autoencodeur.

L’idée n’est pas neuve — SoundStream l’a appliquée aux codecs audio en 2021, et elle circule dans le traitement du signal depuis les années quatre-vingt.

Le multi-niveaux n’a pas de réponse canonique

Avec un codec à huit niveaux, chaque extrait devient un tableau à deux dimensions : le temps d’un côté, les niveaux de l’autre. Or un modèle de langage attend une seule file. Comment gérer huit jetons par instant ?

En 2025, aucune ne s’est imposée. Pour qui débute, c’est une bonne nouvelle : il n’y a pas de solution canonique qu’on serait censé connaître, il y a un espace de conception encore ouvert.

Mimi, et le jeton qui porte le sens

Quatre années de recherche ont produit bien mieux que le codec artisanal. Mimi, développé chez Kyutai pour Moshi, apporte trois choses.

Une perte adverse plutôt que spectrale : un discriminateur apprend à repérer les reconstructions, le codec apprend à le tromper. Comme le juge s’améliore en même temps que l’élève, il n’y a pas de recette figée à exploiter.

Un abandon aléatoire de niveaux pendant l’entraînement — le RVQ dropout. Le codec apprend à ne pas dépendre de tous ses niveaux, et l’on peut donc tronquer librement à l’usage. J’ai mesuré ce que ça coûte : avec dropout, 0,01688 de MSE à quatre niveaux ; sans, 0,01560. On paie environ 8 % de qualité pour la liberté de tronquer. Sans lui, il faudrait réentraîner un modèle par nombre de niveaux.

Et surtout 12,5 vecteurs par seconde au lieu de 125, soit dix fois moins. Le corpus de 10 000 heures tombe de 134 Go à 54 Go. À fenêtre de contexte égale, le modèle voit dix fois plus loin : là où il apercevait une fraction de mot, il voit une phrase.

Le fond et la forme

Le tout premier niveau de Mimi n’est pas de même nature que les autres. C’est le jeton sémantique, distillé depuis WavLM, et son rôle est de porter le sens sans nécessairement contribuer à la qualité de reconstruction.

L’expérience qui le démontre est élégante. On entraîne un modèle sur les 32 niveaux, puis à la génération on impose de force les jetons sémantiques de l’audio d’origine, en laissant le modèle inventer tout le reste. Le résultat : la voix obtenue est complètement différente, mais elle dit exactement la même chose.

Le jeton sémantique est le scénario du film. Les jetons acoustiques sont le casting, les décors et la lumière. On peut refaire le film avec d’autres acteurs sans changer une ligne du scénario.

Le fossé entre modalités

Le bilan de Volhejn est mesuré. Avec un codec, un modèle de langage tout à fait ordinaire produit de la parole partiellement cohérente ; sans codec, le même modèle exactement produit du grésillement. La démonstration est faite. Mais on reste très loin des modèles de texte.

Moshi modélise trois flux en parallèle : l’audio de l’utilisateur, son propre audio, et un flux de texte qui joue le rôle de monologue intérieur. Les ablations montrent que ce flux textuel aide massivement — et c’est là que l’article devient un peu mélancolique. L’essentiel du raisonnement semble délégué au texte, tandis que les flux audio finissent par ne servir que de reconnaissance et de synthèse vocales intégrées.

Plus d’un an après Moshi, personne n’explique vraiment pourquoi les modèles audio restent en retard. Volhejn appelle ça le fossé entre modalités, et conclut que c’est ce mystère non résolu qui rend le domaine passionnant.

Une piste à surveiller : certains travaux récents se passent entièrement de jetons discrets et travaillent dans un espace latent continu. Si cette approche mûrit, toute la machinerie décrite ici deviendrait un détour historique.

Voilà pour la mécanique telle qu’elle est censée fonctionner.

Ce carnet est donc un atelier autant qu’une vitrine. J’y noterai les décisions techniques que je prends au quotidien : pourquoi tel modèle plutôt qu’un autre, pourquoi telle contrainte matérielle change tout, pourquoi une solution élégante sur le papier s’effondre dès qu’on la branche à une caméra réelle.

Ce que vous y trouverez

• Des notes de terrain. Vision par ordinateur, LLM embarqués, fusion de capteurs. Du concret, avec les pièges.
• Des post-mortem honnêtes. Ce qui a cassé, et ce que j’aurais dû voir venir.
• Le contexte africain comme contrainte première. Connexion intermittente, matériel modeste, déploiement hors-ligne.

Ce que vous n’y trouverez pas

Pas de tutoriels recopiés, pas de hype. Si je n’ai pas mis les mains dedans, je n’en parle pas.

Écrire, c’est penser deux fois.

À bientôt dans le prochain article.

L’idée

Un marqueur ArUco est un motif noir et blanc dont OpenCV connaît la taille physique. En plaçant quelques marqueurs à des positions connues du sol, j’obtiens une correspondance entre pixels et coordonnées réelles. C’est une homographie — une matrice 3×3 qui projette un plan sur un autre.

Concrètement, j’imprime une planche de quatre marqueurs du dictionnaire DICT_4X4_50, que je découpe et pose au sol en rectangle :

Le code

D’abord, détecter les marqueurs dans l’image :

import cv2
import numpy as np

aruco_dict = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_4X4_50)
params = cv2.aruco.DetectorParameters()
detector = cv2.aruco.ArucoDetector(aruco_dict, params)

frame = cv2.imread("scene.jpg")
corners, ids, _ = detector.detectMarkers(frame)

Ensuite, on associe chaque marqueur détecté (en pixels) à sa position réelle connue (en mètres), puis on calcule l’homographie :

# Coins image (pixels) -> coins monde (mètres)
image_pts = np.array([c[0].mean(axis=0) for c in corners], dtype=np.float32)
world_pts = np.array([
    [0.0, 0.0],   # marqueur id 0 au coin de la pièce
    [3.0, 0.0],   # 3 m sur l'axe X
    [3.0, 4.0],
    [0.0, 4.0],
], dtype=np.float32)

H, _ = cv2.findHomography(image_pts, world_pts)

Enfin, projeter n’importe quel point de l’image vers le monde réel :

def pixel_to_world(px, py, H):
    pt = np.array([px, py, 1.0])
    world = H @ pt
    world /= world[2]          # normalisation homogène
    return world[0], world[1]  # x, y en mètres

Précision en pratique

Sur mon installation, voici l’erreur médiane mesurée selon la distance à la caméra :

La leçon : un seul capteur ne suffit jamais. Au-delà de quatre mètres, je fusionne la position visuelle avec celle des balises RFID. Mais ça, ce sera le sujet d’un prochain article.

À retenir

• Imprime tes marqueurs en grand : un ArUco minuscule à 4 m, c’est du bruit.
• Mesure les positions réelles au cordeau, pas à l’œil.
• Garde toujours un capteur de secours pour les zones lointaines.