Spaces:

akagtag
/

deepdetection

Paused

App Files Files Community

akagtag commited on 29 days ago

Commit

19d9b40

1 Parent(s): 5756499

Fix ZeroGPU startup and local GPU inference path

Browse files

Files changed (9) hide show

modules/m1_lipsync.py +1 -1
modules/m3_sstgnn.py +1 -1
packages.txt +4 -1
src/api/main.py +157 -95
src/engines/coherence/engine.py +11 -2
src/engines/fingerprint/engine.py +11 -2
src/engines/sstgnn/engine.py +10 -1
tests/test_api.py +4 -3
tests/test_zero_gpu_contract.py +3 -3

modules/m1_lipsync.py CHANGED Viewed

@@ -28,7 +28,7 @@ class LipSyncModule:
     def _load_model(self) -> None:
         ckpt_path = hf_hub_download(
-            repo_id="AkshatAgarwal/LipFD-checkpoint",
             filename="ckpt.pth",
             cache_dir=self.cache_dir,
         )

     def _load_model(self) -> None:
         ckpt_path = hf_hub_download(
+            repo_id="akagtag/LipFD-checkpoint",
             filename="ckpt.pth",
             cache_dir=self.cache_dir,
         )

modules/m3_sstgnn.py CHANGED Viewed

@@ -11,7 +11,7 @@ class SSTGNNModule:
         self.load_error = ""
         try:
             ckpt_path = hf_hub_download(
-                repo_id="AkshatAgarwal/SSTGNN-deepfake",
                 filename="sstgnn_best.pt",
                 cache_dir=cache_dir,
             )

         self.load_error = ""
         try:
             ckpt_path = hf_hub_download(
+                repo_id="akagtag/SSTGNN-deepfake",
                 filename="sstgnn_best.pt",
                 cache_dir=cache_dir,
             )

packages.txt CHANGED Viewed

@@ -1,3 +1,6 @@
 ffmpeg
 libsndfile1-dev

 ffmpeg
 libsndfile1-dev
+libgles2
+libegl1
+libgl1
+libglib2.0-0

src/api/main.py CHANGED Viewed

@@ -14,9 +14,26 @@ import numpy as np
 from dotenv import load_dotenv
 from fastapi import FastAPI, File, HTTPException, UploadFile
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import HTMLResponse, RedirectResponse
 from PIL import ExifTags, Image
 from src.continual.novelty_detector import NoveltyDetector
 from src.continual.registry import GeneratorRegistry
 from src.engines.coherence.engine import CoherenceEngine
@@ -252,8 +269,23 @@ def _model_inventory() -> dict[str, object]:
 @app.get("/", response_class=HTMLResponse)
-async def root() -> RedirectResponse:
-    return RedirectResponse(url="/gradio", status_code=307)
 @app.on_event("startup")
@@ -262,11 +294,6 @@ async def preload() -> None:
         logger.info("Skipping startup preload in test mode")
         return
-    backend = get_inference_backend()
-    if backend in {"hf", "runpod"}:
-        logger.info("Skipping local model preload for backend=%s", backend)
-        return
     logger.info("Preloading models...")
     # Keep model imports/loads sequential to avoid lazy-import race issues.
     await asyncio.to_thread(_fp._ensure)
