add gradio ui with seperate frontent/backend

pyproject_amd.toml

@@ -0,0 +1,69 @@
+[project]
+name = "sharp"
+version = "0.1"
+description = "Inference/Network/Model code for SHARP view synthesis model."
+readme = "README.md"
+dependencies = [
+  "click",
+  "gsplat",
+  "imageio[ffmpeg]",
+  "matplotlib",
+  "pillow-heif",
+  "plyfile",
+  "scipy",
+  "timm",
+  "torch",
+  "torchvision",
+]
+
+[project.scripts]
+sharp = "sharp.cli:main_cli"
+
+[project.urls]
+Homepage = "https://github.com/apple/ml-sharp"
+Repository = "https://github.com/apple/ml-sharp"
+
+[build-system]
+requires = ["setuptools", "setuptools-scm"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pyright]
+include = ["src"]
+exclude = [
+    "**/node_modules",
+    "**/__pycache__",
+]
+pythonVersion = "3.12"
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = "-ra -q"
+testpaths = [
+    "tests"
+]
+filterwarnings = [
+    "ignore::DeprecationWarning"
+]
+
+[tool.lint.per-file-ignores]
+"__init__.py" = ["F401", "D100", "D104"]
+
+[tool.ruff]
+line-length = 100
+lint.select = ["E", "F", "D", "I"]
+lint.ignore = ["D100", "D105",
+  # Imperative mood of docstring.
+  "D401",
+]
+extend-exclude = [
+    "*external*",
+    "third_party",
+]
+src = ["sharp"]
+target-version = "py39"
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"

requirements.txt

@@ -1,172 +1,6 @@
-# This file was autogenerated by uv via the following command:
-#    uv pip compile requirements.in -o requirements.txt --universal
--e .
-    # via -r requirements.in
-certifi==2025.8.3
-    # via requests
-charset-normalizer==3.4.3
-    # via requests
-click==8.3.0
-    # via sharp
-colorama==0.4.6 ; sys_platform == 'win32'
-    # via
-    #   click
-    #   tqdm
-contourpy==1.3.3
-    # via matplotlib
-cycler==0.12.1
-    # via matplotlib
-filelock==3.19.1
-    # via
-    #   huggingface-hub
-    #   torch
-fonttools==4.61.0
-    # via matplotlib
-fsspec==2025.9.0
-    # via
-    #   huggingface-hub
-    #   torch
-gsplat==1.5.3
-    # via sharp
-hf-xet==1.1.10 ; platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'
-    # via huggingface-hub
-huggingface-hub==0.35.3
-    # via timm
-idna==3.10
-    # via requests
-imageio==2.37.0
-    # via sharp
-imageio-ffmpeg==0.6.0
-    # via imageio
-jaxtyping==0.3.3
-    # via gsplat
-jinja2==3.1.6
-    # via torch
-kiwisolver==1.4.9
-    # via matplotlib
-markdown-it-py==4.0.0
-    # via rich
-markupsafe==3.0.3
-    # via jinja2
-matplotlib==3.10.6
-    # via sharp
-mdurl==0.1.2
-    # via markdown-it-py
-mpmath==1.3.0
-    # via sympy
-networkx==3.5
-    # via torch
-ninja==1.13.0
-    # via gsplat
-numpy==2.3.3
-    # via
-    #   contourpy
-    #   gsplat
-    #   imageio
-    #   matplotlib
-    #   plyfile
-    #   scipy
-    #   torchvision
-nvidia-cublas-cu12==12.8.4.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
-    # via
-    #   nvidia-cudnn-cu12
-    #   nvidia-cusolver-cu12
-    #   torch
-nvidia-cuda-cupti-cu12==12.8.90 ; platform_machine == 'x86_64' and sys_platform == 'linux'
-    # via torch
-nvidia-cuda-nvrtc-cu12==12.8.93 ; platform_machine == 'x86_64' and sys_platform == 'linux'
-    # via torch
-nvidia-cuda-runtime-cu12==12.8.90 ; platform_machine == 'x86_64' and sys_platform == 'linux'
-    # via torch
-nvidia-cudnn-cu12==9.10.2.21 ; platform_machine == 'x86_64' and sys_platform == 'linux'
-    # via torch
-nvidia-cufft-cu12==11.3.3.83 ; platform_machine == 'x86_64' and sys_platform == 'linux'
-    # via torch
-nvidia-cufile-cu12==1.13.1.3 ; platform_machine == 'x86_64' and sys_platform == 'linux'
-    # via torch
-nvidia-curand-cu12==10.3.9.90 ; platform_machine == 'x86_64' and sys_platform == 'linux'
-    # via torch
-nvidia-cusolver-cu12==11.7.3.90 ; platform_machine == 'x86_64' and sys_platform == 'linux'
-    # via torch
-nvidia-cusparse-cu12==12.5.8.93 ; platform_machine == 'x86_64' and sys_platform == 'linux'
-    # via
-    #   nvidia-cusolver-cu12
-    #   torch
-nvidia-cusparselt-cu12==0.7.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
-    # via torch
-nvidia-nccl-cu12==2.27.3 ; platform_machine == 'x86_64' and sys_platform == 'linux'
-    # via torch
-nvidia-nvjitlink-cu12==12.8.93 ; platform_machine == 'x86_64' and sys_platform == 'linux'
-    # via
-    #   nvidia-cufft-cu12
-    #   nvidia-cusolver-cu12
-    #   nvidia-cusparse-cu12
-    #   torch
-nvidia-nvtx-cu12==12.8.90 ; platform_machine == 'x86_64' and sys_platform == 'linux'
-    # via torch
-packaging==25.0
-    # via
-    #   huggingface-hub
-    #   matplotlib
-pillow==11.3.0
-    # via
-    #   imageio
-    #   matplotlib
-    #   pillow-heif
-    #   torchvision
-pillow-heif==1.1.1
-    # via sharp
-plyfile==1.1.2
-    # via sharp
-psutil==7.1.0
-    # via imageio
-pygments==2.19.2
-    # via rich
-pyparsing==3.2.5
-    # via matplotlib
-python-dateutil==2.9.0.post0
-    # via matplotlib
-pyyaml==6.0.3
-    # via
-    #   huggingface-hub
-    #   timm
+# Front-end requirements for Hugging Face Spaces (Gradio UI)
+# Deploy the Gradio app in src/sharp/web/app.py using these minimal dependencies.
+# Install with: pip install -r requirements.txt
+
+gradio==4.44.0
 requests==2.32.5
