Drop torch.compile from the upscale model; run eager (#50) (#70)

Dev-Space A/B via UPSCALE_COMPILE (#69), 53 frames, back-to-back runs:
- compiled (832x624 / 624x832): model_time 10.56-11.04s cold, 2.72-5.42s
warm, almost entirely the per-request first-call (compile/guard) penalty
- eager (544x832): model_time 0.96s cold and 0.96s warm, first call ~0.1s

Eager's steady compute is ~25% slower per pixel (~+0.2s per request at
832x624), far below the 1.9-10s compile penalty it removes. Remove the
compile path and the now-unneeded UPSCALE_COMPILE flag, and update the
profiler docstring that assumed compile.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

postprocess/upscale/profiling.py

@@ -1,10 +1,10 @@
 """Optional profiling for `upscale_frames()`, gated by `UPSCALE_PROFILE=1` (see `upscale.PROFILE`).
 
 Buckets each tiled `model()` call into "first call at this (tile-shape, batch-size)" vs. "steady
-call" (a repeat of a shape/batch-size combo already seen this run): `torch.compile(dynamic=True)`
-only marks a dim dynamic after seeing more than one value for it, so the very first call at a
-given (shape, batch_size) pair is the one that risks eating a recompile, not just the first call
-overall. Also tracks peak CUDA memory for the run. See issue #48.
+call" (a repeat of a shape/batch-size combo already seen this run): the first call at a new
+shape is where one-off costs land (CUDA/cuDNN lazy init today; per-shape recompiles back when the
+model was torch.compile'd — dropped per issue #50). Also tracks peak CUDA memory for the run. See
+issue #48.
 
 The memory line also reports what was already allocated when the run started (e.g. the diffusion
 pipeline's weights, resident in the same process — `reset_peak_memory_stats` resets the peak, not

postprocess/upscale/upscale.py

@@ -78,12 +78,6 @@ dtype = torch.float16 if device.type == "cuda" else torch.float32
 # for each upscale_frames() invocation — see profiling.py. Off by default.
 PROFILE = os.environ.get("UPSCALE_PROFILE", "") not in ("", "0")
 
-# Set UPSCALE_COMPILE=0 to run the eager model instead of torch.compile on CUDA. On by default.
-# Compiling costs a per-request first-call penalty at each shape (~9.8s cold, ~1.9s even on a warm
-# container) against ~0.06s/batch of steady compute, so eager may well be faster end to end —
-# this flag exists to measure that on the dev Space (issue #50).
-COMPILE = os.environ.get("UPSCALE_COMPILE", "1") != "0"
-
 ProgressCallback = Callable[[int, int], None]
 
 
@@ -110,19 +104,10 @@ def _load_model() -> torch.nn.Module:
     state_dict = load_file(_weights_path())
     model.load_state_dict(state_dict, strict=True)
     model.to(device=device, dtype=dtype).eval()
-    if device.type == "cuda" and COMPILE:
-        try:
-            # dynamic=True avoids a fresh recompile for every distinct tile shape (interior
-            # tiles vs. the last row/column, clipped against the image edge) — there are only a
-            # handful of those per video, but recompiling per-shape would otherwise eat into the
-            # first frame's latency. Guarded: torch.compile can fail to initialize (e.g. missing
-            # or incompatible triton on the target GPU image), in which case the eager model is
-            # used as-is.
-            model = cast(torch.nn.Module, torch.compile(model, dynamic=True))
-        except Exception as e:
-            print(f"[upscale] torch.compile failed to initialize, using eager model: {e!r}", flush=True)
-    elif device.type == "cuda":
-        print("[upscale] UPSCALE_COMPILE=0: using eager model", flush=True)
+    # Deliberately not torch.compile'd. Measured on the dev Space (issue #50), 53 frames:
+    # compiled model time was ~11s cold / 2.7-5.4s warm, almost all of it a per-request
+    # first-call (compile/guard) penalty, vs. ~0.96s cold *and* warm for eager. Eager's steady
+    # compute is ~25% slower per pixel (~+0.2s/request at 832x624), far less than that penalty.
     return model