多卡微调大模型实战：Trainer+DeepSpeed配置与避坑指南

简介：这份资源面向希望入门大模型多卡微调的人工智能开发者与研究者，围绕Deepspeed与PyTorch Trainer的组合，讲解如何以简洁代码实现多GPU并行微调，覆盖垂直领域大模型与多模态场景，适合具备一定PyTorch基础、想降低训练成本的中级学习者。压缩包共18个文件，以11个Python脚本为核心，涵盖LoRA、P-Tuning、Freeze等微调方式及ChatGLM建模与分词模块，另有3个Shell启动脚本、2个JSON配置与数据文件，以及LICENSE和README，整体约116KB，结构紧凑便于快速上手。资源中提供了完整的训练脚本、Deepspeed参数配置、指令数据集与推理脚本，读者可据此理解多卡并行策略、梯度累积与优化器配置的落地方式，并掌握从微调到推理的完整链路。目前已有355人学习，适合作为多卡微调大模型的实践参考。

1. 多卡微调大模型：为什么 Trainer + DeepSpeed 是性价比最高的起点

单卡 24G 显存想微调 7B 模型，跑两步就 OOM，这是很多人做大模型微调时遇到的第一个硬墙。换多卡吧，DataParallel 显存不均、梯度同步慢、配置繁琐，折腾一天跑不起来。DeepSpeed 配合 HuggingFace Trainer，是目前把多卡微调大模型这件事做得最简单、最不容易翻车的组合之一——你不需要手写分布式采样器，不需要自己管理 ZeRO 分片，Trainer 已经把集成做好了，你只需要写一个 JSON 配置文件，加几个启动参数。

这套方案适合谁？手里有 2 到 8 张卡、想微调 7B 到 13B 级别模型、不想从零搭训练框架的工程师和研究者。它解决的核心问题是：用最低的代码改动量，把单卡跑不动的微调任务扩展到多卡，同时通过 ZeRO 优化把显存占用压下来。下面从环境搭建到踩坑排查，把这条路走通。

2. 环境搭建与 DeepSpeed 配置：从零到能跑的最小闭环

2.1 版本匹配：最容易翻车的第一步

DeepSpeed、PyTorch、CUDA、Transformers 这四个东西的版本兼容性，是整件事里最玄学的部分。我踩过的坑是：pip install deepspeed 装了最新版，结果和本机 CUDA 对不上，编译直接失败。血泪经验是——先确定 CUDA 版本，再选 PyTorch，最后装 DeepSpeed。

常见做法是先用 conda 锁定 CUDA 和 PyTorch 的对应关系：

# 查看本机 CUDA 版本 nvcc --version nvidia-smi # 以 CUDA 11.8 为例，创建环境 conda create -n ds_train python=3.10 -y conda activate ds_train # 安装对应 CUDA 11.8 的 PyTorch pip install torch==2.1.2 torchvision==0.16.2 --index-url https://download.pytorch.org/whl/cu118 # 安装 transformers 和 deepspeed pip install transformers==4.36.2 pip install deepspeed==0.12.6

这里选 PyTorch 2.1.2 + DeepSpeed 0.12.6 是一个经过验证的稳定组合。DeepSpeed 安装时会自动检测 CUDA 版本并编译对应的算子，如果编译报错，大概率是 CUDA toolkit 没装或者版本不匹配。可以用ds_report命令检查安装状态：

ds_report

输出里重点看DeepSpeed C++/CUDA extension op report部分，如果Compatible NCCL和Compatible CUDA都是 OK，说明环境没问题。如果 CUDA 算子编译失败但你不使用自定义算子，加DS_BUILD_OPS=0跳过编译也能跑，只是某些优化用不了。

2.2 ZeRO 配置文件的三个关键参数

DeepSpeed 的核心配置就是一个 JSON 文件。很多人直接抄网上的配置，但不知道每个参数在干什么，出了问题也不知道从哪调。下面是一个针对多卡微调 7B 模型的 ZeRO-2 配置：

