Skip to content

[OMNIML-5477, OMNIML-5119] Add module-specific AutoQuant search spaces#1949

Merged
meenchen merged 11 commits into
mainfrom
weimingc/autoquant-module-search-space
Jul 22, 2026
Merged

[OMNIML-5477, OMNIML-5119] Add module-specific AutoQuant search spaces#1949
meenchen merged 11 commits into
mainfrom
weimingc/autoquant-module-search-space

Conversation

@meenchen

@meenchen meenchen commented Jul 9, 2026

Copy link
Copy Markdown
Contributor

What does this PR do?

Type of change: New feature.

This PR adds ordered, module-name-specific search spaces to AutoQuant so different runtime decision groups can use different candidate formats.

The user-facing design now separates fixed PTQ configuration from the AutoQuant search space:

  • A normal top-level quantize config defines the fixed baseline for modules that are not searched.
  • auto_quantize.module_search_spaces explicitly lists only the module families AutoQuant should search.
  • Top-level auto_quantize.candidate_formats remains available for the existing global-search mode, but it is mutually exclusive with a fixed quantize baseline.
  • Fixed and searched groups still participate in one integrated calibration, sensitivity-scoring, active-MoE cost, LP selection, checkpoint, and export flow.

Additional safeguards:

  • Reject module rules that partially split a runtime-fused decision group.
  • Keep BF16/no-quant as an internal sensitivity baseline while allowing each search-space rule to control whether it is solver-selectable.
  • Isolate fixed groups from unrelated calibration algorithms.
  • Reject infeasible budgets from the resolved per-group choices before calibration.
  • Fingerprint the fixed PTQ baseline, runtime groups, candidate choices, scoring boundaries, replay attributes, and cost weights before checkpoint reuse.
  • Preserve the previous global candidate-format API and one-candidate module rules for backward compatibility.

Design rationale

The fixed configuration should use the same PTQ recipe system users already use for uniform NVFP4, W4A16, FP8, and other baseline configurations. AutoQuant then only needs to describe what is genuinely searched.

For example, the Qwen3.6 recipe reuses the model-specific quantization configuration from huggingface/qwen3_5_moe/ptq/w4a16_nvfp4-fp8_attn-kv_fp8_cast. Unmatched modules retain that PTQ baseline, while shared experts, self-attention, linear-attention, and lm_head are explicitly searched. The original PTQ recipe is unchanged, and a loader test asserts that both recipes resolve to the same fixed quantize configuration.

This remains one AutoQuant operation rather than staged PTQ plus AutoQuant:

  • NAS SearchSpace models generic architecture hyperparameters and is not connected to AutoQuant calibration snapshots, sensitivity scoring, runtime-fused groups, active-MoE accounting, or quant-config export.
  • Ordered QuantizeConfig wildcard rules can describe a final static assignment, but cannot express per-family candidate sets in one global budget solve.
  • Applying fixed PTQ before or after a separate AutoQuant pass would remove those modules from the shared sensitivity baseline and active-MoE numerator/denominator.

The implementation therefore composes the existing PTQ recipe schema with the existing AutoQuant/PuLP path instead of introducing another search framework or solver.

Usage

imports:
  model_quant_cfg: huggingface/qwen3_5/ptq/w4a16_nvfp4-fp8_attn-kv_fp8_cast.quant_cfg
  w4a16_nvfp4: configs/ptq/presets/model/w4a16_nvfp4
  fp8: configs/ptq/presets/model/fp8

# Same model-specific baseline as the Qwen3.5-MoE PTQ recipe.
quantize:
  algorithm:
    method: max
    layerwise:
      enable: false
  quant_cfg:
    - $import: model_quant_cfg

auto_quantize:
  constraints:
    effective_bits: 6.0
    cost_model: active_moe
    cost:
      active_moe_expert_ratio: 0.03125

  # Only these modules are AutoQuant decision variables.
  module_search_spaces:
    - module_name_patterns:
        - "*mlp.shared_expert*"
        - "*linear_attn*"
        - "*self_attn*"
        - "*lm_head*"
      candidate_formats:
        - $import: w4a16_nvfp4
        - $import: fp8
      allow_no_quant: false

The legacy global-search form remains supported by omitting quantize and supplying top-level auto_quantize.candidate_formats.

Qwen3.6 search-space comparison

