DeepSpeed与Trainer组合：多卡大模型微调实战指南

简介：在深度学习领域，分布式训练是解决大模型显存瓶颈的关键技术。其核心原理是通过模型并行、数据并行等方法，将计算负载和模型状态分布到多个GPU上，从而突破单卡显存限制，实现更大规模模型的训练与微调。这项技术的核心价值在于显著提升硬件资源利用率，降低训练成本，并加速模型迭代。其典型应用场景包括大规模语言模型的预训练与指令微调。本文聚焦于利用DeepSpeed的ZeRO优化技术和Hugging Face Trainer的高级API，通过简洁的配置与代码，实现多卡环境下大语言模型的高效微调，有效解决了显存不足和分布式编程复杂两大工程难题。

1. 项目概述：为什么选择 DeepSpeed + Trainer 组合？

如果你正在尝试微调一个参数规模超过10亿的大语言模型，比如 Llama 3、Qwen 或者 InternLM，那么“显存不足”这个红色警告大概率是你遇到的第一个拦路虎。单张消费级显卡（比如 24GB 显存的 RTX 4090）在开启全参数微调时，可能连加载一个 7B 模型都显得捉襟见肘，更别提训练了。这时候，多卡并行训练就成了必须跨越的门槛。

然而，多卡训练的门槛并不低。你需要处理模型并行、数据并行、梯度同步、优化器状态分发等一系列复杂问题。手动编写这些分布式训练代码，不仅容易出错，而且会严重分散你对模型本身和业务逻辑的注意力。这正是deepspeed+trainer这个组合拳的价值所在——它旨在将开发者从繁琐的分布式工程细节中解放出来，用最简单、最高效的方式启动多卡大模型微调。

简单来说，DeepSpeed是微软开源的深度学习优化库，它的核心武器是 ZeRO（Zero Redundancy Optimizer）系列技术，能够智能地将模型状态（参数、梯度、优化器状态）分割并分布到多张 GPU 上，从而极大地降低单卡显存占用，让你能用有限的显卡资源训练起更大的模型。而Trainer（这里通常指 Hugging Face Transformers 库中的Trainer类）是一个高级训练 API，它封装了标准的训练循环、评估、日志记录和 checkpoint 保存等流程，让用户只需关注数据、模型和训练参数。

将两者结合，你就能用几乎与单卡训练相同的简洁代码，享受到 DeepSpeed 带来的强大分布式训练和显存优化能力。这个项目标题deepspeed+trainer简单高效实现多卡微调大模型.zip所指向的，正是这样一套开箱即用的解决方案或示例代码包。它承诺的“简单高效”，意味着你不需要成为分布式系统专家，也能快速搭建起自己的大模型微调实验环境。

2. 核心组件深度解析：DeepSpeed 与 Trainer 如何协同工作？

要理解这个组合为何高效，我们需要拆开看看这两个核心组件各自扮演的角色，以及它们是如何无缝衔接的。

2.1 DeepSpeed：你的显存“魔术师”与分布式“引擎”

DeepSpeed 的核心价值在于其 ZeRO 优化阶段。对于大模型训练，显存主要消耗在三个方面：模型参数（FP16下约 2字节/参数）、梯度（同样约 2字节/参数）和优化器状态（例如 Adam 优化器，需要保存参数的动量（momentum）和方差（variance），在 FP32 下约 8字节/参数）。对于一个 7B 的模型，仅优化器状态就可能需要 7B * 8字节 ≈ 56 GB 显存，这远超单卡容量。

ZeRO 通过在不同阶段消除这些状态在 GPU 间的冗余存储来解决这个问题：

• ZeRO-Stage 1：仅对优化器状态进行分区。每个 GPU 只存储和更新分配给自己的那部分参数的优化器状态。在反向传播后，通过集合通信（All-Reduce）来同步梯度。
• ZeRO-Stage 2：在 Stage 1 基础上，对梯度也进行分区。每个 GPU 只保留与其负责的优化器状态对应的那部分梯度。这进一步降低了显存。
• ZeRO-Stage 3：在 Stage 2 基础上，对模型参数本身也进行分区。每个 GPU 只持有模型的一部分参数。在前向和反向传播过程中，需要时通过通信（gather/scatter）来获取完整的参数或梯度。这是显存节省最激进的模式，可以训练规模远超单卡显存容量的模型，但通信开销会相应增加。

