模型微调步骤

图像模型

微调的核心步骤​

1. 预训练模型选择与加载

• 选择与目标任务匹配的成熟模型（如ResNet、ViT等视觉模型）
• 加载预训练权重，冻结底部特征提取层（保留通用视觉特征）

示例：在PyTorch中加载ResNet并冻结底层

1
2
3
4

import torchvision
model = torchvision.models.resnet50(pretrained=True)
for param in model.parameters():
    param.requires_grad = False  # 冻结参数

2. ​模型结构调整

• 替换顶部全连接层：修改输出节点数与新任务类别匹配
• 添加适配层：针对小数据集可插入中间过渡层（如256维全连接层）

示例：替换ResNet分类头

1

model.fc = torch.nn.Linear(model.fc.in_features, num_classes)

3. 数据工程优化

• 数据增强：旋转/裁剪/翻转（如文档3中随机水平翻转和缩放）
• 标准化处理：对齐ImageNet均值方差或领域特定统计量
• 特殊处理：文档4提到的扩散模型需添加噪声后去噪训练

4. ​训练参数配置

• 分层学习率设置：顶部新层用较高学习率（如0.01），底部冻结层用低学习率（如0.001）
• 正则化策略：Dropout（0.5）、权重衰减（1e-4）
• 训练轮次控制：文档2建议通过验证集早停防止过拟合

5. ​评估与迭代

• 指标监控：准确率、混淆矩阵、特征可视化（Grad-CAM）
• 领域自适应：文档5提到的调整模型适应医学/工业图像
• 模型压缩：知识蒸馏优化部署效率

完整的过程

步骤1：数据准备与预处理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import torch
from torchvision import datasets, transforms

# 数据增强与标准化（参考文档[1][3]）
transform = transforms.Compose([
    transforms.Resize(256),  # 调整输入尺寸
    transforms.CenterCrop(224),  # 中心裁剪
    transforms.ToTensor(),  # 转为张量
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # ImageNet标准化
])

# 加载数据集（文档[1][3]示例）
train_dataset = datasets.OxfordIIITPet(
    root="./data",
    split="trainval",
    download=True,
    transform=transform
)
train_loader = torch.utils.data.DataLoader(
    train_dataset,
    batch_size=32,
    shuffle=True
)

步骤2：加载预训练模型

1
2
3
4
5

from torchvision import models

# 加载ResNet50预训练模型（文档[1]实现）
model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
num_classes = len(train_dataset.classes)  # 获取分类数（如宠物数据集为37类）

步骤3：模型结构调整

1
2
3
4
5
6
7

# 冻结除最后一层外的参数（文档[1][3]方案）
for name, param in model.named_parameters():
    if "layer4" not in name and "fc" not in name:
        param.requires_grad = False

# 修改分类头（文档[1][3]核心逻辑）
model.fc = torch.nn.Linear(model.fc.in_features, num_classes)

步骤4：训练配置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import torch.optim as optim
import torch.nn as nn

# 分层学习率设置（文档[1]优化策略）
optimizer = optim.Adam([
    {"params": model.fc.parameters(), "lr": 1e-3},
    {"params": model.layer4.parameters(), "lr": 1e-5}
])

# 损失函数
criterion = nn.CrossEntropyLoss()

步骤5：训练循环

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

for epoch in range(10):
    model.train()
    for inputs, labels in train_loader:
        inputs, labels = inputs.to(device), labels.to(device)
        
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
    
    # 验证代码（参考文档[3]评估方法）
    model.eval()
    correct = 0
    with torch.no_grad():
        for inputs, labels in train_loader:
            inputs, labels = inputs.to(device), labels.to(device)
            outputs = model(inputs)
            _, preds = torch.max(outputs, 1)
            correct += (preds == labels).sum().item()
    print(f"Epoch {epoch} Acc: {correct/len(train_dataset):.2f}")

步骤6：模型测试（单张图片推理）​

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

from PIL import Image

# 加载测试图片
img = Image.open("test_cat.jpg").convert("RGB")
input_tensor = transform(img).unsqueeze(0).to(device)

