Dépêche

MACHINES

DeepSeek a publié ses comptes. Les loueurs de GPU devraient les lire

Le 20 octobre, DeepSeek a mis DeepInfer sur GitHub. Pas un modèle de plus : le moteur qui fait tourner ses modèles dans ses data centers. Et avec lui, des chiffres que les loueurs de GPU feraient mieux de lire deux fois.

DeepSeek a publié ses comptes. Les loueurs de GPU devraient les lire

Mardi 20 octobre, DeepSeek pousse DeepInfer sur GitHub.

Licence Apache 2.0. Utilisable commercialement, sans limite. Vingt mille étoiles en une semaine.

Ce n’est pas juste un modèle de plus. On parle là du moteur d’inférence qui fait tourner ses modèles dans ses propres data centers. Celui qui traite 155 000 milliards de tokens par jour, sur un seul cluster.

Le web salue le « chevalier blanc » de l’open source. Celui qui « offre » tout.

Sauf que ce n’est pas un cadeau. C’est un cours d’ingénierie.


Jusqu’ici, DeepSeek publiait ses poids : un fichier de 510 gigaoctets de matrices pour V4.1 Flash, n’importe qui pouvait le télécharger.

Mais entre des poids et un service qui répond 24 h sur 24 à 200 tokens par seconde, il y a un gouffre. (Publier des poids, c’est donner la recette. Publier le moteur, c’est donner la cuisine).

Et c’est la première fois qu’un labo de cette taille ouvre cette porte.

Le moteur, c’était pourtant son vrai avantage. Selon Vercel, en septembre, les modèles DeepSeek ont traité 58 % des tokens de sa plateforme pour 6,6 % de la dépense. Personne ne servait DeepSeek aussi bien que DeepSeek lui-même.

Ce moteur-là est maintenant sur GitHub.


Pourquoi c’est un morceau de bravoure ? Regardez les quatre problèmes qui se dressent entre des poids et un service.

  • D’abord, le modèle ne tient pas sur une carte. Plusieurs centaines de gigaoctets, face aux 192 gigaoctets qu’embarque une B200, la plus grosse carte du moment.
  • Lire une question et écrire la réponse sont deux métiers différents. L’un est un gros calcul d’un bloc, l’autre un filet de tokens.
  • Par défaut, le modèle relit tout l’historique à chaque réponse. Chez DeepSeek, 77 000 tokens par requête en moyenne. Dont 96 % déjà vus.
  • Enfin, 384 experts spécialisés, certains bien plus sollicités que d’autres. Il faut les répartir sur les cartes sans qu’un seul engorge tous les autres.

DeepSeek a résolu les quatre, et il a publié la solution, réglage par réglage.


La trouvaille, c’est le cache KV. En gros, les notes que le modèle prend sur chaque mot pour se souvenir de ce qu’il a lu.

Les chiffres :

Cache KV2023 (première génération)2026 (V4.1 Flash)
Octets par token389 120890
Une conversation de 77 000 tokens30 gigaoctets68 mégaoctets

Divisé par 437.

En trois ans !

Pour le dire simplement : avant, il fallait garder cette conversation en mémoire vive. La mémoire la plus chère de la machine. Aujourd’hui, elle tient sur un bête SSD.

Et c’est exactement ce qu’ils font. 100 pétaoctets de SSD, sur un système de fichiers distribué maison. Les conversations restent posées là trois à sept jours.

Résultat : 96 % des tokens déjà lus sont récupérés depuis le disque au lieu d’être recalculés. La lecture, devenue le vrai coût de l’inférence, s’effondre.


La mécanique derrière tient en une phrase : DeepSeek a conçu le modèle et le serveur ensemble. Comme Apple conçoit la puce et le logiciel ensemble.

V4.1 Flash active 8 milliards de paramètres pour lire, 16 pour écrire. Lire coûte deux fois moins cher qu’écrire. Partout ailleurs, c’est la lecture qui plombe la facture.

La répartition, en clair :

ÉtageRéglage
Préremplissage (lecture)EP2 à 8
Décodage (écriture)EP64 à 128
Experts par GPU7

Lecture et écriture tournent sur des machines séparées. Les experts sont répartis à raison de sept par carte.

Ajoutez le décodage spéculatif. C’est plus ou moins l’équivalent d’un brouillon écrit d’avance, qu’on ne recopie que s’il est bon. DeepSeek en tire 4 à 7 % de débit en plus.

Et un ordonnanceur asynchrone, qui ne laisse jamais une carte inactive.

La FAQ de DeepInfer détaille tout ça noir sur blanc. Chiffres de réglage compris.


Une précision, pour être juste : tout n’est pas ouvert.

Le cache et la répartition de charge entre serveurs restent fermés. Trop collés à leur infrastructure. Le README le dit en toutes lettres.

Mais ce n’est pas ça, la leçon. En quelques jours, vLLM, le moteur open source américain dont DeepInfer est issu, a réimplémenté les mêmes idées. Et retrouvé le même chiffre : 38,96 dollars par GPU et par heure.

Le rempart n’est pas dans le code. Il est dans la discipline du co-design. Et celle-là ne se télécharge pas.


Restent les comptes. Ceux du titre.

38 dollars par GPU et par heure, en heures creuses. Un plafond de facturation, pas un bénéfice net. Il faut le dire.

Mais à ce rythme :

Une carte à 55 000 $Temps pour se rembourser
Servie par DeepSeek (38 $/h)2 mois
Louée par CoreWeave (5,27 $/h)1,2 an

