Upload gdn_fla_tilelang_bench.py with huggingface_hub

gdn_fla_tilelang_bench.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""A/B benchmark for PR#32: does fla's tilelang GatedDeltaNet backend actually beat the
+pure-PyTorch delta-rule fallback on Hopper (sm90)?
+
+Context: on Hopper with Triton>=3.4 fla's gated chunk_bwd Triton kernel is miscomputed and
+HARD-RAISES (fla #640). The worker USED to drop fla -> transformers' pure-PyTorch delta rule
+(correct, slow). PR#32 instead installs fla's **tilelang** backend (correct on Triton>=3.4) and
+keeps fla. transformers gates GDN on is_fla_available(), so:
+
+  * mode 'off'      -> fla physically removed -> pure-PyTorch delta rule  (the OLD fallback)
+  * mode 'tilelang' -> fla + pinned tilelang present -> fla tilelang GDN  (the NEW fast path)
+
+Run BOTH as separate processes (fla import state is sticky), then compare ms/step + peak VRAM:
+    FLA_MODE=off      python gdn_fla_tilelang_bench.py
+    FLA_MODE=tilelang python gdn_fla_tilelang_bench.py
+
+Higher speedup (off_ms / tilelang_ms) and lower peak mem => PR#32's win is real on this host.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import time
+
+TILELANG_PIN = "0.1.11"
+TVM_FFI_PIN = "0.1.11"
+FLA_GIT = "git+https://github.com/fla-org/flash-linear-attention.git@f0e213dbd8b5fb90c3c7eca869ac1706d5377139"
+
+
+def _run(*a: str) -> int:
+    return subprocess.run([sys.executable, "-m", "pip", *a], check=False).returncode
+
+
+def _remove_fla() -> None:
+    """Physically remove fla so is_fla_available() is False -> transformers native torch delta."""
+    import importlib
+    import importlib.util
+    import shutil
+
+    _run("uninstall", "-y", "-q", "flash-linear-attention")
+    for _ in range(6):
+        importlib.invalidate_caches()
+        spec = importlib.util.find_spec("fla")
+        if spec is None:
+            break
+        locs = list(getattr(spec, "submodule_search_locations", []) or [])
+        if spec.origin:
+            locs.append(os.path.dirname(spec.origin))
+        gone = False
+        for loc in locs:
+            if loc and os.path.isdir(loc) and os.path.basename(loc.rstrip("/")) == "fla":
+                shutil.rmtree(loc, ignore_errors=True)
+                gone = True
+        if not gone:
+            break
+    importlib.invalidate_caches()
+
+
+def _ensure_tilelang() -> None:
+    import importlib
+    import importlib.metadata as md
+
+    def ver(d):
+        try:
+            return md.version(d)
+        except Exception:
+            return None
+
+    if ver("tilelang") != TILELANG_PIN:
+        _run("install", "-q", f"tilelang=={TILELANG_PIN}")
+    if ver("apache-tvm-ffi") != TVM_FFI_PIN:
+        _run("install", "-q", f"apache-tvm-ffi=={TVM_FFI_PIN}")
+    if importlib.util.find_spec("fla") is None or importlib.util.find_spec("fla.modules") is None:
+        _run("install", "-q", "--no-deps", FLA_GIT)
+    importlib.invalidate_caches()
+
+
+def main() -> None:
+    mode = os.environ.get("FLA_MODE", "tilelang")
+    model_id = os.environ.get("MODEL", "Qwen/Qwen3.5-0.8B")
+    seqs = [int(s) for s in os.environ.get("SEQS", "4096,8192,16384").split(",")]
+    warmup, iters = 2, 6
+
+    if mode == "off":
+        _remove_fla()
+    else:
+        _ensure_tilelang()
+
+    import torch
+
+    # Report the resolved backend state so the comparison is auditable.
+    try:
+        from transformers.utils.import_utils import is_fla_available
+
+        fla_ok = bool(is_fla_available())
+    except Exception:
+        import importlib.util as _u
+
+        fla_ok = _u.find_spec("fla") is not None
+    tl = None
+    try:
+        import importlib.metadata as md
+
+        import tilelang  # noqa: F401
+
+        tl = md.version("tilelang")
+    except Exception:
+        tl = None
+
+    name = torch.cuda.get_device_name(0)
+    cap = torch.cuda.get_device_capability(0)
+    print(
+        f"[gdn-bench] mode={mode} gpu={name} sm{cap[0]}{cap[1]} "
+        f"is_fla_available={fla_ok} tilelang={tl} torch={torch.__version__}",
+        flush=True,
+    )
+
+    from peft import LoraConfig, get_peft_model
+    from transformers import AutoModelForCausalLM
+
+    model = AutoModelForCausalLM.from_pretrained(
+        model_id, dtype=torch.bfloat16, attn_implementation="sdpa"
+    ).cuda()
+    model = get_peft_model(
+        model,
+        LoraConfig(r=16, lora_alpha=32, target_modules="all-linear", task_type="CAUSAL_LM"),
+    )
+    model.train()
+    model.gradient_checkpointing_enable()
+    vocab = model.config.vocab_size
+
+    results = []
+    g = torch.Generator(device="cpu").manual_seed(0)
+    for L in seqs:
+        rec = {"seq": L}
+        try:
+            ids = torch.randint(0, vocab, (1, L), generator=g).cuda()
+            torch.cuda.reset_peak_memory_stats()
+
+            def step(ids=ids):
+                out = model(input_ids=ids, labels=ids)
+                out.loss.backward()
+                model.zero_grad(set_to_none=True)
+                return float(out.loss.detach())
+
+            loss = 0.0
+            for _ in range(warmup):
+                loss = step()
+            torch.cuda.synchronize()
+            t0 = time.perf_counter()
+            for _ in range(iters):
+                loss = step()
+            torch.cuda.synchronize()
+            ms = (time.perf_counter() - t0) / iters * 1000.0
+            rec.update(
+                ms_per_step=round(ms, 1),
+                peak_gb=round(torch.cuda.max_memory_allocated() / 1e9, 2),
+                loss=round(loss, 5),
+            )
+            print(f"[gdn-bench] seq={L}: {rec['ms_per_step']} ms/step  "
+                  f"peak={rec['peak_gb']} GB  loss={rec['loss']}", flush=True)
+        except Exception as e:  # capture (e.g. fla #640 hard-raise) instead of aborting the sweep
+            rec["error"] = f"{type(e).__name__}: {e}"
+            print(f"[gdn-bench] seq={L}: ERROR {rec['error']}", flush=True)
+            torch.cuda.empty_cache()
+        results.append(rec)
+
+    print("RESULT_JSON " + json.dumps({"mode": mode, "model": model_id, "gpu": name,
+                                       "sm": f"{cap[0]}{cap[1]}", "is_fla_available": fla_ok,
+                                       "tilelang": tl, "results": results}), flush=True)
+
+
+if __name__ == "__main__":
+    main()