WiFi DensePose 深度解析：用无线电波「看穿」世界——从 CSI 信号到人体姿态的完整工程实践

你家的 WiFi 路由器，或许比你想象中更「聪明」。2026 年开春，GitHub 上一个名为 WiFi DensePose 的开源项目迅速突破 1.7 万 Star——它用普通的 WiFi 信号，穿墙实时追踪人体姿态、监测呼吸心跳，全程不需要一颗摄像头。这不是科幻，这是已经可以 Docker 一键跑起来的真实技术。本文从信号处理到深度学习模型，从 ESP32 固件到 Rust 高性能推理，带你完整拆解 WiFi 感知的工程全链路。

一、为什么 WiFi 感知值得每个程序员关注

1.1 传统感知方案的死穴

先说结论：现有的人体感知方案，没有一个既便宜、又隐私、还能穿墙。

WiFi 感知的核心优势是：复用已有的 WiFi 基础设施。全球有超过 4 亿个 WiFi 路由器在持续发射信号——每一个都可以成为感知节点。这不是在造新轮子，而是在挖掘已有轮子的第二春。

1.2 WiFi DensePose 的技术定位

WiFi DensePose 不是从零开始的。它的技术血统可以追溯到两支研究脉络：

1. DensePose（Facebook AI Research, 2018）：将 2D 图像中的每个像素映射到 3D 人体表面模型的 UV 坐标，实现稠密的人体姿态估计。
2. WiFi CSI 感知（学术界多年积累）：利用 WiFi 信道状态信息（CSI）的变化来检测人体活动。

2023 年，卡内基梅隆大学（CMU）的团队在论文《DensePose From WiFi》中首次将两者结合——用 WiFi CSI 替代 RGB 图像作为 DensePose 的输入。2026 年，ruvnet 团队在此基础上做了生产级重构：用 Rust 重写推理引擎，实现了约 54,000 FPS 的处理速度和低于 50ms 的端到端延迟。

这就是我们今天要拆解的对象。

二、CSI：WiFi 感知的「眼睛」

2.1 什么是 CSI？

WiFi 通信中，信号从发射端（Tx）到接收端（Rx）不是一条直线过去的。它会反射、散射、衍射——经过多条路径到达接收端。每条路径有不同的衰减和延迟。CSI（Channel State Information）就是对这些多径效应的数学描述。

在 OFDM 系统中（WiFi 4/5/6 都用 OFDM），CSI 对每个子载波都有一个复数值：

H[k] = |H[k]| · e^(jφ[k])

其中：

• |H[k]| 是幅度（Amplitude），反映信号强度的变化
• φ[k] 是相位（Phase），反映信号传播时间的变化
• k 是子载波索引

人体在空间中移动时，会改变多径传播的环境，从而导致 CSI 的幅度和相位发生变化。这就是 WiFi 感知的物理基础。

2.2 CSI vs RSSI：为什么必须用 CSI

很多人会问：WiFi 信号强度（RSSI）不也能感知吗？确实可以，但效果天差地别。

┌──────────────────────────────────────────┐
│ RSSI（接收信号强度指示）                    │
│ - 单一标量值，信息量极少                    │
│ - 受环境干扰大，信噪比低                    │
│ - 只能做粗粒度存在检测                      │
│ - 任何 WiFi 设备都能获取                    │
├──────────────────────────────────────────┤
│ CSI（信道状态信息）                         │
│ - 每个子载波的复数值，信息量丰富              │
│ - 包含幅度+相位，可重建空间信息              │
│ - 能做细粒度姿态估计                        │
│ - 需要特定硬件/固件支持                     │
└──────────────────────────────────────────┘

用个比喻：RSSI 是「听到有人在说话」，CSI 是「能分辨出每个人说了什么」。

在 WiFi 5（802.11ac）的 20MHz 信道中，有 56 个子载波；40MHz 信道有 114 个。每个子载波都有幅度和相位——这就是 CSI 提供的高维信息。

2.3 CSI 采集的硬件门槛

这是 WiFi 感知最大的实际门槛。大多数消费级 WiFi 网卡不开放 CSI 原始数据。

目前可用的 CSI 采集方案：

WiFi DensePose 项目推荐的是 ESP32-S3 方案——3-6 个 ESP32 节点配合一个普通路由器，总成本约 $54，就能实现实时姿态感知。

2.4 CSI 采集的代码实现

以 ESP32-S3 为例，核心是修改 WiFi 驱动以提取 CSI 数据：

// esp32_csi_collector.c - ESP32 CSI 数据采集核心
#include "esp_wifi.h"
#include "esp_wifi_types.h"

// CSI 回调函数 - 每收到一个 WiFi 数据包就会触发
void wifi_csi_rx_cb(void *ctx, esp_wifi_csi_info_t *info) {
    // 1. 获取 CSI 数据
    int8_t *csi_buf = info->rx_ctrl.buf;
    int csi_len = info->rx_ctrl.len;
    
    // 2. 提取子载波数据
    // ESP32-S3 在 20MHz 模式下有 64 个子载波
    // 其中有效子载波为 -28 到 -1 和 1 到 28（共 56 个）
    csi_data_t csi;
    for (int i = 0; i < csi_len / 2; i++) {
        // CSI 数据为 I/Q 两路，每个子载波一个复数
        int8_t i_val = csi_buf[i * 2];      // 同相分量
        int8_t q_val = csi_buf[i * 2 + 1];  // 正交分量
        
        // 计算幅度和相位
        csi.amplitude[i] = sqrt(i_val * i_val + q_val * q_val);
        csi.phase[i] = atan2(q_val, i_val);
    }
    
    // 3. 添加时间戳
    csi.timestamp = esp_timer_get_time();
    
    // 4. 发送到处理节点（通过 WiFi UDP）
    send_csi_to_processor(&csi);
}

// 初始化 CSI 采集
void init_csi_collection(void) {
    // 配置 WiFi 为 STA 模式
    wifi_config_t wifi_config = {
        .sta = {
            .ssid = "your_router_ssid",
            .password = "your_password",
        },
    };
    esp_wifi_set_config(WIFI_IF_STA, &wifi_config);
    esp_wifi_start();
    esp_wifi_connect();
    
    // 注册 CSI 回调
    esp_wifi_set_csi_rx_cb(wifi_csi_rx_cb, NULL);
    
    // 配置 CSI 采集参数
    wifi_csi_config_t csi_config = {
        .lltf_en = true,     // 启用 L-LTF CSI
        .htltf_en = true,    // 启用 HT-LTF CSI
        .stbc_htltf2_en = true,  // STBC 模式
        .ltf_merge_en = true,    // 合并 LTF
        .channel_filter_en = false,  // 不过滤信道
        .manu_scale = true,       // 手动缩放
    };
    esp_wifi_set_csi_config(&csi_config);
    
    // 启用 CSI 采集
    esp_wifi_set_csi(true);
}