Vendre des tokens rapporte quatre à sept fois plus que louer la carte.

C’est pour ça que les loueurs de GPU devraient lire ces comptes deux fois.


Parce que la suite est brutale.

SemiAnalysis prévoit 50 gigawatts de capacité ajoutée en 2027, hors Chine. Aux tarifs de DeepSeek, un gigawatt produit 150 milliards de dollars de tokens par an. Multiplié par 50 : 7 500 milliards. Six pour cent du PIB mondial.

Anthropic et OpenAI réunis facturent 120 milliards par an.

De deux choses l’une : soit la demande est multipliée par soixante, soit les prix s’effondrent.

Et le marché a déjà commencé à trancher. Selon Vercel, les modèles à poids ouverts fournissent 71,5 % des tokens pour 23 % de la dépense.


Alors que faire, quand on bâtit sur l’IA ?

Ne pas parier sur une pénurie de calcul éternelle.

Construire de quoi changer de moteur en une après-midi, plutôt que de se marier avec un fournisseur.

Mettre sa valeur là où DeepSeek ne peut pas la copier : ses données, son flux de travail, sa garantie quand ça casse.

Dépêche

MACHINES

DeepSeek published its accounts. GPU renters should read them

On October 20, DeepSeek published DeepInfer, the engine that runs its models in its own data centers. Not another model: the kitchen. And with it, numbers GPU renters should probably read twice.

DeepSeek published its accounts. GPU renters should read them

On October 20, DeepSeek published the engine that serves its models. Apache 2.0. Commercial use, no strings attached. Twenty thousand GitHub stars in a week.

The comfortable reading is that DeepSeek is the open-source white knight again, giving everything away. The less comfortable reading is that it just handed over the one thing it never had to.

Here is the thing about weights. A model's weights are a 510-gigabyte file of matrices. Anyone can download them. What nobody can download is everything between those matrices and a service that answers 200 tokens a second, around the clock, for a few million people. That is the engine. The weights are the recipe; the engine is the kitchen. And until that Tuesday, no lab of this size had opened the kitchen.

Why does that matter? Because between weights and a service sit four problems:

1. The model doesn't fit on a card. A few hundred gigabytes, against the 192 a B200 carries.
2. Reading a question and writing the answer are two different jobs. One is one big blocking calculation, the other a trickle of tokens.
3. By default, the model re-reads the entire conversation on every answer. At DeepSeek, 77,000 tokens per request on average, 96% of which it has already seen.
4. 384 specialized experts, some far more solicited than others, to spread across cards so that no single one clogs the rest.

DeepSeek solved all four, and then published the solution, setting by setting.

The part that jumps out is the KV cache — the notes the model takes on each word so it can remember what it read. Three years ago, the first DeepSeek stored 389,120 bytes per token. V4.1 Flash today: 890. Divided by 437.

KV cache2023 (first generation)2026 (V4.1 Flash)
Bytes per token389,120890
A 77,000-token conversation30 GB68 MB

In plain terms: that conversation used to have to live in GPU memory, the most expensive memory in the machine. Now it lives on a boring SSD. Which is exactly what they do — 100 petabytes of SSD on a homegrown distributed file system, keeping conversations around for three to seven days. The result: 96% of already-read tokens get pulled off disk instead of recomputed. Reading, which has become the real cost of inference, collapses.

The mechanics fit in one sentence: DeepSeek designed the model and the server together, the way Apple designs the chip and the software together. V4.1 Flash activates 8 billion parameters to read and 16 to write. Reading costs half as much as writing. Everywhere else, reading is what bloats the bill.

StageSetting
Prefill (reading)EP2 to 8
Decode (writing)EP64 to 128
Experts per GPU7

Reading and writing run on separate machines, and the experts are spread seven to a card. Add speculative decoding — more or less the equivalent of writing a draft ahead of time and only copying it out if it's good — plus an asynchronous scheduler that never leaves a card idle. DeepInfer's FAQ spells all of this out in black and white, tuning values included.

To be fair, not everything is open. The cache and the load balancing between servers stay closed, too tied to their infrastructure. The README says so. But that isn't the lesson. Within days, vLLM — the American open-source engine DeepInfer is actually built on — reimplemented the same ideas and landed on the same number: $38.96 per GPU-hour. The moat was never the code. It is the co-design discipline, and that does not download.

Which brings us to the accounts. The ones in the title.

$38 per GPU-hour, off-peak. A billing ceiling, not a net profit — let's be clear. But at that rate:

A $55,000 cardTime to pay itself back
Served by DeepSeek ($38/h)2 months
Rented by CoreWeave ($5.27/h)1.2 years

Selling tokens pays four to seven times more than renting the card. If you are in the business of renting GPUs, you probably want to read those numbers twice.

Because it gets worse. SemiAnalysis expects 50 gigawatts of new capacity in 2027, outside China. At DeepSeek's prices, one gigawatt produces $150 billion of tokens a year. Times fifty: $7,500 billion. Six percent of world GDP. Anthropic and OpenAI combined bill about $120 billion a year. Either demand rises sixty-fold, or prices fall through the floor. And the market has already started choosing: at Vercel, open-weight models supply 71.5% of tokens for 23% of the spend.

So what do you do if you build on AI? Don't bet on an eternal compute shortage. Build so you can swap engines in an afternoon rather than marry a vendor. Put your value where DeepSeek can't copy it: your data, your workflow, your guarantee when it breaks.