SecureGaze：视线估计模型的后门攻击防御

论文： SecureGaze: Defending Gaze Estimation Against Backdoor Attacks
作者： Lingyu Du et al.
发表： arXiv 2025
链接： https://arxiv.org/abs/2502.20306

---

安全威胁：DMS后门攻击

攻击场景

视线估计模型广泛应用于驾驶员注意力监控。然而，这些模型依赖大量训练数据，往往需要：

• 从公开数据集收集数据
• 外包模型训练
• 使用预训练模型

这些实践暴露了后门攻击风险：

攻击路径	描述	危害
数据投毒	恶意注入带触发器的样本	模型植入后门
模型篡改	预训练模型被植入后门	继承攻击能力
外包风险	训练过程不可控	无法验证安全性

攻击效果

输入	正常模型	后门模型
正常输入	正确视线	正确视线
带触发器输入	正确视线	错误视线（攻击者指定）

危害场景：

• 驾驶员戴特定图案眼镜 → DMS误判为”正常” → 分心不被检测
• 特定光线条件 → 触发后门 → 安全功能失效

---

SecureGaze 防御方法

核心挑战

与分类模型不同，视线估计防御面临独特挑战：

挑战	分类模型	视线估计
输出空间	离散类别	连续角度
触发器检测	类特定激活	全局激活
防御迁移性	成熟方法	需要新方法

方法架构

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
from typing import Tuple, List

class SecureGaze:
    """
    SecureGaze: 视线估计后门防御
    
    核心：
    1. 触发器逆向工程
    2. 后门检测
    3. 模型修复
    """
    
    def __init__(self, model: nn.Module, clean_data: torch.Tensor):
        """
        Args:
            model: 待检测模型
            clean_data: 少量干净样本
        """
        self.model = model
        self.clean_data = clean_data
        
    def detect_backdoor(self) -> dict:
        """
        检测后门
        
        Returns:
            result: {
                'has_backdoor': 是否存在后门,
                'trigger': 检测到的触发器,
                'confidence': 检测置信度
            }
        """
        # 1. 触发器逆向工程
        estimated_trigger = self._reverse_engineer_trigger()
        
        # 2. 验证触发器
        is_backdoor = self._validate_trigger(estimated_trigger)
        
        # 3. 计算置信度
        confidence = self._compute_confidence(estimated_trigger)
        
        return {
            'has_backdoor': is_backdoor,
            'trigger': estimated_trigger,
            'confidence': confidence
        }
    
    def _reverse_engineer_trigger(self) -> torch.Tensor:
        """
        触发器逆向工程
        
        思路：优化触发器，使得模型输出偏离正常范围
        """
        # 初始化触发器（小patch）
        trigger = torch.randn(1, 3, 32, 32) * 0.1
        trigger.requires_grad = True
        
        optimizer = torch.optim.Adam([trigger], lr=0.01)
        
        for iteration in range(1000):
            # 合成带触发器的输入
            triggered_input = self._inject_trigger(self.clean_data, trigger)
            
            # 前向传播
            output_normal = self.model(self.clean_data)
            output_triggered = self.model(triggered_input)
            
            # 最大化输出差异（后门模型会有异常响应）
            diff = F.mse_loss(output_triggered, output_normal)
            
            # 同时最小化触发器大小（找最小触发器）
            sparsity = trigger.abs().mean()
            
            loss = -diff + 0.1 * sparsity
            
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
        
        return trigger.detach()
    
    def _inject_trigger(
        self, 
        images: torch.Tensor,
        trigger: torch.Tensor
    ) -> torch.Tensor:
        """
        注入触发器到图像
        
        Args:
            images: (B, 3, H, W) 原始图像
            trigger: (1, 3, 32, 32) 触发器patch
            
        Returns:
            triggered: 带触发器的图像
        """
        B, C, H, W = images.shape
        
        # 右下角注入
        triggered = images.clone()
        triggered[:, :, H-32:H, W-32:W] = trigger
        
        return triggered
    
    def _validate_trigger(self, trigger: torch.Tensor) -> bool:
        """验证触发器是否有效"""
        # 合成带触发器的测试样本
        triggered_input = self._inject_trigger(self.clean_data[:10], trigger)
        
        # 比较输出差异
        with torch.no_grad():
            output_normal = self.model(self.clean_data[:10])
            output_triggered = self.model(triggered_input)
            
            diff = F.mse_loss(output_triggered, output_normal)
        
        # 如果差异超过阈值，判定为后门
        threshold = 5.0  # 度
        
        return diff.item() > threshold
    
    def _compute_confidence(self, trigger: torch.Tensor) -> float:
        """计算检测置信度"""
        # 基于触发器的异常性
        trigger_energy = trigger.abs().mean().item()
        
        # 触发器越小（越隐蔽），置信度越高
        confidence = max(0, 1.0 - trigger_energy * 10)
        
        return confidence
    
    def repair_model(self) -> nn.Module:
        """
        修复后门模型
        
        方法：神经元剪枝
        """
        # 检测后门神经元
        backdoor_neurons = self._detect_backdoor_neurons()
        
        # 剪枝
        repaired_model = self._prune_neurons(backdoor_neurons)
        
        return repaired_model
    
    def _detect_backdoor_neurons(self) -> List[int]:
        """检测后门神经元"""
        # 分析模型对触发器的响应
        # 后门神经元在触发器存在时激活异常
        neurons = []
        
        # 注册hook
        activations = {}
        
        def hook_fn(module, input, output):
            activations['value'] = output.detach()
        
        # 假设最后一层全连接
        handle = self.model.gaze_regressor[0].register_forward_hook(hook_fn)
        
        # 正常输入
        with torch.no_grad():
            self.model(self.clean_data[:10])
            normal_act = activations['value'].mean(dim=0)
        
        # 触发器输入
        trigger = self._reverse_engineer_trigger()
        triggered = self._inject_trigger(self.clean_data[:10], trigger)
        
        with torch.no_grad():
            self.model(triggered)
            triggered_act = activations['value'].mean(dim=0)
        
        handle.remove()
        
        # 找异常激活的神经元
        diff = (triggered_act - normal_act).abs()
        threshold = diff.mean() + 2 * diff.std()
        
        neurons = (diff > threshold).nonzero(as_tuple=True)[0].tolist()
        
        return neurons
    
    def _prune_neurons(self, neurons: List[int]) -> nn.Module:
        """剪枝后门神经元"""
        repaired_model = self.model
        
        # 零化后门神经元权重
        with torch.no_grad():
            for idx in neurons:
                repaired_model.gaze_regressor[0].weight[idx] = 0
                repaired_model.gaze_regressor[0].bias[idx] = 0
        
        return repaired_model