# 推理预测
model.eval()
with torch.no_grad():
    output = model(input_tensor)
    pred_class = torch.argmax(output).item()
    print(f"预测类别: {train_dataset.classes[pred_class]}")

执行

1
2
3
4
5

# 环境配置
pip install torch torchvision pillow

# 运行训练
python fine_tune.py --epochs 10 --batch_size 32

视频

视频微调比图像多了一条时间维度，核心不是“把每一帧都单独训练”，而是让模型学到动作、顺序和跨帧关系。

1. 先明确任务类型

• 动作分类：给整段视频打一个类别标签
• 时序检测：找出某个动作发生的起止时间
• 视频字幕/问答：输入视频，输出文本描述或答案
• 视频检索：用文本或样本视频去检索相似内容

2. 数据准备

• 统一 fps、分辨率、clip 长度，比如每段采样 8/16/32 帧
• 长视频通常先切成 clip，再做 clip-level 训练，推理时聚合成 video-level 结果
• 除了随机裁剪、翻转，还要做时间抖动、随机采样起点，避免模型只记住固定位置

3. 模型选择与结构调整

• 常见基座：I3D、SlowFast、TimeSformer、VideoMAE、InternVideo
• 小数据集通常先冻结大部分 backbone，只训练分类头，或者在 attention block 上做 LoRA
• 做视频字幕/视频问答时，常见结构是视频编码器 + LLM 解码器

4. 训练要点

• 视频显存开销很大，通常需要混合精度、梯度累积、分布式训练
• 学习率一般比从头训练更小，batch size、帧数、分辨率要一起权衡
• 训练时要区分 frame-level augment 和 sequence-level augment，避免把时序关系增强坏了

5. 评估与部署

• 分类任务看 Top-1/Top-5，检测任务看 mAP，字幕任务看 BLEU/ROUGE
• 推理阶段常做多 clip 采样再投票，吞吐量通常比单帧图像任务低很多
• 上线时还要考虑解码开销，很多系统瓶颈不在模型，而在视频读取和采样

音频

音频微调的核心是把连续波形变成模型能稳定利用的时频特征，再根据任务决定是做分类、识别还是生成。

1. 常见任务

• 语音识别（ASR）：语音转文字
• 说话人识别：判断是谁在说话
• 情感分类：识别开心、愤怒、中性等标签
• 关键词检测：检测固定唤醒词或命令词

2. 数据预处理

• 统一采样率，常见是 16kHz
• 裁掉长静音，控制片段长度，避免大量无效样本
• 常见特征包括 Mel 频谱、log-Mel、MFCC，也可以直接喂原始波形

3. 模型选择

• 语音识别常见基座：Whisper、wav2vec 2.0、HuBERT
• 音频分类常见基座：PANNs、AST、BEATs
• 小样本任务优先用预训练模型，避免从头学声学特征

4. 微调方式

• 分类任务通常替换最后的分类头即可
• ASR 常见做法是保留编码器，微调 CTC 头或 seq2seq 解码器
• 资源有限时适合 LoRA/Adapter，尤其适合只改业务词表或口音适配

5. 训练与评估

• 常见增强：加噪、时间遮挡、频率遮挡、SpecAugment
• 指标按任务选：ASR 看 WER/CER，分类看 Accuracy/F1
• 音频任务很容易被录音设备、噪声环境、口音分布影响，验证集必须贴近真实场景

文本

文本模型微调现在最常见的是 SFT 加参数高效微调，而不是一上来就做全参训练。

1. 先定义任务和数据格式

• 分类、抽取、总结、问答、翻译、代码补全，本质上对应不同的输入输出格式
• 如果是大模型，最好先把样本整理成 instruction/input/output 三段式，方便后续扩展

2. 数据清洗比训练技巧更重要

• 去掉重复、矛盾、过短、无标签样本
• 控制最大长度，避免大量超长样本把显存和训练时间拖垮
• 保留验证集和难例集，不要只看训练损失下降

3. 微调策略选择

