多模态大模型简介

什么是"多模态"？

模态（Modality）= 信息的载体形式。文本是一种模态，图像是另一种，音频、视频、心电图（ECG）信号也都是不同的模态。

多模态 AI 的目标是让模型同时理解和关联多种模态——就像人类既会看（视觉）又会听（听觉）还会读（文字），三者互相补充。

模态编码器

多模态模型的核心架构是一个"翻译 + 融合"的过程：每种模态先用自己的编码器转成特征向量，再在"公共空间"里对齐。

模态	编码器	输入 → 输出	代表模型
📝 文本	Transformer（BERT/GPT）	"一只猫" → [768维向量]	BERT, Qwen, LLaMA
🖼️ 图像	ViT（Vision Transformer）	224×224×3 → [patch序列 → 768维]	ViT, ConvNeXt
📊 时序/ECG	1D CNN / TimesNet	5000采样点 × 12导联 → [特征向量]	ResNet-1D, Transformer-1D
🎵 音频	Whisper Encoder	16kHz波形 → [mel频谱 → token]	Whisper, HuBERT
🎬 视频	ViT + 时序建模	T帧 × 224×224 → [时空特征]	VideoMAE, TimeSformer

💡 核心思想：所有的编码器都输出相同维度的向量，这样不同模态的向量就可以在"公共语义空间"里比较——文本"猫"的向量和猫图片的向量，在空间中距离很近。 

# 不同模态的编码器：输入不同，目标相同——输出特征向量
import torch
from transformers import CLIPModel, CLIPProcessor# CLIP 同时包含文本编码器和图像编码器
model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")# 文本编码器：一句话 → 512维向量
text_inputs = CLIPProcessor(text=["一只猫在沙发上"], return_tensors="pt")
text_features = model.get_text_features(**text_inputs)  # shape: (1, 512)# 图像编码器：一张图 → 512维向量
# image_inputs = CLIPProcessor(images=cat_image, return_tensors="pt")
# image_features = model.get_image_features(**image_inputs)  # shape: (1, 512)print(f"文本特征维度: {text_features.shape}")  # (1, 512)
print(f"两个模态输出同一维度 → 可以直接比较相似度！")

CLIP：图文对齐的鼻祖（2021，OpenAI）

CLIP = Contrastive Language-Image Pre-training。它是第一个用对比学习大规模对齐图文的大模型。

1、训练方式

CLIP 用 4 亿对（图片，描述文字）训练。核心思想极其简单：

🎯 配对的正样本要靠近，不配对的负样本要远离。
假设一个 batch 有 N 对（图片, 文字）→ 只有 N 对是"真正的配对"（对角线），其余 N×(N-1) 对都是"假配对"（负样本）。 

# CLIP 对比学习的核心计算逻辑
# 假设已通过编码器得到图文特征，都已 L2 归一化import torch
import torch.nn.functional as F# 模拟：batch=4 对（猫图+猫文, 狗图+狗文, 车图+车文, 花图+花文）
image_features = torch.randn(4, 512)  # 第0行=猫图, 第1=狗图, ...
text_features  = torch.randn(4, 512)  # 第0行=猫文, 第1=狗文, ...# L2 归一化（让向量落在单位球面上，用余弦相似度）
image_features = F.normalize(image_features, dim=1)
text_features  = F.normalize(text_features, dim=1)# 计算相似度矩阵：image[i] 和 text[j] 的余弦相似度
# logits[i][j] 越大 → 第 i 张图和第 j 段文字越匹配
temperature = 0.07  # 温度参数，控制分布的"尖锐度"
logits = (image_features @ text_features.T) / temperature
# logits 是 4×4 矩阵：对角线是配对分数，其余是负样本分数# 标签：对角线为"正确答案"
labels = torch.arange(4)  # [0,1,2,3] → 第i张图应该匹配第i段文字# 两个方向的交叉熵 loss 取平均
loss_img = F.cross_entropy(logits, labels)       # 图像→文字
loss_txt = F.cross_entropy(logits.T, labels)     # 文字→图像
loss = (loss_img + loss_txt) / 2print(f"对比学习 loss: {loss.item():.4f}")
print(f"相似度矩阵:\n{logits}")
# 训练目标：对角线值越大越好，非对角线值越小越好

