Upload 12 files

.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/nodeids

@@ -0,0 +1,6 @@
+[
+  "tests/test_rag_utils.py::test_minmax_hi_is_bounded_and_monotone",
+  "tests/test_rag_utils.py::test_rag_top10_ranker_runs_on_toy_index",
+  "tests/test_rag_utils.py::test_zscore_constant_is_zero",
+  "tests/test_toy.py::test_toy_build_and_search"
+]

baselines/README.md

@@ -0,0 +1,13 @@
+# Baselines
+
+The result tables keep all baseline families used during development: TF-IDF, BM25, MiniLM/FAISS, Contriever, SPLADE++, BGE, ColBERT, and the historical version of OURS.
+
+`run_local_lexical.py` reproduces local TF-IDF and an effectiveness-oriented BM25 sanity check. Its BM25 latency is **not** a production inverted-index benchmark and is labelled accordingly.
+
+For neural/vector baselines, use the authors' released models and index libraries. Their effectiveness values in `results/beir/rag_top10_pool_sweep_scifact_treccovid.json` are retained as the comparison ledger from the experiment campaign. Before a publication-quality speed claim, rerun every baseline on the same CPU and report both:
+
+- query encoder time;
+- index/search time;
+- end-to-end query time.
+
+Do not compare an end-to-end sparse retrieval number with ANN-only latency that excludes query embedding inference.

baselines/msmarco_scale/BASELINE_COMPARISON.json

@@ -0,0 +1,96 @@
+{
+  "dataset": "TREC Deep Learning 2019 Passage / MS MARCO v1 passage corpus",
+  "corpus_size": 8841823,
+  "queries": 43,
+  "ours": {
+    "source": "local frozen implementation; TRAIN-fold selected parameters; no post-test tuning",
+    "ndcg10_trec_eval_linear_gain": 0.35912864519537124,
+    "mrr10_binary_rel_ge_2": 0.5196382428940569,
+    "p10_binary_rel_ge_2": 0.28837209302325584,
+    "r100_binary_rel_ge_2": 0.32448471642019855,
+    "r1000_binary_rel_ge_2": 0.5097617112453317,
+    "route_recall_macro_binary_rel_ge_2": 0.7011717028045845,
+    "pool2000_recall_macro_binary_rel_ge_2": 0.5414967376369709,
+    "median_ms_local_warm": 86.52526099831448,
+    "p95_ms_local_warm": 163.08966510223397,
+    "avg_routed_docs": 86049.18604651163,
+    "deployable_index_bytes": 2629229405
+  },
+  "local_same_tokenizer_bm25_sanity": {
+    "note": "Effectiveness-only streaming full-corpus scan; NOT an indexed query-latency measurement. Lowercase regex tokenizer, no stemming, k1=.9 b=.4.",
+    "ndcg10_trec_eval_linear_gain": 0.4845300219597866,
+    "mrr10_binary_rel_ge_2": 0.6200535252860835,
+    "p10_binary_rel_ge_2": 0.38372093023255816,
+    "r100_binary_rel_ge_2": 0.465414572538343,
+    "full_corpus_parallel_scan_seconds": 321.1634156703949
+  },
+  "published_same_test": [
+    {
+      "method": "BM25 default",
+      "index": "Lucene/Anserini sparse",
+      "ndcg10": 0.5058,
+      "r1000": 0.7501,
+      "p10": 0.4116,
+      "rr_nist": 0.7036
+    },
+    {
+      "method": "BM25 + RM3",
+      "index": "Lucene/Anserini sparse",
+      "ndcg10": 0.518,
+      "r1000": 0.7998,
+      "p10": 0.4372,
+      "rr_nist": 0.6683
+    },
+    {
+      "method": "BM25 + PRF default",
+      "index": "traditional sparse",
+      "ndcg10": 0.5372
+    },
+    {
+      "method": "BM25 + PRF tuned",
+      "index": "traditional sparse",
+      "ndcg10": 0.5536
+    },
+    {
+      "method": "ANCE",
+      "index": "FAISS Flat",
+      "ndcg10": 0.6452,
+      "r1000": 0.7554
+    },
+    {
+      "method": "BGE-base-en-v1.5",
+      "index": "FAISS Flat float32",
+      "ndcg10": 0.7016,
+      "r1000": 0.8427
+    },
+    {
+      "method": "BGE-base-en-v1.5",
+      "index": "Lucene HNSW",
+      "ndcg10": 0.7016,
+      "r1000": 0.8441
+    },
+    {
+      "method": "BGE-base-en-v1.5",
+      "index": "Lucene HNSW int8",
+      "ndcg10": 0.7017,
+      "r1000": 0.8436
+    },
+    {
+      "method": "TCT-ColBERT-V2-HN+",
+      "index": "FAISS Flat",
+      "ndcg10": 0.7204,
+      "r1000": 0.8261
+    },
+    {
+      "method": "OPQIVFPQ SiamBERT",
+      "index": "FAISS OPQ-IVF-PQ, 256 B/doc",
+      "ndcg10": 0.613,
+      "r1000": 0.675,
+      "note": "different encoder; not apples-to-apples with BGE"
+    }
+  ],
+  "metric_notes": {
+    "ndcg": "trec_eval ndcg_cut uses raw qrel grade as gain; official TREC-DL19 comparison uses graded judgments.",
+    "binary": "NIST passage grade 1 is Related but NOT relevant; binary metrics use grades >=2."
+  }
+}

