code/vera/models.py

"""A portable registry of the pretrained biological models this harness can call.

Written so the code runs unchanged on another machine. Nothing here hardcodes a lab path:
each model is named, and resolution walks an ordered search path

    1. ``$VERA_MODEL_ROOT/<relative path>``      -- an explicit, machine-local root
    2. any directory in ``$VERA_MODEL_PATH``     -- colon-separated, like ``$PATH``
    3. the Hugging Face cache, via the hub id    -- downloaded on first use

so a new machine needs at most one environment variable, and none at all if it is willing
to download. `ensure_local` reports which rung it used, because "the model was silently
re-downloaded" and "the model was silently the wrong one" are both failures that look like
success.

Layout under a root is fixed and shallow, so a directory can be rsynced between machines
and still resolve::

    $VERA_MODEL_ROOT/
        c2s/celltype/            vandijklab/C2S-Pythia-410m-cell-type-prediction
        dna/nucleotide-transformer/  InstaDeepAI/nucleotide-transformer-v2-500m-multi-species
        dna/dnabert2/            zhihan1996/DNABERT-2-117M
"""

from __future__ import annotations

import os
from dataclasses import dataclass
from pathlib import Path

# Where a lab machine may already hold these, tried before any download. Extend rather
# than edit: an unreachable entry is skipped, so listing several machines is harmless.
FALLBACK_ROOTS = (
    Path("/srv/disk00/sshfs/pengchx3/vera_models"),
    Path("/tmp/galaxy_srv_disk00/pengchx3/vera_models"),
)


# Tasks a model can answer. Grouping by task rather than by model is deliberate: rbio1
# reports that *composing* several approximate verifiers beats any one of them, and a
# registry keyed by model cannot express "ask everything that speaks to this question".
CELL_TYPE = "cell_type"
DNA_SEQUENCE = "dna_sequence"


@dataclass(frozen=True)
class ModelSpec:
    """One callable pretrained model.

    Attributes:
        key: Short name used by callers and on the command line.
        hub_id: Hugging Face id, used for download and as the cache key. Empty for
            models that are not distributed through the hub (see `kind`).
        relpath: Location under a model root, so roots stay rsync-compatible.
        task: Which question this answers. Several models may share a task.
        kind: How to load it -- ``"hf"`` for transformers weights, ``"celltypist"`` for a
            CellTypist model resolved by name. New kinds are added here rather than by
            special-casing at call sites.
        description: What it answers, in the vocabulary of the benchmark's questions.
        tokenizer_hub_id: Where to get the tokenizer when the weights directory has
            none. Several HF repos ship weights only and expect the base model's
            tokenizer; loading `AutoTokenizer` from such a directory does not raise --
            it yields a tokenizer that encodes to ZERO tokens, and generation then fails
            with an unrelated reshape error minutes later.
        note: Anything a caller must know before trusting its output.
    """

    key: str
    hub_id: str
    relpath: str
    task: str
    description: str
    kind: str = "hf"
    tokenizer_hub_id: str = ""
    note: str = ""


REGISTRY: dict[str, ModelSpec] = {
    "c2s-celltype": ModelSpec(
        key="c2s-celltype",
        hub_id="vandijklab/C2S-Pythia-410m-cell-type-prediction",
        relpath="c2s/celltype",
        task=CELL_TYPE,
        description="cell type from a cell's ranked gene expression (Cell2Sentence)",
        # The published repo ships weights without a tokenizer; C2S-Pythia is a Pythia
        # derivative, so the base tokenizer is the correct one.
        tokenizer_hub_id="EleutherAI/pythia-410m",
        note="Cell2Sentence: input is gene symbols ordered by descending expression.",
    ),
    # A second, independent opinion on the same question. CellTypist is a different model
    # family (regression over marker genes, not a language model), so its agreement with
    # Cell2Sentence is evidence rather than a restatement -- two models that fail the same
    # way would agree confidently and teach nothing.
    "celltypist": ModelSpec(
        key="celltypist",
        hub_id="",
        relpath="celltypist",
        task=CELL_TYPE,
        description="cell type from an expression matrix (CellTypist, marker-based)",
        kind="celltypist",
        note="Resolved by CellTypist model name, e.g. Immune_All_Low.pkl.",
    ),
    "nt-500m": ModelSpec(
        key="nt-500m",
        hub_id="InstaDeepAI/nucleotide-transformer-v2-500m-multi-species",
        relpath="dna/nucleotide-transformer",
        task=DNA_SEQUENCE,
        description="embed or score a DNA sequence (Nucleotide Transformer v2)",
    ),
    "dnabert2": ModelSpec(
        key="dnabert2",
        hub_id="zhihan1996/DNABERT-2-117M",
        relpath="dna/dnabert2",
        task=DNA_SEQUENCE,
        description="embed a DNA sequence (DNABERT-2)",
    ),
}


