视觉+触觉多模态疲劳驾驶检测：柔性电子皮肤+CNN特征融合的跨模态框架

论文信息

项目 内容
标题 A multimodal framework for fatigue driving detection via feature fusion of vision and tactile information
期刊 npj Flexible Electronics, Vol. 10, Article 40
发表 2026年2月5日
作者 Li K, Yue W, Shin DB et al.
链接 https://www.nature.com/articles/s41528-026-00543-7
核心方法 视觉（面部CNN）+ 触觉（柔性电子皮肤压力）特征融合
传感器 柔性压阻式电子皮肤阵列

核心创新

  1. 视觉+触觉跨模态：首个用面部视觉+方向盘触觉融合检测疲劳的框架
  2. 柔性电子皮肤：方向盘上大面积柔性压力传感器阵列
  3. 特征级融合：CNN提取视觉特征+RNN提取触觉时序特征→融合分类
  4. npj Flexible Electronics：Nature子刊，柔性电子权威

问题定义

单模态局限

模态 可检测疲劳信号 局限
视觉（DMS摄像头） 眨眼/哈欠/头部姿态 光照敏感、遮挡
触觉（方向盘压力） 握力变化/频率/模式 无法区分疲劳vs放松
视觉+触觉 互补+冗余 本论文

疲劳的触觉表现

触觉信号 清醒 疲劳
平均握力 15-25N 8-12N（↓）
握力波动 σ=3N σ=1.5N（↓波动减小）
握持面积 大面积 小面积（手指松开）
方向盘修正频率 2-5次/min 0.5-1次/min（↓）
脱手时长 0s >2s（微睡眠）

方法详解

跨模态架构

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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
import torch
import torch.nn as nn
import numpy as np

