MFT: 多模态融合Transformer检测手机分心，95%准确率可迁移座舱

论文信息

  • 标题： Detecting Phone-Induced Pedestrian Distraction via a Multimodal Fusion Transformer
  • arXiv： 2609.23507 (2026年9月20日)
  • 会议： IEEE ICEICT 2026
  • 作者： Yuanzhe Li 等
  • 数据集： 287行人实例，20,741张图像（手动标注）

核心创新

MFT提出跨模态注意力融合Transformer，同时提取人体姿态关键点和视觉外观特征，检测手机引起的分心行为。95%准确率，超基线6%。

关键指标

指标 MFT 基线最佳 提升
总体准确率 95% 89% +6%
数据集 287实例/20,741图 — 手动标注
模态 姿态+视觉 单模态 互补

方法详解

架构图

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
行人图像 ──→ ┌──────────────────────────────┐
              │      MFT 架构                 │
              │                               │
         ┌────┴────┐    ┌─────────────┐      │
         │ 姿态分支│    │ 视觉分支    │      │
         │         │    │             │      │
         │ 关键点   │    │ CNN特征     │      │
         │ 提取     │    │ 提取        │      │
         │ (COCO   │    │ (ResNet    │      │
         │  17点)  │    │  /ViT)     │      │
         └────┬────┘    └──────┬──────┘      │
              │                │              │
              │   跨模态注意力  │              │
              └───────┬────────┘              │
                      │                       │
                      ▼                       │
              ┌───────────────┐               │
              │ Transformer   │               │
              │ Encoder       │               │
              │ (时序注意力)  │               │
              └───────┬───────┘               │
                      │                       │
                      ▼                       │
              ┌───────────────┐               │
              │ 分类头        │               │
              │ 分心/正常     │               │
              └───────────────┘               │
              │                               │
              └──────────────────────────────┘

模型实现

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
"""
论文：MFT: Multimodal Fusion Transformer for Phone Distraction
arXiv: 2609.23507
会议：IEEE ICEICT 2026

核心方法：跨模态注意力融合姿态+视觉特征
"""

import torch
import torch.nn as nn
import torch.nn.functional as F