{ "train_batch_size": "auto", "train_micro_batch_size_per_gpu": "auto", "gradient_accumulation_steps": "auto", "zero_optimization": { "stage": 2, "allgather_partitions": true, "allgather_bucket_size": 5e8, "overlap_comm": true, "reduce_scatter": true, "reduce_bucket_size": 5e8, "contiguous_gradients": true }, "fp16": { "enabled": true, "loss_scale": 0, "loss_scale_window": 1000, "initial_scale_power": 16, "hysteresis": 2, "min_loss_scale": 1 }, "gradient_clipping": 1.0, "steps_per_print": 50, "wall_clock_breakdown": false }

三个最关键的参数：

stage：ZeRO 的阶段。stage 1 只分片优化器状态，stage 2 额外分片梯度，stage 3 连模型参数也分片。7B 模型用 stage 2 通常够用，stage 3 虽然省显存但通信开销大，训练速度会明显下降。我一般先用 stage 2 试，OOM 了再升 stage 3。

offload：如果显存实在不够，可以在 zero_optimization 里加"offload_optimizer": {"device": "cpu"}，把优化器状态卸到 CPU 内存。代价是训练速度会慢 20% 到 40%，但能让你在更少的卡上跑更大的模型。

fp16 和 bf16：A100 及以后的卡优先用 bf16，不需要 loss scaling，更稳定。V100 及以前的卡只能用 fp16，需要配置 loss_scale。把上面配置里的"fp16"换成"bf16": {"enabled": true}即可。

注意：train_batch_size设为"auto"时，DeepSpeed 会根据per_device_train_batch_size、gradient_accumulation_steps和卡数自动计算。如果你手动指定了具体数字，三者对不上会直接报错。

2.3 用 Trainer 串起来：训练脚本的最小实现

环境好了，配置有了，接下来是把 Trainer 和 DeepSpeed 接起来。核心改动只有两处：TrainingArguments 里加deepspeed参数指向配置文件，其余代码和单卡训练几乎一样。

import torch from transformers import ( AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments, DataCollatorForSeq2Seq, ) from datasets import load_dataset # 1. 加载模型和 tokenizer model_name = "Qwen/Qwen2-7B" tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True) model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.bfloat16, trust_remote_code=True, ) # 2. 准备数据集（以 alpaca 格式为例） dataset = load_dataset("json", data_files="train.json", split="train") def preprocess(example): messages = [ {"role": "user", "content": example["instruction"]}, {"role": "assistant", "content": example["output"]}, ] text = tokenizer.apply_chat_template(messages, tokenize=False) tokenized = tokenizer(text, truncation=True, max_length=2048, padding=False) tokenized["labels"] = tokenized["input_ids"].copy() return tokenized tokenized_dataset = dataset.map(preprocess, remove_columns=dataset.column_names) # 3. 训练参数 training_args = TrainingArguments( output_dir="./output", num_train_epochs=3, per_device_train_batch_size=4, gradient_accumulation_steps=4, learning_rate=2e-5, lr_scheduler_type="cosine", warmup_ratio=0.1, bf16=True, logging_steps=10, save_strategy="epoch", deepspeed="./ds_config.json", # 关键：指向 DeepSpeed 配置 gradient_checkpointing=True, # 省显存，但慢约 20% dataloader_num_workers=4, report_to="none", ) # 4. 创建 Trainer 并启动 trainer = Trainer( model=model, args=training_args, train_dataset=tokenized_dataset, data_collator=DataCollatorForSeq2Seq(tokenizer, padding=True), ) trainer.train()

逻辑说明：Trainer 检测到deepspeed参数后，会自动初始化 DeepSpeed 引擎，把模型、优化器、数据加载器都交给 DeepSpeed 管理。你不需要手动写DistributedDataParallel或DistributedSampler，Trainer 内部已经处理了。

参数说明：per_device_train_batch_size是每张卡上的 batch size，gradient_accumulation_steps是梯度累积步数，两者相乘再乘以卡数就是全局 batch size。7B 模型 + bf16 + ZeRO-2，单卡 24G 显存下per_device_train_batch_size设 2 到 4 比较稳妥。gradient_checkpointing能省不少显存，但会拖慢训练速度，显存够的话可以关掉。

