AI全景之第六章第四节：多模态大模型

第六章：自然语言处理技术全景

6.4 多模态大模型：视觉-语言联合理解

学习目标

掌握多模态学习的基本原理与核心挑战，理解视觉-语言预训练的关键技术，掌握主流多模态模型的设计思想，具备构建和优化多模态AI系统的实践能力。

一、多模态学习的基本原理

1.1 什么是多模态学习？

多模态的定义

多模态学习研究如何让AI系统理解和关联来自不同模态（如视觉、语言、音频）的信息。

人类多模态认知的启示

人类感知世界天生是多模态的：

• 视觉：识别物体、场景、动作
• 语言：描述、解释、推理
• 听觉：声音、语调、情感
• 触觉：材质、形状、温度

多模态AI的核心挑战

1. 模态鸿沟：不同模态数据分布差异巨大
   • 图像：连续高维空间
   • 文本：离散符号序列
   • 音频：时频信号
2. 表示对齐：如何建立跨模态语义对应
3. 信息融合：如何有效整合不同模态信息
4. 任务适配：不同任务需要不同的融合策略

1.2 多模态任务的分类

1.3 多模态学习的核心问题

语义鸿沟的数学表达

给定图像表示v∈Rdvv \in \mathbb{R}^{d_v}v∈Rdv​和文本表示t∈Rdtt \in \mathbb{R}^{d_t}t∈Rdt​，寻找映射函数fff使得：
[
f(v) \approx g(t)
]
其中ggg是某种语义度量。

对齐策略分类

1. 早期融合：在输入层或低层融合 2. 中期融合：在中间表示层融合 3. 晚期融合：在决策层融合 4. 混合融合：多阶段多层次融合

二、视觉-语言预训练（VLP）的技术演进

2.1 预训练范式的三次跃迁

第一代：双塔架构（Dual Encoder）

classDualEncoderModel(nn.Module):"""双塔架构：图像和文本独立编码"""def__init__(self,image_encoder,text_encoder):super().__init__()self.image_encoder=image_encoder# 如ResNet、ViTself.text_encoder=text_encoder# 如BERTdefforward(self,image,text):# 独立编码image_features=self.image_encoder(image)# [batch, d]text_features=self.text_encoder(text)# [batch, d]# 计算相似度（点积或余弦）similarity=torch.matmul(F.normalize(image_features,dim=-1),F.normalize(text_features,dim=-1).T)returnsimilarity

优点：计算效率高，适合大规模检索
缺点：模态间交互有限，难以处理复杂推理

第二代：融合编码器（Fusion Encoder）

classFusionEncoderModel(nn.Module):"""融合架构：图像和文本深度交互"""def__init__(self,cross_attention_layers):super().__init__()self.cross_attention_layers=cross_attention_layersdefforward(self,image_features,text_features):# 图像和文本特征的深度交互forlayerinself.cross_attention_layers:# 图像作为查询，文本作为键值image_features=layer(query=image_features,key=text_features,value=text_features)# 文本作为查询，图像作为键值text_features=layer(query=text_features,key=image_features,value=image_features)returnimage_features,text_features

优点：模态间充分交互，适合复杂任务
缺点：计算复杂度高，难以扩展

第三代：统一Transformer（Unified Transformer）

将图像和文本统一表示为序列，使用单一Transformer处理：

classUnifiedTransformer(nn.Module):"""统一Transformer：图像patch和文本token一起处理"""def__init__(self,transformer_layers):super().__init__()self.transformer=transformer_layersdefforward(self,image_tokens,text_tokens):# 拼接图像和文本tokencombined_tokens=torch.cat([image_tokens,text_tokens],dim=1)# 统一Transformer处理output=self.transformer(combined_tokens)# 分割输出image_output=output[:,:image_tokens.size(1)]text_output=output[:,image_tokens.size(1):]returnimage_output,text_output

2.2 预训练任务设计

图像-文本对比学习（ITC）

核心思想：拉近匹配的图像-文本对，推远不匹配的对。

