# Quantization Recipes

The quantization recipe system provides a registry of named recipes that
encapsulate complete quantization workflows (quantizer + optimizer chains).

## RecipeRegistry

- *class* qairt.experimental.pipeline.torch.llm.quantization.recipes.registry.RecipeRegistry

    - Bases: `object`

Central registry for quantization recipes.

- *classmethod* get(*name: str*) → Type[[AIMETQuantizationRecipe](https://docs.qualcomm.com/doc/80-87189-2/topic/qairt-pipeline-quantization.html#qairt.experimental.pipeline.torch.llm.quantization.recipes.recipe.AIMETQuantizationRecipe)]

    - Get recipe class by name.

- Parameters

    - **name** – Recipe identifier

- Returns

    - Recipe class

- Raises

    - **ValueError** – If recipe not found

- *classmethod* get\_default\_config(*name: str*) → Optional[Path]

    - Get default config path for recipe.

- Parameters

    - **name** – Recipe identifier

- Returns

    - Path to default config file, or None if not registered

- *classmethod* list\_recipes() → list[dict]

    - List all registered recipes with metadata.

- Returns

    - List of dicts with ‘name’, ‘result\_type’, and ‘description’ keys.

- *classmethod* register(*name: str*, *recipe\_class: Type[[AIMETQuantizationRecipe](https://docs.qualcomm.com/doc/80-87189-2/topic/qairt-pipeline-quantization.html#qairt.experimental.pipeline.torch.llm.quantization.recipes.recipe.AIMETQuantizationRecipe)]*, *default\_config: Optional[Union[str, Path]] = None*)

    - Register a recipe with optional default config.

- Parameters

    - - **name** – Recipe identifier (e.g., “lpbq\_mse”)
- **recipe\_class** – Recipe class to register
- **default\_config** – Path to default YAML config file

## AIMETQuantizationRecipe

- *class* qairt.experimental.pipeline.torch.llm.quantization.recipes.recipe.AIMETQuantizationRecipe

    - Bases: `ABC`

Base class for AIMET Quantization Recipes.

A recipe combines optimization techniques (e.g., SpinQuant, AdaScale) with
quantization techniques (e.g., LPBQ, PCQ) to create complete quantization workflows.

Recipes use a nested parameter convention with maximum 2 levels:

<technique>: {<parameter>: <value>, ...}
    Copy to clipboard

Example:

seqmse:
        num_batches: 20
        num_candidates: 20
    lpbq:
        module_precisions:
          lm_head: "int8"
        tie_quantizers: [concat]
    Copy to clipboard

- *abstract* apply(*model: Module*, *context\_length: int = 4096*, *sequence\_length: int = 2048*, *tokenizer: Optional[AutoTokenizer] = None*, *dataloader: Optional[DataLoader] = None*, *\*\*recipe\_kwargs*) → qairt.experimental.pipeline.torch.llm.quantization.techniques.bases.definitions.QuantizationResult | qairt.experimental.pipeline.torch.llm.quantization.techniques.bases.definitions.OptimizationResult

    - Apply the quantization recipe.

- Parameters

    - - **model** – HuggingFace model to quantize.
- **context\_length** – Max context length for inputs.
- **sequence\_length** – Sequence length for dummy inputs.
- **tokenizer** – Optional tokenizer associated with the model.
- **dataloader** – Optional dataloader for calibration/optimization.
- **\*\*recipe\_kwargs** – Additional keyword arguments to forward to optimizers/quantizers.
Recipe kwargs use nested structure (max 2 levels):
`<technique>: {<parameter>: <value>, ...}`
Example: `seqmse={'num_batches': 20, 'num_candidates': 20}`

- Returns

    - QuantizationResult if recipe includes quantization step, or
OptimizationResult if recipe only performs optimization.

- *classmethod* apply\_from\_config(*config: Optional[Union[str, Dict]] = None*, *config\_overrides: Optional[Dict] = None*, *model: Optional[Module] = None*, *tokenizer: Optional[AutoTokenizer] = None*, *dataloader: Optional[DataLoader] = None*) → qairt.experimental.pipeline.torch.llm.quantization.techniques.bases.definitions.QuantizationResult | qairt.experimental.pipeline.torch.llm.quantization.techniques.bases.definitions.OptimizationResult | None

    - Apply the quantization recipe entirely using configuration from a YAML file.

The configuration file must include:

- ‘model\_id’: Model identifier. Used to load model/tokenizer if not provided, and to
filter whether recipe should be applied if model is already provided.

The configuration file can optionally include:

- ‘dataset’: Automatically create a dataloader. Currently supports ‘wikitext’.
If specified and dataloader is None, a dataloader will be created automatically.

- Parameters

    - - **config** – Path to recipe configuration YAML file or config dict. If None, uses default config from class.
- **config\_overrides** – Optional dictionary to override specific configuration parameters.
- **model** – Optional HuggingFace model to quantize. If None, will be loaded using
‘model\_id’ from config.
- **tokenizer** – Optional tokenizer. If None, will be loaded using ‘model\_id’ from config.
- **dataloader** – Optional dataloader for calibration/optimization.

- Returns

    - QuantizationResult or OptimizationResult with recipe applied, or None if model\_id filter does not match.

- Raises

    - **ValueError** – If model\_id is not in config and model is None.

- config*: Optional[Union[Dict[str, Any], str]]*  *= None*

    - 

- result\_type

    - alias of `QuantizationResult`

## Module-Level Functions

- qairt.experimental.pipeline.torch.llm.quantization.recipes.registry.list\_recipes() → list[dict]

    - List all available recipes with metadata.

- Returns

    - List of dicts with ‘name’, ‘result\_type’, and ‘description’ keys.

- qairt.experimental.pipeline.torch.llm.quantization.recipes.registry.load\_recipe(*name: str*, *\**, *config\_overrides: Optional[Dict[str, Any]] = None*)

- qairt.experimental.pipeline.torch.llm.quantization.recipes.registry.load\_recipe(*name: str*, *config: Optional[Union[str, Path, Dict[str, Any]]]*, *config\_overrides: Optional[Dict[str, Any]] = None*)

    - Load a recipe by name, returning a callable that delegates to apply\_from\_config.

- Parameters

    - - **name** – Recipe identifier (e.g., “lpbq\_seqmse”)
- **config** – Optional config source:
- `None`: use the recipe class default config.
- `dict`: dict of overrides applied on top of the class default config.
- `str`/`Path`: load YAML and resolve `name` as a top-level key.
- **config\_overrides** – Optional dict to override default config values

- Returns

    - A functools.partial wrapping recipe\_class.apply\_from\_config

- Raises

    - **ValueError** – If recipe not found

Example

recipe = load\_recipe(“lpbq\_seqmse”)
result = recipe(model=model, tokenizer=tok, dataloader=loader)

- qairt.experimental.pipeline.torch.llm.quantization.recipes.registry.register\_recipe(*name: str*, *default\_config: Optional[Union[str, Path]] = None*)

    - Decorator to register a recipe.

Example:

@register_recipe("lpbq_mse", default_config="recipes/configs/lpbq_mse.yaml")
    class LPBQ_SeqMSE_Recipe(AIMETQuantizationRecipe):
        ...
    Copy to clipboard

- Parameters

    - - **name** – Recipe identifier
- **default\_config** – Optional path to default YAML config file. When omitted,
it is inferred as `<recipe_file_parent>/configs/<name>.yaml`.

- Returns

    - Decorator function

## Default Recipes

Default concrete recipe implementations.

- *class* qairt.experimental.pipeline.torch.llm.quantization.recipes.defaults.AdaScaleHfRecipe

    - Bases: [`AIMETQuantizationRecipe`](https://docs.qualcomm.com/doc/80-87189-2/topic/qairt-pipeline-quantization.html#qairt.experimental.pipeline.torch.llm.quantization.recipes.recipe.AIMETQuantizationRecipe)

AdaScale HF-adapter optimization (adaptive weight scaling).

- apply(*model: Module*, *context\_length: int = 4096*, *sequence\_length: int = 2048*, *tokenizer=None*, *dataloader=None*, *\*\*recipe\_kwargs*) → OptimizationResult

    - Apply the quantization recipe.

- Parameters

    - - **model** – HuggingFace model to quantize.
- **context\_length** – Max context length for inputs.
- **sequence\_length** – Sequence length for dummy inputs.
- **tokenizer** – Optional tokenizer associated with the model.
- **dataloader** – Optional dataloader for calibration/optimization.
- **\*\*recipe\_kwargs** – Additional keyword arguments to forward to optimizers/quantizers.
Recipe kwargs use nested structure (max 2 levels):
`<technique>: {<parameter>: <value>, ...}`
Example: `seqmse={'num_batches': 20, 'num_candidates': 20}`

- Returns

    - QuantizationResult if recipe includes quantization step, or
OptimizationResult if recipe only performs optimization.

- config*: Dict[str, Any] | str | None*  *= 'configs/ada\_scale\_hf.yaml'*

    - 

- result\_type

    - alias of `OptimizationResult`

- *class* qairt.experimental.pipeline.torch.llm.quantization.recipes.defaults.AdaScale\_GPTAQ\_Recipe

    - Bases: [`AIMETQuantizationRecipe`](https://docs.qualcomm.com/doc/80-87189-2/topic/qairt-pipeline-quantization.html#qairt.experimental.pipeline.torch.llm.quantization.recipes.recipe.AIMETQuantizationRecipe)

Recipe combining AdaScale optimization with GPTAQ optimization.

- apply(*model: Module*, *context\_length: int = 4096*, *sequence\_length: int = 2048*, *tokenizer: Optional[AutoTokenizer] = None*, *dataloader: Optional[DataLoader] = None*, *generator: Optional[Any] = None*, *\*\*recipe\_kwargs*) → OptimizationResult

    - Apply the quantization recipe.

- Parameters

    - - **model** – HuggingFace model to quantize.
- **context\_length** – Max context length for inputs.
- **sequence\_length** – Sequence length for dummy inputs.
- **tokenizer** – Optional tokenizer associated with the model.
- **dataloader** – Optional dataloader for calibration/optimization.
- **\*\*recipe\_kwargs** – Additional keyword arguments to forward to optimizers/quantizers.
Recipe kwargs use nested structure (max 2 levels):
`<technique>: {<parameter>: <value>, ...}`
Example: `seqmse={'num_batches': 20, 'num_candidates': 20}`

- Returns

    - QuantizationResult if recipe includes quantization step, or
OptimizationResult if recipe only performs optimization.

- config*: Dict[str, Any] | str | None*  *= 'configs/adascale\_gptaq.yaml'*

    - 

- result\_type

    - alias of `OptimizationResult`

- *class* qairt.experimental.pipeline.torch.llm.quantization.recipes.defaults.CalibratorRecipe

    - Bases: [`AIMETQuantizationRecipe`](https://docs.qualcomm.com/doc/80-87189-2/topic/qairt-pipeline-quantization.html#qairt.experimental.pipeline.torch.llm.quantization.recipes.recipe.AIMETQuantizationRecipe)

Plain Calibrator recipe for calibration-and-export-oriented PTQ flows.

- apply(*model: Module*, *context\_length: int = 4096*, *sequence\_length: int = 2048*, *tokenizer: Optional[AutoTokenizer] = None*, *dataloader: Optional[DataLoader] = None*, *generator: Optional[Any] = None*, *\*\*recipe\_kwargs*) → QuantizationResult

    - Apply the existing Calibrator technique through the recipe registry.

This recipe intentionally performs only calibration/encoding generation.
It does not run LPBQ, SeqMSE, AdaScale, GPTAQ, or any other optimization
pass.  Keeping it as a normal recipe preserves the YAML pipeline contract:
QuantizationStage selects by recipe\_name and remains unaware of raw
technique classes.

- config*: Dict[str, Any] | str | None*  *= 'configs/calibrator.yaml'*

    - 

- result\_type

    - alias of `QuantizationResult`

- *class* qairt.experimental.pipeline.torch.llm.quantization.recipes.defaults.GPTAQHfRecipe

    - Bases: [`AIMETQuantizationRecipe`](https://docs.qualcomm.com/doc/80-87189-2/topic/qairt-pipeline-quantization.html#qairt.experimental.pipeline.torch.llm.quantization.recipes.recipe.AIMETQuantizationRecipe)

GPTAQ weight quantization pass.

- apply(*model: Module*, *context\_length: int = 4096*, *sequence\_length: int = 2048*, *tokenizer=None*, *dataloader=None*, *\*\*recipe\_kwargs*) → OptimizationResult

    - Apply the quantization recipe.

- Parameters

    - - **model** – HuggingFace model to quantize.
- **context\_length** – Max context length for inputs.
- **sequence\_length** – Sequence length for dummy inputs.
- **tokenizer** – Optional tokenizer associated with the model.
- **dataloader** – Optional dataloader for calibration/optimization.
- **\*\*recipe\_kwargs** – Additional keyword arguments to forward to optimizers/quantizers.
Recipe kwargs use nested structure (max 2 levels):
`<technique>: {<parameter>: <value>, ...}`
Example: `seqmse={'num_batches': 20, 'num_candidates': 20}`

- Returns

    - QuantizationResult if recipe includes quantization step, or
OptimizationResult if recipe only performs optimization.

- config*: Dict[str, Any] | str | None*  *= 'configs/gptaq\_hf.yaml'*

    - 

- result\_type

    - alias of `OptimizationResult`

- *class* qairt.experimental.pipeline.torch.llm.quantization.recipes.defaults.LPBQ\_SeqMSE\_Recipe

    - Bases: [`AIMETQuantizationRecipe`](https://docs.qualcomm.com/doc/80-87189-2/topic/qairt-pipeline-quantization.html#qairt.experimental.pipeline.torch.llm.quantization.recipes.recipe.AIMETQuantizationRecipe)

Recipe combining LPBQ quantization with SeqMSE optimization.

- Execution order:
    - 1. Create quantsim with module precisions
2. Apply LPBQ blockwise topology (before any optimization)
3. Run SeqMSE (optimizes with LPBQ topology in place)
4. Calibrate / compute encodings (directly on quantsim)

- Uses nested parameter structure (max 2 levels):
    - seqmse: {num\_batches: 20, num\_candidates: 20}
lpbq: {module\_precisions: {kv\_cache: {weight\_precision: int8}}, tie\_quantizers: [concat]}

- apply(*model: Module*, *context\_length: int = 4096*, *sequence\_length: int = 2048*, *tokenizer: Optional[AutoTokenizer] = None*, *dataloader: Optional[DataLoader] = None*, *seqmse\_dataloader: Optional[DataLoader] = None*, *generator: Optional[Any] = None*, *\*\*recipe\_kwargs*) → QuantizationResult

    - Apply the quantization recipe.

- Parameters

    - - **model** – HuggingFace model to quantize.
- **context\_length** – Max context length for inputs.
- **sequence\_length** – Sequence length for dummy inputs.
- **tokenizer** – Optional tokenizer associated with the model.
- **dataloader** – Optional dataloader for calibration/optimization.
- **\*\*recipe\_kwargs** – Additional keyword arguments to forward to optimizers/quantizers.
Recipe kwargs use nested structure (max 2 levels):
`<technique>: {<parameter>: <value>, ...}`
Example: `seqmse={'num_batches': 20, 'num_candidates': 20}`

- Returns

    - QuantizationResult if recipe includes quantization step, or
OptimizationResult if recipe only performs optimization.

- config*: Dict[str, Any] | str | None*  *= 'configs/lpbq\_seqmse.yaml'*

    -

- *class* qairt.experimental.pipeline.torch.llm.quantization.recipes.defaults.PrefixQuantRecipe

    - Bases: [`AIMETQuantizationRecipe`](https://docs.qualcomm.com/doc/80-87189-2/topic/qairt-pipeline-quantization.html#qairt.experimental.pipeline.torch.llm.quantization.recipes.recipe.AIMETQuantizationRecipe)

Prefix KV-cache pre-computation optimization.

- apply(*model: Module*, *context\_length: int = 4096*, *sequence\_length: int = 2048*, *tokenizer=None*, *dataloader=None*, *\*\*recipe\_kwargs*) → OptimizationResult

    - Apply the quantization recipe.

- Parameters

    - - **model** – HuggingFace model to quantize.
- **context\_length** – Max context length for inputs.
- **sequence\_length** – Sequence length for dummy inputs.
- **tokenizer** – Optional tokenizer associated with the model.
- **dataloader** – Optional dataloader for calibration/optimization.
- **\*\*recipe\_kwargs** – Additional keyword arguments to forward to optimizers/quantizers.
Recipe kwargs use nested structure (max 2 levels):
`<technique>: {<parameter>: <value>, ...}`
Example: `seqmse={'num_batches': 20, 'num_candidates': 20}`

- Returns

    - QuantizationResult if recipe includes quantization step, or
OptimizationResult if recipe only performs optimization.

- config*: Dict[str, Any] | str | None*  *= 'configs/prefix\_quant.yaml'*

    - 

- result\_type

    - alias of `OptimizationResult`

- *class* qairt.experimental.pipeline.torch.llm.quantization.recipes.defaults.SeqMSEOptimizationRecipe

    - Bases: [`AIMETQuantizationRecipe`](https://docs.qualcomm.com/doc/80-87189-2/topic/qairt-pipeline-quantization.html#qairt.experimental.pipeline.torch.llm.quantization.recipes.recipe.AIMETQuantizationRecipe)

SeqMSE weight optimization

- apply(*model: Module*, *context\_length: int = 4096*, *sequence\_length: int = 2048*, *tokenizer=None*, *dataloader=None*, *\*\*recipe\_kwargs*) → OptimizationResult

    - Apply the quantization recipe.

- Parameters

    - - **model** – HuggingFace model to quantize.
- **context\_length** – Max context length for inputs.
- **sequence\_length** – Sequence length for dummy inputs.
- **tokenizer** – Optional tokenizer associated with the model.
- **dataloader** – Optional dataloader for calibration/optimization.
- **\*\*recipe\_kwargs** – Additional keyword arguments to forward to optimizers/quantizers.
Recipe kwargs use nested structure (max 2 levels):
`<technique>: {<parameter>: <value>, ...}`
Example: `seqmse={'num_batches': 20, 'num_candidates': 20}`

- Returns

    - QuantizationResult if recipe includes quantization step, or
OptimizationResult if recipe only performs optimization.

- config*: Dict[str, Any] | str | None*  *= 'configs/seq\_mse\_opt.yaml'*

    - 

- result\_type

    - alias of `OptimizationResult`

- *class* qairt.experimental.pipeline.torch.llm.quantization.recipes.defaults.SpinQuant\_AdaScale\_Recipe

    - Bases: [`AIMETQuantizationRecipe`](https://docs.qualcomm.com/doc/80-87189-2/topic/qairt-pipeline-quantization.html#qairt.experimental.pipeline.torch.llm.quantization.recipes.recipe.AIMETQuantizationRecipe)

Recipe combining SpinQuant and AdaScale optimizations.

- apply(*model: Module*, *context\_length: int = 4096*, *sequence\_length: int = 2048*, *tokenizer: Optional[AutoTokenizer] = None*, *dataloader: Optional[DataLoader] = None*, *generator: Optional[Any] = None*, *\*\*recipe\_kwargs*) → OptimizationResult

    - Apply SpinQuant followed by AdaScale optimization.

- config*: Dict[str, Any] | str | None*  *= 'configs/spinquant\_adascale.yaml'*

    - 

- result\_type

    - alias of `OptimizationResult`

- *class* qairt.experimental.pipeline.torch.llm.quantization.recipes.defaults.SpinQuant\_Recipe

    - Bases: [`AIMETQuantizationRecipe`](https://docs.qualcomm.com/doc/80-87189-2/topic/qairt-pipeline-quantization.html#qairt.experimental.pipeline.torch.llm.quantization.recipes.recipe.AIMETQuantizationRecipe)

Recipe applying SpinQuant optimization only (no quantization).

- Uses nested parameter structure (max 2 levels):
    - spinquant: {} (currently no parameters)

- apply(*model: Module*, *context\_length: int = 4096*, *sequence\_length: int = 2048*, *tokenizer: Optional[AutoTokenizer] = None*, *dataloader: Optional[DataLoader] = None*, *\*\*recipe\_kwargs*) → OptimizationResult

    - Apply the quantization recipe.

- Parameters

    - - **model** – HuggingFace model to quantize.
- **context\_length** – Max context length for inputs.
- **sequence\_length** – Sequence length for dummy inputs.
- **tokenizer** – Optional tokenizer associated with the model.
- **dataloader** – Optional dataloader for calibration/optimization.
- **\*\*recipe\_kwargs** – Additional keyword arguments to forward to optimizers/quantizers.
Recipe kwargs use nested structure (max 2 levels):
`<technique>: {<parameter>: <value>, ...}`
Example: `seqmse={'num_batches': 20, 'num_candidates': 20}`

- Returns

    - QuantizationResult if recipe includes quantization step, or
OptimizationResult if recipe only performs optimization.

- config*: Dict[str, Any] | str | None*  *= 'configs/spinquant.yaml'*

    - 

- result\_type

    - alias of `OptimizationResult`

Last Published: Jul 08, 2026

[Previous Topic
GenAIBuilderStage](https://docs.qualcomm.com/bundle/publicresource/80-87189-2/topics/qairt-pipeline-stages.md)