ruvnet--RuView/benchmarks/wiflow-std/RESULTS.md

WiFlow-STD (DY2434) Benchmark Results — ADR-152 §2.2

Upstream: https://github.com/DY2434/WiFlow-WiFi-Pose-Estimation-with-Spatio-Temporal-Decoupling pinned at 06899d29 (2026-04-05), Apache-2.0. Dataset: Kaggle kaka2434/wiflow-dataset (12.8 GB archive → 15.5 GB extracted; 360,000 windows of 540×20 CSI + 15-keypoint 2D labels).

Published claims (README "Setting 1"): PCK@20 97.25%, PCK@30 98.63%, PCK@40 99.16%, PCK@50 99.48%, MPJPE 0.007 m, 2.23M params, 0.07 GFLOPs.

Measurement (a): their model on their data

Artifact verification (MEASURED, 2026-06-10, this repo eval_repro.py)

Check	Result
Parameter count	2,225,042 (2.23M) — matches claim
FLOPs (torch profiler, batch 1)	~0.055 GFLOPs — consistent with 0.07B claim
CPU latency (Windows box, torch 2.12 CPU)	13.2 ms/window @ batch 1 (76/s); 2.48 ms/sample @ batch 64 (403/s)
Checkpoint load	weights_only=True (no pickle code execution)

Released checkpoint does NOT reproduce the claims — REFUTED as shipped

Running the released best_pose_model.pth through the released code on the released dataset with the released split procedure (seed-42 file-level 70/15/15; 54,000 test samples) yields:

Metric	Published	Measured (shipped checkpoint)
PCK@20	97.25%	0.08%
PCK@30	98.63%	0.78%
PCK@40	99.16%	5.53%
PCK@50	99.48%	15.42%
MPJPE	0.007	NaN (dataset contains NaN CSI windows)

Raw output: results/repro_a.json.

Diagnostics (on 2,000 NaN-free windows from the first files of the dataset, i.e. mostly would-be training data — so this is not a split mismatch):

• Predictions correlate with targets (Pearson r ≈ 0.76) — the checkpoint is a trained model, but in a different keypoint normalization/order than the released data.
• Best-case post-hoc global per-axis affine correction: PCK@20 ≈ 20%.
• Best-case per-keypoint affine correction (15×2 fitted transforms — generous cheating): PCK@20 ≈ 72%, still far below 97.25%.
• Pred↔target keypoint correspondence matrix is degenerate (multiple predicted keypoints best-match the same target joint) — keypoint convention mismatch.

Reproducibility defects in the released artifacts

1. models/__init__.py imports TemporalConvNet, which models/tcn.py does not define — the published code does not import/run as-is.
2. The released root checkpoint uses pre-rename module names (att.*, final_conv.*) vs the published code (attention.*, decoder.*) — same shapes/param count, but confirms the checkpoint predates the published code.
3. The second shipped checkpoint (cross_dataset_test/WiFlow/best_pose_model.pth) is a different architecture (342-channel input = MM-Fi layout, 3 TCN layers, 3-channel/3D decoder) — not usable on their own dataset.
4. run.py ignores --data_dir and hardcodes ../preprocessed_csi_data.
5. The released dataset's final 13 files (indices 487–499; 9,072 windows, 2.52%) are corrupted: NaN values plus garbage amplitudes up to 3.4e38 (float32 max) in data that is otherwise [0,1]-normalized. Upstream code has no NaN/inf handling; training as published on this download diverges — the first corrupted batch overflows fp16 autocast and permanently poisons BatchNorm running statistics (GradScaler step-skipping does not protect BN). The authors' training curves show normal convergence, so their local data evidently differed from the Kaggle upload. Window masks: results/nan_windows_mask.npy, results/big_windows_mask.npy.

Reproducing the corruption masks

The two mask files (9,070 NaN/Inf windows, 9,072 with |amplitude| > 1.5; union 9,072, all in dataset files 487–499) are committed ground truth (gitignore-negated, ~352 KB each). They can only be regenerated from a pristine Kaggle download: remote/clean_v2.py repairs the dataset by zeroing the corrupted windows in place, after which the corruption evidence is gone and a rescan returns all-False. generate_corruption_masks.py re-derives them (chunked scan, criteria: any non-finite value OR max |finite| > 1.5 per 540×20 window) and refuses to write all-False masks, which indicate a cleaned copy. Verified 2026-06-11: a regeneration from the local pristine download is bit-identical to the committed masks.

