bev-project/project/docs/自动驾驶全感知网络扩展方案.md

# BEVFusion 扩展为自动驾驶全感知网络

**设计时间**：2025-10-22  
**目标**：从单一感知任务扩展为完整的感知+定位+地图系统  
**基础**：当前BEVFusion双任务模型（检测+分割）

---

## 🎯 扩展目标

### 当前能力 ✅
```
BEVFusion 双任务系统
├── 3D目标检测 (Object Detection)
│   └── 输出: 3D边界框、类别、速度
└── BEV地图分割 (Semantic Segmentation)
    └── 输出: 6类语义分割mask
```

### 扩展后能力 🚀
```
自动驾驶全感知网络 (Autonomous Driving Perception System)
├── 1. 3D目标检测 ✅ 已有
├── 2. BEV语义分割 ✅ 已有
├── 3. 矢量地图预测 🆕 新增
├── 4. 车辆定位 🆕 新增
├── 5. 轨迹预测 🆕 新增（可选）
└── 6. 占用网格 🆕 新增（可选）
```

---

## 🏗️ 完整架构设计

### 系统架构图

```
┌─────────────────────────────────────────────────────────────────┐
│                    多传感器输入层                                  │
├─────────────────────────────────────────────────────────────────┤
│  Camera (6视角)  │  LiDAR点云  │  Radar  │  IMU  │  GPS/RTK    │
└────────┬────────────────┬────────────┬────────┬──────┬──────────┘
         │                │            │        │      │
         ▼                ▼            ▼        │      │
┌─────────────────────────────────────────────┐ │      │
│        BEVFusion统一特征提取                  │ │      │
├─────────────────────────────────────────────┤ │      │
│  Camera Encoder  │  LiDAR Encoder  │ Radar  │ │      │
│       ↓                  ↓              ↓    │ │      │
│  BEV Features (统一的鸟瞰图表示)              │ │      │
│  (B, 256, 180, 180)                         │ │      │
└────────┬────────────────────────────────────┘ │      │
         │                                      │      │
         ▼                                      ▼      ▼
┌──────────────────────────────────────────────────────────────┐
│                   多任务感知头层                               │
├──────────────────────────────────────────────────────────────┤
│                                                                │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐  │
│  │ Task 1      │  │ Task 2      │  │ Task 3              │  │
│  │ 3D检测      │  │ BEV分割     │  │ 矢量地图 🆕         │  │
│  │ TransFusion │  │ Enhanced    │  │ MapTR Head          │  │
│  └──────┬──────┘  └──────┬──────┘  └──────┬──────────────┘  │
│         │                │                │                   │
│         ▼                ▼                ▼                   │
│    3D Boxes       Semantic Masks    Vector Map               │
│                                                                │
│  ┌─────────────┐  ┌──────────────────┐  ┌────────────────┐  │
│  │ Task 4 🆕   │  │ Task 5 🆕        │  │ Task 6 🆕      │  │
│  │ 自车定位    │  │ 目标轨迹预测     │  │ 占用网格       │  │
│  │ Localization│  │ Trajectory Pred  │  │ Occupancy Grid │  │
│  └──────┬──────┘  └──────┬───────────┘  └──────┬─────────┘  │
│         │                │                      │             │
│         ▼                ▼                      ▼             │
│    Ego Pose        Future Trajectory       Occupancy Map     │
│                                                                │
└──────────────────────────────────────────────────────────────┘
         │                │                      │
         ▼                ▼                      ▼
┌──────────────────────────────────────────────────────────────┐
│                   融合决策层                                    │
├──────────────────────────────────────────────────────────────┤
│  综合所有任务输出，提供完整的场景理解                            │
│  → 用于路径规划、决策控制                                       │
└──────────────────────────────────────────────────────────────┘
```

---

## 📋 扩展任务详解

### Task 3: 矢量地图预测 🆕

**目标**：预测高精度矢量地图元素

**输出内容**：
- 车道线（Lane Lines）
- 道路边界（Road Boundaries）
- 人行横道（Pedestrian Crossings）
- 停止线（Stop Lines）
- 道路分隔线（Dividers）

