| """On-disk embedding cache. |
| |
| All four upstream projects re-implemented "encode once, save to disk, skip on |
| re-run". This centralises it. Embeddings are stored as ``.npy`` next to a |
| ``.ids.json`` so a cached matrix can be validated against the ids it was built |
| for (a mismatch means the corpus changed and we must re-encode). |
| """ |
|
|
| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| import os |
| import re |
| from typing import Callable, List, Sequence |
|
|
| import numpy as np |
|
|
|
|
| def _slug(s: str) -> str: |
| return re.sub(r"[^0-9A-Za-z._-]+", "_", s)[:120] |
|
|
|
|
| class EmbeddingCache: |
| def __init__(self, root: str, enabled: bool = True): |
| self.root = root |
| self.enabled = enabled |
|
|
| def _paths(self, model_tag: str, task_name: str, split: str): |
| d = os.path.join(self.root, _slug(model_tag), _slug(task_name)) |
| base = os.path.join(d, _slug(split)) |
| return d, base + ".npy", base + ".ids.json" |
|
|
| def get_or_encode( |
| self, |
| model_tag: str, |
| task_name: str, |
| split: str, |
| ids: Sequence[str], |
| encode_fn: Callable[[], np.ndarray], |
| ) -> np.ndarray: |
| """Return cached embeddings if present and ids match, else encode + save. |
| |
| ``encode_fn`` is a zero-arg closure so encoding only happens on a miss. |
| """ |
| ids = [str(i) for i in ids] |
| if not self.enabled: |
| return encode_fn().astype("float32") |
|
|
| d, emb_path, ids_path = self._paths(model_tag, task_name, split) |
| if os.path.exists(emb_path) and os.path.exists(ids_path): |
| with open(ids_path, "r", encoding="utf-8") as f: |
| cached_ids = json.load(f) |
| if _ids_match(cached_ids, ids): |
| return np.load(emb_path).astype("float32") |
|
|
| emb = encode_fn().astype("float32") |
| os.makedirs(d, exist_ok=True) |
| np.save(emb_path, emb) |
| with open(ids_path, "w", encoding="utf-8") as f: |
| json.dump({"n": len(ids), "hash": _ids_hash(ids)}, f) |
| return emb |
|
|
|
|
| def _ids_hash(ids: List[str]) -> str: |
| h = hashlib.sha1() |
| for i in ids: |
| h.update(i.encode("utf-8")) |
| h.update(b"\x00") |
| return h.hexdigest() |
|
|
|
|
| def _ids_match(cached, ids: List[str]) -> bool: |
| if isinstance(cached, dict): |
| return cached.get("n") == len(ids) and cached.get("hash") == _ids_hash(ids) |
| return list(cached) == ids |
|
|