Retraining result (MEASURED, 2026-06-10): claims APPROXIMATELY REPRODUCED

Since the shipped checkpoint is unusable, measurement (a) fell back to retraining with upstream code + defaults (seed 42, batch 64, early-stopped at epoch 41 of 50, best epoch 36, ~75 s/epoch) on ruvultra (RTX 5080). Deviations, all forced and documented: one-line fix for defect (1); torch 2.x+cu128 instead of pinned 2.3.1 (Blackwell sm_120 unsupported); the 9,072 corrupted windows (defect 5) zeroed entirely — without this the published pipeline produces NaN from epoch 1 (observed). Scripts mirrored in remote/; raw metrics in results/eval_retrained.json.

Metric	Published	Retrained (full test, 54,000)	Retrained (corruption-free, 52,560)
PCK@20	97.25%	96.09%	96.61%
PCK@30	98.63%	97.89%	98.23%
PCK@40	99.16%	98.58%	98.79%
PCK@50	99.48%	98.99%	99.11%
MPJPE	0.007	0.0098	0.0094

Within ~0.6–1.2 PCK points of every published figure (single run, corrupted train windows zeroed, different torch/GPU). Verdict: the accuracy claims are credible and approximately reproducible — but only after repairing the released dataset and code. Val best: PCK@20 96.99%, MPJPE 0.0086 (epoch 36).

One more defect found during the run:

6. train.py calls plot_training_history, which is not defined anywhere — the built-in post-training test evaluation is unreachable as published (crashes with NameError after training completes).

ADR-152 §2.2 citation rule

Evidence grade for the WiFlow-STD accuracy claims after measurement (a): MEASURED-EQUIVALENT (96.1–96.6% PCK@20 reproduced by retraining; shipped checkpoint REFUTED; dataset/code require repairs). RuView docs may cite "~96% PCK@20 (our reproduction)" — still not comparable to our 17-keypoint ESP32 numbers (different hardware, 5 subjects, in-domain random split, 15 keypoints).

Edge optimization (measured)

ADR-152 "optimize beyond SOTA" track, 2026-06-10, this Windows box (Windows 11, 16 torch threads, torch 2.12.0+cpu, onnxruntime 1.26.0). Subject: the retrained checkpoint results/retrained_best_pose_model.pth (2,225,042 fp32 params). Scripts: quantize_bench.py, onnx_bench.py, eval_ort_accuracy.py. Raw numbers: results/edge_optimization.json.

Accuracy is on a 10,000-window seed-42 random subset of the corruption-free test split (same seed-42 file-level 70/15/15 split as eval_repro.py; 54,000 test windows, 1,440 corrupted excluded via results/nan_windows_mask.npy | results/big_windows_mask.npy, leaving 52,560; subset drawn with np.random.default_rng(42)). The fp32 subset PCK@20 (96.68%) matches the full clean-test figure (96.61%), so the subset is representative.

Latency is CPU ms/window, median of repeated runs, 3 interleaved repetitions per variant (medians below; run-to-run spread on this box is large, roughly ±20-40% at batch 1 — reps are in the JSON).

Variant	Disk size	Batch 1 (ms/win)	Batch 64 (ms/win)	PCK@20	PCK@50	MPJPE
torch fp32 (baseline)	9.07 MB	11.0	2.27	96.68%	99.15%	0.00936
torch fp16 (.half())	4.58 MB	24.3	2.42	96.68%	99.15%	0.00946
torch int8 dynamic	9.07 MB (unchanged)	15.6	2.06	96.68% (identical)	99.15%	0.00936
ONNX fp32 (onnxruntime)	8.97 MB	3.2	2.0	96.68%	99.15%	0.00936
ONNX int8 (ORT dynamic, supplementary)	2.44 MB	6.5	5.8	96.52%	99.15%	0.01108

Findings:

• torch dynamic INT8 quantizes nothing on this model. The architecture has zero nn.Linear layers — it is entirely Conv1d (21) + Conv2d (22) + BatchNorm. torch.ao.quantization.quantize_dynamic (requested over {Linear, Conv1d, Conv2d}) converted 0 modules / 0.0% of params: dynamic quantization only has kernels for Linear/RNN-family modules and silently skips convolutions. The "int8" model is bit-identical to fp32 (same outputs, same 9.07 MB). Conv quantization would require static (PTQ) quantization with calibration — out of scope here; the ORT dynamic path below is the honest int8 datapoint.
• fp16 halves size for free accuracy-wise (PCK@20 −0.005 pt, MPJPE +0.0001) but is slower on CPU at batch 1 (~2.2×) — torch CPU fp16 conv kernels are emulated. fp16 is a storage/transport format here, not a CPU runtime win.
• ONNX Runtime is the real batch-1 latency win: ~3.4× faster than torch (3.2 vs 11.0 ms/window) at identical accuracy (parity 2.4e-7).

Verdict on the paper's "~2.2 MB int8" claim

Plausible but not free, and unreachable by the obvious PyTorch route. 2,225,042 params × 1 byte ≈ 2.2 MB assumes every parameter quantizes. PyTorch dynamic quantization — the one-liner most readers would reach for — yields 9.07 MB (0% quantized) because the model has no Linear layers. ONNX Runtime dynamic quantization, which does have int8 conv weight support, gets 2.44 MB (close to the claim; the overhead is BatchNorm params/buffers and quantization scales kept in fp32) at a measurable accuracy cost: PCK@20 96.68 → 96.52% (−0.16 pt) and MPJPE 0.00936 → 0.01108 (+18%), and ~2× slower inference than ONNX fp32 (ConvInteger kernels). The paper does not state a method or an int8 accuracy; treat "2.2 MB" as a weight-arithmetic estimate, achievable in practice only via conv-capable quantization toolchains and with a small accuracy penalty.

ONNX export status

Works. Exported via the TorchScript exporter (dynamo=False), opset 17, with a dynamic batch axis — results/retrained_fp32_dynamic.onnx (8.97 MB), verified to run at batch 1/2/64. The axial attention's view(N*W, C, H) reshape traced correctly (sizes recorded as graph ops, not baked constants). The dynamo exporter also captures the graph but crashed on this box writing a ✅ to a cp1252 console (cosmetic Windows encoding issue, not a model blocker). Parity vs torch on the stored fixture (results/parity_fixture.npz, batch 2, seed 42): max abs diff 2.4e-7 — PASS (< 1e-4). ORT-quantized int8 model: results/retrained_int8_ort_dynamic.onnx.

Static PTQ (calibrated) — follow-up

Follow-up to the dynamic-int8 row above (2026-06-10, same box, onnxruntime 1.26.0): ONNX Runtime static post-training quantization (quantize_static, QDQ format, per-channel int8 weights + int8 activations) of the same fp32 export, calibrated on corruption-free TRAINING-split windows only (seed-42 file-level split, same masks; 1,000 windows for MinMax, 512 for the histogram calibrators; never test windows). Scopes: "conv-only" (op_types_to_quantize=["Conv"] — the attention path exports as Einsum/Softmax, which ORT never quantizes anyway, so "all-ops" additionally quantizes the elementwise Mul/Sigmoid/Add/AveragePool glue). Accuracy on the identical 10k-window seed-42 corruption-free test subset; latency median of 3 interleaved reps (fp32/dynamic re-benched in-session as references). Script: static_ptq_bench.py; raw: results/edge_optimization.json (onnx_static_ptq).

Variant	Disk size	Batch 1 (ms/win)	Batch 64 (ms/win)	PCK@20	PCK@50	MPJPE
ONNX fp32 (reference)	8.97 MB	2.5	1.9	96.68%	99.15%	0.00936
ORT dynamic int8 (baseline)	2.44 MB	5.7	4.6	96.52%	99.15%	0.01108
static QDQ Percentile(99.99) conv-only	2.53 MB	5.3	4.7	96.61%	99.16%	0.01031
static QDQ MinMax conv-only	2.53 MB	5.2	3.3	96.63%	99.19%	0.01084
static QDQ Entropy conv-only	2.53 MB	5.2	3.1	96.60%	99.19%	0.01078
static QDQ MinMax all-ops	2.60 MB	6.5	3.9	95.45%	99.14%	0.01486
static QDQ Entropy all-ops	2.60 MB	5.7	4.1	95.30%	99.13%	0.01510
static QDQ Percentile all-ops	2.60 MB	5.3	4.3	96.39%	99.17%	0.01218