2.4 启动命令与多卡通信检查

脚本写好了，启动方式有两种。推荐用torchrun：

# 4 卡训练 torchrun --nproc_per_node=4 train.py # 指定特定卡（比如只用 0,1,2,3 号卡） CUDA_VISIBLE_DEVICES=0,1,2,3 torchrun --nproc_per_node=4 train.py

也可以用deepspeed命令启动，效果一样：

deepspeed --num_gpus=4 train.py

启动后先看日志里有没有DeepSpeed相关的初始化信息，确认world_size等于你的卡数。如果卡在初始化阶段不动，大概率是 NCCL 通信问题。加两个环境变量能看到更详细的日志：

NCCL_DEBUG=INFO torchrun --nproc_per_node=4 train.py 2>&1 | head -50

常见的是 NCCL 版本不匹配或者网卡选错了。多机训练时还需要设置MASTER_ADDR和MASTER_PORT，单机多卡一般不用管。

3. 显存与吞吐调优：多卡微调大模型的参数怎么设

3.1 显存不够时的排查顺序

多卡微调大模型，显存问题是最常见的。OOM 报错时不要盲目加卡，按下面的顺序排查：

第一步，看是哪张卡 OOM。如果只有 0 号卡 OOM，说明模型加载或数据分发不均衡。DeepSpeed 的 ZeRO 会均匀分片，但模型加载时如果用了device_map="auto"，可能分布不均。微调场景下不要用device_map，让 DeepSpeed 自己管。

第二步，算一下理论显存需求。7B 模型 bf16 权重约 14GB，优化器状态（Adam）约 56GB，梯度约 14GB，总共约 84GB。4 张 24G 卡共 96GB，ZeRO-2 分片后每卡约 21GB 权重+梯度+优化器，加上激活值，刚好卡在边界。这时候要么减 batch size，要么开 gradient_checkpointing，要么升 ZeRO-3。

第三步，检查是否有显存泄漏。常见的是 tokenizer 的padding=True导致动态 padding 到最大长度，浪费大量显存。改成padding="max_length"配合固定长度截断，或者用 DataCollator 的动态 padding。

3.2 吞吐量上不去的四个原因

显存够了但训练慢，也是常见问题。四个排查方向：

通信开销：ZeRO-3 的通信量比 ZeRO-2 大很多，如果卡间带宽不够（比如 PCIe 而不是 NVLink），stage 3 可能比 stage 2 还慢。用nvidia-smi topo -m看卡间连接方式，NVLink 可以放心用 stage 3，PCIe 建议 stage 2。

数据加载瓶颈：dataloader_num_workers设太小，GPU 等数据。一般设成 CPU 核数的 1/4 到 1/2。但注意，多卡训练时每个进程都会创建 workers，总 workers 数 = num_workers × 卡数，设太大反而会 CPU 争抢。

梯度累积与 batch size：gradient_accumulation_steps设太大，单步计算量小，通信占比高。一般让per_device_train_batch_size尽量大，梯度累积步数控制在 4 到 8 之间。

DeepSpeed 配置里的 bucket size：allgather_bucket_size和reduce_bucket_size默认 5e8，如果模型小或者卡少，可以调小到 2e8 减少通信等待。如果卡多带宽好，调大到 1e9 能提升吞吐。

3.3 学习率与 batch size 的缩放关系

多卡训练时全局 batch size 变大了，学习率要不要跟着调？这是很多人纠结的问题。经验规则是：全局 batch size 翻倍，学习率可以适当增大，但不是线性关系。我一般用平方根缩放：新学习率 = 基础学习率 × sqrt(新 batch size / 基础 batch size)。

比如单卡 batch size 4、学习率 2e-5，换成 4 卡后全局 batch size 变成 16，学习率可以调到 2e-5 × sqrt(16/4) = 4e-5。但这不是铁律，还要看任务。微调任务通常学习率在 1e-5 到 5e-5 之间，先用小学习率跑几百步看 loss 曲线，再决定要不要调大。