**技术方案**：MapTRv2集成
```python
# 新增MapTRHead
model:
  heads:
    vector_map:
      type: MapTRHead
      num_queries: 50
      num_points: 20
      embed_dims: 256
```

**数据需求**：
- nuScenes矢量地图标注
- 车道线点集
- 拓扑关系

**预期性能**：
- 矢量地图mAP: 50-55%

**实施时间**：2周

---

### Task 4: 自车定位（Ego Localization）🆕

**目标**：估计自车在全局坐标系中的精确位置和姿态

**输出内容**：
```python
ego_pose = {
    'position': [x, y, z],        # 全局坐标（米）
    'orientation': [qw, qx, qy, qz],  # 四元数
    'velocity': [vx, vy, vz],     # 速度（m/s）
    'uncertainty': covariance     # 6×6协方差矩阵
}
```

**技术方案选择**：

#### 方案A：基于地图匹配的定位（推荐）⭐⭐⭐⭐⭐
```python
# 利用BEV特征和地图进行定位
class BEVLocalizationHead(nn.Module):
    """
    基于BEV特征匹配预构建地图进行定位
    """
    def __init__(self):
        # 1. 地图编码器
        self.map_encoder = MapEncoder()
        
        # 2. 特征匹配网络
        self.matcher = FeatureMatcher()
        
        # 3. 位姿回归
        self.pose_regressor = PoseRegressor()
    
    def forward(self, bev_features, prior_map):
        # BEV特征 + 先验地图 → 匹配 → 位姿
        map_features = self.map_encoder(prior_map)
        similarity = self.matcher(bev_features, map_features)
        pose = self.pose_regressor(similarity)
        return pose
```

**优势**：
- ✅ 利用BEV表示天然适合
- ✅ 精度高（厘米级）
- ✅ 鲁棒性好

**数据需求**：
- 预构建的BEV地图
- GPS/IMU融合的ground truth位姿
- 地图tile管理系统

---

#### 方案B：视觉惯性里程计（VIO）⭐⭐⭐⭐
```python
class VisualInertialOdometry(nn.Module):
    """
    视觉+IMU融合的相对定位
    """
    def __init__(self):
        # 1. 视觉里程计
        self.visual_odometry = VisualOdometry()
        
        # 2. IMU预积分
        self.imu_integrator = IMUIntegrator()
        
        # 3. 卡尔曼滤波融合
        self.ekf = ExtendedKalmanFilter()
    
    def forward(self, images_seq, imu_data):
        # 相对位姿估计
        relative_pose = self.visual_odometry(images_seq)
        imu_pose = self.imu_integrator(imu_data)
        fused_pose = self.ekf.update(relative_pose, imu_pose)
        return fused_pose
```

**优势**：
- ✅ 不依赖预构建地图
- ✅ 实时性好
- ⚠️ 存在累积误差

---

### Task 5: 目标轨迹预测 🆕

**目标**：预测周围车辆和行人的未来轨迹

**输出内容**：
```python
trajectory = {
    'object_id': 123,
    'current_state': [x, y, vx, vy],
    'future_trajectory': [
        [x1, y1, t1],  # 1秒后
        [x2, y2, t2],  # 2秒后
        [x3, y3, t3],  # 3秒后
    ],
    'probability': [0.8, 0.7, 0.6],  # 置信度
    'mode': 'turn_left',  # 运动模式
}
```

**技术方案**：
```python
class TrajectoryPredictionHead(nn.Module):
    """
    基于检测结果预测未来轨迹
    """
    def __init__(self):
        # 1. 历史轨迹编码器
        self.history_encoder = LSTMEncoder()
        
        # 2. 场景上下文编码
        self.scene_encoder = SceneEncoder()  # 使用BEV特征
        
        # 3. 交互建模
        self.interaction_module = InteractionGraph()
        
        # 4. 多模态轨迹解码器
        self.trajectory_decoder = MultiModalDecoder(num_modes=6)
    
    def forward(self, objects, bev_features, history):
        # 历史 + 场景 + 交互 → 未来轨迹
        hist_feat = self.history_encoder(history)
        scene_feat = self.scene_encoder(bev_features)
        interaction = self.interaction_module(objects)
        trajectories = self.trajectory_decoder(hist_feat, scene_feat, interaction)
        return trajectories
```

