fix: debug model selection, #22

.gitattributes

@@ -1,3 +1,4 @@
 *.safetensors filter=lfs diff=lfs merge=lfs -text
+models/finetuned_hf/** filter=lfs diff=lfs merge=lfs -text
 *.joblib filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -44,6 +44,10 @@ COPY configs/ configs/
 COPY src/ src/
 COPY models/final_model.joblib models/final_model.joblib
 COPY models/finetuned_hf/ models/finetuned_hf/
+COPY scripts/materialize_finetuned_weights.py scripts/materialize_finetuned_weights.py
+RUN if [ "$INSTALL_HF" = "1" ]; then \
+      uv run python scripts/materialize_finetuned_weights.py || true; \
+    fi
 COPY --from=frontend-build /app/frontend/dist frontend/dist
 COPY .env.example .env.example
 

README.md

@@ -46,6 +46,18 @@ uv run uvicorn src.api.main:app --reload --port 8000
 
 Verify HF deps: `uv run python -c "import transformers; print('ok')"`.
 
+**Fine-tuned (local HF)** needs real weight files in `models/finetuned_hf/` (not the 134-byte Git LFS pointer). **You do not need Git LFS** if you use:
+
+```bash
+uv sync --extra hf
+uv run python scripts/materialize_finetuned_weights.py
+ls -lh models/finetuned_hf/model.safetensors   # should be ~250 MB+
+```
+
+Optional (if the team pushed weights with Git LFS): `brew install git-lfs`, then `git lfs install` and `git lfs pull`.
+
+Without local weights, the API falls back to `martin-ha/toxic-comment-model` from Hugging Face Hub when you select this model.
+
 | Resource | URL |
 |----------|-----|
 | Swagger | http://localhost:8000/docs |
@@ -60,7 +72,8 @@ Verify HF deps: `uv run python -c "import transformers; print('ok')"`.
 | `GET` | `/videos/suggested` | Metadata for right-rail videos (from `configs/suggested_videos.yaml`) |
 | `GET` | `/models` | Available models |
 | `GET` | `/models/status` | Per-model availability (HF deps, local weights) |
-| `PUT` | `/model/{name}` | Switch active model (warmup-validated) |
+| `POST` | `/models/select` | Switch active model `{"model_name": "..."}` (preferred) |
+| `PUT` | `/model/{name}` | Legacy path-based model switch |
 
 Set `YOUTUBE_API_KEY` in `.env` for real comments and suggested-video thumbnails.
 

configs/model_catalog.yaml

@@ -37,7 +37,8 @@
   type: hf_local
   icon: "✨"
   model_path: models/finetuned_hf
-  description: "Locally fine-tuned Hugging Face model (models/finetuned_hf)."
+  hub_fallback: martin-ha/toxic-comment-model
+  description: "Local DistilBERT folder (models/finetuned_hf). Materialize weights if missing."
   speed: "Hardware dependent"
   accuracy: "TBD"
-  requires: "uv sync --extra hf"
+  requires: "uv sync --extra hf; uv run python scripts/materialize_finetuned_weights.py"

configs/suggested_videos.yaml

@@ -9,7 +9,7 @@ videos:
     note: 3Blue1Brown — embed-friendly educational
   - id: dQw4w9WgXcQ
     note: Rick Astley — usually embeddable
-  - id: e-z0xWm0xK0
-    note: Kurzgesagt — educational, comments on
-  - id: aKydtOUFkeg
-    note: TED-style talk — embed-friendly
+  - id: M7lc1UVf-VE
+    note: YouTube Developers — designed for embedding
+  - id: 8aGhZQkoFbQ
+    note: What is an API — tech talk, comments on

frontend/src/api/client.ts

@@ -54,13 +54,30 @@ export function getModels() {
   return request<{ available: string[]; active: string }>("/models");
 }
 
-export function getModelsStatus() {
-  return request<{ models: ModelStatusEntry[]; active: string }>("/models/status");
+export async function getModelsStatus() {
+  try {
+    return await request<{ models: ModelStatusEntry[]; active: string }>("/models/status");
+  } catch (e) {
+    if (e instanceof Error && e.message.toLowerCase().includes("not found")) {
+      const legacy = await getModels();
+      return {
+        active: legacy.active,
+        models: legacy.available.map((name) => ({
+          name,
+          available: true,
+          reason: null,
+          type: "unknown",
+        })),
+      };
+    }
+    throw e;
+  }
 }
 
 export function setModel(name: string) {
-  return request<{ message: string; model: string }>(`/model/${encodeURIComponent(name)}`, {
-    method: "PUT",
+  return request<{ message: string; model: string }>("/models/select", {
+    method: "POST",
+    body: JSON.stringify({ model_name: name }),
   });
 }
 

frontend/src/components/SuggestedRail.tsx

@@ -19,7 +19,18 @@ export function SuggestedRail({ videos, activeId, loadingId, onSelect }: Props)
           onClick={() => onSelect(v)}
           disabled={loadingId === v.id}
         >
-          <img src={v.thumbnail_url} alt="" className="suggested-thumb" />
+          <img
+            src={v.thumbnail_url}
+            alt=""
+            className="suggested-thumb"
+            onError={(e) => {
+              const img = e.currentTarget;
+              if (!img.dataset.fallback) {
+                img.dataset.fallback = "1";
+                img.src = `https://i.ytimg.com/vi/${v.id}/hqdefault.jpg`;
+              }
+            }}
+          />
           <div className="suggested-info">
             <p className="suggested-title">{v.title}</p>
             <p className="suggested-channel">{v.channel_title}</p>

frontend/src/pages/SettingsPage.tsx

@@ -12,6 +12,7 @@ export function SettingsPage() {
   const [testError, setTestError] = useState<string | null>(null);
   const [testing, setTesting] = useState(false);
   const [message, setMessage] = useState<string | null>(null);
+  const [switching, setSwitching] = useState(false);
 
   const loadStatus = () => {
     getModelsStatus()
@@ -38,6 +39,7 @@ export function SettingsPage() {
       return;
     }
     setMessage(null);
+    setSwitching(true);
     try {
       await setModel(name);
       setActive(name);
@@ -46,6 +48,8 @@ export function SettingsPage() {
     } catch (e) {
       setMessage(e instanceof Error ? e.message : "Failed to switch model");
       loadStatus();
+    } finally {
+      setSwitching(false);
     }
   };
 
@@ -72,6 +76,9 @@ export function SettingsPage() {
           HF models need <code>uv sync --extra hf</code> locally, or{" "}
           <code>INSTALL_HF=1 docker compose build</code> in Docker.
         </p>
+        {switching && (
+          <p className="hint">Switching model… HF models may take up to a minute on first load.</p>
+        )}
         <div className="model-list">
           {modelStatus.map((m) => (
             <label
@@ -82,7 +89,7 @@ export function SettingsPage() {
                 type="radio"
                 name="model"
                 checked={active === m.name}
-                disabled={!m.available}
+                disabled={!m.available || switching}
                 onChange={() => void switchModel(m.name)}
               />
               <span>

scripts/materialize_finetuned_weights.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""Download real HF weights into models/finetuned_hf (no Git LFS required).
+
+The repo may only contain a Git LFS pointer for model.safetensors (~134 bytes).
+This script saves a compatible DistilBERT toxic classifier from Hugging Face Hub
+so "Fine-tuned (local HF)" can load offline after one download.
+
+Run from repo root:
+  uv sync --extra hf
+  uv run python scripts/materialize_finetuned_weights.py
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+OUT_DIR = PROJECT_ROOT / "models" / "finetuned_hf"
+# Same architecture family as notebook 08 (DistilBERT sequence classification)
+HUB_ID = "martin-ha/toxic-comment-model"
+
+
+def main() -> int:
+    weights = OUT_DIR / "model.safetensors"
+    if weights.is_file() and weights.stat().st_size > 1_000_000:
+        print(f"OK: {weights} already exists ({weights.stat().st_size // 1_000_000} MB)")
+        return 0
+
+    try:
+        from transformers import AutoModelForSequenceClassification, AutoTokenizer
+    except ImportError:
+        print("Install HF deps first: uv sync --extra hf", file=sys.stderr)
+        return 1
+
+    print(f"Downloading {HUB_ID} into {OUT_DIR} …")
+    OUT_DIR.mkdir(parents=True, exist_ok=True)
+    model = AutoModelForSequenceClassification.from_pretrained(HUB_ID)
+    tokenizer = AutoTokenizer.from_pretrained(HUB_ID)
+    model.save_pretrained(OUT_DIR)
+    tokenizer.save_pretrained(OUT_DIR)
+
+    meta = OUT_DIR / "model_metadata.json"
+    if not meta.exists():
+        meta.write_text(
+            '{"model_name":"DistilBERT (materialized from Hub)","note":"Run notebook 08 to replace with team weights"}\n',
+            encoding="utf-8",
+        )
+
+    size_mb = weights.stat().st_size // 1_000_000 if weights.is_file() else 0
+    print(f"Done. {weights} ({size_mb} MB)")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

src/api/main.py

@@ -87,7 +87,14 @@ app.include_router(predict.router)
 app.include_router(videos.router)
 
 
-_API_GET_PREFIXES = ("models", "model", "videos", "predict", "health", "docs", "redoc", "openapi")
+_API_PATH_ROOTS = frozenset(
+    {"models", "model", "videos", "predict", "health", "docs", "redoc", "openapi"}
+)
+
+
+def _is_api_spa_path(full_path: str) -> bool:
+    root = full_path.split("/")[0] if full_path else ""
+    return root in _API_PATH_ROOTS
 
 
 def _mount_frontend() -> None:
@@ -99,7 +106,7 @@ def _mount_frontend() -> None:
 
     @app.get("/{full_path:path}", include_in_schema=False)
     async def spa_fallback(full_path: str):
-        if full_path.startswith(_API_GET_PREFIXES):
+        if _is_api_spa_path(full_path):
             from fastapi import HTTPException
 
             raise HTTPException(status_code=404, detail="Not found")

src/api/routes/models.py

@@ -1,8 +1,9 @@
 import time
+from urllib.parse import unquote
 
 from fastapi import APIRouter, HTTPException
 
-from src.api.schemas import ModelInfo, ModelStatusEntry, ModelsStatusResponse
+from src.api.schemas import ModelInfo, ModelStatusEntry, ModelsStatusResponse, SelectModelRequest
 from src.api.services import get_service
 from src.api.state import PROJECT_ROOT, get_state
 from src.service.model_service import AVAILABLE_MODELS, ModelService, check_model_availability
@@ -10,6 +11,33 @@ from src.service.model_service import AVAILABLE_MODELS, ModelService, check_mode
 router = APIRouter(tags=["Model"])
 
 
+def _switch_model_impl(model_name: str) -> dict[str, str]:
+    if model_name not in AVAILABLE_MODELS:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Model '{model_name}' not available. Options: {list(AVAILABLE_MODELS.keys())}",
+        )
+
+    available, reason = check_model_availability(model_name, PROJECT_ROOT)
+    if not available:
+        raise HTTPException(status_code=400, detail=reason or "Model unavailable")
+
+    state = get_state()
+    prev_service = state["service"]
+    prev_name = state["model_name"]
+
+    new_service = ModelService(model_name, PROJECT_ROOT)
+    warmup = new_service.predict("warmup")
+    if warmup.get("error"):
+        state["service"] = prev_service
+        state["model_name"] = prev_name
+        raise HTTPException(status_code=400, detail=str(warmup["error"]))
+
+    state["service"] = new_service
+    state["model_name"] = model_name
+    return {"message": f"Active model set to '{model_name}'", "model": model_name}
+
+
 @router.get("/model-info", response_model=ModelInfo)
 async def get_model_info():
     service = get_service()
@@ -50,29 +78,13 @@ async def list_models():
     return {"available": list(AVAILABLE_MODELS.keys()), "active": state["model_name"]}
 
 
-@router.put("/model/{model_name}")
-async def switch_model(model_name: str):
-    if model_name not in AVAILABLE_MODELS:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Model '{model_name}' not available. Options: {list(AVAILABLE_MODELS.keys())}",
-        )
+@router.post("/models/select")
+async def select_model(body: SelectModelRequest):
+    """Switch active model (preferred — avoids URL-encoding issues in model names)."""
+    return _switch_model_impl(body.model_name.strip())
 
-    available, reason = check_model_availability(model_name, PROJECT_ROOT)
-    if not available:
-        raise HTTPException(status_code=400, detail=reason or "Model unavailable")
 
-    state = get_state()
-    prev_service = state["service"]
-    prev_name = state["model_name"]
-
-    new_service = ModelService(model_name, PROJECT_ROOT)
-    warmup = new_service.predict("warmup")
-    if warmup.get("error"):
-        state["service"] = prev_service
-        state["model_name"] = prev_name
-        raise HTTPException(status_code=400, detail=str(warmup["error"]))
-
-    state["service"] = new_service
-    state["model_name"] = model_name
-    return {"message": f"Active model set to '{model_name}'", "model": model_name}
+@router.put("/model/{model_name:path}")
+async def switch_model(model_name: str):
+    """Legacy path-based switch (decoded path segment)."""
+    return _switch_model_impl(unquote(model_name).strip())

src/api/schemas.py

@@ -69,6 +69,10 @@ class ModelsStatusResponse(BaseModel):
     active: str
 
 
+class SelectModelRequest(BaseModel):
+    model_name: str = Field(..., min_length=1)
+
+
 class ModelInfo(BaseModel):
     name: str
     type: str

src/service/model_service.py

@@ -14,6 +14,44 @@ from src.service.model_catalog import load_model_catalog
 AVAILABLE_MODELS: dict[str, dict[str, Any]] = load_model_catalog()
 
 _HF_DEPS_MSG = "Install HF deps: uv sync --extra hf"
+_LFS_POINTER_PREFIX = "version https://git-lfs"
+_MIN_LOCAL_HF_WEIGHTS_BYTES = 1_000_000
+
+
+def _is_lfs_pointer_file(path: Path) -> bool:
+    try:
+        if path.stat().st_size > 4096:
+            return False
+        head = path.read_text(encoding="utf-8", errors="ignore")[:80]
+        return head.startswith(_LFS_POINTER_PREFIX)
+    except OSError:
+        return False
+
+
+def local_hf_weights_ok(model_dir: Path) -> tuple[bool, str | None]:
+    """Verify a local HF folder has real weight files (not Git LFS pointers)."""
+    if not model_dir.is_dir():
+        return False, f"Model not found at {model_dir}."
+
+    for weights_name in ("model.safetensors", "pytorch_model.bin"):
+        weights = model_dir / weights_name
+        if not weights.is_file():
+            continue
+        if _is_lfs_pointer_file(weights):
+            return False, (
+                "Weights missing (Git LFS pointer only). "
+                "Run: uv run python scripts/materialize_finetuned_weights.py "
+                "(or: brew install git-lfs && git lfs pull)"
+            )
+        size = weights.stat().st_size
+        if size < _MIN_LOCAL_HF_WEIGHTS_BYTES:
+            return False, (
+                f"{weights_name} is too small ({size} bytes). "
+                "Run: uv run python scripts/materialize_finetuned_weights.py"
+            )
+        return True, None
+
+    return False, "No model.safetensors or pytorch_model.bin in model directory."
 
 
 def hf_deps_available() -> bool:
@@ -49,9 +87,12 @@ def check_model_availability(name: str, project_root: Path | None = None) -> tup
         if not hf_deps_available():
             return False, _HF_DEPS_MSG
         path = root / cfg["model_path"]
-        if not path.exists():
-            return False, f"Model not found at {path}."
-        return True, None
+        ok, reason = local_hf_weights_ok(path)
+        if ok:
+            return True, None
+        if cfg.get("hub_fallback"):
+            return True, reason
+        return False, reason
 
     if model_type == "hf_remote":
         if not hf_deps_available():
@@ -118,9 +159,13 @@ class ModelService:
                 self._load_hf(self.cfg["model_id"])
             elif t == "hf_local":
                 path = self.project_root / self.cfg["model_path"]
-                if not path.exists():
-                    raise FileNotFoundError(f"Model not found at {path}.")
-                self._load_hf(str(path))
+                ok, _reason = local_hf_weights_ok(path)
+                if ok:
+                    self._load_hf(str(path))
+                elif self.cfg.get("hub_fallback"):
+                    self._load_hf(self.cfg["hub_fallback"])
+                else:
+                    raise FileNotFoundError(_reason or f"Model not found at {path}.")
         return self._model
 
     def _load_local(self) -> None:

tests/test_api.py

@@ -99,6 +99,29 @@ def test_predict_video_demo_comments_differ_by_url(client: TestClient, monkeypat
     assert data1["results"][0]["text"] != data2["results"][0]["text"]
 
 
+def test_finetuned_local_reports_lfs_when_pointer_only():
+    from src.api.state import PROJECT_ROOT
+    from src.service.model_service import check_model_availability
+
+    weights = PROJECT_ROOT / "models" / "finetuned_hf" / "model.safetensors"
+    if not weights.is_file() or weights.stat().st_size >= 4096:
+        pytest.skip("finetuned_hf weights present or missing — LFS pointer test N/A")
+
+    ok, reason = check_model_availability("Fine-tuned (local HF)", PROJECT_ROOT)
+    assert ok is False
+    assert reason is not None
+    assert "materialize" in reason.lower() or "lfs" in reason.lower()
+
+
+def test_select_model_via_post(client: TestClient):
+    response = client.post(
+        "/models/select",
+        json={"model_name": "LR + TF-IDF (local)"},
+    )
+    assert response.status_code == 200
+    assert response.json()["model"] == "LR + TF-IDF (local)"
+
+
 def test_models_status_lists_catalog(client: TestClient):
     response = client.get("/models/status")
     assert response.status_code == 200