Add FitGenie CalorieCLIP API for HF Spaces deployment.

FastAPI /predict endpoint with pre-downloaded CalorieCLIP weights at Docker build time.

Co-authored-by: Cursor <cursoragent@cursor.com>

Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    HF_HOME=/app/.cache/huggingface
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgl1 \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY model_core.py app.py gradio_app.py .
+
+# Pre-download weights at build time so cold starts are faster.
+RUN python -c "from huggingface_hub import hf_hub_download; hf_hub_download('jc-builds/CalorieCLIP', 'calorie_clip.pt')"
+
+EXPOSE 8000
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=120s --retries=3 \
+  CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/health')"
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -1,12 +1,173 @@
 ---
-title: Fitgenie Calorie Clip
-emoji: 📈
-colorFrom: yellow
-colorTo: yellow
+title: FitGenie CalorieCLIP
+emoji: 🍎
+colorFrom: green
+colorTo: blue
 sdk: docker
+app_port: 8000
 pinned: false
 license: mit
-short_description: Instant food calorie estimate API for FitGenie(~51 MAE, CPU)
+short_description: Instant food calorie estimate API for FitGenie (~51 MAE)
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# FitGenie CalorieCLIP
+
+Free-to-host **instant calorie estimate** from food photos for the [FitGenie](https://github.com) nutrition app.
+
+| | |
+|---|---|
+| **Model** | [jc-builds/CalorieCLIP](https://huggingface.co/jc-builds/CalorieCLIP) (CLIP ViT-B/32 + regression) |
+| **Output** | Calories only (not protein/carbs/fat) |
+| **Speed** | ~50–200 ms on CPU |
+| **Cost** | **$0** on Hugging Face Spaces free tier |
+
+---
+
+## One-click deploy on Hugging Face (free)
+
+### Step 1 — Create the Space
+
+1. Go to **[huggingface.co/new-space](https://huggingface.co/new-space)**
+2. Fill in:
+   - **Owner:** your username
+   - **Space name:** `fitgenie-calorie-clip` (or any name)
+   - **License:** MIT
+   - **SDK:** **Docker**
+   - **Hardware:** **CPU basic** (free — 16 GB RAM)
+3. Click **Create Space**
+
+### Step 2 — Upload these files
+
+Upload the contents of `fitgenie_calorie_clip/` to the Space repo:
+
+```
+app.py
+model_core.py
+gradio_app.py
+Dockerfile
+requirements.txt
+README.md          ← this file (frontmatter configures the Space)
+```
+
+**Or** connect your GitHub repo and set the Space to sync from `fitgenie_calorie_clip/`.
+
+### Step 3 — Wait for build
+
+First build takes **5–15 minutes** (downloads CLIP + CalorieCLIP weights).
+
+When status is **Running**, your API base URL is:
+
+```
+https://YOUR-USERNAME-fitgenie-calorie-clip.hf.space
+```
+
+### Step 4 — Test
+
+```bash
+curl https://YOUR-USERNAME-fitgenie-calorie-clip.hf.space/health
+# → {"status":"ok","model":"CalorieCLIP"}
+
+curl -X POST https://YOUR-USERNAME-fitgenie-calorie-clip.hf.space/predict \
+  -H "Content-Type: application/json" \
+  -d '{"image":"'$(base64 -i food.jpg | tr -d '\n')'"}'
+# → {"calories":342}
+```
+
+### Step 5 — Wire to FitGenie backend
+
+On **Render** → your `fitgenie-backend` service → **Environment**:
+
+```bash
+CALORIE_CLIP_URL=https://YOUR-USERNAME-fitgenie-calorie-clip.hf.space/predict
+CALORIE_CLIP_API_KEY=choose-a-secret-string
+FOOD_ANALYSIS_PROVIDER=gpt
+OPENAI_API_KEY=sk-...
+```
+
+On the **HF Space** → **Settings** → **Variables**:
+
+```bash
+CALORIE_CLIP_API_KEY=same-secret-as-backend
+```
+
+Redeploy backend. Photo flow will show real kcal estimates instead of ~400 fallback.
+
+### Step 6 — Keep Space awake (optional, free)
+
+Free Spaces sleep after **48 hours** of no traffic.
+
+1. Sign up at [uptimerobot.com](https://uptimerobot.com) (free)
+2. Add monitor: URL `https://YOUR-SPACE.hf.space/health`, interval **30 min**
+
+---
+
+## Optional: Gradio demo Space (browser UI)
+
+For a **visual demo** (no API), create a second Space:
+
+| Setting | Value |
+|---------|-------|
+| SDK | **Gradio** |
+| Hardware | CPU basic |
+| App file | `gradio_app.py` |
+
+Use this README frontmatter instead:
+
+```yaml
+---
+title: FitGenie CalorieCLIP Demo
+sdk: gradio
+sdk_version: 4.44.1
+app_file: gradio_app.py
+hardware: cpu-basic
+---
+```
+
+---
+
+## API reference
+
+| Endpoint | Method | Body | Response |
+|----------|--------|------|----------|
+| `/health` | GET | — | `{ "status": "ok", "model": "CalorieCLIP" }` |
+| `/predict` | POST | `{ "image": "<base64>" }` | `{ "calories": 342 }` |
+
+Optional header: `X-API-Key: your-secret` (when `CALORIE_CLIP_API_KEY` is set).
+
+---
+
+## Environment variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `CALORIE_CLIP_API_KEY` | (empty) | Require `X-API-Key` header |
+| `CALORIE_CLIP_MODEL_REPO` | `jc-builds/CalorieCLIP` | HuggingFace weights repo |
+| `MAX_IMAGE_BYTES` | `8388608` | Max upload size (8 MB) |
+
+---
+
+## Limits (free tier)
+
+| Topic | Detail |
+|-------|--------|
+| Indian food | Weak — trained on US cafeteria + 2 Indian Food-101 classes |
+| Macros | **Not supported** — use GPT-4o or `fitgenie_food_analysis` for P/C/F |
+| Thali / multi-item | Poor — single calorie number for whole image |
+| Sleep | After 48h idle — use UptimeRobot |
+
+---
+
+## Local dev
+
+```bash
+pip install -r requirements.txt
+uvicorn app:app --reload --port 8000
+# or visual demo:
+python gradio_app.py
+```
+
+---
+
+## License
+
+MIT (service code) · CalorieCLIP model MIT · FitGenie integration

app.py

@@ -0,0 +1,61 @@
+"""
+CalorieCLIP API for FitGenie backend.
+
+  POST /predict  { "image": "<base64>" }  ->  { "calories": 342 }
+  GET  /health                              ->  { "status": "ok" }
+"""
+
+from __future__ import annotations
+
+import os
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, Header, HTTPException
+from pydantic import BaseModel, Field
+
+from model_core import decode_base64_image, load_models, predict_calories
+
+API_KEY = os.getenv("CALORIE_CLIP_API_KEY", "").strip()
+
+
+def _require_api_key(x_api_key: str | None) -> None:
+    if not API_KEY:
+        return
+    if x_api_key != API_KEY:
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+
+@asynccontextmanager
+async def lifespan(_: FastAPI):
+    load_models()
+    yield
+
+
+app = FastAPI(title="FitGenie CalorieCLIP", version="1.1.0", lifespan=lifespan)
+
+
+class PredictRequest(BaseModel):
+    image: str = Field(..., description="Base64-encoded food photo")
+
+
+@app.get("/")
+def root() -> dict[str, str]:
+    return {"service": "FitGenie CalorieCLIP", "endpoints": "/health, /predict"}
+
+
+@app.get("/health")
+def health() -> dict[str, str]:
+    return {"status": "ok", "model": "CalorieCLIP"}
+
+
+@app.post("/predict")
+def predict(
+    req: PredictRequest,
+    x_api_key: str | None = Header(default=None, alias="X-API-Key"),
+) -> dict[str, int]:
+    _require_api_key(x_api_key)
+    try:
+        image = decode_base64_image(req.image)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    return {"calories": predict_calories(image)}

gradio_app.py

@@ -0,0 +1,36 @@
+"""
+Gradio demo for Hugging Face Spaces (SDK: gradio).
+Upload a food photo → see estimated calories in the browser.
+"""
+
+from __future__ import annotations
+
+import gradio as gr
+
+from model_core import load_models, predict_calories
+
+load_models()
+
+
+def estimate(image) -> str:
+    if image is None:
+        return "Upload a food photo to get started."
+    calories = predict_calories(image)
+    return f"**Estimated calories:** ~{calories} kcal\n\n*Preview only — FitGenie uses GPT/VLM for full protein & macros.*"
+
+
+demo = gr.Interface(
+    fn=estimate,
+    inputs=gr.Image(type="pil", label="Food photo"),
+    outputs=gr.Markdown(label="Calorie estimate"),
+    title="FitGenie CalorieCLIP",
+    description=(
+        "Instant calorie estimate from a food photo (~51 kcal MAE on Western cafeteria food). "
+        "Works best on single-plate photos. For Indian thali / full macros, use FitGenie app with GPT analysis."
+    ),
+    examples=None,
+    allow_flagging="never",
+)
+
+if __name__ == "__main__":
+    demo.launch()

model_core.py

@@ -0,0 +1,96 @@
+"""Shared CalorieCLIP loading and inference."""
+
+from __future__ import annotations
+
+import base64
+import io
+import logging
+import os
+from typing import Any
+
+import open_clip
+import torch
+import torch.nn as nn
+from huggingface_hub import hf_hub_download
+from PIL import Image
+
+logger = logging.getLogger("calorie_clip")
+
+MODEL_REPO = os.getenv("CALORIE_CLIP_MODEL_REPO", "jc-builds/CalorieCLIP")
+WEIGHTS_FILE = os.getenv("CALORIE_CLIP_WEIGHTS_FILE", "calorie_clip.pt")
+MAX_IMAGE_BYTES = int(os.getenv("MAX_IMAGE_BYTES", str(8 * 1024 * 1024)))
+
+_state: dict[str, Any] = {}
+
+
+class RegressionHead(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(512, 512),
+            nn.BatchNorm1d(512),
+            nn.ReLU(),
+            nn.Dropout(0.4),
+            nn.Linear(512, 256),
+            nn.BatchNorm1d(256),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(256, 64),
+            nn.ReLU(),
+            nn.Linear(64, 1),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.net(x)
+
+
+def load_models() -> None:
+    if _state.get("ready"):
+        return
+    logger.info("Loading CalorieCLIP from %s/%s", MODEL_REPO, WEIGHTS_FILE)
+    clip_model, _, preprocess = open_clip.create_model_and_transforms(
+        "ViT-B-32",
+        pretrained="openai",
+    )
+    weights_path = hf_hub_download(repo_id=MODEL_REPO, filename=WEIGHTS_FILE)
+    checkpoint = torch.load(weights_path, map_location="cpu", weights_only=False)
+    clip_model.load_state_dict(checkpoint["clip_state"], strict=False)
+    head = RegressionHead()
+    head.load_state_dict(checkpoint["regressor_state"])
+    clip_model.eval()
+    head.eval()
+
+    _state["clip"] = clip_model
+    _state["head"] = head
+    _state["preprocess"] = preprocess
+    _state["ready"] = True
+    logger.info("CalorieCLIP ready")
+
+
+def decode_image_bytes(raw: bytes) -> Image.Image:
+    if len(raw) > MAX_IMAGE_BYTES:
+        raise ValueError("Image too large")
+    return Image.open(io.BytesIO(raw)).convert("RGB")
+
+
+def decode_base64_image(b64: str) -> Image.Image:
+    cleaned = b64.strip()
+    if cleaned.startswith("data:"):
+        cleaned = cleaned.split(",", 1)[1]
+    try:
+        raw = base64.b64decode(cleaned, validate=True)
+    except Exception as exc:
+        raise ValueError("Invalid base64 image") from exc
+    return decode_image_bytes(raw)
+
+
+def predict_calories(image: Image.Image) -> int:
+    load_models()
+    clip_model = _state["clip"]
+    head = _state["head"]
+    preprocess = _state["preprocess"]
+    tensor = preprocess(image).unsqueeze(0)
+    with torch.no_grad():
+        features = clip_model.encode_image(tensor)
+        calories = float(head(features).item())
+    return round(max(0.0, calories))

requirements.txt

@@ -0,0 +1,9 @@
+fastapi==0.115.0
+uvicorn[standard]==0.30.6
+open-clip-torch==2.26.1
+torch==2.4.1
+torchvision==0.19.1
+pillow==10.4.0
+huggingface-hub==0.24.7
+pydantic==2.9.2
+gradio==4.44.1