class MFT(nn.Module):
    """
    Multimodal Fusion Transformer (MFT)
    
    论文核心模型：
    1. 姿态分支: 从关键点提取骨骼动力学特征
    2. 视觉分支: 从图像提取外观特征
    3. 跨模态注意力: 多头交叉注意力融合
    4. 时序注意力: Transformer编码器捕获时序依赖
    5. 分类: 分心/正常二分类
    """
    
    def __init__(self, 
                 num_keypoints: int = 17,
                 keypoint_dim: int = 2,
                 visual_feat_dim: int = 512,
                 hidden_dim: int = 256,
                 num_heads: int = 8,
                 num_layers: int = 4,
                 num_classes: int = 2):
        super().__init__()
        
        # === 姿态分支 ===
        # COCO 17关键点 → 骨骼动力学特征
        self.pose_encoder = nn.Sequential(
            nn.Linear(num_keypoints * keypoint_dim, hidden_dim),
            nn.GELU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.GELU(),
            nn.Linear(hidden_dim, hidden_dim)
        )
        
        # === 视觉分支 ===
        # 图像 → CNN/ViT特征
        self.visual_encoder = nn.Sequential(
            nn.Conv2d(3, 64, 3, stride=2, padding=1),
            nn.BatchNorm2d(64),
            nn.GELU(),
            nn.Conv2d(64, 128, 3, stride=2, padding=1),
            nn.BatchNorm2d(128),
            nn.GELU(),
            nn.Conv2d(128, 256, 3, stride=2, padding=1),
            nn.BatchNorm2d(256),
            nn.GELU(),
            nn.Conv2d(256, 512, 3, stride=2, padding=1),
            nn.BatchNorm2d(512),
            nn.GELU(),
            nn.AdaptiveAvgPool2d(1),
            nn.Flatten(),
            nn.Linear(512, hidden_dim)
        )
        
        # === 跨模态注意力模块 ===
        # 多头交叉注意力: 姿态→视觉, 视觉→姿态
        self.cross_attn_p2v = nn.MultiheadAttention(
            embed_dim=hidden_dim, num_heads=num_heads,
            batch_first=True
        )
        self.cross_attn_v2p = nn.MultiheadAttention(
            embed_dim=hidden_dim, num_heads=num_heads,
            batch_first=True
        )
        self.norm_p = nn.LayerNorm(hidden_dim)
        self.norm_v = nn.LayerNorm(hidden_dim)
        
        # === 时序注意力融合 ===
        # Transformer编码器捕获时序依赖
        encoder_layer = nn.TransformerEncoderLayer(
            d_model=hidden_dim * 2,  # 姿态+视觉拼接
            nhead=num_heads,
            dim_feedforward=hidden_dim * 4,
            dropout=0.1,
            activation='gelu',
            batch_first=True
        )
        self.temporal_encoder = nn.TransformerEncoder(
            encoder_layer, num_layers=num_layers
        )
        
        # === 分类头 ===
        self.classifier = nn.Sequential(
            nn.Linear(hidden_dim * 2, hidden_dim),
            nn.GELU(),
            nn.Dropout(0.3),
            nn.Linear(hidden_dim, hidden_dim // 2),
            nn.GELU(),
            nn.Dropout(0.3),
            nn.Linear(hidden_dim // 2, num_classes)
        )
        
    def forward(self, images, keypoints, seq_len=1):
        """
        Args:
            images: (B, T, C, H, W) 图像序列
            keypoints: (B, T, N, D) 关键点序列
            seq_len: 时序长度
        
        Returns:
            logits: (B, num_classes)
        """
        B, T = images.shape[:2]
        
        # 展平时序
        images_flat = images.view(B * T, *images.shape[2:])
        kp_flat = keypoints.view(B * T, -1)
        
        # 1. 姿态特征
        pose_feat = self.pose_encoder(kp_flat)  # (B*T, hidden)
        pose_feat = pose_feat.view(B, T, -1)
        
        # 2. 视觉特征
        visual_feat = self.visual_encoder(images_flat)  # (B*T, hidden)
        visual_feat = visual_feat.view(B, T, -1)
        
        # 3. 跨模态注意力
        # 姿态→视觉
        p2v_attn, _ = self.cross_attn_p2v(
            visual_feat, pose_feat, pose_feat
        )
        visual_enhanced = self.norm_v(visual_feat + p2v_attn)
        
        # 视觉→姿态
        v2p_attn, _ = self.cross_attn_v2p(
            pose_feat, visual_feat, visual_feat
        )
        pose_enhanced = self.norm_p(pose_feat + v2p_attn)
        
        # 4. 拼接+时序编码
        fused = torch.cat([pose_enhanced, visual_enhanced], dim=-1)  # (B, T, hidden*2)
        temporal_out = self.temporal_encoder(fused)  # (B, T, hidden*2)
        
        # 5. 取最后时刻输出
        last_output = temporal_out[:, -1, :]
        
        # 6. 分类
        logits = self.classifier(last_output)
        
        return logits


# 测试
if __name__ == "__main__":
    # 模拟数据
    B, T = 4, 10  # 4个样本, 10帧时序
    images = torch.randn(B, T, 3, 224, 224)
    keypoints = torch.randn(B, T, 17, 2)  # COCO 17关键点
    
    # 模型
    model = MFT(num_keypoints=17, keypoint_dim=2, hidden_dim=256)
    
    # 前向
    logits = model(images, keypoints)
    
    print(f"图像输入: {images.shape}")
    print(f"关键点输入: {keypoints.shape}")
    print(f"输出logits: {logits.shape}")
    print(f"参数量: {sum(p.numel() for p in model.parameters()):,}")
    
    # 论文结果
    print("\n=== 论文实验结果 ===")
    print(f"总体准确率: 95%")
    print(f"基线最佳: 89%")
    print(f"提升: +6%")
    print(f"数据集: 287行人, 20,741图像")
    print(f"模态: 姿态关键点 + 视觉外观")
    print(f"跨模态注意力: 多头交叉注意力")
    print(f"时序建模: Transformer编码器")

从行人分心到驾驶员分心

迁移方案

行人场景 (论文) 驾驶员场景 (迁移) 调整
行人手持手机 驾驶员手持手机 相似
行人姿态17关键点 驾驶员上半身关键点 调整关键点集
户外图像 座舱红外图像 切换模态
分心/正常 疲劳/分心/正常 扩展类别
10帧时序 30帧(1秒) 增加时序

座舱MFT架构

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
# 座舱版MFT
class CabinMFT(nn.Module):
    """座舱多模态融合Transformer"""
    
    def __init__(self):
        super().__init__()
        # 视觉分支: 红外摄像头
        self.visual_encoder = IREncoder()  # RGB-IR编码器
        
        # 姿态分支: 驾驶员关键点
        # 眼睛(6) + 鼻子(1) + 嘴巴(3) + 头部轮廓(7) + 手部(2)
        self.pose_encoder = DriverPoseEncoder(num_keypoints=19)
        
        # 跨模态注意力 (与MFT相同)
        self.cross_attn = CrossModalAttention()
        
        # 时序编码
        self.temporal = TransformerEncoder()
        
        # 多级分类
        self.classifier = nn.Sequential(
            nn.Linear(512, 256),
            nn.GELU(),
            nn.Linear(256, 4)  # 正常/疲劳/分心/手机
        )
    
    def forward(self, ir_images, keypoints):
        # 与MFT相同流程
        pass

Euro NCAP DSM场景对应

Euro NCAP场景 MFT模态 可检测
D-02: 手持手机至耳边 视觉+姿态 ✅ 手部关键点+视觉
D-03: 手持手机打字 视觉+姿态 ✅ 手部位置+视觉
D-05: 视线偏离 姿态(眼/头) ✅ 眼部关键点
F-01: PERCLOS 姿态(眼) ✅ 眼睑开度

参考

发布时间: 2026-09-25 03:30
分类: 分心检测 | 多模态融合 | Transformer | 手机检测 | 论文解读