除了 ZeRO，DeepSpeed 还提供了诸如ZeRO-Offload（将优化器状态和梯度卸载到 CPU 内存）、ZeRO-Infinity（进一步卸载到 NVMe 磁盘）等更极致的省显存技术，以及混合精度训练、梯度检查点等优化。

在deepspeed+trainer的架构中，DeepSpeed 扮演着底层分布式训练引擎的角色。Trainer 会将优化器、学习率调度器以及梯度累积等逻辑委托给 DeepSpeed 来处理。

2.2 Trainer：你的标准化训练“流水线”

Hugging Face 的Trainer类是一个抽象层。它定义了一个标准深度学习训练流程所需的所有步骤：从数据加载、批次组织，到前向传播、损失计算、反向传播、参数更新，再到评估指标计算、日志记录和模型保存。用户通过定义TrainingArguments来配置这个流程。

Trainer的强大之处在于其可扩展性。它通过“回调函数”机制允许用户在任何训练阶段插入自定义逻辑。更重要的是，它原生支持与 DeepSpeed 的集成。你只需要在TrainingArguments中指定一个deepspeed配置文件路径，Trainer就会在后台自动初始化 DeepSpeed 引擎，并将训练循环中的优化器、梯度累积、梯度裁剪等操作委托给 DeepSpeed 执行。

这种协同工作的流程可以概括为：

1. 用户层面：你像写单卡训练一样，定义模型、数据、TrainingArguments（其中包含deepspeed配置路径）。
2. Trainer 层面：Trainer初始化时，检测到deepspeed配置，便会调用 DeepSpeed 的初始化函数。
3. DeepSpeed 层面：DeepSpeed 根据配置文件，初始化分布式环境，对模型进行包装（注入 ZeRO 分区逻辑），创建分布式优化器。
4. 执行层面：当调用trainer.train()时，每一步的训练迭代实际上是由 DeepSpeed 引擎驱动的。Trainer负责组织数据并调用引擎的forward、backward和step方法。

2.3 关键配置文件：ds_config.json

连接 Trainer 和 DeepSpeed 的桥梁是一个 JSON 格式的配置文件，通常命名为ds_config.json或类似。这个文件决定了 DeepSpeed 将以何种模式工作。一个针对大模型微调（全参微调）的典型基础配置可能如下所示：

{ “fp16”: { “enabled”: true, “loss_scale”: 0, “loss_scale_window”: 1000, “initial_scale_power”: 16, “hysteresis”: 2, “min_loss_scale”: 1 }, “optimizer”: { “type”: “AdamW”, “params”: { “lr”: 2e-5, “betas”: [0.9, 0.95], “eps”: 1e-8, “weight_decay”: 0.01 } }, “scheduler”: { “type”: “WarmupLR”, “params”: { “warmup_min_lr”: 0, “warmup_max_lr”: 2e-5, “warmup_num_steps”: 500 } }, “zero_optimization”: { “stage”: 2, “allgather_partitions”: true, “allgather_bucket_size”: 2e8, “overlap_comm”: true, “reduce_scatter”: true, “reduce_bucket_size”: 2e8, “contiguous_gradients”: true }, “gradient_accumulation_steps”: 4, “gradient_clipping”: 1.0, “steps_per_print”: 10, “train_batch_size”: “auto”, “train_micro_batch_size_per_gpu”: “auto”, “wall_clock_breakdown”: false }

配置要点解析：

• “zero_optimization”: {“stage”: 2}：这是核心。我们使用 ZeRO Stage 2，在优化器状态和梯度层面进行分区，能在显著节省显存和保持通信效率之间取得很好的平衡，非常适合多卡微调场景。
• “fp16”: {“enabled”: true}：启用混合精度训练，利用 Tensor Cores 加速计算并节省显存。loss_scale设为 0 表示使用动态损失缩放，这是训练稳定性的关键。
• “optimizer”和“scheduler”：在这里统一定义优化器和学习率调度器，DeepSpeed 会据此创建分布式版本。
• “overlap_comm”: true和“contiguous_gradients”: true：这两个是重要的性能优化选项。前者让通信和计算重叠，后者将梯度在通信前复制到连续内存中，都能提升训练速度。
• “train_micro_batch_size_per_gpu”: “auto”：设置为“auto”后，DeepSpeed 会自动采用你在TrainingArguments中设置的per_device_train_batch_size。

