[Frontend][IR][LLVM] Add end-to-end QDQ lowering with roundeven + clamp

[jb2733]

Description

This PR adds end-to-end support for QDQ (Quantize -> Dequantize) lowering in Allo from the PyTorch frontend through IR lowering and LLVM execution.

It lowers torch.quantize_per_tensor(...).dequantize() into explicit fake-quant computation using divide, round-even, zero-point adjustment, clamp, and rescale operations, and verifies numerical agreement with PyTorch.

Problems

Previously, QDQ-style quantization patterns from PyTorch were not fully supported end-to-end. In particular, quantization rounding and clamp behavior were not correctly lowered through the Allo pipeline to LLVM execution.

Proposed Solutions

This PR adds:

• PyTorch frontend handling for torch.quantize_per_tensor and .dequantize()
• explicit QDQ lowering into float-domain fake-quant math
• IR support for roundeven
• correct lowering of clamp behavior through min / max
• backend LLVM pipeline fixes and attribute placement needed for successful lowering
• an end-to-end test validating MLIR generation and numerical agreement with PyTorch

Examples

Input:

• x = torch.quantize_per_tensor(x, scale, zero_point, dtype).dequantize()

Lowered computation:

• x = x / scale
• x = roundeven(x)
• x = x + zero_point
• x = max(x, qmin)
• x = min(x, qmax)
• x = x - zero_point
• x = x * scale

Expected behavior:

• Generated MLIR contains math.roundeven
• Clamp lowering produces arith.maximumf and arith.minimumf
• LLVM execution matches PyTorch numerically within tolerance

Checklist

Please make sure to review and check all of these items:

• PR's title starts with a category (e.g. [Bugfix], [IR], [Builder], etc)
• All changes have test coverage (It would be good to provide ~2 different test cases to test the robustness of your code)
• Pass the formatting check locally
• Code is well-documented

[Copilot]

Pull request overview

Adds end-to-end lowering for PyTorch QDQ (quantize → dequantize) patterns through Allo IR down to LLVM execution, including round-to-even and clamp behavior, with accompanying tests to validate MLIR generation and numeric correctness.

Changes:

• Add PyTorch frontend lowering for torch.quantize_per_tensor(...).dequantize() into explicit fake-quant math (div → roundeven → zp adjust → clamp → rescale).
• Extend IR inference/builder to support roundeven/clampf and ensure tensor min/max lower via linalg generic ops.
• Update backend decomposition/lowering to rewrite math.clampf and adjust LLVM lowering pipeline; add end-to-end tests.

Reviewed changes

Copilot reviewed 7 out of 9 changed files in this pull request and generated 4 comments.

Show a summary per file

File	Description
tests/test_pytorch_qdq_end_to_end.py	New end-to-end tests checking FX graph, MLIR ops (roundeven, maximumf/minimumf), and LLVM vs PyTorch numerics.
tests/test_clampf.py	New clampf MLIR + execution test.
allo/passes.py	Decompose pass now rewrites math.clampf to arith.maximumf + arith.minimumf prior to backend lowering.
allo/ir/infer.py	Type/shape inference support for roundeven and clampf.
allo/ir/builder.py	Lower tensor min/max via library path; add library lowering for roundeven/clampf; update scalar external-call operand handling.
allo/frontend/pytorch.py	PyTorch FX lowering for quantize_per_tensor into fake-quant math; treat dequantize as identity; add scalar resolution helpers.
allo/backend/llvm.py	Adjust LLVM compilation flow/attribute placement and pass pipeline; includes new debug prints.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

This test unnecessarily depends on PyTorch: it importorskip("torch") and imports torch.nn, but never uses torch. That will skip the clampf test in environments without torch even though clampf is independent; please remove the torch-related imports/skip here.

Suggested change

	torch = pytest.importorskip("torch")
	import torch.nn as nn

[Copilot]

In the scalar-math fast path, opcls = {...}.get(fn_name) can be None for an unsupported scalar function name, and the subsequent call will raise a TypeError instead of the intended RuntimeError at the end of this routine. Add an explicit check for opcls is None and raise a clear error before calling it.

Suggested change

	}.get(fn_name)
	}.get(fn_name)
	if opcls is None:
	raise RuntimeError(
	f"Unsupported scalar math function '{fn_name}' in scalar fast path"
	)

[Copilot]

These two consecutive checks use the exact same condition (isinstance(op, func_d.FuncOp) and not op.is_external). Consider merging them into a single if block to avoid redundant condition evaluation and make the control flow clearer.

Suggested change

if isinstance(op, func_d.FuncOp) and not op.is_external:

[Copilot]

Remove the unconditional debug prints of the entire MLIR module ("=== BEFORE/AFTER DECOMPOSE ==="). This will spam stdout during normal execution/tests; gate it behind an explicit verbose/debug flag or use the existing logging infrastructure.