baselines/msmarco_scale/README.md

@@ -0,0 +1,11 @@
+# Baseline notes — full MS MARCO / TREC-DL19
+
+`run_bm25_test_streaming_effectiveness.py` is a local effectiveness sanity check over all 8,841,823 passages. It is deliberately **not** reported as an indexed BM25 latency measurement because it scans the corpus.
+
+`BASELINE_COMPARISON.json` records the locally measured frozen-system result and published same-test reference rows. Published rows should be cited to NIST/Pyserini/the original dense-retrieval papers in manuscripts.
+
+TREC-DL19 passage judgments require two evaluation conventions:
+- `nDCG@10`: retain graded qrel values (trec_eval `ndcg_cut` uses raw relevance values as gains);
+- binary MRR/P/Recall/Hit: grade 1 is only *Related*, not relevant, therefore use relevance >= 2.
+
+The local frozen-system evaluator in `../scale_experiments/msmarco_test_baseline_compare.py` returns top 1000 and applies the correct binary threshold.

baselines/msmarco_scale/run_bm25_test_streaming_effectiveness.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+import gzip,pickle,json,re,csv,math,time,heapq,glob,os
+from pathlib import Path
+from collections import Counter,defaultdict
+from multiprocessing import Pool, get_context
+import numpy as np
+
+ROOT=Path('/mnt/data'); WORK=ROOT/'msmarco_scale_work'; OUT=WORK/'baselines'; OUT.mkdir(exist_ok=True)
+N=8_841_823; TOPK=1000
+# Same token boundary as frozen system / sklearn token_pattern for query terms.
+TOKEN_RE=re.compile(r'(?u)\b\w\w+\b')
+
+# Load qids and query texts
+qrels_rows=[]; qids=set()
+with open(ROOT/'test.tsv',newline='') as f:
+    r=csv.DictReader(f,delimiter='\t')
+    for x in r:
+        q=str(x['query-id']); d=int(x['corpus-id']); rel=float(x['score']); qids.add(q); qrels_rows.append((q,d,rel))
+qids=sorted(qids,key=lambda x:int(x)); qindex={q:i for i,q in enumerate(qids)}
+texts={}
+with open(ROOT/'queries.jsonl') as f:
+    for line in f:
+        o=json.loads(line); q=str(o['_id'])
+        if q in qids: texts[q]=o['text']
+assert len(texts)==len(qids)==43
+qtoks={q:TOKEN_RE.findall(texts[q].lower()) for q in qids}
+allterms=sorted(set(t for z in qtoks.values() for t in z))
+
+# full-corpus known df from the exact 50k vocabulary build
+with gzip.open(WORK/'final_vocab_50k.pkl.gz','rb') as f:z=pickle.load(f)
+terms50=z['terms'].tolist(); df50=np.asarray(z['df']); term2df={t:int(df50[i]) for i,t in enumerate(terms50)}
+oov=sorted(t for t in allterms if t not in term2df)
+print('queries',len(qids),'query terms',len(allterms),'oov',oov,flush=True)
+
+# locate 36 shards in order
+def shard_path(i):
+    hits=list(ROOT.glob(f'corpus_{i:04d}.jsonl*.gz'))
+    if i==35 and len(hits)==0: hits=list((ROOT/'restored').glob(f'corpus_{i:04d}.jsonl*.gz'))
+    assert len(hits)==1,(i,hits)
+    return str(hits[0])
+SHARDS=[shard_path(i) for i in range(36)]
+
+# Exact OOV df with one cheap corpus scan, only 10 rare strings.
+OOV_PAT=re.compile(r'(?u)\b(?:'+'|'.join(re.escape(t) for t in sorted(oov,key=len,reverse=True))+r')\b') if oov else None
+
+def count_oov_one(args):
+    sid,path=args; c=Counter(); n=0; t0=time.time()
+    with gzip.open(path,'rt',encoding='utf-8') as f:
+        for line in f:
+            o=json.loads(line); tx=((o.get('title') or '')+' '+(o.get('text') or '')).lower(); n+=1
+            if OOV_PAT:
+                m=set(OOV_PAT.findall(tx))
+                for t in m:c[t]+=1
+    return sid,n,dict(c),time.time()-t0
+
+if oov:
+    t0=time.time();
+    with get_context('fork').Pool(processes=8) as p:
+        rr=p.map(count_oov_one,list(enumerate(SHARDS)))
+    oo=Counter();
+    for sid,n,c,sec in rr: oo.update(c)
+    for t in oov: term2df[t]=int(oo[t])
+    print('oov df',dict(oo),'sec',time.time()-t0,flush=True)
+
+# Robertson BM25 idf; base parameters match common Anserini MS MARCO defaults.
+def make_idf():
+    return {t:math.log(1.0+(N-term2df[t]+0.5)/(term2df[t]+0.5)) for t in allterms}
+idf=make_idf()
+# Query term multiplicity mapping term -> [(query index,multiplicity)]
+t2q=defaultdict(list)
+for q in qids:
+    c=Counter(qtoks[q])
+    for t,m in c.items(): t2q[t].append((qindex[q],m))
+# compiled union matcher exact same word boundaries, avoids tokenizing irrelevant words
+PAT=re.compile(r'(?u)\b(?:'+'|'.join(re.escape(t) for t in sorted(allterms,key=len,reverse=True))+r')\b')
+avgdl=float(json.load(open(WORK/'full_index/meta.json'))['avg_doc_length'])
+# existing exact tokenizer document lengths
+DL_PATH=str(WORK/'full_index/doc_lengths.u16')
+
+# Each shard returns top1000 per q. Global top1000 is exactly merge of shard top1000.
+def score_shard(args):
+    sid,path,k1,b=args
+    dlarr=np.memmap(DL_PATH,dtype=np.uint16,mode='r',shape=(N,))
+    heaps=[[] for _ in qids]
+    n=0; matched=0; t0=time.time()
+    with gzip.open(path,'rt',encoding='utf-8') as f:
+        for line in f:
+            o=json.loads(line); d=int(o['_id']); tx=((o.get('title') or '')+' '+(o.get('text') or '')).lower(); n+=1
+            mm=PAT.findall(tx)
+            if not mm: continue
+            matched+=1; tf=Counter(mm); norm=k1*(1.0-b+b*(float(dlarr[d])/avgdl))
+            qs={}
+            for term,freq in tf.items():
+                w=idf[term]*((freq*(k1+1.0))/(freq+norm))
+                for qi,qm in t2q[term]: qs[qi]=qs.get(qi,0.0)+w*qm
+            for qi,sc in qs.items():
+                h=heaps[qi]; item=(float(sc),-d) # lower docid wins exact tie
+                if len(h)<TOPK: heapq.heappush(h,item)
+                elif item>h[0]: heapq.heapreplace(h,item)
+    return sid,heaps,n,matched,time.time()-t0
+
+def retrieve(k1,b,label):
+    t0=time.time()
+    with get_context('fork').Pool(processes=8) as p:
+        rr=p.map(score_shard,[(i,SHARDS[i],k1,b) for i in range(36)])
+    globalh=[[] for _ in qids]
+    for sid,heaps,n,matched,sec in rr:
+        for qi,h in enumerate(heaps):
+            gh=globalh[qi]
+            for item in h:
+                if len(gh)<TOPK: heapq.heappush(gh,item)
+                elif item>gh[0]: heapq.heapreplace(gh,item)
+    run={}
+    for qi,q in enumerate(qids):
+        arr=sorted(globalh[qi],reverse=True); run[q]=[-negd for sc,negd in arr]
+    sec=time.time()-t0
+    print(label,'retrieval scan sec',sec,flush=True)
+    return run,sec
+
+# TREC-compliant eval: passage level 1 = related/not relevant for binary metrics. nDCG remains graded.
+qrels=defaultdict(dict)
+for q,d,r in qrels_rows:qrels[q][d]=r
+
+def evaluate(run):
+    vals=defaultdict(list)
+    for q in qids:
+        qr=qrels[q]; rank=run.get(q,[])
+        binary={d for d,r in qr.items() if r>=2.0}; den=max(1,len(binary))
+        h10=sum(d in binary for d in rank[:10]); h100=sum(d in binary for d in rank[:100])
+        vals['P@10'].append(h10/10); vals['R@10'].append(h10/den); vals['R@100'].append(h100/den); vals['Hit@10'].append(float(h10>0)); vals['Hit@100'].append(float(h100>0))
+        rr=0.0
+        for i,d in enumerate(rank[:10],1):
+            if d in binary: rr=1.0/i;break
+        vals['MRR@10'].append(rr)
+        obs=[qr.get(d,0.0) for d in rank[:10]]; ideal=sorted(qr.values(),reverse=True)[:10]
+        dcg=sum(r/math.log2(i+2) for i,r in enumerate(obs)); idcg=sum(r/math.log2(i+2) for i,r in enumerate(ideal)); vals['nDCG@10'].append(dcg/idcg if idcg else 0.0)
+    return {k:float(np.mean(v)) for k,v in vals.items()} | {'n_queries':len(qids),'n_binary_relevant':sum(r>=2 for _,_,r in qrels_rows)}
+
+if __name__=='__main__':
+    # Common MS MARCO/Anserini-like BM25 and a conventional default variant for sensitivity.
+    out={'tokenizer':'lowercase regex (?u)\\b\\w\\w+\\b; no stemming','N':N,'avgdl':avgdl,'oov_df':{t:term2df[t] for t in oov}}
+    for k1,b,label in [(0.9,0.4,'bm25_k1_0.9_b_0.4'),(1.2,0.75,'bm25_k1_1.2_b_0.75')]:
+        run,sec=retrieve(k1,b,label); met=evaluate(run); out[label]={'k1':k1,'b':b,'metrics':met,'full_corpus_parallel_scan_seconds':sec,'run_top1000':run}; print(label,met,flush=True)
+    json.dump(out,open(OUT/'bm25_local_test.json','w'),indent=2)
+    print('SAVED',OUT/'bm25_local_test.json',flush=True)