注意：这个配置是一个通用的起点。你需要根据你的具体硬件（GPU 型号、数量、显存）、模型大小和数据批次大小来调整stage、bucket_size、gradient_accumulation_steps等参数。例如，如果 4 张 24GB 卡跑 13B 模型仍显存不足，可能需要考虑启用stage: 3或offload_optimizer。

3. 从零到一的完整实操流程

假设我们有一个包含代码的deepspeed+trainer简单高效实现多卡微调大模型.zip压缩包，解压后我们该如何从零开始，让一个大规模语言模型在我们的多卡机器上跑起来？下面是一个详细的步骤拆解。

3.1 环境准备与依赖安装

首先，确保你的环境是干净的。建议使用 Conda 或虚拟环境。

# 1. 创建并激活虚拟环境 conda create -n ds_trainer python=3.10 conda activate ds_trainer # 2. 安装 PyTorch (请根据你的 CUDA 版本到官网选择对应命令) # 例如，对于 CUDA 11.8 pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 # 3. 安装 Hugging Face 核心库和 DeepSpeed pip install transformers datasets accelerate pip install deepspeed # 4. 安装其他可能需要的工具 pip install peft # 如果你后续想尝试 LoRA 等参数高效微调 pip install tensorboard # 用于可视化 pip install scipy sklearn # 用于一些评估指标

环境验证： 安装完成后，强烈建议运行一个简单的 DeepSpeed 测试，确保分布式环境能正常工作。

deepspeed --num_gpus=2 test_installation.py

你可以创建一个test_installation.py文件，内容为import deepspeed; print(‘DeepSpeed installation OK!’)。如果看到各 GPU 进程都打印成功信息，说明基础环境没问题。

3.2 数据准备与预处理

微调的核心之一是数据。我们需要将原始数据（如 JSONL、CSV 或文本文件）处理成Trainer能够消费的Dataset格式。

假设我们做指令微调，数据格式为{“instruction”: “…”, “input”: “…”, “output”: “…”}。

from datasets import load_dataset, Dataset import json # 方式1：从本地文件加载 def load_data_from_file(file_path): data = [] with open(file_path, ‘r’, encoding=‘utf-8’) as f: for line in f: data.append(json.loads(line)) return data raw_data = load_data_from_file(“your_data.jsonl”) dataset = Dataset.from_list(raw_data) # 方式2：使用 Hugging Face datasets 库直接加载（如果数据已上传） # dataset = load_dataset(“your_username/your_dataset_name”) # 关键步骤：数据预处理（Tokenization） from transformers import AutoTokenizer model_name = “meta-llama/Llama-3-8B-Instruct” # 以 Llama 3 为例 tokenizer = AutoTokenizer.from_pretrained(model_name) tokenizer.pad_token = tokenizer.eos_token # 设置填充令牌 def preprocess_function(examples): # 构建模型输入的 prompt 模板 prompts = [] for i in range(len(examples[‘instruction’])): inst = examples[‘instruction’][i] inp = examples[‘input’][i] if inp: prompt = f”Instruction: {inst}\nInput: {inp}\nResponse:” else: prompt = f”Instruction: {inst}\nResponse:” prompts.append(prompt) # 对输入（prompt）进行编码 model_inputs = tokenizer(prompts, max_length=512, truncation=True, padding=“max_length”) # 对输出（response）进行编码，并作为标签 # 注意：在计算损失时，通常只对“响应”部分计算，需要构建 labels responses = examples[‘output’] # 将响应也 tokenize with tokenizer.as_target_tokenizer(): labels = tokenizer(responses, max_length=256, truncation=True, padding=“max_length”) # labels 中，需要将 prompt 部分对应的 token 设为 -100，以便在计算损失时被忽略 labels_input_ids = labels[“input_ids”] # 假设我们将 labels 直接作为完整的 target，更常见的做法是拼接 # 这里我们采用一个更标准的做法：构建一个完整的序列 full_input_ids = [] full_attention_mask = [] full_labels = [] for i in range(len(prompts)): input_ids = model_inputs[“input_ids”][i] response_ids = labels_input_ids[i] # 拼接 prompt 和 response sequence = input_ids + response_ids # 注意力掩码全为1 attention_mask = [1] * len(sequence) # 标签：prompt 部分为 -100，response 部分为 response_ids label = [-100] * len(input_ids) + response_ids # 统一填充或截断到最大长度 max_len = 768 # 总长度 if len(sequence) < max_len: pad_len = max_len - len(sequence) sequence = sequence + [tokenizer.pad_token_id] * pad_len attention_mask = attention_mask + [0] * pad_len label = label + [-100] * pad_len else: sequence = sequence[:max_len] attention_mask = attention_mask[:max_len] label = label[:max_len] full_input_ids.append(sequence) full_attention_mask.append(attention_mask) full_labels.append(label) model_inputs[“input_ids”] = full_input_ids model_inputs[“attention_mask”] = full_attention_mask model_inputs[“labels”] = full_labels return model_inputs # 应用预处理函数 tokenized_dataset = dataset.map(preprocess_function, batched=True, remove_columns=dataset.column_names) # 分割训练集和验证集 split_dataset = tokenized_dataset.train_test_split(test_size=0.1) train_dataset = split_dataset[“train”] eval_dataset = split_dataset[“test”]

