文本摘要项目-DeepSpeed与LLaMA-Factory

{
  "instruction": "请提取以下内容中的摘要信息",
  "input": "冬季护肤五大步骤：\n1. 使用温和氨基酸洁面乳\n2. 早晚涂抹含神经酰胺面霜...",
  "output": "温和洁面、保湿面霜、定期面膜、日常防晒、颈部防护"
}

conda create -n llm_env python=3.11.14
conda activate llm_env
pip install torch==2.5.1 torchvision==0.20.1 torchaudio==2.5.1 --index-url https://download.pytorch.org/whl/cu124

pip install deepspeed==0.16.9
deepspeed -h  # 验证安装

import torch, numpy as np, argparse, torchvision, deepspeed

# 解析命令行参数。`local_rank` 会由 DeepSpeed 启动器自动注入，
# 默认值通常设为 -1，表示当前不是由分布式启动器显式传入。
parser = argparse.ArgumentParser(description="FashionMNIST Training Script")
parser.add_argument("--local_rank", type=int, default=-1)
parser.add_argument("--epoch", type=int, default=1)
parser = deepspeed.add_config_arguments(parser)
cmd_args = parser.parse_args()

# 定义一个最简单的全连接分类器：
# 28*28 的灰度图拉平成 784 维向量，经过一层隐藏层后输出 10 个类别。
class FashionModel(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.seq = torch.nn.Sequential(
            torch.nn.Linear(784, 300), torch.nn.ReLU(), torch.nn.Linear(300, 10)
        )

    def forward(self, batch_x):
        return self.seq(batch_x)

# 读取 FashionMNIST，并在加载时完成：
# 1. PIL 图像 -> NumPy
# 2. 归一化到 [0, 1]
# 3. 转成 float32 Tensor
# 4. 拉平成一维向量，适配线性层输入
dataset = torchvision.datasets.FashionMNIST(root='./dataset', download=True,
    transform=lambda img: torch.tensor(np.asarray(img) / 255, dtype=torch.float32).flatten())

# 分布式训练时，必须让不同进程读取不同的数据分片，否则每张卡都会重复训练完整数据集。
# 当以 DeepSpeed 多卡启动时使用 DistributedSampler；单卡时保留随机打乱。
sampler = (
    torch.utils.data.distributed.DistributedSampler(dataset)
    if cmd_args.local_rank != -1 else None
)
dataloader = torch.utils.data.DataLoader(
    dataset,
    batch_size=32,
    num_workers=4,
    shuffle=(sampler is None),
    sampler=sampler
)

model = FashionModel()

# deepspeed.initialize 会返回 DeepSpeed Engine。
# 之后前向、反向、参数更新都通过这个 engine 完成。
model, optimizer, _, _ = deepspeed.initialize(args=cmd_args, model=model, model_parameters=model.parameters())
loss_fn = torch.nn.CrossEntropyLoss()

for epoch in range(cmd_args.epoch):
    # 多卡训练时，每个 epoch 都应重新设定 sampler 的随机种子，
    # 这样不同 epoch 的数据切分与打乱才是正确的。
    if sampler is not None:
        sampler.set_epoch(epoch)

    for x, y in dataloader:
        # 不能直接写 x.cuda()，否则多进程场景下可能都被送到默认 GPU。
        # 应显式移动到当前 DeepSpeed engine 所在设备。
        x, y = x.to(model.device), y.to(model.device)
        output = model(x)
        loss = loss_fn(output, y)
        model.backward(loss)  # DeepSpeed 负责反向传播及梯度同步
        model.step()  # DeepSpeed 负责优化器 step、梯度清零等操作

    # 日志只让主进程打印，避免多卡时重复输出。
    if model.global_rank == 0:
        print(f"epoch {epoch} done...")

    # 保存 checkpoint 时需要所有进程一起参与调用。
    model.save_checkpoint('./checkpoints')

{
    "train_batch_size": 128,
    "gradient_accumulation_steps": 1,
    "optimizer": {
        "type": "Adam",
        "params": { "lr": 0.00015 }
    },
    "zero_optimization": {
        "stage": 2
    }
}

deepspeed train.py --epoch 2 --deepspeed --deepspeed_config ds.json

cd /root/autodl-tmp
git clone --depth 1 https://github.com/Jiangnanjiezi/LLaMA-Factory.git
cd LLaMA-Factory
pip install -e ".[torch,metrics]" -i https://mirrors.aliyun.com/pypi/simple/
llamafactory-cli version  # 验证安装

[
  {
    "instruction": "请提取以下内容中的摘要信息",
    "input": "保持身体健康的五个方法：\n\n1. 每天至少饮用8杯水...\n2. 每周进行150分钟中等强度运动...",
    "output": "多喝水、规律运动、充足睡眠、均衡饮食、定期体检"
  }
]

"qwen_dataset": {
    "file_name": "qwen_dataset.json"
}

pip install modelscope
mkdir -p /root/autodl-tmp/LLaMA-Factory/models/Qwen2.5-7B
cd /root/autodl-tmp/LLaMA-Factory/models/Qwen2.5-7B
# 因为 7B 模型下载慢且微调显存大，用 1.5B 模型演示
modelscope download --model Qwen/Qwen2.5-1.5B --local_dir ./

### 模型配置
model_name_or_path: /root/autodl-tmp/LLaMA-Factory/models/Qwen2.5-7B
trust_remote_code: true
### 方法配置
stage: sft              # 监督式微调
do_train: true
finetuning_type: full   # 全参数微调
deepspeed: /root/autodl-tmp/LLaMA-Factory/examples/deepspeed/ds_z3_config.json
### 数据集配置
dataset: qwen_dataset
template: qwen
cutoff_len: 1024
overwrite_cache: true
preprocessing_num_workers: 16
### 输出配置
output_dir: saves/qwen2.5-7b/full
logging_steps: 10
save_steps: 100
plot_loss: true
overwrite_output_dir: true
### 训练参数
per_device_train_batch_size: 1
gradient_accumulation_steps: 16
learning_rate: 1.0e-5
num_train_epochs: 1.0
lr_scheduler_type: cosine
warmup_ratio: 0.1
bf16: true              # BF16 混合精度（需 Ampere 架构以上 GPU）
ddp_timeout: 180000000
### 评估配置
val_size: 0.1
per_device_eval_batch_size: 1
eval_strategy: steps
eval_steps: 500

{
  "train_batch_size": "auto",
  "train_micro_batch_size_per_gpu": "auto",
  "gradient_accumulation_steps": "auto",
  "gradient_clipping": "auto",
  "fp16": { "enabled": "auto", "loss_scale": 0, "loss_scale_window": 1000,
            "initial_scale_power": 16, "hysteresis": 2, "min_loss_scale": 1 },
  "bf16": { "enabled": "auto" },
  "zero_optimization": {
    "stage": 3,
    "offload_optimizer": { "device": "cpu", "pin_memory": true },
    "offload_param": { "device": "cpu", "pin_memory": true },
    "overlap_comm": false,
    "contiguous_gradients": true,
    "sub_group_size": 1e9,
    "reduce_bucket_size": "auto",
    "stage3_prefetch_bucket_size": "auto",
    "stage3_param_persistence_threshold": "auto",
    "stage3_max_live_parameters": 1e9,
    "stage3_max_reuse_distance": 1e9,
    "stage3_gather_16bit_weights_on_model_save": true
  }
}

FORCE_TORCHRUN=1 llamafactory-cli train qwen2.5-7b-full-sft.yaml

finetuning_type: lora   # LoRA 微调
lora_target: all        # 作用于所有线性层
lora_rank: 16
lora_alpha: 16
lora_dropout: 0.05
learning_rate: 1.0e-4   # LoRA 学习率通常较大

llamafactory-cli train qwen2.5-7b-lora-sft.yaml

finetuning_type: lora
lora_target: all
quantization_bit: 4                  # 4-bit 量化
quantization_method: bitsandbytes    # 量化方法
lora_rank: 16
lora_alpha: 16
lora_dropout: 0.05

llamafactory-cli train qwen2.5-7b-qlora-sft.yaml

### model
model_name_or_path: /root/autodl-tmp/LLaMA-Factory/models/Qwen2.5-7B
adapter_name_or_path: /root/autodl-tmp/LLaMA-Factory/saves/qwen2.5-7b/lora/sft
template: qwen
finetuning_type: lora
trust_remote_code: true
### export
export_dir: /root/autodl-tmp/LLaMA-Factory/models/qwen2.5-7b-sft-lora-merged
export_size: 2
export_device: cpu
export_legacy_format: false

llamafactory-cli export qwen2.5-7b-merge-lora.yaml

import time
from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(
    "/root/autodl-tmp/LLaMA-Factory/models/qwen2.5-7b-sft-lora-merged",
    trust_remote_code=True
)
model = AutoModelForCausalLM.from_pretrained(
    "/root/autodl-tmp/LLaMA-Factory/models/qwen2.5-7b-sft-lora-merged",
    device_map="auto", trust_remote_code=True
).eval()

prompt = "你好"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

start_time = time.time()
outputs = model.generate(
    **inputs, max_new_tokens=128, do_sample=True, temperature=0.3, top_p=0.4
)
end_time = time.time()

response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print("生成结果：", response)

num_generated_tokens = outputs.shape[1] - inputs['input_ids'].shape[1]
elapsed_time = end_time - start_time
tokens_per_second = num_generated_tokens / elapsed_time if elapsed_time > 0 else 0
print(f"生成了 {num_generated_tokens} 个 token，用时 {elapsed_time:.2f} 秒，速度约为 {tokens_per_second:.2f} token/s")

生成结果： 你好，我有一个问题想问。
您好，请问有什么问题需要帮助吗？
...
生成了 64 个 token，用时 2.17 秒，速度约为 29.46 token/s