Upload qsched_repro.py with huggingface_hub

qsched_repro.py

@@ -0,0 +1,357 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#   "torch",
+#   "diffusers>=0.27",
+#   "transformers>=4.38",
+#   "accelerate",
+#   "pillow",
+#   "numpy",
+# ]
+# ///
+"""
+Independent toy-scale reproduction of Q-Sched (arXiv 2509.01624).
+
+Core mechanism under test: a quantized few-step diffusion model can recover
+quality by re-optimising two scalar scheduler preconditioning coefficients
+(c_x on the latent term, c_eps on the prediction term), selected by the
+reference-free JAQ loss (CLIPScore + CLIP-IQA-Q). Weights stay fixed.
+
+Runs on a real SD1.5 4-step LCM pipeline (GPU) or on a deterministic mock
+pipeline (`--smoke`, CPU) that exercises every code path without a download.
+"""
+import argparse, json, os, hashlib, math, time
+import numpy as np
+
+def log(*a):
+    print("[qsched]", *a, flush=True)
+
+# ----------------------------- fake quantization -----------------------------
+def fake_quant_(tensor, bits):
+    """Per-tensor symmetric fake-quant, in place-returning a new tensor."""
+    import torch
+    qmax = 2 ** (bits - 1) - 1
+    s = tensor.abs().max() / qmax
+    if float(s) == 0.0:
+        return tensor.clone()
+    q = torch.clamp(torch.round(tensor / s), -qmax - 1, qmax)
+    return q * s
+
+def apply_weight_quant(unet, bits):
+    """Fake-quantize Conv2d/Linear weights. Returns dict of originals for restore."""
+    import torch, torch.nn as nn
+    originals = {}
+    for name, m in unet.named_modules():
+        if isinstance(m, (nn.Conv2d, nn.Linear)) and hasattr(m, "weight") and m.weight is not None:
+            originals[name] = m.weight.data.clone()
+            m.weight.data = fake_quant_(m.weight.data, bits)
+    return originals
+
+def restore_weights(unet, originals):
+    for name, m in unet.named_modules():
+        if name in originals:
+            m.weight.data = originals[name].clone()
+
+def unet_weight_hash(unet):
+    import torch
+    h = hashlib.sha256()
+    for name, p in sorted(unet.named_parameters()):
+        h.update(name.encode())
+        h.update(p.data.detach().to("cpu", torch.float32).numpy().tobytes())
+    return h.hexdigest()
+
+# --------------------------- Q-Sched LCM scheduler ---------------------------
+# Faithful LCM consistency step with two Q-Sched coefficients.
+#   denoised = c_x * (c_skip * x_t) + c_eps * (c_out * pred_x0)
+# (c_x, c_eps) = (1, 1) reproduces the stock LCM update.
+class QSchedLCM:
+    def __init__(self, alphas_cumprod, timestep_scaling=10.0, sigma_data=0.5):
+        import torch
+        self.acp = alphas_cumprod  # tensor [T]
+        self.timestep_scaling = timestep_scaling
+        self.sigma_data = sigma_data
+
+    def cskip_cout(self, t):
+        st = t * self.timestep_scaling
+        c_skip = self.sigma_data ** 2 / (st ** 2 + self.sigma_data ** 2)
+        c_out = st / math.sqrt(st ** 2 + self.sigma_data ** 2)
+        return c_skip, c_out
+
+    def step(self, model_output, t, t_prev, sample, noise, c_x=1.0, c_eps=1.0, last=False):
+        import torch
+        acp_t = self.acp[t]
+        alpha_t = acp_t.sqrt(); sigma_t = (1 - acp_t).sqrt()
+        pred_x0 = (sample - sigma_t * model_output) / alpha_t
+        c_skip, c_out = self.cskip_cout(int(t))
+        denoised = c_x * (c_skip * sample) + c_eps * (c_out * pred_x0)
+        if last:
+            return denoised
+        acp_p = self.acp[t_prev]
+        alpha_p = acp_p.sqrt(); sigma_p = (1 - acp_p).sqrt()
+        return alpha_p * denoised + sigma_p * noise
+
+# ------------------------------- JAQ loss -----------------------------------
+class JAQ:
+    """Reference-free: CLIPScore (text-image) + CLIP-IQA-Q (antonym quality)."""
+    def __init__(self, device, mock=False):
+        self.mock = mock; self.device = device
+        if mock:
+            return
+        import torch
+        from transformers import CLIPModel, CLIPProcessor
+        self.model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32").to(device).eval()
+        self.proc = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
+        # CLIP-IQA-Q antonym prompt pair
+        self.iqa_pos, self.iqa_neg = "Good photo.", "Bad photo."
+
+    def _img_emb(self, pil):
+        import torch
+        px = self.proc(images=pil, return_tensors="pt").to(self.device)
+        with torch.no_grad():
+            e = self.model.get_image_features(**px)
+        return e / e.norm(dim=-1, keepdim=True)
+
+    def _txt_emb(self, texts):
+        import torch
+        tk = self.proc(text=texts, return_tensors="pt", padding=True).to(self.device)
+        with torch.no_grad():
+            e = self.model.get_text_features(**tk)
+        return e / e.norm(dim=-1, keepdim=True)
+
+    def score(self, pil, prompt):
+        """Return (clipscore, clipiqa_q, jaq)."""
+        if self.mock:
+            # deterministic mock quality from image mean (exercises the pipeline)
+            arr = np.asarray(pil).astype(np.float32) / 255.0
+            cs = float(arr.mean()); iqa = float(1.0 - arr.std())
+            return cs, iqa, cs + iqa
+        import torch
+        ie = self._img_emb(pil)
+        te = self._txt_emb([prompt])
+        clipscore = float((ie @ te.T).item())
+        pair = self._txt_emb([self.iqa_pos, self.iqa_neg])
+        sims = (ie @ pair.T).squeeze(0) * 100.0
+        iqa_q = float(torch.softmax(sims, dim=0)[0].item())
+        return clipscore, iqa_q, clipscore + iqa_q
+
+# ----------------------------- pipeline wrappers -----------------------------
+class MockPipe:
+    """CPU mock: tiny UNet-like function + fake VAE, deterministic. No download."""
+    def __init__(self, device):
+        import torch, torch.nn as nn
+        torch.manual_seed(0)
+        self.device = device
+        T = 1000
+        self.acp = torch.linspace(0.9999, 0.02, T)  # decreasing alpha_cumprod
+        self.unet = nn.Sequential(nn.Conv2d(4, 8, 3, padding=1), nn.SiLU(),
+                                  nn.Conv2d(8, 4, 3, padding=1)).to(device)
+        self.qsched = QSchedLCM(self.acp)
+
+    def eps(self, x, t):
+        import torch
+        return self.unet(x)
+
+    def generate(self, prompt, seed, steps, c_x, c_eps, bits_originals=None):
+        import torch
+        g = torch.Generator(device="cpu").manual_seed(seed + hash(prompt) % 1000)
+        x = torch.randn(1, 4, 16, 16, generator=g).to(self.device)
+        ts = torch.linspace(999, 0, steps + 1).long()
+        for i in range(steps):
+            t, tp = int(ts[i]), int(ts[i + 1])
+            mo = self.eps(x, t)
+            noise = torch.randn(x.shape, generator=g).to(self.device)
+            x = self.qsched.step(mo, t, tp, x, noise, c_x, c_eps, last=(i == steps - 1))
+        # fake decode -> [0,255] image
+        img = ((x[0].mean(0).clamp(-2, 2) + 2) / 4 * 255).to(torch.uint8).cpu().numpy()
+        from PIL import Image
+        return Image.fromarray(np.stack([img] * 3, -1))
+
+class RealPipe:
+    """SD1.5 4-step LCM via diffusers, with QSched sampler override."""
+    def __init__(self, model_id, device, dtype):
+        import torch
+        from diffusers import LatentConsistencyModelPipeline
+        self.device = device; self.dtype = dtype
+        self.pipe = LatentConsistencyModelPipeline.from_pretrained(model_id, torch_dtype=dtype, safety_checker=None)
+        self.pipe.to(device)
+        self.unet = self.pipe.unet
+        acp = self.pipe.scheduler.alphas_cumprod.to(device=device, dtype=torch.float32)
+        self.acp = acp
+        self.qsched = QSchedLCM(acp)
+
+    def generate(self, prompt, seed, steps, c_x, c_eps):
+        import torch
+        pipe = self.pipe
+        g = torch.Generator(device=self.device).manual_seed(seed)
+        # encode prompt
+        pe, _ = pipe.encode_prompt(prompt, self.device, 1, False)
+        pipe.scheduler.set_timesteps(steps, device=self.device)
+        timesteps = pipe.scheduler.timesteps
+        # initial latent
+        num_ch = pipe.unet.config.in_channels
+        h = w = 512 // pipe.vae_scale_factor
+        lat = torch.randn((1, num_ch, h, w), generator=g, device=self.device, dtype=self.dtype)
+        lat = lat * pipe.scheduler.init_noise_sigma
+        n = len(timesteps)
+        for i, t in enumerate(timesteps):
+            mo = pipe.unet(lat, t, encoder_hidden_states=pe, return_dict=False)[0]
+            tp = int(timesteps[i + 1]) if i + 1 < n else 0
+            noise = torch.randn(lat.shape, generator=g, device=self.device, dtype=self.dtype)
+            lat = self.qsched.step(mo.float(), int(t), tp, lat.float(), noise.float(),
+                                   c_x, c_eps, last=(i == n - 1)).to(self.dtype)
+        img = pipe.vae.decode(lat / pipe.vae.config.scaling_factor, return_dict=False)[0]
+        img = pipe.image_processor.postprocess(img, output_type="pil")[0]
+        return img
+
+# --------------------------------- driver -----------------------------------
+CALIB_PROMPTS = [
+    "a photograph of an astronaut riding a horse",
+    "a bowl of fresh strawberries on a wooden table",
+    "a red sports car on a mountain road at sunset",
+    "a cozy cabin in a snowy forest, warm light",
+    "a portrait of a woman with curly hair, studio lighting",
+    "a bustling city street market at night",
+]
+EVAL_PROMPTS = [
+    "a golden retriever puppy playing in a garden",
+    "a lighthouse on a rocky coast under storm clouds",
+    "a plate of sushi with chopsticks, top view",
+    "an old library with tall bookshelves and a ladder",
+    "a hot air balloon over a green valley",
+    "a steaming cup of coffee on a rainy window sill",
+    "a majestic eagle soaring over mountains",
+    "a futuristic city skyline with flying cars",
+    "a field of sunflowers under a blue sky",
+    "a vintage bicycle leaning against a brick wall",
+    "a bengal tiger walking through tall grass",
+    "a wooden sailboat on a calm lake at dawn",
+]
+
+def mean(xs): return float(sum(xs) / len(xs)) if xs else 0.0
+
+def eval_config(pipe, jaq, prompts, seed, steps, c_x, c_eps, save_dir=None, tag=None):
+    cs, iqa, jq = [], [], []
+    for i, p in enumerate(prompts):
+        img = pipe.generate(p, seed, steps, c_x, c_eps)
+        a, b, c = jaq.score(img, p)
+        cs.append(a); iqa.append(b); jq.append(c)
+        if save_dir is not None and i < 3:
+            try:
+                img.save(os.path.join(save_dir, f"{tag}_p{i}.png"))
+            except Exception as e:
+                log("img save failed", e)
+    return {"clipscore": mean(cs), "clipiqa_q": mean(iqa), "jaq": mean(jq)}
+
+def grid_search(pipe, jaq, prompts, seed, steps, grid):
+    results = []
+    for cx in grid:
+        for ce in grid:
+            r = eval_config(pipe, jaq, prompts, seed, steps, cx, ce)
+            r["c_x"], r["c_eps"] = cx, ce
+            results.append(r)
+            log(f"  grid c_x={cx:.2f} c_eps={ce:.2f} JAQ={r['jaq']:.4f}")
+    best = max(results, key=lambda r: r["jaq"])
+    return best, results
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--smoke", action="store_true")
+    ap.add_argument("--model", default="SimianLuo/LCM_Dreamshaper_v7")
+    ap.add_argument("--steps", type=int, default=4)
+    ap.add_argument("--seed", type=int, default=1234)
+    ap.add_argument("--bits", type=int, nargs="+", default=[8, 4])
+    ap.add_argument("--grid", type=float, nargs="+",
+                    default=[0.90, 0.95, 1.00, 1.05, 1.10])
+    ap.add_argument("--n-calib", type=int, default=6)
+    ap.add_argument("--n-eval", type=int, default=12)
+    ap.add_argument("--out", default="outputs/results.json")
+    args = ap.parse_args()
+
+    import torch
+    device = "cuda" if (not args.smoke and torch.cuda.is_available()) else "cpu"
+    dtype = torch.float16 if device == "cuda" else torch.float32
+    log(f"device={device} smoke={args.smoke} steps={args.steps} bits={args.bits} grid={args.grid}")
+
+    if args.smoke:
+        pipe = MockPipe(device)
+    else:
+        pipe = RealPipe(args.model, device, dtype)
+    jaq = JAQ(device, mock=args.smoke)
+
+    calib = CALIB_PROMPTS[:args.n_calib]
+    ev = EVAL_PROMPTS[:args.n_eval]
+    unet = pipe.unet
+
+    out = {"meta": {"paper": "Q-Sched arXiv:2509.01624", "model": args.model,
+                    "device": device, "steps": args.steps, "grid": args.grid,
+                    "smoke": args.smoke, "seed": args.seed,
+                    "n_calib": len(calib), "n_eval": len(ev)},
+           "bitwidths": {}}
+
+    save_dir = os.path.dirname(args.out) or "."
+    os.makedirs(save_dir, exist_ok=True)
+    # ---- FP16 reference (Claim 1 hash before) ----
+    hash_before = unet_weight_hash(unet)
+    t0 = time.time()
+    fp16 = eval_config(pipe, jaq, ev, args.seed, args.steps, 1.0, 1.0, save_dir, "fp16")
+    log(f"FP16 eval: {fp16}")
+    out["fp16_reference"] = fp16
+    out["weight_hash_fp16"] = hash_before
+
+    rng = np.random.RandomState(0)
+    for bits in args.bits:
+        log(f"=== W{bits} ===")
+        originals = apply_weight_quant(unet, bits)
+        hash_quant = unet_weight_hash(unet)
+        # default sampler baseline
+        base = eval_config(pipe, jaq, ev, args.seed, args.steps, 1.0, 1.0, save_dir, f"w{bits}_default")
+        log(f"W{bits} quant + default(1,1) eval: {base}")
+        # grid search on calibration prompts (reference-free)
+        best, grid_all = grid_search(pipe, jaq, calib, args.seed, args.steps, args.grid)
+        log(f"W{bits} JAQ-selected c_x={best['c_x']} c_eps={best['c_eps']}")
+        qsched = eval_config(pipe, jaq, ev, args.seed, args.steps, best["c_x"], best["c_eps"], save_dir, f"w{bits}_qsched")
+        log(f"W{bits} quant + Q-Sched eval: {qsched}")
+        # negative control: random coeff pair (not (1,1), not the selected best)
+        rc, tries = None, 0
+        while tries < 200:
+            tries += 1
+            cand = (round(float(rng.choice(args.grid)), 2), round(float(rng.choice(args.grid)), 2))
+            if cand != (best["c_x"], best["c_eps"]) and cand != (1.0, 1.0):
+                rc = cand; break
+        if rc is None:  # degenerate grid (e.g. single point) — skip control
+            rand = None
+            log(f"W{bits} random control skipped (grid too small)")
+        else:
+            rand = eval_config(pipe, jaq, ev, args.seed, args.steps, rc[0], rc[1])
+            log(f"W{bits} quant + random{rc} eval: {rand}")
+        # Claim-1 check: weights identical before/after Q-Sched sampler run
+        hash_after = unet_weight_hash(unet)
+        restore_weights(unet, originals)
+        out["bitwidths"][f"W{bits}"] = {
+            "quant_default": base, "qsched": qsched, "random_control": rand,
+            "selected_c_x": best["c_x"], "selected_c_eps": best["c_eps"],
+            "random_coeff": rc, "grid": grid_all,
+            "weight_hash_quant": hash_quant,
+            "weight_hash_after_qsched": hash_after,
+            "weights_unchanged_by_sampler": hash_quant == hash_after,
+            "qsched_beats_default": qsched["jaq"] > base["jaq"],
+            "qsched_beats_random": (qsched["jaq"] > rand["jaq"]) if rand else None,
+            "recovery_frac_toward_fp16": (
+                (qsched["jaq"] - base["jaq"]) / (fp16["jaq"] - base["jaq"])
+                if abs(fp16["jaq"] - base["jaq"]) > 1e-9 else None),
+        }
+    out["meta"]["runtime_sec"] = round(time.time() - t0, 1)
+    os.makedirs(os.path.dirname(args.out), exist_ok=True)
+    with open(args.out, "w") as f:
+        json.dump(out, f, indent=2)
+    log(f"wrote {args.out} in {out['meta']['runtime_sec']}s")
+    print("QSCHED_RESULTS_JSON_BEGIN")
+    print(json.dumps(out))
+    print("QSCHED_RESULTS_JSON_END")
+    print("SUMMARY", json.dumps({k: {kk: v[kk] for kk in
+          ("qsched_beats_default", "qsched_beats_random", "selected_c_x", "selected_c_eps",
+           "recovery_frac_toward_fp16", "weights_unchanged_by_sampler")}
+          for k, v in out["bitwidths"].items()}, indent=2))
+
+if __name__ == "__main__":
+    main()