Use sequential CPU offload instead of moving full pipeline to GPU at once

pipe.to(device) staged all ~37GB of weights (transformer + text_encoder +
vae) onto GPU simultaneously, which OOM'd on smaller MIG slices (e.g. the
47GB 2g.48gb partition ZeroGPU sometimes hands out). enable_model_cpu_offload
uses the pipeline's declared model_cpu_offload_seq to keep only the active
component resident on GPU at a time.

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

app.py

@@ -402,12 +402,14 @@ def _infer_gpu(pil_images, prompt, seed, guidance_scale, steps, width, height, m
         print(f"[infer] GPU: {p.name}, total={p.total_memory/1024**3:.1f}GB, cap={p.major}.{p.minor}")
         torch.cuda.reset_peak_memory_stats()
 
-    print(f"[infer] moving pipe to {device}... — t={time.perf_counter()-t0:.1f}s")
-    pipe.to(device)
-    print(f"[infer] pipe on {device} — {_gpu_mem_str(_cuda_ok)} — t={time.perf_counter()-t0:.1f}s")
-
-    torch.cuda.empty_cache()
-    print(f"[infer] cache cleared — {_gpu_mem_str(_cuda_ok)}")
+    # Sequential offload: only the component currently doing work (text_encoder,
+    # then transformer, then vae — see model_cpu_offload_seq) sits on GPU at a
+    # time, instead of the full ~37GB pipeline resident simultaneously. Needed
+    # to fit on smaller MIG slices (e.g. the 47GB 2g.48gb partition) without OOM.
+    if getattr(pipe.transformer, "_hf_hook", None) is None:
+        pipe.enable_model_cpu_offload(device=device)
+        print(f"[infer] enabled sequential cpu offload on {device}")
+    print(f"[infer] {_gpu_mem_str(_cuda_ok)} — t={time.perf_counter()-t0:.1f}s")
 
     print(f"[infer] {len(pil_images)} image(s) pre-decoded, output={width}x{height}, seed={seed}")
 
@@ -450,8 +452,9 @@ def _infer_gpu(pil_images, prompt, seed, guidance_scale, steps, width, height, m
         timer.print_timings()
         raise
     finally:
-        print(f"[infer] moving pipe to CPU... t={time.perf_counter()-t0:.1f}s")
-        pipe.to("cpu")
+        # No manual pipe.to("cpu") — that fights the offload hooks' own device
+        # bookkeeping. Hooks already return each component to CPU after its
+        # forward; empty_cache() just reclaims the freed GPU blocks.
         gc.collect()
         torch.cuda.empty_cache()
         print(f"[infer] ===== END t={time.perf_counter()-t0:.1f}s =====")