多模态学习实战：文本与图像联合建模方法

多模态学习实战：文本与图像联合建模方法

想象一下，你正在开发一个电商应用，用户上传了一张商品图片，系统不仅能识别出这是一件“蓝色条纹衬衫”，还能自动生成一段吸引人的商品描述：“这款蓝色条纹衬衫采用纯棉面料，版型修身，适合商务休闲场合。” 或者，你正在做一个内容审核工具，需要同时分析图片中的敏感内容和配文的潜在风险。这些场景背后，都离不开一个关键技术：文本与图像的联合建模，也就是我们常说的多模态学习。

传统的AI模型往往“单打独斗”，要么只处理文字，要么只分析图片。但在真实世界里，信息从来不是孤立的。一张图胜过千言万语，而一段文字又能为图片赋予更丰富的内涵。多模态学习的目标，就是让AI学会像人一样，综合理解来自不同“感官”（模态）的信息，并建立起它们之间的深层联系。

这篇文章，我们就来聊聊如何动手实现文本与图像的联合建模。我会避开那些晦涩的理论推导，直接带你从工程落地的角度，看看几种主流的特征融合和跨模态注意力方法到底怎么用，用代码说话，让你看完就能在自己的项目里试试看。

1. 为什么需要文本与图像联合建模？

在深入技术细节之前，我们先搞清楚，费这么大劲把文字和图片绑在一起建模，到底图个啥？简单说，就是为了解决单一模态模型“看不懂”或“看不全”的问题。

单模态的局限性很明显。一个训练好的图像分类模型，看到猫的图片能认出是“猫”，但它无法告诉你这是“一只正在晒太阳的橘猫”。一个文本情感分析模型，能判断“这部电影太精彩了”是正面评价，但它无法结合电影海报的视觉风格来更精准地判断受众。很多任务本质上就是多模态的，比如：

• 图像描述生成：给一张图，写一段话。
• 视觉问答：根据图片内容回答问题（“图片里有多少个人？”）。
• 跨模态检索：用文字搜图片，或者用图片搜文字。
• 多模态情感分析：结合推文图片和文字判断用户情绪。

联合建模的核心思想，不是简单地把图像特征和文本特征拼接到一起，而是要让它们真正“对话”和“理解”彼此。模型需要学习到，哪些视觉区域对应着文本中的哪些关键词，以及文本的语义如何帮助聚焦图像中的重要部分。这样产生的联合表示，往往比单独处理两个模态然后简单组合，包含更丰富、更鲁棒的信息。

接下来，我们就从最简单的特征拼接开始，逐步深入到更复杂的跨模态注意力机制。

2. 环境搭建与数据准备

工欲善其事，必先利其器。多模态模型通常会用到一些特定的库来处理视觉和语言数据。

2.1 快速搭建PyTorch环境

如果你还没有环境，用conda或pip可以快速搞定。这里假设你已经有Python环境（3.8以上）。

# 使用conda创建环境（推荐，便于管理） conda create -n multimodal python=3.9 conda activate multimodal # 安装PyTorch（请根据你的CUDA版本去PyTorch官网选择对应命令，这里是CPU版本示例） pip install torch torchvision torchaudio # 安装多模态和NLP常用库 pip install transformers # Hugging Face的Transformer库，包含各种预训练文本模型 pip install pillow # 图像处理 pip install pandas # 数据处理

对于多模态学习，transformers库是个宝藏，它不仅提供了BERT、GPT等强大的文本模型，也集成了像CLIP、BLIP这样的多模态预训练模型，我们后面会用到。

2.2 准备一个简单的多模态数据集

为了演示，我们使用一个简化版的“图像-描述”对数据集。你可以很容易地替换成自己的数据。

