What is a ternary LLM? BitNet 1.58-bit weights explainedQu'est-ce qu'un LLM ternaire ? Les poids 1,58 bit de BitNet

The Atome 944K checkpoint ships as a 271 KB binary. The same model stored as 32-bit floats is 3.7 MB. That roughly 14× shrink — about 20× at the smaller engine-default configuration — comes almost entirely from one decision: ternary weights. If you have heard the phrase “1.58-bit LLM” and wondered what it actually means, this is the short, practical version.Le point de contrôle 944K d'Atome est livré sous forme d'un binaire de 271 Ko. Le même modèle stocké en flottants 32 bits pèse 3,7 Mo. Cette réduction d'environ 14× — près de 20× dans la configuration par défaut du moteur, plus petite — provient presque entièrement d'une décision : les poids ternaires. Si vous avez entendu l'expression « LLM 1,58 bit » sans savoir ce qu'elle recouvre, en voici la version courte et concrète.

Three values per weightTrois valeurs par poids

In a normal neural network each weight is a 32-bit floating-point number. In a ternary network each weight is one of just three values: −α, 0, or +α, where α is a single scaling factor shared across a whole tensor. That is the BitNet b1.58 idea. Because three states carry log₂(3) ≈ 1.58 bits of information, the scheme is called “1.58-bit.” Packed efficiently in base-3 — the Atome ATOME01 format stores four trits per byte — the model collapses to a small fraction of its floating-point size.Dans un réseau de neurones classique, chaque poids est un nombre flottant 32 bits. Dans un réseau ternaire, chaque poids vaut l'une de trois valeurs seulement : −α, 0 ou +α, où α est un unique facteur d'échelle partagé sur tout un tenseur. C'est l'idée de BitNet b1.58. Comme trois états portent log₂(3) ≈ 1,58 bit d'information, on parle de « 1,58 bit ». Empaqueté efficacement en base 3 — le format ATOME01 d'Atome stocke quatre trits par octet — le modèle se réduit à une petite fraction de sa taille en flottant.

Why it is fast, not just smallPourquoi c'est rapide, pas seulement petit

Size is only half the story. Ternary weights also remove the multiplications from the matrix multiply: multiplying an activation by −1, 0, or +1 is a sign flip, a skip, or a copy — no floating-point multiply at all. On a microcontroller with no floating-point unit and no SIMD, that is an enormous saving. The expensive inner loop of inference becomes additions and sign changes, which a tiny Cortex-M core can do quickly and predictably.La taille n'est que la moitié de l'histoire. Les poids ternaires éliminent aussi les multiplications du produit matriciel : multiplier une activation par −1, 0 ou +1 revient à un changement de signe, un saut ou une copie — aucune multiplication flottante. Sur un microcontrôleur sans unité de calcul flottant ni SIMD, c'est une économie énorme. La boucle interne coûteuse de l'inférence se réduit à des additions et des changements de signe, ce qu'un petit cœur Cortex-M exécute vite et de façon prévisible.

What it costsCe que cela coûte

Quantization is never free. Three levels per weight is a genuine capacity limit, and the honest result is that the ternary inductive bias substitutes for capacity at small scale and constrains it at large scale. At about 60K parameters Atome's routed-ternary block beats a parameter-matched FP32 transformer by roughly 22% in perplexity. But scale the same recipe to about 944K parameters and a plain float model wins by roughly 11%. Ternary is the right tool when flash and RAM are the binding constraint — not when peak accuracy at scale is the goal.La quantification n'est jamais gratuite. Trois niveaux par poids constituent une vraie limite de capacité, et le résultat honnête est que le biais inductif ternaire compense la capacité à petite échelle et la contraint à grande échelle. Autour de 60K paramètres, le bloc ternaire routé d'Atome bat un transformeur FP32 à nombre de paramètres égal d'environ 22 % en perplexité. Mais portez la même recette à environ 944K paramètres et un modèle flottant classique l'emporte d'environ 11 %. Le ternaire est le bon outil quand le flash et la RAM sont la contrainte déterminante — pas quand l'objectif est la précision maximale à l'échelle.

