GazeCapsNet轻量化视线估计：11.7M参数20ms推理的边缘AI突破——IMS视线追踪新方案

论文信息

项目	内容
标题	GazeCapsNet: A Lightweight Gaze Estimation Framework
会议/期刊	Sensors 2025
年份	2025
链接	https://pmc.ncbi.nlm.nih.gov/articles/PMC11860563/
核心创新	胶囊网络 + Self-Attention Routing + MobileNet融合

核心创新

轻量化视线估计突破：

• 11.7M参数（vs 传统196M）
• 20ms推理延迟（实时50fps）
• MAE降低15%（ETH-XGaze/Gaze360）
• 无面部关键点依赖（端到端预测）

适用于Euro NCAP 2026 DSM的Owl/Lizard检测，边缘设备可直接部署。

1. 问题背景

1.1 传统视线估计的局限

方法	模型参数	推理延迟	MAE精度	局限
FullFace	196.6M	50ms	4.8°	计算量巨大
RT-GENE	~100M	40ms	5.1°	仍偏重
GazeTR-Pure	>200M	>100ms	4.3°	Transformer不实用
传统CNN	~50M	30ms	6-8°	精度不足

1.2 IMS视线估计需求

Euro NCAP场景	精度要求	延迟要求	模型大小限制
Owl检测（头部）	±10°	≤50ms	<20MB
Lizard检测（眼球）	±5°	≤30ms	<10MB
手机位置判定	±3°	≤20ms	<5MB

1.3 车载边缘设备限制

平台	NPU算力	内存	模型大小限制
QCS8255	26TOPS	4GB	<50MB
TI TDA4VM	8TOPS	2GB	<20MB
NXP S32G	5TOPS	1GB	<10MB

2. GazeCapsNet架构详解

2.1 核心架构

graph TD
    A[输入图像] --> B[MobileNet v2特征提取]
    A --> C[ResNet-18特征提取]
    
    B --> D[特征融合]
    C --> D
    
    D --> E[胶囊网络CapsNet]
    
    E --> F[Self-Attention Routing]
    
    F --> G[动态路由]
    G --> H[空间层次保持]
    
    H --> I[3D视线向量输出]
    
    I --> J[θx, θy, θz]

2.2 胶囊网络优势

特性	传统CNN	胶囊网络	优势
空间层次	丢失	保持	面部部件关系保留
视角变化	需大量数据	天然鲁棒	头部姿态变化适应
特征表达	标量	向量	更丰富特征编码
动态路由	无	SAR	自动聚焦关键区域

2.3 Self-Attention Routing (SAR)

"""
Self-Attention Routing (SAR) 实现
参考：GazeCapsNet论文

核心思想：
- 替代迭代路由（计算量大）
- 使用注意力机制动态分配资源
- 轻量化+精度保持
"""

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