• 全参微调：效果上限高，但显存、训练成本、部署成本都高
• LoRA/QLoRA：最常见，适合业务定制、领域知识补充、风格对齐
• Prefix/Prompt Tuning：参数更少，但适用范围通常比 LoRA 窄

4. 训练流程

• 先固定 tokenizer 和 prompt 模板，再做数据打包（packing）和截断策略
• 学习率通常比从头训练小很多，LoRA 常见量级在 1e-4 左右，全参常更低
• 如果目标是对话模型，通常先做 SFT，再看是否需要 DPO/RLHF 这类偏好对齐

5. 评估重点

• 不只看困惑度，还要看任务指标，比如 Rouge、Exact Match、F1、人工抽检
• 重点观察幻觉、格式错误、遗漏字段、拒答率这些线上更敏感的问题
• 领域微调要注意灾难性遗忘，别把原有通用能力训坏了

多模态

多模态微调本质上是让不同模态在同一个语义空间里对齐，再把这种对齐能力用到问答、检索、生成和理解任务上。

1. 常见任务

• 图文问答、图像描述、OCR 理解
• 视频问答、视频字幕
• 语音问答、语音指令理解
• 跨模态检索：文搜图、图搜文、音频搜文本

2. 数据组织方式

• 最基础的是成对数据，如 image-text、audio-text、video-text
• 更复杂的是多轮对话数据、区域标注数据、时间片段标注数据
• 多模态数据难点不在量，而在对齐质量，错配样本会直接把模型训偏

3. 常见模型结构

• 双塔检索模型：如 CLIP，一边编码图像，一边编码文本
• 编码器 + 大模型：如 BLIP-2、LLaVA、Qwen-VL、InternVL
• 训练时常冻结视觉编码器或 LLM 主体，只训练 projector、adapter 或 LoRA

4. 微调重点

• 先明确是“看懂”还是“会说”，前者偏表示学习，后者偏生成能力
• 图像分辨率、patch 数量、视频帧数会直接影响显存和速度
• 文本模板要统一，不然模型会把格式差异学成任务差异

5. 评估与落地

• 看准确率还不够，还要看 grounding、OCR 正确率、定位一致性、幻觉率
• 多模态模型常见问题不是答不出来，而是“看错了还答得很自信”
• 上线时要单独测编码耗时、显存峰值和多轮对话稳定性

补充概念

导数是什么

导数可以先把它理解成“某个点附近的变化速度”。

比如函数：

1

y = x^2

它的导数是：

1

y' = 2x

如果 x = 3，那么导数就是 6。这表示当 x 在 3 附近增加一点点时，y 大约会以 6 倍的速度变化。
例如 x 从 3 变到 3.1：

1
2

3^2 = 9
3.1^2 = 9.61

真实增加了 0.61，而导数给出的线性近似是：

1

6 × 0.1 = 0.6

很接近。这就是导数最直观的意义：描述局部斜率。

梯度下降是什么

梯度下降是训练模型时最常见的参数更新方法，目标是让损失函数一点点变小。

假设有一个很简单的损失函数：

1

L(w) = (w - 2)^2

它在 w = 2 时最小。
它的导数是：

1

L'(w) = 2(w - 2)

如果当前 w = 6，那么导数是：

1

L'(6) = 2 × (6 - 2) = 8

说明当前位置往右是上坡，往左才是下坡。
如果学习率是 0.1，那就按下面的公式更新：

1

w_new = w_old - lr × gradient

代入后得到：

1

w_new = 6 - 0.1 × 8 = 5.2

参数从 6 走到 5.2，离最优点 2 更近了一点。反复执行这个过程，参数就会逐步逼近最优值。

为什么训练时既要算导数又要做反向传播

• 导数回答的是：当前参数往哪个方向改，损失会降得更快
• 梯度是多参数情况下的“导数集合”
• 反向传播是高效计算每个参数梯度的方法

所以训练过程可以概括成四步：

1. 前向计算，得到预测值和损失
2. 反向传播，算出每个参数的梯度
3. 优化器根据梯度更新参数
4. 重复很多轮，直到损失收敛或指标稳定

经典模型

Transformer

自注意力机制的原理 ​- QKV 向量生成