Verdict: static PTQ (conv-only) is the new best int8 point on accuracy — but only modestly, and it does not fix int8's latency penalty.

• Accuracy: beats dynamic. All three conv-only calibrations land at PCK@20 96.60–96.63% (vs dynamic 96.52%, fp32 96.68% — recovers ~⅔ of the dynamic gap) and MPJPE 0.0103–0.0108 (vs dynamic 0.01108). Best MPJPE: Percentile conv-only, +10% over fp32 instead of dynamic's +18%.
• Size: slightly worse. 2.53 MB vs 2.44 MB (+3.6%) — QDQ nodes and per-channel scales cost a little; BatchNorm stays fp32 in both (the 12 BNs follow Slice/Einsum/Reshape, never Conv, so they cannot be folded).
• Latency: a wash vs dynamic, still ~2× slower than ONNX fp32 at batch 1. Batch-1 medians 5.2–5.3 vs dynamic 5.7 ms/win in-session — within this box's ±20–40% noise. Batch 64 leans static (3.1–3.3 for MinMax/Entropy conv-only vs 4.6), same caveat.
• All-ops QDQ is strictly worse: up to −1.4 pt PCK@20 and +60% MPJPE for zero size/latency benefit — int8 activations through the elementwise glue around the attention blocks is where the damage is. Conv-only is the right scope.
• Negative result worth recording: Entropy calibration is a no-op here — on an identical calibration set it selects full-range thresholds bit-identical to MinMax (all 247 scales equal; verified on a 64-window smoke set). Also, ORT 1.26's CalibMaxIntermediateOutputs raises a spurious "No data is collected" when the batch count divides the chunk size (worked around in the script).

Deployment guidance: need speed → ONNX fp32 (3.2 ms b1). Need int8 weights for size → static QDQ conv-only (Percentile or MinMax, results/retrained_int8_static_percentile_conv.onnx), which strictly dominates dynamic int8 on accuracy at ~equal latency and +0.09 MB.

Efficiency sweep (MEASURED, overnight 2026-06-10/11)

ADR-152 beyond-SOTA track: compact purpose-built variants of the WiFlow-STD architecture, trained from scratch on the same cleaned dataset, identical seed-42 file-level split, loss and protocol as the measurement-(a) reference (fp32, batch 64, ≤50 epochs, patience 5; RTX 5080, ~22–29 min/variant). Variant transforms are pure channel/group/stride scalings of an architecture-exact parameterized model (validated: reproduces 2,225,042 params at the reference config). Scripts: remote/sweep/; raw: results/efficiency_sweep.jsonl; checkpoints results/{half,quarter,tiny}_best.pth (gitignored).

Variant	Params	vs 2.23M	Clean-test PCK@20	PCK@50	MPJPE	Best epoch
full (reference, meas. a)	2,225,042	1×	96.61%	99.11%	0.0094	36
half	843,834	0.38×	96.62%	99.47%	0.00898	23
quarter	338,600	0.15×	96.05%	99.43%	0.00928	50
tiny	56,290	0.025×	94.11%	99.36%	0.0125	47

Findings:

• The half model (843k params) strictly dominates the full reference on this dataset — equal PCK@20, better PCK@50 and MPJPE, converges in fewer epochs. The published 2.23M architecture is over-parameterized for its own benchmark.
• tiny (56k params, 1/39.5) holds 94.11% PCK@20 — a ~220 KB fp32 / ~60 KB int8-class model in reach of severely constrained edge targets, at −2.5 pt from the full reference.
• Caveats: in-domain (5-subject random-file split) like every number on this dataset; single run per variant; corruption-free test subset (52,560). Cross-domain behavior of compact variants is untested — ADR-150's evidence says capacity hurts cross-subject, so the compact end may generalize no worse, but that is a hypothesis, not a measurement.

Compact-variant edge artifacts (MEASURED, 2026-06-11)

