🔬 condensed matter

A Modern Multimodal Assistant on a 6 GB 2011 GPU: Stage-Validated, All-GPU CUDA Inference for Fermi

Cet article démontre la faisabilité de l'exécution d'un assistant multimodal moderne entièrement sur un GPU Fermi de 6 Go de 2011 en concevant un moteur d'inférence entièrement GPU qui surmonte les limitations matérielles grâce à des GEMM déquantifiés optimisés, des couches récurrentes par blocs et des noyaux d'attention économes en mémoire, atteignant un questionnement-réponse sur image de bout en bout en 1,7 seconde.

Auteurs originaux : A. C. Opus, J. Q. Lu

Publié 2026-07-17

📖 7 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : A. C. Opus, J. Q. Lu

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous possédez un cerveau de robot super intelligent capable de voir des images et de répondre à des questions à leur sujet. Habituellement, ces cerveaux sont si massifs et gourmands en énergie qu'ils nécessitent un ordinateur énorme et coûteux pour fonctionner, ou bien ils doivent être divisés de sorte que certaines parties du cerveau vivent dans la mémoire de l'ordinateur tandis que d'autres vivent sur le processeur. Mais et si vous vouliez faire fonctionner ce super-cerveau sur une pièce d'ordinateur qui a quatorze ans ? C'est le défi que cet article relève. C'est comme essayer de faire tourner un jeu vidéo moderne en haute définition sur un ordinateur portable de 2011. L'idée clé ici est l'« inférence », ce qui est juste un mot savant pour dire que le robot est réellement en train de réfléchir et de répondre à une question après avoir été enseigné. L'article pose la question : pouvons-nous faire fonctionner une IA moderne capable de lire des images entièrement sur une carte graphique très ancienne et faible, sans avoir besoin d'aide du cerveau principal de l'ordinateur ? Pour ce faire, les chercheurs ont dû être incroyablement ingénieux dans l'organisation de leurs calculs mathématiques, car la vieille carte ne possède pas beaucoup des outils spéciaux dont disposent les cartes modernes.

L'histoire de cet article concerne une équipe d'ingénieurs qui a pris un assistant IA moderne et flambant neuf appelé MiniCPM-V-4.6 et l'a forcé à fonctionner sur une carte graphique NVIDIA de 2011 (la Tesla C2075) qui ne possède que 6 Go de mémoire. Habituellement, cette carte est considérée comme « abandonnée » par le monde du logiciel, ce qui signifie que plus personne n'écrit de nouveaux programmes pour elle. Les chercheurs voulaient voir s'ils pouvaient faire fonctionner l'ensemble du système entièrement sur cette vieille carte, sans avoir besoin de déplacer des données de l'ordinateur vers le processeur principal. Ils ont réussi, mais pas par devinette ; ils ont réussi en mesurant tout et en réalisant que leurs premières intuitions étaient souvent erronées.

Voici ce qu'ils ont découvert et comment ils l'ont fait :

1. Les « vieux outils » étaient meilleurs que les nouveaux
L'équipe a commencé par essayer d'écrire ses propres outils mathématiques personnalisés (appelés noyaux ou kernels) pour faire fonctionner l'IA rapidement. Ils pensaient que leur meilleur code mathématique écrit à la main serait le plus rapide. Mais lorsqu'ils l'ont mesuré, ils ont découvert que leur code personnalisé n'atteignait que 37 % de la vitesse maximale de la carte. Ensuite, ils ont essayé d'utiliser un outil standard et ancien qui accompagnait le logiciel de la carte il y a dix ans (appelé cuBLAS). Étonnamment, cet ancien outil fonctionnait à 64 % de la vitesse maximale — soit presque le double de leur code personnalisé ! Ils ont appris que sur du matériel ancien, les outils pré-faits et « ennuyeux » sont parfois les plus rapides. Ils ont donc décidé de traduire leurs données dans un format que l'ancien outil pouvait comprendre et ont laissé l'ancien outil faire le gros du travail.

2. L'erreur du « ralenti »
L'IA possède une partie spéciale qui se souvient des choses au fur et à mesure qu'elle les lit, un peu comme une personne qui tient une conversation. L'équipe a essayé d'accélérer cela en découpant la conversation en petits morceaux. Au début, ils ont pensé que cette nouvelle méthode était plus lente. Ils ont failli abandonner ! Mais en regardant de plus près le minutage, ils ont découvert qu'une infime partie de leur code effectuait deux fois le même calcul et attendait trop souvent que l'ordinateur s'arrête et redémarre. Une fois qu'ils ont corrigé cette seule mauvaise partie, la nouvelle méthode par « morceaux » est devenue 2,8 fois plus rapide que l'ancienne. C'est une leçon qui montre qu'on ne peut pas se contenter de regarder l'image globale ; il faut vérifier chaque étape pour trouver le goulot d'étranglement.