Compared the default W4A16 NVFP4/FP8 search against the historical two-format module-specific recipe that keeps routed experts on the W4A16 PTQ baseline while shared experts and attention search W4A16 versus FP8. The final PR recipe keeps every matched quantizable group in W4A16 or FP8 (allow_no_quant: false). The table below is retained as evidence for the fixed-baseline design; the final recipe validation follows it.

Both lanes used local raw-gradient scoring, active-MoE accounting, batch size 1, code32k calibration, full parser-on LiveCodeBench with 8 repeats, and full SciCode. Active GiB/token includes scale storage.

Target bits Active GiB/token, default -> fixed W4 routed Attention BF16+FP8, default -> fixed W4 routed LCB, default -> fixed W4 routed SciCode, default -> fixed W4 routed
5.8 2.1289 -> 2.0135 49.2% -> 80.0% 70.8150 -> 72.4945 (+1.6795 pp) 40.0518 -> 40.4216 (+0.3698 pp)
6.1 2.2342 -> 2.1070 61.5% -> 93.8% 72.5220 -> 73.5683 (+1.0463 pp) 39.1642 -> 39.3861 (+0.2219 pp)
6.4 2.3387 -> 2.2181 67.7% -> 79.2% 72.0540 -> 73.9813 (+1.9273 pp) 38.2027 -> 39.9038 (+1.7011 pp)
6.7 2.4392 -> 2.3173 72.3% -> 93.8% 72.5220 -> 73.4581 (+0.9361 pp) 38.7944 -> 39.6820 (+0.8876 pp)

BF16 references are 74.3667 LCB and 40.7914 SciCode. With a 1.5 percentage-point tolerance, the fixed-routed-expert lane jointly passes at targets 6.1, 6.4, and 6.7; the default lane has no joint pass. This comparison is end-to-end rather than an isolated solver ablation because the historical default lane used full attention-family grouping while the module-specific lane used runtime-required grouping.

Final no-BF16 recipe validation used the model-specific PTQ baseline, codeblend 16k calibration, local gradient scoring, active-MoE accounting, batch size 1, and full parser-on LiveCodeBench with 8 repeats:

Target bits Active GiB/token Linear attention FP8/W4 Self attention FP8/W4 Shared experts FP8/W4 lm_head LCB pass@1 avg-of-8 Avg completion tokens Delta vs BF16
6.0 2.0823 80/10 36/4 97/23 W4 73.2930 39,319.1 -1.0737 pp
6.3 2.1848 59/31 35/5 84/36 FP8 73.8711 38,515.8 -0.4956 pp

Both targets pass the BF16-minus-1.5pp threshold. The model-specific baseline intentionally leaves linear-attention A/B and non-linear helper modules unquantized; all searched quantizable projections are W4A16 or FP8, and the artifact audit found no missing quant tensors.

Testing

  • Fresh four-GPU Qwen3.6 model-specific-baseline E2E runs completed calibration, gradient search, ModelOpt export, and runtime validation at 6.0 and 6.3 effective bits. Slurm jobs 2649968 and 2649969 completed with exit code 0. Both artifacts had complete shards, valid runtime metadata, and zero quantized modules missing quant tensors.
  • Pre-commit passed: Ruff, formatting, mypy, Bandit, Markdown/YAML checks, and recipe validation.
  • 306 focused AutoQuant, recipe-loader, and HF PTQ tests passed for the implementation.
  • All 212 recipe-loader and HF PTQ mapping tests passed for the model-specific PTQ baseline integration. After the final allow_no_quant: false update, the focused loader/HF mapping tests and full pre-commit recipe validation passed. The original PTQ recipe remains unchanged, and the resolved fixed baselines compare equal.
  • The distributed AutoQuant unit test passed separately outside the local socket sandbox.
  • Wider quantization validation reached 782 passing tests; remaining local failures were unrelated optional dependency/socket limitations.
  • Historical four-GPU Qwen3.6 E2E calibration, search, export, and metadata verification for the fixed-W4 baseline variant:
    • Slurm job 2645235 completed with exit code 0 in 9m53s.
    • Achieved 5.99 effective bits.
    • All 40 routed-expert groups remained fixed W4A16.
    • Exported valid searched allocations: linear attention FP8/W4 = 78/12, self-attention = 37/3, shared experts = 112/8, lm_head = W4.
    • Produced and verified a 21 GiB ModelOpt checkpoint.
  • Completed the four-target full parser-on LCB/SciCode evaluation summarized above.
  • Final no-BF16 parser-on LCB jobs 2650360 and 2650367 completed with exit code 0; their 8-repeat results are summarized above.

