What INT8 quantization does
INT8 quantization is the process of storing and computing a neural network with 8-bit integers instead of 32-bit floating-point numbers. Models are usually trained in FP32, but inference rarely needs that much precision. Quantization maps each value onto 256 integer levels, using a small calibration set of real data to choose the ranges. Where accuracy drops too far, quantization-aware training builds the reduced precision into training so the model learns to cope with it.
The gains come from three places. An 8-bit value takes a quarter of the memory of a 32-bit one, so the model is smaller and moves through memory four times faster. Integer arithmetic needs far less silicon than floating point, so accelerators fit many more multipliers in the same space. And less data movement means less power, which matters most in fanless and battery-powered systems.
How the conversion works
Each tensor of weights or activations gets a scale factor, and sometimes a zero point, that maps its real range onto the integer range of −128 to 127. A value is divided by the scale, rounded and stored as an integer; the hardware multiplies the integers and the result is rescaled at the end. Symmetric quantization centres the range on zero, which is simpler and usual for weights, while asymmetric quantization adds a zero point to fit ranges that are not centred, as activations often are.
The scale can be set for a whole tensor or per channel. Per-channel scales follow the different ranges of each filter in a layer and usually keep more accuracy, so most current toolkits use them for weights.
-
//
Post-training quantization. Converts a finished model using a calibration dataset, with no retraining. It is fast and the usual first step.
-
//
Quantization-aware training. Simulates INT8 during training or fine-tuning to keep more accuracy, at the cost of a training run.
-
//
Calibration. Sample data, typically a few hundred representative images, that sets the value range for each layer.
-
//
Validation. Always test the INT8 model on your own data before deployment.
INT8 compared with other precisions
INT8 is one point on a range of number formats. Hardware support decides which ones a given chip can run quickly.
| Format | Bits | Size vs FP32 | Typical role | Hardware support |
|---|---|---|---|---|
| FP32 | 32 | 1× | Training, reference accuracy | All CPUs and GPUs |
| FP16 / BF16 | 16 | ½ | Training and GPU inference | GPUs, Jetson, many NPUs |
| FP8 | 8 | ¼ | Transformer and LLM inference | Recent NVIDIA GPUs such as Ada and Blackwell |
| INT8 | 8 | ¼ | Vision and general edge inference | NPUs, Jetson, Hailo, GPUs, CPUs |
| INT4 | 4 | ⅛ | Language model weights | Recent NPUs, GPUs and the Hailo-10H |
The precision also sets the performance figure. Most TOPS ratings are quoted at INT8, so a model only reaches the hardware’s headline speed once it is quantized.
Tools that quantize models
-
//
NVIDIA TensorRT. Calibrates and builds INT8 engines for Jetson and NVIDIA GPUs, and can keep sensitive layers at FP16.
-
//
Intel OpenVINO. Its NNCF toolkit applies post-training and quantization-aware methods for Intel CPUs, GPUs and NPUs.
-
//
ONNX Runtime. Built-in static and dynamic quantization that works across many processors.
-
//
Hailo Dataflow Compiler. Quantizes and compiles models for the Hailo-8 and Hailo-10H accelerators.
Getting good accuracy
For common vision models, a well-calibrated INT8 version typically loses around a percentage point of accuracy or less, but some models are more sensitive. The usual fixes are a better calibration set that reflects real site conditions, per-channel scales, keeping one or two sensitive layers at FP16, and, if needed, quantization-aware training. Our OpenVINO FAQ and TensorRT FAQ cover the Intel and NVIDIA toolkits that quantize models, and our Hailo range uses accelerators that run models prepared by the Hailo Dataflow Compiler.
When INT8 is not the right choice
INT8 is the default for edge vision, but not for every model. Regression models that output precise measurements, such as depth, pose or dimensions from a camera, can lose more accuracy than a classifier, because small rounding errors show directly in the result. Some transformer layers have outlier values that a single integer scale handles badly, which is one reason FP8 and mixed precision have grown for language models.
In those cases teams often run the model at FP16 on a GPU or Jetson, or quantize most layers to INT8 and keep the sensitive ones at higher precision. The right answer comes from measuring accuracy and speed on the target hardware, not from the format alone.
Quick answers on INT8 quantization
INT8 quantization: common questions
What is the range of INT8?
−128 to 127 for signed INT8. Unsigned UINT8 covers 0 to 255. Either way, there are 256 possible values.
INT8 vs FP8: which is better?
It depends on the model and hardware. FP8 keeps a floating-point range, which suits transformers and language models, but needs recent NVIDIA GPUs. INT8 runs on almost every accelerator and suits most vision models.
INT4 vs INT8: what is the difference?
Half the bits again. INT4 halves the model size compared with INT8, which helps fit language models into limited memory, but loses more accuracy and is usually applied to weights only.
Does quantization make a model less accurate?
Slightly, usually. The loss is often small enough not to matter, but it must be measured on your own data before deployment.
Do I need to retrain to use INT8?
Usually not. Post-training quantization works for most models. Quantization-aware training is the fallback when accuracy drops too far.
We supply edge AI computers with the runtime for your target hardware installed and validated as standard. Send us your model and accuracy target, and we will recommend the accelerator and precision to match.