upload queries

queries/_checksums.json

@@ -0,0 +1,18 @@
+{
+  "dense": {
+    "rows": 100000,
+    "query_text_sha256": "3a354db0c5aa2bcf5d4563844c645d8fc23ff1780f83cce28900b7fc917a5756"
+  },
+  "sparse": {
+    "rows": 10000,
+    "query_text_sha256": "fd33c5fe47600b11fe12b7438a342cfa866e2ada82f911726e91c04ad079dfc5"
+  },
+  "text_filters": {
+    "rows": 4953,
+    "query_text_sha256": "80d4a77cc3cbed241399fe01525e07987aa886178dcccf943a070a4e2e391fed"
+  },
+  "structured_filters": {
+    "rows": 5000,
+    "query_text_sha256": "9023ccb0e1afdda88c20a2d83923102d53b33b989b9ce0f2b11a256a16ae9e83"
+  }
+}

queries/_sets.json

@@ -0,0 +1,63 @@
+[
+  {
+    "set": "dense",
+    "file": "gt_dense_k1000.parquet",
+    "rows": 100000,
+    "columns": [
+      "msmarco_config",
+      "msmarco_split",
+      "msmarco_query_id",
+      "hit_scores",
+      "hit_fineweb_ids"
+    ],
+    "regenerate_vectors": "dense"
+  },
+  {
+    "set": "sparse",
+    "file": "gt_sparse_k1000.parquet",
+    "rows": 10000,
+    "columns": [
+      "msmarco_config",
+      "msmarco_split",
+      "msmarco_query_id",
+      "hit_scores",
+      "hit_fineweb_ids"
+    ],
+    "regenerate_vectors": "sparse"
+  },
+  {
+    "set": "text_filters",
+    "file": "gt_text_filters_k1000.parquet",
+    "rows": 4953,
+    "columns": [
+      "msmarco_config",
+      "msmarco_split",
+      "msmarco_query_id",
+      "hit_scores",
+      "hit_fineweb_ids",
+      "selectivity_tier",
+      "keyword_phrase",
+      "domains"
+    ],
+    "regenerate_vectors": "dense"
+  },
+  {
+    "set": "structured_filters",
+    "file": "gt_structured_filters_k1000.parquet",
+    "rows": 5000,
+    "columns": [
+      "msmarco_config",
+      "msmarco_split",
+      "msmarco_query_id",
+      "hit_scores",
+      "hit_fineweb_ids",
+      "selectivity_tier",
+      "structured_group",
+      "ls_gte",
+      "date_gte",
+      "date_lt",
+      "dump_set"
+    ],
+    "regenerate_vectors": "dense"
+  }
+]

queries/gt_dense_k1000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f69daadce2c36f76ee5a2bbfc3d94397a34115ad1685869ae32d8b8db7e1269
+size 2129786818

queries/gt_sparse_k1000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:48e9bc62a0af8c0e50c5aa560763e5ed4106d8bd315e761fdb39ea07a3f36863
+size 214140613

queries/gt_structured_filters_k1000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f1ac2bfbda019e067b03ff8b1c3e535eaa8717ef92bec6ed6158b62e1afcb70
+size 110162713

queries/gt_text_filters_k1000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56e3939087a7f2c5b7a450c5daf82dfe02fba903ea6671535a2fd974ddcc8a6b
+size 98190990

