#!/usr/bin/env python3 """Reproducible EDA for the unlabeled image-to-image retrieval dataset.""" from __future__ import annotations import argparse import hashlib import json import math import os import sys import tempfile from collections import Counter, defaultdict from pathlib import Path import cv2 os.environ.setdefault("MPLCONFIGDIR", str(Path(tempfile.gettempdir()) / "matplotlib-cache")) import matplotlib import numpy as np import pandas as pd from PIL import Image, ImageDraw, ImageOps matplotlib.use("Agg") import matplotlib.pyplot as plt # noqa: E402 MANIFESTS = { "train": "train_unlabeled.json", "gallery": "public_test/public_test/gallery.json", "query": "public_test/public_test/queries.json", } PLOT_METRICS = [ "luminance_mean", "luminance_std", "blur_laplacian_var", "entropy", "high_frequency_energy", "near_black_ratio", "edge_density", ] def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--data-root", type=Path, default=Path("data/dataset2")) parser.add_argument("--output-dir", type=Path, default=Path("eda_output")) parser.add_argument("--seed", type=int, default=42) parser.add_argument("--grid-size", type=int, default=48) return parser.parse_args() def load_manifest(path: Path) -> list[dict[str, str]]: with path.open(encoding="utf-8") as handle: rows = json.load(handle) if not isinstance(rows, list): raise ValueError("manifest root must be a JSON list") for index, row in enumerate(rows): if not isinstance(row, dict) or not isinstance(row.get("image_id"), str) or not isinstance(row.get("image_path"), str): raise ValueError(f"row {index} must contain string image_id and image_path") return rows def resolve_image(data_root: Path, manifest: Path, relative: str) -> Path: rel = Path(relative) candidates = [ data_root / rel, manifest.parent / rel, manifest.parent.parent / rel, ] for candidate in candidates: if candidate.is_file(): return candidate.resolve() return candidates[0].resolve() def sha256(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as handle: for chunk in iter(lambda: handle.read(1024 * 1024), b""): digest.update(chunk) return digest.hexdigest() def image_metrics(rgb: np.ndarray) -> dict[str, float]: gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY) histogram = np.bincount(gray.ravel(), minlength=256).astype(np.float64) probabilities = histogram[histogram > 0] / gray.size blurred = cv2.GaussianBlur(gray, (0, 0), 1.0) edges = cv2.Canny(gray, 50, 150) return { "luminance_mean": float(gray.mean()), "luminance_std": float(gray.std()), "red_mean": float(rgb[..., 0].mean()), "red_std": float(rgb[..., 0].std()), "green_mean": float(rgb[..., 1].mean()), "green_std": float(rgb[..., 1].std()), "blue_mean": float(rgb[..., 2].mean()), "blue_std": float(rgb[..., 2].std()), "blur_laplacian_var": float(cv2.Laplacian(gray, cv2.CV_64F).var()), "entropy": float(-(probabilities * np.log2(probabilities)).sum()), "high_frequency_energy": float(np.mean(np.abs(gray.astype(np.float32) - blurred.astype(np.float32)))), "near_black_ratio": float(np.mean(np.all(rgb < 10, axis=2))), "edge_density": float(np.mean(edges > 0)), } def inspect_dataset(data_root: Path) -> tuple[pd.DataFrame, dict, list[str]]: records: list[dict] = [] integrity: dict = {"splits": {}, "hash_groups": {}} problems: list[str] = [] hashes: defaultdict[str, list[str]] = defaultdict(list) for split, relative_manifest in MANIFESTS.items(): manifest = data_root / relative_manifest rows = load_manifest(manifest) ids = [row["image_id"] for row in rows] paths = [row["image_path"] for row in rows] split_info = { "rows": len(rows), "unique_ids": len(set(ids)), "unique_manifest_paths": len(set(paths)), "duplicate_ids": sorted(key for key, count in Counter(ids).items() if count > 1), "duplicate_manifest_paths": sorted(key for key, count in Counter(paths).items() if count > 1), "missing": [], "broken": [], } integrity["splits"][split] = split_info for row in rows: path = resolve_image(data_root, manifest, row["image_path"]) if not path.is_file(): split_info["missing"].append(str(path)) problems.append(f"missing: {path}") continue try: with Image.open(path) as image: image.load() mode, image_format, size = image.mode, image.format, image.size rgb = np.asarray(image.convert("RGB")) digest = sha256(path) hashes[digest].append(f"{split}:{row['image_id']}") records.append( { "split": split, "image_id": row["image_id"], "manifest_path": row["image_path"], "resolved_path": str(path), "sha256": digest, "format": image_format, "mode": mode, "width": size[0], "height": size[1], "file_size_bytes": path.stat().st_size, **image_metrics(rgb), } ) except Exception as exc: # report corrupt/unsupported images and continue message = f"{path}: {type(exc).__name__}: {exc}" split_info["broken"].append(message) problems.append(f"broken: {message}") if split_info["duplicate_ids"]: problems.append(f"{split}: duplicate image_id values") if split_info["duplicate_manifest_paths"]: problems.append(f"{split}: duplicate image_path values") integrity["hash_groups"] = {digest: items for digest, items in hashes.items() if len(items) > 1} return pd.DataFrame(records), integrity, problems def create_summary(metrics: pd.DataFrame) -> pd.DataFrame: numeric = [ "width", "height", "file_size_bytes", *PLOT_METRICS, "red_mean", "red_std", "green_mean", "green_std", "blue_mean", "blue_std", ] return metrics.groupby("split")[numeric].agg(["count", "mean", "std", "min", "median", "max"]) def thumbnail(path: str, size: int = 128) -> Image.Image: with Image.open(path) as image: return ImageOps.fit(image.convert("RGB"), (size, size), method=Image.Resampling.LANCZOS) def save_grid(rows: pd.DataFrame, output: Path, title: str, limit: int = 48) -> None: rows = rows.head(limit) if rows.empty: return columns = min(8, len(rows)) item_width, image_size, label_height = 128, 128, 32 grid_rows = math.ceil(len(rows) / columns) canvas = Image.new("RGB", (columns * item_width, grid_rows * (image_size + label_height) + 28), "white") draw = ImageDraw.Draw(canvas) draw.text((6, 6), title, fill="black") for index, (_, row) in enumerate(rows.iterrows()): x = (index % columns) * item_width y = 28 + (index // columns) * (image_size + label_height) canvas.paste(thumbnail(row["resolved_path"], image_size), (x, y)) draw.text((x + 2, y + image_size + 2), str(row["image_id"])[:20], fill="black") draw.text((x + 2, y + image_size + 16), str(row["split"]), fill="black") canvas.save(output, quality=92) def save_grids(metrics: pd.DataFrame, output_dir: Path, seed: int, grid_size: int) -> None: for split in MANIFESTS: subset = metrics[metrics["split"] == split] sample = subset.sample(n=min(grid_size, len(subset)), random_state=seed) save_grid(sample, output_dir / f"grid_random_{split}.jpg", f"Random sample: {split}", grid_size) extremes = { "most_blurred": ("blur_laplacian_var", True), "most_noisy": ("high_frequency_energy", False), "darkest": ("luminance_mean", True), "brightest": ("luminance_mean", False), "most_near_black": ("near_black_ratio", False), } for name, (column, ascending) in extremes.items(): ordered = metrics.sort_values([column, "image_id"], ascending=[ascending, True]) save_grid(ordered, output_dir / f"grid_{name}.jpg", name.replace("_", " ").title(), grid_size) def save_distributions(metrics: pd.DataFrame, output: Path) -> None: figure, axes = plt.subplots(3, 3, figsize=(15, 12)) axes = axes.ravel() colors = {"train": "#4C78A8", "gallery": "#F58518", "query": "#E45756"} for axis, metric in zip(axes, PLOT_METRICS): for split in MANIFESTS: values = metrics.loc[metrics["split"] == split, metric].dropna() axis.hist(values, bins=40, density=True, alpha=0.4, label=split, color=colors[split]) axis.set_title(metric.replace("_", " ")) axis.grid(alpha=0.2) for axis in axes[len(PLOT_METRICS):]: axis.axis("off") axes[0].legend() figure.suptitle("Image degradation metrics by split", fontsize=16) figure.tight_layout() figure.savefig(output, dpi=150) plt.close(figure) def write_integrity_report(path: Path, integrity: dict, problems: list[str]) -> None: lines = ["IMAGE RETRIEVAL DATASET INTEGRITY", "=" * 33] for split, info in integrity["splits"].items(): lines.extend( [ "", f"[{split}]", f"rows: {info['rows']}", f"unique_ids: {info['unique_ids']}", f"unique_manifest_paths: {info['unique_manifest_paths']}", f"missing: {len(info['missing'])}", f"broken: {len(info['broken'])}", f"duplicate_ids: {info['duplicate_ids'] or 'none'}", f"duplicate_manifest_paths: {info['duplicate_manifest_paths'] or 'none'}", ] ) lines.extend(["", "[exact duplicate SHA-256 groups]"]) if integrity["hash_groups"]: lines.extend(f"{digest}: {', '.join(items)}" for digest, items in integrity["hash_groups"].items()) else: lines.append("none") lines.extend(["", "[problems]", *(problems or ["none"])]) path.write_text("\n".join(lines) + "\n", encoding="utf-8") def write_markdown_report(path: Path, metrics: pd.DataFrame, integrity: dict) -> None: counts = metrics.groupby("split").size().to_dict() medians = metrics.groupby("split")[PLOT_METRICS].median().reindex(MANIFESTS) lines = [ "# Image retrieval EDA", "", "## Dataset", "", f"- Readable images: **{len(metrics):,}**.", *[f"- {split}: **{counts.get(split, 0):,}** images." for split in MANIFESTS], f"- Exact duplicate groups: **{len(integrity['hash_groups'])}**.", "", "## Median degradation metrics", "", medians.round(4).to_markdown(), "", "## Distribution shift: query versus train", "", ] for metric in PLOT_METRICS: train = medians.loc["train", metric] query = medians.loc["query", metric] delta = query - train relative = delta / abs(train) * 100 if train else float("nan") lines.append(f"- `{metric}`: {delta:+.4f} ({relative:+.1f}% of train median).") lines.extend( [ "", "## Retrieval implications", "", "- Large blur/noise shifts suggest matching augmentations for representation learning.", "- Near-black regions can represent rotation borders or occlusion; avoid treating them as scene content.", "- Inspect the extreme grids before choosing color, texture, or edge-sensitive descriptors.", "- This EDA does not infer labels or perform retrieval.", "", "See `distributions.png` and the `grid_*.jpg` files for visual evidence.", ] ) path.write_text("\n".join(lines) + "\n", encoding="utf-8") def main() -> int: args = parse_args() data_root = args.data_root.resolve() output_dir = args.output_dir.resolve() if args.grid_size < 1: print("error: --grid-size must be at least 1", file=sys.stderr) return 2 missing_manifests = [str(data_root / relative) for relative in MANIFESTS.values() if not (data_root / relative).is_file()] if missing_manifests: print("error: missing manifest(s):\n " + "\n ".join(missing_manifests), file=sys.stderr) return 2 output_dir.mkdir(parents=True, exist_ok=True) try: metrics, integrity, problems = inspect_dataset(data_root) except (OSError, json.JSONDecodeError, ValueError) as exc: print(f"error: invalid manifest: {exc}", file=sys.stderr) return 2 metrics.to_csv(output_dir / "image_metrics.csv", index=False) if not metrics.empty: create_summary(metrics).to_csv(output_dir / "summary.csv") save_grids(metrics, output_dir, args.seed, args.grid_size) save_distributions(metrics, output_dir / "distributions.png") write_markdown_report(output_dir / "report.md", metrics, integrity) write_integrity_report(output_dir / "integrity_report.txt", integrity, problems) print(f"EDA complete: {len(metrics):,} readable images -> {output_dir}") if problems: print(f"Integrity failed with {len(problems)} problem(s); see integrity_report.txt", file=sys.stderr) return 1 return 0 if __name__ == "__main__": raise SystemExit(main())