**数据需求**：
- 历史轨迹数据（nuScenes提供）
- 未来3秒ground truth
- 交互场景标注

**参考模型**：
- MTR (Motion Transformer)
- Wayformer
- MultiPath++

---

### Task 6: 占用网格预测 🆕

**目标**：预测3D空间的占用状态

**输出内容**：
```python
occupancy_grid = {
    'grid': (B, X, Y, Z),  # 3D网格
    'values': [0, 1],      # 0:空闲, 1:占用
    'semantics': [0-N],    # 语义类别（可选）
    'resolution': 0.4m,    # 网格分辨率
}
```

**技术方案**：
```python
class OccupancyHead(nn.Module):
    """
    3D占用网格预测
    """
    def __init__(self):
        # BEV → 3D占用
        self.bev_to_3d = BEV3DUpsampler()
        self.occupancy_predictor = OccupancyPredictor()
    
    def forward(self, bev_features):
        # BEV特征 → 3D占用网格
        features_3d = self.bev_to_3d(bev_features)
        occupancy = self.occupancy_predictor(features_3d)
        return occupancy
```

**参考模型**：
- MonoScene
- TPVFormer
- OccNet

---

## 🔧 完整扩展方案

### 阶段1：三任务系统（2周）

**任务组合**：
```
检测 + 分割 + 矢量地图
```

**实施步骤**：
1. 集成MapTRHead（基于现有MAPTR_INTEGRATION_PLAN.md）
2. 提取矢量地图数据
3. 三任务联合训练
4. 性能评估

**预期性能**：
- 检测mAP: 65-68%
- 分割mIoU: 55-58%
- 矢量地图mAP: 50-55%

---

### 阶段2：加入定位功能（1-2周）

**方案选择**：地图匹配定位（推荐）

**实施步骤**：

#### Step 1: 构建BEV地图数据库（3天）
```python
# tools/build_bev_map_database.py

def build_bev_map_database(nusc_root, output_dir):
    """
    为每个地图区域构建BEV地图tile
    """
    maps = ['boston-seaport', 'singapore-onenorth', 
            'singapore-hollandvillage', 'singapore-queenstown']
    
    for map_name in maps:
        nusc_map = NuScenesMap(nusc_root, map_name)
        
        # 划分为100m×100m的tile
        tiles = create_map_tiles(nusc_map, tile_size=100)
        
        for tile in tiles:
            # 渲染为BEV表示
            bev_map = render_bev_map(tile, resolution=0.3)
            # 保存
            save_tile(bev_map, output_dir, map_name, tile.id)
    
    print(f"✅ BEV地图数据库构建完成")
```

