fusion_levels = {
    "数据级(Early Fusion)": {
        "原理": "原始传感器数据直接融合",
        "DMS示例": "摄像头+雷达点云→联合编码",
        "优势": "信息保留最完整",
        "劣势": "时空对齐要求高",
        "适用": "传感器同类型/同视角"
    },
    "特征级(Feature Fusion)": {
        "原理": "各传感器提取特征后融合",
        "DMS示例": "面部特征+头部姿态特征→联合分类",
        "优势": "灵活、可异构",
        "劣势": "信息有损失",
        "适用": "DMS最常用"
    },
    "决策级(Late Fusion)": {
        "原理": "各传感器独立决策后投票",
        "DMS示例": "摄像头说疲劳+雷达说正常→加权决策",
        "优势": "模块化、可插拔",
        "劣势": "信息利用最不充分",
        "适用": "不同功能模块独立运行"
    }
}

# 基于任务条件选择融合策略
def select_fusion_strategy(task, sensors, latency_budget, accuracy_priority):
    """
    任务驱动的融合策略选择
    
    Args:
        task: 检测/识别/诊断
        sensors: 可用传感器列表
        latency_budget: 延迟预算(ms)
        accuracy_priority: 精度优先级(1-5)
    """
    if task == "fatigue_diagnosis":
        if latency_budget > 50 and accuracy_priority >= 4:
            return "特征级融合(Transformer attention)"
        elif latency_budget < 20:
            return "决策级融合(加权投票)"
        else:
            return "特征级融合(简单拼接)"
    
    elif task == "occupant_detection":
        if len(sensors) <= 2:
            return "数据级融合(联合编码)"
        else:
            return "特征级融合(attention)"
    
    elif task == "child_presence":
        if "radar" in sensors and "camera" in sensors:
            return "条件融合(摄像头优先→遮挡时切换雷达)"
        elif "radar" in sensors:
            return "单模态(雷达呼吸检测)"
        else:
            return "单模态(摄像头)"
    
    return "特征级融合(默认)"


# 测试
tasks = [
    ("疲劳诊断", ["camera", "rppg", "steering"], 30, 5),
    ("乘员检测", ["pressure", "radar"], 10, 3),
    ("儿童检测", ["camera", "radar"], 15, 5),
    ("分心检测", ["camera"], 15, 4),
]

for task, sensors, lat, pri in tasks:
    strategy = select_fusion_strategy(
        task.lower().replace("诊断", "_diagnosis").replace("检测", "_detection"),
        sensors, lat, pri
    )
    print(f"{task:<12} 传感器={str(sensors):<35} 策略: {strategy}")

import torch
import torch.nn as nn

class DMSMultimodalFusion(nn.Module):
    """
    DMS多模态融合框架
    
    分层架构：
    1. 特征提取（各模态独立）
    2. 特征融合（任务相关）
    3. 决策输出
    """
    
    def __init__(self):
        super().__init__()
        
        # 面部特征提取器
        self.face_encoder = nn.Sequential(
            nn.Linear(68*2 + 1 + 1 + 2 + 4, 256),  # landmarks+perclos+blink+gaze+head
            nn.GELU(),
            nn.Linear(256, 128)
        )
        
        # 雷达特征
        self.radar_encoder = nn.Sequential(
            nn.Linear(50, 64), nn.GELU(), nn.Linear(64, 32)
        )
        
        # rPPG特征
        self.rppg_encoder = nn.Sequential(
            nn.Linear(4, 32), nn.GELU(), nn.Linear(32, 32)
        )
        
        # 方向盘特征
        self.steering_encoder = nn.Sequential(
            nn.Linear(5, 32), nn.GELU(), nn.Linear(32, 16)
        )
        
        # Attention融合（面部相关）
        self.face_attention = nn.MultiheadAttention(128, 4, batch_first=True)
        
        # 门控融合（全模态）
        self.gate = nn.Sequential(
            nn.Linear(128 + 32 + 32 + 16, 64),
            nn.GELU(),
            nn.Linear(64, 4),  # 4个可靠性门
            nn.Sigmoid()
        )
        
        # 决策头
        self.fatigue_head = nn.Sequential(
            nn.Linear(128 + 32 + 16, 64), nn.GELU(), nn.Linear(64, 1)
        )
        self.distraction_head = nn.Sequential(
            nn.Linear(128, 64), nn.GELU(), nn.Linear(64, 1)
        )
        self.cpd_head = nn.Sequential(
            nn.Linear(32 + 128, 64), nn.GELU(), nn.Linear(64, 3)  # 空/成人/儿童
        )
    
    def forward(self, face_feat, radar_feat, rppg_feat, steering_feat):
        # 编码
        f = self.face_encoder(face_feat)  # (B, 128)
        r = self.radar_encoder(radar_feat)  # (B, 32)
        p = self.rppg_encoder(rppg_feat)  # (B, 32)
        s = self.steering_encoder(steering_feat)  # (B, 16)
        
        # 门控
        combined = torch.cat([f, r, p, s], dim=-1)
        gates = self.gate(combined)  # (B, 4)
        
        # 门控融合
        f_g = f * gates[:, 0:1]
        r_g = r * gates[:, 1:2]
        p_g = p * gates[:, 2:3]
        s_g = s * gates[:, 3:4]
        
        # 决策
        fatigue = self.fatigue_head(torch.cat([f_g, p_g, s_g], dim=-1))
        distraction = self.distraction_head(f_g)
        cpd = self.cpd_head(torch.cat([r_g, f_g], dim=-1))
        
        return {
            "fatigue": fatigue,
            "distraction": distraction,
            "cpd": cpd,
            "gates": gates
        }


# 测试
if __name__ == "__main__":
    model = DMSMultimodalFusion()
    
    B = 4  # batch
    face = torch.randn(B, 68*2 + 1 + 1 + 2 + 4)
    radar = torch.randn(B, 50)
    rppg = torch.randn(B, 4)
    steering = torch.randn(B, 5)
    
    out = model(face, radar, rppg, steering)
    
    print("DMS多模态融合输出:")
    print(f"  疲劳评分: {out['fatigue'].shape}")
    print(f"  分心评分: {out['distraction'].shape}")
    print(f"  CPD分类: {out['cpd'].shape}")
    print(f"  传感器门控:")
    labels = ["摄像头", "雷达", "rPPG", "方向盘"]
    for i, label in enumerate(labels):
        print(f"    {label}: {out['gates'][0, i].item():.3f}")