Buckets:
| # WiFi DensePose Implementation - Core Architecture (NumPy-based prototype) | |
| # Based on "DensePose From WiFi" by Carnegie Mellon University | |
| import numpy as np | |
| import math | |
| from typing import Dict, List, Tuple, Optional | |
| from collections import OrderedDict | |
| import json | |
| class CSIPhaseProcessor: | |
| """ | |
| Processes raw CSI phase data through unwrapping, filtering, and linear fitting | |
| Based on the phase sanitization methodology from the paper | |
| """ | |
| def __init__(self, num_subcarriers: int = 30): | |
| self.num_subcarriers = num_subcarriers | |
| print(f"Initialized CSI Phase Processor with {num_subcarriers} subcarriers") | |
| def unwrap_phase(self, phase_data: np.ndarray) -> np.ndarray: | |
| """ | |
| Unwrap phase values to handle discontinuities | |
| """ | |
| unwrapped = np.copy(phase_data) | |
| for i in range(1, phase_data.shape[1]): # Along frequency dimension | |
| diff = unwrapped[:, i] - unwrapped[:, i-1] | |
| # Apply unwrapping logic | |
| unwrapped[:, i] = np.where(diff > np.pi, | |
| unwrapped[:, i-1] + diff - 2*np.pi, | |
| unwrapped[:, i]) | |
| unwrapped[:, i] = np.where(diff < -np.pi, | |
| unwrapped[:, i-1] + diff + 2*np.pi, | |
| unwrapped[:, i]) | |
| return unwrapped | |
| def apply_filters(self, phase_data: np.ndarray) -> np.ndarray: | |
| """ | |
| Apply median and uniform filters to eliminate outliers | |
| """ | |
| filtered = np.copy(phase_data) | |
| # Apply simple smoothing in time dimension | |
| for i in range(1, phase_data.shape[0]-1): | |
| filtered[i] = (phase_data[i-1] + phase_data[i] + phase_data[i+1]) / 3 | |
| # Apply smoothing in frequency dimension | |
| for i in range(1, phase_data.shape[1]-1): | |
| filtered[:, i] = (filtered[:, i-1] + filtered[:, i] + filtered[:, i+1]) / 3 | |
| return filtered | |
| def linear_fitting(self, phase_data: np.ndarray) -> np.ndarray: | |
| """ | |
| Apply linear fitting to remove systematic phase drift | |
| """ | |
| fitted_data = np.copy(phase_data) | |
| F = self.num_subcarriers | |
| for sample_idx in range(phase_data.shape[0]): | |
| for ant_i in range(phase_data.shape[2]): | |
| for ant_j in range(phase_data.shape[3]): | |
| phase_seq = phase_data[sample_idx, :, ant_i, ant_j] | |
| # Calculate linear coefficients | |
| alpha1 = (phase_seq[-1] - phase_seq[0]) / (2 * np.pi * F) | |
| alpha0 = np.mean(phase_seq) | |
| # Apply linear fitting | |
| frequencies = np.arange(1, F + 1) | |
| linear_trend = alpha1 * frequencies + alpha0 | |
| fitted_data[sample_idx, :, ant_i, ant_j] = phase_seq - linear_trend | |
| return fitted_data | |
| def sanitize_phase(self, raw_phase: np.ndarray) -> np.ndarray: | |
| """ | |
| Complete phase sanitization pipeline | |
| """ | |
| print("Sanitizing CSI phase data...") | |
| print(f"Input shape: {raw_phase.shape}") | |
| # Step 1: Unwrap phase | |
| unwrapped = self.unwrap_phase(raw_phase) | |
| print("✓ Phase unwrapping completed") | |
| # Step 2: Apply filters | |
| filtered = self.apply_filters(unwrapped) | |
| print("✓ Filtering completed") | |
| # Step 3: Linear fitting | |
| sanitized = self.linear_fitting(filtered) | |
| print("✓ Linear fitting completed") | |
| return sanitized | |
| class WiFiDensePoseConfig: | |
| """ | |
| Configuration class for WiFi DensePose system | |
| """ | |
| def __init__(self): | |
| # Hardware configuration | |
| self.num_transmitters = 3 | |
| self.num_receivers = 3 | |
| self.num_subcarriers = 30 | |
| self.sampling_rate = 100 # Hz | |
| self.consecutive_samples = 5 | |
| # Network configuration | |
| self.input_amplitude_shape = (150, 3, 3) # 5 samples * 30 frequencies, 3x3 antennas | |
| self.input_phase_shape = (150, 3, 3) | |
| self.output_feature_shape = (3, 720, 1280) # Image-like feature map | |
| # DensePose configuration | |
| self.num_body_parts = 24 | |
| self.num_keypoints = 17 | |
| self.keypoint_heatmap_size = (56, 56) | |
| self.uv_map_size = (112, 112) | |
| # Training configuration | |
| self.learning_rate = 1e-3 | |
| self.batch_size = 16 | |
| self.num_epochs = 145000 | |
| self.lambda_dp = 0.6 # DensePose loss weight | |
| self.lambda_kp = 0.3 # Keypoint loss weight | |
| self.lambda_tr = 0.1 # Transfer learning loss weight | |
| class WiFiDataSimulator: | |
| """ | |
| Simulates WiFi CSI data for demonstration purposes | |
| """ | |
| def __init__(self, config: WiFiDensePoseConfig): | |
| self.config = config | |
| np.random.seed(42) # For reproducibility | |
| def generate_csi_sample(self, num_people: int = 1, movement_intensity: float = 1.0) -> Tuple[np.ndarray, np.ndarray]: | |
| """ | |
| Generate simulated CSI amplitude and phase data | |
| """ | |
| # Base CSI signal (environment) | |
| amplitude = np.ones(self.config.input_amplitude_shape) * 50 # Base signal strength | |
| phase = np.zeros(self.config.input_phase_shape) | |
| # Add noise | |
| amplitude += np.random.normal(0, 5, self.config.input_amplitude_shape) | |
| phase += np.random.normal(0, 0.1, self.config.input_phase_shape) | |
| # Simulate human presence effects | |
| for person in range(num_people): | |
| # Random position effects | |
| pos_x = np.random.uniform(0.2, 0.8) | |
| pos_y = np.random.uniform(0.2, 0.8) | |
| # Create interference patterns | |
| for tx in range(3): | |
| for rx in range(3): | |
| # Distance-based attenuation | |
| distance = np.sqrt((tx/2 - pos_x)**2 + (rx/2 - pos_y)**2) | |
| attenuation = movement_intensity * np.exp(-distance * 2) | |
| # Frequency-dependent effects | |
| for freq in range(30): | |
| freq_effect = np.sin(2 * np.pi * freq / 30 + person * np.pi/2) | |
| # Amplitude effects | |
| for sample in range(5): | |
| sample_idx = sample * 30 + freq | |
| amplitude[sample_idx, tx, rx] *= (1 - attenuation * 0.3 * freq_effect) | |
| # Phase effects | |
| for sample in range(5): | |
| sample_idx = sample * 30 + freq | |
| phase[sample_idx, tx, rx] += attenuation * freq_effect * movement_intensity | |
| return amplitude, phase | |
| def generate_ground_truth_poses(self, num_people: int = 1) -> Dict: | |
| """ | |
| Generate simulated ground truth pose data | |
| """ | |
| poses = [] | |
| for person in range(num_people): | |
| # Simulate a person's bounding box | |
| x = np.random.uniform(100, 620) # Within 720px width | |
| y = np.random.uniform(100, 1180) # Within 1280px height | |
| w = np.random.uniform(80, 200) | |
| h = np.random.uniform(150, 400) | |
| # Simulate keypoints (17 COCO keypoints) | |
| keypoints = [] | |
| for kp in range(17): | |
| kp_x = x + np.random.uniform(-w/4, w/4) | |
| kp_y = y + np.random.uniform(-h/4, h/4) | |
| confidence = np.random.uniform(0.7, 1.0) | |
| keypoints.extend([kp_x, kp_y, confidence]) | |
| poses.append({ | |
| 'bbox': [x, y, w, h], | |
| 'keypoints': keypoints, | |
| 'person_id': person | |
| }) | |
| return {'poses': poses, 'num_people': num_people} | |
| # Initialize the system | |
| config = WiFiDensePoseConfig() | |
| phase_processor = CSIPhaseProcessor(config.num_subcarriers) | |
| data_simulator = WiFiDataSimulator(config) | |
| print("WiFi DensePose System Initialized!") | |
| print(f"Configuration:") | |
| print(f" - Hardware: {config.num_transmitters}x{config.num_receivers} antenna array") | |
| print(f" - Frequencies: {config.num_subcarriers} subcarriers at 2.4GHz") | |
| print(f" - Sampling: {config.sampling_rate}Hz") | |
| print(f" - Body parts: {config.num_body_parts}") | |
| print(f" - Keypoints: {config.num_keypoints}") | |
| # Demonstrate CSI data processing | |
| print("\n" + "="*60) | |
| print("DEMONSTRATING CSI DATA PROCESSING") | |
| print("="*60) | |
| # Generate sample CSI data | |
| amplitude_data, phase_data = data_simulator.generate_csi_sample(num_people=2, movement_intensity=1.5) | |
| print(f"Generated CSI data:") | |
| print(f" Amplitude shape: {amplitude_data.shape}") | |
| print(f" Phase shape: {phase_data.shape}") | |
| print(f" Amplitude range: [{amplitude_data.min():.2f}, {amplitude_data.max():.2f}]") | |
| print(f" Phase range: [{phase_data.min():.2f}, {phase_data.max():.2f}]") | |
| # Process phase data | |
| sanitized_phase = phase_processor.sanitize_phase(phase_data) | |
| print(f"Sanitized phase range: [{sanitized_phase.min():.2f}, {sanitized_phase.max():.2f}]") | |
| # Generate ground truth | |
| ground_truth = data_simulator.generate_ground_truth_poses(num_people=2) | |
| print(f"\nGenerated ground truth for {ground_truth['num_people']} people") | |
| for i, pose in enumerate(ground_truth['poses']): | |
| bbox = pose['bbox'] | |
| print(f" Person {i+1}: bbox=[{bbox[0]:.1f}, {bbox[1]:.1f}, {bbox[2]:.1f}, {bbox[3]:.1f}]") | |
| print("\nCSI processing demonstration completed!") |
Xet Storage Details
- Size:
- 9.64 kB
- Xet hash:
- 8b9ecdba7409b38425424f2c509c32b9adc884bbd24cca9cdd6953ceec28bdd5
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.