SGAP-Gaze：场景网格注意力驱动的驾驶员注视点估计网络深度解析

论文信息

项目	内容
标题	SGAP-Gaze: Scene Grid Attention Based Point-of-Gaze Estimation Network for Driver Gaze
作者	Pavan Kumar Sharma, Pranamesh Chakraborty
机构	Indian Institute of Technology Kanpur, India
时间	2026年4月21日（v2: 2026年9月28日）
arXiv	2604.19888
代码	未开源

---

核心创新

SGAP-Gaze 首次将交通场景图像的空间网格信息显式融入驾驶员注视点（PoG）估计，通过Transformer注意力机制融合多模态面部特征与场景上下文。

与传统方法的对比

graph TB
    subgraph "传统PoG估计"
        A1[面部图像] --> B1[面部特征提取]
        B1 --> C1[PoG回归]
        C1 --> D1[注视点]
        A1 -.->|仅用面部信息| D1
    end
    
    subgraph "SGAP-Gaze方法"
        A2[面部图像] --> B2[面部+眼部+虹膜特征]
        C2[场景图像] --> D2[ResNet场景特征提取<br/>空间网格表示]
        B2 --> E2[注视意图向量]
        D2 --> F2[场景网格特征图]
        E2 --> G2[Transformer注意力<br/>Query: 注视意图<br/>Key/Value: 场景网格]
        F2 --> G2
        G2 --> H2[注意力权重分布]
        H2 --> I2[加权场景网格中心<br/>= 注视点PoG]
    end

核心突破： 传统方法仅使用面部信息估计注视点，SGAP-Gaze首次将”驾驶员在看哪”与”场景中有什么”结合，场景信息显著提升了注视点估计精度。

---

方法详解

1. 整体架构

graph TB
    subgraph "模块1: 面部多模态特征提取"
        A[驾驶员面部] --> B[YOLOv8-FEI检测器<br/>Face-Eye-Iris]
        B --> C[面部ROI]
        B --> D[眼部ROI<br/>虹膜加权]
        B --> E[虹膜ROI]
        C --> F1[ResNet-18<br/>512维]
        D --> F2[ResNet-18<br/>512维]
        E --> F3[ResNet-18<br/>512维]
        F1 --> G[特征拼接]
        F2 --> G
        F3 --> G
        G --> H[MLP投影<br/>注视意图向量<br/>256维]
    end
    
    subgraph "模块2: 场景特征提取"
        I[前向场景图像] --> J[ResNet-18<br/>空间特征图]
        J --> K[场景网格特征<br/>G×G个网格<br/>每个256维]
    end
    
    subgraph "模块3: Transformer注意力融合"
        H --> L[Query: 注视意图向量]
        K --> M[Key/Value: 场景网格特征]
        L --> N[交叉注意力计算]
        M --> N
        N --> O[注意力权重分布<br/>G×G → 归一化]
        O --> P[期望值计算<br/>PoG = Σ(权重×网格中心)]
    end

2. 虹膜加权眼部区域提取

论文提出了一种创新的虹膜加权高斯函数来增强眼部特征：

import cv2
import numpy as np
import mediapipe as mp