2、零样本分类——CLIP 的"超能力"

CLIP 训练完后，不需要任何微调就能做图像分类。只需把类别名填进模板："a photo of {类别}"，选相似度最高的。

# CLIP 零样本分类：不需要训练数据，直接把类别名当"query"
from transformers import CLIPModel, CLIPProcessor
from PIL import Imagemodel = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")# 假设有一张"金毛犬"的照片
# image = Image.open("golden_retriever.jpg")# 定义候选类别：用自然语言描述每个类别
classes = ["a photo of a dog","a photo of a cat","a photo of a car","a photo of a flower",
]# CLIP 会计算图片和每个类别描述的相似度，取最高的
inputs = processor(text=classes, images=image, return_tensors="pt", padding=True)
outputs = model(**inputs)
predicted_class = classes[outputs.logits_per_image.argmax()]
print("零样本分类不需要任何训练数据，直接做分类！")

理解"对比学习"——多模态对齐的核心引擎

对比学习（Contrastive Learning）不是多模态独有的，但在多模态中它是最核心的训练范式。

InfoNCE Loss 公式

对于一对正样本 (x, y) 和 N-1 对负样本：

Loss = -log( e^sim(x,y)/τ / (e^sim(x,y)/τ + Σ e^{sim(x,y_neg)/τ}) )

直觉：分子的 e^sim 代表正样本的吸引力，分母是所有样本的吸引力之和。loss 越小 = 正样本在分母中占比越大 = 正样本比其他所有负样本都更相似。

参数	含义	典型值
τ（温度）	控制区分度。τ 越小 → 对"不够相似"的惩罚越重	0.07
batch size	越大 → 负样本越多 → 学习越充分	CLIP用了 32,768
sim(x,y)	相似度函数，通常用余弦相似度	cos(x,y) = x·y/|x||y|

BLIP-2 / Q-Former：图文 → LLM 的桥梁

CLIP 训练完只能做"相似度匹配"，不能生成文字。怎么让 LLM"看懂"图片并回答问题？

BLIP-2 提出了一个优雅的方案：Q-Former（Querying Transformer）——在图像编码器和 LLM 之间加一个"翻译层"。

1、Q-Former工作流程

图像→ ViT编码 → 257个patch特征→ Q-Former（32个可学习Query token通过Cross-Attention从图像特征中"提取"关键信息）→LLM（把32个Query token当作"软文本"输入生成回答）

# Q-Former 的核心思想：用少量 Query Token "压缩"图像信息
# 类比：你看一张图，不需要记住每个像素，只需要提取"关键信息"class SimpleQFormer(torch.nn.Module):# 简化版 Q-Former：从图像特征中提取压缩表示def __init__(self, image_dim=768, num_queries=32, llm_dim=4096):super().__init__()# 可学习的 Query Token（随机初始化，通过训练学会"问什么"）self.query_tokens = torch.nn.Parameter(torch.randn(1, num_queries, llm_dim))# Cross-Attention：Query Token 去"看"图像特征self.cross_attn = torch.nn.MultiheadAttention(llm_dim, 8, batch_first=True)# 投影层：将图像维度映射到 LLM 维度self.image_proj = torch.nn.Linear(image_dim, llm_dim)def forward(self, image_features):# image_features: (batch, 257, 768) — ViT 输出的 patch 特征batch = image_features.shape[0]image_features = self.image_proj(image_features)  # (batch, 257, 4096)queries = self.query_tokens.expand(batch, -1, -1)  # (batch, 32, 4096)# Cross-Attention：Query 是 Q，图像特征是 K 和 V# 32 个 query 从 257 个图像特征中"挑选"最相关的信息compressed, _ = self.cross_attn(queries, image_features, image_features)return compressed  # (batch, 32, 4096) — 压缩后的图像表示# 这个输出可以直接拼接到 LLM 的 token 序列中