classImageTextContrastiveLoss:"""图像-文本对比损失"""def__init__(self,temperature=0.07):self.temperature=temperaturedefcompute_loss(self,image_features,text_features):""" image_features: [batch_size, dim] text_features: [batch_size, dim] """# 归一化image_features=F.normalize(image_features,dim=-1)text_features=F.normalize(text_features,dim=-1)# 计算相似度矩阵logits=torch.matmul(image_features,text_features.T)/self.temperature# [batch_size, batch_size]# 标签：对角线为匹配对labels=torch.arange(logits.size(0),device=logits.device)# 对称对比损失loss_i=F.cross_entropy(logits,labels)# 图像->文本loss_t=F.cross_entropy(logits.T,labels)# 文本->图像return(loss_i+loss_t)/2

掩码语言建模（MLM）的视觉扩展

classMaskedLanguageModelingWithVision:"""结合视觉信息的掩码语言建模"""def__init__(self,mask_prob=0.15):self.mask_prob=mask_probdefcreate_masked_inputs(self,text_tokens,image_features):"""创建掩码文本输入"""batch_size,seq_len=text_tokens.shape# 随机选择掩码位置mask=torch.rand(batch_size,seq_len)<self.mask_prob# 创建掩码后的tokenmasked_tokens=text_tokens.clone()# 80%替换为[MASK]mask_replace=mask&(torch.rand(batch_size,seq_len)<0.8)masked_tokens[mask_replace]=self.mask_token_id# 10%替换为随机词mask_random=mask&(torch.rand(batch_size,seq_len)<0.1)&~mask_replace random_tokens=torch.randint(0,self.vocab_size,(batch_size,seq_len))masked_tokens[mask_random]=random_tokens[mask_random]# 10%保持不变returnmasked_tokens,maskdefcompute_loss(self,text_predictions,original_tokens,mask_positions):"""计算MLM损失（结合视觉信息）"""# 只计算掩码位置的损失masked_predictions=text_predictions[mask_positions]masked_labels=original_tokens[mask_positions]loss=F.cross_entropy(masked_predictions.view(-1,self.vocab_size),masked_labels.view(-1))returnloss

图像-文本匹配（ITM）

classImageTextMatching:"""图像-文本匹配任务"""def__init__(self):self.classifier=nn.Linear(hidden_size,2)# 匹配/不匹配defcreate_negative_pairs(self,image_features,text_features):"""创建负样本对（用于ITM）"""batch_size=image_features.size(0)# 随机打乱文本创建负样本neg_indices=torch.randperm(batch_size)negative_text_features=text_features[neg_indices]# 构建正负样本positive_pairs=torch.cat([image_features,text_features],dim=-1)negative_pairs=torch.cat([image_features,negative_text_features],dim=-1)# 合并并创建标签all_pairs=torch.cat([positive_pairs,negative_pairs],dim=0)labels=torch.cat([torch.ones(batch_size),# 正样本torch.zeros(batch_size)# 负样本]).long()returnall_pairs,labelsdefcompute_loss(self,pair_features,labels):"""计算匹配损失"""logits=self.classifier(pair_features)loss=F.cross_entropy(logits,labels)returnloss

掩码图像建模（MIM）

classMaskedImageModeling:"""掩码图像建模"""def__init__(self,mask_ratio=0.75):self.mask_ratio=mask_ratiodefcreate_masked_images(self,image_patches):"""创建掩码图像patch"""batch_size,num_patches,_=image_patches.shape# 随机选择掩码位置num_masked=int(self.mask_ratio*num_patches)mask_indices=torch.rand(batch_size,num_patches).argsort(dim=-1)mask_indices=mask_indices[:,:num_masked]# 创建掩码mask=torch.zeros(batch_size,num_patches,dtype=torch.bool)foriinrange(batch_size):mask[i,mask_indices[i]]=True# 应用掩码masked_patches=image_patches.clone()# 用可学习的掩码token替换masked_token=nn.Parameter(torch.randn(1,1,image_patches.shape[-1]))masked_patches[mask]=masked_token.expand_as(masked_patches[mask])returnmasked_patches,maskdefcompute_loss(self,reconstructed_patches,original_patches,mask):"""计算重建损失"""# 只计算掩码位置的损失masked_reconstruction=reconstructed_patches[mask]masked_original=original_patches[mask]# MSE损失loss=F.mse_loss(masked_reconstruction,masked_original)returnloss

