Pytorch深度学习框架60天进阶学习计划 - 第56天：大模型微调实践（一）

Pytorch深度学习框架60天进阶学习计划 - 第56天大模型微调实践（一）

欢迎来到我们的PyTorch进阶学习计划第56天！今天，我们将深入研究大型语言模型(LLM)的微调技术，特别是使用LoRA（低秩适配器）来高效微调LLaMA-2模型。
这是一项强大的技术，可以让我们用有限的计算资源定制大型模型，使其能够适应特定任务和领域。让我们开始这个激动人心的旅程吧！

第一部分：LoRA微调原理与环境搭建

1. 大型语言模型微调的挑战与解决方案

随着大型语言模型(如LLaMA-2、GPT系列、PaLM等)的发展，它们的参数规模已经达到了数十亿甚至数千亿级别。这些模型展现了惊人的能力，但也带来了几个关键挑战：

1. 计算资源需求高：完整微调需要大量GPU内存和计算能力
2. 过拟合风险：微调所有参数容易导致过拟合，特别是在小数据集上
3. 灾难性遗忘：微调可能导致模型丢失预训练中获得的通用知识

为了解决这些问题，参数高效微调技术(Parameter-Efficient Fine-Tuning, PEFT)应运而生。PEFT方法的核心思想是：只更新模型的一小部分参数，或添加少量可训练参数，同时保持大部分原始预训练权重不变。

常见的PEFT方法比较

在这些方法中，LoRA (Low-Rank Adaptation) 因其实现简单、内存效率高和出色的性能表现而备受欢迎，特别是在大型语言模型的微调中。

2. LoRA原理详解

LoRA是由微软研究院在2021年提出的一种参数高效微调技术。它的核心思想是：大型模型的权重更新可以通过低秩分解来近似。

2.1 数学原理

假设原始预训练模型中有一个权重矩阵 $W\in {\mathbb{R}}^{d\times k}$，传统微调会直接更新整个矩阵。而在LoRA中，我们：

1. 保持原始权重矩阵 $W$ 冻结（不更新）
2. 引入两个低秩矩阵 $A\in {\mathbb{R}}^{d\times r}$ 和 $B\in {\mathbb{R}}^{r\times k}$，其中 $r\ll \min (d,k)$
3. 在前向传播时使用 $W+\Delta W=W+AB$ 作为新的权重

对于输入 $x$，输出变为：
$$h=xW+x\Delta W=xW+xAB$$

关键点：

• 通常只有 $r=4,8,16$ 或 $32$，远小于 $d$ 和 $k$
• 仅更新 $A$ 和 $B$ 矩阵，大幅减少可训练参数
• 可以选择性地应用于模型中的不同模块（如注意力权重、前馈层等）

2.2 LoRA的优势

1. 内存效率高：无需存储完整模型的优化器状态
2. 训练速度快：更新参数少，反向传播更高效
3. 模块化设计：不同任务可使用不同LoRA适配器
4. 易于部署：可以合并权重或动态切换适配器
5. 可扩展性：适用于各种模型架构

2.3 LoRA与其他PEFT方法的对比

其中：

• $d$: 隐藏维度大小
• $r$: LoRA秩
• $b$: 适配器瓶颈维度
• $l$: 层数
• $p$: 前缀长度

3. 环境准备与依赖安装

为了进行LLaMA-2的LoRA微调，我们需要搭建适当的环境。以下是完整的设置步骤：

3.1 硬件要求

虽然LoRA大大减少了内存需求，但微调LLaMA-2仍需要一定的硬件资源：

3.2 创建虚拟环境并安装依赖

# 创建新的conda环境
conda create -n llama_lora python=3.10
conda activate llama_lora

# 安装PyTorch (根据你的CUDA版本选择)
pip install torch==2.0.1 torchvision==0.15.2 torchaudio==2.0.2 --index-url https://download.pytorch.org/whl/cu118

# 安装Hugging Face库
pip install transformers==4.31.0
pip install datasets==2.14.0
pip install accelerate==0.21.0
pip install bitsandbytes==0.40.2
pip install scipy==1.11.2
pip install sentencepiece==0.1.99
pip install wandb==0.15.8  # 用于实验跟踪（可选）

