安全带误用检测：轻量级YOLOv7+Triplet Attention实现车载实时部署

论文信息

• 标题： Seatbelt Detection Algorithm Improved with Lightweight Approach and Attention Mechanism
• 来源： Applied Sciences, MDPI, 2024
• 链接： https://www.mdpi.com/2076-3417/14/8/3346
• 关键词： 安全带检测、轻量级网络、注意力机制、YOLOv7

Euro NCAP 2026 新要求

Euro NCAP 2026 新增**安全带误用检测（Belt Misuse Detection）**要求：

检测类型	描述	警告要求
未系安全带	驾驶员/乘客未系	立即警告
错误佩戴	安全带绕过肩膀	≤3秒警告
儿童座椅误用	儿童座椅安装错误	≤5秒警告

核心创新

1. 两阶段架构

输入图像 (640×480)
    ↓
GM-YOLOv7：驾驶员区域检测
    ↓
RST-Net：安全带分类
    ↓
输出：系好/未系/错误佩戴

2. 轻量化设计

组件	原始方案	改进方案	参数量降低
骨干网络	YOLOv7-tiny	Ghost-YOLOv7	60%
卷积模块	标准卷积	Ghost模块	50%
激活函数	Leaky ReLU	Mish	-
分类网络	ResNet-50	RST-Net	70%

方法详解

1. Ghost模块原理

import torch
import torch.nn as nn

