#!/usr/bin/env python
"""
07_export_v3.py — WEG C, ROBUSTE fp16-Konvertierung gegen WebGPU-Ueberlauf.

D.5-Strategie (statt op_block_list, das an Lib-Bugs/Grenzen scheitert):
  1. convert_float_to_float16(op_block_list=[])  -> alles fp16 (wie v1, laedt-faehig-Basis)
  2. fix_edges()   -> Cast to=FLOAT -> FLOAT16 (macht es ladefaehig, wie v1)
  3. wrap_rmsnorm_fp32() -> jede ReduceMean-Reduktion in fp32 (verhindert
     fp16-Ueberlauf der Summe-der-Quadrate auf echten WebGPU-Kerneln)
Alle drei Schritte in der Sandbox verifiziert (laedt + ReduceMean fp32).

Start: nohup python 07_export_v3.py > export_v3.log 2>&1 &
"""
import gc, os
from pathlib import Path
import torch, onnx
from onnx import TensorProto, helper

os.environ.setdefault("HF_HOME", "/root/hf-cache")
MODEL_ID = "/root/gemma4-bund-merged"
STOCK    = "onnx-community/gemma-4-E4B-it-ONNX"
OUT      = Path("/root/train/gemma4-bund-final-v3"); ONNX_DIR = OUT/"onnx"; ONNX_DIR.mkdir(parents=True, exist_ok=True)
FP32=ONNX_DIR/"decoder_model_merged.onnx"; FP32_DATA="decoder_model_merged.onnx_data"
FP16=ONNX_DIR/"decoder_model_merged_fp16.onnx"; FP16_DATA="decoder_model_merged_fp16.onnx_data"
Q4=ONNX_DIR/"decoder_model_merged_q4f16.onnx"; Q4_DATA="decoder_model_merged_q4f16.onnx_data"

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

def fix_edges(m):
    n=0
    for nd in m.graph.node:
        if nd.op_type=="Cast":
            for a in nd.attribute:
                if a.name=="to" and a.i==TensorProto.FLOAT: a.i=TensorProto.FLOAT16; n+=1
    return n

def wrap_rmsnorm_fp32(m):
    g=m.graph; new=[]; nw=0
    for node in list(g.node):
        if node.op_type=="ReduceMean":
            rin=node.input[0]; pre=rin+"_to32"
            new.append(helper.make_node("Cast",[rin],[pre],to=TensorProto.FLOAT,name=node.name+"/CastIn32"))
            node.input[0]=pre
            outp=node.output[0]; post=outp+"_f32"; node.output[0]=post
            new.append(node)
            new.append(helper.make_node("Cast",[post],[outp],to=TensorProto.FLOAT16,name=node.name+"/CastOut16"))
            nw+=1
        else:
            new.append(node)
    del g.node[:]; g.node.extend(new); return nw

# A) laden
log("A) Modell laden (fp32)")
from transformers import AutoTokenizer, AutoModelForImageTextToText, DynamicCache
tok=AutoTokenizer.from_pretrained(MODEL_ID)
model=AutoModelForImageTextToText.from_pretrained(MODEL_ID,dtype=torch.float32,device_map="cpu").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) Geometrie
log("B) Trockenlauf")
with torch.no_grad():
    ids=torch.tensor([[1,2,3,4]]); emb=lm.get_input_embeddings()(ids); ple=lm.get_per_layer_inputs(ids,emb)
    print("per_layer_inputs Shape:",tuple(ple.shape))
    probe=lm(inputs_embeds=emb,per_layer_inputs=ple,use_cache=True,return_dict=True)
pkv=probe.past_key_values; N_CACHE=len(pkv.layers); print("n_cache_layers:",N_CACHE)
KV_SHAPES=[(int(pkv.layers[i].keys.shape[1]),int(pkv.layers[i].keys.shape[3])) for i in range(N_CACHE)]
print("head_dims:",sorted({s[1] for s in KV_SHAPES}))
del probe,pkv,emb,ple,ids; gc.collect()