Edge pipeline for the tiny checkpoint (56,290 params), same machinery and protocol as the full-model edge rows above (this Windows box, torch 2.12.0+cpu, onnxruntime 1.26.0; dynamic-batch opset-17 TorchScript export; static QDQ Percentile(99.99) conv-only int8 calibrated on 512 corruption-free TRAIN-split windows; accuracy on the identical 10k-window seed-42 clean test subset; latency = median ms/window over 3 interleaved reps, with the full-model fp32/int8 sessions interleaved as same-session references). Script: tiny_edge_bench.py; raw: results/edge_optimization.json (tiny_variant). Torch-vs-ORT parity on the stored fixture input: max abs diff 1.5e-7 — PASS (< 1e-4). The tiny fp32 subset PCK@20 (94.11%) matches the full clean-test sweep figure (94.11%) exactly, so the subset remains representative.

Two forced deviations, both recorded in the JSON:

1. Adaptive-pool export rewrite. tiny's derived stride schedule [2,1,1,1] leaves feature width 16, and the TorchScript exporter rejects AdaptiveAvgPool2d((15,1)) when 15 is not a factor of the input height (the full model never hit this — its width was exactly 15). Since the pool over a fixed-size map is a fixed linear operator, the export wrapper replaces it with mean(-1) (W axis, a factor) + a constant averaging matmul using PyTorch's exact bin rule; the parity check (vs the original torch model with the real pool) proves exactness.
2. Calibration count 512, not "~500": ORT 1.26's histogram collector np.asarray()'s the per-batch maxima, so the calibration count must be a multiple of the 64-window calibration batch or the ragged last batch crashes it (the earlier static-PTQ run dodged this by using exactly 512).

Variant	Disk size	Batch 1 (ms/win)	Batch 64 (ms/win)	PCK@20	PCK@50	MPJPE
full ONNX fp32 (same-session ref)	8.97 MB	2.27	1.42	96.68%	99.15%	0.00936
full static QDQ Percentile conv-only (same-session ref)	2.53 MB	5.53	3.82	96.61%	99.16%	0.01031
tiny ONNX fp32	0.295 MB	0.66	0.24	94.11%	99.37%	0.01253
tiny static QDQ Percentile conv-only	0.248 MB	0.85	1.03	92.68%	99.33%	0.01491

(tiny torch .pth checkpoint for reference: 0.34 MB on disk; 56,290 fp32 params ≈ 225 KB of weights.)

Findings:

• The smallest deployable WiFlow-class model is the tiny ONNX fp32 artifact: ~295 KB on disk, 0.66 ms/window batch-1 CPU (~1,500 windows/s), 94.1% PCK@20 — 30× smaller and ~3.4× faster (in-session) than the full ONNX fp32 model for −2.6 pt PCK@20.
• int8 is a bad trade at this scale. Static QDQ conv-only — the recipe that cost the full model only 0.07 pt — costs tiny −1.43 pt PCK@20 (94.11 → 92.68%) and +19% MPJPE, saves only 47 KB (−16%; QDQ scales and the fp32 BN/attention glue are proportionally larger in a small graph), and is slower than tiny fp32 (0.85 vs 0.66 ms b1; 1.03 vs 0.24 ms b64 — QDQ kernel overhead dominates when the convs are this small). A 56k-param model has little redundancy left to absorb weight+activation rounding.
• Deployment guidance, compact edition: ship tiny as ONNX fp32 — at 295 KB the int8 size saving solves no real constraint and costs accuracy and speed. If ~250 KB vs ~295 KB ever matters, weight-only quantization would be the thing to try next, not QDQ.

Measurement (b): BLOCKED-ON-DATA (attempted 2026-06-10)

The fine-tune-on-ESP32 measurement stopped at dataset characterization, per the pre-registered stop rule (<2,000 paired windows). Findings (MEASURED):

