PawTrace read-only demo: reid model + 1000-dog haystack

.gitattributes

@@ -1,3 +1,6 @@
+# Large model weights go through git-LFS (needed for the Hugging Face Space repo).
+best.pt filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
 backend/demo_data/app.db filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -17,8 +17,11 @@ venv/
 backend/data/
 *.db
 *.sqlite3
+*.db-wal
+*.db-shm
+app.db.pre-*
 # NOTE: keep data/zip_centroids.csv tracked — the app needs it.
-# EXCEPTION: the demo snapshot shipped to Render (the 115-dog HF haystack) IS tracked.
+# EXCEPTION: the shipped demo snapshot (the 1,000-dog haystack DB + its media) IS tracked.
 !backend/demo_data/
 !backend/demo_data/app.db
 !backend/demo_data/media/
@@ -50,3 +53,10 @@ Thumbs.db
 
 # Analysis notebooks — kept locally, excluded from the repo
 *.ipynb
+
+# Local re-ID training data (YT-BB-Dog + Sibetan, ~2GB) — never commit
+reid_data/
+
+# Local-only: personal test photos + one-off data-prep scripts (kept on disk, not deployed)
+DobbyTesting/
+reid_research/

DEPLOY.md

@@ -1,113 +0,0 @@
-# Deploying PawTrace to Render
-
-This gets the whole app (frontend + backend) online as **one service** on Render, linkable from your
-personal site. It starts in **mock mode** (free, fake match scores) so your first deploy costs nothing
-and is low-risk; flipping to the real ML model is a small change at the end.
-
-The repo already contains everything you need: a `Dockerfile` that builds the React app and runs the
-FastAPI API that serves it, plus `render.yaml`.
-
----
-
-## Step 1 — Put the code on GitHub
-
-You've pushed frontends before, so this is familiar. One repo-specific thing first: **don't push the
-giant dataset folders** — they're already in `.gitignore`, so just make sure you don't force-add them.
-
-```bash
-# from the project root
-git init                      # if it isn't a git repo yet
-git add .
-git commit -m "PawTrace: add Render deploy (Dockerfile, render.yaml)"
-```
-
-Create a new **empty** repo on GitHub, then:
-
-```bash
-git branch -M main
-git remote add origin https://github.com/<you>/<repo>.git
-git push -u origin main
-```
-
-Sanity check on GitHub: the repo should be small (a few MB). If it's hundreds of MB, a dataset folder
-slipped in — remove it (`git rm -r --cached "Multi-pose dog dataset"`), commit, and push again.
-
-## Step 2 — Create the Render service
-
-1. Sign up at **render.com** with your GitHub account.
-2. **New +  →  Web Service  →** pick your repo (authorize Render if asked).
-3. Render detects the `Dockerfile`. Set:
-   - **Name:** `pawtrace` (this becomes `pawtrace.onrender.com`)
-   - **Branch:** `main`
-   - **Instance type:** **Free**
-4. **Environment variables** (Advanced → Add):
-   - `JWT_SECRET` → click **Generate** (or paste a long random string)
-   - `EMBEDDER` → `mock`
-   - `BREED_CLASSIFIER` → `mock`
-   *(`DATABASE_URL` and `MEDIA_DIR` are already set inside the Dockerfile.)*
-5. **Create Web Service.** First build takes a few minutes (it builds the React app, then the API).
-
-> Shortcut: instead of steps 2–4 you can use **New + → Blueprint**, pick the repo, and Render reads
-> `render.yaml` for you.
-
-## Step 3 — Try it
-
-Open your `https://pawtrace.onrender.com` URL. You should be able to register, add a dog, upload
-photos, create cases, and click through everything. **Breed estimation works for real even in mock
-mode** — it's the best thing to show off. (Match *scores* are placeholder until Step 5.)
-
-Note: the **free** instance sleeps after ~15 min idle, so the first visit after a nap takes ~30s to
-wake. That's normal for free hosting and fine for a demo.
-
-## Step 4 — Link it from your personal site
-
-Just a link:
-
-```html
-<a href="https://pawtrace.onrender.com">Try PawTrace</a>
-```
-
-Optional nicer URL: in Render → your service → **Settings → Custom Domains**, add e.g.
-`pawtrace.yourdomain.com`. Render shows you a **CNAME** to create in your DigitalSpace domain/DNS
-settings. Once it propagates, that address serves your app over HTTPS (Render issues the certificate).
-
----
-
-## Step 5 — Turn on real matching (when you're ready)
-
-Real matching loads a PyTorch model (~1–2 GB RAM), so it needs a paid instance.
-
-1. In the root **`Dockerfile`**, uncomment the `REAL MATCHING` block (the two `pip install` lines for
-   `torch` / `transformers`), commit, and push.
-2. In Render → **Environment**, change:
-   - `EMBEDDER` → `hf`
-   - `BREED_CLASSIFIER` → `hf`
-   - add `HF_HOME` → `/app/data/hf-cache` (so the model download is cached on the disk)
-3. In Render → **Settings**, bump the **instance type** to one with **≥ 1 GB RAM**.
-4. **Add persistence** so uploads/DB survive redeploys: uncomment the `disk:` block in `render.yaml`
-   (or in the dashboard add a **Disk** mounted at **`/app/data`**, ~1 GB). *Do this when you go paid —
-   free instances can't have a disk.*
-5. Redeploy. The first request downloads the ~43 MB model once (cached afterward).
-
-## Demo data (so the site isn't empty)
-
-`render.yaml` sets **`SEED_DEMO=true`**, so on startup an empty database is auto-filled with a small
-Houston-area set: **4 registered dogs (2 reported lost) + 5 found dogs**, a couple of which match a
-lost dog. On the free tier the DB resets on each cold start, so this repopulates every time.
-
-Demo logins (all password **`password123`**):
-- **admin@example.com** — the admin dashboard (all dogs/cases/owners)
-- **owner0@example.com** … **owner3@example.com** — owner views; owner0 ("Rex") and owner1 ("Bella")
-  have a lost case with a candidate match already waiting.
-
-When you move to a **real** deployment with actual users, set `SEED_DEMO=false` (or remove it) so the
-demo dogs don't get added.
-
----
-
-## Troubleshooting
-- **Build fails on `npm run build`** → run `npm run build` in `frontend/` locally to see the real
-  error (usually a TypeScript issue).
-- **App loads but API calls fail** → check the service **Logs** in Render; confirm `JWT_SECRET` is set.
-- **Everything resets after a deploy** → expected without a Disk (Step 5.4). Add one on a paid plan.
-- **Repo too big to push** → a dataset folder got added; `git rm -r --cached <folder>` and re-commit.

