# QAIRT Quantization Specification | **Document Version** | **QAIRT SDK Release** | **AIMET SDK Release** | | --- | --- | --- | | v0.1 (Alpha) | v2.36 | v2.3 | - [Introduction](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#introduction) - [Converter quantization workflow](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#converter-quantization-workflow) - [Quantization inputs](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#quantization-inputs) - [Quantization processing](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#quantization-processing) - [Quantization outputs](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#quantization-outputs) - [Target specific processing](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#target-specific-processing) - [Handle data movement ops](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#handle-data-movement-ops) - [Tag super groups](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#tag-super-groups) - [Select op precision](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#select-op-precision) - [Insert converts](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#insert-converts) - [Quantize static tensors](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#quantize-static-tensors) - [Debugging](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#debugging) - [Log level INFO (CSV)](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#log-level-info-csv) - [Stats summary](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#stats-summary) - [Log level TRACE (TXT)](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#log-level-trace-txt) - [Understanding errors](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#understanding-errors) - [Appendix A: Classification of quantization techniques](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#appendix-a-classification-of-quantization-techniques) - [Appendix B: Quantized model formats](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#appendix-b-quantized-model-formats) - [ONNX](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#onnx) - [TFLite](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#tflite) - [TensorFlow](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#tensorflow) - [Appendix C: JSON schema version 2.0.0](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#appendix-c-json-schema-version-2-0-0) - [Per tensor quantization encoding example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#per-tensor-quantization-encoding-example) - [Per channel quantization encoding example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#per-channel-quantization-encoding-example) - [Blockwise quantization encoding (BQ) example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#blockwise-quantization-encoding-bq-example) - [Blockwise quantization encoding (BQ) with float offset example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#blockwise-quantization-encoding-bq-with-float-offset-example) - [Low power blockwise quantization (LPBQ) example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#low-power-blockwise-quantization-lpbq-example) - [Array-Of encoding example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#array-of-encoding-example) - [Array-Of encoding with per-channel sub-encodings example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#array-of-encoding-with-per-channel-sub-encodings-example) - [Appendix D: Super groups](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#appendix-d-super-groups) - [HTP super groups](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#htp-super-groups) - [Appendix E: Data movement ops](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#appendix-e-data-movement-ops) - [HTP data movement ops](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#htp-data-movement-ops) ## [Introduction](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id6) Most neural network models use 32-bit floating point representation for weights and activations. However, these high-precision representations are often optimized for inference, especially when deploying models on edge devices where available memory and compute resources are more limited. Quantization is a model compression technique used to lower memory footprint, power consumption, data transfers and improve inference speed by reducing the precision of the model’s weights and activations with minimal accuracy loss. For more information on quantization techniques refer to the Appendix of this document. The goals of this document are: - To describe the QAIRT workflow for quantized networks and explain how quantization data is processed by the QAIRT stack. - To document the quantization encoding formats supported by the QAIRT stack for benefit of customers using third-party quantization tools. Note that Qualcomm’s AI Model Efficiency Toolkit (AIMET) supports these output formats for seamless operation with QAIRT. ## [Converter quantization workflow](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id7) ![../_static/resources/AE_fig1.png](data:image/png;base64,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) Quantization workflow The above figure shows the high-level workflow for converting from framework model format to a Deep Learning Contained (DLC). The *qairt-converter* converts a model for source framework format into a DLC which can be used for inference. ### [Quantization inputs](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id8) The *qairt-converter* accepts the following inputs: - **Model input (mandatory)** - **Float model:** A 32-bit floating point model (no quantization information) - **Quantized model:** A model containing quantized nodes. Ex: TFLite models. - **Q-DQ model:** A model where quantization information is signaled using Q-DQ nodes. E.g. an ONNX model with QuantizeLinear, DequantizeLinear Note For more details see [Appendix B: Quantized model formats](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#ae-appendix-b) - **Quantization Encoding Overrides (optional)** - **Encoding Overrides:** a JSON file with quantization information for each tensor may be passed using the *–quantization\_overrides* option. Quantization information in the encodings override file will take precedence over information in source model file. See [Quantization Overrides](https://docs.qualcomm.com/bundle/publicresource/topics/80-63442-10/quantization.html#quantization-overrides) in the QAIRT SDK documentation for detailed information. - Note that AIMET can be used to perform quantization and to produce a quantization overrides JSON file. Quantization information from third-party tools can be specified in the same format. - See [Appendix C: JSON schema version 2.0.0](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#ae-appendix-c) for a detailed description of the encoding file format. - **Target (optional)** - The target backend (*HTP, LPAI*, etc) can be specified using *–target\_backend* option. Run *qairt-converter–help* for additional details on it. When the target device is provided, additional target-specific processing during the conversion processing is performed. Without target device information, only target-agnostic quantization will be performed. Examples commands: - Converting a 32-bit floating-point model with quantization overrides file `qairt-converter -i model.onnx --quantization_overrides model.encodings –-target_backend=HTP` - Converting an ONNX Q-DQ model `qairt-converter -i model_qdq.onnx –-target_backend=HTP` ### [Quantization processing](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id9) Quantization processing by the *qairt-converter* consists of two steps: quantization extraction and quantization adaptation. The *qairt-converter* first extracts quantization encoding information from the source model and encoding overrides file (if present). Note that quantization information in the source model can exist at different granularities such as per-tensor, per-channel, per-block, etc… See [Appendix A: Classification of quantization techniques](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#ae-appendix-a) for more information. If a tensor has encoding information in both the model and overrides file, the overrides file will take precedence. See [Appendix C: JSON schema version 2.0.0](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#ae-appendix-c) and [Appendix B: Quantized model formats](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#ae-appendix-b) for more details. Next, target-specific processing is performed, and the resulting quantization information is applied to tensors. When encodings associated with an operation cannot be mapped directly to the target device the encodings are adapted to the specified target. The adaption process has a defined set of rules that are documented in [Target specific processing](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#target-specific-processing). ### [Quantization outputs](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id10) **DLC** - The output of the *qairt-converter* is a DLC ready for inference or compilation with the QAIRT stack. ## [Target specific processing](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id11) During target-specific processing, the quantization information extracted from processing the source model and overrides files is compared with the supported datatypes and operations on the specified target. If the extracted quantization information cannot be directly mapped, quantization information is adapted. The following guidelines are used when adapting an encoding to a target. - 32-bit floating point tensors are assigned float16 precision (default precision for the targets supported by QAIRT). - Tensors with no encoding information are treated as 16-bit floating point. - If the extracted quantized encoding if not supported by the target, the qairt-converter will fall back to a higher precision (that is supported on the target) in order to maintain accuracy. Precision precedence order is: float32, float16, int32, int16, int8, int4, and int2 (from highest to lowest). The figure below shows the processing steps involved in adapting quantization encodings for a target. Steps include handling for data movement ops, supergroups, promotion and assignment of encodings, inserting appropriate conversion ops, quantizing static tensors, etc… and are detailed below. ![../_static/resources/AE_fig5.png](data:image/png;base64,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) Adapt Encodings – Algorithm ### [Handle data movement ops](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id12) Assign quantization encoding to the tensors associated with data movement ops and ensure matching quantization encodings are assigned along the chain of data movement operations. Operations that do not fall in the category of data movement ops are unaffected. List of [Appendix E: Data movement ops](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#appendix-e-data-movement-ops). *Rules:* - Quantization encoding of the input and output tensor of data movement operations must be equivalent. - A continuous sequence, or chain, of data movement ops is uniformly assigned the same encoding value as the range is not expected to change within the chain. - When different bit widths are detected at input and output of the op or chain of ops, the module assigns the minimum bit width for that op or group. This may result in a ConvertOp or CastOp at the start or end of the chain. For debugging, see TRACE log: [Propagate Encodings](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#trace-propagate-encodings), [Inject Convert Ops](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#trace-inject-convert-ops). ### [Tag super groups](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id13) A super group is a subgraph which executes in the same precision from start to end. Super groups are identified and tagged at this stage. Super groups are used to: - Avoid quantization noise by holding intermediate tensor data in higher precision to improve accuracy. - Enable targets to fuse the subgraph, when possible, to improve performance. - For example, the *Conv->ReLU* pattern will be detected and marked in the DLC so that fusion can be performed during target compilation. Super groups are target specific. A complete list of the super groups can be found in [Appendix D: Super groups](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#appendix-d-super-groups). Tools like AIMET simulate super group patterns during quantization and calibration for improved accuracy and performance. *Rules:* - The super group pattern must be supported by the target ([Appendix D: Super groups](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#appendix-d-super-groups)). - Quantization encoding must be only specified for tensors at the start and end of the super groups, and no encoding must be specified for intermediate tensors. - For a sequence of ops to qualify as a super group the intermediate tensors must not be consumed outside of the super group ops. (For example, in the *Add->Relu* sequence the tensor between *Add* and *Relu*) - The super group operator dimensions and other attributes must be supported by the specified target. For debugging, see TRACE log: [Tag Tensors In SuperGroups](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#trace-tag-tensors-in-supergroups). ### [Select op precision](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id14) - Each target supports operations in different precisions (datatype, bit width, symmetry, etc) as tabulated in the [Backend Supplemental Op Definition for each target](https://docs.qualcomm.com/bundle/publicresource/topics/80-63442-10/operations.html#backend-supplements). Tensors with missing quantization encoding information are assigned the default, float 16 datatype. For each op, the selection process determines if the encoding is supported by the target. If the encoding is supported, then it is used as-is. If the encoded precision is not supported, the precision will fall back to the nearest supported higher precision. Precision precedence order is: float32, float16, int32, int16, int8, int4, and int2 (from highest to lowest). If a higher precision is not available, it is reported as an error. *Rules:* - Tensors with no encoding are first assigned a float type (default). At this point all tensors must have an assigned encoding. - Quantization encoding is assigned to tensors and then ops connected to that tensor are evaluated to ensure a matching kernel is available on a backend for execution. - When a matching kernel is not available, iteratively, look for nearest higher precision kernel. - Checks performed when finding a matching a kernel. 1. When the user provided Symmetry is not supported it is an error. 2. When user provided encodings do not meet the granularity (per-tensor, per-channel or per-block) requirements then it is an error. 3. When the user provided *y\_scale* does not meet constraint specified by the target then, it is an error unless it can be rescaled to match the desired range for the selected bit width. 4. When the user provided sign of the *output\_dtype* does not match then, a kernel with opposite sign is looked for by changing the offset value. 5. When the user provided bit width is not supported by the kernel even after changing the sign then, higher bit width is looked for by repeating the steps from 1 to 5. For debugging, see TRACE log: [Fill Missing Encodings](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#trace-fill-missing-encodings), [Kernel Selection](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#trace-kernel-selection). ### [Insert converts](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id15) For every tensor where the tensor’s producer and consumer operations have different datatype requirements an appropriate Convert (rescale, quantize, or de-quantize) or Cast Op is inserted between ops. *Rules:* - Insert a convert or cast op from tensor datatype present in the model to a user specified datatype - If the selected datatype is different from user specified datatype, then another conversion is done from user specified to selected datatype. For debugging, see TRACE log: [Inject Convert Ops](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#trace-inject-convert-ops). ### [Quantize static tensors](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id16) Quantize static tensor values and store to avoid inserting a conversion op. This step helps reduce runtime cycles. *Rules:* - Static tensors are quantized using the precision selected in Select Op Precision. When quantization bit width is less than the 8-bit multiple elements may be packed in packed into 8-bit. For example: two 4-bit elements can be packed in one 8-bit datatype. For debugging, see TRACE log: [Compute Static / Bias Encodings](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#trace-compute-static-bias-encodings). ## [Debugging](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id17) The *qairt-converter* can optionally emit log files that can be used to review the extracted encodings, the process of encoding selection and adaptation, and any encountered errors. These logs are available via the following options: `--quantizer_log ` and `--quantizer_log_level `. The following options are supported for ``: - `NONE` (default): No file. Warnings and errors go to the console. - `INFO`: CSV file (use a `.csv` filename). Summary of modified tensors. - `TRACE`: Plain-text file (use a `.txt` filename). Detailed per-phase trace. Only one log file can be emitted at a time. ### [Log level INFO (CSV)](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id18) The CSV contains one row per modified or injected tensor during target-specific processing. Unmodified tensors are omitted. The following columns are emitted: - **Tensor name**: Name in the output graph. - **Original tensor name**: If this tensor was injected, this is the name of the tensor from which this tensor’s encoding was derived from. In the case of Convert/Quantize/Dequantize injection, this will be the name of the tensor on which the op was injected on. - **Encoding type**: e.g. `scale_offset`, `axis_scale_offset`. - **Selected datatype**: Datatype after processing. - **Requested datatype**: Datatype as interpreted from the override encodings. - **Reason**: One or more `^`-delimited tokens: - `DATA_MOVEMENT_PROPAGATION`: Encoding propagated across a data movement op chain. - `FLOAT_FALLBACK`: No encoding; assigned default float16 or float32, depending on backend. - `SUPERGROUP_PROPAGATION`: Encoding inferred by [Tag super groups](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#tag-super-groups). - `DUPLICATED_BIAS`: Shared bias tensor was duplicated per consumer. - `OP_ADAPTATION`: Op adapted to a higher precision; Convert/Quantize/Dequantize inserted. - `SOURCE_TENSOR_DEAD_CODE_ELIMINATED`: Original tensor for a Convert was removed by dead-code elimination. - **Scale / Original scale**: Up to five `^`-delimited scale values. - **Offset / Original offset**: Corresponding offset values. ### [Stats summary](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id19) The *qairt-converter* always emits a stats summarization of the quantization pass, regardless of log level. At NONE or INFO level the stats are printed to the console; when TRACE level is selected, the stats are emitted at the end of the log file. The summary can be very useful for identifying if quantization went as expected. For example, the presence of converts to/from floating point can quickly indicate that necessary encodings were missing or an unsupported combination of precisions were passed for an op, necessitating promotion to float. The stats and the INFO CSV complement each other for validating and understanding the overall quantization outcome: the stats give a high-level pass/fail signal, while the CSV provides per-tensor detail for deeper analysis. Neither is designed for debugging encoding errors; use the TRACE log for that. The stats section uses the following fields: - `[MISSING ENC.]`: tensors that had no encoding at the start of target-specific processing, as a percentage of all tensors. Broken down into sub-categories: - `[PROPAGATED]`: encoding inferred via data movement propagation (`DATA_MOVEMENT_PROPAGATION` in the CSV). - `[FP16 FALLBACK]`: no encoding found; assigned float16 (`FLOAT_FALLBACK` in the CSV). - `[FP32 FALLBACK]`: no encoding found; assigned float32 (`FLOAT_FALLBACK` in the CSV). - `[SUPERGROUPED]`: encoding inferred via supergroup handling (`SUPERGROUP_PROPAGATION` in the CSV). - `[BIAS FXP]`: bias tensors with no encoding assumed to be fixed-point (absolute count, no percentage). - `[DUP. BIASES]`: bias tensors duplicated (`DUPLICATED_BIAS` in the CSV). - `[ADAPTED OPS]`: ops whose kernel was not an exact match, as a percentage of all ops, with a table of requested-to-selected dtype pairs (`OP_ADAPTATION` in the CSV). Only emitted when adapted ops result in injected converts. - `[COMP. ENC.]`: tensors whose encoding was computed by the quantizer rather than supplied by the user, as a percentage of tensors that were missing encodings. - `[CONVERTS]`: net Convert/Cast ops injected (after pruning), with a matrix showing the count of conversions between each source and destination dtype. - `[PRUNED CONVERTS]`: convert-type ops that were injected and then pruned (`PRUNED` in the CSV). ### [Log level TRACE (TXT)](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id20) Records the full graph state and every decision made during target-specific processing. Phases are delimited by `BEGIN`/`END` banners. The full graph state (all tensors with their datatypes and encodings) is printed at the beginning and end, allowing users to directly compare what changes were made. Datatypes are encoded to short strings according to the following pattern: Datatype short-string tokens in TRACE logs | Datatype family | Prefix | Bit-width / value | | --- | --- | --- | | Signed integer | `is` | `is` | | Unsigned integer | `iu` | `iu` | | Signed fixed-point | `s` | `s` | | Unsigned fixed-point | `u` | `u` | | Boolean | `b` | `b` | | Floating point | `f` | `f` | | Undefined | `und` | (none) | **Graph** `GRAPH` banners bracket the pass, recording the full graph state before and after processing. Each tensor entry in the `TENSORS` section contains the following fields: - `[consumers]`: each op that reads this tensor, with the input slot index in brackets (e.g. `matmul (MatMul) [2]`). - `[producer]`: the op that produces this tensor, with the output slot index in brackets. - `[notes]`: additional attributes; `APP_WRITE` marks a network input tensor and `APP_READ` marks a network output tensor. - `datatype`: the tensor’s current IR datatype. - `encoding`: the encoding assigned to the tensor, with the following sub-fields. `UNDEFINED ENCODING` appears when no encoding has been assigned at that point in processing. - `bw`: bit-width of the quantized representation. - `scale` / `offset`: quantization parameters. - `is_sym`: `T` if the encoding is symmetric (offset is constrained to zero). - `is_fxp`: `T` if the encoding is fixed-point; `F` for floating-point encodings. - `dtype`: the quantized datatype implied by the encoding. - `overridden`: `T` if the encoding was supplied by the user in the encodings file; `F` if it was computed or inferred by the quantizer. During processing, tensors may start with a float `datatype` while carrying a quantized encoding (`dtype`). Later snapshots may show the `datatype` updated to match. **Propagate Encodings** (see [Handle data movement ops](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#handle-data-movement-ops)) - `[INV. OP ]` — a data movement op identified during this phase. These entries enumerate candidate ops before groups are resolved. - `[INV. OP GRP.]` — a resolved data movement op group, showing the ops in the group, the selected encoding, and the original entry and exit encodings. **Inject Convert Ops** - `[IDENT. CONVERT]` — convert site identified - `[INJECT CONVERT]` — convert op inserted into the graph. Note This phase is run multiple times to inject converts after different phases. It will appear in the trace multiple times. **Tag Tensors In SuperGroups** (see [Tag super groups](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#tag-super-groups)) - `[SUPER GROUP]` — super group detected - `[SUPER GRP. ENC.]` — encoding assigned to an intermediate tensor. - `[WARN: COMP. ENC.]` — encoding computed for a supergroup coefficient tensor. This token also appears in the [Compute Static / Bias Encodings](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#trace-compute-static-bias-encodings) phase. **Fill Missing Encodings** (see [Select op precision](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#select-op-precision)) - `[WARN: FP FALL]` — tensor had no encoding and was assigned float type. **Duplicate Shared Biases** - `[WARN: DUP. BIAS]` — bias tensor duplicated. Biases are duplicated if they have multiple consumers, allowing hardware friendly quantization based on each consumers’ weight and activation quantization. **Make Requested Kernels** Prepares the requested kernel dtype tuples for each op prior to kernel selection. No log tokens are emitted for this phase. **Kernel Selection** (see [Select op precision](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#select-op-precision)) Each op has the datatypes of its input and output tensors represented in a tuple. For example, `IN < s8, > OUT < s8, >` indicates that the input tensor at index 0 has datatype `s8` and output tensor at index 0 has datatype `s8`. For packed weight formats, a `CONTAINER IN[N]: ` annotation may follow the dtype tuple, giving the storage dtype of the packed tensor at input slot N (e.g. `u4` weights stored in a `u8` container). The kernel dtype refers to the logical dtype, not the container dtype. Per-op sub-section with: - `[REQUESTED KERN.]`: Input/output dtype tuple requested. - `[REJ. KERN.]`: Rejected candidate with reason and distance metric. - `[CURR. BEST]`: Best non-exact match seen so far. - `[SELECTED KERN.]`: Chosen kernel with total distance. Zero means exact match; non-zero means the op was adapted (`[ADAPTED OP]`). The distance metric is a per-slot tuple mirroring the dtype tuple, e.g. `IN < 0, 0.1, 0, > OUT < 0, > total: 0.1`. Each value quantifies the mismatch cost at that input or output slot; `total` is the sum. A `total` of zero is an exact match. `[CURR. BEST]` tracks the lowest-cost candidate seen so far, and `[SELECTED KERN.]` is the candidate with the lowest `total` overall. **Compute Static / Bias Encodings** (see [Quantize static tensors](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#quantize-static-tensors)) - `[WARN: COMP. ENC.]` — the quantizer computed or adjusted the encoding for a static or bias tensor. ### [Understanding errors](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id21) The *qairt-converter* quantizer accumulates all non-fatal errors and emits them in order of occurence upon exit. Generally, it is best to start with the error that was encountered first (top of the emitted errors), as this error may trickle down and cause the remaining errors. The most common error is “No accuracy preserving kernels found for <op name>.” This indicates that the *qairt-converter* was unable to find a kernel supported by the selected backend that would preserve accuracy. This often occurs when an unsupported combination of encodings were provided. To get more information, generate the TRACE log and look in the kernel selection section for the <op name>. The `[REJ. KERN.]` entries there will show why each candidate was eliminated. The most common rejection reasons are: - `no Cast/Convert from X to Y for input index N`: the backend has no op that can bridge the dtype mismatch at that input slot. The fix is typically to supply an encoding for that tensor that matches a dtype the backend supports at that position. - `constraint violation (...)`: a backend-specific constraint rules out the kernel regardless of dtype compatibility. The message names the exact constraint (e.g. *w4fp16 kernel is supported only when theweights are axis or block quantized*). Adjust the encoding or quantization granularity of the relevant tensor accordingly. - `INF distance, likely a non-accuracy preserving kernel`: the kernel exists but is considered non-accuracy-preserving for the requested dtype combination. The distance tuple will show `inf` values. This kernel will never be selected regardless of other candidates. To identify which tensor corresponds to a given slot index, consult the initial `GRAPH` snapshot. Each tensor entry lists its consumers and producer with an index in brackets: `[consumers] [ matmul (MatMul) [2], ]` means that tensor is consumed at input slot 2 of that op, and `[producer ] matmul (MatMul) [0]` means it is the first output. These indices map directly to the positions in the `IN < ... > OUT < ... >` tuples. For example, if kernel selection for `matmul` rejects a candidate due to `no Cast/Convert from s32 to u8 for input index 2`, the initial `GRAPH` snapshot will show the tensor with `[consumers] [ matmul (MatMul) [2], ]` — which in this case is the bias tensor with `dtype: s32`. ## [Appendix A: Classification of quantization techniques](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id22) Quantization can be categorized based on the aspects of the model it affects and the methods it uses: - **Based on Scope** - *Weight Quantization:* Reduces the precision of weights, which represent learned parameters. Weight quantization is particularly effective because weights are fixed after training. - *Activation Quantization:* Reduces the precision of activation, which represents intermediate outputs of the model during inference. Activation quantization is more challenging due to dynamic data ranges. - *Bias Quantization:* Reduces precision of bias. Quantization of bias depends on weight and activation quantization. - **Based on Granularity** - *Per Tensor Quantization:* The entire tensor (weights or activations) shares a single scaling factor. [Per tensor quantization encoding example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#per-tensor-quantization-encoding-example) - *Per Channel Quantization (PCQ):* Each output channel of a layer has its own scaling factor. [Per channel quantization encoding example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#per-channel-quantization-encoding-example) - *Block Quantization (BQ):* Quantizes weights or activations in blocks rather than per tensor/channel. For BQ encodings, QAIRT supports offsets of both int and float32. [Blockwise quantization encoding (BQ) example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#blockwise-quantization-encoding-bq-example) [Blockwise quantization encoding (BQ) with float offset example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#blockwise-quantization-encoding-bq-with-float-offset-example) - *Low Power Block Quantization (LPBQ):* Encodings at a lower bit width are determined and then adjusted such that they lie on a common higher bit width per channel grid. [Low power blockwise quantization (LPBQ) example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#low-power-blockwise-quantization-lpbq-example) ## [Appendix B: Quantized model formats](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id23) Quantization information can be provided in the model source graphs using Q-DQ nodes or using quantized operations depending on the source framework being used. The following table lists the combinations of inputs supported by the *qairt-converter* for each framework. Input model formats, framework and quantization granularity support matrix | Framework | Formats | Quantization Granularity | | --- | --- | --- | | ONNX | Float model, Q-DQ model | Per-tensor, Per-channel,


