Skip to main content
AI SOFTWARE · MODELS

What Is INT8 Quantization?

INT8 quantization converts an AI model’s weights and calculations from 32-bit floating point (FP32) to 8-bit integers. The model becomes about a quarter of the size and runs faster on NPUs, GPUs and AI accelerators, usually with only a small loss of accuracy. It is a standard step when preparing a trained model for inference at the edge.

01

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.

02

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.
03

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.

FAQ · 01
What is the difference between AI inference and training?
Training is how an AI model learns: it is fed large sets of labeled data and adjusted until it predicts accurately, which needs powerful GPUs. Inference is using the trained model on new data to make a decision. Quantization happens between the two, preparing the trained model for inference.
Read the full FAQ —
04

Tools that quantize models

Most edge AI hardware is built to run INT8 models efficiently, and each vendor supplies the tools to get a model there. A model is usually exported from PyTorch or TensorFlow to ONNX first, then quantized by the toolkit for the target hardware.

  • //
    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.
05

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.

06

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.

07

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.