3. Le piège du « 4-bits »
Dans le monde de l'IA, les gens essaient souvent de réduire la mémoire de leur modèle en utilisant des nombres en « 4-bits » au lieu de « 8-bits », pensant que des nombres plus petits signifient une vitesse plus élevée. L'équipe a testé cela sur la vieille carte. Même si les nombres en 4-bits occupent deux fois moins de place, la carte doit effectuer des calculs supplémentaires pour les « déballer », et la vieille carte est lente pour ce calcul spécifique. Résultat ? La version 4-bits était en fait 12 % plus lente que la version 8-bits. Ils sont donc restés sur les nombres 8-bits plus grands car, sur cette carte ancienne spécifique, le plus grand était en fait le plus rapide.

4. La règle du « départage »
Lorsque l'IA regarde une image, elle doit déterminer l'emplacement de chaque morceau de l'image. Les chercheurs ont essayé d'écrire leur propre mathématique pour décider quoi faire lorsque deux morceaux sont exactement sur la même ligne (un « tie » ou égalité). Ils ont essayé de nombreuses méthodes différentes pour résoudre cela, mais à chaque fois, le résultat était légèrement différent de la réponse de l'IA originale. Ils ont découvert que la façon dont l'IA originale décidait les égalités était une règle minuscule et spécifique qui ne pouvait pas être parfaitement copiée avec des mathématiques standards. La solution ? Ils ont arrêté d'essayer de réinventer la roue et ont simplement demandé à la bibliothèque mathématique de l'IA originale de faire le départage pour eux. Cela a permis de garantir que leur version était exactement identique à l'originale.

5. Le problème de la « longue histoire »
La plus grande surprise est survenue lorsqu'ils ont testé l'IA avec des questions très longues. Lorsque la question était courte (2 000 mots), l'IA était rapide. Mais quand ils ont rendu la question très longue (10 000 mots), l'IA a ralenti jusqu'à devenir extrêmement lente, devenant 17 fois plus lente. Il s'est avéré que la façon dont l'IA regardait en arrière vers les mots précédents devenait désordonnée et inefficace. L'équipe a réécrit cette partie pour utiliser le même « vieil outil » (cuBLAS) qu'ils avaient utilisé précédemment, mais ils ont organisé les données de manière à ce qu'elles s'insèrent parfaitement dans la mémoire que l'IA utilisait déjà. Cela a complètement réglé le problème. Désormais, l'IA est presque aussi rapide avec une question de 10 000 mots qu'avec une question courte.

Le résultat final
En utilisant ces astuces, l'équipe a réussi à faire fonctionner une IA moderne capable de lire des images entièrement sur une carte graphique de 2011. L'ensemble du système tient dans la mémoire de la carte, et elle peut répondre à une question sur une image en seulement 1,7 seconde. Elle peut même gérer des documents très longs et de grandes images sans planter. La leçon la plus importante de cet article n'est pas seulement qu'ils ont fait fonctionner un vieil ordinateur ; c'est qu'ils ont appris à faire confiance aux mesures plutôt qu'à leur propre intuition. Chaque fois qu'ils pensaient connaître la réponse (comme « le 4-bits est plus rapide » ou « notre code personnalisé est le meilleur »), les mesures prouvaient qu'ils avaient tort. En écoutant les données et en utilisant les bons outils, ils ont transformé un matériel vieux de quatorze ans en un assistant IA moderne et fonctionnel.

Résumé Technique : Un Assistant Multimodal Moderne sur un GPU de 6 Go de 2011

Énoncé du Problème
Ce rapport traite du défi consistant à faire fonctionner un assistant multimodal de génération actuelle entièrement en local sur une NVIDIA Tesla C2075 (architecture Fermi, 2011), un GPU doté de 6 Go de mémoire, sans cœurs Tensor, et d'une capacité de calcul (sm_20) abandonnée par les outils modernes (dernière prise en charge par CUDA 8.0). Contrairement à une étude complémentaire [1] qui gérait un modèle de 35 milliards de paramètres en diffusant les poids depuis la RAM de l'hôte et en déchargeant le décodage vers le CPU, ce travail cible un modèle moderne plus petit (MiniCPM-V-4.6) qui tient entièrement dans la mémoire de l'appareil. L'objectif principal est de déterminer la vitesse et la justesse atteignables d'un pipeline d'inférence entièrement GPU pour une architecture multimodale hybride sur ce matériel hérité, en dépassant les contraintes de mémoire pour se concentrer sur l'optimisation du débit et la fidélité de l'implémentation.

Méthodologie
Les auteurs ont déployé MiniCPM-V-4.6, qui se compose d'un encodeur de vision SigLIP2, d'un fusionneur d'attention par fenêtre (window-attention merger) et d'un squelette de langage hybride à portes delta-net (gated-delta-net) de 0,8 milliard de paramètres. Le système fonctionne avec des poids de langage quantifiés en 8 bits et des poids de vision en FP32, maintenant l'ensemble du modèle, le cache KV et les tampons de travail (scratch buffers) résidents sur le GPU. La méthodologie repose sur trois piliers fondamentaux :

