Upload 07_export_v3.py

07_export_v3.py

@@ -0,0 +1,166 @@
+#!/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!")