#### Step 2: 实现定位Head（2天）
```python
# mmdet3d/models/heads/localization/bev_localization_head.py

@HEADS.register_module()
class BEVLocalizationHead(nn.Module):
    """
    基于BEV特征匹配的定位head
    """
    def __init__(
        self,
        in_channels=256,
        map_embedding_dim=128,
        pose_dims=6,  # x, y, z, roll, pitch, yaw
    ):
        super().__init__()
        
        # 1. BEV特征编码器
        self.bev_encoder = nn.Sequential(
            nn.Conv2d(in_channels, 128, 3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(),
            nn.Conv2d(128, map_embedding_dim, 3, padding=1),
        )
        
        # 2. 地图编码器（预训练）
        self.map_encoder = nn.Sequential(
            nn.Conv2d(3, 64, 3, padding=1),
            nn.ReLU(),
            nn.Conv2d(64, map_embedding_dim, 3, padding=1),
        )
        
        # 3. 相关性计算
        self.correlator = SpatialCorrelation()
        
        # 4. 位姿回归
        self.pose_head = nn.Sequential(
            nn.Linear(map_embedding_dim * 4, 256),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(256, pose_dims + 6*6),  # pose + covariance
        )
    
    def forward(self, bev_features, prior_map_tile, gps_hint=None):
        """
        Args:
            bev_features: (B, 256, H, W) 当前BEV特征
            prior_map_tile: (B, 3, H, W) 先验地图tile
            gps_hint: (B, 2) GPS粗略位置（可选）
        
        Returns:
            pose: (B, 6) [x, y, z, roll, pitch, yaw]
            uncertainty: (B, 6, 6) 协方差矩阵
        """
        # 编码BEV和地图
        bev_emb = self.bev_encoder(bev_features)
        map_emb = self.map_encoder(prior_map_tile)
        
        # 计算相关性（匹配）
        correlation = self.correlator(bev_emb, map_emb)
        
        # 全局池化
        pooled = F.adaptive_avg_pool2d(correlation, 1).flatten(1)
        
        # 回归位姿
        output = self.pose_head(pooled)
        pose = output[:, :6]
        covariance_vec = output[:, 6:]
        
        # 重构协方差矩阵
        uncertainty = self.reconstruct_covariance(covariance_vec)
        
        return pose, uncertainty
    
    def loss(self, pred_pose, gt_pose, pred_cov):
        """
        定位损失函数
        """
        # 1. 位姿L1损失
        loss_pose = F.l1_loss(pred_pose, gt_pose)
        
        # 2. 不确定性损失（负对数似然）
        loss_uncertainty = self.nll_loss(pred_pose, gt_pose, pred_cov)
        
        return {
            'loss_localization': loss_pose,
            'loss_uncertainty': loss_uncertainty,
        }
```

#### Step 3: 数据准备（1天）
```python
# 为每个样本准备：
1. BEV地图tile（从数据库查询）
2. Ground truth位姿（从nuScenes）
3. GPS粗略位置（初始化）
```

#### Step 4: 训练策略（5-7天）
```yaml
# 阶段1: 冻结其他head，只训练定位head（3 epochs）
model:
  freeze_heads: ['object', 'map', 'vector_map']
  
# 阶段2: 联合fine-tune（5 epochs）
model:
  freeze_heads: []
  loss_scale:
    object: 1.0
    map: 1.0
    vector_map: 1.0
    localization: 2.0  # 定位权重稍高
```

---

### Task 5: 轨迹预测（可选）🆕

**目标**：预测其他交通参与者的未来轨迹

**技术方案**：
```python
@HEADS.register_module()
class TrajectoryPredictionHead(nn.Module):
    """
    多模态轨迹预测
    基于检测结果和场景上下文
    """
    def __init__(
        self,
        history_steps=10,      # 历史10帧（2秒）
        future_steps=30,       # 未来30帧（6秒）
        num_modes=6,           # 6种可能模式
        hidden_dim=256,
    ):
        super().__init__()
        
        # 1. 历史轨迹编码
        self.history_encoder = nn.LSTM(4, hidden_dim, 2)  # (x,y,vx,vy)
        
        # 2. Agent特征提取（从BEV）
        self.agent_encoder = AgentROIExtractor()
        
        # 3. 场景上下文（road graph）
        self.scene_encoder = VectorizedSceneEncoder()
        
        # 4. 交互建模（agent-agent）
        self.interaction = MultiAgentInteraction(hidden_dim)
        
        # 5. 多模态解码器
        self.decoder = nn.ModuleList([
            TrajectoryDecoder(hidden_dim, future_steps)
            for _ in range(num_modes)
        ])
        
        # 6. 模式分类器
        self.mode_classifier = nn.Linear(hidden_dim, num_modes)
    
    def forward(self, detected_objects, bev_features, history_tracks):
        """
        预测所有检测到的目标的未来轨迹
        """
        # 编码历史
        hist_features, _ = self.history_encoder(history_tracks)
        
        # 提取agent特征
        agent_features = self.agent_encoder(bev_features, detected_objects)
        
        # 编码场景（车道、路口等）
        scene_features = self.scene_encoder(bev_features)
        
        # 建模交互
        interaction_features = self.interaction(agent_features)
        
        # 融合所有特征
        fused = hist_features + agent_features + scene_features + interaction_features
        
        # 多模态预测
        trajectories = []
        for decoder in self.decoder:
            traj = decoder(fused)
            trajectories.append(traj)
        
        # 模式概率
        mode_probs = F.softmax(self.mode_classifier(fused), dim=-1)
        
        return trajectories, mode_probs
```