• 每个输入元素（如单词）通过三个独立的线性变换生成三个向量：

如 ​- 查询向量（Query）​：表示当前元素的“提问”，用于查找相关信息 ​- 键向量（Key）​：存储序列元素的“索引”，供 Query 匹配 ​- 值向量（Value）​：包含元素的实际语义内容

公式：

• Q = X * W_Q
• K = X * W_K
• V = X * W_V

​注意力得分计算

• 通过 Query 与所有 Key 的点积计算相似度，再通过缩放和归一化生成权重：

注意力得分 = softmax( (Q·K^T) / √d_k )
-（d_k 为 Key 的维度，用于防止梯度爆炸）

例子：我爱打球
输入向量示例​（简化版）：

• “我” -> [0.9, 0.4, 0.2, 0.1]
• “爱” -> [0.4, 0.8, 0.3, 0.2]
• “打” -> [0.2, 0.3, 0.6, 0.4]
• “球” -> [0.1, 0.2, 0.4, 0.9]

​计算注意力权重​（以“爱”为当前词）：
计算“爱”的 Query 与所有 Key 的点积：

• Q_爱·K_我 = 0.4 * 0.9 + 0.8 * 0.4 + 0.3 * 0.2 + 0.2 * 0.1 = 0.76
• Q_爱·K_爱 = 0.4 * 0.4 + 0.8 * 0.8 + 0.3 * 0.3 + 0.2 * 0.2 = 0.89
• …（其他词同理）

缩放并 softmax 归一化：

• 除以√d_k，d_k=4）：​0.76 / 2 = 0.38

​**“爱"与"爱”**：

• [0.4×0.5, 0.8×0.7, 0.3×0.3, 0.2×0.1] → 0.2 + 0.56 + 0.09 + 0.02 = 0.87
• 缩放后：0.87 / 2 ≈ 0.44

​**“爱"与"打”**：

• [0.4×0.3, 0.8×0.2, 0.3×0.6, 0.2×0.4] → 0.12 + 0.16 + 0.18 + 0.08 = 0.54
• 缩放后：0.54 / 2 = 0.27

​**“爱"与"球”**：

• [0.4×0.1, 0.8×0.2, 0.3×0.4, 0.2×0.9] → 0.04 + 0.16 + 0.12 + 0.18 = 0.5
• 缩放后：0.5 / 2 = 0.25

将四个得分转换为概率分布：

• 原始得分：[0.38（我）, 0.44（爱）, 0.27（打）, 0.25（球）]
• Softmax后：
• exp(0.38)=1.46, exp(0.44)=1.55, exp(0.27)=1.31, exp(0.25)=1.28
• 总和：1.46 + 1.55 + 1.31 + 1.28 ≈ 5.6
• 权重：
• [1.46/5.6≈0.26, 1.55/5.6≈0.28, 1.31/5.6≈0.23, 1.28/5.6≈0.23]

最终权重：

• “爱"与"我”：26%
• “爱"与"爱”：28%
• “爱"与"打”：23%
• “爱"与"球”：23%

概念定义与角色分工
1、Query（查询）​

• ​功能：代表当前需要处理的词或位置的“提问需求”，用于在上下文中检索相关信息。
• ​类比：类似搜索引擎中的用户输入关键词，如搜索“北京天气”时，Query 是用户的问题。
• ​技术逻辑：通过线性变换（权重矩阵）将输入向量转换为 Query 向量，其维度与 Key 一致。
• ​示例：句子“我爱打球”中，“爱”的 Query 向量会聚焦于“谁爱”和“爱什么”的语义关联

2、​Key（键）​

• 功能：作为上下文中所有词的“索引标签”，用于与 Query 匹配相关性。
• ​类比：类似数据库的索引字段，如文档标题、关键词等，用于快速匹配查询需求。
• ​技术逻辑：通过线性变换（权重矩阵 W ）生成 Key 向量，与 Query 点积计算相似度。
• ​示例：在“我爱打球”中，“打”的 Key 可能编码动作特征，与“球”的 Key 形成动宾关联

3、​Value（值）​