import torch from torch.utils.data import Dataset, DataLoader from PIL import Image import pandas as pd import os # 假设我们有一个CSV文件，包含图片路径和对应的文本描述 # data.csv 内容类似： # image_path,text # images/cat.jpg,一只猫在沙发上 # images/dog.jpg,公园里奔跑的狗 class MultimodalDataset(Dataset): def __init__(self, csv_file, image_dir, transform=None, tokenizer=None, max_length=30): self.data = pd.read_csv(csv_file) self.image_dir = image_dir self.transform = transform # 图像预处理（缩放、归一化等） self.tokenizer = tokenizer # 文本分词器 self.max_length = max_length def __len__(self): return len(self.data) def __getitem__(self, idx): img_name = os.path.join(self.image_dir, self.data.iloc[idx, 0]) image = Image.open(img_name).convert('RGB') text = self.data.iloc[idx, 1] if self.transform: image = self.transform(image) if self.tokenizer: # 将文本转换为模型可输入的token ids和attention mask encoding = self.tokenizer(text, padding='max_length', truncation=True, max_length=self.max_length, return_tensors='pt') # 去掉最外层的batch维度，因为DataLoader会自己加 input_ids = encoding['input_ids'].squeeze(0) attention_mask = encoding['attention_mask'].squeeze(0) else: input_ids, attention_mask = None, None return { 'image': image, 'input_ids': input_ids, 'attention_mask': attention_mask, 'text': text # 保留原始文本用于验证 } # 示例：定义图像预处理和文本分词器 from torchvision import transforms from transformers import AutoTokenizer # 图像预处理（使用ImageNet的均值和标准差进行归一化是常见做法） image_transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) # 使用BERT的分词器 text_tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased') # 创建数据集和数据加载器 dataset = MultimodalDataset(csv_file='data.csv', image_dir='./', transform=image_transform, tokenizer=text_tokenizer) dataloader = DataLoader(dataset, batch_size=4, shuffle=True) # 检查一个批次的数据 batch = next(iter(dataloader)) print(f"图像张量形状: {batch['image'].shape}") # [batch_size, 3, 224, 224] print(f"文本ID形状: {batch['input_ids'].shape}") # [batch_size, max_length] print(f"注意力掩码形状: {batch['attention_mask'].shape}") print(f"示例文本: {batch['text'][0]}")

数据准备好了，我们就可以开始探索如何让文字和图片的特征“相遇”了。

3. 基础方法：早期与晚期特征融合

特征融合是多模态建模的第一步，根据融合发生的阶段，主要分为早期融合和晚期融合。

3.1 晚期融合：独立处理，最后决策

这是最直观、也最常用的方法。让两个专家（图像CNN和文本Encoder）分别处理自己的数据，在做出最终决策（如分类）前，再把它们的“意见”结合起来。

import torch.nn as nn from transformers import BertModel import torchvision.models as models class LateFusionModel(nn.Module): def __init__(self, num_classes, text_model_name='bert-base-uncased', img_embed_dim=512, txt_embed_dim=768): super().__init__() # 图像编码器：使用预训练的ResNet，去掉最后的全连接层 self.img_encoder = models.resnet18(pretrained=True) self.img_encoder.fc = nn.Identity() # 我们只提取特征 # 加一个投影层，将ResNet输出（512维）映射到统一维度 self.img_proj = nn.Linear(512, img_embed_dim) # 文本编码器：使用预训练的BERT self.txt_encoder = BertModel.from_pretrained(text_model_name) # BERT的[CLS] token输出是768维，也投影到统一维度 self.txt_proj = nn.Linear(txt_embed_dim, txt_embed_dim) # 融合后分类 # 假设融合方式是拼接(concat) combined_dim = img_embed_dim + txt_embed_dim self.classifier = nn.Sequential( nn.Linear(combined_dim, 256), nn.ReLU(), nn.Dropout(0.5), nn.Linear(256, num_classes) ) def forward(self, images, input_ids, attention_mask): # 编码图像 img_features = self.img_encoder(images) # [batch, 512] img_features = self.img_proj(img_features) # [batch, img_embed_dim] # 编码文本 txt_outputs = self.txt_encoder(input_ids=input_ids, attention_mask=attention_mask) # 取[CLS] token的输出作为句子表示 txt_features = txt_outputs.last_hidden_state[:, 0, :] # [batch, 768] txt_features = self.txt_proj(txt_features) # [batch, txt_embed_dim] # 晚期融合：拼接特征 combined_features = torch.cat([img_features, txt_features], dim=1) # [batch, img_embed_dim+txt_embed_dim] # 分类 logits = self.classifier(combined_features) return logits # 实例化模型 model = LateFusionModel(num_classes=2) # 假设是二分类任务，比如“图文是否相关” print(model)

