"""Per-head CE (text + 12 codebooks) of a checkpoint on a fixed set of single-speaker batches.
usage: per_head_ce.py <model_path> [n_batches]"""
import json, random, sys

sys.path.insert(0, "/data/mukil/datasets/fused/tts/moss_tts_local_v1.5/finetuning")
import numpy as np
import torch
import torch.nn.functional as F
from transformers import AutoModel

import sft
from dataset import SingleSpeakerContextDataset, load_prompt_index

model_path = sys.argv[1]
n_batches = int(sys.argv[2]) if len(sys.argv) > 2 else 16
random.seed(0); torch.manual_seed(0)
processor = sft.load_processor_with_codec_kwargs(
    "OpenMOSS-Team/MOSS-TTS-Local-Transformer-v1.5", codec_path="OpenMOSS-Team/MOSS-Audio-Tokenizer-v2",
    codec_weight_dtype="fp32", codec_compute_dtype="bf16", codec_attention_implementation="sdpa",
    load_audio_tokenizer=False)
path = "/data/mukil/datasets/fused/jsonl/train-00120-of-00121.jsonl"
records = [dict(json.loads(l), _base_dir="/data/mukil/datasets/fused/jsonl") for l in open(path)]
records = random.Random(0).sample(records, n_batches * 4)
# Same drop probabilities as training, fixed seed so every checkpoint sees identical batches.
ds = SingleSpeakerContextDataset(records, processor, load_prompt_index("/data/mukil/datasets/fused/prompt_index"))
random.seed(1)
batches = [ds.collate_fn([ds[i] for i in range(b * 4, b * 4 + 4)]) for b in range(n_batches)]

model = AutoModel.from_pretrained(model_path, trust_remote_code=True, dtype=torch.bfloat16,
                                  attn_implementation="sdpa").cuda().eval()
losses = []
orig_ce = F.cross_entropy
def recording_ce(*a, **k):
    out = orig_ce(*a, **k); losses.append(float(out)); return out
F.cross_entropy = recording_ce
rows = []
with torch.no_grad():
    for batch in batches:
        losses.clear()
        total = sft.compute_supervised_loss(
            model, input_ids=batch["input_ids"].cuda(), attention_mask=batch["attention_mask"].cuda(),
            labels=batch["labels"].cuda(), channelwise_loss_weight=[1.0] + [32 / 12] * 12)
        rows.append([float(total)] + losses)
r = np.array(rows).mean(0)
print(f"{model_path}\n weighted_total={r[0]:.4f}  text/eos={r[1]:.4f}")
print(" codebooks: " + " ".join(f"vq{i}={v:.3f}" for i, v in enumerate(r[2:])))
print(f" uniform over 1024 codes = {np.log(1024):.3f}")