Dockerfile

@@ -1,9 +1,8 @@
-# PawTrace — single-service image: builds the React frontend, then runs the FastAPI API which
-# also serves that frontend (one origin, no CORS). This image runs in REAL (HF) mode: it bundles
-# the PyTorch re-ID / breed model AND a 115-dog demo database, so the live site reproduces the full
-# photo-matching demo. Measured ~356 MB RAM peak while serving, so it fits a Render Starter (512 MB)
-# instance. For a tiny free/mock image instead, drop the torch block below and set
-# EMBEDDER/BREED_CLASSIFIER=mock + SEED_DEMO=true.
+# PawTrace — single-service image for the READ-ONLY demo (Hugging Face Spaces / any Docker host).
+# Builds the React frontend, then runs the FastAPI API which also serves that frontend (one origin,
+# no CORS). Bundles the fine-tuned PyTorch re-ID model (best.pt) + the HF breed classifier + the
+# 1,000-dog demo database, and runs with DEMO_MODE=true so every write is blocked server-side.
+# Needs ~1 GB RAM with both models loaded — fine on a Spaces CPU-basic (16 GB) box.
 
 # ---- Stage 1: build the React frontend -> /web/dist ----
 FROM node:20-slim AS frontend
@@ -31,13 +30,17 @@ RUN pip install torch torchvision --index-url https://download.pytorch.org/whl/c
 # Pre-download the model into the image (into HF_HOME) so the first live match doesn't stall on a
 # runtime download. This is a big, stable layer — kept cached across code changes below.
 ENV HF_HOME=/app/hf_cache
