fixes

Dockerfile

@@ -1,17 +1,20 @@
 FROM python:3.10
+
 WORKDIR /app
+
 COPY . /app
+
 RUN pip install --no-cache-dir -r requirements.txt
 
+# Pre-download model
 RUN python -c "from transformers import CLIPModel, CLIPProcessor; \
-    CLIPModel.from_pretrained('openai/clip-vit-base-patch32'); \
-    CLIPProcessor.from_pretrained('openai/clip-vit-base-patch32')"
+CLIPModel.from_pretrained('openai/clip-vit-base-patch32'); \
+CLIPProcessor.from_pretrained('openai/clip-vit-base-patch32')"
 
-# Lock HuggingFace to use only the cached model at runtime
 ENV TRANSFORMERS_OFFLINE=1
 ENV HF_DATASETS_OFFLINE=1
+ENV TOKENIZERS_PARALLELISM=false
 
 EXPOSE 7860
-CMD ["gunicorn", "-k", "uvicorn.workers.UvicornWorker", "backend.main:app", "-b", "0.0.0.0:7860"]
-
 
+CMD ["gunicorn", "-k", "uvicorn.workers.UvicornWorker", "backend.main:app", "-b", "0.0.0.0:7860"]

backend/ai.py

@@ -1,49 +1,99 @@
-import os
-os.environ["TOKENIZERS_PARALLELISM"] = "false"
+import logging
 
+import numpy as np
 import torch
+from PIL import Image
 from transformers import CLIPModel, CLIPProcessor
 
-MODEL = "openai/clip-vit-base-patch32"
+logger = logging.getLogger(__name__)
 
+# Stable CLIP model for Apple Silicon / CPU
+_MODEL_NAME = "openai/clip-vit-base-patch32"
 
-device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
-print("CLIP running on:", device)
+# ---------------------------------------------------------------------------
+# Lazy initialization
+# ---------------------------------------------------------------------------
 
-model = CLIPModel.from_pretrained(MODEL).to(device)
-model.eval()
+_device: torch.device | None = None
+_model: CLIPModel | None = None
+_processor: CLIPProcessor | None = None
 
-processor = CLIPProcessor.from_pretrained(MODEL, use_fast=True)
+
+def _get_device() -> torch.device:
+    # Force CPU for stability on M1/M2 Macs
+    return torch.device("cpu")
+
+
+def _load() -> None:
+    """Load model and processor exactly once."""
+    global _device, _model, _processor
+
+    if _model is not None:
+        return
+
+    _device = _get_device()
+
+    logger.info(
+        "Loading CLIP model '%s' on %s…",
+        _MODEL_NAME,
+        _device,
+    )
+
+    try:
+        _model = CLIPModel.from_pretrained(_MODEL_NAME).to(_device)
+        _model.eval()
+
+        _processor = CLIPProcessor.from_pretrained(_MODEL_NAME)
+
+    except Exception as exc:
+        _model = None
+        _processor = None
+
+        raise RuntimeError(
+            f"Failed to load CLIP model '{_MODEL_NAME}'"
+        ) from exc
+
+    logger.info("CLIP model ready.")
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
 
 @torch.no_grad()
-def encode_image(img):
+def encode_image(img: Image.Image) -> np.ndarray:
+    """
+    Encode a PIL image into a normalized float32 embedding.
+
+    Returns
+    -------
+    np.ndarray
+        Shape (1, 512), dtype float32, L2-normalized.
+    """
+
     if img is None:
-        raise RuntimeError("embed_image() called with empty image")
+        raise ValueError("encode_image() called with img=None")
 
-    img = img.resize((224, 224))
-    batch = processor(images=img, return_tensors="pt").to(device)
-    vec = model.get_image_features(**batch)
+    _load()
 
-    # fashion-clip may return a wrapped object instead of a raw tensor
-    if not isinstance(vec, torch.Tensor):
-        if hasattr(vec, "pooler_output") and vec.pooler_output is not None:
-            vec = vec.pooler_output
-        elif hasattr(vec, "last_hidden_state"):
-            vec = vec.last_hidden_state[:, 0, :]
+    batch = _processor(
+        images=img,
+        return_tensors="pt"
+    ).to(_device)
 
