dearsky/wifi-densepose
1
0
Fork 0
Code Issues 20 Pull Requests 5 Actions Packages Projects Releases 1 Wiki Activity

fix: harden MERIDIAN modules from code review + security audit

Browse Source 
- domain.rs: atomic instance counter for unique Linear weight seeds (C3)
- rapid_adapt.rs: adapt() returns Result instead of panicking (C5),
  bounded calibration buffer with max_buffer_frames cap (F1-HIGH),
  validate lora_rank >= 1 (F10)
- geometry.rs: 24-bit PRNG precision matching f32 mantissa (C2)
- virtual_aug.rs: guard against room_scale=0 division-by-zero (F6)
- signal/lib.rs: re-export AmplitudeStats from hardware_norm (W1)
- train/lib.rs: crate-root re-exports for all MERIDIAN types (W2)

All 201 tests pass (96 unit + 24 integration + 18 subcarrier +
10 metrics + 7 doctests + 105 signal + 10 validation + 1 signal doctest).

Co-Authored-By: claude-flow <ruv@ruv.net>
This commit is contained in:
ruv
2026-03-01 12:11:56 -05:00
parent 2d6dc66f7c
commit 8da6767273
6 changed files with 99 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
rust-port/wifi-densepose-rs/crates/wifi-densepose-signal/src/lib.rs
View File