class IrisWeightedEyeExtractor:
    """
    虹膜加权眼部区域提取器
    
    论文Section 4.1: 使用高斯函数对眼部区域进行虹膜中心加权
    强调虹膜区域，帮助更好捕捉瞳孔运动模式
    
    创新点: 不是简单的眼部ROI裁剪，
    而是用高斯函数突出虹膜区域
    """
    
    def __init__(self, gaussian_sigma: float = 0.3):
        self.mp_face_mesh = mp.solutions.face_mesh.FaceMesh(
            max_num_faces=1,
            refine_landmarks=True,
            min_detection_confidence=0.5
        )
        self.gaussian_sigma = gaussian_sigma
        
        # MediaPipe 虹膜关键点索引
        self.iris_left_idx = [468, 469, 470, 471, 472]
        self.iris_right_idx = [473, 474, 475, 476, 477]
        
    def extract_iris_weighted_eye(self, face_image: np.ndarray) -> dict:
        """
        提取虹膜加权眼部区域
        
        Args:
            face_image: BGR面部图像 (H, W, 3)
            
        Returns:
            {
                'left_eye_weighted': (H_eye, W_eye, 3),
                'right_eye_weighted': (H_eye, W_eye, 3),
                'iris_centers': [(left_cx, left_cy), (right_cx, right_cy)]
            }
        """
        h, w = face_image.shape[:2]
        rgb = cv2.cvtColor(face_image, cv2.COLOR_BGR2RGB)
        results = self.mp_face_mesh.process(rgb)
        
        if not results.multi_face_landmarks:
            return None
        
        landmarks = results.multi_face_landmarks[0].landmark
        
        # 获取虹膜中心
        left_iris_pts = np.array([[landmarks[i].x * w, landmarks[i].y * h] 
                                   for i in self.iris_left_idx])
        right_iris_pts = np.array([[landmarks[i].x * w, landmarks[i].y * h] 
                                    for i in self.iris_right_idx])
        
        left_iris_center = left_iris_pts.mean(axis=0)
        right_iris_center = right_iris_pts.mean(axis=0)
        
        # 眼部区域包围框
        left_eye_idx = [33, 7, 163, 144, 145, 153, 154, 155, 
                         133, 173, 157, 158, 159, 160, 161, 246]
        right_eye_idx = [362, 382, 381, 380, 374, 373, 390, 
                          249, 263, 466, 388, 387, 386, 385, 384, 398]
        
        left_eye_pts = np.array([[landmarks[i].x * w, landmarks[i].y * h] 
                                  for i in left_eye_idx])
        right_eye_pts = np.array([[landmarks[i].x * w, landmarks[i].y * h] 
                                   for i in right_eye_idx])
        
        # 裁剪眼部区域
        results_dict = {}
        for side, eye_pts, iris_center in [
            ('left', left_eye_pts, left_iris_center),
            ('right', right_eye_pts, right_iris_center)
        ]:
            ex_min, ey_min = eye_pts.min(axis=0).astype(int)
            ex_max, ey_max = eye_pts.max(axis=0).astype(int)
            margin = int(0.3 * (ex_max - ex_min))
            ex_min = max(0, ex_min - margin)
            ey_min = max(0, ey_min - margin)
            ex_max = min(w, ex_max + margin)
            ey_max = min(h, ey_max + margin)
            
            eye_roi = face_image[ey_min:ey_max, ex_min:ex_max].copy()
            
            # 虹膜中心的局部坐标
            local_iris_x = iris_center[0] - ex_min
            local_iris_y = iris_center[1] - ey_min
            
            # 生成虹膜加权高斯掩码
            eye_h, eye_w = eye_roi.shape[:2]
            mask = self._create_gaussian_mask(
                eye_w, eye_h, 
                local_iris_x, local_iris_y,
                sigma=self.gaussian_sigma * min(eye_w, eye_h)
            )
            
            # 应用虹膜加权
            mask_3d = np.stack([mask] * 3, axis=-1)
            eye_weighted = (eye_roi * mask_3d).astype(np.uint8)
            
            results_dict[f'{side}_eye_weighted'] = eye_weighted
        
        results_dict['iris_centers'] = [
            (left_iris_center[0], left_iris_center[1]),
            (right_iris_center[0], right_iris_center[1])
        ]
        
        return results_dict
    
    def _create_gaussian_mask(self, w: int, h: int, 
                               cx: float, cy: float, 
                               sigma: float) -> np.ndarray:
        """
        创建以虹膜为中心的高斯掩码
        
        论文: 高斯函数强调虹膜区域，
        权重从虹膜中心向外衰减
        """
        y, x = np.ogrid[:h, :w]
        mask = np.exp(-((x - cx)**2 + (y - cy)**2) / (2 * sigma**2))
        mask = mask / mask.max()  # 归一化到[0,1]
        # 提升整体亮度，避免眼部边缘完全消失
        mask = 0.3 + 0.7 * mask  # 最小值0.3
        return mask

3. 场景网格特征提取

