core/vision.py

"""Handicate vision: identify anything, and learn new concepts on the fly.

Two parts:
  1. VisionPerceiver  -- a VLM (Qwen2.5-VL) that identifies/describes an image, plus an
     image embedder (SigLIP) for the concept memory.
  2. ConceptMemory    -- a growing vector store of (image_embedding -> label). Teaching a
     new thing is instant (learn); recognizing it later is a nearest-neighbour lookup
     (no retraining). This is the "learn on the fly" mechanism.

How it ties into the improving system: the concept memory is periodically DISTILLED into
the VLM's weights (vision SFT on the accumulated (image, label) pairs) and then the raw
entries are DISCARDED -- on-the-fly knowledge becomes permanent, weighted knowledge.

Honest scope: a VLM identifies a broad range, not literally everything. The memory +
distillation is how Handicate expands to new/unusual/just-shown things over time.
"""
import json
from pathlib import Path

import numpy as np


class ConceptMemory:
    """Instant on-the-fly visual learning via an embedding store (pure numpy, testable)."""

    def __init__(self, path=None):
        self.labels = []
        self.embs = []          # list of unit-norm np.float32 vectors
        self.path = path
        if path and Path(path).exists():
            self.load()

    @staticmethod
    def _unit(v):
        v = np.asarray(v, dtype=np.float32)
        return v / (np.linalg.norm(v) + 1e-8)

    def learn(self, embedding, label):
        """Teach a new concept instantly -- no training step."""
        self.embs.append(self._unit(embedding))
        self.labels.append(label)

    def recognize(self, embedding):
        """Return (label, similarity) of the closest learned concept, or (None, 0)."""
        if not self.embs:
            return None, 0.0
        e = self._unit(embedding)
        sims = np.array([float(e @ m) for m in self.embs])
        i = int(sims.argmax())
        return self.labels[i], float(sims[i])

    def export_for_distill(self):
        """The (label, embedding) pairs to fold into the VLM, after which raw is discarded."""
        return [{"label": l, "embedding": e.tolist()} for l, e in zip(self.labels, self.embs)]

    def clear(self):
        self.labels, self.embs = [], []

    def save(self):
        if not self.path:
            return
        Path(self.path).parent.mkdir(parents=True, exist_ok=True)
        np.savez(self.path, embs=np.array(self.embs) if self.embs else np.zeros((0,)),
                 labels=np.array(self.labels, dtype=object))

    def load(self):
        d = np.load(self.path, allow_pickle=True)
        self.embs = [self._unit(e) for e in d["embs"]] if len(d["embs"]) else []
        self.labels = list(d["labels"])


class VisionPerceiver:
    """Eyes: VLM identification + image embedding. Lazy-loaded (GPU)."""

    def __init__(self, vlm="Qwen/Qwen2.5-VL-3B-Instruct",
                 embedder="google/siglip-base-patch16-224", device="cuda"):
        self.vlm_name, self.emb_name, self.device = vlm, embedder, device
        self._vlm = self._proc = self._emb = self._emb_proc = None

    def _ensure_vlm(self):
        if self._vlm is None:
            import torch
            from transformers import AutoModelForImageTextToText, AutoProcessor
            self._proc = AutoProcessor.from_pretrained(self.vlm_name)
            self._vlm = AutoModelForImageTextToText.from_pretrained(
                self.vlm_name, torch_dtype=torch.bfloat16, device_map=self.device)

    def _ensure_emb(self):
        if self._emb is None:
            import torch
            from transformers import AutoModel, AutoProcessor
            self._emb_proc = AutoProcessor.from_pretrained(self.emb_name)
            self._emb = AutoModel.from_pretrained(
                self.emb_name, torch_dtype=torch.float32, device_map=self.device)

    def identify(self, image, question="What is in this image? Identify it specifically."):
        self._ensure_vlm()
        import torch
        msgs = [{"role": "user", "content": [{"type": "image", "image": image},
                                             {"type": "text", "text": question}]}]
        inputs = self._proc.apply_chat_template(msgs, add_generation_prompt=True,
                                                tokenize=True, return_dict=True, return_tensors="pt")
        inputs = {k: v.to(self._vlm.device) for k, v in inputs.items()}
        with torch.no_grad():
            out = self._vlm.generate(**inputs, max_new_tokens=120, do_sample=False)
        return self._proc.decode(out[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True).strip()

    def embed(self, image):
        self._ensure_emb()
        import torch
        from PIL import Image
        img = Image.open(image).convert("RGB") if isinstance(image, str) else image
        inp = self._emb_proc(images=img, return_tensors="pt").to(self._emb.device)
        with torch.no_grad():
            feats = self._emb.get_image_features(**inp)
        return feats[0].float().cpu().numpy()

    def see(self, image, memory, threshold=0.85, label=None):
        """The on-the-fly loop: teach if a label is given, else recognize-or-identify."""
        emb = self.embed(image)
        if label is not None:
            memory.learn(emb, label)
            return f"learned '{label}' on the fly"
        known, sim = memory.recognize(emb)
        if known and sim >= threshold:
            return f"{known}  (recognized from memory, sim {sim:.2f})"
        desc = self.identify(image)
        return f"{desc}  (identified by VLM; teach me with a label to remember it)"