class SelfAttentionRouting(nn.Module):
    """
    自注意力路由机制
    
    原理：
    1. 计算低层胶囊到高层胶囊的注意力权重
    2. 基于权重聚合低层胶囊输出
    3. 非线性"squash"激活
    
    优势：
    - 无迭代（vs 传统Routing）
    - 计算量大幅降低
    - 自动聚焦关键面部区域
    """
    
    def __init__(
        self,
        in_channels: int,
        out_channels: int,
        num_routes: int,
        attention_dim: int = 64
    ):
        """
        Args:
            in_channels: 输入胶囊通道数
            out_channels: 输出胶囊通道数
            num_routes: 路由数量
            attention_dim: 注意力维度
        """
        super().__init__()
        
        # 注意力计算
        self.attention = nn.Sequential(
            nn.Linear(in_channels, attention_dim),
            nn.ReLU(),
            nn.Linear(attention_dim, out_channels),
            nn.Softmax(dim=-1)
        )
        
        # 路由权重
        self.route_weights = nn.Parameter(
            torch.randn(num_routes, in_channels, out_channels)
        )
        
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """
        前向传播
        
        Args:
            x: 低层胶囊输出, shape=(B, N, in_channels)
               N = num_routes
               
        Returns:
            v_j: 高层胶囊输出, shape=(B, out_channels)
        
        SAR流程：
        1. 计算注意力权重 c_ij
        2. 加权聚合 s_j = Σ c_ij * u_i
        3. squash激活 v_j = ||s_j||² / (1+||s_j||²) * s_j / ||s_j||
        """
        B, N, D_in = x.shape
        
        # 计算注意力权重
        c_ij = self.attention(x)  # (B, N, out_channels)
        
        # 加权聚合
        # s_j = Σ c_ij * u_i * W_ij
        s_j = torch.einsum('bnd,nkd->bkd', x, self.route_weights)
        s_j = torch.einsum('bnd,bnd->bd', s_j, c_ij)
        
        # Squash激活
        # v_j = ||s_j||² / (1+||s_j||²) * s_j / ||s_j||
        norm_s = torch.norm(s_j, dim=-1, keepdim=True)
        squash_factor = norm_s ** 2 / (1 + norm_s ** 2)
        v_j = squash_factor * s_j / (norm_s + 1e-8)
        
        return v_j