+    # Forward pass through vision encoder
+    outputs = _model.vision_model(**batch)
+
+    # Extract pooled CLS embedding
+    vec = outputs.pooler_output
+
+    # L2 normalize
     vec = vec / vec.norm(dim=-1, keepdim=True)
-    return vec.cpu().numpy().astype("float32")
 
-@torch.no_grad()
-def encode_text(text):
-    inputs = processor(text=[text], return_tensors="pt", padding=True).to(device)
-    vec = model.get_text_features(**inputs)
+    result = vec.cpu().numpy().astype("float32")
 
-    if not isinstance(vec, torch.Tensor):
-        if hasattr(vec, "pooler_output") and vec.pooler_output is not None:
-            vec = vec.pooler_output
-        elif hasattr(vec, "last_hidden_state"):
-            vec = vec.last_hidden_state[:, 0, :]
+    assert result.shape == (1, 768), (
+        f"Unexpected embedding shape: {result.shape}"
+    )
 
-    vec = vec / vec.norm(dim=-1, keepdim=True)
-    return vec.cpu().numpy().astype("float32")
+    return result

backend/generate_metadata.py

@@ -1,78 +1,96 @@
 import os
 import csv
+import sys
 from PIL import Image
-from ai import encode_image
-# Root folder where product images are stored.
-# Each subfolder represents a frame style (aviator, round, etc.)
+from backend.ai import encode_image
 
 BASE_DIR = os.path.dirname(__file__)
-
 IMAGE_DIR = os.path.join(BASE_DIR, "data/images")
 META_FILE = os.path.join(BASE_DIR, "data/metadata.csv")
-# Mapping of folder names to readable product styles.
-# Keeping this explicit avoids relying on folder naming everywhere else.
+
 STYLE_MAP = {
-    "aviator": "Aviator","round": "Round","square": "Square","rimless": "Rimless","transparent":"Transparent",
+    "aviator": "Aviator",
+    "round": "Round",
+    "square": "Square",
+    "rimless": "Rimless",
+    "transparent": "Transparent",
     "rectangle": "Rectangle",
 }
-# Simple material rotation to add demo variety.
-# This keeps the dataset from feeling artificially uniform.
 MATERIALS = ["Metal", "Plastic", "Steel"]
-rows = []
-pid = 0
+
+
 def is_valid_image(filename: str) -> bool:
-     """Small helper to filter supported image formats."""
-     return filename.lower().endswith((".jpg", ".png", ".jpeg", ".webp"))
+    """Return True for supported image formats."""
+    return filename.lower().endswith((".jpg", ".jpeg", ".png", ".webp"))
 
 
-# Walk through each style folder and convert images into product records
-for folder in sorted(os.listdir(IMAGE_DIR)):
-    style = STYLE_MAP.get(folder.lower())
+def main(force: bool = False) -> None:
+    if os.path.exists(META_FILE) and not force:
+        print(f"{META_FILE} already exists. Use --force to overwrite.")
+        sys.exit(0)
 
-    # Skip unknown folders (e.g., stray files or system artifacts)
-    if not style:
-        continue
+    rows = []
+    pid = 0
 
-    folder_path = os.path.join(IMAGE_DIR, folder)
+    for folder in sorted(os.listdir(IMAGE_DIR)):
+        style = STYLE_MAP.get(folder.lower())
 
-    for img in sorted(os.listdir(folder_path)):
-        if not is_valid_image(img):
+        # Skip unknown folders (e.g. stray files or system artifacts)
+        if not style:
             continue
 
-        image_path = os.path.join(folder_path, img)
+        folder_path = os.path.join(IMAGE_DIR, folder)
 
-        # Try loading the image. If an image fails, we skip it instead of
-        # breaking the whole dataset generation process.
-        try:
-            image = Image.open(image_path).convert("RGB")
-        except Exception as e:
-            print(f"Skipping corrupted image: {image_path} ({e})")
+        # Guard against loose files sitting directly inside IMAGE_DIR
+        if not os.path.isdir(folder_path):
             continue
 