**数据需求**：
- 历史轨迹（从tracking得到）
- 未来轨迹ground truth
- 场景图（道路拓扑）

**参考数据集**：
- nuScenes Prediction Challenge
- Waymo Motion Dataset

---

### Task 6: 占用网格预测（可选）🆕

**目标**：预测3D空间占用状态

```python
@HEADS.register_module()
class OccupancyHead(nn.Module):
    """
    3D占用网格预测
    输出: (B, X, Y, Z) 3D网格
    """
    def __init__(
        self,
        in_channels=256,
        grid_size=[200, 200, 16],  # X, Y, Z
        num_classes=2,  # 空闲/占用 或 多类语义
    ):
        super().__init__()
        
        # BEV → 3D特征
        self.bev_to_3d = nn.Sequential(
            nn.Conv2d(in_channels, 128, 3, padding=1),
            nn.ReLU(),
            # 上采样到3D
        )
        
        # 3D卷积预测
        self.occupancy_3d = nn.Sequential(
            nn.Conv3d(128, 64, 3, padding=1),
            nn.ReLU(),
            nn.Conv3d(64, num_classes, 1),
        )
    
    def forward(self, bev_features):
        # BEV → 3D占用
        features_3d = self.bev_to_3d(bev_features)
        occupancy = self.occupancy_3d(features_3d)
        return occupancy
```

**应用场景**：
- 碰撞检测
- 路径规划
- 安全距离计算

---

## 📊 完整系统对比

### 功能对比

| 功能 | 当前BEVFusion | 三任务系统 | 全感知系统 |
|------|--------------|-----------|-----------|
| 3D检测 | ✅ | ✅ | ✅ |
| BEV分割 | ✅ | ✅ | ✅ |
| 矢量地图 | ❌ | ✅ | ✅ |
| 自车定位 | ❌ | ❌ | ✅ |
| 轨迹预测 | ❌ | ❌ | ✅ |
| 占用网格 | ❌ | ❌ | ✅ |

### 性能对比

| 系统 | 参数量 | 推理时间 | 输出 | 应用 |
|------|--------|----------|------|------|
| 双任务 | 110M | 90ms | 检测+分割 | 基础感知 |
| 三任务 | 125M | 110ms | +矢量地图 | 高精地图 |
| 五任务 | 150M | 140ms | +定位+轨迹 | 规划决策 |
| 六任务 | 170M | 160ms | +占用网格 | 完整感知 |

---

## 🚀 实施路线图

### 方案A：渐进式扩展（推荐）⭐⭐⭐⭐⭐

```
当前: 双任务（检测+分割）✅
  ↓ +2周
阶段1: 三任务（+矢量地图）
  ↓ +1周
阶段2: 四任务（+定位）
  ↓ +1周（可选）
阶段3: 五任务（+轨迹预测）
  ↓ +1周（可选）
阶段4: 六任务（+占用网格）

总时间: 5-7周
```

**优势**：
- ✅ 风险可控
- ✅ 每阶段独立验证
- ✅ 可以根据需求停止扩展

---

### 方案B：核心三任务+定位（实用）⭐⭐⭐⭐

```
当前: 双任务 ✅
  ↓ +2周
三任务: 检测+分割+矢量地图
  ↓ +1周
四任务: +定位

总时间: 3周
输出: 核心感知+定位系统
```

**优势**：
- ✅ 时间可控
- ✅ 覆盖核心需求
- ✅ 适合部署

---

## 📅 详细时间表

### Week 1-2：当前训练（进行中）
- 🔄 完成增强版训练（Epoch 23）
- ⏳ 预计10-29完成
- 🎯 目标mIoU: 60-65%

### Week 3-4：MapTR集成
**11-01 ~ 11-14**

