Improve: Consolidate scripts and package into single-file modules

.gitattributes

@@ -0,0 +1 @@
+*.f16bin filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -205,3 +205,9 @@ cython_debug/
 marimo/_static/
 marimo/_lsp/
 __marimo__/
+
+# WikiVerse-specific: deprecated (binary files now tracked via Git LFS)
+data/
+state/
+benchmarks/results/
+logs/

README.md

@@ -92,64 +92,67 @@ Average article length across all languages is ~400 tokens, but this is dragged
 
 ## Dataset Layout
 
-Data is published on HuggingFace with one __config per model__, so users download only what they need.
-Embedding vectors are stored as `.fbin` (row-major binary: `uint32 rows, uint32 cols, float16/float32 data`) for direct compatibility with [USearch bench_cpp](https://github.com/unum-cloud/usearch/blob/main/BENCHMARKS.md) and the Big-ANN benchmark ecosystem.
+Layout mirrors [FineWiki's](https://huggingface.co/datasets/HuggingFaceFW/finewiki) `data/<wiki>/<group>_<shard>.parquet` structure: one directory per Wikipedia language, with shard filenames preserved 1:1.
+Each `.f16bin` is row-aligned with its source parquet — `.f16bin` row N is the embedding of parquet row N, in native order.
+If the source text was empty or null the row is a zero vector (`norm == 0`); the parquet's `id` column provides the doc identifier, so no separate ids file is needed.
+
+Binary format: `u32` rows count, `u32` columns count, then `rows × cols` little-endian `f16` values — directly compatible with [USearch](https://github.com/unum-cloud/USearch)'s and the Big-ANN benchmark ecosystem.
+
+`.body.f16bin` is the article-body embedding; `.title.f16bin` is the title-only embedding (short-context, useful for title-vs-body retrieval studies).
 
 ```
 unum-cloud/WikiVerse/
 ├── README.md
+├── LICENSE
+├── .gitattributes
+├── wikiverse.py                              # consumer module: load_lang, read_bin, ...
+├── embed.py                                  # reference embedding pipeline (TEI-based)
 │
-├── corpus/
-│   ├── passages-en-00000-of-00050.parquet    # doc_id, title, text, section
-│   ├── passages-en-00001-of-00050.parquet
-│   └── ...
-│
-├── graph/
-│   ├── pagelinks-en.parquet                  # source_id, target_id
-│   ├── categories-en.parquet                 # page_id, category
-│   ├── wikidata-en.parquet                   # page_id, qid, entity_type
-│   └── ...
-│
-├── qwen3-embedding-0.6b/
-│   ├── base.6.6M.f16bin                      # 6.6M × 1024, float16
-│   ├── query.10K.f16bin                      # 10K × 1024, float16
-│   └── groundtruth.10K.ibin                  # 10K × 100 neighbors
+├── qwen3-embedding-0.6b/                     # 1024-dim, decoder, float16
+│   ├── enwiki/
+│   │   ├── 000_00000.body.f16bin             # mirrors enwiki/000_00000.parquet
+│   │   ├── 000_00000.title.f16bin
+│   │   ├── 000_00001.body.f16bin
+│   │   ├── 000_00001.title.f16bin
+│   │   └── ...
+│   ├── dewiki/
+│   │   └── ...
+│   └── ...                                   # one dir per Wikipedia language
 │
-├── e5-mistral-7b-instruct/
-│   ├── base.6.6M.f16bin                      # 6.6M × 4096, float16
-│   ├── query.10K.f16bin
-│   └── groundtruth.10K.ibin
+├── snowflake-arctic-embed-l-v2.0/            # 1024-dim, encoder, float16
+│   └── <wiki>/<group>_<shard>.{body,title}.f16bin
 │
-├── arctic-embed-l-v2.0/
-│   ├── base.6.6M.f16bin                      # 6.6M × 1024, float16
-│   ├── query.10K.f16bin
-│   └── groundtruth.10K.ibin
+├── nomic-embed-text-v1.5/                    #  768-dim, encoder, float16
+│   └── <wiki>/<group>_<shard>.{body,title}.f16bin
 │
-├── nomic-embed-text-v1.5/
-│   ├── base.6.6M.f16bin                      # 6.6M × 768, float16
-│   ├── query.10K.f16bin
-│   └── groundtruth.10K.ibin
+├── e5-mistral-7b-instruct/                   # 4096-dim, decoder, float16 (planned)
+│   └── <wiki>/<group>_<shard>.{body,title}.f16bin
 │
-└── gte-moderncolbert-v1/
-    ├── base.6.6M.f16bin                      # ~13.2B × 128, float16
-    ├── query.10K.f16bin
-    └── groundtruth.10K.ibin
+└── gte-moderncolbert-v1/                     #  128-dim per token, ColBERT (planned)
+    └── <wiki>/<group>_<shard>.{body,title}.f16bin
+```
+
+Binary embedding files are tracked via [Git LFS](https://git-lfs.com).
+To clone the repo without downloading the binaries (~600 GB):
+
+```sh
+GIT_LFS_SKIP_SMUDGE=1 git clone https://huggingface.co/datasets/unum-cloud/WikiVerse
 ```
 
-Load a specific model's embeddings:
+Load embeddings for a single language (Python):
 
 ```python
-from datasets import load_dataset
-corpus = load_dataset("unum-cloud/WikiVerse", "corpus")
+from wikiverse import read_bin
+mat = read_bin("qwen3-embedding-0.6b/enwiki/000_00000.body.f16bin", dtype="f16")
+# mat.shape == (n_articles_in_shard, 1024)
 ```
 
-Or download binary vectors directly for C++/Rust benchmarking:
+Or pull just one model's embeddings for a single language:
 
 ```sh
 huggingface-cli download unum-cloud/WikiVerse \
-    qwen3-embedding-0.6b/base.6.6M.f16bin \
-    qwen3-embedding-0.6b/query.10K.f16bin \
-    qwen3-embedding-0.6b/groundtruth.10K.ibin
+    --repo-type dataset \
+    --include "qwen3-embedding-0.6b/enwiki/*"
 ```
 
 ### Workflow

embed.py

@@ -0,0 +1,196 @@
+"""Embed FineWiki shards via a running TEI server.
+
+Usage:
+  python embed.py --cache-dir /path/to/hf-cache --output /path/to/embeddings \\
+      --wiki enwiki --model-subdir qwen3-embedding-0.6b --dimensions 1024
+
+For title embeddings, add: --text-column title --output-suffix title --char-cap 256
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import time
+from pathlib import Path
+
+import httpx
+import numpy as np
+
+from wikiverse import Shard, load_lang, load_shard_texts, write_bin
+
+
+def select_shards(all_shards: list[Shard], gpu_id: int, world_size: int) -> list[Shard]:
+    return [
+        shard for index, shard in enumerate(all_shards) if index % world_size == gpu_id
+    ]
+
+
+async def embed_texts(
+    client: httpx.AsyncClient,
+    url: str,
+    texts: list[str],
+    batch_size: int,
+    concurrency: int,
+    character_cap: int,
+    dimensions: int,
+) -> tuple[np.ndarray, dict[str, float]]:
+    """Embed `texts` via TEI in input order; empty inputs map to zero rows."""
+    semaphore = asyncio.Semaphore(concurrency)
+    output = np.zeros((len(texts), dimensions), dtype=np.float16)
+
+    nonempty_indices = [index for index, text in enumerate(texts) if text]
+    truncated = [texts[index][:character_cap] for index in nonempty_indices]
+    received: list[list[float] | None] = [None] * len(truncated)
+
+    async def submit(start: int) -> None:
+        end = min(start + batch_size, len(truncated))
+        chunk = truncated[start:end]
+        async with semaphore:
+            response = await client.post(
+                url, json={"inputs": chunk, "truncate": True}, timeout=600.0
+            )
+            response.raise_for_status()
+            vectors = response.json()
+        for offset, vector in enumerate(vectors):
+            received[start + offset] = vector
+
+    started = time.monotonic()
+    if truncated:
+        await asyncio.gather(
+            *(submit(index) for index in range(0, len(truncated), batch_size))
+        )
+    elapsed = time.monotonic() - started
+
+    for received_index, vector in enumerate(received):
+        output[nonempty_indices[received_index]] = np.asarray(vector, dtype=np.float16)
+
+    return output, {
+        "embed_seconds": elapsed,
+        "n_docs": len(texts),
+        "n_nonempty": len(truncated),
+    }
+
+
+async def run(args: argparse.Namespace) -> None:
+    output_root = Path(args.output) / args.model_subdir
+    output_root.mkdir(parents=True, exist_ok=True)
+
+    suffix = f".{args.output_suffix}" if args.output_suffix else ""
+
+    shards = load_lang(args.cache_dir, args.wiki)
+    owned = select_shards(shards, args.gpu_id, args.world_size)
+    pending = [
+        shard
+        for shard in owned
+        if not (output_root / shard.wikiname / f"{shard.stem}{suffix}.f16bin").exists()
+    ]
+    print(
+        f"[gpu{args.gpu_id} TEI col={args.text_column} suffix='{args.output_suffix}'] "
+        f"{len(owned)} owned, {len(pending)} pending @ {args.url}",
+        flush=True,
+    )
+    if not pending:
+        return
+
+    started = time.monotonic()
+    total_docs = 0
+
+    async with httpx.AsyncClient() as probe:
+        try:
+            response = await probe.get(
+                args.url.rsplit("/", 1)[0] + "/health", timeout=10.0
+            )
+            response.raise_for_status()
+        except Exception as error:
+            raise SystemExit(f"TEI not reachable at {args.url}: {error}")
+
+    async with httpx.AsyncClient() as client:
+        for shard in pending:
+            wiki_dir = output_root / shard.wikiname
+            wiki_dir.mkdir(parents=True, exist_ok=True)
+            vector_path = wiki_dir / f"{shard.stem}{suffix}.f16bin"
+
+            _identifiers, texts = load_shard_texts(shard, text_column=args.text_column)
+            if not texts:
+                np.zeros((0, args.dimensions), dtype=np.float16).tofile(vector_path)
+                continue
+
+            embeddings, stats = await embed_texts(
+                client,
+                args.url,
+                texts,
+                batch_size=args.batch_size,
+                concurrency=args.concurrency,
+                character_cap=args.character_cap,
+                dimensions=args.dimensions,
+            )
+            if embeddings.shape != (len(texts), args.dimensions):
+                raise RuntimeError(
+                    f"shape {embeddings.shape} != ({len(texts)}, {args.dimensions})"
+                )
+
+            temp_path = vector_path.with_suffix(vector_path.suffix + ".tmp")
+            write_bin(temp_path, embeddings, dtype="f16")
+            temp_path.rename(vector_path)
+
+            total_docs += stats["n_docs"]
+            docs_per_second = stats["n_docs"] / max(stats["embed_seconds"], 1e-3)
+            print(
+                f"[gpu{args.gpu_id} TEI] {shard.wikiname}/{shard.stem}{suffix}: "
+                f"{stats['n_docs']} docs ({stats['n_nonempty']} non-empty) "
+                f"in {stats['embed_seconds']:.1f}s -> {docs_per_second:.0f} doc/s",
+                flush=True,
+            )
+
+    wall_seconds = time.monotonic() - started
+    print(
+        f"[gpu{args.gpu_id} TEI] DONE: {total_docs} docs in {wall_seconds:.0f}s "
+        f"-> {total_docs/max(wall_seconds,1):.0f} doc/s",
+        flush=True,
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--cache-dir", default="/home/ubuntu/wikiverse-data/hf-cache")
+    parser.add_argument("--output", default="/home/ubuntu/wikiverse-data/embeddings")
+    parser.add_argument("--gpu-id", type=int, default=0)
+    parser.add_argument("--world-size", type=int, default=8)
+    parser.add_argument(
+        "--wiki", required=True, help="single language code (enwiki, dewiki, etc)"
+    )
+    parser.add_argument("--url", default="http://localhost:8080/embed")
+    parser.add_argument(
+        "--batch-size", type=int, default=32, help="docs per HTTP request"
+    )
+    parser.add_argument("--concurrency", type=int, default=8)
+    parser.add_argument("--text-column", default="text", choices=["text", "title"])
+    parser.add_argument(
+        "--character-cap",
+        type=int,
+        default=16384,
+        help="truncate each input at this many characters (~max_length × 4 for English)",
+    )
+    parser.add_argument(
+        "--output-suffix",
+        default="body",
+        help="filename suffix, e.g. 'body' or 'title'",
+    )
+    parser.add_argument(
+        "--model-subdir",
+        default="qwen3-embedding-0.6b",
+        help="output goes to {output}/{model-subdir}/, e.g. snowflake-arctic-embed-l-v2.0",
+    )
+    parser.add_argument(
+        "--dimensions",
+        type=int,
+        default=1024,
+        help="embedding dimensionality (1024 Qwen3/arctic, 768 nomic, 4096 e5-mistral)",
+    )
+    args = parser.parse_args()
+    asyncio.run(run(args))
+
+
+if __name__ == "__main__":
+    main()

wikiverse.py

@@ -0,0 +1,114 @@
+"""WikiVerse: embeddings for FineWiki articles and titles."""
+
+from __future__ import annotations
+
+import re
+import struct
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterator, Literal
+
+import numpy as np
+import pyarrow.parquet as pq
+
+shard_pattern = re.compile(r"(\d{3})_(\d{5})\.parquet$")
+
+numpy_dtypes = {"f16": np.float16, "f32": np.float32, "i32": np.int32}
+file_extensions = {"f16": "f16bin", "f32": "fbin", "i32": "ibin"}
+
+DType = Literal["f16", "f32", "i32"]
+
+
+@dataclass(frozen=True, slots=True)
+class Shard:
+    wikiname: str
+    group: int
+    index: int
+    path: Path
+
+    @property
+    def stem(self) -> str:
+        return f"{self.group:03d}_{self.index:05d}"
+
+
+def find_snapshot(cache_dir: str | Path) -> Path:
+    cache_dir = Path(cache_dir)
+    snapshots = cache_dir / "datasets--HuggingFaceFW--finewiki" / "snapshots"
+    if not snapshots.is_dir():
+        raise FileNotFoundError(f"no FineWiki snapshot under {snapshots}")
+    return max(snapshots.iterdir(), key=lambda path: path.stat().st_mtime)
+
+
+def load_lang(cache_dir: str | Path, wikiname: str) -> list[Shard]:
+    """Discover all FineWiki shards for a single language."""
+    data_root = find_snapshot(cache_dir) / "data"
+    wiki_dir = data_root / wikiname
+    if not wiki_dir.is_dir():
+        raise FileNotFoundError(f"no shard directory for {wikiname}")
+    shards: list[Shard] = []
+    for parquet_path in sorted(wiki_dir.glob("*.parquet")):
+        match = shard_pattern.search(parquet_path.name)
+        if not match:
+            continue
+        shards.append(
+            Shard(
+                wikiname=wikiname,
+                group=int(match.group(1)),
+                index=int(match.group(2)),
+                path=parquet_path,
+            )
+        )
+    return shards
+
+
+def iter_articles(
+    shard: Shard, text_column: str = "text", id_column: str = "id"
+) -> Iterator[tuple[str, str]]:
+    """Yield (id, text) tuples from a parquet shard, in parquet row order.
+
+    Empty/null texts pass through as empty string — embedders should write
+    zero vectors so row N in .f16bin aligns with parquet row N.
+    """
+    table = pq.read_table(shard.path, columns=[id_column, text_column])
+    identifiers = table.column(id_column).to_pylist()
+    texts = table.column(text_column).to_pylist()
+    for identifier, text in zip(identifiers, texts):
+        yield str(identifier), text or ""
+
+
+def load_shard_texts(
+    shard: Shard, text_column: str = "text", id_column: str = "id"
+) -> tuple[list[str], list[str]]:
+    """Load a whole shard into parallel lists (ids, texts), parquet row order preserved."""
+    identifiers: list[str] = []
+    texts: list[str] = []
+    for identifier, text in iter_articles(
+        shard, text_column=text_column, id_column=id_column
+    ):
+        identifiers.append(identifier)
+        texts.append(text)
+    return identifiers, texts
+
+
+def write_bin(path: str | Path, matrix: np.ndarray, dtype: DType) -> None:
+    """Write a 2-D matrix to a binary file with a `uint32 rows, uint32 cols` header."""
+    if matrix.ndim != 2:
+        raise ValueError(f"expected 2-D matrix, got shape {matrix.shape}")
+    matrix = np.ascontiguousarray(matrix.astype(numpy_dtypes[dtype], copy=False))
+    rows, columns = matrix.shape
+    with open(path, "wb") as file:
+        file.write(struct.pack("<II", rows, columns))
+        file.write(matrix.tobytes(order="C"))
+
+
+def read_bin(path: str | Path, dtype: DType) -> np.ndarray:
+    """Read a 2-D matrix from a binary file with a `uint32 rows, uint32 cols` header."""
+    with open(path, "rb") as file:
+        rows, columns = struct.unpack("<II", file.read(8))
+        return np.frombuffer(file.read(), dtype=numpy_dtypes[dtype]).reshape(
+            rows, columns
+        )
+
+
+def shard_filename(stem: str, dtype: DType) -> str:
+    return f"{stem}.{file_extensions[dtype]}"