Per-block | | TensorFlow | Float model, FakeQuant model | Per-tensor, Per-channel | | TFL | Float model, Quantized model | Per-tensor, Per-channel | | PyTorch | Float model | Per-tensor, Per-channel | ### [ONNX](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id24) A sequence of *QuantizeLinear* and *DequantizeLinear* (Q-DQ) nodes are used in the ONNX graph to specify quantization information. During model conversion in *qairt-converter*, quantization information from Q-DQ sequence is extracted as metadata and the corresponding *QuantizeLinear* and *DequantizeLinear* nodes are folded to produce a quantized graph. For example, a ReLU node between a dequantize and quantize node, *int8 →Dequantize → fp32 → ReLU → fp32 → Quantize → int8* is treated equivalent to a quantized ReLU operator *int8-> ReLU → int8*. First, quantization encoding from Q-DQ nodes is extracted and stored as metadata (also referred to as Encoding) attached to the corresponding tensor. Next, the encoding is applied to the tensor resulting in a quantized graph. The following figure shows how the Q-DQ nodes are folded to extract quantization encoding and then produce a quantized graph. Encoding collected from the source model may be overridden using the *–quantization-overrides* option. ![../_static/resources/AE_fig3.png](data:image/png;base64,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) Extract encodings from Q-DQ model and quantized tensors to build a quantized graph For more information about ONNX Q-DQ, see [QuantizeLinear - ONNX 1.18.0 documentation](https://onnx.ai/onnx/operators/onnx__QuantizeLinear.html). ### [TFLite](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id25) TFLite uses quantized nodes to convert floating-point models to lower precision. The TFLite model, including its quantized nodes, is converted into a DLC. This process involves deriving quantization encodings using TFLite quantization parameters (scale, zero-point) before associating it with the tensor in the DLC. Encodings collected from the source model may be overridden using the *–quantization-overrides* option. ### [TensorFlow](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id26) The *FakeQuant* node in TensorFlow is used for quantization-aware training. It simulates the effects of quantization during training, allowing the model to learn the quantization effects and potentially achieve higher accuracy when quantized. Quantization information present in the *FakeQuant* node stored as quantization encoding metadata (preceding figure shows int8 encodings stored as metadata associated with float-16 tensors). Encoding collected from the source model may be overridden using the *–quantization-overrides* option. For more information on FakeQuant see [tf.quantization.fake_quant_with_min_max_args](https://www.tensorflow.org/api_docs/python/tf/quantization/fake_quant_with_min_max_args). ## [Appendix C: JSON schema version 2.0.0](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id27) JSON schema uses keys which are closely aligned with attributes of the ONNX *QuantizeLinear* operators detailed below. - **name**: name of the tensor - **output\_dtype:** tensor data type with bit-width appended. Valid values for this field are listed. “int4”, “uint4”, “int8”, “uint8”, “int16”, “uint16”, “int32”, “uint32”, “float32”, “float16”. - **y\_scale**: tensor data is quantized with this scale value. - **y\_zero\_point (optional, default = 0)**: tensor data is quantized with the provided zero point. Internally this is stored as *offset =- y\_zero\_point*. Its value may be used to interpret symmetry of the quantized data. - **axis (optional)**: Set when per-channel quantization or block quantization is used. For per-channel quantization, it indicates the channel axis along which the scale values are specified. For block quantization, (when *block\_size* is specified) it indicates the tensor axis along which blocking is done. - **block\_size (optional)**: Set only when block quantization is used. Size of the block along the specified *axis*. - **per\_channel\_float\_scale (optional):** TBD - **per\_block\_int\_scale (optional)**: Applicable when Low Power Block Quantization is used, for which block\_size must be provided. An integer scale is assigned per block. - **index\_tensor (optional)**: When present, indicates that this tensor uses an Array-Of encoding. An Array-Of encoding wraps multiple sub-encodings (e.g. per-tensor or per-channel) into a single tensor encoding. This is used for operations like [QNN_OP_ELEMENT_WISE_MUX](https://docs.qualcomm.com/bundle/publicresource/topics/80-63442-10/operations.html#elementwisemux) where the output tensor may dynamically select between different quantization parameters at runtime. Specifies the name of the tensor that serves as the index selector for choosing which sub-encoding to apply at runtime. For example, in a `QNN_OP_ELEMENT_WISE_MUX` operation, this would be the condition input tensor. When `index_tensor` is present, the `y_scale`, `y_zero_point`, and other array fields are interpreted as arrays of arrays, where each outer element defines one sub-encoding. ### [Per tensor quantization encoding example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id28) { “name”: “activation”, “output_dtype”: “uint8”, “y_scale”: 1.0, “y_zero_point”: 128 } Copy to clipboard ### [Per channel quantization encoding example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id29) Example encodings for channel *axis = 0* and *length = 3.* { “name”: “conv.weight”, “output_dtype”: “int8”, “y_scale”: [ 0.0050100767984986305, 0.0017133733490481973, 0.0017133733490481973, ] “axis”: 0 } Copy to clipboard ### [Blockwise quantization encoding (BQ) example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id30) shape: [3, 64] channel\_axis: 0 block\_axis: 1 block\_size: 32 { “name”: “conv22.weight”, “output_dtype”: “int4” “y_scale”: [ [0.01, 0.02], [0.03, 0.04], [0.05, 0.06] ], “y_zero_point”: [ [0, 0], [0, 0], [0, 0] ], “axis”: 1, “block_size”: 32, } Copy to clipboard ### [Blockwise quantization encoding (BQ) with float offset example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id31) shape: [3, 64] channel\_axis: 0 block\_axis: 1 block\_size: 32 { “name”: “conv22.weight”, “output_dtype”: “int4” “y_scale”: [ [0.01, 0.02], [0.03, 0.04], [0.05, 0.06] ], “y_zero_point”: [ [-0.16, 0.24], [-0.35, 0.13], [-0.14, 0.37] ], “axis”: 1, “block_size”: 32, } Copy to clipboard ### [Low power blockwise quantization (LPBQ) example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id32) { "name": "conv2.weight", "output_dtype": "int4" "per_channel_float_scale": [ 0.01, 0.02, 0.03 ], "per_block_int_scale": [ [1, 2, 16], [2, 16, 7], [16, 3, 1] ], "offset": 0, "block_size": [1, 3], } Copy to clipboard ### [Array-Of encoding example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id33) An Array-Of encoding is used for tensors whose quantization parameters are selected dynamically at runtime, such as the output of a [QNN_OP_ELEMENT_WISE_MUX](https://docs.qualcomm.com/bundle/publicresource/topics/80-63442-10/operations.html#elementwisemux) operation. The encoding contains multiple sub-encodings, one for each possible selection path. The `index_tensor` field names the selector tensor and its presence indicates that this is an Array-Of encoding. { "name": "mux_output", "output_dtype": "uint8", "index_tensor": "condition_tensor", "y_scale": [ [0.05], [0.03] ], "y_zero_point": [ [128], [64] ] } Copy to clipboard ### [Array-Of encoding with per-channel sub-encodings example](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id34) An Array-Of encoding can also wrap per-channel sub-encodings. In this case, each sub-encoding specifies an array of per-channel scale and zero-point values along with the `axis` field indicating the channel axis. Example with channel *axis = 0* and *length = 3*, with 2 sub-encodings corresponding to 2 possible selections from the index tensor: { "name": "mux_output", "output_dtype": "int8", "index_tensor": "condition_tensor", "y_scale": [ [0.005, 0.002, 0.003], [0.004, 0.001, 0.006] ], "y_zero_point": [ [0, 0, 0], [0, 0, 0] ], "axis": 0 } Copy to clipboard ## [Appendix D: Super groups](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id35) Super groups are listed per target in this section. ### [HTP super groups](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id36) The following table lists the super groups for HTP backend. These super groups are supported by Hexagon architecture version greater than v73. | **Super group patterns** | | --- | | QNN\_OP\_ELEMENT\_WISE\_ADD + QNN\_OP\_RELU | | QNN\_OP\_CONV\_2D + QNN\_OP\_HARD\_SWISH | | QNN\_OP\_CONV\_2D + QNN\_OP\_PRELU | | QNN\_OP\_CONV\_2D + QNN\_OP\_RELU\_MIN\_MAX | | QNN\_OP\_CONV\_2D + QNN\_OP\_RELU | | QNN\_OP\_TRANSPOSE\_CONV\_2D + QNN\_OP\_RELU | | QNN\_OP\_FULLY\_CONNECTED + QNN\_OP\_RELU | ## [Appendix E: Data movement ops](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id37) Data movement ops must have the same input and output quantization encodings. ### [HTP data movement ops](https://docs.qualcomm.com/doc/80-63442-10/topic/applyencodings.html#id38) The following is the complete list of data movement ops supported by HTP. | **Data Movement Ops** | | --- | | QNN\_OP\_GATHER | | QNN\_OP\_GATHER\_ELEMENTS | | QNN\_OP\_GATHER\_ND | | QNN\_OP\_TOP\_K | | QNN\_OP\_BATCH\_TO\_SPACE | | QNN\_OP\_CHANNEL\_SHUFFLE | | QNN\_OP\_SPACE\_TO\_BATCH | | QNN\_OP\_TILE | Last Published: Jun 04, 2026 [Previous Topic Quantization](https://docs.qualcomm.com/bundle/publicresource/80-63442-10/topics/quantization.md) [Next Topic Tutorials](https://docs.qualcomm.com/bundle/publicresource/80-63442-10/topics/general_tutorials.md)