2、两阶段训练

Q-Former 的训练分两个阶段，训练内容完全不同但共用同一个 Q-Former——通过不同的 attention mask 让同一个模型完成不同的任务。

Stage 1：图文表示学习 — 让 Q-Former 学会"看图提取信息"

冻结 ViT，只训练 Q-Former。同一个 Q-Former 同时被 三个 loss 联合训练，共享同一个模型参数：

Loss	全称	做什么	怎么算
ITC	Image-Text Contrastive	图文对比：这张图和这句话是不是在说同一件事？	和 CLIP 一模一样——Query Token 的全局表示 vs 文本 [CLS] 的 InfoNCE loss。用双向 attention。
ITG	Image-grounded Text Generation	看图写话：根据图像生成对应的文本描述	Query Token 的全局表示作为视觉上下文，Q-Former 自己逐 token 预测文本（不是用 LLM）。用因果 attention（只能看前面的 token）。
ITM	Image-Text Matching	图文匹配：这对图文是不是真的配对？	Query Token 全局特征 + 文本 [CLS] 拼起来，过个二分类头，输出是/否。和 ITC 互补——ITC 比"谁更像"，ITM 判断"是不是一对"。用双向 attention。

💡 三个 loss 怎么共用一个 Q-Former？
通过控制 self-attention mask：ITC 和 ITM 用双向 mask（所有 token 互相看见），ITG 用因果 mask（只看前面的）。

同一个 Q-Former 参数，不同 mask 就切换不同任务。这就像同一个人在考试时分别切换"判断题"和"作文题"模式。 

Stage 2：视觉→语言生成学习 — 让 LLM 学会"看懂"图像

冻结 ViT + LLM，只训练 Q-Former。这次 Q-Former 的输出不参与任何 loss 计算——它只是把 32 个 query token 的特征作为 soft visual prompt 喂给 LLM：

ViT 图像特征→Q-Former(输出32个token)→LLM（视觉token + 文本token）→ 自回归生成文字

loss 只算在 LLM 输出的文字部分。

反向传播时：梯度从 LLM 的 loss 传回 Q-Former → Q-Former 学会"调整自己的输出，让它对 LLM 生成正确文字最有帮助"。

Stage 1 vs Stage 2 的核心区别：Stage 1 里 Q-Former 自己是"演员"（直接出 loss），Stage 2 里 Q-Former 是"传话者"（自己不产出最终结果，而是把图像翻译成 LLM 能消化的格式）。因为 LLM 是冻住的，Q-Former 必须学会"说 LLM 听得懂的视觉语言"。 

LLaVA：多模态对话模型

LLaVA（Large Language and Vision Assistant）是目前最流行的开源多模态对话模型。核心思路极其简洁——比 BLIP-2 还简单。

1、LLaVA 架构 = ViT + 投影层 + LLM

图片→ViT-L/14→一个线性投影层（W·x + b）把图像特征映射到 LLM 空间→LLaMA / Qwen（图像token拼在文本token前面一起输入 LLM）

# LLaVA 架构：比 BLIP-2 更简单——投影层代替 Q-Former
# 核心操作：把图像 token 直接拼到文本 token 序列前面class SimpleLLaVA(torch.nn.Module):def __init__(self, vision_encoder, llm, image_dim=1024, llm_dim=4096):super().__init__()self.vision_encoder = vision_encoder  # 冻结的 ViTself.llm = llm                          # LLaMA / Qwen# 只训练这一个投影层！（和 LoRA 的思路类似——改动最小）self.proj = torch.nn.Linear(image_dim, llm_dim)def forward(self, image, text_tokens):# 1. 图像 → ViT → patch 特征img_feat = self.vision_encoder(image)       # (B, N_patches, 1024)# 2. 投影到 LLM 空间img_tokens = self.proj(img_feat)              # (B, N_patches, 4096)# 3. 图像 token + 文本 token → LLM#   [IMG][IMG]...[IMG] [USER]请描述这张图[\n][ASST]combined = torch.cat([img_tokens, text_tokens], dim=1)output = self.llm(inputs_embeds=combined)return output  # LLM 就会"看图说话"了