数据处理的核心心法：

• 对齐损失计算：大语言模型微调通常是因果语言建模任务。labels的构建是关键，必须将不需要计算损失的部分（如指令、输入）标记为-100，CrossEntropyLoss 会自动忽略这些位置。
• 长度处理：根据你的 GPU 显存，谨慎设置max_length。序列长度是显存占用的二次方增长因素（因为注意力矩阵）。对于微调，通常不需要像预训练那样使用很长的序列。
• 批处理：map函数的batched=True能极大提升 tokenization 速度。

3.3 模型加载与 Trainer 配置

数据准备好后，我们来配置模型和 Trainer。

from transformers import AutoModelForCausalLM, TrainingArguments, Trainer import torch # 1. 加载模型 model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.float16, # 使用半精度加载模型，节省显存 device_map=“auto”, # 使用 accelerate 的自动设备映射，在多卡上平衡加载 trust_remote_code=True # 如果模型需要（如一些社区模型），则开启 ) # 2. 定义训练参数 training_args = TrainingArguments( output_dir=“./output”, # 输出目录 num_train_epochs=3.0, # 训练轮数 per_device_train_batch_size=2, # **重要**：每个 GPU 上的批次大小 per_device_eval_batch_size=2, # 评估批次大小 gradient_accumulation_steps=4, # **重要**：梯度累积步数 # 实际总批次大小 = per_device_train_batch_size * gradient_accumulation_steps * GPU数量 warmup_steps=500, # 学习率预热步数 logging_steps=10, # 日志记录间隔 save_steps=500, # 保存 checkpoint 的间隔 eval_steps=500, # 评估间隔 evaluation_strategy=“steps”, # 按步数评估 save_strategy=“steps”, load_best_model_at_end=True, # 训练结束后加载最佳模型 metric_for_best_model=“eval_loss”, # 根据评估损失选择最佳模型 greater_is_better=False, fp16=True, # 启用混合精度训练（与 DeepSpeed 配置中的 fp16 协同） deepspeed=“./ds_config.json”, # **核心**：指定 DeepSpeed 配置文件路径 report_to=“tensorboard”, # 使用 TensorBoard 记录 ddp_find_unused_parameters=False, # 多卡训练时建议设为 False 以避免警告 ) # 3. 定义评估函数（可选但推荐） def compute_metrics(eval_pred): predictions, labels = eval_pred # 这里 labels 是我们在预处理中构建的，包含 -100 # 我们可以计算准确率或困惑度等 # 简单示例：计算非 -100 位置的平均准确率 predictions = np.argmax(predictions, axis=-1) # 将 labels 中 -100 的位置掩码掉 mask = labels != -100 # 只计算有效位置 predictions = predictions[mask] labels = labels[mask] accuracy = (predictions == labels).astype(np.float32).mean().item() return {“accuracy”: accuracy} # 4. 初始化 Trainer trainer = Trainer( model=model, args=training_args, train_dataset=train_dataset, eval_dataset=eval_dataset, tokenizer=tokenizer, # data_collator=data_collator, # 如果预处理已处理好填充，通常不需要额外的 collator compute_metrics=compute_metrics, )

