GO TO A SECTION

↑ ↓ to navigate · Enter to openExplore all sections →
FDEInterviews logo
arXiv preprint

The Era of 1-bit LLMs: All Large Language Models are in 1.58 Bits

Weights of only -1, 0 or +1, trained from scratch: at 3B parameters, Microsoft's ternary model matched its FP16 baseline in perplexity with 3.55x less GPU memory and 2.71x faster decoding.

Breakdown by FDE Interviews · 10 min read · Updated

About the original · 2024
AUTHORS
Ma, Wang, Ma, Wang, et al.
FROM
Microsoft Research, University of Chinese Academy of Sciences
PUBLISHED
Feb 2024 · arXiv preprint
CITED BY
522Semantic Scholar · Nov 2026
IN THIS BREAKDOWN · 10 SECTIONS

You can read 22% of this breakdown.

01

The paper in one minute

BitNet trained Transformers with weights of +1 or −1 from scratch and got close to FP16 quality. BitNet b1.58 adds one more value, zero, so each weight is −1, 0 or +1. Three values need log₂3 ≈ 1.58 bits, hence the name. The zero lets the model switch individual inputs off, which the authors call feature filtering, and it makes the method much stronger.

The quantizer is simple. Divide each weight matrix by its mean absolute value, round, and clip to the range −1 to 1; about a third of the weights land on zero. Activations are quantized to 8 bits per token by their absolute maximum. The model is otherwise a LLaMA-style Transformer: RMSNorm, SwiGLU, rotary embeddings, no biases. As in BitNet, training keeps full-precision latent weights and quantizes on the fly.

The authors trained their own FP16 LLaMA baselines and BitNet b1.58 models at 700M, 1.3B and 3B parameters on 100 billion tokens of RedPajama. The ternary model trails at 700M and 1.3B and draws level at 3B: perplexity 9.91 against 10.04, and a seven-task zero-shot average of 50.2 against 49.7. Measured with a 2-bit kernel in FasterTransformer, the 3B model used 3.55 times less GPU memory and decoded 2.71 times faster. At 70B (costs only, no quality reported), it decoded 4.1 times faster, and two A100s served 11 times the batch size and 8.9 times the throughput. An energy model puts the matrix-multiply arithmetic at 71.4 times less energy, because ternary weights turn multiplications into 8-bit additions.

The paper argues this defines a new scaling law and calls for hardware built for 1-bit models. It is a short report, labeled work in progress, and every cost comparison is against FP16, not against the 4-bit quantized models people actually deploy.

THE IDEA, VISUALLY
ABSMEAN TERNARY QUANTIZATION (SECTION 2) gamma = mean |W| = 0.165 +0.31 +1 -0.02 0 +0.07 0 -0.40 -1 +0.12 +1 -0.15 -1 +0.03 0 +0.22 +1 W~ = RoundClip(W / gamma, -1, 1); ~1/3 of normal weights become 0. Activations: 8-bit per token. W~x = x1 - x4 + x5 - x6 + x8 (zeros skipped, no multiplies), then one rescale WHAT IS IN THE MODEL LLaMA-style body: RMSNorm, SwiGLU, rotary, no biases trained from scratch: 100B RedPajama tokens per size FP16 baselines reproduced by the authors, same data 3B ZERO-SHOT, 7 TASKS (TABLE 2) ARC-e ARC-c HS BoolQ OBQA PIQA WGe ternary minus FP16: ahead on 3 of 7; average 50.2 vs 49.7 3B AGAINST FP16 LLAMA (TABLE 1) FP16 b1.58 perplexity 10.04 9.91 GPU memory 7.89 GB 2.22 GB ms per token 5.07 1.87 70B WEIGHTS, THE BASELINE THAT IS MISSING FP16 (paper's baseline) 140 GB 4-bit, block 64 (not tested) 37.2 GB 2-bit packed (paper's kernel) 17.5 GB 1.58-bit ideal 13.9 GB 7.16x less than FP16, but about 2x less than a 4-bit model a customer would actually run 70B ON TWO A100S (TABLE 3) max batch 16 vs 176 (11x) 333 vs 2,977 tokens/s (8.9x) energy for matmul: 71.4x less (modeled) arXiv 2402.17764, Microsoft Research, February 2024
BitNet b1.58 rounds every weight to -1, 0 or +1 after scaling by the mean absolute weight, so a matrix multiply becomes additions and subtractions, with zeros skipped. Trained this way from scratch, a 3B model matched a reproduced FP16 LLaMA in perplexity and zero-shot average.
Research notes: the problem, approach and results
9.91 vs 10.04