-    # via huggingface-hub
-rich==14.1.0
-    # via gsplat
-safetensors==0.6.2
-    # via timm
-scipy==1.16.2
-    # via sharp
-setuptools==80.9.0
-    # via
-    #   torch
-    #   triton
-six==1.17.0
-    # via python-dateutil
-sympy==1.14.0
-    # via torch
-timm==1.0.20
-    # via sharp
-torch==2.8.0
-    # via
-    #   gsplat
-    #   sharp
-    #   timm
-    #   torchvision
-torchvision==0.23.0
-    # via
-    #   sharp
-    #   timm
-tqdm==4.67.1
-    # via huggingface-hub
-triton==3.4.0 ; platform_machine == 'x86_64' and sys_platform == 'linux'
-    # via torch
-typing-extensions==4.15.0
-    # via
-    #   huggingface-hub
-    #   torch
-urllib3==2.6.0
-    # via requests
-wadler-lindig==0.1.7
-    # via jaxtyping

requirements_api.txt

@@ -0,0 +1,118 @@
+
+# This file was autogenerated by uv via the following command:
+#    uv pip compile requirements.in -o requirements.txt --universal
+-e .
+    # via -r requirements.in
+certifi==2025.8.3
+    # via requests
+charset-normalizer==3.4.3
+    # via requests
+click==8.3.0
+    # via sharp
+colorama==0.4.6 ; sys_platform == 'win32'
+    # via
+    #   click
+    #   tqdm
+contourpy==1.3.3
+    # via matplotlib
+cycler==0.12.1
+    # via matplotlib
+filelock==3.19.1
+    # via
+    #   huggingface-hub
+    #   torch
+fonttools==4.61.0
+    # via matplotlib
+fsspec==2025.9.0
+    # via
+    #   huggingface-hub
+    #   torch
+# gsplat==1.5.3
+    # via sharp
+hf-xet==1.1.10 ; platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'
+    # via huggingface-hub
+huggingface-hub==0.35.3
+    # via timm
+idna==3.10
+    # via requests
+imageio==2.37.0
+    # via sharp
+imageio-ffmpeg==0.6.0
+    # via imageio
+jaxtyping==0.3.3
+    # via gsplat
+jinja2==3.1.6
+    # via torch
+kiwisolver==1.4.9
+    # via matplotlib
+markdown-it-py==4.0.0
+    # via rich
+markupsafe==3.0.3
+    # via jinja2
+matplotlib==3.10.6
+    # via sharp
+mdurl==0.1.2
+    # via markdown-it-py
+mpmath==1.3.0
+    # via sympy
+networkx==3.5
+    # via torch
+ninja==1.13.0
+    # via gsplat
+# numpy==2.3.3
+numpy<2
+packaging==25.0
+    # via
+    #   huggingface-hub
+    #   matplotlib
+pillow==11.3.0
+    # via
+    #   imageio
+    #   matplotlib
+    #   pillow-heif
+    #   torchvision
+pillow-heif==1.1.1
+    # via sharp
+plyfile==1.1.2
+    # via sharp
+psutil==7.1.0
+    # via imageio
+pygments==2.19.2
+    # via rich
+pyparsing==3.2.5
+    # via matplotlib
+python-dateutil==2.9.0.post0
+    # via matplotlib
+pyyaml==6.0.3
+    # via
+    #   huggingface-hub
+    #   timm
+requests==2.32.5
+    # via huggingface-hub
+rich==14.1.0
+    # via gsplat
+safetensors==0.6.2
+    # via timm
+scipy==1.16.2
+    # via sharp
+setuptools==80.9.0
+    # via
+    #   torch
+    #   triton
+six==1.17.0
+    # via python-dateutil
+sympy==1.14.0
+    # via torch
+timm==1.0.20
+    # via sharp
+tqdm==4.67.1
+    # via huggingface-hub
+typing-extensions
+urllib3==2.6.0
+    # via requests
+wadler-lindig==0.1.7
+    # via jaxtyping
+# Backend API server runtime deps
+fastapi
+uvicorn[standard]
+python-multipart