这种方法的优点是：

• 简单灵活：两个模态的模型可以独立预训练，甚至使用不同的架构。
• 易于实现：代码直观，调试方便。缺点是：
• 缺乏交互：在特征提取阶段，图像和文本完全不知道对方的存在，可能丢失了重要的跨模态关联信息。

3.2 早期融合：先混合，再深加工

与晚期融合相反，早期融合在数据处理的初始阶段就将两个模态的信息合并。一种常见做法是将图像特征“铺平”成序列，然后和文本token序列拼接，一起送入一个Transformer编码器。

class EarlyFusionModel(nn.Module): def __init__(self, num_classes, text_model_name='bert-base-uncased', visual_patch_size=16, img_size=224): super().__init__() # 文本编码器：我们仍然用BERT，但只使用它的嵌入层和Transformer层 self.txt_encoder = BertModel.from_pretrained(text_model_name) txt_embed_dim = self.txt_encoder.config.hidden_size # 视觉编码器：使用一个简单的线性层将图像块映射到与文本相同的维度 # 模拟ViT的思路，将图像分割成块 num_patches = (img_size // visual_patch_size) ** 2 patch_dim = 3 * visual_patch_size * visual_patch_size # RGB通道 self.visual_proj = nn.Linear(patch_dim, txt_embed_dim) self.num_patches = num_patches # 可学习的[CLS] token和位置编码 self.cls_token = nn.Parameter(torch.randn(1, 1, txt_embed_dim)) self.pos_embed = nn.Parameter(torch.randn(1, num_patches + 1 + 1, txt_embed_dim)) # +1 for [CLS], +1 for文本序列？这里简化了，实际文本序列长度可变 # 跨模态Transformer编码器（可以直接复用BERT的encoder层） self.cross_modal_transformer = self.txt_encoder.encoder # 分类头 self.classifier = nn.Linear(txt_embed_dim, num_classes) def forward(self, images, input_ids, attention_mask): batch_size = images.shape[0] # 1. 处理图像为序列 # 这里简化处理，实际应用中需要使用卷积或ViT的patch embedding # 假设 images: [batch, 3, 224, 224] # 我们用一个简单的投影来模拟 visual_tokens = self.visual_proj(images.view(batch_size, 3, -1).permute(0, 2, 1)) # [batch, num_pixels, embed_dim] 简化版 # 2. 处理文本（获取token embeddings） txt_embeddings = self.txt_encoder.embeddings(input_ids) # [batch, txt_len, embed_dim] # 3. 早期融合：拼接视觉token和文本token # 添加[CLS] token cls_tokens = self.cls_token.expand(batch_size, -1, -1) # [batch, 1, embed_dim] combined_seq = torch.cat([cls_tokens, visual_tokens, txt_embeddings], dim=1) # [batch, 1+num_patches+txt_len, embed_dim] # 4. 添加位置编码并送入Transformer combined_seq = combined_seq + self.pos_embed[:, :combined_seq.size(1), :] # 需要构建一个覆盖整个融合序列的attention mask（这里简化，实际需要区分图像和文本部分） extended_attention_mask = attention_mask.unsqueeze(1).unsqueeze(2) # 标准BERT mask处理 # ... 这里需要扩展mask以包含视觉token ... encoded_output = self.cross_modal_transformer(combined_seq, extended_attention_mask)[0] # 取最后一层输出 # 5. 用融合后的[CLS] token表示进行分类 fused_cls_output = encoded_output[:, 0, :] # [batch, embed_dim] logits = self.classifier(fused_cls_output) return logits

早期融合的优点是：

