Upload app.py

Fixed both in to_upload\app.py:

duration=30 instead of 120
The GPU section is now timed separately, so the results box reports:
Segmentation time: 7.02 s (GPU 2.14 s, queue+CPU 4.88 s)

That split tells you what you actually need to know. If GPU is ~2 s and queue+CPU is ~5 s, the compute is fine and you're waiting for hardware. If GPU is ~6 s, the model itself is the cost.

app.py

@@ -572,7 +572,7 @@ def _segment_patch(args):
     return mask, row_start, col_start
 
 
-@spaces.GPU(duration=120)
+@spaces.GPU(duration=30)
 def run_segmentation_patched(image_np, model_filename):
     """
     Split image into overlapping patches, run Cellpose on each in parallel,
@@ -586,6 +586,7 @@ def run_segmentation_patched(image_np, model_filename):
     Falls back to whole-image segmentation if the image is small enough
     that patching adds overhead without benefit.
     """
+    _t_gpu = time.perf_counter()
     h, w = image_np.shape[:2]
     model_path = hf_hub_download(repo_id=HF_REPO_ID, filename=model_filename)
     if model_filename in loaded_models:
@@ -597,7 +598,7 @@ def run_segmentation_patched(image_np, model_filename):
     # Small images: no benefit from patching
     if max(h, w) <= MIN_PATCH_DIM * 2:
         mask, _, _ = model.eval(image_np, diameter=None, channels=[0, 0])
-        return mask, 1   # 1 patch
+        return mask, 1, time.perf_counter() - _t_gpu
 
     patches = _split_patches(image_np)
     n_patches = len(patches)
@@ -621,7 +622,7 @@ def run_segmentation_patched(image_np, model_filename):
     patch_results.sort(key=lambda x: (x[1], x[2]))
 
     full_mask = _merge_patch_masks(patch_results, h, w)
-    return full_mask, n_patches
+    return full_mask, n_patches, time.perf_counter() - _t_gpu
 
 
 def render_segmentation(base_masks, processed_image_np,
@@ -701,7 +702,8 @@ def run_segmentation(image, model_choice, min_cell_size, max_cell_size,
             processed_image_np = image_np
 
         # Run patch-parallel Cellpose segmentation
-        masks_raw, n_patches = run_segmentation_patched(processed_image_np, model_filename)
+        masks_raw, n_patches, gpu_seconds = run_segmentation_patched(
+            processed_image_np, model_filename)
 
         # Same single pass feeds the log line and the recommendation below;
         # this used to be computed from scratch twice.
@@ -783,7 +785,10 @@ def run_segmentation(image, model_choice, min_cell_size, max_cell_size,
         info_msg += "Now run the viability classification model for viability assessment."
 
         seg_seconds = time.perf_counter() - _t_start
-        info_msg = f"Segmentation time: {seg_seconds:.2f} s\n" + info_msg
+        other = max(0.0, seg_seconds - gpu_seconds)
+        info_msg = (f"Segmentation time: {seg_seconds:.2f} s "
+                    f"(GPU {gpu_seconds:.2f} s, queue+CPU {other:.2f} s)\n"
+                    + info_msg)
 
         return (
             cell_count,