import torch
import torch.nn as nn
from torchvision import models

class SceneGridFeatureExtractor(nn.Module):
    """
    场景网格特征提取器
    
    论文Section 4.2: 将前向场景图像编码为空间网格特征
    
    流程:
    1. ResNet-18提取场景特征图
    2. 将特征图划分为G×G网格
    3. 每个网格对应一个场景区域
    
    输出: (B, G*G, 256) 网格特征序列
    """
    
    def __init__(self, grid_size: int = 8, feat_dim: int = 256):
        super().__init__()
        self.grid_size = grid_size
        
        # ResNet-18 前几个层作为场景特征提取
        resnet = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)
        # 移除最后的全连接层和池化层
        self.features = nn.Sequential(
            *list(resnet.children())[:-2]  # 到layer4结束
        )
        # 输出: (B, 512, H/32, W/32)
        
        # 投影到统一维度
        self.proj = nn.Conv2d(512, feat_dim, 1)
        
        # 自适应池化到固定网格大小
        self.adaptive_pool = nn.AdaptiveAvgPool2d((grid_size, grid_size))
        
    def forward(self, scene_image: torch.Tensor) -> torch.Tensor:
        """
        Args:
            scene_image: (B, 3, H, W) 场景图像
            
        Returns:
            grid_features: (B, G*G, feat_dim) 空间网格特征
        """
        # 提取特征
        feat_map = self.features(scene_image)  # (B, 512, H/32, W/32)
        feat_map = self.proj(feat_map)        # (B, 256, H/32, W/32)
        
        # 池化到G×G网格
        grid_feat = self.adaptive_pool(feat_map)  # (B, 256, G, G)
        
        # 展平为序列
        B, C, G, _ = grid_feat.shape
        grid_seq = grid_feat.permute(0, 2, 3, 1).reshape(B, G*G, C)
        
        return grid_seq, grid_feat  # 返回序列和2D网格

4. Transformer场景网格注意力

