大模型微调企业——决定微调成败的基石

{
  "instruction": "请根据以下研报内容，生成一段不超过300字的摘要，并提取目标价、评级和EPS预测。",
  "input": "研报全文（约8000字）...",
  "output": "摘要文本... \n【关键指标】目标价：15.8元；评级：买入；EPS预测：2025年1.24元，2026年1.52元。"
}

from datasets import Dataset
import pandas as pd

df = pd.read_json("raw_data.jsonl", lines=True)
# 过滤 input 长度 < 500 字或 output 长度 < 50 字的样本
df = df[(df['input'].str.len() >= 500) & (df['output'].str.len() >= 50)]
# 基于input的SimHash去重（简化示例）
df = df.drop_duplicates(subset=['input'])
# 最终训练集 1.2w 条，验证集 1500 条

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-7B", trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token

def tokenize_fn(example):
    # 拼接 instruction + input
    text = example['instruction'] + "\n" + example['input'] + "\n" + example['output']
    # 注意：训练时只计算 output 部分的 loss，需设置 labels
    # 这里仅做演示，实际使用 tokenizer 的 padding 和 truncation
    tokenized = tokenizer(text, max_length=4096, truncation=True, padding="max_length")
    return tokenized

import torch
from transformers import AutoModelForCausalLM, TrainingArguments, Trainer
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from datasets import load_dataset

# 加载模型（4bit量化以节省显存）
model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2.5-7B",
    torch_dtype=torch.bfloat16,
    device_map="auto",
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
)
model = prepare_model_for_kbit_training(model)

# LoRA配置
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()  # 约 0.2% 的参数可训练

# 训练参数
training_args = TrainingArguments(
    output_dir="./qwen_finetune",
    per_device_train_batch_size=2,
    per_device_eval_batch_size=2,
    gradient_accumulation_steps=8,   # 有效batch=16
    num_train_epochs=3,
    learning_rate=2e-4,
    warmup_ratio=0.03,
    logging_steps=10,
    eval_steps=100,
    save_steps=500,
    report_to="wandb",
    fp16=False,
    bf16=True,
    optim="paged_adamw_8bit",
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_train,
    eval_dataset=tokenized_val,
    data_collator=DataCollatorForSeq2Seq(tokenizer, padding=True),
)
trainer.train()

from rouge_score import rouge_scorer
import json

scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)

def evaluate_predictions(preds, refs):
    scores = []
    for p, r in zip(preds, refs):
        scores.append(scorer.score(r, p))
    avg = {k: sum(s[k].fmeasure for s in scores)/len(scores) for k in scores[0]}
    return avg

from peft import PeftModel

base_model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2.5-7B",
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
lora_model = PeftModel.from_pretrained(base_model, "./qwen_finetune/checkpoint-1500")
merged_model = lora_model.merge_and_unload()
merged_model.save_pretrained("./merged_model")

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from vllm import LLM, SamplingParams

app = FastAPI()
llm = LLM(model="./merged_model", tensor_parallel_size=1, dtype="bfloat16")

class SummarizeRequest(BaseModel):
    report_text: str

class SummarizeResponse(BaseModel):
    summary: str
    metrics: dict

sampling_params = SamplingParams(
    temperature=0.2,
    top_p=0.9,
    max_tokens=512,
    stop=["<|im_end|>"]
)

@app.post("/summarize", response_model=SummarizeResponse)
async def summarize(req: SummarizeRequest):
    prompt = f"请根据以下研报内容，生成摘要和关键指标。\n{req.report_text}\n"
    outputs = llm.generate([prompt], sampling_params)
    generated_text = outputs[0].outputs[0].text
    # 解析摘要和指标（正则提取）
    # ...
    return SummarizeResponse(summary=summary, metrics=extracted_metrics)

# 增量微调时，加载已有LoRA checkpoint，再训练
model = PeftModel.from_pretrained(base_model, "./lora_checkpoint_v1")
model.train()  # 继续用新数据训练