mmExpert 深度解读：LLM 驱动的 mmWave 雷达数据合成与理解——CPD 与舱内感知的新范式

mmExpert 深度解读：LLM 驱动的 mmWave 雷达数据合成与理解

论文信息

项目	内容
标题	mmExpert: Integrating Large Language Models for Comprehensive mmWave Data Synthesis and Understanding
会议	MobiHoc 2025
核心	LLM → mmWave 合成 + mmWave → LLM 理解
零样本准确率	84.6%（15类人体动作）
合成速度	12秒动作序列 → 1秒合成
开源	是

---

1. 核心创新

首次将 LLM 与 mmWave 雷达双向打通：

• 正向： 文本描述 → LLM生成场景 → 3D动作 → SMPL人体模型 → 电磁仿真 → 合成mmWave信号
• 反向： mmWave信号 → CLIP对齐 → WaveLLM → 文本理解/问答

1.1 mmWave 数据瓶颈

问题	现状	mmExpert方案
数据采集成本高	每场景需招募被试	LLM自动生成
标注困难	需专家手动标注	自动文本标注
场景覆盖不足	难以覆盖所有姿势	开放词汇生成
泛化性差	新场景需重训	零样本迁移
Sim-to-Real gap	仿真≠真实	域随机化

---

2. 方法论

2.1 系统架构

graph TB
    subgraph "正向：Text → mmWave 数据合成"
        A[用户文本提示] --> B[LLM 场景描述生成器<br/>生成多样化动作描述]
        B --> C[动作合成器<br/>文本→3D动作序列]
        C --> D[SMPL 人体表面模型<br/>拟合人体网格]
        D --> E[RF 电磁仿真<br/>路径损耗+天线+散射]
        E --> F[域随机化<br/>视角/天线/噪声变化]
        F --> G[合成 mmWave 数据集]
    end
    
    subgraph "反向：mmWave → Text 理解"
        H[mmWave 信号] --> I[Transformer 特征提取<br/>时序+多普勒特征]
        I --> J[CLIP 对齐<br/>雷达特征↔文本嵌入]
        J --> K[WaveLLM<br/>多模态LLM]
        K --> L[动作分类/描述/问答]
    end
    
    G --> I
    L --> M[零样本理解<br/>84.6% 准确率]

2.2 Text-to-mmWave 生成管线

import torch
import torch.nn as nn
from typing import Tuple, Dict
import numpy as np

class TextToMmWavePipeline:
    """
    mmExpert 文本→mmWave 合成管线
    
    流程：
    1. LLM 生成场景描述（动作、环境、上下文）
    2. 文本→3D动作序列（预训练运动模型）
    3. SMPL 人体模型拟合
    4. 电磁仿真生成雷达信号
    5. 域随机化增强泛化
    """
    
    def __init__(self):
        # Stage 1: LLM 场景描述
        self.scenario_generator = LLMScenarioGenerator()
        
        # Stage 2: 文本→动作
        self.motion_synthesizer = MotionSynthesizer()
        
        # Stage 3: SMPL 拟合
        self.smpl_model = SMPLModel()
        
        # Stage 4: RF 仿真
        self.rf_simulator = RFSignalSimulator()
        
        # Stage 5: 域随机化
        self.domain_randomizer = DomainRandomizer()
    
    def generate(
        self,
        prompt: str,
        num_samples: int = 100,
    ) -> Dict:
        """
        从文本提示生成 mmWave 合成数据
        
        Args:
            prompt: "一个孩子在后座睡觉"
            num_samples: 生成样本数
        
        Returns:
            data: {
                'mmwave_signals': (N, T, F) 多普勒频谱
                'text_labels': [str] 文本标签
                'motion_params': SMPL参数
            }
        
        Example:
            >>> pipe = TextToMmWavePipeline()
            >>> data = pipe.generate("child sleeping in rear seat", 50)
            >>> print(f"生成 {len(data['mmwave_signals'])} 个样本")
        """
        # Stage 1: LLM 生成多样化场景描述
        descriptions = self.scenario_generator.generate(prompt, num_samples)
        
        # Stage 2: 文本→3D动作
        motions = self.motion_synthesizer.synthesize(descriptions)
        
        # Stage 3: SMPL 拟合
        smpl_params = self.smpl_model.fit(motions)
        
        # Stage 4: RF 仿真
        raw_signals = self.rf_simulator.simulate(smpl_params)
        
        # Stage 5: 域随机化
        augmented = self.domain_randomizer.augment(raw_signals)
        
        return {
            'mmwave_signals': augmented,
            'text_labels': descriptions,
            'motion_params': smpl_params,
        }


