Integer-only inference is a deployment mode where a neural network's forward pass executes exclusively using integer arithmetic, typically int8 or int4, without any floating-point operations. This is achieved by quantizing weights, activations, and mathematical operations like matrix multiplication and convolution to integer representations, allowing the model to run on fixed-point digital signal processor slices and custom logic within FPGAs.
Glossary
Integer-Only Inference

What is Integer-Only Inference?
A deployment mode where all neural network arithmetic is performed using integer operations, eliminating the need for floating-point units.
This approach eliminates the silicon area and power overhead of floating-point units, directly mapping multiply-accumulate operations to efficient DSP48 blocks. By folding batch normalization parameters and applying cross-layer equalization during the quantization process, integer-only inference maintains classification accuracy while achieving maximum throughput on resource-constrained edge hardware for real-time RF signal processing.
Key Characteristics of Integer-Only Inference
Integer-only inference is a deployment mode where all neural network arithmetic—including activations, weights, and intermediate tensors—is performed using integer operations. This eliminates floating-point units, enabling efficient execution on fixed-point DSP slices and custom logic within FPGAs.
Uniform Int8 Quantization
Maps floating-point tensors to 8-bit integers using a scale factor and zero-point. The affine mapping r = s(q - z) allows all matrix multiplications and convolutions to be computed with integer arithmetic. This is the foundational scheme for TensorFlow Lite and PyTorch Mobile integer pipelines.
Per-Tensor vs. Per-Channel Granularity
Per-tensor quantization assigns a single scale and zero-point to an entire weight tensor, maximizing simplicity. Per-channel quantization assigns separate scales to each output channel, preserving fine-grained weight distributions. Per-channel is critical for maintaining accuracy in depthwise separable convolutions used in mobile RF classifiers.
Integer-Only Activation Functions
Standard activations like sigmoid and tanh require floating-point exponentials. Integer-only inference replaces them with lookup tables (LUTs) or fixed-point polynomial approximations. ReLU6 and hard-swish are preferred as they map directly to simple integer clipping and multiplication operations.
Fused Quantized Operations
Integer-only graphs fuse convolution + bias + activation into a single quantized kernel. This eliminates intermediate memory round-trips and reduces the overhead of requantization steps between layers. Operator fusion is a graph-level optimization applied before code generation for the target FPGA.
Requantization Arithmetic
When multiplying two int8 matrices, the accumulator must hold an int32 result to prevent overflow. A requantization step then scales the int32 sum back to int8 using a multiplier derived from the ratio of input and output scales. This is implemented efficiently using fixed-point multiply-and-shift operations on DSP slices.
Symmetric vs. Asymmetric Schemes
Symmetric quantization maps values around zero with zero-point = 0, simplifying arithmetic by eliminating cross-terms. Asymmetric quantization uses a non-zero zero-point to cover skewed distributions like ReLU outputs. Symmetric is preferred for weights; asymmetric is often necessary for activations.
Frequently Asked Questions
Clear, technical answers to the most common questions about deploying modulation classifiers using purely integer arithmetic on FPGAs and fixed-point hardware.
Integer-only inference is a deployment mode where all neural network arithmetic—including matrix multiplications, convolutions, and activation functions—is performed exclusively using integer operations, completely eliminating floating-point units. This is achieved by quantizing both weights and activations to fixed-point representations (typically INT8 or INT4) and replacing floating-point nonlinearities like softmax with integer-compatible alternatives such as hard sigmoid or lookup-table approximations. During execution, the hardware multiplies two integer matrices and accumulates the results in a wider accumulator (e.g., INT32) before requantizing the output back to the target bit-width. This approach maps directly to DSP48 slices in FPGA fabric, which natively perform 18x18 or 27x18 multiply-accumulate operations, enabling maximum throughput without the area and latency overhead of IEEE 754 floating-point logic.
Integer-Only vs. Mixed-Precision vs. Floating-Point Inference
A comparison of three numerical precision strategies for deploying neural network inference on resource-constrained hardware, evaluating their impact on accuracy, latency, and hardware compatibility for modulation classification workloads.
| Feature | Integer-Only Inference | Mixed-Precision Inference | Floating-Point Inference |
|---|---|---|---|
Numerical Format | INT8 (weights and activations) | INT8 + FP16 hybrid per layer | FP32 or FP16 throughout |
Requires Floating-Point Unit | |||
DSP Slice Utilization | 1 MAC per DSP48 slice | 1-2 MACs per DSP48 slice | Requires multiple DSP slices per MAC |
Memory Bandwidth per Inference | Lowest (1 byte per value) | Moderate (1-2 bytes per value) | Highest (2-4 bytes per value) |
Typical Accuracy Drop vs. FP32 Baseline | 0.5-2.0% | 0.1-0.5% | 0.0% (baseline) |
Quantization-Aware Training Required | |||
FPGA LUT Resource Overhead | Minimal (integer arithmetic only) | Moderate (mixed arithmetic units) | High (full FP datapath) |
Inference Latency (Relative) | 1.0x (fastest) | 1.2-1.5x | 2.0-4.0x (slowest) |
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Related Terms
Core techniques and hardware considerations that enable or complement integer-only inference for deploying modulation classifiers on resource-constrained FPGAs and edge devices.
Quantization-Aware Training (QAT)
A training methodology that simulates the effects of low-precision integer arithmetic during the forward and backward passes. By inserting fake quantization nodes that mimic the rounding and clipping behavior of int8 or int4 operations, the network learns to adapt its weights to quantization error. This is critical for integer-only inference because it prevents the catastrophic accuracy collapse that often occurs when a floating-point model is naively quantized post-training, especially for sensitive signal classification tasks.
Batch Normalization Folding
A mandatory pre-deployment graph optimization for integer-only inference. During training, batch normalization layers compute a linear transformation using running mean, variance, scale, and shift parameters. Before integer deployment, these parameters are mathematically absorbed into the preceding convolutional layer's weights and biases. This eliminates the floating-point batch normalization computation at runtime, ensuring the entire model graph consists purely of integer convolutions and activations without any residual floating-point operations.
Multiply-Accumulate (MAC) Operations
The fundamental arithmetic primitive that dominates neural network computation. A MAC consists of a multiplication followed by an addition, directly mapping to the DSP48 slices in Xilinx FPGA fabric. Integer-only inference leverages the fact that DSP slices can perform int8 MACs at significantly higher throughput and lower power than floating-point equivalents. Modern FPGAs can pack two int8 multiplications into a single DSP slice, effectively doubling the peak compute density for quantized modulation classifiers.
Straight-Through Estimator (STE)
The gradient approximation technique that makes quantization-aware training possible. The quantization rounding function is inherently non-differentiable—its gradient is zero almost everywhere. The STE bypasses this by passing the gradient through the rounding operation unchanged during backpropagation, treating it as an identity function. This allows gradients to flow through discrete integer operations, enabling the network to learn robust representations that survive the precision loss inherent in integer-only inference.
Cross-Layer Equalization
A pre-quantization technique that addresses the dynamic range imbalance between consecutive layers. In deep networks, the weight distributions of adjacent layers can have vastly different scales. Cross-layer equalization exploits the scale-equivariance property of ReLU activations to transfer scaling factors between layers, equalizing their ranges. This minimizes the clipping error when mapping floating-point tensors to uniform integer grids, preserving the signal fidelity required for accurate modulation classification under integer-only constraints.
Deep Learning Processor Unit (DPU)
A dedicated hardware IP core optimized specifically for integer convolutional neural network inference. The DPU features a custom instruction set and a dedicated systolic array of MAC units designed to execute int8 operations with maximum efficiency. When deploying integer-only modulation classifiers on Xilinx FPGAs, the DPU provides a pre-verified, high-performance compute fabric that handles the scheduling, data movement, and parallel execution of quantized operations, abstracting away low-level hardware design complexity.

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us