baselines/run_local_lexical.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+"""Local lexical references for sanity checking, not the headline speed baseline.
+
+The BM25 implementation here is an effectiveness implementation over the loaded
+corpus. Do not present its latency as a production inverted-index latency.
+"""
+import argparse,json,time,math,re
+from collections import Counter
+import numpy as np
+from scipy import sparse
+from sklearn.feature_extraction.text import TfidfVectorizer
+from geomretrieval import load_beir_zip,load_beir_directory,evaluate_run
+
+def load_dataset(path,split):
+    return load_beir_zip(path,split) if str(path).lower().endswith('.zip') else load_beir_directory(path,split)
+
+def topk(x,k):
+    k=min(k,len(x)); ii=np.argpartition(x,-k)[-k:] if k<len(x) else np.arange(len(x)); return ii[np.argsort(x[ii])[::-1]]
+
+def tfidf(ds):
+    v=TfidfVectorizer(dtype=np.float32,norm='l2'); X=v.fit_transform(ds.corpus_texts); run={}; times=[]
+    qids=[q for q in ds.qrels if q in ds.queries]
+    for qid in qids:
+        t=time.perf_counter(); q=v.transform([ds.queries[qid]]); s=(X@q.T).toarray().ravel(); ii=topk(s,100); times.append((time.perf_counter()-t)*1000);run[qid]=[ds.corpus_ids[i] for i in ii]
+    m=evaluate_run(run,ds.qrels,ks=(10,100),ndcg_k=10,mrr_k=10,exp_gain=False);m['median_ms']=float(np.median(times));m['p95_ms']=float(np.percentile(times,95));return m
+
+def bm25_effectiveness(ds,k1=.9,b=.4):
+    tok=lambda s: re.findall(r'(?u)\\b\\w\\w+\\b',s.lower())
+    docs=[tok(x) for x in ds.corpus_texts]; N=len(docs); lens=np.array([len(x) for x in docs],np.float32);avg=max(1,float(lens.mean()));df=Counter()
+    for x in docs: df.update(set(x))
+    postings={}
+    for di,x in enumerate(docs):
+        c=Counter(x)
+        for t,tf in c.items(): postings.setdefault(t,[]).append((di,tf))
+    run={};times=[]
+    for qid in [q for q in ds.qrels if q in ds.queries]:
+        t0=time.perf_counter();score=np.zeros(N,np.float32)
+        for term in tok(ds.queries[qid]):
+            plist=postings.get(term,()); n=df.get(term,0);idf=math.log(1+(N-n+.5)/(n+.5))
+            for d,tf in plist:
+                den=tf+k1*(1-b+b*lens[d]/avg);score[d]+=idf*(tf*(k1+1))/den
+        ii=topk(score,100);times.append((time.perf_counter()-t0)*1000);run[qid]=[ds.corpus_ids[i] for i in ii]
+    m=evaluate_run(run,ds.qrels,ks=(10,100),ndcg_k=10,mrr_k=10,exp_gain=False);m['median_ms_effectiveness_impl']=float(np.median(times));m['p95_ms_effectiveness_impl']=float(np.percentile(times,95));return m
+
+def main():
+    p=argparse.ArgumentParser();p.add_argument('dataset');p.add_argument('--split',default='test');p.add_argument('--output',default=None);a=p.parse_args();ds=load_dataset(a.dataset,a.split)
+    out={'tfidf':tfidf(ds),'bm25':bm25_effectiveness(ds)};print(json.dumps(out,indent=2));
+    if a.output: open(a.output,'w').write(json.dumps(out,indent=2))
+if __name__=='__main__':main()

