transfer_necessity = {
    "乘用车数据": "10万+图片, 10类分心行为",
    "公交车数据": "几乎为0",
    "直接迁移问题": "视角差异大→准确率骤降",
    "解决方案": "领域自适应知识迁移"
}

import torch
import torch.nn as nn

class CNNBiLSTMTransfer(nn.Module):
    """
    CNN-BiLSTM + 知识迁移框架
    
    CNN: 提取空间特征（面部/手部/姿态）
    BiLSTM: 建模时序依赖（分心行为序列）
    
    知识迁移: 从乘用车预训练→公交车微调
    """
    
    def __init__(self, num_classes=10, pretrained=True):
        super().__init__()
        
        # CNN骨干（ImageNet预训练→乘用车DMS微调）
        self.backbone = self._build_backbone(pretrained)
        
        # 时序建模
        self.bilstm = nn.LSTM(
            input_size=512,  # CNN特征维度
            hidden_size=256,
            num_layers=2,
            batch_first=True,
            bidirectional=True
        )
        
        # 分类头
        self.classifier = nn.Sequential(
            nn.Linear(512, 128),  # BiLSTM双向=512
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, num_classes)
        )
    
    def _build_backbone(self, pretrained):
        """构建CNN骨干网络"""
        # 使用ResNet-18作为基础
        import torchvision.models as models
        resnet = models.resnet18(pretrained=pretrained)
        # 移除最后的FC层
        return nn.Sequential(*list(resnet.children())[:-1])
    
    def forward(self, x):
        """
        Args:
            x: 视频帧序列, shape=(B, T, C, H, W)
               T=帧数（时序窗口）
        """
        B, T, C, H, W = x.shape
        
        # CNN逐帧特征提取
        x = x.view(B * T, C, H, W)
        cnn_features = self.backbone(x)  # (B*T, 512, 1, 1)
        cnn_features = cnn_features.view(B, T, -1)  # (B, T, 512)
        
        # BiLSTM时序建模
        lstm_out, _ = self.bilstm(cnn_features)  # (B, T, 512)
        
        # 取最后时间步
        output = self.classifier(lstm_out[:, -1, :])
        
        return output


# 知识迁移策略
class KnowledgeTransfer:
    """
    三阶段知识迁移
    
    Stage 1: ImageNet → 乘用车DMS (源域)
    Stage 2: 乘用车DMS → 公交车DMS (目标域)  
    Stage 3: 公交车DMS微调
    """
    
    def __init__(self):
        self.model = CNNBiLSTMTransfer(pretrained=True)
    
    def stage1_source_train(self, car_dms_data):
        """Stage 1: 在乘用车DMS数据集上训练"""
        # 使用StateFarm/DDD等公开数据集
        optimizer = torch.optim.Adam(self.model.parameters(), lr=1e-4)
        # ... 标准训练循环
        pass
    
    def stage2_domain_adapt(self, bus_data_limited):
        """Stage 2: 领域自适应"""
        # 冻结CNN骨干底层，仅微调高层+BiLSTM
        for param in self.model.backbone[:-2].parameters():
            param.requires_grad = False
        
        # 对抗域适应
        self.domain_discriminator = nn.Sequential(
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Linear(256, 2)  # 源域/目标域
        )
        
        optimizer = torch.optim.Adam(
            filter(lambda p: p.requires_grad, self.model.parameters()),
            lr=1e-5
        )
        pass
    
    def stage3_finetune(self, bus_data):
        """Stage 3: 在公交车数据上微调"""
        # 解冻所有层
        for param in self.model.parameters():
            param.requires_grad = True
        
        optimizer = torch.optim.Adam(
            self.model.parameters(), lr=1e-6
        )
        pass