# Quantization Recipes

The pipeline provides a set of built-in quantization recipes that encapsulate
complete quantization workflows. Each recipe combines one or more techniques
(quantizers and optimizers) in a specific order.

## lpbq\_seqmse

**Description:** LPBQ quantization with SeqMSE optimization — the default
recipe for high accuracy.

**Technique chain:** SeqMSE → LPBQ → Calibration

**When to use:** Default choice for most models. Provides the best balance of
accuracy and compression.

**Parameters:**

| Parameter | Default | Description |
| --- | --- | --- |
| `seqmse.num_batches` | 20 | Number of batches for SeqMSE optimization |
| `seqmse.num_candidates` | 30 | Number of candidates to evaluate per parameter |
| `seqmse.block_size` | 4096 | Block size for SeqMSE token computation |
| `lpbq.num_calibration_batches` | 200 | Batches for calibration/encoding computation |
| `lpbq.module_precisions` | (model-specific) | Per-module precision overrides (kv\_cache, lm\_head, etc.) |
| `lpbq.tie_quantizers` | `["concat"]` | Quantizer tying strategy |
| `lpbq.clip_weights_to_7f7f` | true | Clip weights after calibration for int8 stability |

**YAML example:**

stages:
      quantization:
        recipe_name: lpbq_seqmse
        technique_kwargs:
          seqmse:
            num_batches: 20
            num_candidates: 30
          lpbq:
            num_calibration_batches: 200
    Copy to clipboard

## spinquant

**Description:** SpinQuant Hadamard rotation optimization — a pre-quantization
optimization that improves quantization quality by applying learned rotations.

**Technique chain:** SpinQuant

**When to use:** As a pre-quantization optimization stage
(`quantization_opt`) before running quantization. Improves accuracy without
adding quantization artifacts.

**Parameters:**

| Parameter | Default | Description |
| --- | --- | --- |
| `spinquant.*` | (none) | Currently no user-configurable parameters |

**YAML example:**

stages:
      quantization_opt:
        recipe_name: spinquant
    Copy to clipboard

## spinquant\_adascale

**Description:** SpinQuant rotation followed by AdaScale adaptive weight
scaling — combines two complementary optimization techniques.

**Technique chain:** SpinQuant → AdaScale → Calibration

**When to use:** When maximum accuracy is required and you can afford longer
optimization time. Combines rotation-based and scale-based optimizations.

**Parameters:**

| Parameter | Default | Description |
| --- | --- | --- |
| `spinquant.*` | (none) | SpinQuant parameters (none currently configurable) |
| `adascale.*` | (defaults) | AdaScale optimizer parameters |
| `calibration.module_precisions` | (model-specific) | Per-module precision overrides |
| `calibration.tie_quantizers` | `["concat"]` | Quantizer tying strategy |

**YAML example:**

stages:
      quantization:
        recipe_name: spinquant_adascale
    Copy to clipboard

## adascale\_gptaq

**Description:** AdaScale adaptive weight scaling followed by GPTAQ
group-quantization — combines continuous and discrete optimization.

**Technique chain:** AdaScale → GPTAQ → Calibration

**When to use:** When you need strong compression with good accuracy. GPTAQ
provides aggressive weight quantization while AdaScale preserves quality.

**Parameters:**

| Parameter | Default | Description |
| --- | --- | --- |
| `adascale.*` | (defaults) | AdaScale optimizer parameters |
| `gptaq.param_bw` | 4 | Quantization bitwidth for weights |
| `gptaq.group_size` | -1 | Group size for group quantization (-1 = per-channel) |
| `gptaq.num_calib_batches` | -1 | Number of calibration batches (-1 = use all) |
| `gptaq.seqlen` | (sequence\_length) | Sequence length for GPTAQ calibration |
| `gptaq.device` | `"cpu"` | Device for GPTAQ computation |
| `calibration.module_precisions` | (model-specific) | Per-module precision overrides |

**YAML example:**

stages:
      quantization:
        recipe_name: adascale_gptaq
        technique_kwargs:
          gptaq:
            param_bw: 4
            group_size: 128
    Copy to clipboard

## seq\_mse\_opt

**Description:** SeqMSE weight optimization only — no quantization is applied.
Used as a pre-quantization optimization step.

**Technique chain:** SeqMSE

**When to use:** As a standalone optimization in the `quantization_opt` stage
when you want to apply SeqMSE before a separate quantization stage.

**Parameters:**

| Parameter | Default | Description |
| --- | --- | --- |
| `seq_mse.num_batches` | 20 | Number of batches for optimization |
| `seq_mse.num_candidates` | 30 | Candidate count per parameter |

**YAML example:**

stages:
      quantization_opt:
        recipe_name: seq_mse_opt
    Copy to clipboard

## ada\_scale\_hf

**Description:** AdaScale optimization using the HuggingFace adapter
integration — applies adaptive weight scaling through the HF quantization API.

**Technique chain:** HF-adapter AdaScale

**When to use:** When working with HuggingFace-native quantization workflows
and you need adaptive scaling.

**Parameters:**

| Parameter | Default | Description |
| --- | --- | --- |
| `context_length` | 4096 | Context length for optimization |
| `sequence_length` | 2048 | Sequence length for optimization |

**YAML example:**

stages:
      quantization_opt:
        recipe_name: ada_scale_hf
    Copy to clipboard

## gptaq\_hf

**Description:** GPTAQ weight quantization using the HuggingFace adapter
integration — applies group-wise quantization through the HF API.

**Technique chain:** HF-adapter GPTAQ

**When to use:** For HuggingFace-integrated GPTAQ quantization when you need
strong weight compression.

**Parameters:**

| Parameter | Default | Description |
| --- | --- | --- |
| `param_bw` | 4 | Weight quantization bitwidth |
| `group_size` | -1 | Group size for group quantization |
| `num_calib_batches` | -1 | Number of calibration batches |
| `seqlen` | (sequence\_length) | Sequence length for calibration |

**YAML example:**

stages:
      quantization:
        recipe_name: gptaq_hf
        technique_kwargs:
          param_bw: 4
          group_size: 128
    Copy to clipboard

## prefix\_quant

**Description:** Prefix KV-cache pre-computation optimization — optimizes the
KV-cache prefix computation for faster inference.

**Technique chain:** HF-adapter PrefixQuant

**When to use:** When targeting inference scenarios with shared prefixes (e.g.,
system prompts) to reduce first-token latency.

**Parameters:**

| Parameter | Default | Description |
| --- | --- | --- |
| (recipe-specific) | (defaults) | PrefixQuant configuration parameters |

**YAML example:**

stages:
      quantization_opt:
        recipe_name: prefix_quant
    Copy to clipboard

Last Published: Jul 08, 2026

[Previous Topic
Quantization Recipes](https://docs.qualcomm.com/bundle/publicresource/80-87189-2/topics/pipeline_configuration.md) [Next Topic
Customizing the Pipeline](https://docs.qualcomm.com/bundle/publicresource/80-87189-2/topics/pipeline_customization.md)