• 深度融合：模型从一开始就能学习跨模态的交互。缺点是：
• 计算复杂：序列长度变长（图像块+文本），显著增加计算开销。
• 对齐困难：原始的低层特征可能不在一个语义空间，直接融合效果不一定好。

4. 进阶核心：跨模态注意力机制

无论是早期还是晚期融合，都显得有些“机械”。跨模态注意力机制才是让模型学会“看图说话”和“听文想图”的关键。它允许一个模态的表示（Query）去“询问”另一个模态的表示（Key-Value），从而动态地捕捉相关性。

4.1 双线性注意力网络（Bilinear Attention Networks）

这是一种经典的跨模态注意力，计算图像区域和文本单词之间的细粒度相关性。

class BilinearAttention(nn.Module): """计算图像区域特征V和文本单词特征Q之间的注意力""" def __init__(self, v_dim, q_dim, hidden_dim): super().__init__() self.v_proj = nn.Linear(v_dim, hidden_dim) self.q_proj = nn.Linear(q_dim, hidden_dim) self.hidden_dim = hidden_dim def forward(self, v, q, q_mask=None): """ v: 视觉特征 [batch, num_regions, v_dim] q: 文本特征 [batch, num_words, q_dim] q_mask: 文本掩码 [batch, num_words]，1为有效词，0为填充 返回: 加权的视觉特征 [batch, v_dim] """ batch_size, num_regions, _ = v.size() num_words = q.size(1) # 投影到共同空间 v_proj = self.v_proj(v) # [batch, num_regions, hidden_dim] q_proj = self.q_proj(q) # [batch, num_words, hidden_dim] # 计算双线性注意力分数 # 简化计算：att = softmax(v_proj * q_proj^T) att_scores = torch.bmm(v_proj, q_proj.transpose(1, 2)) # [batch, num_regions, num_words] att_scores = att_scores / (self.hidden_dim ** 0.5) # 缩放 # 应用文本掩码（将填充部分的注意力分数设为极小值） if q_mask is not None: q_mask = q_mask.unsqueeze(1) # [batch, 1, num_words] att_scores = att_scores.masked_fill(q_mask == 0, -1e9) # 计算注意力权重（在文本维度上归一化，表示每个图像区域对每个词的关注程度） att_weights = torch.softmax(att_scores, dim=-1) # [batch, num_regions, num_words] # 用注意力权重对文本特征进行加权求和，得到每个图像区域对应的上下文文本向量 # 这里我们计算每个图像区域的文本上下文 v_context = torch.bmm(att_weights, q_proj) # [batch, num_regions, hidden_dim] # 也可以反过来，计算每个文本单词对应的视觉上下文（双向注意力） # 这里只演示单向 return v_context, att_weights # 将双线性注意力集成到模型中 class BANModel(nn.Module): def __init__(self, v_dim=512, q_dim=768, hidden_dim=1024, num_classes=2): super().__init__() # 假设我们已经有了图像区域特征和文本单词特征 self.attention = BilinearAttention(v_dim, q_dim, hidden_dim) # 注意力后融合与分类 self.fusion = nn.Sequential( nn.Linear(v_dim + hidden_dim, 512), # 拼接原始视觉特征和注意力上下文 nn.ReLU(), nn.Dropout(0.5), ) # 全局池化（例如，对所有区域取平均） self.classifier = nn.Linear(512, num_classes) def forward(self, v, q, q_mask): v_context, att_weights = self.attention(v, q, q_mask) # 拼接每个区域的特征与其文本上下文 fused_per_region = torch.cat([v, v_context], dim=-1) # [batch, num_regions, v_dim+hidden_dim] fused_per_region = self.fusion(fused_per_region) # [batch, num_regions, 512] # 全局平均池化 global_feature = fused_per_region.mean(dim=1) # [batch, 512] logits = self.classifier(global_feature) return logits, att_weights # 返回注意力权重可用于可视化

这种注意力机制能生成一个热力图，显示模型在生成某个单词时关注了图像的哪些区域，可解释性很强。

