#!/usr/bin/env python3
"""KiT 最小训练脚本（搞懂AI 课程用，非官方）。

官方仓库的训练代码还没发布（kit_v1/train/README.md 写着 TBD）。这个脚本只用仓库里已经公开的
模型、特征和窗口代码，按论文 3.1 / 3.5 节写出训练目标，让你在一张消费级显卡上把训练循环跑通：

  1. 从 100 只演示股票里随机切出很多 (历史 Lc 根, 未来 Lh 根) 窗口；
  2. 未来那段加噪：z_t = (1 - t) * x + t * eps，t 按 logit-normal 抽样；
  3. 模型看着干净的历史和加噪的未来，预测“速度” v = eps - x，损失是这一段上的均方误差；
  4. 存出来的检查点（best.pt 验证损失最低的一份，last.pt 最后一份）可以直接交给官方的 eval/infer_for_pred.py --ckpt 使用。

没有做的（论文里有）：条件随机丢弃（CFG 用）、历史截断、多市场多粒度混合采样、FSDP 多卡、参数 EMA。
放在 KiT 仓库根目录运行：
  python train_mini.py --scale 1d --steps 300                       # 从零训练一个 3000 万参数的小模型
  python train_mini.py --scale 1d --ckpt ckpt/step_market_284M.pt --train-last 4   # 在官方权重上继续训练最后 4 层（微调）
"""
from __future__ import annotations

import argparse
import json
import math
import random
import time
from pathlib import Path

import numpy as np
import pandas as pd
import torch

from kit_v1.config import Config, get_config
from kit_v1.data.calendar import bars_per_day, load_trading_days
from kit_v1.data.features import FEATURE_NAMES, compute_features
from kit_v1.data.normalize import load_stats, normalize, stats_key
from kit_v1.infer import load_model_and_config, prepare_inference_window
from kit_v1.model import KlineDiT

MARKET = "ashare"


def build_windows(args, cfg, stats, tdays, instruments, lo, hi, per_stock, rng):
    """切窗口：锚点（历史的最后一根）在 [lo, hi] 之间，且未来 Lh 根也不超过 hi。"""
    Lc, Lh = cfg.data.window_for(args.scale)
    half_life = cfg.data.vol_ema_half_life_days * bars_per_day(MARKET, args.scale)
    warm = int(math.ceil(12 * half_life)) + 8          # 成交量 EMA 预热，和官方推理脚本取法一致
    out = []
    for code, inst in instruments.items():
        path = args.data_root / MARKET / args.scale / f"{code}.parquet"
        if not path.is_file():
            continue
        df = pd.read_parquet(path, columns=["datetime", "open", "high", "low", "close", "volume"])
        ts = pd.DatetimeIndex(df["datetime"])
        ok = [i for i in range(Lc + warm, len(df) - Lh)
              if ts[i] >= pd.Timestamp(lo) and ts[i + Lh] <= pd.Timestamp(hi) + pd.Timedelta(days=1)]
        for i in rng.sample(ok, min(per_stock, len(ok))):
            part = df.iloc[i + 1 - Lc - warm:i + 1 + Lh].reset_index(drop=True)
            hist, fut = part.iloc[:-Lh], part.iloc[-Lh:]
            win = prepare_inference_window(
                hist, MARKET, args.scale, Lc=Lc, Lh=Lh, stats=stats, soft_clip_c=cfg.data.soft_clip_c,
                half_life_days=cfg.data.vol_ema_half_life_days, sector_id=int(inst.get("sector", 0)),
                inst_id=int(inst.get("vocab_index", 0)), trading_days=tdays)
            # 停牌、缺数据时日历推出来的未来时间和真实的对不上，这种窗口不要
            if win["n_pad"] or not pd.DatetimeIndex(fut["datetime"]).equals(pd.DatetimeIndex(win["future_timestamps"])):
                continue
            feats = compute_features(*(part[c].to_numpy(np.float64) for c in ("open", "high", "low", "close", "volume")),
                                     half_life_bars=half_life)
            x = np.stack([normalize(feats[n], float(stats[stats_key(MARKET, args.scale, n)]), c=cfg.data.soft_clip_c)
                          for n in FEATURE_NAMES], axis=1).astype(np.float32)
            out.append((win["x_ctx"][0], torch.from_numpy(x[-Lh:]), {k: v[0] for k, v in win["cond"].items()}))
    return out


def collate(items, device):
    x_ctx = torch.stack([a for a, _, _ in items]).to(device)
    x_tgt = torch.stack([b for _, b, _ in items]).to(device)
    cond = {k: torch.stack([c[k] for _, _, c in items]).to(device) for k in items[0][2]}
    return x_ctx, x_tgt, cond


def fm_loss(model, x_ctx, x_tgt, cond, precision, gen=None):
    """论文式 (8)：只在未来那 Lh 根上算速度的均方误差。gen 给定时噪声和 t 固定，用来算可比的验证损失。"""
    B, Lh = x_tgt.shape[0], x_tgt.shape[1]
    dev = x_tgt.device
    t = torch.sigmoid(torch.randn(B, generator=gen, device="cpu")).to(dev)          # logit-normal
    eps = torch.randn(x_tgt.shape, generator=gen, device="cpu").to(dev)
    z = (1 - t)[:, None, None] * x_tgt + t[:, None, None] * eps
    with torch.autocast("cuda", dtype=torch.bfloat16, enabled=precision == "bf16" and dev.type == "cuda"):
        v = model(torch.cat([x_ctx, z], dim=1), t, cond, Lh)
    return ((v.float() - (eps - x_tgt)) ** 2).mean()