-RUN python -c "from transformers import AutoImageProcessor, AutoModelForImageClassification as M; \
-k='jhoppanne/Dogs-Breed-Image-Classification-V1'; AutoImageProcessor.from_pretrained(k); M.from_pretrained(k)"
+RUN python -c "from transformers import AutoImageProcessor, AutoModel, AutoModelForImageClassification as M; \
+k='jhoppanne/Dogs-Breed-Image-Classification-V1'; AutoImageProcessor.from_pretrained(k); \
+M.from_pretrained(k); AutoModel.from_pretrained(k)"
 # ------------------------------------------------------------------------------------------------
 
 # Backend source (includes backend/demo_data/ — the shipped snapshot).
 COPY backend/ ./
 
+# Fine-tuned re-ID model weights (git-LFS in the Space repo) -> loaded when EMBEDDER=reid.
+COPY best.pt /app/best.pt
+
 # Geo centroid CSV lives at the repo root; copy it in and point the app at it.
 COPY data/zip_centroids.csv /app/geo/zip_centroids.csv
 ENV ZIP_CENTROID_FILE=/app/geo/zip_centroids.csv
@@ -45,24 +48,27 @@ ENV ZIP_CENTROID_FILE=/app/geo/zip_centroids.csv
 # Built frontend from stage 1 (the API serves this at "/").
 COPY --from=frontend /web/dist ./frontend_dist
 
-# Bake the 115-dog demo snapshot (SQLite DB + processed photos) into the image's data dir, then drop
-# the source copy. On a paid instance the container stays warm, so demo registrations persist for the
-# session; a redeploy resets to this clean snapshot. (Mount a Render Disk at /app/data for true
-# persistence across restarts — see render.yaml.)
+# Bake the 1,000-dog demo snapshot (SQLite DB + processed photos) into the image's data dir, then
+# drop the source copy. DEMO_MODE blocks all writes, so the DB never changes; a redeploy just
+# reloads this same read-only snapshot.
 RUN mkdir -p /app/data \
  && cp /app/demo_data/app.db /app/data/app.db \
  && cp -r /app/demo_data/media /app/data/media \
  && rm -rf /app/demo_data
 ENV DATABASE_URL=sqlite:////app/data/app.db \
     MEDIA_DIR=/app/data/media \
-    EMBEDDER=hf \
+    EMBEDDER=reid \
+    REID_MODEL_PATH=/app/best.pt \
+    REID_MODEL_VERSION=v4 \
     BREED_CLASSIFIER=hf \
+    BREED_TOP_K=10 \
+    DEMO_MODE=true \
     HF_HUB_OFFLINE=1 \
     TRANSFORMERS_OFFLINE=1
 # HF_HUB_OFFLINE/TRANSFORMERS_OFFLINE: use the model baked into HF_HOME above; never call
 # huggingface.co at runtime (faster cold start, no external dependency during a demo).
 
-# No EXPOSE: Render routes public traffic to the port the app actually opens (below). An EXPOSE that
-# differs from the bound port makes Render send public traffic to the wrong port -> 502.
-# Render provides $PORT (default 10000); bind to it.
-CMD ["sh", "-c", "uvicorn app.main:app --host 0.0.0.0 --port ${PORT:-10000}"]
+# HF Spaces routes to the port declared as `app_port` in README.md (7860). Bind there; ${PORT} keeps
+# it portable to hosts that inject a port (Render, etc.).
+EXPOSE 7860
+CMD ["sh", "-c", "uvicorn app.main:app --host 0.0.0.0 --port ${PORT:-7860}"]

README.md

@@ -1,3 +1,14 @@
+---
+title: PawTrace
+emoji: 🐕
+colorFrom: yellow
+colorTo: green
+sdk: docker
+app_port: 7860
+pinned: false
+short_description: Find a lost dog by its image — an AI dog re-identification demo.
+---
+
 # PawTrace — Lost-Dog Reunification Platform
 
 A responsive web app that helps reunite lost dogs with their owners by matching photos with

backend/app/api/geo.py

@@ -1,7 +1,13 @@
 from __future__ import annotations
 
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends
+from sqlalchemy import func, select
+from sqlalchemy.orm import Session
 
+from ..config import settings
+from ..db import get_db
+from ..models import UnknownDog
+from ..models.base import UnknownDogStatus
 from .shelters import nearby_shelters
 
 router = APIRouter(tags=["geo"])
@@ -15,3 +21,13 @@ def get_nearby_shelters(zip: str | None = None) -> dict:
 @router.get("/healthz")
 def healthz() -> dict:
     return {"status": "ok"}
