INT8 quantization is the conversion of a neural network’s weights and activations from 32-bit floating point to 8-bit signed integers, using a scale factor and often a zero point to map real values onto 256 integer levels. In Edge AI, it is the most widely deployed compression technique because it cuts model size by about four times and lets phones, PCs and embedded processors run inference on fast integer hardware.
The technique is also called 8-bit quantization. It sits between gentler options such as FP16 and more aggressive ones such as 4-bit quantization, and it is the default target format of most mobile accelerators, digital signal processors and neural processing units.
How INT8 quantization maps real numbers to integers
INT8 quantization applies an affine mapping in which a real value r is approximated as r = S × (q − Z), where q is the stored integer, S is a positive scale and Z is the zero point. The scale sets the step size between neighboring levels, so a tensor whose values span from −6 to +6 receives a step of roughly 0.047.
Two schemes dominate. Symmetric quantization fixes the zero point at 0 and uses the range −127 to +127, which simplifies the arithmetic and suits weights centered on zero. Asymmetric quantization uses a nonzero zero point and the full range of 256 levels, which suits activations after ReLU that are never negative.
During inference, the hardware multiplies INT8 operands and accumulates the products in 32-bit integer accumulators to avoid overflow. A final requantization step rescales the INT32 sum back to INT8 for the next layer, usually with a fixed-point multiplier and a bit shift so that no floating-point unit is needed.
The following table summarizes the parameters that define an INT8 scheme and what each one controls.
| Parameter | Typical setting | What it controls |
|---|---|---|
| Scale (S) | Float32 per tensor or per channel | Step size between integer levels |
| Zero point (Z) | 0 for weights, 0-255 or −128-127 for activations | Which integer represents real zero |
| Granularity | Per tensor or per output channel | How closely ranges fit each filter |
| Accumulator width | INT32 | Headroom for summing many products |
| Clipping range | Min-max, percentile or entropy based | Trade-off between outliers and resolution |
Calibration and the two main workflows
Weights are known in advance, but activation ranges depend on the input, so an INT8 model needs calibration or training to fix those ranges. Engineers obtain them through one of two workflows that differ in cost and resulting accuracy.
Post-training quantization runs a small calibration dataset, often 100 to 1,000 representative samples, through the float model and records activation statistics. Quantization-aware training inserts simulated quantization into the forward pass during fine-tuning, so the network learns weights that tolerate rounding. A third variant, dynamic quantization, stores weights in INT8 but computes activation scales at run time.
The table below compares these workflows on the points that usually decide between them.
| Workflow | Data needed | Effort | Typical accuracy loss |
|---|---|---|---|
| Post-training static | Unlabeled calibration set | Minutes to hours | Often under 1 percentage point on CNNs |
| Dynamic quantization | None | Very low | Small; latency gain is limited |
| Quantization-aware training | Labeled training data | Days of fine-tuning | Usually the smallest loss |
The choice of clipping method during calibration matters as much as the workflow. A simple min-max range lets one outlier stretch the scale and waste resolution, whereas percentile or entropy-based clipping sacrifices rare extreme values to keep fine steps where most values lie.
Why INT8 suits edge hardware
INT8 quantization reduces memory traffic, which is the dominant energy cost on mobile and embedded chips. Moving one byte instead of four lowers bandwidth pressure, keeps more of the model in on-chip cache and shortens load time from flash storage.
Integer multiply-accumulate units are also smaller and more power efficient than floating-point units, so accelerators pack many more of them into the same silicon area. Many mobile NPUs, DSP-based hardware delegates and microcontroller kernels execute only integer operators, which makes INT8 a requirement rather than an option on those targets.
The next table places INT8 among the numeric formats used for on-device inference.
| Format | Bits per weight | Size versus FP32 | Typical use |
|---|---|---|---|
| FP32 | 32 | 1× | Training and reference accuracy |
| FP16 or BF16 | 16 | 0.5× | GPUs and capable mobile accelerators |
| INT8 | 8 | About 0.25× | CNNs, speech and vision on NPUs and DSPs |
| INT4 | 4 | About 0.125× | Weight-only compression of large language models |
Real speedups vary widely. On hardware with native integer paths, 2× to 4× faster inference than FP32 is common, yet a CPU without efficient INT8 kernels may show little gain, and inserted conversion operators can even make a model slower.
Accuracy risks and how practitioners reduce them
Accuracy suffers when a tensor has a wide dynamic range with outliers, because a single scale cannot represent both tiny and large values well. Depthwise convolutions in compact networks and activation outliers in transformer models are the classic trouble spots.
Most problems map to a known cause and a standard remedy, as the following table shows.
| Symptom | Likely cause | Typical fix |
|---|---|---|
| Large drop on a compact CNN | Per-tensor scales on depthwise layers | Use per-channel quantization for weights |
| Errors only on some inputs | Unrepresentative calibration data | Calibrate on samples from the deployment domain |
| Transformer quality collapses | Activation outliers in a few channels | Apply SmoothQuant or keep those layers in higher precision |
| No speedup on device | Unsupported operators fall back to float | Check the runtime’s operator coverage |
A frequent strategy is mixed precision, in which sensitive layers such as the first convolution or the final classifier stay in FP16 while the rest runs in INT8. Engineers locate those layers with layer-wise sensitivity analysis, quantizing one layer at a time and measuring the accuracy change.
- Validate on the target device, because simulated quantization on a workstation can differ from the integer kernels of the deployment runtime.
- Fuse batch normalization into preceding convolutions before quantizing, so that the folded weights receive one consistent scale.
- Measure task metrics, not only top-1 accuracy, since detection boxes and speech timing can degrade differently.
INT8 among related compression techniques
INT8 quantization changes numeric precision but keeps the network architecture intact, which distinguishes it from neural network pruning, low-rank factorization and weight clustering. These methods are complementary, and a production pipeline often prunes or distills a model first and then quantizes it to INT8 as the last step before model conversion.
For large language models, INT8 is frequently applied as weight-only quantization or combined with activation smoothing, while methods such as GPTQ and AWQ push weights further to 4 bits. For convolutional and audio models, full integer INT8 remains the most mature and broadly supported format across edge inference runtimes.
The short version
A trained AI model is made of millions of very precise decimal numbers. INT8 quantization rounds them to whole numbers between −128 and 127, a bit like describing a long distance in whole meters instead of millimeters. The answer stays almost the same, but it takes far less space to write down.
Because each number now needs one byte instead of four, the model becomes about four times smaller, and simple whole-number arithmetic is quick and cheap for phone and gadget chips. The cost is a small loss of accuracy, which careful setup usually keeps barely noticeable.
Where it makes a difference
A team building a smart doorbell wants on-device person detection so that video never leaves the home. Their float object detector is 24 MB and runs at about 4 frames per second on the device’s application processor, which is too slow and drains the battery.
They apply post-training INT8 quantization with per-channel weight scales, calibrating on 500 frames captured by real doorbells at dawn, noon and night. The resulting model is about 6 MB and runs entirely on the chip’s neural accelerator at roughly 15 frames per second.
Mean average precision falls by less than one percentage point, except at night, where a small accuracy drop appears. The team keeps the first convolution in FP16, recovers most of that loss and ships a doorbell that detects visitors without any cloud processing.