提示：多卡训练时 loss 曲线会比单卡更平滑，因为梯度是多个卡平均的。不要因为 loss 下降慢就急着调大学习率，先确认全局 batch size 和学习率的比例是否合理。

4. 避坑与排查：多卡微调大模型最常见的五个翻车现场

4.1 坑一：NCCL 超时导致训练卡死

现象：训练启动后卡在Initializing process group或跑了几步后 hang 住，日志没有报错，GPU 利用率掉到 0。

原因：NCCL 通信超时，常见于卡间通信被防火墙拦截、网卡选择错误、或者某张卡被其他进程占用。

解决：先设置export NCCL_TIMEOUT=1800增大超时时间。然后检查是否有残留进程占用 GPU：nvidia-smi看有没有僵尸进程，有的话kill -9掉。如果是多机训练，确认MASTER_ADDR和MASTER_PORT正确，且端口没有被防火墙拦截。单机多卡的话，加export NCCL_P2P_DISABLE=1禁用 P2P 通信试试，有时候是 P2P 兼容性问题。

4.2 坑二：DeepSpeed 配置里的 auto 值对不上

现象：启动时报错AssertionError: train_batch_size must be equal to ...或者micro_batch_size * gradient_accumulation_steps * world_size != train_batch_size。

原因：DeepSpeed 配置里train_batch_size设了具体数字，但和 TrainingArguments 里的per_device_train_batch_size、gradient_accumulation_steps以及卡数不匹配。

解决：最简单的办法是把这三个值都设成"auto"，让 DeepSpeed 自己算。如果非要手动指定，公式是：train_batch_size = per_device_train_batch_size × gradient_accumulation_steps × world_size。改完配置后确认一下卡数有没有变，换了卡数这个值也要跟着改。

4.3 坑三：模型保存时只有主进程有文件

现象：训练结束，output_dir里只有pytorch_model.bin或者分片文件不全，加载模型时报错。

原因：DeepSpeed 保存的是分片 checkpoint，需要额外转换才能变成 HuggingFace 格式。Trainer 默认会调用save_model保存完整模型，但如果中途手动中断或者配置不对，可能只保存了 DeepSpeed 的 checkpoint。

解决：训练结束后用 Trainer 的save_model方法显式保存：

trainer.save_model("./final_model") tokenizer.save_pretrained("./final_model")

如果只有 DeepSpeed 的分片 checkpoint，可以用脚本转换：

python zero_to_fp32.py ./output/checkpoint-1000 ./final_model/pytorch_model.bin

这个脚本在 DeepSpeed 安装目录下，转换时需要指定 checkpoint 目录和输出路径。

4.4 坑四：bf16 和 fp16 混用导致 loss 变 NaN

现象：训练几步后 loss 变成 NaN，或者梯度爆炸。

原因：模型加载时用了 bf16，但 DeepSpeed 配置里开的是 fp16，两者冲突。或者 V100 卡上强行用 bf16，硬件不支持。

解决：确认卡的支持情况。A100、A800、H100、H800 支持 bf16，V100、T4、2080Ti 只支持 fp16。模型加载的torch_dtype和 DeepSpeed 配置里的精度设置必须一致。用 fp16 时如果 loss 变 NaN，把initial_scale_power从 16 调到 12 或更低，让 loss scaling 更保守。

4.5 坑五：数据并行时指标计算重复

现象：训练日志里的 loss 看起来正常，但自己算的 eval loss 和 Trainer 报的对不上，或者 accuracy 偏高。

原因：多卡训练时每个进程都会算指标，Trainer 默认会做 all_reduce 平均，但如果自定义了compute_metrics函数，没有正确处理多卡情况，指标会重复计算。

解决：用 Trainer 内置的指标计算，或者在自己的compute_metrics里用accelerator.gather收集所有卡的预测结果再算。简单做法是只在主进程算指标：

from transformers import Trainer class CustomTrainer(Trainer): def compute_metrics(self, eval_pred): if not self.is_world_process_zero(): return {} # 只在主进程计算 preds = eval_pred.predictions.argmax(-1) labels = eval_pred.label_ids return {"accuracy": (preds == labels).mean()}