+
+
+@router.get("/config")
+def public_config(db: Session = Depends(get_db)) -> dict:
+    """Public runtime config the frontend reads on load: which UI to render, and how many
+    found/unclaimed dogs a photo search is compared against (the searchable haystack size)."""
+    haystack_size = db.execute(
+        select(func.count(UnknownDog.id)).where(UnknownDog.status == UnknownDogStatus.pending)
+    ).scalar()
+    return {"demo_mode": settings.demo_mode, "haystack_size": haystack_size}

backend/app/config.py

@@ -25,17 +25,32 @@ class Settings(BaseSettings):
     media_dir: str = "./data/media"
     storage_backend: str = "local"  # local | s3
 
-    # Embedder / ML
-    embedder: str = "mock"  # mock | cnn | hf
-    embedder_model: str = "resnet50"  # torchvision backbone when EMBEDDER=cnn
+    # Embedder / ML.  THE SINGLE SWITCH between one-model and two-model modes:
+    #   EMBEDDER=hf    -> SINGLE model: the breed model runs ONCE per image and yields BOTH the
+    #                     matching vector (penultimate features) and the top-K breed labels.
+    #   EMBEDDER=reid  -> TWO models: the fine-tuned re-ID model (reid_model_path) produces the
+    #                     matching vector, and the separate breed classifier produces the top-K
+    #                     breeds. Better matching, at the cost of a second forward pass + model.
+    # (Routing is automatic: with EMBEDDER=reid the embedder != breed model, so images.py takes its
+    #  existing two-model path. Set BREED_CLASSIFIER=hf in reid mode to keep real breed labels.)
+    embedder: str = "mock"  # mock | hf | reid
     # HF re-ID embedder: uses the penultimate (pre-classifier) pooled features as the vector.
     embedder_hf_model: str = "jhoppanne/Dogs-Breed-Image-Classification-V1"
-    detector_enabled: bool = False
+    # Fine-tuned re-ID checkpoint (EMBEDDER=reid): a train_reid.py best.pt loaded into the breed
+    # backbone. reid_model_version tags stored vectors so matching only compares same-model vectors
+    # (switching modes needs a re-embed — the tag keeps old/new vectors from being mixed).
+    reid_model_path: str = "./best.pt"
+    reid_model_version: str = "v4"
 
     # Populate a small demo dataset on startup when the DB is empty (SEED_DEMO=1). For free/mock
     # deploys so the app isn't blank; safe to leave on (only ever seeds an empty database).
     seed_demo: bool = False
 
+    # Public read-only showcase (DEMO_MODE=1): the frontend renders the 3-page demo shell, and the
+    # backend HARD-BLOCKS every write — only the two transient, no-persist photo-search endpoints are
+    # allowed. Nothing can modify the database (not the demo UI, a direct API call, or curl).
+    demo_mode: bool = False
+
     # Breed classifier — cheap estimated-breed candidate gate (spec §9.3, extends metadata gate).
     # Predicts breed *labels only*; never used for similarity. mock = deterministic, no downloads.
     breed_classifier: str = "mock"  # mock | hf

backend/app/main.py

@@ -74,6 +74,26 @@ async def _validation_exc_handler(_: Request, exc: RequestValidationError) -> JS
     )
 
 
+# ---- Demo mode: hard, server-side read-only guard ----
+# When DEMO_MODE=1 the app is a public showcase. The ONLY writes allowed are the two transient
+# photo-search endpoints (which persist nothing). Every other mutating request is refused here — so
+# the database can never be modified from the demo UI, a direct API call, or curl. Safety is enforced
+# on the server, not by hiding buttons in the frontend.
+if settings.demo_mode:
+    _DEMO_WRITE_ALLOWLIST = {"/search/by-photo", "/search/breed"}
+    _MUTATING_METHODS = {"POST", "PUT", "PATCH", "DELETE"}
+
+    @app.middleware("http")
+    async def _demo_readonly_guard(request: Request, call_next):
+        if request.method in _MUTATING_METHODS and request.url.path not in _DEMO_WRITE_ALLOWLIST:
+            return JSONResponse(
+                status_code=403,
+                content={"error": {"code": 403,
+                                   "message": "This is a read-only demo — changes are disabled."}},
+            )
+        return await call_next(request)
+
+
 # ---- Routers ----
 app.include_router(auth.router)
 app.include_router(dogs.router)

backend/app/ml/breed.py