| 天数 | 任务 | 时间 |
|------|------|------|
| Day 1-2 | 研究MapTR代码 | 2天 |
| Day 3 | 提取矢量地图数据 | 1天 |
| Day 4-5 | 实现MapTRHead | 2天 |
| Day 6 | 集成测试 | 1天 |
| Day 7-9 | 三任务训练 | 3天 |
| Day 10 | 评估 | 1天 |

**交付**：
- 三任务模型（检测+分割+矢量）
- 矢量地图mAP: 50-55%

---

### Week 5：定位功能开发
**11-15 ~ 11-21**

| 天数 | 任务 | 时间 |
|------|------|------|
| Day 1-3 | 构建BEV地图数据库 | 3天 |
| Day 4-5 | 实现定位Head | 2天 |
| Day 6 | 数据准备和测试 | 1天 |
| Day 7 | 集成到系统 | 1天 |

**交付**：
- BEV地图数据库
- 定位Head实现

---

### Week 6：四任务训练
**11-22 ~ 11-28**

| 天数 | 任务 | 时间 |
|------|------|------|
| Day 1-2 | 准备训练数据 | 2天 |
| Day 3-7 | 四任务联合训练 | 5天 |

**训练策略**：
```yaml
# 阶段1: 冻结前三个任务，训练定位（3 epochs）
model:
  freeze_heads: ['object', 'map', 'vector_map']

# 阶段2: 四任务联合fine-tune（5 epochs）
model:
  freeze_heads: []
  loss_scale:
    object: 1.0
    map: 1.0
    vector_map: 1.0
    localization: 2.0
```

**交付**：
- 四任务模型
- 定位精度: <0.5m（目标）

---

### Week 7（可选）：轨迹预测
**11-29 ~ 12-05**

- 实现TrajectoryHead
- 准备轨迹数据
- 五任务训练

---

### Week 8（可选）：占用网格
**12-06 ~ 12-12**

- 实现OccupancyHead
- 准备占用数据
- 六任务训练

---

## 💾 数据需求

### 三任务（检测+分割+矢量）
- ✅ nuScenes原始数据（已有）
- 🆕 矢量地图标注（需提取）
  - 来源：nuScenes map API
  - 大小：~500MB
  - 时间：30分钟提取

### 四任务（+定位）
- 🆕 BEV地图数据库
  - 4个地图区域
  - 每个区域100-200个tile
  - 总大小：~5GB
  - 构建时间：1-2天

- 🆕 位姿ground truth
  - 来源：nuScenes ego_pose
  - 精度：GPS/IMU融合（~1m）
  - 目标：提升到<0.5m

### 五任务（+轨迹）
- 🆕 历史轨迹数据
  - 来源：nuScenes tracking
  - 时间跨度：过去2秒
  - 未来预测：3秒

---

## 🎯 最终系统能力

### 输出完整场景理解

```python
# 一次前向传播输出
perception_output = model(images, points, imu, gps)

outputs = {
    # Task 1: 3D检测
    'objects': [
        {
            'bbox_3d': [x, y, z, w, h, l, yaw],
            'class': 'car',
            'score': 0.95,
            'velocity': [vx, vy],
            'track_id': 123,
        },
        ...
    ],
    
    # Task 2: BEV分割
    'segmentation': {
        'mask': (200, 200),  # 语义分割
        'classes': ['drivable', 'walkway', ...],
    },
    
    # Task 3: 矢量地图
    'vector_map': [
        {
            'type': 'lane_line',
            'points': [[x1,y1], [x2,y2], ...],
            'confidence': 0.9,
        },
        ...
    ],
    
    # Task 4: 自车定位
    'ego_pose': {
        'position': [x, y, z],
        'orientation': [qw, qx, qy, qz],
        'uncertainty': covariance_matrix,
    },
    
    # Task 5: 轨迹预测（可选）
    'trajectories': {
        123: {  # track_id
            'future': [[x1,y1,t1], [x2,y2,t2], ...],
            'modes': ['turn_left', 'go_straight', ...],
            'probabilities': [0.6, 0.3, 0.1],
        },
        ...
    },
    
    # Task 6: 占用网格（可选）
    'occupancy': {
        'grid_3d': (200, 200, 16),  # X, Y, Z
        'resolution': 0.4,  # 米
    },
}
```