• Only one trainable paired dataset exists: ruvultra:~/work/cog-pose-train/paired.jsonl — 1,077 windows (one subject, one room, one 29.9-min session, single node; CSI [56, 20]; 17 COCO keypoints, MediaPipe confidence mean 0.44 — only 264 windows pass ADR-079's own conf>0.5 training filter). Prior measured attempts on this exact set: 0–3% torso-PCK@20 (temporal splits, three independent pipelines). Fine-tuning a 2.23M-param model on ~860 train windows would measure memorization, not transfer.
• The April session behind the old "92.9% PCK@20" claim is lost (345 samples, 35 subcarriers; raw CSI gone from ruvzen/ruvultra/cognitum-v0; only a 69-sample predictions+GT holdout survives at models/wiflow-real/eval-holdout.jsonl).
• Forensic recheck of that holdout RETRACTS the 92.9% figure: the trainer's pck() used an absolute 0.2 image-unit threshold (not torso-normalized) and the model output a constant pose (pred std 0.0000 across 69 near-static frames; a mean predictor scores 100% under the same protocol). The torso-normalized PCK@20 on the same holdout is 19.1%. This corroborates the 2026-05-11 audit retraction (CHANGELOG, PR #535); stale doc citations were removed 2026-06-10 (user-guide, readme-details, ADR-152 §2.1.3). The §2.2 no-citation rule now applies to ADR-079 accuracy claims.

Unblock criteria: a paired collection session of ≥2k windows (≈35+ min at the observed stride; multi-pose, conf>0.5, ideally with the §2.1.3 two-checkerboard calibration), plus a re-baselined our-pipeline number under torso-PCK@20 on the same split. WiFlow-STD assets stand ready on ruvultra (~/wiflow-std-bench/). Also worth investigating: ADR-079's protocol predicts ~9k windows per 30 min; the May session under-delivered ~8× (aligner drop rate?).

Measurement (b) (MEASURED 2026-06-10/11)

The data baseline unblocked: the 2026-06-10 22:10–22:40 collection session produced 2,046 paired windows (ruvultra:~/wiflow-std-bench/paired-20260610.jsonl; ONE subject, ONE room, ONE ESP32 node, varied poses: walk/raise/squat/kick/wave/turn/ jump/sit; aligner scripts/align-ground-truth.js, non-overlapping 20-frame windows ~0.42 s; 17 COCO keypoints in normalized [0,1] camera coords; MediaPipe confidence mean 0.802, min 0.692 — all windows pass the conf>0.5 filter). The −4 h timestamp bug and the empty-frame confidence-dilution aligner findings are recorded separately; results only here. Trained on ruvultra (RTX 5080, torch 2.11+cu128, fp32, batch 32, GPU shared with the efficiency sweep). Scripts mirrored in remote/measb/; raw metrics + full training curves in results/measurement_b.json.

Two new aligner/dataset findings (forced deviations, MEASURED)

1. csi_shape is heterogeneous, not [70, 20]: 1,347× [70,20], 284× [134,20], 243× [26,20], 130× [12,20], 42× [20,20]. The ESP32 stream emits mixed frame types and extractCsiMatrix stamps each window's subcarrier count from window[0].subcarriers, zero-padding/truncating the other frames — even native-70 windows contain ~20.4% internally zero-padded short frames (subcarriers 40–69 all-zero). Handling: the primary suite ("all 2,046") linearly resamples every frame's subcarrier axis to 70 bins (identity for native-70 frames) so the pre-registered n and split sizes hold; a secondary suite restricts to the 1,347 native [70,20] windows as a homogeneity check.
2. Aligner layout bug: extractCsiMatrix fills matrix[f * nSc + s] (frame-major) but declares shape: [nSc, nFrames] — the stored shape label is transposed relative to the data. Confirmed by coherent per-frame zero-tails; corrected on load (reshape(nFrames, nSc).T).

Protocol (pre-registered, followed)

Temporal split, no shuffling across time: first 70% train (1,432), next 15% val (307), last 15% test (307); seed 42 elsewhere. Model: learned 1×1 Conv1d 70→540 adapter prepended to the upstream WiFlow-STD trunk; K=17 via the parameter-free adaptive pool (AdaptiveAvgPool2d((17,1)) — pretrained weights load strict for any K). CSI normalized by the TRAIN-split p99 amplitude (129.7 all / 130.9 native-70), clipped to [0,1]. Three runs, ≤60 epochs, early-stop patience 8 on val MPJPE, AdamW (adapter lr 1e-4; pretrained trunk lr 1e-5, 10× lower; scratch all 1e-4), fp32. Pretrained init = the measurement-(a) retrained checkpoint (upstream/test/best_pose_model.pth, ~96% PCK@20 on WiFlow data; the att./final_conv. key remap from eval_repro.py applied defensively — a no-op, that checkpoint already uses post-rename keys). Frozen-trunk run: trunk requires_grad=False and held in .eval() so BatchNorm running stats cannot drift — a pure transfer probe; only the 70→540 adapter (38,340 params) trains.

PCK is torso-normalized with torso = ‖l_shoulder(5) − l_hip(11)‖ (upstream calculate_pck math — per-frame norm clamped at 0.01, mean over keypoints × frames — but upstream's NECK_IDX/PELVIS_IDX = 2, 12 is a 15-keypoint convention; on 17-kp COCO those indices are right_eye/right_hip, so the indices were replaced, not the math). MPJPE is in normalized image units (not meters).

Results — primary suite, all 2,046 windows (test = last 307)

Run	PCK@10	PCK@20	PCK@30	PCK@40	PCK@50	MPJPE	pred std	best ep
mean-pose baseline (honesty bar)	73.1%	95.9%	98.7%	99.3%	99.3%	0.0148	0 (by constr.)	—
(i) pretrained-init, full fine-tune	26.0%	65.0%	88.0%	96.4%	98.9%	0.0313	0.0113	58/60
(ii) scratch	0.0%	0.0%	0.0%	0.0%	0.0%	0.2554	0.0002	4 (stop @13)
(iii) frozen-trunk (adapter only)	0.0%	0.0%	0.2%	3.2%	14.4%	0.1260	0.0073	59/60

Secondary suite (native [70,20] windows only, n=1,347, test=202) reproduces the same ordering: mean-baseline 96.0% / pretrained 67.1% / scratch 0.0% / frozen-trunk 0.0% PCK@20 (MPJPE 0.0153 / 0.0318 / 0.2236 / 0.1343) — the subcarrier-resampling choice does not change any conclusion.

Interpretation

• Did pretraining-transfer happen? Partially — as optimization transfer, not feature transfer, and not past the honesty bar.
  • Pretrained vs scratch: dramatic (65.0% vs 0.0% PCK@20). The pretrained init is the only configuration that trains at all under the pre-registered budget.
  • Frozen-trunk: near-zero (0.0% PCK@20, 14.4% @50). WiFlow-STD's frozen features do not transfer to our ESP32 domain through a linear subcarrier adapter — the pretrained benefit is a well-conditioned initialization (incl. calibrated BN/output scales), not reusable CSI→pose features.
  • Everything vs mean-pose baseline: no run beats it. A constant train-mean pose scores 95.9% torso-PCK@20 / 0.0148 MPJPE on this test split, because a single subject in one camera frame barely moves in normalized coordinates. The fine-tuned model is a real, non-constant model (pred std 0.0113 > 0 — passes the constant-pose detector that retracted the old 92.9% figure) but its deviations from the mean hurt: it fits train-period temporal dynamics that do not generalize across the temporal split.
• Verdict for ADR-152 §2.2(b): fine-tuning WiFlow-STD on this dataset does not demonstrate CSI→pose signal beyond the mean pose. Until a model beats the mean-pose baseline on a temporal split, no PCK number from this line may be cited as pose-estimation capability.

Caveats (honest, pre-registered)

• Single subject, single room, single session (30 min), single ESP32 node — in-domain temporal split only; nothing here speaks to cross-room or cross-subject generalization.
• 2k windows vs the 360k-window WiFlow-STD corpus — NOT comparable to the ~96% in-domain measurement-(a) number, and the published 97.25% even less so.
• The scratch run's total collapse (it cannot even reach the mean pose; its output BatchNorm/SiLU head must learn output scale from random init at lr 1e-4) is an optimization outcome under the fixed budget, not proof the architecture cannot learn from scratch — the pretrained-vs-scratch gap partially reflects this conditioning advantage.
• Mixed-subcarrier frames (finding 1) mean even the "clean" windows carry ~20% zero-padded frames; collection-side frame-type filtering should precede the next session.
• Mean-baseline PCK is inflated by low pose variance relative to torso size (~0.2–0.3 image units); PCK@10 (73.1%) shows the same ceiling effect at a stricter threshold — the bar is the bar, but a livelier dataset would lower it.

Pending

• (b) fine-tune on our ESP32 17-keypoint eval set — MEASURED 2026-06-10/11, see above: no run beats the mean-pose baseline; pretraining transfers as optimization aid only.
• (c) our internal WiFlow on their dataset (15-keypoint subset mapping) — also affected: there is currently no validated internal pose model to compare (the 92.9% artifact is retracted; the MM-Fi SOTA models in ADR-150 §3 are a different input domain).