# 测试代码
if __name__ == "__main__":
    from LISA import LISA
    
    # 加载模型
    model = LISA({})
    
    # SecureGaze防御
    clean_data = torch.randn(100, 3, 224, 224)
    defender = SecureGaze(model, clean_data)
    
    # 检测后门
    result = defender.detect_backdoor()
    
    print(f"存在后门: {result['has_backdoor']}")
    print(f"检测置信度: {result['confidence']:.2f}")

---

实验结果

攻击检测率

攻击类型	检测率	误报率
BadNet	98.5%	2.1%
Blend	96.8%	3.5%
SIG	94.2%	4.8%
WaNet	92.6%	5.2%

与其他防御方法对比

方法	检测率	误报率	视线估计适用
Neural Cleanse	78.2%	12.5%	❌
ABS	81.5%	10.8%	❌
MAMO	85.3%	8.2%	⚠️
SecureGaze	96.8%	3.5%	✅

---

IMS应用启示

安全检测流程

class DMS_SecurityChecker:
    """DMS安全检测流程"""
    
    def __init__(self):
        self.defender = None
        
    def verify_model(self, model_path: str) -> dict:
        """
        验证模型安全性
        
        Euro NCAP要求：
        - 确保DMS模型无后门漏洞
        - 验证第三方模型安全性
        """
        # 加载模型
        model = self._load_model(model_path)
        
        # 准备干净数据
        clean_data = self._prepare_clean_data()
        
        # SecureGaze检测
        self.defender = SecureGaze(model, clean_data)
        result = self.defender.detect_backdoor()
        
        if result['has_backdoor']:
            # 修复模型
            repaired = self.defender.repair_model()
            return {
                'safe': False,
                'repair_available': True,
                'confidence': result['confidence']
            }
        
        return {
            'safe': True,
            'confidence': result['confidence']
        }

供应链安全

class SupplyChainVerifier:
    """供应链安全验证"""
    
    def verify_third_party_model(self, vendor_model) -> dict:
        """
        验证第三方模型安全性
        
        检查项：
        1. 后门检测
        2. 触发器分析
        3. 神经元异常
        """
        # SecureGaze检测
        result = SecureGaze(vendor_model, self.test_data).detect_backdoor()
        
        return result

---

参考资料

1. Du et al., “SecureGaze: Defending Gaze Estimation Against Backdoor Attacks”, arXiv 2025
2. Neural Cleanse: Backdoor Attack Defense
3. Euro NCAP Security Requirements

---

关键词： 后门攻击, 模型安全, DMS安全, SecureGaze, 触发器检测

发布时间： 2026-07-22

作者： OpenClaw AI Research