configs/msmarco_fullscale_lock.json

@@ -0,0 +1,25 @@
+{
+  "protocol": "Final architecture lock after five disjoint 1000-query TRAIN folds. A parameter change is accepted only when it improves nDCG@10 on all five folds; DEV and TEST are not used for this final lock.",
+  "frozen_params": {
+    "preselection_eta": 1.0,
+    "preselection_idf_power": 1.0,
+    "P": 2000,
+    "gamma_tail": 0.25,
+    "lambda_M": 0.125,
+    "final_idf_power": 2.0,
+    "final_length_b": 0.1,
+    "coordination_alpha": 0.25,
+    "lambda_lex": 4.0,
+    "lambda_sem": 0.3,
+    "rare_topk": 3,
+    "rare_coverage_weight": 1.0,
+    "h": 0,
+    "S": 16
+  },
+  "remaining_train_sweeps": {
+    "length_coordination": "No change. Current b=0.1, alpha=0.25 had the highest five-fold mean nDCG@10 (0.1616578464).",
+    "final_weights": "No change. w_sem=0.5 increased mean by 0.00024547 but improved only 3/5 folds and had worst-fold delta -0.00036559; rejected.",
+    "rare_weight": "No change. top3 weight 1.25 increased mean by 0.00017519 but improved only 3/5 folds and had worst-fold delta -0.00024270; rejected."
+  },
+  "test_policy": "test.tsv evaluated once after this lock; no post-test tuning."
+}

