Binarisation vs Quantisation

Quantisation takes a neural network trained with 32-bit floating-point arithmetic and maps its weights and activations to lower-precision formats — FP16, INT8, INT4, or even 1-bit.

Every neural network inference is dominated by multiply-accumulate operations. Each weight is stored as a 32-bit float, occupying 4 bytes of memory and consuming substantial energy when the processor reads it. Quantisation addresses this by asking: can we represent this weight with fewer bits and still get an acceptable answer?

The mathematics work like this. A floating-point value x is mapped to a quantised integer x_q using a scale factor S and a zero-point Z: x_q = clip(round(x / S + Z)). When the model actually runs, those integers are dequantised back: x ≈ S × (x_q − Z). The gap between the original value and the recovered approximation is quantisation error — information that cannot be recovered. It accumulates through every layer.

Two approaches dominate practice. Post-training quantisation (PTQ) applies after training is complete, using a small calibration dataset — typically around 200 representative samples — to determine optimal scale factors. It requires no retraining, which is why it is the preferred route for large language models. Quantisation-aware training (QAT) integrates simulated quantisation into the training loop itself, exposing the network to quantisation effects during learning. PyTorch benchmarks show QAT recovers up to 96% of accuracy degradation compared to PTQ on standard benchmarks.

The honest answer is: it depends entirely on which kind of binarisation you mean.

Weight binarisation — constraining a neural network’s weights to binary values of +1 or −1 — is indeed an extreme form of quantisation. It sits at the far end of the spectrum: FP32 → FP16 → INT8 → INT4 → binary. The same Straight-Through Estimator used across INT4 and INT2 also applies here. These are Binary Neural Networks (BNNs), and they inherit the same trade-off as every other step down the precision ladder — you gain efficiency, you give up accuracy. On ImageNet, XNOR-Net AlexNet achieved 44.2% top-1 accuracy versus 56.6% for the full-precision original — a gap of more than twelve percentage points.

Data binarisation is something else entirely. Rather than reducing the precision of existing numerical values, it transforms continuous input features into binary logical propositions — true-or-false statements that enable propositional logic reasoning. A temperature of 38.5°C does not become a less precise number. It becomes the proposition: “temperature_above_37 = TRUE.”

Quantisation compresses a value into fewer bits — the value still represents the same quantity, just with less precision. Data binarisation changes what is being represented entirely — from a number to a logical proposition. This is not lossy compression. It is a different language.

This is the binarisation that Tsetlin Machines and Logic-Based Networks use. The purpose is not approximation. It is a transformation from the numerical domain to the logical domain — unlocking propositional logic as the engine of inference, rather than matrix multiplication.

Quantisation

What it is

• Reduces the numerical precision of neural network weights and activations
• Compresses FP32 values to INT8, INT4, or binary (1-bit BNN)
• Applied to a trained model (PTQ) or integrated during training (QAT)
• Produces a smaller, faster version of the same neural network architecture
• Requires calibration data to determine optimal scale factors and zero-points

Examples

• INT8 inference for MobileNet on a smartphone — <1% accuracy loss
• GPTQ INT4 for LLaMA-3 on a single GPU — 2.69× throughput improvement
• TensorFlow Lite INT8 model running on an ARM Cortex-M3 with 16KB runtime
• NVIDIA TensorRT FP8 for BERT — 1.7× speedup over INT8

Data Binarisation (LBN)

What it is

• Transforms continuous input features into binary logical propositions
• Methods include thresholding, thermometer encoding, and multi-threshold binarisation
• Not compression — a representational transformation into the logical domain
• The native input format for Tsetlin Machines and Logic-Based Networks
• Enables propositional logic inference — no matrix multiplication required

Examples

• Temperature 38.5°C → “temperature_above_37 = TRUE”
• Vibration level 4.2g → “vibration_above_3g = TRUE, above_5g = FALSE”
• Sound frequency 3.2kHz → thermometer-encoded as a sequence of logical propositions
• Sensor fusion across 12 data channels on an ARM Cortex-M7 — 4µs inference, 4kB footprint

The gains from quantisation are real, and well understood. So are the limits.

The last row is not a more extreme version of what came before it. Logic-Based Networks are not Binary Neural Networks optimised further. They are a different architecture operating on a different computational foundation — which is precisely why the accuracy column reads differently.

Quantisation is the production workhorse of neural network deployment. INT8 is reliable, widely supported, and delivers genuine gains with minimal pain.

At INT8, post-training quantisation typically introduces less than 1% accuracy loss. The 70B-parameter Qwen3 model shows only a 0.04% accuracy drop at INT8 — essentially statistical noise. Model size drops 4×. Inference energy drops 18–30× per operation versus FP32, according to Dally (2015). This is the sweet spot, and it has broad hardware support: NVIDIA Tensor Cores, ARM NEON, and Intel VNNI all accelerate INT8 natively.

Reach for quantisation when:

• You have an existing neural network that you cannot retrain from scratch
• The model is destined for a GPU, mobile phone, or server — not a constrained MCU
• You need to reduce VRAM requirements to serve a large language model on fewer GPUs
• Accuracy loss of 1–6% is acceptable — and you have the benchmark infrastructure to verify it
• INT8 precision suffices; the significant complications begin below INT8

The 176B-parameter BLOOM model, which in full FP32 precision requires eight 80GB GPUs, runs on a single machine with INT8 quantisation. For LLM inference at scale, that is a compelling case.