关键参数解读：

• per_device_train_batch_size：这是每个 GPU 每次前向传播处理的样本数。这是决定显存占用的首要因素。一开始必须设得很小（比如 1 或 2），然后根据 DeepSpeed 报告的显存使用情况调整。
• gradient_accumulation_steps：梯度累积步数。假设per_device_train_batch_size=2，gradient_accumulation_steps=4，GPU数量=4，那么有效的全局批次大小= 2 * 4 * 4 = 32。这个参数让你在有限的单卡批次大小下，模拟一个大的全局批次，这对训练稳定性很重要。
• fp16=True：必须在TrainingArguments中启用，以与ds_config.json中的fp16配置保持一致。
• deepspeed=”./ds_config.json”：这是触发 DeepSpeed 集成的开关。

3.4 启动训练与监控

配置完成后，启动训练就一行命令。但这里有个关键点：必须使用deepspeed启动器，而不是直接运行 Python 脚本。

# 假设你的训练脚本名为 train.py deepspeed --num_gpus=4 train.py

--num_gpus=4指定使用的 GPU 数量。DeepSpeed 会自动处理分布式进程的启动和通信后端（如 torch.distributed）的初始化。

训练监控：

• 控制台日志：DeepSpeed 会打印丰富的日志，包括各 GPU 的显存使用情况、通信时间、迭代速度等。关注[rank0]进程的日志。
• TensorBoard：如果配置了report_to=“tensorboard”，会在output_dir下的runs/目录生成日志。使用tensorboard --logdir ./output/runs查看损失、学习率、评估指标等曲线。
• 显存监控：在另一个终端，使用nvidia-smi -l 1实时观察各卡显存占用。理想情况下，在多卡 ZeRO 训练下，各卡的显存占用应该是比较均衡的。

一个成功的启动标志：你会在日志开头看到 DeepSpeed 的初始化信息，包括 ZeRO 阶段、优化器类型等，并且训练迭代会顺利进行，损失稳步下降。

4. 实战中的核心技巧与避坑指南

纸上得来终觉浅，绝知此事要躬行。下面分享一些在真实多卡微调场景中积累的经验和常见问题的解决方法。

4.1 批次大小与显存优化的艺术

这是微调成功与否的第一个技术关键点。总显存占用 ≈ 模型显存 + 激活显存 + 优化器状态显存 + 梯度显存。DeepSpeed ZeRO 主要优化后三者。

实操步骤：

1. 从极小值开始：将per_device_train_batch_size设为 1，gradient_accumulation_steps根据你想要的全局批次大小反推（例如，想要全局批次 32，用 4 卡，则gradient_accumulation_steps=8）。
2. 启动训练并观察：运行几分钟，看 DeepSpeed 日志中的memory (MB)部分，以及nvidia-smi显示的显存占用。确保没有发生 OOM（Out-Of-Memory）。
3. 逐步增加：如果显存还有富余，可以逐步增加per_device_train_batch_size（每次翻倍）。增加批次大小能提升 GPU 计算利用率，但显存占用几乎线性增长。
4. 调整 ZeRO Stage：如果batch_size=1时依然 OOM，说明模型本身太大。首先尝试在ds_config.json中将zero_optimization.stage从 2 改为 3。这会将参数也分区，节省大量显存，但会增加通信开销。
5. 启用 Offload：如果 Stage 3 还不够，可以考虑启用 CPU Offload。在zero_optimization部分添加：

   “offload_optimizer”: { “device”: “cpu” }

   这会将优化器状态和梯度卸载到 CPU 内存，进一步释放 GPU 显存，代价是训练速度会变慢。