# C) Wrapper + Export
class DecoderWrapper(torch.nn.Module):
    def __init__(s,lm,lm_head,n): super().__init__(); s.lm,s.lm_head,s.n=lm,lm_head,n
    def forward(s,inputs_embeds,per_layer_inputs,attention_mask,position_ids,*past):
        cache=None
        if len(past)==2*s.n and past[0].shape[2]>0:
            cache=DynamicCache(config=s.lm.config)
            for i in range(s.n): cache.update(past[2*i],past[2*i+1],i)
        out=s.lm(inputs_embeds=inputs_embeds,per_layer_inputs=per_layer_inputs,attention_mask=attention_mask,
                 position_ids=position_ids,past_key_values=cache,use_cache=True,return_dict=True)
        logits=s.lm_head(out.last_hidden_state); present=[]
        for i in range(s.n): present+= [out.past_key_values.layers[i].keys,out.past_key_values.layers[i].values]
        return (logits,*present)
wrapper=DecoderWrapper(lm,lm_head,N_CACHE).eval()
log("C) Dummy + Export (LANGE STILLE NORMAL)")
with torch.no_grad():
    d_ids=torch.tensor([[42]],dtype=torch.long); d_emb=lm.get_input_embeddings()(d_ids).detach()
    d_ple=lm.get_per_layer_inputs(d_ids,d_emb).detach()