Ternary vs other quantizationTernaire face aux autres quantifications

Most edge quantization stops at 8-bit (int8), which gives a 4× size reduction and keeps multiplies. Ternary goes much further on size and removes multiplies entirely, at the cost of more aggressive rounding. Atome also ships an optional power-of-three “spectrum” quantizer (levels {0, ±1, ±3, ±9}·α, about 2.81 bits) that recovers a little accuracy when the extra precision is worth the bytes — in the public three-seed run it edged plain ternary, 7.40 versus 7.77 perplexity. The point is that quantization is a dial, and ternary sits at the extreme end where memory matters most.La plupart des quantifications embarquées s'arrêtent au 8 bits (int8), qui offre une réduction de taille de 4× et conserve les multiplications. Le ternaire va beaucoup plus loin en taille et supprime entièrement les multiplications, au prix d'un arrondi plus agressif. Atome propose aussi un quantificateur « spectre » optionnel en puissances de trois (niveaux {0, ±1, ±3, ±9}·α, environ 2,81 bits) qui récupère un peu de précision quand les octets supplémentaires en valent la peine — dans le run public à trois graines, il a devancé le ternaire simple, 7,40 contre 7,77 de perplexité. L'idée est que la quantification est un curseur, et le ternaire se situe à l'extrême où la mémoire compte le plus.

All of this is reproducible from the public repository: the packing code, the trained checkpoints, and the step-by-step training logs are bundled so every number above can be checked, not just trusted.Tout ceci est reproductible depuis le dépôt public : le code d'empaquetage, les points de contrôle entraînés et les journaux d'entraînement pas à pas sont fournis, de sorte que chaque chiffre ci-dessus peut être vérifié et non simplement cru.

How training keeps ternary weights usableComment l'entraînement garde les poids ternaires utilisables

If you simply rounded a trained float model to three levels, you would destroy it — the rounding error per weight is enormous. Ternary models avoid this by being trained ternary from the start, using a straight-through estimator: the forward pass quantizes weights to {−α, 0, +α}, while the backward pass updates a hidden full-precision shadow copy as if the quantization were the identity. Over training, the network learns weights that are robust to being snapped to three levels, because it has only ever seen the quantized values in its own forward pass. The scaling factor α per tensor absorbs the overall magnitude, so the three levels carry the sign and sparsity while α carries the scale.Si vous arrondissiez simplement un modèle flottant entraîné à trois niveaux, vous le détruiriez — l'erreur d'arrondi par poids est énorme. Les modèles ternaires l'évitent en étant entraînés ternaires dès le départ, à l'aide d'un estimateur straight-through : la passe avant quantifie les poids vers {−α, 0, +α}, tandis que la passe arrière met à jour une copie fantôme cachée en pleine précision comme si la quantification était l'identité. Au fil de l'entraînement, le réseau apprend des poids robustes au fait d'être ramenés à trois niveaux, parce qu'il n'a jamais vu que les valeurs quantifiées dans sa propre passe avant. Le facteur d'échelle α par tenseur absorbe la magnitude globale, donc les trois niveaux portent le signe et la parcimonie tandis que α porte l'échelle.

The sparsity bonusLe bonus de parcimonie

The middle level — zero — is not just a value; it is free compression and free computation. A weight that is exactly zero contributes nothing to the output, so it can be skipped entirely in the matrix multiply. Trained ternary networks tend to push a large fraction of weights to zero, which means a meaningful share of the multiply-accumulate work simply disappears. On a microcontroller, where every cycle and every microamp counts, skipping zero-weighted connections is a direct, measurable saving, on top of the smaller flash footprint.Le niveau central — zéro — n'est pas qu'une valeur ; c'est de la compression gratuite et du calcul gratuit. Un poids exactement nul ne contribue en rien à la sortie, il peut donc être entièrement ignoré dans le produit matriciel. Les réseaux ternaires entraînés tendent à pousser une grande part des poids vers zéro, ce qui signifie qu'une part significative du travail de multiplication-accumulation disparaît tout simplement. Sur un microcontrôleur, où chaque cycle et chaque microampère compte, ignorer les connexions à poids nul est une économie directe et mesurable, en plus de l'empreinte flash réduite.

