Add detailed generation timing summary

app.py

@@ -339,6 +339,49 @@ def _format_seconds(seconds: float) -> str:
     return f"{secs}s"
 
 
+def _format_timing(seconds: float) -> str:
+    seconds = max(0.0, float(seconds))
+    if seconds < 10:
+        return f"{seconds:.1f}s"
+    return _format_seconds(seconds)
+
+
+def _format_generation_summary(
+    *,
+    preset: ModelPreset,
+    width: int,
+    height: int,
+    steps: int,
+    guidance_scale: float,
+    seed: int,
+    total_seconds: float,
+    model_load_seconds: float,
+    model_was_loaded: bool,
+    setup_seconds: float,
+    denoise_seconds: float,
+    decode_seconds: float,
+) -> str:
+    if denoise_seconds > 0 and steps > 0:
+        speed = f"{steps / denoise_seconds:.2f} steps/s ({denoise_seconds / steps:.2f}s/step)"
+    else:
+        speed = "n/a"
+    load_note = "already in memory" if model_was_loaded else "download/load/switch"
+
+    return (
+        "### Generation summary\n\n"
+        f"`{preset.repo_id}` · {width}x{height} · {steps} steps · "
+        f"guidance {guidance_scale} · seed {seed}\n\n"
+        "| Phase | Time |\n"
+        "| --- | ---: |\n"
+        f"| Total backend time | {_format_timing(total_seconds)} |\n"
+        f"| Model {load_note} | {_format_timing(model_load_seconds)} |\n"
+        f"| Prompt + latent setup | {_format_timing(setup_seconds)} |\n"
+        f"| Raw denoising | {_format_timing(denoise_seconds)} |\n"
+        f"| Decode + output | {_format_timing(decode_seconds)} |\n"
+        f"| Raw denoising speed | {speed} |\n"
+    )
+
+
 def model_defaults(model_key: str):
     preset = MODEL_PRESETS[model_key]
     return (
@@ -429,14 +472,27 @@ def generate(
             torch.backends.cuda.matmul.allow_tf32 = True
 
         progress(0, desc=f"Loading {preset.label}")
+        model_was_loaded = _LOADED_PIPE is not None and _LOADED_MODEL_KEY == model_key
+        load_started_at = time.monotonic()
         pipe = _load_pipe(model_key)
-        denoise_started_at = time.monotonic()
-        progress(0, desc=f"Denoising 0/{steps} steps")
+        load_finished_at = time.monotonic()
+        pipe_started_at = load_finished_at
+        denoise_started_at: float | None = None
+        last_denoise_step_at: float | None = None
+        progress(0, desc="Preparing prompt and latents")
 
         def report_step(step: int, total: int) -> None:
+            nonlocal denoise_started_at, last_denoise_step_at
             total = max(1, int(total))
             step = min(max(0, int(step)), total)
-            elapsed = time.monotonic() - denoise_started_at
+            now = time.monotonic()
+            if step == 0:
+                denoise_started_at = now
+            if denoise_started_at is None:
+                denoise_started_at = now
+            if step > 0:
+                last_denoise_step_at = now
+            elapsed = now - denoise_started_at
             remaining = 0.0
             if step > 0:
                 remaining = (elapsed / step) * (total - step)
@@ -456,6 +512,7 @@ def generate(
             seed=int(seed),
             progress_callback=report_step,
         )
+        pipe_finished_at = time.monotonic()
         progress(1, desc="Finalizing image")
     except Exception as exc:
         traceback.print_exc()
@@ -464,12 +521,27 @@ def generate(
     if not images:
         return None, "Generation finished without an image.", seed
 
+    request_finished_at = time.monotonic()
+    if denoise_started_at is None:
+        denoise_started_at = pipe_started_at
+    if last_denoise_step_at is None:
+        last_denoise_step_at = denoise_started_at
+
     return (
         images[0],
-        (
-            f"Generated with `{preset.repo_id}` at {width}x{height}, "
-            f"{steps} steps, guidance {guidance_scale}, seed {seed}. "
-            f"Total time: {_format_seconds(time.monotonic() - request_started_at)}."
+        _format_generation_summary(
+            preset=preset,
+            width=width,
+            height=height,
+            steps=steps,
+            guidance_scale=guidance_scale,
+            seed=seed,
+            total_seconds=request_finished_at - request_started_at,
+            model_load_seconds=load_finished_at - load_started_at,
+            model_was_loaded=model_was_loaded,
+            setup_seconds=denoise_started_at - pipe_started_at,
+            denoise_seconds=last_denoise_step_at - denoise_started_at,
+            decode_seconds=pipe_finished_at - last_denoise_step_at,
         ),
         seed,
     )
@@ -506,6 +578,22 @@ APP_CSS = """
     white-space: normal;
     line-height: 1.35;
 }
+
+#generation_status table {
+    width: 100%;
+    margin-top: 0.5rem;
+}
+
+#generation_status th,
+#generation_status td {
+    padding: 6px 8px;
+}
+
+#generation_status th:last-child,
+#generation_status td:last-child {
+    text-align: right;
+    white-space: nowrap;
+}
 """
 
 
@@ -570,7 +658,8 @@ guidance-1.0 setting, and 5B RL is the reinforced-learning checkpoint.
                     f"Selected `{MODEL_PRESETS[DEFAULT_MODEL].repo_id}`. Defaults: "
                     f"{MODEL_PRESETS[DEFAULT_MODEL].steps} steps, "
                     f"guidance {MODEL_PRESETS[DEFAULT_MODEL].guidance}."
-                )
+                ),
+                elem_id="generation_status",
             )
 
     examples = gr.Dataset(

sefi/runner.py

@@ -678,6 +678,9 @@ class SEFIInferenceRunner:
                 u_sem_raw_schedule=u_sem_raw_schedule,
             )
 
+        if progress_callback is not None:
+            progress_callback(0, num_inference_steps)
+
         for step in range(num_inference_steps):
             u_sem_raw_cur = torch.full(
                 (batch_size,),