注意：多卡训练时日志和保存默认只在主进程执行，但如果你自己写了 print 或文件写入，记得加if trainer.is_world_process_zero()判断，否则每个卡都会写一遍。

5. 进阶技巧：用 DeepSpeed 的推理优化和 checkpoint 管理省下后悔药

训练跑通了只是第一步，后面还有两件事值得花时间：推理加速和 checkpoint 管理。这两个做不好，前面省下的时间全得还回去。

5.1 用 DeepSpeed Inference 加速微调后的模型

微调完的模型要上线推理，直接用 PyTorch 加载，7B 模型单卡推理延迟可能到几百毫秒。DeepSpeed 的 Inference 引擎可以做张量并行，把模型切到多卡上，延迟能降不少。用法比训练简单：

import deepspeed import torch from transformers import AutoModelForCausalLM, AutoTokenizer model_name = "./final_model" tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.bfloat16) # 初始化 DeepSpeed Inference 引擎 ds_engine = deepspeed.init_inference( model, mp_size=2, # 张量并行度，等于使用的卡数 dtype=torch.bfloat16, replace_with_kernel_inject=True, # 用 DeepSpeed 的优化 kernel ) # 推理 input_text = "介绍一下深度学习" inputs = tokenizer(input_text, return_tensors="pt").to("cuda") outputs = ds_engine.module.generate(**inputs, max_new_tokens=128) print(tokenizer.decode(outputs[0], skip_special_tokens=True))

mp_size设成 2 表示用 2 张卡做张量并行，每张卡存一半的模型参数。replace_with_kernel_inject=True会替换 Transformer 里的注意力计算为 DeepSpeed 的优化实现，速度提升明显。注意这个模式只适合推理，不能继续训练。

5.2 checkpoint 的保留策略与恢复训练

多卡微调大模型，checkpoint 文件很大。7B 模型一个 checkpoint 约 14GB，如果每 500 步存一次，跑 5000 步就是 10 个 checkpoint，140GB 硬盘就没了。合理的策略是：

恢复训练时，Trainer 会自动检测 output_dir 里最新的 checkpoint：

torchrun --nproc_per_node=4 train.py --resume_from_checkpoint ./output/checkpoint-1500

或者在 TrainingArguments 里设resume_from_checkpoint=True，让它自动找最新的。注意 DeepSpeed 的 checkpoint 恢复需要所有卡上的分片文件都在，少一个都会报错。如果中途换了卡数，checkpoint 可能不兼容，需要重新转换。

5.3 一个我常用的调试习惯

多卡训练出问题时，日志信息量大但关键信息容易被淹没。我习惯在训练脚本开头加一段环境信息打印，出问题时一眼就能看到关键配置：

import os import torch import deepspeed def print_env_info(): print(f"CUDA_VISIBLE_DEVICES: {os.environ.get('CUDA_VISIBLE_DEVICES', 'not set')}") print(f"World size: {torch.distributed.get_world_size() if torch.distributed.is_initialized() else 'not initialized'}") print(f"Local rank: {os.environ.get('LOCAL_RANK', 'not set')}") print(f"DeepSpeed version: {deepspeed.__version__}") print(f"PyTorch version: {torch.__version__}") print(f"CUDA available: {torch.cuda.is_available()}") print(f"GPU count: {torch.cuda.device_count()}") for i in range(torch.cuda.device_count()): print(f"GPU {i}: {torch.cuda.get_device_name(i)}, " f"Memory: {torch.cuda.get_device_properties(i).total_memory / 1e9:.1f} GB") print_env_info()

这段代码在训练启动时打印一次，能快速确认卡数、版本、显存是否符合预期。我遇到过好几次因为CUDA_VISIBLE_DEVICES没设对，导致实际只用了一张卡但以为用了四张的情况。多卡训练这件事，配置对了就很简单，配置错了就是黑匣子。把环境信息打出来，至少能排除一半的低级问题。

希望帮到你。

本文还有配套的精品资源，点击获取