def models_for_task(task: str) -> tuple[ModelSpec, ...]:
    """Every registered model that answers `task`, in registration order.

    Callers that want a consensus iterate this rather than naming one model, so adding a
    model to the registry widens the consensus without touching call sites.
    """
    return tuple(m for m in REGISTRY.values() if m.task == task)


def search_roots() -> list[Path]:
    """Model roots to try, most explicit first."""
    roots: list[Path] = []
    explicit = os.environ.get("VERA_MODEL_ROOT")
    if explicit:
        roots.append(Path(explicit).expanduser())
    for entry in (os.environ.get("VERA_MODEL_PATH") or "").split(os.pathsep):
        if entry.strip():
            roots.append(Path(entry.strip()).expanduser())
    roots.extend(FALLBACK_ROOTS)
    return roots


def _looks_like_a_model(path: Path) -> bool:
    """Whether `path` holds loadable weights, not just an empty placeholder.

    Checked because an interrupted copy leaves a directory that exists and fails at load
    time, several minutes into a run. Weights only -- the tokenizer is resolved separately
    by `resolve_tokenizer`, because some repos legitimately ship without one.
    """
    if not path.is_dir():
        return False
    if not (path / "config.json").is_file():
        return False
    return any(path.glob("*.safetensors")) or any(path.glob("*.bin"))


TOKENIZER_FILES = ("tokenizer.json", "tokenizer_config.json", "vocab.json",
                   "spiece.model", "merges.txt")


def has_tokenizer(path: Path) -> bool:
    """Whether a directory carries a usable tokenizer.

    Note the doubled `any`: ``any(path.glob(p) for p in ...)`` tests the truthiness of
    generator OBJECTS, which are always truthy, so that spelling returns True for an
    empty directory. This guard silently passed before it was mutation-tested.
    """
    return any(any(path.glob(name)) for name in TOKENIZER_FILES)


def resolve_tokenizer(key: str) -> tuple[str, str]:
    """Resolve where to load this model's tokenizer from.

    Returns:
        ``(target, source)`` as `resolve` does. Falls back to `tokenizer_hub_id`, then to
        the model's own hub id, when the local weights directory has no tokenizer files.
    """
    spec = REGISTRY[key]
    local = find_local(key)
    if local is not None and has_tokenizer(local):
        return str(local), "local"
    return (spec.tokenizer_hub_id or spec.hub_id), "hub"


def find_local(key: str) -> Path | None:
    """First local directory holding this model, or None.

    Raises:
        KeyError: If `key` is not registered, so a typo fails loudly rather than
            silently falling through to a download of nothing.
    """
    spec = REGISTRY[key]
    for root in search_roots():
        candidate = root / spec.relpath
        if _looks_like_a_model(candidate):
            return candidate
    return None


def resolve(key: str) -> tuple[str, str]:
    """Resolve a model to something loadable.

    Args:
        key: Registry key.

    Returns:
        ``(target, source)`` where `target` is a local path or a hub id, and `source` is
        ``"local"`` or ``"hub"``. Callers should log `source`: a silent fall-through to
        the hub is how a 15 GB re-download happens on a machine that already had the file.

    Raises:
        KeyError: If `key` is not registered.
    """
    spec = REGISTRY[key]
    if spec.kind != "hf":
        raise ValueError(f"{key!r} is a {spec.kind} model; resolve() is for hub weights")
    local = find_local(key)
    if local is not None:
        return str(local), "local"
    return spec.hub_id, "hub"


def describe() -> str:
    """One line per registered model, for a prompt or a CLI listing."""
    lines = []
    for task in sorted({m.task for m in REGISTRY.values()}):
        lines.append(f"[{task}]")
        for spec in models_for_task(task):
            if spec.kind == "hf":
                target, source = resolve(spec.key)
                where = f"{source}: {target}"
            else:
                where = spec.kind
            lines.append(f"  {spec.key:<14} {spec.description}  [{where}]")
    return "\n".join(lines)