菜单
Primus-Turbo accuracy verification — compare an operator against a higher-precision reference for forward and backward, with the right gate (allclose for bf16/fp16/fp32, SNR for fp8/fp4) and FP8 encoding awareness. Use when validating numerical correctness of a Primus-Turbo operator.
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
基于 SOC 职业分类
Primus-Turbo handoff to the autonomous kernel-optimize loop — collect the prerequisites (kernel path, focused test/bench commands, scoring metric, execution mode, quick-validation harness) a kernel campaign needs and pass them on. Use when pushing a Primus-Turbo kernel toward the hardware limit, not just spot-checking perf.
Develop, debug, and validate Primus-Turbo operators and modules on AMD GPUs. Covers the layered architecture (ops / kernels-dispatcher / Triton / HIP-CK csrc / modules), how to add or change a feature end-to-end, accuracy verification (SNR, tolerances, reference implementations), performance benchmarking, the backend dispatch system, and build/test/bench commands. Use for any Primus-Turbo development task (GEMM, Attention, GroupedGEMM, MoE, quantization, normalization, activation) and for accuracy or performance validation.
AI-driven operator performance optimization framework. Defines the optimization loop, execution environment selection, knowledge routing, and logging conventions to drive agent-autonomous iteration toward hardware limits.
Primus-Turbo feature development workflow — the layered architecture (ops / kernels-dispatcher / Triton / HIP-CK csrc / modules), how to wire a new operator end-to-end, which layer to touch, and which existing file to copy. Use when adding or changing a Primus-Turbo operator or module on AMD GPUs.
Primus-Turbo performance verification — run single-operator and suite benchmarks, read the latency/TFLOPS metrics, source real-model shapes, and derive a combined training-step metric. Use when measuring latency or throughput of a Primus-Turbo operator.
ROCm profiling workflow for AMD GPU kernels using rocprofv3 and rocprof-compute. Use when profiling hot kernels, collecting counters, diagnosing memory-vs-compute-vs-stall bottlenecks, reading Perfetto traces, or validating low-precision AMD kernels.
| name | verify-accuracy |
| description | Primus-Turbo accuracy verification — compare an operator against a higher-precision reference for forward and backward, with the right gate (allclose for bf16/fp16/fp32, SNR for fp8/fp4) and FP8 encoding awareness. Use when validating numerical correctness of a Primus-Turbo operator. |
Prove an operator is numerically correct against a higher-precision PyTorch reference, for both forward and backward. Read the hub ../SKILL.md first.
Copy the structure of an existing test rather than writing one from scratch:
| Your case | Copy from |
|---|---|
| Dense fwd+bwd, parametrized shapes/dtypes/layouts | tests/pytorch/ops/test_gemm.py |
| Low-precision (SNR gate, backend parametrize) | tests/pytorch/ops/test_gemm_fp8.py |
| Determinism (bitwise) | test_gemm.py::test_gemm_deterministic |
| Attention / MoE / grouped | tests/pytorch/ops/test_attention.py, test_moe_permute.py, test_grouped_gemm.py |
Rules those tests follow: seed with torch.manual_seed(42); clone a _ref input with its own requires_grad_() so grads stay independent; normalize sensitive inputs (a = a / a.abs().max()); reset a.grad = None between reuses; pytest.skip unsupported combos instead of failing.
tests/pytorch/ref/)Put ground-truth math here, computed in float()/fp32, then compare the lower-precision Turbo output against it. Existing references to reuse or mirror: gemm_ref.py (incl. grouped_gemm_ref), attention_ref.py (uses torch.nn.functional.scaled_dot_product_attention under sdpa_kernel), moe_ref.py, permuatation_ref.py, quantization_ref.py, deep_ep_ref.py.
get_tolerances(dtype) in tests/pytorch/test_utils.py returns allclose tolerances only: fp32 1e-4, fp16/bf16 1e-2, and intentionally-loose fp8 1e-1 / fp4 0.5. Use it with torch.testing.assert_close for fp32/fp16/bf16. The fp8/fp4 tolerances are too loose to be a real gate — low precision gates on SNR instead (element-wise tolerance is meaningless after quantization).
| Type | Real gate | Threshold | Defined in |
|---|---|---|---|
| FP32 | assert_close(**get_tolerances) | rtol=atol=1e-4 | test_utils.py |
| FP16 / BF16 | assert_close(**get_tolerances) | rtol=atol=1e-2 | test_utils.py |
| FP8 E4M3 | SNR (dB) | ≥ 25 | test/bench constant (e.g. check_gemm_correctness_by_snr, SNR_THRESHOLD) |
| FP8 E5M2 | SNR (dB) | ≥ 20 | same |
| FP4 (E2M1) | SNR (dB) | ≥ 10 | same |
| Determinism | bitwise over N runs | rtol=atol=0 | test body |
The SNR thresholds (25 / 20 / 10) are not returned by get_tolerances; they are hardcoded in the test/bench files. compute_snr(ref, actual) is the primary low-precision gate (arg order is reference-first); relative_error, mean_squared_error, max_abs_error, cosine_similarity, symmetric_similarity_diff are for diagnosis.
Encoding is arch-dependent and chosen in core/low_precision.py: gfx942 → FNUZ, gfx950 → OCP (MXFP8/MXFP4 require gfx950). Build the config with Float8QuantConfig / Float4QuantConfig; gate with check_fp8_support() / check_mxfp8_support() / check_mxfp4_support() before running. Separate conversion errors from scale errors from kernel-math errors — never label a failure only as "fp8".
pytest tests/pytorch/ops/test_gemm_fp8.py -v -k "blockwise and CK" # focused: op + backend
pytest tests/pytorch/ -n 8 # single-GPU suite (1 GPU/worker)
pytest tests/pytorch/ -n 8 --deterministic-only # bitwise-determinism suite
pytest tests/pytorch/ --dist-only # multi-GPU suite
tests/conftest.py pins each xdist worker to one GPU and defines the deterministic / multigpu markers (those suites are skipped in the normal run). Backends are parametrized inside test files, so -k "TRITON" / -k "CK" selects one; force a backend in-test with GlobalBackendManager.set_gemm_backend(...) and reset() in teardown.
For "does AMD match CPU / NVIDIA on this math?" (not pass/fail): benchmark/accuracy/eval_gemm_accuracy.py, eval_sf_accuracy.py (GPU-vs-CPU, write .xlsx). GPU-vs-GPU is a 3-step dump/transfer/compare flow — see benchmark/accuracy/README.md.
- [ ] Reference impl in tests/pytorch/ref/ (fp32 / PyTorch-native)
- [ ] Forward AND backward compared
- [ ] Parametrized over representative shapes, dtypes, layouts, backends
- [ ] Correct gate (allclose for bf16/fp16/fp32, SNR for fp8/fp4)
- [ ] FP8/FP4 encoding (FNUZ vs OCP) and arch support asserted
- [ ] Determinism test if bit-reproducibility is required
- [ ] Focused test green, then `pytest tests/pytorch/ -n 8` green