perplexity of BitNet b1.58 3B and the reproduced FP16 LLaMA 3B, same data and tokens (Table 1)

3.55x / 2.71x

less GPU memory and faster decoding than FP16 LLaMA at 3B, measured with a 2-bit kernel (Table 1)

8.9x

throughput of BitNet b1.58 70B against FP16 LLaMA 70B on two A100 80GB GPUs (Table 3)

THE PROBLEM

The original BitNet showed 1-bit weights could be trained, but still trailed FP16 models of the same size. Post-training quantization below 4 bits loses too much quality, so cheaper inference needed a better low-bit training recipe.

THE IDEA

Add a zero to BitNet's weight values. An absmean quantizer scales each weight matrix by its mean absolute value and rounds to -1, 0 or +1; activations are 8-bit per token. The rest of the model follows LLaMA (RMSNorm, SwiGLU, rotary embeddings, no biases) so existing tooling can host it.

THE RESULT

Trained on 100B tokens of RedPajama, BitNet b1.58 matched a reproduced FP16 LLaMA at 3B: perplexity 9.91 against 10.04, zero-shot average 50.2 against 49.7, with 3.55x less memory and 2.71x lower decoding latency. At 70B it supported 11x the batch size and 8.9x the throughput on two A100s, all against FP16.

02

Why it matters to an FDE

BitNet b1.58 is the most cited argument that future models could be trained low-bit from the start. Knowing exactly what it shows keeps you from overselling or dismissing it.

It only helps models trained this way. Like BitNet, the gains require pretraining with ternary weights. A customer's existing model cannot be converted. The value depends on someone releasing a strong ternary model in the size they need.

The baseline is FP16, not 4-bit. Memory and speed ratios are against 16-bit models. The realistic alternative is a 4-bit post-training quantized model, which already cuts weight memory about fourfold. The paper does not measure that comparison, so do not quote "3.55x less memory" as the gain over what a customer would otherwise deploy.

Batch size and throughput are where it shines. At 70B on two A100s, the small weights left room for 11 times the batch. For high-volume serving, freed memory turns into throughput, the same mechanism that makes 4-bit attractive, pushed further.

THE FULL BREAKDOWN

Understand the mechanism. Try it on a real problem.

Unlock this breakdown and 290 more papers.

Premium opens every paper in full, plus every answer, concept, course and guide on the site. One payment for six months of access.

6 months · One payment · No auto-renewal

Get Premium · ₹2,000 / $25
  • ◇1 architecture diagram
  • </>1 runnable code experiment
  • ▦2 results tables
  • ?5 interview questions with answers
  1. 03Key takeaways

    The absmean quantizer, the role of zero, the scaling claims, what is measured and two misreadings

    Free account
  2. 04How it works

    The quantizer, activations, the LLaMA-style body, the training setup and how costs were measured

    Premium
  3. 05The numbers that matter

    Tables 1-4: perplexity, cost, zero-shot, throughput and the 2T-token comparison

    Premium
  4. 06Try it yourself

    Ternarize a weight matrix, count the bytes against a 4-bit baseline, and recheck the tables

    Premium
  5. 07Where it breaks

    The missing 4-bit baseline, small-scale quality evidence, kernels, and what was not released

    Premium
  6. 08Using it on a deployment

    What to ask for before planning around a ternary model, and how to compare it fairly

    Premium
  7. 09Interview angles

    Five questions this paper prepares you for, with answer hints

    Premium
Back to the paper library →