Upload 03_export_quant_c.py

03_export_quant_c.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python
+"""
+03_export_quant_c.py — WEG C (Decoder-only, ohne Embedding-Gewichte)
+
+Der Decoder bekommt inputs_embeds UND per_layer_inputs (4D) von aussen.
+Damit landen die 14 GB Gather-Gewichte (embed_tokens + embed_tokens_per_layer)
+NICHT im Graphen -> fp32 ~10 GB -> q4f16 ~2 GB.
+
+Das Embed-Modell wird NICHT exportiert: das Stock-embed_tokens_q4f16.onnx von
+onnx-community/gemma-4-E4B-it-ONNX ist bitidentisch (LoRA hat nur
+q/k/v/o/gate/up/down_proj beruehrt) und wird einfach danebengelegt.
+
+Start IMMER mit nohup:
+  nohup python 03_export_quant_c.py > export_c.log 2>&1 &
+"""
+
+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"
+STOCK = "onnx-community/gemma-4-E4B-it-ONNX"
+OUT = Path("/root/train/gemma4-bund-final")
+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"
+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)
+
+
+# ------------------------------------------------------------------ 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()
+HIDDEN = lm.config.hidden_size
+print("hidden_size:", HIDDEN)
+
+
+# ------------------------------------------------- B) Cache-Geometrie messen
+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), "(erwartet: 1,4,42,256)")
+    probe = lm(inputs_embeds=emb, per_layer_inputs=ple, use_cache=True, return_dict=True)
+
+PLE_SHAPE = tuple(ple.shape[2:])          # (42, 256)
+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("head_dims:", sorted({s[1] for s in KV_SHAPES}), "(erwartet: [256, 512])")
+
+del probe, pkv, emb, ple, ids
+gc.collect()
+
+
+# ---------------------------------------------------------------- C) Wrapper
+class DecoderWrapper(torch.nn.Module):
+    def __init__(self, lm, lm_head, n_cache):
+        super().__init__()
+        self.lm, self.lm_head, self.n_cache = lm, lm_head, n_cache
+
+    def forward(self, inputs_embeds, per_layer_inputs,
+                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(
+            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 = 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")
+B, S, P = 1, 1, 1
+# ECHTE Embeddings (keine Nullen) — Gemma 4 prueft die Konsistenz
+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(B, P + S, dtype=torch.long)
+d_pos = torch.tensor([[P]], dtype=torch.long)
+d_past = []
+for (n_kv, hd) in KV_SHAPES:
+    d_past += [torch.zeros(B, n_kv, P, hd), torch.zeros(B, n_kv, P, 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"}
+
+log("C) torch.onnx.export — LANGE STILLE IST NORMAL (30-60 Min)")
+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")
+os.system(f"du -sh {ONNX_DIR}; df -h /root")
+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()
+os.system(f"df -h /root; ls -la {ONNX_DIR}")
+onnx.checker.check_model(str(FP32))
+print("fp32 valide.")
+
+
+# ------------------------------------------------------------------ E) q4f16
+log("E) q4f16")
+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)
+
+mf = onnx.load(str(FP32), 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()
+
+# fp32 wegwerfen — sonst laeuft die Disk beim Upload voll
+FP32.unlink(missing_ok=True)
+(ONNX_DIR / FP32_DATA).unlink(missing_ok=True)
+
+
+# ---------------------------------------------------- F) Stock-Embed + Config
+log("F) Stock-Embed holen + Tokenizer/Config schreiben")
+from huggingface_hub import hf_hub_download
+import shutil, json
+
+for fn in ("onnx/embed_tokens_q4f16.onnx", "onnx/embed_tokens_q4f16.onnx_data"):
+    try:
+        p = hf_hub_download(STOCK, fn)
+        shutil.copy(p, ONNX_DIR / Path(fn).name)
+        print("geholt:", fn)
+    except Exception as e:
+        print("nicht vorhanden (evtl. ok):", fn, e)
+
+tok.save_pretrained(str(OUT))
+from transformers import AutoConfig
+c = AutoConfig.from_pretrained(MODEL_ID)
+c.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": True,
+        "embed_tokens_q4f16.onnx": True,
+    },
+    "kv_cache_dtype": "float16",
+}
+json.dump(cfg, open(cp, "w"), indent=2)
+print("transformers.js_config geschrieben.")
+
+
+# ------------------------------------------------------------ G) Verifikation
+log("G) Verifikation")
+onnx.checker.check_model(str(Q4))
+size = (ONNX_DIR / Q4_DATA).stat().st_size / 1e6
+print(f"decoder q4f16 data: {size:.0f} MB")
+print("!! >3500 MB = Browser-Limit" if size > 3500 else "OK: browsertauglich")
+
+import onnxruntime as ort
+s = ort.InferenceSession(str(Q4), providers=["CPUExecutionProvider"])
+print("Inputs:", [i.name for i in s.get_inputs()][:4], "... total", len(s.get_inputs()))
+os.system(f"du -sh {OUT}; ls -la {ONNX_DIR}")
+
+log("FERTIG. JETZT SOFORT auf HF pushen — /root ist fluechtig!")
+print(f"  hf upload gfp78/gemma4-bund-onnx {OUT} . --repo-type model")