99_监督微调：Alpaca数据集格式与实现

监督微调的工作流程
预训练模型 → 高质量标注数据 → 参数调整 → 特定任务适配 → 评估与优化

{
  "instruction": "解释什么是机器学习",
  "input": "",
  "output": "机器学习是人工智能的一个分支，它允许计算机系统通过数据学习并改进性能，而无需被明确编程。在机器学习中，算法被设计用来识别数据中的模式，基于这些模式做出决策或预测。机器学习的主要类型包括监督学习、无监督学习和强化学习。它已被广泛应用于图像识别、自然语言处理、推荐系统等领域。"
}

{
  "instruction": "将以下英文文本翻译成中文",
  "input": "Machine learning is a method of data analysis that automates analytical model building.",
  "output": "机器学习是一种数据分析方法，它可以自动构建分析模型。"
}

{
  "instruction": "为一家咖啡店创建一个吸引人的标语",
  "input": "",
  "output": ""每一杯都是匠心之作，每一刻都是味蕾之旅。" 欢迎来到我们的咖啡世界，这里有香浓的咖啡，有舒适的环境，还有温暖的服务，让您的每一次到访都成为一次愉悦的体验。"
}

数据集构建流程
数据收集 → 数据清洗 → 格式转换 → 质量评估 → 数据集分割 → 数据增强 → 最终数据集

# 安装PyTorch和CUDA支持
!pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

# 安装Transformers库
!pip install transformers==4.36.2

# 安装数据集处理库
!pip install datasets==2.10.1

# 安装PEFT库（用于参数高效微调）
!pip install peft==0.7.0

# 安装加速库
!pip install accelerate==0.25.0

# 安装bitsandbytes（用于量化）
!pip install bitsandbytes==0.41.3

# 安装其他工具库
!pip install sentencepiece==0.1.99
!pip install tensorboardX==2.6

from datasets import load_dataset
import json

def load_alpaca_dataset(data_path, split_ratio=0.9):
    """
    加载和处理Alpaca格式数据集
    
    Args:
        data_path: Alpaca格式JSON文件路径
        split_ratio: 训练集与验证集的分割比例
        
    Returns:
        训练集和验证集
    """
    # 加载JSON格式数据
    dataset = load_dataset("json", data_files=data_path)
    
    # 分割训练集和验证集
    train_val = dataset["train"].train_test_split(test_size=1-split_ratio)
    train_dataset = train_val["train"]
    val_dataset = train_val["test"]
    
    return train_dataset, val_dataset

# 使用示例
train_dataset, val_dataset = load_alpaca_dataset("data/alpaca_data.json")
print(f"训练集大小: {len(train_dataset)}")
print(f"验证集大小: {len(val_dataset)}")
print("数据样例:")
print(train_dataset[0])

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

def load_model_and_tokenizer(model_name_or_path, use_4bit=False):
    """
    加载预训练模型和分词器
    
    Args:
        model_name_or_path: 模型名称或本地路径
        use_4bit: 是否使用4位量化
        
    Returns:
        模型和分词器
    """
    # 加载分词器
    tokenizer = AutoTokenizer.from_pretrained(
        model_name_or_path,
        use_fast=False,
        trust_remote_code=True
    )
    
    # 设置padding token（如果不存在）
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token
    
    # 加载模型
    model_kwargs = {
        "torch_dtype": torch.float16,
        "device_map": "auto",
        "trust_remote_code": True
    }
    
    # 如果使用4位量化
    if use_4bit:
        model_kwargs["load_in_4bit"] = True
        model_kwargs["quantization_config"] = {
            "load_in_4bit": True,
            "bnb_4bit_compute_dtype": torch.float16,
            "bnb_4bit_use_double_quant": True,
            "bnb_4bit_quant_type": "nf4"
        }
    
    model = AutoModelForCausalLM.from_pretrained(
        model_name_or_path,
        **model_kwargs
    )
    
    return model, tokenizer

# 使用示例
model, tokenizer = load_model_and_tokenizer("facebook/opt-1.3b")

def preprocess_function(examples, tokenizer, max_length=1024):
    """
    预处理Alpaca格式数据
    
    Args:
        examples: 数据样本
        tokenizer: 分词器
        max_length: 最大序列长度
        
    Returns:
        处理后的输入数据
    """
    # 构建输入文本
    inputs = []
    outputs = []
    
    for instruction, input_text, output_text in zip(
        examples["instruction"], examples["input"], examples["output"]
    ):
        # 构建提示
        prompt = f"### 指令:\n{instruction}\n"
        
        # 如果有输入，添加输入部分
        if input_text.strip():
            prompt += f"### 输入:\n{input_text}\n"
        
        prompt += "### 回答:\n"
        
        inputs.append(prompt)
        outputs.append(output_text)
    
    # 分词
    model_inputs = tokenizer(
        inputs,
        max_length=max_length,
        padding="max_length",
        truncation=True,
        return_tensors="pt"
    )
    
    # 处理标签
    with tokenizer.as_target_tokenizer():
        labels = tokenizer(
            outputs,
            max_length=max_length,
            padding="max_length",
            truncation=True,
            return_tensors="pt"
        )["input_ids"]
    
    # 设置padding部分的标签为-100，这样在计算损失时会被忽略
    labels[labels == tokenizer.pad_token_id] = -100
    
    model_inputs["labels"] = labels
    
    return model_inputs