---

## 🔧 技术实现细节

### 共享Backbone策略

```
所有任务共享：
├── Camera Encoder (60M参数)
├── LiDAR Encoder (10M参数)
├── Fuser (2M参数)
└── BEV Decoder (20M参数)

任务特定Head：
├── Object Head (8M)          ← 已有
├── Map Head (10M)            ← 已有
├── VectorMap Head (15M)      ← 新增
├── Localization Head (5M)    ← 新增
├── Trajectory Head (8M)      ← 新增（可选）
└── Occupancy Head (7M)       ← 新增（可选）

总参数量：
- 三任务: 125M
- 四任务: 130M
- 五任务: 138M
- 六任务: 145M
```

---

## 💡 关键技术点

### 1. 多任务Loss平衡
```yaml
loss_scale:
  object: 1.0        # 检测
  map: 1.0           # 分割
  vector_map: 1.0    # 矢量地图
  localization: 2.0  # 定位（权重稍高）
  trajectory: 0.5    # 轨迹（权重较低）
  occupancy: 0.8     # 占用
```

### 2. 训练策略
```
阶段1: 冻结前N个任务，训练新任务（3-5 epochs）
阶段2: 所有任务联合fine-tune（5-8 epochs）
```

### 3. 数据增强
```python
# 保持空间一致性
augmentation:
  - RandomFlip3D: 同时翻转所有任务的GT
  - GlobalRotScaleTrans: 同时变换
  - 确保位姿、轨迹、地图的一致性
```

---

## 📊 性能目标

### 最小目标
- 检测mAP: >63%
- 分割mIoU: >55%
- 矢量地图mAP: >48%
- 定位误差: <1.0m
- 轨迹ADE: <1.5m（3秒）

### 理想目标
- 检测mAP: >65%
- 分割mIoU: >60%
- 矢量地图mAP: >52%
- 定位误差: <0.5m
- 轨迹ADE: <1.0m（3秒）

---

## 🚀 快速开始方案

### 最小可行系统（MVP）

**推荐配置**：三任务 + 定位
```
核心能力:
├── 3D检测  ✅
├── BEV分割 ✅
├── 矢量地图 🆕
└── 自车定位 🆕

时间: 3-4周
参数: 130M
推理: 120ms
```

**应用场景**：
- ✅ 完整的感知
- ✅ 精确的定位
- ✅ 高精地图构建
- ✅ 满足L2+自动驾驶需求

---

## 📋 立即可做的准备工作

### 1. MapTR代码研究（4小时）
```bash
cd /workspace
git clone https://github.com/hustvl/MapTR.git
# 研究MapTRHead实现
```

### 2. 定位方案设计（2小时）
```
- 选择定位方案（地图匹配 vs VIO）
- 设计数据流
- 准备BEV地图tile方案
```

### 3. 数据需求分析（1小时）
```
- 矢量地图标注
- BEV地图数据库
- 位姿ground truth
- 存储空间需求
```

---

## 🎯 建议实施路径

### 路径1：全功能系统（7-8周）⭐⭐⭐⭐⭐
```
Week 1-2: 当前训练完成 ✅
Week 3-4: 三任务（+矢量地图）
Week 5: 四任务（+定位）
Week 6: 五任务（+轨迹）可选
Week 7: 优化和部署
```

### 路径2：核心系统（4-5周）⭐⭐⭐⭐⭐
```
Week 1-2: 当前训练完成 ✅
Week 3-4: 三任务（+矢量地图）
Week 5: 四任务（+定位）
  ↓
直接进入部署和优化
```

### 路径3：快速验证（3周）⭐⭐⭐
```
Week 1-2: 当前训练完成 ✅
Week 3: 跳过MapTR，直接实现简化定位
  ↓
快速部署验证
```

---

**下一步决策**：需要确定扩展范围和时间预算！