Inférence locale : mesurer le débit de Spark-X2.6-4B12 min de lecture2 335 mots

Inférence locale : mesurer le débit de Spark-X2.6-4B

Découvrez ce que les tests TensorFold de Spark-X2.6-4B révèlent sur le débit, la latence, la mémoire et les limites d’un modèle local sur GPU CUDA.

inférence localedébit LLMmodèle d’IA localGPU CUDATensorFold
Inférence locale : mesurer le débit de Spark-X2.6-4B

Quatre requêtes en parallèle : ce que TensorFold révèle sur l'inférence locale

Un modèle installé sur votre machine peut donner une impression de vitesse spectaculaire quand une seule personne lui pose des questions. Mais dès que plusieurs demandes arrivent en même temps, le décor change : la latence perçue à la première réponse varie, et le serveur peut aussi « coûter » davantage en mémoire. Pour une équipe qui envisage un déploiement interne, ces détails comptent autant que le débit maximal affiché.

Le projet communautaire TensorFold aborde justement ces points avec Spark-X2.6-4B et une recette CUDA native. Sur une RTX 5090, le débit agrégé grimpe avec le nombre de flux simultanés. En parallèle, d'autres mesures montrent que l'allongement du contexte augmente l'attente initiale et que la mémoire consommée augmente avec la concurrence. Ce sont des résultats utiles pour cadrer un essai, mais ce ne sont ni un benchmark indépendant ni une preuve de la qualité des réponses.

L'idée ici : comprendre comment lire ces chiffres, ce qu'ils impliquent pour un service local, et ce qu'il faut vérifier avant de reproduire l'expérience. L'objectif n'est pas de « trouver le GPU gagnant », mais de savoir quelles données vous aident vraiment à décider si une configuration tient la route en usage réel.

Que mesurent les tests de débit de TensorFold ?

La recette CUDA de TensorFold, maintenue par ashhart, mesure le débit de Spark-X2.6-4B avec plusieurs niveaux de concurrence. Sur une RTX 5090 sous Linux, le modèle converti en 8 bits est testé avec un contexte configuré à 32 768 tokens. Les réponses sont des générations gloutonnes de 256 tokens, et les valeurs rapportées sont la médiane de trois réponses par prompt.

Flux simultanés Débit rapporté Lecture pratique
1 191-204 tokens/s Débit d'une requête isolée
2 375-389 tokens/s au total Débit cumulé des deux requêtes
4 716-729 tokens/s au total Débit cumulé des quatre requêtes

Le point clé, c'est total. À quatre flux, 716 à 729 tokens par seconde ne veut pas dire que chaque utilisateur reçoit ce même rythme. Il s'agit du débit agrégé du serveur, réparti entre les générations qui tournent en même temps. La vitesse réellement perçue dépend de l'ordonnancement, de la charge, et du nombre de requêtes qui progressent simultanément.

Pourquoi le débit agrégé ne suffit pas

Un débit élevé répond à une question simple : combien de tokens le système produit sur une période donnée, dans les conditions du test. Ça ne dit pas, à lui seul, combien de temps il faut attendre avant le premier token, ni à quel point cette attente est régulière, ni ce que les réponses valent vraiment. Selon le cas d'usage, vous pouvez tolérer une génération moins rapide si le travail part en tâche de fond. En revanche, pour un assistant interactif utilisé pendant une réunion, une longue attente initiale se remarque très vite.

Et comme toujours, la mesure dépend aussi du protocole : modèle, conversion en 8 bits, GPU, système d'exploitation, longueur des réponses et prompts utilisés. Si vous changez un de ces éléments, les résultats peuvent bouger. Les chiffres publiés sont donc un bon point de départ pour comparer des configurations testées de façon cohérente - pas une promesse de performance valable pour tout contexte.

Ce que la concurrence suggère pour une équipe

Le passage de 1 à 4 flux montre qu'une carte peut absorber plusieurs générations et augmenter le débit global. C'est potentiellement intéressant pour un service interne quand les demandes sont courtes ou quand vous traitez des lots. Mais en pratique, 4 utilisateurs ne soumettent pas forcément leurs requêtes au même instant, et toutes les réponses ne font pas la même longueur.

Pour dimensionner un usage, mesurez au minimum le débit global et le temps de réponse par requête. Ensuite seulement, ajoutez une charge qui ressemble à votre réalité : questions courtes, documents de taille habituelle, pics de connexions, et scénarios qui reflètent votre flux. Le maximum « sur le papier » est rarement ce qui raconte le mieux votre expérience quotidienne.

Que change un contexte long pour un modèle local ?

