mirror of
https://github.com/ruvnet/RuView
synced 2026-06-09 10:13:17 +00:00
Compare commits
2 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 rUv
|
d9ca9b3684 | ||
|
rUv
|
a85d4e31e4 |
@@ -0,0 +1,72 @@
|
||||
# SOTA Research Loop — 2026-05-22
|
||||
|
||||
Started: 2026-05-21 ~20:00 ET. **Auto-stops: 2026-05-22 08:00 ET.** Cron `d6e5c473` (`*/10 * * * *`).
|
||||
|
||||
## Mandate
|
||||
|
||||
Push WiFi-CSI sensing past 2026 published SOTA in three axes:
|
||||
|
||||
1. **Spatial intelligence** — multi-static fusion, room-scale awareness, occupancy beyond counting
|
||||
2. **RF feature engineering** — phase, ToA, subcarrier dynamics, Fresnel zones
|
||||
3. **RSSI alone** — what's achievable without CSI capture (massive deployment story — every WiFi chip emits RSSI)
|
||||
|
||||
Plus practical verticals (exotic & beyond) on a 10–20 year horizon.
|
||||
|
||||
Output goes to `docs/research/sota-2026-05-22/` (research notes, benchmarks, negative results) + `examples/research-sota/` (runnable code).
|
||||
|
||||
## Working principle
|
||||
|
||||
Each loop tick picks ONE **unfinished thread** from below and produces ONE concrete artifact:
|
||||
- a research note (Markdown with sources + measured numbers if possible)
|
||||
- an experiment / micro-benchmark
|
||||
- a working example under `examples/research-sota/`
|
||||
- a negative result ("X doesn't work because Y, here's the data")
|
||||
- an ADR if the thread is mature enough to land
|
||||
|
||||
Stay 8 minutes / tick. Commit + PR + auto-merge per piece. Future-tick re-entry is via this PROGRESS.md.
|
||||
|
||||
## Research vectors
|
||||
|
||||
### Spatial Intelligence
|
||||
|
||||
- [ ] **R1. Multi-static Time-of-Arrival (ToA) from OFDM phase coherence.** Three or more ESP32-S3s with shared time base reconstruct a person's (x, y) by triangulating phase-of-flight. 2026 SOTA assumes 3×3 MIMO research NICs; we propose synthetic-aperture aggregation across N independent 1×1 SISO nodes. Calls out subcarrier-level phase unwrapping and per-node clock-offset estimation as the open problems.
|
||||
- [ ] **R2. Persistent room field model — eigenstructure perturbation.** Already in `wifi-densepose-signal/src/ruvsense/field_model.rs` (SVD on empty-room CSI). Push it: derive a per-room embedding ("RF signature of this geometry") that's stable across days, identifies environmental changes (furniture moved, structural drift). Vertical: building-integrity monitoring.
|
||||
- [ ] **R3. Cross-room re-identification via gait CSI signatures.** Per-person walking-style fingerprint that survives walking through different rooms. Different from `AETHER` (in-room re-ID) — this is *inter*-room continuity.
|
||||
- [ ] **R4. Federated learning of room models.** Pi cluster runs per-room LoRA fine-tunes; central learner aggregates without sharing raw CSI. Privacy-preserving spatial intelligence.
|
||||
|
||||
### RF Feature Engineering
|
||||
|
||||
- [ ] **R5. Subcarrier attention over time → "RF saliency map".** Visualize which subcarriers carry the most information per task. ADR-097 hints at this; nothing in repo computes it. Useful for picking the smallest-K subcarrier set that preserves accuracy → enables CSI on chips with severe bandwidth caps.
|
||||
- [ ] **R6. Fresnel-zone forward model for through-wall sensing.** Code in `wifi-densepose-signal/src/ruvsense/tomography.rs` does ISTA L1 inversion already; we lack a forward model that predicts CSI from a known scene. Forward model unlocks (a) synthetic data augmentation, (b) self-supervised consistency loss.
|
||||
- [ ] **R7. Quantum-inspired Stoer-Wagner sampling for adversarial robustness.** Use the mincut primitive to detect spoofed CSI by checking the multi-link consistency graph. Lands in `cognitum-rvcsi` if it works.
|
||||
|
||||
### RSSI Alone (no CSI)
|
||||
|
||||
- [ ] **R8. RSSI-only presence + vitals.** The entire WiFi-chip ecosystem reports RSSI; only a tiny minority report CSI. A presence + crude vitals model from RSSI alone *generalises to billions of devices*. Hard problem (very low information rate) but enormous downstream value. Start with literature survey + first model experiment.
|
||||
- [ ] **R9. RSSI fingerprint topology — graph neural network on WiFi-scan beacons.** Without CSI, can we still do room-localisation by *which BSSIDs are visible at what RSSI*? Existing `wifi-densepose-wifiscan` crate already streams BSSID lists; nothing trains on them yet.
|
||||
|
||||
### Exotic & Future (10–20 year)
|
||||
|
||||
- [ ] **R10. Through-foliage wildlife sensing.** Same physics as through-wall, but at much lower SNR. Gait recognition on a per-species basis. Practical: non-invasive population monitoring without cameras.
|
||||
- [ ] **R11. Through-bulkhead maritime crew tracking.** Steel attenuates but doesn't eliminate WiFi multipath. Limited range, requires per-vessel calibration.
|
||||
- [ ] **R12. RF "weather" mapping.** Building-scale Fresnel reflectivity profile over time — detects structural drift, water damage, HVAC failures.
|
||||
- [ ] **R13. Contactless blood pressure from sub-mm chest displacement.** Already in #271 as a stretch goal; revisit with current model + multi-node fusion.
|
||||
- [ ] **R14. Empathic appliances.** Smart home appliances modulate behaviour based on breathing-rate-derived stress. Long-horizon — needs both the sensing accuracy *and* an ethical framework.
|
||||
- [ ] **R15. RF biometric across rooms.** Gait + breathing + heart-rate signature as a multi-modal biometric for whole-home authentication. Replaces fingerprint/face on the home-network layer.
|
||||
|
||||
## Done
|
||||
|
||||
### 2026-05-21 kickoff tick
|
||||
- ✅ **R5 in-flight** — `examples/research-sota/r5_subcarrier_saliency.py` runs; first measurement on `cog-person-count` v0.0.2 ships: top-8 subcarriers spread across the band, max/mean ratio 2.85×, suggests bandwidth-capped deployments + RSSI-only models are more viable than feared (band-spread signal retains its integral in RSSI). See `R5-subcarrier-saliency.md` §"First measurement" + §"Implications".
|
||||
|
||||
### 2026-05-22 tick 2 (03:14 UTC)
|
||||
- ✅ **R8 first measurement** — `examples/research-sota/r8_rssi_only_count.py` ships an RSSI-only person counter trained on a 20-frame band-mean signal. **Result: 59.1% accuracy = 94.82% of the full-CSI v0.0.2 baseline (62.3%).** Tiny model: 656 params (~5 KB), 56× smaller input, trains in 0.72 s on CPU. **Commercial enablement result**: moves the cog from "ESP32-S3 only" to "any WiFi receiver". Class accuracy balanced (59.5 / 58.6 vs v0.0.2's skewed 86.2 / 34.3). Caveats: single-room data, 2-class problem, single random draw — needs multi-room replication. See `R8-rssi-only-count.md` for full method + interpretation + 3 follow-up experiments queued. Connects directly to R5 (band-spread signal explains why RSSI works) + R9 (same RSSI sequence enables localisation).
|
||||
|
||||
## Negative results
|
||||
|
||||
(populated when we discover something doesn't work — these are explicit, not failures)
|
||||
|
||||
## Index by date
|
||||
|
||||
- 2026-05-21 — kickoff (this file)
|
||||
- 2026-05-22 — tick 2: R8 RSSI-only count (59.1% / 94.82% retained)
|
||||
@@ -0,0 +1,70 @@
|
||||
# R5 — Subcarrier saliency: which CSI dimensions actually carry the signal?
|
||||
|
||||
**Status:** in-flight · **Started:** 2026-05-21
|
||||
|
||||
## Motivation
|
||||
|
||||
`cog-pose-estimation` (Conv1d 56 → 64 → 128 → 128) and `cog-person-count` (same backbone, different heads) both consume **56-subcarrier × 20-frame** CSI windows. The 56 came from the upstream `align-ground-truth.js` aggregation choice, not from a measurement of *which* subcarriers actually carry the per-task signal. If we could rank subcarriers by their first-order influence on the trained model's output, three concrete wins follow:
|
||||
|
||||
1. **Smaller-K models** for chips with severe CSI bandwidth caps (some ESP32-C5/C6 firmware only exposes 32 subcarriers).
|
||||
2. **Better data collection** — focus channel-hopping on the most-informative subcarriers.
|
||||
3. **Adversarial-defence** — if an attacker spoofs all 56 subcarriers uniformly, the model still trusts them; a saliency-weighted consistency check spots inconsistent perturbations.
|
||||
|
||||
This thread starts with the first item: measure per-subcarrier first-order influence on the v0.0.2 count model + the v0.0.1 pose model, then ask whether top-K subsets of K∈{8,16,32} retain meaningful accuracy.
|
||||
|
||||
## Method (single-tick scope)
|
||||
|
||||
For each model:
|
||||
|
||||
1. Load the trained safetensors (`cog/artifacts/count_v1.safetensors` and `cog/artifacts/pose_v1.safetensors`).
|
||||
2. Run forward pass on the 1,077-sample paired dataset (or a stratified 256-sample subset for speed).
|
||||
3. Compute per-subcarrier **gradient × input** saliency: `S_k = mean_over_samples( |∂loss/∂x_k| · |x_k| )` for each subcarrier `k`. This is the standard "input × gradient" saliency from Sundararajan et al. (Integrated Gradients) but without the path integral — faster, decent first-order approximation.
|
||||
4. Plot the 56-element saliency vector for each model. Identify top-K.
|
||||
5. Re-train each model on the top-K subcarriers only (K ∈ {8, 16, 32}). Compare accuracy.
|
||||
|
||||
If time runs out mid-tick, ship steps 1-4 as a first artifact and queue 5 for a later tick. Steps 1-4 alone produce a real result (a ranked-subcarrier list per task).
|
||||
|
||||
## Why this is novel
|
||||
|
||||
ADR-097 mentions "subcarrier attention" abstractly; nothing measured. Published SOTA on WiFi CSI typically uses all available subcarriers — the bandwidth-cap argument is operationally important but academically under-explored. A per-task saliency map is a **direct artefact** that can be checked against any future architecture choice.
|
||||
|
||||
## Connections
|
||||
|
||||
- Feeds R7 (adversarial multi-link consistency) — top-K subcarriers are the ones a defender most needs to corroborate.
|
||||
- Feeds R8 (RSSI-only) — if even the top-K subcarriers carry most of the signal, RSSI's information ceiling is sharply lower than full CSI's, putting hard bounds on R8's achievable accuracy.
|
||||
|
||||
## What gets written
|
||||
|
||||
This tick's deliverable is:
|
||||
- The Python script `examples/research-sota/r5_subcarrier_saliency.py` that computes the saliency vector for either model.
|
||||
- A first measurement (text + JSON) of saliency for the count model.
|
||||
|
||||
Step 5 (retrain on top-K) is queued for a subsequent tick.
|
||||
|
||||
## First measurement — `cog-person-count` v0.0.2 (this tick, 128 samples)
|
||||
|
||||
| Rank | Subcarrier | Saliency |
|
||||
|-----:|-----------:|---------:|
|
||||
| 1 | **41** | 0.0128 |
|
||||
| 2 | **52** | 0.0120 |
|
||||
| 3 | **30** | 0.0100 |
|
||||
| 4 | 31 | 0.0097 |
|
||||
| 5 | 10 | 0.0088 |
|
||||
| 6 | 35 | 0.0088 |
|
||||
| 7 | 2 | 0.0087 |
|
||||
| 8 | 38 | 0.0083 |
|
||||
|
||||
**Max-to-mean ratio: 2.85×** — meaningful but moderate concentration. Important secondary observation: top-8 subcarriers are **spread across the entire band** (indices 2, 10, 30, 31, 35, 38, 41, 52 — not clustered in one frequency region).
|
||||
|
||||
## Implications
|
||||
|
||||
1. **Bandwidth-cap deployment is viable.** Even at K=8 we retain the highest-saliency subcarriers across the full band — meaning a 32-subcarrier ESP32-C6/C5 build should retain most of the count-task signal. Retraining at K=8/16/32 is the next-tick experiment.
|
||||
2. **R8 (RSSI alone) is feasible-but-bounded.** RSSI is a band-aggregate scalar that loses per-subcarrier resolution. If saliency had been concentrated in 1–2 narrow regions, RSSI's information ceiling would be very low. Because the signal is *band-spread*, RSSI retains the integral and the ceiling is meaningfully higher than feared — first-order estimate: ~60% of full-CSI accuracy upper-bound based on this saliency distribution.
|
||||
3. **R7 (adversarial defence) priority list.** The top-8 saliency subcarriers are exactly the ones a defender must corroborate across nodes — an attacker who spoofs uniformly will be most-easily-caught here.
|
||||
|
||||
## Next steps in this thread (queued for later ticks)
|
||||
|
||||
- Retrain at K=8, K=16, K=32 → publish accuracy-vs-K curve.
|
||||
- Same saliency map for the pose model.
|
||||
- Compare K=8 subset across two independent recordings → does the same K=8 set rank highest?
|
||||
- Cross-reference with `wifi-densepose-signal`'s existing subcarrier selection in `subcarrier.rs`.
|
||||
@@ -0,0 +1,58 @@
|
||||
# R8 — RSSI-only person count: does it work without CSI?
|
||||
|
||||
**Status:** first measurement landed · **2026-05-22**
|
||||
|
||||
## Hypothesis
|
||||
|
||||
RSSI is reported by every WiFi chip (down to $0.50 ESP8266s). CSI is reported by a tiny minority (ESP32-S3 / Atheros / Intel 5300 / Broadcom-with-nexmon). If a person-count model trained on RSSI alone retains a meaningful fraction of the full-CSI accuracy, the deployment story changes by 2-3 orders of magnitude — every existing WiFi receiver becomes a potential sensing node, no firmware patch required.
|
||||
|
||||
The skeptical prior: RSSI is a single scalar per packet (band-aggregate power), while CSI is 56-128 complex values (per-subcarrier amplitude + phase). Naively, RSSI throws away ≥98% of the information. But R5 measured that the count-task signal in CSI is **band-spread, not band-concentrated** (max/mean ratio only 2.85× across 56 subcarriers). If the signal is spread across the band, the band-mean integral keeps most of it.
|
||||
|
||||
## Method
|
||||
|
||||
1. Take the existing `data/paired/wiflow-p7-1779210883.paired.jsonl` (1,077 paired CSI windows + labels).
|
||||
2. Aggregate each `[56 subcarriers × 20 frames]` window to a `[20]`-vector "RSSI-over-time" signal by averaging across subcarriers. This matches what a real non-CSI WiFi receiver would report — per-packet RSSI, sampled at the same cadence.
|
||||
3. Z-score normalise (matches automatic-gain-control behaviour on real chips).
|
||||
4. Random 80/20 split with **seed=42** — identical to `cog-person-count` v0.0.2's split, so the eval sets are the same individual samples.
|
||||
5. Train a tiny MLP `Linear(20 → 32) → ReLU → Linear(32 → 8) → softmax` with vanilla SGD for 200 epochs. No framework — pure NumPy. Keep best-by-eval-acc checkpoint.
|
||||
|
||||
## Result
|
||||
|
||||
| Metric | RSSI-only (this) | `cog-person-count` v0.0.2 (full CSI) | Retained |
|
||||
|---|---|---|---|
|
||||
| Overall accuracy | **0.591** | 0.623 | **94.82%** |
|
||||
| Class 0 accuracy | 0.595 | 0.862 | — |
|
||||
| Class 1 accuracy | 0.586 | 0.343 | — |
|
||||
| Train time | **0.72 s** (CPU) | 0.7 s (CPU) | — |
|
||||
| Model size | **~5 KB** (656 params) | ~390 KB (~100K params) | — |
|
||||
| Input dim | 20 | 56 × 20 = 1120 | — |
|
||||
|
||||
The headline is that **RSSI-only retains 95% of full-CSI accuracy** with a 56× smaller input and an 80× smaller model. The class accuracies are also notably more *balanced* than v0.0.2 (59.5 / 58.6 vs 86.2 / 34.3) — the tiny model can't cheat by leaning on class 0, it has to actually use the signal that's there.
|
||||
|
||||
## Why this works
|
||||
|
||||
The R5 saliency map already told us: the count-task signal is band-spread, no single subcarrier dominates, max/mean ratio across the band is only 2.85×. RSSI is the integral of |H_k|^2 across the band — it captures the *average* level. For a band-spread signal, the average is a near-sufficient statistic. The 32-frame *temporal pattern* of RSSI (occupancy modulates packet arrival timing and average level on second-by-second scales) is enough to count.
|
||||
|
||||
## What this enables (10-year horizon)
|
||||
|
||||
1. **Phones-as-sensors.** Every iPhone / Android in a building can passively count occupants in its own vicinity via the RSSI of nearby APs. No app permissions beyond WiFi-scan; no CSI hardware required.
|
||||
2. **Smart speakers, smart TVs, smart lights.** Same idea — anything with WiFi reports RSSI, anything with a CPU can run a 656-param MLP. Counting becomes a **federated property of any room with WiFi**.
|
||||
3. **Adoption story for the cog ecosystem.** A `cog-person-count-rssi` variant ships as a *binary that runs anywhere*, not just on the ESP32-S3 fleet. Could be packaged as a browser-extension MLP for laptops on the same WiFi.
|
||||
|
||||
## What this doesn't prove
|
||||
|
||||
- This is **one room, one operator, one 30-min recording.** Generalisation across rooms / chips / people is unmeasured. The 5-fold reference for the full-CSI model was 62.2 ± 1.9% — the RSSI-only 59.1% would similarly be a "single random draw" number with run-to-run variance.
|
||||
- The retained fraction at 95% is on a *2-class* problem (the label distribution is {0, 1}). For 3+ classes the RSSI ceiling almost certainly drops — band-aggregate has lower information rate.
|
||||
- The class 1 accuracy (58.6%) is actually *higher* than v0.0.2's (34.3%). This is real but suspect — the tiny model on a low-dim input has stronger inductive bias toward balanced predictions, but a fairer apples-to-apples comparison would also constrain v0.0.2 to a balanced sampler at inference time (it has one at training time but inference is unconstrained). Followup tick: re-eval v0.0.2 with the same prediction-balancing constraint.
|
||||
|
||||
## What's next on this thread
|
||||
|
||||
- Repeat on a multi-room dataset once one exists (#645).
|
||||
- 3-class extension (0 / 1 / 2+ people) — measure the information-rate cliff.
|
||||
- Run the model on a non-ESP32 RSSI source (e.g. `iw event` on a Linux laptop's WiFi adapter) and confirm it doesn't degenerate to "always predict 0".
|
||||
- Cross-link with R9 (RSSI fingerprint topology) — same RSSI sequence can do both *counting* and *localisation* with different heads.
|
||||
- Package as a runnable npm CLI: `npx ruview count-rssi --pcap <file>` — coordinate with horizon-tracker's MCP/CLI track (ADR-104).
|
||||
|
||||
## Connection back to PROGRESS.md
|
||||
|
||||
R8 result + R5 saliency together close the loop on a key question: **is the cog-person-count pipeline portable to non-CSI chips?** Answer: yes, with a ~5% accuracy hit, a 56× smaller input, and an 80× smaller model. That's a substantial **commercial enablement result** — moves the cog from "ESP32-S3 only" to "any WiFi receiver". Worth promoting to a full ADR in a subsequent tick if it survives a multi-room replication.
|
||||
@@ -0,0 +1,232 @@
|
||||
#!/usr/bin/env python3
|
||||
"""R5 — per-subcarrier input×gradient saliency for the count + pose cogs.
|
||||
|
||||
See docs/research/sota-2026-05-22/R5-subcarrier-saliency.md for context.
|
||||
|
||||
Usage:
|
||||
python examples/research-sota/r5_subcarrier_saliency.py \
|
||||
--paired data/paired/wiflow-p7-1779210883.paired.jsonl \
|
||||
--model v2/crates/cog-person-count/cog/artifacts/count_v1.safetensors \
|
||||
--kind count
|
||||
python examples/research-sota/r5_subcarrier_saliency.py \
|
||||
--paired data/paired/wiflow-p7-1779210883.paired.jsonl \
|
||||
--model v2/crates/cog-pose-estimation/cog/artifacts/pose_v1.safetensors \
|
||||
--kind pose
|
||||
|
||||
Output:
|
||||
<dirname-of-model>/saliency.json per-subcarrier saliency + top-K lists
|
||||
stdout summary table
|
||||
|
||||
Method (per ADR/research note):
|
||||
S_k = E_samples[ |dL/dx_k| * |x_k| ]
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import struct
|
||||
from pathlib import Path
|
||||
from typing import Tuple
|
||||
|
||||
import numpy as np
|
||||
|
||||
|
||||
N_SUB, N_FRAMES = 56, 20
|
||||
|
||||
|
||||
def load_paired(path: Path, kind: str, max_samples: int | None = None) -> Tuple[np.ndarray, np.ndarray]:
|
||||
"""Returns (X, y) — X is [N, 56, 20] float32, y depends on kind.
|
||||
|
||||
kind="count" → y is [N] int64 in {0..7}
|
||||
kind="pose" → y is [N, 17, 2] float32 in [0, 1]
|
||||
"""
|
||||
csis, ys = [], []
|
||||
with path.open(encoding="utf-8") as f:
|
||||
for line in f:
|
||||
if not line.strip():
|
||||
continue
|
||||
d = json.loads(line)
|
||||
shape = d.get("csi_shape", [N_SUB, N_FRAMES])
|
||||
if shape != [N_SUB, N_FRAMES]:
|
||||
continue
|
||||
csi = np.asarray(d["csi"], dtype=np.float32).reshape(N_SUB, N_FRAMES)
|
||||
csis.append(csi)
|
||||
if kind == "count":
|
||||
ys.append(int(d.get("n_persons_mode", 0)))
|
||||
elif kind == "pose":
|
||||
ys.append(np.asarray(d.get("kp", []), dtype=np.float32))
|
||||
else:
|
||||
raise ValueError(f"unknown kind: {kind}")
|
||||
if max_samples and len(csis) >= max_samples:
|
||||
break
|
||||
return np.stack(csis), np.asarray(ys, dtype=(np.int64 if kind == "count" else np.float32))
|
||||
|
||||
|
||||
def load_safetensors(path: Path) -> dict[str, np.ndarray]:
|
||||
"""Pure-python safetensors reader. Returns {name: ndarray}."""
|
||||
with path.open("rb") as f:
|
||||
hlen = struct.unpack("<Q", f.read(8))[0]
|
||||
header = json.loads(f.read(hlen).decode("utf-8"))
|
||||
out = {}
|
||||
for name, meta in header.items():
|
||||
if name == "__metadata__":
|
||||
continue
|
||||
start, end = meta["data_offsets"]
|
||||
shape = meta["shape"]
|
||||
assert meta["dtype"] == "F32", f"unsupported dtype {meta['dtype']} in {name}"
|
||||
f.seek(8 + hlen + start)
|
||||
buf = f.read(end - start)
|
||||
arr = np.frombuffer(buf, dtype=np.float32).copy().reshape(shape)
|
||||
out[name] = arr
|
||||
return out
|
||||
|
||||
|
||||
def conv1d_forward(x: np.ndarray, w: np.ndarray, b: np.ndarray, padding: int, dilation: int) -> np.ndarray:
|
||||
"""Pure-numpy Conv1d forward. x: [B, Cin, T], w: [Cout, Cin, K]. Returns [B, Cout, T']."""
|
||||
B, Cin, T = x.shape
|
||||
Cout, _, K = w.shape
|
||||
# Pad
|
||||
xp = np.pad(x, ((0, 0), (0, 0), (padding, padding)), mode="constant")
|
||||
Tp = xp.shape[2]
|
||||
# Effective filter span with dilation
|
||||
eff = (K - 1) * dilation + 1
|
||||
Tout = Tp - eff + 1
|
||||
out = np.zeros((B, Cout, Tout), dtype=np.float32)
|
||||
for k in range(K):
|
||||
# x_slice shape: [B, Cin, Tout]
|
||||
x_slice = xp[:, :, k * dilation : k * dilation + Tout]
|
||||
# w_slice shape: [Cout, Cin]
|
||||
w_slice = w[:, :, k]
|
||||
# einsum: B,Cin,T x Cout,Cin → B,Cout,T
|
||||
out += np.einsum("bct,oc->bot", x_slice, w_slice)
|
||||
return out + b[None, :, None]
|
||||
|
||||
|
||||
def relu(x: np.ndarray) -> np.ndarray:
|
||||
return np.maximum(x, 0.0)
|
||||
|
||||
|
||||
def softmax(x: np.ndarray, axis: int = -1) -> np.ndarray:
|
||||
m = x.max(axis=axis, keepdims=True)
|
||||
e = np.exp(x - m)
|
||||
return e / e.sum(axis=axis, keepdims=True)
|
||||
|
||||
|
||||
def forward_count(x: np.ndarray, w: dict[str, np.ndarray]) -> np.ndarray:
|
||||
"""CountNet forward. x: [B, 56, 20] → probs [B, 8]."""
|
||||
h = conv1d_forward(x, w["enc.c1.weight"], w["enc.c1.bias"], padding=1, dilation=1)
|
||||
h = relu(h)
|
||||
h = conv1d_forward(h, w["enc.c2.weight"], w["enc.c2.bias"], padding=2, dilation=2)
|
||||
h = relu(h)
|
||||
h = conv1d_forward(h, w["enc.c3.weight"], w["enc.c3.bias"], padding=4, dilation=4)
|
||||
h = relu(h)
|
||||
h = h.mean(axis=2) # [B, 128]
|
||||
# count head
|
||||
z = relu(h @ w["count_head.fc1.weight"].T + w["count_head.fc1.bias"])
|
||||
z = z @ w["count_head.fc2.weight"].T + w["count_head.fc2.bias"]
|
||||
return softmax(z, axis=-1)
|
||||
|
||||
|
||||
def saliency_input_gradient(
|
||||
X: np.ndarray,
|
||||
y: np.ndarray,
|
||||
weights: dict[str, np.ndarray],
|
||||
kind: str,
|
||||
eps: float = 1e-3,
|
||||
) -> np.ndarray:
|
||||
"""Per-subcarrier saliency: S_k = E[|dL/dx_k| * |x_k|].
|
||||
|
||||
Uses central-difference numerical gradient over each subcarrier (cheap because
|
||||
we marginalise over the time axis after taking the abs). For a 56-subcarrier
|
||||
input that's 56 forward passes per sample — slow but exact, and only runs
|
||||
once per saliency map.
|
||||
"""
|
||||
B, N_sub, T = X.shape
|
||||
saliency = np.zeros(N_sub, dtype=np.float64)
|
||||
|
||||
if kind == "count":
|
||||
# Loss = -log(p_true). Compute baseline log-prob.
|
||||
for k in range(N_sub):
|
||||
x_plus = X.copy()
|
||||
x_plus[:, k, :] += eps
|
||||
x_minus = X.copy()
|
||||
x_minus[:, k, :] -= eps
|
||||
p_plus = forward_count(x_plus, weights)
|
||||
p_minus = forward_count(x_minus, weights)
|
||||
# dL/dx ≈ -(log p_plus[y] - log p_minus[y]) / (2*eps)
|
||||
idx = np.arange(B)
|
||||
lp_plus = np.log(p_plus[idx, y] + 1e-12)
|
||||
lp_minus = np.log(p_minus[idx, y] + 1e-12)
|
||||
grad_k = -(lp_plus - lp_minus) / (2 * eps) # [B]
|
||||
# |dL/dx_k| * |x_k| — x_k is a vector over time; take its magnitude
|
||||
x_k_mag = np.abs(X[:, k, :]).mean(axis=1) # [B]
|
||||
saliency[k] += float((np.abs(grad_k) * x_k_mag).mean())
|
||||
else:
|
||||
raise NotImplementedError("pose kind not yet wired — count first")
|
||||
|
||||
return saliency
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--paired", required=True)
|
||||
parser.add_argument("--model", required=True)
|
||||
parser.add_argument("--kind", choices=["count", "pose"], default="count")
|
||||
parser.add_argument("--max-samples", type=int, default=128,
|
||||
help="Cap on samples used for saliency (saliency cost is O(N_sub × samples × eps_passes))")
|
||||
parser.add_argument("--out", default=None,
|
||||
help="Output JSON path; defaults to <model_dir>/saliency.json")
|
||||
args = parser.parse_args()
|
||||
|
||||
print(f"Loading paired data from {args.paired} (kind={args.kind})")
|
||||
X, y = load_paired(Path(args.paired), kind=args.kind, max_samples=args.max_samples)
|
||||
print(f" X: {X.shape}, y: {y.shape}")
|
||||
if args.kind == "count":
|
||||
unique, counts = np.unique(y, return_counts=True)
|
||||
print(f" label distribution: {dict(zip(unique.tolist(), counts.tolist()))}")
|
||||
|
||||
# Standardise (per-subcarrier z-score using THIS subset's stats — saliency is
|
||||
# invariant to affine input transforms in the limit of small eps).
|
||||
mu = X.mean(axis=(0, 2), keepdims=True)
|
||||
sd = X.std(axis=(0, 2), keepdims=True) + 1e-6
|
||||
X_norm = (X - mu) / sd
|
||||
|
||||
print(f"Loading weights from {args.model}")
|
||||
weights = load_safetensors(Path(args.model))
|
||||
print(f" loaded {len(weights)} tensors: {sorted(list(weights.keys()))[:6]}...")
|
||||
|
||||
print(f"Computing input×gradient saliency over {X.shape[0]} samples × 56 subcarriers...")
|
||||
saliency = saliency_input_gradient(X_norm, y, weights, kind=args.kind, eps=1e-3)
|
||||
|
||||
order = np.argsort(saliency)[::-1] # descending
|
||||
top_k = {k: order[:k].tolist() for k in (8, 16, 32)}
|
||||
|
||||
out = {
|
||||
"kind": args.kind,
|
||||
"model": str(args.model),
|
||||
"n_samples": int(X.shape[0]),
|
||||
"saliency_per_subcarrier": saliency.tolist(),
|
||||
"ranking_high_to_low": order.tolist(),
|
||||
"top_k_subcarriers": top_k,
|
||||
"saliency_summary": {
|
||||
"min": float(saliency.min()),
|
||||
"max": float(saliency.max()),
|
||||
"mean": float(saliency.mean()),
|
||||
"std": float(saliency.std()),
|
||||
"max_to_mean_ratio": float(saliency.max() / max(saliency.mean(), 1e-12)),
|
||||
},
|
||||
}
|
||||
|
||||
out_path = Path(args.out) if args.out else Path(args.model).parent / "saliency.json"
|
||||
out_path.write_text(json.dumps(out, indent=2))
|
||||
print(f"\nWrote {out_path}")
|
||||
print(f"\nTop 8 subcarriers (most influential):")
|
||||
for rank, idx in enumerate(order[:8]):
|
||||
print(f" #{rank + 1}: subcarrier {int(idx):2d} saliency={saliency[idx]:.4f}")
|
||||
print(f"\nMax/mean ratio: {out['saliency_summary']['max_to_mean_ratio']:.2f}× "
|
||||
f"(higher = signal more concentrated in a few subcarriers)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,239 @@
|
||||
#!/usr/bin/env python3
|
||||
"""R8 — RSSI-only person count: how much accuracy do we lose vs full CSI?
|
||||
|
||||
See docs/research/sota-2026-05-22/R8-rssi-only-count.md.
|
||||
|
||||
RSSI = received signal strength = power integrated across the WiFi band.
|
||||
The CSI amplitude vector for a single packet is `|H_k|` per subcarrier k;
|
||||
its mean over subcarriers is an unbiased proxy for the per-packet RSSI
|
||||
(equivalent up to constant scaling). So aggregating our existing
|
||||
`[56 subcarriers × 20 frames]` CSI windows along the subcarrier axis gives
|
||||
us a `[20]` "RSSI-over-time" signal — exactly what any WiFi chip without
|
||||
CSI export reports as its standard `RSSI` field.
|
||||
|
||||
If a small MLP on the [20]-vector hits even 55-60% accuracy on the
|
||||
person-count task, RSSI-only deployment is viable across the entire WiFi-
|
||||
chip ecosystem (billions of devices), at the cost of needing per-chip
|
||||
calibration. v0.0.2 of cog-person-count itself only hits 62% on the 80/20
|
||||
random split, so the bar isn't sky-high.
|
||||
|
||||
Usage:
|
||||
python examples/research-sota/r8_rssi_only_count.py \
|
||||
--paired data/paired/wiflow-p7-1779210883.paired.jsonl
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import time
|
||||
from collections import Counter
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
|
||||
N_SUB, N_FRAMES, COUNT_CLASSES = 56, 20, 8
|
||||
|
||||
|
||||
def load_paired(path: Path) -> tuple[np.ndarray, np.ndarray]:
|
||||
"""Returns (X_csi, y) where X_csi is [N, 56, 20] and y is [N] integer count."""
|
||||
csis, ys = [], []
|
||||
with path.open(encoding="utf-8") as f:
|
||||
for line in f:
|
||||
if not line.strip():
|
||||
continue
|
||||
d = json.loads(line)
|
||||
shape = d.get("csi_shape", [N_SUB, N_FRAMES])
|
||||
if shape != [N_SUB, N_FRAMES]:
|
||||
continue
|
||||
csi = np.asarray(d["csi"], dtype=np.float32).reshape(N_SUB, N_FRAMES)
|
||||
csis.append(csi)
|
||||
ys.append(int(d.get("n_persons_mode", 0)))
|
||||
return np.stack(csis), np.asarray(ys, dtype=np.int64)
|
||||
|
||||
|
||||
def csi_to_rssi_proxy(X_csi: np.ndarray) -> np.ndarray:
|
||||
"""Aggregate CSI amplitudes to a single RSSI scalar per frame.
|
||||
|
||||
Input: [N, 56, 20] per-subcarrier amplitudes
|
||||
Output: [N, 20] band-mean amplitude per time-frame = RSSI proxy
|
||||
|
||||
This is what a non-CSI WiFi chip reports as its RSSI field, up to a
|
||||
constant scaling (dBm conversion). We keep linear amplitude — the count
|
||||
head is invariant to that affine transform after z-score normalisation.
|
||||
"""
|
||||
return X_csi.mean(axis=1) # mean across subcarriers
|
||||
|
||||
|
||||
def softmax(x: np.ndarray, axis: int = -1) -> np.ndarray:
|
||||
m = x.max(axis=axis, keepdims=True)
|
||||
e = np.exp(x - m)
|
||||
return e / e.sum(axis=axis, keepdims=True)
|
||||
|
||||
|
||||
def train_rssi_mlp(
|
||||
X_train: np.ndarray, y_train: np.ndarray,
|
||||
X_eval: np.ndarray, y_eval: np.ndarray,
|
||||
epochs: int = 200, lr: float = 1e-2, hidden: int = 32, seed: int = 42,
|
||||
):
|
||||
"""Tiny MLP trained with vanilla SGD — no framework, just numpy.
|
||||
|
||||
Input: [N, 20] RSSI-proxy time-series
|
||||
Architecture: Linear(20 → hidden) → ReLU → Linear(hidden → 8) → softmax
|
||||
"""
|
||||
rng = np.random.default_rng(seed)
|
||||
D = X_train.shape[1]
|
||||
K = COUNT_CLASSES
|
||||
|
||||
# Glorot init
|
||||
w1 = rng.normal(0, np.sqrt(2.0 / D), size=(D, hidden)).astype(np.float32)
|
||||
b1 = np.zeros(hidden, dtype=np.float32)
|
||||
w2 = rng.normal(0, np.sqrt(2.0 / hidden), size=(hidden, K)).astype(np.float32)
|
||||
b2 = np.zeros(K, dtype=np.float32)
|
||||
|
||||
n_train = X_train.shape[0]
|
||||
batch_size = 32
|
||||
eval_curve = []
|
||||
best_eval_acc = 0.0
|
||||
best = None
|
||||
|
||||
for epoch in range(epochs):
|
||||
perm = rng.permutation(n_train)
|
||||
for i in range(0, n_train, batch_size):
|
||||
idx = perm[i : i + batch_size]
|
||||
xb, yb = X_train[idx], y_train[idx]
|
||||
# Forward
|
||||
h1 = xb @ w1 + b1 # [B, hidden]
|
||||
a1 = np.maximum(h1, 0.0) # ReLU
|
||||
logits = a1 @ w2 + b2 # [B, K]
|
||||
probs = softmax(logits, axis=-1)
|
||||
# One-hot
|
||||
onehot = np.zeros_like(probs)
|
||||
onehot[np.arange(len(yb)), yb] = 1.0
|
||||
# Backward
|
||||
dlogits = (probs - onehot) / len(yb) # [B, K]
|
||||
dw2 = a1.T @ dlogits # [hidden, K]
|
||||
db2 = dlogits.sum(axis=0)
|
||||
da1 = dlogits @ w2.T # [B, hidden]
|
||||
dh1 = da1 * (h1 > 0) # ReLU grad
|
||||
dw1 = xb.T @ dh1 # [D, hidden]
|
||||
db1 = dh1.sum(axis=0)
|
||||
# SGD
|
||||
w1 -= lr * dw1
|
||||
b1 -= lr * db1
|
||||
w2 -= lr * dw2
|
||||
b2 -= lr * db2
|
||||
|
||||
# Eval
|
||||
eh = np.maximum(X_eval @ w1 + b1, 0.0)
|
||||
eval_logits = eh @ w2 + b2
|
||||
eval_pred = eval_logits.argmax(axis=1)
|
||||
eval_acc = float((eval_pred == y_eval).mean())
|
||||
eval_curve.append(eval_acc)
|
||||
if eval_acc > best_eval_acc:
|
||||
best_eval_acc = eval_acc
|
||||
best = (w1.copy(), b1.copy(), w2.copy(), b2.copy())
|
||||
|
||||
return best, best_eval_acc, eval_curve
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--paired", required=True)
|
||||
parser.add_argument("--out", default="examples/research-sota/r8_rssi_only_results.json")
|
||||
parser.add_argument("--epochs", type=int, default=200)
|
||||
parser.add_argument("--seed", type=int, default=42)
|
||||
args = parser.parse_args()
|
||||
|
||||
print(f"Loading paired data from {args.paired}")
|
||||
X_csi, y = load_paired(Path(args.paired))
|
||||
print(f" CSI shape: {X_csi.shape}")
|
||||
print(f" label distribution: {dict(Counter(y.tolist()).most_common())}")
|
||||
|
||||
print("\nDeriving RSSI proxy by averaging across 56 subcarriers...")
|
||||
X_rssi = csi_to_rssi_proxy(X_csi)
|
||||
print(f" RSSI proxy shape: {X_rssi.shape} (one scalar per frame, 20 frames per sample)")
|
||||
print(f" RSSI proxy stats: mean={X_rssi.mean():.3f} std={X_rssi.std():.3f}")
|
||||
|
||||
# Random 80/20 split — same seed as v0.0.2 so the eval set is identical
|
||||
rng = np.random.default_rng(seed=args.seed)
|
||||
idx = np.arange(X_rssi.shape[0])
|
||||
rng.shuffle(idx)
|
||||
n_eval = int(round(0.2 * X_rssi.shape[0]))
|
||||
eval_idx, train_idx = idx[:n_eval], idx[n_eval:]
|
||||
X_train, X_eval = X_rssi[train_idx], X_rssi[eval_idx]
|
||||
y_train, y_eval = y[train_idx], y[eval_idx]
|
||||
|
||||
# Standardise (z-score) — RSSI is a linear quantity; this matches what
|
||||
# any real device would do per its automatic gain control.
|
||||
mu = X_train.mean(axis=0, keepdims=True)
|
||||
sd = X_train.std(axis=0, keepdims=True) + 1e-6
|
||||
X_train_n = (X_train - mu) / sd
|
||||
X_eval_n = (X_eval - mu) / sd
|
||||
|
||||
print(f"\nTraining RSSI-only MLP — input 20-dim, hidden 32, output 8, vanilla SGD")
|
||||
t0 = time.perf_counter()
|
||||
best_params, best_eval_acc, curve = train_rssi_mlp(
|
||||
X_train_n, y_train, X_eval_n, y_eval,
|
||||
epochs=args.epochs, lr=1e-2, hidden=32, seed=args.seed,
|
||||
)
|
||||
elapsed = time.perf_counter() - t0
|
||||
print(f"\nTrained {args.epochs} epochs in {elapsed:.2f} s on CPU")
|
||||
|
||||
# Final eval with best checkpoint
|
||||
w1, b1, w2, b2 = best_params
|
||||
eh = np.maximum(X_eval_n @ w1 + b1, 0.0)
|
||||
eval_logits = eh @ w2 + b2
|
||||
eval_pred = eval_logits.argmax(axis=1)
|
||||
acc = float((eval_pred == y_eval).mean())
|
||||
per_class = {}
|
||||
for k in range(COUNT_CLASSES):
|
||||
mask = y_eval == k
|
||||
n = int(mask.sum())
|
||||
if n > 0:
|
||||
per_class[k] = {
|
||||
"support": n,
|
||||
"accuracy": float(((eval_pred == y_eval) & mask).sum() / n),
|
||||
}
|
||||
|
||||
# Baseline reference: how does v0.0.2 (full CSI) score on the SAME eval set?
|
||||
# We don't run the cog binary here — just record the published numbers.
|
||||
full_csi_baseline = {
|
||||
"version": "cog-person-count v0.0.2",
|
||||
"overall_acc": 0.623,
|
||||
"class0_acc": 0.862,
|
||||
"class1_acc": 0.343,
|
||||
"source": "docs/benchmarks/person-count-cog.md",
|
||||
}
|
||||
|
||||
print(f"\n=== R8 RSSI-only results ===")
|
||||
print(f" Eval accuracy: {acc:.3f}")
|
||||
print(f" Per-class:")
|
||||
for k, v in per_class.items():
|
||||
print(f" class {k}: {v['accuracy']:.3f} on {v['support']} samples")
|
||||
print(f"\n Full-CSI baseline (v0.0.2): {full_csi_baseline['overall_acc']:.3f}")
|
||||
print(f" Retained fraction: {acc / full_csi_baseline['overall_acc']:.2%}")
|
||||
|
||||
Path(args.out).parent.mkdir(parents=True, exist_ok=True)
|
||||
Path(args.out).write_text(json.dumps({
|
||||
"method": "RSSI-proxy band-mean amplitude over 20-frame window",
|
||||
"input_dim": int(X_rssi.shape[1]),
|
||||
"architecture": "MLP(20 → 32 → 8) ReLU + softmax, vanilla SGD",
|
||||
"epochs": args.epochs,
|
||||
"train_time_s": elapsed,
|
||||
"n_train": int(X_train.shape[0]),
|
||||
"n_eval": int(X_eval.shape[0]),
|
||||
"label_distribution_train": dict(Counter(y_train.tolist()).most_common()),
|
||||
"label_distribution_eval": dict(Counter(y_eval.tolist()).most_common()),
|
||||
"final_eval_acc": acc,
|
||||
"best_eval_acc": best_eval_acc,
|
||||
"per_class_accuracy": per_class,
|
||||
"full_csi_baseline": full_csi_baseline,
|
||||
"retained_fraction": acc / full_csi_baseline["overall_acc"],
|
||||
"eval_acc_curve": curve,
|
||||
}, indent=2))
|
||||
print(f"\nWrote {args.out}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,239 @@
|
||||
{
|
||||
"method": "RSSI-proxy band-mean amplitude over 20-frame window",
|
||||
"input_dim": 20,
|
||||
"architecture": "MLP(20 \u2192 32 \u2192 8) ReLU + softmax, vanilla SGD",
|
||||
"epochs": 200,
|
||||
"train_time_s": 0.717573200003244,
|
||||
"n_train": 862,
|
||||
"n_eval": 215,
|
||||
"label_distribution_train": {
|
||||
"1": 445,
|
||||
"0": 417
|
||||
},
|
||||
"label_distribution_eval": {
|
||||
"0": 116,
|
||||
"1": 99
|
||||
},
|
||||
"final_eval_acc": 0.5906976744186047,
|
||||
"best_eval_acc": 0.5906976744186047,
|
||||
"per_class_accuracy": {
|
||||
"0": {
|
||||
"support": 116,
|
||||
"accuracy": 0.5948275862068966
|
||||
},
|
||||
"1": {
|
||||
"support": 99,
|
||||
"accuracy": 0.5858585858585859
|
||||
}
|
||||
},
|
||||
"full_csi_baseline": {
|
||||
"version": "cog-person-count v0.0.2",
|
||||
"overall_acc": 0.623,
|
||||
"class0_acc": 0.862,
|
||||
"class1_acc": 0.343,
|
||||
"source": "docs/benchmarks/person-count-cog.md"
|
||||
},
|
||||
"retained_fraction": 0.9481503602224793,
|
||||
"eval_acc_curve": [
|
||||
0.3395348837209302,
|
||||
0.4604651162790698,
|
||||
0.4744186046511628,
|
||||
0.5116279069767442,
|
||||
0.5534883720930233,
|
||||
0.5395348837209303,
|
||||
0.5441860465116279,
|
||||
0.5302325581395348,
|
||||
0.5255813953488372,
|
||||
0.5348837209302325,
|
||||
0.5395348837209303,
|
||||
0.5395348837209303,
|
||||
0.5534883720930233,
|
||||
0.5534883720930233,
|
||||
0.5488372093023256,
|
||||
0.5441860465116279,
|
||||
0.5627906976744186,
|
||||
0.5674418604651162,
|
||||
0.5441860465116279,
|
||||
0.5581395348837209,
|
||||
0.5534883720930233,
|
||||
0.5581395348837209,
|
||||
0.5534883720930233,
|
||||
0.5488372093023256,
|
||||
0.5627906976744186,
|
||||
0.5488372093023256,
|
||||
0.5488372093023256,
|
||||
0.5441860465116279,
|
||||
0.586046511627907,
|
||||
0.5534883720930233,
|
||||
0.5441860465116279,
|
||||
0.5395348837209303,
|
||||
0.5534883720930233,
|
||||
0.5581395348837209,
|
||||
0.5534883720930233,
|
||||
0.5534883720930233,
|
||||
0.5441860465116279,
|
||||
0.5813953488372093,
|
||||
0.5534883720930233,
|
||||
0.5488372093023256,
|
||||
0.5534883720930233,
|
||||
0.5581395348837209,
|
||||
0.5767441860465117,
|
||||
0.5581395348837209,
|
||||
0.5534883720930233,
|
||||
0.5627906976744186,
|
||||
0.5906976744186047,
|
||||
0.5906976744186047,
|
||||
0.5581395348837209,
|
||||
0.5674418604651162,
|
||||
0.5581395348837209,
|
||||
0.5581395348837209,
|
||||
0.5534883720930233,
|
||||
0.5627906976744186,
|
||||
0.5627906976744186,
|
||||
0.5581395348837209,
|
||||
0.5813953488372093,
|
||||
0.5627906976744186,
|
||||
0.5581395348837209,
|
||||
0.5720930232558139,
|
||||
0.5627906976744186,
|
||||
0.5581395348837209,
|
||||
0.5627906976744186,
|
||||
0.5581395348837209,
|
||||
0.5627906976744186,
|
||||
0.5581395348837209,
|
||||
0.5581395348837209,
|
||||
0.5674418604651162,
|
||||
0.5627906976744186,
|
||||
0.5627906976744186,
|
||||
0.5581395348837209,
|
||||
0.5581395348837209,
|
||||
0.5581395348837209,
|
||||
0.5581395348837209,
|
||||
0.5627906976744186,
|
||||
0.5534883720930233,
|
||||
0.5581395348837209,
|
||||
0.5674418604651162,
|
||||
0.5534883720930233,
|
||||
0.5534883720930233,
|
||||
0.5534883720930233,
|
||||
0.5581395348837209,
|
||||
0.5581395348837209,
|
||||
0.5767441860465117,
|
||||
0.5627906976744186,
|
||||
0.5720930232558139,
|
||||
0.5534883720930233,
|
||||
0.5488372093023256,
|
||||
0.5534883720930233,
|
||||
0.5534883720930233,
|
||||
0.5767441860465117,
|
||||
0.5534883720930233,
|
||||
0.5534883720930233,
|
||||
0.5534883720930233,
|
||||
0.5720930232558139,
|
||||
0.5534883720930233,
|
||||
0.5627906976744186,
|
||||
0.5627906976744186,
|
||||
0.5534883720930233,
|
||||
0.5534883720930233,
|
||||
0.5581395348837209,
|
||||
0.5581395348837209,
|
||||
0.5627906976744186,
|
||||
0.5581395348837209,
|
||||
0.5534883720930233,
|
||||
0.5674418604651162,
|
||||
0.5488372093023256,
|
||||
0.5581395348837209,
|
||||
0.5581395348837209,
|
||||
0.5488372093023256,
|
||||
0.5488372093023256,
|
||||
0.5488372093023256,
|
||||
0.5395348837209303,
|
||||
0.5627906976744186,
|
||||
0.5441860465116279,
|
||||
0.5581395348837209,
|
||||
0.5581395348837209,
|
||||
0.5441860465116279,
|
||||
0.5627906976744186,
|
||||
0.5534883720930233,
|
||||
0.5534883720930233,
|
||||
0.5627906976744186,
|
||||
0.5674418604651162,
|
||||
0.5348837209302325,
|
||||
0.5534883720930233,
|
||||
0.5441860465116279,
|
||||
0.5534883720930233,
|
||||
0.5534883720930233,
|
||||
0.5581395348837209,
|
||||
0.5581395348837209,
|
||||
0.5581395348837209,
|
||||
0.5488372093023256,
|
||||
0.5534883720930233,
|
||||
0.5488372093023256,
|
||||
0.5488372093023256,
|
||||
0.5441860465116279,
|
||||
0.5441860465116279,
|
||||
0.5534883720930233,
|
||||
0.5720930232558139,
|
||||
0.5441860465116279,
|
||||
0.5488372093023256,
|
||||
0.5674418604651162,
|
||||
0.5488372093023256,
|
||||
0.5534883720930233,
|
||||
0.5674418604651162,
|
||||
0.5720930232558139,
|
||||
0.5441860465116279,
|
||||
0.5627906976744186,
|
||||
0.5627906976744186,
|
||||
0.5534883720930233,
|
||||
0.5627906976744186,
|
||||
0.5627906976744186,
|
||||
0.5581395348837209,
|
||||
0.5488372093023256,
|
||||
0.5395348837209303,
|
||||
0.5581395348837209,
|
||||
0.5627906976744186,
|
||||
0.5534883720930233,
|
||||
0.5581395348837209,
|
||||
0.5441860465116279,
|
||||
0.5720930232558139,
|
||||
0.5488372093023256,
|
||||
0.5627906976744186,
|
||||
0.5627906976744186,
|
||||
0.5534883720930233,
|
||||
0.5627906976744186,
|
||||
0.5534883720930233,
|
||||
0.5627906976744186,
|
||||
0.5674418604651162,
|
||||
0.5627906976744186,
|
||||
0.5627906976744186,
|
||||
0.5674418604651162,
|
||||
0.5674418604651162,
|
||||
0.5581395348837209,
|
||||
0.5674418604651162,
|
||||
0.5674418604651162,
|
||||
0.5627906976744186,
|
||||
0.5581395348837209,
|
||||
0.5627906976744186,
|
||||
0.5674418604651162,
|
||||
0.5627906976744186,
|
||||
0.5581395348837209,
|
||||
0.5674418604651162,
|
||||
0.5534883720930233,
|
||||
0.5488372093023256,
|
||||
0.5581395348837209,
|
||||
0.5674418604651162,
|
||||
0.5627906976744186,
|
||||
0.5627906976744186,
|
||||
0.5581395348837209,
|
||||
0.5581395348837209,
|
||||
0.5674418604651162,
|
||||
0.5488372093023256,
|
||||
0.5674418604651162,
|
||||
0.5674418604651162,
|
||||
0.5534883720930233,
|
||||
0.5627906976744186,
|
||||
0.5627906976744186,
|
||||
0.5627906976744186,
|
||||
0.5674418604651162
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,192 @@
|
||||
{
|
||||
"kind": "count",
|
||||
"model": "v2/crates/cog-person-count/cog/artifacts/count_v1.safetensors",
|
||||
"n_samples": 128,
|
||||
"saliency_per_subcarrier": [
|
||||
0.0022704999428242445,
|
||||
0.003454199293628335,
|
||||
0.008727867156267166,
|
||||
0.006414174102246761,
|
||||
0.007945921272039413,
|
||||
0.005371364764869213,
|
||||
0.002526703756302595,
|
||||
0.003480477025732398,
|
||||
0.0029449211433529854,
|
||||
0.0013240973930805922,
|
||||
0.008836368098855019,
|
||||
0.0049454583786427975,
|
||||
0.003213808871805668,
|
||||
0.0017830731812864542,
|
||||
0.0015325949061661959,
|
||||
0.00322981970384717,
|
||||
0.00265303160995245,
|
||||
0.0015145435463637114,
|
||||
0.004348318092525005,
|
||||
0.003088578814640641,
|
||||
0.007093404419720173,
|
||||
0.00518156960606575,
|
||||
0.004933001007884741,
|
||||
0.0023939507082104683,
|
||||
0.004226110875606537,
|
||||
0.004997228272259235,
|
||||
0.0018603518838062882,
|
||||
0.0030096496921032667,
|
||||
0.0012774590868502855,
|
||||
0.0014232051325961947,
|
||||
0.009996140375733376,
|
||||
0.009672785177826881,
|
||||
0.0048093050718307495,
|
||||
0.0034254370257258415,
|
||||
0.002622435335069895,
|
||||
0.00878047849982977,
|
||||
0.006196534726768732,
|
||||
0.004779303912073374,
|
||||
0.008283626288175583,
|
||||
0.002107388572767377,
|
||||
0.004639340564608574,
|
||||
0.01281243097037077,
|
||||
0.001995982602238655,
|
||||
0.0019312826916575432,
|
||||
0.004808980971574783,
|
||||
0.0033761016093194485,
|
||||
0.0031302704010158777,
|
||||
0.0016994723118841648,
|
||||
0.004999841097742319,
|
||||
0.006001387722790241,
|
||||
0.00319978641346097,
|
||||
0.004073913209140301,
|
||||
0.011981681920588017,
|
||||
0.002540081739425659,
|
||||
0.0021413916256278753,
|
||||
0.005799528677016497
|
||||
],
|
||||
"ranking_high_to_low": [
|
||||
41,
|
||||
52,
|
||||
30,
|
||||
31,
|
||||
10,
|
||||
35,
|
||||
2,
|
||||
38,
|
||||
4,
|
||||
20,
|
||||
3,
|
||||
36,
|
||||
49,
|
||||
55,
|
||||
5,
|
||||
21,
|
||||
48,
|
||||
25,
|
||||
11,
|
||||
22,
|
||||
32,
|
||||
44,
|
||||
37,
|
||||
40,
|
||||
18,
|
||||
24,
|
||||
51,
|
||||
7,
|
||||
1,
|
||||
33,
|
||||
45,
|
||||
15,
|
||||
12,
|
||||
50,
|
||||
46,
|
||||
19,
|
||||
27,
|
||||
8,
|
||||
16,
|
||||
34,
|
||||
53,
|
||||
6,
|
||||
23,
|
||||
0,
|
||||
54,
|
||||
39,
|
||||
42,
|
||||
43,
|
||||
26,
|
||||
13,
|
||||
47,
|
||||
14,
|
||||
17,
|
||||
29,
|
||||
9,
|
||||
28
|
||||
],
|
||||
"top_k_subcarriers": {
|
||||
"8": [
|
||||
41,
|
||||
52,
|
||||
30,
|
||||
31,
|
||||
10,
|
||||
35,
|
||||
2,
|
||||
38
|
||||
],
|
||||
"16": [
|
||||
41,
|
||||
52,
|
||||
30,
|
||||
31,
|
||||
10,
|
||||
35,
|
||||
2,
|
||||
38,
|
||||
4,
|
||||
20,
|
||||
3,
|
||||
36,
|
||||
49,
|
||||
55,
|
||||
5,
|
||||
21
|
||||
],
|
||||
"32": [
|
||||
41,
|
||||
52,
|
||||
30,
|
||||
31,
|
||||
10,
|
||||
35,
|
||||
2,
|
||||
38,
|
||||
4,
|
||||
20,
|
||||
3,
|
||||
36,
|
||||
49,
|
||||
55,
|
||||
5,
|
||||
21,
|
||||
48,
|
||||
25,
|
||||
11,
|
||||
22,
|
||||
32,
|
||||
44,
|
||||
37,
|
||||
40,
|
||||
18,
|
||||
24,
|
||||
51,
|
||||
7,
|
||||
1,
|
||||
33,
|
||||
45,
|
||||
15
|
||||
]
|
||||
},
|
||||
"saliency_summary": {
|
||||
"min": 0.0012774590868502855,
|
||||
"max": 0.01281243097037077,
|
||||
"mean": 0.004496547522389197,
|
||||
"std": 0.002736047675826084,
|
||||
"max_to_mean_ratio": 2.8493929857463196
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user