queries/scripts/regenerate_all.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""Reconstruct every distributable set, one file at a time.
+
+Each ground-truth file names where its queries live in Hugging Face
+`microsoft/ms_marco` but carries no text and no vectors. This walks the four
+sets in turn and, for each, pulls the queries back, re-embeds them, and joins
+the result to that file's ground truth:
+
+    gt_<set>_k1000.parquet  +  Hugging Face  ->  <set>_regenerated.parquet
+
+Run it after downloading the release:
+
+    python scripts/regenerate_all.py --sets release_sets --out-dir regenerated
+
+One set at a time, deliberately: the dense set is 100,000 queries and holding
+four regenerated files at once is needless memory. The MS MARCO download is
+cached across sets in `--cache`, so only the first set that needs a given
+config/split pays for it.
+
+Which vectors each set needs is read from `_sets.json`, written alongside the
+files by `build_release_sets.py` — `sparse` needs the mGTE sparse scheme,
+everything else needs dense GTE.
+
+Reproducibility: the dense embedding is bit-for-bit reproducible when the same
+query set is embedded in one run (verified over 110,000 queries across two
+independent runs). `SentenceTransformer.encode` length-sorts its input
+internally, so embedding a SUBSET produces different batch composition and
+agrees only to ~1e-7 — irrelevant to ranking, but not bitwise. Do not use
+`--limit` to produce vectors you intend to publish.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--sets", required=True, help="dir written by build_release_sets.py")
+    ap.add_argument("--out-dir", required=True)
+    ap.add_argument("--cache", default="data/msmarco_cache")
+    ap.add_argument("--device", default=None, help="cuda / cpu (default: auto)")
+    ap.add_argument("--only", action="append", help="regenerate just this set; repeatable")
+    ap.add_argument("--limit", type=int, default=None,
+                    help="first N rows per set — SMOKE TESTS ONLY, see the note on "
+                         "reproducibility above")
+    args = ap.parse_args()
+
+    sets_dir = Path(args.sets)
+    manifest_path = sets_dir / "_sets.json"
+    if not manifest_path.exists():
+        raise SystemExit(f"{manifest_path} not found — run build_release_sets.py first")
+    manifest = json.loads(manifest_path.read_text())
+    if args.only:
+        manifest = [m for m in manifest if m["set"] in args.only]
+        if not manifest:
+            raise SystemExit(f"no set matches {args.only}")
+
+    out_dir = Path(args.out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    if args.limit is not None:
+        print(f"!! --limit {args.limit}: smoke test only, vectors will NOT be "
+              f"bit-reproducible\n")
+
+    done = []
+    for i, entry in enumerate(manifest, 1):
+        src = sets_dir / entry["file"]
+        dst = out_dir / f"{entry['set']}_regenerated.parquet"
+        print(f"[{i}/{len(manifest)}] {entry['set']}  ({entry['rows']:,} queries, "
+              f"vectors={entry['regenerate_vectors']})")
+        cmd = [
+            sys.executable, str(HERE / "regenerate_queries.py"),
+            "--in", str(src), "--out", str(dst),
+            "--vectors", entry["regenerate_vectors"],
+            "--cache", args.cache, "--keep-raw",
+        ]
+        if args.device:
+            cmd += ["--device", args.device]
+        if args.limit is not None:
+            cmd += ["--limit", str(args.limit)]
+        result = subprocess.run(cmd)
+        if result.returncode != 0:
+            raise SystemExit(f"{entry['set']} failed (exit {result.returncode})")
+        done.append(dst)
+        print()
+
+    print("regenerated:")
+    for p in done:
+        print(f"  {p}  ({p.stat().st_size / 1e6:.1f} MB)")
+
+
+if __name__ == "__main__":
+    main()

queries/scripts/regenerate_queries.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""Rebuild the MS MARCO queries + their embeddings for a stripped release file.
+
+The released files carry results only. Each row names where its query lives in
+Hugging Face `microsoft/ms_marco` (`msmarco_config` / `msmarco_split` /
+`msmarco_query_id`); this script fetches those queries, re-embeds them with the
+models the ground truth was built with, and joins everything back to the hits.
+
+    python scripts/regenerate_queries.py \
+        --in  gt_dense_k1000.parquet \
+        --out regenerated/dense_regenerated.parquet \
+        --vectors dense
+
+Vectors are reproduced with the exact conventions of the original run:
+
+  dense   Alibaba-NLP/gte-multilingual-base via sentence-transformers, plain
+          encode() (the model's own ST config ends in a Normalize module, so
+          output is unit-norm), float32, no query prefix. Verified against the
+          released vectors at cosine >= 0.9999999.
+
+  sparse  mGTE's OFFICIAL sparse scheme: relu of the per-token
+          AutoModelForTokenClassification logit, token-id keys, special tokens
+          dropped, max-dedup, max_length=8192. Verified to reproduce the
+          released sparse vectors exactly (identical token sets, cosine
+          1.0000000).
+
+          NOTE: sentence-transformers' SparseEncoder does NOT produce this
+          scheme for gte -- it attaches a randomly-initialized SPLADE head.
+          Neither does `nova embed`, whose sparse backend is that SparseEncoder.
+          Do not substitute either one.
+
+Only `--vectors none` avoids the torch/sentence-transformers dependency.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+import requests
+
+DATASETS_SERVER = "https://datasets-server.huggingface.co/parquet"
+DENSE_MODEL = "Alibaba-NLP/gte-multilingual-base"
+SPARSE_MODEL = "Alibaba-NLP/gte-multilingual-base"
+MAX_LENGTH = 8192
+
+
+# --------------------------------------------------------------------------
+# MS MARCO query text
+# --------------------------------------------------------------------------
+def _download(url: str, dst: Path) -> None:
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    tmp = dst.with_suffix(dst.suffix + ".part")
+    with requests.get(url, stream=True, timeout=600) as r:
+        r.raise_for_status()
+        with open(tmp, "wb") as fh:
+            for chunk in r.iter_content(chunk_size=1 << 22):
+                fh.write(chunk)
+    tmp.rename(dst)
+
+
+def load_query_text(
+    needed: set[tuple[str, str]], cache: Path, keep_raw: bool
+) -> dict[tuple[str, str, str], str]:
+    """(config, split, query_id) -> query, fetching only the SPLITS needed.
+
+    Keyed on (config, split) throughout, which matters twice:
+
+    * Download size. the dense set needs only v2.1/test (204 MB); keying on config
+      alone would pull all of v2.1 — 7 train shards plus validation, ~2.1 GB —
+      to answer a question none of it can answer.
+    * Cache correctness. The cache is written one file per split, so "this
+      config has a cache file" does not mean "every split I need is cached".
+      Interrupting a download once left later runs convinced they were done,
+      failing far away with an unresolved-rows error.
+    """
+    lookup: dict[tuple[str, str, str], str] = {}
+    todo = set(needed)
+
+    for cfg, split in sorted(needed):
+        hit = cache / f"qids_{cfg}_{split}.parquet"
+        if hit.exists():
+            t = pq.read_table(hit).to_pydict()
+            lookup.update(
+                ((cfg, split, str(i)), q) for i, q in zip(t["query_id"], t["query"])
+            )
+            todo.discard((cfg, split))
+            print(f"  {cfg}/{split}: {len(t['query_id']):,} queries from cache")
+
+    if todo:
+        listing = requests.get(DATASETS_SERVER, params={"dataset": "microsoft/ms_marco"}, timeout=120)
+        listing.raise_for_status()
+        files = [
+            f for f in listing.json()["parquet_files"] if (f["config"], f["split"]) in todo
+        ]
+        per_split: dict[tuple[str, str], dict[str, str]] = {}
+        for f in files:
+            raw = cache / "raw" / f"{f['config']}_{f['split']}_{f['filename']}"
+            if not raw.exists():
+                print(f"  downloading {f['config']}/{f['split']}/{f['filename']} "
+                      f"({f['size']/1e6:.0f} MB)", flush=True)
+                _download(f["url"], raw)
+            t = pq.read_table(raw, columns=["query_id", "query"]).to_pydict()
+            per_split.setdefault((f["config"], f["split"]), {}).update(
+                (str(i), q) for i, q in zip(t["query_id"], t["query"])
+            )
+            if not keep_raw:
+                raw.unlink()
+        for (cfg, split), m in per_split.items():
+            pq.write_table(
+                pa.table({"query_id": list(m), "query": list(m.values())}),
+                cache / f"qids_{cfg}_{split}.parquet",
+                compression="zstd",
+            )
+            lookup.update(((cfg, split, i), q) for i, q in m.items())
+            print(f"  {cfg}/{split}: {len(m):,} queries cached")
+    return lookup
+
+
+# --------------------------------------------------------------------------
+# embedding
+# --------------------------------------------------------------------------
+def embed_dense(texts: list[str], batch_size: int, device: str | None):
+    from sentence_transformers import SentenceTransformer
+
+    model = SentenceTransformer(DENSE_MODEL, trust_remote_code=True, device=device)
+    return model.encode(texts, batch_size=batch_size, convert_to_numpy=True,
+                        show_progress_bar=True).astype("float32")
+
+
+def embed_sparse(texts: list[str], batch_size: int, device: str | None):
+    """mGTE official sparse -- see module docstring."""
+    import torch
+    from transformers import AutoModelForTokenClassification, AutoTokenizer
+
+    tok = AutoTokenizer.from_pretrained(SPARSE_MODEL)
+    model = AutoModelForTokenClassification.from_pretrained(SPARSE_MODEL, trust_remote_code=True)
+    dev = device or ("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(dev).eval()
+    specials = set(tok.all_special_ids)
+
+    out = []
+    for start in range(0, len(texts), batch_size):
+        chunk = texts[start : start + batch_size]
+        enc = tok(chunk, padding=True, truncation=True, max_length=MAX_LENGTH,
+                  return_tensors="pt").to(dev)
+        with torch.no_grad():
+            weights = torch.relu(model(**enc).logits).squeeze(-1)
+        ids_b = enc["input_ids"].tolist()
+        mask_b = enc["attention_mask"].tolist()
+        for ids, mask, ws in zip(ids_b, mask_b, weights.tolist()):
+            acc: dict[int, float] = {}
+            for tid, keep, w in zip(ids, mask, ws):
+                if not keep or tid in specials or w <= 0:
+                    continue
+                acc[tid] = max(acc.get(tid, 0.0), w)   # max-dedup
+            items = sorted(acc.items())
+            out.append({"indices": [k for k, _ in items], "values": [v for _, v in items]})
+        print(f"  sparse {min(start+batch_size, len(texts)):,}/{len(texts):,}",
+              end="\r", file=sys.stderr, flush=True)
+    print(file=sys.stderr)
+    return out
+
+
+# --------------------------------------------------------------------------
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--in", dest="inp", required=True, help="stripped release parquet")
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--vectors", choices=["dense", "sparse", "both", "none"], default="dense")
+    ap.add_argument("--cache", default="data/msmarco_cache")
+    ap.add_argument("--keep-raw", action="store_true",
+                    help="keep the downloaded MS MARCO parquets (~2.1 GB) instead of "
+                         "deleting them once the small id->query cache is built")
+    ap.add_argument("--batch-size", type=int, default=128)
+    ap.add_argument("--device", default=None, help="cuda / cpu (default: auto)")
+    ap.add_argument("--limit", type=int, default=None, help="first N rows only (smoke test)")
+    args = ap.parse_args()
+
+    src = Path(args.inp)
+    pf = pq.ParquetFile(src)
+    names = pf.schema_arrow.names
+    for required in ("msmarco_config", "msmarco_split", "msmarco_query_id"):
+        if required not in names:
+            raise SystemExit(f"{src.name} has no `{required}` column -- is it a stripped release file?")
+
+    prov = pq.read_table(src, columns=["msmarco_config", "msmarco_split", "msmarco_query_id"])
+    if args.limit is not None:
+        prov = prov.slice(0, args.limit)
+    keys = list(zip(prov.column(0).to_pylist(), prov.column(1).to_pylist(), prov.column(2).to_pylist()))
+    print(f"{src.name}: {len(keys):,} rows, configs={sorted({k[0] for k in keys})}")
+
+    cache = Path(args.cache)
+    cache.mkdir(parents=True, exist_ok=True)
+    lookup = load_query_text({(c, s) for c, s, _ in keys}, cache, args.keep_raw)
+
+    missing = [k for k in keys if k not in lookup]
+    if missing:
+        raise SystemExit(f"{len(missing)} rows unresolved, e.g. {missing[:3]}")
+    queries = [lookup[k] for k in keys]
+    print(f"recovered {len(queries):,} query strings")
+
+    dense = sparse = None
+    if args.vectors in ("dense", "both"):
+        print(f"embedding dense with {DENSE_MODEL}")
+        dense = embed_dense(queries, args.batch_size, args.device)
+    if args.vectors in ("sparse", "both"):
+        print(f"embedding sparse with {SPARSE_MODEL} (official mGTE scheme)")
+        sparse = embed_sparse(queries, args.batch_size, args.device)
+
+    Path(args.out).parent.mkdir(parents=True, exist_ok=True)
+    writer = None
+    pos = 0
+    try:
+        for batch in pf.iter_batches(batch_size=2048):
+            n = batch.num_rows
+            if args.limit is not None and pos >= args.limit:
+                break
+            if args.limit is not None and pos + n > args.limit:
+                batch = batch.slice(0, args.limit - pos)
+                n = batch.num_rows
+            arrays = list(batch.columns) + [pa.array(queries[pos : pos + n], pa.string())]
+            out_names = list(batch.schema.names) + ["query"]
+            if dense is not None:
+                # float64 to match the released files' `list<double>`: an
+                # exact upcast from the float32 the model produces, and the
+                # only way `pa.concat_tables([original, regenerated])` works.
+                arrays.append(pa.array([r.tolist() for r in dense[pos : pos + n]],
+                                       pa.list_(pa.float64())))
+                out_names.append("dense_embedding")
+            if sparse is not None:
+                # Likewise int64/double, matching the released sparse struct.
+                arrays.append(pa.array(sparse[pos : pos + n],
+                                       pa.struct([("indices", pa.list_(pa.int64())),
+                                                  ("values", pa.list_(pa.float64()))])))
+                out_names.append("sparse_embedding")
+            rb = pa.RecordBatch.from_arrays(arrays, names=out_names)
+            if writer is None:
+                writer = pq.ParquetWriter(args.out, rb.schema, compression="zstd")
+            writer.write_batch(rb)
+            pos += n
+    finally:
+        if writer is not None:
+            writer.close()
+    print(f"wrote {pos:,} rows -> {args.out}")
+
+
+if __name__ == "__main__":
+    main()

queries/scripts/verify_regeneration.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""Check that a regenerated file recovered the right MS MARCO queries.
+
+    python scripts/verify_regeneration.py --sets . --regenerated regenerated/
+
+Compares the SHA-256 of the recovered `query` column against the fingerprints
+in `_checksums.json`. This is the check worth running: MS MARCO v1.1 and v2.1
+reuse the same numeric query ids for different queries, so a config mix-up
+returns plausible text for the wrong question and silently corrupts every
+recall number computed from it. The hash catches that on the first row.
+
+A mismatch means the join is wrong, not that your embeddings are wrong -- this
+does not check vectors. See the README on reproducibility for those.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from pathlib import Path
+
+import pyarrow.parquet as pq
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--sets", default=".", help="bundle dir holding _checksums.json")
+    ap.add_argument("--regenerated", required=True, help="dir written by regenerate_all.py")
+    args = ap.parse_args()
+
+    expected = json.loads((Path(args.sets) / "_checksums.json").read_text())
+    out_dir = Path(args.regenerated)
+
+    failures, checked = [], 0
+    for name, want in expected.items():
+        path = out_dir / f"{name}_regenerated.parquet"
+        if not path.exists():
+            print(f"{name:19} SKIP  (not regenerated)")
+            continue
+
+        pf = pq.ParquetFile(path)
+        if "query" not in pf.schema_arrow.names:
+            failures.append(f"{name}: no `query` column")
+            print(f"{name:19} FAIL  no `query` column")
+            continue
+
+        h, rows = hashlib.sha256(), 0
+        for batch in pf.iter_batches(batch_size=8192, columns=["query"]):
+            for q in batch.column(0).to_pylist():
+                h.update(q.encode())
+                h.update(b"\0")
+                rows += 1
+
+        checked += 1
+        if rows != want["rows"]:
+            failures.append(f"{name}: {rows:,} rows, expected {want['rows']:,}")
+            print(f"{name:19} FAIL  {rows:,} rows, expected {want['rows']:,}")
+        elif h.hexdigest() != want["query_text_sha256"]:
+            failures.append(f"{name}: query text does not match")
+            print(f"{name:19} FAIL  query text mismatch -- wrong config/split, "
+                  f"or rows reordered")
+        else:
+            print(f"{name:19} ok    {rows:,} rows")
+
+    if failures:
+        raise SystemExit(f"\n{len(failures)} set(s) failed:\n  " + "\n  ".join(failures))
+    if checked == 0:
+        raise SystemExit("\nnothing checked -- is --regenerated pointing at the right dir?")
+    print(f"\n{checked} set(s) verified")
+
+
+if __name__ == "__main__":
+    main()