diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 50111f7..6aa2777 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -125,6 +125,16 @@ jobs:
$PY -m pip install -e ".[all]"
$PY -m pip install "pytest>=7,<10" "PyYAML==6.0.3"
+ - name: Install pinned CPU dependencies for Qwen and W3 tests
+ run: |
+ set -euo pipefail
+ # The full test suite collects W3 subgraph and workflow tests.
+ # Install their actual dependencies instead of skipping those tests.
+ $PY -m pip install "torch==2.7.1" --index-url https://download.pytorch.org/whl/cpu
+ $PY -m pip install -r requirements/qwen3-small-probe.txt "PyYAML==6.0.3"
+ $PY -m pip check
+ $PY -c "import torch, yaml, safetensors; assert torch.__version__ == '2.7.1+cpu' and torch.version.cuda is None, torch.__version__"
+
# Unconditional: a docs-only change never selects the deployment scope, so
# this check cannot live behind a path filter.
- name: Check public instructions and Bash syntax
@@ -192,6 +202,9 @@ jobs:
env:
PYTHONHASHSEED: "0"
SCRATCHV_REQUIRE_RISCV_EXECUTION: "1"
+ OMP_NUM_THREADS: "1"
+ OPENBLAS_NUM_THREADS: "1"
+ MKL_NUM_THREADS: "1"
run: |
mkdir -p benchmark_reports
$PY -m pytest tests/ -v --tb=short \
diff --git a/.github/workflows/llm-deploy.yml b/.github/workflows/llm-deploy.yml
index 22a0227..8c86a43 100644
--- a/.github/workflows/llm-deploy.yml
+++ b/.github/workflows/llm-deploy.yml
@@ -15,9 +15,8 @@ name: LLM Deploy v1.0
# numeric:ir-qwen3-small frontend:parse-qwen3
# unit:frontend-ops unit:backend-ops unit:runtime integration:runtime-model
#
-# Later weeks' gates (numeric:ir-full-qwen3 at W3, numeric:qemu-full-qwen3 at
-# W4, e2e:qemu-paris at W5, release:gate at W8) are NOT stubbed here. They get
-# added when their week arrives, from the plan's §4.3 table.
+# Explicit manual runs can also call the delivered W3 workflows from the same
+# commit. The default W1/W2 checks do not imply full-model IR acceptance.
on:
workflow_call:
@@ -25,6 +24,12 @@ on:
# Nightly, off the hour: 19:23 UTC = 03:23 北京时间.
- cron: '23 19 * * *'
workflow_dispatch:
+ inputs:
+ run_w3_validation:
+ description: Also run complete W3 preparation and seven-case IR validation
+ type: boolean
+ required: false
+ default: false
permissions:
contents: read
@@ -39,6 +44,11 @@ env:
QWEN3_PY: output/qwen3-probe-venv/bin/python
jobs:
+ w3-validation:
+ name: "W3 / explicit full validation"
+ if: ${{ github.event_name == 'workflow_dispatch' && inputs.run_w3_validation }}
+ uses: ./.github/workflows/w3-nightly.yml
+
llm-deploy:
name: "LLM Deploy v1.0 / W1 + W2"
runs-on: ubuntu-24.04
@@ -85,6 +95,9 @@ jobs:
id: docs
run: python3 scripts/check_llm_deploy_docs.py --week W1
+ - name: "docs:linux-reproduction"
+ run: python3 scripts/check_linux_repro_docs.py --check-bash
+
# ── probe:qemu-matmul ─────────────────────────────────────────────
- name: "probe:qemu-matmul"
id: matmul
@@ -534,3 +547,33 @@ jobs:
env:
W2_JOB_RESULTS: ${{ toJSON(needs) }}
run: python3 scripts/check_w2_ci_results.py
+
+ w3-execution-summary:
+ name: "W3 / execution scope"
+ needs: [w3-validation]
+ if: always()
+ runs-on: ubuntu-24.04
+ timeout-minutes: 5
+ steps:
+ - name: State whether W3 actually ran
+ env:
+ W3_RESULT: ${{ needs.w3-validation.result }}
+ run: |
+ python3 - <<'PY'
+ import os
+ result = os.environ.get("W3_RESULT", "")
+ labels = {"success": "PASS", "failure": "FAIL", "cancelled": "CANCELLED", "skipped": "NOT RUN"}
+ label = labels.get(result, "UNCONFIRMED")
+ with open(os.environ["GITHUB_STEP_SUMMARY"], "a", encoding="utf-8") as stream:
+ stream.write("## W3 execution scope\n\n")
+ stream.write(f"**{label}** — W3 preparation and full 28-layer IR numeric.\n\n")
+ if result == "skipped":
+ stream.write("W3 is opt-in and is not executed by default on pull requests. W1/W2 success is not W3 acceptance.\n\n")
+ elif result == "success":
+ stream.write("See the W3 preparation and W3 complete IR numeric summaries in this run for numerical data.\n\n")
+ else:
+ stream.write("No W3 acceptance claimed; inspect the called jobs and any partial evidence.\n\n")
+ stream.write("Scope and evidence
\n\nManual LLM Deploy runs can enable `run_w3_validation`. "
+ "Numerical reports are retained in `w3-preparation-reports` and `w3-full-numeric-reports` when generated. "
+ "Full-model QEMU is a separate W4 gate; independent reproduction and team sign-off remain separate.\n\n' + escape(title) + '
Result: ' + escape(status) +
+ '
' + summary_html + index_html)
+ atomic_text(out / "report.md", markdown)
+ atomic_text(out / "report.html", html)
+ atomic_text(out / "report.json", payload)
+ except Exception as exc:
+ report["passed"] = False
+ report["status"] = "FAIL"
+ report.setdefault("report_errors", []).append(f"{type(exc).__name__}: {exc}")
+ # A human may open a view directly; remove already-written PASS views
+ # as well as JSON when any required report fails to publish.
+ for filename in ("report.md", "report.html", "report.json"):
+ try:
+ (out / filename).unlink(missing_ok=True)
+ except OSError as cleanup_error:
+ report["report_errors"].append(f"cleanup {filename}: {cleanup_error}")
+ target = out / "report.json"
+ try:
+ target.unlink(missing_ok=True)
+ atomic_text(target, json.dumps(report, ensure_ascii=False, indent=2, allow_nan=False) + "\n")
+ except Exception:
+ pass
+ raise
diff --git a/probes/w3_full_preflight/README.md b/probes/w3_full_preflight/README.md
new file mode 100644
index 0000000..02661f8
--- /dev/null
+++ b/probes/w3_full_preflight/README.md
@@ -0,0 +1,15 @@
+# W3 完整资产与静态尺寸预检
+
+复现统一采用 **Ubuntu 24.04 x86_64、Bash、Python 3.12**。先完成 [Linux 环境与资产准备](../../docs/llm-deploy-v1.0/LINUX_REPRODUCTION.md)，再在同一个 Bash 会话、仓库根目录执行命令；该指南设置 `SCRATCHV_PYTHON`、`SCRATCHV_CC` 和 `SCRATCHV_QEMU`。
+
+~~~bash
+set -euo pipefail
+W3_MODEL=/absolute/path/to/qwen3-0.6b-onnx
+"$SCRATCHV_PYTHON" -B -X utf8 probes/w3_full_preflight/run.py --model-dir "$W3_MODEL" --output-dir output/w3-full-preflight-new
+~~~
+
+离线流式校验 W1 固定 manifest 的模型和三个 external-data 文件，复用 ONNX 静态契约/范围检查，统计 initializer、嵌入/外部 tensor、具名 value 与输出的逻辑字节。不加载外部数组进行 IR 运算，也不执行完整 ORT。
+
+报告始终标记 full_ir_executed=false、w3_exit_accepted=false。PASS 只代表准备检查通过；sum_named_value_logical_bytes 包含别名、可能重复，不能作为所需物理内存上限或峰值承诺。process_peak_rss_bytes 只属于这个 metadata-only 预检进程。
+
+完整数值验收仍需 W1 人工前置确认、中等与真实子图基线、完整 IR/ORT <1e-4、三人复现和 Nightly。参见 [W3 准备说明](../../docs/llm-deploy-v1.0/W3/README.md)。
diff --git a/probes/w3_full_preflight/run.py b/probes/w3_full_preflight/run.py
new file mode 100644
index 0000000..8943d32
--- /dev/null
+++ b/probes/w3_full_preflight/run.py
@@ -0,0 +1,101 @@
+"""Verify fixed full-model assets and size accounting without executing full IR."""
+from __future__ import annotations
+import argparse
+from collections import Counter
+import math
+from pathlib import Path
+import sys
+import time
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+ sys.path.insert(0, str(ROOT))
+import numpy as np
+import onnx
+from probes.w1_qwen3_export.run import MANIFEST, verify_files, inspect_model, tensors
+from probes.w3_common import new_output_dir, source_evidence, write_reports, process_peak_rss_bytes
+
+def tensor_size(tensor):
+ return math.prod(tensor.dims) * np.dtype(onnx.helper.tensor_dtype_to_np_dtype(tensor.data_type)).itemsize
+
+def value_size(value):
+ kind = value.type.tensor_type
+ if not kind.HasField("shape"):
+ return None
+ dimensions = []
+ for dim in kind.shape.dim:
+ if not dim.HasField("dim_value"):
+ return None
+ dimensions.append(dim.dim_value)
+ return math.prod(dimensions) * np.dtype(onnx.helper.tensor_dtype_to_np_dtype(kind.elem_type)).itemsize
+
+def size_accounting(model):
+ names = {}
+ unknown = []
+ for value in (*model.graph.input, *model.graph.value_info, *model.graph.output):
+ count = value_size(value)
+ if count is None:
+ unknown.append(value.name)
+ else:
+ if value.name in names and names[value.name] != count:
+ raise ValueError(f"Conflicting shape information: {value.name}")
+ names[value.name] = count
+ initializer_bytes = sum(tensor_size(t) for t in model.graph.initializer)
+ all_tensor_bytes = sum(tensor_size(t) for t in tensors(model))
+ graph_names = {v.name for v in model.graph.input} | {t.name for t in model.graph.initializer}
+ graph_names.update(name for node in model.graph.node for name in node.output if name)
+ known = set(names) | {t.name for t in model.graph.initializer}
+ return {
+ "initializer_logical_bytes": initializer_bytes,
+ "all_embedded_and_external_tensor_logical_bytes": all_tensor_bytes,
+ "sum_named_value_logical_bytes": sum(names.values()),
+ "named_values_with_static_size": len(names), "unknown_size_values": unknown,
+ "graph_value_count": len(graph_names),
+ "values_without_persisted_static_size": sorted(graph_names - known),
+ "output_logical_bytes": {v.name:value_size(v) for v in model.graph.output},
+ "largest_named_values": sorted(names.items(), key=lambda x:(-x[1],x[0]))[:10],
+ "scope": "Static ONNX logical sizes, including aliases. Not measured IR live storage or a process RAM requirement.",
+ }
+
+def main(argv=None):
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument("--model-dir", type=Path, required=True)
+ parser.add_argument("--output-dir", type=Path, required=True)
+ args = parser.parse_args(argv)
+ out = new_output_dir(args.output_dir)
+ report = {
+ "gate":"preflight:w3-full-assets", "status":"FAIL", "passed":False, "stage":"source_evidence",
+ "full_ir_executed":False, "w3_exit_accepted":False,
+ "scope":"Asset integrity and static size preparation only; no ORT/IR/full-model numerical acceptance.",
+ "required_before_full_acceptance":[
+ "W1 human acceptance and interface/risk decisions",
+ "Medium and pretrained subgraph numeric/memory baselines",
+ "Measured host capacity and bounded full IR/ORT runner",
+ "Full IR vs ORT <1e-4, three independent reproductions and successful Nightly",
+ ],
+ }
+ start = time.perf_counter()
+ try:
+ report.update(source_evidence())
+ report["stage"] = "asset_hashes"
+ files = verify_files(args.model_dir)
+ report["files"] = files
+ report["source_revision"] = MANIFEST["revision"]
+ report["stage"] = "onnx_contract"
+ report["onnx_contract"] = inspect_model(args.model_dir, files)
+ report["stage"] = "static_size_accounting"
+ model = onnx.load(str(args.model_dir / "model.onnx"), load_external_data=False)
+ report["node_count"] = len(model.graph.node)
+ report["operator_counts"] = dict(Counter(node.op_type for node in model.graph.node))
+ report["sizes"] = size_accounting(model)
+ report["weights_file_bytes"] = sum(item["bytes"] for item in files if item["name"] != "model.onnx")
+ report.update(passed=True, status="PASS", stage="complete")
+ except Exception as exc:
+ report["error"] = f"{type(exc).__name__}: {exc}"
+ report.update(elapsed_seconds=time.perf_counter()-start,
+ process_peak_rss_bytes=process_peak_rss_bytes(),
+ peak_scope="This metadata-only preflight process, not full parser/IR execution")
+ write_reports(out,report)
+ return 0 if report["passed"] else 1
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/probes/w3_layer_diff/README.md b/probes/w3_layer_diff/README.md
new file mode 100644
index 0000000..94c18dd
--- /dev/null
+++ b/probes/w3_layer_diff/README.md
@@ -0,0 +1,65 @@
+# W3 offline checkpoint comparison
+
+Reproduction targets **Ubuntu 24.04 x86_64, Bash and Python 3.12**. Complete the [Linux environment and asset setup](../../docs/llm-deploy-v1.0/LINUX_REPRODUCTION.md) first. Run commands from the repository root in the same Bash session; the setup exports `SCRATCHV_PYTHON`, `SCRATCHV_CC` and `SCRATCHV_QEMU`.
+
+This tool compares recorded NPZ tensors without executing a model. It reuses
+`probes.w2_qwen3_small.diagnostics.compare_outputs`: exact shape and dtype,
+finite numeric values, and strict `max_abs < atol` (default `1e-5`).
+
+```bash
+set -euo pipefail
+"$SCRATCHV_PYTHON" probes/w3_layer_diff/run.py --actual output/w3/medium/traces/full_seed_0/ir_diagnostic_none.npz --reference output/w3/medium/traces/full_seed_0/reference.npz --schema output/w3/medium/trace_schema.json --out output/w3/layerdiff-full
+```
+
+`--out` must be new. The shared W3 publisher writes `report.json`, `report.md`
+and `report.html` atomically per file, with JSON last. Publication errors fail
+the command. No network, pickle loading or model execution is involved.
+
+The schema is UTF-8 JSON with an explicit ordered checkpoint list:
+
+```json
+{"version":1,"checkpoints":[{"name":"layer_0.hidden","shape":[1,256,128],"dtype":"float32","layer":0,"checkpoint":"hidden","sequence_axis":1}]}
+```
+
+Only `name`, `shape`, and `dtype` are mandatory in each entry. `layer` is a
+nonnegative integer; `checkpoint` is a local selector name; `sequence_axis` is
+an optional valid axis or null. `--reference-schema` can provide a second schema
+which must match exactly, including checkpoint order and metadata. Every NPZ
+must have exactly the schema names, no missing/extra arrays or duplicate ZIP
+members. Duplicate JSON keys/checkpoint names, object arrays, shape/type
+disagreements and nonfinite values fail before comparison. ZIP expanded size
+and schema logical size are limited by `--max-bytes` (default 2 GiB per NPZ);
+schema size is limited to 8 MiB. NPY v1/v2 headers and payload sizes are checked
+against the schema before NumPy allocates an array. This is validation of local evidence, not a
+claim to safely process arbitrary hostile archives.
+
+Repeat `--layer N` or `--checkpoint NAME` to select checkpoints. A checkpoint
+selector matches an exact name or the optional local `checkpoint` field.
+Layer and checkpoint filters intersect; unknown, duplicate and empty selections
+fail. All evidence names, shapes, dtypes and finite values are still validated.
+Every explicitly selected comparison reports **PARTIAL**, even when the
+selection happens to cover every checkpoint; it cannot produce a full PASS.
+
+Exit codes: `0` = all recorded checkpoints compared and passed; `1` = numeric
+difference, invalid evidence or report publication failure; `2` = selected
+checkpoints passed with partial coverage. Reports include ordered per-checkpoint
+errors, the first divergence, the worst absolute-error element, source evidence
+and artifact SHA-256 hashes. A full checkpoint PASS establishes no claim about
+whole-model correctness, causal/padding tests or backend acceptance.
+
+## IR memory observations
+
+`IRInterpreter.run(..., collect_memory_stats=True)` populates
+`ExecutionResult.memory_stats`; it is `None` by default. The optional observation
+records input/initializer logical bytes, peak retained logical bytes, peak
+deduplicated NumPy backing storage, and retained value counts. Inputs retain
+their existing copy semantics; initializers count referenced bound globals
+(including scalar global constants). Views count in logical bytes but share one
+storage owner. ALLOCA buffers are counted. Final return copies are included in
+peaks and separately reported, but excluded from retained counts.
+
+These are instruction-boundary snapshots of values retained by the interpreter,
+not RSS or total process allocation. They exclude caller arrays, transient
+NumPy kernel buffers, Python object sizes and allocator overhead. The observer
+does not release values, change kernels, alter control flow or add tensor copies.
+Use the separate W3 process RSS metric for process-level memory evidence.
diff --git a/probes/w3_layer_diff/__init__.py b/probes/w3_layer_diff/__init__.py
new file mode 100644
index 0000000..be43338
--- /dev/null
+++ b/probes/w3_layer_diff/__init__.py
@@ -0,0 +1 @@
+"""Offline W3 checkpoint evidence comparison."""
diff --git a/probes/w3_layer_diff/run.py b/probes/w3_layer_diff/run.py
new file mode 100644
index 0000000..7be1e81
--- /dev/null
+++ b/probes/w3_layer_diff/run.py
@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""Compare recorded checkpoint arrays without executing a model or loading pickle."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+from pathlib import Path
+import sys
+import zipfile
+
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+ sys.path.insert(0, str(ROOT))
+
+from probes.w2_qwen3_small.diagnostics import compare_outputs, tensor_diff
+from probes.w3_common import source_evidence, write_reports
+
+DEFAULT_MAX_BYTES = 2 * 1024**3
+
+
+class EvidenceError(ValueError):
+ def __init__(self, message, checkpoint=None, details=None):
+ super().__init__(message)
+ self.checkpoint = checkpoint
+ self.details = details
+
+
+def _unique_object(pairs):
+ result = {}
+ for key, value in pairs:
+ if key in result:
+ raise EvidenceError(f"duplicate JSON key: {key}")
+ result[key] = value
+ return result
+
+
+def _integer(value):
+ return isinstance(value, int) and not isinstance(value, bool)
+
+
+def load_schema(path: Path) -> list[dict]:
+ if path.stat().st_size > 8 * 1024**2:
+ raise EvidenceError("schema exceeds 8 MiB limit")
+ document = json.loads(path.read_text(encoding="utf-8"), object_pairs_hook=_unique_object,
+ parse_constant=lambda value: (_ for _ in ()).throw(
+ EvidenceError(f"nonfinite JSON constant: {value}")))
+ if (not isinstance(document, dict) or not _integer(document.get("version"))
+ or document["version"] != 1):
+ raise EvidenceError("schema must be an object with version=1")
+ entries = document.get("checkpoints")
+ if not isinstance(entries, list) or not entries:
+ raise EvidenceError("schema checkpoints must be a nonempty ordered list")
+ seen = set()
+ for entry in entries:
+ if not isinstance(entry, dict) or not {"name", "shape", "dtype"} <= set(entry):
+ raise EvidenceError("each checkpoint requires name, shape and dtype")
+ name = entry["name"]
+ if not isinstance(name, str) or not name or name in seen:
+ raise EvidenceError(f"empty, invalid or duplicate checkpoint name: {name!r}")
+ seen.add(name)
+ shape = entry["shape"]
+ if (not isinstance(shape, list)
+ or any(not _integer(dim) or dim < 0 for dim in shape)):
+ raise EvidenceError("shape must contain nonnegative integer dimensions", name)
+ try:
+ if not isinstance(entry["dtype"], str):
+ raise TypeError("dtype must be a string")
+ dtype = np.dtype(entry["dtype"])
+ except (TypeError, ValueError) as exc:
+ raise EvidenceError(f"invalid dtype: {entry['dtype']!r}", name) from exc
+ if dtype.kind not in "biuf" or dtype.hasobject:
+ raise EvidenceError("dtype must be real numeric or boolean, without objects", name)
+ if "layer" in entry and (not _integer(entry["layer"]) or entry["layer"] < 0):
+ raise EvidenceError("layer must be a nonnegative integer", name)
+ if "checkpoint" in entry and (not isinstance(entry["checkpoint"], str)
+ or not entry["checkpoint"]):
+ raise EvidenceError("checkpoint must be a nonempty string", name)
+ axis = entry.get("sequence_axis")
+ if axis is not None and (not _integer(axis) or not -len(shape) <= axis < len(shape)):
+ raise EvidenceError("sequence_axis is outside checkpoint rank", name)
+ return entries
+
+
+def load_arrays(path: Path, entries: list[dict], max_bytes=DEFAULT_MAX_BYTES) -> dict:
+ """Preflight ZIP membership/size, then load numeric NPY arrays with no pickle."""
+ if not _integer(max_bytes) or max_bytes < 1:
+ raise EvidenceError("max_bytes must be a positive integer")
+ names = [entry["name"] for entry in entries]
+ by_name = {entry["name"]: entry for entry in entries}
+ with zipfile.ZipFile(path) as archive:
+ members = archive.infolist()
+ raw_names = [member.filename for member in members]
+ if len(set(raw_names)) != len(raw_names):
+ raise EvidenceError("NPZ contains duplicate ZIP members")
+ if any(not name.endswith(".npy") or name == ".npy" for name in raw_names):
+ raise EvidenceError("NPZ must contain only named .npy array members")
+ keys = [name[:-4] for name in raw_names]
+ # NpzFile accepts both member paths and names without the .npy suffix;
+ # keys such as x and x.npy would otherwise resolve to the same member.
+ if set(keys) & set(raw_names):
+ raise EvidenceError("NPZ contains ambiguous checkpoint/member name aliases")
+ if len(set(keys)) != len(keys) or set(keys) != set(names):
+ missing, extra = sorted(set(names) - set(keys)), sorted(set(keys) - set(names))
+ first = next((name for name in names if name not in keys), None)
+ raise EvidenceError(f"NPZ names must exactly match schema; missing={missing}, extra={extra}", first)
+ if sum(member.file_size for member in members) > max_bytes:
+ raise EvidenceError("NPZ expanded data exceeds max_bytes")
+ if sum(math.prod(entry["shape"]) * np.dtype(entry["dtype"]).itemsize
+ for entry in entries) > max_bytes:
+ raise EvidenceError("schema logical data exceeds max_bytes")
+ # Inspect headers before NumPy can allocate arrays. A tiny forged member
+ # claiming a huge shape must not bypass the expanded ZIP size limit.
+ for member in members:
+ name = member.filename[:-4]
+ entry = by_name[name]
+ with archive.open(member) as stream:
+ version = np.lib.format.read_magic(stream)
+ if version == (1, 0):
+ shape, _, dtype = np.lib.format.read_array_header_1_0(stream, max_header_size=10000)
+ elif version == (2, 0):
+ shape, _, dtype = np.lib.format.read_array_header_2_0(stream, max_header_size=10000)
+ else:
+ raise EvidenceError(f"unsupported NPY version: {version}", name)
+ if list(shape) != entry["shape"] or dtype != np.dtype(entry["dtype"]):
+ raise EvidenceError(f"{name}: NPY header shape/dtype disagrees with schema", name)
+ if dtype.hasobject or dtype.kind not in "biuf":
+ raise EvidenceError(f"{name}: NPY dtype is not safe numeric data", name)
+ payload_bytes = math.prod(shape) * dtype.itemsize
+ if stream.tell() + payload_bytes != member.file_size:
+ raise EvidenceError(f"{name}: NPY payload size disagrees with header", name)
+ result = {}
+ with np.load(path, allow_pickle=False, max_header_size=10000) as archive:
+ for entry in entries:
+ name = entry["name"]
+ try:
+ array = archive[name]
+ except (ValueError, TypeError, EOFError) as exc:
+ raise EvidenceError(f"cannot safely load checkpoint {name}: {exc}", name) from exc
+ if list(array.shape) != entry["shape"]:
+ raise EvidenceError(f"{name}: array shape {list(array.shape)} disagrees with schema {entry['shape']}", name)
+ if array.dtype != np.dtype(entry["dtype"]):
+ raise EvidenceError(f"{name}: array dtype {array.dtype} disagrees with schema {entry['dtype']}", name)
+ if array.dtype.kind not in "biuf" or not np.isfinite(array).all():
+ diagnostic = tensor_diff(array, array)
+ raise EvidenceError(f"{name}: nonfinite or unsupported array", name,
+ dict(name=name, evidence_path=str(path.resolve()),
+ worst_index=diagnostic["worst_index"],
+ value=diagnostic["actual_value"],
+ reason=diagnostic["reason"]))
+ result[name] = array
+ return result
+
+
+def select_names(entries: list[dict], layers=(), checkpoints=()) -> list[str]:
+ if len(set(layers)) != len(layers) or len(set(checkpoints)) != len(checkpoints):
+ raise EvidenceError("duplicate layer/checkpoint selections are not allowed")
+ known_layers = {entry["layer"] for entry in entries if "layer" in entry}
+ if any(not _integer(layer) or layer < 0 or layer not in known_layers for layer in layers):
+ raise EvidenceError(f"layer selection is outside schema layers {sorted(known_layers)}")
+ known_checkpoints = {entry["name"] for entry in entries}
+ known_checkpoints.update(entry["checkpoint"] for entry in entries if "checkpoint" in entry)
+ if set(checkpoints) - known_checkpoints:
+ raise EvidenceError(f"unknown checkpoint selections: {sorted(set(checkpoints) - known_checkpoints)}")
+ names = [entry["name"] for entry in entries
+ if (not layers or entry.get("layer") in layers)
+ and (not checkpoints or entry["name"] in checkpoints
+ or entry.get("checkpoint") in checkpoints)]
+ if not names:
+ raise EvidenceError("layer/checkpoint selection has an empty intersection")
+ return names
+
+
+def compare_evidence(actual_path, reference_path, schema_path, *, reference_schema_path=None,
+ layers=(), checkpoints=(), atol=1e-5, max_bytes=DEFAULT_MAX_BYTES):
+ # tensor_diff owns the W2 finite positive tolerance contract, even for bad inputs.
+ tensor_diff(np.array([], dtype="float32"), np.array([], dtype="float32"), atol)
+ entries = load_schema(Path(schema_path))
+ reference_entries = load_schema(Path(reference_schema_path)) if reference_schema_path else entries
+ if entries != reference_entries:
+ raise EvidenceError("actual/reference schemas must match exactly in checkpoint order and metadata")
+ names = select_names(entries, layers, checkpoints)
+ # Always validate every member, including unselected evidence, before comparison.
+ actual = load_arrays(Path(actual_path), entries, max_bytes)
+ expected = load_arrays(Path(reference_path), reference_entries, max_bytes)
+ comparison = compare_outputs({name: actual[name] for name in names},
+ {name: expected[name] for name in names}, names, atol=atol)
+ partial = bool(layers or checkpoints)
+ passing = comparison["passed"]
+ worst = max(comparison["checkpoints"],
+ key=lambda row: (math.inf if row["reason"] == "absolute error overflow"
+ else row["max_abs"] if row["max_abs"] is not None else -1),
+ default=None)
+ return dict(gate="w3_layer_diff", status="FAIL" if not passing else ("PARTIAL" if partial else "PASS"),
+ passed=passing and not partial, selected_passed=passing, partial=partial,
+ coverage=dict(total_checkpoints=len(entries), compared_checkpoints=len(names),
+ complete=not partial, selected_names=names,
+ evidence_validated_checkpoints=len(entries)),
+ atol=float(atol), first_divergence=comparison["first_divergence"],
+ worst_element=worst, checkpoints=comparison["checkpoints"],
+ claim="Comparison covers recorded checkpoints only; no whole-model or backend acceptance is implied.")
+
+
+def _file_evidence(path):
+ path = Path(path)
+ digest = hashlib.sha256()
+ with path.open("rb") as stream:
+ for chunk in iter(lambda: stream.read(1024**2), b""):
+ digest.update(chunk)
+ return dict(path=str(path.resolve()), size_bytes=path.stat().st_size, sha256=digest.hexdigest())
+
+
+def main(argv=None) -> int:
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument("--actual", required=True, type=Path)
+ parser.add_argument("--reference", required=True, type=Path)
+ parser.add_argument("--schema", required=True, type=Path)
+ parser.add_argument("--reference-schema", type=Path)
+ parser.add_argument("--out", required=True, type=Path)
+ parser.add_argument("--layer", type=int, action="append", default=[])
+ parser.add_argument("--checkpoint", action="append", default=[])
+ parser.add_argument("--atol", type=float, default=1e-5)
+ parser.add_argument("--max-bytes", type=int, default=DEFAULT_MAX_BYTES)
+ args = parser.parse_args(argv)
+ report = dict(gate="w3_layer_diff", status="FAIL", passed=False)
+ try:
+ # Existing evidence is never overwritten, including on report errors.
+ args.out.mkdir(parents=True, exist_ok=False)
+ except OSError as exc:
+ print(f"FAIL: cannot create fresh output directory: {exc}", file=sys.stderr)
+ return 1
+ try:
+ report.update(source_evidence())
+ report["artifacts"] = {name: _file_evidence(path) for name, path in
+ (("actual", args.actual), ("reference", args.reference),
+ ("schema", args.schema), ("reference_schema", args.reference_schema))
+ if path is not None}
+ report.update(compare_evidence(args.actual, args.reference, args.schema,
+ reference_schema_path=args.reference_schema,
+ layers=args.layer, checkpoints=args.checkpoint,
+ atol=args.atol, max_bytes=args.max_bytes))
+ except Exception as exc:
+ report.update(status="FAIL", passed=False, error=f"{type(exc).__name__}: {exc}",
+ first_divergence=getattr(exc, "checkpoint", None),
+ worst_element=getattr(exc, "details", None))
+ try:
+ write_reports(args.out, report)
+ except Exception as exc:
+ print(f"FAIL: report publication failed: {type(exc).__name__}: {exc}", file=sys.stderr)
+ return 1
+ print(f"{report['status']}: {args.out / 'report.json'}")
+ return 0 if report["passed"] else (2 if report["status"] == "PARTIAL" else 1)
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/probes/w3_qwen3_full/EVIDENCE.md b/probes/w3_qwen3_full/EVIDENCE.md
new file mode 100644
index 0000000..83e78aa
--- /dev/null
+++ b/probes/w3_qwen3_full/EVIDENCE.md
@@ -0,0 +1,58 @@
+# 完整 W3 结果的离线复核
+
+复现统一采用 **Ubuntu 24.04 x86_64、Bash、Python 3.12**。先完成 [Linux 环境与资产准备](../../docs/llm-deploy-v1.0/LINUX_REPRODUCTION.md)，再在同一个 Bash 会话、仓库根目录执行命令；该指南设置 `SCRATCHV_PYTHON`、`SCRATCHV_CC` 和 `SCRATCHV_QEMU`。
+
+`scripts/verify_w3_evidence.py` 对**已有七案例原始产物**重新计算误差，不执行模型、不下载资产。
+它复用完整模型 runner 的 `validate_worker`、`compare_case`、`invariants`，以及安全 NPZ 读取器。
+
+在仓库根目录，使用已有 Python 3.12 和项目锁定依赖运行：
+
+```bash
+set -euo pipefail
+"$SCRATCHV_PYTHON" -B scripts/verify_w3_evidence.py \
+ --evidence-dir output/downloaded-w3-run/raw/w3-full \
+ --output-dir output/w3-evidence-audit-01
+```
+
+输出目录必须不存在；不会覆盖被审核的原报告。
+输出为 `report.json`、`report.md`、`report.html`，退出码 `0` 表示复核通过，`1` 表示证据无效或不足。
+非法参数、已有输出目录等启动错误同样返回非零。
+
+## 所需内容与检查
+
+需要 full runner 的完整输出目录：顶层报告，以及每个案例的 `inputs.npz`、两个后端的报告、
+普通/诊断 `logits.npy`、`diagnostic_logits.npy`、`checkpoints.npz` 和 `checkpoint_schema.json`。
+仅下载 reports artifact 不足以复核，必须同时保留 raw artifact 并保持目录结构。CI raw artifact 内含 `w3-full/` 前缀：指定 `gh run download ... -n w3-full-numeric-raw --dir output/downloaded-w3-run/raw` 后，证据根是 `output/downloaded-w3-run/raw/w3-full`。完整下载和报告 SHA256 获取方法见 [Linux CI 产物说明](../../docs/llm-deploy-v1.0/W3/Linux-CI与Nightly.md#产物与失败定位)。
+
+- 七组案例完整、顺序固定，输入 dtype/shape/有限值以及每个数值均符合确定性输入生成规则。
+- 模型文件描述符与固定 manifest 一致。可选 `--model-dir PATH` 进一步核对本地模型文件哈希，仍不执行模型。
+- worker 报告哈希、产物大小/哈希、checkpoint schema、执行步数、耗时和 ORT 配置符合 runner 的验证规则。
+- 每组普通/诊断 logits 一致，IR/ORT 对全部 256 个位置重新比较，严格 `max_abs < 1e-4`，`rtol=0`。
+- 30 个检查点的 dtype、shape、有限值和误差重新计算；其误差用于诊断定位，不额外替代或改变 logits 验收门槛。
+- 两个后端各自的未来 token 隔离、padding 隔离，共四项 invariant 重新计算。
+- 重新计算结果必须与原报告一致；仅有 `passed: true` 不能通过。
+- 解释器数值模式和策略一致，并受当前验证器支持。当前已提交 reference 契约为 `numpy-fp32-reference-v4`，所有 IR worker 的 `cpu_strategy` 必须一致，且完整 profile 的字段和值须与 `avx2-fma3` 或 `avx512` 的规范契约匹配；不是仅检查一个策略名字。
+
+v4 复核读取生产报告保存的 `cpu_strategy`，不从审计机器 CPU 或 `SCRATCHV_FP32_REFERENCE_CPU` 环境变量推断生产策略。完整 profile 校验包括 `matmul_k_block`、`matmul_row_tile`、`matmul_row_tail`、`matmul_column_tail`、`matmul_layout` 和 `matmul_vector_policy`，不能缺字段或仅靠版本名字通过。因此可以在另一种 CPU 上核对已保存的数组，无需控制或执行本机 ORT。这里的跨机器数组核对不证明该机器实际执行模型也能通过。
+
+当前 v4 验证器不接受历史 v2/v3 profile，须使用报告对应源码版本中的验证器，或重新生成 v4 完整证据。不能手动改旧报告的 profile、CPU 策略或源码哈希。`SCRATCHV_FP32_REFERENCE_CPU=auto|avx2-fma3|avx512` 是实际 reference 执行的选项，默认 `auto`；它不用于把旧证据转换到新契约，也不控制 ORT dispatch。
+
+## 结论边界
+
+`audit:w3-full-saved-evidence` 的 PASS 只说明**保存的文件和数值结果自洽**。
+它不证明生产者身份，也不代表第二人独立执行模型、当前源码已运行、Linux 通过、Nightly 通过或团队验收。
+本工具无法通过保存文件独立证明报告中的历史耗时与执行声明确实发生。
+
+默认 SHA-256 检查发现文件与报告不一致；若报告和数据同时被替换，它不能充当数字签名。
+可从可信渠道预先独立保留原始顶层报告哈希，然后传入：
+
+```bash
+set -euo pipefail
+"$SCRATCHV_PYTHON" -B scripts/verify_w3_evidence.py --evidence-dir output/downloaded-w3-run/raw/w3-full --output-dir output/w3-evidence-audit-02 --expected-report-sha256 ORIGINAL_REPORT_SHA256
+```
+
+`source_comparison` 明确列出原报告中生产源码与当前审计源码的更改、新增、缺失。
+源码不一致时，只要保存的数值契约仍受当前验证器支持，就可复核旧数组；但**不能将旧报告升级成当前源码执行的证明**。不受支持的旧 profile 仍会失败。
+报告同时保存 producer 环境、审计器环境和版本化数值策略。生产环境中的 `environment.numeric_runtime.blas_environment.OPENBLAS_CORETYPE` 是环境变量原值；`numpy_openblas` 的 `status/libraries` 及可用库项的 `core_name/config` 是可选运行诊断。审计不得以本机 CPU SIMD 或 BLAS 内核替填生产环境，也不能从该环境变量推断生产库已采用某个内核。诊断不可用或历史字段缺失不豁免任何数组数值门槛。
+
+当前已提交 v4 的[第四轮 Linux 执行](https://github.com/yuki-328/ScratchV/actions/runs/37299235103)（`1c49e8acbcd9174491b2d0c2a5a0072178ae5f9a`）已在七组完整执行、preparation 与手动汇总通过；完整 raw 数组已下载验真、离线 audit 通过。实际执行 PASS 和保存证据 audit PASS 分别记录，实际 audit 报告及 SHA256、原样保留的源码换行差异说明见 [第四轮实测记录](../../docs/llm-deploy-v1.0/W3/Linux-CI与Nightly.md)。本说明本身不替代该原始记录。
diff --git a/probes/w3_qwen3_full/LOCALIZE.md b/probes/w3_qwen3_full/LOCALIZE.md
new file mode 100644
index 0000000..0af0093
--- /dev/null
+++ b/probes/w3_qwen3_full/LOCALIZE.md
@@ -0,0 +1,46 @@
+# 完整模型的局部数值定位
+
+复现统一采用 **Ubuntu 24.04 x86_64、Bash、Python 3.12**。先完成 [Linux 环境与资产准备](../../docs/llm-deploy-v1.0/LINUX_REPRODUCTION.md)，再在同一个 Bash 会话、仓库根目录执行命令；该指南设置 `SCRATCHV_PYTHON`、`SCRATCHV_CC` 和 `SCRATCHV_QEMU`。
+
+`localize.py` 将同一个完整 ORT 层输入送入原图切片的 ORT 和 ScratchV IR，帮助区分当前层局部误差与上游累计误差。它保留完整 FP32 运算、真实权重和所有 padding query。不会接受 W3 完整数值 gate，也不会修改固定模型或门槛。
+
+先用本目录的 `run.py` 生成完整模型证据，再运行：
+
+```bash
+set -euo pipefail
+W3_MODEL=/absolute/path/to/qwen3-0.6b-onnx
+export OMP_NUM_THREADS='1'
+export OPENBLAS_NUM_THREADS='1'
+export MKL_NUM_THREADS='1'
+export PYTHONIOENCODING='utf-8'
+export SCRATCHV_FP32_REFERENCE_CPU='auto'
+"$SCRATCHV_PYTHON" -B -X utf8 probes/w3_qwen3_full/localize.py \
+ --model-dir "$W3_MODEL" \
+ --case-dir output/full-run/short_17 \
+ --output-dir output/full-localize-new \
+ --layer 0 --layer 21
+```
+
+依赖使用完整探测的固定 CPU 环境。输出目录必须不存在；不指定 `--layer` 时仅诊断第一层，层编号从 0 到 27，可重复指定不同层。原始 case 必须包含 `inputs.npz` 和 `ort/`、`ir/` 下完整 worker 的报告、logits、检查点及 schema。工具重新核验固定资产 SHA256、输入/mask、报告记录的数组哈希、普通/诊断 logits 一致性和固定图的 30 检查点结构。历史 IR/ORT 的源码指纹必须彼此一致，但不要求与新增诊断工具后的源码集相同；旧报告和当前诊断的源码指纹分别保留。
+
+诊断沿用原 IR worker 记录的 `fp32_mode`，并核对完整 reference profile；无模式字段的旧报告按 `native` 解释。当前已提交 reference 版本为 `numpy-fp32-reference-v4`，`SCRATCHV_FP32_REFERENCE_CPU` 可设为 `auto`（默认）、`avx2-fma3` 或 `avx512`。本机自动解析出的策略必须与原报告 `ir.fp32_profile.cpu_strategy` 一致；若跨 CPU 诊断，先读取原报告，在启动 Python 前显式设置同一策略。否则工具会拒绝不一致的 profile，不会静默换用当前机器策略。
+
+复现时另外保留原报告与本机 `environment.numeric_runtime` 中的 `blas_environment.OPENBLAS_CORETYPE`、`numpy_openblas.status/libraries` 及可用库项的 `core_name/config`。CPU SIMD 支持、参考策略和实际 BLAS 内核不同；环境变量原值不证明库已采用该内核。可选诊断不可用时保留原说明，不把它作为跳过数值检查的理由。
+
+这个环境变量只改变本次 IR reference 算术策略，不控制本机 ORT dispatch；局部诊断会实际执行本机 ORT/IR，因此不能把“重放保存的 IR 策略”当作两后端必然一致的保证。这与只读取原始数组的 [离线 audit](EVIDENCE.md) 不同，后者无需在当前机器选择或执行生产 CPU 策略。
+
+未知、互相矛盾或不受当前实现支持的 profile 会失败，不能自动换成最新策略。历史 v2/v3 的局部诊断应使用对应的代码版本，或重新生成 v4 完整证据；原报告的模式、profile 和源码哈希不得改写。
+
+v4 的 profile 还包含 MatMul 分块、尾行/单列处理与布局字段；即使 `cpu_strategy` 相同，也必须与保存证据的完整契约一致。当前 v4 实现不能直接用 v3 证据运行并宣称是在复现原算术策略。
+
+所选层按固定图的依赖关系切片；计算节点与权重不重写，以保存的前一层 ORT hidden state 作为共同输入。每层记录 13 个检查点，包含 Q/K RMSNorm、RoPE、Attention probabilities/context、残差及 MLP。第一次归约的 `Pow/ReduceMean/epsilon/rsqrt` 在选择第 0 层时额外记录。
+
+选择第 0 层时还自动运行五项相同输入原语实验：input RMSNorm 的 ReduceMean、Q/K 投影 MatMul、Attention QK MatMul、Softmax。FP64 仅用于估计原语的数学误差，不参与 IR/ORT 执行、不替换任何输出或正式参考。Softmax 另记录不可见 key 概率和行和偏差。
+
+`report.json`、`report.md`、`report.html` 保存误差、最差索引、有效/padding 分项、耗时、进程峰值 RSS 和源码/资产指纹。`layer-XX-values.npz` 保存原始检查点，`op-*-values.npz` 保存原语输入和双方输出，`.onnx` 是本次使用的实际 FP32 局部图。大文件仅在本地输出目录生成。
+
+退出码 0 与 `status=COMPLETE` 仅表示诊断完成；局部误差超过 `1e-4` 会照实记录为比较不通过，不伪装成工具执行失败。资产、输入、schema、执行或有限值检查失败时退出 1。无论诊断完成与否，`numeric_gate_passed=false`、`w3_exit_accepted=false`，原完整模型失败报告保持原样。
+
+不能单凭一个大值中间张量超 `1e-4` 判定语义错误。例如 6000 量级 FP32 数值的一个 ULP 已可能超过该阈值。应同时查看同输入对照、原语误差、值域和原始 mask 概率，最终仍以完整 runner 的全部 logits `<1e-4` 验收。
+
+当前已提交 v4 的[第四轮 Linux 完整运行](https://github.com/yuki-328/ScratchV/actions/runs/37299235103)（`1c49e8acbcd9174491b2d0c2a5a0072178ae5f9a`）已七组完整执行通过；raw 数组 audit 也已通过。该结论来自完整 runner，局部诊断和本说明不替代完整 gate 或团队验收。
diff --git a/probes/w3_qwen3_full/README.md b/probes/w3_qwen3_full/README.md
new file mode 100644
index 0000000..5b51e48
--- /dev/null
+++ b/probes/w3_qwen3_full/README.md
@@ -0,0 +1,87 @@
+# 完整 Qwen3 IR 数值验证
+
+复现统一采用 **Ubuntu 24.04 x86_64、Bash、Python 3.12**。先完成 [Linux 环境与资产准备](../../docs/llm-deploy-v1.0/LINUX_REPRODUCTION.md)，再在同一个 Bash 会话、仓库根目录执行命令；该指南设置 `SCRATCHV_PYTHON`、`SCRATCHV_CC` 和 `SCRATCHV_QEMU`。
+
+该入口实际执行固定发布的 28 层 Qwen3-0.6B FP32 ONNX，比较 ScratchV IR 与 ORT 的完整 logits，包括右侧 padding query。它使用优化前 IR（none），不会把资产检查、两层模型或部分输入通过视为完整模型数值验收。
+
+## 验证范围
+
+默认运行七组输入：两组满长随机输入、单 token、17/255 个有效 token，以及改变未来 token、改变 padding token 的输入。固定形状为 INT64 input_ids `[1,256]` 和 FP32 加性 mask `[1,1,256,256]`，输出为 FP32 `[1,256,151936]`。输入是可复现的原始 embedding ID，用于数值测试，不作为 tokenizer 或语言生成质量证据。
+
+每组输入分别启动 ORT 和 IR 独立进程；每个后端运行普通与诊断两次，要求两份完整 logits 逐元素完全一致。跨后端对普通、诊断 logits 分别执行严格的 `max_abs < 1e-4`、`rtol=0`，同时报告有效位置和 padding 位置的误差。因果性和 padding 隔离另有四项跨输入检查。
+
+诊断保存 embedding、28 层 residual 输出、final norm 共 30 个检查点，按固定图的实际连接定位。中间张量的 `1e-4` 标记用于定位误差，正式数值门槛作用于完整 logits；某些中间激活很大，单个 FP32 ULP 已可能大于 `1e-4`。报告保留这些标记，不将它们隐藏，也不把中间误差与最终输出误差混为一谈。
+
+## 运行
+
+在 W3 工作树根目录，使用 [固定依赖](../../requirements/qwen3-small-probe.txt)。模型目录必须包含已发布且匹配 manifest 的完整 ONNX 与三份权重分片；入口不下载、不修改模型。
+
+完整入口默认使用 `--fp32-mode reference`，当前已提交策略为 `numpy-fp32-reference-v4`；请在复现命令中显式写出模式。解释器 API 默认仍为 `native`，追加 `--fp32-mode native` 才复现原 NumPy 策略。两种模式、不同版本和不同 CPU 策略的 profile 必须分别记录与验收，不能将一份报告的通过结论用于另一种模式。该参考模式不是跨 CPU、BLAS 或 ORT 版本逐元素一致的保证。
+
+环境变量 `SCRATCHV_FP32_REFERENCE_CPU` 只作用于 `reference` IR 的算术策略，允许以下取值：
+
+| 值 | 行为 |
+|---|---|
+| `auto`（未设置时的默认值） | 从 NumPy 报告的可用 CPU 能力推断；具有 AVX2/FMA3 时，根据 AVX512F 是否可用选择下列一种策略 |
+| `avx2-fma3` | 显式采用对应的参考算术顺序，profile 记录该值 |
+| `avx512` | 显式采用对应的参考算术顺序，profile 记录该值 |
+
+显式设置不会控制 ORT 的 CPU dispatch，也不是启用或禁用真实硬件指令的开关；两条参考路径仍由 NumPy 实现。跨机器重放保存的算术策略时，可以在启动 Python 前显式指定报告中的 `cpu_strategy`，但必须重新比较本机 ORT 输出。未知变量取值会报错；`auto` 模式无法识别所需 CPU 能力，或发现 `NPY_DISABLE_CPU_FEATURES` 遮蔽相关 AVX/FMA 能力时也会明确报错，要求显式选择并记录策略。
+
+v4 把矩阵乘的分块与内存布局纳入版本化 profile；数值策略名字与 CPU 策略相同仍不足以替代完整字段核对：
+
+| profile 字段 | `avx2-fma3` | `avx512` |
+|---|---|---|
+| `matmul_k_block` | 128 | 128；K≤128 时保留原 NumPy 路径 |
+| `matmul_row_tile` | 2 | `null`，保留原宽矩阵路径 |
+| `matmul_row_tail` | `zero-pad-to-two-then-trim` | `native` |
+| `matmul_column_tail` | `zero-pad-single-column-to-two-then-trim` | `native` |
+| `matmul_layout` | `contiguous-matrix-operands-per-k-block` | `native-strides` |
+| `matmul_vector_policy` | `native-numpy-vector-promotion` | `native-numpy-vector-promotion` |
+
+AVX2 矩阵路径按两个输出行计算，尾行和单列临时补零后裁回原输出形状，每个 K 分块的两个矩阵操作数使用 C 连续切片；向量提升继续遵循 NumPy。以上是参考计算契约，不改模型图、权重、输出形状或误差门槛，也不是性能优化验收。本节描述已提交的 v4 实现；第四轮 Linux 已取得同提交七组完整运行 PASS，普通/诊断完整 logits 及四项不变量最大误差均为 0；这是 v4 的新实测证据，历史 v3 或单例结果不能替代它。
+
+~~~bash
+set -euo pipefail
+W3_MODEL=/absolute/path/to/qwen3-0.6b-onnx
+export SCRATCHV_FP32_REFERENCE_CPU=auto
+"$SCRATCHV_PYTHON" -B -X utf8 probes/w3_qwen3_full/run.py \
+ --model-dir "$W3_MODEL" --output-dir output/w3-full-new \
+ --fp32-mode reference --worker-timeout 1800 --max-worker-memory-gib 10
+~~~
+
+需要复现单个失败时追加 `--case short_17`。成功但仅覆盖部分 case 返回 PARTIAL/2，完整七组和不变量全部通过才返回 PASS/0；实际执行失败或数值超标返回 FAIL/1。中断返回 130。输出目录必须是新目录。
+
+每个 worker 的超时和采样内存上限覆盖本次拥有的整棵进程树。Linux 使用独立进程组，采样整个进程树的 RSS，并在超时、超限或中断时清理本次拥有的进程。采样间隔为 0.2 秒，共享内存页可能按进程重复计数。它是超限终止措施，不是操作系统的硬内存配额，短暂峰值仍可能超过界限。失败保留阶段进度、日志、已完成产物和报告；中断、超时及超限会清理本次拥有的进程树。
+
+## 证据与时长
+
+统一 `report.json`、`report.md` 和 `report.html` 包含每组输入、每个 worker、完整比较和四项不变量。`cases[].comparison.logits` 是最终精度验收数据，`checkpoints` 及 `first_divergence` 定位最早超过诊断阈值的检查点。
+
+Summary 将普通图与诊断图的最终 logits 分开，明确实际 `native/reference` 模式，并报告最大绝对误差、余弦相似度和相对 L2 误差；逐用例索引默认折叠，完整检查点和机器证据仅保存在 `report.json`，不重复嵌入摘要。后两项由实际输出和参考数组分块计算，使用 FP64 累积，不改变原有通过门槛。不能把参考兼容模式的通过结果归给默认 NumPy 模式。旧报告不补写或重新命名为本轮运行；离线重算保存数组也不代表重新执行了模型。
+
+PPL（真实文本预测的困惑度）和 zero-shot（无示例任务评分）本轮未评测。这里的随机 token 输入用于数值对齐，不能作为语言质量语料；加入这类评测前需要固定真实文本、Tokenizer、L=256 的分窗及计分方式。
+
+每组目录内有 `inputs.npz`、ORT/IR 日志，以及两个后端各自的完整 logits、诊断 logits、检查点 NPZ、schema、报告和阶段进度。报告包含固定模型、输入、输出及源码哈希；统一入口重新校验原始数组与报告一致性。
+
+`cases[].workers[].stages_seconds` 可查看模型解析、普通执行、诊断执行和写盘时间；统一 `elapsed_seconds` 包括所有 worker 及文件核对。`process_peak_rss_bytes` 为该 worker 的全生命周期峰值，`resource_monitor` 是父进程采样观测。两者测量口径不同。
+
+每个 IR worker 的 `ir.fp32_profile` 记录实际数值策略，包括 `name=numpy-fp32-reference-v4` 与已解析的 `cpu_strategy`；`auto` 是选择方式，不是保存后的策略名称。`environment.numeric_runtime` 补充 CPU 架构、NumPy 构建/运行诊断和线程环境。`blas_environment.OPENBLAS_CORETYPE` 保存环境变量原值，未设置时为 `null`，不是实际生效内核的证明；`numpy_openblas` 保存可选诊断的总体 `status`、`libraries`，可用库项包含 `path`、`status`、`core_name`、`config`，不可用时保存 `reason` 或 `error`。该诊断只读取已装载的 NumPy 私有 OpenBLAS 库，系统 BLAS/MKL 等可明确为不可用。
+
+CPU SIMD 能力、IR 的 `cpu_strategy` 与实际 BLAS 内核须分别看待；上述字段也不证明 ORT 使用了哪一种内部内核。可选诊断不可用或旧证据缺少该字段，不能掩盖数值失败，所有门槛照常执行。独立复现应一并保留这些字段、环境变量原值、依赖版本与源码哈希。
+
+离线 audit 按生产报告中保存的 CPU 策略核对整个 profile，不从审计机器 CPU 推断生产策略，也不会重新运行模型。当前 v4 工具严格验证 v4 契约；历史 v2/v3 原始证据应在其对应源码版本下核对，不能把报告字段改为 v4 或直接沿用旧版本的 PASS。每个提交和策略的完整七组以对应运行结果验收。
+
+完整执行使用只读映射权重、显式借用 initializer、最后一次使用后释放中间 binding；默认解释器 API 仍复制和保留原有数据。只读映射文件在调用期间必须保持不变。解释器的 `peak_numpy_storage_bytes` 计入当时已绑定的借用 buffer，排除已解除绑定但仍由调用方持有的数组、内核临时缓冲和观察回调的拷贝；请同时参考实际进程 RSS。observer 是受信任的同步回调，只读 view 用于防止误写，不提供隔离沙箱。
+
+需要继续定位失败时，使用 [同输入逐层与原语诊断](LOCALIZE.md)。该工具读取已保存的完整执行证据，保存层内检查点和局部 FP64 参考误差；诊断完成不代表完整数值验收通过。
+
+## CI 与阶段结论
+
+[完整模型手动 CI](../../.github/workflows/w3-full-numeric.yml) 已随 PR #96 发布。2026-10-05，作者在提交 `1c49e8acbcd9174491b2d0c2a5a0072178ae5f9a` 的[第四轮 Linux 手动编排](https://github.com/yuki-328/ScratchV/actions/runs/37299235103)中通过 preparation、完整七组 full 和汇总；v4/avx2-fma3、OpenBLAS Haswell 环境下普通/诊断 logits、30 检查点与四不变量最大误差均为 0，完整 runner 用时 `1477.314971525 s`（约 24.6 分钟）。reports 已下载并核对，完整 raw 已下载验真、离线 audit 通过。前三轮失败及旧 v2/v3 记录保留在 [Linux 实测记录](../../docs/llm-deploy-v1.0/W3/Linux-CI与Nightly.md)。实际完整数值失败仍使 job 失败；没有自动忽略 padding、调大阈值、启用低精度或回退到小模型。
+
+该流程同时支持 `workflow_call`，供显式启用的 [Nightly 编排](../../.github/workflows/w3-nightly.yml) 复用；两套自动检查均成功才能通过汇总。Linux 运行、定时启用和资源限制说明见 [Linux CI 与 Nightly](../../docs/llm-deploy-v1.0/W3/Linux-CI与Nightly.md)。收到完整保存目录后，可按 [离线证据复核](EVIDENCE.md) 重新检查数组；这不执行模型，也不替代独立复现。
+
+CI 将报告、哈希和 schema 放入 `w3-full-numeric-reports`（保留 30 天），完整原始输入、logits 和检查点另放入 `w3-full-numeric-raw`（保留 3 天，也包含报告）。需要独立复核原始数值时，应在过期前下载 raw 产物；其解压目录中保留 `w3-full/` 前缀，所以 `--evidence-dir` 应为 `下载目录/w3-full`。下载命令、报告 SHA256 获取与完整 audit 示例见 [产物与失败定位](../../docs/llm-deploy-v1.0/W3/Linux-CI与Nightly.md#产物与失败定位)。仅有摘要和哈希不足以重新比较数组。失败或中断运行的产物可能不完整，须先核对报告状态与覆盖范围。
+
+即使本地数值 PASS，`w3_exit_accepted` 仍为 false：W1 人工前置验收、团队确认、E1/E2/E5 独立复现及 Nightly 状态由团队单独核对。[Linux 完整执行记录](../../docs/llm-deploy-v1.0/W3/W3-完整模型执行与数值诊断报告.md) 保留固定提交、模式和数据，不代表之后版本已经重跑。当前结论以本次完整运行生成的 `report.json`、实际 profile 和源码指纹为准。
diff --git a/probes/w3_qwen3_full/__init__.py b/probes/w3_qwen3_full/__init__.py
new file mode 100644
index 0000000..67f94da
--- /dev/null
+++ b/probes/w3_qwen3_full/__init__.py
@@ -0,0 +1 @@
+"""Bounded full Qwen3 numerical verification workers and gate."""
diff --git a/probes/w3_qwen3_full/cases.py b/probes/w3_qwen3_full/cases.py
new file mode 100644
index 0000000..aa5b542
--- /dev/null
+++ b/probes/w3_qwen3_full/cases.py
@@ -0,0 +1,29 @@
+"""Fixed numerical input suite for the released FP32 L256 model."""
+from __future__ import annotations
+
+import numpy as np
+
+from scratchv.runtime.llm_inputs import prepare_inputs, QWEN3_VOCAB_SIZE
+
+CASE_NAMES = ("full_seed_0", "full_seed_42", "one_token", "short_17", "short_255",
+ "changed_future", "changed_padding")
+SEQ = 256
+
+
+def input_cases():
+ """Raw embedding IDs; this suite makes no tokenizer or language-quality claim."""
+ result = []
+ for name, seed, length in ((CASE_NAMES[0], 0, 256), (CASE_NAMES[1], 42, 256),
+ (CASE_NAMES[2], 7, 1), (CASE_NAMES[3], 7, 17),
+ (CASE_NAMES[4], 7, 255)):
+ tokens = np.random.default_rng(seed).integers(1, QWEN3_VOCAB_SIZE, length, dtype=np.int64)
+ feed = prepare_inputs(tokens, pad_token_id=0).as_feed()
+ result.append((name, length, feed))
+ future = {key: value.copy() for key, value in result[0][2].items()}
+ future["input_ids"][:, 64:] = future["input_ids"][:, 64:] % (QWEN3_VOCAB_SIZE - 1) + 1
+ result.append((CASE_NAMES[5], 256, future))
+ padding = {key: value.copy() for key, value in result[3][2].items()}
+ padding["input_ids"][:, 17:] = np.random.default_rng(99).integers(
+ 1, QWEN3_VOCAB_SIZE, (1, 239), dtype=np.int64)
+ result.append((CASE_NAMES[6], 17, padding))
+ return result
diff --git a/probes/w3_qwen3_full/comparison.py b/probes/w3_qwen3_full/comparison.py
new file mode 100644
index 0000000..478b864
--- /dev/null
+++ b/probes/w3_qwen3_full/comparison.py
@@ -0,0 +1,62 @@
+"""Bounded-memory absolute-error comparisons, including padded query rows."""
+from __future__ import annotations
+
+import math
+import numpy as np
+
+from scratchv.verification.numeric_metrics import numeric_metrics, undefined_numeric_metrics
+
+ATOL = 1e-4
+
+
+def compare_tensor(actual, reference, *, atol=ATOL, chunk_elements=262144):
+ if not math.isfinite(atol) or atol <= 0:
+ raise ValueError("atol must be finite and positive")
+ if type(chunk_elements) is not int or chunk_elements < 1:
+ raise ValueError("chunk_elements must be a positive integer")
+ row = {"passed": False, "atol": atol, "rtol": 0,
+ "shape": list(actual.shape), "reference_shape": list(reference.shape),
+ "dtype": str(actual.dtype), "reference_dtype": str(reference.dtype),
+ "elements": int(actual.size), "max_abs": None, "finite": False}
+ row.update(undefined_numeric_metrics("comparison is invalid"))
+ if actual.shape != reference.shape or actual.dtype != np.float32 or reference.dtype != np.float32:
+ row["reason"] = "shape or FP32 dtype mismatch"
+ row.update(undefined_numeric_metrics(row["reason"]))
+ return row
+ if not actual.size:
+ row["reason"] = "empty comparison is not numerical evidence"
+ row.update(undefined_numeric_metrics(row["reason"]))
+ return row
+ # nditer handles strided slices without a full-size ravel/copy allocation.
+ chunks = np.nditer([actual, reference], flags=["external_loop", "buffered"],
+ op_flags=[["readonly"], ["readonly"]], order="C", buffersize=chunk_elements)
+ maximum, offset, worst = -1.0, 0, None
+ for a, b in chunks:
+ finite = np.isfinite(a) & np.isfinite(b)
+ if not finite.all():
+ index = offset + int(np.flatnonzero(~finite)[0])
+ row.update(reason="nonfinite value", worst_index=list(np.unravel_index(index, actual.shape)))
+ row["worst_index"] = [int(x) for x in row["worst_index"]]
+ row.update(undefined_numeric_metrics(row["reason"]))
+ return row
+ difference = np.abs(a.astype(np.float64) - b.astype(np.float64))
+ local = int(np.argmax(difference))
+ if float(difference[local]) > maximum:
+ maximum = float(difference[local])
+ worst = (offset + local, float(a[local]), float(b[local]))
+ offset += a.size
+ row.update(passed=maximum < atol, finite=True, max_abs=maximum,
+ worst_index=[int(x) for x in np.unravel_index(worst[0], actual.shape)],
+ actual_value=worst[1], reference_value=worst[2])
+ row.update(numeric_metrics(actual, reference, block_elements=chunk_elements))
+ return row
+
+
+def compare_positions(actual, reference, valid_length, *, atol=ATOL):
+ if actual.ndim != 3 or reference.ndim != 3 or not 1 <= valid_length <= actual.shape[1]:
+ raise ValueError("expected [batch, sequence, width] and a valid query length")
+ total = compare_tensor(actual, reference, atol=atol)
+ total["valid_queries"] = compare_tensor(actual[:, :valid_length], reference[:, :valid_length], atol=atol)
+ total["padding_queries"] = (compare_tensor(actual[:, valid_length:], reference[:, valid_length:], atol=atol)
+ if valid_length < actual.shape[1] else None)
+ return total
diff --git a/probes/w3_qwen3_full/localize.py b/probes/w3_qwen3_full/localize.py
new file mode 100644
index 0000000..c4fd787
--- /dev/null
+++ b/probes/w3_qwen3_full/localize.py
@@ -0,0 +1,390 @@
+"""Localize full-Qwen3 numerical differences using identical layer inputs.
+
+A completed diagnosis is not a numerical gate: large intermediate activations
+may differ by more than 1e-4 in a few FP32 ULPs. The full-model runner remains
+the authority for full logits. This tool never changes execution precision.
+"""
+from __future__ import annotations
+
+import argparse
+import copy
+import gc
+import json
+from pathlib import Path
+import sys
+import time
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+ sys.path.insert(0, str(ROOT))
+
+import numpy as np
+import onnx
+
+from probes.w1_qwen3_export.run import verify_files
+from probes.w3_common import (new_output_dir, process_peak_rss_bytes, sha256_file,
+ source_evidence, write_reports)
+from probes.w3_layer_diff.run import load_arrays, load_schema
+from probes.w3_qwen3_full.comparison import compare_tensor
+from probes.w3_qwen3_full.run import validate_worker
+from probes.w3_qwen3_full.worker import checkpoint_schema, load_inputs
+
+
+def require(value, message):
+ if not value:
+ raise ValueError(message)
+
+
+def selected_layers(values):
+ values = [0] if values is None else list(values)
+ require(bool(values) and all(type(v) is int and 0 <= v < 28 for v in values),
+ "Layers must be integer indices in [0, 27]")
+ require(len(values) == len(set(values)), "Duplicate layer selection")
+ return sorted(values)
+
+
+def compare_queries(actual, reference, valid, axis):
+ require(actual.ndim > axis and actual.shape[axis] == 256 and 1 <= valid <= 256,
+ "Expected complete L256 query axis and valid length")
+ row = compare_tensor(actual, reference)
+ prefix = [slice(None)] * actual.ndim
+ suffix = prefix.copy()
+ prefix[axis], suffix[axis] = slice(0, valid), slice(valid, None)
+ row["valid_queries"] = compare_tensor(actual[tuple(prefix)], reference[tuple(prefix)])
+ row["padding_queries"] = (compare_tensor(actual[tuple(suffix)], reference[tuple(suffix)])
+ if valid < 256 else None)
+ row["query_axis"] = axis
+ return row
+
+
+def probability_diagnostics(probabilities, mask):
+ require(probabilities.dtype == np.float32 and probabilities.ndim == 4
+ and probabilities.shape[0] == 1 and probabilities.shape[2:] == (256, 256)
+ and np.isfinite(probabilities).all(), "Invalid attention probabilities")
+ require(mask.shape == (1, 1, 256, 256) and mask.dtype == np.float32,
+ "Invalid attention mask")
+ invisible = np.broadcast_to(mask < 0, probabilities.shape)
+ return {"masked_probability_max_abs": float(np.abs(probabilities[invisible]).max()),
+ "row_sum_max_abs_error": float(np.abs(probabilities.sum(-1, dtype=np.float64) - 1).max()),
+ "minimum_probability": float(probabilities.min())}
+
+
+def fp64_error_oracle(op, feed, ir_value, ort_value):
+ """Double precision is only an independent local error estimate."""
+ require(ir_value.dtype == ort_value.dtype == np.float32,
+ "Execution outputs must remain FP32")
+ if op == "MatMul":
+ truth = np.matmul(feed["a"].astype(np.float64), feed["b"].astype(np.float64))
+ elif op == "ReduceMean":
+ truth = feed["x"].astype(np.float64).mean(-1, keepdims=True)
+ elif op == "Softmax":
+ x = feed["x"].astype(np.float64)
+ exp = np.exp(x - x.max(-1, keepdims=True))
+ truth = exp / exp.sum(-1, keepdims=True)
+ else:
+ raise ValueError("Unsupported local diagnostic operation")
+ return {"scope": "diagnostic only; neither execution result nor acceptance output",
+ "ir_max_abs": float(np.abs(ir_value - truth).max()),
+ "ort_max_abs": float(np.abs(ort_value - truth).max())}
+
+
+class LayerSlice:
+ """Extract exact pinned-graph ancestors; never reconstruct model arithmetic."""
+
+ def __init__(self, model, model_dir):
+ self.model, self.model_dir = model, Path(model_dir)
+ self.nodes = list(model.graph.node)
+ self.producers = {name: node for node in self.nodes for name in node.output}
+ self.info = {v.name: v for v in [*model.graph.value_info, *model.graph.input, *model.graph.output]}
+ self.initializers = {v.name: v for v in model.graph.initializer}
+ require(len(self.producers) == sum(len(n.output) for n in self.nodes),
+ "Duplicate graph values")
+
+ @staticmethod
+ def one(nodes, description):
+ rows = list(nodes)
+ require(len(rows) == 1, f"Expected unique {description}")
+ return rows[0]
+
+ def norm(self, weight):
+ node = self.one((n for n in self.nodes if n.op_type == "Mul" and weight in n.input), weight)
+ value = next(x for x in node.input if x != weight)
+ cast = self.producers[value]
+ require(cast.op_type == "Cast", "Unexpected normalization cast")
+ mul = self.producers[cast.input[0]]
+ require(mul.op_type == "Mul", "Unexpected normalization product")
+ cast = self.producers[mul.input[0]]
+ require(cast.op_type == "Cast", "Unexpected normalization input")
+ return cast.input[0], node.output[0]
+
+ def projection(self, weight):
+ tr = self.one((n for n in self.nodes if n.op_type == "Transpose" and weight in n.input), weight)
+ mat = self.one((n for n in self.nodes if n.op_type == "MatMul" and tr.output[0] in n.input), weight + " MatMul")
+ return mat.input[0], mat.output[0]
+
+ def describe(self, index):
+ p = f"model.model.layers.{index}."
+ hidden, input_norm = self.norm(p + "input_layernorm.weight")
+ residual, postnorm = self.norm(p + "post_attention_layernorm.weight")
+ _, qnorm = self.norm(p + "self_attn.q_norm.weight")
+ _, knorm = self.norm(p + "self_attn.k_norm.weight")
+ _, vproj = self.projection(p + "self_attn.v_proj.weight")
+ context, attn_output = self.projection(p + "self_attn.o_proj.weight")
+ _, mlp = self.projection(p + "mlp.down_proj.weight")
+ final = self.one((n for n in self.nodes if n.op_type == "Add" and mlp in n.input), "MLP residual").output[0]
+ begin, end = self.nodes.index(self.producers[input_norm]), self.nodes.index(self.producers[final])
+ block = self.nodes[begin:end + 1]
+ softmax = self.one((n for n in block if n.op_type == "Softmax"), "layer Softmax").output[0]
+ probs = self.one((n for n in block if n.op_type == "Cast" and softmax in n.input), "Softmax cast").output[0]
+
+ def rope(norm):
+ tr = self.one((n for n in block if n.op_type == "Transpose" and norm in n.input), "norm transpose")
+ mul = self.one((n for n in block if n.op_type == "Mul" and tr.output[0] in n.input), "RoPE cosine product")
+ return self.one((n for n in block if n.op_type == "Add" and mul.output[0] in n.input), "RoPE sum").output[0]
+
+ return hidden, {"input_norm": input_norm, "q_norm": qnorm, "k_norm": knorm, "v_proj": vproj,
+ "rope_q": rope(qnorm), "rope_k": rope(knorm), "attn_probs": probs,
+ "attn_context": context, "attn_output": attn_output, "attn_residual": residual,
+ "post_attention_norm": postnorm, "mlp": mlp, "residual": final}
+
+ def build(self, hidden, outputs):
+ stop, needed, queue, chosen = {hidden, "attention_mask"}, set(outputs), list(outputs), set()
+ while queue:
+ value = queue.pop()
+ if value in stop or value not in self.producers:
+ continue
+ node = self.producers[value]
+ if node.name in chosen:
+ continue
+ chosen.add(node.name)
+ for name in node.input:
+ if name and name not in needed:
+ needed.add(name)
+ queue.append(name)
+ nodes = [copy.deepcopy(n) for n in self.nodes if n.name in chosen]
+ weights = [onnx.numpy_helper.from_array(onnx.numpy_helper.to_array(t, base_dir=str(self.model_dir)), name)
+ for name, t in self.initializers.items() if name in needed and name not in stop]
+ for node in nodes:
+ for attr in node.attribute:
+ if attr.type == onnx.AttributeProto.TENSOR and attr.t.external_data:
+ attr.t.CopyFrom(onnx.numpy_helper.from_array(
+ onnx.numpy_helper.to_array(attr.t, base_dir=str(self.model_dir)), attr.t.name))
+ graph = onnx.helper.make_graph(nodes, "pinned_layer_slice",
+ [copy.deepcopy(self.info[x]) for x in sorted(stop) if x in needed],
+ [copy.deepcopy(self.info[x]) for x in outputs], initializer=weights)
+ result = onnx.helper.make_model(graph, opset_imports=self.model.opset_import)
+ result.ir_version = self.model.ir_version
+ onnx.checker.check_model(result)
+ return result
+
+
+def run_pair(model, feed, outputs, path, *, fp32_mode="native"):
+ """Actual ORT and production Parser/IR execution, with FP32 feeds unchanged."""
+ import onnxruntime as ort
+ from scratchv.frontend.onnx_parser import ONNXParser
+ from scratchv.verification.ir_interpreter import IRInterpreter
+
+ require(all(v.dtype == np.float32 and np.isfinite(v).all() for v in feed.values()),
+ "Local execution feeds must be finite FP32")
+ options = ort.SessionOptions()
+ options.intra_op_num_threads = options.inter_op_num_threads = 1
+ options.enable_cpu_mem_arena = False
+ options.log_severity_level = 3
+ options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_DISABLE_ALL
+ diagnostic_path = path.with_name(path.stem + "-diagnostic.onnx")
+ onnx.save_model(model, diagnostic_path)
+ session = ort.InferenceSession(model.SerializeToString(), sess_options=options, providers=["CPUExecutionProvider"])
+ ort_values = dict(zip(outputs, session.run(list(outputs.values()), feed)))
+ ordinary = copy.deepcopy(model)
+ wanted = outputs[next(reversed(outputs))]
+ last = next(v for v in ordinary.graph.output if v.name == wanted)
+ last = copy.deepcopy(last)
+ del ordinary.graph.output[:]
+ ordinary.graph.output.append(last)
+ onnx.save_model(ordinary, path)
+ parser = ONNXParser()
+ program = parser.parse(str(path))
+ for value in parser.initializers.values():
+ value.setflags(write=False)
+ bindings = {parser._value_map[value].name: name for name, value in outputs.items()}
+ require(len(bindings) == len(outputs), "Aliased/ambiguous diagnostic checkpoints")
+ ir_values = {}
+
+ def observe(name, value):
+ if name in bindings:
+ require(bindings[name] not in ir_values, "Checkpoint executed twice")
+ ir_values[bindings[name]] = value.copy()
+
+ result = IRInterpreter(program).run(feed, initializers=parser.initializers,
+ memory_mode="last_use", copy_initializers=False, observer=observe,
+ fp32_mode=fp32_mode)
+ require(set(ir_values) == set(outputs), "Missing executed checkpoint")
+ require(all(v.dtype == np.float32 and np.isfinite(v).all() for v in [*ir_values.values(), *ort_values.values()]),
+ "Nonfinite/non-FP32 execution output")
+ return ir_values, ort_values, {"executed_steps": result.executed_steps,
+ "fp32_mode": fp32_mode,
+ "model_sha256": sha256_file(path), "model_file": path.name,
+ "ort_model_file": diagnostic_path.name,
+ "ort_model_sha256": sha256_file(diagnostic_path),
+ "checkpoint_onnx_names": dict(outputs)}
+
+
+def primitive(op, feed, shape):
+ inputs, initializers, attrs = list(feed), [], {}
+ if op == "ReduceMean":
+ inputs += ["axes"]
+ initializers = [onnx.numpy_helper.from_array(np.array([-1], dtype=np.int64), "axes")]
+ attrs["keepdims"] = 1
+ elif op == "Softmax":
+ attrs["axis"] = -1
+ graph = onnx.helper.make_graph([onnx.helper.make_node(op, inputs, ["y"], **attrs)], op,
+ [onnx.helper.make_tensor_value_info(k, 1, v.shape) for k, v in feed.items()],
+ [onnx.helper.make_tensor_value_info("y", 1, shape)], initializer=initializers)
+ model = onnx.helper.make_model(graph, opset_imports=[onnx.helper.make_opsetid("", 18)])
+ model.ir_version = 10
+ return model
+
+
+def local_primitives(extract, ort_values, mask, valid, out, *, fp32_mode="native"):
+ rows = []
+
+ def run(name, op, feed, shape, axis=1):
+ ir, ort_values, evidence = run_pair(primitive(op, feed, shape), feed, {"result": "y"},
+ out / f"op-{name}.onnx", fp32_mode=fp32_mode)
+ a, b = ir["result"], ort_values["result"]
+ row = {"name": name, "op": op, "comparison": compare_queries(a, b, valid, axis),
+ "fp64_error_oracle": fp64_error_oracle(op, feed, a, b), **evidence}
+ if op == "Softmax":
+ row["probabilities"] = {"ir": probability_diagnostics(a, mask), "ort": probability_diagnostics(b, mask)}
+ rows.append(row)
+ values_path = out / f"op-{name}-values.npz"
+ np.savez(values_path, ir=a, ort=b, **feed)
+ row["values"] = {"file": values_path.name, "bytes": values_path.stat().st_size,
+ "sha256": sha256_file(values_path)}
+ return b
+
+ run("input_norm_reduce_mean", "ReduceMean", {"x": ort_values["square"]}, [1, 256, 1])
+ for key, width in (("q", 2048), ("k", 1024)):
+ name = f"model.model.layers.0.self_attn.{key}_proj.weight"
+ weight = onnx.numpy_helper.to_array(extract.initializers[name], base_dir=str(extract.model_dir)).T.copy()
+ run(f"projection_{key}", "MatMul", {"a": ort_values["input_norm"], "b": weight}, [1, 256, width])
+ q, k = ort_values["rope_q"], np.repeat(ort_values["rope_k"], 2, axis=1)
+ scores = run("attention_scores", "MatMul", {"a": q, "b": k.transpose(0, 1, 3, 2).copy()}, [1, 16, 256, 256], 2)
+ scores = scores * np.float32(128 ** -0.5) + mask
+ run("attention_softmax", "Softmax", {"x": scores}, [1, 16, 256, 256], 2)
+ return rows
+
+
+def validate_reference_metadata(record, schema, expected_schema, files, input_hash):
+ require(record.get("gate") == "numeric:w3-full-worker" and record.get("backend") == "ort"
+ and record.get("passed") is True and record.get("status") == "PASS", "Expected executed ORT worker")
+ require(record.get("files") == files, "Reference model assets differ")
+ require(record.get("input", {}).get("sha256") == input_hash, "Reference inputs differ")
+ require(schema == expected_schema and record.get("checkpoints") == schema,
+ "Reference schema differs from fixed graph dataflow")
+
+
+def validate_producer_pair(ort_record, ir_record):
+ require(bool(ort_record.get("source_sha256"))
+ and ort_record["source_sha256"] == ir_record.get("source_sha256"),
+ "Historical IR/ORT producer source fingerprints differ")
+
+
+def producer_fp32_mode(ir_record):
+ details = ir_record.get("ir", {})
+ mode = details.get("fp32_mode", "native")
+ require(mode in ("native", "reference"), "Unknown producer FP32 mode")
+ require(ir_record.get("fp32_mode", mode) == mode, "Producer FP32 modes disagree")
+ if mode == "reference":
+ from scratchv.verification.fp32_reference import profile
+ require(details.get("fp32_profile") == profile(),
+ "Unsupported historical FP32 reference profile")
+ else:
+ require("fp32_profile" not in details or details["fp32_profile"] == {"name": "numpy-native"},
+ "Unsupported historical native FP32 profile")
+ return mode
+
+
+def main(argv=None):
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument("--model-dir", type=Path, required=True)
+ parser.add_argument("--case-dir", type=Path, required=True)
+ parser.add_argument("--output-dir", type=Path, required=True)
+ parser.add_argument("--layer", type=int, action="append", help="Repeat for selected indices 0..27; default 0")
+ args = parser.parse_args(argv)
+ try:
+ layers = selected_layers(args.layer)
+ except ValueError as exc:
+ parser.error(str(exc))
+ out = new_output_dir(args.output_dir)
+ report = {"gate": "diagnostic:w3-full-localize", "status": "FAIL", "passed": False,
+ "diagnostic_complete": False, "numeric_gate_passed": False, "w3_exit_accepted": False,
+ "scope": "Selected exact layer slices and equal-input FP32 primitives; cannot accept the full-model gate",
+ "selected_layers": layers, "layers": [], "primitives": [],
+ "execution_dtype": "float32", "fp64_scope": "local error oracle only"}
+ start = time.perf_counter()
+ try:
+ report.update(source_evidence())
+ files = verify_files(args.model_dir)
+ feed, valid = load_inputs(args.case_dir / "inputs.npz")
+ model = onnx.load(args.model_dir / "model.onnx", load_external_data=False)
+ expected = checkpoint_schema(model)
+ folder = args.case_dir / "ort"
+ schema = load_schema(folder / "checkpoint_schema.json")
+ record = json.loads((folder / "report.json").read_text(encoding="utf-8"))
+ ir_folder = args.case_dir / "ir"
+ ir_record = json.loads((ir_folder / "report.json").read_text(encoding="utf-8"))
+ validate_producer_pair(record, ir_record)
+ input_hash = sha256_file(args.case_dir / "inputs.npz")
+ validate_reference_metadata(record, schema, expected, files, input_hash)
+ # Historical source identity is retained rather than falsely claiming a
+ # new localizer file existed when that complete reference was generated.
+ validate_worker(folder, "ort", args.case_dir / "inputs.npz", record["source_sha256"], files)
+ validate_worker(ir_folder, "ir", args.case_dir / "inputs.npz", record["source_sha256"], files)
+ fp32_mode = producer_fp32_mode(ir_record)
+ report["fp32_mode"] = fp32_mode
+ states = load_arrays(folder / "checkpoints.npz", schema, max_bytes=64 * 1024**2)
+ report.update(files=files, valid_length=valid, input_sha256=input_hash,
+ reference_report_sha256=sha256_file(folder / "report.json"),
+ paired_ir_report_sha256=sha256_file(ir_folder / "report.json"),
+ reference_source_sha256=record["source_sha256"])
+ extract = LayerSlice(model, args.model_dir)
+ for index in layers:
+ hidden, names = extract.describe(index)
+ require(hidden == expected[index]["onnx_name"] and names["residual"] == expected[index + 1]["onnx_name"],
+ "Extracted layer boundary differs from audited graph")
+ if index == 0:
+ names = {"square": "pow_1", "mean": "mean", "epsilon_add": "add", "rsqrt": "rsqrt", **names}
+ state = states["embedding" if index == 0 else f"layer_{index - 1}.output"]
+ pair_feed = {hidden: state, "attention_mask": feed["attention_mask"]}
+ graph = extract.build(hidden, list(names.values()))
+ ir, ort_values, evidence = run_pair(graph, pair_feed, names, out / f"layer-{index:02d}.onnx",
+ fp32_mode=fp32_mode)
+ comparisons = {name: compare_queries(ir[name], ort_values[name], valid,
+ 2 if name in ("rope_q", "rope_k", "attn_probs") else 1) for name in names}
+ report["layers"].append({"layer": index, "same_input": comparisons, **evidence,
+ "probabilities": {"ir": probability_diagnostics(ir["attn_probs"], feed["attention_mask"]),
+ "ort": probability_diagnostics(ort_values["attn_probs"], feed["attention_mask"])}})
+ values_path = out / f"layer-{index:02d}-values.npz"
+ np.savez(values_path, **{"ir_" + k: v for k, v in ir.items()},
+ **{"ort_" + k: v for k, v in ort_values.items()})
+ report["layers"][-1]["values"] = {"file": values_path.name, "bytes": values_path.stat().st_size,
+ "sha256": sha256_file(values_path)}
+ if index == 0:
+ report["primitives"] = local_primitives(extract, ort_values, feed["attention_mask"], valid,
+ out, fp32_mode=fp32_mode)
+ del graph, ir, ort_values
+ gc.collect()
+ require(source_evidence()["source_sha256"] == report["source_sha256"], "Sources changed during diagnosis")
+ report.update(status="COMPLETE", passed=True, diagnostic_complete=True)
+ except KeyboardInterrupt:
+ report.update(interrupted=True, error="KeyboardInterrupt: local diagnosis cancelled")
+ except Exception as exc:
+ report["error"] = f"{type(exc).__name__}: {exc}"
+ report.update(elapsed_seconds=time.perf_counter() - start, process_peak_rss_bytes=process_peak_rss_bytes())
+ write_reports(out, report)
+ return 130 if report.get("interrupted") else (0 if report["diagnostic_complete"] else 1)
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/probes/w3_qwen3_full/resources.py b/probes/w3_qwen3_full/resources.py
new file mode 100644
index 0000000..4821ad9
--- /dev/null
+++ b/probes/w3_qwen3_full/resources.py
@@ -0,0 +1,403 @@
+"""Observe and bound an owned full-model worker; no extra monitor dependency."""
+from __future__ import annotations
+
+import ctypes
+import os
+from pathlib import Path
+import subprocess
+import time
+
+from scripts.run_w2_acceptance import terminate_process_tree as _legacy_terminate
+
+
+class _ResidentMemoryUnavailable(OSError):
+ """Linux can drop VmRSS while exit is still in progress, before zombie state."""
+
+
+_RSS_EXIT_GRACE_SECONDS = 0.2
+_RSS_EXIT_RECHECK_SECONDS = 0.01
+
+
+class _VerifiedProcessHandle:
+ """A handle already verified as a member of the owned Windows Job."""
+ def __init__(self, handle):
+ self.handle = handle
+
+
+class _WindowsJob:
+ """Own descendants before the suspended launcher executes any user code.
+
+ Windows 8+ supports nesting under an existing sandbox Job. No breakaway
+ flags or UI limits are used. Assignment failure is fatal, not a fallback
+ to monitoring only the launcher. Handles are non-inheritable.
+ """
+ def __init__(self):
+ from ctypes import wintypes as w
+ self.k = k = ctypes.WinDLL("kernel32", use_last_error=True)
+ prototypes = {
+ "CreateJobObjectW": ([ctypes.c_void_p, w.LPCWSTR], w.HANDLE),
+ "SetInformationJobObject": ([w.HANDLE, ctypes.c_int, ctypes.c_void_p, w.DWORD], w.BOOL),
+ "AssignProcessToJobObject": ([w.HANDLE, w.HANDLE], w.BOOL),
+ "QueryInformationJobObject": ([w.HANDLE, ctypes.c_int, ctypes.c_void_p, w.DWORD, ctypes.c_void_p], w.BOOL),
+ "IsProcessInJob": ([w.HANDLE, w.HANDLE, ctypes.POINTER(w.BOOL)], w.BOOL),
+ "TerminateJobObject": ([w.HANDLE, w.UINT], w.BOOL),
+ "OpenProcess": ([w.DWORD, w.BOOL, w.DWORD], w.HANDLE),
+ "GetExitCodeProcess": ([w.HANDLE, ctypes.POINTER(w.DWORD)], w.BOOL),
+ "CloseHandle": ([w.HANDLE], w.BOOL),
+ "CreateToolhelp32Snapshot": ([w.DWORD, w.DWORD], w.HANDLE),
+ "Thread32First": ([w.HANDLE, ctypes.c_void_p], w.BOOL),
+ "Thread32Next": ([w.HANDLE, ctypes.c_void_p], w.BOOL),
+ "OpenThread": ([w.DWORD, w.BOOL, w.DWORD], w.HANDLE),
+ "GetProcessIdOfThread": ([w.HANDLE], w.DWORD),
+ "ResumeThread": ([w.HANDLE], w.DWORD),
+ }
+ for name, (args, result) in prototypes.items():
+ getattr(k, name).argtypes, getattr(k, name).restype = args, result
+
+ class Basic(ctypes.Structure):
+ _fields_ = [("process_time", ctypes.c_longlong), ("job_time", ctypes.c_longlong),
+ ("flags", w.DWORD), ("min_working", ctypes.c_size_t),
+ ("max_working", ctypes.c_size_t), ("active", w.DWORD),
+ ("affinity", ctypes.c_size_t), ("priority", w.DWORD), ("scheduling", w.DWORD)]
+ class Limits(ctypes.Structure):
+ _fields_ = [("basic", Basic), ("io", ctypes.c_ulonglong * 6),
+ ("process_memory", ctypes.c_size_t), ("job_memory", ctypes.c_size_t),
+ ("peak_process", ctypes.c_size_t), ("peak_job", ctypes.c_size_t)]
+ self.handle = k.CreateJobObjectW(None, None)
+ if not self.handle:
+ raise ctypes.WinError(ctypes.get_last_error())
+ limits = Limits()
+ limits.basic.flags = 0x2000 # JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
+ if not k.SetInformationJobObject(self.handle, 9, ctypes.byref(limits), ctypes.sizeof(limits)):
+ error = ctypes.WinError(ctypes.get_last_error())
+ self.close()
+ raise error
+
+ def assign_and_resume(self, process):
+ from ctypes import wintypes as w
+ if not self.k.AssignProcessToJobObject(self.handle, int(process._handle)):
+ raise ctypes.WinError(ctypes.get_last_error())
+ class ThreadEntry(ctypes.Structure):
+ _fields_ = [("size", w.DWORD), ("usage", w.DWORD), ("tid", w.DWORD),
+ ("pid", w.DWORD), ("priority", w.LONG), ("delta", w.LONG), ("flags", w.DWORD)]
+ snapshot = self.k.CreateToolhelp32Snapshot(4, 0) # TH32CS_SNAPTHREAD
+ if snapshot == ctypes.c_void_p(-1).value:
+ raise ctypes.WinError(ctypes.get_last_error())
+ tids = []
+ try:
+ entry = ThreadEntry()
+ entry.size = ctypes.sizeof(entry)
+ ok = self.k.Thread32First(snapshot, ctypes.byref(entry))
+ while ok:
+ if entry.pid == process.pid:
+ tids.append(entry.tid)
+ ok = self.k.Thread32Next(snapshot, ctypes.byref(entry))
+ if ctypes.get_last_error() != 18: # ERROR_NO_MORE_FILES
+ raise ctypes.WinError(ctypes.get_last_error())
+ finally:
+ self.k.CloseHandle(snapshot)
+ if len(tids) != 1:
+ raise OSError("Suspended launcher must have exactly one primary thread")
+ thread = self.k.OpenThread(0x0002 | 0x0040, False, tids[0])
+ if not thread:
+ raise ctypes.WinError(ctypes.get_last_error())
+ try:
+ if self.k.GetProcessIdOfThread(thread) != process.pid:
+ raise OSError("Suspended primary thread ownership changed")
+ if self.k.ResumeThread(thread) != 1:
+ raise OSError("Suspended launcher did not have exactly one suspension")
+ finally:
+ self.k.CloseHandle(thread)
+
+ def pids(self):
+ # QueryInformationJobObject includes descendant nested Jobs. Retry if
+ # more processes arrived between sizing and reading the PID list.
+ for capacity in (16, 64, 256, 1024, 4096, 16384):
+ buffer = ctypes.create_string_buffer(8 + capacity * ctypes.sizeof(ctypes.c_size_t))
+ ok = self.k.QueryInformationJobObject(self.handle, 3, buffer, len(buffer), None)
+ assigned, count = (ctypes.c_ulong * 2).from_buffer(buffer)
+ if ok and count == assigned and count <= capacity:
+ return list((ctypes.c_size_t * count).from_buffer(buffer, 8))
+ if not ok and ctypes.get_last_error() != 234: # ERROR_MORE_DATA
+ raise ctypes.WinError(ctypes.get_last_error())
+ raise OSError("Owned worker Job exceeds bounded process enumeration")
+
+ def sample(self):
+ from ctypes import wintypes as w
+ total = {"rss_bytes": 0, "private_commit_bytes": 0, "pids": []}
+ for pid in self.pids():
+ handle = self.k.OpenProcess(0x1010, False, pid)
+ if not handle:
+ if pid not in self.pids():
+ continue # Exited after the Job snapshot.
+ raise ctypes.WinError(ctypes.get_last_error())
+ try:
+ member = w.BOOL()
+ if not self.k.IsProcessInJob(handle, self.handle, ctypes.byref(member)):
+ raise ctypes.WinError(ctypes.get_last_error())
+ if not member.value:
+ # PID reuse cannot substitute an unrelated process: never
+ # inspect or terminate the new process's memory.
+ continue
+ try:
+ value = process_memory(_VerifiedProcessHandle(handle))
+ except OSError:
+ code = w.DWORD()
+ if self.k.GetExitCodeProcess(handle, ctypes.byref(code)) and code.value != 259:
+ continue
+ raise
+ total["rss_bytes"] += value["rss_bytes"]
+ total["private_commit_bytes"] += value["private_commit_bytes"] or 0
+ total["pids"].append(pid)
+ finally:
+ self.k.CloseHandle(handle)
+ return total
+
+ def terminate(self):
+ if not self.k.TerminateJobObject(self.handle, 1):
+ raise ctypes.WinError(ctypes.get_last_error())
+ deadline = time.monotonic() + 5
+ while self.pids():
+ if time.monotonic() > deadline:
+ raise OSError("Owned worker Job still has active descendants after termination")
+ time.sleep(0.01)
+
+ def close(self):
+ if self.handle:
+ handle, self.handle = self.handle, None
+ if not self.k.CloseHandle(handle):
+ raise ctypes.WinError(ctypes.get_last_error())
+
+
+def spawn_owned(command, **kwargs):
+ """Create a worker tree whose ownership precedes all executed child code."""
+ if os.name != "nt":
+ kwargs["start_new_session"] = True
+ process = subprocess.Popen(command, **kwargs)
+ process._scratchv_owned_group = True
+ return process
+ flags = kwargs.pop("creationflags", 0)
+ if flags & (0x01000000 | 0x00000004):
+ raise ValueError("Caller cannot request breakaway or manage suspended owned workers")
+ job, process = _WindowsJob(), None
+ try:
+ process = subprocess.Popen(command, creationflags=flags | 0x00000004, **kwargs)
+ process._scratchv_job = job
+ job.assign_and_resume(process)
+ return process
+ except BaseException as original:
+ # Before ResumeThread the launcher cannot have started descendants;
+ # after assignment closing the Job owns every descendant regardless.
+ try:
+ job.close()
+ except BaseException as cleanup:
+ original.add_note(f"Closing failed worker Job: {cleanup}")
+ try:
+ if process is not None:
+ if process.poll() is None:
+ process.kill()
+ process.wait(timeout=5)
+ except BaseException as cleanup:
+ original.add_note(f"Reaping failed launcher: {cleanup}")
+ raise
+
+
+def terminate_process_tree(process):
+ job = getattr(process, "_scratchv_job", None)
+ if job is not None:
+ try:
+ job.terminate()
+ finally:
+ job.close()
+ process._scratchv_job = None
+ process.wait(timeout=5)
+ else:
+ _legacy_terminate(process)
+
+
+class _PosixGroup:
+ """Linux session/group membership, including children outliving launcher."""
+ def __init__(self, process):
+ self.process = process
+ self.rss_exit_rechecks = 0
+
+ @staticmethod
+ def identity(pid):
+ text = Path(f"/proc/{pid}/stat").read_text(encoding="utf-8")
+ fields = text[text.rindex(")") + 2:].split()
+ return fields[0], int(fields[2]), int(fields[3]), int(fields[19])
+
+ def pids(self):
+ found = []
+ for entry in Path("/proc").iterdir():
+ if not entry.name.isdecimal():
+ continue
+ try:
+ state, group, session, _ = self.identity(int(entry.name))
+ except (FileNotFoundError, ProcessLookupError):
+ continue
+ if group == session == self.process.pid and state not in {"Z", "X", "x"}:
+ found.append(int(entry.name))
+ return found
+
+ def _member_memory(self, pid, before):
+ # exit_mm() can remove VmRSS before the process becomes a zombie or
+ # waitpid observes its exit. Only this specific missing-field case gets
+ # a short grace period; permission errors and malformed RSS fail closed.
+ deadline = None
+ while True:
+ try:
+ value = process_memory(pid)
+ except _ResidentMemoryUnavailable:
+ after = self.identity(pid)
+ if before[1:] != after[1:] or after[0] in {"Z", "X", "x"}:
+ return None
+ if deadline is None:
+ deadline = time.perf_counter() + _RSS_EXIT_GRACE_SECONDS
+ if time.perf_counter() >= deadline:
+ raise # Still the same live process and still unobservable.
+ self.rss_exit_rechecks += 1
+ time.sleep(_RSS_EXIT_RECHECK_SECONDS)
+ continue
+ after = self.identity(pid)
+ if before[1:] != after[1:] or after[0] in {"Z", "X", "x"}:
+ return None
+ return value
+
+ def sample(self):
+ total = {"rss_bytes": 0, "private_commit_bytes": None, "pids": []}
+ for pid in self.pids():
+ try:
+ before = self.identity(pid)
+ if (before[1] != self.process.pid or before[2] != self.process.pid
+ or before[0] in {"Z", "X", "x"}):
+ continue
+ value = self._member_memory(pid, before)
+ if value is None:
+ continue # PID was reused/exited during sampling.
+ except (FileNotFoundError, ProcessLookupError):
+ continue
+ except OSError:
+ try:
+ after = self.identity(pid)
+ except (FileNotFoundError, ProcessLookupError):
+ continue
+ if after[0] in {"Z", "X", "x"}:
+ continue
+ raise
+ total["rss_bytes"] += value["rss_bytes"]
+ total["pids"].append(pid)
+ return total
+
+
+def process_memory(pid):
+ """Current RSS, and private committed bytes on Windows (not virtual size)."""
+ if os.name == "nt":
+ from ctypes import wintypes
+ class Counters(ctypes.Structure):
+ _fields_ = [("cb", wintypes.DWORD), ("faults", wintypes.DWORD),
+ ("peak_rss", ctypes.c_size_t), ("rss", ctypes.c_size_t),
+ ("peak_paged", ctypes.c_size_t), ("paged", ctypes.c_size_t),
+ ("peak_nonpaged", ctypes.c_size_t), ("nonpaged", ctypes.c_size_t),
+ ("pagefile", ctypes.c_size_t), ("peak_pagefile", ctypes.c_size_t),
+ ("private", ctypes.c_size_t)]
+ kernel = ctypes.WinDLL("kernel32", use_last_error=True)
+ kernel.OpenProcess.argtypes = [wintypes.DWORD, wintypes.BOOL, wintypes.DWORD]
+ kernel.OpenProcess.restype = wintypes.HANDLE
+ kernel.CloseHandle.argtypes = [wintypes.HANDLE]
+ psapi = ctypes.WinDLL("psapi", use_last_error=True)
+ psapi.GetProcessMemoryInfo.argtypes = [wintypes.HANDLE, ctypes.POINTER(Counters), wintypes.DWORD]
+ psapi.GetProcessMemoryInfo.restype = wintypes.BOOL
+ borrowed = isinstance(pid, _VerifiedProcessHandle)
+ handle = pid.handle if borrowed else kernel.OpenProcess(0x1010, False, pid)
+ if not handle:
+ raise OSError(ctypes.get_last_error(), "Cannot observe worker memory")
+ try:
+ values = Counters()
+ values.cb = ctypes.sizeof(values)
+ if not psapi.GetProcessMemoryInfo(handle, ctypes.byref(values), values.cb):
+ raise OSError(ctypes.get_last_error(), "Cannot read worker memory")
+ return {"rss_bytes": int(values.rss), "private_commit_bytes": int(values.private)}
+ finally:
+ if not borrowed:
+ kernel.CloseHandle(handle)
+ status = Path(f"/proc/{pid}/status").read_text(encoding="utf-8")
+ rows = dict(line.split(":", 1) for line in status.splitlines() if ":" in line)
+ if "VmRSS" not in rows:
+ raise _ResidentMemoryUnavailable(f"Cannot observe worker {pid} resident memory")
+ try:
+ resident = rows["VmRSS"].split()
+ if len(resident) != 2 or resident[1] != "kB":
+ raise ValueError("VmRSS must use the Linux kB unit")
+ rss = int(resident[0]) * 1024
+ if rss < 0:
+ raise ValueError("VmRSS cannot be negative")
+ except ValueError as exc:
+ raise OSError(f"Cannot observe worker {pid} resident memory") from exc
+ return {"rss_bytes": rss, "private_commit_bytes": None}
+
+
+def wait_bounded(process, *, timeout, max_memory_bytes, row, interval=0.2):
+ """A sampled guard, not an OS hard limit. Stop the owned tree on any failure."""
+ started = time.perf_counter()
+ job = getattr(process, "_scratchv_job", None)
+ group = bool(getattr(process, "_scratchv_owned_group", False))
+ tree = job if job is not None else _PosixGroup(process) if group else None
+ observation = {"samples": 0, "rss_peak_sampled_bytes": 0, "private_commit_peak_sampled_bytes": None,
+ "interval_seconds": interval, "limit_bytes": max_memory_bytes,
+ "ownership": "windows_job" if job else "posix_process_group",
+ "observed_pids": [], "peak_sampled_processes": 0,
+ "scope": ("Owned Windows Job and descendants; summed sampled RSS/private commit, shared pages may be counted per process, not a hard OS quota"
+ if job else "Owned Linux process group/session; summed sampled RSS, shared pages may be counted per process, not a hard OS quota")}
+ row["resource_monitor"] = observation
+ try:
+ if os.name == "nt" and isinstance(process, subprocess.Popen) and job is None:
+ raise ValueError("Windows workers must be created with spawn_owned before execution")
+ while process.poll() is None or (tree is not None and tree.pids()):
+ if time.perf_counter() - started > timeout:
+ raise TimeoutError(f"Full worker exceeded {timeout} seconds")
+ try:
+ values = tree.sample() if tree is not None else process_memory(process.pid)
+ except OSError:
+ if process.poll() is not None and (tree is None or not tree.pids()):
+ break
+ raise
+ observation["samples"] += 1
+ observation["rss_peak_sampled_bytes"] = max(observation["rss_peak_sampled_bytes"], values["rss_bytes"])
+ private = values["private_commit_bytes"]
+ pids = values.get("pids", [process.pid])
+ observation["observed_pids"] = sorted(set(observation["observed_pids"]) | set(pids))
+ observation["peak_sampled_processes"] = max(observation["peak_sampled_processes"], len(pids))
+ if private is not None:
+ observation["private_commit_peak_sampled_bytes"] = max(
+ observation["private_commit_peak_sampled_bytes"] or 0, private)
+ if max(values["rss_bytes"], private or 0) > max_memory_bytes:
+ raise MemoryError(f"Full worker exceeded sampled memory limit {max_memory_bytes} bytes")
+ if process.poll() is not None:
+ time.sleep(interval) # Job children can outlive their launcher.
+ else:
+ try:
+ process.wait(timeout=interval)
+ except subprocess.TimeoutExpired:
+ pass
+ return process.wait(timeout=5)
+ except BaseException:
+ if process.poll() is None or job is not None or group:
+ try:
+ terminate_process_tree(process)
+ except (OSError, subprocess.SubprocessError) as cleanup:
+ # Preserve timeout/interruption rather than replacing its
+ # cause with any secondary cleanup diagnostic.
+ row["cleanup_error"] = f"{type(cleanup).__name__}: {cleanup}"
+ raise
+ finally:
+ if isinstance(tree, _PosixGroup):
+ observation["rss_exit_rechecks"] = tree.rss_exit_rechecks
+ if getattr(process, "_scratchv_job", None) is not None:
+ try:
+ job.close()
+ except OSError as cleanup:
+ row["cleanup_error"] = f"{type(cleanup).__name__}: {cleanup}"
+ process._scratchv_job = None
+ row["returncode"] = process.poll()
+ row["elapsed_seconds"] = time.perf_counter() - started
diff --git a/probes/w3_qwen3_full/run.py b/probes/w3_qwen3_full/run.py
new file mode 100644
index 0000000..8695e80
--- /dev/null
+++ b/probes/w3_qwen3_full/run.py
@@ -0,0 +1,295 @@
+"""Full pinned Qwen3 IR/ORT comparison with isolated, resource-bounded workers."""
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+from pathlib import Path
+import subprocess
+import sys
+import time
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+ sys.path.insert(0, str(ROOT))
+
+import numpy as np
+from probes.w1_qwen3_export.run import verify_files
+from probes.w3_common import new_output_dir, sha256_file, source_evidence, write_reports
+from probes.w3_layer_diff.run import load_schema, load_arrays
+from probes.w3_qwen3_full.cases import CASE_NAMES, input_cases
+from probes.w3_qwen3_full.comparison import ATOL, compare_tensor, compare_positions
+from probes.w3_qwen3_full.resources import spawn_owned, wait_bounded
+
+CHECKPOINTS = ("embedding", *(f"layer_{i}.output" for i in range(28)), "final_norm")
+LOGIT_SHAPE = (1, 256, 151936)
+
+
+def require(condition, message):
+ if not condition:
+ raise ValueError(message)
+
+
+def checked_artifact(folder, descriptor, expected_name):
+ require(isinstance(descriptor, dict), f"Missing artifact {expected_name}")
+ require(descriptor.get("path") == expected_name, f"Unexpected artifact path: {expected_name}")
+ path = folder / expected_name
+ require(path.is_file() and path.resolve().parent == folder.resolve(), f"Missing/external artifact: {expected_name}")
+ require(path.stat().st_size == descriptor.get("bytes") and sha256_file(path) == descriptor.get("sha256"),
+ f"Altered artifact: {expected_name}")
+ return path
+
+
+def load_logits(path):
+ value = np.load(path, mmap_mode="r", allow_pickle=False, max_header_size=10000)
+ require(value.shape == LOGIT_SHAPE and value.dtype == np.float32, "Wrong full logits shape/dtype")
+ return value
+
+
+def saved_arithmetic_profile(mode, recorded):
+ """Validate saved arithmetic without guessing it from the auditing host CPU."""
+ require(isinstance(recorded, dict), "Missing saved FP32 arithmetic profile")
+ if mode == "reference":
+ from scratchv.verification.fp32_reference import profile
+ strategy = recorded.get("cpu_strategy")
+ require(strategy in ("avx2-fma3", "avx512"), "Unsupported saved FP32 CPU profile")
+ canonical = profile(cpu_strategy=strategy)
+ else:
+ require(mode == "native", "Unsupported saved FP32 arithmetic profile")
+ canonical = {"name": "numpy-native"}
+ require(recorded == canonical and all(type(recorded[key]) is type(value)
+ for key, value in canonical.items()), "Noncanonical saved FP32 arithmetic profile")
+ return canonical
+
+
+def validate_worker(folder, backend, input_path, sources, assets, *, expected_fp32_mode=None,
+ expected_fp32_profile=None):
+ require(expected_fp32_profile is None or expected_fp32_mode is not None,
+ "Saved FP32 profile requires an explicit mode")
+ for name in ("report.json", "report.md", "report.html"):
+ require((folder/name).is_file(), f"Missing worker {name}")
+ report = json.loads((folder/"report.json").read_text(encoding="utf-8"))
+ require(report.get("gate") == "numeric:w3-full-worker" and report.get("schema_version") == 1,
+ "Wrong worker identity")
+ require(report.get("backend") == backend and report.get("optimization_level") == "none", "Wrong backend")
+ require(report.get("passed") is True and report.get("status") == "PASS", "Worker not PASS")
+ require(report.get("full_model_executed") is True and report.get("full_ir_executed") is (backend == "ir"),
+ "Full model was not actually executed")
+ require(report.get("w3_exit_accepted") is False, "A worker cannot accept the team milestone")
+ require(report.get("source_sha256") == sources, "Worker production sources differ")
+ require(report.get("files") == assets, "Worker assets differ from fixed model")
+ require(report.get("input", {}).get("sha256") == sha256_file(input_path), "Worker input differs")
+ require(type(report.get("process_peak_rss_bytes")) is int and report["process_peak_rss_bytes"] > 0,
+ "Missing measured peak RSS")
+ timings = report.get("stages_seconds")
+ require(isinstance(timings, dict), "Missing worker execution timings")
+ for mode in ("ordinary", "diagnostic"):
+ name = f"{backend}_{mode}_execute"
+ duration = timings.get(name)
+ require(type(duration) in (int, float) and math.isfinite(duration) and duration > 0,
+ f"Missing/invalid worker execution timing: {name}")
+ if backend == "ort":
+ runtime = report.get("ort")
+ expected_runtime = {"provider": "CPUExecutionProvider", "graph_optimization": "disabled",
+ "intra_op_threads": 1, "inter_op_threads": 1, "cpu_mem_arena": False}
+ require(isinstance(runtime, dict) and all(type(runtime.get(key)) is type(value)
+ and runtime.get(key) == value for key, value in expected_runtime.items()),
+ "Worker ORT execution profile differs")
+ comparison = report.get("ordinary_diagnostic", {})
+ require(comparison.get("passed") is True and comparison.get("comparison") == "exact"
+ and comparison.get("max_abs") == 0.0, "Diagnostic execution changed logits")
+ names = {"logits": "logits.npy", "diagnostic_logits": "diagnostic_logits.npy",
+ "checkpoints": "checkpoints.npz", "checkpoint_schema": "checkpoint_schema.json"}
+ artifacts = report.get("artifacts", {})
+ for key, filename in names.items():
+ checked_artifact(folder, artifacts.get(key), filename)
+ schema = load_schema(folder/"checkpoint_schema.json")
+ require(tuple(x["name"] for x in schema) == CHECKPOINTS, "Incomplete/out-of-order full checkpoints")
+ require(all(x["shape"] == [1, 256, 1024] and x["dtype"] == "float32" and x.get("sequence_axis") == 1
+ for x in schema), "Wrong full checkpoint contract")
+ require(report.get("checkpoints") == schema, "Worker report/schema disagree")
+ ordinary, diagnostic = load_logits(folder/"logits.npy"), load_logits(folder/"diagnostic_logits.npy")
+ exact = compare_tensor(ordinary, diagnostic)
+ require(exact["passed"] and exact["max_abs"] == 0, "Ordinary/diagnostic arrays actually differ")
+ del ordinary, diagnostic
+ if backend == "ir":
+ ir = report.get("ir")
+ require(isinstance(ir, dict), "Missing IR execution profile")
+ instruction_count = ir.get("instruction_count")
+ require(type(instruction_count) is int and instruction_count > 0,
+ "Missing/invalid IR instruction count")
+ if expected_fp32_mode is not None:
+ from scratchv.verification.fp32_reference import profile
+ require(report.get("fp32_mode") == expected_fp32_mode,
+ "Worker FP32 execution mode differs")
+ # Live runs require the selected local strategy. Saved-array audits
+ # can explicitly supply a known producer strategy from another CPU;
+ # the complete canonical profile still has to match.
+ expected_profile = (saved_arithmetic_profile(expected_fp32_mode, expected_fp32_profile)
+ if expected_fp32_profile is not None else
+ profile() if expected_fp32_mode == "reference" else {"name": "numpy-native"})
+ require(ir.get("fp32_mode") == expected_fp32_mode
+ and ir.get("fp32_profile") == expected_profile,
+ "Worker FP32 arithmetic profile differs")
+ for mode in ("ordinary", "diagnostic"):
+ execution = report.get("executions", {}).get(mode, {})
+ # The pinned full graph is one straight-line block, including RETURN;
+ # every declared instruction must execute once in both runs.
+ require(type(execution.get("executed_steps")) is int
+ and execution["executed_steps"] == instruction_count,
+ "IR execution steps do not cover the declared instruction count")
+ memory = execution.get("memory_stats", {})
+ require(type(memory.get("peak_numpy_storage_bytes")) is int and memory["peak_numpy_storage_bytes"] > 0,
+ "Missing IR storage measurement")
+ return report
+
+
+def compare_case(folder, valid_length):
+ rows = []
+ for filename in ("logits.npy", "diagnostic_logits.npy"):
+ actual, reference = load_logits(folder/"ir"/filename), load_logits(folder/"ort"/filename)
+ rows.append({"name": filename, **compare_positions(actual, reference, valid_length)})
+ del actual, reference
+ schema = load_schema(folder/"ir/checkpoint_schema.json")
+ require(schema == load_schema(folder/"ort/checkpoint_schema.json"), "IR/ORT checkpoint schema differs")
+ actual = load_arrays(folder/"ir/checkpoints.npz", schema, max_bytes=64*1024**2)
+ reference = load_arrays(folder/"ort/checkpoints.npz", schema, max_bytes=64*1024**2)
+ checkpoints = [{"name": entry["name"], **compare_positions(actual[entry["name"]], reference[entry["name"]], valid_length)}
+ for entry in schema]
+ all_rows = checkpoints + rows
+ worst = max((r for r in all_rows if r["max_abs"] is not None), key=lambda x: x["max_abs"], default=None)
+ return {"passed": all(r["passed"] for r in rows), "logits": rows, "checkpoints": checkpoints,
+ "max_logits_abs": max(r["max_abs"] for r in rows),
+ "checkpoint_threshold_scope": "Diagnostic location only: large intermediate activations can exceed 1e-4 in one FP32 ULP; acceptance applies to complete output logits",
+ "first_divergence": next((r for r in all_rows if not r["passed"]), None),
+ "worst": worst, "atol": ATOL, "rtol": 0}
+
+
+def invariants(out, successful):
+ rows = []
+ for name, reference, prefix in (("changed_future", "full_seed_0", 64), ("changed_padding", "short_17", 17)):
+ if name not in successful or reference not in successful:
+ continue
+ for backend in ("ort", "ir"):
+ a = load_logits(out/name/backend/"logits.npy")
+ b = load_logits(out/reference/backend/"logits.npy")
+ rows.append({"case": name, "reference": reference, "prefix": prefix, "backend": backend,
+ **compare_tensor(a[:, :prefix], b[:, :prefix])})
+ del a, b
+ return rows
+
+
+def run_worker(args, folder, backend, input_path, row=None):
+ command = [str(Path(args.python).resolve()), "-B", "-X", "utf8",
+ "probes/w3_qwen3_full/worker.py", "--backend", backend,
+ "--model-dir", str(args.model_dir.resolve()), "--input-file", str(input_path),
+ "--output-dir", str(folder/backend), "--optimization-level", "none",
+ "--fp32-mode", getattr(args, "fp32_mode", "reference")]
+ row = {} if row is None else row
+ row.update(backend=backend, passed=False, command=command)
+ env = dict(os.environ, PYTHONIOENCODING="utf-8", OMP_NUM_THREADS="1", OPENBLAS_NUM_THREADS="1", MKL_NUM_THREADS="1")
+ options = {"creationflags": subprocess.CREATE_NEW_PROCESS_GROUP} if os.name == "nt" else {"start_new_session": True}
+ with (folder/(backend+".log")).open("w", encoding="utf-8") as stream:
+ process = spawn_owned(command, cwd=ROOT, env=env, stdout=stream, stderr=subprocess.STDOUT, **options)
+ try:
+ row["returncode"] = wait_bounded(process, timeout=args.worker_timeout,
+ max_memory_bytes=int(args.max_worker_memory_gib*1024**3), row=row)
+ require(row["returncode"] == 0, f"{backend} worker exited {row['returncode']}")
+ row["passed"] = True
+ except Exception as exc:
+ row["error"] = f"{type(exc).__name__}: {exc}"
+ for filename in ("report.json", "progress.json"):
+ try:
+ child = json.loads((folder/backend/filename).read_text(encoding="utf-8"))
+ row["child_stage"] = child.get("stage")
+ row["child_error"] = child.get("error")
+ break
+ except (OSError, ValueError):
+ pass
+ return row
+
+
+def main(argv=None):
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument("--model-dir", required=True, type=Path)
+ parser.add_argument("--output-dir", required=True, type=Path)
+ parser.add_argument("--python", default=sys.executable)
+ parser.add_argument("--worker-timeout", type=float, default=1800)
+ parser.add_argument("--max-worker-memory-gib", type=float, default=10)
+ parser.add_argument("--case", action="append", choices=CASE_NAMES)
+ parser.add_argument("--fp32-mode", choices=("native", "reference"), default="reference",
+ help="Explicit IR FP32 arithmetic policy; native reproduces the original NumPy baseline")
+ args = parser.parse_args(argv)
+ if any(not math.isfinite(v) or v <= 0 for v in (args.worker_timeout, args.max_worker_memory_gib)):
+ parser.error("Resource limits must be finite and positive")
+ if args.case and len(args.case) != len(set(args.case)):
+ parser.error("Duplicate case selection")
+ out = new_output_dir(args.output_dir)
+ selected = set(args.case or CASE_NAMES)
+ start = time.perf_counter()
+ report = {"gate": "numeric:ir-full-qwen3", "status": "FAIL", "passed": False,
+ "optimization_level": "none", "atol": ATOL, "rtol": 0,
+ "fp32_mode": args.fp32_mode,
+ "full_ir_executed": False, "w3_exit_accepted": False,
+ "scope": "Pinned 28-layer FP32 L256 IR vs ORT; strict 1e-4 on all ordinary/diagnostic logits including padding; 30 checkpoints localize errors",
+ "cases": [], "invariants": [], "required_cases": list(CASE_NAMES),
+ "selected_cases": [x for x in CASE_NAMES if x in selected], "stage": "sources"}
+ try:
+ report.update(source_evidence())
+ report["stage"] = "assets"
+ assets = verify_files(args.model_dir)
+ report["files"] = assets
+ successful = set()
+ for name, valid, feed in input_cases():
+ if name not in selected:
+ continue
+ report["stage"] = name
+ folder = out/name
+ folder.mkdir()
+ input_path = folder/"inputs.npz"
+ np.savez(input_path, **feed)
+ row = {"name": name, "valid_length": valid, "passed": False, "workers": [],
+ "input_sha256": sha256_file(input_path)}
+ report["cases"].append(row)
+ for backend in ("ort", "ir"):
+ worker = {"backend": backend, "passed": False}
+ row["workers"].append(worker)
+ run_worker(args, folder, backend, input_path, worker)
+ if worker["passed"]:
+ try:
+ evidence = validate_worker(folder/backend, backend, input_path,
+ report["source_sha256"], assets,
+ expected_fp32_mode=args.fp32_mode)
+ require(evidence["input"]["valid_length"] == valid, "Worker valid length differs")
+ worker.update(report_sha256=sha256_file(folder/backend/"report.json"),
+ process_peak_rss_bytes=evidence["process_peak_rss_bytes"],
+ stages_seconds=evidence["stages_seconds"])
+ if backend == "ir":
+ report["full_ir_executed"] = True
+ except Exception as exc:
+ worker.update(passed=False, error=f"{type(exc).__name__}: {exc}")
+ print(f"[{name}/{backend}] {'EXECUTED' if worker['passed'] else 'FAIL'}", flush=True)
+ if all(w["passed"] for w in row["workers"]):
+ row["comparison"] = compare_case(folder, valid)
+ row["passed"] = row["comparison"]["passed"]
+ successful.add(name)
+ print(f"[{name}/compare] {'PASS' if row['passed'] else 'FAIL'}; logits_max_abs={row['comparison']['max_logits_abs']}; diagnostic_max_abs={row['comparison']['worst']['max_abs']}", flush=True)
+ write_reports(out, report)
+ report["invariants"] = invariants(out, successful)
+ require(source_evidence()["source_sha256"] == report["source_sha256"], "Sources changed during full execution")
+ coverage = set(selected) == set(CASE_NAMES) and len(report["cases"]) == len(CASE_NAMES) and len(report["invariants"]) == 4
+ numeric = len(report["cases"]) == len(selected) and all(row["passed"] for row in report["cases"]) and all(x["passed"] for x in report["invariants"])
+ report.update(coverage_complete=coverage, selected_numerical_passed=numeric,
+ passed=coverage and numeric, status="PASS" if coverage and numeric else ("PARTIAL" if numeric else "FAIL"), stage="complete")
+ except KeyboardInterrupt:
+ report.update(status="FAIL", passed=False, interrupted=True, error="KeyboardInterrupt: full verification cancelled")
+ except Exception as exc:
+ report.update(status="FAIL", passed=False, error=f"{type(exc).__name__}: {exc}")
+ report["elapsed_seconds"] = time.perf_counter() - start
+ write_reports(out, report)
+ return 130 if report.get("interrupted") else (0 if report["passed"] else (2 if report["status"] == "PARTIAL" else 1))
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/probes/w3_qwen3_full/worker.py b/probes/w3_qwen3_full/worker.py
new file mode 100644
index 0000000..e86e297
--- /dev/null
+++ b/probes/w3_qwen3_full/worker.py
@@ -0,0 +1,327 @@
+"""Execute one complete pinned Qwen3 backend in an isolated process.
+
+A worker PASS proves execution and ordinary/diagnostic consistency only. The
+parent compares independent IR and ORT results; no worker accepts W3 itself.
+"""
+from __future__ import annotations
+
+import argparse
+import gc
+import json
+import os
+from pathlib import Path
+import sys
+import tempfile
+import time
+import traceback
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+ sys.path.insert(0, str(ROOT))
+
+import numpy as np
+import onnx
+
+from probes.w1_qwen3_export import run as assets
+from probes.w2_qwen3_parse.validation import audit_graph_structure
+from probes.w3_common import (atomic_text, new_output_dir, process_peak_rss_bytes,
+ sha256_file, source_evidence, write_reports)
+from probes.w3_layer_diff.run import load_arrays
+
+GATE = "numeric:w3-full-worker"
+INPUT_SCHEMA = [
+ {"name": "input_ids", "shape": [1, 256], "dtype": "int64"},
+ {"name": "attention_mask", "shape": [1, 1, 256, 256], "dtype": "float32"},
+]
+LOGITS_SHAPE = (1, 256, 151936)
+
+
+def load_inputs(path):
+ """Validate the pinned export's finite additive, right-padded causal mask."""
+ feed = load_arrays(Path(path), INPUT_SCHEMA, max_bytes=1024 * 1024)
+ ids, mask = feed["input_ids"], feed["attention_mask"]
+ if np.any(ids < 0) or np.any(ids >= 151936):
+ raise ValueError("input_ids must be in the fixed Qwen3 vocabulary")
+ length = int(np.count_nonzero(mask[0, 0, -1] == 0))
+ if not 1 <= length <= 256:
+ raise ValueError("attention_mask must expose at least one valid token")
+ query, key = np.arange(256)[:, None], np.arange(256)[None, :]
+ wanted = np.where((key <= query) & (key < length), np.float32(0),
+ np.finfo(np.float32).min).reshape(1, 1, 256, 256)
+ if not np.array_equal(mask, wanted):
+ raise ValueError("attention_mask is not the pinned causal/right-padding additive mask")
+ return feed, length
+
+
+def checkpoint_schema(model, audit=None):
+ """Locate checkpoints from audited dataflow, never layer-name substrings."""
+ audit = audit_graph_structure(model) if audit is None else audit
+ layers = audit.get("layers", [])
+ if (audit.get("passed") is not True or audit.get("layer_count") != 28
+ or [row.get("layer") for row in layers] != list(range(28))):
+ raise ValueError("Checkpoint coverage requires the complete ordered 28-layer audit")
+ by_name = {}
+ for node in model.graph.node:
+ by_name.setdefault(node.name, []).append(node)
+
+ def output(name):
+ nodes = by_name.get(name, [])
+ if len(nodes) != 1 or len(nodes[0].output) != 1:
+ raise ValueError(f"Checkpoint node must be unique with one output: {name}")
+ return nodes[0].output[0]
+
+ rows = [{"name": "embedding", "onnx_name": output(audit["embedding"]),
+ "checkpoint": "embedding"}]
+ rows += [{"name": f"layer_{row['layer']}.output", "onnx_name": row["output"],
+ "layer": row["layer"], "checkpoint": "output"} for row in layers]
+ rows += [{"name": "final_norm", "onnx_name": output(audit["final_norm"]),
+ "checkpoint": "final_norm"}]
+ definitions = {name for node in model.graph.node for name in node.output}
+ names = [row["onnx_name"] for row in rows]
+ if len(names) != len(set(names)) or not set(names) <= definitions:
+ raise ValueError("Checkpoint tensors must be unique graph-produced values")
+ for row in rows:
+ row.update(shape=[1, 256, 1024], dtype="float32", sequence_axis=1)
+ return rows
+
+
+def checked_tensor(array, shape, name):
+ if not isinstance(array, np.ndarray) or array.shape != tuple(shape) or array.dtype != np.float32:
+ raise ValueError(f"{name}: expected FP32 {tuple(shape)}, got "
+ f"{getattr(array, 'shape', None)}/{getattr(array, 'dtype', None)}")
+ for start in range(0, shape[1], 8):
+ if not np.isfinite(array[:, start:start + 8]).all():
+ raise ValueError(f"{name}: nonfinite output")
+ return array
+
+
+def save_array(path, value, *, archive=False):
+ """Atomically persist numeric arrays; leave existing evidence untouched."""
+ path = Path(path)
+ if path.exists():
+ raise FileExistsError(path)
+ fd, temporary = tempfile.mkstemp(prefix="." + path.name, suffix=".tmp", dir=path.parent)
+ try:
+ with os.fdopen(fd, "wb") as stream:
+ if archive:
+ np.savez(stream, **value)
+ else:
+ np.save(stream, value, allow_pickle=False)
+ stream.flush()
+ os.fsync(stream.fileno())
+ os.replace(temporary, path)
+ finally:
+ if os.path.exists(temporary):
+ os.unlink(temporary)
+
+
+def evidence(path, *, array=None):
+ path = Path(path)
+ record = {"path": path.name, "sha256": sha256_file(path), "bytes": path.stat().st_size}
+ if array is not None:
+ record.update(shape=list(array.shape), dtype=str(array.dtype), all_finite=True)
+ return record
+
+
+def save_logits(out, name, array, report):
+ checked_tensor(array, LOGITS_SHAPE, name)
+ path = out / f"{name}.npy"
+ save_array(path, array)
+ report["artifacts"][name] = evidence(path, array=array)
+
+
+def save_checkpoints(out, arrays, schema, report):
+ if set(arrays) != {row["name"] for row in schema} or len(arrays) != 30:
+ raise ValueError("Diagnostic output omitted/duplicated a required checkpoint")
+ for row in schema:
+ checked_tensor(arrays[row["name"]], row["shape"], row["name"])
+ path = out / "checkpoints.npz"
+ save_array(path, arrays, archive=True)
+ report["artifacts"]["checkpoints"] = evidence(path)
+
+
+def exact_ordinary_diagnostic(out):
+ ordinary = np.load(out / "logits.npy", mmap_mode="r", allow_pickle=False)
+ diagnostic = np.load(out / "diagnostic_logits.npy", mmap_mode="r", allow_pickle=False)
+ checked_tensor(ordinary, LOGITS_SHAPE, "ordinary logits")
+ checked_tensor(diagnostic, LOGITS_SHAPE, "diagnostic logits")
+ for start in range(0, LOGITS_SHAPE[1], 8):
+ if not np.array_equal(ordinary[:, start:start + 8], diagnostic[:, start:start + 8]):
+ raise ValueError(f"Ordinary and diagnostic logits differ at sequence chunk {start}")
+ return {"passed": True, "comparison": "exact", "max_abs": 0.0,
+ "positions_compared": 256, "elements_compared": int(np.prod(LOGITS_SHAPE))}
+
+
+def diagnostic_graph(model, schema, model_dir, out):
+ """Add graph outputs without re-exporting or copying the external weights."""
+ model = onnx.ModelProto.FromString(model.SerializeToString())
+ for row in schema:
+ model.graph.output.append(onnx.helper.make_tensor_value_info(
+ row["onnx_name"], onnx.TensorProto.FLOAT, row["shape"]))
+ # External references are now relative to the derived metadata's directory.
+ # Source manifest verification already bounded and validated these files.
+ for tensor in assets.tensors(model):
+ if tensor.data_location == onnx.TensorProto.EXTERNAL:
+ for entry in tensor.external_data:
+ if entry.key == "location":
+ original = (model_dir / entry.value).resolve()
+ if not original.is_relative_to(model_dir.resolve()) or not original.is_file():
+ raise ValueError("Invalid external tensor location in diagnostic model")
+ entry.value = os.path.relpath(original, out).replace("\\", "/")
+ target = out / "diagnostic.onnx"
+ target.write_bytes(model.SerializeToString())
+ return target
+
+
+def execute_ort(model_dir, out, feed, schema, model, report, stage):
+ import onnxruntime as ort
+
+ def session(path):
+ options = ort.SessionOptions()
+ options.intra_op_num_threads = 1
+ options.inter_op_num_threads = 1
+ options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_DISABLE_ALL
+ options.enable_cpu_mem_arena = False
+ return ort.InferenceSession(str(path), options, providers=["CPUExecutionProvider"])
+
+ runtime = stage("ort_ordinary_session", lambda: session(model_dir / "model.onnx"))
+ logits = stage("ort_ordinary_execute", lambda: runtime.run(["logits"], feed)[0])
+ stage("ordinary_save", lambda: save_logits(out, "logits", logits, report))
+ del logits, runtime
+ gc.collect()
+ diagnostic = stage("diagnostic_graph", lambda: diagnostic_graph(model, schema, model_dir, out))
+ report["artifacts"]["diagnostic_model"] = evidence(diagnostic)
+ runtime = stage("ort_diagnostic_session", lambda: session(diagnostic))
+ names = ["logits", *[row["onnx_name"] for row in schema]]
+ results = stage("ort_diagnostic_execute", lambda: runtime.run(names, feed))
+ if len(results) != 31:
+ raise ValueError("ORT diagnostic did not return all 31 outputs")
+ stage("diagnostic_save", lambda: save_logits(out, "diagnostic_logits", results[0], report))
+ arrays = {row["name"]: value for row, value in zip(schema, results[1:])}
+ stage("checkpoints_save", lambda: save_checkpoints(out, arrays, schema, report))
+ report["ort"] = {"provider": "CPUExecutionProvider", "graph_optimization": "disabled",
+ "intra_op_threads": 1, "inter_op_threads": 1, "cpu_mem_arena": False}
+
+
+def execute_ir(model_dir, out, feed, schema, model, report, stage):
+ from scratchv.frontend.onnx_parser import ONNXParser
+ from scratchv.verification.ir_interpreter import IRInterpreter
+ from scratchv.verification.fp32_reference import profile
+
+ fp32_mode = report.get("fp32_mode", "reference")
+
+ parser = ONNXParser()
+ program = stage("scratchv_parse", lambda: parser.parse(str(model_dir / "model.onnx"),
+ mmap_external_data=True))
+ for value in parser.initializers.values():
+ value.setflags(write=False)
+ mapping = {}
+ for row in schema:
+ value = parser._value_map.get(row["onnx_name"])
+ if value is None or value.name in mapping:
+ raise ValueError(f"Missing/non-unique IR checkpoint mapping: {row['name']}")
+ mapping[value.name] = row
+ report["ir_checkpoint_bindings"] = {name: row["name"] for name, row in mapping.items()}
+ report["executions"] = {}
+ for kind in ("ordinary", "diagnostic"):
+ arrays = {}
+
+ def observe(name, value):
+ if name in mapping:
+ row = mapping[name]
+ if row["name"] in arrays:
+ raise ValueError(f"Checkpoint executed multiple times: {row['name']}")
+ arrays[row["name"]] = checked_tensor(value, row["shape"], row["name"]).copy()
+
+ result = stage(f"ir_{kind}_execute", lambda: IRInterpreter(program).run(
+ feed, initializers=parser.initializers, collect_memory_stats=True,
+ memory_mode="last_use", copy_initializers=False,
+ fp32_mode=fp32_mode,
+ observer=observe if kind == "diagnostic" else None))
+ report["executions"][kind] = {"executed_steps": result.executed_steps,
+ "memory_stats": result.memory_stats}
+ label = "logits" if kind == "ordinary" else "diagnostic_logits"
+ stage(f"{kind}_save", lambda: save_logits(out, label, result.return_value, report))
+ if kind == "diagnostic":
+ stage("checkpoints_save", lambda: save_checkpoints(out, arrays, schema, report))
+ del result, arrays
+ gc.collect()
+ report["ir"] = {"optimization_level": "none", "memory_mode": "last_use",
+ "fp32_mode": fp32_mode,
+ "fp32_profile": profile() if fp32_mode == "reference" else {"name": "numpy-native"},
+ "copy_initializers": False, "mmap_external_data": True,
+ "instruction_count": sum(len(b.instructions) for f in program.functions for b in f.blocks)}
+
+
+def main(argv=None):
+ cli = argparse.ArgumentParser(description=__doc__)
+ cli.add_argument("--backend", choices=("ort", "ir"), required=True)
+ cli.add_argument("--model-dir", type=Path, required=True)
+ cli.add_argument("--input-file", type=Path, required=True)
+ cli.add_argument("--output-dir", type=Path, required=True)
+ cli.add_argument("--optimization-level", choices=("none",), default="none")
+ cli.add_argument("--fp32-mode", choices=("native", "reference"), default="reference")
+ args = cli.parse_args(argv)
+ out = new_output_dir(args.output_dir)
+ started = time.perf_counter()
+ report = {"schema_version": 1, "gate": GATE, "backend": args.backend,
+ "optimization_level": args.optimization_level, "status": "FAIL", "passed": False,
+ "fp32_mode": args.fp32_mode if args.backend == "ir" else None,
+ "stage": "initialization", "stages_seconds": {}, "artifacts": {},
+ "full_ir_executed": False, "full_model_executed": False, "w3_exit_accepted": False,
+ "scope": "Complete single-backend execution and exact ordinary/diagnostic consistency. "
+ "Independent IR/ORT comparison belongs to the parent gate; not W3 team acceptance.",
+ "model_id": assets.MANIFEST["model_id"], "revision": assets.MANIFEST["revision"]}
+
+ def stage(name, operation):
+ report["stage"] = name
+ atomic_text(out / "progress.json", json.dumps({"stage": name,
+ "elapsed_seconds": time.perf_counter() - started,
+ "process_peak_rss_bytes": process_peak_rss_bytes()}) + "\n")
+ print(f"[{args.backend}] {name}", flush=True)
+ begin = time.perf_counter()
+ try:
+ return operation()
+ finally:
+ report["stages_seconds"][name] = time.perf_counter() - begin
+
+ try:
+ report.update(stage("source_evidence", source_evidence))
+ model_dir = args.model_dir.resolve()
+ report["model_dir"] = str(model_dir)
+ report["files"] = stage("asset_hashes", lambda: assets.verify_files(model_dir))
+ report["onnx_contract"] = stage("onnx_contract", lambda: assets.inspect_model(model_dir, report["files"]))
+ feed, length = stage("input_validation", lambda: load_inputs(args.input_file))
+ report["input"] = evidence(args.input_file)
+ report["input"].update(path=str(args.input_file.resolve()), valid_length=length)
+ model = stage("metadata_load", lambda: onnx.load(str(model_dir / "model.onnx"), load_external_data=False))
+ report["graph_audit"] = stage("graph_audit", lambda: audit_graph_structure(model))
+ schema = stage("checkpoint_selection", lambda: checkpoint_schema(model, report["graph_audit"]))
+ report["checkpoints"] = schema
+ atomic_text(out / "checkpoint_schema.json", json.dumps({"version": 1, "checkpoints": schema}, indent=2) + "\n")
+ report["artifacts"]["checkpoint_schema"] = evidence(out / "checkpoint_schema.json")
+ executor = execute_ort if args.backend == "ort" else execute_ir
+ executor(model_dir, out, feed, schema, model, report, stage)
+ report["full_model_executed"] = True
+ report["full_ir_executed"] = args.backend == "ir"
+ report["ordinary_diagnostic"] = stage("ordinary_diagnostic_consistency", lambda: exact_ordinary_diagnostic(out))
+ final_sources = stage("source_recheck", source_evidence)["source_sha256"]
+ if final_sources != report["source_sha256"]:
+ raise ValueError("Production sources changed during numerical execution")
+ report.update(passed=True, status="PASS", stage="complete")
+ except BaseException as exc:
+ report["error"] = f"{type(exc).__name__}: {exc}"
+ traceback.print_exc()
+ if isinstance(exc, KeyboardInterrupt):
+ report["interrupted"] = True
+ report.update(elapsed_seconds=time.perf_counter() - started,
+ process_peak_rss_bytes=process_peak_rss_bytes(),
+ peak_scope="Lifetime resident high-water mark of this single backend worker, "
+ "including both ordinary and diagnostic runs; not isolated kernel memory")
+ write_reports(out, report)
+ print(f"[{GATE}] {report['status']}; {out / 'report.json'}", flush=True)
+ return 130 if report.get("interrupted") else 0 if report["passed"] else 1
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/probes/w3_qwen3_medium/README.md b/probes/w3_qwen3_medium/README.md
new file mode 100644
index 0000000..c06072d
--- /dev/null
+++ b/probes/w3_qwen3_medium/README.md
@@ -0,0 +1,110 @@
+# W3 medium Qwen3 host numerical probe
+
+Reproduction targets **Ubuntu 24.04 x86_64, Bash and Python 3.12**. Complete the [Linux environment and asset setup](../../docs/llm-deploy-v1.0/LINUX_REPRODUCTION.md) first. Run commands from the repository root in the same Bash session; the setup exports `SCRATCHV_PYTHON`, `SCRATCHV_CC` and `SCRATCHV_QEMU`.
+
+This is a fixed candidate for the W3 six-layer experiment. The plan fixes six
+layers; the dimensions below are the candidate chosen for this experiment,
+not a claim that the plan mandated a specific hidden or feed-forward width.
+
+| Property | W2 small default | W3 medium candidate |
+|---|---:|---:|
+| Decoder layers | 2 | 6 |
+| Hidden width | 32 | 64 |
+| FFN intermediate width | 96 | 192 |
+| Query heads / KV heads | 4 / 2 | 4 / 2 |
+| Head dimension | 16 | 16 |
+| Vocabulary / sequence length | 128 / 256 | 128 / 256 |
+| Batch / precision | 1 / FP32 | 1 / FP32 |
+| Named checkpoints | 29 | 81 |
+
+Weights are fixed-seed random initialization of the official
+`transformers==4.51.3` `Qwen3ForCausalLM`. No weights or tokenizer are downloaded.
+This gate measures architecture and numerical semantics. It does not establish
+pretrained language quality, full Qwen3-0.6B execution, or RISC-V/QEMU correctness.
+Attention is eager, positions are `0..255`, embeddings and LM head are tied, and
+there is no KV cache. All numerical backends use one CPU thread.
+
+## Run
+
+Use Python 3.12 and the existing pinned
+`requirements/qwen3-small-probe.txt` environment. From the W3 worktree:
+
+```bash
+set -euo pipefail
+export OMP_NUM_THREADS='1'
+export OPENBLAS_NUM_THREADS='1'
+export MKL_NUM_THREADS='1'
+"$SCRATCHV_PYTHON" -m probes.w3_qwen3_medium.run --output-dir output/w3-medium --model-seed 0
+```
+
+The output directory must not already exist, even if it is empty. Preserve a
+failed directory and choose a new path for a retry. The runner exits 0 only if the entire gate passes; numeric,
+parsing, optimization, execution, and missing-reference failures exit 1.
+
+## Acceptance and evidence
+
+The gate uses the existing seven W2 inputs: two full random sequences, lengths
+1, 17, and 255 with right padding, an altered future suffix, and altered masked
+padding tokens. It exports the official model with named observations, then
+produces ordinary logits-only and diagnostic packed-output ONNX graphs.
+
+Both graphs run in ORT with graph optimization disabled and in ScratchV IR at
+`none`, `basic`, and `all`. Every IR path compares against both PyTorch and its
+own ORT graph. Ordinary graph, diagnostic graph, and every optimization level
+record independent results. One failure cannot be masked by another passing
+path. Independent NumPy GQA/probability/context and blocked-attention checks
+also run against PyTorch.
+
+The report uses uppercase `PASS` / `FAIL`. Its `coverage_complete` field requires
+the exact seven named cases and lengths, both ORT graphs, all six IR variants
+per case, and all 18 named/backend/graph isolation checks. Missing or duplicated
+evidence cannot pass by reducing the set of checks being summarized.
+
+All comparisons require matching shape and dtype, finite values, and strict
+`max_abs < 1e-5`, with `rtol=0`. The threshold is fixed and is not a CLI option.
+All positions are included, with valid-token and padding-query errors reported
+separately. Causal and padding isolation compare the valid prefix at **every
+checkpoint**, for PyTorch, both ORT graphs, and all six IR variants.
+
+Checkpoint count is `3 + 13 * num_hidden_layers`: embedding, 13 observations per
+layer, final norm, and logits. Shapes are derived from the actual model config,
+including query/KV head count, head dimension, hidden width, vocabulary, and
+sequence length. `probes/w2_qwen3_small/model.py` retains its two-layer defaults
+and accepts explicit `model_config` overrides plus `sequence_length`.
+
+The output contains:
+
+- `model.onnx`, `checkpoints.onnx`, and `diagnostics.onnx`.
+- `config.json`, `checkpoint_metadata.json`, packed `checkpoints.json`, and
+ versioned named-NPZ `trace_schema.json` / `logits_schema.json`.
+- `inputs_.npz` and `traces//reference.npz` (PyTorch),
+ `ort_normal.npz`, `ort_diagnostic.npz`, and
+ `ir__.npz`.
+- `report.json`, `report.md`, and `report.html`, including config, environment,
+ source/weight/artifact hashes, failures, timings, and memory observations.
+
+Every named NPZ has exactly the keys described by its schema. The report's
+`trace_artifacts` list supplies each path, schema, case/backend/graph, hashes,
+and IR optimization level for an independent layer-diff tool. Actual numerical
+failures retain their NPZ. Malformed IR diagnostic packs are instead saved as
+`*_invalid_pack.npy` and explicitly fail the schema contract.
+
+IR memory statistics describe the interpreter's retained arrays at instruction
+boundaries. Logical bytes and deduplicated NumPy backing storage are distinct;
+the interpreter's existing copy/retention behavior is unchanged. Temporary
+NumPy buffers, allocator overhead, PyTorch, and ORT are outside that accounting.
+`process_peak_rss_bytes` is separately reported as the whole process high-water
+mark, including export and every backend; it is not an IR memory measurement.
+
+## Regression tests
+
+```bash
+set -euo pipefail
+"$SCRATCHV_PYTHON" -m pytest tests/test_qwen3_medium_model.py tests/test_qwen3_medium_probe.py tests/test_qwen3_small_model.py tests/test_qwen3_small_probe.py tests/test_qwen3_small_gate.py -q
+```
+
+Tests exercise all 81 medium shapes, a second configuration changing every
+schema dimension and its real ONNX/ORT round trip, invalid configuration
+rejection, failure isolation across all six IR paths, nonfinite/shape/value
+faults, and the original small-model regressions. The command above includes
+the real W2 gate and its injected-failure checks; it does not run QEMU.
diff --git a/probes/w3_qwen3_medium/__init__.py b/probes/w3_qwen3_medium/__init__.py
new file mode 100644
index 0000000..6f49460
--- /dev/null
+++ b/probes/w3_qwen3_medium/__init__.py
@@ -0,0 +1 @@
+"""Fixed six-layer Qwen3 random-weight host numerical probe."""
diff --git a/probes/w3_qwen3_medium/preset.py b/probes/w3_qwen3_medium/preset.py
new file mode 100644
index 0000000..1065542
--- /dev/null
+++ b/probes/w3_qwen3_medium/preset.py
@@ -0,0 +1,21 @@
+"""Candidate medium preset: larger depth, hidden state, and feed-forward width.
+
+This describes randomly initialized official Qwen3, not a pretrained model.
+It intentionally retains W2's vocabulary, sequence length, and GQA geometry.
+"""
+
+from probes.w2_qwen3_small.model import MODEL_CONFIG, build_model
+
+SEQUENCE_LENGTH = 256
+MEDIUM_CONFIG = {
+ **MODEL_CONFIG,
+ "num_hidden_layers": 6,
+ "hidden_size": 64,
+ "intermediate_size": 192,
+}
+PRESET_NAME = "qwen3-medium-6l-h64-ffn192-q4-kv2-d16-random"
+
+
+def build_medium_model(seed=0):
+ return build_model(seed=seed, model_config=MEDIUM_CONFIG,
+ sequence_length=SEQUENCE_LENGTH)
diff --git a/probes/w3_qwen3_medium/run.py b/probes/w3_qwen3_medium/run.py
new file mode 100644
index 0000000..2ab45d2
--- /dev/null
+++ b/probes/w3_qwen3_medium/run.py
@@ -0,0 +1,410 @@
+"""Gate a fixed six-layer random Qwen3 through PyTorch, ORT, and host IR.
+
+Every ordinary/diagnostic graph and none/basic/all IR path must pass strict
+max_abs < 1e-5, rtol=0. No pretrained quality, full 0.6B, or QEMU claim is made.
+"""
+
+from __future__ import annotations
+
+import argparse
+from collections import Counter
+import copy
+import hashlib
+import json
+import os
+from pathlib import Path
+import sys
+import time
+import traceback
+
+# Set these before NumPy/torch/ORT imports; all numerical backends use one CPU thread.
+for _name in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS"):
+ os.environ[_name] = "1"
+
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+ sys.path.insert(0, str(ROOT))
+
+from probes.w2_qwen3_small.diagnostics import (
+ build_diagnostic_model, compare_outputs, tensor_diff, unpack_trace,
+)
+from probes.w2_qwen3_small.run import (
+ ATOL, arrays_sha256, attention_checks, environment, input_cases,
+ position_comparison, split_positions,
+)
+
+LEVELS = ("none", "basic", "all")
+GRAPH_KINDS = ("normal", "diagnostic")
+CASE_IDENTITIES = (
+ ("full_seed_0", 256), ("full_seed_42", 256), ("one_token", 1),
+ ("short_17", 17), ("short_255", 255), ("changed_future", 256),
+ ("changed_padding", 17),
+)
+INVARIANT_IDENTITIES = {
+ (name, backend, graph)
+ for name in ("causality", "padding_isolation")
+ for backend, graph in (
+ ("pytorch", "diagnostic"), ("ort", "diagnostic"), ("ort", "normal"),
+ *((f"ir_{level}", graph) for level in LEVELS for graph in GRAPH_KINDS),
+ )
+}
+
+
+def trace_schema(metadata):
+ """Stable named-NPZ schema, distinct from the packed ONNX return schema."""
+ checkpoints = []
+ for name, entry in metadata.items():
+ row = {"name": name, "shape": list(entry["shape"]), "dtype": entry["dtype"],
+ "sequence_axis": entry["sequence_axis"], "checkpoint": name.split(".")[-1]}
+ if name.startswith("layer_"):
+ row["layer"] = int(name.split(".")[0].split("_")[1])
+ checkpoints.append(row)
+ return {"version": 1, "checkpoints": checkpoints}
+
+
+def save_trace(out, relative, values, report, *, schema, case, backend, graph, level=None):
+ path = out / relative
+ path.parent.mkdir(parents=True, exist_ok=True)
+ np.savez(path, **values)
+ artifact = {"path": relative, "schema": schema, "case": case, "backend": backend,
+ "graph": graph, "optimization": level, "sha256": hashlib.sha256(path.read_bytes()).hexdigest(),
+ "arrays_sha256": arrays_sha256(values)}
+ report["trace_artifacts"].append(artifact)
+ return artifact
+
+
+def require_valid(program, stage):
+ from scratchv.analysis.ir_verifier import verify_ir
+ passed, issues = verify_ir(program, stage=stage)
+ if not passed:
+ raise ValueError("; ".join(str(issue) for issue in issues))
+
+
+def optimized_copy(program, level):
+ from scratchv.pass_manager import create_optimization_pass_manager
+ manager = create_optimization_pass_manager(level)
+ manager.before_pass = lambda p, data: require_valid(data, f"before:{p.name}")
+ manager.after_pass = lambda p, data: require_valid(data, f"after:{p.name}")
+ result = manager.run_pipeline(copy.deepcopy(program))
+ require_valid(result.data, f"after-pipeline:{level}")
+ return result.data
+
+
+def run_ir_variant(program, initializers, feed, *, kind, level, schema, names,
+ metadata, valid_length, reference, ort_reference, out, case_name, report):
+ """One independently failing path; execution failures never hide sibling paths."""
+ from scratchv.verification.ir_interpreter import IRInterpreter
+ row = {"passed": False, "status": "not_started", "graph": kind, "optimization": level}
+ started = time.perf_counter()
+ try:
+ result = IRInterpreter(program).run(feed, initializers=initializers, collect_memory_stats=True)
+ row["execution_seconds"] = time.perf_counter() - started
+ row["executed_steps"] = result.executed_steps
+ row["memory_stats"] = result.memory_stats
+ if kind == "diagnostic":
+ try:
+ values = unpack_trace(result.return_value, schema)
+ except Exception:
+ # Malformed packed output cannot honestly use the named schema.
+ # Preserve its original bytes for debugging before failing.
+ raw = out / f"traces/{case_name}/ir_{kind}_{level}_invalid_pack.npy"
+ raw.parent.mkdir(parents=True, exist_ok=True)
+ np.save(raw, result.return_value, allow_pickle=False)
+ row["invalid_packed_trace"] = str(raw.relative_to(out)).replace("\\", "/")
+ raise
+ else:
+ values = {"logits": result.return_value}
+ row["trace"] = save_trace(
+ out, f"traces/{case_name}/ir_{kind}_{level}.npz", values, report,
+ schema="trace_schema.json" if kind == "diagnostic" else "logits_schema.json",
+ case=case_name, backend="ir", graph=kind, level=level)
+ expected_names = names if kind == "diagnostic" else ["logits"]
+ pt = {name: reference[name] for name in expected_names}
+ row["pytorch_comparison"] = position_comparison(values, pt, expected_names, metadata, valid_length)
+ # Missing ORT is an explicit failed requirement, even if PyTorch agrees.
+ row["ort_comparison"] = (
+ position_comparison(values, ort_reference, expected_names, metadata, valid_length)
+ if ort_reference is not None else {"passed": False, "error": "ORT reference unavailable"})
+ row["passed"] = row["pytorch_comparison"]["passed"] and row["ort_comparison"]["passed"]
+ row["status"] = "success" if row["passed"] else "numeric_failed"
+ except Exception as exc:
+ row.update(status="runtime_error", error=f"{type(exc).__name__}: {exc}")
+ row["seconds"] = time.perf_counter() - started
+ return row
+
+
+def case_passed(case):
+ """Do not allow one successful graph/optimization to mask another failure."""
+ required = [case["capture_preserves_logits"], *case["attention_checks"],
+ *[case["ort"][kind] for kind in GRAPH_KINDS],
+ *[case["ir"][level][kind] for level in LEVELS for kind in GRAPH_KINDS]]
+ return all(item.get("passed") is True for item in required)
+
+
+def finalize_numeric_report(report):
+ """Require the fixed experiment, not just success among rows that survived."""
+ cases = report.get("cases", [])
+ invariants = report.get("invariants", [])
+ case_coverage = tuple((row.get("name"), row.get("valid_length")) for row in cases) == CASE_IDENTITIES
+ backend_coverage = all(
+ set(row.get("ort", {})) == set(GRAPH_KINDS)
+ and set(row.get("ir", {})) == set(LEVELS)
+ and all(set(row["ir"][level]) == set(GRAPH_KINDS) for level in LEVELS)
+ for row in cases
+ )
+ invariant_coverage = (
+ len(invariants) == len(INVARIANT_IDENTITIES)
+ and {(row.get("name"), row.get("backend"), row.get("graph")) for row in invariants}
+ == INVARIANT_IDENTITIES
+ )
+ report["coverage"] = {"cases": case_coverage, "backends": backend_coverage,
+ "invariants": invariant_coverage,
+ "expected_cases": len(CASE_IDENTITIES), "actual_cases": len(cases),
+ "expected_invariants": len(INVARIANT_IDENTITIES), "actual_invariants": len(invariants)}
+ report["coverage_complete"] = case_coverage and backend_coverage and invariant_coverage
+ report["passed"] = (
+ report["coverage_complete"]
+ and all(case.get("passed") is True for case in cases)
+ and all(row.get("passed") is True for row in invariants)
+ )
+
+
+def isolation_checks(out, metadata):
+ """Check valid prefixes at every checkpoint for each backend and IR variant."""
+ groups = [("pytorch", "reference", "diagnostic"),
+ ("ort", "ort_diagnostic", "diagnostic"), ("ort", "ort_normal", "normal")]
+ groups += [(f"ir_{level}", f"ir_{kind}_{level}", kind) for level in LEVELS for kind in GRAPH_KINDS]
+ checks = []
+ for invariant, left, right, length in (
+ ("causality", "full_seed_0", "changed_future", 64),
+ ("padding_isolation", "short_17", "changed_padding", 17),
+ ):
+ for backend, filename, kind in groups:
+ row = {"name": invariant, "backend": backend, "graph": kind, "passed": False}
+ try:
+ with np.load(out / f"traces/{left}/{filename}.npz", allow_pickle=False) as a, np.load(
+ out / f"traces/{right}/{filename}.npz", allow_pickle=False
+ ) as b:
+ names = list(metadata) if kind == "diagnostic" else ["logits"]
+ before = {name: split_positions(a[name], metadata[name]["sequence_axis"], 0, length) for name in names}
+ after = {name: split_positions(b[name], metadata[name]["sequence_axis"], 0, length) for name in names}
+ row["comparison"] = compare_outputs(after, before, names, ATOL)
+ row["passed"] = row["comparison"]["passed"]
+ except Exception as exc:
+ row["error"] = f"{type(exc).__name__}: {exc}"
+ checks.append(row)
+ return checks
+
+
+def run_probe(out, report, model_seed=0):
+ report["stage"] = "environment"
+ report["environment"] = environment()
+ report["environment"]["threads"] = 1
+ import onnx
+ import onnxruntime as ort
+ import torch
+ from probes.w2_qwen3_small.model import export_onnx
+ from probes.w3_qwen3_medium.preset import PRESET_NAME, build_medium_model
+ from probes.w3_common import source_evidence
+ from scratchv.frontend.onnx_parser import ONNXParser
+
+ torch.set_num_threads(1)
+ torch.use_deterministic_algorithms(True)
+ report.update(stage="model", preset=PRESET_NAME, model_seed=model_seed,
+ provenance=source_evidence(), trace_artifacts=[], timings={})
+ started = time.perf_counter()
+ wrapper = build_medium_model(seed=model_seed)
+ report["timings"]["model_build_seconds"] = time.perf_counter() - started
+ names = list(wrapper.output_names)
+ metadata = wrapper.checkpoint_metadata
+ report["config"] = wrapper.config_metadata
+ report["checkpoint_count"] = len(names)
+ report["checkpoint_count_formula"] = "3 + 13 * num_hidden_layers"
+ report["parameter_count"] = sum(t.numel() for t in wrapper.parameters())
+ report["weights_sha256"] = arrays_sha256({
+ name: tensor.detach().cpu().numpy() for name, tensor in wrapper.model.state_dict().items()})
+ report["checkpoint_metadata"] = metadata
+ (out / "config.json").write_text(wrapper.model.config.to_json_string(use_diff=False), encoding="utf-8")
+ for filename, value in (("trace_schema.json", trace_schema(metadata)),
+ ("logits_schema.json", trace_schema({"logits": metadata["logits"]})),
+ ("checkpoint_metadata.json", metadata)):
+ (out / filename).write_text(json.dumps(value, indent=2) + "\n", encoding="utf-8")
+ cases = input_cases()
+
+ def reference(feed):
+ args = [torch.from_numpy(feed[name]) for name in ("input_ids", "attention_mask")]
+ with torch.inference_mode(), wrapper.capture():
+ tensors = wrapper(*args)
+ return {name: tensor.detach().cpu().numpy().copy() for name, tensor in zip(names, tensors)}
+
+ started = time.perf_counter()
+ first_reference = reference(cases[0][2])
+ first_reference_seconds = time.perf_counter() - started
+ report["stage"] = "export"
+ started = time.perf_counter()
+ tensors = [torch.from_numpy(cases[0][2][name]) for name in ("input_ids", "attention_mask")]
+ report["export"] = export_onnx(wrapper, out / "checkpoints.onnx", *tensors)
+ exported = onnx.load(out / "checkpoints.onnx")
+ onnx.checker.check_model(exported, full_check=True)
+ ordinary = copy.deepcopy(exported)
+ logits_info = copy.deepcopy(next(value for value in ordinary.graph.output if value.name == "logits"))
+ del ordinary.graph.output[:]
+ ordinary.graph.output.append(logits_info)
+ diagnostic, schema = build_diagnostic_model(exported, first_reference)
+ report["checkpoints"] = schema
+ (out / "checkpoints.json").write_text(json.dumps(schema, indent=2) + "\n", encoding="utf-8")
+ report["onnx"] = {}
+ for kind, model, filename in (("normal", ordinary, "model.onnx"),
+ ("diagnostic", diagnostic, "diagnostics.onnx")):
+ onnx.checker.check_model(model, full_check=True)
+ onnx.save(model, out / filename)
+ report["onnx"][kind] = {"path": filename, "nodes": len(model.graph.node),
+ "operators": dict(sorted(Counter(node.op_type for node in model.graph.node).items())),
+ "sha256": hashlib.sha256((out / filename).read_bytes()).hexdigest()}
+ report["timings"]["export_seconds"] = time.perf_counter() - started
+ report["stage"] = "prepare_backends"
+ options = ort.SessionOptions()
+ options.intra_op_num_threads = 1
+ options.inter_op_num_threads = 1
+ options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_DISABLE_ALL
+ report["ort_graph_optimization"] = "ORT_DISABLE_ALL"
+ sessions, parsers, programs = {}, {}, {}
+ report["backends"] = {}
+ for kind, filename in (("normal", "model.onnx"), ("diagnostic", "diagnostics.onnx")):
+ info = report["backends"][kind] = {"ort": {"passed": False}, "ir": {}}
+ started = time.perf_counter()
+ try:
+ sessions[kind] = ort.InferenceSession(str(out / filename), options, providers=["CPUExecutionProvider"])
+ info["ort"]["passed"] = True
+ except Exception as exc:
+ info["ort"]["error"] = f"{type(exc).__name__}: {exc}"
+ info["ort"]["prepare_seconds"] = time.perf_counter() - started
+ started = time.perf_counter()
+ try:
+ parsers[kind] = ONNXParser()
+ original = parsers[kind].parse(str(out / filename))
+ require_valid(original, f"parsed:{kind}")
+ info["parse_seconds"] = time.perf_counter() - started
+ except Exception as exc:
+ info["parse_error"] = f"{type(exc).__name__}: {exc}"
+ original = None
+ for level in LEVELS:
+ started = time.perf_counter()
+ row = info["ir"][level] = {"passed": False}
+ try:
+ if original is None:
+ raise RuntimeError(info["parse_error"])
+ programs[kind, level] = optimized_copy(original, level)
+ row["passed"] = True
+ except Exception as exc:
+ row["error"] = f"{type(exc).__name__}: {exc}"
+ row["prepare_seconds"] = time.perf_counter() - started
+
+ report["stage"] = "numeric"
+ report["cases"] = []
+ for case_name, valid_length, feed in cases:
+ report["current_case"] = case_name
+ case_started = time.perf_counter()
+ case = {"name": case_name, "valid_length": valid_length, "passed": False,
+ "input_sha256": arrays_sha256(feed), "ort": {}, "ir": {}}
+ report["cases"].append(case)
+ np.savez(out / f"inputs_{case_name}.npz", **feed)
+ started = time.perf_counter()
+ pt = first_reference if case_name == cases[0][0] else reference(feed)
+ case["pytorch_reference_seconds"] = (first_reference_seconds if case_name == cases[0][0]
+ else time.perf_counter() - started)
+ case["reference_trace"] = save_trace(out, f"traces/{case_name}/reference.npz", pt, report,
+ schema="trace_schema.json", case=case_name, backend="pytorch", graph="diagnostic")
+ with torch.inference_mode():
+ plain = wrapper.model(input_ids=torch.from_numpy(feed["input_ids"]),
+ attention_mask=torch.from_numpy(feed["attention_mask"]), position_ids=wrapper.positions,
+ use_cache=False, return_dict=False, logits_to_keep=0)[0].numpy()
+ case["capture_preserves_logits"] = tensor_diff(pt["logits"], plain, ATOL)
+ case["attention_checks"] = attention_checks(pt, feed, wrapper.config_metadata)
+ ort_values = {}
+ for kind in GRAPH_KINDS:
+ row = case["ort"][kind] = {"passed": False}
+ started = time.perf_counter()
+ try:
+ if kind not in sessions:
+ raise RuntimeError(report["backends"][kind]["ort"]["error"])
+ values = sessions[kind].run(None, feed)
+ row["execution_seconds"] = time.perf_counter() - started
+ if kind == "diagnostic":
+ actual_names = [output.name for output in sessions[kind].get_outputs()][1:]
+ if actual_names != names or len(values) != len(names) + 1:
+ raise ValueError("Diagnostic ONNX output order/count disagrees with schema")
+ named = dict(zip(names, values[1:]))
+ row["pack_layout"] = compare_outputs(unpack_trace(values[0], schema), named, names, ATOL)
+ else:
+ named = {"logits": values[0]}
+ ort_values[kind] = named
+ row["trace"] = save_trace(out, f"traces/{case_name}/ort_{kind}.npz", named, report,
+ schema="trace_schema.json" if kind == "diagnostic" else "logits_schema.json",
+ case=case_name, backend="ort", graph=kind)
+ ordered = names if kind == "diagnostic" else ["logits"]
+ row["pytorch_comparison"] = position_comparison(named, {n: pt[n] for n in ordered}, ordered, metadata, valid_length)
+ row["passed"] = row["pytorch_comparison"]["passed"] and row.get("pack_layout", {"passed": True})["passed"]
+ except Exception as exc:
+ row["error"] = f"{type(exc).__name__}: {exc}"
+ row["seconds"] = time.perf_counter() - started
+ for level in LEVELS:
+ case["ir"][level] = {}
+ for kind in GRAPH_KINDS:
+ if (kind, level) not in programs:
+ case["ir"][level][kind] = {"passed": False, "status": "preparation_failed",
+ "error": report["backends"][kind]["ir"][level]["error"]}
+ continue
+ case["ir"][level][kind] = run_ir_variant(programs[kind, level], parsers[kind].initializers, feed,
+ kind=kind, level=level, schema=schema, names=names, metadata=metadata,
+ valid_length=valid_length, reference=pt, ort_reference=ort_values.get(kind),
+ out=out, case_name=case_name, report=report)
+ case["passed"] = case_passed(case)
+ case["seconds"] = time.perf_counter() - case_started
+ print(f"[{case_name}] {'PASS' if case['passed'] else 'FAIL'} ({case['seconds']:.2f}s)", flush=True)
+ report["invariants"] = isolation_checks(out, metadata)
+ finalize_numeric_report(report)
+ report["stage"] = "complete"
+ report.pop("current_case", None)
+
+
+def main(argv=None):
+ # The pinned exporter prints Unicode status markers even on redirected
+ # Windows GBK streams. Escaping unencodable log characters preserves the
+ # actual export operation and the caller's chosen text encoding.
+ for stream in (sys.stdout, sys.stderr):
+ if hasattr(stream, "reconfigure"):
+ stream.reconfigure(errors="backslashreplace")
+ cli = argparse.ArgumentParser(description=__doc__)
+ cli.add_argument("--output-dir", type=Path, default=ROOT / "output/w3-medium")
+ cli.add_argument("--model-seed", type=int, default=0)
+ args = cli.parse_args(argv)
+ from probes.w3_common import new_output_dir
+ try:
+ out = new_output_dir(args.output_dir)
+ except FileExistsError:
+ cli.error("--output-dir must not exist; use a new directory to preserve evidence")
+ report = {"title": "Six-layer random Qwen3 medium host gate", "gate": "w3-medium-host", "passed": False,
+ "stage": "initialization", "atol": ATOL, "rtol": 0,
+ "acceptance": "strict max_abs < 1e-5 at all positions including padding queries",
+ "scope": "official random-weight Qwen3; host PyTorch/ORT/IR only; no QEMU or pretrained quality claim"}
+ started = time.perf_counter()
+ try:
+ run_probe(out, report, args.model_seed)
+ except Exception as exc:
+ report.update(passed=False, error=f"{type(exc).__name__}: {exc}")
+ traceback.print_exc()
+ report["seconds"] = time.perf_counter() - started
+ report["status"] = "PASS" if report["passed"] else "FAIL"
+ from probes.w3_common import process_peak_rss_bytes, write_reports
+ report["process_peak_rss_bytes"] = process_peak_rss_bytes()
+ report["process_peak_rss_scope"] = "whole process high-water mark, includes PyTorch exporter, ORT sessions and IR; not IR storage statistics"
+ write_reports(out, report)
+ print(f"[gate] {'PASS' if report['passed'] else 'FAIL'}; report: {out / 'report.json'}", flush=True)
+ return 0 if report["passed"] else 1
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/probes/w3_qwen3_subgraphs/README.md b/probes/w3_qwen3_subgraphs/README.md
new file mode 100644
index 0000000..5db8c48
--- /dev/null
+++ b/probes/w3_qwen3_subgraphs/README.md
@@ -0,0 +1,106 @@
+# W3 authenticated Qwen3 pretrained subgraphs
+
+Reproduction targets **Ubuntu 24.04 x86_64, Bash and Python 3.12**. Complete the [Linux environment and asset setup](../../docs/llm-deploy-v1.0/LINUX_REPRODUCTION.md) first. Run commands from the repository root in the same Bash session; the setup exports `SCRATCHV_PYTHON`, `SCRATCHV_CC` and `SCRATCHV_QEMU`.
+
+This offline gate exercises selected first-layer subgraphs of the pinned
+`Qwen/Qwen3-0.6B` checkpoint at revision
+`c1899de289a04d12100db370d81485cdf75e47ca`. It loads individual tensors with
+`safetensors.safe_open`; it never constructs a full Torch model or downloads
+anything. Checkpoint weights and source assets remain read-only.
+
+Before any tensor is accessed, the gate streams SHA256 verification of the
+checkpoint and all seven source assets against the existing W1 manifest.
+The checkpoint SHA256 is
+`f47f71177f32bcd101b7573ec9171e6a57f4f4d31148d38e382306f42996874b`.
+Each selected tensor also records its shape, original BF16 dtype, promoted
+FP32 hash and byte count. No generated or random weights enter this gate.
+
+Run from this checkout with the pinned CPU export environment:
+
+```bash
+set -euo pipefail
+W3_SOURCE=/absolute/path/to/qwen3-source/c1899de289a04d12100db370d81485cdf75e47ca
+"$SCRATCHV_PYTHON" -X utf8 -B \
+ probes/w3_qwen3_subgraphs/run.py \
+ --source-dir "$W3_SOURCE" \
+ --output-dir output/w3-qwen3-subgraphs-l256 \
+ --seq-len 256
+```
+
+The output directory must not exist. Only L=256 can produce an official PASS.
+`--seq-len 2..255` is a debug subset: even numerical success produces PARTIAL,
+`passed=false`, and exit code 2. Formal success exits 0; every gate failure
+exits 1. OMP, OpenBLAS, MKL, Torch and ORT are limited to one thread.
+
+## Coverage and inputs
+
+All 14 cases are mandatory, with ordinary output and diagnostic checkpoints
+executed by ORT and the production ONNX parser/IR interpreter under
+`none`, `basic` and `all` optimization levels.
+
+| Cases | Real dimensions / learned parameters |
+|---|---|
+| Q/K/V/O projections | 1024→2048, 1024→1024, 1024→1024, 2048→1024 |
+| Hidden/Q/K RMSNorm | Last dimensions 1024/128/128; authentic learned weights; epsilon 1e-6 |
+| Q/K RoPE | 16/8 heads, full head dimension 128; every position 0..255; theta 1e6 |
+| GQA full and key-padded | 16 query heads, 8 KV heads, 128 coordinates, L256 causal masking |
+| GQA changed future/padding | Explicit perturbations verify causality and key-padding isolation |
+| SwiGLU | 1024→3072→1024, authentic gate/up/down weights and intermediate checkpoints |
+
+Activations are explicitly synthetic: NumPy PCG64 seed 20261004 generates
+standard-normal hidden and O-projection input arrays. Q/K RMSNorm receives
+the authentic Q/K projections of that hidden input. RoPE receives those
+normalized Q/K arrays; GQA receives their rotations and the authentic V
+projection. These preparatory activations are computed in Torch and saved
+with shape/dtype/hash evidence. They are not claimed to come from token
+embeddings or a complete decoder-layer forward. No residual, full-layer
+composition, logits, generation, or language quality is established here.
+
+## Independent reference and acceptance
+
+Graphs are assembled from ONNX primitives. References separately use Torch
+`F.linear`, `rsqrt`, direct half-pair rotations, `F.silu`, and per-query-head
+attention. The independent attention loop maps query head `h` to KV head
+`h // 2`, instead of reusing the graph's Expand/Reshape repetition. A manual
+uniform-attention unit fixture additionally verifies this mapping and masks.
+
+For every checkpoint, the gate requires matching shapes and FP32 dtypes,
+finite values, and **max absolute error strictly less than 1e-4, rtol=0**.
+It compares ORT against Torch, every IR level against ORT and Torch, and
+ordinary outputs against diagnostic outputs. Padding queries are included.
+Blocked attention must be zero, probability rows must sum to one, and both
+causality and padding isolation must pass for Torch, ORT and all IR levels.
+
+This W3 real-weight baseline does **not** change W2's strict 1e-5 threshold.
+There is no full-dimension RISC-V execution claim for this gate.
+
+## Evidence and memory
+
+Every case saves `model.onnx`, `diagnostics.onnx`, `checkpoints.json`,
+`inputs.npz`, `torch.npz`, `ort.npz`, three `ir_.npz` files, and ordinary
+outputs. Failure evidence remains in the new output directory, including
+the first failing checkpoint/index, values and errors. The runner continues
+other optimization levels and cases after a case failure when possible.
+
+`report.json`, `report.md` and `report.html` contain source hashes, package
+versions, authenticated weight identity, comparisons, timing and memory.
+JSON is published atomically **last**, after the other required report files.
+Report-write failure cannot leave a new PASS marker.
+
+`process_peak_rss_bytes` is the process lifetime resident-memory high water
+mark, including Torch, ORT and IR. It is not per-case incremental memory.
+`memory_stats` separately describes interpreter retained arrays and backing
+storage; it excludes kernel temporaries and allocator overhead. Ordinary
+graphs and packed diagnostic graphs are labeled separately because packing
+adds output storage. No peak-memory improvement is claimed.
+
+Unit checks:
+
+```bash
+set -euo pipefail
+"$SCRATCHV_PYTHON" -m pytest \
+ tests/test_w3_qwen3_subgraphs.py -q
+```
+
+Unit-test safetensors and attention inputs are explicitly synthetic fixtures
+for contract/error tests; they are never accepted as pretrained evidence.
diff --git a/probes/w3_qwen3_subgraphs/__init__.py b/probes/w3_qwen3_subgraphs/__init__.py
new file mode 100644
index 0000000..657cdd4
--- /dev/null
+++ b/probes/w3_qwen3_subgraphs/__init__.py
@@ -0,0 +1 @@
+"""Offline, pinned pretrained Qwen3 first-layer subgraph probes."""
diff --git a/probes/w3_qwen3_subgraphs/assets.py b/probes/w3_qwen3_subgraphs/assets.py
new file mode 100644
index 0000000..7d3964b
--- /dev/null
+++ b/probes/w3_qwen3_subgraphs/assets.py
@@ -0,0 +1,77 @@
+"""Authenticate an existing snapshot before reading individual tensors.
+
+No model constructor or download is used. Checkpoint hashing is streamed and
+safetensors only materializes tensors explicitly requested by each subgraph.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[2]
+MANIFEST_PATH = ROOT / "probes/w1_qwen3_export/manifest.json"
+MANIFEST = json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))
+DIMENSIONS = {"hidden_size": 1024, "intermediate_size": 3072,
+ "num_attention_heads": 16, "num_key_value_heads": 8,
+ "head_dim": 128, "num_hidden_layers": 28,
+ "rms_norm_eps": 1e-6, "rope_theta": 1000000}
+
+
+def sha256(path):
+ digest = hashlib.sha256()
+ with Path(path).open("rb") as stream:
+ for block in iter(lambda: stream.read(1024 * 1024), b""):
+ digest.update(block)
+ return digest.hexdigest()
+
+
+def verify_source(directory, manifest=MANIFEST):
+ directory = Path(directory).resolve()
+ if not directory.is_dir():
+ raise FileNotFoundError(f"Pinned snapshot directory missing: {directory}")
+ rows = []
+ for item in [{"name": "model.safetensors", "sha256": manifest["source_checkpoint_sha256"]},
+ *manifest["source_files"]]:
+ name = item["name"]
+ if not name or name in (".", "..") or any(c in name for c in "/\\:"):
+ raise ValueError(f"Non-flat snapshot asset name: {name}")
+ path = (directory / name).resolve()
+ if not path.is_relative_to(directory) or not path.is_file():
+ raise FileNotFoundError(f"Missing snapshot asset: {name}")
+ actual = sha256(path)
+ if actual != item["sha256"]:
+ raise ValueError(f"Pinned snapshot SHA256 mismatch: {name}: {actual}")
+ rows.append({"name": name, "sha256": actual, "bytes": path.stat().st_size})
+ config = json.loads((directory / "config.json").read_text(encoding="utf-8"))
+ for key, expected in DIMENSIONS.items():
+ if config.get(key) != expected:
+ raise ValueError(f"Pinned Qwen3 configuration mismatch: {key}")
+ return {"directory": str(directory), "model_id": manifest["model_id"],
+ "revision": manifest["revision"], "manifest_sha256": sha256(MANIFEST_PATH),
+ "verification": "W1 checkpoint and all seven source-file SHA256 values match; offline/read-only",
+ "files": rows, "config": config}
+
+
+class Weights:
+ """Read selected first-layer weights, recording original dtype and FP32 bytes."""
+
+ def __init__(self, source):
+ self.path = Path(source) / "model.safetensors"
+ self.evidence = {}
+
+ def get(self, suffix, shape):
+ from safetensors import safe_open
+ name = "model.layers.0." + suffix
+ with safe_open(str(self.path), framework="pt", device="cpu") as checkpoint:
+ tensor = checkpoint.get_tensor(name)
+ original_dtype = str(tensor.dtype)
+ array = tensor.float().numpy().copy()
+ if array.shape != tuple(shape) or not np.isfinite(array).all():
+ raise ValueError(f"Unexpected/nonfinite source weight: {name}: {array.shape}")
+ self.evidence[name] = {"shape": list(array.shape), "source_dtype": original_dtype,
+ "execution_dtype": str(array.dtype), "fp32_sha256":
+ hashlib.sha256(array.tobytes()).hexdigest(), "bytes": array.nbytes}
+ return array
diff --git a/probes/w3_qwen3_subgraphs/cases.py b/probes/w3_qwen3_subgraphs/cases.py
new file mode 100644
index 0000000..ec810b8
--- /dev/null
+++ b/probes/w3_qwen3_subgraphs/cases.py
@@ -0,0 +1,238 @@
+"""Real dimensions/weights, explicit synthetic activations, independent Torch oracles.
+
+ONNX primitives are assembled directly. Their Torch oracle uses F.linear,
+rsqrt, trigonometric pair rotation, and an explicit per-head attention loop;
+it neither exports nor executes the same ONNX graph to define correctness.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import hashlib
+
+import numpy as np
+import onnx
+from onnx import TensorProto as T, helper, numpy_helper
+import torch
+import torch.nn.functional as F
+
+from .assets import DIMENSIONS
+
+
+@dataclass
+class Case:
+ name: str
+ family: str
+ model: onnx.ModelProto
+ feed: dict
+ expected: dict
+ metadata: dict
+
+
+def node(op, inputs, output, **attrs):
+ return helper.make_node(op, inputs, [output], name=output, **attrs)
+
+
+def graph(name, family, nodes, feed, expected, constants=None, **metadata):
+ model = helper.make_model(helper.make_graph(
+ nodes, name,
+ [helper.make_tensor_value_info(key, T.FLOAT, value.shape) for key, value in feed.items()],
+ [helper.make_tensor_value_info(key, T.FLOAT, value.shape) for key, value in expected.items()],
+ [numpy_helper.from_array(np.asarray(value), key) for key, value in (constants or {}).items()],
+ ), opset_imports=[helper.make_opsetid("", 18)], ir_version=10)
+ onnx.checker.check_model(model, full_check=True)
+ return Case(name, family, model, feed, expected, metadata)
+
+
+def arr(tensor):
+ return tensor.detach().numpy().copy()
+
+
+def rms_reference(x, weight):
+ value = torch.from_numpy(x)
+ return arr(value * torch.rsqrt(value.square().mean(dim=-1, keepdim=True) + 1e-6)
+ * torch.from_numpy(weight))
+
+
+def rope_inverse_frequency():
+ """Materialize Qwen3's FP32 rotary buffer once, as in Transformers.
+
+ NumPy power and Torch power need not round to the same FP32 constants.
+ The graph and independent rotation oracle must consume the same model
+ parameters, just as they consume the same pretrained linear weights.
+ """
+ dimension, theta = DIMENSIONS["head_dim"], DIMENSIONS["rope_theta"]
+ exponent = torch.arange(0, dimension, 2, dtype=torch.int64).to(torch.float32) / dimension
+ return arr(1.0 / (theta ** exponent))
+
+
+def rope_reference(x, position, inv_freq=None):
+ # Pair formula is deliberately separate from ONNX Slice/Neg/Concat.
+ value = torch.from_numpy(x)
+ inv = torch.from_numpy(rope_inverse_frequency() if inv_freq is None else inv_freq)
+ angle = torch.from_numpy(position).reshape(-1, 1) * inv.reshape(1, -1)
+ first, second = value[..., :64], value[..., 64:]
+ return arr(torch.cat((first * angle.cos() - second * angle.sin(),
+ second * angle.cos() + first * angle.sin()), dim=-1))
+
+
+def projection_case(kind, x, weight):
+ expected = arr(F.linear(torch.from_numpy(x), torch.from_numpy(weight)))
+ return graph(f"projection_{kind}", "projection", [node("MatMul", ["x", "weight"], "y")],
+ {"x": x}, {"y": expected}, {"weight": weight.T.copy()},
+ source_weights=[f"model.layers.0.self_attn.{kind}_proj.weight"],
+ purpose="FP32 projection using authentic first-layer checkpoint weight")
+
+
+def norm_case(kind, x, weight, suffix):
+ return graph(f"rmsnorm_{kind}", "rmsnorm", [
+ node("Mul", ["x", "x"], "square"),
+ node("ReduceMean", ["square", "last"], "variance", keepdims=1),
+ node("Add", ["variance", "epsilon"], "stabilized"),
+ node("Sqrt", ["stabilized"], "denominator"),
+ node("Div", ["x", "denominator"], "normalized"),
+ node("Mul", ["normalized", "weight"], "y"),
+ ], {"x": x}, {"y": rms_reference(x, weight)},
+ {"last": np.array([-1], np.int64), "epsilon": np.array(1e-6, np.float32), "weight": weight},
+ source_weights=["model.layers.0." + suffix],
+ purpose="Learned RMSNorm across the final dimension; official epsilon=1e-6")
+
+
+def rope_case(kind, x):
+ length = x.shape[-2]
+ positions = np.arange(length, dtype=np.float32).reshape(1, length, 1)
+ inv = rope_inverse_frequency()
+ return graph(f"rope_{kind}", "rope", [
+ node("Mul", ["position", "inv_freq"], "angle"),
+ node("Concat", ["angle", "angle"], "full_angle", axis=-1),
+ node("Cos", ["full_angle"], "cos_3d"),
+ node("Sin", ["full_angle"], "sin_3d"),
+ node("Unsqueeze", ["cos_3d", "head_axis"], "cos"),
+ node("Unsqueeze", ["sin_3d", "head_axis"], "sin"),
+ node("Slice", ["x", "zero", "half", "last"], "first"),
+ node("Slice", ["x", "half", "end", "last"], "second"),
+ node("Neg", ["second"], "negative_second"),
+ node("Concat", ["negative_second", "first"], "rotated", axis=-1),
+ node("Mul", ["x", "cos"], "real"),
+ node("Mul", ["rotated", "sin"], "imaginary"),
+ node("Add", ["real", "imaginary"], "y"),
+ ], {"x": x, "position": positions}, {"y": rope_reference(x, positions, inv)},
+ {"inv_freq": inv.reshape(1, 1, 64), "head_axis": np.array([1], np.int64),
+ "zero": np.array([0], np.int64), "half": np.array([64], np.int64),
+ "end": np.array([128], np.int64), "last": np.array([-1], np.int64)},
+ source_weights=[f"model.layers.0.self_attn.{kind}_proj.weight",
+ f"model.layers.0.self_attn.{kind}_norm.weight"],
+ purpose="Full head_dim=128 rotate-half, every position 0..L-1, theta=1e6",
+ rotary_parameters={"head_dim": DIMENSIONS["head_dim"], "theta": DIMENSIONS["rope_theta"],
+ "source": "Transformers default RoPE Torch FP32 inverse-frequency buffer",
+ "sharing": "One materialized buffer supplies ONNX and the independent Torch rotation",
+ "inv_freq_sha256": hashlib.sha256(inv.tobytes()).hexdigest()},
+ activation_origin="Synthetic hidden -> authentic projection and Q/K RMSNorm, computed in Torch")
+
+
+def swiglu_case(x, gate, up, down):
+ tx = torch.from_numpy(x)
+ gt = F.linear(tx, torch.from_numpy(gate))
+ ut = F.linear(tx, torch.from_numpy(up))
+ hidden = F.silu(gt) * ut
+ expected = {"gate": arr(gt), "up": arr(ut), "hidden": arr(hidden),
+ "y": arr(F.linear(hidden, torch.from_numpy(down)))}
+ return graph("swiglu", "swiglu", [
+ node("MatMul", ["x", "gate_weight"], "gate"),
+ node("MatMul", ["x", "up_weight"], "up"),
+ node("Sigmoid", ["gate"], "activation"),
+ node("Mul", ["gate", "activation"], "silu"),
+ node("Mul", ["silu", "up"], "hidden"),
+ node("MatMul", ["hidden", "down_weight"], "y"),
+ ], {"x": x}, expected,
+ {"gate_weight": gate.T.copy(), "up_weight": up.T.copy(), "down_weight": down.T.copy()},
+ source_weights=["model.layers.0.mlp." + name + "_proj.weight" for name in ("gate", "up", "down")],
+ purpose="Authentic 1024 -> 3072 -> 1024 SwiGLU, distinct gate/up learned weights")
+
+
+def attention_reference(feed):
+ q, k, v, mask = (torch.from_numpy(feed[name]) for name in ("q", "k", "v", "mask"))
+ probabilities, contexts = [], []
+ # Explicit mapping, unlike ONNX Expand/Reshape: heads (0,1) use KV0, etc.
+ for head in range(16):
+ scores = torch.matmul(q[:, head], k[:, head // 2].transpose(-1, -2)) * (128 ** -0.5)
+ weights = torch.softmax(scores + mask[:, 0], dim=-1)
+ probabilities.append(weights)
+ contexts.append(torch.matmul(weights, v[:, head // 2]))
+ return {"probabilities": arr(torch.stack(probabilities, dim=1)),
+ "y": arr(torch.stack(contexts, dim=1))}
+
+
+def attention_case(name, feed, valid_length, **metadata):
+ length = feed["q"].shape[2]
+ nodes = []
+ for value in ("k", "v"):
+ nodes += [node("Unsqueeze", [value, "repeat_axis"], value + "_5d"),
+ node("Expand", [value + "_5d", "expanded_shape"], value + "_expanded"),
+ node("Reshape", [value + "_expanded", "repeated_shape"], value + "_repeated")]
+ nodes += [node("Transpose", ["k_repeated"], "kt", perm=[0, 1, 3, 2]),
+ node("MatMul", ["q", "kt"], "unscaled"),
+ node("Mul", ["unscaled", "scale"], "scores"),
+ node("Add", ["scores", "mask"], "masked"),
+ node("Softmax", ["masked"], "probabilities", axis=-1),
+ node("MatMul", ["probabilities", "v_repeated"], "y")]
+ return graph(name, "gqa", nodes, feed, attention_reference(feed),
+ {"repeat_axis": np.array([2], np.int64), "scale": np.array(128 ** -0.5, np.float32),
+ "expanded_shape": np.array([1, 8, 2, length, 128], np.int64),
+ "repeated_shape": np.array([1, 16, length, 128], np.int64)},
+ valid_length=valid_length, source_weights=["model.layers.0.self_attn." + suffix + ".weight"
+ for suffix in ("q_proj", "k_proj", "v_proj", "q_norm", "k_norm")],
+ purpose="Real 16Q/8KV, 128-dimensional heads; causal and key-padding masks",
+ activation_origin="Synthetic hidden -> authentic Q/K/V projections, Q/K norm and RoPE, in Torch",
+ **metadata)
+
+
+def causal_mask(length, valid_length):
+ allowed = np.arange(length)[None, :] <= np.arange(length)[:, None]
+ allowed &= np.arange(length)[None, :] < valid_length
+ return np.where(allowed, np.float32(0), np.finfo(np.float32).min).reshape(1, 1, length, length)
+
+
+def iter_cases(weights, length=256):
+ if not 2 <= length <= 256:
+ raise ValueError("Sequence length must be in [2, 256]; official gate requires 256")
+ rng = np.random.default_rng(20261004)
+ x = rng.standard_normal((1, length, 1024), dtype=np.float32)
+ attention_inputs = {}
+ for kind, width in (("q", 2048), ("k", 1024), ("v", 1024)):
+ weight = weights.get(f"self_attn.{kind}_proj.weight", (width, 1024))
+ case = projection_case(kind, x, weight)
+ attention_inputs[kind] = case.expected["y"].reshape(1, length, width // 128, 128).transpose(0, 2, 1, 3).copy()
+ yield case
+ del weight, case
+ context = rng.standard_normal((1, length, 2048), dtype=np.float32)
+ yield projection_case("o", context, weights.get("self_attn.o_proj.weight", (1024, 2048)))
+ yield norm_case("hidden", x, weights.get("input_layernorm.weight", (1024,)), "input_layernorm.weight")
+ for kind in ("q", "k"):
+ suffix = f"self_attn.{kind}_norm.weight"
+ weight = weights.get(suffix, (128,))
+ case = norm_case(kind, attention_inputs[kind], weight, suffix)
+ attention_inputs[kind] = case.expected["y"]
+ yield case
+ case = rope_case(kind, attention_inputs[kind])
+ attention_inputs[kind] = case.expected["y"]
+ yield case
+ del weight, case
+ full = {**attention_inputs, "mask": causal_mask(length, length)}
+ yield attention_case("gqa_full", full, length)
+ valid = min(17, max(1, length // 2))
+ padded = {**attention_inputs, "mask": causal_mask(length, valid)}
+ yield attention_case("gqa_padding", padded, valid)
+ changed_padding = {name: array.copy() for name, array in padded.items()}
+ for name in ("k", "v"):
+ changed_padding[name][:, :, valid:] += np.float32(3)
+ yield attention_case("gqa_changed_padding", changed_padding, valid, changed_from=valid)
+ changed_future = {name: array.copy() for name, array in full.items()}
+ future = max(1, length // 4)
+ for name in ("q", "k", "v"):
+ changed_future[name][:, :, future:] += np.float32(2)
+ yield attention_case("gqa_changed_future", changed_future, length, changed_from=future)
+ del attention_inputs, full, padded, changed_padding, changed_future
+ gate = weights.get("mlp.gate_proj.weight", (3072, 1024))
+ up = weights.get("mlp.up_proj.weight", (3072, 1024))
+ down = weights.get("mlp.down_proj.weight", (1024, 3072))
+ yield swiglu_case(x, gate, up, down)
diff --git a/probes/w3_qwen3_subgraphs/run.py b/probes/w3_qwen3_subgraphs/run.py
new file mode 100644
index 0000000..7d18753
--- /dev/null
+++ b/probes/w3_qwen3_subgraphs/run.py
@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+"""Strict offline pretrained-subgraph gate; no full model is loaded or executed."""
+from __future__ import annotations
+
+import argparse
+import copy
+from dataclasses import asdict, is_dataclass
+import gc
+import hashlib
+import importlib.metadata
+import json
+import os
+from pathlib import Path
+import sys
+import time
+import traceback
+
+# Set before importing numerical runtimes. The process intentionally uses one thread.
+for variable in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS"):
+ os.environ[variable] = "1"
+os.environ["HF_HUB_OFFLINE"] = "1"
+os.environ["TRANSFORMERS_OFFLINE"] = "1"
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+ sys.path.insert(0, str(ROOT))
+
+import numpy as np
+import onnx
+import onnxruntime as ort
+import torch
+
+from probes.w2_qwen3_small.diagnostics import build_diagnostic_model, unpack_trace
+from probes.w3_common import new_output_dir, process_peak_rss_bytes, source_evidence, write_reports
+from probes.w3_qwen3_subgraphs.assets import DIMENSIONS, Weights, sha256, verify_source
+from probes.w3_qwen3_subgraphs.cases import iter_cases
+from scratchv.analysis.ir_verifier import verify_ir
+from scratchv.frontend.onnx_parser import ONNXParser
+from scratchv.pass_manager import create_optimization_pass_manager
+from scratchv.verification.ir_interpreter import IRInterpreter
+from scratchv.verification.numeric_metrics import numeric_metrics, undefined_numeric_metrics
+
+ATOL = 1e-4
+LEVELS = ("none", "basic", "all")
+CASE_NAMES = ("projection_q", "projection_k", "projection_v", "projection_o", "rmsnorm_hidden",
+ "rmsnorm_q", "rope_q", "rmsnorm_k", "rope_k", "gqa_full", "gqa_padding",
+ "gqa_changed_padding", "gqa_changed_future", "swiglu")
+PINNED = {"numpy": "2.2.6", "torch": "2.7.1", "onnx": "1.18.0",
+ "onnxruntime": "1.22.1", "safetensors": "0.5.3"}
+
+
+def array_evidence(arrays):
+ return {name: {"shape": list(value.shape), "dtype": str(value.dtype),
+ "sha256": hashlib.sha256(np.ascontiguousarray(value).tobytes()).hexdigest(),
+ "finite": bool(np.isfinite(value).all()), "bytes": value.nbytes}
+ for name, value in arrays.items()}
+
+
+def tensor_diff(actual, expected, atol=ATOL):
+ """Strict absolute gate with JSON-safe evidence for shape/nonfinite failures."""
+ actual, expected = np.asarray(actual), np.asarray(expected)
+ row = {"shape": list(actual.shape), "expected_shape": list(expected.shape),
+ "shape_matches": actual.shape == expected.shape, "dtype": str(actual.dtype),
+ "expected_dtype": str(expected.dtype), "atol": atol, "rtol": 0,
+ "finite": bool(np.isfinite(actual).all() and np.isfinite(expected).all()),
+ "max_abs_error": None, "firstdiff": None, "passed": False}
+ if not row["shape_matches"]:
+ row["firstdiff"] = {"reason": "shape mismatch"}
+ row.update(undefined_numeric_metrics("shape mismatch"))
+ return row
+ if actual.dtype != np.float32 or expected.dtype != np.float32:
+ row["firstdiff"] = {"reason": "FP32 dtype mismatch"}
+ row.update(undefined_numeric_metrics("FP32 dtype mismatch"))
+ return row
+ row.update(numeric_metrics(actual, expected))
+ with np.errstate(invalid="ignore", over="ignore"):
+ error = np.abs(actual.astype(np.float64) - expected.astype(np.float64))
+ bad = ~np.isfinite(actual) | ~np.isfinite(expected) | (error >= atol)
+ if row["finite"]:
+ row["max_abs_error"] = float(error.max(initial=0))
+ if bad.any():
+ index = tuple(int(value) for value in np.argwhere(bad)[0])
+ def safe_number(value):
+ value = float(value)
+ return value if np.isfinite(value) else str(value)
+ row["firstdiff"] = {"index": list(index), "actual": safe_number(actual[index]),
+ "expected": safe_number(expected[index]), "abs_error": safe_number(error[index])}
+ row["passed"] = bool(row["finite"] and not bad.any())
+ return row
+
+
+def compare(actual, expected):
+ if list(actual) != list(expected):
+ raise ValueError("Checkpoint names/order differ")
+ rows = [{"name": name, **tensor_diff(actual[name], expected[name])} for name in expected]
+ failed = next((row for row in rows if not row["passed"]), None)
+ maxima = [row["max_abs_error"] for row in rows]
+ return {"passed": all(row["passed"] for row in rows), "checkpoints": rows,
+ "max_abs_error": None if any(value is None for value in maxima) else max(maxima, default=0),
+ "first_divergence": None if failed is None else
+ {"checkpoint": failed["name"], "firstdiff": failed["firstdiff"]}}
+
+
+def require_valid(program):
+ passed, issues = verify_ir(program)
+ if not passed:
+ raise ValueError("; ".join(map(str, issues)))
+
+
+def execute_ir(model_path, feed, level):
+ parser = ONNXParser()
+ program = parser.parse(str(model_path))
+ require_valid(program)
+ manager = create_optimization_pass_manager(level)
+ manager.before_pass = lambda unused, value: require_valid(value)
+ manager.after_pass = lambda unused, value: require_valid(value)
+ optimized = manager.run_pipeline(program)
+ require_valid(optimized.data)
+ result = IRInterpreter(optimized.data).run(feed, initializers=parser.initializers,
+ collect_memory_stats=True)
+ memory = result.memory_stats
+ if is_dataclass(memory):
+ memory = asdict(memory)
+ return result.return_value, {"executed_steps": result.executed_steps,
+ "optimization_changes": optimized.report.total_changes, "memory_stats": memory,
+ "process_peak_rss_bytes": process_peak_rss_bytes()}
+
+
+def attention_checks(values, feed):
+ probabilities = values["probabilities"]
+ blocked = feed["mask"][0, 0] < 0
+ return {"blocked_probability": tensor_diff(probabilities[..., blocked],
+ np.zeros_like(probabilities[..., blocked])),
+ "probability_row_sum": tensor_diff(probabilities.sum(axis=-1),
+ np.ones(probabilities.shape[:-1], np.float32))}
+
+
+def run_case(case, out, row):
+ directory = out / case.name
+ directory.mkdir()
+ row.update(name=case.name, family=case.family, metadata=case.metadata,
+ inputs=array_evidence(case.feed), reference=array_evidence(case.expected),
+ passed=False, comparisons={}, executions={}, semantic_checks={})
+ np.savez(directory / "inputs.npz", **case.feed)
+ np.savez(directory / "torch.npz", **case.expected)
+ model = copy.deepcopy(case.model)
+ output = next(value for value in model.graph.output if value.name == "y")
+ del model.graph.output[:]
+ model.graph.output.append(output)
+ onnx.checker.check_model(model, full_check=True)
+ onnx.save(model, directory / "model.onnx")
+ diagnostic, schema = build_diagnostic_model(case.model, case.expected)
+ onnx.save(diagnostic, directory / "diagnostics.onnx")
+ (directory / "checkpoints.json").write_text(json.dumps(schema, indent=2) + "\n", encoding="utf-8")
+ row["artifacts"] = {"directory": case.name, "model_sha256": sha256(directory / "model.onnx"),
+ "diagnostic_sha256": sha256(directory / "diagnostics.onnx")}
+ options = ort.SessionOptions()
+ options.intra_op_num_threads = options.inter_op_num_threads = 1
+ session = ort.InferenceSession(str(directory / "diagnostics.onnx"), options,
+ providers=["CPUExecutionProvider"])
+ values = session.run(None, case.feed)
+ ort_values = {name: array for name, array in zip(case.expected, values[1:])}
+ packed = unpack_trace(values[0], schema)
+ row["comparisons"]["ort_pack_layout"] = compare(packed, ort_values)
+ row["comparisons"]["torch_vs_ort"] = compare(ort_values, case.expected)
+ np.savez(directory / "ort.npz", **ort_values)
+ del session, values, packed
+ session = ort.InferenceSession(str(directory / "model.onnx"), options,
+ providers=["CPUExecutionProvider"])
+ ordinary_ort = session.run(None, case.feed)[0]
+ del session
+ row["comparisons"]["ordinary_ort_vs_torch"] = tensor_diff(ordinary_ort, case.expected["y"])
+ row["comparisons"]["ordinary_ort_vs_diagnostic"] = tensor_diff(ordinary_ort, ort_values["y"])
+ np.save(directory / "ordinary_ort.npy", ordinary_ort)
+ if case.family == "gqa":
+ row["semantic_checks"]["torch"] = attention_checks(case.expected, case.feed)
+ row["semantic_checks"]["ort"] = attention_checks(ort_values, case.feed)
+ for level in LEVELS:
+ try:
+ packed, execution = execute_ir(directory / "diagnostics.onnx", case.feed, level)
+ actual = unpack_trace(packed, schema)
+ np.savez(directory / f"ir_{level}.npz", **actual)
+ row["executions"][level] = {"diagnostic": execution}
+ row["comparisons"][f"ir_{level}_vs_ort"] = compare(actual, ort_values)
+ row["comparisons"][f"ir_{level}_vs_torch"] = compare(actual, case.expected)
+ ordinary, execution = execute_ir(directory / "model.onnx", case.feed, level)
+ row["executions"][level]["ordinary"] = execution
+ np.save(directory / f"ordinary_ir_{level}.npy", ordinary)
+ row["comparisons"][f"ordinary_ir_{level}_vs_ort"] = tensor_diff(ordinary, ordinary_ort)
+ row["comparisons"][f"ordinary_ir_{level}_vs_torch"] = tensor_diff(ordinary, case.expected["y"])
+ row["comparisons"][f"ordinary_ir_{level}_vs_diagnostic"] = tensor_diff(ordinary, actual["y"])
+ if case.family == "gqa":
+ row["semantic_checks"][f"ir_{level}"] = attention_checks(actual, case.feed)
+ del packed, actual, ordinary
+ except Exception as exc:
+ row["executions"].setdefault(level, {})["error"] = f"{type(exc).__name__}: {exc}"
+ row["comparisons"][f"ir_{level}_execution"] = {"passed": False, "error": traceback.format_exc()}
+ row["passed"] = (all(value["passed"] for value in row["comparisons"].values())
+ and all(value["passed"] for checks in row["semantic_checks"].values() for value in checks.values()))
+ row["first_divergence"] = next(({"comparison": name,
+ "detail": value.get("first_divergence", value.get("firstdiff", value.get("error")))}
+ for name, value in row["comparisons"].items() if not value["passed"]), None)
+
+
+def invariants(out, length):
+ rows = []
+ for name, left, right, prefix in (("padding_isolation", "gqa_padding", "gqa_changed_padding", length),
+ ("causality", "gqa_full", "gqa_changed_future", max(1, length // 4))):
+ for backend in ("torch", "ort", "ir_none", "ir_basic", "ir_all"):
+ try:
+ with np.load(out / left / f"{backend}.npz") as a, np.load(out / right / f"{backend}.npz") as b:
+ result = compare({key: a[key][:, :, :prefix] for key in ("probabilities", "y")},
+ {key: b[key][:, :, :prefix] for key in ("probabilities", "y")})
+ rows.append({"name": name, "backend": backend, "query_prefix": prefix, **result})
+ except Exception as exc:
+ rows.append({"name": name, "backend": backend, "passed": False,
+ "error": f"{type(exc).__name__}: {exc}"})
+ return rows
+
+
+def finalize_report(report, length):
+ report["coverage_complete"] = tuple(row["name"] for row in report["cases"]) == CASE_NAMES
+ report["numerical_passed"] = bool(report["coverage_complete"] and all(row["passed"] for row in report["cases"])
+ and len(report["invariants"]) == 10
+ and all(row["passed"] for row in report["invariants"]))
+ report["passed"] = report["numerical_passed"] and length == 256
+ report["status"] = "PASS" if report["passed"] else ("PARTIAL" if report["numerical_passed"] else "FAIL")
+ report["stage"] = "complete"
+ report.pop("current_case", None)
+
+
+def run_probe(source, out, report, length):
+ report.update(source_evidence())
+ report["stage"] = "environment"
+ installed = {name: importlib.metadata.version(name).split("+")[0] for name in PINNED}
+ if sys.version_info[:2] != (3, 12) or installed != PINNED:
+ raise RuntimeError(f"Use pinned Python 3.12 qwen environment: {installed}")
+ torch.set_num_threads(1)
+ torch.set_num_interop_threads(1)
+ torch.use_deterministic_algorithms(True)
+ report["environment"]["threads"] = {"torch": 1, "torch_interop": 1, "ort": 1,
+ **{key: os.environ[key] for key in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS")}}
+ report["stage"] = "verify_source"
+ report["source"] = verify_source(source)
+ weights = Weights(source)
+ report["weight_tensors"] = weights.evidence
+ report["cases"] = []
+ report["stage"] = "subgraphs"
+ for case in iter_cases(weights, length):
+ row = {"name": case.name, "passed": False}
+ report["cases"].append(row)
+ report["current_case"] = case.name
+ started = time.perf_counter()
+ try:
+ run_case(case, out, row)
+ except Exception as exc:
+ row["error"] = f"{type(exc).__name__}: {exc}"
+ row["traceback"] = traceback.format_exc()
+ row["seconds"] = time.perf_counter() - started
+ row["process_peak_rss_bytes"] = process_peak_rss_bytes()
+ print(f"[{case.name}] {'PASS' if row['passed'] else 'FAIL'} "
+ f"first divergence={row.get('first_divergence', row.get('error'))}", flush=True)
+ del case
+ gc.collect()
+ report["invariants"] = invariants(out, length)
+ finalize_report(report, length)
+
+
+def main(argv=None):
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument("--source-dir", type=Path, required=True, help="Existing pinned HF snapshot; never downloaded")
+ parser.add_argument("--output-dir", type=Path, required=True, help="New directory, refuses to overwrite")
+ parser.add_argument("--seq-len", type=int, default=256, choices=range(2, 257), metavar="2..256",
+ help="Only 256 is an official gate; shorter debug runs can only be PARTIAL")
+ args = parser.parse_args(argv)
+ out = new_output_dir(args.output_dir)
+ report = {"gate": "w3_qwen3_subgraphs", "status": "FAIL", "passed": False,
+ "stage": "initializing", "scope": "official L256" if args.seq_len == 256 else "debug subset",
+ "atol": ATOL, "rtol": 0, "comparison": "strict max_abs_error < 1e-4; shapes/dtypes/finite required",
+ "sequence_length": args.seq_len, "dimensions": DIMENSIONS, "levels": list(LEVELS),
+ "weight_origin": "Authenticated pretrained checkpoint, layer 0 only, BF16 values promoted to FP32",
+ "input_origin": "NumPy PCG64 seed 20261004, synthetic N(0,1) hidden/context activations; Q/K/V cases derive from authentic projections",
+ "limitations": ["Selected pretrained subgraphs, not a complete pretrained decoder-layer forward",
+ "No full-model generation or language-quality claim", "No RISC-V claim for these full dimensions",
+ "W3 1e-4 baseline does not modify W2's strict 1e-5 threshold"],
+ "memory_scope": "process_peak_rss_bytes is the process lifetime peak, including Torch/ORT/IR; IR memory_stats is separately reported"}
+ started = time.perf_counter()
+ try:
+ run_probe(args.source_dir, out, report, args.seq_len)
+ except Exception as exc:
+ report.update(passed=False, status="FAIL", error=f"{type(exc).__name__}: {exc}", traceback=traceback.format_exc())
+ report["seconds"] = time.perf_counter() - started
+ report["process_peak_rss_bytes"] = process_peak_rss_bytes()
+ write_reports(out, report)
+ print(f"{report['status']}: {out / 'report.json'}", flush=True)
+ return 0 if report["passed"] else (2 if report["status"] == "PARTIAL" else 1)
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/probes/w3_summary.py b/probes/w3_summary.py
new file mode 100644
index 0000000..63679c1
--- /dev/null
+++ b/probes/w3_summary.py
@@ -0,0 +1,226 @@
+"""Small human summaries; complete machine evidence remains in report.json."""
+from __future__ import annotations
+
+from html import escape
+import math
+
+from probes.numeric_summary import compact_metric_table, compact_metric_table_html, METRIC_EXPLANATION
+
+# The medium gate uses the seven fixed input_cases from w2_qwen3_small.run.
+_MEDIUM_CASE_COUNT = 7
+_INDEX_LIMIT = 20
+
+
+def _short(value, limit=240):
+ """Bound human-facing text without truncating the machine evidence."""
+ text = " ".join(str(value).split())
+ return text if len(text) <= limit else text[:limit] + "…（完整内容见 report.json）"
+
+
+def _first_issue(row, depth=0):
+ """Find one failed check, without printing its entire nested result."""
+ if depth > 6:
+ return ""
+ if isinstance(row, list):
+ return next((text for item in row if (text := _first_issue(item, depth + 1))), "")
+ if not isinstance(row, dict) or row.get("passed") is True:
+ return ""
+ for key in ("error", "reason"):
+ if row.get(key):
+ return _short(row[key])
+ first = row.get("first_divergence")
+ if first:
+ if isinstance(first, dict):
+ first = " / ".join(str(first[key]) for key in ("comparison", "name", "checkpoint", "reason")
+ if first.get(key)) or "结构化定位数据见 report.json"
+ return "首个差异：" + _short(first)
+ # Visit execution/check result structures, never provenance or array data.
+ for key in ("comparison", "comparisons", "ort", "ir", "normal", "diagnostic",
+ "none", "basic", "all", "executions", "workers", "pytorch_comparison",
+ "ort_comparison", "capture_preserves_logits", "pack_layout", "checkpoints"):
+ child = row.get(key)
+ if key == "comparisons" and isinstance(child, dict):
+ child = list(child.values())
+ issue = _first_issue(child, depth + 1)
+ if issue:
+ return issue
+ return ""
+
+
+def _index_status(row):
+ status = row.get("status")
+ if status in ("PARTIAL", "COMPLETE"):
+ return status
+ if row.get("passed") is True:
+ return "PASS" if status in (None, "PASS", "success") else "状态冲突（见 JSON）"
+ if row.get("passed") is False:
+ return _short(status) if status and status != "PASS" else "FAIL"
+ return _short(status) if status else "未确认"
+
+
+def evidence_index_views(report):
+ """A bounded index of recorded results, with the JSON as source of detail."""
+ entries = []
+ for key, label in (("cases", "用例"), ("gates", "子门禁"), ("invariants", "隔离检查")):
+ for index, row in enumerate(report.get(key, []), 1):
+ name = row.get("name", row.get("case", f"{label} {index}"))
+ entries.append((f"{label}：{_short(name, 100)}", row))
+ if report.get("gate") == "w3_layer_diff":
+ entries.extend(("检查点：" + _short(row.get("name", "未命名"), 100), row)
+ for row in report.get("checkpoints", []))
+ if not entries:
+ entries.append(("流程阶段：" + _short(report.get("stage", "未记录"), 100), report))
+ # A late failure must not disappear behind the first twenty successful rows.
+ entries.sort(key=lambda item: item[1].get("passed") is True)
+ selected = entries[:_INDEX_LIMIT]
+ rows = [(name, _index_status(row), _first_issue(row) or "—") for name, row in selected]
+ coverage = f"结果索引：共 {len(entries)} 项，展示 {len(selected)} 项（失败/未确认优先）。"
+ if len(entries) > len(selected):
+ coverage += f" 另 {len(entries) - len(selected)} 项见 report.json。"
+ explanation = ("完整逐用例、检查点、命令、环境和源码指纹保留在同目录 report.json。"
+ "在 GitHub Actions Summary 中，请到本次运行的 Artifacts 下载对应报告；"
+ "下面的相对链接用于下载后同目录查看。")
+ markdown = "简短结果索引与完整证据入口（展开详情）
\n\n"
+ markdown += coverage + "\n\n| 项目 | 结果 | 首个问题 |\n| --- | --- | --- |\n"
+ for row in rows:
+ markdown += "| " + " | ".join(escape(value).replace("|", "|") for value in row) + " |\n"
+ markdown += "\n" + explanation + "\n\n[完整机器报告](report.json)\n\n| 项目 | 结果 | 首个问题 |
|---|
"
+ body = "".join("" + "".join("| " + escape(value) + " | " for value in row) + "
" for row in rows)
+ page = ('简短结果索引与完整证据入口（展开详情）
'
+ + escape(coverage) + '
' + header + '' + body
+ + '
' + escape(explanation)
+ + '
完整机器报告
" + escape(description) + "
"
+ if comparisons:
+ md += compact_metric_table(comparisons) + "\n\n"
+ page += compact_metric_table_html(comparisons)
+ md += "\n\n".join(escape(note) for note in notes) + "\n\n"
+ page += "".join("" + escape(note) + "
" for note in notes)
+ return md, page
diff --git a/pyproject.toml b/pyproject.toml
index 670aa63..b4320d5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -7,7 +7,7 @@ name = "scratchv"
version = "0.3.0"
description = "A compiler from ONNX models to RISC-V assembly and LLVM IR"
readme = "README.md"
-license = {text = "MIT"}
+license = {text = "MIT AND MPL-2.0"}
keywords = ["compiler", "risc-v", "onnx", "llvm", "machine-learning"]
requires-python = ">=3.8"
dependencies = [
@@ -20,6 +20,7 @@ classifiers = [
"Intended Audience :: Developers",
"Intended Audience :: Education",
"License :: OSI Approved :: MIT License",
+ "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
@@ -46,6 +47,9 @@ Documentation = "https://github.com/kinsomwang/ScratchV/tree/main/docs/INDEX.md"
[project.scripts]
scratchv = "scratchv.main:main"
+[tool.setuptools]
+license-files = ["LICENSE", "LICENSES/*.txt", "THIRD_PARTY_NOTICES.txt"]
+
[tool.setuptools.packages.find]
include = ["scratchv", "scratchv.*", "scratchv_dag", "scratchv_dag.*", "benchmarks", "benchmarks.*"]
diff --git a/scratchv/frontend/onnx_parser.py b/scratchv/frontend/onnx_parser.py
index 6bcfacc..364dc0f 100644
--- a/scratchv/frontend/onnx_parser.py
+++ b/scratchv/frontend/onnx_parser.py
@@ -3,7 +3,7 @@
from __future__ import annotations
import math
-from pathlib import Path
+from pathlib import Path, PureWindowsPath
from typing import TYPE_CHECKING
if TYPE_CHECKING:
@@ -34,9 +34,20 @@ def __init__(self):
self._producers = {}
self._constant_cache = {}
self._base_dir = ""
+ self._mmap_external_data = False
- def parse(self, model_path: str) -> Program:
- """Parse an ONNX model file and return an IR Program."""
+ def parse(self, model_path: str, *, mmap_external_data: bool = False) -> Program:
+ """Parse ONNX, optionally mapping external weights as read-only arrays.
+
+ The default loader is unchanged. The explicit mmap mode avoids
+ materializing external weights in TensorProto.raw_data. External files
+ must be within the model directory, with valid byte ranges matching
+ the tensor shape and dtype. The caller must keep those files unchanged
+ while this parser's initializer arrays are in use. Mapping is not an
+ integrity check; model/weight hashes must be validated separately.
+ """
+ if not isinstance(mmap_external_data, bool):
+ raise ONNXParseError("mmap_external_data must be boolean")
try:
import onnx
except ImportError:
@@ -52,6 +63,7 @@ def parse(self, model_path: str) -> Program:
self._producers = {}
self._constant_cache = {}
self._base_dir = str(Path(model_path).resolve().parent)
+ self._mmap_external_data = mmap_external_data
# Inspect/infer the graph before materializing external weights. This
# avoids serializing a >2 GiB protobuf just to infer tensor shapes.
model = onnx.load(model_path, load_external_data=False)
@@ -93,7 +105,10 @@ def parse(self, model_path: str) -> Program:
# Map ONNX initializers (constants) to IR values
for init in graph.initializer:
- arr = onnx.numpy_helper.to_array(init, base_dir=self._base_dir)
+ if mmap_external_data and onnx.external_data_helper.uses_external_data(init):
+ arr = self._map_external_initializer(init)
+ else:
+ arr = onnx.numpy_helper.to_array(init, base_dir=self._base_dir)
self._bind_constant(init.name, arr)
# Map graph inputs to function params
@@ -127,6 +142,66 @@ def parse(self, model_path: str) -> Program:
return self.builder.program
+ def _map_external_initializer(self, tensor):
+ """Validate before mapping; never populate the TensorProto raw_data."""
+ import numpy as np
+ from onnx import helper
+
+ self._dtype(tensor.data_type) # Keep the frontend's supported dtype set.
+ fields = {}
+ for entry in tensor.external_data:
+ if entry.key in fields:
+ raise ONNXParseError(f"Duplicate external field for {tensor.name}: {entry.key}")
+ fields[entry.key] = entry.value
+ unknown = set(fields) - {"location", "offset", "length", "checksum"}
+ if unknown:
+ raise ONNXParseError(f"Unsupported external fields for {tensor.name}: {sorted(unknown)}")
+ location = fields.get("location", "")
+ windows = PureWindowsPath(location)
+ path = Path(location)
+ if (not location or path.is_absolute() or windows.is_absolute()
+ or windows.drive or ".." in path.parts or ".." in windows.parts):
+ raise ONNXParseError(f"External path must stay within the model directory: {tensor.name}")
+ # Recognize either separator on every host; resolve symlinks as well.
+ base = Path(self._base_dir).resolve()
+ candidate = (base / Path(*windows.parts)).resolve()
+ try:
+ candidate.relative_to(base)
+ except ValueError as exc:
+ raise ONNXParseError(f"External path escapes the model directory: {tensor.name}") from exc
+ if candidate == base:
+ raise ONNXParseError(f"External path escapes the model directory: {tensor.name}")
+ if tensor.HasField("raw_data") or tensor.HasField("segment"):
+ raise ONNXParseError(f"Ambiguous raw or segmented external tensor: {tensor.name}")
+ shape = tuple(tensor.dims)
+ if any(dimension < 0 for dimension in shape):
+ raise ONNXParseError(f"Negative external tensor dimension: {tensor.name}")
+ dtype = np.dtype(helper.tensor_dtype_to_np_dtype(tensor.data_type)).newbyteorder("<")
+ expected = math.prod(shape) * dtype.itemsize
+
+ def size_field(name, default):
+ value = fields.get(name)
+ if value is None:
+ return default
+ if not value or not value.isascii() or not value.isdecimal():
+ raise ONNXParseError(f"External {name} must be a nonnegative integer: {tensor.name}")
+ return int(value)
+
+ offset = size_field("offset", 0)
+ length = size_field("length", expected)
+ if length != expected:
+ raise ONNXParseError(f"External length disagrees with tensor shape/dtype: {tensor.name}")
+ try:
+ if not candidate.is_file() or offset + expected > candidate.stat().st_size:
+ raise ONNXParseError(f"External tensor byte range exceeds file: {tensor.name}")
+ if expected == 0:
+ array = np.empty(shape, dtype=dtype)
+ array.setflags(write=False)
+ return array
+ return np.memmap(candidate, mode="r", dtype=dtype, offset=offset, shape=shape, order="C")
+ except (OSError, ValueError, OverflowError) as exc:
+ raise ONNXParseError(f"Cannot map external tensor {tensor.name}: {exc}") from exc
+
def _translate_node(self, node, output_names: set[str]) -> None:
"""Translate a single ONNX node to IR instructions."""
op_type = node.op_type
@@ -244,13 +319,16 @@ def _constant_ints(self, value: Value) -> tuple[int, ...]:
def _handle_constant(self, node, inputs, outputs):
import numpy as np
- from onnx import numpy_helper
+ from onnx import external_data_helper, numpy_helper
attrs = self._attributes(node)
if len(attrs) != 1 or len(outputs) != 1 or inputs:
raise ONNXParseError("Constant requires one value attribute and one output")
key, value = next(iter(attrs.items()))
if key == "value":
- data = numpy_helper.to_array(value, base_dir=self._base_dir)
+ if self._mmap_external_data and external_data_helper.uses_external_data(value):
+ data = self._map_external_initializer(value)
+ else:
+ data = numpy_helper.to_array(value, base_dir=self._base_dir)
elif key in ("value_int", "value_ints"):
data = np.asarray(value, dtype=np.int64)
elif key in ("value_float", "value_floats"):
diff --git a/scratchv/verification/fp32_eigen.py b/scratchv/verification/fp32_eigen.py
new file mode 100644
index 0000000..c53960d
--- /dev/null
+++ b/scratchv/verification/fp32_eigen.py
@@ -0,0 +1,156 @@
+# SPDX-License-Identifier: MPL-2.0
+# Adapted from Eigen (https://gitlab.com/libeigen/eigen), commit
+# 1d8b82b0740839c0de7f1242a3585e3390ff5f33:
+# Eigen/src/Core/Redux.h
+# Eigen/src/Core/arch/SSE/PacketMath.h
+# Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+# Copyright (C) 2006-2008 Benoit Jacob
+# Copyright (C) 2007 Julien Pommier
+# Copyright (C) 2008-2009 Gael Guennebaud
+# Copyright (C) 2009-2019 Gael Guennebaud
+# Copyright (C) 2014 Pedro Gonnet (pedro.gonnet@gmail.com)
+#
+# This Source Code Form is subject to the terms of the Mozilla
+# Public License, v. 2.0. If a copy of the MPL was not distributed
+# with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+# The full license is also distributed in LICENSES/Eigen-MPL-2.0.txt.
+"""Deterministic FP32 reductions and trigonometric approximations.
+
+This NumPy adaptation preserves Eigen's SSE reduction order and its non-FMA
+``psincos_float`` polynomial. All floating-point computation remains FP32.
+It makes no promise of bitwise agreement with every platform's math library.
+The reduction uses canonical contiguous row alignment, independent of the
+input's memory address or strides. Trigonometry uses NumPy outside a shared
+conservative interval for the non-FMA approximation.
+"""
+
+import numpy as np
+
+
+def _fp32_array(values):
+ array = np.asarray(values)
+ if array.dtype != np.dtype(np.float32):
+ raise TypeError("FP32 math requires a float32 array")
+ return array
+
+
+def _sum_last(array, aligned_start=0):
+ """Eigen's two Packet4f accumulators, scalar prefix/tail, and predux."""
+ width = array.shape[-1]
+ if width - aligned_start < 4:
+ result = array[..., 0].copy()
+ for index in range(1, width):
+ result = result + array[..., index]
+ return result
+
+ packet_end = aligned_start + ((width - aligned_start) // 4) * 4
+ pair_end = aligned_start + ((width - aligned_start) // 8) * 8
+ first = array[..., aligned_start : aligned_start + 4].copy()
+ if packet_end - aligned_start > 4:
+ second = array[..., aligned_start + 4 : aligned_start + 8].copy()
+ for index in range(aligned_start + 8, pair_end, 8):
+ first = first + array[..., index : index + 4]
+ second = second + array[..., index + 4 : index + 8]
+ first = first + second
+ if packet_end > pair_end:
+ first = first + array[..., pair_end : pair_end + 4]
+
+ result = (first[..., 0] + first[..., 2]) + (first[..., 1] + first[..., 3])
+ for index in range(aligned_start):
+ result = result + array[..., index]
+ for index in range(packet_end, width):
+ result = result + array[..., index]
+ return result
+
+
+def mean_last(values, keepdims=True):
+ """Reduce a nonempty last dimension using an explicit FP32 sum order.
+
+ Leading dimensions may be empty. Scalar inputs and an empty reduction
+ dimension are rejected rather than inventing a mean for an empty set.
+ Inputs, including read-only and strided arrays, are never modified.
+ """
+ array = _fp32_array(values)
+ if array.ndim == 0 or array.shape[-1] == 0:
+ raise ValueError("mean_last requires a nonempty last dimension")
+ if not isinstance(keepdims, (bool, np.bool_)):
+ raise TypeError("keepdims must be boolean")
+
+ width = array.shape[-1]
+ if width % 4 == 0 or width < 4:
+ sums = _sum_last(array)
+ else:
+ # Model a 16-byte-aligned first row and contiguous successive rows.
+ # Shape alone determines the prefix; array pointer alignment does not.
+ rows = array.reshape(-1, width)
+ row_starts = (-np.arange(rows.shape[0]) * width) % 4
+ sums = np.empty(rows.shape[0], dtype=np.float32)
+ for start in range(4):
+ selected = np.flatnonzero(row_starts == start)
+ if selected.size:
+ sums[selected] = _sum_last(rows[selected], start)
+
+ result = np.asarray(sums / np.float32(width)).reshape(array.shape[:-1] + (1,))
+ return result if keepdims else result.squeeze(axis=-1)
+
+
+def trig(values, sine: bool):
+ """FP32 sine or cosine with Eigen's non-FMA range reduction polynomial.
+
+ The shared interval ``abs(x) < 18000`` is below both upstream non-FMA
+ cutoffs. Larger arguments and nonfinite values retain NumPy semantics.
+ This approximation can differ from NumPy by a few ULP; it is not a claim
+ of universally improved accuracy. Scalar and empty arrays are supported.
+ """
+ array = _fp32_array(values)
+ if not isinstance(sine, (bool, np.bool_)):
+ raise TypeError("sine must be boolean")
+ selected = np.isfinite(array) & (np.abs(array) < np.float32(18000))
+ result = np.array(np.sin(array) if sine else np.cos(array), dtype=np.float32, copy=True)
+ reduced = np.abs(array[selected])
+ rounded = reduced * np.float32(0.636619746685028076171875)
+ rounded = rounded + np.float32(12582912)
+ quadrant = rounded.view(np.uint32)
+ multiple = rounded - np.float32(12582912)
+ for coefficient in (
+ -1.5703125,
+ -0.000483989715576171875,
+ 1.62865035235881805419921875e-7,
+ 5.5644315544167710640977020375430583953857421875e-11,
+ ):
+ reduced = multiple * np.float32(coefficient) + reduced
+
+ squared = reduced * reduced
+ cosine = np.full_like(reduced, np.float32(2.4372266125283204019069671630859375e-5))
+ for coefficient in (
+ -0.00138865201734006404876708984375,
+ 0.041666619479656219482421875,
+ -0.5,
+ 1.0,
+ ):
+ cosine = cosine * squared + np.float32(coefficient)
+
+ sinpoly = np.full_like(
+ reduced,
+ np.float32(-0.0001959234114083702898469196984621021329076029360294342041015625),
+ )
+ sinpoly = sinpoly * squared + np.float32(
+ 0.00833268736556168516937947998712843400426208972930908203125
+ )
+ sinpoly = sinpoly * squared + np.float32(
+ -0.166666620398229825550373561782180331647396087646484375
+ )
+ sinpoly = sinpoly * squared
+ sinpoly = sinpoly * reduced + reduced
+
+ even = (quadrant & np.uint32(1)) == 0
+ if sine:
+ output = np.where(even, sinpoly, cosine)
+ sign = (array[selected].view(np.uint32) ^ (quadrant << np.uint32(30))) & np.uint32(
+ 0x80000000
+ )
+ else:
+ output = np.where(even, cosine, sinpoly)
+ sign = ((quadrant + np.uint32(1)) << np.uint32(30)) & np.uint32(0x80000000)
+ result[selected] = (output.view(np.uint32) ^ sign).view(np.float32)
+ return result
diff --git a/scratchv/verification/fp32_fma.py b/scratchv/verification/fp32_fma.py
new file mode 100644
index 0000000..d035212
--- /dev/null
+++ b/scratchv/verification/fp32_fma.py
@@ -0,0 +1,214 @@
+"""Correctly rounded finite FP32 fused multiply-add using NumPy only.
+
+No floating-point precision promotion is used. The integer fallback aligns
+exact significands in uint64 (or nine uint64 limbs), then performs one binary32
+round-to-nearest-even operation. It supports broadcasting, normals,
+subnormals and signed zero; NaN/Inf inputs and finite-result overflow raise.
+
+The FP32 error-free-transform fast path requires all three absolute inputs
+in [2**-40, 2**40], hence a/b low-part products cannot be smaller than 2**-126
+and no intermediate can overflow. Dekker TwoProduct and Knuth TwoSum give
+exact product_error and sum_error. Let s=fl(fl(a*b)+c), E=product_error+sum_error
+(exact), and r=fl(E). Only cases abs(fl(a*b))<=abs(s), with s not a power of two,
+are accepted. Then s has equal adjacent spacing u, abs(E)<=u, and abs(r)<=u.
+The only rounding boundaries reachable from s are s +/- u/2. If abs(r)==u/2,
+use the integer fallback. Otherwise r's distance from either boundary is at
+least one ulp(r), larger than abs(E-r)<=0.5 ulp(r); fl(s+r) is therefore the
+correct single-rounded result. Excluding powers of two avoids asymmetric
+binade spacing. Cancellation, zero, range boundaries not satisfying these
+conditions, midpoint ambiguity and all other cases use exact integers.
+
+The implementation assumes normal NumPy IEEE binary32 round-to-nearest-even
+operations. It does not change the host rounding mode or enable FTZ/DAZ.
+"""
+import numpy as np
+
+_U = np.uint64
+_I = np.int64
+
+
+def _topbit(x):
+ """floor(log2(x)), choosing zero for x=0; only integer shifts."""
+ x = x.copy()
+ result = np.zeros(x.shape, dtype=np.int64)
+ for shift in (32, 16, 8, 4, 2, 1):
+ high = x >> _U(shift)
+ selected = high != 0
+ result += np.where(selected, shift, 0)
+ x = np.where(selected, high, x)
+ return result
+
+
+def _unpack(array):
+ bits = array.view(np.uint32).reshape(-1)
+ exponent = (bits >> np.uint32(23)) & np.uint32(255)
+ if np.any(exponent == 255):
+ raise ValueError("finite float32 inputs required")
+ mantissa = (bits & np.uint32(0x7fffff)).astype(np.uint64)
+ mantissa |= np.where(exponent != 0, _U(1 << 23), _U(0))
+ scale = np.where(exponent != 0, exponent.astype(np.int64) - _I(150), _I(-149))
+ return bits >> np.uint32(31), mantissa, scale
+
+
+def _pack(sign, q, quantum):
+ carry = q == _U(1 << 24)
+ q = np.where(carry, q >> _U(1), q)
+ quantum = quantum + carry.astype(np.int64)
+ exponent = np.where(q >= _U(1 << 23), quantum + _I(150), _I(0))
+ if np.any(exponent >= 255):
+ raise FloatingPointError("fused result overflows finite float32")
+ bits = ((sign.astype(np.uint32) << np.uint32(31))
+ | (exponent.astype(np.uint32) << np.uint32(23))
+ | (q.astype(np.uint32) & np.uint32(0x7fffff)))
+ return bits.view(np.float32)
+
+
+def _round64(sign, magnitude, scale):
+ quantum = np.maximum(_topbit(magnitude) + scale - _I(23), _I(-149))
+ shift = quantum - scale
+ right = np.maximum(shift, _I(0)).astype(np.uint64)
+ left = np.maximum(-shift, _I(0)).astype(np.uint64)
+ q = (magnitude >> right) << left
+ guard_shift = np.maximum(shift - _I(1), _I(0)).astype(np.uint64)
+ guard = (shift > 0) & (((magnitude >> guard_shift) & _U(1)) != 0)
+ # For shift >=65 all magnitude bits are sticky, but the guard is zero.
+ mask = np.where(guard_shift >= _U(64), _U(0xffffffffffffffff),
+ (_U(1) << np.minimum(guard_shift, _U(63))) - _U(1))
+ sticky = (magnitude & mask) != 0
+ q += (guard & (sticky | ((q & _U(1)) != 0))).astype(np.uint64)
+ return _pack(sign, q, quantum)
+
+
+def _limbs(magnitude, scale):
+ # Smallest exact product quantum is 2^-298. Highest possible product bit
+ # index is 553; 9 _limbs (576 bits) also have room for the final addition.
+ result = np.zeros((9, magnitude.size), dtype=np.uint64)
+ shifts = scale + _I(298)
+ indices = np.arange(magnitude.size)
+ low = shifts // _I(64)
+ rem = (shifts % _I(64)).astype(np.uint64)
+ result[low, indices] = magnitude << rem
+ high = magnitude >> (_U(64) - rem)
+ selected = (low + 1 < 9) & (high != 0)
+ result[low[selected] + 1, indices[selected]] = high[selected]
+ return result
+
+
+def _slow(sign_p, product, ep, sign_c, cm, ec):
+ p, c = _limbs(product, ep), _limbs(cm, ec)
+ greater, less = np.zeros(product.size, dtype=bool), np.zeros(product.size, dtype=bool)
+ for index in range(8, -1, -1):
+ undecided = ~(greater | less)
+ greater |= undecided & (p[index] > c[index])
+ less |= undecided & (p[index] < c[index])
+ p_ge = ~less
+ same = sign_p == sign_c
+ sign = np.where(same | p_ge, sign_p, sign_c)
+ mag = np.zeros_like(p)
+ carry, borrow = np.zeros(product.size, dtype=np.uint64), np.zeros(product.size, dtype=np.uint64)
+ for index in range(9):
+ total = p[index] + c[index]
+ addition = total + carry
+ carry = ((total < p[index]) | (addition < total)).astype(np.uint64)
+ hi, lo = np.where(p_ge, p[index], c[index]), np.where(p_ge, c[index], p[index])
+ diff = hi - lo
+ subtraction = diff - borrow
+ borrow = ((hi < lo) | (subtraction > diff)).astype(np.uint64)
+ mag[index] = np.where(same, addition, subtraction)
+ exact_zero = ~np.any(mag != 0, axis=0)
+ sign = np.where(exact_zero & ~same, np.uint32(0), sign)
+ high_index = np.zeros(product.size, dtype=np.int64)
+ for index in range(9):
+ high_index = np.where(mag[index] != 0, index, high_index)
+ columns = np.arange(product.size)
+ highest = high_index * _I(64) + _topbit(mag[high_index, columns])
+ shift = np.maximum(highest - _I(23), _I(149))
+ index = shift // _I(64)
+ rem = (shift % _I(64)).astype(np.uint64)
+ padded = np.vstack((mag, np.zeros((1, product.size), dtype=np.uint64)))
+ q = (padded[index, columns] >> rem) | (padded[index + 1, columns] << (_U(64) - rem))
+ guard_index = (shift - _I(1)) // _I(64)
+ guard_rem = ((shift - _I(1)) % _I(64)).astype(np.uint64)
+ guard = ((mag[guard_index, columns] >> guard_rem) & _U(1)) != 0
+ mask = (_U(1) << guard_rem) - _U(1)
+ sticky = np.zeros(product.size, dtype=bool)
+ for index in range(9):
+ sticky |= ((index < guard_index) & (mag[index] != 0))
+ sticky |= ((index == guard_index) & ((mag[index] & mask) != 0))
+ q += (guard & (sticky | ((q & _U(1)) != 0))).astype(np.uint64)
+ return _pack(sign, q, shift - _I(298))
+
+
+def _integer_fma(a, b, c):
+ arrays = [np.asarray(x) for x in (a, b, c)]
+ if any(x.dtype != np.dtype("float32") for x in arrays):
+ raise TypeError("FMA requires native float32 inputs")
+ a, b, c = np.broadcast_arrays(*arrays)
+ sa, am, ae = _unpack(a)
+ sb, bm, be = _unpack(b)
+ sc, cm, ce = _unpack(c)
+ product, pe, sp = am * bm, ae + be, sa ^ sb
+ scale = np.where(product == 0, ce, np.where(cm == 0, pe, np.minimum(pe, ce)))
+ ps, cs = pe - scale, ce - scale
+ # Each aligned operand has <=63 significant bits. Their sum fits uint64
+ # (max 2^64-2), and opposite-sign subtraction is exact magnitude arithmetic.
+ fast = (((product == 0) | (_topbit(product) + ps < 63))
+ & ((cm == 0) | (_topbit(cm) + cs < 63)))
+ result = np.empty(product.shape, dtype=np.float32)
+ if np.any(fast):
+ p = product[fast] << np.maximum(ps[fast], _I(0)).astype(np.uint64)
+ cv = cm[fast] << np.maximum(cs[fast], _I(0)).astype(np.uint64)
+ same = sp[fast] == sc[fast]
+ p_ge = p >= cv
+ magnitude = np.where(same, p + cv, np.where(p_ge, p - cv, cv - p))
+ sign = np.where(same | p_ge, sp[fast], sc[fast])
+ sign = np.where((magnitude == 0) & ~same, np.uint32(0), sign)
+ result[fast] = _round64(sign, magnitude, scale[fast])
+ if np.any(~fast):
+ result[~fast] = _slow(sp[~fast], product[~fast], pe[~fast], sc[~fast], cm[~fast], ce[~fast])
+ return result.reshape(a.shape)
+
+
+def fma(a, b, c):
+ """Return round32(a*b+c), rejecting non-f32/nonfinite inputs and overflow."""
+ values = [np.asarray(value) for value in (a, b, c)]
+ if any(value.dtype != np.dtype("float32") for value in values):
+ raise TypeError("FMA requires native float32 inputs")
+ arrays = np.broadcast_arrays(*values)
+ shape = arrays[0].shape
+ a, b, c = [value.reshape(-1) for value in arrays]
+ lower = np.array(87 << 23, dtype=np.uint32).view(np.float32)
+ upper = np.array(167 << 23, dtype=np.uint32).view(np.float32)
+ bounded = np.ones(a.shape, dtype=bool)
+ for value in (a, b, c):
+ bounded &= (np.abs(value) >= lower) & (np.abs(value) <= upper)
+ indices = np.flatnonzero(bounded)
+ result = np.empty(a.shape, dtype=np.float32)
+ accepted = np.zeros(a.shape, dtype=bool)
+ if indices.size:
+ av, bv, cv = a[indices], b[indices], c[indices]
+ product = av * bv
+ split_a = np.float32(4097) * av
+ high_a = split_a - (split_a - av)
+ low_a = av - high_a
+ split_b = np.float32(4097) * bv
+ high_b = split_b - (split_b - bv)
+ low_b = bv - high_b
+ product_error = low_a * low_b - (
+ ((product - high_a * high_b) - low_a * high_b) - high_a * low_b)
+ total = product + cv
+ virtual_c = total - product
+ sum_error = (product - (total - virtual_c)) + (cv - virtual_c)
+ residual = product_error + sum_error
+ total_bits = total.view(np.uint32)
+ exponent = (total_bits >> np.uint32(23)) & np.uint32(255)
+ half_ulp = ((np.maximum(exponent, np.uint32(24)) - np.uint32(24))
+ << np.uint32(23)).view(np.float32)
+ safe = ((np.abs(product) <= np.abs(total))
+ & ((total_bits & np.uint32(0x7fffff)) != 0)
+ & (np.abs(residual) != half_ulp))
+ accepted[indices[safe]] = True
+ result[indices[safe]] = (total + residual)[safe]
+ if np.any(~accepted):
+ result[~accepted] = _integer_fma(a[~accepted], b[~accepted], c[~accepted])
+ return result.reshape(shape)
diff --git a/scratchv/verification/fp32_reference.py b/scratchv/verification/fp32_reference.py
new file mode 100644
index 0000000..24fbbc0
--- /dev/null
+++ b/scratchv/verification/fp32_reference.py
@@ -0,0 +1,269 @@
+"""Opt-in, fixed-order NumPy FP32 reference evaluation.
+
+This profile specifies evaluation order and polynomial approximations, not
+universally greater mathematical accuracy or bitwise equality to every ORT
+build/CPU. No model names, positions, weights, or expected outputs are used.
+Default interpreter execution continues to use the native NumPy kernels.
+
+MLAS polynomial constants/evaluation are adapted from ONNX Runtime v1.22.1:
+core/mlas/lib/logistic.cpp, compute.cpp, x86_64/TransKernelFma3.S and
+x86_64/TransKernelAvx512F.S (including their amd64 Windows equivalents).
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+from __future__ import annotations
+
+import os
+import re
+
+import numpy as np
+
+from scratchv.ir.types import OpCode
+from scratchv.verification.fp32_eigen import mean_last, trig
+from scratchv.verification.fp32_fma import fma
+
+
+_CPU_ENV = "SCRATCHV_FP32_REFERENCE_CPU"
+_CPU_STRATEGIES = ("avx2-fma3", "avx512")
+
+
+def _cpu_features():
+ # NumPy checks both hardware capabilities and usable OS vector state.
+ # This private diagnostic is optional: an explicit strategy works without it.
+ try:
+ from numpy._core._multiarray_umath import __cpu_features__
+ except ImportError:
+ try:
+ from numpy.core._multiarray_umath import __cpu_features__
+ except ImportError:
+ return {}
+ return __cpu_features__
+
+
+def _cpu_strategy(requested=None):
+ """Resolve a reference arithmetic policy; never change ORT dispatch.
+
+ Explicit policies also allow reproducing saved arithmetic on another CPU.
+ NumPy's disable list does not constrain MLAS, so automatic inference must
+ not treat deliberately hidden NumPy capabilities as hardware evidence.
+ """
+ requested = os.environ.get(_CPU_ENV, "auto") if requested is None else requested
+ if requested in _CPU_STRATEGIES:
+ return requested
+ if requested != "auto":
+ raise ValueError(f"{_CPU_ENV} must be auto, avx2-fma3, or avx512")
+ disabled = re.split(r"[\s,]+", os.environ.get("NPY_DISABLE_CPU_FEATURES", "").upper())
+ if any(feature in ("AVX", "AVX2", "FMA3") or feature.startswith("AVX512")
+ for feature in disabled):
+ raise ValueError(f"NPY_DISABLE_CPU_FEATURES obscures MLAS capabilities; set {_CPU_ENV} explicitly")
+ features = _cpu_features()
+ if features.get("AVX2") and features.get("FMA3"):
+ return "avx512" if features.get("AVX512F") else "avx2-fma3"
+ raise ValueError(f"Cannot infer a supported FP32 CPU strategy; set {_CPU_ENV} explicitly")
+
+
+def profile(cpu_strategy=None):
+ """Return a canonical arithmetic contract, independent of selection method.
+
+ Passing a supported explicit cpu_strategy validates a saved profile on a
+ different host without claiming that the local ORT uses that strategy.
+ """
+ strategy = _cpu_strategy(cpu_strategy)
+ lanes = 8 if strategy == "avx2-fma3" else 16
+ return {
+ "name": "numpy-fp32-reference-v4",
+ "dtype": "float32",
+ "cpu_strategy": strategy,
+ "matmul_k_block": 128,
+ "matmul_row_tile": 2 if lanes == 8 else None,
+ "matmul_row_tail": "zero-pad-to-two-then-trim" if lanes == 8 else "native",
+ "matmul_column_tail": "zero-pad-single-column-to-two-then-trim" if lanes == 8 else "native",
+ "matmul_layout": "contiguous-matrix-operands-per-k-block" if lanes == 8 else "native-strides",
+ "matmul_vector_policy": "native-numpy-vector-promotion",
+ "mean": "two-four-lane-last-axis",
+ "trig": "non-fused-range-reduction-polynomial",
+ "softmax": f"exp-polynomial-{lanes}-lane-sum-reciprocal-multiply",
+ "softmax_lanes": lanes,
+ "softmax_exp_lower_bound": float(np.float32(
+ -88.3762626647949 if lanes == 8 else -103.9720840454)),
+ "softmax_exp_scaling": "binary32-exponent-bits" if lanes == 8 else "ldexp",
+ "sigmoid": "bounded-rational-polynomial-clamped-to-[0,1]",
+ "multiply_add": "binary32-round-to-nearest-even",
+ "reference_basis": "ORT 1.22.1 CPU arithmetic; no ORT runtime dependency",
+ "scope": "Explicit FP32 reference evaluation; other dtypes unchanged. "
+ "CPU strategy specifies reference arithmetic, not ORT dispatch. "
+ "Not a promise of bitwise matching every CPU or ORT version.",
+ }
+
+
+def matmul(xs, attrs, dtype):
+ from scratchv.verification.ir_numpy_ops import OpError
+ a, b = xs
+ if "m" in attrs:
+ m, n, k = (attrs[key] for key in ("m", "n", "k"))
+ if a.ndim == b.ndim == 1:
+ a, b = a.reshape(m, k), b.reshape(k, n)
+ elif a.shape != (m, k) or b.shape != (k, n):
+ raise OpError("ShapeError", "MATMUL m/n/k disagree with tensor shapes")
+ # Preserve NumPy's existing vector-promotion arithmetic and shape errors.
+ if a.ndim < 2 or b.ndim < 2:
+ return np.matmul(a, b)
+ if a.shape[-1] != b.shape[-2]:
+ raise OpError("ShapeError", "MATMUL reduction dimensions differ")
+ strategy = _cpu_strategy()
+ if strategy == "avx512" and a.shape[-1] <= 128:
+ return np.matmul(a, b)
+ shape = np.broadcast_shapes(a.shape[:-2], b.shape[:-2]) + (a.shape[-2], b.shape[-1])
+ result = np.zeros(shape, dtype=np.float32)
+ if strategy == "avx512":
+ # Retain the existing wide-matrix policy. SkylakeX small-matrix kernels
+ # have a different reduction order from its ordinary wide GEMM path.
+ for start in range(0, a.shape[-1], 128):
+ result += np.matmul(a[..., start:start + 128], b[..., start:start + 128, :])
+ return result
+ # Haswell OpenBLAS 0.3.29's wider SGEMM tiles use two interleaved K
+ # accumulators on selected boundaries (sgemm_kernel_8x4_haswell_2.c).
+ # A fixed two-row tile avoids those boundaries; padding a single-row
+ # tail also avoids switching to a different GEMV reduction. This applies
+ # to K<=128 too: attention score products use exactly K=128.
+ if not a.shape[-2] or not b.shape[-1]:
+ return result
+ for start in range(0, a.shape[-1], 128):
+ # Packing once per K block also handles stepped/transposed inputs:
+ # non-BLAS NumPy strided loops have a different arithmetic order.
+ left = np.ascontiguousarray(a[..., start:start + 128])
+ right = np.ascontiguousarray(b[..., start:start + 128, :])
+ if left.shape[-2] % 2:
+ padded = np.zeros(left.shape[:-2] + (left.shape[-2] + 1, left.shape[-1]), dtype=np.float32)
+ padded[..., :-1, :] = left
+ left = padded
+ if right.shape[-1] == 1:
+ padded = np.zeros(right.shape[:-1] + (2,), dtype=np.float32)
+ padded[..., :1] = right
+ right = padded
+ for row in range(0, a.shape[-2], 2):
+ rows = min(2, a.shape[-2] - row)
+ product = np.matmul(left[..., row:row + 2, :], right)
+ result[..., row:row + rows, :] += product[..., :rows, :b.shape[-1]]
+ return result
+
+
+def reduce_mean(xs, attrs, dtype):
+ from scratchv.verification.ir_numpy_ops import OpError, axes, flag, reduce_mean as native
+ x = xs[0]
+ requested = attrs.get("axes")
+ selected = tuple(range(x.ndim)) if not requested else axes(requested, x.ndim)
+ if any(x.shape[a] == 0 for a in selected):
+ raise OpError("NumericError", "cannot reduce an empty dimension")
+ if x.ndim and selected == (x.ndim - 1,):
+ return mean_last(x, keepdims=flag(attrs.get("keepdims", True), "keepdims"))
+ return native(xs, attrs, dtype)
+
+
+_SIGMOID_P = tuple(np.float32(v) for v in (
+ 4.37031012579801e-11, 1.15627324459942e-7, 6.08574864600143e-5,
+ 8.51377133304701e-3, 2.48287947061529e-1))
+_SIGMOID_Q = tuple(np.float32(v) for v in (
+ 6.10247389755681e-13, 5.76102136993427e-9, 6.29106785017040e-6,
+ 1.70198817374094e-3, 1.16817656904453e-1, 9.93151921023180e-1))
+_EXP = tuple(np.float32(float.fromhex(v)) for v in (
+ "0x1.694000p-10", "0x1.125edcp-7", "0x1.555b5ap-5", "0x1.555450p-3",
+ "0x1.fffff6p-2", "0x1.000000p+0", "0x1.000000p+0"))
+
+
+def sigmoid(xs, attrs, dtype):
+ x = np.clip(xs[0], np.float32(-18), np.float32(18))
+ squared = x * x
+ numerator = np.full_like(x, _SIGMOID_P[0])
+ denominator = np.full_like(x, _SIGMOID_Q[0])
+ for coefficient in _SIGMOID_P[1:]:
+ numerator = fma(numerator, squared, coefficient)
+ for coefficient in _SIGMOID_Q[1:]:
+ denominator = fma(denominator, squared, coefficient)
+ # Rational-approximation roundoff can cross either saturation endpoint.
+ return np.clip((numerator * x) / denominator + np.float32(0.5),
+ np.float32(0), np.float32(1))
+
+
+def _exp_nonpositive(x, *, cpu_strategy="avx512"):
+ # The bounded polynomial's smallest result rounds to zero; masked -inf
+ # from stable subtraction is consequently normalized to probability zero.
+ x = np.maximum(x, np.float32(
+ -88.3762626647949 if cpu_strategy == "avx2-fma3" else -103.9720840454))
+ bias = np.float32(12582912)
+ rounded = fma(x, np.float32(1.44269504088896341), bias)
+ exponent = rounded - bias
+ x = fma(exponent, np.float32(-6.93145752e-1), x)
+ x = fma(exponent, np.float32(-1.42860677e-6), x)
+ polynomial = np.full_like(x, _EXP[0])
+ for coefficient in _EXP[1:]:
+ polynomial = fma(polynomial, x, coefficient)
+ if cpu_strategy == "avx2-fma3":
+ # FMA3 reconstructs 2**m directly in the binary32 exponent field.
+ # In particular m=-127 becomes zero, unlike AVX512's VSCALEFPS.
+ bits = (rounded.view(np.uint32) << np.uint32(23)) + np.uint32(0x3f800000)
+ return polynomial * bits.view(np.float32)
+ return np.ldexp(polynomial, exponent.astype(np.int32))
+
+
+def _sum_lanes(values, lanes):
+ sums = np.zeros(values.shape[:-1] + (lanes,), dtype=np.float32)
+ for start in range(0, values.shape[-1], lanes):
+ block = values[..., start:start + lanes]
+ sums[..., :block.shape[-1]] += block
+ if lanes == 16:
+ sums = sums[..., :8] + sums[..., 8:]
+ first = (sums[..., 0] + sums[..., 1]) + (sums[..., 2] + sums[..., 3])
+ last = (sums[..., 4] + sums[..., 5]) + (sums[..., 6] + sums[..., 7])
+ return (first + last)[..., None]
+
+
+def _sum_sixteen(values):
+ # Retain the named primitive for existing standalone arithmetic diagnostics.
+ return _sum_lanes(values, 16)
+
+
+def softmax(xs, attrs, dtype):
+ from scratchv.verification.ir_numpy_ops import OpError, axis
+ x = xs[0]
+ selected = axis(attrs.get("axis", -1), x.ndim)
+ if x.shape[selected] == 0:
+ raise OpError("NumericError", "SOFTMAX cannot normalize an empty axis")
+ x = np.moveaxis(x, selected, -1)
+ maximum = np.max(x, axis=-1, keepdims=True)
+ if not np.isfinite(maximum).all():
+ raise OpError("NumericError", "SOFTMAX row is entirely masked or nonfinite")
+ with np.errstate(over="ignore"):
+ reduced = x - maximum
+ strategy = _cpu_strategy()
+ weights = _exp_nonpositive(reduced, cpu_strategy=strategy)
+ result = weights * (np.float32(1) / _sum_lanes(
+ weights, 8 if strategy == "avx2-fma3" else 16))
+ return np.moveaxis(result, -1, selected)
+
+
+HANDLERS = {
+ OpCode.MATMUL: matmul,
+ OpCode.REDUCE_MEAN: reduce_mean,
+ OpCode.SOFTMAX: softmax,
+ OpCode.SIGMOID: sigmoid,
+ OpCode.COS: lambda xs, attrs, dtype: trig(xs[0], sine=False),
+ OpCode.SIN: lambda xs, attrs, dtype: trig(xs[0], sine=True),
+}
diff --git a/scratchv/verification/ir_interpreter.py b/scratchv/verification/ir_interpreter.py
index 1891229..6b1a45f 100644
--- a/scratchv/verification/ir_interpreter.py
+++ b/scratchv/verification/ir_interpreter.py
@@ -3,13 +3,15 @@
Integer ADD/SUB/MUL/NEG wrap at the declared width; DIV truncates toward zero
and rejects zero and min/-1. ALLOCA sizes are bytes; LOAD/STORE access the
first scalar slot only and reject reads before STORE. No host pointers exist.
-Every run owns fresh state and copies external arrays and returned results.
+Every run owns fresh state and, by default, copies external arrays and results.
+Explicit straight-line execution options can borrow immutable weights and
+release values after their final use. Returned results are always copied.
"""
from __future__ import annotations
from dataclasses import dataclass
-from typing import Mapping
+from typing import Callable, Mapping
import numpy as np
@@ -66,6 +68,7 @@ class ExecutionResult:
return_value: np.ndarray | None
executed_steps: int
diagnostics: tuple[VerificationError, ...] = ()
+ memory_stats: dict | None = None
@dataclass
@@ -74,6 +77,80 @@ class _MemorySlot:
initialized: bool = False
+def _backing_storage(array):
+ """Identify the owner of a view without keeping new array references alive."""
+ owner = array
+ seen = set()
+ while id(owner) not in seen:
+ seen.add(id(owner))
+ base = getattr(owner, "base", None)
+ if base is None and isinstance(owner, memoryview):
+ base = owner.obj
+ if base is None:
+ break
+ owner = base
+ try:
+ size = memoryview(owner).nbytes
+ except TypeError:
+ # Normal NumPy views (including broadcast/strided views) terminate in
+ # a buffer owner. Fall back to the root array for unusual owners.
+ size = getattr(owner, "nbytes", array.nbytes)
+ return id(owner), int(size)
+
+
+class _MemoryObservation:
+ """Optional instruction-boundary accounting; never releases/copies values."""
+
+ def __init__(self, values, params, globals_):
+ self.input_bytes = sum(values[name].nbytes for name in params)
+ self.initializer_bytes = sum(
+ values[name].nbytes for name in globals_ if name in values
+ )
+ self.peak_logical = 0
+ self.peak_storage = 0
+ self.observe(values)
+
+ @staticmethod
+ def snapshot(values, returned=None):
+ arrays = [value.storage if isinstance(value, _MemorySlot) else value
+ for value in values.values()]
+ if returned is not None:
+ arrays.append(returned)
+ storage = {}
+ for array in arrays:
+ key, size = _backing_storage(array)
+ storage[key] = max(size, storage.get(key, 0))
+ return sum(int(array.nbytes) for array in arrays), sum(storage.values())
+
+ def observe(self, values, returned=None):
+ logical, storage = self.snapshot(values, returned)
+ self.peak_logical = max(self.peak_logical, logical)
+ self.peak_storage = max(self.peak_storage, storage)
+
+ def finish(self, values, returned):
+ self.observe(values, returned)
+ logical, storage = self.snapshot(values)
+ return {
+ "input_logical_bytes": int(self.input_bytes),
+ "initializer_logical_bytes": int(self.initializer_bytes),
+ "peak_live_logical_bytes": self.peak_logical,
+ "peak_numpy_storage_bytes": self.peak_storage,
+ "retained_values": len(values),
+ "retained_logical_bytes": logical,
+ "retained_numpy_storage_bytes": storage,
+ "return_logical_bytes": 0 if returned is None else int(returned.nbytes),
+ "scope": "interpreter retained values at instruction boundaries; final return copy included in peaks",
+ "notes": [
+ "Logical bytes count each retained binding, including views and ALLOCA storage.",
+ "Storage bytes deduplicate shared backing buffer owners, including NumPy views.",
+ "Initializer bytes count bound referenced globals, including scalar global constants.",
+ "Retained values exclude the independent return copy; peaks include it.",
+ "Counts currently bound buffers, including borrowed initializers; excludes other caller-held arrays, temporary kernel buffers, Python objects and allocator overhead; not process RSS.",
+ "Observation does not change existing copying, value retention, control flow or numeric semantics.",
+ ],
+ }
+
+
_CONTROL_ATTRS = {
OpCode.FOR: {"start", "end", "step"},
OpCode.ENDFOR: set(),
@@ -85,6 +162,19 @@ class _MemorySlot:
OpCode.STORE: set(),
}
+# An explicit allow-list makes future effectful instructions fail closed in
+# the opt-in borrowing/liveness modes. Every listed kernel treats inputs as
+# immutable and returns an array or a view of an input.
+_PURE_OPS = {
+ OpCode.ADD, OpCode.SUB, OpCode.MUL, OpCode.DIV, OpCode.POW,
+ OpCode.NEG, OpCode.ABS, OpCode.COS, OpCode.SIN, OpCode.RECIPROCAL,
+ OpCode.EXP, OpCode.SQRT, OpCode.REDUCE_MEAN, OpCode.LOAD_CONST,
+ OpCode.CAST, OpCode.MATMUL, OpCode.RELU, OpCode.MAXPOOL, OpCode.SOFTMAX,
+ OpCode.GELU, OpCode.DOT, OpCode.CONV, OpCode.GEMM, OpCode.SIGMOID,
+ OpCode.TRANSPOSE, OpCode.RESHAPE, OpCode.CONCAT, OpCode.GATHER,
+ OpCode.SLICE, OpCode.UNSQUEEZE, OpCode.EXPAND,
+}
+
class IRInterpreter:
def __init__(self, program: Program):
@@ -97,7 +187,32 @@ def run(
initializers: Mapping[str, np.ndarray] | None = None,
function_name: str | None = None,
max_steps: int = 1_000_000,
+ collect_memory_stats: bool = False,
+ copy_initializers: bool = True,
+ memory_mode: str = "retain_all",
+ observer: Callable[[str, np.ndarray], None] | None = None,
+ fp32_mode: str = "native",
) -> ExecutionResult:
+ """Run verified IR with strict bindings.
+
+ ``copy_initializers=False`` borrows only read-only NumPy arrays. The
+ caller must not mutate their backing storage for the duration of this
+ synchronous call. ``memory_mode='last_use'`` releases bindings after
+ their final instruction use; it does not skip dead instructions or
+ their errors. Both options require a pure, single-block SSA function
+ ending in one RETURN; unsupported control flow fails explicitly.
+
+ ``observer`` receives each numeric destination and a temporary
+ read-only view after validation, before reclamation. It must not mutate
+ backing storage or retain arrays if bounded memory is desired. Save
+ selected checkpoints synchronously; observer allocations are excluded
+ from interpreter accounting. Inputs and results are always copied.
+
+ ``fp32_mode='reference'`` selects a versioned NumPy FP32 evaluation
+ order and polynomial profile for numerical comparisons. It does not
+ call ORT, change graph optimization, or change non-FP32 kernels. The
+ default ``native`` retains the original NumPy evaluation policy.
+ """
if not isinstance(inputs, Mapping) or (
initializers is not None and not isinstance(initializers, Mapping)
):
@@ -112,6 +227,16 @@ def run(
raise IRExecutionError(
"InvalidOptions", "max_steps must be positive integer"
)
+ if not isinstance(collect_memory_stats, bool):
+ raise IRExecutionError("InvalidOptions", "collect_memory_stats must be boolean")
+ if not isinstance(copy_initializers, bool):
+ raise IRExecutionError("InvalidOptions", "copy_initializers must be boolean")
+ if not isinstance(memory_mode, str) or memory_mode not in ("retain_all", "last_use"):
+ raise IRExecutionError("InvalidOptions", "memory_mode must be retain_all or last_use")
+ if observer is not None and not callable(observer):
+ raise IRExecutionError("InvalidOptions", "observer must be callable or None")
+ if not isinstance(fp32_mode, str) or fp32_mode not in ("native", "reference"):
+ raise IRExecutionError("InvalidOptions", "fp32_mode must be native or reference")
passed, issues = verify_ir(self.program, stage="before-execution")
if not passed:
issue = next(i for i in issues if i.level.value == "error")
@@ -159,6 +284,20 @@ def error(code, message, position=None, instr=None, value_name=None):
value_name=value_name,
)
+ last_uses = None
+ if memory_mode == "last_use" or not copy_initializers:
+ if len(function.blocks) != 1 or function.blocks[0].phi_nodes:
+ raise error("InvalidOptions", "memory optimization requires a pure single-block function")
+ instructions = function.blocks[0].instructions
+ if (not instructions or instructions[-1].opcode != OpCode.RETURN
+ or any(inst.opcode not in _PURE_OPS for inst in instructions[:-1])):
+ raise error("InvalidOptions", "memory optimization requires pure instructions and one final RETURN")
+ if memory_mode == "last_use":
+ last_uses = {}
+ for index, inst in enumerate(instructions):
+ for operand in inst.operands:
+ last_uses[operand.name] = index
+
for block in function.blocks:
for index, instr in enumerate(block.instructions):
position = IRSourcePosition(block.name, index)
@@ -241,7 +380,12 @@ def checked_array(value, data, *, copy=False):
for name in referenced & set(globals_):
value = globals_[name]
if name in initializers:
- data = checked_array(value, initializers[name], copy=True)
+ data = checked_array(value, initializers[name], copy=copy_initializers)
+ if not copy_initializers:
+ if data.flags.writeable:
+ raise error("BindingError", "borrowed initializer must be read-only", value_name=name)
+ data = data.view()
+ data.setflags(write=False)
if value.is_constant:
literal = np.asarray(value.const_value, dtype=DTYPES[value.dtype])
if data.shape != () or not np.array_equal(data, literal):
@@ -258,6 +402,31 @@ def checked_array(value, data, *, copy=False):
"BindingError", "global tensor data missing", value_name=name
)
+ memory = _MemoryObservation(values, params, globals_) if collect_memory_stats else None
+ reclaimed_bindings = 0
+
+ def reclaim(names):
+ nonlocal reclaimed_bindings
+ for name in names:
+ if name in values:
+ del values[name]
+ reclaimed_bindings += 1
+
+ if last_uses is not None:
+ reclaim([name for name in values if name not in last_uses])
+
+ def memory_result(returned):
+ if memory is None:
+ return None
+ stats = memory.finish(values, returned)
+ if memory_mode != "retain_all" or not copy_initializers or observer is not None:
+ stats.update(memory_mode=memory_mode, copy_initializers=copy_initializers,
+ reclaimed_bindings=reclaimed_bindings, observer_enabled=observer is not None)
+ stats["notes"].append(
+ "Opt-in policy applies: borrowed buffers remain resident if retained by the caller; "
+ "reclaimed bindings and observer allocations are not process RSS reductions.")
+ return stats
+
adapter = IRCFGAdapter(function)
cfg = build_cfg(adapter)
plan = adapter.execution_plan
@@ -326,7 +495,8 @@ def resolve(value):
operands = [resolve(v) for v in instr.operands]
if op == OpCode.RETURN:
if not operands:
- return ExecutionResult(None, steps, tuple(issues))
+ return ExecutionResult(None, steps, tuple(issues),
+ memory_result(None))
value = operands[0]
if not isinstance(value, np.ndarray):
raise OpError("MemoryError", "cannot return memory reference")
@@ -335,13 +505,17 @@ def resolve(value):
and not np.isfinite(value).all()
):
raise OpError("NumericError", "return value must be finite")
- return ExecutionResult(value.copy(), steps, tuple(issues))
+ returned = value.copy()
+ return ExecutionResult(returned, steps, tuple(issues),
+ memory_result(returned))
if op == OpCode.ALLOCA:
size = instr.attrs.get("size", 4)
dtype = DTYPES[instr.dest.dtype]
values[instr.dest.name] = _MemorySlot(
np.empty(size // dtype.itemsize, dtype=dtype)
)
+ if memory:
+ memory.observe(values)
continue
if op in (OpCode.LOAD, OpCode.STORE):
slot = operands[0]
@@ -377,7 +551,8 @@ def resolve(value):
bounds = np.iinfo(np.int32)
if total < bounds.min or total > bounds.max:
raise OpError("NumericError", "loop counter overflows i32")
- result = compute(instr, operands)
+ result = (compute(instr, operands) if fp32_mode == "native"
+ else compute(instr, operands, fp32_mode=fp32_mode))
if result.dtype != DTYPES[instr.dest.dtype]:
raise OpError(
"DTypeError",
@@ -393,6 +568,25 @@ def resolve(value):
f"result expected {instr.dest.shape}, got {result.shape}",
)
values[instr.dest.name] = result
+ if observer is not None:
+ observed = result.view()
+ observed.setflags(write=False)
+ try:
+ observer(instr.dest.name, observed)
+ except Exception as exc:
+ raise error("ObserverError", str(exc), position, instr) from exc
+ finally:
+ del observed
+ if memory:
+ memory.observe(values)
+ if last_uses is not None:
+ index = position.instruction_index
+ reclaim({value.name for value in instr.operands
+ if last_uses.get(value.name) == index}
+ | ({instr.dest.name} if instr.dest.name not in last_uses else set()))
+ # Do not accidentally pin reclaimed arrays in loop locals.
+ operands = []
+ result = None
except OpError as exc:
raise error(exc.code, str(exc), position, instr) from exc
except FloatingPointError as exc:
diff --git a/scratchv/verification/ir_numpy_ops.py b/scratchv/verification/ir_numpy_ops.py
index 92baeab..432ff02 100644
--- a/scratchv/verification/ir_numpy_ops.py
+++ b/scratchv/verification/ir_numpy_ops.py
@@ -183,12 +183,15 @@ def check_instruction(instr: Instruction):
raise OpError("AttributeError", f"{key} must be finite numeric")
-def compute(instr, operands):
+def compute(instr, operands, *, fp32_mode="native"):
+ handler = KERNELS[instr.opcode].handler
+ dtype = DTYPES[instr.dest.dtype]
+ if fp32_mode == "reference" and dtype == np.dtype("float32"):
+ from scratchv.verification.fp32_reference import HANDLERS
+ handler = HANDLERS.get(instr.opcode, handler)
with np.errstate(over="raise", divide="raise", invalid="raise", under="ignore"):
result = np.asarray(
- KERNELS[instr.opcode].handler(
- operands, instr.attrs, DTYPES[instr.dest.dtype]
- )
+ handler(operands, instr.attrs, dtype)
)
if np.issubdtype(result.dtype, np.floating) and not np.isfinite(result).all():
raise OpError("NumericError", "operation produced nonfinite output")
diff --git a/scripts/ci_scopes.json b/scripts/ci_scopes.json
index f83c8f5..578d71f 100644
--- a/scripts/ci_scopes.json
+++ b/scripts/ci_scopes.json
@@ -28,7 +28,11 @@
"tests/test_w2_*.py",
"tests/test_numeric_metrics.py",
"tests/test_numeric_summary.py",
- ".github/workflows/llm-deploy.yml"
+ ".github/workflows/llm-deploy.yml",
+ "scripts/summarize_w3_ci.py",
+ "tests/test_w3_actions_summary.py",
+ "tests/test_w3_workflows.py",
+ ".github/workflows/w3-*.yml"
],
"w4": []
}
diff --git a/scripts/collect_w3_ci_evidence.py b/scripts/collect_w3_ci_evidence.py
new file mode 100644
index 0000000..8a65315
--- /dev/null
+++ b/scripts/collect_w3_ci_evidence.py
@@ -0,0 +1,172 @@
+"""Retain bounded diagnostic evidence, with an explicit inventory of omissions."""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import stat
+
+
+MIB = 1024**2
+MAX_FILE_BYTES = 256 * MIB
+MAX_TOTAL_BYTES = 512 * MIB
+MAX_REPORT_BYTES = 32 * MIB
+FAILURE_SUFFIXES = {".npz", ".npy", ".onnx", ".log", ".stdout", ".stderr"}
+
+
+def collect(source, destination, *, max_file_bytes=MAX_FILE_BYTES, max_total_bytes=MAX_TOTAL_BYTES):
+ """Copy selected evidence; omissions remain visible even after raw artifacts expire.
+
+ This inventories copied bytes, but does not rerun any numerical gate. The CLI
+ exits unsuccessfully when selection is incomplete; other safe files survive.
+ """
+ for limit in (max_file_bytes, max_total_bytes):
+ if type(limit) is not int or limit <= 0:
+ raise ValueError("Evidence byte limits must be positive integers")
+ source, destination = Path(source).resolve(), Path(destination).resolve()
+ if destination.is_relative_to(source):
+ raise ValueError("Evidence destination must be outside its source directory")
+ destination.mkdir(parents=True, exist_ok=False)
+ selected, omitted = {}, []
+
+ def omit(path, reason, **details):
+ omitted.append({"path": str(path.relative_to(source)), "reason": reason, **details})
+
+ def safe(path):
+ if not path.resolve().is_relative_to(source):
+ raise ValueError("Evidence path escapes source directory")
+
+ def scan(folder, suffixes, names=(), *, required=False):
+ try:
+ safe(folder)
+ if not folder.exists():
+ if required:
+ omit(folder, "Missing case evidence directory")
+ return
+ # Never follow linked directories while searching for failure evidence.
+ def walk_error(error):
+ omit(folder, f"Cannot scan evidence: {error}")
+
+ for root, dirs, files in os.walk(folder, followlinks=False, onerror=walk_error):
+ root = Path(root)
+ for name in list(dirs):
+ child = root / name
+ if child.is_symlink() or not child.resolve().is_relative_to(source):
+ dirs.remove(name)
+ omit(child, "Linked or external evidence directory")
+ dirs.sort()
+ for name in sorted(files):
+ path = root / name
+ if path.suffix in suffixes or name in names:
+ selected[path] = None
+ except (OSError, ValueError) as exc:
+ omit(folder, str(exc))
+
+ # First priority: the exact trace selected by the independent layer-diff gate.
+ for name in ("trace_schema.json", "traces/short_17/ir_diagnostic_all.npz",
+ "traces/short_17/ort_diagnostic.npz"):
+ selected[source / "medium" / name] = None
+ # Original target logs permit inspection of UART/protocol failures.
+ scan(source / "attention", {".log", ".stdout", ".stderr"}, {"uart.bin"})
+ for gate in ("medium", "subgraphs", "attention"):
+ folder = source / gate
+ report_path = folder / "report.json"
+ if not report_path.exists():
+ # Interrupted runs may have raw evidence but no final report.
+ omit(report_path, "Missing gate report; collected available diagnostics")
+ scan(folder, FAILURE_SUFFIXES, {"uart.bin"})
+ continue
+ try:
+ safe(report_path)
+ info = report_path.stat()
+ if not stat.S_ISREG(info.st_mode):
+ raise ValueError("Report is not a regular file")
+ if info.st_size > MAX_REPORT_BYTES:
+ raise ValueError("Report exceeds size limit")
+ report = json.loads(report_path.read_text(encoding="utf-8"))
+ if not isinstance(report, dict):
+ raise ValueError("Report must be an object")
+ if report.get("passed") is True:
+ continue
+ rows = report.get("cases", [])
+ if not isinstance(rows, list) or any(not isinstance(row, dict) for row in rows):
+ raise ValueError("Report cases must be a list of objects")
+ failed = [row for row in rows if row.get("passed") is not True]
+ # An invariant can fail after all individual comparisons have passed.
+ for row in failed or rows:
+ name = row.get("name")
+ if not isinstance(name, str) or not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]*", name):
+ raise ValueError("Invalid case evidence directory name")
+ case_folder = folder / ("traces" if gate == "medium" else "") / name
+ if not case_folder.resolve().is_relative_to(folder.resolve()):
+ raise ValueError("Case evidence escapes its gate directory")
+ scan(case_folder, FAILURE_SUFFIXES, {"uart.bin"}, required=True)
+ if not rows:
+ scan(folder, FAILURE_SUFFIXES, {"uart.bin"})
+ except (OSError, ValueError) as exc:
+ omit(report_path, f"Cannot select cases from report: {exc}")
+ scan(folder, FAILURE_SUFFIXES, {"uart.bin"})
+
+ records, total = [], 0
+ for path in selected:
+ relative = path.relative_to(source)
+ target = destination / relative
+ try:
+ safe(path)
+ info = path.stat()
+ if not stat.S_ISREG(info.st_mode):
+ raise ValueError("Evidence is not a regular file")
+ if info.st_size > max_file_bytes:
+ raise ValueError("Evidence exceeds per-file byte limit")
+ if info.st_size > max_total_bytes - total:
+ raise ValueError("Evidence exceeds remaining total byte limit")
+ target.parent.mkdir(parents=True, exist_ok=True)
+ digest, copied = hashlib.sha256(), 0
+ with path.open("rb") as src, target.open("xb") as dst:
+ while chunk := src.read(MIB):
+ copied += len(chunk)
+ if copied > min(max_file_bytes, max_total_bytes - total):
+ raise ValueError("Evidence grew beyond byte limit during collection")
+ dst.write(chunk)
+ digest.update(chunk)
+ total += copied
+ records.append({"path": str(relative), "bytes": copied, "sha256": digest.hexdigest()})
+ except (OSError, ValueError) as exc:
+ target.unlink(missing_ok=True)
+ omit(path, str(exc))
+
+ files = [record["path"] for record in records]
+ manifest = {
+ "schema_version": 1,
+ "scope": "Selected preparation trace and failure diagnostics only; not complete W3 raw evidence.",
+ "independent_full_revalidation": False,
+ "validation": "Copy inventory and SHA256 only; this collector does not perform numerical validation.",
+ "selection_complete": not omitted,
+ "limits": {"max_file_bytes": max_file_bytes, "max_total_bytes": max_total_bytes},
+ "retained_bytes": total,
+ "files": records,
+ "omitted": omitted,
+ }
+ (destination / "retained-files.json").write_text(json.dumps(files, indent=2) + "\n", encoding="utf-8")
+ (destination / "retained-evidence.json").write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+ return files
+
+
+def main(argv=None):
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument("--source", type=Path, required=True)
+ parser.add_argument("--destination", type=Path, required=True)
+ args = parser.parse_args(argv)
+ collect(args.source, args.destination)
+ manifest = json.loads((args.destination / "retained-evidence.json").read_text(encoding="utf-8"))
+ if not manifest["selection_complete"]:
+ print(f"Evidence selection incomplete: {len(manifest['omitted'])} omissions; see retained-evidence.json")
+ return 1
+ return 0
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/scripts/package_w3_repro.py b/scripts/package_w3_repro.py
new file mode 100644
index 0000000..3573c65
--- /dev/null
+++ b/scripts/package_w3_repro.py
@@ -0,0 +1,216 @@
+"""Create/verify a bounded, content-addressed W3 source handoff without committing.
+
+This preserves source bytes, not Git history, model assets or execution results.
+The manifest is an integrity inventory, not a signature or numerical acceptance.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path, PurePosixPath
+import subprocess
+import zipfile
+
+
+ROOT = Path(__file__).resolve().parents[1]
+MANIFEST = "W3_SOURCE_MANIFEST.json"
+SCHEMA_VERSION = 2
+ROOT_FILES = {"pyproject.toml", "README.md", "LICENSE", "THIRD_PARTY_NOTICES.txt",
+ ".gitignore", ".gitattributes"}
+TREES = {"scratchv", "scratchv_dag", "benchmarks", "examples", "probes", "scripts", "requirements",
+ "tests", "LICENSES"}
+EXCLUDED_PARTS = {".git", "__pycache__", "output", "out", "build", "dist", ".venv",
+ "venv", ".pytest_cache", ".mypy_cache", ".ruff_cache"}
+EXCLUDED_SUFFIXES = {".onnx", ".data", ".safetensors", ".npy", ".npz", ".pyc",
+ ".elf", ".bin", ".zip", ".pt", ".pth", ".exe", ".dll"}
+MAX_FILE_BYTES = 8 * 1024**2
+MAX_TOTAL_BYTES = 64 * 1024**2
+REQUIRED = {"pyproject.toml", "LICENSE", "scripts/package_w3_repro.py",
+ "probes/w3_qwen3_full/run.py", "requirements/qwen3-small-probe.txt",
+ "examples/run_ir_interpreter.py",
+ "docs/llm-deploy-v1.0/LINUX_REPRODUCTION.md",
+ "docs/llm-deploy-v1.0/W3/README.md"}
+REPRODUCTION = {"platform": "linux", "shell": "bash",
+ "guide": "docs/llm-deploy-v1.0/LINUX_REPRODUCTION.md",
+ "stage_guide": "docs/llm-deploy-v1.0/W3/README.md"}
+
+
+def digest(data):
+ return hashlib.sha256(data).hexdigest()
+
+
+def safe_name(name):
+ if not isinstance(name, str):
+ raise ValueError("Unsafe manifest path")
+ path = PurePosixPath(name)
+ if (not name or "\\" in name or ":" in name
+ or path.is_absolute() or any(x in ("", ".", "..") for x in name.split("/"))):
+ raise ValueError("Unsafe manifest path")
+ return path
+
+
+def included(name):
+ path = safe_name(name)
+ if any(x in EXCLUDED_PARTS or x.startswith(".env") for x in path.parts):
+ return False
+ if path.suffix.lower() in EXCLUDED_SUFFIXES:
+ return False
+ return (name in ROOT_FILES or path.parts[0] in TREES
+ or name.startswith("docs/llm-deploy-v1.0/")
+ or (name.startswith(".github/workflows/w3-") and path.suffix in (".yml", ".yaml")))
+
+
+def git(root, *args):
+ result = subprocess.run(["git", "-C", str(root), *args], check=True,
+ capture_output=True, timeout=30)
+ return result.stdout
+
+
+def candidates(root):
+ raw = git(root, "ls-files", "-z", "--cached", "--others", "--exclude-standard")
+ return sorted({name for value in raw.split(b"\0") if value
+ if included(name := value.decode("utf-8"))
+ and ((root/name).exists() or (root/name).is_symlink())})
+
+
+def read_source(root, name):
+ path = root / name
+ # Reject links including links in parents, even when pointing inside the tree.
+ for part in (path, *path.parents):
+ if part == root:
+ break
+ if part.is_symlink():
+ raise ValueError(f"Linked source is not supported: {name}")
+ if not path.resolve().is_relative_to(root) or not path.is_file():
+ raise ValueError(f"Missing or external source: {name}")
+ if path.stat().st_size > MAX_FILE_BYTES:
+ raise ValueError(f"Source exceeds file limit: {name}")
+ with path.open("rb") as stream:
+ value = stream.read(MAX_FILE_BYTES + 1)
+ if len(value) > MAX_FILE_BYTES:
+ raise ValueError(f"Source grew beyond file limit: {name}")
+ return value
+
+
+def snapshot_id(files):
+ return digest(json.dumps(files, ensure_ascii=False, sort_keys=True,
+ separators=(",", ":")).encode("utf-8"))
+
+
+def create(root, output):
+ root, output = Path(root).resolve(), Path(output).resolve()
+ checksum = output.with_suffix(output.suffix + ".sha256")
+ if output.exists() or checksum.exists():
+ raise ValueError("Archive and checksum must use fresh paths")
+ payload, total = {}, 0
+ for name in candidates(root):
+ value = read_source(root, name)
+ total += len(value)
+ if total > MAX_TOTAL_BYTES:
+ raise ValueError("Source snapshot exceeds total size limit")
+ payload[name] = value
+ for required in REQUIRED:
+ if required not in payload:
+ raise ValueError(f"Missing required source: {required}")
+ files = [{"path": name, "bytes": len(value), "sha256": digest(value)}
+ for name, value in payload.items()]
+ manifest = {"schema_version": SCHEMA_VERSION, "snapshot_id": snapshot_id(files),
+ "base_commit": git(root, "rev-parse", "HEAD").decode().strip(),
+ "scope": "Selected current working-tree source bytes; includes uncommitted W3 files.",
+ "excludes": "Git history, model weights/binaries, environments and run evidence.",
+ "reproduction": dict(REPRODUCTION),
+ "is_commit": False, "numerical_acceptance": False, "files": files}
+ if candidates(root) != list(payload):
+ raise ValueError("Source inventory changed during packaging; retry after edits finish")
+ for name, value in payload.items():
+ if digest(read_source(root, name)) != digest(value):
+ raise ValueError(f"Source changed during packaging: {name}")
+ output.parent.mkdir(parents=True, exist_ok=True)
+ with zipfile.ZipFile(output, "x", compression=zipfile.ZIP_DEFLATED) as archive:
+ for name, value in [*payload.items(), (MANIFEST, json.dumps(
+ manifest, ensure_ascii=False, indent=2).encode("utf-8") + b"\n")]:
+ info = zipfile.ZipInfo(name, date_time=(1980, 1, 1, 0, 0, 0))
+ info.compress_type = zipfile.ZIP_DEFLATED
+ info.external_attr = 0o100644 << 16
+ archive.writestr(info, value)
+ archive_hash = digest(output.read_bytes())
+ with checksum.open("x", encoding="utf-8", newline="\n") as stream:
+ stream.write(f"{archive_hash} {output.name}\n")
+ return {"snapshot_id": manifest["snapshot_id"], "files": len(files),
+ "source_bytes": total, "archive": str(output), "archive_sha256": archive_hash,
+ "base_commit": manifest["base_commit"], "is_commit": False}
+
+
+def verify(root, expected_snapshot_id=None):
+ root = Path(root).resolve()
+ manifest = json.loads(read_source(root, MANIFEST))
+ if (not isinstance(manifest, dict) or manifest.get("schema_version") != SCHEMA_VERSION
+ or not isinstance(manifest.get("files"), list)):
+ raise ValueError("Unsupported source manifest")
+ if manifest.get("reproduction") != REPRODUCTION:
+ raise ValueError("Source manifest must declare the Linux reproduction contract")
+ files = manifest["files"]
+ if not files:
+ raise ValueError("Empty source manifest")
+ actual_id = snapshot_id(files)
+ if actual_id != manifest.get("snapshot_id") or (expected_snapshot_id is not None
+ and actual_id != expected_snapshot_id):
+ raise ValueError("Snapshot identity mismatch")
+ seen, total = set(), 0
+ for entry in files:
+ if not isinstance(entry, dict) or set(entry) != {"path", "bytes", "sha256"}:
+ raise ValueError("Invalid source file descriptor")
+ name = entry["path"]
+ if not isinstance(name, str) or not included(name) or name in seen:
+ raise ValueError("Unexpected or duplicate source path")
+ seen.add(name)
+ value = read_source(root, name)
+ total += len(value)
+ if total > MAX_TOTAL_BYTES or type(entry["bytes"]) is not int:
+ raise ValueError("Invalid source byte inventory")
+ if len(value) != entry["bytes"] or digest(value) != entry["sha256"]:
+ raise ValueError(f"Source bytes differ: {name}")
+ if not REQUIRED.issubset(seen):
+ raise ValueError("Manifest is missing required source files")
+ # Output directories and external models are allowed; added source is not.
+ for folder in [*(root/x for x in TREES), root/"docs/llm-deploy-v1.0", root/".github/workflows"]:
+ if folder.exists():
+ for directory, dirs, names in os.walk(folder, followlinks=False):
+ dirs[:] = [name for name in dirs if name not in EXCLUDED_PARTS]
+ if any((Path(directory)/name).is_symlink() for name in dirs):
+ raise ValueError("Linked source directory is not supported")
+ for filename in names:
+ path = Path(directory) / filename
+ name = path.relative_to(root).as_posix()
+ if included(name) and name not in seen:
+ raise ValueError(f"Unlisted source file: {name}")
+ for name in ROOT_FILES:
+ if (root/name).exists() and name not in seen:
+ raise ValueError(f"Unlisted root source: {name}")
+ return {"passed": True, "snapshot_id": actual_id, "files": len(seen),
+ "source_bytes": total, "claim": "Source integrity only; no numerical or team acceptance."}
+
+
+def main(argv=None):
+ parser = argparse.ArgumentParser(description=__doc__)
+ sub = parser.add_subparsers(dest="command", required=True)
+ make = sub.add_parser("create")
+ make.add_argument("--source-root", type=Path, default=ROOT)
+ make.add_argument("--output", type=Path, required=True)
+ check = sub.add_parser("verify")
+ check.add_argument("--root", type=Path, default=ROOT)
+ check.add_argument("--expected-snapshot-id")
+ args = parser.parse_args(argv)
+ try:
+ result = create(args.source_root, args.output) if args.command == "create" else verify(
+ args.root, args.expected_snapshot_id)
+ except (OSError, ValueError, subprocess.SubprocessError) as exc:
+ parser.exit(1, f"W3 source snapshot failed: {exc}\n")
+ print(json.dumps(result, ensure_ascii=False, indent=2))
+ return 0
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/scripts/run_w3_preparation.py b/scripts/run_w3_preparation.py
new file mode 100644
index 0000000..ebef39f
--- /dev/null
+++ b/scripts/run_w3_preparation.py
@@ -0,0 +1,368 @@
+"""Run the five W3 preparation checks; this is not W3 full-model acceptance."""
+from __future__ import annotations
+import argparse
+import json
+import math
+import os
+from pathlib import Path
+import subprocess
+import sys
+import time
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+ sys.path.insert(0,str(ROOT))
+from probes.w3_common import new_output_dir, source_evidence, sha256_file, write_reports
+from probes.w3_qwen3_full.resources import spawn_owned, terminate_process_tree, wait_bounded
+
+GATES = ("medium","subgraphs","attention","full-preflight","layer-diff")
+IDENTITIES = {"medium":"w3-medium-host","subgraphs":"w3_qwen3_subgraphs",
+ "attention":"unit:attention-backend","full-preflight":"preflight:w3-full-assets",
+ "layer-diff":"w3_layer_diff"}
+LEVELS = ("none", "basic", "all")
+GRAPH_KINDS = ("normal", "diagnostic")
+MEDIUM_CASES = (("full_seed_0",256),("full_seed_42",256),("one_token",1),
+ ("short_17",17),("short_255",255),("changed_future",256),("changed_padding",17))
+MEDIUM_CHECKPOINTS = ("token_embedding",) + tuple(
+ f"layer_{layer}.{name}" for layer in range(6) for name in
+ ("input_norm","q_norm","k_norm","v_proj","rope_q","rope_k","attn_probs","attn_context",
+ "attn_output","attn_residual","post_attention_norm","mlp","residual")) + ("final_norm","logits")
+SUBGRAPH_CASES = ("projection_q","projection_k","projection_v","projection_o","rmsnorm_hidden",
+ "rmsnorm_q","rope_q","rmsnorm_k","rope_k","gqa_full","gqa_padding",
+ "gqa_changed_padding","gqa_changed_future","swiglu")
+ATTENTION_CASES = (("full17",17),("padding17",5),("future17",17),
+ ("padding_changed17",5),("single17",1),("boundary256",255))
+MEMORY_FIELDS = ("input_logical_bytes","initializer_logical_bytes","peak_live_logical_bytes",
+ "peak_numpy_storage_bytes","retained_values","retained_logical_bytes",
+ "retained_numpy_storage_bytes","return_logical_bytes")
+
+def require(condition, message):
+ if not condition:
+ raise ValueError(message)
+
+def check_numeric(value, atol):
+ if isinstance(value,dict):
+ if "passed" in value:
+ require(value["passed"] is True, "A nested required comparison failed")
+ for key,item in value.items():
+ if key in ("max_abs","max_abs_error") and item is not None:
+ require(type(item) in (int,float) and math.isfinite(item) and 0 <= item < atol,
+ f"Numeric error exceeds {atol}")
+ check_numeric(item,atol)
+ elif isinstance(value,list):
+ for item in value:
+ check_numeric(item,atol)
+ elif isinstance(value,float):
+ require(math.isfinite(value),"Nonfinite number in evidence")
+
+
+def checked_keys(value, keys, label):
+ require(isinstance(value,dict) and set(value)==set(keys),f"Missing/extra {label}")
+ return value
+
+
+def checked_rows(rows, identities, fields, label):
+ require(isinstance(rows,list) and all(isinstance(row,dict) for row in rows),f"Missing {label}")
+ actual = [tuple(row.get(field) for field in fields) for row in rows]
+ require(len(actual)==len(identities) and set(actual)==set(identities),f"Missing/duplicate {label}")
+ return rows
+
+
+def checked_tensor(row, atol):
+ require(isinstance(row,dict) and row.get("passed") is True,"Missing passing tensor comparison")
+ require(row.get("finite") is True and row.get("shape_matches") is True,"Missing finite/shape proof")
+ actual_shape = row.get("actual_shape",row.get("shape"))
+ require(isinstance(actual_shape,list) and actual_shape==row.get("expected_shape"),"Tensor shape mismatch")
+ require(row.get("actual_dtype",row.get("dtype"))==row.get("expected_dtype")=="float32","Missing FP32 proof")
+ maximum = row.get("max_abs",row.get("max_abs_error"))
+ require(type(maximum) in (int,float) and math.isfinite(maximum) and 0 <= maximum < atol,"Missing strict numeric proof")
+ require(row.get("atol")==atol and row.get("rtol",0)==0,"Wrong comparison tolerance")
+ require(row.get("empty",False) is False,"Empty tensor comparison")
+
+
+def checked_comparison(comparison, names, atol, *, positions=False, padding=False):
+ require(isinstance(comparison,dict) and comparison.get("passed") is True,"Missing passing comparison")
+ rows = comparison.get("checkpoints")
+ require(isinstance(rows,list) and tuple(row.get("name") for row in rows)==tuple(names),
+ "Missing/duplicate/reordered comparison checkpoints")
+ for row in rows:
+ checked_tensor(row,atol)
+ if positions:
+ checked_tensor(row.get("valid_tokens"),atol)
+ if padding:
+ checked_tensor(row.get("padding_queries"),atol)
+
+
+def checked_memory(execution):
+ require(isinstance(execution,dict) and type(execution.get("executed_steps")) is int
+ and execution["executed_steps"]>0,"Missing IR execution")
+ memory = execution.get("memory_stats")
+ require(isinstance(memory,dict),"Missing memory statistics")
+ require(all(type(memory.get(key)) is int and memory[key]>=0 for key in MEMORY_FIELDS),
+ "Missing/invalid memory statistic")
+ require(isinstance(memory.get("scope"),str) and bool(memory["scope"]),"Missing memory scope")
+
+
+def checked_file(folder, relative, digest=None):
+ require(isinstance(relative,str) and bool(relative),"Missing evidence path")
+ path = (folder/relative).resolve()
+ require(path.is_relative_to(folder.resolve()),"Evidence path escapes output")
+ require(path.is_file(),f"Missing evidence: {relative}")
+ if digest is not None:
+ require(isinstance(digest,str) and len(digest)==64 and sha256_file(path)==digest,
+ f"Evidence hash mismatch: {relative}")
+ return path
+
+
+def checked_artifact(folder, artifact):
+ require(isinstance(artifact,dict) and isinstance(artifact.get("sha256"),str),"Missing artifact hash")
+ return checked_file(folder,artifact.get("path"),artifact["sha256"])
+
+
+def validate_medium(report,folder):
+ require(report.get("checkpoint_count")==81 and report.get("coverage_complete") is True,"Incomplete medium coverage")
+ require(tuple(report.get("checkpoint_metadata",{}))==MEDIUM_CHECKPOINTS,"Wrong medium checkpoints")
+ cases = checked_rows(report.get("cases"),MEDIUM_CASES,("name","valid_length"),"medium cases")
+ kinds = (("pytorch","diagnostic"),("ort","normal"),("ort","diagnostic"),
+ *((f"ir_{level}",kind) for level in LEVELS for kind in GRAPH_KINDS))
+ identities = {(name,backend,kind) for name in ("causality","padding_isolation") for backend,kind in kinds}
+ invariants = checked_rows(report.get("invariants"),identities,("name","backend","graph"),"medium invariants")
+ trace_paths = {}
+ for name,_ in MEDIUM_CASES:
+ trace_paths[f"traces/{name}/reference.npz"] = (name,"pytorch","diagnostic",None)
+ for kind in GRAPH_KINDS:
+ trace_paths[f"traces/{name}/ort_{kind}.npz"] = (name,"ort",kind,None)
+ for level in LEVELS:
+ trace_paths[f"traces/{name}/ir_{kind}_{level}.npz"] = (name,"ir",kind,level)
+ traces = checked_rows(report.get("trace_artifacts"),{(name,) for name in trace_paths},("path",),"medium traces")
+ by_path = {row["path"]:row for row in traces}
+ for trace in traces:
+ require(tuple(trace.get(key) for key in ("case","backend","graph","optimization"))==trace_paths[trace["path"]],
+ "Trace identity does not match its path")
+ checked_artifact(folder,trace)
+ for artifact in checked_keys(report.get("onnx"),GRAPH_KINDS,"medium ONNX graphs").values():
+ checked_artifact(folder,artifact)
+ checked_file(folder,"trace_schema.json")
+ checked_file(folder,"logits_schema.json")
+ for case in cases:
+ require(case.get("passed") is True,"Failed medium case")
+ checked_tensor(case.get("capture_preserves_logits"),1e-5)
+ attention_names = {(f"layer_{layer}.{suffix}",) for layer in range(6)
+ for suffix in ("gqa_probabilities","gqa_context","blocked_attention")}
+ for check in checked_rows(case.get("attention_checks"),attention_names,("name",),"medium attention checks"):
+ checked_tensor(check,1e-5)
+ reference = case.get("reference_trace",{})
+ require(reference==by_path[f"traces/{case['name']}/reference.npz"],"Missing reference trace binding")
+ ort = checked_keys(case.get("ort"),GRAPH_KINDS,"medium ORT graphs")
+ ir = checked_keys(case.get("ir"),LEVELS,"medium IR levels")
+ for kind in GRAPH_KINDS:
+ names = MEDIUM_CHECKPOINTS if kind=="diagnostic" else ("logits",)
+ require(ort[kind].get("passed") is True,"Missing successful medium ORT execution")
+ checked_comparison(ort[kind].get("pytorch_comparison"),names,1e-5,positions=True,padding=case["valid_length"]<256)
+ require(ort[kind].get("trace")==by_path[f"traces/{case['name']}/ort_{kind}.npz"],"Missing ORT trace binding")
+ if kind=="diagnostic":
+ checked_comparison(ort[kind].get("pack_layout"),names,1e-5)
+ for level in LEVELS:
+ execution = checked_keys(ir[level],GRAPH_KINDS,"medium IR graphs")[kind]
+ require(execution.get("status")=="success" and execution.get("passed") is True,"Missing successful medium execution")
+ checked_memory(execution)
+ for comparison in ("pytorch_comparison","ort_comparison"):
+ checked_comparison(execution.get(comparison),names,1e-5,positions=True,padding=case["valid_length"]<256)
+ require(execution.get("trace")==by_path[f"traces/{case['name']}/ir_{kind}_{level}.npz"],"Missing IR trace binding")
+ for invariant in invariants:
+ checked_comparison(invariant.get("comparison"),MEDIUM_CHECKPOINTS if invariant["graph"]=="diagnostic" else ("logits",),1e-5)
+
+
+def validate_subgraphs(report,folder):
+ require(report.get("sequence_length")==256 and report.get("coverage_complete") is True,"Not full L256 subgraph set")
+ require(report.get("levels")==list(LEVELS),"Missing/duplicate subgraph levels")
+ rows = checked_rows(report.get("cases"),{(name,) for name in SUBGRAPH_CASES},("name",),"subgraph cases")
+ base = {"ort_pack_layout","torch_vs_ort","ordinary_ort_vs_torch","ordinary_ort_vs_diagnostic"}
+ keys = base | {f"{prefix}_{level}_vs_{reference}" for level in LEVELS
+ for prefix,references in (("ir",("ort","torch")),("ordinary_ir",("ort","torch","diagnostic")))
+ for reference in references}
+ for row in rows:
+ name = row["name"]
+ require(row.get("passed") is True,"Failed subgraph case")
+ names = ("probabilities","y") if name.startswith("gqa_") else (("gate","up","hidden","y") if name=="swiglu" else ("y",))
+ for key,comparison in checked_keys(row.get("comparisons"),keys,"subgraph comparisons").items():
+ if key.startswith("ordinary_"):
+ checked_tensor(comparison,1e-4)
+ else:
+ checked_comparison(comparison,names,1e-4)
+ for executions in checked_keys(row.get("executions"),LEVELS,"subgraph IR levels").values():
+ for execution in checked_keys(executions,("ordinary","diagnostic"),"subgraph IR graphs").values():
+ checked_memory(execution)
+ artifacts = row.get("artifacts",{})
+ require(artifacts.get("directory")==name,"Wrong subgraph artifact directory")
+ for filename,key in (("model.onnx","model_sha256"),("diagnostics.onnx","diagnostic_sha256")):
+ checked_artifact(folder,{"path":f"{name}/{filename}","sha256":artifacts.get(key)})
+ for filename in ("inputs.npz","torch.npz","ort.npz","ordinary_ort.npy","checkpoints.json",
+ *(f"ir_{level}.npz" for level in LEVELS),*(f"ordinary_ir_{level}.npy" for level in LEVELS)):
+ checked_file(folder,f"{name}/{filename}")
+ if name.startswith("gqa_"):
+ for checks in checked_keys(row.get("semantic_checks"),("torch","ort","ir_none","ir_basic","ir_all"),"GQA backends").values():
+ for comparison in checked_keys(checks,("blocked_probability","probability_row_sum"),"GQA semantics").values():
+ checked_tensor(comparison,1e-4)
+ identities = {(name,backend) for name in ("padding_isolation","causality")
+ for backend in ("torch","ort","ir_none","ir_basic","ir_all")}
+ for invariant in checked_rows(report.get("invariants"),identities,("name","backend"),"subgraph invariants"):
+ require(invariant.get("query_prefix")== (256 if invariant["name"]=="padding_isolation" else 64),"Wrong invariant prefix")
+ checked_comparison(invariant,("probabilities","y"),1e-4)
+
+
+def validate_attention(report,folder):
+ require(report.get("planned_executions")==report.get("passed_executions")==12,"Missing QEMU runs")
+ rows = checked_rows(report.get("cases"),ATTENTION_CASES,("name","valid_length"),"Attention cases")
+ for row in rows:
+ name = row["name"]
+ require(row.get("passed") is True,"Failed Attention case")
+ checked_tensor(row.get("ort_vs_numpy"),1e-4)
+ for filename,key in (("model.onnx","model_sha256"),("inputs.npz","input_sha256")):
+ checked_artifact(folder,{"path":f"{name}/{filename}","sha256":row.get(key)})
+ for execution in checked_rows(row.get("executions"),{("none",),("all",)},("optimization",),"Attention executions"):
+ require(execution.get("status")=="success" and execution.get("passed") is True,"Missing successful target execution")
+ for key in ("ir_vs_ort","ir_vs_numpy","qemu_vs_ort","qemu_vs_numpy"):
+ checked_tensor(execution.get(key),1e-4)
+ elapsed = execution.get("qemu_process_wall_seconds")
+ require(type(elapsed) in (int,float) and math.isfinite(elapsed) and elapsed>=0,"Missing QEMU wall time")
+ for key in ("command","compile_command"):
+ command = execution.get(key)
+ require(isinstance(command,list) and len(command)>1 and all(isinstance(x,str) and x for x in command),"Missing target command")
+ level = execution["optimization"]
+ checked_artifact(folder,{"path":f"{name}/{level}/build/model.elf","sha256":execution.get("elf_sha256")})
+ for filename in ("qemu.npy","ir.npy"):
+ checked_file(folder,f"{name}/{level}/{filename}")
+ identities = {(name,reference,prefix,backend) for name,reference,prefix in
+ (("future17","full17",5),("padding_changed17","padding17",17))
+ for backend in ("ort","ir_none","ir_all","qemu_none","qemu_all")}
+ for invariant in checked_rows(report.get("invariants"),identities,("case","reference","prefix","backend"),"Attention invariants"):
+ checked_tensor(invariant.get("comparison"),1e-4)
+
+def validate_report(name, folder, sources):
+ for filename in ("report.json","report.md","report.html"):
+ require((folder/filename).is_file(),f"Missing {filename}")
+ report = json.loads((folder/"report.json").read_text(encoding="utf-8"))
+ require(report.get("gate")==IDENTITIES[name],"Wrong gate identity")
+ require(report.get("status")=="PASS" and report.get("passed") is True,"Gate not PASS")
+ fingerprints = report.get("source_sha256") or report.get("provenance",{}).get("source_sha256")
+ require(fingerprints == sources,"Source fingerprints differ from this invocation")
+ check_numeric(report,1e-5 if name in ("medium","layer-diff") else 1e-4)
+ if name == "medium":
+ validate_medium(report,folder)
+ elif name == "subgraphs":
+ validate_subgraphs(report,folder)
+ elif name == "attention":
+ validate_attention(report,folder)
+ elif name == "full-preflight":
+ require(report.get("full_ir_executed") is False and report.get("w3_exit_accepted") is False,
+ "Preflight must not claim complete-model numerical acceptance")
+ require(report.get("node_count")==7847 and report.get("weights_file_bytes")==2384201728,"Unexpected fixed full assets")
+ else:
+ coverage = report.get("coverage",{})
+ require(coverage.get("complete") is True and coverage.get("compared_checkpoints")==81,"Incomplete layer comparison")
+ return {"report_sha256":sha256_file(folder/"report.json"),"gate":report["gate"],
+ "child_seconds":report.get("seconds",report.get("elapsed_seconds")),
+ "process_peak_rss_bytes":report.get("process_peak_rss_bytes")}
+
+
+def wait_child(process,timeout,row):
+ """Bound the child and also reclaim its owned process tree on cancellation."""
+ if getattr(process,"_scratchv_job",None) is not None or getattr(process,"_scratchv_owned_group",False):
+ try:
+ # Share the full runner's ownership protocol, including children
+ # surviving their launcher. Preparation has no memory threshold;
+ # the added samples only describe the owned subprocess tree.
+ return wait_bounded(process,timeout=timeout,max_memory_bytes=sys.maxsize,row=row)
+ except TimeoutError:
+ raise subprocess.TimeoutExpired(process.args,timeout) from None
+ try:
+ return process.wait(timeout=timeout)
+ except BaseException:
+ if process.poll() is None:
+ try:
+ terminate_process_tree(process)
+ except (OSError,subprocess.SubprocessError) as cleanup:
+ row["cleanup_error"] = f"{type(cleanup).__name__}: {cleanup}"
+ row["returncode"] = process.returncode
+ raise
+
+def build_commands(args, out):
+ python = [str(Path(args.python).resolve()),"-B","-X","utf8"]
+ tools = []
+ if args.cc:
+ tools += ["--cc",args.cc]
+ if args.qemu:
+ tools += ["--qemu",args.qemu]
+ medium = out/"medium"
+ return {
+ "medium":python+["probes/w3_qwen3_medium/run.py","--output-dir",str(medium)],
+ "subgraphs":python+["probes/w3_qwen3_subgraphs/run.py","--source-dir",str(args.source_dir.resolve()),
+ "--output-dir",str(out/"subgraphs")],
+ "attention":python+["probes/w3_attention/run.py","--output-dir",str(out/"attention"),
+ "--timeout",str(args.qemu_timeout),*tools],
+ "full-preflight":python+["probes/w3_full_preflight/run.py","--model-dir",str(args.model_dir.resolve()),
+ "--output-dir",str(out/"full-preflight")],
+ "layer-diff":python+["probes/w3_layer_diff/run.py",
+ "--actual",str(medium/"traces/short_17/ir_diagnostic_all.npz"),
+ "--reference",str(medium/"traces/short_17/ort_diagnostic.npz"),
+ "--schema",str(medium/"trace_schema.json"),"--out",str(out/"layer-diff")],
+ }
+
+def main(argv=None):
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument("--python",default=sys.executable)
+ parser.add_argument("--source-dir",type=Path,required=True)
+ parser.add_argument("--model-dir",type=Path,required=True)
+ parser.add_argument("--output-dir",type=Path,required=True)
+ parser.add_argument("--cc")
+ parser.add_argument("--qemu")
+ parser.add_argument("--gate-timeout",type=float,default=1800)
+ parser.add_argument("--qemu-timeout",type=float,default=180)
+ args = parser.parse_args(argv)
+ if any(not math.isfinite(x) or x<=0 for x in (args.gate_timeout,args.qemu_timeout)):
+ parser.error("Timeouts must be finite and positive")
+ out = new_output_dir(args.output_dir)
+ (out/"logs").mkdir()
+ started = time.perf_counter()
+ report = {"gate":"preparation:w3","passed":False,"status":"FAIL","gates":[],
+ "w3_exit_accepted":False,"full_ir_executed":False,
+ "scope":"Five local preparation checks only; full IR, team sign-off and Nightly remain separate"}
+ try:
+ report.update(source_evidence())
+ commands = build_commands(args,out)
+ env = dict(os.environ,PYTHONIOENCODING="utf-8",OMP_NUM_THREADS="1",OPENBLAS_NUM_THREADS="1",MKL_NUM_THREADS="1")
+ for name in GATES:
+ row = {"name":name,"passed":False,"status":"FAIL","command":commands[name]}
+ report["gates"].append(row)
+ tick = time.perf_counter()
+ try:
+ if name=="layer-diff":
+ require(report["gates"][0]["passed"],"Layer-diff blocked by failed medium evidence")
+ with (out/"logs"/(name+".log")).open("w",encoding="utf-8") as stream:
+ options = {"creationflags":subprocess.CREATE_NEW_PROCESS_GROUP} if os.name=="nt" else {"start_new_session":True}
+ process = spawn_owned(commands[name],cwd=ROOT,stdout=stream,stderr=subprocess.STDOUT,env=env,**options)
+ try:
+ row["returncode"] = wait_child(process,args.gate_timeout,row)
+ except subprocess.TimeoutExpired:
+ raise TimeoutError(f"{name} exceeded {args.gate_timeout} seconds") from None
+ require(row["returncode"]==0,f"{name} exited {row['returncode']}; see logs/{name}.log")
+ row["validation"] = validate_report(name,out/name,report["source_sha256"])
+ row.update(passed=True,status="PASS")
+ except Exception as exc:
+ row["error"] = f"{type(exc).__name__}: {exc}"
+ row["elapsed_seconds"] = time.perf_counter()-tick
+ print(f"[{name}] {row['status']}: {row.get('error','verified')}",flush=True)
+ require(source_evidence()["source_sha256"]==report["source_sha256"],"Source changed during execution")
+ report["passed"] = len(report["gates"])==len(GATES) and all(r["passed"] for r in report["gates"])
+ except KeyboardInterrupt:
+ report.update(passed=False,interrupted=True,error="KeyboardInterrupt: preparation cancelled")
+ if report["gates"]:
+ report["gates"][-1].update(passed=False,status="FAIL",interrupted=True)
+ except Exception as exc:
+ report["error"] = f"{type(exc).__name__}: {exc}"
+ report.update(status="PASS" if report["passed"] else "FAIL",elapsed_seconds=time.perf_counter()-started)
+ write_reports(out,report)
+ return 130 if report.get("interrupted") else (0 if report["passed"] else 1)
+
+if __name__=="__main__":
+ raise SystemExit(main())
diff --git a/scripts/summarize_w3_ci.py b/scripts/summarize_w3_ci.py
new file mode 100644
index 0000000..1271a89
--- /dev/null
+++ b/scripts/summarize_w3_ci.py
@@ -0,0 +1,199 @@
+"""Publish bounded W3 numerical reports to GitHub Actions without changing gates."""
+from __future__ import annotations
+
+import argparse
+from html import escape
+import json
+import math
+import os
+from pathlib import Path
+import sys
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+ sys.path.insert(0, str(ROOT))
+
+from probes.numeric_summary import compact_metric_table
+from probes.w3_summary import evidence_index_views, numerical_summary
+
+# The medium report currently exceeds 12 MiB because it retains checkpoints.
+# Bound input allocation separately from the much smaller Actions page budget.
+MAX_REPORT_BYTES = 64 * 1024 * 1024
+MAX_SUMMARY_BYTES = 64 * 1024
+
+GATES = (
+ ("medium", "w3-medium-host", "6-layer random Qwen3 / host IR"),
+ ("subgraphs", "w3_qwen3_subgraphs", "Pretrained layer-0 subgraphs / host IR"),
+ ("attention", "unit:attention-backend", "Small Attention / RISC-V QEMU"),
+ ("full-preflight", "preflight:w3-full-assets", "Full assets / static checks only"),
+ ("layer-diff", "w3_layer_diff", "Saved medium-model checkpoints only"),
+)
+
+
+def cell(value, limit=180):
+ text = " ".join(str(value).split())
+ if len(text) > limit:
+ text = text[:limit] + "…"
+ return escape(text).replace("|", "|")
+
+
+def load_report(path, gate):
+ try:
+ with path.open("rb") as stream:
+ payload = stream.read(MAX_REPORT_BYTES + 1)
+ if len(payload) > MAX_REPORT_BYTES:
+ return None, "INVALID REPORT (size limit)"
+ report = json.loads(payload.decode("utf-8"))
+ except FileNotFoundError:
+ return None, "MISSING REPORT"
+ except (OSError, ValueError, RecursionError):
+ return None, "INVALID REPORT"
+ if not isinstance(report, dict) or report.get("gate") != gate:
+ return None, "INVALID REPORT (gate identity)"
+ # Fail closed on malformed structures before calling the shared renderer.
+ for key in ("cases", "gates", "invariants"):
+ rows = report.get(key, [])
+ if not isinstance(rows, list) or not all(isinstance(row, dict) for row in rows):
+ return None, "INVALID REPORT (rows)"
+ return report, ""
+
+
+def status(report):
+ if report.get("status") == "PARTIAL":
+ return "PARTIAL (not acceptance)"
+ if report.get("status") == "PASS" and report.get("passed") is True:
+ if report.get("gate") == "numeric:ir-full-qwen3" and report.get("coverage_complete") is not True:
+ return "INCOMPLETE (not acceptance)"
+ return "PASS"
+ return "FAIL" if report.get("passed") is False else "UNCONFIRMED"
+
+
+def seconds(report):
+ value = report.get("elapsed_seconds", report.get("seconds"))
+ if type(value) in (int, float) and math.isfinite(value) and value >= 0:
+ return f"{value:.3f} s"
+ return "not recorded"
+
+
+def coverage(report):
+ gate = report.get("gate")
+ cases = report.get("cases", [])
+ if gate == "w3_layer_diff":
+ values = report.get("coverage", {})
+ return f"{values.get('compared_checkpoints', '?')}/{values.get('total_checkpoints', '?')} checkpoints"
+ if gate == "preflight:w3-full-assets":
+ return "no model execution"
+ if gate == "unit:attention-backend":
+ count = sum(len(row.get("executions", [])) for row in cases)
+ return f"{len(cases)} cases / {count} target executions recorded"
+ required = report.get("required_cases")
+ expected = len(required) if isinstance(required, list) else {"w3-medium-host": 7, "w3_qwen3_subgraphs": 14}.get(gate, "?")
+ return f"{len(cases)}/{expected} cases recorded"
+
+
+def details(report, title):
+ """Reuse bounded semantic selectors, never dump arbitrary report dictionaries."""
+ description, comparisons, notes = numerical_summary(report)
+ index, _ = evidence_index_views(report)
+ text = f"{cell(title)}
\n\n{cell(description, 700)}\n\n"
+ if comparisons:
+ text += compact_metric_table(comparisons) + "\n\n"
+ if report.get("error"):
+ text += "Issue: " + cell(report["error"], 400) + "\n\n"
+ text += "\n\n".join(cell(note, 500) for note in notes) + "\n\n" + index + "", 1)[0]
+ assert "**PASS**" in visible and "75.125 s" in visible
+ assert "2/2 cases" in visible and "reference" in visible
+ assert format(3e-6, ".16e") in visible and format(6e-6, ".16e") in visible
+ assert format(0.7, ".16e") not in visible
+ assert "No full-model QEMU result" in visible
+ assert "w3-full-numeric-reports" in text and "" in text
+ assert json.loads((tmp_path / "report.json").read_text()) == before
+
+
+@pytest.mark.parametrize("outcome,expected", [("skipped", "NOT RUN"), ("", "NOT RUN"), ("cancelled", "CANCELLED")])
+def test_skipped_step_does_not_reuse_a_passing_report(tmp_path, outcome, expected):
+ save(tmp_path, full_report())
+ text = render("full", tmp_path, outcome)
+ assert f"**{expected}**" in text and "PASS" not in text
+ assert "最大绝对误差" not in text
+
+
+@pytest.mark.parametrize("outcome", ["success", "failure"])
+def test_missing_report_does_not_claim_pass(tmp_path, outcome):
+ text = render("full", tmp_path, outcome)
+ assert "MISSING REPORT" in text and "PASS" not in text and outcome in text
+
+
+@pytest.mark.parametrize("invalid", ["{", "[]", '{"gate":"wrong"}', '{"gate":"numeric:ir-full-qwen3","cases":null}'])
+def test_invalid_reports_do_not_crash_summary(tmp_path, invalid):
+ (tmp_path / "report.json").write_text(invalid)
+ text = render("full", tmp_path, "failure")
+ assert "INVALID REPORT" in text and "PASS" not in text
+
+
+def test_failed_step_overrides_passing_report(tmp_path):
+ save(tmp_path, full_report())
+ text = render("full", tmp_path, "failure")
+ assert "**FAIL (step did not succeed)**" in text
+ assert "**PASS**" not in text
+
+
+def test_partial_coverage_shows_unexecuted_case_and_missing_metrics(tmp_path):
+ report = full_report(status="PARTIAL", passed=False, coverage_complete=False, selected_cases=["one"])
+ report["cases"] = report["cases"][:1]
+ save(tmp_path, report)
+ text = render("full", tmp_path, "failure")
+ assert "**PARTIAL (not acceptance)**" in text
+ assert "1/2 cases recorded" in text and "NOT RUN" in text and "two" in text
+ assert "未记录 1/2" in text and "**PASS**" not in text
+
+
+def test_claimed_pass_with_incomplete_coverage_is_not_pass(tmp_path):
+ save(tmp_path, full_report(coverage_complete=False))
+ assert "**INCOMPLETE (not acceptance)**" in render("full", tmp_path, "success")
+
+
+def test_preparation_lists_all_checks_and_never_claims_full_model_execution(tmp_path):
+ report = {"gate": "preparation:w3", "status": "FAIL", "passed": False, "elapsed_seconds": 32,
+ "gates": [{"name": "attention", "passed": False, "status": "FAIL", "elapsed_seconds": 1.5}]}
+ save(tmp_path, report)
+ save(tmp_path / "attention", {"gate": "unit:attention-backend", "status": "PASS", "passed": True,
+ "cases": [{"name": "one", "executions": [{"optimization": level, "qemu_vs_ort": metric(3e-6, "logits")}
+ for level in ("none", "all")]}]})
+ # A stale medium child without a corresponding parent invocation is ignored.
+ save(tmp_path / "medium", {"gate": "w3-medium-host", "status": "PASS", "passed": True})
+ text = render("preparation", tmp_path, "failure")
+ visible = text.split("", 1)[0]
+ assert "NOT RUN by this job" in visible
+ assert "FAIL (parent validation)" in visible and "1 cases / 2 target executions recorded" in visible
+ for _, _, scope in GATES:
+ assert scope in visible
+ assert visible.count("NOT RUN") == 5
+ assert "w3-preparation-reports" in text
+
+
+def test_missing_child_report_cannot_leave_overall_pass(tmp_path):
+ save(tmp_path, {"gate": "preparation:w3", "status": "PASS", "passed": True,
+ "gates": [{"name": "medium", "status": "PASS", "passed": True}]})
+ text = render("preparation", tmp_path, "success")
+ assert "**INCOMPLETE REPORTS (not acceptance)**" in text and "MISSING REPORT" in text
+ assert "**PASS**" not in text
+
+
+def test_errors_are_escaped_and_arbitrary_machine_evidence_is_not_dumped(tmp_path):
+ report = full_report(status="FAIL", passed=False, error=""}
+ before = deepcopy(report)
+ write_reports(tmp_path, report)
+ assert json.loads((tmp_path / "report.json").read_text(encoding="utf-8")) == before
+ markdown = (tmp_path / "report.md").read_text(encoding="utf-8")
+ page = (tmp_path / "report.html").read_text(encoding="utf-8")
+ assert "Result: **FAIL**" in markdown
+ assert "通过（1/1）" in markdown and "总体结论" in markdown
+ assert "隔离检查未通过 1 项" in markdown
+ assert "" in markdown and "" in page
+ assert markdown.index("最大绝对误差") < markdown.index("")
+ assert '"checkpoints"' not in markdown
+ assert "[完整机器报告](report.json)" in markdown
+ assert 'href="report.json"' in page
+ assert "