Vérification des paramètres¶

Le décompte complet, pas à pas, depuis config.json jusqu'aux 2,4198 T.

La méthode¶

Une seule source d'entrée : le fichier config.json du dépôt officiel, 3,95 ko.

Une seule sortie observée pour contrôle : la taille du dépôt affichée par Hugging Face, 4,89 To sur 213 fragments.

Tous les calculs sont dans le script joint, en Python pur, sans dépendance.

Pourquoi cette vérification a une valeur

Un constructeur qui annonce « 2,4 T de paramètres » peut compter de plusieurs façons : avec ou sans embeddings, avec ou sans couche de prédiction multi-jetons, en arrondissant.

Refaire le calcul permet de savoir quelle convention est utilisée, et de détecter tout écart significatif.

Étape 1 — La structure des couches¶

"num_hidden_layers": 92,
"full_attention_interval": 4

\[ n_{\text{complètes}} = \frac{92}{4} = 23 \qquad n_{\text{linéaires}} = 92 - 23 = 69 \]

Confirmé par la liste layer_types, qui contient 92 entrées suivant le motif [linéaire, linéaire, linéaire, complète] répété 23 fois.

Étape 2 — Une couche d'attention complète¶

"num_attention_heads": 64,
"num_key_value_heads": 4,
"head_dim": 256,
"attn_output_gate": true

Projection	Dimensions	Paramètres
\(W_Q\) + porte	\(8\,192 \times (64 \times 256 \times 2)\)	268 435 456
\(W_K\)	\(8\,192 \times (4 \times 256)\)	8 388 608
\(W_V\)	\(8\,192 \times (4 \times 256)\)	8 388 608
\(W_O\)	\((64 \times 256) \times 8\,192\)	134 217 728
normalisations \(q\), \(k\)	\(2 \times 256\)	512
Total		419 430 912

Le facteur 2 sur \(W_Q\)

attn_output_gate: true implique que la projection des requêtes produit aussi la porte de sortie. C'est la convention de l'implémentation Qwen3-Next, dont ce modèle réutilise le code (Qwen3_5MoeForCausalLM).

Sans ce facteur, le total tomberait à 285 M par couche, et le décompte final manquerait 3 G — un écart détectable.

\[ 23 \times 419\,430\,912 = 9\,646\,910\,976 \approx 9{,}65\ \text{G} \]

Étape 3 — Une couche Gated DeltaNet¶

"linear_num_value_heads": 128,
"linear_num_key_heads": 16,
"linear_key_head_dim": 128,
"linear_value_head_dim": 128,
"linear_conv_kernel_dim": 4

Dimensions dérivées :

\[ d_{qk} = 16 \times 128 = 2\,048 \qquad d_v = 128 \times 128 = 16\,384 \]

Composant	Dimensions	Paramètres
`in_proj_qkvz`	\(8\,192 \times (2\,048 + 2\,048 + 16\,384 + 16\,384)\)	301 989 888
`in_proj_ba`	\(8\,192 \times (128 + 128)\)	2 097 152
convolution causale	\((2\,048 + 2\,048 + 16\,384) \times 4\)	81 920
`out_proj`	\(16\,384 \times 8\,192\)	134 217 728
normalisation	128	128
Total		438 386 816

\[ 69 \times 438\,386\,816 = 30\,248\,690\,304 \approx 30{,}25\ \text{G} \]

Étape 4 — Un bloc MoE¶

"num_experts": 512,
"moe_intermediate_size": 2048,
"shared_expert_intermediate_size": 2048

Un expert SwiGLU :

\[ 3 \times 8\,192 \times 2\,048 = 50\,331\,648 \]

Composant	Paramètres
512 experts routés	25 769 803 776
1 expert partagé	50 331 648
routeur (\(8\,192 \times 512\))	4 194 304
Total par couche	25 824 329 728

Toutes les couches ont un bloc MoE :

\[ 92 \times 25\,824\,329\,728 = 2\,375\,838\,334\,976 \approx 2\,375{,}84\ \text{G} \]

Étape 5 — Embeddings et tête¶

"vocab_size": 248320,
"hidden_size": 8192,
"tie_word_embeddings": false

\[ 248\,320 \times 8\,192 = 2\,034\,237\,440 \]

tie_word_embeddings: false signifie que la tête de sortie a ses propres poids :

\[ 2 \times 2\,034\,237\,440 = 4\,068\,474\,880 \approx 4{,}07\ \text{G} \]

Plus les normalisations : \(2 \times 8\,192 \times 92 + 8\,192 \approx 1{,}5\) M, négligeable mais comptées.

Étape 6 — Le total¶