三、经典多模态模型深度解析

3.1 CLIP：对比学习的革命

核心设计思想

CLIP（Contrastive Language-Image Pretraining）的核心是对比学习：

• 训练目标：最大化匹配图像-文本对的相似度
• 数据规模：4亿个图像-文本对
• 关键创新：从自然语言监督中学习视觉概念

架构实现细节

classCLIPModel(nn.Module):"""CLIP模型完整实现"""def__init__(self,image_encoder_config,text_encoder_config,embed_dim=512):super().__init__()# 图像编码器（ViT或ResNet）self.image_encoder=self.build_image_encoder(image_encoder_config)# 文本编码器（Transformer）self.text_encoder=self.build_text_encoder(text_encoder_config)# 投影层：将不同模态特征映射到共享空间self.image_projection=nn.Linear(self.image_encoder.output_dim,embed_dim)self.text_projection=nn.Linear(self.text_encoder.output_dim,embed_dim)# 可学习的温度参数self.logit_scale=nn.Parameter(torch.ones([])*np.log(1/0.07))defencode_image(self,images):"""编码图像"""image_features=self.image_encoder(images)image_features=self.image_projection(image_features)returnF.normalize(image_features,dim=-1)defencode_text(self,text):"""编码文本"""text_features=self.text_encoder(text)text_features=self.text_projection(text_features)returnF.normalize(text_features,dim=-1)defforward(self,images,text):"""前向传播"""image_features=self.encode_image(images)text_features=self.encode_text(text)# 计算相似度logit_scale=self.logit_scale.exp()logits_per_image=logit_scale*image_features @ text_features.T logits_per_text=logits_per_image.Treturnlogits_per_image,logits_per_textdefbuild_image_encoder(self,config):"""构建图像编码器"""ifconfig['type']=='vit':returnVisionTransformer(image_size=config['image_size'],patch_size=config['patch_size'],hidden_size=config['hidden_size'],num_layers=config['num_layers'],num_heads=config['num_heads'])elifconfig['type']=='resnet':returnResNet(layers=config['layers'],output_dim=config['output_dim'])defbuild_text_encoder(self,config):"""构建文本编码器"""returnTransformerTextEncoder(vocab_size=config['vocab_size'],hidden_size=config['hidden_size'],num_layers=config['num_layers'],num_heads=config['num_heads'],max_length=config['max_length'])

CLIP的训练技巧

classCLIPTrainer:"""CLIP训练优化技巧"""def__init__(self,model,config):self.model=model self.config=config# 梯度缓存：处理超大batch sizeself.gradient_cache=GradientCache()# 混合精度训练self.scaler=torch.cuda.amp.GradScaler()deftraining_step(self,batch):"""训练步骤"""images,texts=batch# 梯度累积withtorch.cuda.amp.autocast():# 前向传播image_features=self.model.encode_image(images)text_features=self.model.encode_text(texts)# 对比损失loss=self.compute_contrastive_loss(image_features,text_features)# 梯度累积loss=loss/self.config.gradient_accumulation_steps# 反向传播self.scaler.scale(loss).backward()# 梯度累积步骤if(self.step+1)%self.config.gradient_accumulation_steps==0:# 梯度裁剪self.scaler.unscale_(self.optimizer)torch.nn.utils.clip_grad_norm_(self.model.parameters(),self.config.max_grad_norm)# 更新参数self.scaler.step(self.optimizer)self.scaler.update()self.optimizer.zero_grad()returnloss.item()defcompute_contrastive_loss(self,</