• ​功能：存储实际语义信息，根据注意力权重加权后传递到后续层。
• ​类比：类似搜索结果的具体内容，如点击链接后展示的网页正文。
• ​技术逻辑：通过线性变换（权重矩阵 W ）生成 Value 向量，其维度通常与 Query/Key 不同。 ​- 示例：当“爱”的 Query 与“我”的 Key 匹配后，其 Value 向量会携带主语“我”的语义信息

DeepSeek 对 MHA 的改进

1、 DeepSeek 的多头注意力机制
基础架构：

• DeepSeek 的基本模型仍基于 Transformer 框架，其核心组件包含多头注意力机制。
• 与传统 MHA 类似，输入序列通过查询（Query）、键（Key）、值（Value）矩阵的分头计算，捕捉序列中不同位置的特征关联

​MLA 的创新：

• DeepSeek 的 ​多头潜在注意力（MLA）​ 通过以下优化提升效率：
• 低秩键值压缩：将键（Key）和值（Value）矩阵压缩为低维潜在向量，减少 KV 缓存需求（降幅达 93.3%）；
• ​解耦旋转位置编码（RoPE）​：优化位置编码的计算和存储效率，降低长序列处理的内存开销； ​- 动态任务滤波器（DTF）​：在多任务学习中，动态调整不同任务的注意力权重。

DeepSeek 的注意力头数因模型版本而异，具体设计如下：

MHA 和 MLA 对比

DeepSeek的其他优化

架构层面

1. 多头潜在注意力（MLA）
2. 混合专家系统（MoE）

训练效率优化

• 多词元预测（Multi-Token Prediction）
  • 通过同时预测多个后续词元（token），减少序列生成的迭代次数，训练速度提升 2.8 倍
• ​组相对策略优化（GRPO）
  • 摒弃传统监督微调（SFT），直接通过强化学习激发模型推理能力，减少人工标注依赖，数据成本降低 40%。
  • 引入多阶段迭代训练，交替进行监督微调与强化学习，提升任务泛化性

推理加速优化

• ​算法-框架-硬件协同设计
  • 定制化 CUDA 内核优化矩阵乘法和注意力计算，单卡推理吞吐量提升 3.2 倍。 -动态量化技术（8-bit 浮点量化）实现边缘设备部署，移动端推理延迟低于 200ms。
• ​极简 KV 缓存
  • 通过潜在注意力机制，单个 token 的键值缓存从传统 2L×d 压缩至 L×d latent128K 长文本处理显存占用减少 93.3%

其他

RNN 循环神经网络
卷积神经网络（Convolutional Neural Network,CNN）
LSTM（Long Short-Term Memory）长短期记忆网络

总结

如果只记一条主线，微调基本都可以收敛到下面这几个步骤：

• 先定义任务：到底是分类、抽取、生成、检索，还是多模态问答
• 再选基座模型：优先选已经在相近领域验证过的预训练模型
• 准备数据：清洗、格式统一、切分训练集/验证集/测试集
• 选择微调方式：全参、冻结部分层、LoRA、QLoRA、Adapter
• 设训练参数：学习率、batch size、最大长度、epoch、权重衰减、早停
• 做评估：看离线指标，也看坏例子、幻觉、延迟、显存、吞吐
• 最后上线：保存权重、量化、推理服务化、监控回流数据继续迭代

工程上最常见的错误不是“模型不会训”，而是数据格式不稳定、验证集不贴近线上、以及过早迷信某个单点技巧。

辅助工具

可视化监控

• tensorboard
• Visdom

辅助工具

• Jupyter：面向交互式开发的通用环境
• Torchvision：专注于计算机视觉的专用工具库

分布式训练

• 单机并行化
• 多机多卡

参考

• Transformer模型详解
• Transformer核心创新
• 10 分钟理解大语言模型工作原理
• 深度学习之——梯度下降法的数学原理
• 一个简单易懂的例子帮助你理解什么是梯度反向传播算法
• 在Transformer模型中d_k是如何确定的
• 终于把 deepseek 中的多头潜在注意力机制搞懂了