diff --git a/clean/l/records/l_default_post_real_weights.json b/clean/l/records/l_default_post_real_weights.json
new file mode 100644
index 00000000..2b3090d4
--- /dev/null
+++ b/clean/l/records/l_default_post_real_weights.json
@@ -0,0 +1,760 @@
+{
+ "what": "Model L's native D3D12 reconstruction: today's default (A, Model M's fused pack12 post) and Model L's own post (B, l_post=own) against Model L's post oracle (clean/l/reference/recon.py), clean/l/runner/l_default_post_check.py; then the new default checked with clean/l/runner/l_frame_check.py",
+ "frames": "l_frame_check's 11 synthetic frames (96 x 64 x 5, 80 x 48 x 3, 77 x 45 x 3; resets on frames 0, 2, 5, 8, 9; special colour values), D = 180 x 108",
+ "model_source": {
+ "kind": "converter",
+ "model_sha256": "d3c040191ec7ab0164efc03ee76413277e7fb54e6e6d2b168f2c0202aa1ad806",
+ "map_sha256": "58e6d0e7cd6926817cfea28a0b4a65c056e9bfa5ca62aa05b968b62590c9e857"
+ },
+ "model_note": "converter-written Model L model.wgcm (WrongGPU.exe model convert --preset=L, as in #133); read by the tools only; digests above",
+ "rule": {
+ "spec_l_post_acceptance": "FP16 values more than 1 ulp off: at most 0.05 % per frame, at most 0.01 % over the run (history and display)",
+ "also": "l_post_rule: no non-finite value, at most 1 % differing, mean error at most 0.1 % of the reference RMS; reduced codes within 1 and 99 % exact",
+ "over_1_per_frame": 0.0005,
+ "over_1_run": 0.0001
+ },
+ "oracle": "candidate positions in float32 as the kernels compute them (this PR; Model M's reference since #142)",
+ "A_m_fused_post_default": {
+ "frames": [
+ {
+ "frame": 0,
+ "history": {
+ "values": 58320,
+ "over_1": 43220,
+ "pct_over_1": 74.10836762688615,
+ "max_f16_steps": 25414,
+ "differ": 51027,
+ "nonfinite": 0,
+ "mean_rel_rms": 0.02428278591844941,
+ "pass": false,
+ "pass_over_1": false
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 10327,
+ "max_code_diff": 894,
+ "pass": false
+ },
+ "pass": false
+ },
+ {
+ "frame": 1,
+ "history": {
+ "values": 58320,
+ "over_1": 50526,
+ "pct_over_1": 86.6358024691358,
+ "max_f16_steps": 21925,
+ "differ": 55228,
+ "nonfinite": 0,
+ "mean_rel_rms": 0.0327054131782265,
+ "pass": false,
+ "pass_over_1": false
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 12340,
+ "max_code_diff": 732,
+ "pass": false
+ },
+ "pass": false
+ },
+ {
+ "frame": 2,
+ "history": {
+ "values": 58320,
+ "over_1": 42833,
+ "pct_over_1": 73.44478737997257,
+ "max_f16_steps": 23094,
+ "differ": 50729,
+ "nonfinite": 0,
+ "mean_rel_rms": 0.022835851737096718,
+ "pass": false,
+ "pass_over_1": false
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 10130,
+ "max_code_diff": 864,
+ "pass": false
+ },
+ "pass": false
+ },
+ {
+ "frame": 3,
+ "history": {
+ "values": 58320,
+ "over_1": 50408,
+ "pct_over_1": 86.43347050754458,
+ "max_f16_steps": 3103,
+ "differ": 55206,
+ "nonfinite": 0,
+ "mean_rel_rms": 0.028227625212641494,
+ "pass": false,
+ "pass_over_1": false
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 12282,
+ "max_code_diff": 784,
+ "pass": false
+ },
+ "pass": false
+ },
+ {
+ "frame": 4,
+ "history": {
+ "values": 58320,
+ "over_1": 44834,
+ "pct_over_1": 76.8758573388203,
+ "max_f16_steps": 18735,
+ "differ": 52277,
+ "nonfinite": 0,
+ "mean_rel_rms": 0.02003211440534733,
+ "pass": false,
+ "pass_over_1": false
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 10981,
+ "max_code_diff": 657,
+ "pass": false
+ },
+ "pass": false
+ },
+ {
+ "frame": 5,
+ "history": {
+ "values": 58320,
+ "over_1": 39216,
+ "pct_over_1": 67.24279835390946,
+ "max_f16_steps": 23735,
+ "differ": 48597,
+ "nonfinite": 0,
+ "mean_rel_rms": 0.017213619645301662,
+ "pass": false,
+ "pass_over_1": false
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 8505,
+ "max_code_diff": 875,
+ "pass": false
+ },
+ "pass": false
+ },
+ {
+ "frame": 6,
+ "history": {
+ "values": 58320,
+ "over_1": 48013,
+ "pct_over_1": 82.32681755829904,
+ "max_f16_steps": 20259,
+ "differ": 53980,
+ "nonfinite": 0,
+ "mean_rel_rms": 0.02072597238123298,
+ "pass": false,
+ "pass_over_1": false
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 11588,
+ "max_code_diff": 796,
+ "pass": false
+ },
+ "pass": false
+ },
+ {
+ "frame": 7,
+ "history": {
+ "values": 58320,
+ "over_1": 45917,
+ "pct_over_1": 78.73285322359396,
+ "max_f16_steps": 3073,
+ "differ": 52989,
+ "nonfinite": 0,
+ "mean_rel_rms": 0.01963232883034721,
+ "pass": false,
+ "pass_over_1": false
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 10998,
+ "max_code_diff": 822,
+ "pass": false
+ },
+ "pass": false
+ },
+ {
+ "frame": 8,
+ "history": {
+ "values": 58320,
+ "over_1": 36373,
+ "pct_over_1": 62.367969821673526,
+ "max_f16_steps": 23759,
+ "differ": 46845,
+ "nonfinite": 0,
+ "mean_rel_rms": 0.0168340269418855,
+ "pass": false,
+ "pass_over_1": false
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 7877,
+ "max_code_diff": 871,
+ "pass": false
+ },
+ "pass": false
+ },
+ {
+ "frame": 9,
+ "history": {
+ "values": 58320,
+ "over_1": 38555,
+ "pct_over_1": 66.10939643347051,
+ "max_f16_steps": 23700,
+ "differ": 48541,
+ "nonfinite": 0,
+ "mean_rel_rms": 0.015628346179535936,
+ "pass": false,
+ "pass_over_1": false
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 8421,
+ "max_code_diff": 829,
+ "pass": false
+ },
+ "pass": false
+ },
+ {
+ "frame": 10,
+ "history": {
+ "values": 58320,
+ "over_1": 47017,
+ "pct_over_1": 80.61899862825788,
+ "max_f16_steps": 20938,
+ "differ": 53588,
+ "nonfinite": 0,
+ "mean_rel_rms": 0.023000312746255178,
+ "pass": false,
+ "pass_over_1": false
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 11208,
+ "max_code_diff": 834,
+ "pass": false
+ },
+ "pass": false
+ }
+ ],
+ "run": {
+ "history": {
+ "values": 641520,
+ "over_1": 486912,
+ "frac_over_1": 0.7589973812196035,
+ "pass": false,
+ "pct_over_1": 75.89973812196035
+ }
+ },
+ "frames_passed": 0,
+ "frames_passed_over_1_limit": 0,
+ "worst_frame": {
+ "frame": 1,
+ "history_pct_over_1": 86.6358024691358
+ },
+ "pass": false,
+ "note": "the fused post writes no display image: judged on the full history and the reduced codes"
+ },
+ "B_l_post_own": {
+ "frames": [
+ {
+ "frame": 0,
+ "history": {
+ "values": 58320,
+ "over_1": 0,
+ "pct_over_1": 0.0,
+ "max_f16_steps": 1,
+ "differ": 3,
+ "nonfinite": 0,
+ "mean_rel_rms": 3.6618337906609727e-08,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "display": {
+ "values": 58320,
+ "over_1": 0,
+ "pct_over_1": 0.0,
+ "max_f16_steps": 1,
+ "differ": 5,
+ "nonfinite": 0,
+ "mean_rel_rms": 2.8292240712329585e-08,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 0,
+ "max_code_diff": 0,
+ "pass": true
+ },
+ "pass": true
+ },
+ {
+ "frame": 1,
+ "history": {
+ "values": 58320,
+ "over_1": 2,
+ "pct_over_1": 0.003429355281207133,
+ "max_f16_steps": 2,
+ "differ": 16,
+ "nonfinite": 0,
+ "mean_rel_rms": 2.4351312539640077e-07,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "display": {
+ "values": 58320,
+ "over_1": 1,
+ "pct_over_1": 0.0017146776406035665,
+ "max_f16_steps": 2,
+ "differ": 14,
+ "nonfinite": 0,
+ "mean_rel_rms": 1.3492423263155083e-07,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 0,
+ "max_code_diff": 0,
+ "pass": true
+ },
+ "pass": true
+ },
+ {
+ "frame": 2,
+ "history": {
+ "values": 58320,
+ "over_1": 0,
+ "pct_over_1": 0.0,
+ "max_f16_steps": 1,
+ "differ": 7,
+ "nonfinite": 0,
+ "mean_rel_rms": 6.944827456073453e-08,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "display": {
+ "values": 58320,
+ "over_1": 0,
+ "pct_over_1": 0.0,
+ "max_f16_steps": 1,
+ "differ": 11,
+ "nonfinite": 0,
+ "mean_rel_rms": 1.1387019723483591e-07,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 1,
+ "max_code_diff": 1,
+ "pass": true
+ },
+ "pass": true
+ },
+ {
+ "frame": 3,
+ "history": {
+ "values": 58320,
+ "over_1": 0,
+ "pct_over_1": 0.0,
+ "max_f16_steps": 1,
+ "differ": 3,
+ "nonfinite": 0,
+ "mean_rel_rms": 3.5120661919935923e-08,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "display": {
+ "values": 58320,
+ "over_1": 0,
+ "pct_over_1": 0.0,
+ "max_f16_steps": 1,
+ "differ": 8,
+ "nonfinite": 0,
+ "mean_rel_rms": 7.908372927822009e-08,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 0,
+ "max_code_diff": 0,
+ "pass": true
+ },
+ "pass": true
+ },
+ {
+ "frame": 4,
+ "history": {
+ "values": 58320,
+ "over_1": 0,
+ "pct_over_1": 0.0,
+ "max_f16_steps": 1,
+ "differ": 12,
+ "nonfinite": 0,
+ "mean_rel_rms": 1.1480842383813212e-07,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "display": {
+ "values": 58320,
+ "over_1": 0,
+ "pct_over_1": 0.0,
+ "max_f16_steps": 1,
+ "differ": 11,
+ "nonfinite": 0,
+ "mean_rel_rms": 1.149860859183812e-07,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 0,
+ "max_code_diff": 0,
+ "pass": true
+ },
+ "pass": true
+ },
+ {
+ "frame": 5,
+ "history": {
+ "values": 58320,
+ "over_1": 0,
+ "pct_over_1": 0.0,
+ "max_f16_steps": 1,
+ "differ": 4,
+ "nonfinite": 0,
+ "mean_rel_rms": 2.402910906356423e-08,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "display": {
+ "values": 58320,
+ "over_1": 0,
+ "pct_over_1": 0.0,
+ "max_f16_steps": 1,
+ "differ": 9,
+ "nonfinite": 0,
+ "mean_rel_rms": 8.365467291114129e-08,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 0,
+ "max_code_diff": 0,
+ "pass": true
+ },
+ "pass": true
+ },
+ {
+ "frame": 6,
+ "history": {
+ "values": 58320,
+ "over_1": 0,
+ "pct_over_1": 0.0,
+ "max_f16_steps": 1,
+ "differ": 10,
+ "nonfinite": 0,
+ "mean_rel_rms": 1.1272363892367749e-07,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "display": {
+ "values": 58320,
+ "over_1": 1,
+ "pct_over_1": 0.0017146776406035665,
+ "max_f16_steps": 2,
+ "differ": 13,
+ "nonfinite": 0,
+ "mean_rel_rms": 1.345432083837459e-07,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 1,
+ "max_code_diff": 1,
+ "pass": true
+ },
+ "pass": true
+ },
+ {
+ "frame": 7,
+ "history": {
+ "values": 58320,
+ "over_1": 0,
+ "pct_over_1": 0.0,
+ "max_f16_steps": 1,
+ "differ": 4,
+ "nonfinite": 0,
+ "mean_rel_rms": 4.3557576442642196e-08,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "display": {
+ "values": 58320,
+ "over_1": 0,
+ "pct_over_1": 0.0,
+ "max_f16_steps": 1,
+ "differ": 7,
+ "nonfinite": 0,
+ "mean_rel_rms": 6.983802196584032e-08,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 2,
+ "max_code_diff": 1,
+ "pass": true
+ },
+ "pass": true
+ },
+ {
+ "frame": 8,
+ "history": {
+ "values": 58320,
+ "over_1": 0,
+ "pct_over_1": 0.0,
+ "max_f16_steps": 1,
+ "differ": 10,
+ "nonfinite": 0,
+ "mean_rel_rms": 1.0689726979230679e-07,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "display": {
+ "values": 58320,
+ "over_1": 1,
+ "pct_over_1": 0.0017146776406035665,
+ "max_f16_steps": 2,
+ "differ": 12,
+ "nonfinite": 0,
+ "mean_rel_rms": 1.208800379622101e-07,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 0,
+ "max_code_diff": 0,
+ "pass": true
+ },
+ "pass": true
+ },
+ {
+ "frame": 9,
+ "history": {
+ "values": 58320,
+ "over_1": 0,
+ "pct_over_1": 0.0,
+ "max_f16_steps": 1,
+ "differ": 8,
+ "nonfinite": 0,
+ "mean_rel_rms": 6.30113743634302e-08,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "display": {
+ "values": 58320,
+ "over_1": 0,
+ "pct_over_1": 0.0,
+ "max_f16_steps": 1,
+ "differ": 6,
+ "nonfinite": 0,
+ "mean_rel_rms": 7.013249724315352e-08,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 0,
+ "max_code_diff": 0,
+ "pass": true
+ },
+ "pass": true
+ },
+ {
+ "frame": 10,
+ "history": {
+ "values": 58320,
+ "over_1": 0,
+ "pct_over_1": 0.0,
+ "max_f16_steps": 1,
+ "differ": 15,
+ "nonfinite": 0,
+ "mean_rel_rms": 1.6948480444486855e-07,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "display": {
+ "values": 58320,
+ "over_1": 1,
+ "pct_over_1": 0.0017146776406035665,
+ "max_f16_steps": 2,
+ "differ": 15,
+ "nonfinite": 0,
+ "mean_rel_rms": 1.7844008452552284e-07,
+ "pass": true,
+ "pass_over_1": true
+ },
+ "reduced": {
+ "values": 14580,
+ "differ": 0,
+ "max_code_diff": 0,
+ "pass": true
+ },
+ "pass": true
+ }
+ ],
+ "run": {
+ "history": {
+ "values": 641520,
+ "over_1": 2,
+ "frac_over_1": 3.117595710188303e-06,
+ "pass": true,
+ "pct_over_1": 0.0003117595710188303
+ },
+ "display": {
+ "values": 641520,
+ "over_1": 4,
+ "frac_over_1": 6.235191420376606e-06,
+ "pass": true,
+ "pct_over_1": 0.0006235191420376606
+ }
+ },
+ "frames_passed": 11,
+ "frames_passed_over_1_limit": 11,
+ "worst_frame": {
+ "frame": 1,
+ "history_pct_over_1": 0.003429355281207133,
+ "display_pct_over_1": 0.0017146776406035665
+ },
+ "pass": true
+ },
+ "B_with_float64_oracle_positions": {
+ "frames_passed": 10,
+ "frames_passed_over_1_limit": 11,
+ "run_over_1": {
+ "history": [
+ 5,
+ 641520
+ ],
+ "display": [
+ 7,
+ 641520
+ ]
+ },
+ "failing": "frame 6: reduced codes 4 off at one pixel (a candidate position on the bottom edge: valid in float32, invalid in float64)"
+ },
+ "new_default_hip_against_oracle": {
+ "real_weights": {
+ "L_pass": true,
+ "M_pass": true,
+ "L_post_run": {
+ "history": {
+ "values": 641520,
+ "over_1": 2,
+ "frac_over_1": 3.117595710188303e-06,
+ "pass": true
+ },
+ "display": {
+ "values": 641520,
+ "over_1": 4,
+ "frac_over_1": 6.235191420376606e-06,
+ "pass": true
+ }
+ }
+ },
+ "synthetic": {
+ "L_pass": true,
+ "M_pass": true,
+ "L_post_run": {
+ "history": {
+ "values": 641520,
+ "over_1": 24,
+ "frac_over_1": 3.7411148522259634e-05,
+ "pass": true
+ },
+ "display": {
+ "values": 641520,
+ "over_1": 24,
+ "frac_over_1": 3.7411148522259634e-05,
+ "pass": true
+ }
+ }
+ }
+ },
+ "new_default_d3d12_against_hip_raw_bytes": {
+ "real_weights": {
+ "L": {
+ "identical_frames": 11,
+ "frames": 11,
+ "outputs_compared": 28,
+ "differing": [],
+ "negative_controls_caught": {
+ "history": true,
+ "reduced": true,
+ "reduced_frame": true,
+ "missing": true
+ },
+ "l_post_d3d12": "l_post_recon"
+ },
+ "M": {
+ "identical_frames": 11,
+ "frames": 11,
+ "outputs_compared": 28,
+ "differing": [],
+ "negative_controls_caught": {
+ "history": true,
+ "reduced": true,
+ "reduced_frame": true,
+ "missing": true
+ },
+ "l_post_d3d12": null
+ }
+ },
+ "synthetic": {
+ "L": {
+ "identical_frames": 11,
+ "frames": 11,
+ "outputs_compared": 28,
+ "differing": [],
+ "negative_controls_caught": {
+ "history": true,
+ "reduced": true,
+ "reduced_frame": true,
+ "missing": true
+ },
+ "l_post_d3d12": "l_post_recon"
+ },
+ "M": {
+ "identical_frames": 11,
+ "frames": 11,
+ "outputs_compared": 28,
+ "differing": [],
+ "negative_controls_caught": {
+ "history": true,
+ "reduced": true,
+ "reduced_frame": true,
+ "missing": true
+ },
+ "l_post_d3d12": null
+ }
+ }
+ }
+}
diff --git a/clean/l/reference/recon.py b/clean/l/reference/recon.py
index 60b9a252..7ae5980a 100644
--- a/clean/l/reference/recon.py
+++ b/clean/l/reference/recon.py
@@ -212,8 +212,11 @@ def reconstruct(x, s, t=_table.TABLE, ldr=False):
W, fbar = gather(feat, x["C"], px, py, rw, rh, window)
cbar, sig, gbar, bh, bo = fbar[..., 0:3], fbar[..., 3:6], fbar[..., 6], fbar[..., 7], fbar[..., 8]
- # 3. motion candidates (Model M's rules)
- fy, fx = _post.point_index(px, py, rw, rh)
+ # 3. motion candidates (Model M's rules), at render positions in float32: the gather's (the model's precision) or,
+ # with Model M's float64 gather, Model M's (post.target_positions_f32), as the kernels compute them
+ half = rc.get("gather", "float64") == "half"
+ mpx, mpy = (px, py) if half else _post.target_positions_f32(rw, rh, dw, dh, jx, jy)
+ fy, fx = _post.point_index(mpx, mpy, rw, rh)
hi = bool(x.get("motion_output_res", False))
nan_valid = bool(x.get("nan_position_valid", hi))
first, second = _post.select_two(sig[..., 0], sig[..., 1], sig[..., 2])
@@ -249,10 +252,17 @@ def along(qx, qy):
h1, nan_h = along(qx.astype(np.float64), qy.astype(np.float64))
h2 = h1
else:
- m = [np.asarray(x["m_near"], np.float64)[fy, fx], _post.bilinear(x["m_center"], px, py),
- np.asarray(x["m_far"], np.float64)[fy, fx]]
- with np.errstate(invalid="ignore"):
- al = [along(X + mk[..., 0], Y + mk[..., 1]) for mk in m]
+ # candidate positions in float32 as the kernel computes them (Model M's reference does the same since #142;
+ # spec: float32 unless stated): m_center's bilinear and q = X + m. The validity test 0 <= q <= D is a
+ # discontinuity: in float64 a real-weight frame had a position just past D that the kernel's float32
+ # arithmetic puts exactly on D (valid), and the two samples differ widely
+ F32 = np.float32
+ m = [np.asarray(x["m_near"], F32)[fy, fx], _post.bilinear_f32(x["m_center"], np.asarray(mpx, F32),
+ np.asarray(mpy, F32)),
+ np.asarray(x["m_far"], F32)[fy, fx]]
+ X32, Y32 = X.astype(F32), Y.astype(F32)
+ with np.errstate(invalid="ignore", over="ignore"):
+ al = [along((X32 + mk[..., 0]).astype(np.float64), (Y32 + mk[..., 1]).astype(np.float64)) for mk in m]
Hk = np.stack([a[0] for a in al], axis=-1)
nk = np.stack([a[1] for a in al], axis=-1)
h1 = np.take_along_axis(Hk, first[..., None, None], -1)[..., 0]
diff --git a/clean/l/runner/l_default_post_check.py b/clean/l/runner/l_default_post_check.py
new file mode 100644
index 00000000..aa7f5cda
--- /dev/null
+++ b/clean/l/runner/l_default_post_check.py
@@ -0,0 +1,153 @@
+# SPDX-License-Identifier: MIT
+"""Model L (issue #89): which reconstruction should Model L's native D3D12 frame use by default? Both candidates against
+Model L's post oracle (clean/l/reference/recon.py), on l_frame_check's frames and models (with --prepare --model: the
+converter's real-weight model.wgcm, the frames synthetic).
+
+ python clean/l/runner/l_frame_check.py --build
--rocm --prepare [--model ] # CPU, once
+ python clean/l/runner/l_default_post_check.py --build --run # GPU, inside a GPU slot
+ python clean/l/runner/l_default_post_check.py --build --compare --json out.json # CPU
+
+/dx12 holds the D3D12 ports (python clean/dx12/build_dx12.py --out --model-l). --run runs l_frame_check's
+frame sequence for Model L on D3D12 twice, each in its own process:
+- "m_default" (A): runtime option l_post=m, today's default (Model M's fused pack12 post, w64/post_tf_f32_p12_diet_vsit,
+ with the runtime's default kernels). It writes the full and reduced history but no display image (the banded form,
+ which would, has no D3D12 port), so A is judged on the full history and the reduced codes;
+- "own_stages" (B): l_post=own (l_post_recon_p12, then the analytic filter) with the D3D12 fusions off
+ (WG_D3D12_FUSION=none, every stage output written), judged on the full history, the display image and the reduced
+ codes. (l_d3d12_own_post_check.py shows the default kernels give the same bytes.)
+--compare checks each run's post per frame on the frame's own inputs (l_frame_check compare_model: the unpacked
+pack12 coefficients, the run's own previous history) against recon.reconstruct, with Model L's post acceptance
+(clean/l/runner/l_post_check.py): FP16 values more than one ulp off at most 0.05 % per frame and 0.01 % over the run
+(history and display), and the rest of l_post_rule (no non-finite value, at most 1 % differing, mean error at most
+0.1 % of the reference RMS); the reduced codes within 1 and 99 % exact. Output: counts only, no timing; the model's
+source (synthetic seed, or the file's and map's SHA-256) from l_frame_check's source.json.
+"""
+import argparse
+import json
+import os
+import pickle
+import subprocess
+import sys
+
+import numpy as np
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.dirname(os.path.dirname(os.path.dirname(HERE)))
+sys.path.insert(0, ROOT)
+
+from clean.l.runner import l_frame_check as F # noqa: E402
+from clean.l.runner import l_post_check as LP # noqa: E402
+
+CONFIGS = {"m_default": ("m", False, 0x5A), "own_stages": ("own", True, 0x3C)}
+
+
+def run_one(build, config):
+ l_post, stages, sentinel = CONFIGS[config]
+ if stages:
+ os.environ["WG_D3D12_FUSION"] = "none" # before the runtime library is loaded
+ from clean.runner.pipeline import Pipeline
+ p = Pipeline(build, "", F.model_dir(build), F.MAX_RENDER, F.OUTPUT,
+ {"depth_inverted": False, "auto_exposure": True, "hdr": True}, backend="d3d12",
+ map_path=F.l_map(build), check_packing=False, kernels={"options": f"model=L;l_post={l_post}"})
+ rng = np.random.default_rng(F.SEED)
+ frames = []
+ for i, ((rw, rh), reset) in enumerate(F.SEQUENCE):
+ fr = F.frame_inputs(rng, rw, rh, reset, True)
+ F.fill_sentinels(p, sentinel, i == 0)
+ out = p.frame(fr, debug=True)
+ frames.append({"inputs": fr, "out": out, "raw": F.raw_outputs(p), "post_last": p.kernels().get("post_last")})
+ rec = {"model": "L", "config": config, "sentinel": sentinel, "kernels": p.kernels(), "notes": p.notes(),
+ "model_source": p.model_source, "dw": p.dw, "dh": p.dh, "ow": p.ow, "oh": p.oh,
+ "taps": p.output_taps(), "frames": frames}
+ with open(os.path.join(build, f"lframe_L_dp_{config}.pkl"), "wb") as f:
+ pickle.dump(rec, f)
+ print("L", config, "frames", len(frames), "post", rec["kernels"].get("post"), "l_post", rec["kernels"].get("l_post"),
+ "post_last", rec["kernels"].get("post_last"))
+
+
+def _load(build, config):
+ with open(os.path.join(build, f"lframe_L_dp_{config}.pkl"), "rb") as f:
+ return pickle.load(f)
+
+
+def post_frames(rec, params):
+ """Per frame: history and display against recon.reconstruct under Model L's post acceptance, reduced codes."""
+ per = F.compare_model(F.fill_pack12(rec), params, bneck_unit=True)
+ rows = []
+ for m in per:
+ row = {"frame": m["frame"]}
+ for k in ("history", "display"):
+ if k not in m["post"]:
+ continue
+ v = m["post"][k]
+ row[k] = {"values": v["values"], "over_1": v["over_1"], "pct_over_1": 100.0 * v["over_1"] / v["values"],
+ "max_f16_steps": v["max_f16_steps"], "differ": v["differ"], "nonfinite": v["nonfinite"],
+ "mean_rel_rms": v["mean_rel_rms"], "pass": bool(v["pass"]),
+ "pass_over_1": v["over_1"] <= LP.L_OVER1_CASE * v["values"]}
+ r = m["post"]["reduced"]
+ row["reduced"] = {"values": r["values"], "differ": r["differ"], "max_code_diff": r["max_code_diff"],
+ "pass": bool(r["pass"])}
+ row["pass"] = all(row[k]["pass"] for k in ("history", "display", "reduced") if k in row)
+ rows.append(row)
+ keys = [k for k in ("history", "display") if k in rows[0]]
+ run = {k: LP.l_post_run([r[k] for r in rows]) for k in keys}
+ for v in run.values():
+ v["pct_over_1"] = 100.0 * v["frac_over_1"]
+ worst = max(rows, key=lambda r: max(r[k]["pct_over_1"] for k in keys))
+ return {"frames": rows, "run": run, "frames_passed": sum(r["pass"] for r in rows),
+ "frames_passed_over_1": sum(all(r[k]["pass_over_1"] for k in keys) for r in rows),
+ "worst_frame": dict({"frame": worst["frame"]}, **{f"{k}_pct_over_1": worst[k]["pct_over_1"] for k in keys}),
+ "pass": all(r["pass"] for r in rows) and all(v["pass"] for v in run.values())}
+
+
+def compare(build, json_path):
+ with open(os.path.join(F.model_dir(build), "params.pkl"), "rb") as f:
+ params = pickle.load(f)["L"]
+ src = os.path.join(F.model_dir(build), "source.json")
+ res = {"model_source": json.load(open(src)) if os.path.exists(src) else None,
+ "rule": {"over_1_per_frame": LP.L_OVER1_CASE, "over_1_run": LP.L_OVER1_RUN}}
+ md, own = _load(build, "m_default"), _load(build, "own_stages")
+ res["kernels"] = {c: r["kernels"] for c, r in (("m_default", md), ("own_stages", own))}
+ res["A_m_post"] = post_frames(md, params)
+ res["B_own_post"] = post_frames(own, params)
+ with open(json_path, "w") as f:
+ json.dump(res, f, indent=1, default=lambda x: x.item() if hasattr(x, "item") else str(x))
+ print("model source:", json.dumps(res["model_source"]))
+ for key in ("A_m_post", "B_own_post"):
+ r = res[key]
+ print(key, "pass" if r["pass"] else "FAIL", "frames passed", r["frames_passed"], "of", len(r["frames"]),
+ "(over-1 limit only:", r["frames_passed_over_1"], ") run:",
+ json.dumps({k: (v["over_1"], v["values"], round(v["pct_over_1"], 5), v["pass"]) for k, v in r["run"].items()}),
+ "worst", json.dumps(r["worst_frame"]))
+ for row in r["frames"]:
+ print(" frame", row["frame"], *[f"{k} {row[k]['over_1']} / {row[k]['values']} "
+ f"{row[k]['pct_over_1']:.5f} % (max {row[k]['max_f16_steps']} ulp)"
+ for k in ("history", "display") if k in row],
+ "reduced differ", row["reduced"]["differ"], "max", row["reduced"]["max_code_diff"],
+ "pass" if row["pass"] else "FAIL")
+ return 0
+
+
+def main(argv=None):
+ ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+ ap.add_argument("--build", required=True)
+ g = ap.add_mutually_exclusive_group(required=True)
+ g.add_argument("--run", action="store_true")
+ g.add_argument("--compare", action="store_true")
+ ap.add_argument("--config", choices=sorted(CONFIGS), help="--run: one configuration (in this process)")
+ ap.add_argument("--json")
+ a = ap.parse_args(argv)
+ if a.run:
+ if a.config:
+ run_one(a.build, a.config)
+ return 0
+ for c in CONFIGS: # one process per configuration
+ r = subprocess.run([sys.executable, os.path.abspath(__file__), "--build", a.build, "--run", "--config", c])
+ if r.returncode:
+ return r.returncode
+ return 0
+ return compare(a.build, a.json or os.path.join(a.build, "l_default_post.json"))
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/clean/l/runner/l_frame_check.py b/clean/l/runner/l_frame_check.py
index 8aab4bc4..122c1672 100644
--- a/clean/l/runner/l_frame_check.py
+++ b/clean/l/runner/l_frame_check.py
@@ -48,10 +48,11 @@
python clean/l/runner/l_frame_check.py --build --compare-d3d12 --json out.json
/dx12 holds the D3D12 ports (python clean/dx12/build_dx12.py --out ). The same frames run on D3D12 with the
-runtime's default kernels there (Model L: its encoder and decoder ports, the pack12 store l_coef_pack12, Model M's
-pack12 post path; Model M: its native frame), and every stage output both backends write is compared with the HIP
-run's ("default"), byte for byte: the D3D12 ports reproduce their HIP kernels byte for byte, and Model M's pack12 post
-path the banded one bit for bit. The pack12 images (A: A0 A1 A2 B0 | B1 B2 C2, C: C0 C1; clean/FORMATS.md) are
+runtime's default kernels there (Model L: its encoder and decoder ports, the pack12 store l_coef_pack12, its own
+reconstruction l_post_recon_p12 and the analytic filter; with l_post=m Model M's pack12 post path instead; Model M:
+its native frame), and every stage output both backends write is compared with the HIP run's ("default"), byte for
+byte: the D3D12 ports reproduce their HIP kernels byte for byte, and Model M's pack12 post path the banded one bit for
+bit. (Where the D3D12 run's reconstruction is not the HIP run's, l_post=m for Model L, its post is checked on its own.) The pack12 images (A: A0 A1 A2 B0 | B1 B2 C2, C: C0 C1; clean/FORMATS.md) are
rearranged into the base layout's bytes and compared with the HIP run's A, B and C.
Byte identity (every "byte for byte" above): the RAW defined bytes of every output (RAW_OUTPUTS, the sizes wg_rt_buffer
@@ -369,14 +370,16 @@ def compare_backends(hip, dx, same_post=True):
"""Per frame: the raw defined bytes of every output, HIP run against D3D12 run (raw_compare; the D3D12 pack12
images in the base layout). same_post False (the backends run different reconstruction kernels): the post outputs
are left out. Not written by design: b0 ... b4 on both (the bottleneck megakernels), on D3D12 the maps its fusions
- keep on chip (enc1's merged map; Model M's dec2 / dec1 outputs, which its fused decoder reads on chip) and the display
- image (the fused pack12 post writes none), on the first frame the previous frame's state on both."""
+ keep on chip (enc1's merged map; Model M's dec2 / dec1 outputs, which its fused decoder reads on chip) and, with the
+ fused pack12 post, the display image (that kernel writes none; Model L's own post writes it), on the first frame the
+ previous frame's state on both."""
fused_onchip = ("enc1.merged",) + (("dec2.out", "dec1.out") if hip["model"] == "M" else ())
+ no_display = "post_tf" in str(dx["kernels"].get("post_last", ""))
def unwritten(k, n):
if n in BNECK_UNWRITTEN or (k == 0 and n in UNWRITTEN_ON_FIRST):
return "both"
- if n in fused_onchip or n == "post.display":
+ if n in fused_onchip or (n == "post.display" and no_display):
return "b"
return None
skip = () if same_post else POST_OUTPUTS_RAW
@@ -452,9 +455,12 @@ def compare_d3d12(build, json_path):
for config in ("default", "d3d12"):
with open(os.path.join(build, f"lframe_{model}_{config}.pkl"), "rb") as f:
recs[config] = pickle.load(f)
- # the HIP run's reconstruction: Model M's (bit-identical to the D3D12 fused pack12 post) or Model L's own
+ # the HIP run's reconstruction: Model M's (bit-identical to the D3D12 fused pack12 post) or Model L's own; the
+ # D3D12 run's: for Model L its own (l_post_recon: the runtime's default where its route applies) or Model M's
+ # fused pack12 post (l_post=m: m_pack12)
hip_post = recs["default"]["kernels"].get("l_post") or recs["default"]["kernels"].get("post_last")
- same_post = hip_post != "l_post_recon"
+ same_post = hip_post != "l_post_recon" or recs["d3d12"]["kernels"].get("l_post") == "l_post_recon"
+ no_display = "post_tf" in str(recs["d3d12"]["kernels"].get("post_last", ""))
frames = compare_backends(recs["default"], recs["d3d12"], same_post)
res[model] = {"kernels_d3d12": recs["d3d12"]["kernels"], "frames": frames,
"outputs_compared": sorted({n for f in frames for n in f["differ"]}),
@@ -466,7 +472,8 @@ def compare_d3d12(build, json_path):
res[model]["negative_controls"] = negative_controls(
dflt, recs["d3d12"], dflt["sentinel"], recs["d3d12"]["sentinel"],
lambda k, n: ("both" if n in BNECK_UNWRITTEN or (k == 0 and n in UNWRITTEN_ON_FIRST) else
- "b" if n in ("enc1.merged", "dec2.out", "dec1.out", "post.display") else None),
+ "b" if n in ("enc1.merged", "dec2.out", "dec1.out") or (n == "post.display" and
+ no_display) else None),
convert_b=True)
if not same_post:
# Model L: HIP runs l_post_recon, D3D12 Model M's fused pack12 post, and each frame's encoder reads the
diff --git a/clean/l/runtime/tests/test_l_runtime_frame.py b/clean/l/runtime/tests/test_l_runtime_frame.py
index 70f8a06f..6608135b 100644
--- a/clean/l/runtime/tests/test_l_runtime_frame.py
+++ b/clean/l/runtime/tests/test_l_runtime_frame.py
@@ -535,7 +535,9 @@ class D3D12(unittest.TestCase):
coefficient store for Model M's pack12 post path; each missing D3D12 port refused by name, never replaced."""
def l_run(self, ports, frames=3, flags=(), **kw):
- return run("model=L", frames=frames, build_files=FT.SHIPPING, flags=("--backend=3",) + tuple(flags),
+ # Model M's fused pack12 post (l_post=m): the route these tests trace; Model L's own post (the default where
+ # its ports are present) is test_own_post's
+ return run("model=L;l_post=m", frames=frames, build_files=FT.SHIPPING, flags=("--backend=3",) + tuple(flags),
manifest=ports, **kw)
def test_missing_ports_named(self):
@@ -700,9 +702,16 @@ def first(options, **kw):
got = first("model=L;l_post=own", flags=("--backend=3",),
manifest=[kc for kc in self.own_ports() if kc[0] != k])
self.assertEqual(got, "ERR create: Model L on native D3D12 (l_post=own): not yet ported to D3D12: " + k)
- # the default stays Model M's fused pack12 post (test_frame), named so; on HIP Model L runs its own post either way
- self.assertEqual(FT.Trace(run("model=L", frames=1, build_files=FT.SHIPPING, **d3d12)).kernels.get("l_post"),
- "m_pack12")
+ # the default: Model L's own post where its route applies (HDR, its ports present), else Model M's fused pack12
+ # post; l_post=m chooses Model M's; on HIP Model L runs its own post either way
+ def default(options="model=L", **kw):
+ return FT.Trace(run(options, frames=1, build_files=FT.SHIPPING, **dict(d3d12, **kw))).kernels.get("l_post")
+ self.assertEqual(default(), "l_post_recon")
+ self.assertEqual(default("model=L;l_post=m"), "m_pack12")
+ self.assertEqual(default(hdr=0), "m_pack12")
+ for k, _ in self.OWN:
+ with self.subTest(default_without=k):
+ self.assertEqual(default(manifest=[kc for kc in self.own_ports() if kc[0] != k]), "m_pack12")
def hip(options):
return [re.sub(r"wg_lfb_\w+", "B", x) for x in run(options, frames=2, build_files=FT.SHIPPING)]
diff --git a/clean/l/tests/test_l_recon.py b/clean/l/tests/test_l_recon.py
index c1a67fec..39c94735 100644
--- a/clean/l/tests/test_l_recon.py
+++ b/clean/l/tests/test_l_recon.py
@@ -141,14 +141,16 @@ def test_linear_combination(self):
e, ep = float(x["exposure"]), float(x["exposure_prev"])
px, py = R.target_positions_f32(rw, rh, dw, dh, *np.asarray(x["jitter"], np.float64))
fy, fx = MP.point_index(px, py, rw, rh)
- X = np.arange(dw)[None, :] + 0.5
- Y = np.arange(dh)[:, None] + 0.5
- m = [np.asarray(x["m_near"], np.float64)[fy, fx], MP.bilinear(x["m_center"], px, py),
- np.asarray(x["m_far"], np.float64)[fy, fx]]
+ # candidate positions in float32 as the kernel (m_center's bilinear, q = X + m)
+ X = (np.arange(dw)[None, :] + 0.5).astype(np.float32)
+ Y = (np.arange(dh)[:, None] + 0.5).astype(np.float32)
+ m = [np.asarray(x["m_near"], np.float32)[fy, fx],
+ MP.bilinear_f32(x["m_center"], np.asarray(px, np.float32), np.asarray(py, np.float32)),
+ np.asarray(x["m_far"], np.float32)[fy, fx]]
cands = []
hist = np.asarray(x["history"], np.float64)
for mk in m:
- qx, qy = X + mk[..., 0], Y + mk[..., 1]
+ qx, qy = (X + mk[..., 0]).astype(np.float64), (Y + mk[..., 1]).astype(np.float64)
valid = (qx >= 0) & (qx <= dw) & (qy >= 0) & (qy <= dh)
hs = R._f32(R._f32(MP.dec(MP.history_sample(hist, np.where(valid, qx, 0.5), np.where(valid, qy, 0.5))))
/ ep)
diff --git a/clean/runtime/runtime.cpp b/clean/runtime/runtime.cpp
index ad56fbc8..9517b6f2 100644
--- a/clean/runtime/runtime.cpp
+++ b/clean/runtime/runtime.cpp
@@ -241,10 +241,16 @@ struct Runtime {
// decoder in step 4 (clean/l/FORMATS.md); the ten Swin stages, exposure and post are Model M's.
bool model_l = false;
// runtime option l_post=own (native D3D12): Model L's own reconstruction l_post_recon_p12 (l_post.co's D3D12 port),
- // then the unbanded analytic filter w64/post_filter_c1_s4, in place of Model M's fused pack12 post (l_post=m, the
- // default there for now). On the direct-resource route the colour is staged into color_net (l_direct_color) and the
- // filter writes the game's texture itself (l_post_filter_direct, dx12/kernels/post_filter.hlsl).
+ // then the unbanded analytic filter w64/post_filter_c1_s4, in place of Model M's fused pack12 post (l_post=m). On the
+ // direct-resource route the colour is staged into color_net (l_direct_color) and the filter writes the game's texture
+ // itself (l_post_filter_direct, dx12/kernels/post_filter.hlsl).
+ // Default (no l_post option): own wherever its route applies (HDR colour, the default pack12 post route, its D3D12
+ // ports present: l_own_post_fits), else m. Why: Model M's post is another algorithm (3 x 3 gather, encoded-domain
+ // history); against Model L's post oracle it fails every frame (about 76 % of the full history's FP16 values more
+ // than one ulp off), Model L's own post passes Model L's post acceptance on every frame (real weights:
+ // clean/l/runner/l_default_post_check.py). LDR keeps m: l_post_recon's LDR form is not written yet.
bool l_own_post = false;
+ int l_post_choice = 0; // the l_post option: 0 not given (the default above), 1 m, 2 own
#ifdef WG_MODEL_L
// The maps of clean/l/FORMATS.md in three buffers (no kernel works in place):
// l_wide [fh + 4][fw + 4] x 64 bytes: q (FP8 halo, 32 bytes a pixel), then x2 (FP16 halo; q is dead after the
@@ -707,10 +713,11 @@ struct Runtime {
if (motion_outres == 1) return fail("Model L: motion_outres=original needs Model M's encoder (encoder_mo.co)");
d1d0_p12_opt = false;
#ifdef WG_MODEL_L
+ if (c.backend == 3 && l_post_choice == 0) l_own_post = l_own_post_fits(c);
if (l_own_post && c.backend == 3 && !l_own_post_setup(c)) return false;
#endif
}
- if (l_own_post && !model_l) return fail("l_post=own is a Model L option (its own reconstruction)");
+ if (l_post_choice == 2 && !model_l) return fail("l_post=own is a Model L option (its own reconstruction)");
if (!mid_setup(c)) return false;
if (!bneck_setup(c)) return false;
// D = O (fast mode, recon=output) runs without pack12, so dec1 + dec0 fused is the default there (bit-identical;
@@ -1107,6 +1114,7 @@ struct Runtime {
if (k == "l_post") {
if (v != "m" && v != "own") return fail("l_post must be m or own (Model L on native D3D12)");
l_own_post = v == "own";
+ l_post_choice = l_own_post ? 2 : 1;
}
if (k == "post_diet") post_diet = !(v == "0" || v == "off" || v == "false");
if (k == "tf_vdiet") tf_vdiet = !(v == "0" || v == "off" || v == "false");
@@ -1643,6 +1651,17 @@ struct Runtime {
// place of Model M's fused post. p12 stays (l_coef_pack12 feeds l_post_recon_p12; frames the pack12 kernels do not
// take run l_coef and l_post_recon); post_recon_stage launches Model L's kernel, step 6 the unbanded default filter
// (w64/post_filter_c1_s4, the analytic build: Model L's file has no output-filter weights).
+ // The default's test: l_own_post_setup's conditions, without failing
+ bool l_own_post_fits(const WgRtConfig& c) {
+ if (!c.hdr || !p12 || post_kernel != "post_recon2_r_band_p12" || filter_kernel != "post_filter_c1_s4_band" || out_f16)
+ return false;
+ std::vector need = {"l_post_recon_p12", "l_post_recon", "l_coef", "w64/post_filter_c1_s4"};
+ if (native_direct_io) {
+ need.push_back("l_direct_color");
+ need.push_back("l_post_filter_direct");
+ }
+ return manifest_missing(need).empty();
+ }
bool l_own_post_setup(const WgRtConfig& c) {
if (!c.hdr)
return fail("Model L: l_post=own needs HDR colour (WgRtConfig.hdr = 1): l_post_recon is HDR, its LDR form is "