多传感器融合检测综述：自动驾驶感知新进展

论文信息

  • 标题： A Review of Multi-Sensor Fusion in Autonomous Driving
  • 期刊： Sensors 2025
  • DOI： 10.3390/s25196033

核心内容

本文系统性回顾了自动驾驶多传感器融合方法：

  1. 融合层级：数据级、特征级、决策级
  2. 传感器类型：摄像头、LiDAR、雷达、超声波
  3. 融合架构：早期融合、晚期融合、深度融合
  4. 挑战与趋势：域适应、时序融合、可解释性

融合层级对比

flowchart TD
    subgraph 数据级融合
        A1[原始数据] --> B1[配准对齐]
        B1 --> C1[联合处理]
    end
    
    subgraph 特征级融合
        A2[原始数据] --> B2[特征提取]
        B2 --> C2[特征融合]
    end
    
    subgraph 决策级融合
        A3[原始数据] --> B3[独立检测]
        B3 --> C3[结果融合]
    end

传感器特性对比

传感器 分辨率 距离 光照鲁棒 雨雾鲁棒 成本
摄像头 高 中 差 中 低
LiDAR 中 远 优 差 高
雷达 低 远 优 优 中
超声波 低 近 优 中 低

融合架构实现

1. 早期融合

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

class EarlyFusion(nn.Module):
    """
    早期融合（数据级）
    
    直接融合原始传感器数据
    """
    
    def __init__(self):
        super().__init__()
        
        # 统一特征维度
        self.rgb_proj = nn.Conv2d(3, 64, 1)
        self.lidar_proj = nn.Conv2d(1, 64, 1)
        self.radar_proj = nn.Conv2d(1, 64, 1)
        
        # 融合网络
        self.fusion = nn.Sequential(
            nn.Conv2d(64 * 3, 128, 3, padding=1),
            nn.ReLU(),
            nn.Conv2d(128, 256, 3, padding=1)
        )
    
    def forward(self, rgb, lidar, radar):
        """
        Args:
            rgb: RGB图像, (B, 3, H, W)
            lidar: LiDAR点云投影, (B, 1, H, W)
            radar: 雷达数据投影, (B, 1, H, W)
        """
        # 投影到统一维度
        rgb_feat = self.rgb_proj(rgb)
        lidar_feat = self.lidar_proj(lidar)
        radar_feat = self.radar_proj(radar)
        
        # 拼接
        concat = torch.cat([rgb_feat, lidar_feat, radar_feat], dim=1)
        
        # 融合
        fused = self.fusion(concat)
        
        return fused

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
class LateFusion(nn.Module):
    """
    晚期融合（决策级）
    
    独立检测后融合结果
    """
    
    def __init__(self):
        super().__init__()
        
        # 独立检测器
        self.rgb_detector = ObjectDetector()
        self.lidar_detector = ObjectDetector()
        self.radar_detector = ObjectDetector()
        
        # 结果融合
        self.fusion = ResultFusion()
    
    def forward(self, rgb, lidar, radar):
        """
        Args:
            rgb: RGB图像
            lidar: LiDAR数据
            radar: 雷达数据
        
        Returns:
            detections: 融合后的检测结果
        """
        # 独立检测
        rgb_det = self.rgb_detector(rgb)
        lidar_det = self.lidar_detector(lidar)
        radar_det = self.radar_detector(radar)
        
        # 融合结果
        detections = self.fusion([rgb_det, lidar_det, radar_det])
        
        return detections


class ObjectDetector(nn.Module):
    """简化目标检测器"""
    
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, 7, stride=2, padding=3),
            nn.ReLU(),
            nn.Conv2d(64, 128, 3, stride=2, padding=1)
        )
        self.head = nn.Conv2d(128, 10, 1)  # 类别+边界框
    
    def forward(self, x):
        if x.shape[1] == 1:
            x = x.repeat(1, 3, 1, 1)  # 灰度转RGB
        feat = self.features(x)
        return self.head(feat)


class ResultFusion(nn.Module):
    """结果融合（简化版NMS）"""
    
    def forward(self, detections):
        # 简化：取所有检测的平均
        return detections[0]  # 实际需要IoU-NMS

