驾驶员状态监测综述：机器学习方法系统性回顾

论文信息

  • 标题： A Review of Driver Gaze Estimation and Application in Gaze Behavior Understanding
  • 期刊： Engineering Applications of Artificial Intelligence
  • 发表时间： 2024年2月
  • DOI： 10.1016/j.engappai.2024.108131

核心内容

本文系统性回顾了驾驶员视线估计方法，涵盖：

  1. 特征提取方法：几何模型 vs 表观模型
  2. 深度学习架构：CNN、Transformer、多任务学习
  3. 数据集与评估：公开数据集与性能指标
  4. 应用场景：分心检测、疲劳预警、人机交互

方法分类

1. 视线估计方法

mindmap
  root((视线估计))
    几何模型
      瞳孔-角膜反射
      头部姿态补偿
      需要标定
    表观模型
      CNN特征
      端到端学习
      无需标定
    混合方法
      特征引导
      多任务学习

2. 深度学习架构对比

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
import torch
import torch.nn as nn

class GazeEstimationCNN(nn.Module):
    """
    传统CNN视线估计
    
    输入: 人眼图像
    输出: 视线向量 (pitch, yaw)
    """
    
    def __init__(self):
        super().__init__()
        
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, 11, stride=4, padding=2),
            nn.ReLU(),
            nn.MaxPool2d(3, stride=2),
            
            nn.Conv2d(64, 192, 5, padding=2),
            nn.ReLU(),
            nn.MaxPool2d(3, stride=2),
            
            nn.Conv2d(192, 384, 3, padding=1),
            nn.ReLU(),
            
            nn.Conv2d(384, 256, 3, padding=1),
            nn.ReLU(),
            
            nn.Conv2d(256, 128, 3, padding=1),
            nn.ReLU()
        )
        
        self.regressor = nn.Sequential(
            nn.Linear(128 * 6 * 6, 4096),
            nn.ReLU(),
            nn.Dropout(),
            nn.Linear(4096, 2)  # pitch, yaw
        )
    
    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0), -1)
        x = self.regressor(x)
        return x


class GazeEstimationTransformer(nn.Module):
    """
    Transformer视线估计
    
    更强的长距离依赖建模
    """
    
    def __init__(self, dim=256, num_heads=8):
        super().__init__()
        
        # Patch embedding
        self.patch_embed = nn.Conv2d(3, dim, 16, 16)
        
        # Transformer编码器
        self.transformer = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(dim, num_heads, dim*4),
            num_layers=6
        )
        
        # 回归头
        self.head = nn.Linear(dim, 2)
    
    def forward(self, x):
        # Patch embedding
        x = self.patch_embed(x)  # (B, C, H', W')
        x = x.flatten(2).transpose(0, 1)  # (N, B, C)
        
        # Transformer
        x = self.transformer(x)
        
        # 平均池化
        x = x.mean(dim=0)
        
        # 回归
        x = self.head(x)
        
        return x


class MultiTaskGazeEstimation(nn.Module):
    """
    多任务视线估计
    
    同时预测视线、头部姿态、眨眼
    """
    
    def __init__(self):
        super().__init__()
        
        # 共享编码器
        self.encoder = nn.Sequential(
            nn.Conv2d(3, 64, 7, stride=2, padding=3),
            nn.ReLU(),
            nn.Conv2d(64, 128, 3, stride=2, padding=1),
            nn.ReLU(),
            nn.Conv2d(128, 256, 3, stride=2, padding=1),
            nn.ReLU()
        )
        
        # 视线头
        self.gaze_head = nn.Linear(256, 2)
        
        # 头部姿态头
        self.pose_head = nn.Linear(256, 3)  # pitch, yaw, roll
        
        # 眨眼头
        self.blink_head = nn.Linear(256, 2)  # open, close
    
    def forward(self, x):
        # 编码
        feat = self.encoder(x)
        feat = feat.mean(dim=[2, 3])
        
        # 多任务输出
        gaze = self.gaze_head(feat)
        pose = self.pose_head(feat)
        blink = self.blink_head(feat)
        
        return {
            'gaze': gaze,
            'pose': pose,
            'blink': blink
        }


# 性能对比
if __name__ == "__main__":
    # 输入
    x = torch.randn(8, 3, 224, 224)
    
    # 传统CNN
    cnn = GazeEstimationCNN()
    gaze_cnn = cnn(x)
    print(f"CNN输出: {gaze_cnn.shape}")
    
    # Transformer
    trans = GazeEstimationTransformer()
    gaze_trans = trans(x)
    print(f"Transformer输出: {gaze_trans.shape}")
    
    # 多任务
    multi = MultiTaskGazeEstimation()
    result = multi(x)
    print(f"多任务输出:")
    print(f"  视线: {result['gaze'].shape}")
    print(f"  头部姿态: {result['pose'].shape}")
    print(f"  眨眼: {result['blink'].shape}")

公开数据集

数据集 样本数 标注 场景
MPIIGaze 213,659 视线向量 实验室+真实
GazeCapture 2,445,504 视线向量 移动设备
UT-Multiview 1,048,890 视线向量 多视角
EyeDiap 1,200,000 视线+眨眼 多模态
DDDS 500,000 视线+分心 驾驶场景

性能指标

方法 数据集 误差(°) 帧率(fps)
AlexNet MPIIGaze 4.8 60
ResNet-50 MPIIGaze 4.5 45
ViT-Base MPIIGaze 4.2 30
LISA MPIIGaze 3.9 25

IMS开发启示

1. 方法选择

场景 推荐方法 理由
实时DMS CNN轻量化 低延迟
高精度 Transformer 更好精度
多任务 多任务网络 共享特征

2. 部署建议

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# gaze-deployment.yaml
deployment:
  platform: "QCS8255"
  
  model:
    type: "ResNet-18"  # 轻量化
    input: [224, 224]
    output: 2  # pitch, yaw
    
  optimization:
    quantization: "int8"
    latency: 15  # ms
    
  integration:
    with_fatigue: true
    with_distraction: true

结论

本文系统回顾了驾驶员视线估计方法：

  1. CNN仍是主流：实时性优先
  2. Transformer崛起：精度优先
  3. 多任务学习：综合效率最高

对于IMS开发，建议：

  • 根据应用场景选择合适架构
  • 平衡精度与实时性
  • 利用公开数据集预训练

参考文献： 详见论文原文。

DMS综述
#疲劳检测 #DMS #分心检测 #机器学习 #综述
驾驶员状态监测综述：机器学习方法系统性回顾
https://dapalm.com/2026/08/13/2026-08-14-driver-gaze-estimation-review/
作者
Mars
发布于
2026年8月13日
许可协议