分布式雷达连续人体动作识别：ConvNeXt-MHSA-BiGRU 在座舱乘员行为监测中的应用

分布式雷达连续人体动作识别：ConvNeXt-MHSA-BiGRU 在座舱乘员行为监测中的应用

论文信息

项目 内容
标题 Robust Continuous Human Activity Recognition Using Deep Learning and Distributed Radar Sensors
arXiv 2609.10419
日期 2026-09-09
领域 eess.SP (Signal Processing)
作者 Mohammad Soleymani 等

核心创新

提出 ConvNeXt-MHSA-BiGRU 框架，解决分布式雷达连续动作识别的三大挑战：

挑战 解决方案
多普勒特征随视角变化 5 节点分布式雷达 + MHSA 自适应视角融合
单雷达视角信息量随运动方向波动 RadarDropout 正则化 + 视角注意力
连续序列中动作转换模糊 BiGRU 双向时序建模

方法详解

架构总览

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
import torch
import torch.nn as nn
import torch.nn.functional as F

class ConvNeXt_MHSA_BiGRU(nn.Module):
    """
    分布式雷达连续动作识别框架
    
    输入: 5个雷达节点的多普勒-时间频谱图
    输出: 逐帧动作分类（9类）
    
    架构:
    1. ConvNeXt 编码器: 提取时频特征
    2. MHSA 雷达视角融合: 自适应多节点融合
    3. BiGRU 时序建模: 帧间动作转换
    """
    
    def __init__(self, n_radar=5, n_classes=9, hidden_dim=256):
        super().__init__()
        self.n_radar = n_radar
        
        # 1. ConvNeXt 启发的共享编码器（每个雷达流独立编码）
        self.encoder = ConvNeXtEncoder(
            in_channels=2,  # 多普勒频谱的实部+虚部
            dims=[96, 192, 384, 768],
            depths=[3, 3, 9, 3]
        )
        
        # 2. 雷达视角 MHSA 融合
        self.radar_mhsa = nn.MultiheadAttention(
            embed_dim=768,
            num_heads=8,
            batch_first=True,
            dropout=0.1
        )
        self.radar_norm = nn.LayerNorm(768)
        
        # RadarDropout: 随机丢弃雷达视角（训练时）
        self.radar_dropout = nn.Dropout(0.2)
        
        # SpecAugment 式时频掩码
        self.time_mask = nn.Dropout(0.1)
        self.freq_mask = nn.Dropout(0.1)
        
        # 3. BiGRU 时序建模
        self.bigru = nn.GRU(
            input_size=768,
            hidden_size=hidden_dim,
            num_layers=2,
            batch_first=True,
            bidirectional=True,
            dropout=0.3
        )
        
        # 分类头
        self.classifier = nn.Linear(hidden_dim * 2, n_classes)
    
    def forward(self, x):
        """
        Args:
            x: (B, R, C, H, W) 雷达频谱图
               B=batch, R=雷达数(5), C=2(实部+虚部), H=time, W=freq
        Returns:
            logits: (B, T, n_classes) 逐帧分类
        """
        B, R, C, H, W = x.shape
        
        # 1. 逐雷达编码
        x = x.view(B * R, C, H, W)
        # SpecAugment 风格增强（训练时）
        if self.training:
            x = self.freq_mask(x)
            x = self.time_mask(x)
        
        features = self.encoder(x)  # (B*R, 768, T')
        T = features.shape[-1]
        features = features.view(B, R, -1, T)  # (B, R, 768, T)
        
        # 2. MHSA 雷达视角融合
        features = features.permute(0, 3, 1, 2)  # (B, T, R, 768)
        features_flat = features.reshape(B * T, R, -1)  # (B*T, R, 768)
        
        # RadarDropout
        features_flat = self.radar_dropout(features_flat)
        
        # 多头自注意力融合
        attn_out, _ = self.radar_mhsa(
            features_flat, features_flat, features_flat
        )
        fused = self.radar_norm(features_flat + attn_out)
        
        # 取平均视角
        fused = fused.mean(dim=1)  # (B*T, 768)
        fused = fused.view(B, T, -1)  # (B, T, 768)
        
        # 3. BiGRU 时序建模
        gru_out, _ = self.bigru(fused)  # (B, T, 2*hidden)
        
        # 4. 分类
        logits = self.classifier(gru_out)  # (B, T, n_classes)
        
        return logits


class ConvNeXtEncoder(nn.Module):
    """ConvNeXt 启发的频谱图编码器"""
    
    def __init__(self, in_channels=2, dims=[96, 192, 384, 768], 
                 depths=[3, 3, 9, 3]):
        super().__init__()
        self.stem = nn.Sequential(
            nn.Conv2d(in_channels, dims[0], 4, 4),
            nn.LayerNorm([dims[0]]),
            nn.GELU()
        )
        
        self.stages = nn.ModuleList()
        for i in range(len(dims) - 1):
            stage = nn.Sequential(
                nn.Conv2d(dims[i], dims[i+1], 2, 2),
                *[ConvNeXtBlock(dims[i+1]) for _ in range(depths[i+1])]
            )
            self.stages.append(stage)
        
        self.norm = nn.LayerNorm(dims[-1])
    
    def forward(self, x):
        x = self.stem(x)
        for stage in self.stages:
            x = stage(x)
        # 全局平均池化 → 时间维度保留
        x = x.mean(dim=(2, 3))  # (B, C)
        return x.unsqueeze(-1)  # (B, C, 1)