Portage Validé par Étapes : Pour porter la tour de vision SigLIP2 vers un code CUDA sm_20 écrit à la main, les auteurs ont établi une « vérité de référence » en forçant l'implémentation de référence à s'exécuter sur le CPU hôte via un chemin de code hérité (contournant les exigences AVX). Ils ont ensuite porté la tour étape par étape (embeddings, 27 couches d'encodeur, fusionneur d'attention par fenêtre, projecteur), validant chaque étape par rapport au dump de référence avec un seuil d'accord strict ( $\sim 10^{-3}$ ).
Optimisation Mesurée plutôt qu'Intuitive : La performance du moteur a été pilotée par la mesure empirique plutôt que par des suppositions théoriques. Les décisions architecturales clés ont été inversées sur la base du profilage :
- Efficacité GEMM : Au lieu de s'appuyer sur des noyaux GEMM écrits à la main, le système déquantifie les poids 8 bits en FP32 une seule fois et appelle le csgemm du fournisseur (CUDA 8.0), qui a atteint 64 % de la performance de pointe FP32, soit presque le double des 37 % atteints par le meilleur tile écrit à la main.
- Couches Récurrentes : Les couches de type gated-delta-net ont été réécrites d'un balayage jeton par jeton vers une forme de règle delta par blocs (intra-/inter-chunk). Les tentatives initiales étaient plus lentes en raison d'un noyau de substitution directe (forward-substitution) inefficace ; corriger cela a rendu l'approche par blocs 2,8 fois plus rapide que la récurrence séquentielle.
- Quantification : Contrairement à l'hypothèse selon laquelle des poids en 4 bits accéléreraient le décodage, les auteurs ont constaté que les instructions de décalage (shift) lentes de Fermi (nécessaires pour le déballage des nibbles) rendaient le décodage 4 bits 12 % plus lent que le 8 bits. Le système a conservé les poids 8 bits pour le décodage.
Réécritures d'Attention : Les auteurs ont identifié un goulot d'étranglement en $O(N^2)$ dans le noyau d'attention qui faisait s'effondrer le débit lors de contextes longs. Ils ont réécrit l'attention bidirectionnelle de la tour de vision ainsi que l'attention causale du modèle de langage en utilisant des appels de GEMM par tête du fournisseur. Crucialement, ils ont utilisé une « astuce de disposition » (layout trick) où le GEMM écrit les scores dans le tampon d'attention existant (interprétation ligne par colonne vs colonne par ligne), nécessitant zéro mémoire supplémentaire sur l'appareil.

Contributions Clés et Résultats

Inférence Multimodale Entièrement sur GPU : Le système exécute avec succès MiniCPM-V-4.6 entièrement sur la C2075. Le squelette de langage décode à 48,6 jetons/seconde (greedy).
Fidélité de la Tour de Vision : La tour SigLIP2 portée à la main correspond à l'implémentation de référence à $1,4 \times 10^{-5}$ par élément. Une découverte critique a été que l'arithmétique d'index impliquant des égalités rationnelles exactes (ex: $10/28 = 25/70$ ) est définie par l'implémentation ; les auteurs ont conclu que de telles opérations doivent appeler l'opérateur de référence plutôt que d'être réimplémentées pour garantir la portabilité.
Optimisation du Débit :
- Prefill : Le noyau d'attention naïf faisait chuter le débit de prefill de 114 jetons/s à un contexte de 2k à 21 jetons/s à 10k. La réécriture GEMM a aplati ce profil, maintenant 361 jetons/s à 10k (une réduction de 17× du temps de prefill).
- Encodage d'Image : La même réécriture GEMM a réduit le temps d'encodage d'image de 6×, passant de 5,7s à 0,93s par image.
Performance de Bout en Bout : Une question sur une image unique est répondue en 1,7 seconde. Une image complexe multi-tranches (896×672) avec texte et formes est traitée en environ 7 secondes. Le système récupère correctement une « aiguille » placée à 60 % de la profondeur d'un document de 10k jetons.

Signification et Revendications
Le papier se positionne comme un rapport d'ingénierie et de mesure plutôt qu'une revendication de nouveauté algorithmique. Sa signification réside dans la démonstration que des assistants multimodaux modernes peuvent fonctionner sur du matériel abandonné par l'écosystème logiciel, à condition que l'implémentation soit rigoureusement validée par rapport à une vérité de référence.

Les auteurs soulignent une leçon méthodologique : les plafonds de performance et l'emplacement des bugs sur le matériel hérité sont peu fiables lorsqu'ils sont raisonnés et ne sont fiables que lorsqu'ils sont mesurés par rapport aux bibliothèques du fournisseur, aux temporisateurs par composant et aux traces de référence. Ce travail renverse quatre intuitions affirmées (que le GEMM écrit à la main est le plafond, que les balayages par blocs sont plus lents, que le décodage 4 bits est plus rapide, et que les benchmarks courts représentent la performance en contexte long) grâce aux données empiriques. De plus, il établit une règle pour le portage de l'arithmétique d'index avec des égalités exactes : ne pas réimplémenter ; invoquer l'opérateur de référence.

Le système sert de preuve de concept qu'un portage « validé par étapes », combiné à des appels d'algèbre linéaire optimisés par le fournisseur et une gestion minutieuse de la mémoire, peut transformer un GPU vieux de 14 ans en un moteur d'inférence multimodale performant et à haut débit.

Articles similaires