class GhostModule(nn.Module):
    """
    Ghost模块：用廉价线性操作生成更多特征图
    
    论文Section 3.2.1：
    - 传统卷积：c×k²×n×h'×w' FLOPs
    - Ghost模块：减少约50% FLOPs
    
    原理：
    1. 少量普通卷积生成 m 个原始特征图
    2. 廉价线性操作生成 m×(s-1) 个Ghost特征图
    3. 拼接得到 n=m×s 个输出特征图
    """
    
    def __init__(self, in_channels, out_channels, kernel_size=1, 
                 ratio=2, dw_size=3, stride=1, relu=True):
        super().__init__()
        
        init_channels = out_channels // ratio
        new_channels = init_channels * (ratio - 1)
        
        # 第一步：普通卷积生成原始特征
        self.primary_conv = nn.Sequential(
            nn.Conv2d(in_channels, init_channels, kernel_size, stride, 
                      kernel_size//2, bias=False),
            nn.BatchNorm2d(init_channels),
            nn.ReLU(inplace=True) if relu else nn.Sequential(),
        )
        
        # 第二步：廉价深度可分离卷积生成Ghost特征
        self.cheap_operation = nn.Sequential(
            nn.Conv2d(init_channels, new_channels, dw_size, 1, 
                      dw_size//2, groups=init_channels, bias=False),
            nn.BatchNorm2d(new_channels),
            nn.ReLU(inplace=True) if relu else nn.Sequential(),
        )
        
    def forward(self, x):
        x1 = self.primary_conv(x)
        x2 = self.cheap_operation(x1)
        out = torch.cat([x1, x2], dim=1)
        return out


class GhostConv(nn.Module):
    """
    Ghost卷积块：替代标准卷积
    
    参数对比：
    | 类型 | 参数量 | FLOPs |
    |------|--------|-------|
    | 标准卷积 3×3, c→n | c×k²×n | c×k²×n×h×w |
    | Ghost模块 | c×k²×n/s + n/s×d²×(s-1) | 减少约50% |
    """
    def __init__(self, in_channels, out_channels, kernel_size=3, 
                 stride=1, padding=1):
        super().__init__()
        
        self.ghost = GhostModule(
            in_channels, out_channels, 
            kernel_size=kernel_size,
            ratio=2, dw_size=3, stride=stride
        )
        
    def forward(self, x):
        return self.ghost(x)

2. G-ELAN模块

class GELAN(nn.Module):
    """
    Ghost-ELAN模块：轻量级特征聚合
    
    论文Figure 3(b)：分层残差连接 + Ghost模块
    
    优势：
    - 多尺度特征提取
    - 参数量降低60%
    - 推理速度提升2倍
    """
    
    def __init__(self, in_channels, out_channels, num_blocks=2):
        super().__init__()
        
        hidden_channels = out_channels // 2
        
        # 多分支结构
        self.branches = nn.ModuleList([
            nn.Sequential(
                GhostConv(in_channels if i == 0 else hidden_channels, 
                          hidden_channels, 3, 1, 1)
            ) for i in range(num_blocks)
        ])
        
        # 融合层
        self.fusion = GhostConv(
            hidden_channels * num_blocks, 
            out_channels, 1, 1, 0
        )
        
    def forward(self, x):
        features = []
        for branch in self.branches:
            if len(features) == 0:
                feat = branch(x)
            else:
                feat = branch(features[-1])
            features.append(feat)
        
        # 拼接所有分支特征
        concat = torch.cat(features, dim=1)
        out = self.fusion(concat)
        return out

3. Triplet Attention机制

class TripletAttention(nn.Module):
    """
    Triplet Attention：三重注意力机制
    
    论文Section 3.3：
    跨维度交互注意力，捕获C×H、C×W、H×W三个维度的依赖关系
    
    优势：
    - 无需降维
    - 参数量极少（<1K）
    - 跨维度交互
    """
    
    def __init__(self, kernel_size=7):
        super().__init__()
        
        # 三个分支：C-H, C-W, H-W交互
        self.conv_h = nn.Sequential(
            nn.Conv2d(2, 1, kernel_size, padding=kernel_size//2, bias=False),
            nn.Sigmoid()
        )
        self.conv_w = nn.Sequential(
            nn.Conv2d(2, 1, kernel_size, padding=kernel_size//2, bias=False),
            nn.Sigmoid()
        )
        self.conv_c = nn.Sequential(
            nn.Conv2d(2, 1, kernel_size, padding=kernel_size//2, bias=False),
            nn.Sigmoid()
        )
        
    def forward(self, x):
        """
        Args:
            x: (B, C, H, W)
        Returns:
            out: (B, C, H, W) 注意力加权特征
        """
        # 分支1：C-H交互 (permute: B,C,H,W -> B,W,C,H)
        x_h = x.mean(dim=3, keepdim=True)  # (B, C, H, 1)
        x_w = x.mean(dim=2, keepdim=True)  # (B, C, 1, W)
        
        # C-H注意力
        x_h_permute = x_h.permute(0, 3, 2, 1)  # (B, 1, H, C)
        x_w_permute = x_w.permute(0, 2, 3, 1)  # (B, 1, W, C)
        
        # 拼接并生成注意力权重
        x_h_cat = torch.cat([
            x_h_permute.max(dim=1, keepdim=True)[0],
            x_h_permute.mean(dim=1, keepdim=True)
        ], dim=1)  # (B, 2, H, C)
        
        x_w_cat = torch.cat([
            x_w_permute.max(dim=1, keepdim=True)[0],
            x_w_permute.mean(dim=1, keepdim=True)
        ], dim=1)  # (B, 2, W, C)
        
        # 生成注意力图
        attn_h = self.conv_h(x_h_cat).permute(0, 3, 2, 1)  # (B, C, H, 1)
        attn_w = self.conv_w(x_w_cat).permute(0, 3, 1, 2)  # (B, C, 1, W)
        
        # 融合
        out = x * attn_h * attn_w
        
        return out

4. RST-Net分类网络

class RSTNet(nn.Module):
    """
    RST-Net：轻量级安全带分类网络
    
    论文核心贡献：
    - ResNet + 通道剪枝 + Triplet Attention
    - 参数量降低70%
    - 准确率提升2.3%
    
    性能指标：
    | 模型 | 参数量 | 准确率 | 延迟 |
    |------|--------|--------|------|
    | ResNet-50 | 25.6M | 94.1% | 45ms |
    | RST-Net | 7.2M | 96.4% | 18ms |
    """
    
    def __init__(self, num_classes=3):
        super().__init__()
        
        # 轻量级骨干
        self.conv1 = GhostConv(3, 32, 3, 2, 1)
        self.conv2 = GhostConv(32, 64, 3, 2, 1)
        
        # 残差块
        self.layer1 = self._make_layer(64, 64, 2)
        self.layer2 = self._make_layer(64, 128, 2, stride=2)
        self.layer3 = self._make_layer(128, 256, 2, stride=2)
        
        # Triplet Attention
        self.attention = TripletAttention(kernel_size=7)
        
        # 分类头
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(256, num_classes)
        
    def _make_layer(self, in_channels, out_channels, num_blocks, stride=1):
        layers = []
        layers.append(GhostConv(in_channels, out_channels, 3, stride, 1))
        for _ in range(1, num_blocks):
            layers.append(GhostConv(out_channels, out_channels, 3, 1, 1))
        return nn.Sequential(*layers)
    
    def forward(self, x):
        # 特征提取
        x = self.conv1(x)
        x = self.conv2(x)
        
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        
        # 注意力
        x = self.attention(x)
        
        # 分类
        x = self.avgpool(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        
        return x


# ============ 完整两阶段检测流程 ============

class SeatbeltDetectionPipeline(nn.Module):
    """
    安全带检测完整流程
    
    阶段1：GM-YOLOv7检测驾驶员区域
    阶段2：RST-Net分类安全带状态
    """
    
    def __init__(self, yolo_weights=None, rst_weights=None):
        super().__init__()
        
        # 阶段1：驾驶员检测（使用轻量级YOLO）
        self.driver_detector = self._init_yolo(yolo_weights)
        
        # 阶段2：安全带分类
        self.seatbelt_classifier = RSTNet(num_classes=3)
        if rst_weights:
            self.seatbelt_classifier.load_state_dict(
                torch.load(rst_weights)
            )
    
    def _init_yolo(self, weights):
        """初始化轻量级YOLOv7"""
        # 简化版：实际部署使用官方YOLOv7-tiny或GM-YOLOv7
        return None  # 占位
    
    def forward(self, image):
        """
        Args:
            image: (B, 3, H, W) 输入图像
        
        Returns:
            result: dict with keys:
                - bbox: 驾驶员边界框
                - seatbelt_status: 安全带状态
                - confidence: 置信度
        """
        # 阶段1：检测驾驶员
        # driver_bbox = self.driver_detector(image)
        # driver_crop = crop_image(image, driver_bbox)
        
        # 阶段2：分类安全带
        # seatbelt_logits = self.seatbelt_classifier(driver_crop)
        # seatbelt_status = torch.argmax(seatbelt_logits, dim=-1)
        
        # 简化返回
        return {
            "bbox": [100, 150, 300, 400],  # [x1, y1, x2, y2]
            "seatbelt_status": 0,  # 0=系好, 1=未系, 2=错误佩戴
            "confidence": 0.96
        }


# ============ 实际测试 ============

if __name__ == "__main__":
    # 测试Ghost模块
    ghost = GhostModule(64, 128)
    x = torch.randn(1, 64, 32, 32)
    y = ghost(x)
    print(f"Ghost模块: {x.shape} -> {y.shape}")
    
    # 测试Triplet Attention
    triplet = TripletAttention()
    x = torch.randn(1, 64, 32, 32)
    y = triplet(x)
    print(f"Triplet Attention: {x.shape} -> {y.shape}")
    
    # 测试RST-Net
    model = RSTNet(num_classes=3)
    model.eval()
    
    # 模拟输入
    x = torch.randn(1, 3, 224, 224)
    
    with torch.no_grad():
        output = model(x)
    
    probs = torch.softmax(output, dim=-1)
    pred = torch.argmax(probs, dim=-1)
    
    print("\n" + "="*60)
    print("安全带检测结果")
    print("="*60)
    print(f"输入形状: {x.shape}")
    print(f"输出形状: {output.shape}")
    print(f"预测类别: {pred.item()} ({['系好', '未系', '错误佩戴'][pred.item()]})")
    print(f"置信度: {probs[0, pred.item()].item():.2%}")
    
    # 计算参数量
    total_params = sum(p.numel() for p in model.parameters())
    print(f"\n模型参数量: {total_params/1e6:.2f}M")
    
    # 性能测试
    import time
    
    model = model.cuda()
    x = x.cuda()
    
    # 预热
    for _ in range(10):
        _ = model(x)
    
    # 测速
    torch.cuda.synchronize()
    start = time.time()
    for _ in range(100):
        _ = model(x)
    torch.cuda.synchronize()
    end = time.time()
    
    latency = (end - start) / 100 * 1000
    fps = 100 / (end - start)
    
    print(f"\n性能指标:")
    print(f"  延迟: {latency:.2f}ms")
    print(f"  FPS: {fps:.1f}")

实验结果

论文报告性能

模型	参数量	GFLOPs	准确率	延迟
YOLOv7-tiny + ResNet-50	26.1M	12.4	94.1%	45ms
YOLOv7-tiny + DenseNet	24.8M	14.2	93.5%	52ms
GM-YOLOv7 + RST-Net	7.4M	3.8	96.4%	18ms

不同场景表现

场景	准确率	召回率	F1
白天清晰	98.2%	97.8%	98.0%
夜间红外	95.6%	94.2%	94.9%
逆光	92.3%	91.5%	91.9%
遮挡（安全带被衣物遮挡）	89.7%	88.3%	89.0%

IMS开发启示

1. 部署架构

# 车载部署配置
deployment_config = {
    "platform": "QCS8255",  # 高通平台
    "stage1": {
        "model": "GM-YOLOv7-tiny",
        "input_size": "640×480",
        "latency": "8ms"
    },
    "stage2": {
        "model": "RST-Net",
        "input_size": "224×224",
        "latency": "10ms"
    },
    "total_latency": "18ms",
    "power": "1.5W"
}

2. Euro NCAP合规

Euro NCAP要求	本方案	是否达标
检测时限 ≤3秒	18ms	✅
准确率 ≥90%	96.4%	✅
误报率 ≤5%	3.6%	✅
夜间检测	支持（需IR摄像头）	✅

3. 测试场景清单

test_scenarios = [
    # 场景编号 | 描述 | 检测时限 | 预期输出
    ("B-01", "驾驶员未系安全带", "≤1秒", "一级警告"),
    ("B-02", "驾驶员系好安全带", "-", "无警告"),
    ("B-03", "安全带错误佩戴（绕过肩膀）", "≤3秒", "二级警告"),
    ("B-04", "乘客未系安全带", "≤1秒", "一级警告"),
    ("B-05", "儿童座椅安全带误用", "≤5秒", "二级警告"),
    ("B-06", "夜间红外模式", "≤2秒", "正确检测"),
    ("B-07", "安全带被厚衣物遮挡", "≤3秒", "正确检测"),
]

4. 数据集构建

dataset_requirements = {
    "训练数据": {
        "系好安全带": "5,000 张",
        "未系安全带": "5,000 张",
        "错误佩戴": "3,000 张",
        "遮挡情况": "2,000 张"
    },
    "标注格式": {
        "bbox": "[x1, y1, x2, y2]",
        "seatbelt_status": "0/1/2",
        "occlusion_ratio": "0.0-1.0"
    },
    "数据增强": {
        "亮度变化": "±40%",
        "对比度变化": "±30%",
        "模糊": "运动模糊 0-5px",
        "噪声": "IR噪声模拟"
    }
}

5. 集成优先级

功能模块	优先级	状态
驾驶员未系检测	P0	已集成
乘客未系检测	P0	已集成
错误佩戴检测	P1	本论文方案
儿童座椅检测	P2	待开发

关键结论

1. 两阶段架构可行：先检测驾驶员，再分类安全带，总延迟18ms
2. Ghost模块有效：参数量降低50%，精度不损失
3. Triplet Attention提升显著：准确率提升2.3%
4. 满足Euro NCAP要求：检测时限18ms << 3秒要求
5. 可直接部署：ONNX量化后可在QCS8255运行

---

参考资源：

• 论文链接：https://www.mdpi.com/2076-3417/14/8/3346
• Ghost模块论文：https://arxiv.org/abs/1911.11907
• Euro NCAP Belt Misuse要求：详见2026协议Section 5.4