class LLMScenarioGenerator(nn.Module):
    """使用 LLM 生成多样化场景描述"""
    
    def __init__(self):
        super().__init__()
        # LLM 提示模板
        self.prompt_template = """
        Generate {n} diverse descriptions of: "{base_prompt}"
        Include variations in:
        - Body posture (sitting, lying, leaning)
        - Movement speed (slow, normal, fast)
        - Environment (vehicle type, seat position)
        - Clothing (winter coat, summer clothes)
        Each description should be unique and realistic.
        """
    
    def generate(self, base_prompt: str, n: int) -> list:
        """生成 n 个多样化描述"""
        # 实际使用 LLM API
        descriptions = [
            f"{base_prompt} - variant {i}: {self._add_variation(base_prompt, i)}"
            for i in range(n)
        ]
        return descriptions
    
    def _add_variation(self, base: str, idx: int) -> str:
        variations = [
            "slow breathing, relaxed posture",
            "occasional limb movement",
            "covered with blanket",
            "sitting upright with head tilted",
            "lying across rear seat",
            "curled fetal position",
        ]
        return variations[idx % len(variations)]


class RFSignalSimulator:
    """
    RF 电磁仿真器
    
    基于论文描述的物理模型：
    - 路径损耗 (path loss)
    - 天线损耗 (antenna loss)  
    - 散射损耗 (scattering loss)
    """
    
    def __init__(self):
        self.c = 3e8  # 光速
        self.fc = 60e9  # 60 GHz mmWave
    
    def simulate(
        self,
        smpl_params: list,
    ) -> np.ndarray:
        """
        仿真 SMPL 人体模型的雷达回波
        
        Args:
            smpl_params: SMPL 参数列表 [(vertices, faces), ...]
        
        Returns:
            signals: (N, T, F) 多普勒频谱
                N: 样本数
                T: 时间帧
                F: 频率bin
        """
        N = len(smpl_params)
        T = 120  # 12s @ 10fps
        F = 64    # 多普勒频率bin
        
        signals = np.zeros((N, T, F), dtype=np.float32)
        
        for i, (vertices, _) in enumerate(smpl_params):
            # 计算每个顶点的 RCS
            rcs = self._compute_rcs(vertices)
            
            # 仿真多普勒频谱
            for t in range(T):
                # 顶点速度 → 多普勒频移
                velocities = self._estimate_vertex_velocity(vertices, t)
                doppler_shifts = 2 * velocities * self.fc / self.c
                
                # 构建多普勒频谱
                spectrum = np.zeros(F, dtype=np.float32)
                for v_idx, shift in enumerate(doppler_shifts):
                    bin_idx = int((shift + F/2) % F)
                    spectrum[bin_idx] += rcs[v_idx]
                
                signals[i, t] = spectrum
        
        return signals
    
    def _compute_rcs(self, vertices: np.ndarray) -> np.ndarray:
        """计算每个顶点的雷达截面(RCS)"""
        # 简化：基于面积和角度
        n_verts = vertices.shape[0]
        rcs = np.random.uniform(0.001, 0.01, n_verts)  # m²
        return rcs
    
    def _estimate_velocity(self, vertices: np.ndarray, t: int) -> np.ndarray:
        """估计顶点速度"""
        # 简化：基于帧差
        return np.random.normal(0, 0.1, vertices.shape[0])


class DomainRandomizer:
    """
    Sim-to-Real 域随机化
    
    论文关键组件：使合成数据训练的模型能零样本迁移到真实数据
    """
    
    def __init__(self):
        self.randomize_params = {
            'radar_view': True,      # 雷达视角变化
            'body_segment': True,    # 身体分割变化
            'antenna_pattern': True,  # 天线方向图变化
            'background_noise': True, # 背景噪声
            'nonlinear_scaling': True, # 非线性缩放
        }
    
    def augment(self, signals: np.ndarray) -> np.ndarray:
        """
        域随机化增强
        
        Args:
            signals: (N, T, F) 原始信号
        
        Returns:
            augmented: (N, T, F) 增强后信号
        """
        N, T, F = signals.shape
        augmented = signals.copy()
        
        # 1. 随机视角偏移
        if self.randomize_params['radar_view']:
            view_shift = np.random.randint(-3, 4, N)
            for i in range(N):
                augmented[i] = np.roll(augmented[i], view_shift[i], axis=1)
        
        # 2. 天线方向图变化
        if self.randomize_params['antenna_pattern']:
            antenna_gain = np.random.uniform(0.7, 1.3, (N, 1, 1))
            augmented *= antenna_gain
        
        # 3. 背景噪声
        if self.randomize_params['background_noise']:
            noise = np.random.normal(0, 0.01, augmented.shape)
            augmented += noise
        
        # 4. 非线性缩放
        if self.randomize_params['nonlinear_scaling']:
            scale = np.random.uniform(0.8, 1.2, (N, 1, 1))
            augmented = augmented * scale + np.tanh(augmented) * (1 - scale)
        
        # 5. 多径效应
        if self.randomize_params['background_noise']:
            multipath = np.random.uniform(0, 0.05, augmented.shape)
            augmented = augmented + multipath * np.roll(augmented, 1, axis=1)
        
        return augmented.astype(np.float32)