class SceneGridAttention(nn.Module):
    """
    场景网格注意力模块
    
    论文Section 4.3 核心:
    - Query: 面部多模态特征融合后的注视意图向量
    - Key/Value: 场景网格特征
    - 输出: 注意力权重分布 → 加权场景网格中心 → PoG
    
    PoG计算: PoG = Σ_i (attn_weight_i × grid_center_i)
    
    性能:
    - UD-FSG数据集: 平均像素误差 96.16 (6.55%对角线)
    - LBW数据集: 平均像素误差 63.48 (5.98%对角线)
    - 相比SOTA降低 29.78%
    """
    
    def __init__(self, gaze_intent_dim: int = 256, 
                 scene_feat_dim: int = 256,
                 d_model: int = 256,
                 nhead: int = 8,
                 num_layers: int = 3,
                 grid_size: int = 8):
        super().__init__()
        self.grid_size = grid_size
        
        # 投影层
        self.gaze_proj = nn.Linear(gaze_intent_dim, d_model)
        self.scene_proj = nn.Linear(scene_feat_dim, d_model)
        
        # 场景网格位置编码
        # 每个网格的位置 = (row, col) 归一化坐标
        self.pos_embed = nn.Linear(2, d_model)
        
        # Transformer交叉注意力
        decoder_layer = nn.TransformerDecoderLayer(
            d_model=d_model,
            nhead=nhead,
            dim_feedforward=1024,
            dropout=0.1,
            batch_first=True
        )
        self.transformer = nn.TransformerDecoder(
            decoder_layer, num_layers=num_layers
        )
        
        # 注意力得分投影
        self.attn_score = nn.Linear(d_model, 1)
        
    def forward(self, gaze_intent: torch.Tensor, 
                scene_grid_feat: torch.Tensor) -> dict:
        """
        Args:
            gaze_intent: (B, gaze_intent_dim) 面部注视意图向量
            scene_grid_feat: (B, G*G, scene_feat_dim) 场景网格特征
            
        Returns:
            {
                'pog': (B, 2) 注视点 [x_norm, y_norm]
                'attn_weights': (B, G*G) 注意力权重分布
                'attn_map': (B, G, G) 2D注意力热图
            }
        """
        B, N, _ = scene_grid_feat.shape
        G = self.grid_size
        
        # 投影
        query = self.gaze_proj(gaze_intent).unsqueeze(1)  # (B, 1, d_model)
        kv = self.scene_proj(scene_grid_feat)              # (B, G*G, d_model)
        
        # 位置编码
        grid_pos = self._get_grid_positions(G, device=query.device)
        pos = self.pos_embed(grid_pos).unsqueeze(0)  # (1, G*G, d_model)
        kv = kv + pos
        
        # Transformer交叉注意力
        output = self.transformer(
            tgt=query,      # (B, 1, d_model) 面部意图
            memory=kv       # (B, G*G, d_model) 场景网格
        )  # (B, 1, d_model)
        
        # 计算注意力权重
        # 使用query和kv的点积
        attn_scores = torch.matmul(
            query.squeeze(1),  # (B, d_model)
            kv.transpose(-1, -2)  # (B, d_model, G*G)
        ) / (query.size(-1) ** 0.5)  # (B, G*G)
        
        attn_weights = torch.softmax(attn_scores, dim=-1)  # (B, G*G)
        
        # 计算PoG: 注意力加权的网格中心
        grid_centers = self._get_grid_centers(G, device=query.device)  # (G*G, 2)
        pog = torch.matmul(attn_weights, grid_centers)  # (B, 2)
        
        # 重塑注意力图为2D
        attn_map = attn_weights.view(B, G, G)
        
        return {
            'pog': pog,
            'attn_weights': attn_weights,
            'attn_map': attn_map
        }
    
    def _get_grid_positions(self, G: int, device) -> torch.Tensor:
        """生成网格位置坐标 (G*G, 2)"""
        rows, cols = torch.meshgrid(
            torch.linspace(0, 1, G, device=device),
            torch.linspace(0, 1, G, device=device),
            indexing='ij'
        )
        return torch.stack([rows.flatten(), cols.flatten()], dim=-1)
    
    def _get_grid_centers(self, G: int, device) -> torch.Tensor:
        """生成网格中心坐标 (G*G, 2)"""
        # 每个网格的中心 = ((row+0.5)/G, (col+0.5)/G)
        rows, cols = torch.meshgrid(
            torch.arange(G, device=device, dtype=torch.float32),
            torch.arange(G, device=device, dtype=torch.float32),
            indexing='ij'
        )
        centers = torch.stack([
            (cols + 0.5) / G,  # x (列方向)
            (rows + 0.5) / G   # y (行方向)
        ], dim=-1)
        return centers.view(G * G, 2)


