#!/usr/bin/env python
"""
02_export_quant_b.py  — WEG B
Gemma 4 E4B (gfp78/gemma4-bund-merged) -> EIN ONNX-Decoder -> q4f16

Unterschied zu 01: Der Wrapper nimmt input_ids statt inputs_embeds.
Der Decoder erzeugt Embeddings UND Per-Layer-Embeddings (PLE) intern selbst.
Kein separates embed_tokens.onnx, kein Reverse-Lookup.
"""

import gc
import os
from pathlib import Path

import torch
import onnx

os.environ.setdefault("HF_HOME", "/root/hf")

MODEL_ID = "gfp78/gemma4-bund-merged"
OUT = Path("/root/train/gemma4-bund-onnx")
OUT.mkdir(parents=True, exist_ok=True)

FP32_ONNX = OUT / "decoder_model_merged.onnx"
FP32_DATA = "decoder_model_merged.onnx_data"
Q4_ONNX = OUT / "decoder_model_merged_q4f16.onnx"
Q4_DATA = "decoder_model_merged_q4f16.onnx_data"


def log(m):
    print(f"\n=== {m}", flush=True)


# ------------------------------------------------------------------ A) laden
log("A) Modell laden")
from transformers import AutoTokenizer, AutoModelForImageTextToText, DynamicCache

tok = AutoTokenizer.from_pretrained(MODEL_ID)
model = AutoModelForImageTextToText.from_pretrained(
    MODEL_ID, dtype=torch.float32, device_map="cpu"
)
model.eval()

lm = model.model.language_model
lm_head = model.lm_head if hasattr(model, "lm_head") else model.get_output_embeddings()
print("hidden_size:", lm.config.hidden_size)


# ------------------------------------------------- B) Cache-Geometrie messen
log("B) Trockenlauf: Cache-Layer + Head-Dims")
with torch.no_grad():
    probe = lm(input_ids=torch.tensor([[1, 2, 3, 4]]), use_cache=True, return_dict=True)

pkv = probe.past_key_values
N_CACHE = len(pkv.layers)
print("n_cache_layers:", N_CACHE, "  (erwartet: 24)")

KV_SHAPES = []
for i in range(N_CACHE):
    k = pkv.layers[i].keys
    KV_SHAPES.append((int(k.shape[1]), int(k.shape[3])))
    print(f"  layer {i:2d}: n_kv_heads={k.shape[1]}, head_dim={k.shape[3]}")

del probe, pkv
gc.collect()


# ---------------------------------------------------------------- C) Wrapper
class DecoderWrapper(torch.nn.Module):
    """input_ids + attention_mask + position_ids + past -> logits + present"""

    def __init__(self, lm, lm_head, n_cache):
        super().__init__()
        self.lm = lm
        self.lm_head = lm_head
        self.n_cache = n_cache

    def forward(self, input_ids, attention_mask, position_ids, *past):
        cache = None
        if len(past) == 2 * self.n_cache and past[0].shape[2] > 0:
            cache = DynamicCache(config=self.lm.config)
            for i in range(self.n_cache):
                cache.update(past[2 * i], past[2 * i + 1], i)

        out = self.lm(
            input_ids=input_ids,              # <-- Weg B: ids, nicht embeds
            attention_mask=attention_mask,
            position_ids=position_ids,
            past_key_values=cache,
            use_cache=True,
            return_dict=True,
        )
        logits = self.lm_head(out.last_hidden_state)

        present = []
        for i in range(self.n_cache):
            present.append(out.past_key_values.layers[i].keys)
            present.append(out.past_key_values.layers[i].values)
        return (logits, *present)


wrapper = DecoderWrapper(lm, lm_head, N_CACHE).eval()

log("C) Dummy-Inputs (echte Token-ID, keine Nullen)")
B, S, P = 1, 1, 1
dummy_ids = torch.tensor([[42]], dtype=torch.long)
dummy_mask = torch.ones(B, P + S, dtype=torch.long)
dummy_pos = torch.tensor([[P]], dtype=torch.long)