2、LLaVA 的两阶段训练详解

Stage 1：特征对齐 — 只有一个 loss，只训投影层

冻结 ViT + LLM，只训练投影层。目标极其简单：让图像 token 经过投影后，和对应的文本 token 在 LLM 的嵌入空间中落在同一区域。

Stage 2：指令微调 — 让 LLM 学会多模态对话

冻结 ViT，训练投影层 + LLM（可 LoRA）。这阶段的数据不再是"图文描述"，而是多模态对话

💡 核心逻辑总结：
Stage 1 = 让投影层学会说"LLM 听懂的语言"（翻译官入职培训）
Stage 2 = LLM + 投影层一起学"多模态对话"（团队实战演练）

ViT 从头到尾冻着不动——它在 4 亿张图上训练过，是团队里不用再充电的学霸。 

时序信号多模态：ECG + 文本

前面的内容都是"图片+文字"，但 ECG（心电图）是时序信号——12 条波形曲线，每条几千个采样点。怎么把时序信号和文本对齐？

1、时序编码器：把波形转成向量

# 1D ResNet：为时序信号设计的编码器
# ECG 输入：(batch, 12导联, 5000采样点) → 输出特征向量
# 
# 时序压缩过程（以 5000 采样点为例）：
#   输入:  (B, 12, 5000)     ← 12导联，每导联5000个时间点
#   conv1: (B, 64, 2500)     ← stride=2，长度减半：5000→2500
#   conv2: (B, 128, 1250)    ← stride=2，再减半：2500→1250  
#   conv3: (B, 256, 625)     ← stride=2，再减半：1250→625
#   pool:  (B, 256)          ← 全局池化，625个时间点→1个值
#   proj:  (B, 512)          ← 投影到目标维度，和文本特征同维class ECGEncoder1D(torch.nn.Module):def __init__(self, in_channels=12, out_dim=512):super().__init__()# 每个卷积层：kernel_size=15（每次看15个时间点的波形），stride=2（每次跳2格，长度减半）self.conv1 = torch.nn.Conv1d(in_channels, 64,  kernel_size=15, stride=2, padding=7)self.conv2 = torch.nn.Conv1d(64, 128, kernel_size=15, stride=2, padding=7)self.conv3 = torch.nn.Conv1d(128, 256, kernel_size=15, stride=2, padding=7)# 全局平均池化：把任意长度压缩到1个值self.pool = torch.nn.AdaptiveAvgPool1d(1)self.proj = torch.nn.Linear(256, out_dim)def forward(self, x):# x: (B, 12, 5000)   12导联 × 每导联5000个采样点 = 共60000个数值x = torch.relu(self.conv1(x))   # (B, 64, 2500)   5000→2500：每2个采样点取1个关键信息x = torch.relu(self.conv2(x))   # (B, 128, 1250)  2500→1250：再压缩一半x = torch.relu(self.conv3(x))   # (B, 256, 625)   1250→625：6万个点被压缩成 ~16万个特征值（256×625）x = self.pool(x).squeeze(-1)    # (B, 256)        全局池化：625个时间步→每个通道只留最有代表性的1个值return self.proj(x)               # (B, 512)        投影到和文本特征相同的512维，后续做对比学习

2、ECG-文本对比学习 = CLIP 的思路直接复用

把 CLIP 的"图像编码器"换成上面的"ECG 编码器"，文本编码器不变——完全相同的对比学习框架，只是输入从图片变成了 ECG 波形。

