Upload milk10k code

.gitignore

@@ -0,0 +1,31 @@
+# Python
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.venv/
+
+# Local agent/tool state
+.agents/
+.codex/
+.understand-anything/
+
+# Data, caches, and learned weights
+data/
+feature_cache/
+checkpoints/
+*.pt
+*.pth
+*.ckpt
+
+# Generated analysis and competition outputs
+eda_output/
+diagnostics_*.csv
+diagnostics_*.png
+submission*.csv
+*.zip
+
+# Editor/OS files
+.DS_Store
+.idea/
+.vscode/
+

.pytest_cache/.gitignore

@@ -0,0 +1,2 @@
+# Created by pytest automatically.
+*

.pytest_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/spec.html

.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

.pytest_cache/v/cache/lastfailed

@@ -0,0 +1 @@
+{}

.pytest_cache/v/cache/nodeids

@@ -0,0 +1,5 @@
+[
+  "tests/test_ssl_retrieval.py::test_degradation_ranking_and_metrics",
+  "tests/test_ssl_retrieval.py::test_manifest_and_pseudo_split",
+  "tests/test_ssl_retrieval.py::test_models_losses_and_checkpoint"
+]

.understand-anything/.understandignore

@@ -0,0 +1,47 @@
+# .understandignore — patterns for files/dirs to exclude from analysis
+# Syntax: same as .gitignore (globs, # comments, ! negation, trailing / for dirs)
+# Lines below are suggestions — uncomment to activate.
+# Use ! prefix to force-include something excluded by defaults.
+#
+# Built-in defaults (always excluded unless negated):
+#   node_modules/, .git/, dist/, build/, obj/, *.lock, *.min.js, etc.
+#
+
+# --- Test file patterns (uncomment to exclude) ---
+
+# JS / TS
+# *.test.*
+# *.spec.*
+# *.snap
+# C# / .NET
+# **/*Tests.cs
+# **/*Test.cs
+# **/*Fixture.cs
+# **/*.Tests.csproj
+# Java / Kotlin
+# **/src/test/**
+# **/*Test.java
+# **/*IT.java
+# **/*Spec.kt
+# Go
+# **/*_test.go
+# C++
+# **/*_test.cc
+# **/*_test.cpp
+# **/*_test.cxx
+# **/*Test.cc
+# **/*Test.cpp
+# **/*_unittest.cc
+# **/*_unittest.cpp
+# **/*_browsertest.cc
+# **/*_benchmark.cc
+# **/*Benchmark.cpp
+
+# Generated datasets, model caches, and analysis outputs
+data/
+feature_cache/
+eda_output/
+best_submission_analysis/
+*.csv
+*.zip
+__pycache__/

.understand-anything/config.json

@@ -0,0 +1,3 @@
+{
+  "outputLanguage": "vi"
+}

.understand-anything/intermediate/assembled-graph.json