dummy_past = []
for (n_kv, hd) in KV_SHAPES:
    dummy_past.append(torch.zeros(B, n_kv, P, hd, dtype=torch.float32))
    dummy_past.append(torch.zeros(B, n_kv, P, hd, dtype=torch.float32))

input_names = ["input_ids", "attention_mask", "position_ids"]
output_names = ["logits"]
dynamic_axes = {
    "input_ids": {0: "batch", 1: "seq"},
    "attention_mask": {0: "batch", 1: "total"},
    "position_ids": {0: "batch", 1: "seq"},
    "logits": {0: "batch", 1: "seq"},
}
for i in range(N_CACHE):
    for kv in ("key", "value"):
        pn, on = f"past_key_values.{i}.{kv}", f"present.{i}.{kv}"
        input_names.append(pn)
        output_names.append(on)
        dynamic_axes[pn] = {0: "batch", 2: "past_seq"}
        dynamic_axes[on] = {0: "batch", 2: "total_seq"}

log("C) torch.onnx.export laeuft — LANGE STILLE IST NORMAL")
with torch.no_grad():
    torch.onnx.export(
        wrapper,
        (dummy_ids, dummy_mask, dummy_pos, *dummy_past),
        str(FP32_ONNX),
        input_names=input_names,
        output_names=output_names,
        dynamic_axes=dynamic_axes,
        opset_version=17,
        do_constant_folding=True,
        dynamo=False,
    )
print("Export geschrieben.")

del model, lm, lm_head, wrapper, dummy_past
gc.collect()


# --------------------------------------------------------- D) Konsolidierung
log("D) Konsolidierung (finaler Name direkt, NIE danach umbenennen)")
m = onnx.load(str(FP32_ONNX), load_external_data=True)
onnx.save_model(m, str(FP32_ONNX), save_as_external_data=True,
                all_tensors_to_one_file=True, location=FP32_DATA, size_threshold=1024)
del m
gc.collect()

for f in OUT.iterdir():
    if f.name.startswith("onnx__") or f.name.startswith("_"):
        f.unlink()
os.system(f"df -h /root; free -g; ls -la {OUT}")

onnx.checker.check_model(str(FP32_ONNX))
print("fp32-Graph valide.")


# ------------------------------------------------------------ E) q4f16
log("E) q4f16-Quantisierung")
try:
    from onnxruntime.quantization.matmul_nbits_quantizer import (
        MatMulNBitsQuantizer as Q, DefaultWeightOnlyQuantConfig)
except ImportError:
    from onnxruntime.quantization.matmul_4bits_quantizer import (
        MatMul4BitsQuantizer as Q, DefaultWeightOnlyQuantConfig)

model_fp32 = onnx.load(str(FP32_ONNX), load_external_data=True)
cfg = DefaultWeightOnlyQuantConfig(block_size=32, is_symmetric=True, accuracy_level=4)
quant = Q(model_fp32, algo_config=cfg)
quant.process()

qm = quant.model.model if hasattr(quant.model, "model") else quant.model
onnx.save_model(qm, str(Q4_ONNX), save_as_external_data=True,
                all_tensors_to_one_file=True, location=Q4_DATA, size_threshold=1024)
print("q4f16 geschrieben.")

del model_fp32, quant, qm
gc.collect()


# ------------------------------------------------------- F) Verifikation
log("F) Verifikation")
onnx.checker.check_model(str(Q4_ONNX))
size_mb = (OUT / Q4_DATA).stat().st_size / 1e6
print(f"{Q4_DATA}: {size_mb:.0f} MB")
print("!! >3500 MB = Browser-Limit gefaehrdet" if size_mb > 3500 else "OK: browsertauglich")

import onnxruntime as ort
sess = ort.InferenceSession(str(Q4_ONNX), providers=["CPUExecutionProvider"])
print("Session OK. Inputs:", len(sess.get_inputs()), "Outputs:", len(sess.get_outputs()))

tok.save_pretrained(str(OUT.parent / "gemma4-bund-final"))
log("FERTIG — jetzt SOFORT auf HF pushen, /root ist fluechtig!")