"""bf16 LoRA 训练，不依赖 unsloth 和 bitsandbytes。

    python scripts/train_peft.py --data data/train.jsonl --out /workspace/out
"""

import argparse
from pathlib import Path

import torch
from datasets import load_dataset
from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed
from trl import SFTConfig, SFTTrainer


def main() -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument("--model", default="Qwen/Qwen3-4B-Instruct-2507")
    ap.add_argument("--data", default="train.jsonl")
    ap.add_argument("--out", default="/workspace/out")
    ap.add_argument("--epochs", type=float, default=3.0)
    ap.add_argument("--lr", type=float, default=2e-4)
    # 有效 batch = bs × accum = 16。第二轮最长样本 2678 token（第一轮 827），4090 上 bs 4 会爆；还 OOM 就 --bs 1 --accum 16
    ap.add_argument("--bs", type=int, default=2)
    ap.add_argument("--accum", type=int, default=8)
    ap.add_argument("--seq", type=int, default=3072)
    ap.add_argument("--no-group", action="store_true",
                    help="不按长度分组。默认分组：样本从两百到两千多 token 不等，随机凑一批的话短的要补齐到长的，白算一大半")
    ap.add_argument("--rank", type=int, default=32)
    ap.add_argument("--seed", type=int, default=42)
    ap.add_argument("--smoke", type=int, default=0, help="只跑这么多步，用来验流程（不合并、不存 8G 的合并版）")
    ap.add_argument("--no-merge", action="store_true", help="只存 LoRA，不存 8G 的合并版（评测用 --adapter）")
    args = ap.parse_args()

    set_seed(args.seed)  # LoRA 的初始化在 Trainer 设种子之前，不在这里设的话两次训练结果不一样
    tok = AutoTokenizer.from_pretrained(args.model)
    model = AutoModelForCausalLM.from_pretrained(
        args.model, torch_dtype=torch.bfloat16, device_map="cuda"
    )
    model.gradient_checkpointing_enable()
    model = get_peft_model(model, LoraConfig(
        r=args.rank, lora_alpha=args.rank * 2, lora_dropout=0.0, bias="none",
        task_type="CAUSAL_LM",
        target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                        "gate_proj", "up_proj", "down_proj"],
    ))
    model.print_trainable_parameters()

    ds = load_dataset("json", data_files=args.data, split="train")
    # 超过 max_length 的样本 TRL 会从右边悄悄截断，截掉的正好是 SQL；宁可直接停下
    longest = max(len(tok.apply_chat_template(r["messages"], tokenize=True)) for r in ds)
    assert longest <= args.seq, f"最长样本 {longest} token，超过 --seq {args.seq}，会把 SQL 截掉"
    print(f"最长样本 {longest} token（上限 {args.seq}）", flush=True)
    # 拆成 prompt / completion，TRL 只在 SQL 上算 loss。
    # 直接喂 messages 的话 loss 算在整条序列上，85% 的 token 是系统提示和建表语句，等于在背 schema。
    ds = ds.map(lambda r: {"prompt": r["messages"][:-1], "completion": r["messages"][-1:]},
                remove_columns=ds.column_names)
    print("样本", len(ds), flush=True)

    cfg = SFTConfig(
        output_dir=args.out,
        per_device_train_batch_size=args.bs,
        gradient_accumulation_steps=args.accum,
        num_train_epochs=args.epochs,
        max_steps=args.smoke if args.smoke else -1,
        learning_rate=args.lr,
        lr_scheduler_type="cosine",
        warmup_ratio=0.03,
        logging_steps=10,
        # 每个 epoch 存一份 LoRA（out/checkpoint-*），评测时用 eval.py --adapter 比较几个 epoch 哪个好
        save_strategy="no" if args.smoke else "epoch",
        save_only_model=True,
        bf16=True,
        optim="adamw_torch",
        max_length=args.seq,
        group_by_length=not args.no_group,
        # 不 packing：TRL 的 bfd packing 要 flash-attention，否则拼在一起的样本会互相看到；样本都短，不 packing 也不亏
        packing=False,
        dataset_kwargs={"skip_prepare_dataset": False},
        report_to="none",
        seed=args.seed,
    )
    trainer = SFTTrainer(model=model, train_dataset=ds, args=cfg, processing_class=tok)
    trainer.train()

    out = Path(args.out)
    model.save_pretrained(str(out / "lora"))
    tok.save_pretrained(str(out / "lora"))
    print("LoRA 存好了", flush=True)
    if args.smoke or args.no_merge:
        print("不合并", flush=True)
        return

    merged = model.merge_and_unload()
    merged.save_pretrained(str(out / "merged"), safe_serialization=True)
    tok.save_pretrained(str(out / "merged"))
    print("合并版存好了", flush=True)


if __name__ == "__main__":
    main()