# 使用示例
train_dataset = train_dataset.map(
    lambda examples: preprocess_function(examples, tokenizer),
    batched=True,
    remove_columns=train_dataset.column_names
)

val_dataset = val_dataset.map(
    lambda examples: preprocess_function(examples, tokenizer),
    batched=True,
    remove_columns=val_dataset.column_names
)

from transformers import TrainingArguments, Trainer, DataCollatorForSeq2Seq

def setup_training_args(output_dir, batch_size=4, learning_rate=2e-5, epochs=3):
    """
    设置训练参数
    
    Args:
        output_dir: 模型保存目录
        batch_size: 批量大小
        learning_rate: 学习率
        epochs: 训练轮次
        
    Returns:
        训练参数
    """
    training_args = TrainingArguments(
        output_dir=output_dir,
        overwrite_output_dir=True,
        num_train_epochs=epochs,
        per_device_train_batch_size=batch_size,
        per_device_eval_batch_size=batch_size,
        gradient_accumulation_steps=4,
        evaluation_strategy="steps",
        eval_steps=500,
        save_steps=1000,
        save_total_limit=3,
        learning_rate=learning_rate,
        weight_decay=0.01,
        warmup_steps=500,
        logging_dir=f"{output_dir}/logs",
        logging_steps=100,
        fp16=True,
        push_to_hub=False,
        report_to="tensorboard"
    )
    
    return training_args

# 创建数据收集器
data_collator = DataCollatorForSeq2Seq(
    tokenizer=tokenizer,
    model=model,
    padding="max_length",
    max_length=1024
)

# 设置训练参数
training_args = setup_training_args(
    output_dir="./fine-tuned-model",
    batch_size=4,
    learning_rate=2e-5,
    epochs=3
)

def create_and_train_model(model, tokenizer, train_dataset, val_dataset, training_args, data_collator):
    """
    创建训练器并训练模型
    
    Args:
        model: 模型
        tokenizer: 分词器
        train_dataset: 训练数据集
        val_dataset: 验证数据集
        training_args: 训练参数
        data_collator: 数据收集器
        
    Returns:
        训练后的模型
    """
    # 创建训练器
    trainer = Trainer(
        model=model,
        args=training_args,
        train_dataset=train_dataset,
        eval_dataset=val_dataset,
        tokenizer=tokenizer,
        data_collator=data_collator
    )
    
    # 开始训练
    trainer.train()
    
    # 保存模型
    trainer.save_model(training_args.output_dir)
    
    return model

# 训练模型
model = create_and_train_model(
    model, tokenizer, train_dataset, val_dataset, training_args, data_collator
)

from peft import LoraConfig, get_peft_model, TaskType

def setup_lora(model, r=8, lora_alpha=16, lora_dropout=0.05):
    """
    设置LoRA配置
    
    Args:
        model: 原始模型
        r: LoRA的秩
        lora_alpha: LoRA的缩放因子
        lora_dropout: LoRA的dropout概率
        
    Returns:
        配置LoRA后的模型
    """
    # LoRA配置
    peft_config = LoraConfig(
        task_type=TaskType.CAUSAL_LM,
        inference_mode=False,
        r=r,
        lora_alpha=lora_alpha,
        lora_dropout=lora_dropout,
        target_modules=["q_proj", "v_proj"]  # 针对Transformer模型的查询和值投影层
    )
    
    # 创建LoRA模型
    peft_model = get_peft_model(model, peft_config)
    peft_model.print_trainable_parameters()  # 打印可训练参数数量
    
    return peft_model

# 使用LoRA
peft_model = setup_lora(model)

# 使用LoRA模型进行训练
trainer = Trainer(
    model=peft_model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=val_dataset,
    tokenizer=tokenizer,
    data_collator=data_collator
)

trainer.train()

# 保存LoRA权重
peft_model.save_pretrained(training_args.output_dir)