TensorFold compare quatre types de prompts avant et après l'ajout d'une entrée de 28 000 tokens. Les catégories testées sont la prose, le code, le JSON et les listes. Après cette entrée, les débits rapportés restent proches des valeurs initiales : entre 197 et 200 tokens par seconde, contre 191 à 204 auparavant.

Type de prompt Entrée courte (tokens/s) Après une entrée de 28 000 tokens (tokens/s)
Prose 199 199
Code 191 198
JSON 203 197
Liste 204 200

Dans ce protocole, ça suggère que la vitesse de génération après lecture reste dans une plage similaire pour les quatre formats. Mais ça ne veut pas dire qu'un document de 28 000 tokens « ne coûte rien ». Les chiffres décrivent la génération une fois le prompt traité ; ils ne mesurent ni le temps total de la tâche, ni la pertinence des réponses produites.

Séparer lecture et génération

Avec une requête contenant un long document, l'utilisateur attend d'abord que le modèle traite l'entrée, puis les tokens de réponse commencent à apparaître. Ces deux phases n'ont pas le même impact sur l'expérience. Un débit de génération stable peut donc coexister avec un délai initial qui s'allonge nettement quand le contexte grandit.

C'est particulièrement important pour les usages documentaires : synthèse de contrats, recherche dans des procédures internes, analyse de dossiers. Dans ces cas-là, une équipe ne devrait pas déduire le temps de traitement d'un document à partir du seul débit de sortie. Il faut mesurer le temps total entre l'envoi de la requête et la réponse complète, et aussi le délai jusqu'au premier token si vous voulez une interaction « réactive ».

Un contexte configuré n'est pas une capacité gratuite

La recette annonce un réglage de contexte à 32 768 tokens. Ça ne garantit pas que n'importe quelle requête tirera parti de cette longueur sans coût ni limite. L'expérience mentionne qu'un point d'entrée prévu à 30 720 tokens a dépassé la limite après tokenisation et a été refusé. Autrement dit, la « taille » réelle dépend du nombre de tokens issus du texte, pas seulement du nombre de mots ou de caractères visibles.

Si vous voulez reproduire un cas métier, testez avec des documents représentatifs et gardez une marge par rapport à la limite observée. Si votre pipeline échoue sur quelques dossiers trop longs, vous devrez probablement découper, ou prévoir une règle de refus explicite. Oui, ça ajoute de la complexité, mais ça évite de confondre capacité théorique et capacité réellement exploitable dans un service.

Comment interpréter la latence et la mémoire en production ?

Le test de latence publié séparément rapporte le temps avant le premier token sur une RTX 4090 sous Windows, avec une conversion 8 bits. L'attente augmente avec la taille de l'entrée : 0,24 seconde à 2 000 tokens, 0,93 seconde à 8 000, 1,93 seconde à 16 000, et 4,65 secondes à 29 000 tokens.

Ces mesures rendent visible un compromis que le débit de génération ne montre pas : plus l'entrée est longue, plus le début de la réponse peut être retardé. En revanche, elles ne permettent pas de comparer directement la RTX 4090 à la RTX 5090, car les tests ne partagent pas exactement le même matériel ni les mêmes conditions. En tirer un classement des cartes serait malhonnête.

Mesurer l'attente réellement perçue

Le temps avant le premier token (TTFT) est utile pour juger la réactivité d'une interface. Mais il faut le lire avec le temps de génération et le temps total. Pour une réponse courte, le TTFT peut représenter une grande partie de l'attente. Pour une réponse longue, la génération pèse aussi très vite dans la balance.

Avant un déploiement, préparez un petit jeu de tests qui reflète vos tâches. Pour chaque requête, notez au minimum :

  • la longueur de l'entrée après tokenisation ;
  • le nombre de requêtes simultanées ;
  • le délai jusqu'au premier token ;
  • le débit de génération par requête et au total ;
  • le temps nécessaire pour terminer la réponse.

Cette fiche vous donne des essais comparables. Elle aide aussi à détecter un changement de comportement après une mise à jour du modèle, de la recette, ou de la charge applicative.

Prévoir la mémoire avec la concurrence

Sur le serveur RTX 5090, TensorFold indique 9,47 Gio pour le modèle, auxquels s'ajoutent 1,23 Gio par flux au réglage de contexte 32 000. À titre indicatif, quatre flux ajouteraient donc environ 4,92 Gio de plus pour les flux, en plus de la mémoire « modèle ». Ce calcul ne remplace pas une mesure complète de la mémoire disponible en situation réelle.

La conséquence pratique est assez directe : dimensionner seulement à partir de la taille du modèle ne suffit pas. La concurrence et le contexte influencent aussi les ressources nécessaires. Une carte qui passe pour une requête peut ne plus laisser assez de marge quand un pic arrive. Garder une réserve réduit le risque d'échec sous charge et laisse de l'air pour les autres composants du service.

