第35课：毕业项目：多模态分类

📖 本课概述

毕业项目！综合运用全部知识，实现一个多模态分类系统——融合图像和文本信息进行分类。

🎓 一、项目概述

📐 二、多模态融合策略

🏗️ 三、系统架构

3.1 完整实现

import torch
import torch.nn as nn

# 多模态分类系统
print("=== 多模态分类系统 ===")

# 图像编码器（简化CNN）
class ImageEncoder(nn.Module):
    def __init__(self, output_dim=128):
        super().__init__()
        self.cnn = nn.Sequential(
            nn.Conv2d(3, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(64, 128, 3, padding=1), nn.ReLU(), nn.AdaptiveAvgPool2d(1),
        )
        self.fc = nn.Linear(128, output_dim)
    
    def forward(self, x):
        x = self.cnn(x).view(x.size(0), -1)
        return self.fc(x)

# 文本编码器（LSTM）
class TextEncoder(nn.Module):
    def __init__(self, vocab_size=5000, embed_dim=64, hidden_dim=128, output_dim=128):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True, bidirectional=True)
        self.fc = nn.Linear(hidden_dim * 2, output_dim)
    
    def forward(self, x):
        x = self.embedding(x)
        _, (h, _) = self.lstm(x)
        h = torch.cat([h[-2], h[-1]], dim=1)
        return self.fc(h)

# 多模态融合分类器
class MultimodalClassifier(nn.Module):
    def __init__(self, img_dim=128, txt_dim=128, num_classes=10, fusion='concat'):
        super().__init__()
        self.img_encoder = ImageEncoder(img_dim)
        self.txt_encoder = TextEncoder(output_dim=txt_dim)
        self.fusion = fusion
        
        if fusion == 'concat':
            self.classifier = nn.Sequential(
                nn.Linear(img_dim + txt_dim, 256), nn.ReLU(), nn.Dropout(0.3),
                nn.Linear(256, num_classes)
            )
        elif fusion == 'attention':
            self.attention = nn.Sequential(
                nn.Linear(img_dim + txt_dim, 128), nn.ReLU(),
                nn.Linear(128, 2), nn.Softmax(dim=1)
            )
            self.classifier = nn.Linear(max(img_dim, txt_dim), num_classes)
    
    def forward(self, img, txt):
        img_feat = self.img_encoder(img)
        txt_feat = self.txt_encoder(txt)
        
        if self.fusion == 'concat':
            combined = torch.cat([img_feat, txt_feat], dim=1)
            return self.classifier(combined)
        elif self.fusion == 'attention':
            combined = torch.cat([img_feat, txt_feat], dim=1)
            weights = self.attention(combined)  # B×2
            weighted = weights[:, 0:1] * img_feat + weights[:, 1:2] * txt_feat
            return self.classifier(weighted)

# 训练对比
torch.manual_seed(42)
num_classes = 10
img_data = torch.randn(200, 3, 32, 32)
txt_data = torch.randint(0, 5000, (200, 20))
labels = torch.randint(0, num_classes, (200,))

for fusion in ['concat', 'attention']:
    model = MultimodalClassifier(fusion=fusion)
    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
    loss_fn = nn.CrossEntropyLoss()
    
    for epoch in range(50):
        optimizer.zero_grad()
        out = model(img_data, txt_data)
        loss = loss_fn(out, labels)
        loss.backward()
        optimizer.step()
    
    with torch.no_grad():
        acc = (model(img_data, txt_data).argmax(1) == labels).float().mean()
    params = sum(p.numel() for p in model.parameters())
    print(f"融合方式={fusion}: acc={acc:.2%}, params={params:,}")

# 单模态 vs 多模态对比
print("\n=== 单模态 vs 多模态 ===")
# 仅图像
img_model = ImageEncoder(10)
img_opt = torch.optim.Adam(img_model.parameters(), lr=0.001)
for _ in range(50):
    img_opt.zero_grad()
    loss = nn.CrossEntropyLoss()(img_model(img_data), labels)
    loss.backward()
    img_opt.step()
img_acc = (img_model(img_data).argmax(1) == labels).float().mean()

# 仅文本
txt_model = TextEncoder(output_dim=10)
txt_opt = torch.optim.Adam(txt_model.parameters(), lr=0.001)
for _ in range(50):
    txt_opt.zero_grad()
    loss = nn.CrossEntropyLoss()(txt_model(txt_data), labels)
    loss.backward()
    txt_opt.step()
txt_acc = (txt_model(txt_data).argmax(1) == labels).float().mean()

# 多模态
mm_model = MultimodalClassifier(fusion='concat')
mm_opt = torch.optim.Adam(mm_model.parameters(), lr=0.001)
for _ in range(50):
    mm_opt.zero_grad()
    loss = nn.CrossEntropyLoss()(mm_model(img_data, txt_data), labels)
    loss.backward()
    mm_opt.step()
mm_acc = (mm_model(img_data, txt_data).argmax(1) == labels).float().mean()

print(f"仅图像: {img_acc:.2%}")
print(f"仅文本: {txt_acc:.2%}")
print(f"多模态: {mm_acc:.2%}")

🔬 深入拓展

核心要点回顾

本课的核心知识点构成了实战项目学习的重要一环。让我们从更高维度审视这些知识之间的关系：

• 理论层面：理解数学原理是正确应用的前提，每个公式背后都有直觉
• 工程层面：PyTorch提供了高效实现，但理解底层原理才能正确调试
• 实践层面：没有银弹，不同场景需要不同的策略组合

常见陷阱与最佳实践

与前后课程的联系

深度学习是一个整体——每一课的知识都不是孤立的：

• 优化器（第5课）的选择影响正则化（第6课）的效果
• 初始化（第7课）决定了训练能否开始
• CNN（第8-14课）的成功依赖训练技巧（第22-28课）
• Transformer（第20-21课）结合了注意力和位置编码
• 实战项目（第29-35课）综合运用所有知识

📖 延伸阅读

📝 练习

💡 多模态技巧

融合优化

• 先分别训练单模态基线
• 晚期融合最简单有效
• 注意模态间的对齐
• 缺失模态的处理

常见错误与解决方案

性能优化建议

🔬 深度拓展：从理论到实践

核心概念网络

理解本课内容需要将其置于更大的知识网络中。每个核心概念都不是孤立的，它们相互关联、相互支撑：

• 数学基础：线性代数、微积分、概率论是理解所有深度学习算法的根基
• 计算基础：自动微分、GPU并行计算让理论变为现实
• 工程基础：数据处理、模型设计、训练技巧的有机结合
• 领域知识：CV、NLP、语音等领域的先验知识指导模型设计

关键洞察与直觉

建立正确的直觉比记住公式更重要：

与其他课程的关联

本课作为实战项目阶段的核心内容，与前后课程紧密关联：

面试常见问题

进阶学习路径

掌握本课内容后，可以通过以下方式继续深入：

• 阅读本课相关的一手论文，理解原始动机和推导
• 复现论文的实验结果，验证自己的理解
• 尝试改进方法，思考为什么现有方法有局限
• 在真实项目或Kaggle竞赛中应用
• 关注该方向的最新进展（arXiv、顶级会议）