# ECG-Text 对比学习：和 CLIP 一模一样，只是图像→ECG
# 配对数据：(ECG波形, 诊断报告) 如 (房颤波形, "检测到心房颤动")ecg_features  = ecg_encoder(ecg_waveforms)   # (B, 512)
text_features = text_encoder(diagnosis_texts) # (B, 512)# 后面完全和 CLIP 相同：归一化 → 算相似度 → InfoNCE loss
ecg_features  = F.normalize(ecg_features, dim=1)
text_features = F.normalize(text_features, dim=1)
logits = (ecg_features @ text_features.T) / 0.07
labels = torch.arange(batch_size)
loss = (F.cross_entropy(logits, labels) + F.cross_entropy(logits.T, labels)) / 2
# 训练目标：同一份 ECG 的波形和诊断报告在向量空间中靠近

一句话总结时序多模态：CLIP = 图片 + 文字对齐，ECG-CLIP = 波形 + 诊断对齐。框架完全相同，只需要把图像编码器换成时序编码器。

医疗多模态大模型全景

模型	模态	训练数据	核心创新
Med-PaLM 2 (Google)	文本 + 医学图像	MedQA, MedMCQA 等	USMLE 86.5% 专家准确率，引入医学知识增强
LLaVA-Med (Microsoft)	图文	GPT-4 合成的生物医学多模态指令	用 GPT-4 生成训练数据 → 微调小模型
BiomedCLIP	图文	PMC-15M（1500万篇生物医学论文配图）	CLIP 在生物医学领域的垂直适配
ECG-Chat (2024)	ECG + 文本	PTB-XL + 诊断标签	首次用 LLM 做心电报告生成
Med-Gemini (Google)	图文 + 视频 + 基因组	多源医学数据	MedQA 91.1%，多模态推理

医疗多模态领域挑战：

数据稀缺

通用多模态有 4 亿图文对；医疗图文对受隐私限制，通常只有几万到几十万。

解决方案：合成数据、迁移学习、少样本学习。

幻觉零容忍

通用聊天可以"随便聊"；医疗诊断说错一个病名可能引发事故。

需要约束解码 + RAG 证据溯源 + 置信度分层。

多模态融合复杂

一个临床诊断可能涉及：ECG波形 + 超声图像 + 化验单文本 + 病史。需要 3-4 种模态同时融合，比一般的图文多模态复杂得多。

用 CLIP 做中文图文检索

使用 Chinese-CLIP（中文优化版 CLIP），实现"以文搜图"和"以图搜文"

pip install cn_clip transformers torch pillow

# Chinese-CLIP 图文检索实战
# 场景：有一批图片，用户输入中文描述，找出最匹配的图片import torch
import numpy as np
from PIL import Image
from transformers import ChineseCLIPModel, ChineseCLIPProcessor# 加载中文 CLIP 模型
model = ChineseCLIPModel.from_pretrained("OFA-Sys/chinese-clip-vit-base-patch16")
processor = ChineseCLIPProcessor.from_pretrained("OFA-Sys/chinese-clip-vit-base-patch16")# ═══ 模拟：5 张图片 + 5 段描述 ═══
images = [Image.open(f"img_{i}.jpg") for i in range(5)]  # 实际使用时加载图片
captions = ["一只橘色的猫趴在窗台上晒太阳","心电图显示正常窦性心律","一辆红色的跑车停在路边","心电波形呈现不规则颤动，提示房颤","CT 影像显示左肺上叶有结节",
]# 文本编码（在实际使用中也会编码图片）
text_inputs = processor(text=captions, return_tensors="pt", padding=True)
with torch.no_grad():text_features = model.get_text_features(**text_inputs)text_features = text_features / text_features.norm(dim=1, keepdim=True)# ═══ 以文搜文：看哪些描述彼此语义相近 ═══
similarity = text_features @ text_features.T
print("文本相似度矩阵:")
for i, caption in enumerate(captions):# 对每个 caption，找最相似的其他 captionscores = similarity[i].numpy()best = np.argsort(-scores)[1]  # 跳过自己（第0是自己）print(f"  [{i}] {caption[:25]:<25s} ←最像→ [{best}] {captions[best][:25]}")
# 输出示例：
# [1] 心电图显示正常窦性心律  ←最像→ [3] 心电波形呈现不规则颤动
# — 两个 ECG 相关的描述被正确聚在一起！

 用 LoRA 微调 LLaVA

 