-        # Generate embedding for similarity-based search and recommendations
-        emb = encode_image(image)[0]
-
-        # Create a product entry.
-        # Some values are generated programmatically to simulate real catalog variety.
-        rows.append({
-            "product_id": pid,
-            "image": f"{folder}/{img}",
-            "brand": "Lenskart",
-            "material": MATERIALS[pid % len(MATERIALS)],
-            "price": 1800 + (pid % 6) * 300,  # small price variation for realism
-            "style": style,
-            "embedding": " ".join(map(str, emb.tolist()))
-        })
-
-        pid += 1
-
-# Write all generated products to a CSV file
-if rows:
+        for img in sorted(os.listdir(folder_path)):
+            if not is_valid_image(img):
+                continue
+
+            image_path = os.path.join(folder_path, img)
+
+            # Skip corrupted images without aborting the whole run
+            try:
+                image = Image.open(image_path).convert("RGB")
+            except Exception as e:
+                print(f"Skipping corrupted image: {image_path} ({e})")
+                continue
+
+            # Generate embedding for similarity-based search
+            emb = encode_image(image)[0]
+
+            rows.append({
+                "product_id": pid,
+                "image": f"{folder}/{img}",
+                "brand": "Lenskart",
+                "material": MATERIALS[pid % len(MATERIALS)],
+                "price": 1800 + (pid % 6) * 300,
+                "style": style,
+                # f"{x:.9g}" preserves full float32 precision (vs default str())
+                "embedding": " ".join(f"{x:.9g}" for x in emb.tolist()),
+            })
+
+            pid += 1
+
+    if not rows:
+        print("Warning: No products were generated. Check IMAGE_DIR and folder structure.")
+        sys.exit(1)
+
     with open(META_FILE, "w", newline="", encoding="utf-8") as f:
         writer = csv.DictWriter(f, fieldnames=rows[0].keys())
         writer.writeheader()
         writer.writerows(rows)
-else:
-    print("Warning: No products were generated. Check IMAGE_DIR and folder structure.")
 
-print(f"Generated {pid} products and stored them in {META_FILE}")
+    print(f"Generated {pid} products → {META_FILE}")
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Ingest product images into metadata CSV.")
+    parser.add_argument("--force", action="store_true", help="Overwrite existing metadata.csv")
+    args = parser.parse_args()
+
+    main(force=args.force)

backend/main.py

@@ -1,6 +1,9 @@
+import logging
 import os
 import csv
 from contextlib import asynccontextmanager
+from urllib.parse import quote_plus
+
 from fastapi import FastAPI, UploadFile, File, Query, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
@@ -11,22 +14,66 @@ from backend.store import VectorStore
 from backend.feedback import get_boost, record_click
 from backend.accuracy_test import run_accuracy_check
 
+logger = logging.getLogger(__name__)
+
 BASE_DIR = os.path.dirname(__file__)
-BASE_URL = "https://diwank3221-visual-search-backend.hf.space"
+BASE_URL = os.getenv("BASE_URL", "https://diwank3221-visual-search-backend.hf.space")
+SEARCH_BASE = "https://www.lenskart.com/search?q="
+
+# ---------------------------------------------------------------------------
+# Startup / shutdown
+# ---------------------------------------------------------------------------
+
+store: VectorStore
+PRODUCTS: dict[int, dict] = {}
+
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    print("\nStarting backend health check...\n")
-    run_accuracy_check()
+    global store, PRODUCTS
+
+    # Initialise heavy resources once, at startup — not at import time
+    store = VectorStore()
+    PRODUCTS = _load_catalog(os.path.join(BASE_DIR, "data/metadata.csv"))
+
+    logger.info("Starting backend health check…")
+    # run_accuracy_check()
+    logger.info("Backend ready — %d products loaded.", len(PRODUCTS))
+
     yield