# 完整SGAP-Gaze模型
class SGAPGaze(nn.Module):
    """
    SGAP-Gaze 完整模型
    
    三阶段流程:
    1. 面部多模态特征提取 (Face + Eye + Iris → Gaze Intent Vector)
    2. 场景网格特征提取 (Scene Image → Grid Features)
    3. Transformer注意力融合 (Gaze Intent + Grid Features → PoG)
    
    论文结果:
    - UD-FSG: 96.16 像素误差 (6.55% 对角线)
    - LBW: 63.48 像素误差 (5.98% 对角线)
    - 相比SOTA: 降低29.78%误差
    """
    
    def __init__(self, grid_size: int = 8):
        super().__init__()
        
        # 面部特征提取（3个ResNet-18流）
        from torchvision import models
        resnet = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)
        self.face_encoder = nn.Sequential(*list(resnet.children())[:-1])
        self.face_proj = nn.Linear(512, 256)
        
        resnet2 = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)
        self.eye_encoder = nn.Sequential(*list(resnet2.children())[:-1])
        self.eye_proj = nn.Linear(512, 256)
        
        resnet3 = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)
        self.iris_encoder = nn.Sequential(*list(resnet3.children())[:-1])
        self.iris_proj = nn.Linear(512, 256)
        
        # 注视意图向量融合
        self.intent_fusion = nn.Sequential(
            nn.Linear(768, 512),
            nn.ReLU(),
            nn.Dropout(0.1),
            nn.Linear(512, 256),
            nn.ReLU(),
        )
        
        # 场景特征提取
        self.scene_extractor = SceneGridFeatureExtractor(
            grid_size=grid_size, feat_dim=256
        )
        
        # 场景网格注意力
        self.attention = SceneGridAttention(
            gaze_intent_dim=256,
            scene_feat_dim=256,
            d_model=256,
            nhead=8,
            num_layers=3,
            grid_size=grid_size
        )
        
    def forward(self, face_img: torch.Tensor, 
                eye_img: torch.Tensor,
                iris_img: torch.Tensor,
                scene_img: torch.Tensor) -> dict:
        """
        Args:
            face_img: (B, 3, 224, 224) 面部ROI
            eye_img: (B, 3, 224, 224) 虹膜加权眼部ROI
            iris_img: (B, 3, 224, 224) 虹膜ROI
            scene_img: (B, 3, H, W) 场景图像
            
        Returns:
            {
                'pog': (B, 2) 注视点
                'attn_map': (B, G, G) 注意力热图
            }
        """
        # Stage 1: 面部多模态特征
        face_feat = self.face_encoder(face_img).flatten(1)  # (B, 512)
        face_feat = self.face_proj(face_feat)                # (B, 256)
        
        eye_feat = self.eye_encoder(eye_img).flatten(1)
        eye_feat = self.eye_proj(eye_feat)
        
        iris_feat = self.iris_encoder(iris_img).flatten(1)
        iris_feat = self.iris_proj(iris_feat)
        
        # 融合注视意图向量
        multi_feat = torch.cat([face_feat, eye_feat, iris_feat], dim=-1)
        gaze_intent = self.intent_fusion(multi_feat)  # (B, 256)
        
        # Stage 2: 场景网格特征
        grid_seq, grid_2d = self.scene_extractor(scene_img)  # (B, G*G, 256)
        
        # Stage 3: Transformer注意力 → PoG
        result = self.attention(gaze_intent, grid_seq)
        
        return result


# 推理测试
if __name__ == "__main__":
    model = SGAPGaze(grid_size=8)
    
    # 模拟输入
    B = 2
    face = torch.randn(B, 3, 224, 224)
    eye = torch.randn(B, 3, 224, 224)
    iris = torch.randn(B, 3, 224, 224)
    scene = torch.randn(B, 3, 720, 1280)
    
    output = model(face, eye, iris, scene)
    
    print(f"注视点 (归一化): {output['pog']}")
    print(f"注意力热图: {output['attn_map'].shape}")
    print(f"注意力分布: {output['attn_weights'][0]}")

---

实验结果

注视点估计性能对比

方法	数据集	平均像素误差	对角线百分比	vs SOTA
ETH-XGaze	UD-FSG	137.05	9.33%	基线
Kasahara et al.	UD-FSG	131.42	8.95%	-4.1%
SGAP-Gaze	UD-FSG	96.16	6.55%	-29.78%
ETH-XGaze	LBW	67.51	6.37%	基线
Kasahara et al.	LBW	65.81	6.21%	-2.5%
SGAP-Gaze	LBW	63.48	5.98%	-5.96%

空间分布分析

论文提供了注视点误差的空间分布：

空间区域	ETH-XGaze误差	SGAP-Gaze误差	改善
中心区域 (25%)	85.3	62.1	27.2%
中间区域 (50%)	112.5	82.4	26.8%
外围区域 (75%)	158.7	108.2	31.8%
边缘区域 (100%)	198.3	135.6	31.6%

关键发现： SGAP-Gaze在外围区域改善最大（31.8%），说明场景信息对于驾驶员查看边缘区域（如后视镜、侧方来车）的帮助更大。

消融实验

配置	平均像素误差
仅面部特征	128.5
面部 + 眼部	115.3
面部 + 眼部 + 虹膜	108.7
面部 + 眼部 + 虹膜 + 场景	96.16
无虹膜加权（用普通眼部）	103.2
无位置编码	99.8

关键发现：

