Llama3-8B 中文微调实战指南

Llama3-8B 中文微调实战指南

1. 环境准备

1.1 硬件要求

• GPU: 至少24GB显存（如RTX 4090、A100等）
• 内存: 32GB以上
• 存储: 100GB可用空间

1.2 软件环境

# 创建虚拟环境
conda create -n llama3-chinese python=3.10
conda activate llama3-chinese

# 安装依赖
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
pip install transformers>=4.40.0
pip install datasets
pip install accelerate
pip install peft
pip install trl
pip install sentencepiece
pip install protobuf
pip install wandb  # 可选，用于实验追踪

2. 数据准备

2.1 数据格式

# 对话格式示例
{
    "conversations": [
        {"role": "user", "content": "什么是机器学习？"},
        {"role": "assistant", "content": "机器学习是人工智能的一个分支..."}
    ]
}

# 指令微调格式
{
    "instruction": "解释以下概念",
    "input": "深度学习",
    "output": "深度学习是机器学习的一个子领域..."
}

2.2 中文数据集推荐

1. Firefly数据集: 中文指令微调数据集
2. BELLE数据集: 中文对话和指令数据集
3. Alpaca-CN: 中文版Alpaca数据集
4. MOSS-SFT: 中文多轮对话数据
5. 自建数据: 领域特定的问答对

2.3 数据预处理脚本

import json
from datasets import Dataset

def prepare_dataset(data_path, output_path):
    with open(data_path, 'r', encoding='utf-8') as f:
        data = json.load(f)
    
    formatted_data = []
    for item in data:
        # 格式化为对话格式
        conversations = []
        if "instruction" in item:
            conversations.append({
                "role": "user",
                "content": f"{item['instruction']}\n{item.get('input', '')}".strip()
            })
            conversations.append({
                "role": "assistant",
                "content": item["output"]
            })
        
        formatted_data.append({
            "conversations": conversations
        })
    
    # 保存处理后的数据
    with open(output_path, 'w', encoding='utf-8') as f:
        json.dump(formatted_data, f, ensure_ascii=False, indent=2)
    
    return Dataset.from_list(formatted_data)

3. 模型下载与加载

3.1 下载Llama3-8B

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

# 从Hugging Face下载
model_name = "meta-llama/Meta-Llama-3-8B"

# 需要先申请访问权限
# 访问：https://huggingface.co/meta-llama/Meta-Llama-3-8B

# 或者使用镜像
# model_name = "modelscope/Llama-3-8B"  # 魔搭社区

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

3.2 添加中文分词器支持（可选）

# 如果需要更好的中文分词，可以扩展词汇表
from transformers import LlamaTokenizer

# 加载额外中文词汇
new_tokens = ["你好", "机器学习", "神经网络"]  # 添加自定义词汇
num_added_tokens = tokenizer.add_tokens(new_tokens)
model.resize_token_embeddings(len(tokenizer))

print(f"Added {num_added_tokens} new tokens")

4. 微调方法选择

4.1 全参数微调（Full Fine-tuning）

from transformers import TrainingArguments, Trainer

training_args = TrainingArguments(
    output_dir="./llama3-8b-zh-finetuned",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=8,
    learning_rate=2e-5,
    fp16=True,
    logging_steps=10,
    save_steps=500,
    eval_steps=500,
    save_total_limit=2,
    push_to_hub=False,
    report_to="wandb",  # 可选
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=val_dataset,
    tokenizer=tokenizer,
)

4.2 LoRA微调（推荐）

from peft import LoraConfig, get_peft_model, TaskType
from transformers import TrainingArguments

# LoRA配置
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=8,  # LoRA秩
    lora_alpha=32,
    lora_dropout=0.1,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    bias="none",
)

# 应用LoRA
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()  # 查看可训练参数数量

# 训练参数
training_args = TrainingArguments(
    output_dir="./llama3-8b-lora-zh",
    num_train_epochs=2,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=1e-4,
    fp16=True,
    logging_steps=10,
    save_strategy="steps",
    save_steps=100,
    evaluation_strategy="steps",
    eval_steps=100,
    save_total_limit=3,
    load_best_model_at_end=True,
    report_to="wandb",
)

4.3 QLoRA微调（低显存方案）

import bitsandbytes as bnb
from transformers import BitsAndBytesConfig

# 4-bit量化配置
quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True,
)

# 加载量化模型
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=quantization_config,
    device_map="auto",
    trust_remote_code=True
)

# 应用LoRA（同上）
model = get_peft_model(model, lora_config)

5. 训练脚本

5.1 完整训练示例

from transformers import DataCollatorForLanguageModeling, Trainer
import torch

def train_model():
    # 数据预处理函数
    def preprocess_function(examples):
        texts = []
        for conv in examples["conversations"]:
            # 构建对话文本
            text = ""
            for msg in conv:
                if msg["role"] == "user":
                    text += f"用户：{msg['content']}\n"
                else:
                    text += f"助手：{msg['content']}\n"
            texts.append(text.strip())
        
        # 分词
        tokenized = tokenizer(
            texts,
            truncation=True,
            padding="max_length",
            max_length=512
        )
        
        # 创建标签（预测下一个token）
        tokenized["labels"] = tokenized["input_ids"].copy()
        return tokenized
    
    # 预处理数据
    tokenized_datasets = dataset.map(
        preprocess_function,
        batched=True,
        remove_columns=dataset.column_names
    )
    
    # 数据收集器
    data_collator = DataCollatorForLanguageModeling(
        tokenizer=tokenizer,
        mlm=False
    )
    
    # 创建Trainer
    trainer = Trainer(
        model=model,
        args=training_args,
        train_dataset=tokenized_datasets["train"],
        eval_dataset=tokenized_datasets["validation"] if "validation" in tokenized_datasets else None,
        data_collator=data_collator,
        tokenizer=tokenizer,
    )
    
    # 开始训练
    trainer.train()
    
    # 保存模型
    trainer.save_model("./llama3-8b-zh-final")
    tokenizer.save_pretrained("./llama3-8b-zh-final")
    
    return trainer