class VisionEncoder(nn.Module):
    """视觉特征编码器（面部CNN）"""
    
    def __init__(self, feature_dim: int = 256):
        super().__init__()
        
        # 轻量CNN骨干
        self.backbone = nn.Sequential(
            nn.Conv2d(3, 32, 3, stride=2, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU6(),
            nn.Conv2d(32, 64, 3, stride=2, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU6(),
            nn.Conv2d(64, 128, 3, stride=2, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU6(),
            nn.AdaptiveAvgPool2d(1),
            nn.Flatten(),
        )
        
        # 面部关键特征提取
        self.face_attention = nn.Sequential(
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, 128),
            nn.Sigmoid()
        )
        
        self.proj = nn.Linear(128, feature_dim)
    
    def forward(self, face_img: torch.Tensor) -> torch.Tensor:
        """
        Args:
            face_img: [B, 3, 96, 96] 面部图像
        Returns:
            features: [B, feature_dim]
        """
        feat = self.backbone(face_img)  # [B, 128]
        att = self.face_attention(feat)
        feat = feat * att
        return self.proj(feat)


class TactileEncoder(nn.Module):
    """触觉特征编码器（方向盘压力时序）"""
    
    def __init__(self, n_sensors: int = 16,
                 feature_dim: int = 256):
        super().__init__()
        
        # 1D-CNN处理压力阵列时序
        self.conv1d = nn.Sequential(
            nn.Conv1d(n_sensors, 32, 5, stride=1),
            nn.BatchNorm1d(32),
            nn.ReLU(),
            nn.Conv1d(32, 64, 3, stride=2),
            nn.BatchNorm2d(64),
            nn.ReLU(),
        )
        
        # BiLSTM时序建模
        self.lstm = nn.LSTM(
            64, 128, batch_first=True,
            bidirectional=True
        )
        
        self.proj = nn.Linear(256, feature_dim)
    
    def forward(self, pressure_seq: torch.Tensor) -> torch.Tensor:
        """
        Args:
            pressure_seq: [B, n_sensors, T] 压力时序
        Returns:
            features: [B, feature_dim]
        """
        # 1D-CNN
        x = self.conv1d(pressure_seq)  # [B, 64, T']
        
        # 转置为时序
        x = x.permute(0, 2, 1)  # [B, T', 64]
        
        # BiLSTM
        out, _ = self.lstm(x)
        feat = out[:, -1, :]  # [B, 256]
        
        return self.proj(feat)


class CrossModalFusion(nn.Module):
    """
    跨模态融合模块
    
    视觉+触觉→注意力加权融合→分类
    """
    
    def __init__(self, feature_dim: int = 256,
                 n_classes: int = 3):
        super().__init__()
        
        # 跨模态注意力
        self.vision_to_tactile = nn.Linear(feature_dim, feature_dim)
        self.tactile_to_vision = nn.Linear(feature_dim, feature_dim)
        
        # 融合
        self.fusion = nn.Sequential(
            nn.Linear(feature_dim * 2, feature_dim),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(feature_dim, n_classes)
        )
        
        # 模态权重
        self.modality_weight = nn.Sequential(
            nn.Linear(feature_dim * 2, 2),
            nn.Softmax(dim=-1)
        )
    
    def forward(self, vision_feat: torch.Tensor,
                tactile_feat: torch.Tensor) -> dict:
        """
        Args:
            vision_feat: [B, D]
            tactile_feat: [B, D]
        
        Returns:
            logits, modality_weights
        """
        # 跨模态注意力
        v_informed = vision_feat * torch.sigmoid(
            self.tactile_to_vision(tactile_feat)
        )
        t_informed = tactile_feat * torch.sigmoid(
            self.vision_to_tactile(vision_feat)
        )
        
        # 拼接
        combined = torch.cat([v_informed, t_informed], dim=-1)
        
        # 模态权重
        weights = self.modality_weight(combined)
        
        # 加权融合
        fused = (
            weights[:, 0:1] * v_informed +
            weights[:, 1:2] * t_informed
        )
        
        logits = self.fusion(combined)
        
        return {
            'logits': logits,
            'modality_weights': weights,
        }


class VisionTactileFatigueModel(nn.Module):
    """
    视觉+触觉多模态疲劳检测完整模型
    """
    
    def __init__(self, n_classes: int = 3):
        super().__init__()
        self.vision_encoder = VisionEncoder()
        self.tactile_encoder = TactileEncoder(n_sensors=16)
        self.fusion = CrossModalFusion(n_classes=n_classes)
    
    def forward(self, face_img: torch.Tensor,
                pressure_seq: torch.Tensor) -> dict:
        v_feat = self.vision_encoder(face_img)
        t_feat = self.tactile_encoder(pressure_seq)
        return self.fusion(v_feat, t_feat)


# 测试
if __name__ == "__main__":
    model = VisionTactileFatigueModel(n_classes=3)
    
    # 模拟输入
    face = torch.randn(4, 3, 96, 96)       # 面部图像
    pressure = torch.randn(4, 16, 100)    # 16传感器×100时间步
    
    result = model(face, pressure)
    
    print("视觉+触觉多模态疲劳检测:")
    print(f"  输出: {result['logits'].shape}")
    print(f"  模态权重: {result['modality_weights']}")
    print(f"  视觉权重: {result['modality_weights'][:, 0].mean():.2f}")
    print(f"  触觉权重: {result['modality_weights'][:, 1].mean():.2f}")
    
    total_params = sum(p.numel() for p in model.parameters())
    print(f"\n总参数: {total_params:,}")

实验结果

性能对比

方法 模态 准确率 F1 延迟
CNN only 视觉 86.5% 85.8% 8ms
RNN only 触觉 78.3% 77.5% 5ms
拼接融合 视觉+触觉 89.2% 88.7% 13ms
跨模态注意力 视觉+触觉 93.7% 93.2% 15ms

模态权重动态变化

状态 视觉权重 触觉权重 主导模态
白天正常驾驶 0.65 0.35 视觉
夜间驾驶 0.45 0.55 触觉
戴口罩/墨镜 0.30 0.70 触觉
方向盘握持松 0.75 0.25 视觉
摄像头被遮挡 0.05 0.95 触觉

触觉特征贡献

触觉特征 清醒 疲劳 区分度
平均握力 18.5N 10.2N 高
握力标准差 3.2N 1.1N 高
脱手次数/5min 0 3.2 极高
方向盘修正/5min 8 1.5 高
握持接触面积 85% 52% 中

IMS开发启示

1. 视觉+触觉在IMS中的互补

场景 视觉表现 触觉表现 融合结果
正常疲劳 眨眼↑ 握力↓ ✅ 确认
戴口罩 面部遮挡 握力↓ ⚠️ 触觉主导
戴手套 眨眼↑ 触觉信号弱 ⚠️ 视觉主导
光照突变 检测中断 握力↓ ⚠️ 触觉备份
自动驾驶脱手 无异常 脱手↑ ✅ 触觉关键

2. 柔性电子皮肤方向盘

参数 规格
传感器类型 压阻式柔性阵列
阵列规模 16×4（方向盘一圈）
材料 PDMS+CNT导电纳米复合
采样率 50Hz
灵敏度 0.5N分辨率
成本 ~$12/套

3. 与IMS管道集成

组件 来源 功能
视觉编码器 DMS摄像头+CNN 面部疲劳特征
触觉编码器 方向盘柔性皮肤 握力/脱手特征
跨模态融合 本论文 注意力加权融合
决策层 证据推理(#08) 不确定性+冲突处理

总结

视觉+触觉跨模态是疲劳检测的互补新维度：

  1. 93.7%准确率：跨模态注意力比单模态高7.2%
  2. 动态模态权重：夜间/遮挡时触觉自动加权
  3. 触觉特征独特：握力↓+脱手↑是疲劳的独立信号
  4. 柔性电子皮肤：16×4阵列方向盘全覆盖，$12/套
  5. 与IMS管道集成：视觉(DMS)+触觉(方向盘)+证据决策三层架构
https://dapalm.com/2026/09/22/2026-09-22-10-vision-tactile-flexible-e-skin-fatigue-fusion-ims/
作者
Mars
发布于
2026年9月22日
许可协议