这段代码展示了 CSI 采集的核心逻辑：注册回调 → 提取 I/Q 数据 → 计算幅度/相位 → 发送到处理节点。

三、信号处理流水线：从原始信号到运动特征

3.1 完整的处理架构

CSI 原始数据充满了噪声，不能直接喂给神经网络。需要一套信号处理流水线：

原始 CSI 数据
    │
    ▼
┌──────────────┐
│  1. 相位清洗  │  消除载波频偏和采样频偏
└──────┬───────┘
       │
       ▼
┌──────────────┐
│  2. 异常值过滤 │  Hampel 滤波器去除脉冲噪声
└──────┬───────┘
       │
       ▼
┌──────────────┐
│  3. 子载波选择 │  去除直流和边缘子载波
└──────┬───────┘
       │
       ▼
┌──────────────┐
│  4. 特征提取  │  时频分析 + Fresnel 区建模
└──────┬───────┘
       │
       ▼
┌──────────────┐
│  5. 滑动窗口  │  构建时序特征张量
└──────┬───────┘
       │
       ▼
  深度学习模型输入

3.2 相位清洗：最关键的一步

CSI 相位数据有一个致命问题：载波频偏（CFO）和采样频偏（SFO）。这两个偏移是收发端晶振不一致导致的，会叠加一个线性的相位偏移到每个子载波上，把真实的人体运动信息淹没掉。

清除方法来自经典论文 SpotFi 的共轭乘法：

# phase_sanitization.py - 相位清洗实现
import numpy as np

def sanitize_csi_phase(phase_raw):
    """
    清洗 CSI 相位数据，消除 CFO 和 SFO
    
    原理：CFO 导致的相位偏移与子载波索引成正比
    SFO 导致的偏移也与子载波索引成正比
    两者叠加后，原始相位 = 真实相位 + a*k + b
    
    通过线性拟合消除 a 和 b
    """
    num_subcarriers = len(phase_raw)
    k = np.arange(num_subcarriers)
    
    # 1. 解卷绕相位（处理 2π 跳变）
    phase_unwrapped = np.unwrap(phase_raw)
    
    # 2. 线性拟合：phase = a*k + b
    coeffs = np.polyfit(k, phase_unwrapped, deg=1)
    a, b = coeffs
    
    # 3. 减去线性偏移
    phase_sanitized = phase_unwrapped - (a * k + b)
    
    # 4. 归一化到 [-π, π]
    phase_sanitized = (phase_sanitized + np.pi) % (2 * np.pi) - np.pi
    
    return phase_sanitized

def conjugate_multiplication(csi_tx, csi_rx):
    """
    SpotFi 共轭乘法 - 用于多天线场景
    
    利用相邻天线的 CSI 做共轭乘法，
    消除公共的相位偏移，保留空间差异
    """
    # csi_tx: (num_antennas, num_subcarriers) 复数
    # csi_rx: (num_antennas, num_subcarriers) 复数
    
    # 天线 i 和天线 j 的共轭乘法
    phase_diff = np.angle(csi_tx * np.conj(csi_rx))
    
    return phase_diff

这一步的效果非常显著。清洗前，相位数据看起来像随机噪声；清洗后，你能清晰地看到人体运动产生的周期性变化。

3.3 Hampel 滤波器：去除脉冲噪声

WiFi 环境中充满了突发干扰——微波炉、蓝牙设备、邻居的 WiFi 都会产生脉冲噪声。Hampel 滤波器是处理这类异常值的利器：

# hampel_filter.py - 异常值检测与过滤
import numpy as np
from scipy import stats

