| """Per-item fingerprints for decontamination (``docs/02_DATA_PIPELINE.md`` §5). |
| |
| Each normalized item is reduced to a set of fingerprints that support exact and |
| fuzzy matching against the frozen evaluation registry: |
| |
| - exact identity: ``base_id``, ``source``/``native_id``, raw ``question_sha256``, |
| ``choices_sha256``, per-image ``image_sha256`` |
| - canonical question SHA-256: NFKC + lowercase + whitespace collapse |
| - 64-bit perceptual hash (pHash) per image |
| - 128-permutation MinHash over question *character* 5-grams |
| - 128-permutation MinHash over choice *character* 5-grams |
| - 128-permutation MinHash over OCR *token* 5-grams (populated by the P5 OCR pass; |
| left empty at P3 — OCR extraction requires the PaddleOCR service) |
| |
| The original model input is never normalized: only a fingerprint *copy* is |
| (``docs/02`` §5.1). MinHash is hand-rolled rather than delegated to ``datasketch`` |
| so the signature is a pure function of the seed and the shingles — no dependency |
| on Python's process-salted ``hash`` — which is what makes the allowlist |
| byte-identical for a fixed seed/input (``docs/07`` §5 completion condition). |
| """ |
|
|
| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| import unicodedata |
| from collections.abc import Callable, Mapping, Sequence |
| from dataclasses import asdict, dataclass, field |
| from pathlib import Path |
| from typing import Any |
|
|
| import numpy as np |
| from PIL import Image |
|
|
| from ..hashing import sha256_text |
|
|
| |
|
|
| MINHASH_PERMUTATIONS = 128 |
| |
| |
| |
| MINHASH_SEED = 20260728 |
| |
| _MERSENNE_PRIME = (1 << 61) - 1 |
| CHAR_NGRAM = 5 |
| TOKEN_NGRAM = 5 |
|
|
|
|
| def _permutations(num: int, seed: int) -> tuple[tuple[int, ...], tuple[int, ...]]: |
| """Deterministic ``(a, b)`` permutation coefficients for ``num`` hashes.""" |
| rng = np.random.default_rng(seed) |
| a = rng.integers(1, _MERSENNE_PRIME, size=num) |
| b = rng.integers(0, _MERSENNE_PRIME, size=num) |
| return tuple(int(x) for x in a), tuple(int(x) for x in b) |
|
|
|
|
| _A, _B = _permutations(MINHASH_PERMUTATIONS, MINHASH_SEED) |
|
|
|
|
| def _shingle_hash(shingle: str) -> int: |
| """Deterministic 64-bit hash of one shingle (SHA-1 prefix, not Python hash).""" |
| digest = hashlib.sha1(shingle.encode("utf-8")).digest() |
| return int.from_bytes(digest[:8], "big") |
|
|
|
|
| def char_ngrams(text: str, n: int = CHAR_NGRAM) -> list[str]: |
| """Character n-grams of ``text`` (short text yields one short shingle).""" |
| if not text: |
| return [] |
| if len(text) <= n: |
| return [text] |
| return [text[i : i + n] for i in range(len(text) - n + 1)] |
|
|
|
|
| def token_ngrams(tokens: Sequence[str], n: int = TOKEN_NGRAM) -> list[str]: |
| """Token n-grams joined by NUL (few tokens yield one joined shingle).""" |
| if not tokens: |
| return [] |
| if len(tokens) <= n: |
| return ["\0".join(tokens)] |
| return ["\0".join(tokens[i : i + n]) for i in range(len(tokens) - n + 1)] |
|
|
|
|
| def minhash_signature(shingles: Sequence[str]) -> tuple[int, ...]: |
| """128-permutation MinHash signature over ``shingles``. |
| |
| An empty shingle set yields an empty signature (treated as Jaccard 0 against |
| anything, never a false near-dup). |
| """ |
| if not shingles: |
| return () |
| hashes = [_shingle_hash(s) for s in shingles] |
| signature = [int(_MERSENNE_PRIME)] * MINHASH_PERMUTATIONS |
| for token_hash in hashes: |
| for i in range(MINHASH_PERMUTATIONS): |
| value = (_A[i] * token_hash + _B[i]) % _MERSENNE_PRIME |
| if value < signature[i]: |
| signature[i] = value |
| return tuple(signature) |
|
|
|
|
| def estimated_jaccard(sig_a: Sequence[int], sig_b: Sequence[int]) -> float: |
| """Fraction of matching signature positions (0.0 if either is empty).""" |
| if not sig_a or not sig_b: |
| return 0.0 |
| matches = sum(1 for x, y in zip(sig_a, sig_b, strict=True) if x == y) |
| return matches / len(sig_a) |
|
|
|
|
| |
|
|
|
|
| def canonical_question(text: str) -> str: |
| """NFKC, lowercase, whitespace collapse (``docs/02`` §5.1).""" |
| normalized = unicodedata.normalize("NFKC", text) |
| normalized = " ".join(normalized.split()) |
| return normalized.lower() |
|
|
|
|
| def canonical_question_sha256(text: str) -> str: |
| return sha256_text(canonical_question(text)) |
|
|
|
|
| def choice_text(choices: Sequence[Mapping[str, Any]]) -> str: |
| """Concatenated choice text in source order (the choice fingerprint input).""" |
| return " ".join(str(c.get("text", "")) for c in choices) |
|
|
|
|
| |
|
|
|
|
| def phash_hex(image_path: str | Path) -> str: |
| """64-bit perceptual hash of an image as 16 hex chars (``imagehash``).""" |
| with Image.open(Path(image_path)) as image: |
| |
| |
| from imagehash import phash |
|
|
| return str(phash(image, hash_size=8)) |
|
|
|
|
| def phash_hamming(a_hex: str, b_hex: str) -> int: |
| """Hamming distance between two pHash hex strings (``imagehash``).""" |
| from imagehash import hex_to_hash |
|
|
| return int(hex_to_hash(a_hex) - hex_to_hash(b_hex)) |
|
|
|
|
| |
|
|
|
|
| @dataclass(frozen=True) |
| class Fingerprints: |
| """All fingerprints for one normalized item or registry row.""" |
|
|
| base_id: str |
| source: str |
| source_revision: str |
| config: str |
| split: str |
| native_id: str |
| policy: str |
| question_sha256: str |
| choices_sha256: str |
| question_canonical_sha256: str |
| image_sha256: tuple[str, ...] |
| image_phash: tuple[str, ...] |
| question_minhash: tuple[int, ...] |
| choice_minhash: tuple[int, ...] |
| ocr_minhash: tuple[int, ...] = () |
| derived_from_eval: bool = False |
| raw: dict[str, Any] = field(default_factory=dict) |
|
|
| def to_record(self) -> dict[str, Any]: |
| record = asdict(self) |
| record["image_sha256"] = list(self.image_sha256) |
| record["image_phash"] = list(self.image_phash) |
| record["question_minhash"] = list(self.question_minhash) |
| record["choice_minhash"] = list(self.choice_minhash) |
| record["ocr_minhash"] = list(self.ocr_minhash) |
| return record |
|
|
|
|
| def _choices_of(row: Mapping[str, Any]) -> list[dict[str, Any]]: |
| choices = row.get("choices") or [] |
| out: list[dict[str, Any]] = [] |
| for choice in choices: |
| if isinstance(choice, Mapping): |
| out.append({"key": str(choice.get("key", "")), "text": str(choice.get("text", ""))}) |
| else: |
| out.append({"key": "", "text": str(choice)}) |
| return out |
|
|
|
|
| def fingerprint_row( |
| row: Mapping[str, Any], |
| *, |
| resolve_image: Callable[[str], str | Path] | None = None, |
| ) -> Fingerprints: |
| """Compute fingerprints for one normalized item or registry row. |
| |
| ``resolve_image`` maps an ``image_paths`` entry to an image file. When it is |
| ``None`` (e.g. the frozen registry, which carries only ``image_sha256`` and |
| no pixels), pHash is skipped and only the text/exact fingerprints are |
| produced. |
| """ |
| base_id = str(row["base_id"]) |
| question = str(row.get("question", "")) |
| choices = _choices_of(row) |
| image_paths: list[str] = list(row.get("image_paths", []) or []) |
| image_sha256: tuple[str, ...] = tuple(row.get("image_sha256", []) or []) |
|
|
| image_phash: tuple[str, ...] = () |
| if resolve_image is not None and image_paths: |
| image_phash = tuple(phash_hex(resolve_image(p)) for p in image_paths) |
|
|
| provenance = row.get("provenance") or {} |
| derived = bool(provenance.get("derived_from_eval", False)) |
|
|
| return Fingerprints( |
| base_id=base_id, |
| source=str(row.get("source", "")), |
| source_revision=str(row.get("source_revision", "")), |
| config=str(row.get("source_config", row.get("config", ""))), |
| split=str(row.get("source_split", row.get("split", ""))), |
| native_id=str(row.get("source_native_id", row.get("native_id", ""))), |
| policy=str(row.get("policy", "")), |
| question_sha256=str(row.get("question_sha256", sha256_text(question))), |
| choices_sha256=str(row.get("choices_sha256", "")), |
| question_canonical_sha256=canonical_question_sha256(question) if question else "", |
| image_sha256=image_sha256, |
| image_phash=image_phash, |
| question_minhash=minhash_signature(char_ngrams(canonical_question(question))), |
| choice_minhash=minhash_signature(char_ngrams(canonical_question(choice_text(choices)))), |
| ocr_minhash=(), |
| derived_from_eval=derived, |
| raw=_compact_raw(row), |
| ) |
|
|
|
|
| def _compact_raw(row: Mapping[str, Any]) -> dict[str, Any]: |
| """A stable JSON-serializable copy of the source row for audit/rebuild.""" |
| compacted: dict[str, Any] = json.loads(json.dumps(dict(row), sort_keys=True)) |
| return compacted |
|
|
|
|
| def ocr_signature(ocr_text: str) -> tuple[int, ...]: |
| """MinHash over OCR token 5-grams (called by the P5 OCR enrichment pass).""" |
| return minhash_signature(token_ngrams(ocr_text.split())) |
|
|
