"""Deduplication engine (global across all classes and queries). Layer 1 exact SHA-256 of the original bytes (already the image_id, so identical downloads collapse at download time) + SHA-256 of the decoded normalized pixels. Layer 2 near-dup pHash AND dHash (64-bit each) within a Hamming-distance budget. Every image also stores the hashes of its horizontally FLIPPED version, and a pair counts as a duplicate if it matches in either orientation (mirror copies). Layer 3 semantic CLIP-embedding cosine clustering. This layer never deletes anything; it only merges cluster ids so the splitter keeps "same board, different angle" together. Layers 1-2 remove images: within a duplicate group the keeper is chosen by (already-processed before new) > (real-world before web) > higher resolution > larger file > id so re-running the pipeline never swaps out an image that was already kept or annotated. Duplicate groups are connected components (union-find), so chains A~B~C collapse into one group. """ from __future__ import annotations import logging from collections import defaultdict from concurrent.futures import ThreadPoolExecutor, as_completed from pathlib import Path from typing import Sequence import imagehash import numpy as np from PIL import Image, ImageOps from tqdm import tqdm from .manifest import Manifest log = logging.getLogger(__name__) # Statuses whose images are candidates for duplicate comparison (hashes present). _PROCESSED = ("deduped", "kept", "review") _CANDIDATES = ("normalized",) + _PROCESSED _POP8 = np.array([bin(i).count("1") for i in range(256)], dtype=np.uint8) # ------------------------------------------------------------------------------------ hashing def compute_hashes(path: str | Path) -> dict[str, str]: """pHash/dHash (8x8 => 64 bit, hex) for an image and for its horizontal mirror.""" with Image.open(path) as im: im.draft("RGB", (512, 512)) # cheap JPEG downscale on decode; same procedure for all images im = ImageOps.exif_transpose(im).convert("RGB") flipped = ImageOps.mirror(im) return { "phash": str(imagehash.phash(im, hash_size=8)), "dhash": str(imagehash.dhash(im, hash_size=8)), "phash_flip": str(imagehash.phash(flipped, hash_size=8)), "dhash_flip": str(imagehash.dhash(flipped, hash_size=8)), } def hex_to_u64(values: Sequence[str]) -> np.ndarray: return np.array([int(v, 16) for v in values], dtype=np.uint64) def popcount64(x: np.ndarray) -> np.ndarray: """Per-element population count of a uint64 array.""" if hasattr(np, "bitwise_count"): # numpy >= 2.0 return np.bitwise_count(x) x = np.ascontiguousarray(x) return _POP8[x.view(np.uint8).reshape(*x.shape, 8)].sum(axis=-1) # --------------------------------------------------------------------------------- union-find class UnionFind: def __init__(self, n: int): self.parent = list(range(n)) def find(self, a: int) -> int: while self.parent[a] != a: self.parent[a] = self.parent[self.parent[a]] a = self.parent[a] return a def union(self, a: int, b: int) -> None: ra, rb = self.find(a), self.find(b) if ra != rb: self.parent[max(ra, rb)] = min(ra, rb) def groups(self) -> list[list[int]]: out: dict[int, list[int]] = defaultdict(list) for i in range(len(self.parent)): out[self.find(i)].append(i) return [g for g in out.values() if len(g) > 1] def near_duplicate_pairs(ph: np.ndarray, dh: np.ndarray, phf: np.ndarray, dhf: np.ndarray, phash_max: int, dhash_max: int, block_cells: int = 4_000_000): """Yield (i, j), i < j, whose pHash *and* dHash are within budget in the same orientation (direct, or with j mirrored). Vectorized in row blocks to bound memory.""" n = len(ph) if n < 2: return block = max(1, block_cells // n) cols = np.arange(n) for a in range(0, n, block): b = min(n, a + block) upper = cols[None, :] > np.arange(a, b)[:, None] direct = (popcount64(ph[a:b, None] ^ ph[None, :]) <= phash_max) & \ (popcount64(dh[a:b, None] ^ dh[None, :]) <= dhash_max) mirrored = (popcount64(ph[a:b, None] ^ phf[None, :]) <= phash_max) & \ (popcount64(dh[a:b, None] ^ dhf[None, :]) <= dhash_max) ii, jj = np.nonzero((direct | mirrored) & upper) for i, j in zip(ii + a, jj): yield int(i), int(j) def find_duplicate_groups(rows: list[dict], phash_max: int, dhash_max: int) -> list[list[int]]: """Group row indices by exact pixel hash + near-duplicate hashes (connected components).""" n = len(rows) uf = UnionFind(n) by_pixels: dict[str, int] = {} for i, r in enumerate(rows): px = r.get("pixel_sha256") if px: if px in by_pixels: uf.union(by_pixels[px], i) else: by_pixels[px] = i if n >= 2: ph = hex_to_u64([r["phash"] for r in rows]) dh = hex_to_u64([r["dhash"] for r in rows]) phf = hex_to_u64([r["phash_flip"] for r in rows]) dhf = hex_to_u64([r["dhash_flip"] for r in rows]) for i, j in near_duplicate_pairs(ph, dh, phf, dhf, phash_max, dhash_max): uf.union(i, j) return uf.groups() def keeper_rank(row: dict) -> tuple: """Lower sorts first = preferred keeper.""" processed = 0 if row["status"] in _PROCESSED else 1 realworld = 0 if row.get("origin") == "realworld" else 1 pixels = (row.get("norm_width") or row.get("width") or 0) * (row.get("norm_height") or row.get("height") or 0) return (processed, realworld, -pixels, -(row.get("filesize") or 0), row["image_id"]) # ------------------------------------------------------------------------------------- stage def run(manifest: Manifest, cfg: dict, data_dir: Path) -> dict[str, int]: """Hash new images, then discard exact/near duplicates across the whole candidate pool.""" dcfg = cfg["dedup"] stats = {"hashed": 0, "exact_duplicate": 0, "near_duplicate": 0, "deduped": 0, "hash_failed": 0} # 1. hashes for images that do not have them yet fresh = [r for r in manifest.images(statuses=["normalized"]) if not r["phash"]] if fresh: def work(r: dict): try: return r, compute_hashes(data_dir / r["norm_path"]), None except Exception as exc: # noqa: BLE001 return r, None, exc with ThreadPoolExecutor(max_workers=int(dcfg.get("hash_workers", 4))) as ex: futures = [ex.submit(work, r) for r in fresh] with manifest.transaction(): for fut in tqdm(as_completed(futures), total=len(futures), desc="hash", unit="img"): r, hashes, err = fut.result() if err is not None: log.warning("hashing failed for %s: %s", r["image_id"], err) manifest.discard(r["image_id"], "hash_failed") stats["hash_failed"] += 1 else: manifest.update_image(r["image_id"], **hashes) stats["hashed"] += 1 # 2. group duplicates over the full candidate pool (new + previously processed) rows = [r for r in manifest.images(statuses=_CANDIDATES) if r["phash"]] groups = find_duplicate_groups(rows, int(dcfg["phash_max_dist"]), int(dcfg["dhash_max_dist"])) log.info("dedup: %d candidates, %d duplicate group(s)", len(rows), len(groups)) discarded: set[str] = set() cluster_of: dict[str, str] = {} # cluster ids assigned during this run with manifest.transaction(): for group in groups: members = sorted((rows[i] for i in group), key=keeper_rank) keeper, losers = members[0], members[1:] # Reuse the keeper's existing cluster id: a previous semantic merge may have # renamed it, and a rerun must never undo that. cid = keeper["cluster_id"] or keeper["image_id"] for member in members: cluster_of[member["image_id"]] = cid manifest.update_image(member["image_id"], cluster_id=cid) for loser in losers: exact = bool(loser["pixel_sha256"]) and loser["pixel_sha256"] == keeper["pixel_sha256"] reason = "exact_duplicate" if exact else "near_duplicate" if loser["status"] == "normalized": manifest.discard(loser["image_id"], reason, dup_of=keeper["image_id"]) discarded.add(loser["image_id"]) stats[reason] += 1 else: # An already-processed image is never removed retroactively (it may already # be annotated); it only joins the cluster so splits stay leak-free. log.warning("kept %s although it duplicates %s (already processed)", loser["image_id"], keeper["image_id"]) # Survivors advance; singletons get their own cluster id. for r in rows: if r["status"] != "normalized" or r["image_id"] in discarded: continue updates = {"status": "deduped"} if not cluster_of.get(r["image_id"]) and not r["cluster_id"]: updates["cluster_id"] = r["image_id"] manifest.update_image(r["image_id"], **updates) stats["deduped"] += 1 log.info("dedup: %s", stats) return stats # ------------------------------------------------------------------------- semantic clustering def semantic_clusters(ids: list[str], emb: np.ndarray, threshold: float, existing: dict[str, str] | None = None, block_cells: int = 4_000_000) -> dict[str, str]: """Merge images into clusters by embedding cosine >= threshold (and by existing cluster ids). Returns image_id -> cluster id (the smallest image_id in the component, deterministic). Assumes rows of ``emb`` are L2-normalized. """ n = len(ids) uf = UnionFind(n) if existing: first_seen: dict[str, int] = {} for i, image_id in enumerate(ids): cid = existing.get(image_id) if cid: if cid in first_seen: uf.union(first_seen[cid], i) else: first_seen[cid] = i if n >= 2: block = max(1, block_cells // n) cols = np.arange(n) for a in range(0, n, block): b = min(n, a + block) sim = emb[a:b] @ emb.T ii, jj = np.nonzero((sim >= threshold) & (cols[None, :] > np.arange(a, b)[:, None])) for i, j in zip(ii + a, jj): uf.union(int(i), int(j)) comp: dict[int, list[str]] = defaultdict(list) for i, image_id in enumerate(ids): comp[uf.find(i)].append(image_id) return {image_id: min(members) for members in comp.values() for image_id in members} def run_semantic(manifest: Manifest, cfg: dict) -> dict[str, int]: """Layer 3: merge cluster ids using stored CLIP embeddings (labels only, deletes nothing).""" rows = manifest.images(statuses=["kept", "review"]) ids, emb = manifest.load_embeddings([r["image_id"] for r in rows]) if not ids: log.warning("cluster: no embeddings found (run `filter` with CLIP first); skipping") return {"clustered": 0, "merged_clusters": 0} existing = {r["image_id"]: r["cluster_id"] or r["image_id"] for r in rows} norms = np.linalg.norm(emb, axis=1, keepdims=True) emb = emb / np.clip(norms, 1e-9, None) new_ids = semantic_clusters(ids, emb, float(cfg["dedup"]["semantic_cosine"]), existing) remap: dict[str, str] = {} for image_id, new in new_ids.items(): old = existing[image_id] if old != new: remap[old] = new with manifest.transaction(): # Update *all* rows (incl. discarded duplicates) that carry a merged cluster id. for old, new in remap.items(): manifest.execute("UPDATE images SET cluster_id=? WHERE cluster_id=?", (new, old)) for image_id, new in new_ids.items(): if image_id not in remap and existing[image_id] != new: manifest.update_image(image_id, cluster_id=new) stats = {"clustered": len(ids), "merged_clusters": len(remap)} log.info("cluster: %s", stats) return stats