Upload 09_export_bisect.py

09_export_bisect.py

@@ -0,0 +1,405 @@
+#!/usr/bin/env python
+"""
+09_export_bisect.py — Export MIT Qualitaetsmessung nach jeder Stufe.
+
+Unterschied zu 07_export_v3.py:
+  * Zwischenstufen werden NICHT geloescht -> Neustart ab beliebiger Stufe moeglich
+  * nach JEDER Stufe ein echter Qualitaetstest (Teacher-Forcing-Perplexitaet)
+  * am Ende eine Tabelle, die zeigt, WELCHE Stufe das Modell zerstoert
+  * Quantisierung asymmetrisch + lm_head ausgenommen (Verdacht aus Code-Review)
+
+Gemessene Stufen:
+  S1  fp32                     (roher torch.onnx.export)
+  S2  fp16                     (convert_float_to_float16 + fix_edges)
+  S3  fp16 + RMSNorm-fp32-Wrap
+  S4  q4f16                    (Endprodukt)
+
+Interpretation der Perplexitaet (ppl):
+  S1 ist die Referenz. Ein Anstieg um Faktor <1.5 ist unkritisch.
+  Die erste Stufe mit ppl > 3x S1 (oder NaN) ist der Schuldige.
+
+Start:
+  cd /root/train && nohup python 09_export_bisect.py > bisect.log 2>&1 &
+  tail -f bisect.log
+"""
+import gc, os, json, shutil
+from pathlib import Path
+import numpy as np
+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-bisect")
+ONNX_DIR = OUT / "onnx"
+ONNX_DIR.mkdir(parents=True, exist_ok=True)
+
+S1    = ONNX_DIR / "s1_fp32.onnx";        S1_D = "s1_fp32.onnx_data"
+S2    = ONNX_DIR / "s2_fp16.onnx";        S2_D = "s2_fp16.onnx_data"
+S3    = ONNX_DIR / "s3_fp16_rms.onnx";    S3_D = "s3_fp16_rms.onnx_data"
+S4    = ONNX_DIR / "decoder_model_merged_q4f16.onnx"
+S4_D  = "decoder_model_merged_q4f16.onnx_data"
+
+PROBE = OUT / "probe.npz"
+RESULTS = []
+
+# Testfall: Frage mit eindeutiger, kurzer Antwort. Teacher-Forcing misst,
+# wie ueberrascht das Modell von der KORREKTEN Antwort ist.
+TEST_Q = "Wie lange dauert die Probezeit bei einer Anstellung beim Bund?"
+TEST_A = "Die Probezeit dauert in der Regel drei Monate."
+
+
+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
+
+
+# ---------------------------------------------------------------- Messung
+def measure(path, label, fp16_io):
+    """Teacher-Forcing-Perplexitaet der Referenzantwort. Kleiner = besser."""
+    import onnxruntime as ort
+    d = np.load(PROBE)
+    emb = d["emb"]; ple = d["ple"]; tgt = d["tgt"]; a_start = int(d["a_start"])
+    n_cache = int(d["n_cache"]); kv = d["kv_shapes"]
+
+    dt = np.float16 if fp16_io else np.float32
+    seq = emb.shape[1]
+    feed = {
+        "inputs_embeds":    emb.astype(dt),
+        "per_layer_inputs": ple.astype(dt),
+        "attention_mask":   np.ones((1, seq), dtype=np.int64),
+        "position_ids":     np.arange(seq, dtype=np.int64)[None, :],
+    }
+    for i in range(n_cache):
+        n_kv, hd = int(kv[i][0]), int(kv[i][1])
+        z = np.zeros((1, n_kv, 0, hd), dtype=dt)
+        feed[f"past_key_values.{i}.key"] = z
+        feed[f"past_key_values.{i}.value"] = z
+
+    try:
+        so = ort.SessionOptions(); so.intra_op_num_threads = 8
+        sess = ort.InferenceSession(str(path), sess_options=so,
+                                    providers=["CPUExecutionProvider"])
+        logits = sess.run(["logits"], feed)[0].astype(np.float64)
+        del sess
+    except Exception as e:
+        msg = str(e).split(chr(10))[0][:140]
+        print(f"    !! LAEDT/LAEUFT NICHT: {msg}", flush=True)
+        RESULTS.append((label, "FEHLER", "-", msg[:60]))
+        return
+
+    if not np.isfinite(logits).all():
+        print("    !! logits enthalten NaN/Inf", flush=True)
+        RESULTS.append((label, "NaN/Inf", "-", "numerischer Ueberlauf"))
+        return
+
+    # Perplexitaet nur ueber die Antwort-Tokens
+    lp = logits[0] - logits[0].max(axis=-1, keepdims=True)
+    lp = lp - np.log(np.exp(lp).sum(axis=-1, keepdims=True))
+    nll, cnt = 0.0, 0
+    for p in range(a_start - 1, len(tgt) - 1):
+        nll -= lp[p, int(tgt[p + 1])]; cnt += 1
+    ppl = float(np.exp(nll / max(cnt, 1)))
+
+    # Erstes Antwort-Token: was sagt das Modell wirklich?
+    top = int(np.argmax(logits[0, a_start - 1]))
+    exp = int(tgt[a_start])
+    hit = "JA" if top == exp else "nein"
+
+    print(f"    ppl={ppl:.3f}   erstes Antwort-Token korrekt: {hit}", flush=True)
+    RESULTS.append((label, f"{ppl:.3f}", hit, ""))
+    gc.collect()
+
+
+def table():
+    log("BISEKTIONS-ERGEBNIS")
+    print(f"{'Stufe':<22}{'ppl':>12}{'1.Token':>10}  Hinweis")
+    print("-" * 72)
+    for r in RESULTS:
+        print(f"{r[0]:<22}{r[1]:>12}{r[2]:>10}  {r[3]}")
+    print("-" * 72)
+    print("Die erste Stufe mit ppl > 3x der Stufe S1 (oder FEHLER/NaN)")
+    print("ist die Ursache. Bleibt ppl ueberall niedrig, liegt der Fehler")
+    print("NICHT im Export, sondern im Embed-Pfad oder im Browser-Prompt.",
+          flush=True)
+
+
+# ================================================================ A) laden
+log("A) Modell laden (fp32) + Probe-Tensoren erzeugen")
+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, flush=True)
+
+# Chat-Template anwenden — exakt wie im Training
+p_txt = tok.apply_chat_template([{"role": "user", "content": TEST_Q}],
+                                tokenize=False, add_generation_prompt=True)
+p_ids = tok(p_txt, add_special_tokens=False)["input_ids"]
+a_ids = tok(TEST_A, add_special_tokens=False)["input_ids"]
+full = p_ids + a_ids
+a_start = len(p_ids)
+print("Prompt-Tokens:", len(p_ids), "| Antwort-Tokens:", len(a_ids), flush=True)
+print("Template-Auszug:", repr(p_txt[:120]), flush=True)
+
+log("B) Trockenlauf (Geometrie)")
+with torch.no_grad():
+    t_ids = torch.tensor([full], dtype=torch.long)
+    t_emb = lm.get_input_embeddings()(t_ids)
+    t_ple = lm.get_per_layer_inputs(t_ids, t_emb)
+    print("per_layer_inputs Shape:", tuple(t_ple.shape), flush=True)
+    probe = lm(inputs_embeds=t_emb[:, :4], per_layer_inputs=t_ple[:, :4],
+               use_cache=True, return_dict=True)
+pkv = probe.past_key_values
+N_CACHE = len(pkv.layers)
+KV_SHAPES = [(int(pkv.layers[i].keys.shape[1]), int(pkv.layers[i].keys.shape[3]))
+             for i in range(N_CACHE)]
+print("n_cache_layers:", N_CACHE, "| head_dims:",
+      sorted({s[1] for s in KV_SHAPES}), flush=True)
+
+np.savez(PROBE,
+         emb=t_emb.numpy().astype(np.float32),
+         ple=t_ple.numpy().astype(np.float32),
+         tgt=np.array(full, dtype=np.int64),
+         a_start=np.array(a_start),
+         n_cache=np.array(N_CACHE),
+         kv_shapes=np.array(KV_SHAPES, dtype=np.int64))
+print("Probe gespeichert:", PROBE, flush=True)
+del probe, pkv, t_emb, t_ple, t_ids
+gc.collect()
+
+
+# ================================================================ C) 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)
+
+
+if not S1.exists():
+    log("C) ONNX-Export fp32 (LANGE STILLE IST NORMAL, 20-40 min)")
+    wrapper = DecoderWrapper(lm, lm_head, N_CACHE).eval()
+    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 kvn in ("key", "value"):
+            pn, on = f"past_key_values.{i}.{kvn}", f"present.{i}.{kvn}"
+            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(S1),
+                          input_names=input_names, output_names=output_names,
+                          dynamic_axes=dyn, opset_version=17,
+                          do_constant_folding=True, dynamo=False)
+    print("Export geschrieben.", flush=True)
+    del wrapper, d_past, d_emb, d_ple
+    del model, lm, lm_head
+    gc.collect()
+
+    log("C.1) Konsolidierung fp32")
+    m = onnx.load(str(S1), load_external_data=True)
+    onnx.save_model(m, str(S1), save_as_external_data=True,
+                    all_tensors_to_one_file=True, location=S1_D, size_threshold=1024)
+    del m; gc.collect()
+    for f in ONNX_DIR.iterdir():
+        if f.name.startswith(("onnx__", "lm.", "_")):
+            f.unlink()
+else:
+    print("S1 existiert bereits — Export uebersprungen.", flush=True)
+    del model, lm, lm_head
+    gc.collect()
+
+log("MESSUNG S1 (fp32) — das ist die Referenz")
+measure(S1, "S1 fp32", fp16_io=False)
+
+
+# ============================================================ D) fp16
+if not S2.exists():
+    log("D) fp16-Konvertierung + fix_edges")
+    from onnxconverter_common import float16
+    m32 = onnx.load(str(S1), 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)
+    print(f"fix_edges Casts: {ne}", flush=True)
+    onnx.save_model(m16, str(S2), save_as_external_data=True,
+                    all_tensors_to_one_file=True, location=S2_D, size_threshold=1024)
+    del m32, m16; gc.collect()
+else:
+    print("S2 existiert bereits.", flush=True)
+
+log("MESSUNG S2 (fp16, ohne RMSNorm-Wrap)")
+measure(S2, "S2 fp16", fp16_io=True)
+
+
+# ============================================================ E) RMSNorm
+if not S3.exists():
+    log("E) RMSNorm-fp32-Wrap")
+    m = onnx.load(str(S2), load_external_data=True)
+    nw = wrap_rmsnorm_fp32(m)
+    print(f"ReduceMean gewrappt: {nw}", flush=True)
+    onnx.save_model(m, str(S3), save_as_external_data=True,
+                    all_tensors_to_one_file=True, location=S3_D, size_threshold=1024)
+    del m; gc.collect()
+else:
+    print("S3 existiert bereits.", flush=True)
+
+log("MESSUNG S3 (fp16 + RMSNorm-fp32)")
+measure(S3, "S3 fp16+RMSwrap", fp16_io=True)
+
+
+# ============================================================ F) q4f16
+if not S4.exists():
+    log("F) q4f16 — asymmetrisch, lm_head ausgenommen")
+    from onnxruntime.quantization.matmul_nbits_quantizer import (
+        MatMulNBitsQuantizer as Q, DefaultWeightOnlyQuantConfig)
+    mf = onnx.load(str(S3), load_external_data=True)
+
+    # lm_head finden: die MatMul mit der groessten Gewichtsmatrix.
+    dims = {i.name: list(i.dims) for i in mf.graph.initializer}
+    big, bigsz = None, 0
+    for nd in mf.graph.node:
+        if nd.op_type in ("MatMul", "Gemm"):
+            for inp in nd.input:
+                d = dims.get(inp)
+                if d and len(d) == 2:
+                    sz = d[0] * d[1]
+                    if sz > bigsz:
+                        bigsz, big = sz, nd.name
+    excl = [big] if big else []
+    print(f"lm_head-Kandidat ausgenommen: {big} ({bigsz/1e6:.0f}M Params)", flush=True)
+
+    quant = Q(mf, algo_config=DefaultWeightOnlyQuantConfig(
+                  block_size=32, is_symmetric=False, accuracy_level=4),
+              nodes_to_exclude=excl)
+    quant.process()
+    qm = quant.model.model if hasattr(quant.model, "model") else quant.model
+    onnx.save_model(qm, str(S4), save_as_external_data=True,
+                    all_tensors_to_one_file=True, location=S4_D, size_threshold=1024)
+    del mf, quant, qm; gc.collect()
+else:
+    print("S4 existiert bereits.", flush=True)
+
+log("MESSUNG S4 (q4f16 — Endprodukt)")
+measure(S4, "S4 q4f16", fp16_io=True)
+
+
+# ============================================================ G) Beiwerk
+log("G) Stock-Embed + Cast auf fp16 + config/tokenizer")
+from huggingface_hub import hf_hub_download
+
+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, flush=True)
+
+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 auf fp16 gecastet:", tg, flush=True)
+
+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.", flush=True)
+
+gc_cfg = OUT / "generation_config.json"
+if not gc_cfg.exists():
+    json.dump({"eos_token_id": [1, 106, 50], "bos_token_id": 2,
+               "pad_token_id": 0}, open(gc_cfg, "w"), indent=2)
+    print("generation_config.json angelegt.", flush=True)
+
+table()
+log("FERTIG. Zwischenstufen bleiben liegen. /root ist fluechtig — JETZT sichern!")