4.2 使用现成的跨模态Transformer：CLIP编码器

对于想快速上手的开发者，直接使用预训练好的跨模态模型是更高效的选择。OpenAI的CLIP就是一个里程碑式的模型，它通过海量的“图像-文本”对进行对比学习，将两个模态映射到了同一个特征空间。

from transformers import CLIPProcessor, CLIPModel import requests from PIL import Image # 加载预训练的CLIP模型和处理器 model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32") processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32") # 准备图像和文本 url = "http://images.cocodataset.org/val2017/000000039769.jpg" image = Image.open(requests.get(url, stream=True).raw) texts = ["一张猫的照片", "一张狗的照片", "两只猫躺在沙发上"] # 处理输入 inputs = processor(text=texts, images=image, return_tensors="pt", padding=True) # 前向传播 outputs = model(**inputs) logits_per_image = outputs.logits_per_image # 图像与文本的相似度分数 [1, 3] probs = logits_per_image.softmax(dim=1) # 转换为概率 print("文本匹配概率:", probs) # 输出类似：tensor([[0.9950, 0.0025, 0.0025]])，模型高度确信图片匹配“一张猫的照片”

CLIP的强大之处在于其零样本能力。你不需要针对“猫”这个类别进行训练，只要提供“一张猫的照片”这个文本描述，CLIP就能从图像特征空间中找出与之最接近的表示。这对于图像检索、零样本分类等任务非常有用。

如何利用CLIP的特征进行下游任务？你可以提取CLIP的图像编码器和文本编码器产生的特征，作为高质量的多模态表示，然后接一个简单的分类器或回归器来微调你的特定任务。

class CLIPBasedClassifier(nn.Module): def __init__(self, clip_model_name='openai/clip-vit-base-patch32', num_classes=10): super().__init__() self.clip = CLIPModel.from_pretrained(clip_model_name) # 冻结CLIP的大部分参数，只微调分类头 for param in self.clip.parameters(): param.requires_grad = False # 获取特征维度 self.feature_dim = self.clip.config.projection_dim # 通常是512 self.classifier = nn.Linear(self.feature_dim * 2, num_classes) # 拼接图像和文本特征 def forward(self, input_ids, attention_mask, pixel_values): # 提取CLIP特征 with torch.no_grad(): # 冻结时不需要梯度 image_features = self.clip.get_image_features(pixel_values=pixel_values) text_features = self.clip.get_text_features(input_ids=input_ids, attention_mask=attention_mask) # 拼接特征并分类 combined_features = torch.cat([image_features, text_features], dim=1) logits = self.classifier(combined_features) return logits

5. 实战案例：构建一个简单的视觉问答（VQA）模型

让我们把上面的知识串起来，用晚期融合+跨模态注意力的思路，搭建一个超简化的VQA模型。