src/sharp/web/README.md

@@ -1,33 +1,101 @@
-# Sharp Web Interface
+# SHARP Web: Frontend (Gradio) + Backend (FastAPI)
 
-This is a web interface for the Sharp 3D prediction model.
+This directory provides a separated deployment:
+- Backend API (`api_server.py`) runs on a GPU cloud with FastAPI
+- Frontend UI (`app.py`) runs on Hugging Face Spaces with Gradio
 
-## Prerequisites
+The UI calls the API via HTTP; the API performs model inference and returns PLY results.
 
-Make sure you have the `sharp` package installed (see root README).
-Install the web dependencies:
+## Repository Layout
 
+- `src/sharp/web/api_server.py` — FastAPI backend hosting inference endpoints
+- `src/sharp/web/app.py` — Gradio frontend calling the backend
+- `requirements_api.txt` — Backend dependencies (GPU cloud)
+- `requirements.txt` — Frontend dependencies (HF Spaces)
+
+## Backend (GPU Cloud)
+
+### Install
+
+On your GPU cloud instance:
 ```bash
-pip install -r requirements.txt
+# From repository root
+pip install -r requirements_api.txt
 ```
 
-## Running the Server
+Notes:
+- Ensure CUDA is available if using NVIDIA GPUs. The Torch version in `requirements_api.txt` is compiled for CUDA 12 on Linux.
+- On macOS, MPS (Apple Silicon) may be detected; otherwise CPU fallback is used.
+
+### Run
+
+From repository root:
+```bash
+python src/sharp/web/api_server.py
+```
+or with Uvicorn:
+```bash
+uvicorn src.sharp.web.api_server:app --host 0.0.0.0 --port 8000
+```
+
+### Endpoints
+
+- `GET /health` — Basic health check, device info, and model-loaded flag
+- `POST /predict` — Multipart upload of one or more images (`files` field); returns JSON with per-image metadata and PLY contents base64-encoded
+- `POST /predict/download` — Multipart upload of one or more images; returns a ZIP stream containing PLY files
+
+CORS is enabled by default to allow calls from the Hugging Face Space. For production, set `allow_origins` to your specific Space domain.
 
-Run the following command from the `web` directory:
+## Frontend (Hugging Face Spaces)
 
+### Install
+
+On HF Spaces:
 ```bash
-python app.py
+pip install -r requirements.txt
 ```
+This installs only Gradio and Requests.
 
-Or using uvicorn directly:
+### Configure
 