Data binarisation is not a shortcut applied to an existing model. It is the foundation of a different approach to building AI — one designed from inception for the hardware that most of the world actually uses.

The industrial world is full of edge devices that will never run a GPU. Microcontrollers, sensor nodes, low-power IoT hardware — these chips have kilobytes of RAM, not gigabytes. They run on coin-cell batteries. A neural network, even an aggressively quantised one, is simply the wrong architecture for this environment. On an ARM Cortex-M4 running at 100MHz with ARM’s own CMSIS-NN optimisations, moderately complex CNN inference takes 100–500ms. For a battery-powered device making decisions every five seconds, that energy cost is prohibitive.

Data binarisation — as the entry point into Logic-Based Network training — is the appropriate choice when:

• The target hardware is a 32-bit MCU, CPU, or constrained edge device — no GPU, no TPU
• Battery life is a product constraint, not an afterthought
• The model must fit in kilobytes, not megabytes
• The application requires explainable decisions — regulatory environments, safety-critical systems
• Outputs must be fully deterministic: identical inputs must always yield identical outputs
• Data arrives as sensor readings, time series, or tabular signals — the native domain of binarisation

A UK water utility deploying IoT sensors across 100,000 sewer sites found that the LSTM model that worked perfectly on paper required £15,000 of mains-power infrastructure per installation. On battery, the sensor lasted three months. An LBN running on the same existing sensor hardware projects a ten-year battery life, making predictions every five seconds, at 455 microjoules per inference. The numbers, as the project brief put it, simply work.

The two techniques are not mutually exclusive, and some deployment scenarios benefit from combining them in sequence.

The most common hybrid approach uses binary weights alongside quantised activations. Many practical Binary Neural Networks keep activations at 8-bit precision whilst binarising weights, trading a modest accuracy recovery for the bulk of the memory and compute savings.

A sequential pipeline approach applies three stages in order: pruning to remove redundant connections, quantisation to compress remaining weights, and binary layers for the compute-intensive middle sections whilst quantised INT8 layers handle input and output. Research shows batch normalisation parameters in BNNs can be quantised to 4-bit with reasonable trade-offs — below 4-bit, performance degrades significantly.

For Logic-Based Networks, this hybrid question has a different shape. Quantisation in the traditional sense is irrelevant to LBNs — there are no floating-point weights to compress. The complementary technique is instead sparsity optimisation, which removes redundant logical clauses and literals after training. Literal Labs’ ETHEREAL approach achieves up to 87.54% model size reduction through sparsity — applied to a model already operating natively at 1-bit. The result is not a degraded version of a larger model. It is a refined version of a model built to be small.

Quantisation is a powerful technique with real limitations. Understanding them is the beginning of understanding why a different architecture exists.

Accuracy degradation is non-linear and accelerates sharply below INT8. While INT8 introduces less than 1% accuracy loss on most models, INT4 produces 1–6% degradation depending on the architecture. At INT2 (ternary) and binary, accuracy drops of 10–30% on complex tasks such as ImageNet classification are common. At each step, the problem compounds: INT4 offers only 16 distinct values; binary offers just 2.

Not all layers respond equally. First and last layers — embedding layers, output classification layers, shortcut-connected layers — are typically most sensitive to quantisation. Mixed-precision approaches, assigning different bit-widths to different layers, help but add significant complexity. Sensitivity analysis tools are required to identify vulnerable layers, and even then, optimal per-layer bit-width selection remains an active research problem.

Calibration presents its own difficulties. Outliers in activation distributions consume disproportionate dynamic range, degrading the representation of common values. ReLU’s unbounded positive range is particularly problematic at low bit-widths — most sub-8-bit methods replace it with bounded alternatives like clipped ReLU or learned clipping thresholds.

Hardware support below INT8 remains uneven. Whilst INT8 acceleration is available across NVIDIA Tensor Cores, ARM NEON, and Intel VNNI, INT4 support is still emerging. Binary operations, despite being theoretically simplest, lack optimised CPU instruction sequences — current x86 and ARM ISAs are optimised for FP32 and INT8, requiring multiple instructions for what ought to be simple binary scalar products. The irony: the most extreme compression receives the least hardware support on conventional processors.

The deepest limitation is architectural. Even a heavily quantised neural network still performs matrix multiplication as its core operation. A quantised INT8 model with ten million parameters still requires approximately ten million multiply-accumulate operations per layer. Logic-Based Networks replace that operation entirely — inference becomes AND, OR, and NOT. Every processor on earth handles those natively.

LBNs do not overcome these limitations by doing quantisation better. They sidestep the problem by operating in a fundamentally different computational paradigm. The Tsetlin Machine learns conjunctive logic rules over binarised propositions using game-theoretic automata feedback — not gradient descent, not backpropagation, not matrix multiplication. The learning process converges to Nash equilibria that provably align with optimal propositional formulas, avoiding the local minima that complicate neural network training.

There is no precision to lose. The architecture never used floating-point, so there is no floating-point precision being degraded. Literal Labs’ benchmarking shows an average accuracy variation of ±2% compared to neural networks — and in some decision intelligence applications, LBNs are up to 20% more accurate. The Convolutional Tsetlin Machine achieves 99.51% on MNIST — competitive with state-of-the-art convolutional neural networks.