Before this PR is ready for review

  • Is this change backward compatible?: ✅
  • If code was copied or a new dependency was added, was the contribution guidance followed?: N/A
  • Were necessary tests added?: ✅
  • Was the changelog updated?: ✅
  • Claude approval after the latest update?: Pending

Additional Information

Related work: OMNIML-5477, OMNIML-5119.

@copy-pr-bot

copy-pr-bot Bot commented Jul 9, 2026

Copy link
Copy Markdown

This pull request requires additional validation before any workflows can run on NVIDIA's runners.

Pull request vetters can view their responsibilities here.

Contributors can view more details about this message here.

@coderabbitai

coderabbitai Bot commented Jul 9, 2026

Copy link
Copy Markdown
Contributor

Review Change Stack

Note

Reviews paused

It looks like this branch is under active development. To avoid overwhelming you with review comments due to an influx of new commits, CodeRabbit has automatically paused this review. You can configure this behavior by changing the reviews.auto_review.auto_pause_after_reviewed_commits setting.

Use the following commands to manage reviews:

  • @coderabbitai resume to resume automatic reviews.
  • @coderabbitai review to trigger a single review.

Use the checkboxes below for quick actions:

  • ▶️ Resume reviews
  • 🔍 Trigger review
📝 Walkthrough

Walkthrough

Changes

AutoQuantize adds module-specific search spaces, optional fixed PTQ baselines, per-group no-quant controls, isolated calibration, stable cost accounting, and checkpoint compatibility validation. Recipe schemas, Hugging Face conversion, documentation, a Qwen recipe, and tests are updated.

AutoQuantize module search spaces