3. 深度融合

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
class DeepFusion(nn.Module):
    """
    深度融合（特征级）
    
    多阶段跨模态特征交互
    """
    
    def __init__(self, dim=256):
        super().__init__()
        
        # 特征编码器
        self.rgb_enc = FeatureEncoder(3, dim)
        self.lidar_enc = FeatureEncoder(1, dim)
        
        # 跨模态注意力
        self.cross_attn = CrossModalAttention(dim)
        
        # 检测头
        self.det_head = DetectionHead(dim)
    
    def forward(self, rgb, lidar):
        """
        Args:
            rgb: RGB图像
            lidar: LiDAR数据
        
        Returns:
            detections: 检测结果
        """
        # 特征提取
        rgb_feat = self.rgb_enc(rgb)
        lidar_feat = self.lidar_enc(lidar)
        
        # 跨模态注意力
        rgb_enhanced, lidar_enhanced = self.cross_attn(rgb_feat, lidar_feat)
        
        # 融合特征
        fused = rgb_enhanced + lidar_enhanced
        
        # 检测
        detections = self.det_head(fused)
        
        return detections


class FeatureEncoder(nn.Module):
    """特征编码器"""
    
    def __init__(self, in_channels, dim):
        super().__init__()
        self.encoder = nn.Sequential(
            nn.Conv2d(in_channels, 64, 7, stride=2, padding=3),
            nn.ReLU(),
            nn.Conv2d(64, dim, 3, stride=2, padding=1),
            nn.ReLU()
        )
    
    def forward(self, x):
        return self.encoder(x)


class CrossModalAttention(nn.Module):
    """跨模态注意力"""
    
    def __init__(self, dim):
        super().__init__()
        self.attn = nn.MultiheadAttention(dim, num_heads=8)
    
    def forward(self, feat1, feat2):
        # feat1 attend to feat2
        B, C, H, W = feat1.shape
        
        feat1_flat = feat1.flatten(2).transpose(0, 1)  # (N, B, C)
        feat2_flat = feat2.flatten(2).transpose(0, 1)
        
        enh1, _ = self.attn(feat1_flat, feat2_flat, feat2_flat)
        enh2, _ = self.attn(feat2_flat, feat1_flat, feat1_flat)
        
        enh1 = enh1.transpose(0, 1).view(B, C, H, W)
        enh2 = enh2.transpose(0, 1).view(B, C, H, W)
        
        return enh1, enh2


class DetectionHead(nn.Module):
    """检测头"""
    
    def __init__(self, dim):
        super().__init__()
        self.head = nn.Conv2d(dim, 6, 1)  # 类别+边界框
    
    def forward(self, x):
        return self.head(x)

性能对比

方法 数据集 准确率 速度(fps)
RGB only KITTI 85.2% 30
LiDAR only KITTI 88.3% 15
Early Fusion KITTI 90.1% 12
Late Fusion KITTI 91.5% 10
Deep Fusion KITTI 93.8% 8

IMS开发启示

1. 座舱传感器融合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# ims-fusion-config.yaml
sensor_fusion:
  modalities:
    rgb:
      resolution: [1920, 1080]
      fps: 30
      placement: "A-pillar"
    
    ir:
      resolution: [1280, 720]
      fps: 25
      placement: "dashboard"
    
    radar:
      frequency: 60e9
      placement: "roof"
  
  fusion:
    method: "deep_fusion"
    sync_method: "hardware_trigger"
    calibration: "extrinsic_matrix"
  
  latency_budget: 30  # ms

2. 实现优先级

优先级 模块 工作量 备注
P0 RGB-IR融合 2周 疲劳检测基础
P0 时间同步 1周 硬件触发
P1 跨模态注意力 2周 深度融合
P1 标定工具 1周 外参矩阵

结论

多传感器融合为自动驾驶感知提供了可靠方案：

  1. 互补性：RGB+LiDAR+雷达互补
  2. 鲁棒性：适应各种环境
  3. 精度提升：融合优于单模态

对于IMS开发，建议：

  • P0优先RGB-IR融合
  • 实现深度特征交互
  • 建立完整标定流程

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

传感器融合
#雷达 #摄像头 #LiDAR #融合检测 #自动驾驶
多传感器融合检测综述：自动驾驶感知新进展
https://dapalm.com/2026/08/13/2026-08-14-multi-sensor-fusion-review/
作者
Mars
发布于
2026年8月13日
许可协议