LLM 微调入门：LoRA 让大模型适配私有场景

W_new = W_original + ΔW = W_original + A × B

# ShareGPT 格式（推荐，支持多轮对话）
{
    "conversations": [
        {"from": "human", "value": "如何查看K8s Pod的资源使用情况？"},
        {"from": "gpt", "value": "使用kubectl top命令：\n```bash\n# 查看所有Pod资源\nkubectl top pods -n <namespace>\n\n# 查看特定Pod\nkubectl top pod <pod-name> -n <namespace>\n```\n\n如果显示error: Metrics API not available，需要安装metrics-server。"}
    ]
}

# Alpaca 格式（单轮，适合指令微调）
{
    "instruction": "解释以下Kubernetes错误",
    "input": "OOMKilled: container exceeded memory limit",
    "output": "OOMKilled表示容器因超过内存限制被系统强制终止。排查步骤：\n1. 查看容器的内存limit设置...\n2. 用kubectl top确认实际内存使用...\n3. 检查是否有内存泄漏..."
}

import json
from pathlib import Path

def validate_dataset(file_path: str):
    data = []
    with open(file_path) as f:
        for line in f:
            data.append(json.loads(line.strip()))

    issues = []
    for i, item in enumerate(data):
        # 检查格式
        if "conversations" not in item:
            issues.append(f"Line {i}: missing conversations field")
            continue

        convs = item["conversations"]

        # 检查长度（太短的回答质量通常差）
        for conv in convs:
            if conv["from"] == "gpt" and len(conv["value"]) < 50:
                issues.append(f"Line {i}: response too short ({len(conv['value'])} chars)")

        # 检查 token 数（超过模型最大长度的样本会被截断）
        total_chars = sum(len(c["value"]) for c in convs)
        if total_chars > 8000:  # 粗略估计，实际要用 tokenizer
            issues.append(f"Line {i}: possibly too long ({total_chars} chars)")

    print(f"Total samples: {len(data)}")
    print(f"Issues found: {len(issues)}")
    for issue in issues[:10]:
        print(f"  - {issue}")

    return len(issues) == 0

validate_dataset("train.jsonl")

# 推荐用 conda 管理环境
conda create -n finetune python=3.11 -y
conda activate finetune

# 安装 Unsloth（会自动匹配 CUDA 版本）
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes

# 验证
python -c "import unsloth; print(unsloth.__version__)"

from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
import torch

# 1. 加载模型（4bit量化）
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="Qwen/Qwen2.5-7B-Instruct",  # 也可以用本地路径
    max_seq_length=4096,
    dtype=None,           # None 自动检测，通常是 bfloat16
    load_in_4bit=True,    # QLoRA
)

# 2. 添加 LoRA adapter
model = FastLanguageModel.get_peft_model(
    model,
    r=16,                          # rank，常用值：8/16/32/64
    target_modules=[               # 作用于哪些层
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj"
    ],
    lora_alpha=16,                 # 缩放因子，通常等于r或2*r
    lora_dropout=0.05,
    bias="none",
    use_gradient_checkpointing="unsloth",  # Unsloth 优化的梯度检查点
    random_state=42,
)

print(model.print_trainable_parameters())
# 输出类似：trainable params: 41,943,040 || all params: 7,677,517,824 || trainable%: 0.5462

# 3. 准备数据集
from datasets import load_dataset

# 本地 jsonl 文件
dataset = load_dataset("json", data_files={"train": "train.jsonl"})["train"]

# 格式化为 Qwen 的 chat template
def format_chat(example):
    conversations = example["conversations"]
    text = tokenizer.apply_chat_template(
        [
            {"role": "user" if c["from"] == "human" else "assistant", "content": c["value"]}
            for c in conversations
        ],
        tokenize=False,
        add_generation_prompt=False
    )
    return {"text": text}

dataset = dataset.map(format_chat)

# 4. 配置训练参数
training_args = TrainingArguments(
    output_dir="./checkpoints",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,  # 有效 batch size = 2 * 4 = 8
    warmup_steps=50,
    learning_rate=2e-4,
    fp16=not torch.cuda.is_bf16_supported(),
    bf16=torch.cuda.is_bf16_supported(),
    logging_steps=10,
    save_steps=100,
    save_total_limit=3,
    optim="adamw_8bit",            # 8bit 优化器，节省显存
    weight_decay=0.01,
    lr_scheduler_type="cosine",
    seed=42,
    report_to="tensorboard",       # 或 "wandb"
)

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=4096,
    dataset_num_proc=4,
    args=training_args,
)

# 5. 开始训练
trainer.train()

# 启动 TensorBoard 监控 loss 曲线
tensorboard --logdir ./checkpoints/runs --port 6006

# 关注指标：
# - train/loss：应该稳定下降，最终在 0.5-1.5 范围正常
# - train/learning_rate：余弦衰减曲线
# - train/grad_norm：梯度范数，突然飙升说明有问题

# 训练结束后合并 LoRA 权重到基础模型
model.save_pretrained_merged(
    "merged_model",
    tokenizer,
    save_method="merged_16bit",  # 合并后保存为fp16
)

# 或者保存为 GGUF 格式（Ollama 使用）
model.save_pretrained_gguf(
    "model_gguf",
    tokenizer,
    quantization_method="q4_k_m"  # 4bit量化，平衡质量和大小
)

# 或者只保存 LoRA adapter（体积小，之后再合并）
model.save_pretrained("lora_adapter")
tokenizer.save_pretrained("lora_adapter")

# 从 GGUF 文件创建 Ollama 模型
cat > Modelfile << 'EOF'
FROM ./model_gguf/model-q4_k_m.gguf

SYSTEM "你是一个专业的运维工程师助手，擅长Kubernetes、Linux系统管理和故障排查。"

PARAMETER temperature 0.1
PARAMETER top_p 0.9
EOF

ollama create myops-model -f Modelfile
ollama run myops-model "如何排查K8s Pod CrashLoopBackOff问题？"

# 安装 vLLM
pip install vllm

# 启动服务（使用合并后的 fp16 模型）
python -m vllm.entrypoints.openai.api_server \
    --model ./merged_model \
    --port 8000 \
    --gpu-memory-utilization 0.9 \
    --max-model-len 4096 \
    --tensor-parallel-size 1  # 多卡时增大

# 测试效果（兼容 OpenAI API）
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="dummy"
)

response = client.chat.completions.create(
    model="merged_model",
    messages=[
        {"role": "user", "content": "Pod内存OOM了怎么排查？"}
    ],
    temperature=0.1
)
print(response.choices[0].message.content)

# 如果 tokenizer 没有 pad token，训练会报错
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token