+Set environment variable `API_BASE_URL` in your Space to point to the public backend URL, for example:
+```
+API_BASE_URL=https://your-api.example.com
+```
+If running locally for testing, `API_BASE_URL` defaults to `http://localhost:8000`.
+
+### Run
+
+Locally:
 ```bash
-uvicorn app:app --reload --host 0.0.0.0 --port 8000
+python src/sharp/web/app.py
 ```
+Gradio will start on port `7860` by default (configured to `0.0.0.0` in the script).
+
+On HF Spaces, simply setting the Space’s “Run” command to `python src/sharp/web/app.py` is sufficient.
+
+### Usage (Frontend)
+
+- Single Image tab: upload one image and click Predict to download its PLY.
+- Batch tab: upload multiple images and click Predict Batch to download a ZIP containing PLY files.
+- The frontend calls the backend `POST /predict` and assembles results for user download.
+
+## Quick Local Test
+
+1. Start backend:
+   ```bash
+   uvicorn src.sharp.web.api_server:app --host 0.0.0.0 --port 8000
+   ```
+
+2. Start frontend (in another terminal):
+   ```bash
+   API_BASE_URL=http://localhost:8000 python src/sharp/web/app.py
+   ```
+
+3. Open the Gradio UI (http://localhost:7860), upload images, and verify outputs.
 
-## Usage
+## Notes & Troubleshooting
 
-1. Open your browser and navigate to `http://localhost:8000`.
-2. Drag and drop images or click to select them.
-3. Click "Predict 3D Gaussians".
-4. A zip file containing the resulting `.ply` files will be downloaded automatically.
+- If imports like `fastapi` or `gradio` show unresolved in your IDE, ensure the correct environment is selected and dependencies installed via the respective requirements file.
+- Network access from HF Spaces to the GPU API must be allowed; ensure your API endpoint is accessible over HTTPS where possible.
+- For security, consider locking down CORS to your Space origin and adding authentication (e.g., an API key header) if needed.

src/sharp/web/api_server.py

@@ -0,0 +1,168 @@
+import sys
+import logging
+import shutil
+import tempfile
+import zipfile
+import io as python_io
+import base64
+from pathlib import Path
+
+from fastapi import FastAPI, UploadFile, File
+from fastapi.responses import StreamingResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import torch
+
+# Ensure we can import the project package: add top-level 'src' to sys.path
+# This file resides at: <repo_root>/src/sharp/web/api_server.py
+# Path(__file__).parents[2] == <repo_root>/src
+sys.path.append(str(Path(__file__).parents[2]))
+
+from sharp.models import PredictorParams, RGBGaussianPredictor, create_predictor
+from sharp.utils import io as sharp_io
+from sharp.utils.gaussians import save_ply
+from sharp.cli.predict import predict_image, DEFAULT_MODEL_URL
+
+logging.basicConfig(level=logging.INFO)
+LOGGER = logging.getLogger("sharp.api")
+
+app = FastAPI()
+
+# CORS - allow HF Spaces frontend to call this API.
+# Consider tightening allow_origins to your Space domain for production.
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+predictor: RGBGaussianPredictor | None = None
+device: torch.device | None = None
+
+
+@app.on_event("startup")
+async def startup_event():
+    global predictor, device
+    try:
+        device_str = (
+            "cuda"
+            if torch.cuda.is_available()
+            else ("mps" if torch.backends.mps.is_available() else "cpu")
+        )
+        device = torch.device(device_str)
+        LOGGER.info(f"Using device: {device}")
+
+        LOGGER.info("Loading SHARP model state dict...")
+        state_dict = torch.hub.load_state_dict_from_url(
+            DEFAULT_MODEL_URL, progress=True, map_location=device
+        )
+
+        predictor = create_predictor(PredictorParams())
+        predictor.load_state_dict(state_dict)
+        predictor.eval()
+        predictor.to(device)
+        LOGGER.info("Model loaded and ready.")
+    except Exception as e:
+        LOGGER.exception("Failed during startup/model init: %s", e)
+        # Leave predictor as None; endpoints will return error until fixed.
+
+
+@app.get("/health")
+async def health():
+    return {
+        "status": "ok",
+        "device": str(device) if device else None,
+        "model_loaded": predictor is not None,
+    }
+
+
+@app.post("/predict")
+async def predict(files: list[UploadFile] = File(...)):
+    """Accept images and return JSON with per-image metadata and PLY as base64."""
+    if not predictor:
+        return JSONResponse({"error": "Model not loaded"}, status_code=500)
+
+    results = []
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_path = Path(temp_dir)
+
+        for file in files:
+            try:
+                # Persist upload to temp
+                file_path = temp_path / file.filename
+                with open(file_path, "wb") as buffer:
+                    shutil.copyfileobj(file.file, buffer)
+
+                # Load input and run prediction
+                image, _, f_px = sharp_io.load_rgb(file_path)
+                gaussians = predict_image(predictor, image, f_px, device)
+
+                # Save PLY
+                ply_filename = f"{file_path.stem}.ply"
+                ply_path = temp_path / ply_filename
+                height, width = image.shape[:2]
+                save_ply(gaussians, f_px, (height, width), ply_path)
+
+                # Encode PLY to base64 for transport
+                with open(ply_path, "rb") as f:
+                    ply_data = base64.b64encode(f.read()).decode("utf-8")
+
+                results.append(
+                    {
+                        "filename": file.filename,
+                        "ply_filename": ply_filename,
+                        "ply_data": ply_data,
+                        "width": width,
+                        "height": height,
+                        "focal_length": f_px,
+                    }
+                )
+            except Exception as e:
+                LOGGER.exception("Error processing %s: %s", file.filename, e)
+                results.append({"filename": file.filename, "error": str(e)})
+
+    return {"results": results}
+
+
+@app.post("/predict/download")
+async def predict_download(files: list[UploadFile] = File(...)):
+    """Accept images and return a ZIP of generated PLY files."""
+    if not predictor:
+        return JSONResponse({"error": "Model not loaded"}, status_code=500)
+
+    output_zip = python_io.BytesIO()
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_path = Path(temp_dir)
+        with zipfile.ZipFile(output_zip, "w") as zf:
+            for file in files:
+                try:
+                    file_path = temp_path / file.filename
+                    with open(file_path, "wb") as buffer:
+                        shutil.copyfileobj(file.file, buffer)
+
+                    image, _, f_px = sharp_io.load_rgb(file_path)
+                    gaussians = predict_image(predictor, image, f_px, device)
+
+                    ply_filename = f"{file_path.stem}.ply"
+                    ply_path = temp_path / ply_filename
+                    height, width = image.shape[:2]
+                    save_ply(gaussians, f_px, (height, width), ply_path)
+
+                    zf.write(ply_path, ply_filename)
+                except Exception as e:
+                    LOGGER.exception("Error processing %s: %s", file.filename, e)
+                    continue
+
+    output_zip.seek(0)
+    return StreamingResponse(
+        output_zip,
+        media_type="application/zip",
+        headers={"Content-Disposition": "attachment; filename=gaussians.zip"},
+    )
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8000)