class ConvNeXtBlock(nn.Module):
    """ConvNeXt 残差块"""
    def __init__(self, dim):
        super().__init__()
        self.dwconv = nn.Conv2d(dim, dim, 7, 1, 3, groups=dim)
        self.norm = nn.LayerNorm(dim)
        self.pwconv1 = nn.Linear(dim, dim * 4)
        self.pwconv2 = nn.Linear(dim * 4, dim)
        self.act = nn.GELU()
    
    def forward(self, x):
        residual = x
        x = self.dwconv(x)
        x = x.permute(0, 2, 3, 1)
        x = self.norm(x)
        x = self.pwconv1(x)
        x = self.act(x)
        x = self.pwconv2(x)
        x = x.permute(0, 3, 1, 2)
        return residual + x


# 测试
if __name__ == "__main__":
    model = ConvNeXt_MHSA_BiGRU(n_radar=5, n_classes=9)
    
    # 模拟 5 雷达输入: batch=4, 5雷达, 2通道, 64时间x128频率
    x = torch.randn(4, 5, 2, 64, 128)
    logits = model(x)
    
    print(f"Input: {x.shape}")
    print(f"Output: {logits.shape}")
    print(f"Parameters: {sum(p.numel() for p in model.parameters()):,}")

9 类动作定义

类别 动作 座舱映射
A1 行走 站立尝试
A2 坐下 落座
A3 站起 离座
A4 拾物 弯腰取物（OOP）
A5 转身 回头看后排
A6 挥手 手势交互
A7 推拉 调整座椅
A8 踢腿 脚放仪表板（OOP）
A9 静止 睡眠/CPD

评估结果

测试方案 准确率 说明
L1PO (留一被试) 87.56% 14 被试独立测试
5折交叉验证 89.2% L1PO + 5折
CNN-RNN 基线 82.3% +5.26% 提升

IMS 应用启示

座舱分布式雷达部署

graph TB
    subgraph 座舱雷达节点
        R1[前挡风上方<br/>雷达1]
        R2[内后视镜<br/>雷达2]
        R3[顶棚中央<br/>雷达3]
        R4[B柱左<br/>雷达4]
        R5[B柱右<br/>雷达5]
    end
    
    subgraph ConvNeXt-MHSA-BiGRU
        E[ConvNeXt 编码器<br/>5路并行]
        M[MHSA 视角融合<br/>自适应权重]
        B[BiGRU 时序<br/>动作转换]
    end
    
    R1 --> E
    R2 --> E
    R3 --> E
    R4 --> E
    R5 --> E
    E --> M
    M --> B
    B --> O{动作分类}
    O -->|A4 弯腰| OOP[OOP 检测]
    O -->|A8 踢腿| OOP
    O -->|A9 静止| CPD[CPD 检测]
    O -->|A6 挥手| GES[手势交互]

与现有方案对比

方案 传感器 精度 隐私 暗光 多角度
摄像头+YOLO RGB-IR 92% ❌ ⚠️ IR ❌ 单视角
单雷达 mmWave 78% ✅ ✅ ❌
分布式雷达 5×mmWave 87.56% ✅ ✅ ✅ 5视角

部署建议

组件 型号 数量 参数
mmWave 雷达 TI IWR6843AOP 5 60GHz, 4Tx/4Rx
处理器 QCS8255 1 26 TOPS
天线 AOP 封装 5 120° FOV
功耗 - - 5×0.8W + 5W = 9W

关键优势

  1. 隐私保护：无图像，符合 GDPR
  2. 多视角鲁棒：5 雷达视角互补，减少遮挡影响
  3. 连续识别：BiGRU 处理动作转换，不需滑窗
  4. RadarDropout：模拟雷达失效，提升鲁棒性

总结

ConvNeXt-MHSA-BiGRU 为座舱分布式雷达动作识别提供了可行框架。87.56% 的跨被试验准确率表明分布式雷达可替代摄像头在隐私敏感场景的应用。对 IMS 开发的核心启示：

  1. 分布式雷达 > 单雷达：多视角互补显著提升精度
  2. MHSA 自适应融合：不同动作的最佳视角不同，注意力机制自动选择
  3. BiGRU 适合连续 OOP 检测：无需固定滑窗，天然处理动作转换
  4. RadarDropout 是关键正则化：座舱中雷达可能被遮挡，需训练时模拟
前沿论文
#雷达 #IMS #mmWave #动作识别 #HAR #BiGRU #ConvNeXt
分布式雷达连续人体动作识别：ConvNeXt-MHSA-BiGRU 在座舱乘员行为监测中的应用
https://dapalm.com/2026/09/11/2026-09-11-distributed-radar-convnext-mhsa-bigru-continuous-har-cabin-ims/
作者
Mars
发布于
2026年9月11日
许可协议