-    print("\nBackend ready.\n")
+    # (add any teardown here if needed)
+
+
+def _load_catalog(path: str) -> dict[int, dict]:
+    """Read metadata.csv and return a dict keyed by product_id."""
+    products: dict[int, dict] = {}
+
+    with open(path, newline="", encoding="utf-8") as f:
+        for r in csv.DictReader(f):
+            try:
+                pid = int(r["product_id"])
+            except (KeyError, ValueError) as exc:
+                logger.warning("Skipping malformed CSV row (%s): %s", exc, r)
+                continue
+
+            # Strip any accidental "images/" prefix left in the CSV
+            r["image"] = r["image"].removeprefix("images/")
+            # NOTE: .title() was removed — it corrupts paths ("img.jpg" → "Img.Jpg")
+            products[pid] = r
+
+    return products
+
+
+# ---------------------------------------------------------------------------
+# App
+# ---------------------------------------------------------------------------
 
 app = FastAPI(title="Visual Product API", lifespan=lifespan)
 
-# Serve product images
 app.mount(
     "/images",
     StaticFiles(directory=os.path.join(BASE_DIR, "data/images")),
-    name="images"
+    name="images",
 )
 
 app.add_middleware(
@@ -36,25 +83,37 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-store = VectorStore()
-PRODUCTS = {}
-SEARCH_BASE = "https://www.lenskart.com/search?q="
 
-# Load catalog safely
-with open(os.path.join(BASE_DIR, "data/metadata.csv"), newline="", encoding="utf-8") as f:
-    for r in csv.DictReader(f):
-        r["image"] = r["image"].replace("images/", "")
-        r["image"] = r["image"].title()
-        PRODUCTS[int(r["product_id"])] = r
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _build_buy_url(style: str, material: str, price: str) -> str:
+    return SEARCH_BASE + quote_plus(f"{style} {material} glasses under {price}")
+
 
-# Helper
-def tag_image(image):
+def _tag_image(image: Image.Image) -> str | None:
+    """Classify the uploaded image into a style tag; returns None on failure."""
     try:
         return store.classify(encode_image(image))
     except Exception:
+        logger.exception("tag_image failed")
         return None
 
-# Search
+
+def _format_product(pid: int, p: dict, score: float | None = None) -> dict:
+    r = {k: v for k, v in p.items() if k != "embedding"}
+    r["image_url"] = f"{BASE_URL}/images/{p['image']}"
+    r["buy_url"] = _build_buy_url(p["style"], p["material"], p["price"])
+    if score is not None:
+        r["score"] = score
+    return r
+
+
+# ---------------------------------------------------------------------------
+# Routes
+# ---------------------------------------------------------------------------
+
 @app.post("/search")
 async def search(
     file: UploadFile = File(...),
@@ -62,62 +121,57 @@ async def search(
     max_price: int = Query(10000, ge=0),
     material: str | None = None,
     style: str | None = None,
-    frame: str | None = None
+    frame: str | None = None,
 ):
-    # Only guard image decoding – this is the most common real-world failure
     try:
         img = Image.open(file.file).convert("RGB")
     except Exception:
-        raise HTTPException(status_code=400, detail="Invalid image file")
+        raise HTTPException(status_code=400, detail="Invalid image file.")
+
     q = encode_image(img)
 
     if not store.is_eyewear(q):
-      raise HTTPException(
-        status_code=400,
-        detail="No eyewear detected. Please upload a glasses image."
-    )
+        raise HTTPException(
+            status_code=400,
+            detail="No eyewear detected. Please upload a glasses image.",
+        )
 
-    tag = tag_image(img)
-    raw = store.search(q, k=60)
+    tag = _tag_image(img)
     results = []
 
-    for item, score in raw:
+    for item, score in store.search(q, k=60):
         pid = int(item["product_id"])
         p = PRODUCTS.get(pid)
         if not p:
             continue
 
         price = int(p["price"])
-        if not (min_price <= price <= max_price): continue
-        if material and p["material"] != material: continue
-        if style and p["style"] != style: continue
-        if frame and p["style"] != frame: continue
+        if not (min_price <= price <= max_price):
+            continue
+        if material and p["material"] != material:
+            continue
+        if style and p["style"] != style:
+            continue
+        if frame and p["style"] != frame:
+            continue
 
-        r = {k: v for k, v in p.items() if k != "embedding"}
-        r["score"] = score * get_boost(pid)
-        r["image_url"] = f"{BASE_URL}/images/{r['image']}"
-        r["buy_url"] = SEARCH_BASE + f"{r['style']} {r['material']} glasses under {r['price']}".replace(" ", "+")
-        results.append(r)
+        results.append(_format_product(pid, p, score=score * get_boost(pid)))
 
     results.sort(key=lambda x: x["score"], reverse=True)
     return {"tag": tag, "results": results[:8]}
-# Product catalog
-@app.get("/products")
-def products():
-    out = []
 
-    for pid, p in PRODUCTS.items():
-        r = {k: v for k, v in p.items() if k != "embedding"}
-        r["boost"] = get_boost(pid)
-        r["image_url"] = f"{BASE_URL}/images/{r['image']}"
-        r["buy_url"] = SEARCH_BASE + f"{r['style']} {r['material']} glasses under {r['price']}".replace(" ", "+")
-        out.append(r)
 
+@app.get("/products")
+def products():
+    out = [
+        {**_format_product(pid, p), "boost": get_boost(pid)}
+        for pid, p in PRODUCTS.items()
+    ]
     out.sort(key=lambda x: x["boost"], reverse=True)
     return {"count": len(out), "results": out}
 
-# Click feedback
+
 @app.post("/click/{pid}")
 def click(pid: int):
     record_click(pid)
-    return {"status": "ok"}
+    return {"status": "ok"}

backend/store.py

@@ -1,82 +1,123 @@
 import csv
+import logging
 import os
+from collections import defaultdict
+
 import faiss
 import numpy as np
-from collections import defaultdict
+
+logger = logging.getLogger(__name__)
+
 BASE_DIR = os.path.dirname(__file__)
 META_FILE = os.path.join(BASE_DIR, "data/metadata.csv")
 INDEX_FILE = os.path.join(BASE_DIR, "index.faiss")
 CENTROID_FILE = os.path.join(BASE_DIR, "centroids.npy")
-# CLIP embedding dimension (fixed)
-DIM = 512
+
+# CLIP embedding dimension (fixed for patrickjohncyh/fashion-clip)
+DIM = 768
+# Minimum cosine similarity to the nearest style centroid for a query
+# to be considered eyewear. Calibrated empirically on the current dataset.
+_EYEWEAR_THRESHOLD = 0.53
+
+
+def _normalise(x: np.ndarray) -> np.ndarray:
+    """L2-normalise each row of a 2-D array in-place-free fashion."""
+    return x / np.linalg.norm(x, axis=-1, keepdims=True)
+
+
 class VectorStore:
     """
-    FAISS based vector store for:
-    - similarity search
-    - rough style classification
+    FAISS-backed vector store providing:
+    - k-NN similarity search over product embeddings
+    - coarse style classification via centroid cosine similarity
+    - eyewear gating to reject non-glasses queries
     """
-    def is_eyewear(self, q, threshold=0.53):
-     q = q / np.linalg.norm(q, axis=1, keepdims=True)
 
-     scores = [float(np.dot(q[0], c)) for c in self.centroids.values()]
-     return max(scores) > threshold
+    def __init__(self) -> None:
+        self.meta = self._load_meta()
 
+        if not self.meta:
+            raise RuntimeError(
+                f"No products found in {META_FILE}. Run ingest.py first."
+            )
 
-    def __init__(self):
-        self.meta = self._load_meta()
-         # Load cached index if available, otherwise build fresh
         if os.path.exists(INDEX_FILE):
-             self.index = faiss.read_index(INDEX_FILE)
+            self.index = faiss.read_index(INDEX_FILE)
+            logger.info("Loaded FAISS index from cache (%d vectors).", self.index.ntotal)
         else:
-            self._build_index() 
-        # Pre-compute normalized centroids for tagging
-        self._build_centroids() 
-    def _load_meta(self):
+            self._build_index()
+
+        # Always rebuild centroids from the CSV so they stay in sync with
+        # the metadata even when the FAISS index is loaded from cache.
+        self._build_centroids()
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _load_meta(self) -> list[dict]:
         with open(META_FILE, newline="", encoding="utf-8") as f:
             rows = list(csv.DictReader(f))
-            print(f"Loaded {len(rows)} products from metadata")
-            return rows
+        logger.info("Loaded %d products from metadata.", len(rows))
+        return rows
 
-    def _build_index(self):
+    def _build_index(self) -> None:
         vectors = []
         for r in self.meta:
             v = np.fromstring(r["embedding"], sep=" ").astype("float32")
-            v = v / np.linalg.norm(v)   # normalize stored vectors
-            vectors.append(v)
+            vectors.append(_normalise(v[np.newaxis])[0])
 
-        vectors = np.vstack(vectors)
+        matrix = np.vstack(vectors)
         self.index = faiss.IndexFlatIP(DIM)
-        self.index.add(vectors)
+        self.index.add(matrix)
         faiss.write_index(self.index, INDEX_FILE)
+        logger.info("Built FAISS index with %d vectors.", self.index.ntotal)
 
-        print(f"[VectorStore] Built FAISS index with {self.index.ntotal} vectors")
-
-    def _build_centroids(self):
-        clusters = defaultdict(list)
+    def _build_centroids(self) -> None:
+        clusters: dict[str, list[np.ndarray]] = defaultdict(list)
         for r in self.meta:
             v = np.fromstring(r["embedding"], sep=" ").astype("float32")
-            v = v / np.linalg.norm(v)   # normalize before clustering
-            clusters[r["style"]].append(v)
-        self.centroids = {}
+            clusters[r["style"]].append(_normalise(v[np.newaxis])[0])
+
+        self.centroids: dict[str, np.ndarray] = {}
         for style, vecs in clusters.items():
             c = np.mean(vecs, axis=0)
-            c = c / np.linalg.norm(c)   # normalize centroid
-            self.centroids[style] = c
-        np.save(CENTROID_FILE, self.centroids)
-        print(f"Built {len(self.centroids)} normalized style centroids")
-
-    def search(self, q, k=40):
-        # Normalize query to match index math
-        q = q / np.linalg.norm(q, axis=1, keepdims=True)
+            self.centroids[style] = _normalise(c[np.newaxis])[0]
+
+        logger.info("Built %d style centroids.", len(self.centroids))
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def is_eyewear(self, q: np.ndarray, threshold: float = _EYEWEAR_THRESHOLD) -> bool:
+        """Return True if *q* is close enough to any style centroid."""
+        q = _normalise(q)
+        scores = [float(np.dot(q[0], c)) for c in self.centroids.values()]
+        return bool(scores) and max(scores) > threshold
+
+    def search(self, q: np.ndarray, k: int = 40) -> list[tuple[dict, float]]:
+        """
+        Return the *k* most similar products to query *q*.
+
+        Filters out FAISS sentinel index -1, which is returned when
+        k > index.ntotal (not enough vectors to fill the result set).
+        """
+        q = _normalise(q)
+        k = min(k, self.index.ntotal)   # guard: k must not exceed index size
         D, I = self.index.search(q, k)
-        return [(self.meta[i], float(score)) for i, score in zip(I[0], D[0])]
-   
-    def classify(self, q):
-        q = q / np.linalg.norm(q, axis=1, keepdims=True)
-        best_style, best_score = None, -1
-        for style, centroid in self.centroids.items():
-            score = float(np.dot(q[0], centroid))
-            if score > best_score:
-                best_style, best_score = style, score
-
-        return best_style
+        return [
+            (self.meta[i], float(score))
+            for i, score in zip(I[0], D[0])
+            if i != -1          # FAISS sentinel for unfilled slots
+        ]
+
+    def classify(self, q: np.ndarray) -> str | None:
+        """Return the style name whose centroid is closest to *q*."""
+        if not self.centroids:
+            return None
+        q = _normalise(q)
+        return max(
+            self.centroids,
+            key=lambda style: float(np.dot(q[0], self.centroids[style])),
+        )