# 测试
if __name__ == "__main__":
    pipe = TextToMmWavePipeline()
    
    # 生成 CPD 场景数据
    data = pipe.generate("child sleeping in rear seat", 50)
    
    print(f"生成样本数: {len(data['mmwave_signals'])}")
    print(f"信号维度: {data['mmwave_signals'].shape}")
    print(f"文本标签示例: {data['text_labels'][0]}")
    
    # 域随机化效果
    print(f"\n域随机化后范围: [{data['mmwave_signals'].min():.3f}, {data['mmwave_signals'].max():.3f}]")

2.3 WaveLLM：mmWave 理解

class WaveLLM(nn.Module):
    """
    WaveLLM: 多模态 LLM 理解 mmWave 信号
    
    架构：
    1. mmWave 特征提取器 (Transformer encoder)
    2. 文本特征提取器 (BERT)
    3. CLIP 对齐
    4. LLM 投影层 + LoRA 微调
    """
    
    def __init__(self, signal_dim: int = 64, text_dim: int = 768, llm_dim: int = 4096):
        super().__init__()
        
        # mmWave 特征提取器
        self.signal_encoder = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(
                d_model=signal_dim,
                nhead=8,
                dim_feedforward=256,
                batch_first=True
            ),
            num_layers=4
        )
        
        # 文本特征提取器 (BERT)
        self.text_encoder = nn.Linear(text_dim, signal_dim)  # BERT投影
        
        # CLIP 对齐 (对比学习)
        self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1/0.07))
        
        # LLM 投影层
        self.llm_projector = nn.Sequential(
            nn.Linear(signal_dim, llm_dim),
            nn.GELU(),
            nn.Linear(llm_dim, llm_dim),
        )
        
    def forward(
        self,
        mmwave_signal: torch.Tensor,
        text_input: torch.Tensor = None,
        mode: str = "classify",
    ) -> torch.Tensor:
        """
        Args:
            mmwave_signal: (B, T, F) 多普勒频谱
            text_input: (B, text_dim) 文本嵌入 (训练时)
            mode: "classify" | "align" | "qa"
        
        Returns:
            classify: (B, num_classes) 分类logits
            align: scalar 对比损失
            qa: (B, llm_dim) LLM输入嵌入
        """
        # mmWave 特征提取
        signal_feat = self.signal_encoder(mmwave_signal)  # (B, T, signal_dim)
        signal_feat = signal_feat.mean(dim=1)  # (B, signal_dim)
        
        if mode == "align" and text_input is not None:
            # CLIP 对齐
            text_feat = self.text_encoder(text_input)  # (B, signal_dim)
            
            # 对比学习损失
            logit_scale = torch.exp(self.logit_scale)
            logits = logit_scale * signal_feat @ text_feat.T
            labels = torch.arange(signal_feat.shape[0])
            loss = nn.functional.cross_entropy(logits, labels)
            return loss
        
        elif mode == "qa":
            # 投影到 LLM 空间
            llm_embed = self.llm_projector(signal_feat)  # (B, llm_dim)
            return llm_embed
        
        else:
            # 分类
            return signal_feat


# 测试
if __name__ == "__main__":
    model = WaveLLM(signal_dim=64, text_dim=768, llm_dim=4096)
    
    # 模拟 mmWave 信号 (B, T, F)
    signal = torch.randn(4, 120, 64)
    
    # 分类模式
    output = model(signal, mode="classify")
    print(f"分类特征维度: {output.shape}")  # (4, 64)
    
    # QA模式
    llm_embed = model(signal, mode="qa")
    print(f"LLM嵌入维度: {llm_embed.shape}")  # (4, 4096)
    
    # 对齐模式
    text = torch.randn(4, 768)
    loss = model(signal, text, mode="align")
    print(f"对比损失: {loss.item():.4f}")

---

3. 关键结果

3.1 零样本分类

方法	训练数据	15类准确率	说明
RFGen	合成	71.2%	基线
Text2Doppler	合成	76.8%	文本→多普勒
mmExpert	合成	84.6%	LLM+域随机化

3.2 鲁棒性