@@ -7,7 +7,7 @@ similarity; that matcher is selected separately.
 
 Mock-first: the default ``MockBreedClassifier`` is deterministic and weight-free, so tests and the
 seed demo run offline. The real ``HFBreedClassifier`` is opt-in via config and lazily imports
-torch/transformers, exactly like ``CNNEmbedder``.
+torch/transformers, exactly like ``HFEmbedder``.
 """
 from __future__ import annotations
 

backend/app/ml/detector.py

@@ -1,55 +0,0 @@
-"""Optional dog-detector crop (spec §8 step 3, milestone 8).
-
-Disabled by default (DETECTOR_ENABLED=false) and never used on the mock path. When enabled with
-torch/torchvision installed, crops the most confident dog box (with padding) before embedding.
-"""
-from __future__ import annotations
-
-from PIL import Image
-
-
-class DogDetector:  # pragma: no cover - only used when DETECTOR_ENABLED + torch installed
-    # COCO class id 18 == "dog".
-    DOG_CLASS_ID = 18
-
-    def __init__(self, score_threshold: float = 0.5, padding: float = 0.1):
-        import torchvision
-        from torchvision.models.detection import (
-            FasterRCNN_ResNet50_FPN_Weights as W,
-        )
-
-        self.score_threshold = score_threshold
-        self.padding = padding
-        weights = W.DEFAULT
-        self._model = torchvision.models.detection.fasterrcnn_resnet50_fpn(
-            weights=weights
-        ).eval()
-        self._preprocess = weights.transforms()
-
-    def detect_box(self, img: Image.Image) -> tuple[int, int, int, int] | None:
-        import torch
-
-        with torch.no_grad():
-            tensor = self._preprocess(img)
-            pred = self._model([tensor])[0]
-        best = None
-        best_score = self.score_threshold
-        for box, label, score in zip(pred["boxes"], pred["labels"], pred["scores"]):
-            if int(label) == self.DOG_CLASS_ID and float(score) >= best_score:
-                best_score = float(score)
-                best = box.tolist()
-        if best is None:
-            return None
-        x1, y1, x2, y2 = best
-        w, h = img.size
-        px, py = (x2 - x1) * self.padding, (y2 - y1) * self.padding
-        return (
-            max(0, int(x1 - px)),
-            max(0, int(y1 - py)),
-            min(w, int(x2 + px)),
-            min(h, int(y2 + py)),
-        )
-
-    def crop(self, img: Image.Image) -> Image.Image:
-        box = self.detect_box(img)
-        return img.crop(box) if box else img

backend/app/ml/embedder.py

@@ -1,4 +1,4 @@
-"""Embedder interface + Mock (default) and CNN (real, optional) implementations (spec §9.1).
+"""Embedder interface + Mock (default), HF, and fine-tuned re-ID implementations (spec §9.1).
 
 The Embedder is one of the four swap points. The matcher only depends on this Protocol, so a
 better model can be dropped in without schema or API changes (A6).
@@ -70,48 +70,6 @@ class MockEmbedder:
         return [self._vector_for(p) for p in image_paths]
 
 
-class CNNEmbedder:  # pragma: no cover - exercised only when torch is installed (milestone 8)
-    """Pretrained CNN backbone, classifier head removed, global-pooled + L2-normalized (spec §9.1).
-
-    Lazily imports torch/torchvision so the mock path never requires them. Optional dog-crop
-    preprocess is gated behind DETECTOR_ENABLED (added in milestone 8).
-    """
-
-    def __init__(self, model_name: str | None = None):
-        import torch  # noqa: F401
-        import torchvision
-        from torchvision.models import ResNet50_Weights
-
-        self.name = model_name or settings.embedder_model
-        self.version = "imagenet-v1"
-        weights = ResNet50_Weights.DEFAULT
-        backbone = torchvision.models.resnet50(weights=weights)
-        import torch.nn as nn
-
-        self._model = nn.Sequential(*list(backbone.children())[:-1]).eval()
-        self._preprocess = weights.transforms()
-        self.dim = 2048
-        self._detector = None
-        if settings.detector_enabled:
-            from .detector import DogDetector
-
-            self._detector = DogDetector()
-
-    def embed(self, image_paths: list[str]) -> list[np.ndarray]:
-        import torch
-
-        out: list[np.ndarray] = []
-        with torch.no_grad():
-            for p in image_paths:
-                img = Image.open(p).convert("RGB")
-                if self._detector is not None:
-                    img = self._detector.crop(img)
-                tensor = self._preprocess(img).unsqueeze(0)
-                feat = self._model(tensor).flatten().cpu().numpy()
-                out.append(_l2_normalize(feat))
-        return out
-
-
 class HFEmbedder:  # pragma: no cover - exercised only when transformers is installed
     """HuggingFace image model used as a re-ID embedder via its penultimate pooled features.
 
