Precision Numerics 发布 1-bit 模型 Boole-1.7B，权重仅 247 MB

Published

October 11, 2026

Author

Hyochan Chong

We are releasing Boole-1.7B, a 1-bit language model derived from Qwen3-1.7B, with 247 MB of stored weights. It scores 50.55 across ten benchmarks, compared with 58.83 for the BF16 baseline. This is 85.9% of the baseline’s ten-task average, with a 13.9× reduction in stored weight size.

HuggingFace Code On-Device Chat

Why 1-bit is hard

A binary weight is a sign, +1 or −1, and its magnitude comes from a scale shared by a group of weights. Two things make this difficult: sharing one magnitude discards information, and the scales themselves take storage.

One magnitude for many weights

A 4-bit format gives each weight one of sixteen levels, so weights in a group keep different magnitudes under a shared scale. A binary group keeps only the signs.

The best shared scale is the group’s mean magnitude^[1], and the error that remains is the variance of the magnitudes within the group:

\[ \begin{aligned} s_G^* &= \frac{1}{g}\sum_{i=1}^{g}|w_i| \\ \mathrm{MSE}_{G,\min} &= \frac{1}{g}\sum_{i=1}^{g}w_i^2 - (s_G^*)^2 \end{aligned} \]

For Gaussian weights with variance \(\sigma^2\), the magnitudes have mean \(\sigma\sqrt{2/\pi}\) and variance \(\sigma^2(1-2/\pi)\), and estimating that mean from \(g\) samples removes a \(1/g\) share of it:

\[ \frac{\mathbb{E}[\mathrm{MSE}_{G,\min}]}{\sigma^2} = \left(1-\frac{1}{g}\right)\left(1-\frac{2}{\pi}\right) \]

This is 36.1% at group size 128 and 35.2% at 32, approaching 36.3% of the weight variance as groups grow. Quadrupling the number of scales buys less than one percentage point. The calculation is idealized and does not predict accuracy loss, but it shows how little a shared scale can recover.

Scales cost storage

Smaller groups need more scales. A \(b_{\mathrm{scale}}\)-bit scale per \(g\) weights adds \(b_{\mathrm{scale}}/g\) bits to each weight:

\[ b_{\mathrm{eff}} = b_{\mathrm{weight}} + \frac{b_{\mathrm{scale}}}{g} \]

Lines use 16-bit scales. Dots use 8-bit block scales: NVFP4^[2] shares an E4M3 scale across 16 values; MXFP8, MXFP6, and MXFP4^[3] share an E8M0 scale across 32. NVFP4’s extra per-tensor scale is excluded.

With a 16-bit scale and groups of 32, the scale adds 0.5 bits per weight to every format. That is 33% of a 1-bit model’s storage, against 6% of an 8-bit model’s. Groups of 8 already cost 3 bits per weight at one bit, and a scale per weight costs 17, more than the 16-bit original.

Boole-1.7B

Boole-1.7B is a 1-bit version of Qwen3-1.7B, intended for English-language inference in non-thinking mode. The summary above compares it with the BF16 original and with PrismML’s 1-bit Bonsai-1.7B, in average score and in intelligence density: capability per gigabyte of weights.

Qwen3-1.7B at other precisions

The same base model exists at many precisions. The chart places Boole among them: Qwen3-1.7B in BF16 and FP8, Unsloth’s GGUF quantizations from 1 to 8 bits, and PrismML’s binary and ternary Bonsai-1.7B.

At nearly the same weight storage, Boole averages 5.58 points above binary Bonsai-1.7B (44.97). Ternary Bonsai-1.7B averages 51.57, 1.02 points above Boole, with 1.9× Boole’s weight storage. Unsloth’s 3-bit GGUFs average 46.57 (Q3_K_S) and 53.66 (Q3_K_M) at 3.5× and 3.8× Boole’s weight storage.

Boole improves on binary Bonsai in seven of ten tasks. The largest gains are in math and code; its scores are lower on MuSR, IFEval, and function calling (BFCLv3).

The small language model frontier

We next compare Boole with 23 small language models in 52 formats, all below 3 GB of weight storage.

Among the variants in this evaluation, Boole has the highest benchmark average at its storage size or below. The smallest variant with a higher average is Ternary-Bonsai-1.7B: 51.57 at 457 MB, or 1.9× Boole’s storage.

Intelligence density

Intelligence density measures benchmark capability per unit of weight storage. We use PrismML’s definition^[4], −ln(1 − average/100) / storage_GB, with the natural logarithm and decimal GB, computed from each model’s ten-task average and its recorded storage size. Higher is better.

Boole has the highest intelligence density of the evaluated models, 2.85 per GB. The next highest is LFM2.5-230M at 2.58.

What's next?

We are building systems to make your hardware more valuable, and pushing the efficiency frontier to benefit the open-source community. For local developers, let us know what you would like to see next. For teams and businesses, reach out to collaborate so we can help your team or business get the most out of your hardware.

References

1. Rastegari et al. (2016). XNOR-Net: ImageNet Classification Using Binary Convolutional Neural Networks. Section 3.1, equations 2–6.
2. NVIDIA. NVFP4. Transformer Engine documentation, data format and scaling factors.
3. Open Compute Project (2023). OCP Microscaling Formats (MX) Specification, version 1.0.
4. PrismML. Bonsai-8B whitepaper. Intelligence density definition.

Cite Boole

@misc{precisionnumerics2026boole1p7b,
  author = {{Precision Numerics}},
  title = {{Boole}-1.7B},
  year = {2026},
  month = {October},
  url = {https://huggingface.co/precision-numerics/Boole-1.7B}
}