src/sharp/web/app.py

@@ -1,184 +1,125 @@
-import sys
-from pathlib import Path
-import logging
-import shutil
-import tempfile
+import os
+import io
 import zipfile
-import io as python_io
 import base64
+import tempfile
+from pathlib import Path
+
+import requests
+import gradio as gr
+
+# Front-end Gradio app that calls the backend FastAPI service hosted on GPU cloud.
+# Configure the backend base URL through environment variable on Hugging Face Spaces.
+# Example: API_BASE_URL = "https://your-api.example.com"
+API_BASE_URL = os.getenv("API_BASE_URL", "http://localhost:8000")
+
+
+def _files_payload(images):
+    """Prepare multipart/form-data payload for requests.post(files=...)."""
+    files = []
+    for img in images:
+        if img is None:
+            continue
+        # gr.Image(type="filepath") returns a string path
+        if isinstance(img, str):
+            path = img
+            files.append(("files", (Path(path).name, open(path, "rb"), "image/*")))
+            continue
+        # gr.File returns objects with a .name attribute (path), or dict-like in some cases
+        path = getattr(img, "name", None)
+        if path is None and isinstance(img, dict) and "name" in img:
+            path = img["name"]
+        if path:
+            files.append(("files", (Path(path).name, open(path, "rb"), "image/*")))
+    return files
+
+
+def predict_single(image):
+    """Call /predict on backend for a single image and return one PLY file to download."""
+    if not image:
+        return None, "No image provided."
+    files = _files_payload([image])
+    if not files:
+        return None, "Invalid image input."
+
+    try:
+        resp = requests.post(f"{API_BASE_URL}/predict", files=files, timeout=120)
+        resp.raise_for_status()
+        data = resp.json()
+    except Exception as e:
+        return None, f"Backend error: {e}"
+
+    results = data.get("results", [])
+    if not results:
+        return None, "No result."
+    item = results[0]
+    if "error" in item:
+        return None, item["error"]
+
+    # Decode base64 PLY to a temporary file
+    ply_bytes = base64.b64decode(item["ply_data"])
+    with tempfile.NamedTemporaryFile(suffix=".ply", delete=False) as tmpf:
+        tmpf.write(ply_bytes)
+        ply_path = tmpf.name
+
+    meta = f"{item['ply_filename']} ({item['width']}x{item['height']}), f={item['focal_length']:.2f}"
+    return ply_path, meta
+
+
+def predict_batch(images):
+    """Call /predict on backend for multiple images and return a ZIP of PLY files."""
+    if not images:
+        return None, "No images provided."
+    files = _files_payload(images)
+    if not files:
+        return None, "Invalid inputs."
 