def hampel_filter(data, window_size=7, n_sigma=3):
    """
    Hampel 滤波器 - 基于滑动窗口的异常值检测
    
    原理：对每个数据点，计算其所在窗口的中位数和 MAD，
    如果该点偏离中位数超过 n_sigma 个 MAD，则替换为中位数
    
    相比均值+标准差，中位数+MAD 对异常值更鲁棒
    """
    filtered = data.copy()
    n = len(data)
    
    for i in range(n):
        # 确定窗口范围
        start = max(0, i - window_size // 2)
        end = min(n, i + window_size // 2 + 1)
        window = data[start:end]
        
        # 计算中位数和 MAD（Median Absolute Deviation）
        median = np.median(window)
        mad = stats.median_abs_deviation(window)
        
        # 标准化 MAD（使其与标准差可比）
        # 对于正态分布，σ ≈ 1.4826 × MAD
        sigma = 1.4826 * mad
        
        # 检测异常值
        if sigma > 0 and abs(data[i] - median) > n_sigma * sigma:
            filtered[i] = median  # 替换为中位数
    
    return filtered

# 应用到 CSI 数据流
def filter_csi_stream(csi_stream, window_size=7, n_sigma=3):
    """
    对 CSI 数据流的每个子载波独立应用 Hampel 滤波
    csi_stream: (num_samples, num_subcarriers)
    """
    num_samples, num_subcarriers = csi_stream.shape
    filtered = np.zeros_like(csi_stream)
    
    for sc in range(num_subcarriers):
        filtered[:, sc] = hampel_filter(
            csi_stream[:, sc], 
            window_size=window_size, 
            n_sigma=n_sigma
        )
    
    return filtered

3.4 Fresnel 区模型：理解信号与运动的关系

Fresnel 区是理解 WiFi 感知为什么能工作的物理模型。简单来说，收发端之间的空间被划分为一系列同心的椭球面，每个椭球面就是一个 Fresnel 区。

# fresnel_model.py - Fresnel 区建模
import numpy as np

def fresnel_zone_radius(n, wavelength, d1, d2):
    """
    计算第 n 个 Fresnel 区在某个点的半径
    
    n: Fresnel 区序号
    wavelength: 信号波长（2.4GHz WiFi → 0.125m, 5GHz → 0.06m）
    d1: 该点到发射端的距离
    d2: 该点到接收端的距离
    """
    return np.sqrt(n * wavelength * d1 * d2 / (d1 + d2))

def detect_crossing(csi_phase_seq, threshold=np.pi/2):
    """
    检测 Fresnel 区穿越事件
    
    当人体穿越 Fresnel 区边界时，CSI 相位会发生约 π 的跳变
    通过检测相位变化率来识别穿越事件
    """
    phase_diff = np.diff(csi_phase_seq)
    crossings = np.where(np.abs(phase_diff) > threshold)[0]
    
    return crossings

def estimate_velocity(crossings, wavelength, fps):
    """
    根据 Fresnel 区穿越频率估算运动速度
    
    每次穿越一个 Fresnel 区边界，人体移动了约 λ/2 的距离
    因此速度 ≈ (穿越次数 × λ/2) / 时间
    """
    num_crossings = len(crossings)
    distance = num_crossings * wavelength / 2
    time = len(csi_phase_seq) / fps
    
    if time > 0:
        velocity = distance / time
    else:
        velocity = 0
    
    return velocity

Fresnel 区模型给出了一个重要的直觉：人体运动越快，CSI 相位变化越频繁；运动幅度越大，CSI 幅度变化越明显。 这为后续的深度学习模型提供了物理可解释性。

3.5 时频分析：提取运动特征

对于呼吸和心跳这种微小的周期性运动，需要做时频分析来提取频率特征：

# feature_extraction.py - 时频特征提取
import numpy as np
from scipy import signal
from scipy.fft import fft, fftfreq

def extract_stft_features(csi_stream, fs=1000, nperseg=256):
    """
    短时傅里叶变换 - 提取时频特征
    
    对于呼吸（0.2-0.5Hz）和心跳（0.8-2Hz）的检测，
    STFT 能很好地在时频域中分离这些微弱信号
    """
    # 对每个子载波做 STFT
    num_samples, num_subcarriers = csi_stream.shape
    all_features = []
    
    for sc in range(num_subcarriers):
        f, t, Zxx = signal.stft(
            csi_stream[:, sc], 
            fs=fs, 
            nperseg=nperseg,
            noverlap=nperseg // 2
        )
        # 取幅度谱
        magnitude = np.abs(Zxx)
        all_features.append(magnitude)
    
    # 堆叠所有子载波的特征
    features = np.stack(all_features, axis=0)  # (subcarriers, freq_bins, time_bins)
    
    return features, f, t

def extract_doppler_features(csi_stream, fs=1000):
    """
    多普勒频移特征提取
    
    人体运动导致的多普勒频移可以反映运动方向和速度
    """
    num_samples, num_subcarriers = csi_stream.shape
    
    # 计算相邻时间步的相位差（瞬时频率）
    phase_diff = np.diff(np.angle(csi_stream), axis=0)
    
    # 多普勒频移 ≈ 相位变化率 / (2π)
    doppler_shift = phase_diff * fs / (2 * np.pi)
    
    # 统计特征
    features = {
        'doppler_mean': np.mean(doppler_shift, axis=0),
        'doppler_std': np.std(doppler_shift, axis=0),
        'doppler_max': np.max(np.abs(doppler_shift), axis=0),
        'doppler_energy': np.sum(doppler_shift**2, axis=0),
    }
    
    return features

def build_sliding_window(csi_stream, window_size=100, stride=20):
    """
    构建滑动窗口数据集
    
    将连续的 CSI 数据切分为固定长度的窗口，
    每个窗口作为一个样本输入到深度学习模型
    """
    num_samples, num_subcarriers = csi_stream.shape
    windows = []
    
    for start in range(0, num_samples - window_size + 1, stride):
        window = csi_stream[start:start + window_size, :]
        windows.append(window)
    
    return np.array(windows)  # (num_windows, window_size, num_subcarriers)

四、深度学习模型架构：从信号到姿态

4.1 双头架构设计

WiFi DensePose 的核心是一个双头（Dual-Head）神经网络：

          ┌─────────────────────┐
          │   CSI 特征输入       │
          │  (window × subcarriers) │
          └──────────┬──────────┘
                     │
          ┌──────────▼──────────┐
          │   共享特征提取器      │
          │   (GNN + Transformer) │
          └──────────┬──────────┘
                     │
          ┌──────────┴──────────┐
          │                     │
┌──────────▼──────┐  ┌──────────▼──────┐
│  Keypoint Head   │  │  DensePose Head │
│  17个COCO关键点   │  │  24个人体区域    │
│  骨骼关节位置     │  │  UV坐标映射     │
└─────────────────┘  └─────────────────┘

• Keypoint Head：输出 17 个 COCO 格式的关键点坐标（鼻、眼、肩、肘、腕、髋、膝、踝），用于骨骼姿态估计。
• DensePose Head：输出 24 个人体区域的 UV 坐标映射，用于稠密的人体表面重建。

4.2 图神经网络：处理 CSI 的空间结构

CSI 数据天然具有图结构——子载波之间有频率域的邻接关系，天线之间有空间域的邻接关系。图神经网络（GNN）是处理这类数据的理想选择。

# model.py - WiFi DensePose 模型核心实现
import torch
import torch.nn as nn
import torch.nn.functional as F

class CSIGraphLayer(nn.Module):
    """
    CSI 图神经网络层
    
    将子载波作为图节点，频率邻接关系作为边，
    通过消息传递聚合空间信息
    """
    def __init__(self, in_features, out_features, num_subcarriers=56):
        super().__init__()
        self.in_features = in_features
        self.out_features = out_features
        
        # 节点特征变换
        self.node_transform = nn.Linear(in_features, out_features)
        
        # 邻居特征变换
        self.neighbor_transform = nn.Linear(in_features, out_features)
        
        # 注意力系数（GAT 风格）
        self.attn = nn.Parameter(torch.zeros(2 * out_features, 1))
        
        # 构建邻接矩阵（子载波频率邻接）
        self.register_buffer('adj', self._build_adj(num_subcarriers))
    
    def _build_adj(self, n):
        """构建子载波邻接矩阵：相邻子载波相连"""
        adj = torch.zeros(n, n)
        for i in range(n):
            if i > 0:
                adj[i, i-1] = 1
            if i < n - 1:
                adj[i, i+1] = 1
            # 也可以加 2-hop 邻居
            if i > 1:
                adj[i, i-2] = 0.5
            if i < n - 2:
                adj[i, i+2] = 0.5
        return adj
    
    def forward(self, x):
        """
        x: (batch, num_subcarriers, in_features)
        """
        B, N, _ = x.shape
        
        # 节点自身特征
        h_self = self.node_transform(x)  # (B, N, out)
        
        # 邻居聚合
        h_neigh = self.neighbor_transform(x)  # (B, N, out)
        
        # 注意力机制
        h_cat = torch.cat([
            h_self.unsqueeze(2).expand(-1, -1, N, -1),
            h_neigh.unsqueeze(1).expand(-1, N, -1, -1)
        ], dim=-1)  # (B, N, N, 2*out)
        
        attn_scores = torch.matmul(h_cat, self.attn).squeeze(-1)  # (B, N, N)
        
        # 掩码：只关注邻居
        attn_scores = attn_scores.masked_fill(self.adj == 0, float('-inf'))
        attn_weights = F.softmax(attn_scores, dim=-1)
        
        # 消息传递
        h_agg = torch.matmul(attn_weights, h_neigh)  # (B, N, out)
        
        # 合并自身和邻居信息
        out = F.relu(h_self + h_agg)
        
        return out


class WiFiDensePoseModel(nn.Module):
    """
    WiFi DensePose 完整模型
    
    输入：CSI 时序数据 (batch, window_size, num_subcarriers)
    输出：关键点坐标 + DensePose UV 映射
    """
    def __init__(self, num_subcarriers=56, window_size=100, 
                 num_keypoints=17, num_body_parts=24):
        super().__init__()
        
        # 1. 输入嵌入：将 CSI 的幅度和相位分别编码
        self.amp_embedding = nn.Sequential(
            nn.Linear(num_subcarriers, 256),
            nn.ReLU(),
            nn.Linear(256, 128),
        )
        self.phase_embedding = nn.Sequential(
            nn.Linear(num_subcarriers, 256),
            nn.ReLU(),
            nn.Linear(256, 128),
        )
        
        # 2. 图神经网络：提取子载波间的空间关系
        self.gnn_layers = nn.ModuleList([
            CSIGraphLayer(256, 256, num_subcarriers)
            for _ in range(3)
        ])
        
        # 3. Transformer：提取时序依赖
        encoder_layer = nn.TransformerEncoderLayer(
            d_model=256, nhead=8, dim_feedforward=1024,
            dropout=0.1, batch_first=True
        )
        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=4)
        
        # 4. 双头输出
        # Keypoint Head
        self.keypoint_head = nn.Sequential(
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Linear(128, num_keypoints * 3),  # x, y, confidence
        )
        
        # DensePose Head
        self.densepose_head = nn.Sequential(
            nn.Linear(256, 256),
            nn.ReLU(),
            nn.Linear(256, num_body_parts * 2),  # U, V coordinates
        )
    
    def forward(self, csi_amp, csi_phase):
        """
        csi_amp: (B, T, num_subcarriers) 幅度
        csi_phase: (B, T, num_subcarriers) 相位
        """
        B, T, N = csi_amp.shape
        
        # 1. 嵌入
        amp_emb = self.amp_embedding(csi_amp)       # (B, T, 128)
        phase_emb = self.phase_embedding(csi_phase)  # (B, T, 128)
        
        # 拼接幅度和相位特征
        x = torch.cat([amp_emb, phase_emb], dim=-1)  # (B, T, 256)
        
        # 2. GNN：在每个时间步独立处理子载波图
        # 需要重塑为 (B*T, N, features) 格式
        # ... (简化处理，实际中需要更精细的维度管理)
        
        # 3. Transformer：建模时序依赖
        x = self.transformer(x)  # (B, T, 256)
        
        # 4. 取最后几个时间步的特征
        x = x[:, -10:, :].mean(dim=1)  # (B, 256)
        
        # 5. 双头输出
        keypoints = self.keypoint_head(x)  # (B, 17*3)
        keypoints = keypoints.view(B, 17, 3)
        
        densepose = self.densepose_head(x)  # (B, 24*2)
        densepose = densepose.view(B, 24, 2)
        
        return keypoints, densepose

4.3 教师-学生训练框架

WiFi DensePose 的训练采用了知识蒸馏的策略：

• 教师模型：用 Kinect 深度摄像头采集的 RGB-D 数据训练一个基于图像的 DensePose 模型，作为「真值」来源。
• 学生模型：用 WiFi CSI 数据作为输入，预测与教师模型相同的姿态输出。

# train.py - 教师-学生训练框架
import torch
import torch.nn as nn

class DensePoseDistillationLoss(nn.Module):
    """
    教师-学生蒸馏损失
    
    包含三个部分：
    1. 姿态回归损失（MSE）
    2. UV 映射损失（MSE）
    3. 特征蒸馏损失（KL 散度）
    """
    def __init__(self, alpha=0.5, beta=0.3, gamma=0.2, temperature=4.0):
        super().__init__()
        self.alpha = alpha  # 姿态损失权重
        self.beta = beta    # UV 损失权重
        self.gamma = gamma  # 蒸馏损失权重
        self.temperature = temperature
        
        self.mse = nn.MSELoss()
        self.kl = nn.KLDivLoss(reduction='batchmean')
    
    def forward(self, student_keypoints, student_densepose,
                teacher_keypoints, teacher_densepose,
                student_features=None, teacher_features=None):
        """
        student_keypoints: (B, 17, 3) 学生模型关键点预测
        teacher_keypoints: (B, 17, 3) 教师模型关键点真值
        student_densepose: (B, 24, 2) 学生模型 UV 预测
        teacher_densepose: (B, 24, 2) 教师模型 UV 真值
        """
        # 1. 关键点回归损失
        loss_keypoints = self.mse(student_keypoints, teacher_keypoints)
        
        # 2. DensePose UV 回归损失
        loss_densepose = self.mse(student_densepose, teacher_densepose)
        
        # 3. 特征蒸馏损失（可选）
        loss_distill = 0
        if student_features is not None and teacher_features is not None:
            # 软化 logits 后做 KL 散度
            T = self.temperature
            student_soft = F.log_softmax(student_features / T, dim=-1)
            teacher_soft = F.softmax(teacher_features / T, dim=-1)
            loss_distill = self.kl(student_soft, teacher_soft) * (T * T)
        
        total_loss = (self.alpha * loss_keypoints + 
                     self.beta * loss_densepose + 
                     self.gamma * loss_distill)
        
        return total_loss, {
            'loss_keypoints': loss_keypoints.item(),
            'loss_densepose': loss_densepose.item(),
            'loss_distill': loss_distill if isinstance(loss_distill, float) else loss_distill.item(),
        }

4.4 为什么需要知识蒸馏

因为 WiFi CSI 数据没有天然的「真值标注」。你不能直接告诉模型「这个 CSI 模式对应的手臂角度是 45°」。但你可以同时用摄像头（Kinect）和 WiFi 采集同一个人的数据——摄像头提供姿态真值，WiFi 提供输入信号，然后让 WiFi 模型学习逼近摄像头的输出。

这就是教师-学生框架的核心思想：用视觉感知作为桥梁，训练出无需视觉的感知模型。

五、Rust 高性能推理引擎：54000 FPS 是怎么做到的

5.1 为什么用 Rust 重写

原始的 Python/PyTorch 实现大约只有 67 FPS——对于实时感知来说远远不够。ruvnet 团队用 Rust 重写了整个推理引擎，性能提升了约 800 倍。

这 800 倍不是来自某个银弹，而是多个优化的叠加：

等等，50-100x 怎么变成 800x？答案是：批处理。Python 版本是逐帧推理，Rust 版本把多帧打包成 batch 一起推理，充分利用 GPU/NPU 的并行能力。

5.2 Rust 推理引擎核心代码

// inference.rs - Rust 高性能推理引擎核心
use std::simd::*;
use rayon::prelude::*;

/// CSI 数据帧
#[repr(C, align(16))]
pub struct CsiFrame {
    pub timestamp: u64,
    pub amplitude: [f32; 56],  // 56 个子载波幅度
    pub phase: [f32; 56],      // 56 个子载波相位
}

/// 滑动窗口缓冲区
pub struct SlidingWindow {
    buffer: Vec<CsiFrame>,
    capacity: usize,
    position: usize,
    is_full: bool,
}

impl SlidingWindow {
    pub fn new(capacity: usize) -> Self {
        Self {
            buffer: Vec::with_capacity(capacity),
            capacity,
            position: 0,
            is_full: false,
        }
    }
    
    pub fn push(&mut self, frame: CsiFrame) -> Option<&[CsiFrame]> {
        if self.buffer.len() < self.capacity {
            self.buffer.push(frame);
            if self.buffer.len() == self.capacity {
                self.is_full = true;
            }
        } else {
            self.buffer[self.position] = frame;
            self.position = (self.position + 1) % self.capacity;
        }
        
        if self.is_full {
            Some(&self.buffer)
        } else {
            None
        }
    }
}

/// SIMD 加速的相位清洗
pub fn sanitize_phase_simd(phase: &[f32; 56]) -> [f32; 56] {
    // 线性拟合：phase = a * k + b
    let k: [f32; 56] = core::array::from_fn(|i| i as f32);
    
    // 计算均值
    let k_mean: f32 = k.iter().sum::<f32>() / 56.0;
    let p_mean: f32 = phase.iter().sum::<f32>() / 56.0;
    
    // 计算斜率 a = Σ(k-k̄)(p-p̄) / Σ(k-k̄)²
    let mut numerator = 0.0f32;
    let mut denominator = 0.0f32;
    for i in 0..56 {
        numerator += (k[i] - k_mean) * (phase[i] - p_mean);
        denominator += (k[i] - k_mean) * (k[i] - k_mean);
    }
    let a = numerator / denominator;
    let b = p_mean - a * k_mean;
    
    // 减去线性偏移
    let mut result = [0.0f32; 56];
    for i in 0..56 {
        result[i] = phase[i] - (a * k[i] + b);
    }
    
    result
}

/// INT8 量化推理
pub struct QuantizedInference {
    weights_i8: Vec<i8>,     // 量化权重
    scales: Vec<f32>,        // 量化缩放因子
    zero_points: Vec<i8>,    // 量化零点
    output_buffer: Vec<f32>, // 输出缓冲区
}

impl QuantizedInference {
    /// INT8 矩阵乘法（核心热路径）
    pub fn matmul_i8(
        &self,
        input: &[i8],     // (1, in_features) 量化输入
        weights: &[i8],   // (out_features, in_features) 量化权重
        output: &mut [f32], // (1, out_features) FP32 输出
        scale: f32,
        in_features: usize,
    ) {
        // 使用 SIMD 加速的整数点积
        for i in 0..output.len() {
            let row = &weights[i * in_features..(i + 1) * in_features];
            
            // 分块累加，每 16 个 i8 做一次 SIMD 点积
            let mut sum_i32: i32 = 0;
            let chunks = in_features / 16;
            
            for c in 0..chunks {
                let offset = c * 16;
                
                // 加载 16 个 i8 到 SIMD 寄存器
                // 在 x86 上使用 _mm256_maddubs_epi16
                // 在 ARM 上使用 vmlal_s8
                let mut local_sum: i32 = 0;
                for j in 0..16 {
                    local_sum += (input[offset + j] as i32) * (row[offset + j] as i32);
                }
                sum_i32 += local_sum;
            }
            
            // 处理剩余元素
            let remainder = in_features % 16;
            for j in 0..remainder {
                let idx = chunks * 16 + j;
                sum_i32 += (input[idx] as i32) * (row[idx] as i32);
            }
            
            // 反量化到 FP32
            output[i] = sum_i32 as f32 * scale;
        }
    }
}

/// 推理引擎主循环
pub struct InferenceEngine {
    window: SlidingWindow,
    phase_sanitizer: PhaseSanitizer,
    hampel_filter: HampelFilter,
    model: QuantizedInference,
    keypoint_decoder: KeypointDecoder,
    densepose_decoder: DensePoseDecoder,
}

impl InferenceEngine {
    /// 处理单个 CSI 帧
    pub fn process_frame(&mut self, frame: CsiFrame) -> Option<PoseResult> {
        // 1. 相位清洗
        let sanitized_phase = self.phase_sanitizer.sanitize(&frame.phase);
        
        // 2. Hampel 滤波
        let filtered_amp = self.hampel_filter.filter(&frame.amplitude);
        
        // 3. 构建清洗后的帧
        let clean_frame = CsiFrame {
            timestamp: frame.timestamp,
            amplitude: filtered_amp,
            phase: sanitized_phase,
        };
        
        // 4. 推入滑动窗口
        let window_data = self.window.push(clean_frame)?;
        
        // 5. 模型推理
        let (keypoints, densepose) = self.model.infer(window_data)?;
        
        // 6. 解码输出
        Some(PoseResult {
            timestamp: frame.timestamp,
            keypoints: self.keypoint_decoder.decode(keypoints),
            body_parts: self.densepose_decoder.decode(densepose),
        })
    }
    
    /// 批量推理（用于 GPU 加速场景）
    pub fn process_batch(&self, frames: &[CsiFrame]) -> Vec<PoseResult> {
        frames.par_iter()  // Rayon 并行
            .filter_map(|frame| self.process_frame(frame.clone()))
            .collect()
    }
}

#[derive(Debug, Clone)]
pub struct PoseResult {
    pub timestamp: u64,
    pub keypoints: Vec<(f32, f32, f32)>,  // (x, y, confidence) × 17
    pub body_parts: Vec<(f32, f32)>,       // (U, V) × 24
}

5.3 延迟分解：50ms 端到端是怎么来的

总延迟 < 50ms 的分解：

CSI 采集         : ~2ms    (ESP32 → 主节点网络传输)
相位清洗         : ~1ms    (SIMD 加速)
Hampel 滤波      : ~1ms    (滑动窗口)
特征提取         : ~3ms    (时频分析)
模型推理(INT8)   : ~8ms    (Rust 量化推理)
后处理/解码       : ~2ms   (关键点 + UV 解码)
网络传输到 UI     : ~3ms    (WebSocket)
───
总计             : ~20ms   (留有 30ms 余量)

六、ESP32 固件：从实验室到客厅

6.1 为什么选择 ESP32

ESP32-S3 是目前 WiFi 感知最实用的硬件平台：

• 价格：约 $8/个，6 个节点不到 $50
• WiFi 支持：802.11 b/g/n，2.4GHz
• CSI 输出：ESP-IDF 4.x+ 原生支持 CSI 回调
• 算力：双核 240MHz LX7，512KB SRAM
• 生态：庞大的开源社区和现成固件

6.2 固件架构

┌─────────────────────────────────────────┐
│            ESP32-S3 固件架构              │
├─────────────────────────────────────────┤
│                                         │
│  ┌───────────┐  ┌───────────────────┐  │
│  │ WiFi CSI  │  │ OTA 升级服务       │  │
│  │ 采集模块  │  │ (远程固件更新)     │  │
│  └─────┬─────┘  └───────────────────┘  │
│        │                                │
│  ┌─────▼─────┐  ┌───────────────────┐  │
│  │ CSI 预处理 │  │ 设备发现与配对     │  │
│  │ (相位清洗) │  │ (mDNS)            │  │
│  └─────┬─────┘  └───────────────────┘  │
│        │                                │
│  ┌─────▼─────┐  ┌───────────────────┐  │
│  │ UDP 发送器 │  │ 看门狗 / 心跳     │  │
│  │ (到主节点) │  │                   │  │
│  └───────────┘  └───────────────────┘  │
│                                         │
└─────────────────────────────────────────┘

6.3 固件烧录和部署

# 1. 克隆项目
git clone https://github.com/ruvnet/wifi-densepose
cd wifi-densepose/esp32-firmware

# 2. 安装 ESP-IDF（如果还没装）
# macOS
brew install esp-idf
# 或者从源码
git clone https://github.com/espressif/esp-idf.git
cd esp-idf && ./install.sh && . ./export.sh

# 3. 配置项目
idf.py menuconfig
# 在菜单中配置：
# - WiFi SSID 和密码
# - 主节点 IP 地址
# - CSI 采集频率（推荐 100Hz）
# - UDP 目标端口

# 4. 编译固件
idf.py build

# 5. 烧录到 ESP32
# 对每个 ESP32 节点：
idf.py -p /dev/ttyUSB0 flash monitor

# 如果是多个节点，可以用脚本批量烧录
for port in /dev/ttyUSB0 /dev/ttyUSB1 /dev/ttyUSB2; do
    idf.py -p $port flash
done

6.4 网络拓扑设计

实际部署中，推荐的网络拓扑：

┌──────────────┐
│  WiFi 路由器  │ (普通家用路由器即可)
│  192.168.1.1  │
└──┬───┬───┬───┘
   │   │   │
   │   │   │    WiFi 连接
   │   │   │
┌──▼┐┌▼──┐┌▼──┐
│ESP ││ESP ││ESP │  CSI 采集节点 × 3-6
│ #1 ││ #2 ││ #3 │  每个 $8
└──┬─┘└─┬─┘└─┬─┘
   │    │    │     UDP CSI 数据流
   └────┼────┘
        │
   ┌────▼────┐
   │ 主处理节点 │  树莓派 / 笔记本 / 边缘盒子
   │ 推理引擎  │  运行 Rust 推理引擎
   │ Web UI   │  http://主节点IP:3000
   └─────────┘

节点数量与感知能力的关系：

七、性能优化实战：压榨每一毫秒

7.1 内存池化：消除运行时分配

在实时系统中，动态内存分配是延迟的隐形杀手。Rust 的 Vec::push() 看起来很快，但堆分配的不确定性会导致偶尔的长尾延迟。

// memory_pool.rs - 内存池化实现
use std::sync::Mutex;

pub struct CsiFramePool {
    pool: Mutex<Vec<Box<CsiFrame>>>,
    frame_size: usize,
}

impl CsiFramePool {
    pub fn new(capacity: usize) -> Self {
        let mut pool = Vec::with_capacity(capacity);
        for _ in 0..capacity {
            pool.push(Box::new(CsiFrame::default()));
        }
        Self {
            pool: Mutex::new(pool),
            frame_size: capacity,
        }
    }
    
    pub fn acquire(&self) -> Option<Box<CsiFrame>> {
        self.pool.lock().unwrap().pop()
    }
    
    pub fn release(&self, frame: Box<CsiFrame>) {
        let mut pool = self.pool.lock().unwrap();
        if pool.len() < self.frame_size {
            pool.push(frame);
        }
    }
}

7.2 锁无关队列：CSI 数据流的生产者-消费者模型

CSI 采集线程（生产者）和推理线程（消费者）之间需要一个高性能的无锁队列：

// lockfree_queue.rs - 基于环形缓冲区的无锁队列
use std::sync::atomic::{AtomicUsize, Ordering};

pub struct LockFreeRingBuffer<T, const N: usize> {
    buffer: [std::cell::UnsafeCell<T>; N],  // 固定大小缓冲区
    head: AtomicUsize,  // 读指针
    tail: AtomicUsize,  // 写指针
}

impl<T: Default + Copy, const N: usize> LockFreeRingBuffer<T, N> {
    pub fn new() -> Self {
        Self {
            buffer: [const { UnsafeCell::new(T::default()) }; N],
            head: AtomicUsize::new(0),
            tail: AtomicUsize::new(0),
        }
    }
    
    /// 生产者：写入一个帧
    pub fn push(&self, item: T) -> bool {
        let tail = self.tail.load(Ordering::Relaxed);
        let next_tail = (tail + 1) % N;
        
        // 检查是否满
        if next_tail == self.head.load(Ordering::Acquire) {
            return false;  // 队列满，丢弃帧
        }
        
        // 写入数据
        unsafe {
            *self.buffer[tail].get() = item;
        }
        
        // 发布写入
        self.tail.store(next_tail, Ordering::Release);
        true
    }
    
    /// 消费者：读取一个帧
    pub fn pop(&self) -> Option<T> {
        let head = self.head.load(Ordering::Relaxed);
        
        // 检查是否空
        if head == self.tail.load(Ordering::Acquire) {
            return None;
        }
        
        // 读取数据
        let item = unsafe { *self.buffer[head].get() };
        
        // 发布读取
        self.head.store((head + 1) % N, Ordering::Release);
        Some(item)
    }
}

7.3 模型量化：FP32 到 INT8 的工程实践

INT8 量化是推理加速的关键手段。核心思路是找到 FP32 权重到 INT8 的线性映射：

# quantization.py - 模型量化工具
import numpy as np
import onnx
import onnxruntime
from onnxruntime.quantization import quantize_dynamic, QuantType

def quantize_onnx_model(model_path, output_path):
    """
    将 ONNX 模型动态量化为 INT8
    
    动态量化：推理时实时量化激活值，权重预先量化
    优点：不需要校准数据集，精度损失小
    缺点：比静态量化慢一点（因为要实时量化激活值）
    """
    quantize_dynamic(
        model_input=model_path,
        model_output=output_path,
        weight_type=QuantType.QUInt8,  # 无符号 INT8
        per_channel=True,  # 按通道量化，精度更好
    )
    
    # 对比量化前后的模型大小
    original_size = os.path.getsize(model_path) / 1024 / 1024
    quantized_size = os.path.getsize(output_path) / 1024 / 1024
    
    print(f"原始模型: {original_size:.1f} MB")
    print(f"量化模型: {quantized_size:.1f} MB")
    print(f"压缩比: {original_size/quantized_size:.1f}x")

def calibrate_quantization(model, dataloader, num_batches=100):
    """
    静态量化：用校准数据集确定量化参数
    
    步骤：
    1. 前向传播校准数据集
    2. 统计每层激活值的分布
    3. 确定最优的缩放因子和零点
    """
    activations = {}
    
    def hook_fn(name):
        def hook(module, input, output):
            activations[name] = output.detach()
        return hook
    
    # 注册 hook
    for name, module in model.named_modules():
        if isinstance(module, nn.Linear):
            module.register_forward_hook(hook_fn(name))
    
    # 校准
    model.eval()
    with torch.no_grad():
        for i, (csi_amp, csi_phase) in enumerate(dataloader):
            if i >= num_batches:
                break
            model(csi_amp, csi_phase)
    
    # 计算量化参数
    quant_params = {}
    for name, act in activations.items():
        act_np = act.cpu().numpy()
        
        # 对称量化
        max_val = np.max(np.abs(act_np))
        scale = max_val / 127.0  # INT8 范围 [-128, 127]
        zero_point = 0  # 对称量化零点为 0
        
        quant_params[name] = {'scale': scale, 'zero_point': zero_point}
    
    return quant_params

八、Docker 一键体验：零硬件也能跑

没有 ESP32 开发板？没关系，WiFi DensePose 提供了模拟数据模式：

# 拉取镜像（Rust 版本，仅 132MB）
docker pull ruvnet/wifi-densepose:latest

# 启动模拟模式（无需任何硬件）
docker run -d \
  --name wifi-densepose \
  -p 3000:3000 \   # Web UI
  -p 3001:3001 \   # WebSocket API
  ruvnet/wifi-densepose:latest

# 访问可视化界面
open http://localhost:3000

模拟模式会生成合成的 CSI 数据，让你验证整个处理流水线的正确性。对于想快速了解项目或者做算法开发的开发者，这是最友好的入口。

WebSocket API 实时数据接入

// 前端实时姿态可视化
const ws = new WebSocket('ws://localhost:3001');

ws.onopen = () => {
    // 订阅姿态数据流
    ws.send(JSON.stringify({
        type: 'subscribe',
        channels: ['pose', 'vitals']
    }));
};

ws.onmessage = (event) => {
    const data = JSON.parse(event.data);
    
    if (data.type === 'pose') {
        // 渲染人体骨骼
        drawSkeleton(data.keypoints);
        // 渲染 DensePose UV 映射
        drawDensePose(data.body_parts);
    }
    
    if (data.type === 'vitals') {
        // 显示生命体征
        updateVitals({
            heartRate: data.heart_rate,    // BPM
            breathingRate: data.breathing_rate, // BPM
            presence: data.presence,        // boolean
        });
    }
};

九、实测数据与效果分析

9.1 姿态估计精度

可以看到，WiFi DensePose 在精度上确实不如视觉方案，但它的独特优势——穿墙和隐私——是视觉方案无法替代的。

9.2 生命体征检测

9.3 不同环境的影响

WiFi 感知的性能受环境影响很大，这是它最大的实际挑战：

┌───────────────────────────────────────────────┐
│ 环境因素影响分析                                 │
├───────────────┬───────────┬─────────────────────┤
│ 因素           │ 影响程度  │ 缓解方案             │
├───────────────┼───────────┼─────────────────────┤
│ 房间大小       │ 中        │ 大房间增加节点数量     │
│ 墙体材质       │ 高        │ 混凝土墙衰减大，加节点 │
│ 金属家具       │ 高        │ 调整节点位置避开遮挡   │
│ 多人重叠       │ 中        │ 增加天线/节点数量      │
│ 其他 WiFi 干扰 │ 中        │ 选择空闲信道           │
│ 温度变化       │ 低        │ 定期重新校准           │
│ 人员着装       │ 低        │ 几乎无影响            │
└───────────────┴───────────┴─────────────────────┘

十、应用场景深度分析

10.1 老人跌倒检测：最迫切的场景

中国有 2.8 亿 60 岁以上老人，独居老人超过 2000 万。跌倒检测是 WiFi 感知最直接的应用。

传统方案的问题：

• 摄像头：老人抗拒（隐私），卫生间无法安装
• 可穿戴设备：老人经常忘记佩戴，充电麻烦
• 紧急按钮：跌倒时可能按不到

WiFi 感知的优势：无感、全屋覆盖、无需佩戴、不拍画面。

# fall_detection.py - 基于 WiFi CSI 的跌倒检测
import numpy as np

class FallDetector:
    """
    跌倒检测器
    
    原理：跌倒时 CSI 信号会出现特征性的急剧变化
    - 幅度突变：身体大幅移动
    - 相位快速变化：速度突然改变
    - 后续静止：跌倒后不动
    """
    def __init__(self, window_size=50, fall_threshold=3.0, 
                 still_threshold=0.1, still_duration=20):
        self.window_size = window_size
        self.fall_threshold = fall_threshold
        self.still_threshold = still_threshold
        self.still_duration = still_duration
        self.buffer = []
        self.fall_cooldown = 0
    
    def process_frame(self, csi_frame):
        """
        处理一个 CSI 帧，返回是否检测到跌倒
        """
        self.buffer.append(csi_frame)
        if len(self.buffer) < self.window_size:
            return False
        
        if len(self.buffer) > self.window_size:
            self.buffer.pop(0)
        
        # 冷却期（避免重复告警）
        if self.fall_cooldown > 0:
            self.fall_cooldown -= 1
            return False
        
        # 1. 计算信号变异系数（CV）
        amplitudes = np.array([f.amplitude for f in self.buffer])
        cv = np.std(amplitudes, axis=0) / (np.mean(amplitudes, axis=0) + 1e-8)
        max_cv = np.max(cv)
        
        # 2. 检测急剧变化
        if max_cv > self.fall_threshold:
            # 3. 检查后续是否静止（跌倒后不动）
            recent = amplitudes[-self.still_duration:]
            recent_cv = np.std(recent, axis=0) / (np.mean(recent, axis=0) + 1e-8)
            
            if np.max(recent_cv) < self.still_threshold:
                self.fall_cooldown = 300  # 30 秒冷却（@ 10Hz）
                return True
        
        return False

10.2 智能家居活动识别

# activity_recognition.py - 基于WiFi的活动识别
import numpy as np
from enum import Enum

class Activity(Enum):
    EMPTY = "房间无人"
    SITTING = "静坐"
    WALKING = "行走"
    LYING = "躺卧"
    COOKING = "烹饪"
    FALL = "跌倒"

class ActivityRecognizer:
    """
    房间活动识别器
    
    利用 CSI 信号的不同模式识别房间内人的活动
    """
    def __init__(self):
        # 每种活动的信号特征模板（通过训练获得）
        self.activity_profiles = {
            Activity.EMPTY: {
                'amplitude_cv': (0.0, 0.02),    # 极低变异
                'phase_range': (0.0, 0.1),       # 相位几乎不变
                'doppler_energy': (0.0, 0.01),   # 无多普勒
            },
            Activity.SITTING: {
                'amplitude_cv': (0.02, 0.08),    # 微弱变化
                'phase_range': (0.1, 0.5),       # 小幅相位变化
                'doppler_energy': (0.01, 0.1),   # 微弱多普勒
            },
            Activity.WALKING: {
                'amplitude_cv': (0.1, 0.5),      # 明显变化
                'phase_range': (0.5, 3.0),       # 大幅相位变化
                'doppler_energy': (0.1, 1.0),    # 强多普勒
            },
            Activity.LYING: {
                'amplitude_cv': (0.01, 0.04),    # 微弱变化
                'phase_range': (0.05, 0.3),      # 周期性（呼吸）
                'doppler_energy': (0.001, 0.05), # 极微弱多普勒
            },
        }
    
    def recognize(self, csi_features):
        """
        根据特征判断活动类型
        
        csi_features: {
            'amplitude_cv': float,
            'phase_range': float,
            'doppler_energy': float,
        }
        """
        best_match = Activity.EMPTY
        best_score = -1
        
        for activity, profile in self.activity_profiles.items():
            score = self._match_score(csi_features, profile)
            if score > best_score:
                best_score = score
                best_match = activity
        
        return best_match, best_score
    
    def _match_score(self, features, profile):
        """计算特征与模板的匹配分数"""
        score = 0
        for key, (low, high) in profile.items():
            val = features.get(key, 0)
            if low <= val <= high:
                # 在模板范围内，越接近中心分数越高
                center = (low + high) / 2
                width = (high - low) / 2
                dist = abs(val - center) / (width + 1e-8)
                score += 1 - dist
            else:
                # 不在范围内，扣分
                overshoot = min(abs(val - low), abs(val - high))
                score -= overshoot / (high - low + 1e-8)
        return score

十一、隐私与伦理：技术之外的思考

WiFi 感知带来一个有趣的悖论：它比摄像头更隐私（不采集图像），但也更危险（用户可能完全不知道自己被感知）。

关键风险点：

1. 无感感知：用户可能不知道 WiFi 信号正在被用于人体监测
2. 穿墙能力：可以监测隔壁房间的活动
3. 低成本：攻击门槛极低（$50 的硬件就能搭一套）

负责任的设计原则：

# privacy.py - 隐私保护设计
class PrivacyGuard:
    """
    WiFi DensePose 的隐私守护层
    
    所有 WiFi 感知系统都应该内置这样的保护机制
    """
    
    # 1. 数据最小化：只输出必要的抽象信息，不存储原始CSI
    def process(self, csi_data):
        # 不存储原始 CSI
        result = self.model.infer(csi_data)
        # 只保留抽象结果（姿态骨架、存在/不存在）
        # 不保留任何可以重建图像的信息
        return result.to_abstract()
    
    # 2. 明确告知：设备工作时必须有物理指示灯
    LED_INDICATOR_REQUIRED = True
    
    # 3. 用户控制：一键关闭感知功能
    def user_disable(self):
        self.sensing_enabled = False
        self.led.turn_off()
    
    # 4. 本地处理：数据不出设备
    LOCAL_PROCESSING_ONLY = True
    
    # 5. 身份剥离：不保留任何身份特征
    def anonymize(self, pose_result):
        # 移除所有可能关联身份的信息
        pose_result.identity = None
        pose_result.timestamp = self.round_timestamp(pose_result.timestamp)
        return pose_result

十二、总结与展望

12.1 WiFi DensePose 的技术定位

WiFi DensePose 不是要取代摄像头，而是在摄像头不合适的场景中提供替代方案。它的价值在于：

• 零视觉隐私风险：适合卫生间、卧室等敏感区域
• 穿墙感知：适合灾后搜救、安防监控
• 极低成本：适合大规模部署的智能家居和养老场景
• 无感交互：不需要用户佩戴任何设备

12.2 技术演进方向

1. WiFi 7 集成：WiFi 7 的 320MHz 信道和 16×16 MIMO 将大幅提升 CSI 信息量，有望将空间精度从 ±0.5m 提升到 ±0.1m。

2. 边缘 AI 芯片：ESP32-P4 已经支持轻量级 CNN 推理，未来可以在 ESP32 上直接运行量化后的 DensePose 模型，省去中心处理节点。

3. 多模态融合：WiFi + 毫米波雷达 + 红外传感器的融合，有望同时获得 WiFi 的经济性和雷达的高精度。

4. CSI 开放标准化：目前 CSI 数据的开放仍是最大瓶颈。如果 WiFi 芯片厂商（Qualcomm、MediaTek、Broadcom）能在驱动层开放 CSI 接口，WiFi 感知将迎来爆发式增长。

5. 联邦学习：多住户场景下，可以在每个家庭本地训练，只上传模型参数不上传数据，进一步保护隐私。

12.3 程序员的切入路径

项目链接：

• GitHub 主仓库：https://github.com/ruvnet/wifi-densepose
• ESP32 固件：https://github.com/ruvnet/RuView
• 原始论文：arXiv:2301.00250

一句话总结：WiFi DensePose 证明了你家的路由器不仅仅是个网络设备——它还是一个 6Dof 空间传感器。$50 的硬件 + 开源软件，就能实现穿墙的人体感知。这不是科幻，这是已经能 Docker 跑起来的真实技术。唯一的问题是：你准备好让你的 WiFi「看见」你了吗？