class SimpleVQAModel(nn.Module): def __init__(self, ans_vocab_size, img_feat_dim=2048, word_embed_dim=300, hidden_dim=1024): super().__init__() # 图像编码器：使用预训练CNN提取网格特征 self.cnn = models.resnet50(pretrained=True) # 移除最后的全连接层和池化层，获取卷积层输出 modules = list(self.cnn.children())[:-2] # 去掉avgpool和fc self.img_encoder = nn.Sequential(*modules) # ResNet50最后一层卷积输出是2048维，特征图大小约7x7 # 问题编码器：简单的LSTM self.word_embed = nn.Embedding(ans_vocab_size, word_embed_dim) # 实际应用应使用预训练词向量 self.lstm = nn.LSTM(word_embed_dim, hidden_dim, batch_first=True, bidirectional=True) # 跨模态注意力（简化版） self.att_proj_v = nn.Linear(img_feat_dim, hidden_dim) self.att_proj_q = nn.Linear(hidden_dim * 2, hidden_dim) # 双向LSTM self.att_combine = nn.Linear(hidden_dim, 1) # 答案预测 self.classifier = nn.Linear(img_feat_dim + hidden_dim * 2, ans_vocab_size) def forward(self, image, question_ids): # 1. 编码图像 [batch, 3, H, W] -> [batch, 2048, 7, 7] img_feat_map = self.img_encoder(image) batch_size, C, H, W = img_feat_map.shape img_feat = img_feat_map.view(batch_size, C, -1).permute(0, 2, 1) # [batch, 49, 2048] # 2. 编码问题 q_embed = self.word_embed(question_ids) # [batch, q_len, word_embed_dim] lstm_out, _ = self.lstm(q_embed) # [batch, q_len, hidden_dim*2] # 取最后一个时间步的输出作为问题表示 q_feat = lstm_out[:, -1, :] # [batch, hidden_dim*2] # 3. 跨模态注意力：问题作为Query，图像区域作为Key/Value q_proj = self.att_proj_q(q_feat).unsqueeze(1) # [batch, 1, hidden_dim] v_proj = self.att_proj_v(img_feat) # [batch, 49, hidden_dim] # 计算注意力分数 att_scores = torch.bmm(v_proj, q_proj.transpose(1, 2)) # [batch, 49, 1] att_scores = att_scores.squeeze(-1) # [batch, 49] att_weights = torch.softmax(att_scores, dim=-1) # [batch, 49] # 加权求和图像特征 att_img_feat = torch.bmm(att_weights.unsqueeze(1), img_feat).squeeze(1) # [batch, 2048] # 4. 融合特征并预测答案 combined = torch.cat([att_img_feat, q_feat], dim=1) # [batch, 2048 + hidden_dim*2] logits = self.classifier(combined) return logits, att_weights # 使用示例 # 假设 ans_vocab_size 是答案词表大小（例如，常见的1000个答案） # image_batch: [batch, 3, 448, 448] (需要调整到CNN输入尺寸) # question_batch: [batch, max_q_len] model = SimpleVQAModel(ans_vocab_size=1000) # ... 训练循环 ...

这个模型虽然简单，但包含了VQA系统的核心组件：视觉特征提取、语言理解、跨模态注意力以及基于融合特征的预测。你可以在此基础上，用更强大的视觉主干网络（如ViT）、更先进的文本编码器（如BERT）以及更复杂的注意力机制（如多层Transformer）来提升性能。

6. 总结与建议

走完这一趟，你应该对文本与图像联合建模的几种实战方法有了直观的感受。从简单的特征拼接，到动态的跨模态注意力，再到直接使用CLIP这样的“巨人”模型，选择哪条路取决于你的具体需求、计算资源和数据情况。

如果你刚刚起步，我建议先从晚期融合开始。它实现简单，能快速验证任务可行性，并且两个模态的预训练模型可以自由组合（比如用ResNet和BERT），效果通常也有保障。

当你需要模型给出“为什么”，比如在医疗影像报告中需要高可解释性，或者在视觉问答中需要关注图像特定区域时，跨模态注意力机制（如BAN）是你的好朋友。它产生的注意力图是连接模型决策与输入数据的桥梁。

如果你的目标是快速原型或零样本应用，并且有充足的文本描述数据，直接微调CLIP等预训练多模态模型可能是最高效的路径。它们提供的联合特征空间非常强大，能大幅降低对下游任务标注数据量的需求。

最后是一些工程上的小建议：

1. 数据是关键：多模态模型对数据质量更敏感。确保你的（图像，文本）对是高质量、强相关的。噪声数据会严重干扰联合表示的学习。
2. 预处理要一致：图像归一化、文本分词等预处理方式，必须与所使用的预训练模型保持一致。
3. 注意模态不平衡：训练时，如果图像和文本特征的量级或更新速度差异太大，可能会导致一个模态“主导”学习过程。可以考虑使用梯度裁剪、不同的学习率等策略。
4. 可视化注意力：如果用了注意力机制，一定要把注意力权重可视化出来看看。这不仅能帮你调试模型，也是理解模型行为、发现数据问题的好方法。

多模态学习正在让AI变得更全面、更智能。希望这篇实战指南能帮你打开这扇门，在实际项目中更好地驾驭文字与图像的力量。

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。