À retenir : mesurez ensemble le débit agrégé, l'attente par requête et la consommation mémoire. Optimiser un seul indicateur peut dégrader les deux autres.

Quelles sont les limites de cette expérience CUDA ?

Les résultats publiés viennent de l'auteur du projet TensorFold ; ils ne proviennent pas d'une reproduction indépendante par SparkLLM. La révision de la recette examinée est identifiée comme 0fed2e4a5fcc03f109cfaaf8eda10734cce21fb7, vérifiée le 13 novembre 2026 UTC. Les essais sur RTX 4090 et RTX 5090 datent du 25 et du 26 octobre 2026 respectivement, sans indication de fuseau horaire. Les graphiques reprennent les valeurs rapportées : ce ne sont pas des captures de l'exécution du modèle.

La recette couvre ces deux cartes, mais les autres GPU CUDA ne sont pas testés. Elle ne sert pas non plus de modèle brouillon pour la génération spéculative ni de mode de sortie structurée. Enfin, le fait que les sorties restent cohérentes entre plusieurs configurations n'est pas une évaluation de leur exactitude.

Cohérence des sorties et qualité des réponses sont deux choses différentes

Dans les vérifications rapportées, 12 réponses concurrentes sur 12 correspondent aux versions exécutées seules. De même, 12 réponses sur 12 obtenues avec les brouillons de copie désactivés correspondent aux réponses avec brouillons. Ces contrôles portent sur la cohérence des sorties entre configurations.

Ils ne disent rien sur l'exactitude, l'utilité, la sécurité ou l'adéquation des réponses à un besoin métier. Pour une équipe qui manipule des données sensibles, la qualité doit être évaluée séparément, sur des cas représentatifs, avec des critères de validation clairs et une vérification humaine quand le coût d'une erreur est élevé. Et le fait d'exécuter localement ne supprime pas la nécessité de définir des règles d'accès, de conservation et de contrôle des données.

Une méthode de test reproductible

Pour arriver à une conclusion exploitable, partez de la recette publiée par TensorFold, qui précise la révision du checkpoint Spark, les commandes de conversion et de compilation, le matériel et les limites. Le dépôt officiel du modèle Spark-X2.6 sert de point de départ pour identifier le modèle utilisé. Si votre objectif est de comparer des essais, il faut conserver la même version et les mêmes paramètres.

Lors d'un test sur une autre carte, consignez au minimum : le modèle et sa quantification, le GPU, le système, la longueur du prompt, la concurrence, le débit de génération et le délai avant le premier token. Indiquez aussi la méthode de calcul et la taille des sorties. Sans ces éléments, un résultat isolé est dur à interpréter et presque impossible à reproduire.

Conclusion : tester le service, pas seulement le GPU

L'expérience TensorFold montre qu'un modèle local peut augmenter fortement son débit agrégé quand plusieurs flux sont servis en parallèle. Elle rappelle aussi que les longues entrées augmentent l'attente initiale, que la concurrence consomme davantage de mémoire, et qu'un contexte configuré ne garantit pas que chaque prompt sera accepté.

Pour savoir si cette approche convient à votre équipe, testez vos propres cas et suivez au même endroit le débit, le délai avant la première réponse, la durée totale et la consommation mémoire. Traitez les chiffres publiés comme un repère à reproduire, pas comme une promesse universelle. Le bon choix, c'est celui qui tient sous votre charge réelle, avec une qualité vérifiée et une marge suffisante pour les mauvaises surprises.

Questions frequentes

Non. Il s’agit du débit agrégé rapporté pour quatre flux simultanés sur la RTX 5090. La production se répartit entre les requêtes actives ; le débit perçu par chaque utilisateur est donc inférieur au total et dépend de l’ordonnancement ainsi que de la charge réelle.
Dans les prompts testés, le débit de génération après traitement du document reste proche des résultats obtenus avec une entrée courte. Cela ne signifie pas que le document est traité sans délai : ces chiffres ne mesurent ni le temps de lecture de l’entrée, ni le temps total de la tâche.
Non. Le test de débit sur RTX 5090 et le test de latence sur RTX 4090 utilisent des matériels et des conditions différents. Ils illustrent des mesures distinctes, mais ne constituent pas un comparatif contrôlé des deux cartes.
Non. Les mesures portent sur le débit, la latence, la mémoire et la cohérence de certaines sorties entre configurations. Elles n’évaluent pas l’exactitude ou la pertinence des réponses pour des tâches métier. Ces critères nécessitent un jeu d’évaluation distinct, adapté à l’usage visé.

Articles similaires