BitNet / Ternary / Binary — Les LLMs 1-bit#

TL;DR — BitNet est une architecture Transformer révolutionnaire où les poids sont binaires {-1, +1} (BitNet b1) ou ternaires {-1, 0, +1} (BitNet b1.58). Au lieu de multiplier, on additionne ou soustrait les activations — éliminant totalement les multiplications matricielles. BitNet b1.58 matche les Transformers FP16/BF16 en qualité tout en divisant la mémoire par ~10×. C'est potentiellement l'avenir de l'inférence LLM.

Le concept radical : pourquoi 1.58 bits ?#

Le constat#

Un LLM classique stocke chaque poids en FP16 ou BF16 : 16 bits par paramètre. Pour un modèle de 70B, cela représente 140 GB de mémoire. La quantification PTQ (GPTQ, AWQ) descend à 4-bit (17.5 GB), mais en deçà, la qualité s'effondre.

L'idée de BitNet : et si on entraînait un modèle from scratch avec des poids qui ne peuvent valoir que -1, 0, ou +1 ?

Pourquoi 1.58 et pas 1 ou 2 ?#

L'analogie pour néophyte#

Imagine que chaque poids d'un réseau de neurones est normalement un nombre à virgule complexe (0.0372...). BitNet dit : remplaçons chaque nombre par un simple signe : positif (+), négatif (−), ou zéro (rien). Au lieu de faire des multiplications compliquées, on ne fait qu'additionner ou soustraire les valeurs d'entrée. C'est comme remplacer une calculatrice scientifique par un compteur d'étiquettes : beaucoup plus rapide, beaucoup moins d'énergie — et étonnamment, ça marche aussi bien !

Papier source#

Mécanisme technique#

BitNet b1 (binaire) : la fondation#

Chaque poids de la couche BitLinear (remplaçant nn.Linear) vaut exactement +1 ou -1.

BitNet b1.58 (ternaire) : l'amélioration décisive#

Chaque poids vaut -1, 0, ou +1. L'ajout du zéro permet la sparsité.

La matrice ternaire en détail#

Comment entraîner un réseau ternaire ?#

Le défi : l'opération round() n'est pas différentiable. Comment backpropagé à travers une quantification ?

Réponse : Straight-Through Estimator (STE)

Architecture complète BitNet#

Performance comparée à FP16#

Le résultat choc de BitNet b1.58#

BitNet b1.58 matche ou surpasse les Transformers FP16/BF16 à taille de modèle équivalente :

b1.58 matche FP16 en perplexité ET en zero-shot tasks.

Avantages systémiques de BitNet b1.58#

Scaling law de BitNet#

BitNet b1.58 (ligne 2) suit la même courbe de scaling que FP16 Transformer (ligne 1) — les deux courbes convergent à mesure que la taille augmente.

BitNet b1.58 suit la même loi de scaling que les Transformers classiques : doubler la taille du modèle réduit la perplexité de la même manière. C'est ce qui rend cette approche crédible à grande échelle.

Pourquoi BitNet est potentiellement l'avenir de l'inférence LLM#

1. Élimination des multiplications#

2. Latence et throughput#

Sans multiplications, le bottleneck devient purement la bande passante mémoire pour charger les activations. Les poids ternaires sont si petits qu'ils tiennent entièrement en cache.

3. Nouveaux paradigmes hardware#

BitNet ouvre la voie à des chips spécialisés conçus pour les opérations ternaires :
- Pas besoin de FPU (floating-point unit)
- Pas besoin de multipliers
- Unités arithmétiques simplifiées → plus de cœurs sur le même silicium
- Consommation énergétique drastiquement réduite

Le défi majeur : entraînement from scratch#

BitNet b1.58 2B4T : premier modèle open-source#

C'est le premier modèle BitNet open-weight entraîné à grande échelle, permettant à la communauté de tester et développer l'écosystème.

BitNet vs quantification PTQ classique#

Exemple pratique#

Utiliser BitNet b1.58 2B4T#

# Installer le runtime BitNet
pip install bitnet

# Ou cloner le repository officiel
git clone https://github.com/microsoft/BitNet.git
cd BitNet
pip install -e .

from bitnet import BitNetModel
from transformers import AutoTokenizer

# Charger le modèle ternaire
model = BitNetModel.from_pretrained("microsoft/bitnet-b1.58-2B-4T")
tokenizer = AutoTokenizer.from_pretrained("microsoft/bitnet-b1.58-2B-4T")

# Inférence
inputs = tokenizer("Explique le concept de quantification ternaire :", return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=200)
print(tokenizer.decode(outputs[0]))

Inférence optimisée avec le runtime bitnet.cpp#

# Compiler le runtime C++ optimisé
cd bitnet
mkdir build && cd build
cmake ..
make -j

# Inférence CPU avec kernels ternaires optimisés
./bin/bitnet \
    -m models/bitnet-b1.58-2B-4T \
    -p "Que sont les LLMs 1-bit ?" \
    -n 200

Aperçu de l'entraînement d'un BitLinear#

import torch
import torch.nn as nn

class BitLinear(nn.Linear):
    """Couche linéaire ternaire BitNet b1.58"""

    def __init__(self, in_features, out_features, bias=False):
        super().__init__(in_features, out_features, bias=bias)

    def forward(self, x):
        # Quantification ternaire des poids avec STE
        w = self.weight  # poids continus (appris)

        # β = moyenne absolue des poids
        beta = w.abs().mean()

        # Quantification : round(w / β) → {-1, 0, +1}
        w_quant = torch.clamp(
            torch.round(w / (beta + 1e-8)),
            min=-1, max=1
        )

        # STE : en backward, le gradient passe à travers
        # (torch.detach() pour le forward, identité pour le backward)
        w_ste = w_quant.detach() + w - w.detach()

        # Multiplication = additions (le hardware le fera nativement)
        return torch.nn.functional.linear(x, w_ste, self.bias)

TernaryLM et autres implémentations#

Résumé : BitNet en 5 points#

1. Poids ternaires {-1, 0, +1} = 1.58 bits/poids → mémoire ÷ 10
2. Pas de multiplications → additions seulement → latence et énergie réduites
3. Qualité équivalente à FP16 (même loi de scaling)
4. Mais : entraînement from scratch obligatoire + hardware non optimisé
5. Potentiel énorme si le hardware ternaire émerge → pourrait redéfinir l'inférence LLM

Références#

• BitNet (b1) — Wang et al., "BitNet: Scaling 1-bit Transformers for Large Language Models", JMLR 2025 — arXiv:2310.11453
• BitNet b1.58 — Ma et al., "The Era of 1-bit LLMs: All Large Language Models are in 1.58 Bits", 2024 — arXiv:2402.17764
• BitNet b1.58 2B4T — "BitNet b1.58 2B4T Technical Report", 2025 — arXiv:2504.12285
• TernaryLM — arXiv:2602.07374
• Code officiel — github.com/microsoft/BitNet
• Voir aussi : Sub-byte Quantification · QAT · QuIP# · AQLM · Index quantification