Spaces:
Sleeping
Sleeping
File size: 2,580 Bytes
ff7b177 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 | """
Local embedding generation using sentence-transformers.
Zero API cost. Model loaded once at startup (singleton via lifespan).
Batch processing for efficiency at 100k scale.
Model: all-MiniLM-L6-v2
- 384 dimensions
- ~80 MB on disk
- ~100ms per batch of 64 on CPU
- Embeddings are L2-normalized → cosine similarity = dot product
"""
import logging
import threading
from typing import Optional
import numpy as np
logger = logging.getLogger(__name__)
_model = None
_model_lock = threading.Lock()
def load_model(model_name: str = "all-MiniLM-L6-v2") -> None:
"""Load (or warm up) the embedding model. Call once at startup."""
global _model
with _model_lock:
if _model is not None:
return
logger.info(f"Loading embedding model: {model_name}")
try:
from sentence_transformers import SentenceTransformer
_model = SentenceTransformer(model_name)
logger.info("Embedding model ready")
except Exception as e:
logger.error(f"Failed to load embedding model: {e}")
raise
def _get_model():
global _model
if _model is None:
load_model()
return _model
def embed_texts(texts: list[str], batch_size: int = 64) -> np.ndarray:
"""
Embed a list of texts.
Returns ndarray of shape (N, 384), L2-normalized.
Cosine similarity between two rows = their dot product.
"""
model = _get_model()
if not texts:
return np.empty((0, 384), dtype=np.float32)
embeddings = model.encode(
texts,
normalize_embeddings=True,
batch_size=batch_size,
show_progress_bar=False,
)
return embeddings.astype(np.float32)
def embed_single(text: str) -> np.ndarray:
"""Embed one text. Returns shape (384,)."""
return embed_texts([text])[0]
def cosine_similarity(a: np.ndarray, b: np.ndarray) -> float:
"""
Cosine similarity between two L2-normalized vectors.
Since both are normalized, dot product == cosine similarity.
Returns value in [-1, 1].
"""
return float(np.dot(a, b))
def normalize_similarity(sim: float) -> float:
"""Map [-1, 1] similarity to [0, 1] score."""
return (sim + 1.0) / 2.0
def batch_cosine_similarity(
query: np.ndarray, corpus: np.ndarray
) -> np.ndarray:
"""
Compute cosine similarity of query against entire corpus in one shot.
query: shape (D,)
corpus: shape (N, D)
Returns: shape (N,) with scores in [-1, 1]
At 100k candidates (D=384): ~10ms on CPU.
"""
return corpus @ query
|