@@ -119,7 +77,7 @@ class HFEmbedder:  # pragma: no cover - exercised only when transformers is inst
     individual-dog re-identification (per the project owner). We run the image through the model,
     take the last hidden state, pool it (global average for CNN feature maps, mean-over-tokens for
     transformer sequences), and L2-normalize. Breed *labels* are NOT used here — that is the
-    separate BreedClassifier swap point. Lazily imports torch/transformers like CNNEmbedder.
+    separate BreedClassifier swap point. Lazily imports torch/transformers only when selected.
     """
 
     def __init__(self, model_id: str | None = None):
@@ -195,16 +153,64 @@ class HFEmbedder:  # pragma: no cover - exercised only when transformers is inst
         return results
 
 
+_MEAN, _STD = [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]  # ImageNet stats (re-ID preprocessing)
+
+
+class ReIDEmbedder:  # pragma: no cover - exercised only when torch is installed
+    """Fine-tuned re-ID embedder (EMBEDDER=reid): the breed backbone further trained with triplet
+    loss for individual-dog re-identification.
+
+    Loads a local checkpoint (a state_dict saved by scripts/train_reid.py's ``ReIDModel`` — keys are
+    prefixed ``backbone.``) into the same ResNet base as the breed model, and emits the L2-normalized
+    penultimate pooled features. Preprocessing matches TRAINING (Resize 224 + ImageNet norm), NOT the
+    HF image processor. This model produces NO breed labels — when it is the active embedder, breed
+    labels come from the separate breed classifier via images.py's two-model path.
+    """
+
+    def __init__(self, ckpt_path: str | None = None, base_model: str | None = None):
+        import torch  # noqa: F401
+        import torchvision.transforms as T
+        from transformers import AutoModel
+
+        self.name = "reid"
+        self.version = settings.reid_model_version
+        base = base_model or settings.embedder_hf_model
+        self.model = AutoModel.from_pretrained(base)
+        raw = torch.load(ckpt_path or settings.reid_model_path, map_location="cpu")
+        # accept the ReIDModel wrapper's 'backbone.'-prefixed keys OR a bare backbone state_dict.
+        state = {k.removeprefix("backbone."): v for k, v in raw.items()}
+        self.model.load_state_dict(state)
+        self.model.eval()
+        self._device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model.to(self._device)
+        self._prep = T.Compose(
+            [T.Resize((224, 224)), T.ToTensor(), T.Normalize(_MEAN, _STD)]
+        )
+        self.dim = 2048
+
+    def embed(self, image_paths: list[str]) -> list[np.ndarray]:
+        import torch
+
+        out: list[np.ndarray] = []
+        with torch.no_grad():
+            for p in image_paths:
+                with Image.open(p) as img:
+                    x = self._prep(img.convert("RGB")).unsqueeze(0).to(self._device)
+                    feat = self.model(x).pooler_output.flatten(1)[0]
+                    out.append(_l2_normalize(feat.cpu().numpy()))
+        return out
+
+
 _embedder: Embedder | None = None
 
 
 def get_embedder() -> Embedder:
     global _embedder
     if _embedder is None:
-        if settings.embedder == "cnn":
-            _embedder = CNNEmbedder()
-        elif settings.embedder == "hf":
+        if settings.embedder == "hf":
             _embedder = HFEmbedder()
+        elif settings.embedder == "reid":
+            _embedder = ReIDEmbedder()
         else:
             _embedder = MockEmbedder()
     return _embedder

backend/demo_data/app.db

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e17ecfb47a92704d6a687c4e0ff1b7815447dbddeea14e61927d0cd99f11f4af
-size 14491648
+oid sha256:3708ba8aa5761b5f6afe855f2c29b55b959eaf987d32018fad4dcb4a41ad4e5c
+size 39477248