fix(config): skip winml quantization for EPs that quantize internally

[KayMKM]

Problem

tests/e2e/test_eval_e2e.py does not fail on an AMD Ryzen AI host — it kills the pytest process on its very first test, so none of its 46 cases run:

$ pytest tests/e2e/test_eval_e2e.py::TestEvalPerTask::test_image_classification -m e2e
collected 1 item
tests/e2e/test_eval_e2e.py::TestEvalPerTask::test_image_classification
EXIT=-1073740791          # 0xC0000409, native fail-fast

The same reproduces straight from the CLI, with no test harness involved:

winml eval -m google/vit-base-patch16-224 --task image-classification --streaming --samples 10

[W PartitionPass.cpp] xir::Op{... type = dequantize-linear} is partitioned to CPU as :
    doesn't supported by target [AMD_AIE2P_4x8_CMC_Overlay].
[W PartitionPass.cpp] xir::Op{... type = :IsNaN} is partitioned to CPU as : ...
[F attrs_imp.cpp:38] Check failed: attrs_.count(key) > 0 Attrs doesn't contain attribute data
*** Check failure stack trace: ***

Root cause

_AUTO_PRECISION in config/precision.py is keyed on the device only:

_AUTO_PRECISION: dict[str, str] = {
    "npu": "w8a16",
    "gpu": "fp32",
    "cpu": "fp32",
}

On an AMD host the auto-selected NPU EP is VitisAI, so --precision auto produces a winml w8a16 QDQ graph. VitisAI quantizes to XINT8 inside the EP and is not meant to consume that graph: it partitions the quantize/dequantize and IsNaN nodes back to CPU, then aborts inside xir. The abort is a native fail-fast, so the process dies rather than the build reporting an error.

This policy was already established — but only inside the eval harness. scripts/e2e_eval/run_eval.py carried its own _EPS_SKIP_WINML_QUANT and worked around the problem by passing --no-quant to winml config / winml build (see #1226). The product itself still handed every AMD NPU user a w8a16 graph.

Verification that the unquantized track is the fix, same model and host:

precision	result
w8a16 (the auto default)	xir abort, 0xC0000409
unquantized	accuracy 1.0, results written

Change

• utils/constants.py: add EPS_WITH_INTERNAL_QUANT as the single source of truth for "this EP runs its own quantization pipeline". run_eval.py now consumes it instead of defining its own copy.

• config/precision.py: resolve_precision sets PrecisionPolicy.skip_quantization when the resolved EP matches, and leaves precision at "auto" — winml makes no precision choice here, the EP does. No fake precision value is invented.

• config/build.py: both policy consumers (_apply_device_precision_policy, resolve_quant_compile_config) honor the flag first and apply exactly what --no-quant does (quant = None).

• Warn at WARNING level so the deviation is visible to end users:

  [WARNING winml.modelkit.config.precision] EP 'VitisAIExecutionProvider' quantizes
  internally, so winml is skipping its own quantization stage (equivalent to
  --no-quant) instead of applying the 'w8a16' default for device 'npu'. This EP
  therefore behaves differently from the others: the artifact stays unquantized and
  the accelerator applies its own scheme at load time. Pass --precision explicitly
  to force a winml quantization pass.
  

• tests/e2e/test_eval_e2e.py: drop the 13 per-test require_not_ep("vitisai") guards. They had been added one at a time as individual models hit the abort; test_image_classification was never guarded, so the module took the whole process down on AMD regardless. These tests now run for real.

An explicit --precision is unaffected — only auto is redirected.

EP	--precision auto	change
VitisAI	skip quantization	was w8a16
QNN	w8a16	unchanged
no --ep on a QNN host	w8a16	unchanged
VitisAI + explicit --precision w8a16	w8a16	user override still honored

Verification

On an AMD Ryzen AI NPU host:

• pytest tests/e2e/test_eval_e2e.py -m e2e → 41 passed, 5 skipped, 0 failed (was: process killed on test 1, 0 cases completed). Zero VitisAI-related skips; the 5 remaining are require_ep("qnn") ×3 and require_not_ep("migraphx") ×2.
• pytest tests/unit → 7897 passed, 77 skipped, 3 xfailed.
• winml config -m microsoft/resnet-50 --device npu --ep vitisai → warning shown, generated config has "quant": null.
• ruff check / ruff format --check clean.

Notes for follow-up (not in this PR)

• Switching VitisAI to the float graph makes its vaip-ort-api.cpp emit one E ... Invalid NodeIndex line per graph node, twice (808 lines for a 404-node ViT; 98.6% of the full e2e log). Inference is correct and the tests pass — it is pure log noise from the EP, but it buries real test output. Worth an upstream report to AMD.
• The e2e run still exits non-zero: after 41 passed, 5 skipped is printed, the process hits 0xC0000005 in Microsoft.Windows.AI.MachineLearning.dll teardown. That is winml perf: post-result Windows 0xC0000005 in Microsoft.Windows.AI.MachineLearning.dll teardown #1233, reproduces on Intel CPU EP too, and is unrelated to this change.

[DingmaomaoBJTU]

LGTM — solid fix. Centralizing the internal-quant EP policy into EPS_WITH_INTERNAL_QUANT in constants.py and deducing the effective EP before the auto-precision decision is the right approach. The skip_quantization flag on PrecisionPolicy makes the caller contract explicit. Test coverage is comprehensive (mocked host deduction for AMD vs QNN, build.py integration, e2e skip removal). Minor nit: the _deduce_ep_for_device.cache_clear() calls in test teardown could be wrapped in try/finally to avoid stale cache if an assertion fails mid-test, but the autouse fixture already handles the main path. Approved.