@@ -275,6 +302,115 @@ async def preload() -> None:
     logger.info("Model preload complete")
 @app.get("/health")
 async def health() -> dict:
     return {
@@ -485,40 +621,12 @@ async def detect_image(file: UploadFile = File(...)) -> DetectionResponse:
         except Exception as exc:
             logger.warning("RunPod image route failed, falling back to local image inference: %s", exc)
-    try:
-        image = Image.open(io.BytesIO(data)).convert("RGB")
-    except Exception as exc:
-        raise HTTPException(status_code=422, detail=f"Could not decode image: {exc}") from exc
-    await _ensure_models_loaded()
-    fp, co, st = await asyncio.gather(
-        asyncio.to_thread(_fp.run, image),
-        asyncio.to_thread(_co.run, image),
-        asyncio.to_thread(_st.run, image),
-    )
-    elapsed_ms = (time.monotonic() - t0) * 1000
-    engine_results = _assign_processing_time([fp, co, st], elapsed_ms)
-    verdict, conf, generator = fuse(engine_results, is_video=False)
-    if _is_test_mode():
-        explanation = _fallback_explanation(verdict, conf, generator)
-    else:
-        explanation = await asyncio.to_thread(explain, verdict, conf, engine_results, generator)
-    response = DetectionResponse(
-        verdict=verdict,
-        confidence=conf,
-        attributed_generator=generator,
-        explanation=explanation,
-        processing_time_ms=elapsed_ms,
-        engine_breakdown=engine_results,
-    )
-    return _apply_metadata_keyword_signal(
-        response,
-        filename=file.filename,
-        metadata_text=metadata_text,
     )
@@ -581,57 +689,11 @@ async def detect_video(file: UploadFile = File(...)) -> DetectionResponse:
         except Exception as exc:
             logger.warning("RunPod route failed, falling back to local video inference: %s", exc)
-    with tempfile.NamedTemporaryFile(
-        suffix=_video_temp_suffix(file.content_type, file.filename),
-        delete=False,
-    ) as tmp:
-        tmp.write(data)
-        tmp_path = tmp.name
-    try:
-        try:
-            frames = await asyncio.to_thread(extract_video_frames, tmp_path, MAX_FRAMES)
-        except Exception as exc:
-            raise HTTPException(status_code=422, detail=f"Video decode failed: {exc}") from exc
-        if not frames:
-            raise HTTPException(status_code=422, detail="Could not extract frames")
-        await _ensure_models_loaded()
-        try:
-            fp, co, st = await asyncio.gather(
-                asyncio.to_thread(_fp.run_video, frames),
-                asyncio.to_thread(_co.run_video, frames, tmp_path),
-                asyncio.to_thread(_st.run_video, frames),
-            )
-        except Exception as exc:
-            logger.exception("Video engine inference failed")
-            raise HTTPException(
-                status_code=503,
-                detail=f"Video analysis failed: {type(exc).__name__}: {exc}",
-            ) from exc
-    finally:
-        Path(tmp_path).unlink(missing_ok=True)
-    elapsed_ms = (time.monotonic() - t0) * 1000
-    engine_results = _assign_processing_time([fp, co, st], elapsed_ms)
-    verdict, conf, generator = fuse(engine_results, is_video=True)
-    if _is_test_mode():
-        explanation = _fallback_explanation(verdict, conf, generator)
-    else:
-        explanation = await asyncio.to_thread(explain, verdict, conf, engine_results, generator)
-    response = DetectionResponse(
-        verdict=verdict,
-        confidence=conf,
-        attributed_generator=generator,
-        explanation=explanation,
-        processing_time_ms=elapsed_ms,
-        engine_breakdown=engine_results,
-    )
-    return _apply_metadata_keyword_signal(
-        response,
-        filename=file.filename,
-        metadata_text=metadata_text,
     )

 from dotenv import load_dotenv
 from fastapi import FastAPI, File, HTTPException, UploadFile
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse
 from PIL import ExifTags, Image
+try:
+    import spaces  # type: ignore
+except ImportError:
+    spaces = None
+if spaces is None or not hasattr(spaces, "GPU"):
+    class _SpacesShim:
+        @staticmethod
+        def GPU(*args, **kwargs):
+            def decorator(fn):
+                return fn
+            return decorator
+    spaces = _SpacesShim()
 from src.continual.novelty_detector import NoveltyDetector
 from src.continual.registry import GeneratorRegistry
 from src.engines.coherence.engine import CoherenceEngine
 @app.get("/", response_class=HTMLResponse)
+async def root() -> HTMLResponse:
+    return HTMLResponse(
+        """
+        <html>
+          <head><title>GenAI-DeepDetect</title></head>
+          <body style="font-family: sans-serif; max-width: 720px; margin: 48px auto; line-height: 1.5;">
+            <h1>GenAI-DeepDetect</h1>
+            <p>The FastAPI backend is running.</p>
+            <ul>
+              <li><a href="/gradio">Open Gradio UI</a></li>
+              <li><a href="/docs">Open API Docs</a></li>
+              <li><a href="/health">Health Check</a></li>
+            </ul>
+          </body>
+        </html>
+        """
+    )
 @app.on_event("startup")
         logger.info("Skipping startup preload in test mode")
         return
     logger.info("Preloading models...")
     # Keep model imports/loads sequential to avoid lazy-import race issues.
     await asyncio.to_thread(_fp._ensure)
     logger.info("Model preload complete")
+@spaces.GPU(duration=120)
+def _local_detect_image_sync(
+    data: bytes,
+    filename: str | None,
+    metadata_text: str,
+    elapsed_start: float,
+) -> DetectionResponse:
+    try:
+        image = Image.open(io.BytesIO(data)).convert("RGB")
+    except Exception as exc:
+        raise HTTPException(status_code=422, detail=f"Could not decode image: {exc}") from exc
+    _fp._ensure()
+    _co._ensure()
+    _st._ensure()
+    fp = _fp.run(image)
+    co = _co.run(image)
+    st = _st.run(image)
+    elapsed_ms = (time.monotonic() - elapsed_start) * 1000
+    engine_results = _assign_processing_time([fp, co, st], elapsed_ms)
+    verdict, conf, generator = fuse(engine_results, is_video=False)
+    if _is_test_mode():
+        explanation = _fallback_explanation(verdict, conf, generator)
+    else:
+        explanation = explain(verdict, conf, engine_results, generator)
+    response = DetectionResponse(
+        verdict=verdict,
+        confidence=conf,
+        attributed_generator=generator,
+        explanation=explanation,
+        processing_time_ms=elapsed_ms,
+        engine_breakdown=engine_results,
+    )
+    return _apply_metadata_keyword_signal(
+        response,
+        filename=filename,
+        metadata_text=metadata_text,
+    )
+@spaces.GPU(duration=180)
+def _local_detect_video_sync(
+    data: bytes,
+    content_type: str | None,
+    filename: str | None,
+    metadata_text: str,
+    elapsed_start: float,
+) -> DetectionResponse:
+    with tempfile.NamedTemporaryFile(
+        suffix=_video_temp_suffix(content_type, filename),
+        delete=False,
+    ) as tmp:
+        tmp.write(data)
+        tmp_path = tmp.name
+    try:
+        try:
+            frames = extract_video_frames(tmp_path, MAX_FRAMES)
+        except Exception as exc:
+            raise HTTPException(status_code=422, detail=f"Video decode failed: {exc}") from exc
+        if not frames:
+            raise HTTPException(status_code=422, detail="Could not extract frames")
+        _fp._ensure()
+        _co._ensure()
+        _st._ensure()
+        try:
+            fp = _fp.run_video(frames)
+            co = _co.run_video(frames, tmp_path)
+            st = _st.run_video(frames)
+        except Exception as exc:
+            logger.exception("Video engine inference failed")
+            raise HTTPException(
+                status_code=503,
+                detail=f"Video analysis failed: {type(exc).__name__}: {exc}",
+            ) from exc
+    finally:
+        Path(tmp_path).unlink(missing_ok=True)
+    elapsed_ms = (time.monotonic() - elapsed_start) * 1000
+    engine_results = _assign_processing_time([fp, co, st], elapsed_ms)
+    verdict, conf, generator = fuse(engine_results, is_video=True)
+    if _is_test_mode():
+        explanation = _fallback_explanation(verdict, conf, generator)
+    else:
+        explanation = explain(verdict, conf, engine_results, generator)
+    response = DetectionResponse(
+        verdict=verdict,
+        confidence=conf,
+        attributed_generator=generator,
+        explanation=explanation,
+        processing_time_ms=elapsed_ms,
+        engine_breakdown=engine_results,
+    )
+    return _apply_metadata_keyword_signal(
+        response,
+        filename=filename,
+        metadata_text=metadata_text,
+    )
 @app.get("/health")
 async def health() -> dict:
     return {
         except Exception as exc:
             logger.warning("RunPod image route failed, falling back to local image inference: %s", exc)
+    return await asyncio.to_thread(
+        _local_detect_image_sync,
+        data,
+        file.filename,
+        metadata_text,
+        t0,
     )
         except Exception as exc:
             logger.warning("RunPod route failed, falling back to local video inference: %s", exc)
+    return await asyncio.to_thread(
+        _local_detect_video_sync,
+        data,
+        file.content_type,
+        file.filename,
+        metadata_text,
+        t0,
     )

src/engines/coherence/engine.py CHANGED Viewed

@@ -13,6 +13,11 @@ from typing import Optional
 import numpy as np
 from PIL import Image
 from src.types import EngineResult
 logger = logging.getLogger(__name__)
@@ -28,6 +33,10 @@ _resnet_fallback = None   # torchvision ResNet-18 used when facenet-pytorch unav
 _transform_fallback = None
 def _skip_model_loads() -> bool:
     return os.environ.get("GENAI_SKIP_MODEL_LOAD", "").strip().lower() in {
         "1",
@@ -130,7 +139,7 @@ def _load() -> None:
         import torch  # type: ignore
         _torch = torch
-        _device = "cuda" if torch.cuda.is_available() else "cpu"
         logger.info("  Coherence device: %s", _device)
         from facenet_pytorch import InceptionResnetV1, MTCNN  # type: ignore
@@ -150,7 +159,7 @@ def _load() -> None:
             import torchvision.transforms as tv_transforms  # type: ignore
             _torch = torch
-            _device = "cuda" if torch.cuda.is_available() else "cpu"
             model = tv_models.resnet18(weights=tv_models.ResNet18_Weights.DEFAULT)
             model.fc = torch.nn.Identity()  # strip classifier → 512-d embedding

 import numpy as np
 from PIL import Image
+try:
+    import spaces  # type: ignore  # noqa: F401
+except ImportError:
+    spaces = None
 from src.types import EngineResult
 logger = logging.getLogger(__name__)
 _transform_fallback = None
+def _prefer_cuda(torch_module) -> bool:
+    return torch_module.cuda.is_available() or os.environ.get("SPACE_ID", "").startswith("akagtag/")
 def _skip_model_loads() -> bool:
     return os.environ.get("GENAI_SKIP_MODEL_LOAD", "").strip().lower() in {
         "1",
         import torch  # type: ignore
         _torch = torch
+        _device = "cuda" if _prefer_cuda(torch) else "cpu"
         logger.info("  Coherence device: %s", _device)
         from facenet_pytorch import InceptionResnetV1, MTCNN  # type: ignore
             import torchvision.transforms as tv_transforms  # type: ignore
             _torch = torch
+            _device = "cuda" if _prefer_cuda(torch) else "cpu"
             model = tv_models.resnet18(weights=tv_models.ResNet18_Weights.DEFAULT)
             model.fc = torch.nn.Identity()  # strip classifier → 512-d embedding

src/engines/fingerprint/engine.py CHANGED Viewed

@@ -17,13 +17,22 @@ import torch
 from PIL import Image
 from transformers import CLIPModel, CLIPProcessor
 from src.types import EngineResult
 logger = logging.getLogger(__name__)
 CACHE = os.environ.get("MODEL_CACHE_DIR", "/tmp/models")
-# GPU device selection — A100 / any CUDA GPU if available, else CPU
-_DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 _PIPELINE_DEVICE = 0 if _DEVICE == "cuda" else -1  # HF pipeline convention
 DETECTOR_CANDIDATES = [

 from PIL import Image
 from transformers import CLIPModel, CLIPProcessor
+try:
+    import spaces  # type: ignore  # noqa: F401
+except ImportError:
+    spaces = None
 from src.types import EngineResult
 logger = logging.getLogger(__name__)
 CACHE = os.environ.get("MODEL_CACHE_DIR", "/tmp/models")
+def _prefer_cuda() -> bool:
+    return torch.cuda.is_available() or os.environ.get("SPACE_ID", "").startswith("akagtag/")
+# GPU device selection — ZeroGPU emulates CUDA outside the decorated section.
+_DEVICE = "cuda" if _prefer_cuda() else "cpu"
 _PIPELINE_DEVICE = 0 if _DEVICE == "cuda" else -1  # HF pipeline convention
 DETECTOR_CANDIDATES = [

src/engines/sstgnn/engine.py CHANGED Viewed

@@ -12,13 +12,22 @@ import numpy as np
 import torch
 from PIL import Image
 from src.types import EngineResult
 logger = logging.getLogger(__name__)
 CACHE = os.environ.get("MODEL_CACHE_DIR", "/tmp/models")
 # GPU device selection
-_DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 _PIPELINE_DEVICE = 0 if _DEVICE == "cuda" else -1  # HF pipeline convention
 _lock = threading.Lock()

 import torch
 from PIL import Image
+try:
+    import spaces  # type: ignore  # noqa: F401
+except ImportError:
+    spaces = None
 from src.types import EngineResult
 logger = logging.getLogger(__name__)
 CACHE = os.environ.get("MODEL_CACHE_DIR", "/tmp/models")
+def _prefer_cuda() -> bool:
+    return torch.cuda.is_available() or os.environ.get("SPACE_ID", "").startswith("akagtag/")
 # GPU device selection
+_DEVICE = "cuda" if _prefer_cuda() else "cpu"
 _PIPELINE_DEVICE = 0 if _DEVICE == "cuda" else -1  # HF pipeline convention
 _lock = threading.Lock()

tests/test_api.py CHANGED Viewed

@@ -51,9 +51,10 @@ def test_health_models_returns_inventory(client):
 # ── GET / ─────────────────────────────────────────────────────────────────────
 def test_root_returns_html(client):
-    r = client.get("/", follow_redirects=False)
-    assert r.status_code == 307
-    assert r.headers["location"] == "/gradio"
 # ── POST /detect/image ────────────────────────────────────────────────────────

 # ── GET / ─────────────────────────────────────────────────────────────────────
 def test_root_returns_html(client):
+    r = client.get("/")
+    assert r.status_code == 200
+    assert "text/html" in r.headers["content-type"]
+    assert "Open Gradio UI" in r.text
 # ── POST /detect/image ────────────────────────────────────────────────────────

tests/test_zero_gpu_contract.py CHANGED Viewed

@@ -40,12 +40,12 @@ def test_app_mounts_gradio_onto_fastapi():
     assert 'uvicorn.run(app, host="0.0.0.0", port=7860, workers=1)' in source
-def test_api_root_redirects_to_gradio():
     source = (ROOT / "src" / "api" / "main.py").read_text(encoding="utf-8")
     tree = ast.parse(source)
-    assert "RedirectResponse" in source
-    assert 'return RedirectResponse(url="/gradio", status_code=307)' in source
     assert any(
         isinstance(node, ast.AsyncFunctionDef) and node.name == "root"
         for node in tree.body

     assert 'uvicorn.run(app, host="0.0.0.0", port=7860, workers=1)' in source
+def test_api_root_serves_html_landing_page():
     source = (ROOT / "src" / "api" / "main.py").read_text(encoding="utf-8")
     tree = ast.parse(source)
+    assert "HTMLResponse" in source
+    assert 'Open Gradio UI' in source
     assert any(
         isinstance(node, ast.AsyncFunctionDef) and node.name == "root"
         for node in tree.body