6. 使用梯度检查点：对于非常深的模型（如 32 层以上），激活值会占用大量显存。可以在加载模型时启用梯度检查点：model.gradient_checkpointing_enable()。这会用时间换空间，大约节省 60%-70% 的激活显存，但每个迭代的训练时间会增加 20%-30%。

心得：微调阶段，由于通常不会更新全部参数（如果是全参微调则更新全部），激活显存是主要矛盾。找到一个在显存不溢出的前提下，能最大化 GPU 利用率的batch_size和gradient_accumulation_steps组合，是调优的第一步。我的经验是，在 4 张 24GB 卡上，用 ZeRO Stage 2，微调一个 13B 的模型，per_device_train_batch_size通常可以设在 2-4 之间。

4.2 通信效率与训练速度瓶颈分析

多卡训练的速度并不总是线性增长。瓶颈可能出现在 GPU 间的通信上。

常见瓶颈及排查：

1. CPU 瓶颈：如果数据预处理（如 tokenization）太慢，GPU 会经常空闲等待数据。解决方案：

   • 使用datasets库的map函数并设置num_proc参数进行多进程预处理。
   • 使用DataLoader的pin_memory=True和num_workers参数。
   • 在预处理阶段就完成所有转换，训练时直接加载处理好的Dataset。

2. 通信瓶颈：在 ZeRO Stage 2/3 下，每个训练步都需要进行 All-Reduce 或 Gather/Scatter 操作。

   • 症状：GPU 利用率（通过nvidia-smi看Volatile GPU-Util）波动很大，经常掉到很低水平。
   • 排查：在ds_config.json中设置“wall_clock_breakdown”: true，DeepSpeed 会输出更详细的时间分析日志，可以看到通信耗时占比。
   • 优化：
     • 确保ds_config.json中overlap_comm: true已启用。
     • 调整allgather_bucket_size和reduce_bucket_size。这两个参数控制通信缓冲区的大小。太小的桶会增加通信次数，太大的桶会占用更多显存。通常2e8（200MB）是个不错的起点，可以根据日志调整。
     • 如果使用 NVLink 互联的 GPU（如 A100/A800/H100），通信瓶颈会小很多。对于 PCIe 互联的消费级卡，通信开销相对更大。

3. IO 瓶颈：频繁保存大的模型 checkpoint（尤其是全量保存，而非 DeepSpeed 的分区保存）会拖慢训练。

   • 解决：合理设置save_steps，不要过于频繁。DeepSpeed 的 ZeRO-3 checkpoint 是分区的，保存和加载速度比全量模型快。

4.3 稳定性与收敛性调优

大模型训练容易发散。以下设置有助于稳定训练：

1. 梯度裁剪：在ds_config.json中设置“gradient_clipping”: 1.0（或一个较小的值）。这是防止梯度爆炸的标配。
2. 学习率与热身：对于微调，学习率通常设置得很小（5e-6 到 2e-5）。使用学习率预热（warmup_steps）至关重要，可以让模型平稳地进入训练。在ds_config.json的scheduler部分配置。
3. 混合精度训练：确保fp16已启用，并使用动态损失缩放（“loss_scale”: 0）。动态损失缩放能自动调整缩放因子，处理梯度下溢和上溢问题，比静态缩放更稳定。
4. 检查 Loss Scale：在 DeepSpeed 日志中，关注[loss_scale]的值。如果它频繁变化或变得非常小，可能是训练不稳定的信号，需要调小学习率或检查数据。
5. 验证集监控：一定要设置一个验证集（eval_dataset）并定期评估。如果训练损失下降但验证损失上升，这是过拟合的典型标志，可能需要早停（early_stopping）或增加正则化（如权重衰减weight_decay）。

4.4 模型保存与加载的注意事项

使用 DeepSpeed 训练后，模型的保存和加载与普通 PyTorch 模型不同。

保存：

• 使用trainer.save_model()或trainer.save_state()，Trainer 会与 DeepSpeed 协作，正确保存 ZeRO 分区的模型和优化器状态。
• 保存的目录下会有多个pytorch_model-00001-of-00002.bin这样的分片文件（对应 GPU 数量或 ZeRO 分区数），以及一个zero_to_fp32.py脚本。