# 运行训练
trainer = train_model()

6. 评估与测试

6.1 生成测试

def generate_response(prompt, model, tokenizer, max_length=512):
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_length=max_length,
            temperature=0.7,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.pad_token_id,
            eos_token_id=tokenizer.eos_token_id,
        )
    
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return response

# 测试示例
test_prompts = [
    "解释一下深度学习的基本原理",
    "用中文写一封感谢信",
    "Python中如何实现快速排序？",
]

for prompt in test_prompts:
    response = generate_response(prompt, model, tokenizer)
    print(f"输入：{prompt}")
    print(f"输出：{response}")
    print("-" * 50)

6.2 评估指标

from evaluate import load

# 加载评估指标
bleu = load("bleu")
rouge = load("rouge")

def evaluate_model(model, tokenizer, eval_dataset):
    predictions = []
    references = []
    
    for example in eval_dataset:
        # 生成预测
        prompt = example["input"]
        reference = example["output"]
        
        prediction = generate_response(prompt, model, tokenizer)
        
        predictions.append(prediction)
        references.append([reference])  # BLEU需要列表格式
    
    # 计算指标
    bleu_score = bleu.compute(predictions=predictions, references=references)
    rouge_score = rouge.compute(predictions=predictions, references=references)
    
    return {
        "bleu": bleu_score,
        "rouge": rouge_score
    }

7. 部署与推理

7.1 模型合并（LoRA）

from peft import PeftModel

# 加载基础模型
base_model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Meta-Llama-3-8B",
    torch_dtype=torch.float16,
    device_map="auto",
)

# 加载LoRA权重
model = PeftModel.from_pretrained(base_model, "./llama3-8b-lora-zh")

# 合并权重
merged_model = model.merge_and_unload()

# 保存完整模型
merged_model.save_pretrained("./llama3-8b-zh-merged")
tokenizer.save_pretrained("./llama3-8b-zh-merged")

7.2 使用Transformers Pipeline

from transformers import pipeline

# 创建文本生成pipeline
generator = pipeline(
    "text-generation",
    model="./llama3-8b-zh-merged",
    tokenizer=tokenizer,
    device=0 if torch.cuda.is_available() else -1,
)

# 使用pipeline生成
results = generator(
    "请写一首关于春天的诗",
    max_length=200,
    temperature=0.8,
    top_p=0.95,
    do_sample=True,
)
print(results[0]["generated_text"])

7.3 Gradio Web界面

import gradio as gr

def chat_interface(message, history):
    # 构建对话历史
    prompt = ""
    for human, assistant in history:
        prompt += f"用户：{human}\n助手：{assistant}\n"
    prompt += f"用户：{message}\n助手："
    
    # 生成回复
    response = generate_response(prompt, model, tokenizer, max_length=1024)
    
    # 提取助手的回复
    assistant_response = response.split("助手：")[-1].strip()
    return assistant_response

# 创建Gradio界面
gr.ChatInterface(
    fn=chat_interface,
    title="Llama3-8B中文助手",
    description="基于Llama3-8B微调的中文对话模型"
).launch()

8. 优化建议

8.1 训练技巧

1. 学习率调度: 使用warmup和余弦衰减
2. 梯度裁剪: 防止梯度爆炸
3. 混合精度训练: 使用fp16或bf16节省显存
4. 梯度累积: 模拟更大batch size
5. 数据增强: 对训练数据进行回译、同义词替换等

8.2 显存优化

# 梯度检查点
model.gradient_checkpointing_enable()

# 更高效的数据加载
training_args = TrainingArguments(
    dataloader_pin_memory=False,
    dataloader_num_workers=4,
)

8.3 中文优化策略

1. 扩充词表: 添加常见中文词汇
2. 数据平衡: 确保中英文数据比例合适
3. 指令格式: 使用中文指令模板
4. 评估指标: 使用中文友好的评估方法

9. 常见问题解决

9.1 显存不足

• 使用QLoRA（4-bit量化+LoRA）
• 减小batch size
• 使用梯度累积
• 启用梯度检查点

9.2 中文生成质量差

• 增加中文数据比例
• 调整温度参数
• 添加重复惩罚
• 使用更好的提示模板

9.3 训练不稳定

• 降低学习率
• 增加warmup步骤
• 使用梯度裁剪
• 检查数据质量

10. 资源推荐

10.1 中文数据集

• Firefly
• BELLE
• Chinese-LLaMA-Alpaca

10.2 预训练模型

• Llama3-8B
• Chinese-Llama-3（社区中文版本）

10.3 工具库

• Transformers: Hugging Face模型库
• PEFT: 参数高效微调
• TRL: Transformer强化学习
• vLLM: 高性能推理

这个实战指南提供了完整的Llama3-8B中文微调流程，可以根据具体需求调整参数和数据。记得在实际操作前确保有足够的硬件资源，并根据任务特点选择合适的微调策略。