Check inputs before reserving the GPU, and skip it entirely for a silent input.

app.py

@@ -32,35 +32,48 @@ model_card = ModelCard(
 )
 
 
-@spaces.GPU
-@torch.inference_mode()
 def process_fn(input_audio_path: str, output_sample_rate: str) -> str:
+    # Checked before the GPU is reserved, so a request the model cannot take spends none of the
+    # caller's ZeroGPU allowance
     if not input_audio_path:
         raise gr.Error("Choose an audio file.")
     audio, input_rate = torchaudio.load(input_audio_path)
-    audio = audio.mean(dim=0, keepdim=True)
     if audio.shape[-1] == 0:
         raise gr.Error("The audio file is empty.")
+
+    # Upstream divides by the input peak, so silence bypasses inference, and the GPU with it
+    if audio.count_nonzero() == 0:
+        output_rate = int(output_sample_rate)
+        return save(torch.zeros(1, ceil(audio.shape[-1] * output_rate / input_rate)), output_rate)
+
+    return extend(input_audio_path, output_sample_rate)
+
+
+@spaces.GPU
+@torch.inference_mode()
+def extend(input_audio_path: str, output_sample_rate: str) -> str:
+    audio, input_rate = torchaudio.load(input_audio_path)
+    audio = audio.mean(dim=0, keepdim=True)
     output_rate = int(output_sample_rate)
     output_length = ceil(audio.shape[-1] * output_rate / input_rate)
     native_length = ceil(audio.shape[-1] * SAMPLE_RATE / input_rate)
 
-    # Upstream divides by the input peak, so silence bypasses inference.
-    if audio.count_nonzero() == 0:
-        result = torch.zeros(1, output_length)
-    else:
-        minimum_length = ceil(2048 * input_rate / SAMPLE_RATE)
-        if audio.shape[-1] < minimum_length:
-            audio = F.pad(audio, (0, minimum_length - audio.shape[-1]))
-        result = model.generate(audio, input_rate, SAMPLE_RATE, timestep=1).cpu()
-        result = result[..., :native_length]
-        if output_rate != SAMPLE_RATE:
-            result = torchaudio.functional.resample(result, SAMPLE_RATE, output_rate)
-        result = result[..., :output_length]
-        peak = result.abs().max()
-        if peak > 1:
-            result *= 0.99 / peak
+    minimum_length = ceil(2048 * input_rate / SAMPLE_RATE)
+    if audio.shape[-1] < minimum_length:
+        audio = F.pad(audio, (0, minimum_length - audio.shape[-1]))
+    result = model.generate(audio, input_rate, SAMPLE_RATE, timestep=1).cpu()
+    result = result[..., :native_length]
+    if output_rate != SAMPLE_RATE:
+        result = torchaudio.functional.resample(result, SAMPLE_RATE, output_rate)
+    result = result[..., :output_length]
+    peak = result.abs().max()
+    if peak > 1:
+        result *= 0.99 / peak
+
+    return save(result, output_rate)
+
 
+def save(result: torch.Tensor, output_rate: int) -> str:
     # mkdtemp, not a context manager: that would delete the directory on exit,
     # taking the written file with it before the caller can read it, which is
     # what the block-cache call here was working around. That also reached for