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 "