d_mask=torch.ones(1,2,dtype=torch.long); d_pos=torch.tensor([[1]],dtype=torch.long); d_past=[]
for (n_kv,hd) in KV_SHAPES: d_past+=[torch.zeros(1,n_kv,1,hd),torch.zeros(1,n_kv,1,hd)]
input_names=["inputs_embeds","per_layer_inputs","attention_mask","position_ids"]; output_names=["logits"]
dyn={"inputs_embeds":{0:"batch",1:"seq"},"per_layer_inputs":{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)
        dyn[pn]={0:"batch",2:"past_seq"}; dyn[on]={0:"batch",2:"total_seq"}
with torch.no_grad():
    torch.onnx.export(wrapper,(d_emb,d_ple,d_mask,d_pos,*d_past),str(FP32),input_names=input_names,
        output_names=output_names,dynamic_axes=dyn,opset_version=17,do_constant_folding=True,dynamo=False)
print("Export geschrieben.")
del model,lm,lm_head,wrapper,d_past,d_emb,d_ple; gc.collect()

# D) Konsolidierung
log("D) Konsolidierung")
m=onnx.load(str(FP32),load_external_data=True)
onnx.save_model(m,str(FP32),save_as_external_data=True,all_tensors_to_one_file=True,location=FP32_DATA,size_threshold=1024)
del m; gc.collect()
for f in ONNX_DIR.iterdir():
    if f.name.startswith("onnx__") or f.name.startswith("lm.") or f.name.startswith("_"): f.unlink()

# D.5) fp16 + fix_edges + ReduceMean-fp32-Wrap
log("D.5) convert(op_block_list=[]) -> fix_edges -> wrap_rmsnorm_fp32")
from onnxconverter_common import float16
m32=onnx.load(str(FP32),load_external_data=True)
m16=float16.convert_float_to_float16(m32,keep_io_types=False,disable_shape_infer=True,op_block_list=[])
ne=fix_edges(m16); nw=wrap_rmsnorm_fp32(m16)
print(f"fix_edges Casts: {ne} | ReduceMean gewrappt (fp32): {nw}")
onnx.save_model(m16,str(FP16),save_as_external_data=True,all_tensors_to_one_file=True,location=FP16_DATA,size_threshold=1024)
del m32,m16; gc.collect()
FP32.unlink(missing_ok=True); (ONNX_DIR/FP32_DATA).unlink(missing_ok=True)
import onnxruntime as ort
try:
    so=ort.SessionOptions(); so.intra_op_num_threads=4
    ort.InferenceSession(str(FP16),sess_options=so,providers=["CPUExecutionProvider"]); print("fp16 LAEDT in ORT.")
except Exception as e: print("!! fp16 LAEDT NICHT:",str(e).split(chr(10))[0][:120])

# E) q4f16
log("E) q4f16")
from onnxruntime.quantization.matmul_nbits_quantizer import MatMulNBitsQuantizer as Q, DefaultWeightOnlyQuantConfig
mf=onnx.load(str(FP16),load_external_data=True)
quant=Q(mf,algo_config=DefaultWeightOnlyQuantConfig(block_size=32,is_symmetric=True,accuracy_level=4)); quant.process()
qm=quant.model.model if hasattr(quant.model,"model") else quant.model
onnx.save_model(qm,str(Q4),save_as_external_data=True,all_tensors_to_one_file=True,location=Q4_DATA,size_threshold=1024)
del mf,quant,qm; gc.collect()
FP16.unlink(missing_ok=True); (ONNX_DIR/FP16_DATA).unlink(missing_ok=True)
try:
    so=ort.SessionOptions(); so.intra_op_num_threads=4
    s=ort.InferenceSession(str(Q4),sess_options=so,providers=["CPUExecutionProvider"]); print("q4f16 LAEDT, Inputs total",len(s.get_inputs()))
except Exception as e: print("!! q4f16 LAEDT NICHT:",str(e).split(chr(10))[0][:120])

# F) Embed-Cast + config + template
log("F) Stock-Embed + fp16-Cast + config/tokenizer")
from huggingface_hub import hf_hub_download
import shutil, json
for fn in ("onnx/embed_tokens_q4f16.onnx","onnx/embed_tokens_q4f16.onnx_data"):
    p=hf_hub_download(STOCK,fn,local_dir="/root/stock-embed"); shutil.copy(p,ONNX_DIR/Path(fn).name); print("geholt:",fn)
ep=ONNX_DIR/"embed_tokens_q4f16.onnx"; em=onnx.load(str(ep),load_external_data=False)
tg=[o.name for o in em.graph.output if o.type.tensor_type.elem_type==TensorProto.FLOAT]
pr={o:(nd,i) for nd in em.graph.node for i,o in enumerate(nd.output) if o in tg}
for name in tg:
    nd,idx=pr[name]; pre=name+"_fp32"; nd.output[idx]=pre
    em.graph.node.append(helper.make_node("Cast",[pre],[name],to=TensorProto.FLOAT16,name=name+"/CastToFp16"))
    for o in em.graph.output:
        if o.name==name: o.type.tensor_type.elem_type=TensorProto.FLOAT16
onnx.save(em,str(ep)); print("Embed-Outputs fp16:",tg)
tok.save_pretrained(str(OUT))
from transformers import AutoConfig
AutoConfig.from_pretrained(MODEL_ID).save_pretrained(str(OUT))
cp=OUT/"config.json"; cfg=json.load(open(cp))
cfg["transformers.js_config"]={"dtype":"q4f16","use_external_data_format":{"decoder_model_merged_q4f16.onnx":2,"embed_tokens_q4f16.onnx":True},"kv_cache_dtype":"float16"}
json.dump(cfg,open(cp,"w"),indent=2)
tcp=OUT/"tokenizer_config.json"; jinja=OUT/"chat_template.jinja"
if jinja.exists():
    tc=json.load(open(tcp)); tc["chat_template"]=jinja.read_text(encoding="utf-8"); json.dump(tc,open(tcp,"w"),ensure_ascii=False,indent=2); print("chat_template eingebettet.")
log("FERTIG bis F. Naechste Schritte: Reshard -> Upload -> Bundesrechner. JETZT sichern, /root ist fluechtig!")