derenrich/wiki-image-vectors

Vector embeddings of images on Wikipedia using google/siglip2-base-patch16-384

Here's an example of how to use this

# /// script
# requires-python = ">=3.11"
# dependencies = [
#     "gradio",
#     "torch",
#     "transformers",
#     "pyarrow",
#     "numpy",
#     "huggingface_hub",
# ]
# ///
"""
Semantic search over Wikipedia/Commons image embeddings (SigLIP 2).

Run locally:
    VECTORS=/path/to/vectors.parquet uv run app.py

Or let it pull from the Hub:
    uv run app.py
"""

import hashlib
import os
from urllib.parse import quote

import gradio as gr
import numpy as np
import pyarrow.parquet as pq
import torch
from transformers import AutoModel, AutoProcessor

CKPT = "google/siglip2-base-patch16-384"
REPO = "derenrich/wiki-image-vectors"
FILE = "vectors/enwiki_siglip2_b384_0000.parquet"
TOPK = 24
THUMB_W = 320
WIKI = "commons"          # "commons" or "en"


# ---------------------------------------------------------------- data

def load_vectors():
    path = os.environ.get("VECTORS")
    if not path:
        from huggingface_hub import hf_hub_download
        path = hf_hub_download(REPO, FILE, repo_type="dataset")

    tbl = pq.read_table(path)

    title_col = "title" if "title" in tbl.column_names else "titles"
    titles = tbl[title_col].to_pylist()

    emb = np.stack(tbl["emb"].to_numpy(zero_copy_only=False)).astype(np.float32)
    emb /= np.linalg.norm(emb, axis=1, keepdims=True) + 1e-12

    return titles, emb


TITLES, E = load_vectors()
print(f"loaded {len(TITLES)} vectors, dim {E.shape[1]}")

model = AutoModel.from_pretrained(CKPT).eval()
processor = AutoProcessor.from_pretrained(CKPT)


# ---------------------------------------------------------------- urls

RASTERIZED = {"svg": ".png", "tif": ".jpg", "tiff": ".jpg",
              "pdf": ".jpg", "djvu": ".jpg"}


def clean_title(title):
    """Strip File:/Image: prefix, underscore spaces, capitalize first char."""
    name = title.split(":", 1)[-1] if title[:6].lower() in ("file:t", "image:") else title
    if ":" in title[:6].lower():
        name = title.split(":", 1)[-1]
    else:
        name = title
    name = name.replace(" ", "_")
    return name[:1].upper() + name[1:] if name else name


def thumb_url(title, width=330):
    site, file_s, title = title.split(":", 2)
    name = title.replace(" ", "_")
    h = hashlib.md5(name.encode("utf-8")).hexdigest()
    n = quote(name)

    wiki = "commons"
    if site == "enwiki":
        wiki = "en"
    
    url = (f"https://upload.wikimedia.org/wikipedia/{wiki}/thumb/"
            f"{h[0]}/{h[:2]}/{n}/{width}px-{n}")
    if title.lower().endswith(".svg"):
        url += ".png"
    elif title.lower().endswith(".tif"):
        url += ".jpg"
    elif title.lower().endswith(".stl"):
        url += ".png"
    return url

def file_page(title):
    site, file_s, title = title.split(":", 2)
    name = title.replace(" ", "_")
    wiki_url = "https://commons.wikimedia.org/wiki/"
    if site == "enwiki":
      wiki_url = "https://en.wikipedia.org/wiki/"    
    return f"{wiki_url}File:{quote(title)}"    


# ---------------------------------------------------------------- search

def text_search(query, k=TOPK):
    if not query or not query.strip():
        return []
    inputs = processor(text=[query], padding="max_length",
                       truncation=True, return_tensors="pt")
    with torch.inference_mode():
        v = model.get_text_features(**inputs).pooler_output
    v = (v / v.norm(dim=-1, keepdim=True)).numpy()[0].astype(np.float32)
    return np.argsort(-(E @ v))[:k].tolist()


def similar(row, k=TOPK):
    sims = E @ E[row]
    sims[row] = -np.inf
    return np.argsort(-sims)[:k].tolist()


# ---------------------------------------------------------------- render

CSS = """
#results { display: flex; flex-wrap: wrap; gap: 8px; }
#results figure { margin: 0; width: 200px; }
#results img {
  width: 200px; height: 160px; object-fit: contain;
  background: #fff; padding: 4px; border-radius: 6px;
  border: 1px solid rgba(0,0,0,.12); cursor: pointer;
  display: block;
}
#results img:hover { border-color: #36c; }
#results figcaption {
  font-size: 11px; line-height: 1.3; margin-top: 4px;
  max-height: 2.6em; overflow: hidden; opacity: .75;
}
#results figcaption a { color: inherit; }
#clickbox { display: none !important; }
"""


def render(idx, heading=""):
    if not idx:
        return "<p style='opacity:.6'>No results.</p>"

    cards = []
    for i in idx:
        t = TITLES[i]
        label = clean_title(t).rsplit(".", 1)[0].replace("_", " ")
        safe = label.replace("&", "&amp;").replace("<", "&lt;").replace('"', "&quot;")
        cards.append(
            "<figure>"
            f'<img src="{thumb_url(t)}" alt="{safe}" title="{safe}" '
            f'loading="lazy" onclick="pickSimilar({i})">'
            f'<figcaption><a href="{file_page(t)}" target="_blank" '
            f'rel="noopener">{safe}</a></figcaption>'
            "</figure>"
        )

    head = f"<p style='opacity:.7;font-size:13px'>{heading}</p>" if heading else ""
    return head + f"<div id='results'>{''.join(cards)}</div>"


JS = """
function pickSimilar(row) {
  const el = document.querySelector('#clickbox textarea, #clickbox input');
  if (!el) { console.warn('clickbox not found'); return; }
  el.value = row + ':' + Date.now();
  el.dispatchEvent(new Event('input', { bubbles: true }));
}
"""


# ---------------------------------------------------------------- app

with gr.Blocks(css=CSS, head=f"<script>{JS}</script>",
               title="Wikipedia image search") as demo:
    gr.Markdown(
        "## Wikipedia image semantic search\n"
        f"{len(TITLES):,} images embedded with `{CKPT}`. "
        "Search in any of ~109 languages. Click an image to find visually "
        "similar ones."
    )

    query = gr.Textbox(
        label="", placeholder="a cat sitting on a windowsill / Sonnenuntergang / 城の写真",
        submit_btn=True,
    )
    clickbox = gr.Textbox(elem_id="clickbox")
    results = gr.HTML()

    def on_query(q):
        return render(text_search(q), f'Results for "{q}"')

    def on_click(payload):
        if not payload:
            return gr.skip()
        row = int(payload.split(":")[0])
        label = clean_title(TITLES[row]).rsplit(".", 1)[0].replace("_", " ")
        return render(similar(row), f"Similar to: {label}")

    query.submit(on_query, query, results)
    clickbox.change(on_click, clickbox, results)

    gr.Examples(
        ["aerial view of a city at night", "medieval manuscript illumination",
         "coat of arms with a lion", "steam locomotive"],
        inputs=query,
    )

if __name__ == "__main__":
    demo.launch(show_error=True)