#!/usr/bin/env python3 """ LAION-Tunes Search Server ========================== FastAPI server providing semantic search, BM25 text search, music similarity search, and metadata filtering over the LAION-Tunes music dataset. Features: - Vector similarity search via FAISS (tag/lyric/mood/caption/transcription embeddings) - Music audio similarity search via Whisper encoder mean-pooled embeddings - BM25 text search (tags, caption, transcription, privacy-hashed lyrics) - Combined search: vector search + BM25 + filter by aesthetics/subset + re-rank - Real-time query embedding via EmbeddingGemma 300M - Audio upload → Whisper encoder embedding → FAISS similarity search - Dark-mode HTML frontend with audio players Usage: python server.py [--port 7860] [--gpu 0] [--host 0.0.0.0] Requires: search_index/ directory built by build_search_index.py """ import os import sys import json import time import hmac import hashlib import pickle import re import sqlite3 import logging import argparse import tempfile import io import threading from pathlib import Path from typing import Optional from contextlib import asynccontextmanager import numpy as np import faiss from fastapi import FastAPI, Query, UploadFile, File, Form, Request from fastapi.responses import HTMLResponse, JSONResponse from fastapi.middleware.cors import CORSMiddleware from pydantic import BaseModel # Import BM25Index from the build script (needed for pickle deserialization) sys.path.insert(0, str(Path(__file__).parent)) from build_search_index import BM25Index # ── Paths ──────────────────────────────────────────────────────────────────── BASE_DIR = Path(__file__).parent INDEX_DIR = BASE_DIR / "search_index" HTML_PATH = BASE_DIR / "index.html" LYRICS_HMAC_KEY = b"laion-tunes-search-2026-secret-key" log = logging.getLogger("server") logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s", datefmt="%H:%M:%S") # ── Global state (loaded at startup) ───────────────────────────────────────── state = { "faiss": {}, # field -> faiss.Index "id_maps": {}, # field -> numpy array of row_ids "bm25": {}, # field -> BM25Index "db_path": None, # SQLite path "embedder": None, # SentenceTransformer model "total_tracks": 0, # Whisper encoder for music similarity "whisper_processor": None, "whisper_encoder": None, "whisper_device": None, "whisper_rid_to_idx": {}, # row_id -> faiss_idx for reverse lookup "audio_emb_cache": {}, # (ip, filename) -> {"embedding": np.array, "expires": timestamp} } # ── Audio Embedding Cache ──────────────────────────────────────────────────── CACHE_TTL = 3600 # 1 hour _cache_lock = threading.Lock() def cache_get(ip, filename): """Get cached audio embedding. Returns numpy array or None.""" key = (ip, filename) with _cache_lock: entry = state["audio_emb_cache"].get(key) if entry and entry["expires"] > time.time(): return entry["embedding"] # Expired or missing if entry: del state["audio_emb_cache"][key] return None def cache_set(ip, filename, embedding): """Cache an audio embedding.""" key = (ip, filename) with _cache_lock: state["audio_emb_cache"][key] = { "embedding": embedding, "expires": time.time() + CACHE_TTL, } # Evict expired entries (max 1000 entries) if len(state["audio_emb_cache"]) > 1000: now = time.time() expired = [k for k, v in state["audio_emb_cache"].items() if v["expires"] < now] for k in expired: del state["audio_emb_cache"][k] # ── Tokenizer (must match build_search_index.py) ───────────────────────────── _TOKEN_RE = re.compile(r"[a-z0-9]+") def tokenize(text): if not text or not isinstance(text, str): return [] return [t for t in _TOKEN_RE.findall(text.lower()) if len(t) >= 2] def tokenize_and_hash(text, secret_key=LYRICS_HMAC_KEY): tokens = tokenize(text) return [hmac.new(secret_key, t.encode(), hashlib.sha256).hexdigest()[:16] for t in tokens] # ── Startup / Shutdown ─────────────────────────────────────────────────────── def load_indices(): """Load all search indices into memory.""" log.info("Loading search indices...") # FAISS indices (including whisper) for field in ["tag", "lyric", "mood", "caption", "transcription", "whisper"]: idx_path = INDEX_DIR / f"faiss_{field}.index" map_path = INDEX_DIR / f"idmap_{field}.npy" if idx_path.exists() and map_path.exists(): state["faiss"][field] = faiss.read_index(str(idx_path)) state["id_maps"][field] = np.load(str(map_path)) log.info(f" FAISS {field}: {state['faiss'][field].ntotal:,} vectors") else: log.info(f" FAISS {field}: not found (skipped)") # Build reverse mapping for whisper (row_id -> faiss_idx) if "whisper" in state["id_maps"]: idmap = state["id_maps"]["whisper"] state["whisper_rid_to_idx"] = {int(rid): idx for idx, rid in enumerate(idmap)} log.info(f" Whisper reverse map: {len(state['whisper_rid_to_idx']):,} entries") # BM25 indices for field in ["tags", "caption", "transcription", "lyrics_hashed"]: pkl_path = INDEX_DIR / f"bm25_{field}.pkl" if pkl_path.exists(): with open(pkl_path, "rb") as f: state["bm25"][field] = pickle.load(f) log.info(f" BM25 {field}: {len(state['bm25'][field].row_ids):,} documents") else: log.info(f" BM25 {field}: not found (skipped)") # SQLite state["db_path"] = str(INDEX_DIR / "metadata.db") conn = sqlite3.connect(state["db_path"]) state["total_tracks"] = conn.execute("SELECT COUNT(*) FROM tracks").fetchone()[0] conn.close() log.info(f" SQLite: {state['total_tracks']:,} tracks") class TEIEmbedder: """Wraps Hugging Face Text Embeddings Inference HTTP API to match SentenceTransformer interface.""" def __init__(self, url): self.url = url.rstrip("/") import requests as _req self._session = _req.Session() # Warm up / verify r = self._session.post(f"{self.url}/embed", json={"inputs": "test"}) r.raise_for_status() self.dim = len(r.json()[0]) log.info(f" TEI connected at {self.url} (dim={self.dim})") def encode(self, text, normalize_embeddings=True): r = self._session.post(f"{self.url}/embed", json={"inputs": text}) r.raise_for_status() emb = np.array(r.json()[0], dtype=np.float32) if normalize_embeddings: norm = np.linalg.norm(emb) if norm > 0: emb = emb / norm return emb def load_embedder(gpu_id): """Load EmbeddingGemma 300M for real-time query embedding. Supports TEI backend (--embedder tei --tei-url URL) or SentenceTransformer. """ tei_url = getattr(app.state, "tei_url", None) if tei_url: log.info(f"Connecting to TEI backend at {tei_url}...") state["embedder"] = TEIEmbedder(tei_url) return hf_cache = str(BASE_DIR / ".hf_cache") os.environ["HF_HOME"] = hf_cache os.environ["TRANSFORMERS_CACHE"] = hf_cache import torch from sentence_transformers import SentenceTransformer # Try ONNX quantized version first (non-gated, faster on CPU) try: log.info("Loading EmbeddingGemma 300M (ONNX quantized, CPU)...") model = SentenceTransformer( "onnx-community/embeddinggemma-300m-ONNX", backend="onnx", model_kwargs={"file_name": "onnx/model_quantized.onnx"}, ) state["embedder"] = model log.info(" EmbeddingGemma ONNX (q8) loaded on CPU") return except Exception as e: log.warning(f" ONNX load failed ({e}), falling back to PyTorch...") # Fallback: PyTorch version (gated, requires HF token) log.info(f"Loading EmbeddingGemma 300M (PyTorch) on GPU {gpu_id}...") device = f"cuda:{gpu_id}" if torch.cuda.is_available() else "cpu" model = SentenceTransformer( "google/embeddinggemma-300m", device=device, model_kwargs={"torch_dtype": torch.bfloat16}, ) state["embedder"] = model log.info(f" EmbeddingGemma loaded on {device}") def load_whisper_encoder(gpu_id): """Load laion/music-whisper encoder for audio similarity search.""" if "whisper" not in state["faiss"]: log.info(" Whisper FAISS index not found, skipping encoder load") return cache_dir = str(BASE_DIR / ".hf_cache_embeddings") os.environ["HF_HOME"] = cache_dir os.environ["TRANSFORMERS_CACHE"] = cache_dir import torch from transformers import WhisperProcessor, WhisperModel device = f"cuda:{gpu_id}" if torch.cuda.is_available() else "cpu" log.info(f"Loading Music-Whisper encoder on {device}...") processor = WhisperProcessor.from_pretrained("laion/music-whisper", cache_dir=cache_dir) model = WhisperModel.from_pretrained("laion/music-whisper", cache_dir=cache_dir) if device != "cpu": encoder = model.encoder.to(device).half().eval() else: encoder = model.encoder.eval() del model if torch.cuda.is_available(): torch.cuda.empty_cache() state["whisper_processor"] = processor state["whisper_encoder"] = encoder state["whisper_device"] = device log.info(f" Music-Whisper encoder loaded on {device}") # Restore HF_HOME for EmbeddingGemma hf_cache = str(BASE_DIR / ".hf_cache") os.environ["HF_HOME"] = hf_cache os.environ["TRANSFORMERS_CACHE"] = hf_cache @asynccontextmanager async def lifespan(app: FastAPI): # Startup load_indices() load_embedder(gpu_id=app.state.gpu_id) if not getattr(app.state, "no_whisper", False): load_whisper_encoder(gpu_id=app.state.gpu_id) else: log.info("Whisper encoder loading skipped (--no-whisper)") yield # Shutdown (nothing to clean up) # ── FastAPI App ────────────────────────────────────────────────────────────── app = FastAPI(title="LAION-Tunes Search", lifespan=lifespan) app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"]) # ── Request/Response models ────────────────────────────────────────────────── class SearchRequest(BaseModel): query: str negative_query: Optional[str] = None # Negative prompt for vector search (subtracted from query) search_type: str = "bm25" # "vector" | "bm25" | "combined" vector_field: str = "caption" # "tag" | "lyric" | "mood" | "caption" | "transcription" bm25_field: str = "caption" # "tags" | "caption" | "transcription" | "lyrics_hashed" rank_by: str = "similarity" # "similarity" | "aesthetics" | "plays" | "likes" min_aesthetics: Optional[float] = None # Filter: minimum score_average min_similarity: Optional[float] = None # Filter: minimum cosine similarity subset_filter: Optional[str] = None # Filter: "suno" | "udio" etc vocal_filter: Optional[str] = None # "instrumental" | "vocals" | None (all) min_duration: Optional[float] = 60.0 # Minimum duration in seconds (default 1 min) languages: Optional[list[str]] = None # List of language codes to include, None = all negative_weight: float = 0.7 # Weight for negative query subtraction (0-1) nsfw_filter: Optional[str] = None # None=all, "sfw_only", "nsfw_only" top_k: int = 50 # Two-stage search stage2_enabled: bool = False stage2_query: Optional[str] = None stage2_search_type: str = "vector" # "vector" | "bm25" stage2_vector_field: str = "caption" stage2_bm25_field: str = "caption" stage2_top_k: int = 50 class SimilarSearchRequest(BaseModel): row_id: int top_k: int = 50 rank_by: str = "similarity" min_aesthetics: Optional[float] = None subset_filter: Optional[str] = None vocal_filter: Optional[str] = None min_duration: Optional[float] = 60.0 languages: Optional[list[str]] = None nsfw_filter: Optional[str] = None # Stage 2 stage2_enabled: bool = False stage2_query: Optional[str] = None stage2_search_type: str = "vector" stage2_vector_field: str = "caption" stage2_bm25_field: str = "caption" stage2_top_k: int = 50 # ── Helper: fetch metadata from SQLite ─────────────────────────────────────── def fetch_tracks(row_ids, conn): """Fetch track metadata for given row_ids from SQLite.""" if len(row_ids) == 0: return {} placeholders = ",".join("?" * len(row_ids)) cursor = conn.execute( f"SELECT * FROM tracks WHERE row_id IN ({placeholders})", list(int(r) for r in row_ids), ) columns = [desc[0] for desc in cursor.description] result = {} for row in cursor: d = dict(zip(columns, row)) result[d["row_id"]] = d return result def format_result(track, score=None, score_type="similarity", has_whisper_emb=False): """Format a track dict for API response.""" # Parse JSON array fields genre = json.loads(track.get("genre_tags") or "[]") scene = json.loads(track.get("scene_tags") or "[]") emotion = json.loads(track.get("emotion_tags") or "[]") return { "row_id": track["row_id"], "title": track.get("title") or "Untitled", "audio_url": track.get("audio_url") or "", "subset": track.get("subset") or "", "tags_text": track.get("tags_text") or "", "mood_text": track.get("mood_text") or "", "genre_tags": genre, "scene_tags": scene, "emotion_tags": emotion, "score_average": track.get("score_average"), "score_coherence": track.get("score_coherence"), "score_musicality": track.get("score_musicality"), "score_memorability": track.get("score_memorability"), "score_clarity": track.get("score_clarity"), "score_naturalness": track.get("score_naturalness"), "play_count": track.get("play_count") or 0, "upvote_count": track.get("upvote_count") or 0, "duration_seconds": track.get("duration_seconds"), "music_whisper_caption": track.get("music_whisper_caption") or "", "has_caption": bool(track.get("has_caption")), "has_transcription": bool(track.get("has_transcription")), "is_instrumental": bool(track.get("is_instrumental")), "language": track.get("language") or "unknown", "score": round(float(score), 4) if score is not None else None, "score_type": score_type, "has_whisper_emb": has_whisper_emb, # NSFW safety labels "nsfw_overall_label": track.get("nsfw_overall_label") or "likely_sfw", "nsfw_gore_label": track.get("nsfw_gore_label") or "likely_sfw", "nsfw_sexual_label": track.get("nsfw_sexual_label") or "likely_sfw", "nsfw_hate_label": track.get("nsfw_hate_label") or "likely_sfw", "nsfw_gore_sim": round(float(track["nsfw_gore_sim"]), 4) if track.get("nsfw_gore_sim") is not None else None, "nsfw_sexual_sim": round(float(track["nsfw_sexual_sim"]), 4) if track.get("nsfw_sexual_sim") is not None else None, "nsfw_hate_sim": round(float(track["nsfw_hate_sim"]), 4) if track.get("nsfw_hate_sim") is not None else None, } # ── Search logic ───────────────────────────────────────────────────────────── def vector_search(query_embedding, field, top_k): """Search FAISS index, return (row_ids, similarities).""" if field not in state["faiss"]: return np.array([]), np.array([]) index = state["faiss"][field] id_map = state["id_maps"][field] # Reshape for FAISS qvec = query_embedding.reshape(1, -1).astype(np.float32) k = min(top_k, index.ntotal) if k == 0: return np.array([]), np.array([]) similarities, indices = index.search(qvec, k) similarities = similarities[0] indices = indices[0] # Map FAISS indices to row_ids valid = indices >= 0 row_ids = id_map[indices[valid]] sims = similarities[valid] return row_ids, sims def bm25_search(query_text, field, top_k): """BM25 text search, return (row_ids, scores).""" if field not in state["bm25"]: return np.array([]), np.array([]) # Hash tokens for lyrics search if field == "lyrics_hashed": tokens = tokenize_and_hash(query_text) else: tokens = tokenize(query_text) return state["bm25"][field].search(tokens, top_k=top_k) def apply_filters(tracks_dict, min_aesthetics=None, subset_filter=None, min_similarity=None, scores=None, vocal_filter=None, min_duration=None, languages=None, nsfw_filter=None): """Filter tracks by criteria. Returns filtered row_ids. nsfw_filter: None=all, 'sfw_only'=exclude NSFW, 'nsfw_only'=only NSFW """ filtered = [] for row_id, track in tracks_dict.items(): if min_aesthetics is not None: avg = track.get("score_average") if avg is None or avg < min_aesthetics: continue if subset_filter: if subset_filter == "no_riffusion": if track.get("subset") == "riffusion": continue elif track.get("subset") != subset_filter: continue if min_similarity is not None and scores is not None: sim = scores.get(row_id, 0) if sim < min_similarity: continue if vocal_filter == "instrumental": if not track.get("is_instrumental"): continue elif vocal_filter == "vocals": if track.get("is_instrumental"): continue if min_duration is not None: dur = track.get("duration_seconds") if dur is not None and dur < min_duration: continue if languages: lang = track.get("language") or "unknown" if lang not in languages: continue if nsfw_filter == "sfw_only": label = track.get("nsfw_overall_label") or "likely_sfw" if label != "likely_sfw": continue elif nsfw_filter == "nsfw_only": label = track.get("nsfw_overall_label") or "likely_sfw" if label == "likely_sfw": continue filtered.append(row_id) return filtered def rank_results(row_ids, tracks_dict, rank_by, sim_scores=None): """Re-rank row_ids by the specified field.""" if rank_by in ("similarity", "music_similarity") and sim_scores: return sorted(row_ids, key=lambda r: sim_scores.get(r, 0), reverse=True) elif rank_by == "aesthetics": return sorted(row_ids, key=lambda r: tracks_dict.get(r, {}).get("score_average") or 0, reverse=True) elif rank_by == "plays": return sorted(row_ids, key=lambda r: tracks_dict.get(r, {}).get("play_count") or 0, reverse=True) elif rank_by == "likes": return sorted(row_ids, key=lambda r: tracks_dict.get(r, {}).get("upvote_count") or 0, reverse=True) return row_ids # ── Audio embedding helper ────────────────────────────────────────────────── def compute_audio_embedding(audio_bytes): """Compute mean-pooled Whisper encoder embedding from audio bytes. Returns L2-normalized 768-dim float32 numpy array. """ import torch import librosa import soundfile as sf processor = state["whisper_processor"] encoder = state["whisper_encoder"] device = state["whisper_device"] if processor is None or encoder is None: raise RuntimeError("Whisper encoder not loaded") # Write bytes to temp file, load with librosa with tempfile.NamedTemporaryFile(suffix=".audio", delete=True) as tmp: tmp.write(audio_bytes) tmp.flush() try: audio, sr = librosa.load(tmp.name, sr=16000, mono=True) except Exception: # Try soundfile as fallback audio, sr = sf.read(tmp.name) if len(audio.shape) > 1: audio = audio.mean(axis=1) if sr != 16000: audio = librosa.resample(audio, orig_sr=sr, target_sr=16000) # Trim to first 30 seconds max_samples = 30 * 16000 audio = audio[:max_samples].astype(np.float32) if len(audio) < 1600: # less than 0.1s raise ValueError("Audio too short (< 0.1 seconds)") # Process through Whisper encoder inputs = processor(audio, sampling_rate=16000, return_tensors="pt") input_features = inputs.input_features.to(device) if device != "cpu": input_features = input_features.half() with torch.no_grad(): outputs = encoder(input_features) hidden = outputs.last_hidden_state # (1, seq, 768) mean_pooled = hidden.mean(dim=1) # (1, 768) mean_pooled = torch.nn.functional.normalize(mean_pooled, p=2, dim=1) embedding = mean_pooled.cpu().float().numpy()[0] # (768,) return embedding def search_by_whisper_embedding(query_embedding, top_k, rank_by, min_aesthetics, subset_filter, vocal_filter, min_duration, languages, nsfw_filter=None): """Search whisper FAISS index with a query embedding, apply filters, return formatted results.""" t0 = time.time() has_filters = (subset_filter or vocal_filter or languages or (min_aesthetics and min_aesthetics > 0) or (min_duration and min_duration > 0)) fetch_k = max(top_k * 100, 20000) if has_filters else max(top_k * 10, 2000) # Search FAISS whisper index row_ids, sims = vector_search(query_embedding, "whisper", fetch_k) sim_scores = {} candidate_row_ids = set() for rid, sim in zip(row_ids, sims): rid = int(rid) sim_scores[rid] = float(sim) candidate_row_ids.add(rid) # Fetch metadata conn = sqlite3.connect(state["db_path"]) conn.row_factory = sqlite3.Row tracks_dict = fetch_tracks(list(candidate_row_ids), conn) # Apply filters filtered_ids = apply_filters( tracks_dict, min_aesthetics=min_aesthetics, subset_filter=subset_filter, vocal_filter=vocal_filter, min_duration=min_duration, languages=languages, nsfw_filter=nsfw_filter, ) # Rank ranked_ids = rank_results(filtered_ids, tracks_dict, rank_by, sim_scores) final_ids = ranked_ids[:top_k] # Build response whisper_rid_set = state["whisper_rid_to_idx"] results = [] for rid in final_ids: track = tracks_dict.get(rid) if not track: continue score = sim_scores.get(rid, 0) score_type = "cosine_similarity" if rank_by == "aesthetics": score = track.get("score_average") or 0 score_type = "aesthetics" elif rank_by == "plays": score = track.get("play_count") or 0 score_type = "play_count" elif rank_by == "likes": score = track.get("upvote_count") or 0 score_type = "upvote_count" r = format_result(dict(track), score=score, score_type=score_type, has_whisper_emb=(rid in whisper_rid_set)) results.append(r) conn.close() search_time_ms = (time.time() - t0) * 1000 return { "results": results, "total_candidates": len(candidate_row_ids), "total_filtered": len(filtered_ids), "total_tracks": state["total_tracks"], "search_time_ms": round(search_time_ms, 1), "search_type": "music_similarity", "vector_field": "whisper", } # ── API Endpoints ──────────────────────────────────────────────────────────── @app.get("/", response_class=HTMLResponse) async def serve_frontend(): """Serve the search frontend.""" return HTML_PATH.read_text(encoding="utf-8") @app.get("/nsfw-report", response_class=HTMLResponse) async def serve_nsfw_report(): """Serve the NSFW safety analysis report.""" report = BASE_DIR / "nsfw_safety_report.html" if report.exists(): return report.read_text(encoding="utf-8") return HTMLResponse("