@@ -56,7 +56,7 @@ pub use motion::{
HumanDetectionResult, MotionAnalysis, MotionDetector, MotionDetectorConfig, MotionScore,
};
pub use hardware_norm::{
CanonicalCsiFrame, HardwareNormError, HardwareNormalizer, HardwareType,
AmplitudeStats, CanonicalCsiFrame, HardwareNormError, HardwareNormalizer, HardwareType,
};
pub use phase_sanitizer::{
PhaseSanitizationError, PhaseSanitizer, PhaseSanitizerConfig, UnwrappingMethod,

10
rust-port/wifi-densepose-rs/crates/wifi-densepose-train/src/domain.rs
View File

@@ -61,14 +61,22 @@ pub struct Linear {
pub out_features: usize,
}
/// Global instance counter to ensure distinct seeds for layers with same dimensions.
static INSTANCE_COUNTER: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
impl Linear {
/// New layer with deterministic Kaiming-uniform weights.
///
/// Each call produces unique weights even for identical `(in_features, out_features)`
/// because an atomic instance counter is mixed into the seed.
pub fn new(in_features: usize, out_features: usize) -> Self {
let instance = INSTANCE_COUNTER.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let bound = (1.0 / in_features as f64).sqrt() as f32;
let n = out_features * in_features;
let mut seed: u64 = (in_features as u64)
.wrapping_mul(6364136223846793005)
.wrapping_add(out_features as u64);
.wrapping_add(out_features as u64)
.wrapping_add(instance.wrapping_mul(2654435761));
let mut next = || -> f32 {
seed = seed.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
((seed >> 33) as f32) / (u32::MAX as f32 / 2.0) - 1.0

3
rust-port/wifi-densepose-rs/crates/wifi-densepose-train/src/geometry.rs
View File

@@ -50,6 +50,7 @@ impl Linear {
}
/// Deterministic xorshift64 uniform in `[lo, hi)`.
/// Uses 24-bit precision (matching f32 mantissa) for uniform distribution.
fn det_uniform(n: usize, lo: f32, hi: f32, seed: u64) -> Vec<f32> {
let r = hi - lo;
let mut s = seed.wrapping_add(0x9E37_79B9_7F4A_7C15);
@@ -58,7 +59,7 @@ fn det_uniform(n: usize, lo: f32, hi: f32, seed: u64) -> Vec<f32> {
s ^= s << 13;
s ^= s >> 7;
s ^= s << 17;
lo + (s >> 11) as f32 / (1u64 << 53) as f32 * r
lo + (s >> 40) as f32 / (1u64 << 24) as f32 * r
})
.collect()
}

9
rust-port/wifi-densepose-rs/crates/wifi-densepose-train/src/lib.rs
View File

@@ -77,5 +77,14 @@ pub use error::{ConfigError, DatasetError, SubcarrierError, TrainError};
pub use error::TrainResult as TrainResultAlias;
pub use subcarrier::{compute_interp_weights, interpolate_subcarriers, select_subcarriers_by_variance};
// MERIDIAN (ADR-027) re-exports.
pub use domain::{
AdversarialSchedule, DomainClassifier, DomainFactorizer, GradientReversalLayer,
};
pub use eval::CrossDomainEvaluator;
pub use geometry::{FilmLayer, FourierPositionalEncoding, GeometryEncoder, MeridianGeometryConfig};
pub use rapid_adapt::{AdaptError, AdaptationLoss, AdaptationResult, RapidAdaptation};
pub use virtual_aug::VirtualDomainAugmentor;
/// Crate version string.
pub const VERSION: &str = env!("CARGO_PKG_VERSION");

90
rust-port/wifi-densepose-rs/crates/wifi-densepose-train/src/rapid_adapt.rs
View File

@@ -49,10 +49,37 @@ pub struct AdaptationResult {
pub adaptation_epochs: usize,
}
/// Error type for rapid adaptation.
#[derive(Debug, Clone)]
pub enum AdaptError {
/// Not enough calibration frames.
InsufficientFrames {
/// Frames currently buffered.
have: usize,
/// Minimum required.
need: usize,
},
/// LoRA rank must be at least 1.
InvalidRank,
}
impl std::fmt::Display for AdaptError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::InsufficientFrames { have, need } =>
write!(f, "insufficient calibration frames: have {have}, need at least {need}"),
Self::InvalidRank => write!(f, "lora_rank must be >= 1"),
}
}
}
impl std::error::Error for AdaptError {}
/// Few-shot rapid adaptation engine.
///
/// Accumulates unlabeled CSI calibration frames and runs test-time training
/// to produce LoRA weight deltas.
/// to produce LoRA weight deltas. Buffer is capped at `max_buffer_frames`
/// (default 10 000) to prevent unbounded memory growth.
///
/// ```rust
/// use wifi_densepose_train::rapid_adapt::{RapidAdaptation, AdaptationLoss};
@@ -60,26 +87,36 @@ pub struct AdaptationResult {
/// let mut ra = RapidAdaptation::new(10, 4, loss);
/// for i in 0..10 { ra.push_frame(&vec![i as f32; 8]); }
/// assert!(ra.is_ready());
/// let r = ra.adapt();
/// let r = ra.adapt().unwrap();
/// assert_eq!(r.frames_used, 10);
/// ```
pub struct RapidAdaptation {
/// Minimum frames before adaptation (default 200 = 10 s @ 20 Hz).
pub min_calibration_frames: usize,
/// LoRA factorization rank (default 4).
/// LoRA factorization rank (must be >= 1).
pub lora_rank: usize,
/// Loss variant for test-time training.
pub adaptation_loss: AdaptationLoss,
/// Maximum buffer size (ring-buffer eviction beyond this cap).
pub max_buffer_frames: usize,
calibration_buffer: Vec<Vec<f32>>,
}
/// Default maximum calibration buffer size.
const DEFAULT_MAX_BUFFER: usize = 10_000;
impl RapidAdaptation {
/// Create a new adaptation engine.
pub fn new(min_calibration_frames: usize, lora_rank: usize, adaptation_loss: AdaptationLoss) -> Self {
Self { min_calibration_frames, lora_rank, adaptation_loss, calibration_buffer: Vec::new() }
Self { min_calibration_frames, lora_rank, adaptation_loss, max_buffer_frames: DEFAULT_MAX_BUFFER, calibration_buffer: Vec::new() }
}
/// Push a single unlabeled CSI frame. Evicts oldest frame when buffer is full.
pub fn push_frame(&mut self, frame: &[f32]) {
if self.calibration_buffer.len() >= self.max_buffer_frames {
self.calibration_buffer.remove(0);
}
self.calibration_buffer.push(frame.to_vec());
}
/// Push a single unlabeled CSI frame.
pub fn push_frame(&mut self, frame: &[f32]) { self.calibration_buffer.push(frame.to_vec()); }
/// True when buffer >= min_calibration_frames.
pub fn is_ready(&self) -> bool { self.calibration_buffer.len() >= self.min_calibration_frames }
/// Number of buffered frames.
@@ -87,10 +124,14 @@ impl RapidAdaptation {
/// Run test-time adaptation producing LoRA weight deltas.
///
/// # Panics
/// Panics if the calibration buffer is empty.
pub fn adapt(&self) -> AdaptationResult {
assert!(!self.calibration_buffer.is_empty(), "empty calibration buffer");
/// Returns an error if the calibration buffer is empty or lora_rank is 0.
pub fn adapt(&self) -> Result<AdaptationResult, AdaptError> {
if self.calibration_buffer.is_empty() {
return Err(AdaptError::InsufficientFrames { have: 0, need: 1 });
}
if self.lora_rank == 0 {
return Err(AdaptError::InvalidRank);
}
let (n, fdim) = (self.calibration_buffer.len(), self.calibration_buffer[0].len());
let lora_sz = 2 * fdim * self.lora_rank;
let mut w = vec![0.01_f32; lora_sz];
@@ -112,7 +153,7 @@ impl RapidAdaptation {
for (wi, gi) in w.iter_mut().zip(g.iter()) { *wi -= lr * gi; }
final_loss = loss;
}
AdaptationResult { lora_weights: w, final_loss, frames_used: n, adaptation_epochs: epochs }
Ok(AdaptationResult { lora_weights: w, final_loss, frames_used: n, adaptation_epochs: epochs })
}
fn contrastive_step(&self, w: &[f32], fdim: usize, grad: &mut [f32]) -> f32 {
@@ -207,7 +248,7 @@ mod tests {
let (fdim, rank) = (16, 4);
let mut a = RapidAdaptation::new(10, rank, AdaptationLoss::ContrastiveTTT { epochs: 3, lr: 0.01 });
for i in 0..10 { a.push_frame(&vec![i as f32 * 0.1; fdim]); }
let r = a.adapt();
let r = a.adapt().unwrap();
assert_eq!(r.lora_weights.len(), 2 * fdim * rank);
assert_eq!(r.frames_used, 10);
assert_eq!(r.adaptation_epochs, 3);
@@ -219,7 +260,7 @@ mod tests {
let mk = |ep| {
let mut a = RapidAdaptation::new(20, rank, AdaptationLoss::ContrastiveTTT { epochs: ep, lr: 0.01 });
for i in 0..20 { let v = i as f32 * 0.1; a.push_frame(&(0..fdim).map(|d| v + d as f32 * 0.01).collect::<Vec<_>>()); }
a.adapt().final_loss
a.adapt().unwrap().final_loss
};
assert!(mk(10) <= mk(1) + 1e-6, "10 epochs should yield <= 1 epoch loss");
}
@@ -229,7 +270,7 @@ mod tests {
let (fdim, rank) = (16, 4);
let mut a = RapidAdaptation::new(10, rank, AdaptationLoss::Combined { epochs: 5, lr: 0.001, lambda_ent: 0.5 });
for i in 0..10 { a.push_frame(&(0..fdim).map(|d| ((i * fdim + d) as f32).sin()).collect::<Vec<_>>()); }
let r = a.adapt();
let r = a.adapt().unwrap();
assert_eq!(r.frames_used, 10);
assert_eq!(r.adaptation_epochs, 5);
assert!(r.final_loss.is_finite());
@@ -237,6 +278,27 @@ mod tests {
assert!(r.lora_weights.iter().all(|w| w.is_finite()));
}
#[test]
fn adapt_empty_buffer_returns_error() {
let a = RapidAdaptation::new(10, 4, AdaptationLoss::ContrastiveTTT { epochs: 1, lr: 0.01 });
assert!(a.adapt().is_err());
}
#[test]
fn adapt_zero_rank_returns_error() {
let mut a = RapidAdaptation::new(1, 0, AdaptationLoss::ContrastiveTTT { epochs: 1, lr: 0.01 });
a.push_frame(&[1.0, 2.0]);
assert!(a.adapt().is_err());
}
#[test]
fn buffer_cap_evicts_oldest() {
let mut a = RapidAdaptation::new(2, 4, AdaptationLoss::ContrastiveTTT { epochs: 1, lr: 0.01 });
a.max_buffer_frames = 3;
for i in 0..5 { a.push_frame(&[i as f32]); }
assert_eq!(a.buffer_len(), 3);
}
#[test]
fn l2_distance_tests() {
assert!(l2_dist(&[1.0, 2.0, 3.0], &[1.0, 2.0, 3.0]).abs() < 1e-10);

4
rust-port/wifi-densepose-rs/crates/wifi-densepose-train/src/virtual_aug.rs
View File

@@ -149,8 +149,8 @@ impl VirtualDomainAugmentor {
let mut out = Vec::with_capacity(n);
for (k, &val) in frame.iter().enumerate() {
let k_f = k as f32;
// 1. Room-scale amplitude attenuation
let scaled = val / domain.room_scale;
// 1. Room-scale amplitude attenuation (guard against zero scale)
let scaled = if domain.room_scale.abs() < 1e-10 { val } else { val / domain.room_scale };
// 2. Reflection coefficient modulation (per-subcarrier)
let refl = domain.reflection_coeff
+ (1.0 - domain.reflection_coeff) * (PI * k_f / n_f).cos();