加载用于推理/后续训练：

1. 加载为单卡模型（用于推理）：

   # 在保存的 checkpoint 目录下运行 python zero_to_fp32.py . pytorch_model_full.bin

   这个脚本会将所有分区合并成一个完整的 FP32 模型文件pytorch_model_full.bin。然后你可以像加载普通模型一样加载它：

   from transformers import AutoModelForCausalLM model = AutoModelForCausalLM.from_pretrained(“./your_checkpoint”)

   注意，your_checkpoint目录下需要包含config.json和合并后的pytorch_model.bin（可将pytorch_model_full.bin重命名）。

2. 加载以继续训练：如果你想从某个 checkpoint 恢复训练，只需在TrainingArguments中设置resume_from_checkpoint=“path_to_checkpoint”，然后正常启动 DeepSpeed 训练即可。DeepSpeed 会自动加载分区的状态。

踩坑记录：千万不要手动去加载那些分片的.bin文件。一定要通过zero_to_fp32.py脚本合并，或者使用 DeepSpeed/Trainer 的恢复机制。我曾尝试直接加载分片文件，导致参数错乱，模型输出全是乱码。

5. 进阶：当全参微调显存不够时——LoRA 与 DeepSpeed 的结合

即使使用了 DeepSpeed ZeRO-3 和 Offload，全参数微调一个 70B 或更大模型对普通硬件来说仍然是不可及的。这时，参数高效微调技术（PEFT）如LoRA就成了救星。LoRA 通过为模型注入少量的可训练适配器层，而冻结原模型绝大部分参数，从而将可训练参数量降低几个数量级。

好消息是，DeepSpeed 和 LoRA 可以完美结合。你既享受 LoRA 的显存节省，又享受 DeepSpeed 的分布式训练和优化器状态分区。

集成步骤：

1. 安装 PEFT 库：pip install peft
2. 创建 LoRA 配置并修改模型：

   from peft import LoraConfig, get_peft_model lora_config = LoraConfig( r=8, # LoRA 秩 lora_alpha=32, target_modules=[“q_proj”, “k_proj”, “v_proj”, “o_proj”], # 针对 Llama 结构的注意力模块 lora_dropout=0.1, bias=“none”, task_type=“CAUSAL_LM” ) model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16, device_map=“auto”) model = get_peft_model(model, lora_config) model.print_trainable_parameters() # 查看可训练参数量，通常只有原模型的 0.1%~1%

3. 使用 DeepSpeed 训练：接下来的步骤和全参微调完全一样！将配置好 LoRA 的model传给Trainer，并使用相同的deepspeed配置启动训练。

结合后的优势：

• 显存占用极低：因为绝大部分参数被冻结，不需要存储其梯度和优化器状态，ZeRO 需要管理的数据量大大减少。你可能发现 ZeRO Stage 1 甚至 Stage 0 就足够了。
• 训练速度快：可训练参数少，反向传播计算量小。通信量也因为优化器状态很小而大幅减少。
• 保存体积小：只需要保存 LoRA 适配器的权重，checkpoint 文件可能只有几十 MB，而不是几十 GB。

注意事项：

• 在ds_config.json中，zero_optimization.stage仍然可以保持为 2，但它现在主要作用于 LoRA 参数和剩余的少量可训练参数（如分类头）。
• 加载用于推理时，需要先加载原模型，然后再加载 LoRA 权重并合并：

  from peft import PeftModel base_model = AutoModelForCausalLM.from_pretrained(base_model_name) model = PeftModel.from_pretrained(base_model, “./your_lora_checkpoint”) model = model.merge_and_unload() # 将 LoRA 权重合并到原模型 model.save_pretrained(“./merged_model”) # 保存合并后的模型

通过 DeepSpeed + Trainer 这个强大的基础框架，无论是全参微调还是 LoRA 微调，你都能获得一个高效、稳定且易于管理的多卡训练环境。这套组合将分布式训练的复杂性封装在配置文件之下，让你能更专注于模型、数据和任务本身，这才是提升生产效率的关键。

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