Reduce ZeroGPU usage by moving CPU work outside GPU scope

- Split infer() into a CPU-only wrapper and @spaces.GPU(duration=120) _infer_gpu()
so image decoding, validation, seed resolution, and dimension computation no
longer consume GPU quota
- Move gc.collect() before the GPU lease is acquired
- Remove torch.cuda.synchronize() from the per-step callback (was blocking once
per step just for wall-clock logging)
- Remove per-step GPU memory queries from the step callback

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

app.py

@@ -332,14 +332,24 @@ with open("templates/app.html") as _f:
 
 # ── Gradio blocks ──────────────────────────────────────────────────────────────
 
-@spaces.GPU
 def infer(images_b64_json, prompt, seed, randomize_seed, guidance_scale, steps, mode="fast", progress=gr.Progress(track_tqdm=True)):
+    # CPU-only preprocessing — GPU not yet allocated
+    gc.collect()
+    pil_images = b64_to_pil_list(images_b64_json)
+    _validate_infer_inputs(pil_images, prompt)
+    seed = _resolve_seed(seed, randomize_seed)
+    width, height = update_dimensions_on_upload(pil_images[0], max_dim_for_mode(mode))
+    return _infer_gpu(pil_images, prompt, seed, guidance_scale, steps, width, height)
+
+
+@spaces.GPU(duration=120)
+def _infer_gpu(pil_images, prompt, seed, guidance_scale, steps, width, height):
     _cuda_ok = torch.cuda.is_available()
     timer = _InferTimer(_cuda_ok)
     t0 = time.perf_counter()
 
     print(f"[infer] ===== START =====")
-    print(f"[infer] steps={steps}, guidance={guidance_scale}, seed={seed}, randomize={randomize_seed}")
+    print(f"[infer] steps={steps}, guidance={guidance_scale}, seed={seed}")
     print(f"[infer] prompt={repr(prompt[:120])}")
 
     if _cuda_ok:
@@ -349,36 +359,23 @@ def infer(images_b64_json, prompt, seed, randomize_seed, guidance_scale, steps,
 
     print(f"[infer] {_gpu_mem_str(_cuda_ok)} — t={time.perf_counter()-t0:.1f}s")
 
-    gc.collect()
     torch.cuda.empty_cache()
     print(f"[infer] cache cleared — {_gpu_mem_str(_cuda_ok)}")
 
-    timer.mark("load_start")
-    pil_images = b64_to_pil_list(images_b64_json)
-    timer.mark("load_end")
-    print(f"[infer] decoded {len(pil_images)} image(s) — {timer.elapsed_ms('load_start', 'load_end'):.0f}ms")
-
-    _validate_infer_inputs(pil_images, prompt)
+    print(f"[infer] {len(pil_images)} image(s) pre-decoded, output={width}x{height}, seed={seed}")
 
-    seed = _resolve_seed(seed, randomize_seed)
     generator = torch.Generator(device=device).manual_seed(seed)
-    width, height = update_dimensions_on_upload(pil_images[0], max_dim_for_mode(mode))
-    print(f"[infer] input={pil_images[0].size}, output={width}x{height}, seed={seed}")
 
-    # Per-step callback: syncs the GPU then records a CUDA event so elapsed_time()
-    # gives true GPU-timeline durations for preprocess / inference / vae_decode.
-    # Step 1 time includes any torch.compile Triton kernel compilation.
     _step_t = []
     def _step_cb(pipeline, step_idx, timestep, cb_kwargs):
-        torch.cuda.synchronize()
         now = time.perf_counter()
         _step_t.append(now)
         if step_idx == 0:
             timer.mark("first_step")
-        timer.mark("last_step")  # overwritten each iteration; final value = end of last step
+        timer.mark("last_step")  # overwritten each step; final value = end of last step
         delta_ms = (now - (_step_t[-2] if len(_step_t) > 1 else t0)) * 1000
         tag = " ← includes compile" if step_idx == 0 else ""
-        print(f"[infer] step {step_idx+1}/{steps} done — {delta_ms:.0f}ms{tag} | {_gpu_mem_str(_cuda_ok)} | t={time.perf_counter()-t0:.1f}s")
+        print(f"[infer] step {step_idx+1}/{steps} done — {delta_ms:.0f}ms{tag} | t={now-t0:.1f}s")
         return cb_kwargs
 
     timer.mark("pipe_start")