环境	准确率	变化
标准	84.6%	baseline
多径反射	83.4%	-1.2%
弱反射	82.1%	-2.5%

3.3 效率

操作	耗时
12秒动作→合成信号	~1秒
LLM Q&A 推理	~3秒
训练ViT分类器	~2小时

---

4. 数据集

4.1 合成数据

维度	数值
基础数据集	HumanML3D (文本+3D动作)
合成增强	LLM 开放词汇扩展
动作类别	15类
信号长度	12秒/样本
合成速度	1秒/12秒序列

4.2 真实评估数据

维度	数值
被试	10名志愿者
样本数	>1000
场景	2个场景
标注	类别+描述+问答
动作类别	15类

---

5. IMS 开发启示

5.1 CPD 数据合成新范式

# mmExpert 用于 CPD 数据合成的配置
CPD_SYNTHESIS_CONFIG = {
    "target_scenario": "child presence detection in rear seat",
    "mmwave_config": {
        "frequency": "60 GHz",      # mmWave 频段
        "bandwidth": "4 GHz",
        "placement": "roof-mounted",  # 车顶安装
    },
    "child_motion_categories": [
        "sleeping_fetal",      # 蜷缩睡眠
        "sleeping_supine",     # 仰卧睡眠
        "sitting_quiet",      # 安静坐着
        "playing_small",       # 小幅活动
        "crying_active",       # 哭闹大幅活动
        "standing_up",         # 站起
        "reaching_for_door",   # 够车门
    ],
    "adult_motion_categories": [
        "sitting_normal",      # 正常坐着
        "leaning_forward",     # 前倾
        "turning_around",      # 转身
        "exiting_vehicle",     # 离车
    ],
    "environment_variations": [
        "sedan_rear_left",
        "sedan_rear_right",
        "suv_rear_left",
        "suv_third_row",
        "minivan_middle",
    ],
    "synthesis_target": "10,000 samples per scenario",
    "domain_randomization": True,
}

5.2 数据合成管线集成

graph LR
    A[CPD场景描述] --> B[LLM 生成器<br/>扩展场景]
    B --> C[动作合成<br/>儿童/成人动作]
    C --> D[SMPL 人体模型<br/>包含儿童体型]
    D --> E[RF 仿真<br/>60GHz mmWave]
    E --> F[域随机化<br/>多径/噪声/视角]
    F --> G[合成数据集<br/>10000+ 样本]
    G --> H[训练 ViT 分类器<br/>零样本迁移]
    H --> I[实车部署<br/>真实mmWave数据]

5.3 对标现有合成方案

方案	数据源	物理仿真	域随机化	零样本	LLM理解
NVIDIA Omniverse	3D场景	光学	❌	❌	❌
Anyverse	3D场景	光学+深度	部分	❌	❌
mmExpert	文本→动作	电磁	✅	✅ 84.6%	✅ WaveLLM

---

6. 部署建议

组件	配置	说明
mmWave 传感器	60GHz FMCW	TI IWR6843AOP
合成数据量	10,000+ 样本	7类儿童×5类环境
训练模型	ViT-B	分类器骨干
零样本目标	>80% 准确率	真实数据验证
WaveLLM	可选	理解+问答能力
延迟目标	<100ms	实时CPD检测

---

7. 局限性

局限	影响	缓解
SMPL 成人模型	儿童体型差异大	需扩展儿童 SMPL
60GHz 简化	穿透损失建模不足	需补充实车测量
评估场景少	仅2场景	需扩展多车型
开放词汇评估难	无标准指标	需建立评估基准
计算成本	GPU 依赖	可用小模型蒸馏

---

8. 结论

mmExpert 的核心贡献：

1. LLM 作为数据生成器：文本→动作→电磁仿真全自动管线，解决 mmWave 数据瓶颈
2. CLIP 对齐实现零样本：合成训练→真实部署无需微调，84.6% 准确率
3. WaveLLM 双向理解：不仅生成数据，还能理解雷达信号并回答问题
4. 域随机化是关键：视角/天线/噪声多维度随机化 → sim-to-real 桥梁

IMS 启示： CPD 训练数据不足是核心痛点。mmExpert 提供了从文本到雷达信号的端到端合成方案，特别适合儿童检测这种难以采集真实数据的场景。建议 IMS 数据合成管线引入 LLM 场景生成 + RF 电磁仿真 + 域随机化三件套。

---

参考文献

• mmExpert: MobiHoc 2025
• CLIP: Radford et al., ICML 2021
• SMPL: Loper et al., SIGGRAPH 2015
• HumanML3D: Pluegers et al., ICCV 2023
• TI IWR6843AOP: Texas Instruments 60GHz mmWave