从零构建多模态大模型：新手入门指南与实战避坑

1次阅读

共计 4471 个字符，预计需要花费 12 分钟才能阅读完成。

多模态大模型（Multimodal Large Model）是指能够同时处理和理解多种数据模态（如文本、图像、音频等）的 AI 模型。与单模态模型相比，它的核心挑战在于实现不同模态间的信息对齐和交互。

模态对齐是指让不同模态的数据在特征空间中具有相似的表示。例如，让 ” 狗 ” 的文本描述和狗的图像在模型内部的特征表示尽可能接近。

这是多模态模型的核心技术之一，允许一个模态的数据去 ” 关注 ” 另一个模态的相关部分。比如在处理 ” 图片中的红色汽车 ” 时，文本中的 ” 红色 ” 可以聚焦到图像中对应的颜色区域。

CLIP：使用对比学习（Contrastive Learning）对齐图像和文本特征
Flamingo：在语言模型基础上添加交叉注意力层处理视觉输入

graph TD
    A[图像输入] --> B[视觉编码器]
    C[文本输入] --> D[文本编码器]
    B --> E[跨模态注意力]
    D --> E
    E --> F[联合表征]

# 检查 CUDA 版本
nvcc --version

# 检查 PyTorch 版本
python -c "import torch; print(torch.__version__)"

# 安装 apex 库（用于混合精度训练）git clone https://github.com/NVIDIA/apex
cd apex
pip install -v --disable-pip-version-check --no-cache-dir --global-option="--cpp_ext" --global-option="--cuda_ext" ./

# 安装 transformers 和 datasets 库
pip install transformers datasets torchvision

from transformers import BertTokenizer, ViTFeatureExtractor
from datasets import load_dataset

# 初始化文本和图像处理器
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
feature_extractor = ViTFeatureExtractor.from_pretrained('google/vit-base-patch16-224')

# 加载多模态数据集
dataset = load_dataset('nlphuji/flickr30k')

def process_example(example):
    # 文本处理
    text_input = tokenizer(example['caption'], 
        padding='max_length', 
        truncation=True, 
        max_length=128,
        return_tensors='pt'
    )

    # 图像处理
    image_input = feature_extractor(example['image'].convert('RGB'),
        return_tensors='pt'
    )

    return {'input_ids': text_input['input_ids'],
        'attention_mask': text_input['attention_mask'],
        'pixel_values': image_input['pixel_values']
    }

dataset = dataset.map(process_example, batched=False)

import torch
import torch.nn as nn
from transformers import BertModel, ViTModel

class CrossModalEncoder(nn.Module):
    def __init__(self):
        super().__init__()
        self.text_encoder = BertModel.from_pretrained('bert-base-uncased')
        self.image_encoder = ViTModel.from_pretrained('google/vit-base-patch16-224')

        # 跨模态注意力层
        self.cross_attention = nn.MultiheadAttention(
            embed_dim=768,  # 与 BERT 和 ViT 的隐藏层维度一致
            num_heads=12
        )

    def forward(self, input_ids, attention_mask, pixel_values):
        # 文本编码
        text_output = self.text_encoder(
            input_ids=input_ids,
            attention_mask=attention_mask
        ).last_hidden_state  # [batch, seq_len, hidden_dim]

        # 图像编码
        image_output = self.image_encoder(pixel_values=pixel_values).last_hidden_state  # [batch, seq_len, hidden_dim]

        # 跨模态注意力
        # 注意：这里简化了实现，实际应用中可能需要更复杂的交互方式
        cross_output, _ = self.cross_attention(
            query=text_output,
            key=image_output,
            value=image_output,
            key_padding_mask=None
        )

        return cross_output

# 使用示例
model = CrossModalEncoder()
with torch.no_grad():
    sample = dataset['train'][0]
    output = model(input_ids=sample['input_ids'].unsqueeze(0),
        attention_mask=sample['attention_mask'].unsqueeze(0),
        pixel_values=sample['pixel_values']
    )

def filter_noisy_pairs(dataset, threshold=0.7):
    """
    基于 CLIP 相似度过滤低质量图文对
    :param threshold: 相似度阈值
    """
    from transformers import CLIPProcessor, CLIPModel

    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    clip_model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32").to(device)
    clip_processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")

    filtered_dataset = []

    for example in dataset:
        inputs = clip_processor(text=example['caption'],
            images=example['image'],
            return_tensors="pt",
            padding=True
        ).to(device)

        with torch.no_grad():
            outputs = clip_model(**inputs)
            logits = outputs.logits_per_image
            similarity = logits.softmax(dim=-1).item()

        if similarity >= threshold:
            filtered_dataset.append(example)

    return filtered_dataset

from torch.cuda.amp import GradScaler, autocast

scaler = GradScaler()
optimizer = torch.optim.AdamW(model.parameters(), lr=5e-5)

for epoch in range(epochs):
    for batch in dataloader:
        optimizer.zero_grad()

        # 混合精度训练
        with autocast():
            outputs = model(input_ids=batch['input_ids'],
                attention_mask=batch['attention_mask'],
                pixel_values=batch['pixel_values']
            )
            loss = compute_loss(outputs, batch['labels'])

        # 梯度缩放和裁剪
        scaler.scale(loss).backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        scaler.step(optimizer)
        scaler.update()

torch.onnx.export(
    model,
    (dummy_input_ids, dummy_attention_mask, dummy_pixel_values),
    "multimodal_model.onnx",
    input_names=["input_ids", "attention_mask", "pixel_values"],
    output_names=["output"],
    dynamic_axes={'input_ids': {0: 'batch_size', 1: 'sequence_length'},
        'attention_mask': {0: 'batch_size', 1: 'sequence_length'},
        'pixel_values': {0: 'batch_size'},
        'output': {0: 'batch_size', 1: 'sequence_length'}
    },
    opset_version=13
)