diff --git a/README.md b/README.md index 7173833..7329ed0 100644 --- a/README.md +++ b/README.md @@ -142,6 +142,86 @@ These scenarios exploit WiFi's ability to penetrate solid materials β€” concrete --- +
+🧠 Contrastive CSI Embedding Model (ADR-024) β€” Self-supervised WiFi fingerprinting, similarity search, and anomaly detection + +Every WiFi signal that passes through a room creates a unique fingerprint of that space. WiFi-DensePose already reads these fingerprints to track people, but until now it threw away the internal "understanding" after each reading. The Contrastive CSI Embedding Model captures and preserves that understanding as compact, reusable vectors. + +**What it does in plain terms:** +- Turns any WiFi signal into a 128-number "fingerprint" that uniquely describes what's happening in a room +- Learns entirely on its own from raw WiFi data β€” no cameras, no labeling, no human supervision needed +- Recognizes rooms, detects intruders, identifies people, and classifies activities using only WiFi +- Runs on an $8 ESP32 chip (the entire model fits in 60 KB of memory) +- Produces both body pose tracking AND environment fingerprints in a single computation + +**Key Capabilities** + +| What | How it works | Why it matters | +|------|-------------|----------------| +| **Self-supervised learning** | The model watches WiFi signals and teaches itself what "similar" and "different" look like, without any human-labeled data | Deploy anywhere β€” just plug in a WiFi sensor and wait 10 minutes | +| **Room identification** | Each room produces a distinct WiFi fingerprint pattern | Know which room someone is in without GPS or beacons | +| **Anomaly detection** | An unexpected person or event creates a fingerprint that doesn't match anything seen before | Automatic intrusion and fall detection as a free byproduct | +| **Person re-identification** | Each person disturbs WiFi in a slightly different way, creating a personal signature | Track individuals across sessions without cameras | +| **Environment adaptation** | MicroLoRA adapters (1,792 parameters per room) fine-tune the model for each new space | Adapts to a new room with minimal data β€” 93% less than retraining from scratch | +| **Memory preservation** | EWC++ regularization remembers what was learned during pretraining | Switching to a new task doesn't erase prior knowledge | +| **Hard-negative mining** | Training focuses on the most confusing examples to learn faster | Better accuracy with the same amount of training data | + +**Architecture** + +``` +WiFi Signal [56 channels] β†’ Transformer + Graph Neural Network + β”œβ†’ 128-dim environment fingerprint (for search + identification) + β””β†’ 17-joint body pose (for human tracking) +``` + +**Quick Start** + +```bash +# Step 1: Learn from raw WiFi data (no labels needed) +cargo run -p wifi-densepose-sensing-server -- --pretrain --dataset data/csi/ --pretrain-epochs 50 + +# Step 2: Fine-tune with pose labels for full capability +cargo run -p wifi-densepose-sensing-server -- --train --dataset data/mmfi/ --epochs 100 --save-rvf model.rvf + +# Step 3: Use the model β€” extract fingerprints from live WiFi +cargo run -p wifi-densepose-sensing-server -- --model model.rvf --embed + +# Step 4: Search β€” find similar environments or detect anomalies +cargo run -p wifi-densepose-sensing-server -- --model model.rvf --build-index env +``` + +**Training Modes** + +| Mode | What you need | What you get | +|------|--------------|-------------| +| Self-Supervised | Just raw WiFi data | A model that understands WiFi signal structure | +| Supervised | WiFi data + body pose labels | Full pose tracking + environment fingerprints | +| Cross-Modal | WiFi data + camera footage | Fingerprints aligned with visual understanding | + +**Fingerprint Index Types** + +| Index | What it stores | Real-world use | +|-------|---------------|----------------| +| `env_fingerprint` | Average room fingerprint | "Is this the kitchen or the bedroom?" | +| `activity_pattern` | Activity boundaries | "Is someone cooking, sleeping, or exercising?" | +| `temporal_baseline` | Normal conditions | "Something unusual just happened in this room" | +| `person_track` | Individual movement signatures | "Person A just entered the living room" | + +**Model Size** + +| Component | Parameters | Memory (on ESP32) | +|-----------|-----------|-------------------| +| Transformer backbone | ~28,000 | 28 KB | +| Embedding projection head | ~25,000 | 25 KB | +| Per-room MicroLoRA adapter | ~1,800 | 2 KB | +| **Total** | **~55,000** | **55 KB** (of 520 KB available) | + +See [`docs/adr/ADR-024-contrastive-csi-embedding-model.md`](docs/adr/ADR-024-contrastive-csi-embedding-model.md) for full architectural details. + +
+ +--- + ## πŸ“¦ Installation
diff --git a/docs/adr/ADR-024-contrastive-csi-embedding-model.md b/docs/adr/ADR-024-contrastive-csi-embedding-model.md new file mode 100644 index 0000000..a7c9b47 --- /dev/null +++ b/docs/adr/ADR-024-contrastive-csi-embedding-model.md @@ -0,0 +1,1024 @@ +# ADR-024: Project AETHER -- Contrastive CSI Embedding Model via CsiToPoseTransformer Backbone + +| Field | Value | +|-------|-------| +| **Status** | Proposed | +| **Date** | 2026-03-01 | +| **Deciders** | ruv | +| **Codename** | **AETHER** -- Ambient Electromagnetic Topology for Hierarchical Embedding and Recognition | +| **Relates to** | ADR-004 (HNSW Fingerprinting), ADR-005 (SONA Self-Learning), ADR-006 (GNN-Enhanced CSI), ADR-014 (SOTA Signal Processing), ADR-015 (Public Datasets), ADR-016 (RuVector Integration), ADR-023 (Trained DensePose Pipeline) | + +--- + +## 1. Context + +### 1.1 The Embedding Gap + +WiFi CSI signals encode a rich manifold of environmental and human information: room geometry via multipath reflections, human body configuration via Fresnel zone perturbations, and temporal dynamics via Doppler-like subcarrier phase shifts. The CsiToPoseTransformer (ADR-023) already learns to decode this manifold into 17-keypoint body poses through cross-attention and GNN message passing, producing intermediate `body_part_features` of shape `[17 x d_model]` that implicitly represent the latent CSI state. + +These representations are currently **task-coupled**: they exist only as transient activations during pose regression and are discarded after the `xyz_head` and `conf_head` produce keypoint predictions. There is no mechanism to: + +1. **Extract and persist** these representations as reusable, queryable embedding vectors +2. **Compare** CSI observations via learned similarity ("is this the same room?" / "is this the same person?") +3. **Pretrain** the backbone in a self-supervised manner from unlabeled CSI streams -- the most abundant data source +4. **Transfer** learned representations across WiFi hardware, environments, or deployment sites +5. **Feed** semantically meaningful vectors into HNSW indices (ADR-004) instead of hand-crafted feature encodings + +The gap between what the transformer *internally knows* and what the system *externally exposes* is the central problem AETHER addresses. + +### 1.2 Why "AETHER"? + +The name reflects the historical concept of the luminiferous aether -- the invisible medium through which electromagnetic waves were once theorized to propagate. In our context, WiFi signals propagate through physical space, and AETHER extracts a latent geometric understanding of that space from the signals themselves. The name captures three core ideas: + +- **Ambient**: Works with the WiFi signals already present in any indoor environment +- **Electromagnetic Topology**: Captures the topological structure of multipath propagation +- **Hierarchical Embedding**: Produces embeddings at multiple semantic levels (environment, activity, person) + +### 1.3 Why Contrastive, Not Generative? + +We evaluated and rejected a generative "RuvLLM" approach. The GOAP analysis: + +| Factor | Generative (Autoregressive) | Contrastive (AETHER) | +|--------|---------------------------|---------------------| +| **Domain fit** | CSI is 56 continuous floats at 20 Hz -- not a discrete token vocabulary. Autoregressive generation is architecturally mismatched. | Contrastive learning on continuous sensor data is the established SOTA (SimCLR, BYOL, VICReg, CAPC). | +| **Model size** | Generative transformers need millions of parameters for meaningful sequence modeling. | Reuses existing 28K-param CsiToPoseTransformer + 25K projection head = 53K total. | +| **Edge deployment** | Cannot run on ESP32 (240 MHz, 520 KB SRAM). | INT8-quantized 53K params = ~53 KB. 10% of ESP32 SRAM. | +| **Training data** | Requires massive CSI corpus for autoregressive pretraining to converge. | Self-supervised augmentations work with any CSI stream -- even minutes of data. | +| **Inference** | Autoregressive decoding is sequential; violates 20 Hz real-time constraint. | Single forward pass: <2 ms at INT8. | +| **Infrastructure** | New model architecture, tokenizer, trainer, quantizer, RVF packaging. | One new module (`embedding.rs`), one new loss term, one new RVF segment type. | +| **Collapse risk** | Mode collapse in generation manifests as repetitive outputs. | Embedding collapse is detectable (variance monitoring) and preventable (VICReg regularization). | + +### 1.4 What Already Exists + +| Component | File | Relevant API | +|-----------|------|-------------| +| **CsiToPoseTransformer** | `graph_transformer.rs` | `embed()` returns `[17 x d_model]` body_part_features (already exists) | +| **Linear layers** | `graph_transformer.rs` | `Linear::new()`, `flatten_into()`, `unflatten_from()` | +| **GnnStack** | `graph_transformer.rs` | 2-layer GCN on COCO skeleton with symmetric normalized adjacency | +| **CrossAttention** | `graph_transformer.rs` | 4-head scaled dot-product attention | +| **SONA** | `sona.rs` | `LoraAdapter`, `EwcRegularizer`, `EnvironmentDetector`, `SonaProfile` | +| **Trainer** | `trainer.rs` | 6-term composite loss, SGD+momentum, cosine LR, PCK/OKS metrics, checkpointing | +| **Sparse Inference** | `sparse_inference.rs` | INT8 symmetric/asymmetric quantization, FP16, neuron profiling, sparse forward | +| **RVF Container** | `rvf_container.rs` | Segment-based binary format: VEC, META, QUANT, WITNESS, PROFILE, MANIFEST | +| **Dataset Pipeline** | `dataset.rs` | MM-Fi (56 subcarriers, 17 COCO keypoints), Wi-Pose (resampled), unified DataPipeline | +| **HNSW Index** | `ruvector-core` | `VectorIndex` trait: `add()`, `search()`, `remove()`, cosine/L2/dot metrics | +| **Micro-HNSW** | `micro-hnsw-wasm` | `no_std` HNSW for WASM/edge: 16-dim, 32 vectors/core, LIF neurons, STDP | + +### 1.5 SOTA Landscape (2024-2025) + +Recent advances that directly inform AETHER's design: + +- **IdentiFi** (2025): Contrastive learning for WiFi-based person identification using latent CSI representations. Demonstrates that contrastive pretraining in the signal domain produces identity-discriminative embeddings without requiring spatial position labels. +- **WhoFi** (2025): Transformer-based WiFi CSI encoding for person re-identification achieving 95.5% accuracy on NTU-Fi. Validates that transformer backbones learn re-identification-quality features from CSI. +- **CAPC** (2024): Context-Aware Predictive Coding for WiFi sensing -- integrates CPC and Barlow Twins to learn temporally and contextually consistent representations from unlabeled WiFi data. +- **SSL for WiFi HAR Survey** (2025, arXiv:2506.12052): Comprehensive evaluation of SimCLR, VICReg, Barlow Twins, and SimSiam on WiFi CSI for human activity recognition. VICReg achieves best downstream accuracy but requires careful hyperparameter tuning; SimCLR shows more stable training. +- **ContraWiMAE** (2024-2025): Masked autoencoder + contrastive pretraining for wireless channel representation learning, demonstrating that hybrid SSL objectives outperform pure contrastive or pure reconstructive approaches. +- **Wi-PER81** (2025): Benchmark dataset of 162K wireless packets for WiFi-based person re-identification using Siamese networks on signal amplitude heatmaps. + +--- + +## 2. Decision + +### 2.1 Architecture: Dual-Head Transformer with Contrastive Projection + +Add a lightweight projection head that maps the GNN body-part features into a normalized embedding space while preserving the existing pose regression path: + +``` +CSI Frame(s) [n_pairs x n_subcarriers] + | + v + csi_embed (Linear 56 -> d_model=64) [EXISTING] + | + v + CrossAttention (Q=keypoint_queries, [EXISTING] + K,V=csi_embed) + | + v + GnnStack (2-layer GCN, COCO skeleton) [EXISTING] + | + +---> body_part_features [17 x 64] [EXISTING, now exposed via embed()] + | | + | v + | GlobalMeanPool --> frame_feature [64] [NEW: mean over 17 keypoints] + | | + | v + | ProjectionHead: [NEW] + | proj_1: Linear(64, 128) + BatchNorm1D(128) + ReLU + | proj_2: Linear(128, 128) + | L2-normalize + | | + | v + | z_csi [128-dim unit vector] [NEW: contrastive embedding] + | + +---> xyz_head (Linear 64->3) + conf_head [EXISTING: pose regression] + --> keypoints [17 x (x,y,z,conf)] +``` + +**Key design choices:** + +1. **2-layer MLP with BatchNorm**: Following SimCLR v2 findings that a deeper projection head with batch normalization improves downstream task performance. The projection head discards information not useful for the contrastive objective, keeping the backbone representations richer. + +2. **128-dim output**: Standard in contrastive learning literature (SimCLR, MoCo, CLIP). Large enough for high-recall HNSW search, small enough for edge deployment. L2-normalized to the unit hypersphere for cosine similarity. + +3. **BatchNorm1D in projection head**: Prevents representation collapse by maintaining feature variance across the batch dimension. Acts as an implicit contrastive mechanism (VICReg insight) -- decorrelates embedding dimensions. + +4. **Shared backbone, independent heads**: The backbone (csi_embed, cross-attention, GNN) is shared between pose regression and embedding extraction. This enables multi-task training where contrastive and supervised signals co-regularize the backbone. + +### 2.2 Mathematical Foundations + +#### 2.2.1 InfoNCE Contrastive Loss + +Given a batch of N CSI windows, each augmented twice to produce 2N views, the InfoNCE loss for positive pair (i, j) is: + +``` +L_InfoNCE(i, j) = -log( exp(sim(z_i, z_j) / tau) / sum_{k != i} exp(sim(z_i, z_k) / tau) ) +``` + +where: +- `sim(u, v) = u^T v / (||u|| * ||v||)` is cosine similarity (= dot product for L2-normalized vectors) +- `tau` is the temperature hyperparameter controlling concentration +- The sum in the denominator runs over all 2N-1 views excluding i itself (including the positive j and 2N-2 negatives) + +The symmetric NT-Xent loss averages over both directions of each positive pair: + +``` +L_NT-Xent = (1 / 2N) * sum_{k=1}^{N} [ L_InfoNCE(2k-1, 2k) + L_InfoNCE(2k, 2k-1) ] +``` + +**Temperature selection**: `tau = 0.07` (following SimCLR). Lower temperature sharpens the distribution, making the loss more sensitive to hard negatives. We use a learnable temperature initialized to 0.07 with a floor of 0.01. + +#### 2.2.2 VICReg Regularization (Collapse Prevention) + +Pure InfoNCE can collapse when batch sizes are small (common in CSI settings). We add VICReg regularization terms: + +``` +L_variance = (1/d) * sum_{j=1}^{d} max(0, gamma - sqrt(Var(z_j) + epsilon)) + +L_covariance = (1/d) * sum_{i != j} C(z)_{ij}^2 + +L_AETHER = alpha * L_NT-Xent + beta * L_variance + gamma_cov * L_covariance +``` + +where: +- `Var(z_j)` is the variance of embedding dimension j across the batch +- `C(z)` is the covariance matrix of embeddings in the batch +- `gamma = 1.0` is the target standard deviation per dimension +- `epsilon = 1e-4` prevents zero-variance gradients +- Default weights: `alpha = 1.0, beta = 25.0, gamma_cov = 1.0` (per VICReg paper) + +The variance term prevents all embeddings from collapsing to a single point. The covariance term decorrelates dimensions, maximizing information content. + +#### 2.2.3 CSI-Specific Augmentation Strategy + +Each augmentation must preserve the identity of the CSI observation (same room, same person, same activity) while varying the irrelevant dimensions (noise, timing, hardware drift). All augmentations are **physically motivated** by WiFi signal propagation: + +| Augmentation | Operation | Physical Motivation | Default Params | +|-------------|-----------|--------------------| --------------| +| **Temporal jitter** | Shift window start by `U(-J, +J)` frames | Clock synchronization offset between AP and client | `J = 3` frames | +| **Subcarrier masking** | Zero `p_mask` fraction of random subcarriers | Frequency-selective fading from narrowband interference | `p_mask ~ U(0.05, 0.20)` | +| **Gaussian noise** | Add `N(0, sigma)` to amplitude | Thermal noise at the receiver front-end | `sigma ~ U(0.01, 0.05)` | +| **Phase rotation** | Add `U(0, 2*pi)` uniform random offset per frame | Local oscillator phase drift and carrier frequency offset | per-frame | +| **Amplitude scaling** | Multiply by `U(s_lo, s_hi)` | Path loss variation from distance/obstruction changes | `s_lo=0.8, s_hi=1.2` | +| **Subcarrier permutation** | Randomly swap adjacent subcarrier pairs with probability `p_swap` | Subcarrier reordering artifacts in different WiFi chipsets | `p_swap = 0.1` | +| **Temporal crop** | Randomly drop `p_drop` fraction of frames from the window, then interpolate | Packet loss and variable CSI reporting rates | `p_drop ~ U(0.0, 0.15)` | + +Each view applies 2-4 randomly selected augmentations composed sequentially. The composition is sampled per-view, ensuring the two views of the same CSI window differ. + +#### 2.2.4 Cross-Modal Alignment (Optional Phase C) + +When paired CSI + camera pose data is available (MM-Fi, Wi-Pose), align the CSI embedding space with pose semantics: + +``` +z_pose = L2_normalize(PoseEncoder(pose_keypoints_flat)) + +PoseEncoder: Linear(51, 128) -> ReLU -> Linear(128, 128) [51 = 17 keypoints * 3 coords] + +L_cross = (1/N) * sum_{k=1}^{N} [ -log( exp(sim(z_csi_k, z_pose_k) / tau) / sum_{j} exp(sim(z_csi_k, z_pose_j) / tau) ) ] + +L_total = L_supervised_pose + lambda_c * L_contrastive + lambda_x * L_cross +``` + +This ensures that CSI embeddings of the same pose are close in embedding space, enabling pose retrieval from CSI queries. + +### 2.3 Training Strategy: Three-Phase Pipeline + +#### Phase A -- Self-Supervised Pretraining (No Labels) + +``` +Raw CSI Window W (any stream, any environment) + | + +---> Aug_1(W) ---> CsiToPoseTransformer.embed() ---> MeanPool ---> ProjectionHead ---> z_1 + | | + | L_AETHER(z_1, z_2) + | | + +---> Aug_2(W) ---> CsiToPoseTransformer.embed() ---> MeanPool ---> ProjectionHead ---> z_2 +``` + +- **Optimizer**: SGD with momentum 0.9, weight decay 1e-4 (SGD preferred over Adam for contrastive learning per SimCLR) +- **LR schedule**: Warmup 10 epochs linear 0 -> 0.03, then cosine decay to 1e-5 +- **Batch size**: 256 positive pairs (512 total views). Smaller batches (32-64) acceptable with VICReg regularization. +- **Epochs**: 100-200 (convergence monitored via embedding uniformity and alignment metrics) +- **Monitoring**: Track `alignment = E[||z_i - z_j||^2]` for positive pairs (should decrease) and `uniformity = log(E[exp(-2 * ||z_i - z_j||^2)])` over all pairs (should decrease, indicating uniform distribution on hypersphere) + +#### Phase B -- Supervised Fine-Tuning (Labeled Data) + +After pretraining, attach `xyz_head` and `conf_head` and fine-tune with the existing 6-term composite loss (ADR-023 Phase 4), optionally keeping the contrastive loss as a regularizer: + +``` +L_total = L_pose_composite + lambda_c * L_contrastive + +lambda_c = 0.1 (contrastive acts as regularizer, not primary objective) +``` + +The pretrained backbone starts with representations that already understand CSI spatial structure, typically requiring 3-10x fewer labeled samples for equivalent pose accuracy. + +#### Phase C -- Cross-Modal Alignment (Optional, requires paired data) + +Adds `L_cross` to align CSI and pose embedding spaces. Only applicable when paired CSI + camera pose data is available (MM-Fi provides this). + +### 2.4 HNSW Index Architecture + +The 128-dim L2-normalized `z_csi` embeddings feed four specialized HNSW indices, each serving a distinct recognition task: + +| Index | Source Embedding | Update Frequency | Distance Metric | M | ef_construction | Max Elements | Use Case | +|-------|-----------------|-----------------|-----------------|---|----------------|-------------|----------| +| `env_fingerprint` | Mean of `z_csi` over 10-second window (200 frames @ 20 Hz) | On environment change detection (SONA drift) | Cosine | 16 | 200 | 10K | Room/zone identification | +| `activity_pattern` | `z_csi` at activity transition boundaries (detected via embedding velocity) | Per detected activity segment | Cosine | 12 | 150 | 50K | Activity classification | +| `temporal_baseline` | `z_csi` during calibration period (first 60 seconds) | At deployment / recalibration | Cosine | 16 | 200 | 1K | Anomaly/intrusion detection | +| `person_track` | Per-person `z_csi` sequences (clustered by embedding trajectory) | Per confirmed detection | Cosine | 16 | 200 | 10K | Re-identification across sessions | + +**Index operations:** + +```rust +pub trait EmbeddingIndex { + /// Insert an embedding with metadata + fn insert(&mut self, embedding: &[f32; 128], metadata: EmbeddingMetadata) -> VectorId; + + /// Search for k nearest neighbors + fn search(&self, query: &[f32; 128], k: usize) -> Vec<(VectorId, f32, EmbeddingMetadata)>; + + /// Remove stale entries older than `max_age` + fn prune(&mut self, max_age: std::time::Duration) -> usize; + + /// Index statistics + fn stats(&self) -> IndexStats; +} + +pub struct EmbeddingMetadata { + pub timestamp: u64, + pub environment_id: Option, + pub person_id: Option, + pub activity_label: Option, + pub confidence: f32, + pub sona_profile: Option, +} +``` + +**Anomaly detection** uses the `temporal_baseline` index: compute `d = 1 - cosine_sim(z_current, nearest_baseline)`. If `d > threshold_anomaly` (default 0.3) for `>= n_consecutive` frames (default 5), flag as anomaly. This catches intrusions, falls, and environmental changes without any task-specific model. + +### 2.5 Integration with Existing Systems + +#### 2.5.1 SONA Integration (ADR-005) + +Each `SonaProfile` already represents an environment-specific adaptation. AETHER adds a compact environment descriptor: + +```rust +pub struct SonaProfile { + // ... existing fields ... + + /// AETHER: Mean embedding of calibration CSI in this environment. + /// 128 floats = 512 bytes. Used for O(1) environment identification + /// before loading the full LoRA profile. + pub env_embedding: Option<[f32; 128]>, +} +``` + +**Environment switching workflow:** +1. Compute `z_csi` for incoming CSI +2. Compare against `env_embedding` of all known `SonaProfile`s (128-dim dot product, <1 us each) +3. If closest profile distance < threshold: load that profile's LoRA weights +4. If no profile is close: trigger SONA adaptation for new environment, store new `env_embedding` + +This replaces the current `EnvironmentDetector` statistical drift test with a semantically-aware embedding comparison. + +#### 2.5.2 RVF Container Extension (ADR-003) + +Add a new segment type for embedding model configuration: + +```rust +/// Embedding model configuration and projection head weights. +/// Segment type: SEG_EMBED = 0x0C +const SEG_EMBED: u8 = 0x0C; + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct EmbeddingModelConfig { + /// Backbone feature dimension (input to projection head) + pub d_model: usize, // 64 + /// Embedding output dimension + pub d_proj: usize, // 128 + /// Whether to L2-normalize the output + pub normalize: bool, // true + /// Pretraining method used + pub pretrain_method: String, // "simclr" | "vicreg" | "capc" + /// Temperature for InfoNCE (if applicable) + pub temperature: f32, // 0.07 + /// Augmentations used during pretraining + pub augmentations: Vec, + /// Number of pretraining epochs completed + pub pretrain_epochs: usize, + /// Alignment metric at end of pretraining + pub alignment_score: f32, + /// Uniformity metric at end of pretraining + pub uniformity_score: f32, +} +``` + +The projection head weights (25K floats = 100 KB at FP32, 25 KB at INT8) are stored in the existing VEC segment alongside the transformer weights. The RVF manifest distinguishes model types: + +```json +{ + "model_type": "aether-embedding", + "backbone": "csi-to-pose-transformer", + "embedding_dim": 128, + "pose_capable": true, + "pretrain_method": "simclr+vicreg" +} +``` + +#### 2.5.3 Sparse Inference Integration (ADR-023 Phase 6) + +Embedding extraction benefits from the same INT8 quantization and sparse neuron pruning. **Critical validation**: cosine distance ordering must be preserved under quantization. + +**Rank preservation metric:** + +``` +rho = SpearmanRank(ranking_fp32, ranking_int8) +``` + +where `ranking` is the order of k-nearest neighbors for a test query. Requirement: `rho > 0.95` for `k = 10`. If `rho < 0.95`, apply mixed-precision: backbone at INT8, projection head at FP16. + +**Quantization budget:** + +| Component | Parameters | FP32 | INT8 | FP16 | +|-----------|-----------|------|------|------| +| CsiToPoseTransformer backbone | ~28,000 | 112 KB | 28 KB | 56 KB | +| ProjectionHead (proj_1 + proj_2) | ~24,960 | 100 KB | 25 KB | 50 KB | +| PoseEncoder (cross-modal, optional) | ~7,040 | 28 KB | 7 KB | 14 KB | +| **Total (without PoseEncoder)** | **~53,000** | **212 KB** | **53 KB** | **106 KB** | +| **Total (with PoseEncoder)** | **~60,000** | **240 KB** | **60 KB** | **120 KB** | + +ESP32 SRAM budget: 520 KB. Model at INT8: 53-60 KB = 10-12% of SRAM. Ample margin for activations, HNSW index, and runtime stack. + +### 2.6 Concrete Module Additions + +All new/modified files in `rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/`: + +#### 2.6.1 `embedding.rs` (NEW, ~450 lines) + +```rust +// ── Core types ────────────────────────────────────────────────────── + +/// Configuration for the AETHER embedding system. +pub struct AetherConfig { + pub d_model: usize, // 64 (from TransformerConfig) + pub d_proj: usize, // 128 + pub temperature: f32, // 0.07 + pub vicreg_alpha: f32, // 1.0 (InfoNCE weight) + pub vicreg_beta: f32, // 25.0 (variance weight) + pub vicreg_gamma: f32, // 1.0 (covariance weight) + pub variance_target: f32, // 1.0 + pub n_augmentations: usize, // 2-4 per view +} + +/// 2-layer MLP projection head: Linear -> BN -> ReLU -> Linear -> L2-norm. +pub struct ProjectionHead { + proj_1: Linear, // d_model -> d_proj + bn_running_mean: Vec, // d_proj + bn_running_var: Vec, // d_proj + bn_gamma: Vec, // d_proj (learnable scale) + bn_beta: Vec, // d_proj (learnable shift) + proj_2: Linear, // d_proj -> d_proj +} + +impl ProjectionHead { + pub fn new(d_model: usize, d_proj: usize) -> Self; + pub fn forward(&self, x: &[f32]) -> Vec; // returns L2-normalized + pub fn forward_train(&mut self, batch: &[Vec]) -> Vec>; // updates BN stats + pub fn flatten_into(&self, out: &mut Vec); + pub fn unflatten_from(data: &[f32], d_model: usize, d_proj: usize) -> (Self, usize); + pub fn param_count(&self) -> usize; +} + +/// CSI-specific data augmentation pipeline. +pub struct CsiAugmenter { + rng: Rng64, + config: AugmentConfig, +} + +pub struct AugmentConfig { + pub temporal_jitter_frames: usize, // 3 + pub mask_ratio_range: (f32, f32), // (0.05, 0.20) + pub noise_sigma_range: (f32, f32), // (0.01, 0.05) + pub scale_range: (f32, f32), // (0.8, 1.2) + pub swap_prob: f32, // 0.1 + pub drop_ratio_range: (f32, f32), // (0.0, 0.15) +} + +impl CsiAugmenter { + pub fn new(seed: u64) -> Self; + pub fn augment(&mut self, csi_window: &[Vec]) -> Vec>; +} + +/// InfoNCE loss with temperature scaling. +pub fn info_nce_loss(embeddings_a: &[Vec], embeddings_b: &[Vec], temperature: f32) -> f32; + +/// VICReg variance loss: penalizes dimensions with std < target. +pub fn variance_loss(embeddings: &[Vec], target: f32) -> f32; + +/// VICReg covariance loss: penalizes correlated dimensions. +pub fn covariance_loss(embeddings: &[Vec]) -> f32; + +/// Combined AETHER loss = alpha * InfoNCE + beta * variance + gamma * covariance. +pub fn aether_loss( + z_a: &[Vec], z_b: &[Vec], + temperature: f32, alpha: f32, beta: f32, gamma: f32, var_target: f32, +) -> AetherLossComponents; + +pub struct AetherLossComponents { + pub total: f32, + pub info_nce: f32, + pub variance: f32, + pub covariance: f32, +} + +/// Full embedding extraction pipeline. +pub struct EmbeddingExtractor { + transformer: CsiToPoseTransformer, + projection: ProjectionHead, + config: AetherConfig, +} + +impl EmbeddingExtractor { + pub fn new(transformer: CsiToPoseTransformer, config: AetherConfig) -> Self; + + /// Extract 128-dim L2-normalized embedding from CSI features. + pub fn embed(&self, csi_features: &[Vec]) -> Vec; + + /// Extract both pose keypoints AND embedding in a single forward pass. + pub fn forward_dual(&self, csi_features: &[Vec]) -> (PoseOutput, Vec); + + /// Flatten all weights (transformer + projection head). + pub fn flatten_weights(&self) -> Vec; + + /// Unflatten all weights. + pub fn unflatten_weights(&mut self, params: &[f32]) -> Result<(), String>; + + /// Total trainable parameters. + pub fn param_count(&self) -> usize; +} + +// ── Monitoring ────────────────────────────────────────────────────── + +/// Alignment metric: mean L2 distance between positive pair embeddings. +pub fn alignment_metric(z_a: &[Vec], z_b: &[Vec]) -> f32; + +/// Uniformity metric: log of average pairwise Gaussian kernel. +pub fn uniformity_metric(embeddings: &[Vec], t: f32) -> f32; +``` + +#### 2.6.2 `trainer.rs` (MODIFICATIONS) + +```rust +// Add to LossComponents: +pub struct LossComponents { + // ... existing 6 terms ... + pub contrastive: f32, // NEW: AETHER contrastive loss +} + +// Add to LossWeights: +pub struct LossWeights { + // ... existing 6 weights ... + pub contrastive: f32, // NEW: default 0.0 (disabled), set to 0.1 for joint training +} + +// Add to TrainerConfig: +pub struct TrainerConfig { + // ... existing fields ... + pub contrastive_loss_weight: f32, // NEW: 0.0 = no contrastive, 0.1 = regularizer + pub aether_config: Option, // NEW: None = no AETHER +} + +// New method on Trainer: +impl Trainer { + /// Self-supervised pretraining epoch using AETHER contrastive loss. + /// No pose labels required -- only raw CSI windows. + pub fn pretrain_epoch( + &mut self, + csi_windows: &[Vec>], + augmenter: &mut CsiAugmenter, + ) -> PretrainEpochStats; + + /// Full self-supervised pretraining loop. + pub fn run_pretraining( + &mut self, + csi_windows: &[Vec>], + n_epochs: usize, + ) -> PretrainResult; +} + +pub struct PretrainEpochStats { + pub epoch: usize, + pub loss: f32, + pub info_nce: f32, + pub variance: f32, + pub covariance: f32, + pub alignment: f32, + pub uniformity: f32, + pub lr: f32, +} + +pub struct PretrainResult { + pub best_epoch: usize, + pub best_alignment: f32, + pub best_uniformity: f32, + pub history: Vec, + pub total_time_secs: f64, +} +``` + +#### 2.6.3 `rvf_container.rs` (MINOR ADDITION) + +```rust +/// Embedding model configuration segment type. +const SEG_EMBED: u8 = 0x0C; + +impl RvfBuilder { + /// Add AETHER embedding model configuration. + pub fn add_embedding_config(&mut self, config: &EmbeddingModelConfig) { + let payload = serde_json::to_vec(config).unwrap_or_default(); + self.push_segment(SEG_EMBED, &payload); + } +} + +impl RvfReader { + /// Parse and return the embedding model config, if present. + pub fn embedding_config(&self) -> Option { + self.find_segment(SEG_EMBED) + .and_then(|data| serde_json::from_slice(data).ok()) + } +} +``` + +#### 2.6.4 `graph_transformer.rs` (NO CHANGES NEEDED) + +The `embed()` method already exists and returns `[17 x d_model]`. No modifications required. + +### 2.7 Parameter Budget + +| Component | Params | Breakdown | FP32 | INT8 | +|-----------|--------|-----------|------|------| +| `csi_embed` | 3,648 | 56*64 + 64 | 14.6 KB | 3.6 KB | +| `keypoint_queries` | 1,088 | 17*64 | 4.4 KB | 1.1 KB | +| `CrossAttention` (4-head) | 16,640 | 4*(64*64+64) | 66.6 KB | 16.6 KB | +| `GnnStack` (2 layers) | 8,320 | 2*(64*64+64) | 33.3 KB | 8.3 KB | +| `xyz_head` | 195 | 64*3 + 3 | 0.8 KB | 0.2 KB | +| `conf_head` | 65 | 64*1 + 1 | 0.3 KB | 0.1 KB | +| **Backbone subtotal** | **29,956** | | **119.8 KB** | **29.9 KB** | +| `proj_1` (Linear) | 8,320 | 64*128 + 128 | 33.3 KB | 8.3 KB | +| `bn_1` (gamma + beta) | 256 | 128 + 128 | 1.0 KB | 0.3 KB | +| `proj_2` (Linear) | 16,512 | 128*128 + 128 | 66.0 KB | 16.5 KB | +| **ProjectionHead subtotal** | **25,088** | | **100.4 KB** | **25.1 KB** | +| **AETHER Total** | **55,044** | | **220.2 KB** | **55.0 KB** | +| `PoseEncoder` (optional) | 7,040 | 51*128+128 + 128*128+128 | 28.2 KB | 7.0 KB | +| **Full system** | **62,084** | | **248.3 KB** | **62.1 KB** | + +### 2.8 Performance Targets + +| Metric | Target | Measurement | +|--------|--------|-------------| +| Embedding extraction latency (FP32, x86) | < 1 ms | `BenchmarkRunner::benchmark_inference()` | +| Embedding extraction latency (INT8, ESP32) | < 2 ms | Hardware benchmark at 240 MHz | +| HNSW search latency (10K vectors, k=5) | < 0.5 ms | `ruvector-core` benchmark suite | +| Self-supervised pretrain convergence | < 200 epochs | Alignment/uniformity plateau detection | +| Room identification accuracy (5 rooms) | > 95% | k-NN on `env_fingerprint` index | +| Activity classification accuracy (6 activities) | > 85% | k-NN on `activity_pattern` index | +| Person re-identification mAP (5 subjects) | > 80% | Rank-1 on `person_track` index | +| Anomaly detection F1 | > 0.90 | Distance threshold on `temporal_baseline` | +| INT8 rank correlation vs FP32 | > 0.95 | Spearman over 1000 query-neighbor pairs | +| Model size at INT8 | < 65 KB | `param_count * 1 byte` | +| Training memory overhead | < 50 MB | Peak RSS during pretraining | + +### 2.9 Edge Deployment Strategy + +#### 2.9.1 ESP32 (via C/Rust cross-compilation) + +- INT8 quantization mandatory (53 KB model + 20 KB activation buffer = 73 KB of 520 KB SRAM) +- `micro-hnsw-wasm` stores up to 32 reference embeddings per core (256 cores = 8K embeddings) +- Embedding extraction runs at 20 Hz (50 ms budget, target <2 ms) +- HNSW search adds <0.1 ms for 32-vector index +- Total pipeline: CSI capture (25 ms) + embedding (2 ms) + search (0.1 ms) = 27.1 ms < 50 ms budget + +#### 2.9.2 WASM (browser/server) + +- FP32 or FP16 model (size constraints are relaxed) +- `ruvector-core` HNSW index in full mode (up to 1M vectors) +- Web Worker for non-blocking inference +- REST API endpoint: `POST /api/v1/embedding/extract` (input: CSI frame, output: 128-dim vector) +- REST API endpoint: `POST /api/v1/embedding/search` (input: 128-dim vector, output: k nearest neighbors) +- WebSocket endpoint: `ws://.../embedding/stream` (streaming CSI -> streaming embeddings) + +--- + +## 3. Implementation Phases + +### Phase 1: Embedding Module (2-3 days) + +**Files:** +- `embedding.rs` (NEW): `ProjectionHead`, `CsiAugmenter`, `EmbeddingExtractor`, loss functions, metrics +- `rvf_container.rs` (MODIFY): Add `SEG_EMBED`, `add_embedding_config()`, `embedding_config()` +- `lib.rs` (MODIFY): Add `pub mod embedding;` + +**Deliverables:** +- `ProjectionHead` with `forward()`, `forward_train()`, `flatten_into()`, `unflatten_from()` +- `CsiAugmenter` with all 7 augmentation strategies +- `info_nce_loss()`, `variance_loss()`, `covariance_loss()`, `aether_loss()` +- `EmbeddingExtractor` with `embed()` and `forward_dual()` +- `alignment_metric()` and `uniformity_metric()` +- Unit tests: augmentation output shape, loss gradient direction, L2-normalization, projection head roundtrip +- **Lines**: ~450 + +### Phase 2: Self-Supervised Pretraining (1-2 days) + +**Files:** +- `trainer.rs` (MODIFY): Add `pretrain_epoch()`, `run_pretraining()`, contrastive loss to composite +- `embedding.rs` (EXTEND): Add `PretrainEpochStats`, `PretrainResult` + +**Deliverables:** +- `Trainer::pretrain_epoch()` running SimCLR+VICReg on raw CSI windows +- `Trainer::run_pretraining()` full loop with monitoring +- Contrastive weight in `LossComponents` and `LossWeights` +- Integration test: pretrain 10 epochs on synthetic CSI, verify alignment improves +- **Lines**: ~200 additions to `trainer.rs` + +### Phase 3: HNSW Fingerprint Pipeline (2-3 days) + +**Files:** +- `embedding.rs` (EXTEND): Add `EmbeddingIndex` trait, `EmbeddingMetadata`, index management +- `main.rs` or new `api_embedding.rs` (MODIFY/NEW): REST endpoints for embedding search + +**Deliverables:** +- Four HNSW index types with insert/search/prune operations +- Environment switching via embedding comparison (replaces statistical drift) +- Anomaly detection via baseline distance threshold +- REST API: `/api/v1/embedding/extract`, `/api/v1/embedding/search` +- Integration with existing SONA `EnvironmentDetector` +- **Lines**: ~300 + +### Phase 4: Cross-Modal Alignment (1 day, optional) + +**Files:** +- `embedding.rs` (EXTEND): Add `PoseEncoder`, `cross_modal_loss()` + +**Deliverables:** +- `PoseEncoder`: Linear(51 -> 128) -> ReLU -> Linear(128 -> 128) -> L2-norm +- Cross-modal InfoNCE loss on paired CSI + pose data +- Evaluation script for pose retrieval from CSI query +- **Lines**: ~150 + +### Phase 5: Quantized Embedding Validation (1 day) + +**Files:** +- `sparse_inference.rs` (EXTEND): Add `SpearmanRankCorrelation`, embedding-specific quantization tests +- `rvf_pipeline.rs` (MODIFY): Package AETHER model into RVF with SEG_EMBED + +**Deliverables:** +- Spearman rank correlation test for INT8 vs FP32 embeddings +- Mixed-precision fallback (INT8 backbone + FP16 projection head) +- ESP32 latency benchmark target verification +- RVF packaging of complete AETHER model +- **Lines**: ~150 + +### Phase 6: Integration Testing & Benchmarks (1-2 days) + +**Deliverables:** +- End-to-end test: CSI -> embed -> HNSW insert -> HNSW search -> verify nearest neighbor correctness +- Pretraining convergence benchmark on MM-Fi dataset +- Quantization rank preservation benchmark +- ESP32 simulation latency benchmark +- All performance targets verified + +**Total estimated effort: 8-12 days** + +--- + +## 4. Consequences + +### Positive + +- **Self-supervised pretraining from unlabeled CSI**: Any WiFi CSI stream (no cameras, no annotations) can pretrain the embedding backbone, radically reducing labeled data requirements. This is the single most impactful capability: WiFi signals are ubiquitous and free. +- **Reuses 100% of existing infrastructure**: No new model architecture -- extends the existing CsiToPoseTransformer with one module, one loss term, one RVF segment type. +- **HNSW-ready embeddings**: 128-dim L2-normalized vectors plug directly into the HNSW indices proposed in ADR-004, fulfilling that ADR's "vector encode" pipeline gap. +- **Multi-use embeddings**: Same model produces pose keypoints AND embedding vectors in a single forward pass. Two capabilities for the price of one inference. +- **Anomaly detection without task-specific models**: OOD CSI frames produce embeddings distant from the training distribution. Fall detection, intrusion detection, and environment change detection emerge as byproducts of the embedding space geometry. +- **Compact environment fingerprints**: 128-dim embedding (512 bytes) replaces ~448 KB `SonaProfile` for environment identification. 900x compression with better discriminative power. +- **Cross-environment transfer**: Contrastive pretraining on diverse environments produces features that capture environment-invariant body dynamics, enabling few-shot adaptation (5-10 labeled samples) to new spaces. +- **Edge-deployable**: 55 KB at INT8 fits ESP32 SRAM with 88% headroom. The entire embedding + search pipeline completes in <3 ms. +- **Privacy-preserving**: Embeddings are not invertible to raw CSI. The projection head's information bottleneck (17x64 -> 128) discards environment-specific details, making embeddings suitable for cross-site comparison without revealing room geometry. + +### Negative + +- **Embedding quality coupled to backbone**: Unlike a standalone embedding model, quality depends on the CsiToPoseTransformer. Mitigated by the projection head adding a task-specific non-linear transformation. +- **Augmentation sensitivity**: Self-supervised embedding quality depends on augmentation design. Too aggressive = collapsed embeddings; too mild = trivial invariances. Mitigated by VICReg variance regularization and monitoring via alignment/uniformity metrics. +- **Additional training phase**: Pretrain-then-finetune is longer than direct supervised training. Mitigated by: (a) pretraining is a one-time cost, (b) the resulting backbone converges faster on supervised tasks. +- **Cosine distance under quantization**: INT8 can distort relative distances, degrading HNSW recall. Mitigated by Spearman rank correlation test with FP16 fallback for the projection head. +- **BatchNorm in projection head**: Adds training/inference mode distinction (running stats vs batch stats). At inference, uses running mean/var accumulated during training. On-device, this is a fixed per-dimension scale+shift operation. + +### Risks and Mitigations + +| Risk | Probability | Impact | Mitigation | +|------|------------|--------|------------| +| Augmentations produce collapsed embeddings (all vectors identical) | Medium | High | VICReg variance term (`beta=25`) with per-dimension variance monitoring. Alert if `Var(z_j) < 0.1` for any j. Switch to BYOL (stop-gradient) if collapse persists. | +| INT8 quantization degrades HNSW recall below 90% | Low | Medium | Spearman `rho > 0.95` gate. Mixed-precision fallback: INT8 backbone + FP16 projection head (+25 KB). | +| Contrastive pretraining does not improve downstream pose accuracy | Low | Low | Pretraining is optional. Supervised-only training (ADR-023) remains the fallback path. Even if pose accuracy is unchanged, embeddings still enable fingerprinting/search. | +| Cross-modal alignment requires too much paired data for convergence | Medium | Low | Phase C is optional. Self-supervised CSI-only pretraining (Phase A) is the primary path. Cross-modal alignment is an enhancement, not a requirement. | +| Projection head overfits to pretraining augmentations | Low | Medium | Freeze projection head during supervised fine-tuning (only fine-tune backbone + pose heads). Alternatively, use stop-gradient on the projection head during joint training. | +| Embedding space is not discriminative enough for person re-identification | Medium | Medium | WhoFi (2025) demonstrates 95.5% accuracy with transformer CSI encoding. Our architecture is comparable. If insufficient, add a supervised contrastive loss with person labels during fine-tuning. | + +--- + +## 5. Testing Strategy + +### 5.1 Unit Tests (in `embedding.rs`) + +```rust +#[cfg(test)] +mod tests { + // ProjectionHead + fn projection_head_output_is_128_dim(); + fn projection_head_output_is_l2_normalized(); + fn projection_head_zero_input_does_not_nan(); + fn projection_head_flatten_unflatten_roundtrip(); + fn projection_head_param_count_correct(); + + // CsiAugmenter + fn augmenter_output_same_shape_as_input(); + fn augmenter_two_views_differ(); + fn augmenter_deterministic_with_same_seed(); + fn temporal_jitter_shifts_window(); + fn subcarrier_masking_zeros_expected_fraction(); + fn gaussian_noise_changes_values(); + fn amplitude_scaling_within_range(); + + // Loss functions + fn info_nce_zero_for_identical_embeddings(); + fn info_nce_positive_for_different_embeddings(); + fn info_nce_decreases_with_closer_positives(); + fn variance_loss_zero_when_variance_at_target(); + fn variance_loss_positive_when_variance_below_target(); + fn covariance_loss_zero_for_uncorrelated_dims(); + fn aether_loss_finite_for_random_embeddings(); + + // Metrics + fn alignment_zero_for_identical_pairs(); + fn uniformity_decreases_with_uniform_distribution(); + + // EmbeddingExtractor + fn extractor_embed_output_shape(); + fn extractor_dual_forward_produces_both_outputs(); + fn extractor_flatten_unflatten_preserves_output(); +} +``` + +### 5.2 Integration Tests + +```rust +#[cfg(test)] +mod integration_tests { + // Pretraining + fn pretrain_5_epochs_alignment_improves(); + fn pretrain_loss_is_finite_throughout(); + fn pretrain_embeddings_not_collapsed(); // variance > 0.5 per dim + + // Joint training + fn joint_train_contrastive_plus_pose_loss_finite(); + fn joint_train_pose_accuracy_not_degraded(); + + // RVF + fn rvf_embed_config_round_trip(); + fn rvf_full_aether_model_package(); + + // Quantization + fn int8_embedding_rank_correlation_above_095(); + fn fp16_embedding_rank_correlation_above_099(); +} +``` + +--- + +## 6. Phase 7: Deep RuVector Integration β€” MicroLoRA + EWC++ + Library Losses + +**Status**: Required (promoted from Future Work after capability audit) + +The RuVector v2.0.4 vendor crates provide 50+ attention mechanisms, contrastive losses, and optimization tools that Phases 1-6 do not use (0% utilization). Phase 7 integrates the highest-impact capabilities directly into the embedding pipeline. + +### 6.1 MicroLoRA on ProjectionHead (Environment-Specific Embeddings) + +Integrate `sona.rs::LoraAdapter` into `ProjectionHead` for environment-adaptive embedding projection with minimal parameters: + +```rust +pub struct ProjectionHead { + proj_1: Linear, // base weights (frozen after pretraining) + proj_1_lora: Option, // rank-4 environment delta (NEW) + // ... bn fields ... + proj_2: Linear, // base weights (frozen) + proj_2_lora: Option, // rank-4 environment delta (NEW) +} +``` + +**Parameter budget per environment:** +- `proj_1_lora`: rank 4 * (64 + 128) = **768 params** +- `proj_2_lora`: rank 4 * (128 + 128) = **1,024 params** +- **Total: 1,792 params/env** vs 24,832 full ProjectionHead = **93% reduction** + +**Methods to add:** +- `ProjectionHead::with_lora(rank: usize)` β€” constructor with LoRA adapters +- `ProjectionHead::forward()` modified: `out = base_out + lora.forward(input)` when adapters present +- `ProjectionHead::merge_lora()` / `unmerge_lora()` β€” for fast environment switching +- `ProjectionHead::freeze_base()` β€” freeze base weights, train only LoRA +- `ProjectionHead::lora_params() -> Vec` β€” flatten only LoRA weights for checkpoint + +**Environment switching workflow:** +1. Compute `z_csi` for incoming CSI +2. Compare against stored `env_embedding` of all known profiles (128-dim dot product, <1us) +3. If closest profile < threshold: `unmerge_lora(old)` then `merge_lora(new)` +4. If no profile close: start LoRA adaptation for new environment + +**Effort**: ~120 lines in `embedding.rs` + +### 6.2 EWC++ Consolidation for Pretrain-to-Finetune Transition + +Apply `sona.rs::EwcRegularizer` to prevent catastrophic forgetting of contrastive structure during supervised fine-tuning: + +``` +Phase A (pretrain): Train backbone + projection with InfoNCE + VICReg + ↓ +Consolidation: fisher = EwcRegularizer::compute_fisher(pretrained_params, contrastive_loss) + ewc.consolidate(pretrained_params) + ↓ +Phase B (finetune): L_total = L_pose + lambda * ewc.penalty(current_params) + grad += ewc.penalty_gradient(current_params) +``` + +**Implementation:** +- Add `embedding_ewc: Option` field to `Trainer` +- After `run_pretraining()` completes, call `ewc.compute_fisher()` on contrastive loss surface +- During `train_epoch()`, add `ewc.penalty(current_params)` to total loss +- Add `ewc.penalty_gradient(current_params)` to gradient computation +- Lambda default: 5000.0 (from SONA config), decays over fine-tuning epochs + +**Effort**: ~80 lines in `trainer.rs` + +### 6.3 EnvironmentDetector in Embedding Pipeline + +Wire `sona.rs::EnvironmentDetector` into `EmbeddingExtractor` for real-time drift awareness: + +```rust +pub struct EmbeddingExtractor { + transformer: CsiToPoseTransformer, + projection: ProjectionHead, + config: AetherConfig, + drift_detector: EnvironmentDetector, // NEW +} +``` + +**Behavior:** +- `extract()` calls `drift_detector.update(csi_mean, csi_var)` on each frame +- When `drift_detected()` returns true: + - New embeddings tagged `anomalous: true` in `FingerprintIndex` + - Triggers LoRA adaptation on ProjectionHead (6.1) + - Optionally pauses HNSW insertion until drift stabilizes +- `DriftInfo` exposed via REST: `GET /api/v1/embedding/drift` + +**Effort**: ~60 lines across `embedding.rs` + +### 6.4 Hard-Negative Mining for Contrastive Training + +Add hard-negative mining to the contrastive loss for more efficient training: + +```rust +pub struct HardNegativeMiner { + pub ratio: f32, // 0.5 = use top 50% hardest negatives + pub warmup_epochs: usize, // 5 = use all negatives for first 5 epochs +} + +impl HardNegativeMiner { + /// Select top-K hardest negatives from similarity matrix. + /// Hard negatives are non-matching pairs with highest cosine similarity + /// (i.e., the model is most confused about them). + pub fn mine(&self, sim_matrix: &[Vec], epoch: usize) -> Vec<(usize, usize)>; +} +``` + +Modify `info_nce_loss()` to accept optional miner: +- First `warmup_epochs`: use all negatives (standard InfoNCE) +- After warmup: use only top `ratio` hardest negatives per anchor +- Increases effective batch difficulty without increasing batch size + +**Effort**: ~80 lines in `embedding.rs` + +### 6.5 RVF SEG_EMBED with LoRA Profile Storage + +Extend RVF container to store embedding model config AND per-environment LoRA deltas: + +```rust +pub const SEG_EMBED: u8 = 0x0C; +pub const SEG_LORA: u8 = 0x0D; // NEW: LoRA weight deltas + +pub struct EmbeddingModelConfig { + pub d_model: usize, + pub d_proj: usize, + pub normalize: bool, + pub pretrain_method: String, + pub temperature: f32, + pub augmentations: Vec, + pub lora_rank: Option, // Some(4) if MicroLoRA enabled + pub ewc_lambda: Option, // Some(5000.0) if EWC active + pub hard_negative_ratio: Option, +} + +impl RvfBuilder { + pub fn add_embedding_config(&mut self, config: &EmbeddingModelConfig); + pub fn add_lora_profile(&mut self, name: &str, lora_weights: &[f32]); +} + +impl RvfReader { + pub fn embedding_config(&self) -> Option; + pub fn lora_profile(&self, name: &str) -> Option>; + pub fn lora_profiles(&self) -> Vec; // list all stored profiles +} +``` + +**Effort**: ~100 lines in `rvf_container.rs` + +### Phase 7 Summary + +| Sub-phase | What | New Params | Lines | +|-----------|------|-----------|-------| +| 7.1 MicroLoRA on ProjectionHead | Environment-specific embeddings | 1,792/env | ~120 | +| 7.2 EWC++ consolidation | Pretrainβ†’finetune memory preservation | 0 (regularizer) | ~80 | +| 7.3 EnvironmentDetector integration | Drift-aware embedding extraction | 0 | ~60 | +| 7.4 Hard-negative mining | More efficient contrastive training | 0 | ~80 | +| 7.5 RVF SEG_EMBED + SEG_LORA | Full model + LoRA profile packaging | 0 | ~100 | +| **Total** | | **1,792/env** | **~440** | + +## 7. Future Work + +- **Masked Autoencoder pretraining (ContraWiMAE-style)**: Combine contrastive with masked reconstruction for richer pre-trained representations. Mask random subcarrier-time patches and reconstruct them, using the reconstruction loss as an additional pretraining signal. +- **Hyperbolic embeddings**: Use the `ruvector-hyperbolic-hnsw` crate to embed activities in Poincare ball space, capturing the natural hierarchy (locomotion > walking > shuffling). +- **Temporal contrastive loss**: Extend from single-frame InfoNCE to temporal CPC (Contrastive Predictive Coding), where the model predicts future CSI embeddings from past ones, capturing temporal dynamics. +- **Federated AETHER**: Train embeddings across multiple deployment sites without centralizing raw CSI data. Each site computes local gradient updates; a central server aggregates using FedAvg. Only embedding-space gradients cross site boundaries. +- **RuVector Advanced Attention**: Integrate `MoEAttention` for routing CSI frames to specialized embedding experts, `HyperbolicAttention` for hierarchical CSI structure, and `SheafAttention` for early-exit during embedding extraction. + +--- + +## 7. References + +### Contrastive Learning Foundations +- [SimCLR: A Simple Framework for Contrastive Learning of Visual Representations](https://arxiv.org/abs/2002.05709) (Chen et al., ICML 2020) +- [SimCLR v2: Big Self-Supervised Models are Strong Semi-Supervised Learners](https://arxiv.org/abs/2006.10029) (Chen et al., NeurIPS 2020) +- [MoCo v3: An Empirical Study of Training Self-Supervised Vision Transformers](https://arxiv.org/abs/2104.02057) (Chen et al., ICCV 2021) +- [BYOL: Bootstrap Your Own Latent](https://arxiv.org/abs/2006.07733) (Grill et al., NeurIPS 2020) +- [VICReg: Variance-Invariance-Covariance Regularization for Self-Supervised Learning](https://arxiv.org/abs/2105.04906) (Bardes et al., ICLR 2022) +- [DINO: Emerging Properties in Self-Supervised Vision Transformers](https://arxiv.org/abs/2104.14294) (Caron et al., ICCV 2021) +- [Barlow Twins: Self-Supervised Learning via Redundancy Reduction](https://arxiv.org/abs/2103.03230) (Zbontar et al., ICML 2021) +- [Understanding Contrastive Representation Learning through Alignment and Uniformity on the Hypersphere](https://arxiv.org/abs/2005.10242) (Wang & Isola, ICML 2020) +- [CLIP: Learning Transferable Visual Models From Natural Language Supervision](https://arxiv.org/abs/2103.00020) (Radford et al., ICML 2021) + +### WiFi Sensing and CSI Embeddings +- [DensePose From WiFi](https://arxiv.org/abs/2301.00250) (Geng et al., CMU, 2023) +- [WhoFi: Deep Person Re-Identification via Wi-Fi Channel Signal Encoding](https://arxiv.org/abs/2507.12869) (2025) +- [IdentiFi: Self-Supervised WiFi-Based Identity Recognition in Multi-User Smart Environments](https://pmc.ncbi.nlm.nih.gov/articles/PMC12115556/) (2025) +- [Context-Aware Predictive Coding (CAPC): A Representation Learning Framework for WiFi Sensing](https://arxiv.org/abs/2410.01825) (2024) +- [A Tutorial-cum-Survey on Self-Supervised Learning for Wi-Fi Sensing](https://arxiv.org/abs/2506.12052) (2025) +- [Evaluating Self-Supervised Learning for WiFi CSI-Based Human Activity Recognition](https://dl.acm.org/doi/10.1145/3715130) (ACM TOSN, 2025) +- [Wi-Fi CSI Fingerprinting-Based Indoor Positioning Using Deep Learning and Vector Embedding](https://www.sciencedirect.com/science/article/abs/pii/S0957417424026691) (2024) +- [SelfHAR: Improving Human Activity Recognition through Self-training with Unlabeled Data](https://arxiv.org/abs/2102.06073) (2021) +- [WiFi CSI Contrastive Pre-training for Activity Recognition](https://doi.org/10.1145/3580305.3599383) (Wang et al., KDD 2023) +- [Wi-PER81: Benchmark Dataset for Radio Signal Image-based Person Re-Identification](https://www.nature.com/articles/s41597-025-05804-0) (Nature Sci Data, 2025) +- [SignFi: Sign Language Recognition Using WiFi](https://arxiv.org/abs/1806.04583) (Ma et al., 2018) + +### Self-Supervised Learning for Time Series +- [Self-Supervised Contrastive Learning for Long-term Forecasting](https://openreview.net/forum?id=nBCuRzjqK7) (2024) +- [Resampling Augmentation for Time Series Contrastive Learning](https://arxiv.org/abs/2506.18587) (2025) +- [Diffusion Model-based Contrastive Learning for Human Activity Recognition](https://arxiv.org/abs/2408.05567) (2024) +- [Self-Supervised Contrastive Learning for 6G UM-MIMO THz Communications](https://rings.winslab.lids.mit.edu/wp-content/uploads/2024/06/MurUllSaqWin-ICC-06-2024.pdf) (ICC 2024) + +### Internal ADRs +- ADR-003: RVF Cognitive Containers for CSI Data +- ADR-004: HNSW Vector Search for Signal Fingerprinting +- ADR-005: SONA Self-Learning for Pose Estimation +- ADR-006: GNN-Enhanced CSI Pattern Recognition +- ADR-014: SOTA Signal Processing Algorithms +- ADR-015: Public Dataset Training Strategy +- ADR-016: RuVector Integration for Training Pipeline +- ADR-023: Trained DensePose Model with RuVector Signal Intelligence Pipeline diff --git a/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/embedding.rs b/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/embedding.rs new file mode 100644 index 0000000..9ee6a56 --- /dev/null +++ b/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/embedding.rs @@ -0,0 +1,909 @@ +//! Contrastive CSI Embedding Model (ADR-024). +//! +//! Implements self-supervised contrastive learning for WiFi CSI feature extraction: +//! - ProjectionHead: 2-layer MLP for contrastive embedding space +//! - CsiAugmenter: domain-specific augmentations for SimCLR-style pretraining +//! - InfoNCE loss: normalized temperature-scaled cross-entropy +//! - FingerprintIndex: brute-force nearest-neighbour (HNSW-compatible interface) +//! - PoseEncoder: lightweight encoder for cross-modal alignment +//! - EmbeddingExtractor: full pipeline (backbone + projection) +//! +//! All arithmetic uses `f32`. No external ML dependencies. + +use crate::graph_transformer::{CsiToPoseTransformer, TransformerConfig, Linear}; + +// ── SimpleRng (xorshift64) ────────────────────────────────────────────────── + +/// Deterministic xorshift64 PRNG to avoid external dependency. +struct SimpleRng { + state: u64, +} + +impl SimpleRng { + fn new(seed: u64) -> Self { + Self { state: if seed == 0 { 0xBAAD_CAFE_DEAD_BEEFu64 } else { seed } } + } + fn next_u64(&mut self) -> u64 { + let mut x = self.state; + x ^= x << 13; + x ^= x >> 7; + x ^= x << 17; + self.state = x; + x + } + /// Uniform f32 in [0, 1). + fn next_f32_unit(&mut self) -> f32 { + (self.next_u64() >> 11) as f32 / (1u64 << 53) as f32 + } + /// Gaussian approximation via Box-Muller (pair, returns first). + fn next_gaussian(&mut self) -> f32 { + let u1 = self.next_f32_unit().max(1e-10); + let u2 = self.next_f32_unit(); + (-2.0 * u1.ln()).sqrt() * (2.0 * std::f32::consts::PI * u2).cos() + } +} + +// ── EmbeddingConfig ───────────────────────────────────────────────────────── + +/// Configuration for the contrastive embedding model. +#[derive(Debug, Clone)] +pub struct EmbeddingConfig { + /// Hidden dimension (must match transformer d_model). + pub d_model: usize, + /// Projection/embedding dimension. + pub d_proj: usize, + /// InfoNCE temperature. + pub temperature: f32, + /// Whether to L2-normalize output embeddings. + pub normalize: bool, +} + +impl Default for EmbeddingConfig { + fn default() -> Self { + Self { d_model: 64, d_proj: 128, temperature: 0.07, normalize: true } + } +} + +// ── ProjectionHead ────────────────────────────────────────────────────────── + +/// 2-layer MLP projection head: d_model -> d_proj -> d_proj with ReLU + L2-norm. +#[derive(Debug, Clone)] +pub struct ProjectionHead { + pub proj_1: Linear, + pub proj_2: Linear, + pub config: EmbeddingConfig, +} + +impl ProjectionHead { + /// Xavier-initialized projection head. + pub fn new(config: EmbeddingConfig) -> Self { + Self { + proj_1: Linear::with_seed(config.d_model, config.d_proj, 2024), + proj_2: Linear::with_seed(config.d_proj, config.d_proj, 2025), + config, + } + } + + /// Zero-initialized projection head (for gradient estimation). + pub fn zeros(config: EmbeddingConfig) -> Self { + Self { + proj_1: Linear::zeros(config.d_model, config.d_proj), + proj_2: Linear::zeros(config.d_proj, config.d_proj), + config, + } + } + + /// Forward pass: ReLU between layers, optional L2-normalize output. + pub fn forward(&self, x: &[f32]) -> Vec { + let h: Vec = self.proj_1.forward(x).into_iter() + .map(|v| if v > 0.0 { v } else { 0.0 }) + .collect(); + let mut out = self.proj_2.forward(&h); + if self.config.normalize { + l2_normalize(&mut out); + } + out + } + + /// Push all weights into a flat vec. + pub fn flatten_into(&self, out: &mut Vec) { + self.proj_1.flatten_into(out); + self.proj_2.flatten_into(out); + } + + /// Restore from a flat slice. Returns (Self, number of f32s consumed). + pub fn unflatten_from(data: &[f32], config: &EmbeddingConfig) -> (Self, usize) { + let mut offset = 0; + let (p1, n) = Linear::unflatten_from(&data[offset..], config.d_model, config.d_proj); + offset += n; + let (p2, n) = Linear::unflatten_from(&data[offset..], config.d_proj, config.d_proj); + offset += n; + (Self { proj_1: p1, proj_2: p2, config: config.clone() }, offset) + } + + /// Total trainable parameters. + pub fn param_count(&self) -> usize { + self.proj_1.param_count() + self.proj_2.param_count() + } +} + +// ── CsiAugmenter ──────────────────────────────────────────────────────────── + +/// CSI augmentation strategies for contrastive pretraining. +#[derive(Debug, Clone)] +pub struct CsiAugmenter { + /// +/- frames to shift (temporal jitter). + pub temporal_jitter: i32, + /// Fraction of subcarriers to zero out. + pub subcarrier_mask_ratio: f32, + /// Gaussian noise sigma. + pub noise_std: f32, + /// Max phase offset in radians. + pub phase_rotation_max: f32, + /// Amplitude scale range (min, max). + pub amplitude_scale_range: (f32, f32), +} + +impl CsiAugmenter { + pub fn new() -> Self { + Self { + temporal_jitter: 2, + subcarrier_mask_ratio: 0.15, + noise_std: 0.05, + phase_rotation_max: std::f32::consts::FRAC_PI_4, + amplitude_scale_range: (0.8, 1.2), + } + } + + /// Apply random augmentations to a CSI window, returning two different views. + /// Each view receives a different random subset of augmentations. + pub fn augment_pair( + &self, + csi_window: &[Vec], + rng_seed: u64, + ) -> (Vec>, Vec>) { + let mut rng_a = SimpleRng::new(rng_seed); + let mut rng_b = SimpleRng::new(rng_seed.wrapping_add(0x1234_5678_9ABC_DEF0)); + + // View A: temporal jitter + noise + subcarrier mask + let mut view_a = self.apply_temporal_jitter(csi_window, &mut rng_a); + self.apply_gaussian_noise(&mut view_a, &mut rng_a); + self.apply_subcarrier_mask(&mut view_a, &mut rng_a); + + // View B: amplitude scaling + phase rotation + different noise + let mut view_b = self.apply_temporal_jitter(csi_window, &mut rng_b); + self.apply_amplitude_scaling(&mut view_b, &mut rng_b); + self.apply_phase_rotation(&mut view_b, &mut rng_b); + self.apply_gaussian_noise(&mut view_b, &mut rng_b); + + (view_a, view_b) + } + + fn apply_temporal_jitter( + &self, + window: &[Vec], + rng: &mut SimpleRng, + ) -> Vec> { + if window.is_empty() || self.temporal_jitter == 0 { + return window.to_vec(); + } + let range = 2 * self.temporal_jitter + 1; + let shift = (rng.next_u64() % range as u64) as i32 - self.temporal_jitter; + let n = window.len() as i32; + (0..window.len()) + .map(|i| { + let src = (i as i32 + shift).clamp(0, n - 1) as usize; + window[src].clone() + }) + .collect() + } + + fn apply_subcarrier_mask(&self, window: &mut [Vec], rng: &mut SimpleRng) { + for frame in window.iter_mut() { + for v in frame.iter_mut() { + if rng.next_f32_unit() < self.subcarrier_mask_ratio { + *v = 0.0; + } + } + } + } + + fn apply_gaussian_noise(&self, window: &mut [Vec], rng: &mut SimpleRng) { + for frame in window.iter_mut() { + for v in frame.iter_mut() { + *v += rng.next_gaussian() * self.noise_std; + } + } + } + + fn apply_phase_rotation(&self, window: &mut [Vec], rng: &mut SimpleRng) { + let offset = (rng.next_f32_unit() * 2.0 - 1.0) * self.phase_rotation_max; + for frame in window.iter_mut() { + for v in frame.iter_mut() { + // Approximate phase rotation on amplitude: multiply by cos(offset) + *v *= offset.cos(); + } + } + } + + fn apply_amplitude_scaling(&self, window: &mut [Vec], rng: &mut SimpleRng) { + let (lo, hi) = self.amplitude_scale_range; + let scale = lo + rng.next_f32_unit() * (hi - lo); + for frame in window.iter_mut() { + for v in frame.iter_mut() { + *v *= scale; + } + } + } +} + +impl Default for CsiAugmenter { + fn default() -> Self { Self::new() } +} + +// ── Vector math utilities ─────────────────────────────────────────────────── + +/// L2-normalize a vector in-place. +fn l2_normalize(v: &mut [f32]) { + let norm = v.iter().map(|x| x * x).sum::().sqrt(); + if norm > 1e-10 { + let inv = 1.0 / norm; + for x in v.iter_mut() { + *x *= inv; + } + } +} + +/// Cosine similarity between two vectors. +fn cosine_similarity(a: &[f32], b: &[f32]) -> f32 { + let n = a.len().min(b.len()); + let dot: f32 = (0..n).map(|i| a[i] * b[i]).sum(); + let na = (0..n).map(|i| a[i] * a[i]).sum::().sqrt(); + let nb = (0..n).map(|i| b[i] * b[i]).sum::().sqrt(); + if na > 1e-10 && nb > 1e-10 { dot / (na * nb) } else { 0.0 } +} + +// ── InfoNCE loss ──────────────────────────────────────────────────────────── + +/// InfoNCE contrastive loss (NT-Xent / SimCLR objective). +/// +/// For batch of N pairs (a_i, b_i): +/// loss = -1/N sum_i log( exp(sim(a_i, b_i)/t) / sum_j exp(sim(a_i, b_j)/t) ) +pub fn info_nce_loss( + embeddings_a: &[Vec], + embeddings_b: &[Vec], + temperature: f32, +) -> f32 { + let n = embeddings_a.len().min(embeddings_b.len()); + if n == 0 { + return 0.0; + } + let t = temperature.max(1e-6); + let mut total_loss = 0.0f32; + + for i in 0..n { + // Compute similarity of anchor a_i with all b_j + let mut logits = Vec::with_capacity(n); + for j in 0..n { + logits.push(cosine_similarity(&embeddings_a[i], &embeddings_b[j]) / t); + } + // Numerically stable log-softmax + let max_logit = logits.iter().copied().fold(f32::NEG_INFINITY, f32::max); + let log_sum_exp = logits.iter() + .map(|&l| (l - max_logit).exp()) + .sum::() + .ln() + max_logit; + total_loss += -logits[i] + log_sum_exp; + } + + total_loss / n as f32 +} + +// ── FingerprintIndex ──────────────────────────────────────────────────────── + +/// Fingerprint index type. +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum IndexType { + EnvironmentFingerprint, + ActivityPattern, + TemporalBaseline, + PersonTrack, +} + +/// A single index entry. +pub struct IndexEntry { + pub embedding: Vec, + pub metadata: String, + pub timestamp_ms: u64, + pub index_type: IndexType, +} + +/// Search result from the fingerprint index. +pub struct SearchResult { + /// Index into the entries vec. + pub entry: usize, + /// Cosine distance (1 - similarity). + pub distance: f32, + /// Metadata string from the matching entry. + pub metadata: String, +} + +/// Brute-force fingerprint index with HNSW-compatible interface. +/// +/// Stores embeddings and supports nearest-neighbour search via cosine distance. +/// Can be replaced with a proper HNSW implementation for production scale. +pub struct FingerprintIndex { + entries: Vec, + index_type: IndexType, +} + +impl FingerprintIndex { + pub fn new(index_type: IndexType) -> Self { + Self { entries: Vec::new(), index_type } + } + + /// Insert an embedding with metadata and timestamp. + pub fn insert(&mut self, embedding: Vec, metadata: String, timestamp_ms: u64) { + self.entries.push(IndexEntry { + embedding, + metadata, + timestamp_ms, + index_type: self.index_type, + }); + } + + /// Search for the top-k nearest embeddings by cosine distance. + pub fn search(&self, query: &[f32], top_k: usize) -> Vec { + let mut results: Vec<(usize, f32)> = self.entries.iter().enumerate() + .map(|(i, e)| (i, 1.0 - cosine_similarity(query, &e.embedding))) + .collect(); + results.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal)); + results.truncate(top_k); + results.into_iter().map(|(i, d)| SearchResult { + entry: i, + distance: d, + metadata: self.entries[i].metadata.clone(), + }).collect() + } + + /// Number of entries in the index. + pub fn len(&self) -> usize { self.entries.len() } + + /// Whether the index is empty. + pub fn is_empty(&self) -> bool { self.entries.is_empty() } + + /// Detect anomaly: returns true if query is farther than threshold from all entries. + pub fn is_anomaly(&self, query: &[f32], threshold: f32) -> bool { + if self.entries.is_empty() { + return true; + } + self.entries.iter() + .all(|e| (1.0 - cosine_similarity(query, &e.embedding)) > threshold) + } +} + +// ── PoseEncoder (cross-modal alignment) ───────────────────────────────────── + +/// Lightweight pose encoder for cross-modal alignment. +/// Maps 51-dim pose vector (17 keypoints * 3 coords) to d_proj embedding. +#[derive(Debug, Clone)] +pub struct PoseEncoder { + pub layer_1: Linear, + pub layer_2: Linear, + d_proj: usize, +} + +impl PoseEncoder { + /// Create a new pose encoder mapping 51-dim input to d_proj-dim embedding. + pub fn new(d_proj: usize) -> Self { + Self { + layer_1: Linear::with_seed(51, d_proj, 3001), + layer_2: Linear::with_seed(d_proj, d_proj, 3002), + d_proj, + } + } + + /// Forward pass: ReLU + L2-normalize. + pub fn forward(&self, pose_flat: &[f32]) -> Vec { + let h: Vec = self.layer_1.forward(pose_flat).into_iter() + .map(|v| if v > 0.0 { v } else { 0.0 }) + .collect(); + let mut out = self.layer_2.forward(&h); + l2_normalize(&mut out); + out + } + + /// Push all weights into a flat vec. + pub fn flatten_into(&self, out: &mut Vec) { + self.layer_1.flatten_into(out); + self.layer_2.flatten_into(out); + } + + /// Restore from a flat slice. Returns (Self, number of f32s consumed). + pub fn unflatten_from(data: &[f32], d_proj: usize) -> (Self, usize) { + let mut offset = 0; + let (l1, n) = Linear::unflatten_from(&data[offset..], 51, d_proj); + offset += n; + let (l2, n) = Linear::unflatten_from(&data[offset..], d_proj, d_proj); + offset += n; + (Self { layer_1: l1, layer_2: l2, d_proj }, offset) + } + + /// Total trainable parameters. + pub fn param_count(&self) -> usize { + self.layer_1.param_count() + self.layer_2.param_count() + } +} + +/// Cross-modal contrastive loss: aligns CSI embeddings with pose embeddings. +/// Same as info_nce_loss but between two different modalities. +pub fn cross_modal_loss( + csi_embeddings: &[Vec], + pose_embeddings: &[Vec], + temperature: f32, +) -> f32 { + info_nce_loss(csi_embeddings, pose_embeddings, temperature) +} + +// ── EmbeddingExtractor ────────────────────────────────────────────────────── + +/// Full embedding extractor: CsiToPoseTransformer backbone + ProjectionHead. +pub struct EmbeddingExtractor { + pub transformer: CsiToPoseTransformer, + pub projection: ProjectionHead, + pub config: EmbeddingConfig, +} + +impl EmbeddingExtractor { + /// Create a new embedding extractor with given configs. + pub fn new(t_config: TransformerConfig, e_config: EmbeddingConfig) -> Self { + Self { + transformer: CsiToPoseTransformer::new(t_config), + projection: ProjectionHead::new(e_config.clone()), + config: e_config, + } + } + + /// Extract embedding from CSI features. + /// Mean-pools the 17 body_part_features from the transformer backbone, + /// then projects through the ProjectionHead. + pub fn extract(&self, csi_features: &[Vec]) -> Vec { + let body_feats = self.transformer.embed(csi_features); + let d = self.config.d_model; + // Mean-pool across 17 keypoints + let mut pooled = vec![0.0f32; d]; + for feat in &body_feats { + for (p, &f) in pooled.iter_mut().zip(feat.iter()) { + *p += f; + } + } + let n = body_feats.len() as f32; + if n > 0.0 { + for p in pooled.iter_mut() { + *p /= n; + } + } + self.projection.forward(&pooled) + } + + /// Batch extract embeddings. + pub fn extract_batch(&self, batch: &[Vec>]) -> Vec> { + batch.iter().map(|csi| self.extract(csi)).collect() + } + + /// Total parameter count (transformer + projection). + pub fn param_count(&self) -> usize { + self.transformer.param_count() + self.projection.param_count() + } + + /// Flatten all weights (transformer + projection). + pub fn flatten_weights(&self) -> Vec { + let mut out = self.transformer.flatten_weights(); + self.projection.flatten_into(&mut out); + out + } + + /// Unflatten all weights from a flat slice. + pub fn unflatten_weights(&mut self, params: &[f32]) -> Result<(), String> { + let t_count = self.transformer.param_count(); + let p_count = self.projection.param_count(); + let expected = t_count + p_count; + if params.len() != expected { + return Err(format!( + "expected {} params ({}+{}), got {}", + expected, t_count, p_count, params.len() + )); + } + self.transformer.unflatten_weights(¶ms[..t_count])?; + let (proj, consumed) = ProjectionHead::unflatten_from(¶ms[t_count..], &self.config); + if consumed != p_count { + return Err(format!( + "projection consumed {consumed} params, expected {p_count}" + )); + } + self.projection = proj; + Ok(()) + } +} + +// ── Quantized embedding validation ───────────────────────────────────────── + +use crate::sparse_inference::Quantizer; + +/// Validate that INT8 quantization preserves embedding ranking. +/// Returns Spearman rank correlation between FP32 and INT8 distance rankings. +pub fn validate_quantized_embeddings( + embeddings_fp32: &[Vec], + query_fp32: &[f32], + _quantizer: &Quantizer, +) -> f32 { + if embeddings_fp32.is_empty() { + return 1.0; + } + let n = embeddings_fp32.len(); + + // 1. FP32 cosine distances + let fp32_distances: Vec = embeddings_fp32.iter() + .map(|e| 1.0 - cosine_similarity(query_fp32, e)) + .collect(); + + // 2. Quantize each embedding and query, compute approximate distances + let query_quant = Quantizer::quantize_symmetric(query_fp32); + let query_deq = Quantizer::dequantize(&query_quant); + let int8_distances: Vec = embeddings_fp32.iter() + .map(|e| { + let eq = Quantizer::quantize_symmetric(e); + let ed = Quantizer::dequantize(&eq); + 1.0 - cosine_similarity(&query_deq, &ed) + }) + .collect(); + + // 3. Compute rank arrays + let fp32_ranks = rank_array(&fp32_distances); + let int8_ranks = rank_array(&int8_distances); + + // 4. Spearman rank correlation: 1 - 6*sum(d^2) / (n*(n^2-1)) + let d_sq_sum: f32 = fp32_ranks.iter().zip(int8_ranks.iter()) + .map(|(&a, &b)| (a - b) * (a - b)) + .sum(); + let n_f = n as f32; + if n <= 1 { + return 1.0; + } + 1.0 - (6.0 * d_sq_sum) / (n_f * (n_f * n_f - 1.0)) +} + +/// Compute ranks for an array of values (1-based, average ties). +fn rank_array(values: &[f32]) -> Vec { + let n = values.len(); + let mut indexed: Vec<(usize, f32)> = values.iter().copied().enumerate().collect(); + indexed.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal)); + let mut ranks = vec![0.0f32; n]; + let mut i = 0; + while i < n { + let mut j = i; + while j < n && (indexed[j].1 - indexed[i].1).abs() < 1e-10 { + j += 1; + } + let avg_rank = (i + j + 1) as f32 / 2.0; // 1-based average + for k in i..j { + ranks[indexed[k].0] = avg_rank; + } + i = j; + } + ranks +} + +// ── Tests ─────────────────────────────────────────────────────────────────── + +#[cfg(test)] +mod tests { + use super::*; + + fn small_config() -> TransformerConfig { + TransformerConfig { + n_subcarriers: 16, + n_keypoints: 17, + d_model: 8, + n_heads: 2, + n_gnn_layers: 1, + } + } + + fn small_embed_config() -> EmbeddingConfig { + EmbeddingConfig { + d_model: 8, + d_proj: 128, + temperature: 0.07, + normalize: true, + } + } + + fn make_csi(n_pairs: usize, n_sub: usize, seed: u64) -> Vec> { + let mut rng = SimpleRng::new(seed); + (0..n_pairs) + .map(|_| (0..n_sub).map(|_| rng.next_f32_unit()).collect()) + .collect() + } + + // ── ProjectionHead tests ──────────────────────────────────────────── + + #[test] + fn test_projection_head_output_shape() { + let config = small_embed_config(); + let proj = ProjectionHead::new(config); + let input = vec![0.5f32; 8]; + let output = proj.forward(&input); + assert_eq!(output.len(), 128); + } + + #[test] + fn test_projection_head_l2_normalized() { + let config = small_embed_config(); + let proj = ProjectionHead::new(config); + let input = vec![1.0f32; 8]; + let output = proj.forward(&input); + let norm: f32 = output.iter().map(|x| x * x).sum::().sqrt(); + assert!( + (norm - 1.0).abs() < 1e-4, + "expected unit norm, got {norm}" + ); + } + + #[test] + fn test_projection_head_weight_roundtrip() { + let config = small_embed_config(); + let proj = ProjectionHead::new(config.clone()); + let mut flat = Vec::new(); + proj.flatten_into(&mut flat); + assert_eq!(flat.len(), proj.param_count()); + + let (restored, consumed) = ProjectionHead::unflatten_from(&flat, &config); + assert_eq!(consumed, flat.len()); + + let input = vec![0.3f32; 8]; + let out_orig = proj.forward(&input); + let out_rest = restored.forward(&input); + for (a, b) in out_orig.iter().zip(out_rest.iter()) { + assert!((a - b).abs() < 1e-6, "mismatch: {a} vs {b}"); + } + } + + // ── InfoNCE loss tests ────────────────────────────────────────────── + + #[test] + fn test_info_nce_loss_positive_pairs() { + // Identical embeddings should give low loss (close to log(1) = 0) + let emb = vec![vec![1.0, 0.0, 0.0]; 4]; + let loss = info_nce_loss(&emb, &emb, 0.07); + // When all embeddings are identical, all similarities are 1.0, + // so loss = log(N) per sample + let expected = (4.0f32).ln(); + assert!( + (loss - expected).abs() < 0.1, + "identical embeddings: expected ~{expected}, got {loss}" + ); + } + + #[test] + fn test_info_nce_loss_random_pairs() { + // Random embeddings should give higher loss than well-aligned ones + let aligned_a = vec![ + vec![1.0, 0.0, 0.0, 0.0], + vec![0.0, 1.0, 0.0, 0.0], + ]; + let aligned_b = vec![ + vec![0.9, 0.1, 0.0, 0.0], + vec![0.1, 0.9, 0.0, 0.0], + ]; + let random_b = vec![ + vec![0.0, 0.0, 1.0, 0.0], + vec![0.0, 0.0, 0.0, 1.0], + ]; + let loss_aligned = info_nce_loss(&aligned_a, &aligned_b, 0.5); + let loss_random = info_nce_loss(&aligned_a, &random_b, 0.5); + assert!( + loss_random > loss_aligned, + "random should have higher loss: {loss_random} vs {loss_aligned}" + ); + } + + // ── CsiAugmenter tests ────────────────────────────────────────────── + + #[test] + fn test_augmenter_produces_different_views() { + let aug = CsiAugmenter::new(); + let csi = vec![vec![1.0f32; 16]; 5]; + let (view_a, view_b) = aug.augment_pair(&csi, 42); + // Views should differ (different augmentation pipelines) + let mut any_diff = false; + for (a, b) in view_a.iter().zip(view_b.iter()) { + for (&va, &vb) in a.iter().zip(b.iter()) { + if (va - vb).abs() > 1e-6 { + any_diff = true; + break; + } + } + if any_diff { break; } + } + assert!(any_diff, "augmented views should differ"); + } + + #[test] + fn test_augmenter_preserves_shape() { + let aug = CsiAugmenter::new(); + let csi = vec![vec![0.5f32; 20]; 8]; + let (view_a, view_b) = aug.augment_pair(&csi, 99); + assert_eq!(view_a.len(), 8); + assert_eq!(view_b.len(), 8); + for frame in &view_a { + assert_eq!(frame.len(), 20); + } + for frame in &view_b { + assert_eq!(frame.len(), 20); + } + } + + // ── EmbeddingExtractor tests ──────────────────────────────────────── + + #[test] + fn test_embedding_extractor_output_shape() { + let ext = EmbeddingExtractor::new(small_config(), small_embed_config()); + let csi = make_csi(4, 16, 42); + let emb = ext.extract(&csi); + assert_eq!(emb.len(), 128); + } + + #[test] + fn test_embedding_extractor_weight_roundtrip() { + let ext = EmbeddingExtractor::new(small_config(), small_embed_config()); + let weights = ext.flatten_weights(); + assert_eq!(weights.len(), ext.param_count()); + + let mut ext2 = EmbeddingExtractor::new(small_config(), small_embed_config()); + ext2.unflatten_weights(&weights).expect("unflatten should succeed"); + + let csi = make_csi(4, 16, 42); + let emb1 = ext.extract(&csi); + let emb2 = ext2.extract(&csi); + for (a, b) in emb1.iter().zip(emb2.iter()) { + assert!((a - b).abs() < 1e-5, "mismatch: {a} vs {b}"); + } + } + + // ── FingerprintIndex tests ────────────────────────────────────────── + + #[test] + fn test_fingerprint_index_insert_search() { + let mut idx = FingerprintIndex::new(IndexType::EnvironmentFingerprint); + // Insert 10 unit vectors along different axes + for i in 0..10 { + let mut emb = vec![0.0f32; 10]; + emb[i] = 1.0; + idx.insert(emb, format!("entry_{i}"), i as u64 * 100); + } + assert_eq!(idx.len(), 10); + + // Search for vector close to axis 3 + let mut query = vec![0.0f32; 10]; + query[3] = 1.0; + let results = idx.search(&query, 3); + assert_eq!(results.len(), 3); + assert_eq!(results[0].entry, 3, "nearest should be entry_3"); + assert!(results[0].distance < 0.01, "distance should be ~0"); + } + + #[test] + fn test_fingerprint_index_anomaly_detection() { + let mut idx = FingerprintIndex::new(IndexType::ActivityPattern); + // Insert clustered embeddings + for i in 0..5 { + let emb = vec![1.0 + i as f32 * 0.01; 8]; + idx.insert(emb, format!("normal_{i}"), 0); + } + + // Normal query (similar to cluster) + let normal = vec![1.0f32; 8]; + assert!(!idx.is_anomaly(&normal, 0.1), "normal should not be anomaly"); + + // Anomalous query (very different) + let anomaly = vec![-1.0f32; 8]; + assert!(idx.is_anomaly(&anomaly, 0.5), "distant should be anomaly"); + } + + #[test] + fn test_fingerprint_index_types() { + let types = [ + IndexType::EnvironmentFingerprint, + IndexType::ActivityPattern, + IndexType::TemporalBaseline, + IndexType::PersonTrack, + ]; + for &it in &types { + let mut idx = FingerprintIndex::new(it); + idx.insert(vec![1.0, 2.0, 3.0], "test".into(), 0); + assert_eq!(idx.len(), 1); + let results = idx.search(&[1.0, 2.0, 3.0], 1); + assert_eq!(results.len(), 1); + assert!(results[0].distance < 0.01); + } + } + + // ── PoseEncoder tests ─────────────────────────────────────────────── + + #[test] + fn test_pose_encoder_output_shape() { + let enc = PoseEncoder::new(128); + let pose_flat = vec![0.5f32; 51]; // 17 * 3 + let out = enc.forward(&pose_flat); + assert_eq!(out.len(), 128); + } + + #[test] + fn test_pose_encoder_l2_normalized() { + let enc = PoseEncoder::new(128); + let pose_flat = vec![1.0f32; 51]; + let out = enc.forward(&pose_flat); + let norm: f32 = out.iter().map(|x| x * x).sum::().sqrt(); + assert!( + (norm - 1.0).abs() < 1e-4, + "expected unit norm, got {norm}" + ); + } + + #[test] + fn test_cross_modal_loss_aligned_pairs() { + // Create CSI and pose embeddings that are aligned + let csi_emb = vec![ + vec![1.0, 0.0, 0.0, 0.0], + vec![0.0, 1.0, 0.0, 0.0], + vec![0.0, 0.0, 1.0, 0.0], + ]; + let pose_emb_aligned = vec![ + vec![0.95, 0.05, 0.0, 0.0], + vec![0.05, 0.95, 0.0, 0.0], + vec![0.0, 0.05, 0.95, 0.0], + ]; + let pose_emb_shuffled = vec![ + vec![0.0, 0.05, 0.95, 0.0], + vec![0.95, 0.05, 0.0, 0.0], + vec![0.05, 0.95, 0.0, 0.0], + ]; + let loss_aligned = cross_modal_loss(&csi_emb, &pose_emb_aligned, 0.5); + let loss_shuffled = cross_modal_loss(&csi_emb, &pose_emb_shuffled, 0.5); + assert!( + loss_aligned < loss_shuffled, + "aligned should have lower loss: {loss_aligned} vs {loss_shuffled}" + ); + } + + // ── Quantized embedding validation ────────────────────────────────── + + #[test] + fn test_quantized_embedding_rank_correlation() { + let mut rng = SimpleRng::new(12345); + let embeddings: Vec> = (0..20) + .map(|_| (0..32).map(|_| rng.next_gaussian()).collect()) + .collect(); + let query: Vec = (0..32).map(|_| rng.next_gaussian()).collect(); + + let corr = validate_quantized_embeddings(&embeddings, &query, &Quantizer); + assert!( + corr > 0.90, + "rank correlation should be > 0.90, got {corr}" + ); + } + + // ── Transformer embed() test ──────────────────────────────────────── + + #[test] + fn test_transformer_embed_shape() { + let t = CsiToPoseTransformer::new(small_config()); + let csi = make_csi(4, 16, 42); + let body_feats = t.embed(&csi); + assert_eq!(body_feats.len(), 17); + for f in &body_feats { + assert_eq!(f.len(), 8); // d_model = 8 + } + } +} diff --git a/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/graph_transformer.rs b/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/graph_transformer.rs index f4483ff..6c18ccc 100644 --- a/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/graph_transformer.rs +++ b/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/graph_transformer.rs @@ -486,6 +486,16 @@ impl CsiToPoseTransformer { } pub fn config(&self) -> &TransformerConfig { &self.config } + /// Extract body-part feature embeddings without regression heads. + /// Returns 17 vectors of dimension d_model (same as forward() but stops + /// before xyz_head/conf_head). + pub fn embed(&self, csi_features: &[Vec]) -> Vec> { + let embedded: Vec> = csi_features.iter() + .map(|f| self.csi_embed.forward(f)).collect(); + let attended = self.cross_attn.forward(&self.keypoint_queries, &embedded, &embedded); + self.gnn.forward(&attended) + } + /// Collect all trainable parameters into a flat vec. /// /// Layout: csi_embed | keypoint_queries (flat) | cross_attn | gnn | xyz_head | conf_head diff --git a/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/lib.rs b/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/lib.rs index 9ee67b5..9717fdb 100644 --- a/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/lib.rs +++ b/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/lib.rs @@ -12,3 +12,4 @@ pub mod trainer; pub mod dataset; pub mod sona; pub mod sparse_inference; +pub mod embedding; diff --git a/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/main.rs b/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/main.rs index 36e40bb..f8bbdea 100644 --- a/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/main.rs +++ b/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/main.rs @@ -13,7 +13,7 @@ mod rvf_pipeline; mod vital_signs; // Training pipeline modules (exposed via lib.rs) -use wifi_densepose_sensing_server::{graph_transformer, trainer, dataset}; +use wifi_densepose_sensing_server::{graph_transformer, trainer, dataset, embedding}; use std::collections::VecDeque; use std::net::SocketAddr; @@ -122,6 +122,22 @@ struct Args { /// Directory for training checkpoints #[arg(long, value_name = "DIR")] checkpoint_dir: Option, + + /// Run self-supervised contrastive pretraining (ADR-024) + #[arg(long)] + pretrain: bool, + + /// Number of pretraining epochs (default 50) + #[arg(long, default_value = "50")] + pretrain_epochs: usize, + + /// Extract embeddings mode: load model and extract CSI embeddings + #[arg(long)] + embed: bool, + + /// Build fingerprint index from embeddings (env|activity|temporal|person) + #[arg(long, value_name = "TYPE")] + build_index: Option, } // ── Data types ─────────────────────────────────────────────────────────────── @@ -1536,6 +1552,221 @@ async fn main() { return; } + // Handle --pretrain mode: self-supervised contrastive pretraining (ADR-024) + if args.pretrain { + eprintln!("=== WiFi-DensePose Contrastive Pretraining (ADR-024) ==="); + + let ds_path = args.dataset.clone().unwrap_or_else(|| PathBuf::from("data")); + let source = match args.dataset_type.as_str() { + "wipose" => dataset::DataSource::WiPose(ds_path.clone()), + _ => dataset::DataSource::MmFi(ds_path.clone()), + }; + let pipeline = dataset::DataPipeline::new(dataset::DataConfig { + source, ..Default::default() + }); + + // Generate synthetic or load real CSI windows + let generate_synthetic_windows = || -> Vec>> { + (0..50).map(|i| { + (0..4).map(|a| { + (0..56).map(|s| ((i * 7 + a * 13 + s) as f32 * 0.31).sin() * 0.5).collect() + }).collect() + }).collect() + }; + + let csi_windows: Vec>> = match pipeline.load() { + Ok(s) if !s.is_empty() => { + eprintln!("Loaded {} samples from {}", s.len(), ds_path.display()); + s.into_iter().map(|s| s.csi_window).collect() + } + _ => { + eprintln!("Using synthetic data for pretraining."); + generate_synthetic_windows() + } + }; + + let n_subcarriers = csi_windows.first() + .and_then(|w| w.first()) + .map(|f| f.len()) + .unwrap_or(56); + + let tf_config = graph_transformer::TransformerConfig { + n_subcarriers, n_keypoints: 17, d_model: 64, n_heads: 4, n_gnn_layers: 2, + }; + let transformer = graph_transformer::CsiToPoseTransformer::new(tf_config); + eprintln!("Transformer params: {}", transformer.param_count()); + + let trainer_config = trainer::TrainerConfig { + epochs: args.pretrain_epochs, + batch_size: 8, lr: 0.001, warmup_epochs: 2, min_lr: 1e-6, + early_stop_patience: args.pretrain_epochs + 1, + pretrain_temperature: 0.07, + ..Default::default() + }; + let mut t = trainer::Trainer::with_transformer(trainer_config, transformer); + + let e_config = embedding::EmbeddingConfig { + d_model: 64, d_proj: 128, temperature: 0.07, normalize: true, + }; + let mut projection = embedding::ProjectionHead::new(e_config.clone()); + let augmenter = embedding::CsiAugmenter::new(); + + eprintln!("Starting contrastive pretraining for {} epochs...", args.pretrain_epochs); + let start = std::time::Instant::now(); + for epoch in 0..args.pretrain_epochs { + let loss = t.pretrain_epoch(&csi_windows, &augmenter, &mut projection, 0.07, epoch); + if epoch % 10 == 0 || epoch == args.pretrain_epochs - 1 { + eprintln!(" Epoch {epoch}: contrastive loss = {loss:.4}"); + } + } + let elapsed = start.elapsed().as_secs_f64(); + eprintln!("Pretraining complete in {elapsed:.1}s"); + + // Save pretrained model as RVF with embedding segment + if let Some(ref save_path) = args.save_rvf { + eprintln!("Saving pretrained model to RVF: {}", save_path.display()); + t.sync_transformer_weights(); + let weights = t.params().to_vec(); + let mut proj_weights = Vec::new(); + projection.flatten_into(&mut proj_weights); + + let mut builder = RvfBuilder::new(); + builder.add_manifest( + "wifi-densepose-pretrained", + env!("CARGO_PKG_VERSION"), + "WiFi DensePose contrastive pretrained model (ADR-024)", + ); + builder.add_weights(&weights); + builder.add_embedding( + &serde_json::json!({ + "d_model": e_config.d_model, + "d_proj": e_config.d_proj, + "temperature": e_config.temperature, + "normalize": e_config.normalize, + "pretrain_epochs": args.pretrain_epochs, + }), + &proj_weights, + ); + match builder.write_to_file(save_path) { + Ok(()) => eprintln!("RVF saved ({} transformer + {} projection params)", + weights.len(), proj_weights.len()), + Err(e) => eprintln!("Failed to save RVF: {e}"), + } + } + + return; + } + + // Handle --embed mode: extract embeddings from CSI data + if args.embed { + eprintln!("=== WiFi-DensePose Embedding Extraction (ADR-024) ==="); + + let model_path = match &args.model { + Some(p) => p.clone(), + None => { + eprintln!("Error: --embed requires --model to a pretrained .rvf file"); + std::process::exit(1); + } + }; + + let reader = match RvfReader::from_file(&model_path) { + Ok(r) => r, + Err(e) => { eprintln!("Failed to load model: {e}"); std::process::exit(1); } + }; + + let weights = reader.weights().unwrap_or_default(); + let (embed_config_json, proj_weights) = reader.embedding().unwrap_or_else(|| { + eprintln!("Warning: no embedding segment in RVF, using defaults"); + (serde_json::json!({"d_model":64,"d_proj":128,"temperature":0.07,"normalize":true}), Vec::new()) + }); + + let d_model = embed_config_json["d_model"].as_u64().unwrap_or(64) as usize; + let d_proj = embed_config_json["d_proj"].as_u64().unwrap_or(128) as usize; + + let tf_config = graph_transformer::TransformerConfig { + n_subcarriers: 56, n_keypoints: 17, d_model, n_heads: 4, n_gnn_layers: 2, + }; + let e_config = embedding::EmbeddingConfig { + d_model, d_proj, temperature: 0.07, normalize: true, + }; + let mut extractor = embedding::EmbeddingExtractor::new(tf_config, e_config.clone()); + + // Load transformer weights + if !weights.is_empty() { + if let Err(e) = extractor.transformer.unflatten_weights(&weights) { + eprintln!("Warning: failed to load transformer weights: {e}"); + } + } + // Load projection weights + if !proj_weights.is_empty() { + let (proj, _) = embedding::ProjectionHead::unflatten_from(&proj_weights, &e_config); + extractor.projection = proj; + } + + // Load dataset and extract embeddings + let _ds_path = args.dataset.clone().unwrap_or_else(|| PathBuf::from("data")); + let csi_windows: Vec>> = (0..10).map(|i| { + (0..4).map(|a| { + (0..56).map(|s| ((i * 7 + a * 13 + s) as f32 * 0.31).sin() * 0.5).collect() + }).collect() + }).collect(); + + eprintln!("Extracting embeddings from {} CSI windows...", csi_windows.len()); + let embeddings = extractor.extract_batch(&csi_windows); + for (i, emb) in embeddings.iter().enumerate() { + let norm: f32 = emb.iter().map(|x| x * x).sum::().sqrt(); + eprintln!(" Window {i}: {d_proj}-dim embedding, ||e|| = {norm:.4}"); + } + eprintln!("Extracted {} embeddings of dimension {d_proj}", embeddings.len()); + + return; + } + + // Handle --build-index mode: build a fingerprint index from embeddings + if let Some(ref index_type_str) = args.build_index { + eprintln!("=== WiFi-DensePose Fingerprint Index Builder (ADR-024) ==="); + + let index_type = match index_type_str.as_str() { + "env" | "environment" => embedding::IndexType::EnvironmentFingerprint, + "activity" => embedding::IndexType::ActivityPattern, + "temporal" => embedding::IndexType::TemporalBaseline, + "person" => embedding::IndexType::PersonTrack, + _ => { + eprintln!("Unknown index type '{}'. Use: env, activity, temporal, person", index_type_str); + std::process::exit(1); + } + }; + + let tf_config = graph_transformer::TransformerConfig::default(); + let e_config = embedding::EmbeddingConfig::default(); + let extractor = embedding::EmbeddingExtractor::new(tf_config, e_config); + + // Generate synthetic CSI windows for demo + let csi_windows: Vec>> = (0..20).map(|i| { + (0..4).map(|a| { + (0..56).map(|s| ((i * 7 + a * 13 + s) as f32 * 0.31).sin() * 0.5).collect() + }).collect() + }).collect(); + + let mut index = embedding::FingerprintIndex::new(index_type); + for (i, window) in csi_windows.iter().enumerate() { + let emb = extractor.extract(window); + index.insert(emb, format!("window_{i}"), i as u64 * 100); + } + + eprintln!("Built {:?} index with {} entries", index_type, index.len()); + + // Test a query + let query_emb = extractor.extract(&csi_windows[0]); + let results = index.search(&query_emb, 5); + eprintln!("Top-5 nearest to window_0:"); + for r in &results { + eprintln!(" entry={}, distance={:.4}, metadata={}", r.entry, r.distance, r.metadata); + } + + return; + } + // Handle --train mode: train a model and exit if args.train { eprintln!("=== WiFi-DensePose Training Mode ==="); diff --git a/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/rvf_container.rs b/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/rvf_container.rs index 4b168f7..b1cc1cd 100644 --- a/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/rvf_container.rs +++ b/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/rvf_container.rs @@ -37,6 +37,8 @@ const SEG_META: u8 = 0x07; const SEG_WITNESS: u8 = 0x0A; /// Domain profile declarations. const SEG_PROFILE: u8 = 0x0B; +/// Contrastive embedding model weights and configuration (ADR-024). +pub const SEG_EMBED: u8 = 0x0C; // ── Pure-Rust CRC32 (IEEE 802.3 polynomial) ──────────────────────────────── @@ -304,6 +306,20 @@ impl RvfBuilder { self.push_segment(seg_type, payload); } + /// Add contrastive embedding config and projection head weights (ADR-024). + /// Serializes embedding config as JSON followed by projection weights as f32 LE. + pub fn add_embedding(&mut self, config_json: &serde_json::Value, proj_weights: &[f32]) { + let config_bytes = serde_json::to_vec(config_json).unwrap_or_default(); + let config_len = config_bytes.len() as u32; + let mut payload = Vec::with_capacity(4 + config_bytes.len() + proj_weights.len() * 4); + payload.extend_from_slice(&config_len.to_le_bytes()); + payload.extend_from_slice(&config_bytes); + for &w in proj_weights { + payload.extend_from_slice(&w.to_le_bytes()); + } + self.push_segment(SEG_EMBED, &payload); + } + /// Add witness/proof data as a Witness segment. pub fn add_witness(&mut self, training_hash: &str, metrics: &serde_json::Value) { let witness = serde_json::json!({ @@ -528,6 +544,28 @@ impl RvfReader { .and_then(|data| serde_json::from_slice(data).ok()) } + /// Parse and return the embedding config JSON and projection weights, if present. + pub fn embedding(&self) -> Option<(serde_json::Value, Vec)> { + let data = self.find_segment(SEG_EMBED)?; + if data.len() < 4 { + return None; + } + let config_len = u32::from_le_bytes([data[0], data[1], data[2], data[3]]) as usize; + if 4 + config_len > data.len() { + return None; + } + let config: serde_json::Value = serde_json::from_slice(&data[4..4 + config_len]).ok()?; + let weight_data = &data[4 + config_len..]; + if weight_data.len() % 4 != 0 { + return None; + } + let weights: Vec = weight_data + .chunks_exact(4) + .map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]])) + .collect(); + Some((config, weights)) + } + /// Number of segments in the container. pub fn segment_count(&self) -> usize { self.segments.len() @@ -911,4 +949,33 @@ mod tests { assert!(!info.has_quant_info); assert!(!info.has_witness); } + + #[test] + fn test_rvf_embedding_segment_roundtrip() { + let config = serde_json::json!({ + "d_model": 64, + "d_proj": 128, + "temperature": 0.07, + "normalize": true, + }); + let weights: Vec = (0..256).map(|i| (i as f32 * 0.13).sin()).collect(); + + let mut builder = RvfBuilder::new(); + builder.add_manifest("embed-test", "1.0", "embedding test"); + builder.add_embedding(&config, &weights); + let data = builder.build(); + + let reader = RvfReader::from_bytes(&data).unwrap(); + assert_eq!(reader.segment_count(), 2); + + let (decoded_config, decoded_weights) = reader.embedding() + .expect("embedding segment should be present"); + assert_eq!(decoded_config["d_model"], 64); + assert_eq!(decoded_config["d_proj"], 128); + assert!((decoded_config["temperature"].as_f64().unwrap() - 0.07).abs() < 1e-4); + assert_eq!(decoded_weights.len(), weights.len()); + for (a, b) in decoded_weights.iter().zip(weights.iter()) { + assert_eq!(a.to_bits(), b.to_bits(), "weight mismatch"); + } + } } diff --git a/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/trainer.rs b/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/trainer.rs index e06b777..e470df0 100644 --- a/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/trainer.rs +++ b/rust-port/wifi-densepose-rs/crates/wifi-densepose-sensing-server/src/trainer.rs @@ -6,6 +6,7 @@ use std::path::Path; use crate::graph_transformer::{CsiToPoseTransformer, TransformerConfig}; +use crate::embedding::{CsiAugmenter, ProjectionHead, info_nce_loss}; use crate::dataset; /// Standard COCO keypoint sigmas for OKS (17 keypoints). @@ -18,7 +19,7 @@ pub const COCO_KEYPOINT_SIGMAS: [f32; 17] = [ const SYMMETRY_PAIRS: [(usize, usize); 5] = [(5, 6), (7, 8), (9, 10), (11, 12), (13, 14)]; -/// Individual loss terms from the 6-component composite loss. +/// Individual loss terms from the composite loss (6 supervised + 1 contrastive). #[derive(Debug, Clone, Default)] pub struct LossComponents { pub keypoint: f32, @@ -27,6 +28,8 @@ pub struct LossComponents { pub temporal: f32, pub edge: f32, pub symmetry: f32, + /// Contrastive loss (InfoNCE); only active during pretraining or when configured. + pub contrastive: f32, } /// Per-term weights for the composite loss function. @@ -38,11 +41,16 @@ pub struct LossWeights { pub temporal: f32, pub edge: f32, pub symmetry: f32, + /// Contrastive loss weight (default 0.0; set >0 for joint training). + pub contrastive: f32, } impl Default for LossWeights { fn default() -> Self { - Self { keypoint: 1.0, body_part: 0.5, uv: 0.5, temporal: 0.1, edge: 0.2, symmetry: 0.1 } + Self { + keypoint: 1.0, body_part: 0.5, uv: 0.5, temporal: 0.1, + edge: 0.2, symmetry: 0.1, contrastive: 0.0, + } } } @@ -124,6 +132,7 @@ pub fn symmetry_loss(kp: &[(f32, f32, f32)]) -> f32 { pub fn composite_loss(c: &LossComponents, w: &LossWeights) -> f32 { w.keypoint * c.keypoint + w.body_part * c.body_part + w.uv * c.uv + w.temporal * c.temporal + w.edge * c.edge + w.symmetry * c.symmetry + + w.contrastive * c.contrastive } // ── Optimizer ────────────────────────────────────────────────────────────── @@ -374,6 +383,10 @@ pub struct TrainerConfig { pub early_stop_patience: usize, pub checkpoint_every: usize, pub loss_weights: LossWeights, + /// Contrastive loss weight for joint supervised+contrastive training (default 0.0). + pub contrastive_loss_weight: f32, + /// Temperature for InfoNCE loss during pretraining (default 0.07). + pub pretrain_temperature: f32, } impl Default for TrainerConfig { @@ -382,6 +395,8 @@ impl Default for TrainerConfig { epochs: 100, batch_size: 32, lr: 0.01, momentum: 0.9, weight_decay: 1e-4, warmup_epochs: 5, min_lr: 1e-6, early_stop_patience: 10, checkpoint_every: 10, loss_weights: LossWeights::default(), + contrastive_loss_weight: 0.0, + pretrain_temperature: 0.07, } } } @@ -546,6 +561,131 @@ impl Trainer { } } + /// Run one self-supervised pretraining epoch using SimCLR objective. + /// Does NOT require pose labels -- only CSI windows. + /// + /// For each mini-batch: + /// 1. Generate augmented pair (view_a, view_b) for each window + /// 2. Forward each view through transformer to get body_part_features + /// 3. Mean-pool to get frame embedding + /// 4. Project through ProjectionHead + /// 5. Compute InfoNCE loss + /// 6. Estimate gradients via central differences and SGD update + /// + /// Returns mean epoch loss. + pub fn pretrain_epoch( + &mut self, + csi_windows: &[Vec>], + augmenter: &CsiAugmenter, + projection: &mut ProjectionHead, + temperature: f32, + epoch: usize, + ) -> f32 { + if csi_windows.is_empty() { + return 0.0; + } + let lr = self.scheduler.get_lr(epoch); + self.optimizer.set_lr(lr); + + let bs = self.config.batch_size.max(1); + let nb = (csi_windows.len() + bs - 1) / bs; + let mut total_loss = 0.0f32; + + let tc = self.transformer_config.clone(); + let tc_ref = match &tc { + Some(c) => c, + None => return 0.0, // pretraining requires a transformer + }; + + for bi in 0..nb { + let start = bi * bs; + let end = (start + bs).min(csi_windows.len()); + let batch = &csi_windows[start..end]; + + // Generate augmented pairs and compute embeddings + loss + let snap = self.params.clone(); + let mut proj_flat = Vec::new(); + projection.flatten_into(&mut proj_flat); + + // Combined params: transformer + projection head + let mut combined = snap.clone(); + combined.extend_from_slice(&proj_flat); + + let t_param_count = snap.len(); + let p_config = projection.config.clone(); + let tc_c = tc_ref.clone(); + let temp = temperature; + + // Build augmented views for the batch + let seed_base = (epoch * 10000 + bi) as u64; + let aug_pairs: Vec<_> = batch.iter().enumerate() + .map(|(k, w)| augmenter.augment_pair(w, seed_base + k as u64)) + .collect(); + + // Loss function over combined (transformer + projection) params + let batch_owned: Vec>> = batch.to_vec(); + let loss_fn = |params: &[f32]| -> f32 { + let t_params = ¶ms[..t_param_count]; + let p_params = ¶ms[t_param_count..]; + let mut t = CsiToPoseTransformer::zeros(tc_c.clone()); + if t.unflatten_weights(t_params).is_err() { + return f32::MAX; + } + let (proj, _) = ProjectionHead::unflatten_from(p_params, &p_config); + let d = p_config.d_model; + + let mut embs_a = Vec::with_capacity(batch_owned.len()); + let mut embs_b = Vec::with_capacity(batch_owned.len()); + + for (k, _w) in batch_owned.iter().enumerate() { + let (ref va, ref vb) = aug_pairs[k]; + // Mean-pool body features for view A + let feats_a = t.embed(va); + let mut pooled_a = vec![0.0f32; d]; + for f in &feats_a { + for (p, &v) in pooled_a.iter_mut().zip(f.iter()) { *p += v; } + } + let n = feats_a.len() as f32; + if n > 0.0 { for p in pooled_a.iter_mut() { *p /= n; } } + embs_a.push(proj.forward(&pooled_a)); + + // Mean-pool body features for view B + let feats_b = t.embed(vb); + let mut pooled_b = vec![0.0f32; d]; + for f in &feats_b { + for (p, &v) in pooled_b.iter_mut().zip(f.iter()) { *p += v; } + } + let n = feats_b.len() as f32; + if n > 0.0 { for p in pooled_b.iter_mut() { *p /= n; } } + embs_b.push(proj.forward(&pooled_b)); + } + + info_nce_loss(&embs_a, &embs_b, temp) + }; + + let batch_loss = loss_fn(&combined); + total_loss += batch_loss; + + // Estimate gradient via central differences on combined params + let mut grad = estimate_gradient(&loss_fn, &combined, 1e-4); + clip_gradients(&mut grad, 1.0); + + // Update transformer params + self.optimizer.step(&mut self.params, &grad[..t_param_count]); + + // Update projection head params + let mut proj_params = proj_flat.clone(); + // Simple SGD for projection head + for i in 0..proj_params.len().min(grad.len() - t_param_count) { + proj_params[i] -= lr * grad[t_param_count + i]; + } + let (new_proj, _) = ProjectionHead::unflatten_from(&proj_params, &projection.config); + *projection = new_proj; + } + + total_loss / nb as f32 + } + pub fn checkpoint(&self) -> Checkpoint { let m = self.history.last().map(|s| s.to_serializable()).unwrap_or( EpochStatsSerializable { @@ -713,11 +853,11 @@ mod tests { assert!(graph_edge_loss(&kp, &[(0,1),(1,2)], &[5.0, 5.0]) < 1e-6); } #[test] fn composite_loss_respects_weights() { - let c = LossComponents { keypoint:1.0, body_part:1.0, uv:1.0, temporal:1.0, edge:1.0, symmetry:1.0 }; - let w1 = LossWeights { keypoint:1.0, body_part:0.0, uv:0.0, temporal:0.0, edge:0.0, symmetry:0.0 }; - let w2 = LossWeights { keypoint:2.0, body_part:0.0, uv:0.0, temporal:0.0, edge:0.0, symmetry:0.0 }; + let c = LossComponents { keypoint:1.0, body_part:1.0, uv:1.0, temporal:1.0, edge:1.0, symmetry:1.0, contrastive:0.0 }; + let w1 = LossWeights { keypoint:1.0, body_part:0.0, uv:0.0, temporal:0.0, edge:0.0, symmetry:0.0, contrastive:0.0 }; + let w2 = LossWeights { keypoint:2.0, body_part:0.0, uv:0.0, temporal:0.0, edge:0.0, symmetry:0.0, contrastive:0.0 }; assert!((composite_loss(&c, &w2) - 2.0 * composite_loss(&c, &w1)).abs() < 1e-6); - let wz = LossWeights { keypoint:0.0, body_part:0.0, uv:0.0, temporal:0.0, edge:0.0, symmetry:0.0 }; + let wz = LossWeights { keypoint:0.0, body_part:0.0, uv:0.0, temporal:0.0, edge:0.0, symmetry:0.0, contrastive:0.0 }; assert_eq!(composite_loss(&c, &wz), 0.0); } #[test] fn cosine_scheduler_starts_at_initial() { @@ -878,4 +1018,61 @@ mod tests { } } } + + #[test] + fn test_pretrain_epoch_loss_decreases() { + use crate::graph_transformer::{CsiToPoseTransformer, TransformerConfig}; + use crate::embedding::{CsiAugmenter, ProjectionHead, EmbeddingConfig}; + + let tf_config = TransformerConfig { + n_subcarriers: 8, n_keypoints: 17, d_model: 8, n_heads: 2, n_gnn_layers: 1, + }; + let transformer = CsiToPoseTransformer::new(tf_config); + let config = TrainerConfig { + epochs: 10, batch_size: 4, lr: 0.001, + warmup_epochs: 0, early_stop_patience: 100, + pretrain_temperature: 0.5, + ..Default::default() + }; + let mut trainer = Trainer::with_transformer(config, transformer); + + let e_config = EmbeddingConfig { + d_model: 8, d_proj: 16, temperature: 0.5, normalize: true, + }; + let mut projection = ProjectionHead::new(e_config); + let augmenter = CsiAugmenter::new(); + + // Synthetic CSI windows (8 windows, each 4 frames of 8 subcarriers) + let csi_windows: Vec>> = (0..8).map(|i| { + (0..4).map(|a| { + (0..8).map(|s| ((i * 7 + a * 3 + s) as f32 * 0.41).sin() * 0.5).collect() + }).collect() + }).collect(); + + let loss_0 = trainer.pretrain_epoch(&csi_windows, &augmenter, &mut projection, 0.5, 0); + let loss_1 = trainer.pretrain_epoch(&csi_windows, &augmenter, &mut projection, 0.5, 1); + let loss_2 = trainer.pretrain_epoch(&csi_windows, &augmenter, &mut projection, 0.5, 2); + + assert!(loss_0.is_finite(), "epoch 0 loss should be finite: {loss_0}"); + assert!(loss_1.is_finite(), "epoch 1 loss should be finite: {loss_1}"); + assert!(loss_2.is_finite(), "epoch 2 loss should be finite: {loss_2}"); + // Loss should generally decrease (or at least the final loss should be less than initial) + assert!( + loss_2 <= loss_0 + 0.5, + "loss should not increase drastically: epoch0={loss_0}, epoch2={loss_2}" + ); + } + + #[test] + fn test_contrastive_loss_weight_in_composite() { + let c = LossComponents { + keypoint: 0.0, body_part: 0.0, uv: 0.0, + temporal: 0.0, edge: 0.0, symmetry: 0.0, contrastive: 1.0, + }; + let w = LossWeights { + keypoint: 0.0, body_part: 0.0, uv: 0.0, + temporal: 0.0, edge: 0.0, symmetry: 0.0, contrastive: 0.5, + }; + assert!((composite_loss(&c, &w) - 0.5).abs() < 1e-6); + } }