update

README.md

@@ -7,7 +7,6 @@ sdk_version: 5.31.0
 app_file: src/app.py
 tags:
 - gradio
-- zero-gpu
 pinned: true
 license: apache-2.0
 emoji: 🚀

requirements.txt

@@ -1,6 +1,5 @@
 # requirements.txt
 gradio==5.31.0
-spaces>=0.30.0
 pandas==2.3.1
 torch==2.8.0
 numpy==2.1.3

src/app.py

@@ -1,10 +1,9 @@
 """
 DetectGPTPro — Gradio front end for AdaDetectGPT.
 
-Migrated from Streamlit so the Space can run on Hugging Face's ZeroGPU
-(dynamic, pay-per-call GPU allocation, which is only available to Gradio SDK
-Spaces). All detection logic still lives in FineTune/model.py, feedback.py,
-and stats.py, unchanged — this file only rebuilds the UI layer.
+Runs on plain CPU (HF Spaces "CPU basic" tier — ZeroGPU requires a PRO
+account). All detection logic still lives in FineTune/model.py,
+feedback.py, and stats.py, unchanged — this file only builds the UI layer.
 
 See streamlit_backup/ (repo root) for the original Streamlit app.
 """
@@ -34,45 +33,18 @@ from FineTune.model import ComputeStat
 from feedback import FeedbackManager
 from stats import StatsManager
 
-# -----------------------------------------------------------------------
-# ZeroGPU support
-# -----------------------------------------------------------------------
-# `spaces` is preinstalled on every Gradio-SDK HF Space and is what lets a
-# Space request/release a GPU per call. It's a no-op outside ZeroGPU
-# hardware, but it isn't installed at all when running locally without the
-# `spaces` package — so fall back to a plain no-op decorator in that case.
-try:
-    import spaces
-
-    ZERO_GPU_AVAILABLE = True
-except ImportError:
-    ZERO_GPU_AVAILABLE = False
-
-    class _SpacesShim:
-        """Stand-in for the `spaces` module when developing outside HF Spaces."""
-
-        @staticmethod
-        def GPU(func=None, **_kwargs):
-            if func is not None:
-                return func
-            return lambda f: f
-
-    spaces = _SpacesShim()
-
 
 def resolve_device() -> str:
     """Pick an inference device, in priority order:
 
     1. `MODEL_DEVICE` env var, if the user wants to force one.
-    2. 'cuda' on a ZeroGPU Space (the `spaces` package manages the virtual device).
-    3. 'cpu' on any other HF Space (e.g. a plain CPU-tier deployment).
-    4. 'mps' / 'cpu' for local development on Apple Silicon / everything else.
+    2. 'cpu' on the Space (this deployment targets HF's free "CPU basic"
+       tier — ZeroGPU needs a PRO account, so we don't attempt it).
+    3. 'mps' / 'cpu' for local development on Apple Silicon / everything else.
     """
     explicit = os.environ.get("MODEL_DEVICE")
     if explicit:
         return explicit
-    if ZERO_GPU_AVAILABLE and os.environ.get("SPACE_ID"):
-        return "cuda"
     if os.environ.get("SPACE_ID"):
         return "cpu"
     try:
@@ -115,8 +87,7 @@ FEEDBACK_DATASET_ID = os.environ.get("FEEDBACK_DATASET_ID", f"{ACCOUNT_NAME}/use
 # process startup, same lifetime as st.cache_resource gave us before).
 # -----------------------------------------------------------------------
 def load_model():
-    print(f"🔄 Loading model on device='{MODEL_CONFIG['device']}' "
-          f"(ZeroGPU {'enabled' if ZERO_GPU_AVAILABLE else 'unavailable'})...")
+    print(f"🔄 Loading model on device='{MODEL_CONFIG['device']}'...")
     model = ComputeStat.from_pretrained(
         MODEL_CONFIG["from_pretrained"],
         MODEL_CONFIG["base_model"],
@@ -148,21 +119,10 @@ stats_manager = StatsManager(
 
 
 # -----------------------------------------------------------------------
-# Inference — isolated in its own function and GPU-decorated so ZeroGPU
-# can allocate a GPU just for the duration of this call and release it
-# right after.
-#
-# `duration` reserves that many seconds of ZeroGPU quota *up front* for
-# every call, regardless of how long the call actually takes — so it
-# should track real measured inference time, not just be left generous.
-# Override with the ZERO_GPU_DURATION env var once you've profiled a
-# typical request (Settings on the Space, or locally via `time.time()`
-# around `_run_inference`).
+# Inference — isolated in its own function so it's easy to time and to
+# swap back to a GPU-decorated version later if this ever moves off CPU
+# basic hardware.
 # -----------------------------------------------------------------------
-ZERO_GPU_DURATION = int(os.environ.get("ZERO_GPU_DURATION", "60"))
-
-
-@spaces.GPU(duration=ZERO_GPU_DURATION)
 def _run_inference(text: str, domain: str):
     crit, p_value = model.compute_p_value(text, domain)
     if hasattr(crit, "item"):
@@ -172,11 +132,6 @@ def _run_inference(text: str, domain: str):
     return crit, p_value
 
 
-def _is_zero_gpu_quota_error(exc: Exception) -> bool:
-    message = str(exc).lower()
-    return "quota" in message and "gpu" in message
-
-
 def format_conclusion(p_value: float, alpha: float) -> str:
     """Build the conclusion as a framed HTML card (rendered inside gr.Markdown,
     which passes raw HTML through) so the verdict stands out instead of
@@ -243,11 +198,6 @@ def run_detection(text: str, domain: str, alpha: float):
     except gr.Error:
         raise
     except Exception as e:  # noqa: BLE001 — surfaced to the user via gr.Error
-        if _is_zero_gpu_quota_error(e):
-            raise gr.Error(
-                "⏳ This Space's free GPU quota is used up for now — it resets "
-                "on a rolling basis, so please try again shortly."
-            )
         raise gr.Error(f"Detection failed: {e}")
     elapsed_time = time.time() - start_time