class GazeCapsNet(nn.Module):
    """
    GazeCapsNet完整模型
    
    架构：
    1. MobileNet v2 + ResNet-18 双分支特征提取
    2. 特征融合
    3. 初级胶囊层
    4. SAR路由到高层胶囊
    5. 3D视线向量回归
    """
    
    def __init__(
        self,
        gaze_dim: int = 3,  # θx, θy, θz
        num_primary_caps: int = 32,
        primary_caps_dim: int = 8,
        num_classes_caps: int = 16
    ):
        super().__init__()
        
        # MobileNet v2特征提取（轻量化）
        self.mobilenet = nn.Sequential(
            nn.Conv2d(3, 32, 3, stride=2, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            
            # MobileNet v2 block简化版
            nn.Conv2d(32, 64, 3, stride=1, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            
            nn.Conv2d(64, 128, 3, stride=2, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(),
            
            nn.Conv2d(128, 256, 3, stride=2, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(),
            
            nn.AdaptiveAvgPool2d(1)
        )
        
        # ResNet-18特征提取（补充）
        self.resnet_lite = nn.Sequential(
            nn.Conv2d(3, 64, 7, stride=2, padding=3),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(3, stride=2, padding=1),
            
            nn.Conv2d(64, 128, 3, stride=2, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(),
            
            nn.AdaptiveAvgPool2d(1)
        )
        
        # 特征融合
        self.fusion = nn.Sequential(
            nn.Linear(256 + 128, 512),
            nn.ReLU(),
            nn.Dropout(0.3)
        )
        
        # 初级胶囊层
        self.primary_caps = nn.Sequential(
            nn.Linear(512, num_primary_caps * primary_caps_dim),
            nn.ReLU()
        )
        
        # SAR路由
        self.sar = SelfAttentionRouting(
            in_channels=primary_caps_dim,
            out_channels=num_classes_caps,
            num_routes=num_primary_caps
        )
        
        # 视线回归头
        self.gaze_head = nn.Sequential(
            nn.Linear(num_classes_caps, 64),
            nn.ReLU(),
            nn.Linear(64, gaze_dim)
        )
        
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """
        前向传播
        
        Args:
            x: 输入图像, shape=(B, C, H, W)
            
        Returns:
            gaze_vector: 3D视线向量, shape=(B, 3)
               θx: 水平角度（左负右正）
               θy: 垂直角度（上负下正）
               θz: 深度方向（前正后负）
        """
        B = x.shape[0]
        
        # 双分支特征提取
        feat1 = self.mobilenet(x).view(B, -1)  # (B, 256)
        feat2 = self.resnet_lite(x).view(B, -1)  # (B, 128)
        
        # 特征融合
        fused = self.fusion(torch.cat([feat1, feat2], dim=-1))
        
        # 初级胶囊
        primary = self.primary_caps(fused)  # (B, num_primary_caps * primary_caps_dim)
        primary = primary.view(B, -1, 8)  # (B, num_primary_caps, primary_caps_dim)
        
        # SAR路由
        high_caps = self.sar(primary)  # (B, num_classes_caps)
        
        # 视线回归
        gaze = self.gaze_head(high_caps)  # (B, 3)
        
        return gaze


# 测试
if __name__ == "__main__":
    model = GazeCapsNet()
    
    # 计算参数量
    total_params = sum(p.numel() for p in model.parameters())
    print(f"模型参数: {total_params / 1e6:.2f}M")
    
    # 模拟输入
    x = torch.randn(4, 3, 112, 112)
    
    # 推理
    import time
    start = time.time()
    gaze = model(x)
    elapsed = (time.time() - start) * 1000
    
    print(f"推理延迟: {elapsed:.2f}ms")
    print(f"视线向量:")
    for i in range(4):
        print(f"  样本{i+1}: θx={gaze[i,0]:.1f}°, θy={gaze[i,1]:.1f}°, θz={gaze[i,2]:.1f}°")

2.4 无面部关键点依赖

传统方法	GazeCapsNet
先检测关键点	直接预测视线
1. 人脸检测	无需关键点
2. 关键点定位	端到端回归
3. 特征提取	减少计算步骤
4. 视线估计	简化pipeline

优势：

• 减少计算量
• 避免关键点检测误差传递
• 更好的泛化性

3. 性能对比

3.1 基准测试结果

数据集	GazeCapsNet MAE	FullFace MAE	RT-GENE MAE	提升
ETH-XGaze	3.8°	4.8°	5.1°	-21%
Gaze360	6.2°	7.3°	7.8°	-15%
MPIIFaceGaze	4.1°	4.8°	5.0°	-15%

3.2 轻量化对比

模型	参数量	延迟	适用平台
GazeCapsNet	11.7M	20ms	移动端/车载
FullFace	196.6M	50ms	GPU服务器
RT-GENE	~100M	40ms	高性能SoC
传统CNN	~50M	30ms	中等性能

3.3 边缘部署测试

平台	延迟	内存占用	可部署性
QCS8255 (NPU)	25ms	45MB	✅ 可部署
TI TDA4VM	35ms	38MB	✅ 可部署
NXP S32G	50ms	30MB	✅ 可部署
智能手机CPU	80ms	50MB	⚠️ 略慢

4. IMS开发启示

4.1 Owl检测应用

"""
GazeCapsNet应用于Euro NCAP 2026 Owl检测

Owl检测：基于头部运动推断视线
精度要求：±10°
GazeCapsNet精度：±3.8° → 完全满足
"""

import torch
import numpy as np

class OwlDetector:
    """
    Owl检测器（基于GazeCapsNet）
    
    Euro NCAP 2026 Owl场景：
    - D-01: 驾驶员侧窗查看（Yaw > 30°）
    - D-02: 副驾侧窗查看（Yaw > 30°）
    - D-08: 后视镜查看（Yaw ≈ 15-30°）
    """
    
    def __init__(self, model_path: str = None):
        self.model = GazeCapsNet()
        
        # 加载预训练权重（实际应用）
        # if model_path:
        #     self.model.load_state_dict(torch.load(model_path))
        
        # Owl阈值
        self.owl_thresholds = {
            'side_window_yaw': 30,  # 侧窗：Yaw > 30°
            'mirror_yaw': 15,       # 后视镜：Yaw ≈ 15-30°
            'dashboard_pitch': 10   # 仪表盘：Pitch > 10°
        }
        
    def detect_owl_scenario(
        self,
        gaze_vector: torch.Tensor
    ) -> Dict[str, bool]:
        """
        检测Owl场景
        
        Args:
            gaze_vector: 视线向量 (θx, θy, θz)
            
        Returns:
            scenarios: 各场景检测结果
        """
        theta_x = gaze_vector[0].item()  # 水平角度
        theta_y = gaze_vector[1].item()  # 垂直角度
        
        scenarios = {
            'left_window': abs(theta_x) > self.owl_thresholds['side_window_yaw'] and theta_x < 0,
            'right_window': abs(theta_x) > self.owl_thresholds['side_window_yaw'] and theta_x > 0,
            'mirror': abs(theta_x) >= self.owl_thresholds['mirror_yaw'] and 
                      abs(theta_x) <= self.owl_thresholds['side_window_yaw'],
            'dashboard': theta_y > self.owl_thresholds['dashboard_pitch']
        }
        
        return scenarios


# 测试
if __name__ == "__main__":
    detector = OwlDetector()
    
    # 场景1：驾驶员侧窗查看
    gaze_left = torch.tensor([-35, 0, 0])
    scenarios = detector.detect_owl_scenario(gaze_left)
    print(f"左侧窗查看场景:")
    print(f"  视线向量: θx={gaze_left[0]:.1f}°")
    print(f"  检测结果: {scenarios}")
    
    # 场景2：后视镜查看
    gaze_mirror = torch.tensor([20, -5, 0])
    scenarios = detector.detect_owl_scenario(gaze_mirror)
    print(f"\n后视镜查看场景:")
    print(f"  视线向量: θx={gaze_mirror[0]:.1f}°")
    print(f"  检测结果: {scenarios}")

4.2 Lizard检测应用

"""
GazeCapsNet应用于Euro NCAP 2026 Lizard检测

Lizard检测：基于眼球注视点检测
精度要求：±5°
GazeCapsNet精度：±3.8° → 完全满足

关键：手机位置判定需要高精度视线
"""

class LizardDetector:
    """
    Lizard检测器（基于GazeCapsNet）
    
    Euro NCAP 2026 Lizard场景：
    - P-01: 驾驶员膝盖（外侧）
    - P-02: 驾驶员膝盖（内侧）
    - P-06: 方向盘9-11点钟区域（Advanced）
    - P-08: 风挡视野内（Advanced）
    """
    
    def __init__(self):
        # Gaze区域定义（相对于驾驶员）
        self.gaze_regions = {
            'left_knee': {'x': (-40, -20), 'y': (20, 40)},
            'right_knee': {'x': (20, 40), 'y': (20, 40)},
            'lap': {'x': (-10, 10), 'y': (20, 35)},
            'steering_wheel_upper': {'x': (-15, 15), 'y': (5, 15)},  # Advanced
            'windshield': {'x': (-20, 20), 'y': (-10, 5)},          # Advanced
            'dashboard': {'x': (-25, 25), 'y': (10, 20)},
            'navigation_screen': {'x': (-20, 20), 'y': (10, 15)}
        }
        
    def classify_gaze_region(
        self,
        gaze_vector: torch.Tensor
    ) -> str:
        """
        分类视线落点区域
        
        Args:
            gaze_vector: 视线向量
            
        Returns:
            region_name: 区域名称
        """
        theta_x = gaze_vector[0].item()
        theta_y = gaze_vector[1].item()
        
        for region_name, bounds in self.gaze_regions.items():
            x_min, x_max = bounds['x']
            y_min, y_max = bounds['y']
            
            if x_min <= theta_x <= x_max and y_min <= theta_y <= y_max:
                return region_name
        
        return 'road_center'  # 正常道路前方
    
    def classify_phone_use(
        self,
        region_name: str
    ) -> str:
        """
        分类手机使用类型
        
        Args:
            region_name: 视线区域
            
        Returns:
            phone_type: 'Basic' / 'Advanced' / 'None'
        
        Euro NCAP 2026判定：
        - Basic: 膝盖/腿上/仪表盘固定位置
        - Advanced: 方向盘上方/风挡视野
        """
        basic_regions = ['left_knee', 'right_knee', 'lap', 'dashboard']
        advanced_regions = ['steering_wheel_upper', 'windshield']
        
        if region_name in advanced_regions:
            return 'Advanced'
        elif region_name in basic_regions:
            return 'Basic'
        else:
            return 'None'


# 测试
if __name__ == "__main__":
    detector = LizardDetector()
    
    # 场景1：Basic手机使用（膝盖）
    gaze_knee = torch.tensor([30, 30])  # 右膝盖
    region = detector.classify_gaze_region(gaze_knee)
    phone_type = detector.classify_phone_use(region)
    print(f"膝盖手机使用:")
    print(f"  视线: θx={gaze_knee[0]:.1f}°, θy={gaze_knee[1]:.1f}°")
    print(f"  区域: {region}")
    print(f"  手机类型: {phone_type}")
    
    # 场景2：Advanced手机使用（方向盘上方）
    gaze_steering = torch.tensor([5, 12])
    region = detector.classify_gaze_region(gaze_steering)
    phone_type = detector.classify_phone_use(region)
    print(f"\n方向盘上方手机使用:")
    print(f"  视线: θx={gaze_steering[0]:.1f}°, θy={gaze_steering[1]:.1f}°")
    print(f"  区域: {region}")
    print(f"  手机类型: {phone_type} → 二级警告+FCW")

4.3 开发优先级

优先级	开发项	技术路线	Euro NCAP得分
🔴 P0	GazeCapsNet移植	PyTorch → ONNX	Owl/Lizard基础
🔴 P0	Owl场景检测	Yaw阈值判定	0.06分/场景
🔴 P0	Lizard区域分类	Gaze区域判定	0.06分/场景
🟡 P1	手机位置判定	Advanced/Basic分类	0.12分
🟡 P1	边缘量化部署	INT8量化	提升性能
🟢 P2	多任务训练	视线+疲劳联合	精度+5%

4.4 系统架构

graph TD
    A[车内摄像头] --> B[图像预处理]
    
    B --> C[GazeCapsNet模型]
    
    C --> D[3D视线向量]
    
    D --> E{Owl检测}
    D --> F{Lizard检测}
    
    E --> G[Yaw/Pitch阈值判定]
    F --> H[Gaze区域分类]
    
    G --> I[分心场景判定]
    H --> J[手机使用分类]
    
    I --> K[警告触发]
    J --> L[Basic:一级警告]
    J --> M[Advanced:二级+FCW]
    
    K --> N[Euro NCAP DSM评分]

5. 总结

GazeCapsNet是轻量化视线估计的突破：

核心优势

1. 11.7M参数：比传统CNN小16倍
2. 20ms推理：满足车载实时要求
3. MAE -15%：精度优于传统方法
4. 无关键点依赖：简化pipeline

IMS落地要点

• Owl检测精度满足：±3.8° < ±10°要求
• Lizard检测精度满足：±3.8° < ±5°要求
• 边缘部署可行：11.7M参数在QCS8255/TDA4VM均可运行
• 多场景覆盖：侧窗/后视镜/仪表盘/手机位置全覆盖

Euro NCAP 2026贡献

• Owl场景得分：0.06分/场景 × 8场景 = 0.48分
• Lizard场景得分：0.06分/场景 × 6场景 = 0.36分
• 手机分类得分：0.12分
• 总计：约1分，占DSM总分的重要部分

---

参考链接：

• https://pmc.ncbi.nlm.nih.gov/articles/PMC11860563/
• https://arxiv.org/html/2411.18064v1 (Lightweight Gaze Estimation)
• https://www.mdpi.com/2076-3417/16/2/1037 (Edge-VisionGuard)