def evaluate_model(model, tokenizer, val_dataset, max_new_tokens=128):
    """
    评估模型性能
    
    Args:
        model: 训练后的模型
        tokenizer: 分词器
        val_dataset: 验证数据集
        max_new_tokens: 生成的最大token数
        
    Returns:
        生成的预测结果
    """
    model.eval()
    predictions = []
    
    # 随机选择一些样本进行测试
    test_samples = val_dataset.shuffle(seed=42).select(range(10))
    
    for i, sample in enumerate(test_samples):
        # 构建输入
        instruction = sample["instruction"]
        input_text = sample["input"]
        
        prompt = f"### 指令:\n{instruction}\n"
        if input_text.strip():
            prompt += f"### 输入:\n{input_text}\n"
        prompt += "### 回答:\n"
        
        # 分词
        inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
        
        # 生成回答
        with torch.no_grad():
            outputs = model.generate(
                **inputs,
                max_new_tokens=max_new_tokens,
                temperature=0.7,
                top_p=0.95,
                do_sample=True
            )
        
        # 解码输出
        prediction = tokenizer.decode(outputs[0], skip_special_tokens=True)
        
        # 提取生成的回答部分
        answer_start = prediction.find("### 回答:")
        if answer_start != -1:
            answer_start += len("### 回答:")
            prediction = prediction[answer_start:].strip()
        
        predictions.append({
            "instruction": instruction,
            "input": input_text,
            "ground_truth": sample["output"],
            "prediction": prediction
        })
    
    return predictions

# 评估模型
predictions = evaluate_model(model, tokenizer, val_dataset)

# 打印评估结果
for i, pred in enumerate(predictions):
    print(f"\n样本 {i+1}:")
    print(f"指令: {pred['instruction']}")
    if pred['input']:
        print(f"输入: {pred['input']}")
    print(f"真实输出: {pred['ground_truth']}")
    print(f"模型输出: {pred['prediction']}")

监督微调实现流程
环境准备 → 数据集加载 → 模型加载 → 数据预处理 → 训练配置 → 模型训练 → 模型评估 → 部署应用

# 安装LLaMA Factory
pip install llamafactory

# 使用命令行进行微调
llamafactory-cli finetune \
    --model_name_or_path facebook/llama-2-7b-hf \
    --do_train \
    --dataset alpaca_dataset \
    --template llama2 \
    --finetuning_type lora \
    --lora_target q_proj,v_proj \
    --output_dir ./fine-tuned-llama2 \
    --per_device_train_batch_size 4 \
    --gradient_accumulation_steps 4 \
    --lr_scheduler_type cosine \
    --learning_rate 5e-5 \
    --num_train_epochs 3 \
    --plot_loss

from trl import SFTTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from datasets import load_dataset

# 加载模型和分词器
model = AutoModelForCausalLM.from_pretrained("facebook/opt-1.3b")
tokenizer = AutoTokenizer.from_pretrained("facebook/opt-1.3b")

# 加载数据集
dataset = load_dataset("json", data_files="alpaca_data.json")

# 配置训练参数
training_args = TrainingArguments(
    output_dir="./sft-model",
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-5,
    num_train_epochs=3,
    logging_steps=100,
    evaluation_strategy="steps",
    eval_steps=500,
    save_steps=1000
)

# 创建SFT训练器
trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    args=training_args,
    train_dataset=dataset["train"],
    dataset_text_field="text",  # 假设数据集中有一个合并了instruction、input和output的text字段
    packing=True  # 启用序列打包以提高训练效率
)

# 开始训练
trainer.train()

from unsloth import FastLanguageModel
from transformers import TrainingArguments
from datasets import load_dataset
import torch

# 加载模型（使用Unsloth的优化版本）
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="meta-llama/Llama-2-7b-hf",
    max_seq_length=2048,
    dtype=torch.float16,
    load_in_4bit=True
)

# 配置LoRA
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    lora_alpha=16,
    lora_dropout=0,
    target_modules=["q_proj", "v_proj"],
    bias="none",
    use_gradient_checkpointing=True
)

# 加载数据集
dataset = load_dataset("json", data_files="alpaca_data.json")

# 格式化数据集
def formatting_func(examples):
    instructions = examples["instruction"]
    inputs = examples["input"]
    outputs = examples["output"]
    texts = []
    for instruction, input_text, output in zip(instructions, inputs, outputs):
        text = f"### 指令:\n{instruction}\n"
        if input_text:
            text += f"### 输入:\n{input_text}\n"
        text += f"### 回答:\n{output}"
        texts.append(text)
    return {"text": texts}

dataset = dataset.map(formatting_func, batched=True)

# 配置训练参数
training_args = TrainingArguments(
    output_dir="./unsloth-fine-tuned",
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    num_train_epochs=3,
    logging_steps=10,
    save_steps=100
)

# 开始训练
FastLanguageModel.train(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset["train"],
    args=training_args,
    dataset_text_field="text"
)