configs/rag_top10_current.json

@@ -0,0 +1,47 @@
+{
+  "representation": {
+    "F": 4,
+    "B": 64,
+    "S": 16,
+    "L": 12,
+    "tau": 20,
+    "beta": -0.2
+  },
+  "routing": {
+    "gamma_tail": 0.25,
+    "lambda_membership": 0.125
+  },
+  "early_rescue": {
+    "idf_power": 1.0,
+    "length_b": 0.2
+  },
+  "final_chunk_score": {
+    "idf_power": 2.0,
+    "length_b": 0.1,
+    "coordination_alpha": 0.25,
+    "lambda_lex": 4.0,
+    "lambda_sem": 0.3,
+    "rare_topk": 3,
+    "rare_weight": 1.0,
+    "semantic_k": 16
+  },
+  "top10_set_selection": {
+    "branch_quality_top_docs": 3,
+    "eligible_high_quality_branches": 10,
+    "lambda_diversity": 0.1,
+    "rank1_pure_relevance": true,
+    "repeated_branches_allowed": true
+  },
+  "rag_pool": {
+    "tested": [
+      25,
+      50,
+      100,
+      200,
+      500,
+      2000
+    ],
+    "large_route_provisional": 100,
+    "note": "Pool size is a RAG top-10 handle, not a deep-recall constant. Small-route corpora may prefer no additional pruning."
+  }
+}

data/README.md

@@ -0,0 +1,20 @@
+# Data
+
+Datasets are intentionally not committed to the repository.
+
+The code accepts either an extracted standard BEIR directory or a standard BEIR `.zip` containing:
+
+```text
+corpus.jsonl
+queries.jsonl
+qrels/test.tsv
+```
+
+Examples used in the current repository:
+
+```text
+data/scifact.zip
+data/trec-covid.zip
+```
+
+For full MS MARCO scale reproduction, follow `docs/REPRODUCIBILITY.md` and the shard manifest in `manifests/`.