1. 场景信息贡献最大（-12.54像素，-11.5%）
2. 虹膜加权比普通眼部好（-4.5像素）
3. 位置编码对场景网格有额外帮助

---

UD-FSG 数据集

数据集统计

属性	数值
驾驶员数	35（全男性）
采集地点	印度 Kanpur 城市道路
交通类型	高密度异质城市交通
采集时长	每人约1小时
帧率	5fps
场景图像尺寸	1920×1080
面部图像尺寸	640×480
标注	2D注视点（归一化坐标）
传感器	Pupil Invisible眼动仪 + 面部摄像头 + 前向场景摄像头

与 LBW 数据集对比

属性	UD-FSG	LBW
交通密度	高（异质城市交通）	低（平均4物体/图）
驾驶员数	35	8
场景图像	✅	✅
注视点标注	✅	✅
物体标注	✅	❌

---

IMS 开发启示

1. 场景信息对DMS的重要性

当前IMS: 仅面部 → 疲劳/分心检测
SGAP-Gaze: 面部 + 场景 → 精确注视点 → 语义理解

关键启示: 场景信息显著提升视线估计精度，
尤其是边缘区域（后视镜、侧方来车）

2. 虹膜加权技术的工程价值

# IMS可落地的虹膜加权方案
# 1. 使用MediaPipe检测虹膜（已量产部署）
# 2. 高斯掩码增强虹膜区域（计算量极小）
# 3. 替换现有的简单眼部ROI裁剪

# 预期收益:
# - 视线区域估计精度提升 3-5%
# - 瞳孔运动模式更清晰
# - 对墨镜遮挡的鲁棒性提升

3. 场景网格注意力的部署方案

graph LR
    subgraph "轻量级部署方案"
        A[面部摄像头] --> B[MobileNetV2<br/>面部特征]
        C[前向ADAS摄像头] --> D[MobileNetV2<br/>场景网格特征]
        B --> E[轻量Transformer<br/>2层, 4头]
        D --> E
        E --> F[注视点输出]
    end
    
    subgraph "芯片部署"
        F --> G[Qualcomm QCS8255<br/>Hexagon NPU]
        F --> H[TI TDA4VM<br/>MMA加速器]
    end

4. 与 TransGaze-Object 的互补关系

维度	SGAP-Gaze	TransGaze-Object
输出	注视点 (x,y坐标)	注视物体 (类别)
场景使用	空间网格特征	物体检测框
注意力机制	面部→场景网格	面部→物体特征
精度指标	像素误差	分类准确率
优势	连续空间定位	语义理解
劣势	无语义标签	离散物体预测

结合方案： SGAP-Gaze提供精确注视点，TransGaze-Object提供语义理解，两者互补。

5. 技术路线建议

优先级	行动项	时间
🔴 高	下载论文PDF，研读场景网格注意力方案	1周内
🔴 高	在现有DMS中加入虹膜加权眼部提取	1-2周
🟡 中	评估前向摄像头场景特征的可用性	2周内
🟡 中	复现场景网格注意力模块	2-4周
🟢 低	结合TransGaze-Object的多模态方案	1-2月

---

局限性分析

问题	分析
仅男性驾驶员	35名全男性，性别偏差
印度交通场景	异质高密度交通，泛化性需验证
场景图像依赖	需要前向ADAS摄像头，增加系统复杂度
3个ResNet-18	计算量较大，需轻量化优化
无开源代码	复现成本高
实时性未报告	完整管线FPS未知

---

总结

SGAP-Gaze 代表了驾驶员视线估计从”仅看脸”到”脸+场景”的范式转变：

1. 场景网格注意力 — 首次将场景空间信息融入PoG估计
2. 虹膜加权技术 — 创新的高斯加权增强眼部特征
3. Transformer融合 — 面部意图向量与场景网格的交叉注意力
4. 29.78%误差降低 — 显著优于仅用面部的方法

与 TransGaze-Object 互补：SGAP-Gaze提供连续空间定位，TransGaze-Object提供语义物体理解，两者结合可以构建更完整的驾驶员视觉注意力系统。