Composant	Paramètres	Part
Blocs MoE	2 375 838 334 976	98,18 %
Couches DeltaNet	30 248 690 304	1,25 %
Couches d'attention complète	9 646 910 976	0,40 %
Embeddings + tête	4 068 474 880	0,17 %
Normalisations	~1 515 520	~0 %
Total	2 419 802 390 528	100 %

\[ \boxed{2{,}4198\ \text{T}} \]

Annoncé : 2,4 T. Écart : 0,83 %.

Vérification 1 passée

L'écart de 0,83 % s'explique entièrement par l'arrondi commercial. Le modèle contient bien environ 2,4 billions de paramètres, et la structure décrite par config.json est cohérente avec cette annonce.

Étape 7 — Les paramètres actifs¶

Par jeton, seuls 11 experts sur 513 sont évalués :

\[ 11 \times 50\,331\,648 + 4\,194\,304 = 557\,842\,432 \text{ par couche} \]

\[ 92 \times 557\,842\,432 = 51\,321\,503\,744 \approx 51{,}32\ \text{G} \]

Toute l'attention est active :

Composant	Actif
Blocs MoE	51 321 503 744
Couches DeltaNet	30 248 690 304
Couches d'attention complète	9 646 910 976
Tête de sortie	2 034 237 440
Normalisations	~1 515 520
Sous-total	93 252 857 984
Table d'embeddings	2 034 237 440
Total avec embeddings	95 287 095 424

Deux conventions, deux résultats :

Convention	Résultat	Écart avec 95 G annoncés
Hors table d'embeddings	93,25 G	1,84 %
Table d'embeddings incluse	95,29 G	0,30 %

Vérification 2 passée — et la convention est établie

L'accord à 0,30 % avec la convention « embeddings inclus » indique que c'est celle qu'utilise Qwen.

C'est une information utile en soi : elle permet de comparer correctement le chiffre « 95 G » à ceux d'autres constructeurs, qui n'utilisent pas tous la même convention.

Part du modèle activée :

\[ \frac{95{,}29}{2\,419{,}80} = 3{,}94\ \% \]

Étape 8 — La couche MTP et la taille du dépôt¶

C'est le résultat le plus instructif.

Le corps du modèle, en BF16 :

\[ 2\,419\,802\,390\,528 \times 2 = 4\,839\,604\,781\,056\ \text{octets} = 4{,}84\ \text{To} \]

Le dépôt affiche 4,89 To. Écart : 50 Go, soit environ 25 G de paramètres non expliqués.

Or config.json contient :

"mtp_num_hidden_layers": 1,
"mtp_use_dedicated_embeddings": false

Si cette couche reproduit le motif du modèle — un bloc d'attention complète plus un bloc MoE :

\[ 25\,824\,329\,728 + 419\,430\,912 = 26\,243\,760\,640 \approx 26{,}24\ \text{G} \]

\[ (2\,419\,802\,390\,528 + 26\,243\,760\,640) \times 2 = 4\,892\,092\,302\,336 = 4{,}892\ \text{To} \]

Écart avec les 4,89 To observés : 0,04 %.

Vérification 3 passée — un résultat que la documentation ne donne pas

L'accord à 0,04 % établit deux choses :

La couche MTP est bien présente dans les poids publiés.
Sa structure est cohérente avec « un bloc d'attention + un bloc MoE ».

Ni la carte de modèle ni le communiqué ne le disent. Et mtp_use_dedicated_embeddings: false est confirmé au passage : si la couche avait ses propres embeddings, il faudrait ajouter 2 G, ce qui dégraderait l'accord.

La limite du raisonnement

Un accord numérique n'est pas une preuve formelle. Une couche MTP de structure différente totalisant approximativement 26 G donnerait le même résultat.

Ce qui est établi : il y a environ 26 G de paramètres au-delà du corps du modèle. Ce qui est la meilleure explication : la couche MTP déclarée dans config.json.

Récapitulatif¶

Vérification	Calculé	Référence	Écart	Statut
Paramètres totaux	2,4198 T	2,4 T annoncés	0,83 %	✅
Paramètres actifs	95,29 G	95 G annoncés	0,30 %	✅
Taille du dépôt	4,892 To	4,89 To observés	0,04 %	✅

Aucune des trois affirmations chiffrées d'Alibaba sur l'architecture n'est démentie par le calcul.

Ce que cela signifie

Sur l'architecture, la communication d'Alibaba est exacte. Les approximations sont commerciales — arrondir 2,4198 à 2,4 — et non trompeuses.

C'est un point à créditer, et il contraste avec l'imprécision de la même communication sur la multimodalité et le contexte d'un million de jetons.

Rejouer les calculs¶

python3 verif-qwen3-8-max.py

Le script ne dépend de rien, ne lit rien en réseau, et sort avec un code non nul si une vérification échoue.