Report not generated yet

", status_code=404) @app.post("/api/search") async def search(req: SearchRequest): """Main search endpoint supporting vector, BM25, and combined search.""" t0 = time.time() # Embed query (and optional negative query) t_emb_start = time.time() query_embedding = state["embedder"].encode( req.query, normalize_embeddings=True ).astype(np.float32) # Negative prompt: subtract negative embedding from positive, then re-normalize if req.negative_query and req.negative_query.strip() and req.search_type in ("vector", "combined"): neg_embedding = state["embedder"].encode( req.negative_query.strip(), normalize_embeddings=True ).astype(np.float32) weight = max(0.0, min(1.0, req.negative_weight)) query_embedding = query_embedding - weight * neg_embedding # Re-normalize to unit length for cosine similarity norm = np.linalg.norm(query_embedding) if norm > 0: query_embedding = query_embedding / norm emb_time_ms = (time.time() - t_emb_start) * 1000 conn = sqlite3.connect(state["db_path"]) conn.row_factory = sqlite3.Row # Determine candidate pool size - fetch large pool so filters don't starve results. # FAISS IndexFlatIP scans all vectors regardless of k, so large k is ~free. has_filters = (req.subset_filter or req.vocal_filter or req.languages or (req.min_aesthetics and req.min_aesthetics > 0) or (req.min_duration and req.min_duration > 0)) fetch_k = max(req.top_k * 100, 20000) if has_filters else max(req.top_k * 10, 2000) sim_scores = {} # row_id -> similarity score bm25_scores = {} # row_id -> bm25 score candidate_row_ids = set() if req.search_type in ("vector", "combined"): row_ids, sims = vector_search(query_embedding, req.vector_field, fetch_k) for rid, sim in zip(row_ids, sims): rid = int(rid) sim_scores[rid] = float(sim) candidate_row_ids.add(rid) if req.search_type in ("bm25", "combined"): row_ids, scores = bm25_search(req.query, req.bm25_field, fetch_k) for rid, score in zip(row_ids, scores): rid = int(rid) bm25_scores[rid] = float(score) candidate_row_ids.add(rid) if req.search_type == "combined" and sim_scores and bm25_scores: # For combined: intersect vector and BM25 candidates candidate_row_ids = set(sim_scores.keys()) & set(bm25_scores.keys()) if not candidate_row_ids: # If no intersection, fall back to union candidate_row_ids = set(sim_scores.keys()) | set(bm25_scores.keys()) # Fetch metadata for candidates tracks_dict = fetch_tracks(list(candidate_row_ids), conn) # Use primary scores based on search type for similarity filtering primary_scores = sim_scores if req.search_type in ("vector", "combined") else bm25_scores # Apply filters filtered_ids = apply_filters( tracks_dict, min_aesthetics=req.min_aesthetics, subset_filter=req.subset_filter, min_similarity=req.min_similarity, scores=primary_scores, vocal_filter=req.vocal_filter, min_duration=req.min_duration, languages=req.languages, nsfw_filter=req.nsfw_filter, ) # Rank ranked_ids = rank_results(filtered_ids, tracks_dict, req.rank_by, primary_scores) # Take top_k stage1_ids = ranked_ids[:req.top_k] # ── Stage 2: re-filter by a second query ──────────────────────────── stage2_scores = {} stage2_info = None if req.stage2_enabled and req.stage2_query and req.stage2_query.strip(): stage1_set = set(stage1_ids) s2_query = req.stage2_query.strip() if req.stage2_search_type == "vector": s2_emb = state["embedder"].encode(s2_query, normalize_embeddings=True).astype(np.float32) # Search with large K to cover stage1 candidates s2_fetch_k = max(len(stage1_set) * 20, 50000) s2_rids, s2_sims = vector_search(s2_emb, req.stage2_vector_field, s2_fetch_k) for rid, sim in zip(s2_rids, s2_sims): rid = int(rid) if rid in stage1_set: stage2_scores[rid] = float(sim) else: # bm25 s2_fetch_k = max(len(stage1_set) * 20, 50000) s2_rids, s2_scores_arr = bm25_search(s2_query, req.stage2_bm25_field, s2_fetch_k) for rid, sc in zip(s2_rids, s2_scores_arr): rid = int(rid) if rid in stage1_set: stage2_scores[rid] = float(sc) # Rank stage1 candidates by stage2 score, take stage2_top_k stage1_ids = sorted(stage1_ids, key=lambda r: stage2_scores.get(r, -999), reverse=True) stage1_ids = stage1_ids[:req.stage2_top_k] stage2_info = { "query": s2_query, "search_type": req.stage2_search_type, "field": req.stage2_vector_field if req.stage2_search_type == "vector" else req.stage2_bm25_field, "matched": len(stage2_scores), "returned": len(stage1_ids), } final_ids = stage1_ids # Build response whisper_rid_set = state.get("whisper_rid_to_idx", {}) results = [] for rid in final_ids: track = tracks_dict.get(rid) if not track: continue # Pick the best score to show if stage2_scores: score = stage2_scores.get(rid, 0) score_type = "cosine_similarity" if req.stage2_search_type == "vector" else "bm25" else: score = primary_scores.get(rid, 0) score_type = "cosine_similarity" if req.search_type == "vector" else "bm25" if req.rank_by == "aesthetics" and not stage2_scores: score = track.get("score_average") or 0 score_type = "aesthetics" elif req.rank_by == "plays" and not stage2_scores: score = track.get("play_count") or 0 score_type = "play_count" elif req.rank_by == "likes" and not stage2_scores: score = track.get("upvote_count") or 0 score_type = "upvote_count" r = format_result(dict(track), score=score, score_type=score_type, has_whisper_emb=(rid in whisper_rid_set)) # Attach both scores when stage2 is active if stage2_scores: r["stage1_score"] = round(primary_scores.get(rid, 0), 4) r["stage2_score"] = round(stage2_scores.get(rid, 0), 4) results.append(r) conn.close() search_time_ms = (time.time() - t0) * 1000 resp = { "results": results, "total_candidates": len(candidate_row_ids), "total_filtered": len(filtered_ids), "total_tracks": state["total_tracks"], "search_time_ms": round(search_time_ms, 1), "query_embedding_time_ms": round(emb_time_ms, 1), "search_type": req.search_type, "vector_field": req.vector_field, "bm25_field": req.bm25_field, } if stage2_info: resp["stage2"] = stage2_info return resp @app.post("/api/search_by_audio") async def search_by_audio( request: Request, audio: UploadFile = File(...), top_k: int = Form(50), rank_by: str = Form("similarity"), subset_filter: Optional[str] = Form(None), vocal_filter: Optional[str] = Form(None), min_duration: Optional[float] = Form(None), min_aesthetics: Optional[float] = Form(None), languages: Optional[str] = Form(None), # comma-separated language codes nsfw_filter: Optional[str] = Form(None), # None=all, "sfw_only", "nsfw_only" # Stage 2 fields stage2_enabled: Optional[str] = Form(None), stage2_query: Optional[str] = Form(None), stage2_search_type: Optional[str] = Form("vector"), stage2_vector_field: Optional[str] = Form("caption"), stage2_bm25_field: Optional[str] = Form("caption"), stage2_top_k: int = Form(50), ): """Search by uploaded audio: compute whisper embedding, find nearest neighbors.""" if "whisper" not in state["faiss"]: return JSONResponse(status_code=503, content={"error": "Whisper index not available"}) if state["whisper_encoder"] is None: return JSONResponse(status_code=503, content={"error": "Whisper encoder not loaded"}) t0 = time.time() # Client IP for caching client_ip = request.client.host if request.client else "unknown" filename = audio.filename or "unknown" # Check cache cached_emb = cache_get(client_ip, filename) cache_hit = cached_emb is not None if cache_hit: query_embedding = cached_emb emb_time_ms = 0.0 log.info(f"Audio embedding cache hit: {filename} from {client_ip}") else: # Read audio bytes audio_bytes = await audio.read() if len(audio_bytes) == 0: return JSONResponse(status_code=400, content={"error": "Empty audio file"}) if len(audio_bytes) > 100 * 1024 * 1024: # 100 MB limit return JSONResponse(status_code=400, content={"error": "File too large (max 100 MB)"}) # Compute embedding t_emb = time.time() try: query_embedding = compute_audio_embedding(audio_bytes) except Exception as e: return JSONResponse(status_code=400, content={"error": f"Audio processing failed: {str(e)}"}) emb_time_ms = (time.time() - t_emb) * 1000 # Cache the result cache_set(client_ip, filename, query_embedding) log.info(f"Cached audio embedding: {filename} from {client_ip} ({emb_time_ms:.0f}ms)") # Parse languages lang_list = None if languages and languages.strip(): lang_list = [l.strip() for l in languages.split(",") if l.strip()] # Parse optional floats that come as "None" strings from form min_dur = min_duration if min_duration and min_duration > 0 else None min_aes = min_aesthetics if min_aesthetics and min_aesthetics > 0 else None sub_filter = subset_filter if subset_filter and subset_filter != "null" else None voc_filter = vocal_filter if vocal_filter and vocal_filter != "null" else None nsfw_f = nsfw_filter if nsfw_filter and nsfw_filter not in ("null", "") else None result = search_by_whisper_embedding( query_embedding, top_k, rank_by, min_aes, sub_filter, voc_filter, min_dur, lang_list, nsfw_filter=nsfw_f, ) result["query_embedding_time_ms"] = round(emb_time_ms, 1) result["audio_filename"] = filename result["cache_hit"] = cache_hit # Stage 2: re-filter music similarity results by text query s2_enabled = stage2_enabled and stage2_enabled.lower() in ("true", "1", "yes") if s2_enabled and stage2_query and stage2_query.strip(): stage1_results = result["results"] stage1_set = {r["row_id"] for r in stage1_results} s2_query = stage2_query.strip() stage2_scores = {} if stage2_search_type == "vector": s2_emb = state["embedder"].encode(s2_query, normalize_embeddings=True).astype(np.float32) s2_fetch_k = max(len(stage1_set) * 20, 50000) s2_rids, s2_sims = vector_search(s2_emb, stage2_vector_field, s2_fetch_k) for rid, sim in zip(s2_rids, s2_sims): rid = int(rid) if rid in stage1_set: stage2_scores[rid] = float(sim) else: # bm25 s2_fetch_k = max(len(stage1_set) * 20, 50000) s2_rids, s2_scores_arr = bm25_search(s2_query, stage2_bm25_field, s2_fetch_k) for rid, sc in zip(s2_rids, s2_scores_arr): rid = int(rid) if rid in stage1_set: stage2_scores[rid] = float(sc) # Re-rank by stage2 score for r in stage1_results: r["stage1_score"] = r.get("score", 0) r["stage2_score"] = round(stage2_scores.get(r["row_id"], -999), 4) stage1_results.sort(key=lambda r: r["stage2_score"], reverse=True) result["results"] = stage1_results[:stage2_top_k] result["stage2"] = { "query": s2_query, "search_type": stage2_search_type, "field": stage2_vector_field if stage2_search_type == "vector" else stage2_bm25_field, "matched": len(stage2_scores), "returned": len(result["results"]), } return result @app.post("/api/search_similar") async def search_similar(req: SimilarSearchRequest): """Search for tracks similar to a given sample using pre-computed whisper embeddings.""" if "whisper" not in state["faiss"]: return JSONResponse(status_code=503, content={"error": "Whisper index not available"}) rid_to_idx = state["whisper_rid_to_idx"] if req.row_id not in rid_to_idx: return JSONResponse(status_code=404, content={ "error": f"No whisper embedding found for row_id {req.row_id}. " f"Only {len(rid_to_idx):,} of {state['total_tracks']:,} tracks have whisper embeddings." }) t0 = time.time() # Reconstruct the embedding from FAISS index faiss_idx = rid_to_idx[req.row_id] query_embedding = state["faiss"]["whisper"].reconstruct(faiss_idx) result = search_by_whisper_embedding( query_embedding, req.top_k, req.rank_by, req.min_aesthetics, req.subset_filter, req.vocal_filter, req.min_duration, req.languages, nsfw_filter=req.nsfw_filter, ) result["reference_row_id"] = req.row_id # Look up title for the reference conn = sqlite3.connect(state["db_path"]) row = conn.execute("SELECT title FROM tracks WHERE row_id=?", (req.row_id,)).fetchone() conn.close() if row: result["reference_title"] = row[0] or "Untitled" # Stage 2: re-filter music similarity results by text query if req.stage2_enabled and req.stage2_query and req.stage2_query.strip(): stage1_results = result["results"] stage1_set = {r["row_id"] for r in stage1_results} s2_query = req.stage2_query.strip() stage2_scores = {} if req.stage2_search_type == "vector": s2_emb = state["embedder"].encode(s2_query, normalize_embeddings=True).astype(np.float32) s2_fetch_k = max(len(stage1_set) * 20, 50000) s2_rids, s2_sims = vector_search(s2_emb, req.stage2_vector_field, s2_fetch_k) for rid, sim in zip(s2_rids, s2_sims): rid = int(rid) if rid in stage1_set: stage2_scores[rid] = float(sim) else: # bm25 s2_fetch_k = max(len(stage1_set) * 20, 50000) s2_rids, s2_scores_arr = bm25_search(s2_query, req.stage2_bm25_field, s2_fetch_k) for rid, sc in zip(s2_rids, s2_scores_arr): rid = int(rid) if rid in stage1_set: stage2_scores[rid] = float(sc) for r in stage1_results: r["stage1_score"] = r.get("score", 0) r["stage2_score"] = round(stage2_scores.get(r["row_id"], -999), 4) stage1_results.sort(key=lambda r: r["stage2_score"], reverse=True) result["results"] = stage1_results[:req.stage2_top_k] result["stage2"] = { "query": s2_query, "search_type": req.stage2_search_type, "field": req.stage2_vector_field if req.stage2_search_type == "vector" else req.stage2_bm25_field, "matched": len(stage2_scores), "returned": len(result["results"]), } return result @app.get("/api/stats") async def stats(): """Dataset statistics.""" conn = sqlite3.connect(state["db_path"]) total = conn.execute("SELECT COUNT(*) FROM tracks").fetchone()[0] subsets = {} for row in conn.execute("SELECT subset, COUNT(*) FROM tracks GROUP BY subset"): subsets[row[0]] = row[1] avg_scores = {} for row in conn.execute( "SELECT AVG(score_average), MIN(score_average), MAX(score_average) FROM tracks WHERE score_average IS NOT NULL" ): avg_scores = {"mean": round(row[0], 3) if row[0] else None, "min": row[1], "max": row[2]} with_caption = conn.execute("SELECT COUNT(*) FROM tracks WHERE has_caption=1").fetchone()[0] with_transcription = conn.execute("SELECT COUNT(*) FROM tracks WHERE has_transcription=1").fetchone()[0] faiss_stats = {} for field, idx in state["faiss"].items(): faiss_stats[field] = idx.ntotal bm25_stats = {} for field, idx in state["bm25"].items(): bm25_stats[field] = len(idx.row_ids) # Language distribution languages = {} for row in conn.execute( "SELECT language, COUNT(*) FROM tracks WHERE language IS NOT NULL AND language != '' " "GROUP BY language ORDER BY COUNT(*) DESC" ): languages[row[0]] = row[1] instrumental = conn.execute("SELECT COUNT(*) FROM tracks WHERE is_instrumental=1").fetchone()[0] conn.close() return { "total_tracks": total, "subsets": subsets, "score_average": avg_scores, "with_caption": with_caption, "with_transcription": with_transcription, "faiss_indices": faiss_stats, "bm25_indices": bm25_stats, "languages": languages, "instrumental_count": instrumental, "whisper_embeddings": state["faiss"]["whisper"].ntotal if "whisper" in state["faiss"] else 0, } # ── Main ───────────────────────────────────────────────────────────────────── def main(): parser = argparse.ArgumentParser(description="LAION-Tunes Search Server") parser.add_argument("--port", type=int, default=7860) parser.add_argument("--host", type=str, default="0.0.0.0") parser.add_argument("--gpu", type=int, default=0, help="GPU ID for EmbeddingGemma") parser.add_argument("--tei-url", type=str, default=None, help="Use TEI backend for embeddings (e.g. http://localhost:8090)") parser.add_argument("--no-whisper", action="store_true", help="Skip loading whisper encoder (for CPU-only deployment)") args = parser.parse_args() app.state.gpu_id = args.gpu app.state.tei_url = args.tei_url app.state.no_whisper = args.no_whisper import uvicorn uvicorn.run(app, host=args.host, port=args.port, log_level="info") if __name__ == "__main__": main()