Fix inference type coercion for Gradio float inputs (ADM)

app.py

@@ -17,6 +17,7 @@ except ImportError:  # Local development without the Spaces runtime.
 
     spaces = _SpacesStub()  # type: ignore[assignment]
 
+import traceback
 from typing import Any
 
 import gradio as gr
@@ -28,7 +29,7 @@ from model_catalog import (
     get_profile_by_label,
     parse_model_label,
 )
-from model_loader import PIPELINE_MANAGER, run_inference
+from model_loader import PIPELINE_MANAGER, _to_float, _to_int, run_inference
 
 
 DEFAULT_MODEL = MODEL_LABELS[0]
@@ -112,6 +113,34 @@ def on_model_change(model_label: str):
     return _config_from_profile(get_profile_by_label(model_label))
 
 
+def _coerce_inference_inputs(
+    class_label: Any,
+    seed: Any,
+    num_steps: Any,
+    guidance_scale: Any,
+    height: Any,
+    width: Any,
+    guidance_interval_start: Any,
+    guidance_interval_end: Any,
+    guidance_interval_min: Any,
+    guidance_interval_max: Any,
+    noise_scale: Any,
+) -> tuple[str, int, int, float, int, int, float, float, float, float, float]:
+    return (
+        str(class_label or "").strip(),
+        _to_int(seed, default=42),
+        _to_int(num_steps, default=50),
+        _to_float(guidance_scale, default=4.0),
+        _to_int(height, default=256),
+        _to_int(width, default=256),
+        _to_float(guidance_interval_start, default=0.0),
+        _to_float(guidance_interval_end, default=0.7),
+        _to_float(guidance_interval_min, default=0.2),
+        _to_float(guidance_interval_max, default=0.6),
+        _to_float(noise_scale, default=4.0),
+    )
+
+
 def _gpu_duration(
     model_label: str,
     num_steps: int,
@@ -127,6 +156,7 @@ def _gpu_duration(
     noise_scale: float,
 ) -> int:
     profile = get_profile_by_label(model_label)
+    num_steps = _to_int(num_steps, default=profile.default_steps)
     step_budget = num_steps if not profile.steps_are_list else max(num_steps, 40)
     base = 45 if profile.gpu_size == "large" else 90
     return int(min(300, max(base, step_budget * 0.6 + 30)))
@@ -167,6 +197,32 @@ def _generate_on_gpu(
     guidance_interval_max: float,
     noise_scale: float,
 ):
+    (
+        class_label,
+        seed,
+        num_steps,
+        guidance_scale,
+        height,
+        width,
+        guidance_interval_start,
+        guidance_interval_end,
+        guidance_interval_min,
+        guidance_interval_max,
+        noise_scale,
+    ) = _coerce_inference_inputs(
+        class_label,
+        seed,
+        num_steps,
+        guidance_scale,
+        height,
+        width,
+        guidance_interval_start,
+        guidance_interval_end,
+        guidance_interval_min,
+        guidance_interval_max,
+        noise_scale,
+    )
+
     profile = get_profile_by_label(model_label)
     collection, variant = parse_model_label(model_label)
     if PIPELINE_MANAGER.loaded_label != model_label or PIPELINE_MANAGER.pipe is None:
@@ -228,7 +284,8 @@ def generate(
             noise_scale,
         )
     except Exception as exc:
-        raise gr.Error(f"Generation failed for `{model_label}`: {exc}") from exc
+        detail = traceback.format_exc(limit=6).strip()
+        raise gr.Error(f"Generation failed for `{model_label}`: {exc}\n\n{detail}") from exc
     label = PIPELINE_MANAGER.loaded_label or model_label
     return f"Generated with `{label}`.", image
 

model_loader.py

@@ -170,11 +170,36 @@ class PipelineManager:
 PIPELINE_MANAGER = PipelineManager()
 
 
-def build_inference_steps(profile: ModelProfile, steps: int) -> int | list[int]:
+def _to_int(value: Any, *, default: int = 0) -> int:
+    if value is None:
+        return default
+    if isinstance(value, bool):
+        return int(value)
+    if isinstance(value, (int, float)):
+        return int(value)
+    text = str(value).strip()
+    if not text:
+        return default
+    return int(float(text))
+
+
+def _to_float(value: Any, *, default: float = 0.0) -> float:
+    if value is None:
+        return default
+    if isinstance(value, (int, float)):
+        return float(value)
+    text = str(value).strip()
+    if not text:
+        return default
+    return float(text)
+
+
+def build_inference_steps(profile: ModelProfile, steps: Any) -> int | list[int]:
+    steps = _to_int(steps, default=profile.default_steps)
     if profile.steps_are_list:
         per_stage = max(1, steps // 4)
         return [per_stage, per_stage, per_stage, per_stage]
-    return int(steps)
+    return steps
 
 
 def run_inference(
@@ -189,19 +214,32 @@ def run_inference(
     width: int,
     extra_kwargs: dict[str, Any] | None = None,
 ) -> Any:
-    generator = torch.Generator(device="cuda").manual_seed(int(seed))
+    seed = _to_int(seed, default=profile.default_seed)
+    num_steps = _to_int(num_steps, default=profile.default_steps)
+    guidance_scale = _to_float(guidance_scale, default=profile.default_guidance)
+    height = _to_int(height, default=0)
+    width = _to_int(width, default=0)
+
+    generator = torch.Generator(device="cuda").manual_seed(seed)
     call_kwargs: dict[str, Any] = {
         "num_inference_steps": build_inference_steps(profile, num_steps),
-        "guidance_scale": float(guidance_scale),
+        "guidance_scale": guidance_scale,
         "generator": generator,
     }
     call_kwargs.update(extra_kwargs if extra_kwargs is not None else profile.extra_call_kwargs)
 
-    label = class_label.strip() or profile.default_class_label
-    call_kwargs["class_labels"] = int(label) if label.isdigit() else label
+    label = str(class_label or "").strip() or profile.default_class_label
+    if label.isdigit():
+        call_kwargs["class_labels"] = int(label)
+    elif label.replace(".", "", 1).isdigit():
+        call_kwargs["class_labels"] = int(float(label))
+    else:
+        call_kwargs["class_labels"] = label
 
+    native = profile.infer_resolution()
     if height > 0 and width > 0:
-        call_kwargs["height"] = int(height)
-        call_kwargs["width"] = int(width)
+        if profile.collection != "ADM-diffusers" or height != native or width != native:
+            call_kwargs["height"] = height
+            call_kwargs["width"] = width
 
     return pipe(**call_kwargs).images[0]