DeepSeek publie DSpark, un framework de décodage spéculatif qui accélère la génération par utilisateur de DeepSeek-V4 de 60 à 85 % par rapport à MTP-1

DeepSeek publie en open source DSpark, un framework qui accélère l'inférence des LLM jusqu'à 85%

DeepSeek a publié ce week-end DSpark, un nouveau système open source sous licence MIT conçu pour accélérer significativement l'inférence des grands modèles de langage. Le framework repose sur une technique appelée décodage spéculatif : un petit module "brouillon" anticipe plusieurs tokens à l'avance, tandis que le modèle principal valide ou invalide ces prédictions en une seule passe. Lorsque les prédictions sont bonnes, le modèle avance beaucoup plus vite ; lorsqu'elles sont mauvaises, DSpark évite de gaspiller des ressources à les vérifier. DeepSeek a rendu publics le code source sur GitHub et Hugging Face, un article technique détaillant la méthode, les checkpoints des modèles, ainsi que DeepSpec, une base de code dédiée à l'entraînement et à l'évaluation de systèmes de décodage spéculatif. Le framework a été testé en production sur DeepSeek-V4-Flash, un modèle mixture-of-experts de 284 milliards de paramètres avec 13 milliards de paramètres actifs, et sur DeepSeek-V4-Pro, le modèle phare de 1,6 billion de paramètres avec 49 milliards de paramètres actifs, les deux supportant des fenêtres de contexte allant jusqu'à un million de tokens. Les chiffres publiés par DeepSeek sont substantiels. En production, DSpark améliore le débit global de 51% pour V4-Flash et de 52% pour V4-Pro à des cibles de service réalistes (respectivement 80 et 35 tokens par seconde par utilisateur). À capacité système équivalente, la vitesse de génération perçue par chaque utilisateur individuel augmente de 60 à 85% pour V4-Flash et de 57 à 78% pour V4-Pro par rapport à la baseline MTP-1 précédente. Ces gains concernent directement l'expérience utilisateur dans les cas d'usage les plus exigeants : chatbots grand public, assistants de code, workflows agentiques et systèmes d'entreprise où la fluidité des réponses longues est critique pour l'adoption. Réduire la latence d'inférence sans modifier les sorties du modèle est l'un des problèmes les plus coûteux de l'industrie IA, car il conditionne directement l'économie du déploiement à grande échelle. DSpark n'est pas conçu comme une solution réservée aux modèles DeepSeek. Les checkpoints publiés couvrent d'autres familles de modèles open source, notamment Qwen d'Alibaba et Gemma de Google, ouvrant la porte à des adaptations par des équipes tierces qui contrôlent leurs propres poids et infrastructure de déploiement. Cette publication intervient dans un contexte géopolitique tendu, alors que le gouvernement américain cherche à limiter l'accès aux modèles d'Anthropic et OpenAI sur certains marchés. DeepSeek, qui avait déjà bouleversé les références de l'industrie début 2025 avec ses modèles R1 et V3, confirme avec DSpark une stratégie délibérée d'open source agressif qui redistribue les capacités technologiques à l'échelle mondiale, indépendamment des restrictions diplomatiques.

NVIDIA : le décodage spéculatif dans NeMo RL accélère la génération de 1,8× à 8B et vise 2,5× à 235B

Des chercheurs de NVIDIA ont publié une étude intégrée à NeMo RL v0.6.0 qui accélère significativement la phase d'entraînement par renforcement des grands modèles de langage grâce au décodage spéculatif. Le principe repose sur un petit modèle dit "brouillon" qui propose plusieurs tokens en avance, tandis que le modèle principal, celui qu'on entraîne réellement, les vérifie via un mécanisme de rejet statistique. Sur 32 GPU GB200 (8 nœuds NVL72), cette approche réduit la latence de génération de 100 secondes à 56,6 secondes sur la tâche RL-Zero, soit un gain de 1,8× sur la génération. À l'échelle d'un modèle de 235 milliards de paramètres, les projections donnent un gain de bout en bout de 2,5×. Le framework EAGLE-3 est utilisé comme moteur de brouillon, compatible avec n'importe quel modèle pré-entraîné sans nécessiter de tête de prédiction multi-token native. Ce résultat est particulièrement précieux parce qu'il ne sacrifie rien à la fidélité d'entraînement. La génération par rollout représente entre 65 et 72 % du temps total d'une étape RL, mesure faite sur Qwen3-8B dans deux configurations, RL-Think et RL-Zero. C'est donc le seul goulet d'étranglement qui vaille la peine d'être attaqué. Or les méthodes habituelles d'accélération, exécution asynchrone, replay hors-politique, précision réduite, introduisent toutes un décalage de distribution qui contamine le signal d'entraînement. Le décodage spéculatif, lui, garantit mathématiquement que la distribution de sortie du modèle cible reste identique à ce qu'elle aurait été sans brouillon. Aucune correction hors-politique, aucun biais introduit dans la récompense. L'intégration dans une boucle d'entraînement par renforcement posait néanmoins un défi d'ingénierie non trivial : à chaque mise à jour des poids de la politique, le modèle brouillon doit rester aligné avec cette politique en évolution. NVIDIA a résolu cela avec une architecture à deux chemins dans NeMo RL, un chemin général via EAGLE-3 et un chemin natif pour les modèles disposant de têtes MTP intégrées. Lorsque l'adaptation en ligne du brouillon est activée, les états cachés et log-probabilités issus du passage avant du vérificateur MegatronLM sont réutilisés pour superviser la tête brouillon via un gradient détaché, de sorte que l'entraînement du brouillon n'interfère jamais avec le gradient de politique. Cette fonctionnalité est désormais disponible en production dans NeMo RL v0.6.0, aux côtés du backend SGLang, de l'optimiseur Muon et de l'entraînement long contexte YaRN.

