dtoro
fa9b21856f
Face detection/recognition: - Replace YuNet + SFace with InsightFace buffalo_l (RetinaFace + ArcFace) - 512-d ArcFace embeddings (was 128-d SFace), migration 0006 resizes column - Remove YOLO person-bbox workaround — RetinaFace is accurate enough - Detection threshold 0.65 cleanly separates real faces (0.72+) from false positives on dogs/paintings (0.56-0.61) Content-type classification: - CLIP zero-shot classifier using native PyTorch text encoder + ONNX image encoder for high-quality text-image similarity - Categories: photograph, screenshot, document, receipt, meme, artwork - Writes Tag(kind=content_type) per photo via photo_tags - Margin-based confidence: top-1 vs top-2 score difference - New ClassifierSettings in config (enabled, min_confidence) - Wired into vision_fanout pipeline Tested: 6 real faces from 4 photos (zero false positives), 11/13 photos classified (8 photograph, 2 artwork, 1 meme). Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
85 lines
3.0 KiB
Python
85 lines
3.0 KiB
Python
"""
|
|
ModelRegistry — singleton that lazy-loads vision models per worker process.
|
|
|
|
Usage from Celery tasks:
|
|
|
|
from app.services.vision.registry import registry
|
|
embedder = registry.get_embedder()
|
|
vec = embedder.embed_image(img)
|
|
|
|
Models are created on first access and cached for the worker's lifetime.
|
|
The registry reads settings.vision to decide which backend to use and
|
|
where model weights live.
|
|
"""
|
|
import logging
|
|
from functools import lru_cache
|
|
|
|
from app.config import settings
|
|
from app.services.vision.base import Embedder, OCREngine, ObjectDetector, FaceProcessor, ContentClassifier
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class ModelRegistry:
|
|
"""Central access point for all vision models."""
|
|
|
|
def __init__(self):
|
|
self._vision = settings.vision
|
|
|
|
@lru_cache(maxsize=1)
|
|
def get_embedder(self) -> Embedder:
|
|
logger.info("Loading embedder: %s (backend=%s)", self._vision.embedder.name, self._vision.backend)
|
|
return self._load_backend().create_embedder()
|
|
|
|
@lru_cache(maxsize=1)
|
|
def get_ocr(self) -> OCREngine:
|
|
logger.info("Loading OCR engine (backend=%s)", self._vision.backend)
|
|
return self._load_backend().create_ocr()
|
|
|
|
@lru_cache(maxsize=1)
|
|
def get_detector(self) -> ObjectDetector:
|
|
logger.info("Loading object detector (backend=%s)", self._vision.backend)
|
|
return self._load_backend().create_detector()
|
|
|
|
@lru_cache(maxsize=1)
|
|
def get_face_processor(self) -> FaceProcessor:
|
|
logger.info("Loading face processor (backend=%s)", self._vision.backend)
|
|
return self._load_backend().create_face_processor()
|
|
|
|
@lru_cache(maxsize=1)
|
|
def get_classifier(self) -> ContentClassifier:
|
|
logger.info("Loading content classifier (backend=%s)", self._vision.backend)
|
|
return self._load_backend().create_classifier()
|
|
|
|
@lru_cache(maxsize=1)
|
|
def _load_backend(self):
|
|
"""Import and instantiate the configured backend."""
|
|
backend_name = self._vision.backend
|
|
if backend_name == "onnx":
|
|
from app.services.vision.onnx_backend import ONNXBackend
|
|
return ONNXBackend(self._vision)
|
|
elif backend_name == "rocm":
|
|
from app.services.vision.rocm_backend import ROCmBackend
|
|
return ROCmBackend(self._vision)
|
|
else:
|
|
raise ValueError(f"Unknown vision backend: {backend_name}")
|
|
|
|
def warmup(self):
|
|
"""Pre-load all enabled models. Called from Celery worker_process_init
|
|
on the vision queue to avoid cold-start latency on the first task."""
|
|
logger.info("Warming up vision models...")
|
|
self.get_embedder()
|
|
if self._vision.ocr.enabled:
|
|
self.get_ocr()
|
|
if self._vision.detector.enabled:
|
|
self.get_detector()
|
|
if self._vision.faces.enabled:
|
|
self.get_face_processor()
|
|
if self._vision.classifier.enabled:
|
|
self.get_classifier()
|
|
logger.info("Vision model warmup complete")
|
|
|
|
|
|
# Module-level singleton. Import this from tasks.
|
|
registry = ModelRegistry()
|