# 安装PEFT库用于LoRA微调
pip install peft==0.4.0

# 安装评估和可视化工具
pip install evaluate==0.4.0
pip install matplotlib==3.7.2
pip install seaborn==0.12.2

3.3 验证安装并检查GPU可用性

创建一个简单的Python脚本来验证环境设置：

# check_environment.py
import torch
import transformers
import peft
import bitsandbytes as bnb
import datasets

# 检查GPU可用性
print(f"CUDA可用: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"GPU数量: {torch.cuda.device_count()}")
    print(f"GPU型号: {torch.cuda.get_device_name(0)}")
    print(f"当前GPU内存使用情况: {torch.cuda.memory_allocated(0)/1024**3:.2f} GB")
    print(f"GPU总内存: {torch.cuda.get_device_properties(0).total_memory/1024**3:.2f} GB")

# 检查库版本
print(f"PyTorch版本: {torch.__version__}")
print(f"Transformers版本: {transformers.__version__}")
print(f"PEFT版本: {peft.__version__}")
print(f"BitsAndBytes版本: {bnb.__version__}")
print(f"Datasets版本: {datasets.__version__}")

# 简单测试PEFT功能
try:
    from peft import LoraConfig, get_peft_model
    print("PEFT库中的LoRA功能正常导入")
except ImportError:
    print("PEFT库导入失败，请检查安装")

运行验证脚本：

python check_environment.py

4. 获取LLaMA-2模型和访问权限

LLaMA-2是Meta发布的强大开源语言模型，但需要申请访问权限。以下是获取模型的步骤：

4.1 申请访问权限

1. 访问Meta AI的LLaMA页面: https://ai.meta.com/llama/
2. 填写访问申请表格（需要提供个人或组织信息和使用目的）
3. 等待审批邮件（通常需要1-3天）
4. 收到批准后，您将获得访问模型的链接

4.2 通过Hugging Face获取模型

LLaMA-2模型已在Hugging Face平台上提供，但同样需要申请访问：

1. 访问Hugging Face上的Meta-LLaMA模型页面: https://huggingface.co/meta-llama
2. 提交访问请求
3. 使用您的Hugging Face账户登录并接受使用条款
4. 设置Hugging Face CLI令牌（用于程序中访问模型）

# 安装Hugging Face CLI工具
pip install -U huggingface_hub

# 登录（将在浏览器中打开认证页面）
huggingface-cli login

5. 数据集准备与指令模板设计

为了进行有效的指令微调，我们需要准备适当的数据集并设计指令模板。

5.1 常用指令微调数据集

为了本教程，我们将使用Alpaca数据集的一个子集，这是一个流行的指令微调数据集。

5.2 指令模板设计

指令模板定义了如何格式化输入提示和输出响应。不同的模型可能需要不同的模板格式。对于LLaMA-2，我们采用以下模板：

<s>[INST] <<SYS>>
{system_prompt}
<</SYS>>

{instruction} [/INST] {response} </s>

其中：

• [INST]和[/INST]：标记指令的开始和结束
• <<SYS>>和<</SYS>>：包含系统提示的部分
• {system_prompt}：对AI助手行为的整体指导
• {instruction}：用户输入的具体指令
• {response}：模型应生成的答复

5.3 数据集处理代码

让我们编写代码来下载和处理Alpaca数据集：

# prepare_dataset.py
import json
import random
import torch
from datasets import load_dataset, Dataset

def prepare_alpaca_dataset(subset_size=1000, test_size=100, seed=42):
    """
    准备Alpaca数据集的子集用于指令微调
    
    参数:
        subset_size: 要使用的样本数量
        test_size: 测试集大小
        seed: 随机种子
    
    返回:
        train_dataset, test_dataset: 训练集和测试集
    """
    # 设置随机种子
    random.seed(seed)
    torch.manual_seed(seed)
    
    # 从Hugging Face加载Alpaca数据集
    try:
        dataset = load_dataset("yahma/alpaca-cleaned")
        print("成功从Hugging Face加载Alpaca数据集")
    except Exception as e:
        print(f"无法从Hugging Face加载数据集: {e}")
        # 尝试从GitHub加载
        try:
            alpaca_url = "https://raw.githubusercontent.com/tatsu-lab/stanford_alpaca/main/alpaca_data.json"
            dataset = load_dataset("json", data_files={"train": alpaca_url})
            print("成功从GitHub加载Alpaca数据集")
        except Exception as e2:
            print(f"无法加载数据集: {e2}")
            return None, None
    
    # 获取数据集的子集
    full_dataset = dataset["train"]
    
    # 随机选择子集
    selected_indices = random.sample(range(len(full_dataset)), min(subset_size + test_size, len(full_dataset)))
    selected_data = [full_dataset[i] for i in selected_indices]
    
    # 分割训练集和测试集
    train_data = selected_data[:-test_size] if test_size > 0 else selected_data
    test_data = selected_data[-test_size:] if test_size > 0 else []
    
    # 创建指令模板格式化函数
    def format_instruction(example):
        # 默认系统提示
        system_prompt = "You are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe. Your answers should be detailed, accurate and provide enough reasoning. Be concise, but not at the expense of clarity."
        
        # 格式化为LLaMA-2聊天模板
        formatted_prompt = f"<s>[INST] <<SYS>>\n{system_prompt}\n<</SYS>>\n\n{example['instruction']}"
        
        # 添加输入（如果有）
        if example.get('input') and example['input'].strip():
            formatted_prompt += f"\n\n{example['input']}"
            
        formatted_prompt += f" [/INST] {example['output']} </s>"
        
        return {
            "formatted_prompt": formatted_prompt,
            "instruction": example['instruction'],
            "input": example.get('input', ''),
            "output": example['output']
        }
    
    # 应用格式化
    train_formatted = [format_instruction(example) for example in train_data]
    test_formatted = [format_instruction(example) for example in test_data]
    
    # 创建Hugging Face数据集
    train_dataset = Dataset.from_dict({
        "formatted_prompt": [item["formatted_prompt"] for item in train_formatted],
        "instruction": [item["instruction"] for item in train_formatted],
        "input": [item["input"] for item in train_formatted],
        "output": [item["output"] for item in train_formatted]
    })
    
    test_dataset = Dataset.from_dict({
        "formatted_prompt": [item["formatted_prompt"] for item in test_formatted],
        "instruction": [item["instruction"] for item in test_formatted],
        "input": [item["input"] for item in test_formatted],
        "output": [item["output"] for item in test_formatted]
    })
    
    print(f"准备好训练集: {len(train_dataset)}个样本")
    print(f"准备好测试集: {len(test_dataset)}个样本")
    
    # 查看示例
    print("\n示例格式化提示:")
    print(train_dataset[0]['formatted_prompt'][:500] + "...")
    
    return train_dataset, test_dataset

if __name__ == "__main__":
    train_dataset, test_dataset = prepare_alpaca_dataset(subset_size=1000, test_size=100)
    
    # 保存数据集（可选）
    if train_dataset is not None and test_dataset is not None:
        train_dataset.save_to_disk("alpaca_train_subset")
        test_dataset.save_to_disk("alpaca_test_subset")
        print("数据集已保存到本地")

运行此脚本以准备数据集：

python prepare_dataset.py

6. 创建LoRA微调配置

现在我们将创建LoRA微调所需的配置。我们使用PEFT库进行LoRA配置。

6.1 LoRA配置参数详解

LoRA微调需要几个关键参数：

6.2 LoRA配置脚本

让我们创建一个配置脚本，用于设置微调参数：

# lora_config.py
from dataclasses import dataclass, field
from typing import List, Optional

@dataclass
class ModelArguments:
    """
    与加载模型权重相关的参数
    """
    model_name_or_path: str = field(
        default="meta-llama/Llama-2-7b-hf",
        metadata={"help": "从Hugging Face Hub加载的预训练模型路径或名称"}
    )
    use_auth_token: bool = field(
        default=True,
        metadata={"help": "是否使用Hugging Face授权令牌"}
    )

@dataclass
class LoRAArguments:
    """
    LoRA特定参数
    """
    lora_r: int = field(
        default=16,
        metadata={"help": "LoRA适配器的秩"}
    )
    lora_alpha: int = field(
        default=32,
        metadata={"help": "LoRA alpha参数"}
    )
    lora_dropout: float = field(
        default=0.05,
        metadata={"help": "LoRA dropout概率"}
    )
    target_modules: List[str] = field(
        default_factory=lambda: ["q_proj", "v_proj", "k_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
        metadata={"help": "要应用LoRA的模块名称列表"}
    )
    bias: str = field(
        default="none",
        metadata={"help": "LoRA偏置参数，可选值：'none', 'all', 'lora_only'"}
    )
    modules_to_save: Optional[List[str]] = field(
        default=None,
        metadata={"help": "除了LoRA参数外要保存的模块，常用于词汇表扩展"}
    )

@dataclass
class TrainingArguments:
    """
    训练相关参数
    """
    output_dir: str = field(
        default="./llama2-lora-output",
        metadata={"help": "训练输出保存路径"}
    )
    num_train_epochs: int = field(
        default=3,
        metadata={"help": "训练的总轮数"}
    )
    per_device_train_batch_size: int = field(
        default=4,
        metadata={"help": "每个设备的训练批次大小"}
    )
    per_device_eval_batch_size: int = field(
        default=4,
        metadata={"help": "每个设备的评估批次大小"}
    )
    gradient_accumulation_steps: int = field(
        default=8,
        metadata={"help": "梯度累积步数"}
    )
    learning_rate: float = field(
        default=2e-4,
        metadata={"help": "初始学习率"}
    )
    weight_decay: float = field(
        default=0.01,
        metadata={"help": "权重衰减系数"}
    )
    warmup_ratio: float = field(
        default=0.03,
        metadata={"help": "学习率预热的比例"}
    )
    logging_steps: int = field(
        default=10,
        metadata={"help": "记录日志的步数间隔"}
    )
    evaluation_strategy: str = field(
        default="steps",
        metadata={"help": "评估策略: 'no', 'steps', 'epoch'"}
    )
    eval_steps: int = field(
        default=100,
        metadata={"help": "评估间隔步数"}
    )
    save_strategy: str = field(
        default="steps",
        metadata={"help": "保存策略: 'no', 'steps', 'epoch'"}
    )
    save_steps: int = field(
        default=100,
        metadata={"help": "保存检查点的间隔步数"}
    )
    save_total_limit: int = field(
        default=3,
        metadata={"help": "保存的检查点总数限制"}
    )
    load_best_model_at_end: bool = field(
        default=True,
        metadata={"help": "训练结束时是否加载最佳模型"}
    )
    metric_for_best_model: str = field(
        default="eval_loss",
        metadata={"help": "用于确定最佳模型的指标"}
    )
    greater_is_better: bool = field(
        default=False,
        metadata={"help": "指标是否越大越好"}
    )
    fp16: bool = field(
        default=True,
        metadata={"help": "是否使用混合精度训练"}
    )
    bf16: bool = field(
        default=False,
        metadata={"help": "是否使用bfloat16混合精度"}
    )
    torch_compile: bool = field(
        default=False,
        metadata={"help": "是否使用PyTorch 2.0编译模型"}
    )
    optim: str = field(
        default="adamw_torch",
        metadata={"help": "优化器类型"}
    )
    report_to: str = field(
        default="none",
        metadata={"help": "报告运行指标的平台(wandb, tensorboard等)"}
    )

def get_default_lora_config():
    """
    返回默认的LoRA和训练配置
    """
    model_args = ModelArguments()
    lora_args = LoRAArguments()
    training_args = TrainingArguments()
    
    return model_args, lora_args, training_args

if __name__ == "__main__":
    # 打印默认配置
    model_args, lora_args, training_args = get_default_lora_config()
    
    print("=== 模型配置 ===")
    print(f"模型路径: {model_args.model_name_or_path}")
    
    print("\n=== LoRA配置 ===")
    print(f"LoRA秩(r): {lora_args.lora_r}")
    print(f"LoRA alpha: {lora_args.lora_alpha}")
    print(f"LoRA dropout: {lora_args.lora_dropout}")
    print(f"目标模块: {', '.join(lora_args.target_modules)}")
    
    print("\n=== 训练配置 ===")
    print(f"输出目录: {training_args.output_dir}")
    print(f"训练轮数: {training_args.num_train_epochs}")
    print(f"每设备批次大小: {training_args.per_device_train_batch_size}")
    print(f"梯度累积步数: {training_args.gradient_accumulation_steps}")
    print(f"有效批次大小: {training_args.per_device_train_batch_size * training_args.gradient_accumulation_steps}")
    print(f"学习率: {training_args.learning_rate}")
    print(f"FP16训练: {'启用' if training_args.fp16 else '禁用'}")

运行此脚本以查看默认配置：

python lora_config.py

7. 实现LoRA微调脚本

最后，我们将实现完整的LLaMA-2 LoRA微调脚本：

# train_llama_lora.py
import os
import torch
import logging
from datasets import load_from_disk
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    HfArgumentParser,
    TrainingArguments,
    DataCollatorForSeq2Seq,
    Trainer,
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from lora_config import ModelArguments, LoRAArguments, TrainingArguments as CustomTrainingArguments

# 设置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def train():
    # 解析参数
    parser = HfArgumentParser((ModelArguments, LoRAArguments, CustomTrainingArguments))
    model_args, lora_args, training_args = parser.parse_args_into_dataclasses()
    
    # 将自定义参数转换为Transformers训练参数
    training_args_dict = vars(training_args)
    # 移除不在TrainingArguments中的参数
    for arg in list(training_args_dict.keys()):
        if arg not in TrainingArguments.__dataclass_fields__:
            training_args_dict.pop(arg)
    
    transformers_training_args = TrainingArguments(**training_args_dict)
    
    # 加载分词器
    tokenizer = AutoTokenizer.from_pretrained(
        model_args.model_name_or_path,
        use_auth_token=model_args.use_auth_token,
        trust_remote_code=True
    )
    # 确保tokenizer有pad_token
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token
    
    # 加载和准备数据集
    try:
        train_dataset = load_from_disk("alpaca_train_subset")
        eval_dataset = load_from_disk("alpaca_test_subset")
        logger.info(f"加载了{len(train_dataset)}个训练样本和{len(eval_dataset)}个评估样本")
    except Exception as e:
        logger.error(f"加载数据集失败: {e}")
        logger.info("请首先运行prepare_dataset.py准备数据集")
        return
    
    # 定义分词函数
    def tokenize_function(examples):
        return tokenizer(
            examples["formatted_prompt"],
            padding="max_length",
            truncation=True,
            max_length=512,
            return_tensors="pt"
        )
    
    # 分词数据集
    tokenized_train = train_dataset.map(tokenize_function, batched=True)
    tokenized_eval = eval_dataset.map(tokenize_function, batched=True)
    
    # 数据整理器
    data_collator = DataCollatorForSeq2Seq(
        tokenizer=tokenizer,
        padding=True,
        return_tensors="pt"
    )
    
    # 加载模型
    logger.info(f"加载基础模型: {model_args.model_name_or_path}")
    # 使用BitsAndBytes进行量化
    quantization_config = None
    model_kwargs = {}
    
    # 尝试使用4位量化加载，如果支持的话
    try:
        import bitsandbytes as bnb
        from transformers import BitsAndBytesConfig
        
        quantization_config = BitsAndBytesConfig(
            load_in_4bit=True,
            bnb_4bit_quant_type="nf4",
            bnb_4bit_compute_dtype=torch.float16,
            bnb_4bit_use_double_quant=True,
        )
        logger.info("将使用4位量化加载模型")
        model_kwargs["quantization_config"] = quantization_config
    except ImportError:
        logger.warning("BitsAndBytes库不可用，将使用fp16加载模型")
        logger.warning("要使用量化功能，请安装最新版本的bitsandbytes")
        model_kwargs["torch_dtype"] = torch.float16
    
    model = AutoModelForCausalLM.from_pretrained(
        model_args.model_name_or_path,
        use_auth_token=model_args.use_auth_token,
        trust_remote_code=True,
        **model_kwargs
    )
    
    # 准备模型进行量化训练（如果使用量化）
    if quantization_config is not None:
        model = prepare_model_for_kbit_training(model)
    
    # 创建LoRA配置
    logger.info(f"创建LoRA配置: r={lora_args.lora_r}, alpha={lora_args.lora_alpha}")
    lora_config = LoraConfig(
        r=lora_args.lora_r,
        lora_alpha=lora_args.lora_alpha,
        lora_dropout=lora_args.lora_dropout,
        target_modules=lora_args.target_modules,
        bias=lora_args.bias,
        task_type="CAUSAL_LM",
        modules_to_save=lora_args.modules_to_save
    )
    
    # 应用LoRA适配器
    model = get_peft_model(model, lora_config)
    model.print_trainable_parameters()
    
    # 创建Trainer
    trainer = Trainer(
        model=model,
        args=transformers_training_args,
        train_dataset=tokenized_train,
        eval_dataset=tokenized_eval,
        tokenizer=tokenizer,
        data_collator=data_collator
    )
    
    # 训练模型
    logger.info("开始训练...")
    trainer.train()
    
    # 保存模型
    logger.info(f"保存模型到 {training_args.output_dir}")
    trainer.save_model()
    
    # 保存分词器
    tokenizer.save_pretrained(training_args.output_dir)
    
    logger.info("训练完成!")

if __name__ == "__main__":
    train()

8. 运行微调

现在我们可以运行微调脚本：

python train_llama_lora.py \
  --model_name_or_path meta-llama/Llama-2-7b-hf \
  --output_dir ./llama2-lora-alpaca \
  --num_train_epochs 3 \
  --per_device_train_batch_size 4 \
  --per_device_eval_batch_size 4 \
  --gradient_accumulation_steps 8 \
  --learning_rate 2e-4 \
  --warmup_ratio 0.03 \
  --evaluation_strategy steps \
  --eval_steps 100 \
  --save_strategy steps \
  --save_steps 100 \
  --logging_steps 10 \
  --fp16 \
  --report_to wandb

如果您使用的是下面的GPU，请相应地调整批次大小和梯度累积步数：

9. LoRA微调性能分析

LoRA方法极大地提高了微调LLaMA-2的参数效率。以下是一些关键指标的分析：

9.1 参数效率分析

9.2 不同LoRA秩的效果对比

注：性能比例是相对于完整微调的性能估计值。

10. 总结与问题排查

在本部分中，我们学习了：

1. 大型语言模型微调的挑战与解决方案
2. LoRA (低秩适配器) 的原理与数学基础
3. 环境搭建与依赖安装
4. 获取LLaMA-2模型的方法
5. 数据集准备与指令模板设计
6. LoRA配置参数详解
7. 实现完整的微调脚本
8. LoRA微调的参数效率分析

常见问题排查

1. CUDA内存不足

   • 减小批次大小
   • 增加梯度累积步数
   • 使用4位量化加载模型

2. 模型加载失败

   • 检查Hugging Face授权令牌
   • 确认已获得LLaMA-2访问权限

3. 训练进度缓慢

   • 使用混合精度训练(fp16)
   • 尝试更强大的GPU
   • 减小LoRA秩®值

4. 性能不佳

   • 增加训练轮数
   • 增加LoRA秩®值
   • 调整学习率
   • 更改目标模块列表

在下一部分中，我们将探讨如何评估微调后的模型，进行推理，并实现合并权重和模型导出。

清华大学全五版的《DeepSeek教程》完整的文档需要的朋友，关注我私信：deepseek 即可获得。

怎么样今天的内容还满意吗？再次感谢朋友们的观看，关注GZH：凡人的AI工具箱，回复666，送您价值199的AI大礼包。最后，祝您早日实现财务自由，还请给个赞，谢谢！