# LLaVA 微调：用 LoRA 在自定义数据上训练多模态对话
# 数据格式：{"image": "图片路径", "conversations": [{"role":"user","content":"..."},{"role":"assistant","content":"..."}]}from transformers import LlavaForConditionalGeneration, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model# ═══ Step 1: 加载基座模型（4-bit 量化节省显存）═══
bnb_config = BitsAndBytesConfig(load_in_4bit=True,bnb_4bit_quant_type="nf4",bnb_4bit_use_double_quant=True,
)
model = LlavaForConditionalGeneration.from_pretrained("llava-hf/llava-1.5-7b-hf",quantization_config=bnb_config,device_map="auto",
)# ═══ Step 2: 配置 LoRA — 只训练投影层 + LLM 注意力层 ═══
lora_config = LoraConfig(r=16,                    # LoRA 秩：越大适配能力越强，显存也越大lora_alpha=32,           # 缩放因子：alpha/r = 实际缩放倍率target_modules=["q_proj", "v_proj", "o_proj"],  # 只训练注意力层的 Q、V、Olora_dropout=0.05,bias="none",task_type="CAUSAL_LM",
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()  # 输出：trainable params: ~8M / total: ~7B（0.1%）# ═══ Step 3: 准备训练数据 ═══
# 每条数据：一张图 + 多轮对话
train_data = [{"image": "ecg_afib.jpg","conversations": [{"role": "user", "content": "这张心电图显示了什么异常？"},{"role": "assistant", "content": "检测到心房颤动（AFib）：RR间期不规则，P波消失，心室率约120次/分。建议临床确认。"},]},# ... 更多 ECG 图文对数据
]# ═══ Step 4: 训练（用 Trainer 或手动训练循环）═══
from transformers import Trainer, TrainingArgumentstraining_args = TrainingArguments(output_dir="./llava-ecg-lora",per_device_train_batch_size=2,gradient_accumulation_steps=4,   # 有效 batch = 2×4 = 8learning_rate=2e-4,num_train_epochs=3,logging_steps=10,save_strategy="epoch",fp16=True,                      # 混合精度训练remove_unused_columns=False,
)# trainer = Trainer(model=model, args=training_args, train_dataset=train_dataset)
# trainer.train()
# model.save_pretrained("./llava-ecg-lora-final")  # 只保存 ~30MB 的 LoRA 权重print("LLaVA LoRA 微调完成！只训练了 ~0.1% 参数，权重文件 ~30MB")

 💡 LLaVA 微调的核心要点：

① 图像编码器（ViT）始终冻结——它已经见过 4 亿张图，不需要再训；

② 投影层（一个 Linear）是必训的——它是"翻译官"；

③ LLM 部分用 LoRA 微调——让模型学会"看图说话"的对话模式。 

前沿趋势与总结

Any-to-Any 多模态

GPT-4o, Gemini 等模型可以接受文本+图片+音频+视频的任意组合输入，输出也可以是任意模态。这是多模态的终极形态。

多模态 + Agent

多模态模型不再只是"看图说话"，而是能操作 GUI、控制机器人、分析医学影像并给出治疗建议。

科学多模态

蛋白质结构 + 文本、分子式 + 文献、气象数据 + 卫星图——科学领域的多模态融合刚刚开始。

轻量化多模态

MobileVLM、TinyLLaVA 等 1-3B 参数的多模态模型可以在手机端运行——医疗 AI 下乡成为可能。