None of this is magic, and the trade-off from the main section still holds: three levels limit capacity, which is why ternary shines at small scale and is overtaken by float models when there is room for one. But it explains why a ternary model is not merely a compressed float model — it is a different object, trained differently, with computation and memory characteristics that suit a microcontroller far better than a rounded-down GPU model ever could.Rien de tout cela n'est magique, et le compromis de la section principale tient toujours : trois niveaux limitent la capacité, c'est pourquoi le ternaire brille à petite échelle et se fait dépasser par les modèles flottants quand la place existe. Mais cela explique pourquoi un modèle ternaire n'est pas simplement un modèle flottant compressé — c'est un objet différent, entraîné différemment, dont les caractéristiques de calcul et de mémoire conviennent à un microcontrôleur bien mieux qu'un modèle GPU arrondi ne le pourrait jamais.

Where ternary fits in the quantization landscapeOù le ternaire se situe dans le paysage de la quantification

It helps to place ternary on the same map as the quantization schemes you may already know. Full 32-bit floating point is the training default and the most accurate, but also the largest and the most expensive to compute. Eight-bit integer quantization, the workhorse of mobile and embedded inference, cuts size by four and keeps integer multiplies, which is a comfortable middle ground when you have a few megabytes to spend. Ternary sits at the far end of the spectrum: roughly twenty times smaller than float, with the multiplies removed entirely, at the cost of the most aggressive rounding. The right choice depends on where your binding constraint is. If you have megabytes, eight-bit is often the pragmatic pick. If your constraint is kilobytes of microcontroller SRAM and flash, ternary is the technique that actually fits, and Atome is built around that end of the dial rather than trying to be optimal everywhere.Il est utile de placer le ternaire sur la même carte que les schémas de quantification que vous connaissez peut-être déjà. La virgule flottante 32 bits complète est le défaut d'entraînement et la plus précise, mais aussi la plus grande et la plus coûteuse à calculer. La quantification en entiers 8 bits, le cheval de trait de l'inférence mobile et embarquée, réduit la taille par quatre et conserve les multiplications entières, un compromis confortable quand on dispose de quelques mégaoctets. Le ternaire se situe à l'extrémité du spectre : environ vingt fois plus petit que le flottant, avec les multiplications entièrement supprimées, au prix de l'arrondi le plus agressif. Le bon choix dépend de l'emplacement de votre contrainte déterminante. Si vous avez des mégaoctets, le 8 bits est souvent le choix pragmatique. Si votre contrainte est des kilooctets de SRAM et de flash de microcontrôleur, le ternaire est la technique qui tient réellement, et Atome est construit autour de cette extrémité du curseur plutôt que de chercher à être optimal partout.

Bottom lineEn résumé

A ternary LLM stores each weight as one of three values — about 1.58 bits instead of 32 — which is what lets a trained model shrink from megabytes to hundreds of kilobytes and drop the multiplies from inference. It is trained ternary from the start, not rounded after the fact, and the zero level buys both compression and skipped computation. The trade-off is real: three levels help at small scale and constrain at large scale, so ternary is the right tool when flash and RAM are the binding constraint. That is precisely the regime Atome is built for.Un LLM ternaire stocke chaque poids comme l'une de trois valeurs — environ 1,58 bit au lieu de 32 — ce qui permet à un modèle entraîné de passer de mégaoctets à des centaines de kilooctets et d'éliminer les multiplications de l'inférence. Il est entraîné ternaire dès le départ, pas arrondi après coup, et le niveau zéro apporte à la fois compression et calcul économisé. Le compromis est réel : trois niveaux aident à petite échelle et contraignent à grande échelle, donc le ternaire est le bon outil quand le flash et la RAM sont la contrainte déterminante. C'est précisément le régime pour lequel Atome est conçu.

Frequently asked questionsQuestions fréquentes

← All posts← Tous les articles Source & data on GitHubCode & données sur GitHub