Layer / File(s) Summary
Public module-space contract
modelopt/recipe/config.py, modelopt/torch/quantization/model_quant.py
Adds validated module-specific formats, allow_no_quant, optional fixed baselines, and API plumbing.
Searcher and calibration execution
modelopt/torch/quantization/algorithms.py, modelopt/torch/quantization/model_quant.py
Resolves runtime groups, applies fixed and searched recipes, isolates calibration, preserves cost denominators, and records checkpoint signatures.
Recipe and HF export wiring
examples/hf_ptq/*, modelopt_recipes/..., examples/hf_ptq/README.md, CHANGELOG.rst
Maps per-module formats and fixed baselines into HF inputs, adds a Qwen recipe, and documents configuration styles.
Validation and replay coverage
tests/examples/hf_ptq/*, tests/unit/recipe/*, tests/unit/torch/quantization/test_autoquant.py
Tests recipe loading, format mapping, fixed-module behavior, runtime-group validation, calibration isolation, cost handling, and checkpoint replay.

Estimated code review effort: 4 (Complex) | ~45 minutes

Sequence Diagram(s)

sequenceDiagram
  participant Recipe
  participant AutoQuantize
  participant Searcher
  participant QuantRecipeHparam
  Recipe->>AutoQuantize: provide module_search_spaces and fixed baseline
  AutoQuantize->>Searcher: submit normalized search configuration
  Searcher->>QuantRecipeHparam: resolve runtime-group choices
  Searcher->>QuantRecipeHparam: set_calibration_recipe(recipe)
  QuantRecipeHparam-->>Searcher: restore_active_quantizers()
  Searcher-->>AutoQuantize: resolve configuration and checkpoint state
Loading

Suggested reviewers: edwardf0t1, realasma, ajrasane

🚥 Pre-merge checks | ✅ 5 | ❌ 1

❌ Failed checks (1 warning)

Check name Status Explanation Resolution
Docstring Coverage ⚠️ Warning Docstring coverage is 44.23% which is insufficient. The required threshold is 80.00%. Write docstrings for the functions missing them to satisfy the coverage threshold.
✅ Passed checks (5 passed)
Check name Status Explanation
Linked Issues check ✅ Passed Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check ✅ Passed Check skipped because no linked issues were found for this pull request.
Security Anti-Patterns ✅ Passed PASS: The commit touches only tests; no changed modelopt/examples Python files contain unsafe load, trust_remote_code, eval/exec, or # nosec patterns.
Description Check ✅ Passed Check skipped - CodeRabbit’s high-level summary is enabled.
Title check ✅ Passed The title clearly summarizes the main change: adding module-specific AutoQuant search spaces.
✨ Finishing Touches
🧪 Generate unit tests (beta)
  • Create PR with unit tests
  • Commit unit tests in branch weimingc/autoquant-module-search-space

Comment @coderabbitai help to get the list of available commands.

@github-actions

github-actions Bot commented Jul 9, 2026

Copy link
Copy Markdown
Contributor
PR Preview Action v1.8.1
Preview removed because the pull request was closed.
2026-07-22 19:12 UTC

@codecov

codecov Bot commented Jul 9, 2026

Copy link
Copy Markdown

Codecov Report

❌ Patch coverage is 96.12676% with 11 lines in your changes missing coverage. Please review.
✅ Project coverage is 77.79%. Comparing base (f10d518) to head (a60306b).
⚠️ Report is 2 commits behind head on main.

Files with missing lines Patch % Lines
modelopt/torch/quantization/algorithms.py 96.58% 7 Missing ⚠️
modelopt/torch/quantization/model_quant.py 92.15% 4 Missing ⚠️
Additional details and impacted files
@@            Coverage Diff             @@
##             main    #1949      +/-   ##
==========================================
+ Coverage   75.76%   77.79%   +2.03%     
==========================================
  Files         518      518              
  Lines       58269    58498     +229     
==========================================
+ Hits        44148    45510    +1362     
+ Misses      14121    12988    -1133     
Flag Coverage Δ
examples 43.31% <66.90%> (-0.12%) ⬇️
gpu 58.92% <61.97%> (+7.96%) ⬆️
regression 15.12% <13.38%> (+0.07%) ⬆️
unit 55.03% <96.12%> (+0.16%) ⬆️

Flags with carried forward coverage won't be shown. Click here to find out more.

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:
  • ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

@meenchen meenchen self-assigned this Jul 9, 2026
@meenchen
meenchen marked this pull request as ready for review July 14, 2026 20:05
@meenchen
meenchen requested review from a team as code owners July 14, 2026 20:05

@cjluo-nv cjluo-nv left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Bot review (gpt-5.6-sol) — DM the bot to share feedback.

The implementation looks cohesive and well tested, and I did not find a concrete correctness regression in the module-specific candidate selection, fixed-group cost accounting, calibration isolation, fused-group validation, or checkpoint signature handling. The added YAML header follows the short SPDX style, but it does not match the complete canonical text in root LICENSE_HEADER, so this GitHub PR still needs human licensing sign-off under the review policy.

Design review: the problem is to let existing AutoQuantize runtime decision groups use family-specific candidate sets, including truly fixed quantized groups, without losing sensitivity baselines or active-MoE accounting. Plausible alternatives are (1) extending the repository's existing NAS SearchSpace/wildcard-rule machinery (modelopt/torch/nas/search_space.py), (2) expressing family overrides through the existing ordered QuantizeConfig.quant_cfg/last-match-wins mechanism plus pre-partitioned AutoQuant runs, or (3) keeping one global AutoQuant search and applying a fixed PTQ config to routed experts before/after it. Already-imported Pydantic/OmegaConf can model the declarative schema, while PuLP remains the existing solver; no dependency offers the AutoQuant-specific grouped scoring directly. The PR correctly extends the existing AutoQuant/Pydantic/PuLP path rather than creating a separate solver, and its Qwen3.6 evaluation provides strong motivation, but the PR body does not explicitly compare or reject the obvious in-repo NAS/wildcard and staged-PTQ alternatives. Because design review was required, please have the owner sign off or add that rationale to the PR body.

@kevalmorabia97
kevalmorabia97 requested review from shengliangxu and removed request for kevalmorabia97 July 14, 2026 20:10

@coderabbitai coderabbitai Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Warning

CodeRabbit couldn't request changes on this pull request because it doesn't have sufficient GitHub permissions.

Please grant CodeRabbit Pull requests: Read and write permission and re-run the review.

👉 Steps to fix this

Actionable comments posted: 3

🤖 Prompt for all review comments with AI agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@modelopt/torch/quantization/algorithms.py`:
- Around line 911-943: Extend the checkpoint compatibility logic around
module_search_space_signature to also record and compare a signature for
config["quantization_formats"] whenever quantizer_states or candidate_stats are
restored. Reject mismatched current formats before reusing checkpoint state, and
explicitly define the behavior for legacy checkpoints that lack the stored
format signature, consistent with the existing module-search-space handling.

In `@modelopt/torch/quantization/model_quant.py`:
- Around line 522-550: Update the public validation in the quantization entry
point before calls to _process_quantization_formats: require global and
per-module quantization_formats inputs to be valid non-empty candidate
collections, rejecting strings, mappings, and empty lists explicitly. Replace
the optimization-removable assert on processed global formats with an explicit
validation error, and apply equivalent validation to each module_search_spaces
entry before normalization.

In `@tests/unit/torch/quantization/test_autoquant.py`:
- Around line 369-370: Move the model_quant import from inside
test_auto_quantize_fixed_module_isolated_from_unrelated_calibration to the
module-level imports at the top of the test file. Remove the function-local
import while preserving the test’s existing module reference and behavior.
🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

  • Push a commit to this branch (recommended)
  • Create a new PR with the fixes

ℹ️ Review info
⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Enterprise

Run ID: 4a55fb6d-15fa-4af8-b9d1-86163a14b061

📥 Commits

Reviewing files that changed from the base of the PR and between 66633d8 and 4a25092.

📒 Files selected for processing (10)
  • CHANGELOG.rst
  • examples/hf_ptq/README.md
  • examples/hf_ptq/hf_ptq.py
  • modelopt/recipe/config.py
  • modelopt/torch/quantization/algorithms.py
  • modelopt/torch/quantization/model_quant.py
  • modelopt_recipes/huggingface/qwen3_6_moe/auto_quantize/w4a16_nvfp4_fp8_module_spaces_at_6p0bits-active_moe.yaml
  • tests/examples/hf_ptq/test_hf_ptq_args.py
  • tests/unit/recipe/test_loader.py
  • tests/unit/torch/quantization/test_autoquant.py

Comment thread modelopt/torch/quantization/algorithms.py
Comment thread modelopt/torch/quantization/model_quant.py Outdated
Comment thread tests/unit/torch/quantization/test_autoquant.py Outdated
@meenchen meenchen changed the title Add module-specific AutoQuant search spaces [OMNIML-5477, OMNIML-5119] Add module-specific AutoQuant search spaces Jul 14, 2026
@meenchen
meenchen requested a review from ajrasane July 14, 2026 22:22

@cjluo-nv cjluo-nv left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Bot review (gpt-5.6-sol) — DM the bot to share feedback.

Re-review: the implementation remains cohesive and well tested, and the three actionable CodeRabbit findings are addressed: the critical checkpoint-integrity issue now validates both global and module-specific format signatures (including legacy behavior), while candidate-collection validation and the test-local import (minor) are fixed with focused tests. I found no new correctness regression.

Design review: the problem is to let AutoQuant runtime decision groups use module-family-specific candidate sets, including fixed quantized groups, while preserving sensitivity baselines and active-MoE cost accounting. Plausible alternatives are the existing NAS SearchSpace wildcard/rule machinery in modelopt/torch/nas/search_space.py, existing ordered QuantizeConfig.quant_cfg last-match-wins overrides plus staged AutoQuant/PTQ, or a global AutoQuant search followed by fixed PTQ for routed experts. The manifest already provides Pydantic/OmegaConf for schema/composition and PuLP for solving; this PR reasonably extends that existing AutoQuant/Pydantic/PuLP path rather than adding another solver. However, the PR body still gives evaluation motivation without explaining why the obvious in-repo NAS/wildcard or staged-PTQ alternatives were rejected, so the required architectural choice needs owner sign-off or rationale added to the PR body.

Licensing also requires human sign-off: the new YAML uses only the two-line SPDX header, which does not match the complete canonical root LICENSE_HEADER. Under the GitHub licensing policy this cannot be auto-approved.

@shengliangxu shengliangxu left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

In general looking good to me.

@meenchen

Copy link
Copy Markdown
Contributor Author

/ok to test 058601e

@juhi10071998

Copy link
Copy Markdown
Contributor

hi @meenchen, thanks for this, will take a detailed look today/ tomo

Comment thread modelopt/torch/quantization/algorithms.py
Comment thread modelopt/torch/quantization/algorithms.py
@juhi10071998

juhi10071998 commented Jul 17, 2026

Copy link
Copy Markdown
Contributor

thanks Wei-Ming! overall the idea looks good to me. This is basically helping in two ways right if you can confirm

  1. we only run calibration on the groups we know will be accounted for in the sensitivity analysis (will help speedup the calibration a bit (maybe) and the sensitivity scoring)

  2. the quantization stats for a given layer and given candidate still assume the previous layer was either not quantized or quantized in the same precision right? even though the final mixed precision recipe could have the layer before the given layer in a different format.
    - this is still better where we are assuming realistic choices for calibration (un-quantized in that format), rather than assuming a format we know will not hold in final state

@meenchen

Copy link
Copy Markdown
Contributor Author

Thanks, @juhi10071998. Two nuances on the behavior:

  1. Calibration is isolated by candidate format: on each format pass, only groups that expose that candidate use it; other groups are switched to their no-quant/BF16 calibration state. This prevents an unrelated algorithm (for example AWQ) from mutating a fixed FP8 group. It can reduce unnecessary quantizer work, although the full model forward still runs once per format in the union, so this PR does not claim a proportional end-to-end calibration speedup.

  2. Sensitivity is still a local, one-decision-at-a-time estimate. Other configurable groups are at no-quant/BF16 while one group/candidate is perturbed; truly fixed one-format groups remain at their fixed format. It therefore does not model interactions among the eventual mixed-format assignments. Parent/group scoring or interaction-aware scoring would be a separate algorithmic extension.

I also added a Design rationale section to the PR body: NAS SearchSpace is not wired to AutoQuant calibration/sensitivity/cost/export, static quant_cfg wildcards cannot express candidate sets in one solve, and staged PTQ would move fixed groups outside the common sensitivity baseline and active-MoE budget.

@meenchen

Copy link
Copy Markdown
Contributor Author

/ok to test 5627f98

# One selectable format makes routed experts fixed W4A16. allow_no_quant
# controls solver choices only; their BF16-equivalent denominator cost and
# active-MoE ratio remain part of effective-bit accounting.
- module_name_patterns:

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

does it mean we don't search and only apply w4a16?

@cjluo-nv cjluo-nv left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The config design LGTM

- $import: w4a16_nvfp4
- $import: fp8
allow_no_quant: true
allow_no_quant: false

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

LGTM, I am in general curious in what cases do we want to have the unquantized bf16 for certain modules. Router is sensitive to quantization so that could be one. Have we observed other bf16 in final recipe before? Asking so if we should have any recommendation for the user generally

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

That depends on the sensitivity of the module and also the candidate formats. In this case, since fp8 is able to maintain accuracy well, we don't need to explore bf16.

@juhi10071998 juhi10071998 left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Thanks Wei-Ming, left a minor comment.
So basically the cost accounting still remains same as before right for every module. We are restricting the search space for the modules and will only use the corresponding cost associated to that candidate for the given module.

@meenchen

Copy link
Copy Markdown
Contributor Author

/ok to test c2bdd81

@meenchen
meenchen enabled auto-merge (squash) July 22, 2026 17:37
meenchen added 11 commits July 22, 2026 11:07
Signed-off-by: weimingc <17592131+meenchen@users.noreply.github.com>
Signed-off-by: weimingc <17592131+meenchen@users.noreply.github.com>
Signed-off-by: weimingc <17592131+meenchen@users.noreply.github.com>
Signed-off-by: weimingc <17592131+meenchen@users.noreply.github.com>
Signed-off-by: weimingc <17592131+meenchen@users.noreply.github.com>
Signed-off-by: weimingc <17592131+meenchen@users.noreply.github.com>
Signed-off-by: weimingc <17592131+meenchen@users.noreply.github.com>
Signed-off-by: weimingc <17592131+meenchen@users.noreply.github.com>
Signed-off-by: weimingc <17592131+meenchen@users.noreply.github.com>
Signed-off-by: weimingc <17592131+meenchen@users.noreply.github.com>
Signed-off-by: weimingc <17592131+meenchen@users.noreply.github.com>
@meenchen
meenchen force-pushed the weimingc/autoquant-module-search-space branch from c2bdd81 to a60306b Compare July 22, 2026 18:09
@meenchen

Copy link
Copy Markdown
Contributor Author

/ok to test a60306b

@meenchen
meenchen merged commit 309f0ea into main Jul 22, 2026
53 checks passed
@meenchen
meenchen deleted the weimingc/autoquant-module-search-space branch July 22, 2026 19:12
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

4 participants