@@ -0,0 +1,1223 @@
+{
+  "nodes": [
+    {
+      "id": "file:.understand-anything/.understandignore",
+      "type": "file",
+      "name": ".understandignore",
+      "filePath": ".understand-anything/.understandignore",
+      "summary": "Danh sách quy tắc loại trừ dùng khi quét project để knowledge graph bỏ qua dữ liệu, artifact sinh ra, cache và các file không cần phân tích.",
+      "tags": [
+        "configuration",
+        "ignore-rules",
+        "knowledge-graph"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "config:.understand-anything/config.json",
+      "type": "config",
+      "name": "config.json",
+      "filePath": ".understand-anything/config.json",
+      "summary": "Cấu hình Understand Anything chọn tiếng Việt làm ngôn ngữ đầu ra cho nội dung knowledge graph.",
+      "tags": [
+        "configuration",
+        "localization",
+        "knowledge-graph"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "file:baseline_dinov3.py",
+      "type": "file",
+      "name": "baseline_dinov3.py",
+      "filePath": "baseline_dinov3.py",
+      "summary": "Pipeline baseline dạng notebook-script dùng DINOv3/ConvNeXt để trích xuất embedding, tìm kiếm cosine, thử TTA và tạo submission cho image-to-image retrieval không nhãn. File còn cung cấp kiểm tra định dạng submission và trực quan hóa kết quả.",
+      "tags": [
+        "retrieval",
+        "feature-extraction",
+        "dinov3",
+        "entry-point"
+      ],
+      "complexity": "complex",
+      "languageNotes": "Python cell markers `# %%` cho phép chạy tuần tự như notebook; inference dùng PyTorch autocast và embedding chuẩn hóa L2."
+    },
+    {
+      "id": "document:de_bai_image_to_image_retrieval.md",
+      "type": "document",
+      "name": "de_bai_image_to_image_retrieval.md",
+      "filePath": "de_bai_image_to_image_retrieval.md",
+      "summary": "Đặc tả bài thi Olympic AI về instance retrieval không nhãn, gồm dữ liệu train/public/private test, định dạng top-10 submission, chỉ số mAP@10 và các ràng buộc chống suy diễn nhãn.",
+      "tags": [
+        "documentation",
+        "problem-specification",
+        "retrieval",
+        "evaluation"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "file:eda.py",
+      "type": "file",
+      "name": "eda.py",
+      "filePath": "eda.py",
+      "summary": "CLI EDA tái lập được cho dataset retrieval không nhãn: kiểm tra manifest và tính toàn vẹn ảnh, đo thống kê suy giảm/chuyển dịch phân phối, rồi xuất CSV, báo cáo Markdown và các grid/histogram.",
+      "tags": [
+        "entry-point",
+        "eda",
+        "data-validation",
+        "visualization"
+      ],
+      "complexity": "complex",
+      "languageNotes": "Tách backend Matplotlib `Agg` để chạy headless và dùng SHA-256 phát hiện ảnh trùng chính xác giữa các split."
+    },
+    {
+      "id": "file:notebook324f4a11f8_upgraded.ipynb",
+      "type": "file",
+      "name": "notebook324f4a11f8_upgraded.ipynb",
+      "filePath": "notebook324f4a11f8_upgraded.ipynb",
+      "summary": "Notebook thử nghiệm nâng cấp pipeline image retrieval, lưu cả code cell, metadata và output thực thi để nghiên cứu các biến thể feature extraction, ranking và chẩn đoán.",
+      "tags": [
+        "notebook",
+        "retrieval",
+        "experimentation",
+        "data-science"
+      ],
+      "complexity": "complex",
+      "languageNotes": "Định dạng Jupyter Notebook JSON gói code, kết quả và metadata trong một artifact lớn."
+    },
+    {
+      "id": "file:retrieval_advanced.py",
+      "type": "file",
+      "name": "retrieval_advanced.py",
+      "filePath": "retrieval_advanced.py",
+      "summary": "Pipeline retrieval nâng cao kết hợp max-over-D4 global similarity, dense symmetric-Chamfer reranking và SIFT/RANSAC geometric reranking. Feature được cache theo model, manifest và view; pipeline xuất submission cùng diagnostics không cần nhãn.",
+      "tags": [
+        "retrieval",
+        "reranking",
+        "feature-cache",
+        "dinov3",
+        "entry-point"
+      ],
+      "complexity": "complex",
+      "languageNotes": "Script dùng `# %%` như notebook, hỗ trợ cả tensor feature map của ConvNeXt và patch-token sequence của ViT/EVA."
+    },
+    {
+      "id": "function:baseline_dinov3.py:load_manifest",
+      "type": "function",
+      "name": "load_manifest",
+      "filePath": "baseline_dinov3.py",
+      "lineRange": [
+        43,
+        51
+      ],
+      "summary": "Đọc JSON manifest và xác thực từng bản ghi có `image_id` cùng `image_path`.",
+      "tags": [
+        "validation",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:baseline_dinov3.py:resolve_image_path",
+      "type": "function",
+      "name": "resolve_image_path",
+      "filePath": "baseline_dinov3.py",
+      "lineRange": [
+        54,
+        65
+      ],
+      "summary": "Thử các gốc đường dẫn hợp lệ để ánh xạ đường dẫn ảnh trong manifest tới file thực.",
+      "tags": [
+        "path-resolution",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "class:baseline_dinov3.py:RetrievalDataset",
+      "type": "class",
+      "name": "RetrievalDataset",
+      "filePath": "baseline_dinov3.py",
+      "lineRange": [
+        68,
+        91
+      ],
+      "summary": "Dataset PyTorch nạp ảnh RGB, áp dụng view transform tùy chọn rồi preprocessing cho backbone retrieval.",
+      "tags": [
+        "data-model",
+        "dataset",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:baseline_dinov3.py:extract_features",
+      "type": "function",
+      "name": "extract_features",
+      "filePath": "baseline_dinov3.py",
+      "lineRange": [
+        133,
+        150
+      ],
+      "summary": "Chạy inference theo batch, gom ID và trả embedding đã chuẩn hóa L2 sau global pooling khi cần.",
+      "tags": [
+        "feature-extraction",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:baseline_dinov3.py:validate_submission",
+      "type": "function",
+      "name": "validate_submission",
+      "filePath": "baseline_dinov3.py",
+      "lineRange": [
+        183,
+        198
+      ],
+      "summary": "Kiểm tra tập query, số lượng và tính duy nhất của top-k gallery ID trong submission.",
+      "tags": [
+        "validation",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:baseline_dinov3.py:extract_view",
+      "type": "function",
+      "name": "extract_view",
+      "filePath": "baseline_dinov3.py",
+      "lineRange": [
+        252,
+        255
+      ],
+      "summary": "Tạo dataset/loader cho một TTA view và chuyển tiếp sang bước trích xuất feature.",
+      "tags": [
+        "feature-extraction",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:baseline_dinov3.py:show_changed_top1",
+      "type": "function",
+      "name": "show_changed_top1",
+      "filePath": "baseline_dinov3.py",
+      "lineRange": [
+        333,
+        366
+      ],
+      "summary": "Trực quan hóa các query mà lựa chọn top-1 thay đổi giữa baseline và TTA, ưu tiên trường hợp score đổi mạnh.",
+      "tags": [
+        "visualization",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "complex"
+    },
+    {
+      "id": "function:baseline_dinov3.py:show_retrievals",
+      "type": "function",
+      "name": "show_retrievals",
+      "filePath": "baseline_dinov3.py",
+      "lineRange": [
+        373,
+        394
+      ],
+      "summary": "Vẽ query cùng các gallery candidate xếp hạng cao và score tương ứng để kiểm tra định tính.",
+      "tags": [
+        "visualization",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:eda.py:parse_args",
+      "type": "function",
+      "name": "parse_args",
+      "filePath": "eda.py",
+      "lineRange": [
+        43,
+        49
+      ],
+      "summary": "Khai báo tham số CLI cho thư mục dữ liệu, thư mục output, seed và kích thước grid.",
+      "tags": [
+        "cli",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:eda.py:load_manifest",
+      "type": "function",
+      "name": "load_manifest",
+      "filePath": "eda.py",
+      "lineRange": [
+        52,
+        60
+      ],
+      "summary": "Đọc manifest JSON và xác thực mỗi hàng chứa chuỗi `image_id` cùng `image_path`.",
+      "tags": [
+        "validation",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:eda.py:resolve_image",
+      "type": "function",
+      "name": "resolve_image",
+      "filePath": "eda.py",
+      "lineRange": [
+        63,
+        73
+      ],
+      "summary": "Giải đường dẫn ảnh tương đối qua các vị trí khả dĩ quanh data root và manifest.",
+      "tags": [
+        "path-resolution",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:eda.py:sha256",
+      "type": "function",
+      "name": "sha256",
+      "filePath": "eda.py",
+      "lineRange": [
+        76,
+        81
+      ],
+      "summary": "Tính SHA-256 theo chunk để nhận diện file ảnh trùng mà không nạp toàn bộ file vào RAM.",
+      "tags": [
+        "integrity-check",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:eda.py:image_metrics",
+      "type": "function",
+      "name": "image_metrics",
+      "filePath": "eda.py",
+      "lineRange": [
+        84,
+        104
+      ],
+      "summary": "Tính các chỉ số ảnh về độ sáng, màu, blur, entropy, high-frequency energy, vùng đen và mật độ cạnh.",
+      "tags": [
+        "image-analysis",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:eda.py:inspect_dataset",
+      "type": "function",
+      "name": "inspect_dataset",
+      "filePath": "eda.py",
+      "lineRange": [
+        107,
+        168
+      ],
+      "summary": "Duyệt mọi split, xác thực ID/path/file ảnh, phát hiện bản sao SHA-256 và thu thập metric thành DataFrame.",
+      "tags": [
+        "data-validation",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "complex"
+    },
+    {
+      "id": "function:eda.py:create_summary",
+      "type": "function",
+      "name": "create_summary",
+      "filePath": "eda.py",
+      "lineRange": [
+        171,
+        176
+      ],
+      "summary": "Tổng hợp count và thống kê mô tả của các metric số theo từng split.",
+      "tags": [
+        "aggregation",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:eda.py:thumbnail",
+      "type": "function",
+      "name": "thumbnail",
+      "filePath": "eda.py",
+      "lineRange": [
+        179,
+        181
+      ],
+      "summary": "Tạo thumbnail RGB vuông bằng phép fit Lanczos từ một ảnh nguồn.",
+      "tags": [
+        "image-processing",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:eda.py:save_grid",
+      "type": "function",
+      "name": "save_grid",
+      "filePath": "eda.py",
+      "lineRange": [
+        184,
+        200
+      ],
+      "summary": "Ghép các thumbnail cùng nhãn ID/split thành một ảnh grid để kiểm tra trực quan.",
+      "tags": [
+        "visualization",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:eda.py:save_grids",
+      "type": "function",
+      "name": "save_grids",
+      "filePath": "eda.py",
+      "lineRange": [
+        203,
+        218
+      ],
+      "summary": "Sinh grid mẫu ngẫu nhiên theo split và grid các trường hợp cực trị về blur, noise hay độ sáng.",
+      "tags": [
+        "visualization",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:eda.py:save_distributions",
+      "type": "function",
+      "name": "save_distributions",
+      "filePath": "eda.py",
+      "lineRange": [
+        221,
+        237
+      ],
+      "summary": "Vẽ histogram mật độ của các metric suy giảm cho train, gallery và query.",
+      "tags": [
+        "visualization",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:eda.py:write_integrity_report",
+      "type": "function",
+      "name": "write_integrity_report",
+      "filePath": "eda.py",
+      "lineRange": [
+        240,
+        262
+      ],
+      "summary": "Ghi báo cáo text về số dòng, trùng ID/path, file thiếu/hỏng và nhóm ảnh trùng hash.",
+      "tags": [
+        "reporting",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:eda.py:write_markdown_report",
+      "type": "function",
+      "name": "write_markdown_report",
+      "filePath": "eda.py",
+      "lineRange": [
+        265,
+        303
+      ],
+      "summary": "Ghi báo cáo Markdown tóm tắt dataset, median metric, distribution shift và hàm ý retrieval.",
+      "tags": [
+        "reporting",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "complex"
+    },
+    {
+      "id": "function:eda.py:main",
+      "type": "function",
+      "name": "main",
+      "filePath": "eda.py",
+      "lineRange": [
+        306,
+        337
+      ],
+      "summary": "Điều phối CLI EDA, kiểm tra input, tạo artifact và trả exit code phản ánh lỗi dữ liệu.",
+      "tags": [
+        "entry-point",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "complex"
+    },
+    {
+      "id": "function:retrieval_advanced.py:load_manifest",
+      "type": "function",
+      "name": "load_manifest",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        50,
+        58
+      ],
+      "summary": "Đọc và xác thực manifest ảnh dưới dạng danh sách các bản ghi ID/path.",
+      "tags": [
+        "validation",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:retrieval_advanced.py:resolve_image_path",
+      "type": "function",
+      "name": "resolve_image_path",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        61,
+        67
+      ],
+      "summary": "Giải đường dẫn ảnh tương đối từ data root hoặc các thư mục cha của manifest.",
+      "tags": [
+        "path-resolution",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:retrieval_advanced.py:apply_d4",
+      "type": "function",
+      "name": "apply_d4",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        80,
+        93
+      ],
+      "summary": "Áp dụng một trong tám phép biến đổi nhóm D4 gồm quay và lật ảnh.",
+      "tags": [
+        "augmentation",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "class:retrieval_advanced.py:ImageDataset",
+      "type": "class",
+      "name": "ImageDataset",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        96,
+        110
+      ],
+      "summary": "Dataset PyTorch nạp ảnh RGB, bảo toàn kích thước qua D4 view rồi áp dụng transform của model.",
+      "tags": [
+        "data-model",
+        "dataset",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:retrieval_advanced.py:cache_key",
+      "type": "function",
+      "name": "cache_key",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        114,
+        118
+      ],
+      "summary": "Băm nội dung manifest cùng model, split, view và phiên bản dense feature để định danh cache.",
+      "tags": [
+        "feature-cache",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:retrieval_advanced.py:cache_path",
+      "type": "function",
+      "name": "cache_path",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        121,
+        123
+      ],
+      "summary": "Tạo đường dẫn cache feature an toàn từ tên model và cache key.",
+      "tags": [
+        "feature-cache",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:retrieval_advanced.py:split_global_dense",
+      "type": "function",
+      "name": "split_global_dense",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        126,
+        146
+      ],
+      "summary": "Chuyển output backbone thành global embedding và dense spatial descriptors chuẩn hóa, hỗ trợ ConvNeXt lẫn ViT/EVA.",
+      "tags": [
+        "feature-extraction",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:retrieval_advanced.py:extract_and_cache",
+      "type": "function",
+      "name": "extract_and_cache",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        150,
+        186
+      ],
+      "summary": "Tái sử dụng cache hợp lệ hoặc chạy batched inference để lưu global và dense feature theo D4 view.",
+      "tags": [
+        "feature-cache",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "complex"
+    },
+    {
+      "id": "function:retrieval_advanced.py:make_submission",
+      "type": "function",
+      "name": "make_submission",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        247,
+        258
+      ],
+      "summary": "Chuyển ranking tensor thành CSV top-10, đồng thời xác thực query và gallery ID không trùng.",
+      "tags": [
+        "serialization",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:retrieval_advanced.py:row_minmax",
+      "type": "function",
+      "name": "row_minmax",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        266,
+        268
+      ],
+      "summary": "Chuẩn hóa từng hàng score về khoảng min-max với mẫu số được chặn để tránh chia cho zero.",
+      "tags": [
+        "normalization",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:retrieval_advanced.py:local_features",
+      "type": "function",
+      "name": "local_features",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        297,
+        304
+      ],
+      "summary": "Phóng to ảnh xám, tăng tương phản CLAHE và trích xuất SIFT keypoint/descriptor.",
+      "tags": [
+        "feature-extraction",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:retrieval_advanced.py:geometric_score",
+      "type": "function",
+      "name": "geometric_score",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        307,
+        322
+      ],
+      "summary": "Ghép SIFT bằng ratio test, ước lượng homography RANSAC và tạo score từ số lượng cùng tỷ lệ inlier.",
+      "tags": [
+        "geometric-verification",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:retrieval_advanced.py:overlap",
+      "type": "function",
+      "name": "overlap",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        349,
+        350
+      ],
+      "summary": "Tính overlap trung bình giữa hai tập top-k ranking cho mọi query.",
+      "tags": [
+        "evaluation",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:retrieval_advanced.py:show_top1_comparison",
+      "type": "function",
+      "name": "show_top1_comparison",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        379,
+        396
+      ],
+      "summary": "Vẽ top-1 của global, dense và geometry cạnh query để so sánh định tính.",
+      "tags": [
+        "visualization",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    }
+  ],
+  "edges": [
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:load_manifest",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:load_manifest",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:resolve_image_path",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:resolve_image_path",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "class:baseline_dinov3.py:RetrievalDataset",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "class:baseline_dinov3.py:RetrievalDataset",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:extract_features",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:extract_features",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:validate_submission",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:validate_submission",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:extract_view",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:extract_view",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:show_changed_top1",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:show_changed_top1",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:show_retrievals",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:show_retrievals",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:parse_args",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:parse_args",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:load_manifest",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:load_manifest",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:resolve_image",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:resolve_image",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:sha256",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:sha256",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:image_metrics",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:image_metrics",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:inspect_dataset",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:inspect_dataset",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:create_summary",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:create_summary",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:thumbnail",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:thumbnail",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:save_grid",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:save_grid",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:save_grids",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:save_grids",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:save_distributions",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:save_distributions",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:write_integrity_report",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:write_integrity_report",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:write_markdown_report",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:write_markdown_report",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:main",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:main",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:load_manifest",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:load_manifest",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:resolve_image_path",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:resolve_image_path",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:apply_d4",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:apply_d4",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "class:retrieval_advanced.py:ImageDataset",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "class:retrieval_advanced.py:ImageDataset",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:cache_key",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:cache_key",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:cache_path",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:cache_path",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:split_global_dense",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:split_global_dense",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:extract_and_cache",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:extract_and_cache",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:make_submission",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:make_submission",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:row_minmax",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:row_minmax",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:local_features",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:local_features",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:geometric_score",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:geometric_score",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:overlap",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:overlap",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:show_top1_comparison",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:show_top1_comparison",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    }
+  ]
+}

.understand-anything/intermediate/batch-1.json

@@ -0,0 +1,1224 @@
+{
+  "nodes": [
+    {
+      "id": "file:.understand-anything/.understandignore",
+      "type": "file",
+      "name": ".understandignore",
+      "filePath": ".understand-anything/.understandignore",
+      "summary": "Danh sách quy tắc loại trừ dùng khi quét project để knowledge graph bỏ qua dữ liệu, artifact sinh ra, cache và các file không cần phân tích.",
+      "tags": [
+        "configuration",
+        "ignore-rules",
+        "knowledge-graph"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "config:.understand-anything/config.json",
+      "type": "config",
+      "name": "config.json",
+      "filePath": ".understand-anything/config.json",
+      "summary": "Cấu hình Understand Anything chọn tiếng Việt làm ngôn ngữ đầu ra cho nội dung knowledge graph.",
+      "tags": [
+        "configuration",
+        "localization",
+        "knowledge-graph"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "file:baseline_dinov3.py",
+      "type": "file",
+      "name": "baseline_dinov3.py",
+      "filePath": "baseline_dinov3.py",
+      "summary": "Pipeline baseline dạng notebook-script dùng DINOv3/ConvNeXt để trích xuất embedding, tìm kiếm cosine, thử TTA và tạo submission cho image-to-image retrieval không nhãn. File còn cung cấp kiểm tra định dạng submission và trực quan hóa kết quả.",
+      "tags": [
+        "retrieval",
+        "feature-extraction",
+        "dinov3",
+        "entry-point"
+      ],
+      "complexity": "complex",
+      "languageNotes": "Python cell markers `# %%` cho phép chạy tuần tự như notebook; inference dùng PyTorch autocast và embedding chuẩn hóa L2."
+    },
+    {
+      "id": "document:de_bai_image_to_image_retrieval.md",
+      "type": "document",
+      "name": "de_bai_image_to_image_retrieval.md",
+      "filePath": "de_bai_image_to_image_retrieval.md",
+      "summary": "Đặc tả bài thi Olympic AI về instance retrieval không nhãn, gồm dữ liệu train/public/private test, định dạng top-10 submission, chỉ số mAP@10 và các ràng buộc chống suy diễn nhãn.",
+      "tags": [
+        "documentation",
+        "problem-specification",
+        "retrieval",
+        "evaluation"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "file:eda.py",
+      "type": "file",
+      "name": "eda.py",
+      "filePath": "eda.py",
+      "summary": "CLI EDA tái lập được cho dataset retrieval không nhãn: kiểm tra manifest và tính toàn vẹn ảnh, đo thống kê suy giảm/chuyển dịch phân phối, rồi xuất CSV, báo cáo Markdown và các grid/histogram.",
+      "tags": [
+        "entry-point",
+        "eda",
+        "data-validation",
+        "visualization"
+      ],
+      "complexity": "complex",
+      "languageNotes": "Tách backend Matplotlib `Agg` để chạy headless và dùng SHA-256 phát hiện ảnh trùng chính xác giữa các split."
+    },
+    {
+      "id": "file:notebook324f4a11f8_upgraded.ipynb",
+      "type": "file",
+      "name": "notebook324f4a11f8_upgraded.ipynb",
+      "filePath": "notebook324f4a11f8_upgraded.ipynb",
+      "summary": "Notebook thử nghiệm nâng cấp pipeline image retrieval, lưu cả code cell, metadata và output thực thi để nghiên cứu các biến thể feature extraction, ranking và chẩn đoán.",
+      "tags": [
+        "notebook",
+        "retrieval",
+        "experimentation",
+        "data-science"
+      ],
+      "complexity": "complex",
+      "languageNotes": "Định dạng Jupyter Notebook JSON gói code, kết quả và metadata trong một artifact lớn."
+    },
+    {
+      "id": "file:retrieval_advanced.py",
+      "type": "file",
+      "name": "retrieval_advanced.py",
+      "filePath": "retrieval_advanced.py",
+      "summary": "Pipeline retrieval nâng cao kết hợp max-over-D4 global similarity, dense symmetric-Chamfer reranking và SIFT/RANSAC geometric reranking. Feature được cache theo model, manifest và view; pipeline xuất submission cùng diagnostics không cần nhãn.",
+      "tags": [
+        "retrieval",
+        "reranking",
+        "feature-cache",
+        "dinov3",
+        "entry-point"
+      ],
+      "complexity": "complex",
+      "languageNotes": "Script dùng `# %%` như notebook, hỗ trợ cả tensor feature map của ConvNeXt và patch-token sequence của ViT/EVA."
+    },
+    {
+      "id": "function:baseline_dinov3.py:load_manifest",
+      "type": "function",
+      "name": "load_manifest",
+      "filePath": "baseline_dinov3.py",
+      "lineRange": [
+        43,
+        51
+      ],
+      "summary": "Đọc JSON manifest và xác thực từng bản ghi có `image_id` cùng `image_path`.",
+      "tags": [
+        "validation",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:baseline_dinov3.py:resolve_image_path",
+      "type": "function",
+      "name": "resolve_image_path",
+      "filePath": "baseline_dinov3.py",
+      "lineRange": [
+        54,
+        65
+      ],
+      "summary": "Thử các gốc đường dẫn hợp lệ để ánh xạ đường dẫn ảnh trong manifest tới file thực.",
+      "tags": [
+        "path-resolution",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "class:baseline_dinov3.py:RetrievalDataset",
+      "type": "class",
+      "name": "RetrievalDataset",
+      "filePath": "baseline_dinov3.py",
+      "lineRange": [
+        68,
+        91
+      ],
+      "summary": "Dataset PyTorch nạp ảnh RGB, áp dụng view transform tùy chọn rồi preprocessing cho backbone retrieval.",
+      "tags": [
+        "data-model",
+        "dataset",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:baseline_dinov3.py:extract_features",
+      "type": "function",
+      "name": "extract_features",
+      "filePath": "baseline_dinov3.py",
+      "lineRange": [
+        133,
+        150
+      ],
+      "summary": "Chạy inference theo batch, gom ID và trả embedding đã chuẩn hóa L2 sau global pooling khi cần.",
+      "tags": [
+        "feature-extraction",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:baseline_dinov3.py:validate_submission",
+      "type": "function",
+      "name": "validate_submission",
+      "filePath": "baseline_dinov3.py",
+      "lineRange": [
+        183,
+        198
+      ],
+      "summary": "Kiểm tra tập query, số lượng và tính duy nhất của top-k gallery ID trong submission.",
+      "tags": [
+        "validation",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:baseline_dinov3.py:extract_view",
+      "type": "function",
+      "name": "extract_view",
+      "filePath": "baseline_dinov3.py",
+      "lineRange": [
+        252,
+        255
+      ],
+      "summary": "Tạo dataset/loader cho một TTA view và chuyển tiếp sang bước trích xuất feature.",
+      "tags": [
+        "feature-extraction",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:baseline_dinov3.py:show_changed_top1",
+      "type": "function",
+      "name": "show_changed_top1",
+      "filePath": "baseline_dinov3.py",
+      "lineRange": [
+        333,
+        366
+      ],
+      "summary": "Trực quan hóa các query mà lựa chọn top-1 thay đổi giữa baseline và TTA, ưu tiên trường hợp score đổi mạnh.",
+      "tags": [
+        "visualization",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "complex"
+    },
+    {
+      "id": "function:baseline_dinov3.py:show_retrievals",
+      "type": "function",
+      "name": "show_retrievals",
+      "filePath": "baseline_dinov3.py",
+      "lineRange": [
+        373,
+        394
+      ],
+      "summary": "Vẽ query cùng các gallery candidate xếp hạng cao và score tương ứng để kiểm tra định tính.",
+      "tags": [
+        "visualization",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:eda.py:parse_args",
+      "type": "function",
+      "name": "parse_args",
+      "filePath": "eda.py",
+      "lineRange": [
+        43,
+        49
+      ],
+      "summary": "Khai báo tham số CLI cho thư mục dữ liệu, thư mục output, seed và kích thước grid.",
+      "tags": [
+        "cli",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:eda.py:load_manifest",
+      "type": "function",
+      "name": "load_manifest",
+      "filePath": "eda.py",
+      "lineRange": [
+        52,
+        60
+      ],
+      "summary": "Đọc manifest JSON và xác thực mỗi hàng chứa chuỗi `image_id` cùng `image_path`.",
+      "tags": [
+        "validation",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:eda.py:resolve_image",
+      "type": "function",
+      "name": "resolve_image",
+      "filePath": "eda.py",
+      "lineRange": [
+        63,
+        73
+      ],
+      "summary": "Giải đường dẫn ảnh tương đối qua các vị trí khả dĩ quanh data root và manifest.",
+      "tags": [
+        "path-resolution",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:eda.py:sha256",
+      "type": "function",
+      "name": "sha256",
+      "filePath": "eda.py",
+      "lineRange": [
+        76,
+        81
+      ],
+      "summary": "Tính SHA-256 theo chunk để nhận diện file ảnh trùng mà không nạp toàn bộ file vào RAM.",
+      "tags": [
+        "integrity-check",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:eda.py:image_metrics",
+      "type": "function",
+      "name": "image_metrics",
+      "filePath": "eda.py",
+      "lineRange": [
+        84,
+        104
+      ],
+      "summary": "Tính các chỉ số ảnh về độ sáng, màu, blur, entropy, high-frequency energy, vùng đen và mật độ cạnh.",
+      "tags": [
+        "image-analysis",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:eda.py:inspect_dataset",
+      "type": "function",
+      "name": "inspect_dataset",
+      "filePath": "eda.py",
+      "lineRange": [
+        107,
+        168
+      ],
+      "summary": "Duyệt mọi split, xác thực ID/path/file ảnh, phát hiện bản sao SHA-256 và thu thập metric thành DataFrame.",
+      "tags": [
+        "data-validation",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "complex"
+    },
+    {
+      "id": "function:eda.py:create_summary",
+      "type": "function",
+      "name": "create_summary",
+      "filePath": "eda.py",
+      "lineRange": [
+        171,
+        176
+      ],
+      "summary": "Tổng hợp count và thống kê mô tả của các metric số theo từng split.",
+      "tags": [
+        "aggregation",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:eda.py:thumbnail",
+      "type": "function",
+      "name": "thumbnail",
+      "filePath": "eda.py",
+      "lineRange": [
+        179,
+        181
+      ],
+      "summary": "Tạo thumbnail RGB vuông bằng phép fit Lanczos từ một ảnh nguồn.",
+      "tags": [
+        "image-processing",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:eda.py:save_grid",
+      "type": "function",
+      "name": "save_grid",
+      "filePath": "eda.py",
+      "lineRange": [
+        184,
+        200
+      ],
+      "summary": "Ghép các thumbnail cùng nhãn ID/split thành một ảnh grid để kiểm tra trực quan.",
+      "tags": [
+        "visualization",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:eda.py:save_grids",
+      "type": "function",
+      "name": "save_grids",
+      "filePath": "eda.py",
+      "lineRange": [
+        203,
+        218
+      ],
+      "summary": "Sinh grid mẫu ngẫu nhiên theo split và grid các trường hợp cực trị về blur, noise hay độ sáng.",
+      "tags": [
+        "visualization",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:eda.py:save_distributions",
+      "type": "function",
+      "name": "save_distributions",
+      "filePath": "eda.py",
+      "lineRange": [
+        221,
+        237
+      ],
+      "summary": "Vẽ histogram mật độ của các metric suy giảm cho train, gallery và query.",
+      "tags": [
+        "visualization",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:eda.py:write_integrity_report",
+      "type": "function",
+      "name": "write_integrity_report",
+      "filePath": "eda.py",
+      "lineRange": [
+        240,
+        262
+      ],
+      "summary": "Ghi báo cáo text về số dòng, trùng ID/path, file thiếu/hỏng và nhóm ảnh trùng hash.",
+      "tags": [
+        "reporting",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:eda.py:write_markdown_report",
+      "type": "function",
+      "name": "write_markdown_report",
+      "filePath": "eda.py",
+      "lineRange": [
+        265,
+        303
+      ],
+      "summary": "Ghi báo cáo Markdown tóm tắt dataset, median metric, distribution shift và hàm ý retrieval.",
+      "tags": [
+        "reporting",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "complex"
+    },
+    {
+      "id": "function:eda.py:main",
+      "type": "function",
+      "name": "main",
+      "filePath": "eda.py",
+      "lineRange": [
+        306,
+        337
+      ],
+      "summary": "Điều phối CLI EDA, kiểm tra input, tạo artifact và trả exit code phản ánh lỗi dữ liệu.",
+      "tags": [
+        "entry-point",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "complex"
+    },
+    {
+      "id": "function:retrieval_advanced.py:load_manifest",
+      "type": "function",
+      "name": "load_manifest",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        50,
+        58
+      ],
+      "summary": "Đọc và xác thực manifest ảnh dưới dạng danh sách các bản ghi ID/path.",
+      "tags": [
+        "validation",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:retrieval_advanced.py:resolve_image_path",
+      "type": "function",
+      "name": "resolve_image_path",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        61,
+        67
+      ],
+      "summary": "Giải đường dẫn ảnh tương đối từ data root hoặc các thư mục cha của manifest.",
+      "tags": [
+        "path-resolution",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:retrieval_advanced.py:apply_d4",
+      "type": "function",
+      "name": "apply_d4",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        80,
+        93
+      ],
+      "summary": "Áp dụng một trong tám phép biến đổi nhóm D4 gồm quay và lật ảnh.",
+      "tags": [
+        "augmentation",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "class:retrieval_advanced.py:ImageDataset",
+      "type": "class",
+      "name": "ImageDataset",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        96,
+        110
+      ],
+      "summary": "Dataset PyTorch nạp ảnh RGB, bảo toàn kích thước qua D4 view rồi áp dụng transform của model.",
+      "tags": [
+        "data-model",
+        "dataset",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:retrieval_advanced.py:cache_key",
+      "type": "function",
+      "name": "cache_key",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        114,
+        118
+      ],
+      "summary": "Băm nội dung manifest cùng model, split, view và phiên bản dense feature để định danh cache.",
+      "tags": [
+        "feature-cache",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:retrieval_advanced.py:cache_path",
+      "type": "function",
+      "name": "cache_path",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        121,
+        123
+      ],
+      "summary": "Tạo đường dẫn cache feature an toàn từ tên model và cache key.",
+      "tags": [
+        "feature-cache",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:retrieval_advanced.py:split_global_dense",
+      "type": "function",
+      "name": "split_global_dense",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        126,
+        146
+      ],
+      "summary": "Chuyển output backbone thành global embedding và dense spatial descriptors chuẩn hóa, hỗ trợ ConvNeXt lẫn ViT/EVA.",
+      "tags": [
+        "feature-extraction",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:retrieval_advanced.py:extract_and_cache",
+      "type": "function",
+      "name": "extract_and_cache",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        150,
+        186
+      ],
+      "summary": "Tái sử dụng cache hợp lệ hoặc chạy batched inference để lưu global và dense feature theo D4 view.",
+      "tags": [
+        "feature-cache",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "complex"
+    },
+    {
+      "id": "function:retrieval_advanced.py:make_submission",
+      "type": "function",
+      "name": "make_submission",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        247,
+        258
+      ],
+      "summary": "Chuyển ranking tensor thành CSV top-10, đồng thời xác thực query và gallery ID không trùng.",
+      "tags": [
+        "serialization",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:retrieval_advanced.py:row_minmax",
+      "type": "function",
+      "name": "row_minmax",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        266,
+        268
+      ],
+      "summary": "Chuẩn hóa từng hàng score về khoảng min-max với mẫu số được chặn để tránh chia cho zero.",
+      "tags": [
+        "normalization",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:retrieval_advanced.py:local_features",
+      "type": "function",
+      "name": "local_features",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        297,
+        304
+      ],
+      "summary": "Phóng to ảnh xám, tăng tương phản CLAHE và trích xuất SIFT keypoint/descriptor.",
+      "tags": [
+        "feature-extraction",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:retrieval_advanced.py:geometric_score",
+      "type": "function",
+      "name": "geometric_score",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        307,
+        322
+      ],
+      "summary": "Ghép SIFT bằng ratio test, ước lượng homography RANSAC và tạo score từ số lượng cùng tỷ lệ inlier.",
+      "tags": [
+        "geometric-verification",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    },
+    {
+      "id": "function:retrieval_advanced.py:overlap",
+      "type": "function",
+      "name": "overlap",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        349,
+        350
+      ],
+      "summary": "Tính overlap trung bình giữa hai tập top-k ranking cho mọi query.",
+      "tags": [
+        "evaluation",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "simple"
+    },
+    {
+      "id": "function:retrieval_advanced.py:show_top1_comparison",
+      "type": "function",
+      "name": "show_top1_comparison",
+      "filePath": "retrieval_advanced.py",
+      "lineRange": [
+        379,
+        396
+      ],
+      "summary": "Vẽ top-1 của global, dense và geometry cạnh query để so sánh định tính.",
+      "tags": [
+        "visualization",
+        "utility",
+        "retrieval"
+      ],
+      "complexity": "moderate"
+    }
+  ],
+  "edges": [
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:load_manifest",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:load_manifest",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:resolve_image_path",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:resolve_image_path",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "class:baseline_dinov3.py:RetrievalDataset",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "class:baseline_dinov3.py:RetrievalDataset",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:extract_features",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:extract_features",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:validate_submission",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:validate_submission",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:extract_view",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:extract_view",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:show_changed_top1",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:show_changed_top1",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:show_retrievals",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:baseline_dinov3.py",
+      "target": "function:baseline_dinov3.py:show_retrievals",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:parse_args",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:parse_args",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:load_manifest",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:load_manifest",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:resolve_image",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:resolve_image",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:sha256",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:sha256",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:image_metrics",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:image_metrics",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:inspect_dataset",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:inspect_dataset",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:create_summary",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:create_summary",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:thumbnail",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:thumbnail",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:save_grid",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:save_grid",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:save_grids",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:save_grids",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:save_distributions",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:save_distributions",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:write_integrity_report",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:write_integrity_report",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:write_markdown_report",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:write_markdown_report",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:main",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:eda.py",
+      "target": "function:eda.py:main",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:load_manifest",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:load_manifest",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:resolve_image_path",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:resolve_image_path",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:apply_d4",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:apply_d4",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "class:retrieval_advanced.py:ImageDataset",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "class:retrieval_advanced.py:ImageDataset",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:cache_key",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:cache_key",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:cache_path",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:cache_path",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:split_global_dense",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:split_global_dense",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:extract_and_cache",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:extract_and_cache",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:make_submission",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:make_submission",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:row_minmax",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:row_minmax",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:local_features",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:local_features",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:geometric_score",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:geometric_score",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:overlap",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:overlap",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:show_top1_comparison",
+      "type": "contains",
+      "direction": "forward",
+      "weight": 1
+    },
+    {
+      "source": "file:retrieval_advanced.py",
+      "target": "function:retrieval_advanced.py:show_top1_comparison",
+      "type": "exports",
+      "direction": "forward",
+      "weight": 0.8
+    }
+  ]
+}
+

.understand-anything/intermediate/batches.json

@@ -0,0 +1,111 @@
+{
+  "schemaVersion": 1,
+  "algorithm": "louvain",
+  "totalFiles": 7,
+  "totalBatches": 1,
+  "exportsByPath": {
+    ".understand-anything/.understandignore": [],
+    "baseline_dinov3.py": [
+      "load_manifest",
+      "resolve_image_path",
+      "RetrievalDataset",
+      "extract_features",
+      "validate_submission",
+      "extract_view",
+      "show_changed_top1",
+      "show_retrievals"
+    ],
+    "eda.py": [
+      "parse_args",
+      "load_manifest",
+      "resolve_image",
+      "sha256",
+      "image_metrics",
+      "inspect_dataset",
+      "create_summary",
+      "thumbnail",
+      "save_grid",
+      "save_grids",
+      "save_distributions",
+      "write_integrity_report",
+      "write_markdown_report",
+      "main"
+    ],
+    "notebook324f4a11f8_upgraded.ipynb": [],
+    "retrieval_advanced.py": [
+      "load_manifest",
+      "resolve_image_path",
+      "apply_d4",
+      "ImageDataset",
+      "cache_key",
+      "cache_path",
+      "split_global_dense",
+      "extract_and_cache",
+      "make_submission",
+      "row_minmax",
+      "local_features",
+      "geometric_score",
+      "overlap",
+      "show_top1_comparison"
+    ]
+  },
+  "batches": [
+    {
+      "batchIndex": 1,
+      "files": [
+        {
+          "path": ".understand-anything/.understandignore",
+          "language": "unknown",
+          "sizeLines": 47,
+          "fileCategory": "code"
+        },
+        {
+          "path": ".understand-anything/config.json",
+          "language": "json",
+          "sizeLines": 3,
+          "fileCategory": "config"
+        },
+        {
+          "path": "baseline_dinov3.py",
+          "language": "python",
+          "sizeLines": 397,
+          "fileCategory": "code"
+        },
+        {
+          "path": "de_bai_image_to_image_retrieval.md",
+          "language": "markdown",
+          "sizeLines": 66,
+          "fileCategory": "docs"
+        },
+        {
+          "path": "eda.py",
+          "language": "python",
+          "sizeLines": 341,
+          "fileCategory": "code"
+        },
+        {
+          "path": "notebook324f4a11f8_upgraded.ipynb",
+          "language": "ipynb",
+          "sizeLines": 3255,
+          "fileCategory": "code"
+        },
+        {
+          "path": "retrieval_advanced.py",
+          "language": "python",
+          "sizeLines": 399,
+          "fileCategory": "code"
+        }
+      ],
+      "batchImportData": {
+        ".understand-anything/.understandignore": [],
+        ".understand-anything/config.json": [],
+        "baseline_dinov3.py": [],
+        "de_bai_image_to_image_retrieval.md": [],
+        "eda.py": [],
+        "notebook324f4a11f8_upgraded.ipynb": [],
+        "retrieval_advanced.py": []
+      },
+      "neighborMap": {}
+    }
+  ]
+}

.understand-anything/intermediate/scan-result.json

@@ -0,0 +1,68 @@
+{
+  "name": "openai_cv",
+  "description": "Không có mô tả.",
+  "languages": [
+    "ipynb",
+    "json",
+    "markdown",
+    "python",
+    "unknown"
+  ],
+  "frameworks": [],
+  "files": [
+    {
+      "path": ".understand-anything/.understandignore",
+      "language": "unknown",
+      "sizeLines": 47,
+      "fileCategory": "code"
+    },
+    {
+      "path": ".understand-anything/config.json",
+      "language": "json",
+      "sizeLines": 3,
+      "fileCategory": "config"
+    },
+    {
+      "path": "baseline_dinov3.py",
+      "language": "python",
+      "sizeLines": 397,
+      "fileCategory": "code"
+    },
+    {
+      "path": "de_bai_image_to_image_retrieval.md",
+      "language": "markdown",
+      "sizeLines": 66,
+      "fileCategory": "docs"
+    },
+    {
+      "path": "eda.py",
+      "language": "python",
+      "sizeLines": 341,
+      "fileCategory": "code"
+    },
+    {
+      "path": "notebook324f4a11f8_upgraded.ipynb",
+      "language": "ipynb",
+      "sizeLines": 3255,
+      "fileCategory": "code"
+    },
+    {
+      "path": "retrieval_advanced.py",
+      "language": "python",
+      "sizeLines": 399,
+      "fileCategory": "code"
+    }
+  ],
+  "totalFiles": 7,
+  "filteredByIgnore": 32,
+  "estimatedComplexity": "small",
+  "importMap": {
+    ".understand-anything/.understandignore": [],
+    ".understand-anything/config.json": [],
+    "baseline_dinov3.py": [],
+    "de_bai_image_to_image_retrieval.md": [],
+    "eda.py": [],
+    "notebook324f4a11f8_upgraded.ipynb": [],
+    "retrieval_advanced.py": []
+  }
+}

.understand-anything/tmp/ua-file-analyzer-input-1.json

@@ -0,0 +1,21 @@
+{
+  "projectRoot": "/mnt/data/openai_cv",
+  "batchFiles": [
+    {"path": ".understand-anything/.understandignore", "language": "unknown", "sizeLines": 47, "fileCategory": "code"},
+    {"path": ".understand-anything/config.json", "language": "json", "sizeLines": 3, "fileCategory": "config"},
+    {"path": "baseline_dinov3.py", "language": "python", "sizeLines": 397, "fileCategory": "code"},
+    {"path": "de_bai_image_to_image_retrieval.md", "language": "markdown", "sizeLines": 66, "fileCategory": "docs"},
+    {"path": "eda.py", "language": "python", "sizeLines": 341, "fileCategory": "code"},
+    {"path": "notebook324f4a11f8_upgraded.ipynb", "language": "ipynb", "sizeLines": 3255, "fileCategory": "code"},
+    {"path": "retrieval_advanced.py", "language": "python", "sizeLines": 399, "fileCategory": "code"}
+  ],
+  "batchImportData": {
+    ".understand-anything/.understandignore": [],
+    ".understand-anything/config.json": [],
+    "baseline_dinov3.py": [],
+    "de_bai_image_to_image_retrieval.md": [],
+    "eda.py": [],
+    "notebook324f4a11f8_upgraded.ipynb": [],
+    "retrieval_advanced.py": []
+  }
+}

.understand-anything/tmp/ua-file-extract-results-1.json

@@ -0,0 +1,2834 @@
+{
+  "scriptCompleted": true,
+  "filesAnalyzed": 7,
+  "filesSkipped": [],
+  "results": [
+    {
+      "path": ".understand-anything/.understandignore",
+      "language": "unknown",
+      "fileCategory": "code",
+      "totalLines": 47,
+      "nonEmptyLines": 44,
+      "metrics": {}
+    },
+    {
+      "path": ".understand-anything/config.json",
+      "language": "json",
+      "fileCategory": "config",
+      "totalLines": 3,
+      "nonEmptyLines": 3,
+      "sections": [
+        {
+          "heading": "outputLanguage",
+          "level": 1,
+          "line": 2
+        }
+      ],
+      "metrics": {
+        "importCount": 0,
+        "exportCount": 0,
+        "functionCount": 0,
+        "classCount": 0,
+        "sectionCount": 1
+      }
+    },
+    {
+      "path": "baseline_dinov3.py",
+      "language": "python",
+      "fileCategory": "code",
+      "totalLines": 397,
+      "nonEmptyLines": 328,
+      "functions": [
+        {
+          "name": "load_manifest",
+          "startLine": 43,
+          "endLine": 51,
+          "params": [
+            "path"
+          ]
+        },
+        {
+          "name": "resolve_image_path",
+          "startLine": 54,
+          "endLine": 65,
+          "params": [
+            "data_root",
+            "manifest_path",
+            "image_path"
+          ]
+        },
+        {
+          "name": "extract_features",
+          "startLine": 133,
+          "endLine": 150,
+          "params": [
+            "loader"
+          ]
+        },
+        {
+          "name": "validate_submission",
+          "startLine": 183,
+          "endLine": 198,
+          "params": [
+            "frame",
+            "expected_query_ids",
+            "valid_gallery_ids",
+            "k"
+          ]
+        },
+        {
+          "name": "extract_view",
+          "startLine": 252,
+          "endLine": 255,
+          "params": [
+            "manifest",
+            "view_transform"
+          ]
+        },
+        {
+          "name": "show_changed_top1",
+          "startLine": 333,
+          "endLine": 366,
+          "params": [
+            "limit"
+          ]
+        },
+        {
+          "name": "show_retrievals",
+          "startLine": 373,
+          "endLine": 394,
+          "params": [
+            "query_indices",
+            "candidates"
+          ]
+        }
+      ],
+      "classes": [
+        {
+          "name": "RetrievalDataset",
+          "startLine": 68,
+          "endLine": 91,
+          "methods": [
+            "__init__",
+            "__len__",
+            "__getitem__"
+          ],
+          "properties": []
+        }
+      ],
+      "exports": [
+        {
+          "name": "load_manifest",
+          "line": 43,
+          "isDefault": false
+        },
+        {
+          "name": "resolve_image_path",
+          "line": 54,
+          "isDefault": false
+        },
+        {
+          "name": "RetrievalDataset",
+          "line": 68,
+          "isDefault": false
+        },
+        {
+          "name": "extract_features",
+          "line": 132,
+          "isDefault": false
+        },
+        {
+          "name": "validate_submission",
+          "line": 183,
+          "isDefault": false
+        },
+        {
+          "name": "extract_view",
+          "line": 252,
+          "isDefault": false
+        },
+        {
+          "name": "show_changed_top1",
+          "line": 333,
+          "isDefault": false
+        },
+        {
+          "name": "show_retrievals",
+          "line": 373,
+          "isDefault": false
+        }
+      ],
+      "callGraph": [
+        {
+          "caller": "load_manifest",
+          "callee": "path.open",
+          "lineNumber": 44
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "json.load",
+          "lineNumber": 45
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "isinstance",
+          "lineNumber": 46
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "ValueError",
+          "lineNumber": 47
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "enumerate",
+          "lineNumber": 48
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "isinstance",
+          "lineNumber": 49
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "row.keys",
+          "lineNumber": 49
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "ValueError",
+          "lineNumber": 50
+        },
+        {
+          "caller": "resolve_image_path",
+          "callee": "Path",
+          "lineNumber": 56
+        },
+        {
+          "caller": "resolve_image_path",
+          "callee": "candidate.is_file",
+          "lineNumber": 63
+        },
+        {
+          "caller": "resolve_image_path",
+          "callee": "FileNotFoundError",
+          "lineNumber": 65
+        },
+        {
+          "caller": "__init__",
+          "callee": "load_manifest",
+          "lineNumber": 71
+        },
+        {
+          "caller": "__init__",
+          "callee": "resolve_image_path",
+          "lineNumber": 75
+        },
+        {
+          "caller": "__len__",
+          "callee": "len",
+          "lineNumber": 80
+        },
+        {
+          "caller": "__getitem__",
+          "callee": "Image.open",
+          "lineNumber": 84
+        },
+        {
+          "caller": "__getitem__",
+          "callee": "image.convert",
+          "lineNumber": 85
+        },
+        {
+          "caller": "__getitem__",
+          "callee": "self.view_transform",
+          "lineNumber": 88
+        },
+        {
+          "caller": "__getitem__",
+          "callee": "self.transform",
+          "lineNumber": 90
+        },
+        {
+          "caller": "extract_features",
+          "callee": "images.to",
+          "lineNumber": 137
+        },
+        {
+          "caller": "extract_features",
+          "callee": "torch.autocast",
+          "lineNumber": 138
+        },
+        {
+          "caller": "extract_features",
+          "callee": "nullcontext",
+          "lineNumber": 138
+        },
+        {
+          "caller": "extract_features",
+          "callee": "model",
+          "lineNumber": 140
+        },
+        {
+          "caller": "extract_features",
+          "callee": "features.flatten(2).mean",
+          "lineNumber": 142
+        },
+        {
+          "caller": "extract_features",
+          "callee": "features.flatten",
+          "lineNumber": 142
+        },
+        {
+          "caller": "extract_features",
+          "callee": "F.normalize",
+          "lineNumber": 143
+        },
+        {
+          "caller": "extract_features",
+          "callee": "features.float",
+          "lineNumber": 143
+        },
+        {
+          "caller": "extract_features",
+          "callee": "all_ids.extend",
+          "lineNumber": 144
+        },
+        {
+          "caller": "extract_features",
+          "callee": "all_features.append",
+          "lineNumber": 145
+        },
+        {
+          "caller": "extract_features",
+          "callee": "features.cpu",
+          "lineNumber": 145
+        },
+        {
+          "caller": "extract_features",
+          "callee": "torch.cat",
+          "lineNumber": 147
+        },
+        {
+          "caller": "extract_features",
+          "callee": "len",
+          "lineNumber": 148
+        },
+        {
+          "caller": "extract_features",
+          "callee": "torch.isfinite(embeddings).all",
+          "lineNumber": 149
+        },
+        {
+          "caller": "extract_features",
+          "callee": "torch.isfinite",
+          "lineNumber": 149
+        },
+        {
+          "caller": "validate_submission",
+          "callee": "list",
+          "lineNumber": 189
+        },
+        {
+          "caller": "validate_submission",
+          "callee": "frame[\"query_id\"].tolist",
+          "lineNumber": 190
+        },
+        {
+          "caller": "validate_submission",
+          "callee": "set",
+          "lineNumber": 193
+        },
+        {
+          "caller": "validate_submission",
+          "callee": "frame.itertuples",
+          "lineNumber": 194
+        },
+        {
+          "caller": "validate_submission",
+          "callee": "value.split",
+          "lineNumber": 195
+        },
+        {
+          "caller": "validate_submission",
+          "callee": "len",
+          "lineNumber": 196
+        },
+        {
+          "caller": "validate_submission",
+          "callee": "len",
+          "lineNumber": 197
+        },
+        {
+          "caller": "validate_submission",
+          "callee": "set",
+          "lineNumber": 197
+        },
+        {
+          "caller": "validate_submission",
+          "callee": "set",
+          "lineNumber": 198
+        },
+        {
+          "caller": "extract_view",
+          "callee": "RetrievalDataset",
+          "lineNumber": 253
+        },
+        {
+          "caller": "extract_view",
+          "callee": "DataLoader",
+          "lineNumber": 254
+        },
+        {
+          "caller": "extract_view",
+          "callee": "extract_features",
+          "lineNumber": 255
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "torch.where",
+          "lineNumber": 334
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "len",
+          "lineNumber": 335
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "print",
+          "lineNumber": 336
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "(tta_top1 - baseline_top1).abs",
+          "lineNumber": 339
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "torch.argsort",
+          "lineNumber": 340
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "dict",
+          "lineNumber": 341
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "zip",
+          "lineNumber": 341
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "plt.subplots",
+          "lineNumber": 342
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "len",
+          "lineNumber": 342
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "len",
+          "lineNumber": 342
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "np.atleast_2d",
+          "lineNumber": 343
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "enumerate",
+          "lineNumber": 345
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "int",
+          "lineNumber": 346
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "int",
+          "lineNumber": 347
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "int",
+          "lineNumber": 348
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "enumerate",
+          "lineNumber": 359
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "zip",
+          "lineNumber": 359
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "Image.open",
+          "lineNumber": 360
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "axes[plot_row, column].imshow",
+          "lineNumber": 361
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "image.convert",
+          "lineNumber": 361
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "axes[plot_row, column].set_title",
+          "lineNumber": 362
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "axes[plot_row, column].axis",
+          "lineNumber": 363
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "plt.tight_layout",
+          "lineNumber": 365
+        },
+        {
+          "caller": "show_changed_top1",
+          "callee": "plt.show",
+          "lineNumber": 366
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "dict",
+          "lineNumber": 374
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "zip",
+          "lineNumber": 374
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "len",
+          "lineNumber": 375
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "plt.subplots",
+          "lineNumber": 376
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "np.atleast_2d",
+          "lineNumber": 377
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "enumerate",
+          "lineNumber": 379
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "Image.open",
+          "lineNumber": 380
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "axes[plot_row, 0].imshow",
+          "lineNumber": 381
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "image.convert",
+          "lineNumber": 381
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "axes[plot_row, 0].set_title",
+          "lineNumber": 382
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "range",
+          "lineNumber": 384
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "Image.open",
+          "lineNumber": 386
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "axes[plot_row, rank + 1].imshow",
+          "lineNumber": 387
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "image.convert",
+          "lineNumber": 387
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "top_scores[query_index, rank].item",
+          "lineNumber": 388
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "axes[plot_row, rank + 1].set_title",
+          "lineNumber": 389
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "axes.ravel",
+          "lineNumber": 391
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "axis.axis",
+          "lineNumber": 392
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "plt.tight_layout",
+          "lineNumber": 393
+        },
+        {
+          "caller": "show_retrievals",
+          "callee": "plt.show",
+          "lineNumber": 394
+        }
+      ],
+      "metrics": {
+        "importCount": 0,
+        "exportCount": 8,
+        "functionCount": 7,
+        "classCount": 1
+      }
+    },
+    {
+      "path": "de_bai_image_to_image_retrieval.md",
+      "language": "markdown",
+      "fileCategory": "docs",
+      "totalLines": 67,
+      "nonEmptyLines": 44,
+      "sections": [
+        {
+          "heading": "Đề thi Olympic AI — Image-to-Image Instance Retrieval (không nhãn)",
+          "level": 1,
+          "line": 1
+        },
+        {
+          "heading": "1. Bài toán",
+          "level": 2,
+          "line": 3
+        },
+        {
+          "heading": "2. Dữ liệu — không có nhãn nào được cung cấp",
+          "level": 2,
+          "line": 13
+        },
+        {
+          "heading": "3. Cấu trúc cuộc thi (train / public test / private test)",
+          "level": 2,
+          "line": 23
+        },
+        {
+          "heading": "4. Định dạng nộp bài",
+          "level": 2,
+          "line": 29
+        },
+        {
+          "heading": "5. Chấm điểm",
+          "level": 2,
+          "line": 43
+        },
+        {
+          "heading": "6. Ràng buộc",
+          "level": 2,
+          "line": 61
+        }
+      ],
+      "metrics": {
+        "importCount": 0,
+        "exportCount": 0,
+        "functionCount": 0,
+        "classCount": 0,
+        "sectionCount": 7
+      }
+    },
+    {
+      "path": "eda.py",
+      "language": "python",
+      "fileCategory": "code",
+      "totalLines": 341,
+      "nonEmptyLines": 297,
+      "functions": [
+        {
+          "name": "parse_args",
+          "startLine": 43,
+          "endLine": 49,
+          "params": []
+        },
+        {
+          "name": "load_manifest",
+          "startLine": 52,
+          "endLine": 60,
+          "params": [
+            "path"
+          ]
+        },
+        {
+          "name": "resolve_image",
+          "startLine": 63,
+          "endLine": 73,
+          "params": [
+            "data_root",
+            "manifest",
+            "relative"
+          ]
+        },
+        {
+          "name": "sha256",
+          "startLine": 76,
+          "endLine": 81,
+          "params": [
+            "path"
+          ]
+        },
+        {
+          "name": "image_metrics",
+          "startLine": 84,
+          "endLine": 104,
+          "params": [
+            "rgb"
+          ]
+        },
+        {
+          "name": "inspect_dataset",
+          "startLine": 107,
+          "endLine": 168,
+          "params": [
+            "data_root"
+          ]
+        },
+        {
+          "name": "create_summary",
+          "startLine": 171,
+          "endLine": 176,
+          "params": [
+            "metrics"
+          ]
+        },
+        {
+          "name": "thumbnail",
+          "startLine": 179,
+          "endLine": 181,
+          "params": [
+            "path",
+            "size"
+          ]
+        },
+        {
+          "name": "save_grid",
+          "startLine": 184,
+          "endLine": 200,
+          "params": [
+            "rows",
+            "output",
+            "title",
+            "limit"
+          ]
+        },
+        {
+          "name": "save_grids",
+          "startLine": 203,
+          "endLine": 218,
+          "params": [
+            "metrics",
+            "output_dir",
+            "seed",
+            "grid_size"
+          ]
+        },
+        {
+          "name": "save_distributions",
+          "startLine": 221,
+          "endLine": 237,
+          "params": [
+            "metrics",
+            "output"
+          ]
+        },
+        {
+          "name": "write_integrity_report",
+          "startLine": 240,
+          "endLine": 262,
+          "params": [
+            "path",
+            "integrity",
+            "problems"
+          ]
+        },
+        {
+          "name": "write_markdown_report",
+          "startLine": 265,
+          "endLine": 303,
+          "params": [
+            "path",
+            "metrics",
+            "integrity"
+          ]
+        },
+        {
+          "name": "main",
+          "startLine": 306,
+          "endLine": 337,
+          "params": []
+        }
+      ],
+      "exports": [
+        {
+          "name": "parse_args",
+          "line": 43,
+          "isDefault": false
+        },
+        {
+          "name": "load_manifest",
+          "line": 52,
+          "isDefault": false
+        },
+        {
+          "name": "resolve_image",
+          "line": 63,
+          "isDefault": false
+        },
+        {
+          "name": "sha256",
+          "line": 76,
+          "isDefault": false
+        },
+        {
+          "name": "image_metrics",
+          "line": 84,
+          "isDefault": false
+        },
+        {
+          "name": "inspect_dataset",
+          "line": 107,
+          "isDefault": false
+        },
+        {
+          "name": "create_summary",
+          "line": 171,
+          "isDefault": false
+        },
+        {
+          "name": "thumbnail",
+          "line": 179,
+          "isDefault": false
+        },
+        {
+          "name": "save_grid",
+          "line": 184,
+          "isDefault": false
+        },
+        {
+          "name": "save_grids",
+          "line": 203,
+          "isDefault": false
+        },
+        {
+          "name": "save_distributions",
+          "line": 221,
+          "isDefault": false
+        },
+        {
+          "name": "write_integrity_report",
+          "line": 240,
+          "isDefault": false
+        },
+        {
+          "name": "write_markdown_report",
+          "line": 265,
+          "isDefault": false
+        },
+        {
+          "name": "main",
+          "line": 306,
+          "isDefault": false
+        }
+      ],
+      "callGraph": [
+        {
+          "caller": "parse_args",
+          "callee": "argparse.ArgumentParser",
+          "lineNumber": 44
+        },
+        {
+          "caller": "parse_args",
+          "callee": "parser.add_argument",
+          "lineNumber": 45
+        },
+        {
+          "caller": "parse_args",
+          "callee": "Path",
+          "lineNumber": 45
+        },
+        {
+          "caller": "parse_args",
+          "callee": "parser.add_argument",
+          "lineNumber": 46
+        },
+        {
+          "caller": "parse_args",
+          "callee": "Path",
+          "lineNumber": 46
+        },
+        {
+          "caller": "parse_args",
+          "callee": "parser.add_argument",
+          "lineNumber": 47
+        },
+        {
+          "caller": "parse_args",
+          "callee": "parser.add_argument",
+          "lineNumber": 48
+        },
+        {
+          "caller": "parse_args",
+          "callee": "parser.parse_args",
+          "lineNumber": 49
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "path.open",
+          "lineNumber": 53
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "json.load",
+          "lineNumber": 54
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "isinstance",
+          "lineNumber": 55
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "ValueError",
+          "lineNumber": 56
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "enumerate",
+          "lineNumber": 57
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "isinstance",
+          "lineNumber": 58
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "isinstance",
+          "lineNumber": 58
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "row.get",
+          "lineNumber": 58
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "isinstance",
+          "lineNumber": 58
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "row.get",
+          "lineNumber": 58
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "ValueError",
+          "lineNumber": 59
+        },
+        {
+          "caller": "resolve_image",
+          "callee": "Path",
+          "lineNumber": 64
+        },
+        {
+          "caller": "resolve_image",
+          "callee": "candidate.is_file",
+          "lineNumber": 71
+        },
+        {
+          "caller": "resolve_image",
+          "callee": "candidate.resolve",
+          "lineNumber": 72
+        },
+        {
+          "caller": "resolve_image",
+          "callee": "candidates[0].resolve",
+          "lineNumber": 73
+        },
+        {
+          "caller": "sha256",
+          "callee": "hashlib.sha256",
+          "lineNumber": 77
+        },
+        {
+          "caller": "sha256",
+          "callee": "path.open",
+          "lineNumber": 78
+        },
+        {
+          "caller": "sha256",
+          "callee": "iter",
+          "lineNumber": 79
+        },
+        {
+          "caller": "sha256",
+          "callee": "handle.read",
+          "lineNumber": 79
+        },
+        {
+          "caller": "sha256",
+          "callee": "digest.update",
+          "lineNumber": 80
+        },
+        {
+          "caller": "sha256",
+          "callee": "digest.hexdigest",
+          "lineNumber": 81
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "cv2.cvtColor",
+          "lineNumber": 85
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "np.bincount(gray.ravel(), minlength=256).astype",
+          "lineNumber": 86
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "np.bincount",
+          "lineNumber": 86
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "gray.ravel",
+          "lineNumber": 86
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "cv2.GaussianBlur",
+          "lineNumber": 88
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "cv2.Canny",
+          "lineNumber": 89
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "float",
+          "lineNumber": 91
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "gray.mean",
+          "lineNumber": 91
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "float",
+          "lineNumber": 92
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "gray.std",
+          "lineNumber": 92
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "float",
+          "lineNumber": 93
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "rgb[..., 0].mean",
+          "lineNumber": 93
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "float",
+          "lineNumber": 94
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "rgb[..., 0].std",
+          "lineNumber": 94
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "float",
+          "lineNumber": 95
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "rgb[..., 1].mean",
+          "lineNumber": 95
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "float",
+          "lineNumber": 96
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "rgb[..., 1].std",
+          "lineNumber": 96
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "float",
+          "lineNumber": 97
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "rgb[..., 2].mean",
+          "lineNumber": 97
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "float",
+          "lineNumber": 98
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "rgb[..., 2].std",
+          "lineNumber": 98
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "float",
+          "lineNumber": 99
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "cv2.Laplacian(gray, cv2.CV_64F).var",
+          "lineNumber": 99
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "cv2.Laplacian",
+          "lineNumber": 99
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "float",
+          "lineNumber": 100
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "(probabilities * np.log2(probabilities)).sum",
+          "lineNumber": 100
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "np.log2",
+          "lineNumber": 100
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "float",
+          "lineNumber": 101
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "np.mean",
+          "lineNumber": 101
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "np.abs",
+          "lineNumber": 101
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "gray.astype",
+          "lineNumber": 101
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "blurred.astype",
+          "lineNumber": 101
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "float",
+          "lineNumber": 102
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "np.mean",
+          "lineNumber": 102
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "np.all",
+          "lineNumber": 102
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "float",
+          "lineNumber": 103
+        },
+        {
+          "caller": "image_metrics",
+          "callee": "np.mean",
+          "lineNumber": 103
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "defaultdict",
+          "lineNumber": 111
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "MANIFESTS.items",
+          "lineNumber": 113
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "load_manifest",
+          "lineNumber": 115
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "len",
+          "lineNumber": 119
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "len",
+          "lineNumber": 120
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "set",
+          "lineNumber": 120
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "len",
+          "lineNumber": 121
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "set",
+          "lineNumber": 121
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "sorted",
+          "lineNumber": 122
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "Counter(ids).items",
+          "lineNumber": 122
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "Counter",
+          "lineNumber": 122
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "sorted",
+          "lineNumber": 123
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "Counter(paths).items",
+          "lineNumber": 123
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "Counter",
+          "lineNumber": 123
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "resolve_image",
+          "lineNumber": 130
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "path.is_file",
+          "lineNumber": 131
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "split_info[\"missing\"].append",
+          "lineNumber": 132
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "str",
+          "lineNumber": 132
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "problems.append",
+          "lineNumber": 133
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "Image.open",
+          "lineNumber": 136
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "image.load",
+          "lineNumber": 137
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "np.asarray",
+          "lineNumber": 139
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "image.convert",
+          "lineNumber": 139
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "sha256",
+          "lineNumber": 140
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "hashes[digest].append",
+          "lineNumber": 141
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "records.append",
+          "lineNumber": 142
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "str",
+          "lineNumber": 147
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "path.stat",
+          "lineNumber": 153
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "image_metrics",
+          "lineNumber": 154
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "type",
+          "lineNumber": 158
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "split_info[\"broken\"].append",
+          "lineNumber": 159
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "problems.append",
+          "lineNumber": 160
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "problems.append",
+          "lineNumber": 163
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "problems.append",
+          "lineNumber": 165
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "hashes.items",
+          "lineNumber": 167
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "len",
+          "lineNumber": 167
+        },
+        {
+          "caller": "inspect_dataset",
+          "callee": "pd.DataFrame",
+          "lineNumber": 168
+        },
+        {
+          "caller": "create_summary",
+          "callee": "metrics.groupby(\"split\")[numeric].agg",
+          "lineNumber": 176
+        },
+        {
+          "caller": "create_summary",
+          "callee": "metrics.groupby",
+          "lineNumber": 176
+        },
+        {
+          "caller": "thumbnail",
+          "callee": "Image.open",
+          "lineNumber": 180
+        },
+        {
+          "caller": "thumbnail",
+          "callee": "ImageOps.fit",
+          "lineNumber": 181
+        },
+        {
+          "caller": "thumbnail",
+          "callee": "image.convert",
+          "lineNumber": 181
+        },
+        {
+          "caller": "save_grid",
+          "callee": "rows.head",
+          "lineNumber": 185
+        },
+        {
+          "caller": "save_grid",
+          "callee": "min",
+          "lineNumber": 188
+        },
+        {
+          "caller": "save_grid",
+          "callee": "len",
+          "lineNumber": 188
+        },
+        {
+          "caller": "save_grid",
+          "callee": "math.ceil",
+          "lineNumber": 190
+        },
+        {
+          "caller": "save_grid",
+          "callee": "len",
+          "lineNumber": 190
+        },
+        {
+          "caller": "save_grid",
+          "callee": "Image.new",
+          "lineNumber": 191
+        },
+        {
+          "caller": "save_grid",
+          "callee": "ImageDraw.Draw",
+          "lineNumber": 192
+        },
+        {
+          "caller": "save_grid",
+          "callee": "draw.text",
+          "lineNumber": 193
+        },
+        {
+          "caller": "save_grid",
+          "callee": "enumerate",
+          "lineNumber": 194
+        },
+        {
+          "caller": "save_grid",
+          "callee": "rows.iterrows",
+          "lineNumber": 194
+        },
+        {
+          "caller": "save_grid",
+          "callee": "canvas.paste",
+          "lineNumber": 197
+        },
+        {
+          "caller": "save_grid",
+          "callee": "thumbnail",
+          "lineNumber": 197
+        },
+        {
+          "caller": "save_grid",
+          "callee": "draw.text",
+          "lineNumber": 198
+        },
+        {
+          "caller": "save_grid",
+          "callee": "str",
+          "lineNumber": 198
+        },
+        {
+          "caller": "save_grid",
+          "callee": "draw.text",
+          "lineNumber": 199
+        },
+        {
+          "caller": "save_grid",
+          "callee": "str",
+          "lineNumber": 199
+        },
+        {
+          "caller": "save_grid",
+          "callee": "canvas.save",
+          "lineNumber": 200
+        },
+        {
+          "caller": "save_grids",
+          "callee": "subset.sample",
+          "lineNumber": 206
+        },
+        {
+          "caller": "save_grids",
+          "callee": "min",
+          "lineNumber": 206
+        },
+        {
+          "caller": "save_grids",
+          "callee": "len",
+          "lineNumber": 206
+        },
+        {
+          "caller": "save_grids",
+          "callee": "save_grid",
+          "lineNumber": 207
+        },
+        {
+          "caller": "save_grids",
+          "callee": "extremes.items",
+          "lineNumber": 216
+        },
+        {
+          "caller": "save_grids",
+          "callee": "metrics.sort_values",
+          "lineNumber": 217
+        },
+        {
+          "caller": "save_grids",
+          "callee": "save_grid",
+          "lineNumber": 218
+        },
+        {
+          "caller": "save_grids",
+          "callee": "name.replace(\"_\", \" \").title",
+          "lineNumber": 218
+        },
+        {
+          "caller": "save_grids",
+          "callee": "name.replace",
+          "lineNumber": 218
+        },
+        {
+          "caller": "save_distributions",
+          "callee": "plt.subplots",
+          "lineNumber": 222
+        },
+        {
+          "caller": "save_distributions",
+          "callee": "axes.ravel",
+          "lineNumber": 223
+        },
+        {
+          "caller": "save_distributions",
+          "callee": "zip",
+          "lineNumber": 225
+        },
+        {
+          "caller": "save_distributions",
+          "callee": "metrics.loc[metrics[\"split\"] == split, metric].dropna",
+          "lineNumber": 227
+        },
+        {
+          "caller": "save_distributions",
+          "callee": "axis.hist",
+          "lineNumber": 228
+        },
+        {
+          "caller": "save_distributions",
+          "callee": "axis.set_title",
+          "lineNumber": 229
+        },
+        {
+          "caller": "save_distributions",
+          "callee": "metric.replace",
+          "lineNumber": 229
+        },
+        {
+          "caller": "save_distributions",
+          "callee": "axis.grid",
+          "lineNumber": 230
+        },
+        {
+          "caller": "save_distributions",
+          "callee": "len",
+          "lineNumber": 231
+        },
+        {
+          "caller": "save_distributions",
+          "callee": "axis.axis",
+          "lineNumber": 232
+        },
+        {
+          "caller": "save_distributions",
+          "callee": "axes[0].legend",
+          "lineNumber": 233
+        },
+        {
+          "caller": "save_distributions",
+          "callee": "figure.suptitle",
+          "lineNumber": 234
+        },
+        {
+          "caller": "save_distributions",
+          "callee": "figure.tight_layout",
+          "lineNumber": 235
+        },
+        {
+          "caller": "save_distributions",
+          "callee": "figure.savefig",
+          "lineNumber": 236
+        },
+        {
+          "caller": "save_distributions",
+          "callee": "plt.close",
+          "lineNumber": 237
+        },
+        {
+          "caller": "write_integrity_report",
+          "callee": "integrity[\"splits\"].items",
+          "lineNumber": 242
+        },
+        {
+          "caller": "write_integrity_report",
+          "callee": "lines.extend",
+          "lineNumber": 243
+        },
+        {
+          "caller": "write_integrity_report",
+          "callee": "len",
+          "lineNumber": 250
+        },
+        {
+          "caller": "write_integrity_report",
+          "callee": "len",
+          "lineNumber": 251
+        },
+        {
+          "caller": "write_integrity_report",
+          "callee": "lines.extend",
+          "lineNumber": 256
+        },
+        {
+          "caller": "write_integrity_report",
+          "callee": "lines.extend",
+          "lineNumber": 258
+        },
+        {
+          "caller": "write_integrity_report",
+          "callee": "', '.join",
+          "lineNumber": 258
+        },
+        {
+          "caller": "write_integrity_report",
+          "callee": "integrity[\"hash_groups\"].items",
+          "lineNumber": 258
+        },
+        {
+          "caller": "write_integrity_report",
+          "callee": "lines.append",
+          "lineNumber": 260
+        },
+        {
+          "caller": "write_integrity_report",
+          "callee": "lines.extend",
+          "lineNumber": 261
+        },
+        {
+          "caller": "write_integrity_report",
+          "callee": "path.write_text",
+          "lineNumber": 262
+        },
+        {
+          "caller": "write_integrity_report",
+          "callee": "\"\\n\".join",
+          "lineNumber": 262
+        },
+        {
+          "caller": "write_markdown_report",
+          "callee": "metrics.groupby(\"split\").size().to_dict",
+          "lineNumber": 266
+        },
+        {
+          "caller": "write_markdown_report",
+          "callee": "metrics.groupby(\"split\").size",
+          "lineNumber": 266
+        },
+        {
+          "caller": "write_markdown_report",
+          "callee": "metrics.groupby",
+          "lineNumber": 266
+        },
+        {
+          "caller": "write_markdown_report",
+          "callee": "metrics.groupby(\"split\")[PLOT_METRICS].median().reindex",
+          "lineNumber": 267
+        },
+        {
+          "caller": "write_markdown_report",
+          "callee": "metrics.groupby(\"split\")[PLOT_METRICS].median",
+          "lineNumber": 267
+        },
+        {
+          "caller": "write_markdown_report",
+          "callee": "metrics.groupby",
+          "lineNumber": 267
+        },
+        {
+          "caller": "write_markdown_report",
+          "callee": "len",
+          "lineNumber": 273
+        },
+        {
+          "caller": "write_markdown_report",
+          "callee": "counts.get",
+          "lineNumber": 274
+        },
+        {
+          "caller": "write_markdown_report",
+          "callee": "len",
+          "lineNumber": 275
+        },
+        {
+          "caller": "write_markdown_report",
+          "callee": "medians.round(4).to_markdown",
+          "lineNumber": 279
+        },
+        {
+          "caller": "write_markdown_report",
+          "callee": "medians.round",
+          "lineNumber": 279
+        },
+        {
+          "caller": "write_markdown_report",
+          "callee": "abs",
+          "lineNumber": 288
+        },
+        {
+          "caller": "write_markdown_report",
+          "callee": "float",
+          "lineNumber": 288
+        },
+        {
+          "caller": "write_markdown_report",
+          "callee": "lines.append",
+          "lineNumber": 289
+        },
+        {
+          "caller": "write_markdown_report",
+          "callee": "lines.extend",
+          "lineNumber": 290
+        },
+        {
+          "caller": "write_markdown_report",
+          "callee": "path.write_text",
+          "lineNumber": 303
+        },
+        {
+          "caller": "write_markdown_report",
+          "callee": "\"\\n\".join",
+          "lineNumber": 303
+        },
+        {
+          "caller": "main",
+          "callee": "parse_args",
+          "lineNumber": 307
+        },
+        {
+          "caller": "main",
+          "callee": "args.data_root.resolve",
+          "lineNumber": 308
+        },
+        {
+          "caller": "main",
+          "callee": "args.output_dir.resolve",
+          "lineNumber": 309
+        },
+        {
+          "caller": "main",
+          "callee": "print",
+          "lineNumber": 311
+        },
+        {
+          "caller": "main",
+          "callee": "str",
+          "lineNumber": 313
+        },
+        {
+          "caller": "main",
+          "callee": "MANIFESTS.values",
+          "lineNumber": 313
+        },
+        {
+          "caller": "main",
+          "callee": "(data_root / relative).is_file",
+          "lineNumber": 313
+        },
+        {
+          "caller": "main",
+          "callee": "print",
+          "lineNumber": 315
+        },
+        {
+          "caller": "main",
+          "callee": "\"\\n  \".join",
+          "lineNumber": 315
+        },
+        {
+          "caller": "main",
+          "callee": "output_dir.mkdir",
+          "lineNumber": 318
+        },
+        {
+          "caller": "main",
+          "callee": "inspect_dataset",
+          "lineNumber": 320
+        },
+        {
+          "caller": "main",
+          "callee": "print",
+          "lineNumber": 322
+        },
+        {
+          "caller": "main",
+          "callee": "metrics.to_csv",
+          "lineNumber": 325
+        },
+        {
+          "caller": "main",
+          "callee": "create_summary(metrics).to_csv",
+          "lineNumber": 327
+        },
+        {
+          "caller": "main",
+          "callee": "create_summary",
+          "lineNumber": 327
+        },
+        {
+          "caller": "main",
+          "callee": "save_grids",
+          "lineNumber": 328
+        },
+        {
+          "caller": "main",
+          "callee": "save_distributions",
+          "lineNumber": 329
+        },
+        {
+          "caller": "main",
+          "callee": "write_markdown_report",
+          "lineNumber": 330
+        },
+        {
+          "caller": "main",
+          "callee": "write_integrity_report",
+          "lineNumber": 331
+        },
+        {
+          "caller": "main",
+          "callee": "print",
+          "lineNumber": 333
+        },
+        {
+          "caller": "main",
+          "callee": "len",
+          "lineNumber": 333
+        },
+        {
+          "caller": "main",
+          "callee": "print",
+          "lineNumber": 335
+        },
+        {
+          "caller": "main",
+          "callee": "len",
+          "lineNumber": 335
+        }
+      ],
+      "metrics": {
+        "importCount": 0,
+        "exportCount": 14,
+        "functionCount": 14,
+        "classCount": 0
+      }
+    },
+    {
+      "path": "notebook324f4a11f8_upgraded.ipynb",
+      "language": "ipynb",
+      "fileCategory": "code",
+      "totalLines": 3255,
+      "nonEmptyLines": 3255,
+      "metrics": {}
+    },
+    {
+      "path": "retrieval_advanced.py",
+      "language": "python",
+      "fileCategory": "code",
+      "totalLines": 399,
+      "nonEmptyLines": 334,
+      "functions": [
+        {
+          "name": "load_manifest",
+          "startLine": 50,
+          "endLine": 58,
+          "params": [
+            "path"
+          ]
+        },
+        {
+          "name": "resolve_image_path",
+          "startLine": 61,
+          "endLine": 67,
+          "params": [
+            "manifest",
+            "relative_path"
+          ]
+        },
+        {
+          "name": "apply_d4",
+          "startLine": 80,
+          "endLine": 93,
+          "params": [
+            "image",
+            "view"
+          ]
+        },
+        {
+          "name": "cache_key",
+          "startLine": 114,
+          "endLine": 118,
+          "params": [
+            "manifest",
+            "split",
+            "view"
+          ]
+        },
+        {
+          "name": "cache_path",
+          "startLine": 121,
+          "endLine": 123,
+          "params": [
+            "manifest",
+            "split",
+            "view"
+          ]
+        },
+        {
+          "name": "split_global_dense",
+          "startLine": 126,
+          "endLine": 146,
+          "params": [
+            "model",
+            "raw_features"
+          ]
+        },
+        {
+          "name": "extract_and_cache",
+          "startLine": 150,
+          "endLine": 186,
+          "params": [
+            "model",
+            "transform",
+            "ids",
+            "paths",
+            "manifest",
+            "split",
+            "view"
+          ]
+        },
+        {
+          "name": "make_submission",
+          "startLine": 247,
+          "endLine": 258,
+          "params": [
+            "ranking",
+            "output"
+          ]
+        },
+        {
+          "name": "row_minmax",
+          "startLine": 266,
+          "endLine": 268,
+          "params": [
+            "values"
+          ]
+        },
+        {
+          "name": "local_features",
+          "startLine": 297,
+          "endLine": 304,
+          "params": [
+            "path"
+          ]
+        },
+        {
+          "name": "geometric_score",
+          "startLine": 307,
+          "endLine": 322,
+          "params": [
+            "query_feature",
+            "gallery_feature"
+          ]
+        },
+        {
+          "name": "overlap",
+          "startLine": 349,
+          "endLine": 350,
+          "params": [
+            "left",
+            "right",
+            "k"
+          ]
+        },
+        {
+          "name": "show_top1_comparison",
+          "startLine": 379,
+          "endLine": 396,
+          "params": [
+            "indices"
+          ]
+        }
+      ],
+      "classes": [
+        {
+          "name": "ImageDataset",
+          "startLine": 96,
+          "endLine": 110,
+          "methods": [
+            "__init__",
+            "__len__",
+            "__getitem__"
+          ],
+          "properties": []
+        }
+      ],
+      "exports": [
+        {
+          "name": "load_manifest",
+          "line": 50,
+          "isDefault": false
+        },
+        {
+          "name": "resolve_image_path",
+          "line": 61,
+          "isDefault": false
+        },
+        {
+          "name": "apply_d4",
+          "line": 80,
+          "isDefault": false
+        },
+        {
+          "name": "ImageDataset",
+          "line": 96,
+          "isDefault": false
+        },
+        {
+          "name": "cache_key",
+          "line": 114,
+          "isDefault": false
+        },
+        {
+          "name": "cache_path",
+          "line": 121,
+          "isDefault": false
+        },
+        {
+          "name": "split_global_dense",
+          "line": 126,
+          "isDefault": false
+        },
+        {
+          "name": "extract_and_cache",
+          "line": 149,
+          "isDefault": false
+        },
+        {
+          "name": "make_submission",
+          "line": 247,
+          "isDefault": false
+        },
+        {
+          "name": "row_minmax",
+          "line": 266,
+          "isDefault": false
+        },
+        {
+          "name": "local_features",
+          "line": 297,
+          "isDefault": false
+        },
+        {
+          "name": "geometric_score",
+          "line": 307,
+          "isDefault": false
+        },
+        {
+          "name": "overlap",
+          "line": 349,
+          "isDefault": false
+        },
+        {
+          "name": "show_top1_comparison",
+          "line": 379,
+          "isDefault": false
+        }
+      ],
+      "callGraph": [
+        {
+          "caller": "load_manifest",
+          "callee": "path.open",
+          "lineNumber": 51
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "json.load",
+          "lineNumber": 52
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "isinstance",
+          "lineNumber": 53
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "ValueError",
+          "lineNumber": 54
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "enumerate",
+          "lineNumber": 55
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "isinstance",
+          "lineNumber": 56
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "row.keys",
+          "lineNumber": 56
+        },
+        {
+          "caller": "load_manifest",
+          "callee": "ValueError",
+          "lineNumber": 57
+        },
+        {
+          "caller": "resolve_image_path",
+          "callee": "Path",
+          "lineNumber": 62
+        },
+        {
+          "caller": "resolve_image_path",
+          "callee": "candidate.is_file",
+          "lineNumber": 65
+        },
+        {
+          "caller": "resolve_image_path",
+          "callee": "FileNotFoundError",
+          "lineNumber": 67
+        },
+        {
+          "caller": "apply_d4",
+          "callee": "image.transpose",
+          "lineNumber": 92
+        },
+        {
+          "caller": "__len__",
+          "callee": "len",
+          "lineNumber": 101
+        },
+        {
+          "caller": "__getitem__",
+          "callee": "Image.open",
+          "lineNumber": 104
+        },
+        {
+          "caller": "__getitem__",
+          "callee": "image.convert",
+          "lineNumber": 105
+        },
+        {
+          "caller": "__getitem__",
+          "callee": "apply_d4",
+          "lineNumber": 107
+        },
+        {
+          "caller": "__getitem__",
+          "callee": "self.transform",
+          "lineNumber": 109
+        },
+        {
+          "caller": "cache_key",
+          "callee": "hashlib.sha256",
+          "lineNumber": 115
+        },
+        {
+          "caller": "cache_key",
+          "callee": "digest.update",
+          "lineNumber": 116
+        },
+        {
+          "caller": "cache_key",
+          "callee": "manifest.read_bytes",
+          "lineNumber": 116
+        },
+        {
+          "caller": "cache_key",
+          "callee": "digest.update",
+          "lineNumber": 117
+        },
+        {
+          "caller": "cache_key",
+          "callee": "f\"{MODEL_NAME}|{split}|{view}|dense8x8-v1\".encode",
+          "lineNumber": 117
+        },
+        {
+          "caller": "cache_key",
+          "callee": "digest.hexdigest",
+          "lineNumber": 118
+        },
+        {
+          "caller": "cache_path",
+          "callee": "MODEL_NAME.replace(\"/\", \"_\").replace",
+          "lineNumber": 122
+        },
+        {
+          "caller": "cache_path",
+          "callee": "MODEL_NAME.replace",
+          "lineNumber": 122
+        },
+        {
+          "caller": "cache_path",
+          "callee": "cache_key",
+          "lineNumber": 123
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "model.forward_head",
+          "lineNumber": 127
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "global_features.flatten(2).mean",
+          "lineNumber": 129
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "global_features.flatten",
+          "lineNumber": 129
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "int",
+          "lineNumber": 134
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "getattr",
+          "lineNumber": 134
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "math.isqrt",
+          "lineNumber": 136
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "ValueError",
+          "lineNumber": 138
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "tokens.transpose(1, 2).reshape",
+          "lineNumber": 139
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "tokens.transpose",
+          "lineNumber": 139
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "ValueError",
+          "lineNumber": 141
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "tuple",
+          "lineNumber": 141
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "min",
+          "lineNumber": 144
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "min",
+          "lineNumber": 144
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "F.adaptive_avg_pool2d(dense, (target_h, target_w)).flatten(2).transpose",
+          "lineNumber": 145
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "F.adaptive_avg_pool2d(dense, (target_h, target_w)).flatten",
+          "lineNumber": 145
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "F.adaptive_avg_pool2d",
+          "lineNumber": 145
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "F.normalize",
+          "lineNumber": 146
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "global_features.float",
+          "lineNumber": 146
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "F.normalize",
+          "lineNumber": 146
+        },
+        {
+          "caller": "split_global_dense",
+          "callee": "dense.float",
+          "lineNumber": 146
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "cache_path",
+          "lineNumber": 151
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "output.is_file",
+          "lineNumber": 152
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "torch.load",
+          "lineNumber": 153
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "print",
+          "lineNumber": 155
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "DataLoader",
+          "lineNumber": 158
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "ImageDataset",
+          "lineNumber": 159
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "images.to",
+          "lineNumber": 167
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "torch.autocast",
+          "lineNumber": 168
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "nullcontext",
+          "lineNumber": 168
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "model.forward_features",
+          "lineNumber": 170
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "split_global_dense",
+          "lineNumber": 171
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "extracted_ids.extend",
+          "lineNumber": 172
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "global_batches.append",
+          "lineNumber": 173
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "global_features.cpu",
+          "lineNumber": 173
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "dense_batches.append",
+          "lineNumber": 174
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "dense_features.half().cpu",
+          "lineNumber": 174
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "dense_features.half",
+          "lineNumber": 174
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "torch.cat",
+          "lineNumber": 178
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "torch.cat",
+          "lineNumber": 179
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "torch.isfinite(payload[\"global\"]).all",
+          "lineNumber": 183
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "torch.isfinite",
+          "lineNumber": 183
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "torch.isfinite(payload[\"dense\"]).all",
+          "lineNumber": 183
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "torch.isfinite",
+          "lineNumber": 183
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "torch.save",
+          "lineNumber": 184
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "print",
+          "lineNumber": 185
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "tuple",
+          "lineNumber": 185
+        },
+        {
+          "caller": "extract_and_cache",
+          "callee": "tuple",
+          "lineNumber": 185
+        },
+        {
+          "caller": "make_submission",
+          "callee": "pd.DataFrame",
+          "lineNumber": 248
+        },
+        {
+          "caller": "make_submission",
+          "callee": "\" \".join",
+          "lineNumber": 251
+        },
+        {
+          "caller": "make_submission",
+          "callee": "ranking.tolist",
+          "lineNumber": 251
+        },
+        {
+          "caller": "make_submission",
+          "callee": "len",
+          "lineNumber": 254
+        },
+        {
+          "caller": "make_submission",
+          "callee": "len",
+          "lineNumber": 254
+        },
+        {
+          "caller": "make_submission",
+          "callee": "all",
+          "lineNumber": 255
+        },
+        {
+          "caller": "make_submission",
+          "callee": "len",
+          "lineNumber": 255
+        },
+        {
+          "caller": "make_submission",
+          "callee": "value.split",
+          "lineNumber": 255
+        },
+        {
+          "caller": "make_submission",
+          "callee": "len",
+          "lineNumber": 255
+        },
+        {
+          "caller": "make_submission",
+          "callee": "set",
+          "lineNumber": 255
+        },
+        {
+          "caller": "make_submission",
+          "callee": "value.split",
+          "lineNumber": 255
+        },
+        {
+          "caller": "make_submission",
+          "callee": "frame.to_csv",
+          "lineNumber": 256
+        },
+        {
+          "caller": "make_submission",
+          "callee": "print",
+          "lineNumber": 257
+        },
+        {
+          "caller": "row_minmax",
+          "callee": "values.min",
+          "lineNumber": 267
+        },
+        {
+          "caller": "row_minmax",
+          "callee": "values.max",
+          "lineNumber": 267
+        },
+        {
+          "caller": "row_minmax",
+          "callee": "(high - low).clamp_min",
+          "lineNumber": 268
+        },
+        {
+          "caller": "local_features",
+          "callee": "cv2.imread",
+          "lineNumber": 298
+        },
+        {
+          "caller": "local_features",
+          "callee": "str",
+          "lineNumber": 298
+        },
+        {
+          "caller": "local_features",
+          "callee": "ValueError",
+          "lineNumber": 300
+        },
+        {
+          "caller": "local_features",
+          "callee": "cv2.resize",
+          "lineNumber": 301
+        },
+        {
+          "caller": "local_features",
+          "callee": "cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)).apply",
+          "lineNumber": 302
+        },
+        {
+          "caller": "local_features",
+          "callee": "cv2.createCLAHE",
+          "lineNumber": 302
+        },
+        {
+          "caller": "local_features",
+          "callee": "cv2.SIFT_create",
+          "lineNumber": 303
+        },
+        {
+          "caller": "local_features",
+          "callee": "sift.detectAndCompute",
+          "lineNumber": 304
+        },
+        {
+          "caller": "geometric_score",
+          "callee": "len",
+          "lineNumber": 310
+        },
+        {
+          "caller": "geometric_score",
+          "callee": "len",
+          "lineNumber": 310
+        },
+        {
+          "caller": "geometric_score",
+          "callee": "cv2.BFMatcher(cv2.NORM_L2).knnMatch",
+          "lineNumber": 312
+        },
+        {
+          "caller": "geometric_score",
+          "callee": "cv2.BFMatcher",
+          "lineNumber": 312
+        },
+        {
+          "caller": "geometric_score",
+          "callee": "len",
+          "lineNumber": 314
+        },
+        {
+          "caller": "geometric_score",
+          "callee": "len",
+          "lineNumber": 315
+        },
+        {
+          "caller": "geometric_score",
+          "callee": "np.float32([query_keypoints[match.queryIdx].pt for match in good]).reshape",
+          "lineNumber": 316
+        },
+        {
+          "caller": "geometric_score",
+          "callee": "np.float32",
+          "lineNumber": 316
+        },
+        {
+          "caller": "geometric_score",
+          "callee": "np.float32([gallery_keypoints[match.trainIdx].pt for match in good]).reshape",
+          "lineNumber": 317
+        },
+        {
+          "caller": "geometric_score",
+          "callee": "np.float32",
+          "lineNumber": 317
+        },
+        {
+          "caller": "geometric_score",
+          "callee": "cv2.findHomography",
+          "lineNumber": 318
+        },
+        {
+          "caller": "geometric_score",
+          "callee": "int",
+          "lineNumber": 319
+        },
+        {
+          "caller": "geometric_score",
+          "callee": "mask.sum",
+          "lineNumber": 319
+        },
+        {
+          "caller": "geometric_score",
+          "callee": "len",
+          "lineNumber": 320
+        },
+        {
+          "caller": "geometric_score",
+          "callee": "math.log1p",
+          "lineNumber": 321
+        },
+        {
+          "caller": "geometric_score",
+          "callee": "len",
+          "lineNumber": 322
+        },
+        {
+          "caller": "overlap",
+          "callee": "float",
+          "lineNumber": 350
+        },
+        {
+          "caller": "overlap",
+          "callee": "np.mean",
+          "lineNumber": 350
+        },
+        {
+          "caller": "overlap",
+          "callee": "len",
+          "lineNumber": 350
+        },
+        {
+          "caller": "overlap",
+          "callee": "set",
+          "lineNumber": 350
+        },
+        {
+          "caller": "overlap",
+          "callee": "set",
+          "lineNumber": 350
+        },
+        {
+          "caller": "overlap",
+          "callee": "zip",
+          "lineNumber": 350
+        },
+        {
+          "caller": "overlap",
+          "callee": "left.tolist",
+          "lineNumber": 350
+        },
+        {
+          "caller": "overlap",
+          "callee": "right.tolist",
+          "lineNumber": 350
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "range",
+          "lineNumber": 379
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "plt.subplots",
+          "lineNumber": 381
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "len",
+          "lineNumber": 381
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "tuple",
+          "lineNumber": 381
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "len",
+          "lineNumber": 381
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "tuple",
+          "lineNumber": 381
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "np.atleast_2d",
+          "lineNumber": 382
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "enumerate",
+          "lineNumber": 383
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "Image.open",
+          "lineNumber": 384
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "axes[row, 0].imshow",
+          "lineNumber": 385
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "image.convert",
+          "lineNumber": 385
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "axes[row, 0].set_title",
+          "lineNumber": 386
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "enumerate",
+          "lineNumber": 387
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "int",
+          "lineNumber": 388
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "Image.open",
+          "lineNumber": 389
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "axes[row, column].imshow",
+          "lineNumber": 390
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "image.convert",
+          "lineNumber": 390
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "axes[row, column].set_title",
+          "lineNumber": 391
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "axis.axis",
+          "lineNumber": 393
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "plt.tight_layout",
+          "lineNumber": 394
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "plt.savefig",
+          "lineNumber": 395
+        },
+        {
+          "caller": "show_top1_comparison",
+          "callee": "plt.show",
+          "lineNumber": 396
+        }
+      ],
+      "metrics": {
+        "importCount": 0,
+        "exportCount": 14,
+        "functionCount": 13,
+        "classCount": 1
+      }
+    }
+  ]
+}

.understand-anything/tmp/ua-import-map-input.json

@@ -0,0 +1,12 @@
+{
+  "projectRoot": "/mnt/data/openai_cv",
+  "files": [
+    {"path":".understand-anything/.understandignore","language":"unknown","sizeLines":47,"fileCategory":"code"},
+    {"path":".understand-anything/config.json","language":"json","sizeLines":3,"fileCategory":"config"},
+    {"path":"baseline_dinov3.py","language":"python","sizeLines":397,"fileCategory":"code"},
+    {"path":"de_bai_image_to_image_retrieval.md","language":"markdown","sizeLines":66,"fileCategory":"docs"},
+    {"path":"eda.py","language":"python","sizeLines":341,"fileCategory":"code"},
+    {"path":"notebook324f4a11f8_upgraded.ipynb","language":"ipynb","sizeLines":3255,"fileCategory":"code"},
+    {"path":"retrieval_advanced.py","language":"python","sizeLines":399,"fileCategory":"code"}
+  ]
+}

.understand-anything/tmp/ua-import-map-output.json

@@ -0,0 +1,17 @@
+{
+  "scriptCompleted": true,
+  "stats": {
+    "filesScanned": 7,
+    "filesWithImports": 0,
+    "totalEdges": 0
+  },
+  "importMap": {
+    ".understand-anything/.understandignore": [],
+    ".understand-anything/config.json": [],
+    "baseline_dinov3.py": [],
+    "de_bai_image_to_image_retrieval.md": [],
+    "eda.py": [],
+    "notebook324f4a11f8_upgraded.ipynb": [],
+    "retrieval_advanced.py": []
+  }
+}

.understand-anything/tmp/ua-scan-files.json

@@ -0,0 +1,65 @@
+{
+  "scriptCompleted": true,
+  "files": [
+    {
+      "path": ".understand-anything/.understandignore",
+      "language": "unknown",
+      "sizeLines": 47,
+      "fileCategory": "code"
+    },
+    {
+      "path": ".understand-anything/config.json",
+      "language": "json",
+      "sizeLines": 3,
+      "fileCategory": "config"
+    },
+    {
+      "path": "baseline_dinov3.py",
+      "language": "python",
+      "sizeLines": 397,
+      "fileCategory": "code"
+    },
+    {
+      "path": "de_bai_image_to_image_retrieval.md",
+      "language": "markdown",
+      "sizeLines": 66,
+      "fileCategory": "docs"
+    },
+    {
+      "path": "eda.py",
+      "language": "python",
+      "sizeLines": 341,
+      "fileCategory": "code"
+    },
+    {
+      "path": "notebook324f4a11f8_upgraded.ipynb",
+      "language": "ipynb",
+      "sizeLines": 3255,
+      "fileCategory": "code"
+    },
+    {
+      "path": "retrieval_advanced.py",
+      "language": "python",
+      "sizeLines": 399,
+      "fileCategory": "code"
+    }
+  ],
+  "totalFiles": 7,
+  "filteredByIgnore": 32,
+  "estimatedComplexity": "small",
+  "stats": {
+    "filesScanned": 7,
+    "byCategory": {
+      "code": 5,
+      "config": 1,
+      "docs": 1
+    },
+    "byLanguage": {
+      "unknown": 1,
+      "json": 1,
+      "python": 3,
+      "markdown": 1,
+      "ipynb": 1
+    }
+  }
+}

README.md

@@ -0,0 +1,20 @@
+# Self-supervised image retrieval
+
+`ssl_retrieval` trains retrieval representations for the 64×64 unlabeled image dataset. It contains frozen DINO inference, SimCLR, an autoencoder pretext task, four-way rotation prediction, and joint training. Retrieval always uses the normalized encoder embedding and cosine similarity.
+
+## Commands
+
+```bash
+python -m ssl_retrieval train --method simclr --output checkpoints/simclr.pt
+python -m ssl_retrieval train --method joint --output checkpoints/joint.pt
+python -m ssl_retrieval evaluate --method joint --checkpoint checkpoints/joint.pt
+python -m ssl_retrieval retrieve --method joint --checkpoint checkpoints/joint.pt \
+  --gallery data/dataset2/public_test/public_test/gallery.json \
+  --queries data/dataset2/public_test/public_test/queries.json \
+  --output submission_public.csv
+```
+
+Use `--from-scratch` to disable the default ImageNet initialization. Joint loss weights are configurable with `--contrastive-weight`, `--reconstruction-weight`, and `--rotation-weight`.
+
+Training reserves a deterministic pseudo-gallery of 1,000 train images and creates 200 degraded queries from it. The remaining 2,000 images are used for optimization. The best checkpoint maximizes the mean of Recall@1, Recall@5, Recall@10, and mAP@10. Defaults target one 8 GB GPU and the competition's 20-minute limit; reduce `--epochs` if needed.
+

baseline_dinov3.py

@@ -0,0 +1,11 @@
+"""Deprecated compatibility entrypoint for frozen DINO retrieval."""
+
+import sys
+
+from ssl_retrieval.__main__ import main
+
+
+if __name__ == "__main__":
+    print("Deprecated: use `python -m ssl_retrieval retrieve --method dino ...`", file=sys.stderr)
+    main(["retrieve", "--method", "dino", *sys.argv[1:]])
+

de_bai_image_to_image_retrieval.md

@@ -0,0 +1,67 @@
+# Đề thi Olympic AI — Image-to-Image Instance Retrieval (không nhãn)
+
+## 1. Bài toán
+
+Bạn được cung cấp một **gallery** gồm $N$ ảnh và một tập **queries** gồm $M$ ảnh truy vấn. Với **mỗi** ảnh truy vấn $q$, trong gallery có **đúng một ảnh** là "cùng một cảnh gốc" với $q$ (chỉ khác góc chụp/crop/xoay và có thể bị suy giảm chất lượng) — gọi là **ảnh khớp đúng**. Mọi ảnh gallery còn lại đều **không khớp**, kể cả khi chúng trông khá giống $q$ về mặt nội dung tổng quát (cùng loại địa hình, cùng tông màu...).
+
+Nhiệm vụ: xây dựng một hệ thống trả về **top-10 ảnh trong gallery** có khả năng cao nhất là ảnh khớp đúng của $q$, xếp theo độ ưu tiên giảm dần.
+
+Cách bạn biểu diễn ảnh, đo độ giống nhau, và (nếu muốn) huấn luyện mô hình như thế nào là **hoàn toàn tự do** — đề không yêu cầu thuật toán cụ thể.
+
+**Khác biệt quan trọng so với bài toán phân loại ảnh:** đây **không phải** bài toán "đoán ảnh thuộc nhóm/thể loại nào rồi lấy đại diện của nhóm đó". Gallery có nhiều ảnh trông rất giống nhau về tổng thể (cùng kiểu địa hình), nhưng chỉ **một ảnh cụ thể duy nhất** là đáp án đúng cho mỗi query — hệ thống phải phân biệt được sự khớp ở mức **từng ảnh cụ thể** (instance), không chỉ ở mức "cùng thể loại chung chung". Một hệ thống chỉ biết gom nhóm/phân loại tổng quát sẽ liên tục nhầm giữa nhiều ảnh "giống loại" mà không tìm ra đúng ảnh gốc.
+
+## 2. Dữ liệu — không có nhãn nào được cung cấp
+
+Ảnh trong bộ dữ liệu này **không đi kèm bất kỳ nhãn, thể loại, hay mô tả nào** — chỉ là các file ảnh. Bạn không được cho biết ảnh thuộc chủ đề gì, có bao nhiêu nhóm, hay các nhóm đó là gì. Đây là chủ đích của đề: bạn phải tự xây dựng biểu diễn ảnh (feature/embedding) từ chính cấu trúc dữ liệu, không dựa vào nhãn có sẵn.
+
+- **`train_unlabeled/`**: 3.000 ảnh không nhãn, tự do sử dụng để pretraining biểu diễn ảnh (self-supervised learning, ví dụ contrastive learning kiểu SimCLR/MoCo, autoencoder, rotation prediction, hoặc trích đặc trưng tay). `train_unlabeled.json` chỉ có `image_id`/`image_path`, không có trường nhãn nào.
+- **`public_test/gallery.json` + `queries.json`**: 1.000 ảnh gallery + 200 ảnh query, không nhãn. Ảnh đã bị suy giảm chất lượng (nhiễu, mờ, sai lệch sáng/tương phản, che khuất một phần, thay đổi góc chụp/crop...) so với ảnh gốc.
+- **`private_test/gallery.json` + `queries.json`**: cùng cấu trúc, 1.000 gallery + 200 query, ảnh **bị suy giảm chất lượng nặng hơn/khác kiểu**, và **gallery cố tình chứa nhiều ảnh "giống loại" với ảnh đúng** (hard negative) để việc chỉ nhận diện thể loại chung chung không đủ tìm ra đáp án — bạn phải phân biệt đúng ảnh cụ thể.
+
+`image_id` là chuỗi ngẫu nhiên, không mang thông tin gì về nội dung ảnh.
+
+## 3. Cấu trúc cuộc thi (train / public test / private test)
+
+- `train_unlabeled/`: dùng tự do, không tính điểm.
+- `public_test/`: nộp `submission_public.csv` **nhiều lần trong suốt thời gian thi** (tối đa N lần/ngày, ví dụ 5) để nhận điểm public leaderboard tức thời (tham khảo, không tính vào điểm cuối).
+- `private_test/`: nộp `submission_private.csv` **một lần duy nhất** khi hết giờ thi. Không hiển thị điểm lúc thi — chỉ ban giám khảo chấm sau khi đóng cổng, dùng để **xếp hạng cuối cùng**.
+
+## 4. Định dạng nộp bài
+
+Hai file CSV tách riêng, mỗi file 2 cột, dòng đầu là header bắt buộc:
+
+```csv
+query_id,gallery_ids
+q_abc123,gal_x1 gal_x2 gal_x3 gal_x4 gal_x5 gal_x6 gal_x7 gal_x8 gal_x9 gal_x10
+```
+
+- Mỗi dòng ứng với đúng 1 `query_id`; cột `gallery_ids` là **đúng 10** `gallery_id` cách nhau bằng dấu cách, xếp theo độ ưu tiên giảm dần.
+- `submission_public.csv` chỉ trỏ vào `gallery_id` thuộc `public_test/gallery.json`; `submission_private.csv` chỉ trỏ vào `private_test/gallery.json`.
+- Phải có đủ dòng cho mọi `query_id` — thiếu dòng nào bị 0 điểm cho query đó. Trùng `gallery_id` trong 1 dòng → dòng đó bị 0 điểm (không ảnh hưởng các dòng khác).
+- Kèm mã nguồn tái tạo được kết quả. Khuyến khích (không bắt buộc, không tính điểm) nộp thêm báo cáo ngắn mô tả cách tiếp cận.
+
+## 5. Chấm điểm
+
+Với mỗi query, **chỉ có đúng 1 ảnh gallery liên quan** (ảnh khớp đúng — instance-level, không phải "cùng nhóm").
+
+| Tiêu chí | Trọng số |
+|---|---|
+| Recall@1 (private) | 25% |
+| Recall@5 (private) | 25% |
+| Recall@10 (private) | 25% |
+| mAP@10 (private) | 25% |
+
+Vì mỗi query chỉ có 1 ảnh đúng duy nhất, mAP@10 ở đây tương đương **1/thứ hạng của ảnh đúng** (nếu lọt top-10), hoặc 0 nếu không lọt — **thứ tự trả về thực sự quan trọng**, không giống các bài toán mà "cùng nhóm là được".
+
+**Công thức chính xác** (áp dụng cho từng query, rồi lấy trung bình trên toàn bộ query):
+
+- **Recall@K** = 1 nếu ảnh khớp đúng nằm trong K vị trí đầu tiên bạn trả về, ngược lại = 0.
+- **AP@10** (average precision, chỉ 1 ảnh liên quan/query): gọi $r$ là thứ hạng (1-indexed) của ảnh khớp đúng trong 10 ảnh bạn trả về — nếu có, AP = $1/r$; nếu ảnh khớp đúng không nằm trong top-10, AP = 0. **mAP@10** = trung bình AP@10 trên toàn bộ query.
+
+## 6. Ràng buộc
+
+- Ngôn ngữ: tự chọn (Python khuyến nghị).
+- Được phép dùng internet (tải backbone/mô hình pretrained, tra cứu tài liệu...).
+- **Quy định danh dự (honor code)**: không được cố tình tra cứu/suy luận ngược nguồn gốc ảnh (reverse image search, tìm ra bộ dữ liệu gốc rồi tra cứu) để lấy thông tin ngoài hệ thống retrieval bạn tự xây dựng. Vi phạm bị xử lý theo quy chế thi nếu bị phát hiện.
+- Thời gian chạy toàn bộ pipeline (từ ảnh thô đến CSV nộp bài) ≤ 20 phút trên máy thi.
+- Được dùng backbone/mô hình pretrained sẵn có (torchvision, HuggingFace...), miễn không phải mô hình đã huấn luyện sẵn cho chính bộ dữ liệu/bài toán này.

eda.py

@@ -0,0 +1,341 @@
+#!/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())

requirements.txt

@@ -0,0 +1,5 @@
+Pillow>=10
+timm>=1.0
+torch>=2.2
+torchvision>=0.17
+

retrieval_advanced.py

@@ -0,0 +1,11 @@
+"""Deprecated compatibility entrypoint for learned retrieval checkpoints."""
+
+import sys
+
+from ssl_retrieval.__main__ import main
+
+
+if __name__ == "__main__":
+    print("Deprecated: use `python -m ssl_retrieval retrieve ...`", file=sys.stderr)
+    main(["retrieve", *sys.argv[1:]])
+

ssl_retrieval/__init__.py

@@ -0,0 +1,4 @@
+"""Learning-based self-supervised image retrieval."""
+
+__version__ = "1.0.0"
+

ssl_retrieval/__main__.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import argparse
+
+import torch
+
+from .engine import evaluate, retrieve, train
+
+
+def parser():
+    root = argparse.ArgumentParser(description="Self-supervised image retrieval")
+    sub = root.add_subparsers(dest="command", required=True)
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--data-root", default="data/dataset2")
+    common.add_argument("--batch-size", type=int, default=64)
+    common.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
+    common.add_argument("--seed", type=int, default=42)
+    method = argparse.ArgumentParser(add_help=False, parents=[common])
+    method.add_argument("--method", choices=("dino", "simclr", "autoencoder", "rotation", "joint"), required=True)
+    method.add_argument("--checkpoint")
+
+    training = sub.add_parser("train", parents=[common])
+    training.add_argument("--method", choices=("simclr", "autoencoder", "rotation", "joint"), required=True)
+    training.add_argument("--train-manifest", default="data/dataset2/train_unlabeled.json")
+    training.add_argument("--output", default="checkpoints/best.pt")
+    training.add_argument("--epochs", type=int, default=20)
+    training.add_argument("--lr", type=float, default=3e-4)
+    training.add_argument("--temperature", type=float, default=0.2)
+    training.add_argument("--contrastive-weight", type=float, default=1.0)
+    training.add_argument("--reconstruction-weight", type=float, default=0.1)
+    training.add_argument("--rotation-weight", type=float, default=0.5)
+    training.add_argument("--from-scratch", action="store_true")
+    training.set_defaults(handler=train)
+
+    evaluation = sub.add_parser("evaluate", parents=[method])
+    evaluation.add_argument("--train-manifest", default="data/dataset2/train_unlabeled.json")
+    evaluation.set_defaults(handler=evaluate)
+
+    retrieval = sub.add_parser("retrieve", parents=[method])
+    retrieval.add_argument("--gallery", required=True)
+    retrieval.add_argument("--queries", required=True)
+    retrieval.add_argument("--output", required=True)
+    retrieval.set_defaults(handler=retrieve)
+    return root
+
+
+def main(argv=None):
+    args = parser().parse_args(argv)
+    args.handler(args)
+
+
+if __name__ == "__main__":
+    main()
+

ssl_retrieval/checkpoints.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import torch
+
+from . import __version__
+from .models import SSLModel
+
+
+def save_checkpoint(path, model, method, config, epoch, metrics):
+    payload = {
+        "version": __version__, "method": method, "epoch": epoch,
+        "config": config, "metrics": metrics, "encoder": model.encoder.state_dict(),
+        "projector": model.projector.state_dict() if model.projector else None,
+        "rotation_head": model.rotation_head.state_dict() if model.rotation_head else None,
+        "decoder": model.decoder.state_dict() if model.decoder else None,
+    }
+    Path(path).parent.mkdir(parents=True, exist_ok=True)
+    torch.save(payload, path)
+
+
+def load_checkpoint(path, device="cpu"):
+    payload = torch.load(path, map_location=device, weights_only=True)
+    model = SSLModel(payload["method"], pretrained=False)
+    model.encoder.load_state_dict(payload["encoder"])
+    for name in ("projector", "rotation_head", "decoder"):
+        module, state = getattr(model, name), payload.get(name)
+        if module is not None and state is not None:
+            module.load_state_dict(state)
+    return model.to(device), payload
+

ssl_retrieval/data.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import json
+import random
+from dataclasses import dataclass
+from pathlib import Path
+
+from PIL import Image
+from torch.utils.data import Dataset
+
+
+@dataclass(frozen=True)
+class ImageRecord:
+    image_id: str
+    path: Path
+
+
+def load_manifest(path: str | Path, data_root: str | Path | None = None) -> list[ImageRecord]:
+    manifest = Path(path)
+    root = Path(data_root) if data_root else manifest.parent
+    rows = json.loads(manifest.read_text(encoding="utf-8"))
+    if not isinstance(rows, list):
+        raise ValueError(f"{manifest}: expected a JSON list")
+    records = []
+    for index, row in enumerate(rows):
+        if not isinstance(row, dict) or not {"image_id", "image_path"} <= row.keys():
+            raise ValueError(f"{manifest}: invalid row {index}")
+        relative = Path(row["image_path"])
+        candidates = (relative,) if relative.is_absolute() else (
+            root / relative,
+            manifest.parent / relative,
+            manifest.parent.parent / relative,
+            manifest.parent.parent.parent / relative,
+        )
+        resolved = next((candidate for candidate in candidates if candidate.is_file()), None)
+        if resolved is None:
+            raise FileNotFoundError(f"Cannot resolve {relative} from {manifest}")
+        records.append(ImageRecord(str(row["image_id"]), resolved.resolve()))
+    if len({record.image_id for record in records}) != len(records):
+        raise ValueError(f"{manifest}: duplicate image IDs")
+    return records
+
+
+def pseudo_split(records: list[ImageRecord], seed: int = 42, gallery_size: int = 1000, query_size: int = 200):
+    if len(records) < gallery_size:
+        raise ValueError(f"Need at least {gallery_size} records")
+    shuffled = records.copy()
+    random.Random(seed).shuffle(shuffled)
+    gallery = shuffled[:gallery_size]
+    query_indices = random.Random(seed + 1).sample(range(gallery_size), query_size)
+    queries = [(gallery[index], seed * 100_000 + order) for order, index in enumerate(query_indices)]
+    return shuffled[gallery_size:], gallery, queries
+
+
+class ImageDataset(Dataset):
+    def __init__(self, records: list[ImageRecord], transform):
+        self.records, self.transform = records, transform
+
+    def __len__(self):
+        return len(self.records)
+
+    def __getitem__(self, index):
+        record = self.records[index]
+        with Image.open(record.path) as image:
+            return record.image_id, self.transform(image.convert("RGB"))
+
+
+class TrainingDataset(Dataset):
+    def __init__(self, records: list[ImageRecord], method: str, transforms):
+        self.records, self.method, self.transforms = records, method, transforms
+
+    def __len__(self):
+        return len(self.records)
+
+    def __getitem__(self, index):
+        with Image.open(self.records[index].path) as source:
+            image = source.convert("RGB")
+            clean = self.transforms.clean(image)
+            sample = {"clean": clean}
+            if self.method in {"simclr", "joint"}:
+                sample["view1"] = self.transforms.contrastive(image)
+                sample["view2"] = self.transforms.contrastive(image)
+            if self.method in {"autoencoder", "joint"}:
+                sample["degraded"] = self.transforms.degraded(image)
+            if self.method in {"rotation", "joint"}:
+                rotated, label = self.transforms.rotation(image)
+                sample["rotated"], sample["rotation_label"] = rotated, label
+            return sample
+

ssl_retrieval/engine.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import json
+import random
+from contextlib import nullcontext
+from pathlib import Path
+
+import torch
+from PIL import Image
+from torch.nn import functional as F
+from torch.utils.data import DataLoader
+
+from .checkpoints import load_checkpoint, save_checkpoint
+from .data import ImageDataset, TrainingDataset, load_manifest, pseudo_split
+from .losses import nt_xent
+from .models import DINOEncoder, SSLModel
+from .retrieval import rank_embeddings, rankings, retrieval_metrics, validate_rankings, write_submission
+from .transforms import TrainTransforms, deterministic_degrade, inference_transform
+
+
+@torch.inference_mode()
+def encode(model, records, batch_size, device, transform=inference_transform):
+    loader = DataLoader(ImageDataset(records, transform), batch_size=batch_size, shuffle=False)
+    ids, batches = [], []
+    model.eval()
+    for batch_ids, images in loader:
+        ids.extend(batch_ids)
+        batches.append(model(images.to(device)).cpu())
+    return ids, torch.cat(batches)
+
+
+@torch.inference_mode()
+def evaluate_pseudo(model, train_manifest, data_root, batch_size, device, seed=42):
+    records = load_manifest(train_manifest, data_root)
+    _, gallery, query_pairs = pseudo_split(records, seed)
+    query_records = []
+    query_tensors = []
+    for order, (record, degradation_seed) in enumerate(query_pairs):
+        query_records.append(f"pseudo_q_{order:04d}")
+        with Image.open(record.path) as image:
+            query_tensors.append(inference_transform(deterministic_degrade(image, degradation_seed)))
+    gallery_ids, gallery_features = encode(model, gallery, batch_size, device)
+    query_features = []
+    for start in range(0, len(query_tensors), batch_size):
+        query_features.append(model(torch.stack(query_tensors[start:start + batch_size]).to(device)).cpu())
+    _, indices = rank_embeddings(torch.cat(query_features), gallery_features)
+    predictions = rankings(query_records, gallery_ids, indices)
+    truth = {query_records[i]: record.image_id for i, (record, _) in enumerate(query_pairs)}
+    return retrieval_metrics(predictions, truth)
+
+
+def train(args):
+    random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(args.seed)
+    device = torch.device(args.device)
+    records = load_manifest(args.train_manifest, args.data_root)
+    training, _, _ = pseudo_split(records, args.seed)
+    dataset = TrainingDataset(training, args.method, TrainTransforms())
+    loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True, drop_last=args.method in {"simclr", "joint"})
+    model = SSLModel(args.method, pretrained=not args.from_scratch).to(device)
+    optimizer = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=1e-4)
+    scaler = torch.amp.GradScaler("cuda", enabled=device.type == "cuda")
+    best = -1.0
+    config = {key: value for key, value in vars(args).items() if key != "handler"}
+    for epoch in range(1, args.epochs + 1):
+        model.train()
+        total = 0.0
+        for sample in loader:
+            optimizer.zero_grad(set_to_none=True)
+            amp = torch.autocast("cuda", dtype=torch.float16) if device.type == "cuda" else nullcontext()
+            with amp:
+                loss = torch.zeros((), device=device)
+                if args.method in {"simclr", "joint"}:
+                    loss = loss + args.contrastive_weight * nt_xent(model.project(sample["view1"].to(device)), model.project(sample["view2"].to(device)), args.temperature)
+                if args.method in {"autoencoder", "joint"}:
+                    loss = loss + args.reconstruction_weight * F.mse_loss(model.reconstruct(sample["degraded"].to(device)), sample["clean"].to(device))
+                if args.method in {"rotation", "joint"}:
+                    loss = loss + args.rotation_weight * F.cross_entropy(model.predict_rotation(sample["rotated"].to(device)), sample["rotation_label"].to(device))
+            scaler.scale(loss).backward()
+            scaler.step(optimizer)
+            scaler.update()
+            total += float(loss.detach())
+        metrics = evaluate_pseudo(model.encoder, args.train_manifest, args.data_root, args.batch_size, device, args.seed)
+        print(json.dumps({"epoch": epoch, "loss": total / len(loader), **metrics}))
+        if metrics["score"] > best:
+            best = metrics["score"]
+            save_checkpoint(args.output, model, args.method, config, epoch, metrics)
+
+
+def load_encoder(method, checkpoint, device):
+    if method == "dino":
+        return DINOEncoder().eval().to(device)
+    if not checkpoint:
+        raise ValueError(f"--checkpoint is required for {method}")
+    model, _ = load_checkpoint(checkpoint, device)
+    if model.method != method:
+        raise ValueError(f"Checkpoint method is {model.method}, not {method}")
+    return model.encoder.eval()
+
+
+def evaluate(args):
+    device = torch.device(args.device)
+    model = load_encoder(args.method, args.checkpoint, device)
+    print(json.dumps(evaluate_pseudo(model, args.train_manifest, args.data_root, args.batch_size, device, args.seed), indent=2))
+
+
+def retrieve(args):
+    device = torch.device(args.device)
+    model = load_encoder(args.method, args.checkpoint, device)
+    gallery = load_manifest(args.gallery, args.data_root)
+    queries = load_manifest(args.queries, args.data_root)
+    gallery_ids, gallery_features = encode(model, gallery, args.batch_size, device)
+    query_ids, query_features = encode(model, queries, args.batch_size, device)
+    _, indices = rank_embeddings(query_features, gallery_features)
+    predictions = rankings(query_ids, gallery_ids, indices)
+    validate_rankings(predictions, query_ids, gallery_ids)
+    write_submission(predictions, args.output)
+    print(f"saved {args.output}")

ssl_retrieval/losses.py

@@ -0,0 +1,14 @@
+import torch
+from torch.nn import functional as F
+
+
+def nt_xent(left: torch.Tensor, right: torch.Tensor, temperature: float = 0.2) -> torch.Tensor:
+    batch = left.shape[0]
+    if batch < 2:
+        raise ValueError("NT-Xent requires batch size >= 2")
+    features = torch.cat((left, right), dim=0)
+    logits = features @ features.T / temperature
+    logits.fill_diagonal_(float("-inf"))
+    targets = (torch.arange(2 * batch, device=features.device) + batch) % (2 * batch)
+    return F.cross_entropy(logits, targets)
+

ssl_retrieval/models.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import timm
+import torch
+from torch import nn
+from torch.nn import functional as F
+from torchvision.models import ResNet18_Weights, resnet18
+
+
+class Encoder(nn.Module):
+    output_dim = 512
+
+    def __init__(self, pretrained: bool = True):
+        super().__init__()
+        model = resnet18(weights=ResNet18_Weights.DEFAULT if pretrained else None)
+        model.conv1 = nn.Conv2d(3, 64, 3, 1, 1, bias=False)
+        model.maxpool = nn.Identity()
+        model.fc = nn.Identity()
+        self.model = model
+
+    def forward(self, images):
+        return F.normalize(self.model(images), dim=1)
+
+
+class SSLModel(nn.Module):
+    def __init__(self, method: str, pretrained: bool = True, projection_dim: int = 128):
+        super().__init__()
+        self.method = method
+        self.encoder = Encoder(pretrained)
+        dim = self.encoder.output_dim
+        self.projector = nn.Sequential(nn.Linear(dim, dim), nn.ReLU(), nn.Linear(dim, projection_dim)) if method in {"simclr", "joint"} else None
+        self.rotation_head = nn.Linear(dim, 4) if method in {"rotation", "joint"} else None
+        self.decoder = nn.Sequential(
+            nn.Linear(dim, 512 * 4 * 4), nn.Unflatten(1, (512, 4, 4)),
+            nn.ConvTranspose2d(512, 256, 4, 2, 1), nn.ReLU(),
+            nn.ConvTranspose2d(256, 128, 4, 2, 1), nn.ReLU(),
+            nn.ConvTranspose2d(128, 64, 4, 2, 1), nn.ReLU(),
+            nn.ConvTranspose2d(64, 3, 4, 2, 1), nn.Sigmoid(),
+        ) if method in {"autoencoder", "joint"} else None
+
+    def embedding(self, images):
+        return self.encoder(images)
+
+    def project(self, images):
+        return F.normalize(self.projector(self.encoder(images)), dim=1)
+
+    def reconstruct(self, images):
+        return self.decoder(self.encoder(images))
+
+    def predict_rotation(self, images):
+        return self.rotation_head(self.encoder(images))
+
+
+class DINOEncoder(nn.Module):
+    def __init__(self, model_name="convnext_tiny.dinov3_lvd1689m"):
+        super().__init__()
+        self.model = timm.create_model(model_name, pretrained=True, num_classes=0)
+
+    def forward(self, images):
+        features = self.model(images)
+        if features.ndim > 2:
+            features = features.flatten(2).mean(-1)
+        return F.normalize(features.float(), dim=1)
+

ssl_retrieval/retrieval.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+
+import torch
+from torch.nn import functional as F
+
+
+def rank_embeddings(query: torch.Tensor, gallery: torch.Tensor, top_k: int = 10):
+    if gallery.shape[0] < top_k:
+        raise ValueError(f"Gallery has fewer than {top_k} images")
+    scores = F.normalize(query.float(), dim=1) @ F.normalize(gallery.float(), dim=1).T
+    return scores.topk(top_k, dim=1, sorted=True)
+
+
+def rankings(query_ids, gallery_ids, indices):
+    return {query_id: [gallery_ids[i] for i in row] for query_id, row in zip(query_ids, indices.tolist())}
+
+
+def retrieval_metrics(predictions: dict[str, list[str]], truth: dict[str, str]):
+    ranks = []
+    for query_id, correct in truth.items():
+        row = predictions.get(query_id, [])[:10]
+        ranks.append(row.index(correct) + 1 if correct in row else None)
+    metrics = {f"recall@{k}": sum(rank is not None and rank <= k for rank in ranks) / len(ranks) for k in (1, 5, 10)}
+    metrics["map@10"] = sum(1 / rank if rank else 0 for rank in ranks) / len(ranks)
+    metrics["score"] = sum(metrics.values()) / 4
+    return metrics
+
+
+def validate_rankings(predictions, query_ids, gallery_ids, top_k=10):
+    if set(predictions) != set(query_ids):
+        raise ValueError("Predictions do not contain exactly the expected queries")
+    valid = set(gallery_ids)
+    for query_id, row in predictions.items():
+        if len(row) != top_k or len(set(row)) != top_k or not set(row) <= valid:
+            raise ValueError(f"Invalid ranking for {query_id}")
+
+
+def write_submission(predictions, path: str | Path):
+    with Path(path).open("w", newline="", encoding="utf-8") as file:
+        writer = csv.writer(file)
+        writer.writerow(("query_id", "gallery_ids"))
+        writer.writerows((query_id, " ".join(row)) for query_id, row in predictions.items())
+

ssl_retrieval/transforms.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import io
+import random
+
+import torch
+from PIL import Image, ImageEnhance, ImageFilter, ImageOps
+from torchvision import transforms as T
+from torchvision.transforms import functional as TF
+
+MEAN = (0.485, 0.456, 0.406)
+STD = (0.229, 0.224, 0.225)
+
+
+def _tensor(image: Image.Image) -> torch.Tensor:
+    return TF.normalize(TF.to_tensor(image.resize((64, 64), Image.Resampling.BICUBIC)), MEAN, STD)
+
+
+class TrainTransforms:
+    def __init__(self):
+        self.clean_transform = T.Compose([T.Resize((64, 64)), T.ToTensor()])
+        self.contrastive_transform = T.Compose([
+            T.RandomResizedCrop(64, scale=(0.45, 1.0)),
+            T.RandomHorizontalFlip(),
+            T.RandomApply([T.ColorJitter(0.45, 0.45, 0.25, 0.05)], p=0.8),
+            T.RandomGrayscale(p=0.1),
+            T.RandomApply([T.GaussianBlur(5, sigma=(0.2, 2.0))], p=0.4),
+            T.ToTensor(), T.Normalize(MEAN, STD),
+        ])
+        self.degraded_transform = T.Compose([
+            T.RandomResizedCrop(64, scale=(0.45, 1.0)),
+            T.RandomPerspective(0.15, p=0.4),
+            T.ColorJitter(0.45, 0.45, 0.25, 0.05),
+            T.RandomApply([T.GaussianBlur(7, sigma=(0.5, 2.5))], p=0.5),
+            T.ToTensor(), T.Normalize(MEAN, STD),
+        ])
+
+    def clean(self, image):
+        return self.clean_transform(image)
+
+    def contrastive(self, image):
+        return self.contrastive_transform(image)
+
+    def degraded(self, image):
+        return self.degraded_transform(image)
+
+    def rotation(self, image):
+        label = random.randrange(4)
+        return _tensor(image.rotate(90 * label)), label
+
+
+def inference_transform(image: Image.Image) -> torch.Tensor:
+    return _tensor(image)
+
+
+def deterministic_degrade(image: Image.Image, seed: int) -> Image.Image:
+    rng = random.Random(seed)
+    image = image.convert("RGB")
+    width, height = image.size
+    scale = rng.uniform(0.45, 0.9)
+    crop_w, crop_h = max(8, int(width * scale)), max(8, int(height * scale))
+    left, top = rng.randrange(width - crop_w + 1), rng.randrange(height - crop_h + 1)
+    image = image.crop((left, top, left + crop_w, top + crop_h)).resize((64, 64), Image.Resampling.BICUBIC)
+    image = image.rotate(rng.uniform(-30, 30), resample=Image.Resampling.BICUBIC)
+    margin = rng.randint(1, 7)
+    image = TF.perspective(
+        image,
+        [[0, 0], [63, 0], [63, 63], [0, 63]],
+        [[rng.randint(0, margin), rng.randint(0, margin)],
+         [63 - rng.randint(0, margin), rng.randint(0, margin)],
+         [63 - rng.randint(0, margin), 63 - rng.randint(0, margin)],
+         [rng.randint(0, margin), 63 - rng.randint(0, margin)]],
+        interpolation=T.InterpolationMode.BILINEAR,
+    )
+    image = ImageEnhance.Brightness(image).enhance(rng.uniform(0.55, 1.45))
+    image = ImageEnhance.Contrast(image).enhance(rng.uniform(0.5, 1.5))
+    if rng.random() < 0.6:
+        image = image.filter(ImageFilter.GaussianBlur(rng.uniform(0.4, 2.2)))
+    if rng.random() < 0.55:
+        generator = torch.Generator().manual_seed(seed + 17)
+        pixels = TF.to_tensor(image)
+        pixels = (pixels + torch.randn(pixels.shape, generator=generator) * rng.uniform(0.02, 0.12)).clamp(0, 1)
+        image = TF.to_pil_image(pixels)
+    if rng.random() < 0.5:
+        small = rng.randint(18, 48)
+        image = image.resize((small, small), Image.Resampling.BILINEAR).resize((64, 64), Image.Resampling.BILINEAR)
+    if rng.random() < 0.45:
+        x, y, size = rng.randrange(52), rng.randrange(52), rng.randrange(5, 13)
+        image.paste(tuple(rng.randrange(256) for _ in range(3)), (x, y, x + size, y + size))
+    buffer = io.BytesIO()
+    image.save(buffer, "JPEG", quality=rng.randint(20, 75))
+    buffer.seek(0)
+    return Image.open(buffer).convert("RGB").copy()

tests/test_ssl_retrieval.py

@@ -0,0 +1,63 @@
+import json
+
+import torch
+from PIL import Image
+from torch.nn import functional as F
+
+from ssl_retrieval.checkpoints import load_checkpoint, save_checkpoint
+from ssl_retrieval.data import load_manifest, pseudo_split
+from ssl_retrieval.losses import nt_xent
+from ssl_retrieval.models import SSLModel
+from ssl_retrieval.retrieval import rank_embeddings, rankings, retrieval_metrics, validate_rankings
+from ssl_retrieval.transforms import deterministic_degrade
+
+
+def test_manifest_and_pseudo_split(tmp_path):
+    records = []
+    for index in range(12):
+        path = tmp_path / f"{index}.jpg"
+        Image.new("RGB", (64, 64), (index, index, index)).save(path)
+        records.append({"image_id": str(index), "image_path": path.name})
+    manifest = tmp_path / "images.json"
+    manifest.write_text(json.dumps(records))
+    loaded = load_manifest(manifest)
+    train, gallery, queries = pseudo_split(loaded, gallery_size=10, query_size=2)
+    assert (len(train), len(gallery), len(queries)) == (2, 10, 2)
+
+
+def test_models_losses_and_checkpoint(tmp_path):
+    images = torch.randn(2, 3, 64, 64)
+    for method in ("simclr", "autoencoder", "rotation", "joint"):
+        model = SSLModel(method, pretrained=False)
+        assert model.embedding(images).shape == (2, 512)
+        assert torch.allclose(model.embedding(images).norm(dim=1), torch.ones(2), atol=1e-5)
+        if model.projector:
+            assert torch.isfinite(nt_xent(model.project(images), model.project(images)))
+        if model.decoder:
+            assert model.reconstruct(images).shape == images.shape
+        if model.rotation_head:
+            assert model.predict_rotation(images).shape == (2, 4)
+        loss = torch.zeros(())
+        if model.projector:
+            loss = loss + nt_xent(model.project(images), model.project(images + 0.01))
+        if model.decoder:
+            loss = loss + 0.1 * F.mse_loss(model.reconstruct(images), torch.sigmoid(images))
+        if model.rotation_head:
+            loss = loss + 0.5 * F.cross_entropy(model.predict_rotation(images), torch.tensor([0, 1]))
+        loss.backward()
+        assert all(torch.isfinite(parameter.grad).all() for parameter in model.parameters() if parameter.grad is not None)
+        path = tmp_path / f"{method}.pt"
+        save_checkpoint(path, model, method, {}, 1, {"score": 0.0})
+        restored, payload = load_checkpoint(path)
+        assert payload["method"] == method and restored.embedding(images).shape == (2, 512)
+
+
+def test_degradation_ranking_and_metrics():
+    image = Image.new("RGB", (64, 64), "green")
+    assert list(deterministic_degrade(image, 7).getdata()) == list(deterministic_degrade(image, 7).getdata())
+    gallery = torch.eye(10)
+    _, indices = rank_embeddings(gallery[:2], gallery)
+    prediction = rankings(["q0", "q1"], [f"g{i}" for i in range(10)], indices)
+    validate_rankings(prediction, ["q0", "q1"], [f"g{i}" for i in range(10)])
+    metrics = retrieval_metrics(prediction, {"q0": "g0", "q1": "g1"})
+    assert metrics == {"recall@1": 1.0, "recall@5": 1.0, "recall@10": 1.0, "map@10": 1.0, "score": 1.0}

upload_milk10k.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+import os
+from pathlib import Path
+
+from huggingface_hub import HfApi
+
+REPO_ID = "duyle2408/milk10k_new_code"
+REPO_TYPE = "dataset"
+FOLDER = Path(__file__).resolve().parent
+
+IGNORE = [
+    "**/__pycache__/**",
+    "**/*.pyc",
+    "**/.cache/**",
+    "**/.git/**",
+    "**/.agents/**",
+    "**/.codex/**",
+    "**/.understand-anything/**",
+    "**/.pytest_cache/**",
+    "**/.venv/**",
+    "data/**",
+    "feature_cache/**",
+    "checkpoints/**",
+    "eda_output/**",
+    "diagnostics_*.csv",
+    "diagnostics_*.png",
+    "submission*.csv",
+    "**/*.zip",
+    "**/*.pt",
+    "**/*.pth",
+    "**/*.ckpt",
+]
+
+
+def main():
+    api = HfApi(token=os.environ.get("HF_TOKEN"))
+    api.create_repo(
+        repo_id=REPO_ID,
+        repo_type=REPO_TYPE,
+        private=False,
+        exist_ok=True,
+    )
+    api.upload_folder(
+        repo_id=REPO_ID,
+        repo_type=REPO_TYPE,
+        folder_path=str(FOLDER),
+        ignore_patterns=IGNORE,
+        commit_message="Upload milk10k code",
+    )
+
+
+if __name__ == "__main__":
+    main()