@torch.no_grad()
def val_loss(model, val, args, device):
    model.eval()
    gen, total, n = torch.Generator().manual_seed(1234), 0.0, 0
    for s in range(0, len(val), args.batch):
        items = val[s:s + args.batch]
        total += fm_loss(model, *collate(items, device), args.precision, gen).item() * len(items)
        n += len(items)
    model.train()
    return total / max(n, 1)


def main():
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("--data-root", type=Path, default=Path("data"))
    ap.add_argument("--scale", default="1d", help="训练用的时间粒度：1m 5m 15m 30m 1h 2h 1d 之一")
    ap.add_argument("--ckpt", default="none", help="none = 从零训练；给检查点路径 = 在它上面继续训练")
    ap.add_argument("--config", default="configs/dit_30m.yaml", help="从零训练时的模型大小")
    ap.add_argument("--train-start", default="2016-01-01")
    ap.add_argument("--train-end", default="2025-06-30")
    ap.add_argument("--val-start", default="2025-07-01")
    ap.add_argument("--val-end", default="2025-12-31")
    ap.add_argument("--per-stock", type=int, default=40, help="每只股票切多少个训练窗口")
    ap.add_argument("--steps", type=int, default=300)
    ap.add_argument("--batch", type=int, default=16)
    ap.add_argument("--lr", type=float, default=1e-4, help="论文的峰值学习率是 1e-4")
    ap.add_argument("--warmup", type=int, default=50)
    ap.add_argument("--eval-every", type=int, default=50)
    ap.add_argument("--train-last", type=int, default=0,
                    help="只训练最后 N 个 Transformer 块和输出层，其余冻结（0 = 全部训练）。显存不够微调大模型时用")
    ap.add_argument("--precision", choices=("bf16", "fp32"), default="bf16")
    ap.add_argument("--out", type=Path, default=Path("runs/mini"))
    ap.add_argument("--seed", type=int, default=0)
    ap.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
    args = ap.parse_args()

    torch.manual_seed(args.seed)
    rng = random.Random(args.seed)
    device = torch.device(args.device)
    if args.ckpt == "none":
        cfg = Config.load_yaml(args.config, base=get_config("tiny"))
        model = KlineDiT(cfg.model)
    else:
        model, cfg = load_model_and_config(args.ckpt, "tiny", args.seed)
    model.to(device).train()
    n_params = sum(p.numel() for p in model.parameters())
    if args.train_last > 0:
        # 冻结大部分参数：没有梯度、也没有优化器状态，显存主要省在这里
        for p in model.parameters():
            p.requires_grad_(False)
        for m in [*model.blocks[-args.train_last:], model.final_norm, model.out_proj]:
            for p in m.parameters():
                p.requires_grad_(True)
        model.head_bias.requires_grad_(True)
    trainable = [p for p in model.parameters() if p.requires_grad]

    instruments = json.loads((args.data_root / "instruments.json").read_text(encoding="utf-8"))
    stats = load_stats(args.data_root / "stats.json")
    tdays = load_trading_days(args.data_root / "trade_dates.csv")
    t0 = time.time()
    train = build_windows(args, cfg, stats, tdays, instruments, args.train_start, args.train_end, args.per_stock, rng)
    val = build_windows(args, cfg, stats, tdays, instruments, args.val_start, args.val_end, 4, rng)
    Lc, Lh = cfg.data.window_for(args.scale)
    print(f"model {n_params / 1e6:.1f}M params ({sum(p.numel() for p in trainable) / 1e6:.1f}M trainable) | scale {args.scale} Lc={Lc} Lh={Lh} | "
          f"windows train {len(train)} val {len(val)} ({time.time() - t0:.0f}s)", flush=True)

    # 论文：AdamW(β1=0.9, β2=0.95, weight decay 0.1)、梯度裁剪 1.0、峰值学习率 1e-4 加预热
    opt = torch.optim.AdamW(trainable, lr=args.lr, betas=(0.9, 0.95), weight_decay=0.1)
    sched = torch.optim.lr_scheduler.LambdaLR(opt, lambda s: min(1.0, (s + 1) / args.warmup))
    args.out.mkdir(parents=True, exist_ok=True)
    log = []
    v0 = val_loss(model, val, args, device)
    print(f"step 0 | val {v0:.4f}", flush=True)
    log.append({"step": 0, "val": v0})
    best = v0
    save = lambda name, step: torch.save({"config": cfg.to_dict(), "model": {k: v.detach().cpu() for k, v in model.state_dict().items()},
                                          "step": step, "note": "train_mini.py (unofficial)"}, args.out / name)
    t0, running = time.time(), []
    for step in range(1, args.steps + 1):
        loss = fm_loss(model, *collate(rng.sample(train, args.batch), device), args.precision)
        opt.zero_grad(set_to_none=True)
        loss.backward()
        torch.nn.utils.clip_grad_norm_(trainable, 1.0)
        opt.step(); sched.step()
        running.append(loss.item())
        if step % args.eval_every == 0 or step == args.steps:
            v = val_loss(model, val, args, device)
            tr = sum(running) / len(running); running = []
            mem = torch.cuda.max_memory_allocated() / 2**30 if device.type == "cuda" else 0
            print(f"step {step} | train {tr:.4f} | val {v:.4f} | {time.time() - t0:.0f}s | peak GPU {mem:.1f} GB", flush=True)
            log.append({"step": step, "train": tr, "val": v})
            if v < best:   # 验证损失创新低就存一份：训练损失还在降、验证损失开始升，就是过拟合了，要用这一份
                best = v; save("best.pt", step)
                print(f"  saved best.pt (val {v:.4f})", flush=True)
    save("last.pt", args.steps)
    (args.out / "log.json").write_text(json.dumps(log, indent=1))
    print(f"saved {args.out / 'last.pt'}", flush=True)


if __name__ == "__main__":
    main()
