[ONNX][Autocast] Adds nodes_to_exclude regex support to the QDQ-aware convert_to_f16() API (#2241)

### What does this PR do?

Type of change: New feature

Adds `nodes_to_exclude` regex support to the QDQ-aware
`convert_to_f16()` API, matching the node-name exclusion semantics
already supported by `convert_to_mixed_precision()`.

This allows callers to keep selected numerically sensitive subgraphs in
FP32 while converting the rest of a quantized ONNX graph to FP16 or
BF16. Existing `op_block_list` and `tensor_block_dict` behavior remains
unchanged.

The regression test reuses the existing conversion fixture and verifies
that:
- op_block_list continues to preserve matching operations in FP32.
- nodes_to_exclude preserves regex-matching nodes in FP32.
- Non-matching computation is converted to FP16.
- The resulting ONNX model passes full validation.

### Usage

```python
import onnx

from modelopt.onnx.autocast import convert_to_f16

model = onnx.load("model.onnx", load_external_data=True)

converted_model = convert_to_f16(
    model,
    low_precision_type="fp16",
    # Preserve Q/DQ operations using the existing op-type policy.
    op_block_list=["QuantizeLinear", "DequantizeLinear"],
    # Keep the numerically sensitive RMSNorm calculation in FP32.
    nodes_to_exclude=[
        r"^/rms/(Pow|ReduceMean|Add|Sqrt|Div)$",
    ],
)

onnx.save(converted_model, "model_fp16.onnx")

### Testing

```bash
pytest tests/unit/onnx/autocast/test_precisionconverter.py
```

Result: 185 tests passed.
Added focused coverage for combining operation-type and node-name exclusions. The test also includes a non-excluded FP16 conversion control.

### Before your PR is "*Ready for review*"

Make sure you read and follow [Contributor guidelines](https://github.com/NVIDIA/Model-Optimizer/blob/main/CONTRIBUTING.md) and your commits are signed (`git commit -s -S`).

Make sure you read and follow the [Security Best Practices](https://github.com/NVIDIA/Model-Optimizer/blob/main/SECURITY.md#security-coding-practices-for-contributors) (e.g. avoiding hardcoded `trust_remote_code=True`, `torch.load(..., weights_only=False)`, `pickle`, etc.).

- Is this change backward compatible?: ✅ 
- If you copied code from any other sources or added a new PIP dependency, did you follow guidance in `CONTRIBUTING.md`: N/A — no copied code or new dependency.
- Did you write any new necessary tests?: ✅ 
- Did you update [Changelog](https://github.com/NVIDIA/Model-Optimizer/blob/main/CHANGELOG.rst)?: ✅ 
- Did you get Claude approval on this PR?: ❌ — pending /claude review.

### Additional Information
This addresses QDQ-aware mixed-precision conversion of numerically sensitive named subgraphs without requiring callers to expand an entire operation type into op_block_list.
No new runtime or PIP dependencies are introduced.


<!-- This is an auto-generated comment: release notes by coderabbit.ai -->
## Summary by CodeRabbit

* **New Features**
  * Added Muse Glimmer AutoQuantize, Alpamayo QAD, and streaming Kimi-K3 conversion.
  * Added layerwise checkpoint export and ONNX Q/DQ node-name exclusion support.
  * Added temporary quantization contexts and improved CUDA capability handling.

* **Bug Fixes**
  * Fixed NVFP4 calibration and export issues.
  * Ensured excluded nodes and blocked operators remain in FP32 during FP16 conversion.
  * Improved strict ONNX model validation.

* **Documentation**
  * Documented new quantization contexts and CUDA capability behavior.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Signed-off-by: Jai Prajapati <jprajapati@nvidia.com>

Author: jai17

CHANGELOG.rst

@@ -23,6 +23,7 @@ Changelog
 
 *Misc*
 
+- Add ``nodes_to_exclude`` regex support to the Q/DQ-aware ONNX ``convert_to_f16`` API, matching ``convert_to_mixed_precision`` node-name exclusion semantics while composing with the existing operation and tensor block lists.
 - Add ``modelopt.torch.utils.mlflow.MlflowRunLogger`` for recording a script run on an MLflow tracking server: the invocation, the ModelOpt version, the run log (captured by teeing ``stdout``/``stderr``) and any caller-supplied artifacts, with configuration as searchable params. ``mlflow`` is an optional dependency, imported only when tracking is enabled.
 - Add ``--mlflow <tracking-uri>`` to ``examples/hf_ptq/hf_ptq.py`` (MLflow's own ``MLFLOW_TRACKING_URI`` is honoured too). A tracked run records the invocation, the resolved recipe (``$import``\ s expanded), the run log and the quantization summaries, with every command-line argument as a searchable param; failed runs are recorded with their traceback. The experiment defaults to ``$USER/hf_ptq/<checkpoint basename>-<recipe name or --qformat>`` and can be overridden with ``--mlflow_experiment`` / ``--mlflow_run_name``.
 - Add ``--mlflow <tracking-uri>`` to ``examples/vllm_serve/vllm_serve_fakequant.py`` (MLflow's own ``MLFLOW_TRACKING_URI`` is honoured too), so a fake-quant serve records what it quantized and an evaluation of that endpoint can be traced back to a recipe. A tracked run uploads the launcher command, the resolved ``RECIPE_PATH`` (or the merged ``QUANT_CFG``/``KV_QUANT_CFG`` when presets are used), the worker log and the quantizer summary; the experiment defaults to ``$USER/vllm_serve_fakequant/<model basename>-<recipe name or quantization config>`` and can be overridden with ``--mlflow-experiment`` / ``--mlflow-run-name``.

modelopt/onnx/autocast/convert.py

@@ -32,7 +32,11 @@
 import modelopt.onnx.utils as onnx_utils
 from modelopt.onnx.autocast.graphsanitizer import GraphSanitizer
 from modelopt.onnx.autocast.logging_config import logger
-from modelopt.onnx.autocast.nodeclassifier import NodeClassifier, NodeRuleBase
+from modelopt.onnx.autocast.nodeclassifier import (
+    DisabledNodeNameRegexRule,
+    NodeClassifier,
+    NodeRuleBase,
+)
 from modelopt.onnx.autocast.precisionconverter import PrecisionConverter
 from modelopt.onnx.autocast.referencerunner import ReferenceRunner
 from modelopt.onnx.utils import get_min_opset_for_precisions, get_qdq_precisions
@@ -221,6 +225,7 @@ def convert_to_f16(
     trt_plugins: list[str] | None = [],
     use_standalone_type_inference: bool = False,
     opset: int | None = None,
+    nodes_to_exclude: list[str] | None = None,
 ) -> onnx.ModelProto:
     """Convert model to mixed precision, using PrecisionConverter.
 
@@ -240,6 +245,7 @@ def convert_to_f16(
                (22 for bf16, 19 for fp16) and Q/DQ node requirements. The opset may be automatically
                increased if Q/DQ nodes in the model require a higher version (e.g., FP8 requires 19,
                INT4 requires 21, NVFP4 requires 23).
+        nodes_to_exclude: List of regex patterns to match node names that should remain in FP32.
     """
     assert low_precision_type in ["fp16", "bf16"], "low_precision_type must be either fp16 or bf16"
     original_network_io_metadata = _capture_network_io_metadata(model, keep_io_types)
@@ -303,9 +309,15 @@ def convert_to_f16(
         use_standalone_type_inference=use_standalone_type_inference,
         original_network_io_metadata=original_network_io_metadata,
     )
-    high_precision_nodes = [node.name for node in model.graph.node if node.op_type in op_block_list]
+    node_name_rule = DisabledNodeNameRegexRule(nodes_to_exclude or [])
+    high_precision_nodes = [
+        node.name
+        for node in model.graph.node
+        if node.op_type in op_block_list or node_name_rule.check(node)
+    ]
+    high_precision_node_set = set(high_precision_nodes)
     low_precision_nodes = [
-        node.name for node in model.graph.node if node.op_type not in op_block_list
+        node.name for node in model.graph.node if node.name not in high_precision_node_set
     ]
     model_mod = precision_converter.convert(high_precision_nodes, low_precision_nodes)
     return model_mod

tests/unit/onnx/autocast/test_precisionconverter.py

@@ -2220,6 +2220,25 @@ def test_convert_to_f16_restores_public_io_metadata_from_entry_boundary():
     onnx.checker.check_model(converted, full_check=True)
 
 
+def test_convert_to_f16_combines_op_and_node_exclusions(simple_model):
+    model, *_ = simple_model
+    converted = convert_to_f16(
+        model,
+        keep_io_types=False,
+        op_block_list=["MatMul"],
+        nodes_to_exclude=[r"^add$"],
+    )
+
+    value_types = {
+        value.name: value.type.tensor_type.elem_type
+        for value in (*converted.graph.output, *converted.graph.value_info)
+    }
+    assert value_types["gemm_output"] == TensorProto.FLOAT
+    assert value_types["add_output"] == TensorProto.FLOAT
+    assert value_types["Y"] == TensorProto.FLOAT16
+    onnx.checker.check_model(converted, full_check=True)
+
+
 def test_convert_to_f16_refreshes_gathernd_pre_cast_declaration(monkeypatch):
     def discover_test_plugins_without_trt(self):
         self.custom_ops = {