💬 Le vrai problème du RLHF à grande échelle, c'est que 70% du temps tu le passes juste à générer des rollouts. NVIDIA s'y attaque proprement avec le décodage spéculatif dans NeMo : un modèle brouillon qui anticipe, un modèle principal qui valide, et la garantie mathématique que la distribution reste intacte, pas de biais hors-politique introduit en douce. 1,8× sur 8B, 2,5× visé sur 235B, c'est le genre d'optimisation qu'on attendait depuis qu'on fait du RL sérieusement.

Les modèles open source Gemma 4 de Google utilisent le décodage spéculatif pour atteindre jusqu'à 3x plus de rapidité

Google a lancé ce printemps sa nouvelle gamme de modèles d'IA ouverts, Gemma 4, conçus pour fonctionner en local sur le matériel des utilisateurs. Quelques semaines seulement après ce lancement, l'entreprise publie des modèles auxiliaires appelés "MTP drafters" (drafters à prédiction multi-token), exploitant une technique connue sous le nom de décodage spéculatif. Le principe : ces modèles légers anticipent les prochains tokens avant que le modèle principal ne les génère, ce qui peut accélérer la vitesse de génération jusqu'à trois fois par rapport à une inférence classique. Gemma 4 repose sur la même architecture de base que Gemini, le modèle frontier de Google, mais est optimisé pour tourner sur une seule machine, y compris sur un GPU grand public avec quantification. L'enjeu est considérable pour quiconque veut utiliser des modèles puissants sans dépendre d'un service cloud. En local, les contraintes matérielles sont sévères : bande passante mémoire limitée, absence de clusters de TPUs comme ceux dont dispose Google en interne. Le décodage spéculatif contourne en partie ces goulots d'étranglement en parallélisant une partie du travail d'inférence. Pour les développeurs et chercheurs qui font tourner des modèles sur leur propre infrastructure, un gain de 3x sur la vitesse de génération représente une différence très concrète en termes de productivité et de coût opérationnel. Google a également profité du lancement de Gemma 4 pour changer de licence : exit la licence Gemma propriétaire des versions précédentes, place à l'Apache 2.0, bien plus permissive et appréciée de l'écosystème open source. Ce choix positionne Gemma 4 comme un concurrent direct de Llama de Meta ou des modèles Mistral, dans une course où la liberté d'usage est devenue un argument de poids. Les MTP drafters sont encore présentés comme expérimentaux, mais ils signalent clairement la direction que prend Google : rendre ses modèles ouverts non seulement plus capables, mais aussi plus rapides à exploiter sur du matériel ordinaire.

💬 Le décodage spéculatif, ça fait des années qu'on en parle en labo, mais là Google le rend pratique sur un GPU grand public. Le vrai truc de cette annonce, c'est quand même le passage à Apache 2.0, les anciennes licences Gemma c'était de l'open source du dimanche. Reste à voir si le x3 tient en prod réelle, parce que les benchmarks Google ont une tendance connue à se dégonfler un peu.

DiffusionGemma : l’IA de Google met un coup d’accélérateur à la génération de texte

Google a présenté DiffusionGemma, un modèle expérimental de génération de texte qui abandonne l'approche séquentielle classique au profit d'une génération par blocs parallèles. Reposant sur une architecture Mixture of Experts de 26 milliards de paramètres, dont seulement 3,8 milliards activés lors de la génération, le modèle traite jusqu'à 256 jetons simultanément plutôt que de les produire un par un. Google revendique une vitesse pouvant atteindre plus de 1 000 jetons par seconde sur certains accélérateurs haut de gamme, soit jusqu'à quatre fois plus rapide que les modèles autorégressifs traditionnels comme Gemma 4. Le fonctionnement s'inspire directement des modèles de diffusion d'images : DiffusionGemma part d'un brouillon de jetons aléatoires, qu'il affine sur plusieurs passes successives jusqu'à produire un texte cohérent. Son attention bidirectionnelle permet à chaque partie du texte généré de prendre en compte l'ensemble du bloc en cours de construction, ce qui le rend particulièrement adapté à des tâches comme l'édition, le remplissage de code ou toute application où le contexte global est déterminant. Cette vitesse d'exécution représente un enjeu concret pour les développeurs qui cherchent à intégrer des IA dans des interfaces temps réel, des outils d'autocomplétion ou des applications où la latence perçue doit être quasi nulle. En exploitant plus efficacement la parallélisation des GPU modernes, DiffusionGemma réduit aussi les ressources laissées inutilisées entre chaque jeton généré sous l'approche classique. Sa compatibilité avec des GPU grand public, grâce à l'activation partielle des paramètres, ouvre également la porte à des déploiements moins coûteux en infrastructure, un argument de poids pour les équipes qui opèrent hors des datacenters hyperscale. Cette annonce s'inscrit dans une dynamique plus large d'expérimentation autour des alternatives aux modèles autorégressifs. La recherche sur les modèles de diffusion textuelle existe depuis plusieurs années, mais leur intégration dans des architectures de grande taille et leur viabilité pratique restaient limitées. Google, en publiant DiffusionGemma sous forme expérimentale, reconnaît lui-même que la qualité globale des réponses reste inférieure à celle de Gemma 4 classique : la vitesse a un coût en précision et en cohérence générale. Le modèle n'est donc pas encore positionné comme un successeur direct de la gamme Gemma, mais comme un terrain d'expérimentation pour les cas d'usage où la rapidité prime sur la finesse. L'enjeu des prochains mois sera de savoir si la recherche parvient à combler cet écart de qualité, et si d'autres acteurs comme Meta, Mistral ou OpenAI s'engagent à leur tour sur cette voie architecturale.