BitNet b1.58 : le LLM 1 bit de Microsoft qui exécute un modèle 100 B sur un seul processeur
##Présentation
En avril 2025, Microsoft Research a discrètement brisé l'une des hypothèses les plus anciennes de l'IA : selon laquelle pour obtenir de bonnes performances à partir d'un grand modèle de langage, vous avez besoin de pondérations à virgule flottante de pleine précision. Ils ont publié BitNet b1.58 2B4T, le premier grand modèle de langage open source formé à partir de zéro en utilisant uniquement des poids ternaires — valeurs de {-1, 0, +1} — et a fourni des résultats qui correspondent ou battent les modèles 10 fois plus grands sur la plupart des benchmarks.
Le nom « 1,58 bits » vient d'un simple aperçu de la théorie de l'information : représenter trois états distincts nécessite « log₂(3) ≈ 1,58 » bits. En limitant chaque paramètre à ces trois valeurs, BitNet atteint la limite théorique de ce qu'un système de pondération à 3 états peut coder. La désignation « b1.58 » n’est pas un gadget marketing : elle est précise, mesurable et prouvée optimale pour la quantification ternaire.
Les chiffres sont frappants. Un modèle de 2 milliards de paramètres qui tient dans moins de 700 Mo d'espace disque. Un modèle de 100 milliards de paramètres qui fonctionne à 5 à 7 jetons par seconde sur un seul processeur, soit une vitesse de lecture proche d'un humain. Un gain d'efficacité énergétique allant jusqu'à 82,2 % sur les processeurs x86 par rapport aux références de pleine précision. Il ne s'agit pas d'une optimisation incrémentielle. Il s'agit d'un nouveau point sur la frontière de Pareto.
Dans cet article, nous expliquons comment BitNet fonctionne sous le capot, où il se situe par rapport aux modèles concurrents tels que Qwen2.5, Gemma et SmolLM2, comment vous pouvez le faire fonctionner localement aujourd'hui et ce que l'avenir réserve à l'infra-IA 1 bit.
Table of Contents
- Le problème : les LLM sont trop chers pour être partout
- La solution : BitNet b1.58 – Architecture née pour les poids ternaires
- Mise en route : exécutez BitNet b1.58 sur votre machine dès aujourd'hui
- Sous le capot : pourquoi BitNet est rapide et pourquoi c'est important
- Où BitNet b1.58 se situe par rapport aux modèles concurrents
- Avancé : modèles de déploiement de production
- Comparaison et alternatives : où se situe BitNet dans l'écosystème de quantification
- Conclusion et prochaines étapes
Le problème : les LLM sont trop chers pour être partout
!BitNet b1.58 performance benchmarks: 1-bit vs full precision across latency, memory, accuracy
Pour comprendre pourquoi BitNet est important, vous devez commencer par une dure vérité : les LLM ouverts de pointe ne sont pas pratiques pour la plupart des scénarios de déploiement du monde réel.
Les chiffres racontent l'histoire. L'exécution d'un modèle de 7 milliards de paramètres avec une précision maximale nécessite environ 14 Go de VRAM pour l'inférence. Quantifiez-le jusqu'à 4 bits et vous avez toujours besoin de près de 4 Go. Quoi qu’il en soit, la plupart des ordinateurs portables grand public, des appareils de pointe et des microserveurs sont verrouillés. Même les serveurs d'inférence modestes coûtent des centaines de dollars par mois en heures GPU. Pour une startup créant un chatbot, une équipe déployant un assistant de connaissances interne ou un développeur exécutant des expériences sur un ordinateur portable, la qualité du modèle est peut-être là, mais pas l'infrastructure.
Les méthodes de quantification existantes – INT4, INT8, GPTQ, AWQ – ont été conçues comme des étapes post-formation appliquées à des modèles de pleine précision. Ils sont efficaces pour compresser les empreintes mémoire, mais ils sont fondamentalement limités : vous exécutez toujours des opérations arithmétiques sur des valeurs qui se comportent fondamentalement comme des nombres à virgule flottante. Ils réduisent le coût de l'échelle ; ils ne changent pas la géométrie du problème.
Ce dont l'industrie a réellement besoin, c'est d'une architecture de modèle conçue dès le départ pour une représentation avec une précision minimale — une architecture dans laquelle le processus de formation lui-même produit des pondérations naturellement discrètes. C'est exactement ce que propose BitNet.
La solution : BitNet b1.58 – Architecture née pour les poids ternaires
BitNet b1.58 n'est pas une version quantifiée d'un modèle pleine précision. Il a été entraîné à partir de zéro sur un corpus de 4 000 milliards de jetons, toutes les couches linéaires étant remplacées par une nouvelle couche « BitLinear » personnalisée qui applique des pondérations ternaires tout au long du processus de formation. Cette distinction est extrêmement importante : la quantification post-formation perd toujours quelque chose en traduction. L'entraînement natif avec une précision de 1,58 bits garantit l'absence de prune fuite de décision se produit.
Le poids ternaire : {-1, 0, +1}
La quantification de base utilise un schéma absmean qui mappe les valeurs de poids à virgule flottante à un ensemble ternaire d'entiers signés lors de chaque passage avant. Le facteur d'échelle est calculé comme l'inverse de la valeur absolue moyenne sur le tenseur de poids :
scale_w = 1 / moyenne(|W_ij|)
W_quantized = pince(-1, 1)(rond(W × scale_w))La valeur zéro n'est pas seulement pratique : elle introduit une parsité utile. Environ 40 à 60 % des poids dans un modèle quantifié de cette manière atterrissent à zéro ou près de zéro, ce qui signifie que les multiplications matricielles peuvent ignorer des pans entiers de calcul. Il s'agit de la même astuce de parcimonie qui sous-tend les modèles de mélange d'experts — sauf qu'ici, la parcimonie est une propriété du schéma de quantification, et non un choix délibéré de routage architectural.
BitLinear : la pierre angulaire
Chaque torch.nn.Linear dans le transformateur est remplacé par une couche BitLinear avec trois modifications :
- Quantisation du poids en ternaire
{-1, 0, +1}via absmean (ci-dessus) - Quantification d'activation sur INT8 via absmax, appliquée par jeton — maintient l'activation absolue maximale par ligne mappée à 127, déplaçant l'intégralité des activations du jeton dans la plage INT8 sans perdre d'informations relatives
- SubLayerNorm (une variante simplifiée de LayerNorm) placé avant l'activation de la quantification pour la stabilité de l'entraînement dans le régime quantifié
Le pipeline de formation introduit Straight Through Estimator (STE) pour gérer le « round() » non différenciable dans la fonction de quantification — lors du passage en arrière, l'étape d'arrondi est remplacée par une identité (détacher), de sorte que la quantification est effectivement traitée comme différentiable. Combinée aux fonctions d'activation « Squared ReLU » dans les couches de rétroaction et aux intégrations positionnelles rotatives (RoPE), l'architecture converge de manière stable à ce niveau de précision extrême.
Que signifie réellement « 1,58 bits » – et pourquoi il bat « 1 bit »
Un point de confusion courant : « 1,58 bits » signifie-t-il 1 bit ? Pas tout à fait. Un seul trit code log₂(3) ≈ 1,585 bits d'information. Un réseau de 1 000 de ces trits stocke environ 1 585 bits de capacité d'informations.
En revanche, un véritable réseau binaire à 1 bit ne peut faire la distinction qu'entre {−1, +1} — pas de zéro, donc pas de parcimonie, pas de mécanismes de saut efficaces. Les auteurs de BitNet b1.58 ont montré que l'ajout du troisième état (zéro) surpasse considérablement les approches uniquement binaires sans modifier sensiblement le coût de stockage. Les ~0,58 bits supplémentaires par poids sont une bonne affaire pour les gains de précision et d'efficacité qu'ils permettent.
Mise en route : exécutez BitNet b1.58 sur votre machine dès aujourd'hui
BitNet b1.58 fonctionne sur CPU (x86 et ARM), avec des noyaux GPU publiés en mai 2025 et la prise en charge des NPU sur la feuille de route. Voici comment commencer.
Installer bitnet.cpp
Le framework d'inférence officiel est microsoft/BitNet, un framework C++/Python construit sur la fondation llama.cpp :
## Cloner le dépôt
clone git https://github.com/microsoft/BitNet.git
cd BitNet
## Installer les dépendances Python
pip install -r exigences.txt
## Téléchargez le modèle recommandé (quantification 2B, I2_S)
python utils/prepare_model.py microsoft/BitNet-b1.58-2B-4TExécuter l'inférence
## Démarrez le serveur
./build/bin/llama-server -m models/BitNet-b1.58-2B-4T/ggml-model-i2_s.gguf \
-c 2048 --threads 4
## Envoyer une complétion via l'API (par défaut : http://localhost:8080)
curl http://localhost:8080/completion -H "Type de contenu : application/json" \
-d '{"invite":"Expliquez l'informatique quantique en un seul paragraphe.", "n_predict": 256}'Sur un processeur d'ordinateur portable moderne, vous devriez voir des réponses de l'ordre de centaines de jetons par seconde. Sur un modèle à l'échelle 100 B (toujours avec un seul processeur), vous verrez environ 5 t/s, ce qui est lisible en temps réel. Ce dernier point a de profondes implications.
Alternative au visage câlin : affinez le vôtre
Si vous souhaitez affiner les modèles existants plutôt que de vous entraîner à partir de zéro, l'équipe de Hugging Face a publié en septembre 2024 un pipeline qui adapte tout LLM existant à une précision de 1,58 bits sans recyclage à partir de zéro. Avec juste une installation pip des derniers « transformateurs » :
à partir des transformateurs, importez AutoModelForCausalLM, AutoTokenizer
importer une torche
modèle = AutoModelForCausalLM.from_pretrained(
"Jetons HF1BitLLM/Llama3-8B-1.58-100B",
device_map="cuda",
torch_dtype=torch.bfloat16,
)
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B-Instruct")Ceci est extensible, accessible et immédiatement utile pour toute personne travaillant déjà dans l'écosystème Hugging Face.
Sous le capot : pourquoi BitNet est rapide et pourquoi c'est important
Densité de mémoire extrême
Un modèle de 2 milliards de paramètres à 1,58 bits par paramètre pèse environ 400 Mo de poids de modèle, soit environ ce qu'occupe une seule photographie haute résolution. Il ne s’agit pas seulement d’une curiosité technique ; il permet des scénarios de déploiement qui étaient tout simplement impossibles auparavant :
L'arithmétique de l'énergie
Le nombre le plus puissant de l'article BitNet se trouve dans un tableau comparatif de la consommation d'énergie pour les opérations de multiplication matricielle :
Une seule multiplication matricielle INT8 consomme environ 4,4 % de l'énergie d'une multiplication FP16 pour les additions et ~20,5 % pour les multiplications. Depuis que BitNet remplace les opérations d'ajout de multiplication FP16 par des opérations d'ajout INT8 - où l'addition elle-même est triviale en énergie - les économies d'énergie composées sur des milliards d'opérations par passe d'inférence s'élèvent à 71,9 % à 82,2 % de réduction d'énergie sur x86 et 55,4 % à 70,0 % sur ARM.
Il ne s’agit pas seulement d’une expérience d’ordinateur portable plus rapide. Il s'agit d'un changement fondamental dans la physique du coût par jeton de l'inférence de l'IA, avec des implications directes sur l'empreinte environnementale de l'exécution des LLM à grande échelle.
Comment BitNet.cpp atteint la vitesse
Le moteur d'inférence BitNet.cpp est construit sur des noyaux optimisés pour les tables de recherche (LUT) inspirés de T-MAC, un projet Microsoft axé sur l'exécution d'opérations tensorielles sur les microcontrôleurs Cortex-M :
- Les implémentations parallèles du noyau publiées en janvier 2026 ont ajouté une mosaïque configurable sur toutes les plates-formes matérielles, offrant une accélération supplémentaire de 1,15x à 2,1x.
- Démo du modèle de paramètres 2B : une démo en direct hébergée par Azure (
demo-bitnet-h0h8hcfqeqhrf5gf.canadacentral-01.azurewebsites.net) exécute BitNet b1.58 3B sur un Apple M2, accessible à toute personne sans configuration - Stockage des poids mappé en mémoire : puisque les poids ne sont que des recherches à partir d'un petit ensemble de valeurs
{-1, 0, +1}, le noyau évite le mur de mémoire qui entrave le trafic.conceptions supplémentaires de stockage de poids
La version 2025 du noyau d’inférence GPU a considérablement élargi l’histoire. Bien que l'inférence CPU reste l'élément phare des performances, le noyau GPU permet aux modèles BitNet b1.58 d'être déployés dans des contextes qui nécessitent un débit plutôt qu'une simple latence brute.
Où BitNet b1.58 se situe par rapport aux modèles concurrents
Comment fonctionne réellement un modèle 2B quantifié ternaire de 400 Mo ? Le rapport technique d'avril 2025 compare BitNet b1.58 2B4T aux modèles à poids ouvert les plus compétitifs dans la plage de paramètres 1 à 3B :
BitNet b1.58 2B4T est en tête sur ARC-Challenge, GSM8K et CommonsenseQA – des domaines qui nécessitent un raisonnement précis et un rappel des connaissances du monde – et reste compétitif sur les tâches de bon sens et de raisonnement.
Le plus frappant est qu'il le fait tout en utilisant une empreinte mémoire environ 4,5 fois inférieure à celle de son concurrent le plus proche. La comparaison de la latence d'inférence est tout aussi frappante : dans les tests de référence de la communauté, elle a enregistré une latence de 29 ms par rapport à la plage de 50 à 200 ms des concurrents. La plupart des modèles testés se situaient dans la plage de paramètres 1B-2B. BitNet b1.58 était plus rapide sur tous les plans.
Les discussions communautaires sur r/LocalLLaMA de Reddit ont également confirmé ces résultats. Un benchmarker a spécifiquement exécuté des modèles 1 bit sur ARM et x86 et a trouvé que BitNet b1.58 était le modèle 1 bit le plus rapide sur toutes les plates-formes – bien qu'ils aient noté que le domaine était encore en pleine maturité.
Avancé : modèles de déploiement de production
Sans serveur sur AWS Lambda
L'employé d'AWS Manu Mishra a publié un didacticiel complet exécutant BitNet b1.58 sur AWS Lambda en tant que fonction de conteneur. Points clés à retenir de ce modèle :
## Environnement spécifique à Lambda - évite les conflits de threads
importer le système d'exploitation
os.environ['OMP_NUM_THREADS'] = '1'
os.environ['OMP_THREAD_LIMIT'] = '1'
os.environ['GGML_OPENMP'] = 'OFF'
os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'L'image du conteneur pèse environ 1,1 Go, toutes dépendances comprises (dans la limite de 250 Mo compressés / 10 Go décompressés de Lambda) et utilise une construction Docker en deux étapes pour exclure tous les artefacts de construction de l'image finale. Cela définit un modèle concret pour BitNet sans serveur dans n'importe quel environnement FaaS.
IA sur appareil et inférence Edge
Étant donné que le chemin d'inférence CPU uniquement ne nécessite aucun matériel spécialisé, BitNet b1.58 est un candidat naturel pour :
- IA sur smartphone sur l'appareil : l'empreinte du modèle de 400 Mo est suffisamment petite pour être pré-intégrée dans des applications
- Inférence Raspberry Pi / SBC : fonctionne entièrement sur les ordinateurs monocarte ARM sans exigences GPU
- Browser / WebAssembly : Une possibilité intéressante à long terme ; BitNet.cpp est C++ et pourrait être compilé en WASM
- Contrôleur IoT AI : le budget énergétique du jeton d'environ 0,028 J par inférence et les exigences de stockage minimes en font la première option crédible de classe LLM pour les appareils de périphérie alimentés par batterie.
Comparaison et alternatives : où se situe BitNet dans l'écosystème de quantification
La distinction clé est natif et post-traitement : BitNet b1.58 a été conçu et formé pour les poids ternaires. Chaque technique de quantification post-formation applique une perte de précision à un modèle qui n'a jamais été conçu pour cela. BitNet b1.58 a internalisé la contrainte dès la première étape de l'optimiseur.
Alternatives dans l'espace :
- Modèles clairsemés de Neural Magic — élagage de poids agressif + quantification ; des performances extrêmement compétitives, mais l'écosystème est moins mature et les licences peuvent être restrictives
- TinyLlama / SMS-1B — Modèles 1.1B dépourvus de couches ; bon pour les projets de loisirs mais n'atteignant pas une précision comparable
- Distillation de style DistilBERT — la distillation des connaissances peut pousser plus loin les gains de 1,58 bits ; des recherches dans ce sens sont en cours
Conclusion et prochaines étapes
BitNet b1.58 n'est pas seulement un résultat papier soigné. Il remet en question les hypothèses économiques sur les coûts de fonctionnement d'un LLM : en termes de matériel, d'énergie et de délais. Un modèle 2B, 400 Mo que vous pouvez exécuter sur un ordinateur portable sans GPU, qui surpasse ses concurrents plusieurs fois sa taille sur les tâches de raisonnement, et qui y est parvenu grâce à une modification architecturale propre (remplacement de Linear par BitLinear et formation à partir de zéro) est un résultat véritablement historique.
Microsoft Research ne s'arrête pas à 2B. Ils ont indiqué des orientations de recherche claires pour l'avenir : des variantes LLM 1 bit plus grandes, des capacités multilingues, des extensions multimodales, des fenêtres contextuelles plus longues et, peut-être le plus excitant, une logique matérielle dédiée pour le calcul ternaire/trit, qui pourrait débloquer un saut d'efficacité de second ordre au-delà de ce que les processeurs x86 et ARM actuels peuvent offrir.
Ce que vous pouvez faire aujourd'hui :
- ⭐ Démarrez le dépôt : github.com/microsoft/BitNet
- 🚀 Exécutez BitNet localement : clonez et construisez
bitnet.cpp— cela prend moins de 10 minutes sur une machine moderne - 🐳 Essayez la démo en direct : demo-bitnet-h0h8hcfqeqhrf5gf.canadacentral-01.azurewebsites.net
- 📚 Lire l'article : L'ère des LLM 1 bit et le Rapport technique BitNet b1.58 2B4T
- 🔬 Affiner sur Hugging Face : récupérez le modèle Llama 3 8B 1,58 bits de HF1BitLLM et itérez
L’ère des LLM 1 bit n’est pas une curiosité marginale. C'est ici, c'est open source, et c'est peut-être ainsi que la plupart des IA seront exploitées dans trois à cinq ans. La question n'est plus de savoir si les LLM 1 bit fonctionnent, mais plutôt de savoir si vous serez prêt à construire avec eux.