-from fastapi import FastAPI, Request, UploadFile, File
-from fastapi.responses import HTMLResponse, StreamingResponse, JSONResponse
-from fastapi.staticfiles import StaticFiles
-from fastapi.templating import Jinja2Templates
-import torch
-import numpy as np
-
-# Add src to path so we can import sharp
-sys.path.append(str(Path(__file__).parent.parent / "src"))
-
-from sharp.models import (
-    PredictorParams,
-    RGBGaussianPredictor,
-    create_predictor,
-)
-from sharp.utils import io as sharp_io
-from sharp.utils.gaussians import save_ply
-from sharp.cli.predict import predict_image, DEFAULT_MODEL_URL
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-LOGGER = logging.getLogger(__name__)
-
-app = FastAPI()
-
-# Mount static files if needed (we created the dir)
-app.mount("/static", StaticFiles(directory=Path(__file__).parent / "static"), name="static")
-
-templates = Jinja2Templates(directory=Path(__file__).parent / "templates")
-
-# Global variables for the model
-predictor: RGBGaussianPredictor = None
-device: torch.device = None
-
-@app.on_event("startup")
-async def startup_event():
-    global predictor, device
-    
-    # Determine device
-    if torch.cuda.is_available():
-        device_str = "cuda"
-    elif torch.mps.is_available():
-        device_str = "mps"
-    else:
-        device_str = "cpu"
-    
-    device = torch.device(device_str)
-    LOGGER.info(f"Using device: {device}")
-
-    # Load model
-    LOGGER.info("Loading model...")
     try:
-        # Try to load from cache or download
-        state_dict = torch.hub.load_state_dict_from_url(DEFAULT_MODEL_URL, progress=True, map_location=device)
-        
-        predictor = create_predictor(PredictorParams())
-        predictor.load_state_dict(state_dict)
-        predictor.eval()
-        predictor.to(device)
-        LOGGER.info("Model loaded successfully.")
+        resp = requests.post(f"{API_BASE_URL}/predict", files=files, timeout=300)
+        resp.raise_for_status()
+        data = resp.json()
     except Exception as e:
-        LOGGER.error(f"Failed to load model: {e}")
-        raise e
-
-@app.get("/", response_class=HTMLResponse)
-async def read_root(request: Request):
-    return templates.TemplateResponse("index.html", {"request": request})
-
-@app.post("/predict")
-async def predict(files: list[UploadFile] = File(...)):
-    """Process images and return PLY data for viewing or download."""
-    if not predictor:
-        return JSONResponse({"error": "Model not loaded"}, status_code=500)
-
-    # Create a temporary directory to process files
-    with tempfile.TemporaryDirectory() as temp_dir:
-        temp_path = Path(temp_dir)
-        results = []
-        
-        for file in files:
-            try:
-                # Save uploaded file
-                file_path = temp_path / file.filename
-                with open(file_path, "wb") as buffer:
-                    shutil.copyfileobj(file.file, buffer)
-                
-                LOGGER.info(f"Processing {file.filename}")
-                
-                # Load image using sharp's IO to get focal length and handle rotation
-                image, _, f_px = sharp_io.load_rgb(file_path)
-                
-                # Run prediction
-                gaussians = predict_image(predictor, image, f_px, device)
-                
-                # Save PLY
-                ply_filename = f"{file_path.stem}.ply"
-                ply_path = temp_path / ply_filename
-                
-                height, width = image.shape[:2]
-                save_ply(gaussians, f_px, (height, width), ply_path)
-                
-                # Read PLY file and encode as base64
-                with open(ply_path, "rb") as f:
-                    ply_data = base64.b64encode(f.read()).decode("utf-8")
-                
-                results.append({
-                    "filename": file.filename,
-                    "ply_filename": ply_filename,
-                    "ply_data": ply_data,
-                    "width": width,
-                    "height": height,
-                    "focal_length": f_px,
-                })
-                
-            except Exception as e:
-                LOGGER.error(f"Error processing {file.filename}: {e}")
-                results.append({
-                    "filename": file.filename,
-                    "error": str(e),
-                })
-        
-        return JSONResponse({"results": results})
-
-
-@app.post("/predict/download")
-async def predict_download(files: list[UploadFile] = File(...)):
-    """Process images and return a ZIP file for download."""
-    if not predictor:
-        return HTMLResponse("Model not loaded", status_code=500)
-
-    # Create a temporary directory to process files
-    with tempfile.TemporaryDirectory() as temp_dir:
-        temp_path = Path(temp_dir)
-        output_zip = python_io.BytesIO()
-        
-        with zipfile.ZipFile(output_zip, "w") as zf:
-            for file in files:
-                try:
-                    # Save uploaded file
-                    file_path = temp_path / file.filename
-                    with open(file_path, "wb") as buffer:
-                        shutil.copyfileobj(file.file, buffer)
-                    
-                    LOGGER.info(f"Processing {file.filename}")
-                    
-                    # Load image using sharp's IO to get focal length and handle rotation
-                    image, _, f_px = sharp_io.load_rgb(file_path)
-                    
-                    # Run prediction
-                    gaussians = predict_image(predictor, image, f_px, device)
-                    
-                    # Save PLY
-                    ply_filename = f"{file_path.stem}.ply"
-                    ply_path = temp_path / ply_filename
-                    
-                    height, width = image.shape[:2]
-                    save_ply(gaussians, f_px, (height, width), ply_path)
-                    
-                    # Add to zip
-                    zf.write(ply_path, ply_filename)
-                    
-                except Exception as e:
-                    LOGGER.error(f"Error processing {file.filename}: {e}")
-                    continue
-        
-        output_zip.seek(0)
-        return StreamingResponse(
-            output_zip, 
-            media_type="application/zip", 
-            headers={"Content-Disposition": "attachment; filename=gaussians.zip"}
+        return None, f"Backend error: {e}"
+
+    results = data.get("results", [])
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w") as zf:
+        metas = []
+        for item in results:
+            if "error" in item:
+                metas.append(f"{item.get('filename', '?')}: ERROR {item['error']}")
+                continue
+            ply_bytes = base64.b64decode(item["ply_data"])
+            zf.writestr(item["ply_filename"], ply_bytes)
+            metas.append(
+                f"{item['filename']} -> {item['ply_filename']} "
+                f"({item['width']}x{item['height']}, f={item['focal_length']:.2f})"
+            )
+    buf.seek(0)
+    return buf, "\n".join(metas)
+
+
+with gr.Blocks(title="SHARP View Synthesis") as demo:
+    gr.Markdown(
+        "# SHARP View Synthesis\nUpload image(s) to generate 3D Gaussian PLY files via the backend API."
+    )
+
+    with gr.Tab("Single Image"):
+        in_img = gr.Image(type="filepath", label="Input Image")
+        out_file = gr.File(label="Generated PLY")
+        out_info = gr.Textbox(label="Info")
+        btn = gr.Button("Predict")
+        btn.click(predict_single, inputs=[in_img], outputs=[out_file, out_info])
+
+    with gr.Tab("Batch"):
+        in_imgs = gr.File(
+            file_count="multiple", file_types=["image"], label="Input Images"
         )
+        out_zip = gr.File(label="PLY ZIP")
+        out_info2 = gr.Textbox(label="Info")
+        btn2 = gr.Button("Predict Batch")
+        btn2.click(predict_batch, inputs=[in_imgs], outputs=[out_zip, out_info2])
 
 if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    # On Hugging Face Spaces, API_BASE_URL must point to your GPU cloud FastAPI server
+    demo.launch(server_name="0.0.0.0", server_port=7860)