Upload 103 files

docs/BASELINE_SUITE.md

@@ -0,0 +1,30 @@
+# Full baseline suite and provenance policy
+
+Every benchmark table in this project keeps the complete comparison suite visible, even when a particular baseline has not yet been rerun on the current dataset.
+
+| Baseline | Representation / search | Speed quantity that must be reported |
+|---|---|---|
+| TF-IDF | sparse lexical, exact scan or inverted index | end-to-end query + search |
+| BM25 | sparse lexical inverted index | end-to-end query + postings traversal |
+| FAISS Flat | fixed dense embeddings, exact inner product/cosine | query encoder + exact vector search |
+| FAISS HNSW | fixed dense embeddings, HNSW | query encoder + ANN search |
+| FAISS IVF-Flat | fixed dense embeddings, IVF | query encoder + ANN search |
+| FAISS IVF-PQ | fixed dense embeddings, IVF + product quantization | query encoder + ANN search |
+| hnswlib HNSW | fixed dense embeddings, HNSW | query encoder + ANN search |
+| ScaNN | fixed dense embeddings, pruning/quantization | query encoder + ANN search |
+| Contriever | neural dense retrieval + ANN | query encoder + ANN search |
+| SPLADE++ | neural sparse expansion + inverted index | sparse query encoder + search |
+| BGE-base | neural dense retrieval + ANN | query encoder + ANN search |
+| Modern ColBERT | neural multi-vector late interaction | query encoder + candidate generation + late interaction |
+| OURS | sparse TF-IDF geometry + signed residuals | TF-IDF query construction + routing + shortlist + top-10 selection |
+
+## Missing values are shown, not hidden
+
+A dash in a result table means the baseline has not yet been rerun under the same representation/hardware/protocol. It is intentionally left visible. We do not fill missing latency with a number from a different CPU/GPU and we do not compare ANN-only latency against our end-to-end latency.
+
+## Current provenance classes
+
+- **local**: executed on the current dataset by the code in this repository/session;
+- **historical local**: executed in an earlier frozen version of the same project;
+- **published/context ledger**: retained from the baseline ledger used during the experimental campaign; not presented as a same-hardware speed result;
+- **pending same-representation rerun**: part of the required suite but deliberately blank until a controlled experiment exists.

docs/LITERATURE_AND_SPEED.md

@@ -0,0 +1,41 @@
+# Retrieval literature through the speed lens
+
+Speed is not a secondary metric in this project. A retriever that produces an excellent rank at a cost incompatible with interactive RAG has solved a different problem.
+
+## The computational boundary we measure
+
+A RAG request pays for **query representation + retrieval + shortlist scoring + top-10 selection**. For ANN baselines, the literature often reports ANN search after the dense query embedding has already been computed. We therefore keep two latency columns whenever possible:
+
+1. **ANN/search-only latency** — useful for comparing indexes.
+2. **End-to-end query latency** — the number relevant to an actual RAG request.
+
+The two must never be silently mixed.
+
+| Family | Query-time representation | Search object | Speed implication |
+|---|---|---|---|
+| BM25 | tokenization only | inverted postings | no neural query inference; strong classical latency reference |
+| FAISS Flat / IVF / PQ | dense query embedding | dense vectors / quantized vectors | optimized vector search; encoder cost is normally outside ANN timing |
+| HNSW | dense query embedding | graph over dense vectors | very fast ANN search, but memory-heavy graph and query encoder remain |
+| ScaNN | dense query embedding | partitioned/quantized dense vectors | search is optimized around MIPS/quantization; encoder cost is separate |
+| Contriever / BGE | neural dense encoder | ANN dense index | representation quality is strong, but query inference is part of deployed RAG cost |
+| SPLADE | neural sparse encoder | sparse inverted index | sparse search, but query sparse vector is produced by a transformer |
+| ColBERTv2 | neural token encoder | compressed multi-vector index + late interaction | excellent quality, but multiple query vectors and late interaction increase work |
+| **Sparse Geometric RAG (this repo)** | **TF-IDF query vector; no neural inference** | **fuzzy sparse branches + 16-coordinate signed residuals** | **query formation is cheap; routing and local scoring touch tiny sparse structures; only a small shortlist reaches chunk-level scoring** |
+
+## Primary references
+
+- Johnson, Douze, Jégou, *Billion-scale similarity search with GPUs* (FAISS): https://arxiv.org/abs/1702.08734
+- Douze et al., *The Faiss Library*: https://arxiv.org/abs/2401.08281
+- Malkov and Yashunin, *Efficient and robust approximate nearest neighbor search using Hierarchical Navigable Small World graphs*: https://arxiv.org/abs/1603.09320
+- Guo et al., *Accelerating Large-Scale Inference with Anisotropic Vector Quantization* (ScaNN): https://arxiv.org/abs/1908.10396
+- Izacard et al., *Unsupervised Dense Information Retrieval with Contrastive Learning* (Contriever): https://arxiv.org/abs/2112.09118
+- Formal et al., *SPLADE v2*: https://arxiv.org/abs/2109.10086
+- Santhanam et al., *ColBERTv2: Effective and Efficient Retrieval via Lightweight Late Interaction*: https://arxiv.org/abs/2112.01488
+- Xiao et al., *C-Pack: Packaged Resources To Advance General Chinese Embedding* (BGE family): https://arxiv.org/abs/2309.07597
+- Thakur et al., *BEIR: A Heterogeneous Benchmark for Zero-shot Evaluation of Information Retrieval Models*: https://arxiv.org/abs/2104.08663
+
+## Why this method is different computationally
+
+FAISS, HNSW, and ScaNN solve the problem “search a database of dense vectors quickly.” This project asks a prior question: **does the retrieval database need a dense vector per chunk at all?** The stored object is instead a coarse fuzzy location plus a very small signed departure from its local center. Query-time work follows that sparse geometry.
+
+The intended speed story is therefore not “we wrote a faster HNSW.” It is: **avoid most of the arithmetic and memory traffic that make ANN necessary in the first place.**

docs/METHOD.md

@@ -0,0 +1,37 @@
+# Method
+
+## Offline representation
+
+For each chunk, construct a sparse normalized TF-IDF vector. Keep its top `F=4` coordinates as fuzzy branch memberships. For branch `j`, keep a sparse `B=64` membership-weighted center. For every chunk-branch membership, retain only `S=16` residual coordinates chosen from terms actually present in the chunk and store their **signs**, not document-specific residual amplitudes.
+
+A zero-inclusive branch-local sign variance is shrunk toward the global term variance and converted to a mild inverse reliability weight, approximately `variance^-0.2`. The corpus also produces a sparse PPMI association graph and a second-order context graph for query routing.
+
+## Query routing and local scoring
+
+The query retains real TF-IDF amplitudes. Weak second-order expansion exposes nearby branches. A branch-local signed score evaluates only the 16 stored residual coordinates and is weighted by fuzzy membership, route strength, query-mass significance, and inverse local sign variance.
+
+## Early rescue and chunk shortlist
+
+The routed representations are cheaply ordered using geometric evidence plus whole-chunk **binary IDF^1** support. The best `P` representations are mapped to their corresponding chunks. No dense 384/768-dimensional embedding is required at this stage.
+
+## Final chunk score
+
+For each shortlisted chunk, the final lexical statistic is binary presence weighted by **IDF squared**:
+
+```text
+sum_{t in query ∩ chunk} IDF(t)^2
+```
+
+It is combined with a weak length correction, query coordination, sparse semantic presence, and coverage of the three rarest query terms. The validated score components retain their per-query z-normalization.
+
+## High-quality branches and soft diversity
+
+Branch quality is query-specific. For branch `j`, define branch-specific evidence `E_dj` using the geometric membership contribution. The quality score is the mean of the top three evidences in that branch:
+
+```text
+H_j = mean(top3_d E_dj)
+```
+
+Only the ten branches with largest `H_j` are eligible for a diversity bonus. Rank 1 is pure relevance. For ranks 2–10, a candidate can receive a small bonus if one of its high-quality supporting branch centers deviates from the centroid of branches already represented. Repeated branches are allowed.
+
+This is **not blind diversification** and it is **not one-document-per-branch**.

docs/RAG_PROTOCOL.md

@@ -0,0 +1,34 @@
+# Practical RAG evaluation protocol: measure the first ten chunks
+
+## Why K=10 is the deployment target
+
+A RAG system does not consume an abstract recall curve. It consumes a small context set. Chunks ranked at 100, 500, or 1000 are normally never passed to the generator. Optimizing deep recall can therefore reward a retriever for spending CPU, memory bandwidth, and storage on results that have zero downstream utility.
+
+For this repository, the primary protocol is deliberately strict:
+
+- retrieve a ranked **top 10**;
+- report **nDCG@10, MRR@10, Precision@10, Recall@10, Hit@10**;
+- measure **CPU median latency, p95 latency, and QPS**;
+- report the number of routed candidates and the chunk shortlist size `P`;
+- use deep-recall metrics only as diagnostics, never as the main optimization objective.
+
+This is the only protocol in the repository used to decide whether a change helps practical RAG.
+
+## Why shortlist size P is a RAG parameter
+
+The historical system used `P=2000` because it was selected for Recall@100. Once the objective became top-10 RAG quality, the relevant question changed to:
+
+> How many retrieved geometric representations should be exposed to chunk-level scoring before choosing ten chunks?
+
+The current sweep is therefore `P in {25, 50, 100, 200, 500}` plus the historical `P=2000` reference. TREC-COVID has a large route and peaks sharply at `P=100`; SciFact has a tiny route (~157 candidates/query) and improves as the artificial pruning is removed. The lesson is not that 100 is universal. The lesson is that **the shortlist must be evaluated for the top-10 deployment objective rather than inherited from a deep-recall benchmark.**
+
+## Timing discipline
+
+Speed is a first-class result.
+
+1. CPU is the principal deployment regime.
+2. Warm the index before timing.
+3. Record median and p95, not only an average.
+4. Report query representation time separately when a baseline uses a neural encoder.
+5. Never compare our end-to-end latency with an ANN-only latency that silently excludes dense query encoding.
+6. Mark diagnostic Python implementations as diagnostic; do not present them as optimized production latency.

docs/REPRODUCIBILITY.md

@@ -0,0 +1,46 @@
+# Reproducibility
+
+## Environment
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -U pip
+pip install -e .
+```
+
+Optional ANN/neural baselines:
+
+```bash
+pip install -r requirements-baselines.txt
+```
+
+## SciFact
+
+Place a standard BEIR archive at `data/scifact.zip` and run:
+
+```bash
+./scripts/reproduce_scifact.sh data/scifact.zip artifacts/scifact_index
+```
+
+## TREC-COVID
+
+Place a standard BEIR archive at `data/trec-covid.zip` and run:
+
+```bash
+./scripts/reproduce_treccovid.sh data/trec-covid.zip artifacts/treccovid_index
+```
+
+## One configuration
+
+```bash
+python experiments/beir/run_rag_top10.py   data/trec-covid.zip artifacts/treccovid_index   --pool 100 --hq-branches 10 --lambda-diversity 0.1   --output results/reproduced/treccovid_p100.json
+```
+
+## Full MS MARCO
+
+The exact historical full-scale scripts are preserved under `experiments/msmarco_scale/`. They are intentionally kept close to the scripts that produced the recorded JSON files. The 8.84M corpus shards and multi-GB generated arrays are not in this repository. Use `manifests/msmarco_manifest.json` to verify the shard set, then follow the build order described in the root README.
+
+## Exact experiment history vs cleaned runner
+
+`experiments/beir/*exact_history.py` contains the scripts as executed in the current session, including their original local paths. `experiments/beir/run_rag_top10.py` and `run_pool_sweep.py` are cleaned path-independent runners using the same formulas.

experiments/beir/run_pool_sweep.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+import argparse,json
+from pathlib import Path
+from geomretrieval import GeometricIndex,RAGTop10Config,RAGTop10Ranker,load_beir_zip,load_beir_directory
+
+def load_dataset(path,split):
+    return load_beir_zip(path,split) if str(path).lower().endswith('.zip') else load_beir_directory(path,split)
+
+def main():
+    p=argparse.ArgumentParser(description='Top-10 RAG shortlist sweep. Deep-recall metrics are intentionally not used for model selection.')
+    p.add_argument('dataset'); p.add_argument('index'); p.add_argument('--split',default='test')
+    p.add_argument('--pools',type=int,nargs='+',default=[25,50,100,200,500])
+    p.add_argument('--output',default='pool_sweep.json')
+    a=p.parse_args(); ds=load_dataset(a.dataset,a.split); idx=GeometricIndex.load(a.index)
+    out={'dataset':ds.name,'split':a.split,'protocol':'top-10 RAG only','pools':{}}
+    for P in a.pools:
+        ranker=RAGTop10Ranker(idx,RAGTop10Config(pool_size=P))
+        metrics,_=ranker.evaluate(ds,k=10)
+        out['pools'][str(P)]=metrics
+        print('P=',P,json.dumps(metrics,sort_keys=True))
+    Path(a.output).write_text(json.dumps(out,indent=2))
+if __name__=='__main__':main()

experiments/beir/run_rag_top10.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+import argparse, json
+from pathlib import Path
+
+from geomretrieval import GeometricIndex, RAGTop10Config, RAGTop10Ranker, load_beir_zip, load_beir_directory
+
+
+def load_dataset(path, split):
+    return load_beir_zip(path, split) if str(path).lower().endswith('.zip') else load_beir_directory(path, split)
+
+
+def main():
+    p=argparse.ArgumentParser(description='Evaluate the current top-10 RAG protocol on a BEIR dataset.')
+    p.add_argument('dataset', help='BEIR zip or extracted dataset directory')
+    p.add_argument('index', help='saved GeometricIndex directory')
+    p.add_argument('--split', default='test')
+    p.add_argument('--pool', type=int, default=100)
+    p.add_argument('--hq-branches', type=int, default=10)
+    p.add_argument('--lambda-diversity', type=float, default=0.1)
+    p.add_argument('--output', default=None)
+    a=p.parse_args()
+    ds=load_dataset(a.dataset,a.split)
+    idx=GeometricIndex.load(a.index)
+    cfg=RAGTop10Config(pool_size=a.pool,hq_top_branches=a.hq_branches,lambda_diversity=a.lambda_diversity)
+    ranker=RAGTop10Ranker(idx,cfg)
+    metrics,run=ranker.evaluate(ds,k=10)
+    result={'dataset':ds.name,'split':a.split,'config':cfg.__dict__,'metrics':metrics}
+    print(json.dumps(result,indent=2))
+    if a.output:
+        Path(a.output).write_text(json.dumps({'summary':result,'run':run},indent=2))
+
+if __name__=='__main__': main()

experiments/beir/scifact_pool_sweep_exact_history.py

@@ -0,0 +1,265 @@
+from __future__ import annotations
+import sys,time,json,math,os
+import numpy as np
+sys.path.insert(0,'/mnt/data/work_code/geomretrieval_msmarco_scale_codebase/original_v0')
+from geomretrieval import GeometricIndex, load_beir_directory, evaluate_run
+
+IDX='/mnt/data/scifact_geom_index'
+ROOT='/mnt/data/work_scifact/scifact'
+idx=GeometricIndex.load(IDX); M=idx.vocab_size
+P=int(os.environ.get("POOL_P","100")); GAMMA=.25; LAM_M=.125; PRE_B=.2; FINAL_B=.1; ALPHA=.25
+WLEX=4.0; WSEM=.3; WRARE=1.0; SEMK=16; EPS=1e-8
+
+
+def zscore(x):
+    x=np.asarray(x,np.float32)
+    if not len(x): return x
+    sd=float(x.std())
+    return np.zeros_like(x) if sd<1e-8 else (x-float(x.mean()))/sd
+
+def minmax_hi(x):
+    x=np.asarray(x,np.float32)
+    if not len(x): return x
+    mn=float(x.min()); mx=float(x.max()); den=mx-mn
+    return np.ones_like(x) if den<1e-8 else (x-mn)/den
+
+def topk_large(score,k):
+    n=len(score); k=min(k,n)
+    if k<=0:return np.empty(0,np.int64)
+    if n<=k:return np.argsort(score)[::-1]
+    ii=np.argpartition(score,-k)[-k:]
+    return ii[np.argsort(score[ii])[::-1]]
+
+def center_sparse(j):
+    t=idx.center_terms[j]; v=idx.center_values[j]; ok=t>=0
+    t=t[ok].astype(np.int32); v=v[ok].astype(np.float32)
+    n=float(np.linalg.norm(v))
+    if n>0:v=v/n
+    oo=np.argsort(t)
+    return t[oo],v[oo]
+
+def spdot(a_t,a_v,b_t,b_v):
+    i=j=0;s=0.0
+    while i<len(a_t) and j<len(b_t):
+        if a_t[i]==b_t[j]:s+=float(a_v[i])*float(b_v[j]);i+=1;j+=1
+        elif a_t[i]<b_t[j]:i+=1
+        else:j+=1
+    return s
+
+def prepare(text):
+    q=idx._query_vector(text)
+    if q.nnz==0:return None
+    qd=np.zeros(M,np.float32); qd[q.indices]=q.data
+    rt,rv,qt=idx._expanded_route(q)
+    if not len(rt):return None
+    rd=np.zeros(M,np.float32);rd[rt]=rv
+    pieces=[]
+    for j in rt:
+        a,b=idx.branch_offsets[j],idx.branch_offsets[j+1]
+        if b>a:pieces.append(idx.branch_order[a:b])
+    if not pieces:return None
+    fp=np.concatenate(pieces).astype(np.int64,copy=False)
+    docs=(fp//idx.config.F).astype(np.int64); slots=(fp%idx.config.F).astype(np.int64)
+    br=idx.branches[docs,slots]
+    terms=idx.res_terms[docs,slots];valid=terms>=0;safe=np.where(valid,terms,0);qv=qd[safe]
+    local=np.sum(idx.res_reliability[docs,slots].astype(np.float32)*(qv-idx.res_center_values[docs,slots])*idx.res_signs[docs,slots].astype(np.float32)*valid,axis=1)
+    sig=np.sum((qv*qv)*valid,axis=1)
+    cons=idx.memberships[docs,slots]*rd[br]
+    branch_ev=(cons*local*np.power(np.maximum(sig,0),GAMMA)).astype(np.float32)  # E_dj exactly
+    base=cons*local
+    ud,inv=np.unique(docs,return_inverse=True)
+    tail=np.bincount(inv,weights=branch_ev,minlength=len(ud)).astype(np.float32)
+    tail += LAM_M*np.bincount(inv,weights=cons,minlength=len(ud)).astype(np.float32)
+    # dominant routed branch retained for diagnostics
+    bestv=np.full(len(ud),-1e30,np.float32);db=np.full(len(ud),-1,np.int32)
+    for p,u in enumerate(inv):
+        if cons[p]>bestv[u]:bestv[u]=cons[p];db[u]=int(br[p])
+    # frozen early lexical rescue
+    qlex=np.zeros(M,np.float32);qlex[q.indices]=idx.idf[q.indices]
+    lex1=np.zeros(len(ud),np.float32)
+    for i,d in enumerate(ud):
+        a,b=idx.support_indptr[d],idx.support_indptr[d+1];sup=idx.support_indices[a:b]
+        raw=float(qlex[sup].sum());den=(1-PRE_B)+PRE_B*(float(idx.doc_lengths[d])/idx.avg_doc_length)
+        lex1[i]=raw/(den if den>0 else 1.)
+    pre=zscore(tail)+zscore(lex1)
+    sel=topk_large(pre,P)
+    dd=ud[sel];ts=tail[sel];db=db[sel]
+    # mapping routed-doc local index -> pool local index
+    poolpos=np.full(len(ud),-1,np.int32); poolpos[sel]=np.arange(len(sel),dtype=np.int32)
+    mp=poolpos[inv]
+    keep=mp>=0
+    mem_pool=mp[keep].astype(np.int32)
+    mem_br=br[keep].astype(np.int32)
+    mem_ev=branch_ev[keep].astype(np.float32)
+    # final current features
+    semvec=np.zeros(M,np.float32)
+    for t,amp in zip(q.indices,q.data):
+        a,b=idx.A.indptr[t],idx.A.indptr[t+1];nb=idx.A.indices[a:b][:SEMK];sv=idx.A.data[a:b][:SEMK]
+        if len(nb):semvec[nb]+=float(amp)*sv*idx.idf[nb]
+    qset=set(map(int,q.indices));rare=set(map(int,q.indices[np.argsort(idx.idf[q.indices])[::-1]][:3]));nq=max(1,len(q.indices))
+    lx=np.zeros(len(dd),np.float32);sm=np.zeros(len(dd),np.float32);qc=np.zeros(len(dd),np.float32);r3=np.zeros(len(dd),np.float32)
+    for i,d in enumerate(dd):
+        a,b=idx.support_indptr[d],idx.support_indptr[d+1];sup=idx.support_indices[a:b]
+        sm[i]=float(semvec[sup].sum())
+        match=[int(t) for t in sup if int(t) in qset]
+        raw=sum(float(idx.idf[t])**2 for t in match);den=(1-FINAL_B)+FINAL_B*(float(idx.doc_lengths[d])/idx.avg_doc_length)
+        lx[i]=raw/(den if den>0 else 1.);qc[i]=len(match);r3[i]=sum(t in rare for t in match)
+    cov=qc/nq;ladj=lx*np.power(np.maximum(cov,1e-6),ALPHA);rarecov=r3/max(1,min(3,nq))
+    base_score=zscore(ts)+WLEX*zscore(ladj)+WSEM*zscore(sm)+WRARE*zscore(rarecov)
+
+    # Build H_j = mean of top 3 E_dj among selected pool documents for branch j.
+    # Multiple memberships of same doc+branch should not occur; if they do, keep max.
+    branch_pairs={}
+    for pi,b,e in zip(mem_pool,mem_br,mem_ev):
+        key=(int(b),int(pi))
+        if key not in branch_pairs or e>branch_pairs[key]: branch_pairs[key]=float(e)
+    byb={}
+    for (b,pi),e in branch_pairs.items(): byb.setdefault(b,[]).append((e,pi))
+    H={}; bestdoc={}; docs_by_branch={}
+    for b,vals in byb.items():
+        vals.sort(key=lambda x:x[0],reverse=True)
+        top=vals[:3]
+        H[b]=float(np.mean([e for e,_ in top]))
+        bestdoc[b]=int(max(vals,key=lambda x: float(base_score[x[1]]))[1])  # best final-relevance doc in branch
+        docs_by_branch[b]=np.asarray([pi for _,pi in vals],dtype=np.int32)
+    ub=np.asarray(sorted(H.keys()),dtype=np.int32)
+    h=np.asarray([H[int(b)] for b in ub],dtype=np.float32)
+    hnorm=minmax_hi(h)
+    bmap={int(b):i for i,b in enumerate(ub)}
+    reps=[center_sparse(int(b)) for b in ub]
+    C=np.eye(len(ub),dtype=np.float32)
+    for i in range(len(ub)):
+        for j in range(i+1,len(ub)):
+            C[i,j]=C[j,i]=spdot(*reps[i],*reps[j])
+    return {'docs':dd,'base':base_score,'tail':ts,'lex':ladj,'sem':sm,'rare':rarecov,
+            'route_docs':ud,'branches_dom':db,'ub':ub,'H':h,'Hn':hnorm,'bmap':bmap,'cos':C,
+            'bestdoc':bestdoc,'docs_by_branch':docs_by_branch}
+
+def plain(p,k=100):
+    oo=np.argsort(p['base'])[::-1][:k]
+    return p['docs'][oo].tolist()
+
+def Dvec(p, selected_bidx):
+    C=p['cos']
+    if not selected_bidx:return np.zeros(len(C),np.float32)
+    si=np.asarray(selected_bidx,np.int32)
+    mumun=float(np.mean(C[np.ix_(si,si)]))
+    return 1.0+mumun-2.0*np.mean(C[:,si],axis=1)
+
+def select_hq_branches(p, topN=20, lam=1.0, nsel=10, pure_div=False):
+    if len(p['ub'])==0:return []
+    # eligible branches are the top-N robust-quality H_j branches
+    order=np.argsort(p['H'])[::-1]
+    elig=order[:min(topN,len(order))]
+    # first branch = highest H_j
+    selected=[int(elig[0])]
+    remaining=set(map(int,elig[1:]))
+    while remaining and len(selected)<min(nsel,len(elig)):
+        rem=np.asarray(sorted(remaining),dtype=np.int32)
+        D=Dvec(p,selected)
+        dnorm=minmax_hi(D[rem])
+        if pure_div:
+            val=dnorm
+        else:
+            h=p['Hn'][rem]
+            val=h+float(lam)*dnorm
+        pick=int(rem[int(np.argmax(val))])
+        selected.append(pick); remaining.remove(pick)
+    return selected
+
+def rank_hq_oneper(p,topN=20,lam=1.0,pure_div=False,k=100):
+    # one best final-score document from each selected high-quality/diverse branch for top 10
+    sb=select_hq_branches(p,topN,lam,10,pure_div)
+    chosen=[]; used=set()
+    for bi in sb:
+        b=int(p['ub'][bi]); pi=int(p['bestdoc'][b])
+        if pi not in used: chosen.append(pi); used.add(pi)
+    # if fewer than 10, fill by ordinary score
+    for pi in np.argsort(p['base'])[::-1]:
+        pi=int(pi)
+        if len(chosen)>=10:break
+        if pi not in used: chosen.append(pi);used.add(pi)
+    # rest by ordinary score
+    for pi in np.argsort(p['base'])[::-1]:
+        pi=int(pi)
+        if len(chosen)>=k:break
+        if pi not in used: chosen.append(pi);used.add(pi)
+    return p['docs'][np.asarray(chosen[:k],dtype=np.int64)].tolist()
+
+def rank_hq_softdoc(p,topN=20,lam=.25,k=100):
+    # restrict diversity bonus to high-quality branches; repeated branches allowed.
+    # docs outside HQ set retain pure relevance and are still eligible.
+    base=p['base']; n=len(base); order=np.argsort(base)[::-1]
+    first=int(order[0]); chosen=[first]; used={first}
+    elig_order=np.argsort(p['H'])[::-1][:min(topN,len(p['H']))]
+    eligset=set(map(int,elig_order))
+    # branch memberships for each pool doc: use all high-quality branches the doc belongs to
+    doc_hq=[[] for _ in range(n)]
+    for bi in elig_order:
+        b=int(p['ub'][bi])
+        for pi in p['docs_by_branch'][b]: doc_hq[int(pi)].append(int(bi))
+    # selected branch representation starts with highest-quality HQ branch supporting first, if any
+    selected=[]
+    if doc_hq[first]:
+        selected=[max(doc_hq[first], key=lambda bi: float(p['H'][bi]))]
+    for _ in range(1,min(10,k,n)):
+        rem=np.asarray([i for i in range(n) if i not in used],dtype=np.int32)
+        if not len(rem):break
+        D=Dvec(p,selected) if selected else np.zeros(len(p['ub']),np.float32)
+        # normalize only across eligible branches
+        if len(elig_order):
+            ed=minmax_hi(D[elig_order]); dn={int(bi):float(v) for bi,v in zip(elig_order,ed)}
+        else: dn={}
+        # relevance minmax across remaining top pool; high = good
+        rn=minmax_hi(base[rem])
+        bonus=np.zeros(len(rem),np.float32)
+        for k2,pi in enumerate(rem):
+            if doc_hq[int(pi)]: bonus[k2]=max(dn.get(bi,0.0) for bi in doc_hq[int(pi)])
+        val=rn+float(lam)*bonus
+        pi=int(rem[int(np.argmax(val))]); chosen.append(pi); used.add(pi)
+        if doc_hq[pi]:
+            # add the supporting HQ branch with max diversity, ties quality
+            bi=max(doc_hq[pi],key=lambda x:(dn.get(x,0.0),float(p['H'][x])))
+            selected.append(int(bi))
+    for pi in order:
+        pi=int(pi)
+        if len(chosen)>=k:break
+        if pi not in used:chosen.append(pi);used.add(pi)
+    return p['docs'][np.asarray(chosen[:k],dtype=np.int64)].tolist()
+
+def evaluate(ds,packs,ranker,**kw):
+    run={};route_num=pool_num=den=0;cands=[]
+    for qid,p in packs.items():
+        rr=[] if p is None else ranker(p,**kw)
+        run[str(qid)]=[str(idx.doc_ids[int(d)]) for d in rr]
+        if p is not None:
+            route={str(idx.doc_ids[int(d)]) for d in p['route_docs']};pool={str(idx.doc_ids[int(d)]) for d in p['docs']}
+            pos={str(d) for d,v in ds.qrels[qid].items() if v>0};den+=len(pos);route_num+=sum(d in route for d in pos);pool_num+=sum(d in pool for d in pos);cands.append(len(route))
+    m=evaluate_run(run,ds.qrels,ks=(10,100),ndcg_k=10,mrr_k=10,exp_gain=False)
+    m['route_recall_micro']=route_num/max(1,den);m['pool_recall_micro']=pool_num/max(1,den);m['avg_candidates']=float(np.mean(cands)) if cands else 0
+    return m
+
+
+ds=load_beir_directory(ROOT,'test')
+packs={}; prep=[]
+for i,qid in enumerate(ds.qrels):
+    t=time.perf_counter(); packs[qid]=prepare(ds.queries[qid]); prep.append((time.perf_counter()-t)*1000)
+    if (i+1)%10==0: print('prepared',i+1,flush=True)
+
+def eval_timed(name,fn,**kw):
+    # rank timing only on prepared packs
+    rt=[]
+    for qid,p in packs.items():
+        t=time.perf_counter(); _=[] if p is None else fn(p,**kw); rt.append((time.perf_counter()-t)*1000)
+    m=evaluate(ds,packs,fn,**kw)
+    m['rank_median_ms']=float(np.median(rt)); m['rank_p95_ms']=float(np.percentile(rt,95))
+    print(name,m,flush=True); return m
+
+res={'dataset':'SciFact','P':P,'branch_quality':'mean top-3 E_dj among P pool docs; E_dj=m_dj*rho_q(j)*L_dj*C_dj^gamma',
+     'selection':'top-10 branches by H_j; soft document diversity lambda_D=0.1; IDF^2 final lexical term',
+     'timing':{'prepare_median_ms':float(np.median(prep)),'prepare_p95_ms':float(np.percentile(prep,95))},'variants':{}}
+res['variants']['current_z']=eval_timed('current_z',plain)
+res['variants']['hq10_softdoc_l0.1']=eval_timed('hq10_softdoc_l0.1',rank_hq_softdoc,topN=10,lam=0.1)
+out=f'/mnt/data/scifact_p{P}_sweep_result.json'
+json.dump(res,open(out,'w'),indent=2)
+print('saved',out,flush=True)

experiments/beir/treccovid_collision_diag_exact_history.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+import json, sys, math
+from collections import defaultdict
+import numpy as np
+from scipy.spatial import cKDTree
+
+# Load function definitions only, avoiding the experiment main block.
+path='/mnt/data/treccovid_hq_branch_compact.py'
+src=open(path,'r',encoding='utf-8').read()
+prefix=src.split("ds=load_beir_directory(ROOT,'test')",1)[0]
+ns={}
+exec(compile(prefix,path,'exec'),ns)
+idx=ns['idx']; ROOT=ns['ROOT']; prepare=ns['prepare']; rank_hq_softdoc=ns['rank_hq_softdoc']; load_beir_directory=ns['load_beir_directory']
+
+ds=load_beir_directory(ROOT,'test')
+
+def minmax_cols(X):
+    X=np.asarray(X,np.float64)
+    mn=X.min(axis=0); mx=X.max(axis=0); den=mx-mn
+    den=np.where(den<1e-12,1.0,den)
+    return (X-mn)/den
+
+def doc_support_mask(d, qids, qpos):
+    a,b=idx.support_indptr[d],idx.support_indptr[d+1]
+    sup=idx.support_indices[a:b]
+    mask=0
+    # qpos dict is tiny
+    for t in sup:
+        p=qpos.get(int(t))
+        if p is not None: mask |= (1<<p)
+    return int(mask)
+
+def dom_slot(d, b):
+    slots=np.where(idx.branches[int(d)]==int(b))[0]
+    return int(slots[0]) if len(slots) else -1
+
+def residual_keys(d, b, qpos):
+    sl=dom_slot(d,b)
+    if sl<0: return (),()
+    terms=idx.res_terms[int(d),sl]
+    signs=idx.res_signs[int(d),sl]
+    full=[]; proj=[]
+    for t,s in zip(terms,signs):
+        ti=int(t)
+        if ti<0: continue
+        si=int(s)
+        full.append((ti,si))
+        p=qpos.get(ti)
+        if p is not None: proj.append((int(p),si))
+    return tuple(full),tuple(proj)
+
+def mixed_class_stats(keys, labels):
+    groups=defaultdict(lambda:[0,0])
+    for k,y in zip(keys,labels): groups[k][int(y)]+=1
+    mixed={k:v for k,v in groups.items() if v[0]>0 and v[1]>0}
+    n=len(keys); nrel=int(np.sum(labels)); nnon=n-nrel
+    rel_mixed=sum(v[1] for v in mixed.values()); non_mixed=sum(v[0] for v in mixed.values())
+    docs_mixed=rel_mixed+non_mixed
+    return {
+        'n_docs':n,'n_classes':len(groups),'n_mixed_classes':len(mixed),
+        'docs_in_mixed_classes':docs_mixed,
+        'doc_mixed_fraction':docs_mixed/max(1,n),
+        'relevant_docs':nrel,'relevant_in_mixed_classes':rel_mixed,
+        'relevant_mixed_fraction':rel_mixed/max(1,nrel),
+        'nonrelevant_in_mixed_classes':non_mixed,
+        'largest_class':max((sum(v) for v in groups.values()), default=0),
+        'largest_mixed_class':max((sum(v) for v in mixed.values()), default=0),
+    }
+
+def near_stats(X,y):
+    X=np.asarray(X,np.float64); y=np.asarray(y,np.int8)
+    rel=np.where(y==1)[0]; non=np.where(y==0)[0]
+    if len(rel)==0 or len(non)==0:
+        return {'n_rel':len(rel),'n_nonrel':len(non)}
+    tree=cKDTree(X[non])
+    dist,_=tree.query(X[rel],k=1)
+    out={'n_rel':int(len(rel)),'n_nonrel':int(len(non)),
+         'nearest_nonrel_median':float(np.median(dist)),
+         'nearest_nonrel_p25':float(np.percentile(dist,25)),
+         'nearest_nonrel_p75':float(np.percentile(dist,75)),
+         'nearest_nonrel_p90':float(np.percentile(dist,90))}
+    for th in [0.005,0.01,0.02,0.05,0.10,0.20]:
+        out[f'frac_rel_nn_le_{th:g}']=float(np.mean(dist<=th))
+    return out
+
+def quantized_mixed(X,y,bins):
+    # X already in [0,1]; map each dimension into 0..bins-1
+    Q=np.minimum(bins-1,np.floor(np.asarray(X)*bins).astype(np.int16))
+    keys=[tuple(row.tolist()) for row in Q]
+    return mixed_class_stats(keys,y)
+
+perq={}
+agg_light=[]; agg_full=[]
+# aggregate counters manually by concatenating keys with qid prefix to avoid cross-query collisions
+all_light_keys=[]; all_full_keys=[]; all_labels=[]
+all_X=[]; all_y=[]
+all_pool_X=[]; all_pool_y=[]
+q_oracle=[]
+actual_top10_rel=[]
+base_top10_rel=[]
+rel_pool_total=rel_hq_total=0
+
+for qi,qid in enumerate(ds.qrels):
+    p=prepare(ds.queries[qid])
+    if p is None: continue
+    q=idx._query_vector(ds.queries[qid])
+    qids=list(map(int,q.indices)); qpos={t:i for i,t in enumerate(qids)}
+    rare_ids=set(map(int,q.indices[np.argsort(idx.idf[q.indices])[::-1]][:3]))
+    # labels for 2k
+    pos={str(d) for d,v in ds.qrels[qid].items() if v>0}
+    labels=np.asarray([1 if str(idx.doc_ids[int(d)]) in pos else 0 for d in p['docs']],dtype=np.int8)
+    # high-quality top10 branches
+    elig_order=np.argsort(p['H'])[::-1][:min(10,len(p['H']))]
+    hq_positions=set()
+    for bi in elig_order:
+        b=int(p['ub'][int(bi)])
+        hq_positions.update(map(int,p['docs_by_branch'][b]))
+    hq=np.asarray(sorted(hq_positions),dtype=np.int32)
+    if len(hq)==0: continue
+    yh=labels[hq]
+    # feature vectors: tail, lex, sem, rare. normalize over full 2k, then subset HQ
+    V=np.column_stack([p['tail'],p['lex'],p['sem'],p['rare']]).astype(np.float64)
+    Vn=minmax_cols(V)
+    Xh=Vn[hq]
+    # symbolic keys
+    light=[]; full=[]
+    for pi in hq:
+        d=int(p['docs'][pi]); b=int(p['branches_dom'][pi])
+        smask=doc_support_mask(d,qids,qpos)
+        rmask=0
+        for t in rare_ids:
+            qp=qpos.get(t)
+            if qp is not None and (smask & (1<<qp)): rmask |= (1<<qp)
+        fkey,pkey=residual_keys(d,b,qpos)
+        light.append((smask,rmask,b,pkey))
+        full.append((smask,rmask,b,fkey))
+    ls=mixed_class_stats(light,yh); fs=mixed_class_stats(full,yh); ns4=near_stats(Xh,yh)
+    qmix={str(b):quantized_mixed(Xh,yh,b) for b in [10,20,50,100]}
+    # ceilings
+    nrel_pool=int(labels.sum()); nrel_hq=int(yh.sum())
+    rel_pool_total += nrel_pool; rel_hq_total += nrel_hq
+    oracle_top10=min(10,nrel_hq)
+    q_oracle.append(oracle_top10)
+    # current HQ-div rank and plain rank rel count
+    rr=rank_hq_softdoc(p,topN=10,lam=.1,k=10)
+    rr_ext={str(idx.doc_ids[int(d)]) for d in rr}
+    ar=sum(d in pos for d in rr_ext); actual_top10_rel.append(ar)
+    bo=np.argsort(p['base'])[::-1][:10]
+    br=sum(labels[bo]); base_top10_rel.append(int(br))
+    perq[str(qid)]={'pool_rel':nrel_pool,'hq_docs':int(len(hq)),'hq_rel':nrel_hq,
+                    'actual_hqdiv_rel10':int(ar),'plain_rel10':int(br),'oracle_rel10_hq':int(oracle_top10),
+                    'light_collision':ls,'full_collision':fs,'near4d':ns4,'quantized4d':qmix}
+    # aggregate with qid prefix
+    all_light_keys.extend([(str(qid),)+tuple(k) for k in light])
+    all_full_keys.extend([(str(qid),)+tuple(k) for k in full])
+    all_labels.extend(yh.tolist())
+    all_X.append(Xh); all_y.append(yh)
+    all_pool_X.append(Vn); all_pool_y.append(labels)
+
+Y=np.asarray(all_labels,np.int8); X=np.vstack(all_X); PY=np.concatenate(all_pool_y); PX=np.vstack(all_pool_X)
+result={
+    'dataset':'TREC-COVID',
+    'diagnostic':'2k -> 10 discrimination inside top-10 high-quality branches',
+    'definitions':{
+        'hq_branches':'top 10 branches by H_j = mean top-3 branch-specific E_dj',
+        'light_collision':'same whole-query binary support mask + same rare-term mask + same dominant branch + same query-projected residual sign signature',
+        'full_collision':'same support/rare masks + same dominant branch + identical full 16-coordinate residual (term,sign) code',
+        'near4d':'Euclidean distance after per-query min-max normalization of [tail, IDF^2 lexical+coordination, semantic support, rare3 coverage]',
+    },
+    'aggregate':{
+        'queries':len(perq),'pool_relevant_total':int(rel_pool_total),'hq_relevant_total':int(rel_hq_total),
+        'hq_share_of_pool_relevant':float(rel_hq_total/max(1,rel_pool_total)),
+        'mean_plain_relevant_at10':float(np.mean(base_top10_rel)),
+        'mean_hqdiv_relevant_at10':float(np.mean(actual_top10_rel)),
+        'mean_oracle_relevant_at10_if_perfect_inside_hq':float(np.mean(q_oracle)),
+        'light_collision':mixed_class_stats(all_light_keys,Y),
+        'full_collision':mixed_class_stats(all_full_keys,Y),
+        'near4d_hq':near_stats(X,Y),
+        'near4d_full_pool':near_stats(PX,PY),
+        'quantized4d_hq':{str(b):quantized_mixed(X,Y,b) for b in [10,20,50,100]},
+        'quantized4d_full_pool':{str(b):quantized_mixed(PX,PY,b) for b in [10,20,50,100]},
+    },
+    'per_query':perq,
+}
+out='/mnt/data/treccovid_collision_diagnostic.json'
+json.dump(result,open(out,'w'),indent=2)
+print(json.dumps(result['aggregate'],indent=2))
+print('saved',out)

experiments/beir/treccovid_hq_branch_exact_history.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+import sys,time,json,math,os
+import numpy as np
+sys.path.insert(0,'/mnt/data/work_code/geomretrieval_msmarco_scale_codebase/original_v0')
+from geomretrieval import GeometricIndex, load_beir_directory, evaluate_run
+
+IDX='/mnt/data/treccovid_geom_index'
+ROOT='/mnt/data/work_treccovid/trec-covid'
+idx=GeometricIndex.load(IDX); M=idx.vocab_size
+P=2000; GAMMA=.25; LAM_M=.125; PRE_B=.2; FINAL_B=.1; ALPHA=.25
+WLEX=4.0; WSEM=.3; WRARE=1.0; SEMK=16; EPS=1e-8
+
+
+def zscore(x):
+    x=np.asarray(x,np.float32)
+    if not len(x): return x
+    sd=float(x.std())
+    return np.zeros_like(x) if sd<1e-8 else (x-float(x.mean()))/sd
+
+def minmax_hi(x):
+    x=np.asarray(x,np.float32)
+    if not len(x): return x
+    mn=float(x.min()); mx=float(x.max()); den=mx-mn
+    return np.ones_like(x) if den<1e-8 else (x-mn)/den
+
+def topk_large(score,k):
+    n=len(score); k=min(k,n)
+    if k<=0:return np.empty(0,np.int64)
+    if n<=k:return np.argsort(score)[::-1]
+    ii=np.argpartition(score,-k)[-k:]
+    return ii[np.argsort(score[ii])[::-1]]
+
+def center_sparse(j):
+    t=idx.center_terms[j]; v=idx.center_values[j]; ok=t>=0
+    t=t[ok].astype(np.int32); v=v[ok].astype(np.float32)
+    n=float(np.linalg.norm(v))
+    if n>0:v=v/n
+    oo=np.argsort(t)
+    return t[oo],v[oo]
+
+def spdot(a_t,a_v,b_t,b_v):
+    i=j=0;s=0.0
+    while i<len(a_t) and j<len(b_t):
+        if a_t[i]==b_t[j]:s+=float(a_v[i])*float(b_v[j]);i+=1;j+=1
+        elif a_t[i]<b_t[j]:i+=1
+        else:j+=1
+    return s
+
+def prepare(text):
+    q=idx._query_vector(text)
+    if q.nnz==0:return None
+    qd=np.zeros(M,np.float32); qd[q.indices]=q.data
+    rt,rv,qt=idx._expanded_route(q)
+    if not len(rt):return None
+    rd=np.zeros(M,np.float32);rd[rt]=rv
+    pieces=[]
+    for j in rt:
+        a,b=idx.branch_offsets[j],idx.branch_offsets[j+1]
+        if b>a:pieces.append(idx.branch_order[a:b])
+    if not pieces:return None
+    fp=np.concatenate(pieces).astype(np.int64,copy=False)
+    docs=(fp//idx.config.F).astype(np.int64); slots=(fp%idx.config.F).astype(np.int64)
+    br=idx.branches[docs,slots]
+    terms=idx.res_terms[docs,slots];valid=terms>=0;safe=np.where(valid,terms,0);qv=qd[safe]
+    local=np.sum(idx.res_reliability[docs,slots].astype(np.float32)*(qv-idx.res_center_values[docs,slots])*idx.res_signs[docs,slots].astype(np.float32)*valid,axis=1)
+    sig=np.sum((qv*qv)*valid,axis=1)
+    cons=idx.memberships[docs,slots]*rd[br]
+    branch_ev=(cons*local*np.power(np.maximum(sig,0),GAMMA)).astype(np.float32)  # E_dj exactly
+    base=cons*local
+    ud,inv=np.unique(docs,return_inverse=True)
+    tail=np.bincount(inv,weights=branch_ev,minlength=len(ud)).astype(np.float32)
+    tail += LAM_M*np.bincount(inv,weights=cons,minlength=len(ud)).astype(np.float32)
+    # dominant routed branch retained for diagnostics
+    bestv=np.full(len(ud),-1e30,np.float32);db=np.full(len(ud),-1,np.int32)
+    for p,u in enumerate(inv):
+        if cons[p]>bestv[u]:bestv[u]=cons[p];db[u]=int(br[p])
+    # frozen early lexical rescue
+    qlex=np.zeros(M,np.float32);qlex[q.indices]=idx.idf[q.indices]
+    lex1=np.zeros(len(ud),np.float32)
+    for i,d in enumerate(ud):
+        a,b=idx.support_indptr[d],idx.support_indptr[d+1];sup=idx.support_indices[a:b]
+        raw=float(qlex[sup].sum());den=(1-PRE_B)+PRE_B*(float(idx.doc_lengths[d])/idx.avg_doc_length)
+        lex1[i]=raw/(den if den>0 else 1.)
+    pre=zscore(tail)+zscore(lex1)
+    sel=topk_large(pre,P)
+    dd=ud[sel];ts=tail[sel];db=db[sel]
+    # mapping routed-doc local index -> pool local index
+    poolpos=np.full(len(ud),-1,np.int32); poolpos[sel]=np.arange(len(sel),dtype=np.int32)
+    mp=poolpos[inv]
+    keep=mp>=0
+    mem_pool=mp[keep].astype(np.int32)
+    mem_br=br[keep].astype(np.int32)
+    mem_ev=branch_ev[keep].astype(np.float32)
+    # final current features
+    semvec=np.zeros(M,np.float32)
+    for t,amp in zip(q.indices,q.data):
+        a,b=idx.A.indptr[t],idx.A.indptr[t+1];nb=idx.A.indices[a:b][:SEMK];sv=idx.A.data[a:b][:SEMK]
+        if len(nb):semvec[nb]+=float(amp)*sv*idx.idf[nb]
+    qset=set(map(int,q.indices));rare=set(map(int,q.indices[np.argsort(idx.idf[q.indices])[::-1]][:3]));nq=max(1,len(q.indices))
+    lx=np.zeros(len(dd),np.float32);sm=np.zeros(len(dd),np.float32);qc=np.zeros(len(dd),np.float32);r3=np.zeros(len(dd),np.float32)
+    for i,d in enumerate(dd):
+        a,b=idx.support_indptr[d],idx.support_indptr[d+1];sup=idx.support_indices[a:b]
+        sm[i]=float(semvec[sup].sum())
+        match=[int(t) for t in sup if int(t) in qset]
+        raw=sum(float(idx.idf[t])**2 for t in match);den=(1-FINAL_B)+FINAL_B*(float(idx.doc_lengths[d])/idx.avg_doc_length)
+        lx[i]=raw/(den if den>0 else 1.);qc[i]=len(match);r3[i]=sum(t in rare for t in match)
+    cov=qc/nq;ladj=lx*np.power(np.maximum(cov,1e-6),ALPHA);rarecov=r3/max(1,min(3,nq))
+    base_score=zscore(ts)+WLEX*zscore(ladj)+WSEM*zscore(sm)+WRARE*zscore(rarecov)
+
+    # Build H_j = mean of top 3 E_dj among selected pool documents for branch j.
+    # Multiple memberships of same doc+branch should not occur; if they do, keep max.
+    branch_pairs={}
+    for pi,b,e in zip(mem_pool,mem_br,mem_ev):
+        key=(int(b),int(pi))
+        if key not in branch_pairs or e>branch_pairs[key]: branch_pairs[key]=float(e)
+    byb={}
+    for (b,pi),e in branch_pairs.items(): byb.setdefault(b,[]).append((e,pi))
+    H={}; bestdoc={}; docs_by_branch={}
+    for b,vals in byb.items():
+        vals.sort(key=lambda x:x[0],reverse=True)
+        top=vals[:3]
+        H[b]=float(np.mean([e for e,_ in top]))
+        bestdoc[b]=int(max(vals,key=lambda x: float(base_score[x[1]]))[1])  # best final-relevance doc in branch
+        docs_by_branch[b]=np.asarray([pi for _,pi in vals],dtype=np.int32)
+    ub=np.asarray(sorted(H.keys()),dtype=np.int32)
+    h=np.asarray([H[int(b)] for b in ub],dtype=np.float32)
+    hnorm=minmax_hi(h)
+    bmap={int(b):i for i,b in enumerate(ub)}
+    reps=[center_sparse(int(b)) for b in ub]
+    C=np.eye(len(ub),dtype=np.float32)
+    for i in range(len(ub)):
+        for j in range(i+1,len(ub)):
+            C[i,j]=C[j,i]=spdot(*reps[i],*reps[j])
+    return {'docs':dd,'base':base_score,'tail':ts,'lex':ladj,'sem':sm,'rare':rarecov,
+            'route_docs':ud,'branches_dom':db,'ub':ub,'H':h,'Hn':hnorm,'bmap':bmap,'cos':C,
+            'bestdoc':bestdoc,'docs_by_branch':docs_by_branch}
+
+def plain(p,k=100):
+    oo=np.argsort(p['base'])[::-1][:k]
+    return p['docs'][oo].tolist()
+
+def Dvec(p, selected_bidx):
+    C=p['cos']
+    if not selected_bidx:return np.zeros(len(C),np.float32)
+    si=np.asarray(selected_bidx,np.int32)
+    mumun=float(np.mean(C[np.ix_(si,si)]))
+    return 1.0+mumun-2.0*np.mean(C[:,si],axis=1)
+
+def select_hq_branches(p, topN=20, lam=1.0, nsel=10, pure_div=False):
+    if len(p['ub'])==0:return []
+    # eligible branches are the top-N robust-quality H_j branches
+    order=np.argsort(p['H'])[::-1]
+    elig=order[:min(topN,len(order))]
+    # first branch = highest H_j
+    selected=[int(elig[0])]
+    remaining=set(map(int,elig[1:]))
+    while remaining and len(selected)<min(nsel,len(elig)):
+        rem=np.asarray(sorted(remaining),dtype=np.int32)
+        D=Dvec(p,selected)
+        dnorm=minmax_hi(D[rem])
+        if pure_div:
+            val=dnorm
+        else:
+            h=p['Hn'][rem]
+            val=h+float(lam)*dnorm
+        pick=int(rem[int(np.argmax(val))])
+        selected.append(pick); remaining.remove(pick)
+    return selected
+
+def rank_hq_oneper(p,topN=20,lam=1.0,pure_div=False,k=100):
+    # one best final-score document from each selected high-quality/diverse branch for top 10
+    sb=select_hq_branches(p,topN,lam,10,pure_div)
+    chosen=[]; used=set()
+    for bi in sb:
+        b=int(p['ub'][bi]); pi=int(p['bestdoc'][b])
+        if pi not in used: chosen.append(pi); used.add(pi)
+    # if fewer than 10, fill by ordinary score
+    for pi in np.argsort(p['base'])[::-1]:
+        pi=int(pi)
+        if len(chosen)>=10:break
+        if pi not in used: chosen.append(pi);used.add(pi)
+    # rest by ordinary score
+    for pi in np.argsort(p['base'])[::-1]:
+        pi=int(pi)
+        if len(chosen)>=k:break
+        if pi not in used: chosen.append(pi);used.add(pi)
+    return p['docs'][np.asarray(chosen[:k],dtype=np.int64)].tolist()
+
+def rank_hq_softdoc(p,topN=20,lam=.25,k=100):
+    # restrict diversity bonus to high-quality branches; repeated branches allowed.
+    # docs outside HQ set retain pure relevance and are still eligible.
+    base=p['base']; n=len(base); order=np.argsort(base)[::-1]
+    first=int(order[0]); chosen=[first]; used={first}
+    elig_order=np.argsort(p['H'])[::-1][:min(topN,len(p['H']))]
+    eligset=set(map(int,elig_order))
+    # branch memberships for each pool doc: use all high-quality branches the doc belongs to
+    doc_hq=[[] for _ in range(n)]
+    for bi in elig_order:
+        b=int(p['ub'][bi])
+        for pi in p['docs_by_branch'][b]: doc_hq[int(pi)].append(int(bi))
+    # selected branch representation starts with highest-quality HQ branch supporting first, if any
+    selected=[]
+    if doc_hq[first]:
+        selected=[max(doc_hq[first], key=lambda bi: float(p['H'][bi]))]
+    for _ in range(1,min(10,k,n)):
+        rem=np.asarray([i for i in range(n) if i not in used],dtype=np.int32)
+        if not len(rem):break
+        D=Dvec(p,selected) if selected else np.zeros(len(p['ub']),np.float32)
+        # normalize only across eligible branches
+        if len(elig_order):
+            ed=minmax_hi(D[elig_order]); dn={int(bi):float(v) for bi,v in zip(elig_order,ed)}
+        else: dn={}
+        # relevance minmax across remaining top pool; high = good
+        rn=minmax_hi(base[rem])
+        bonus=np.zeros(len(rem),np.float32)
+        for k2,pi in enumerate(rem):
+            if doc_hq[int(pi)]: bonus[k2]=max(dn.get(bi,0.0) for bi in doc_hq[int(pi)])
+        val=rn+float(lam)*bonus
+        pi=int(rem[int(np.argmax(val))]); chosen.append(pi); used.add(pi)
+        if doc_hq[pi]:
+            # add the supporting HQ branch with max diversity, ties quality
+            bi=max(doc_hq[pi],key=lambda x:(dn.get(x,0.0),float(p['H'][x])))
+            selected.append(int(bi))
+    for pi in order:
+        pi=int(pi)
+        if len(chosen)>=k:break
+        if pi not in used:chosen.append(pi);used.add(pi)
+    return p['docs'][np.asarray(chosen[:k],dtype=np.int64)].tolist()
+
+def evaluate(ds,packs,ranker,**kw):
+    run={};route_num=pool_num=den=0;cands=[]
+    for qid,p in packs.items():
+        rr=[] if p is None else ranker(p,**kw)
+        run[str(qid)]=[str(idx.doc_ids[int(d)]) for d in rr]
+        if p is not None:
+            route={str(idx.doc_ids[int(d)]) for d in p['route_docs']};pool={str(idx.doc_ids[int(d)]) for d in p['docs']}
+            pos={str(d) for d,v in ds.qrels[qid].items() if v>0};den+=len(pos);route_num+=sum(d in route for d in pos);pool_num+=sum(d in pool for d in pos);cands.append(len(route))
+    m=evaluate_run(run,ds.qrels,ks=(10,100),ndcg_k=10,mrr_k=10,exp_gain=False)
+    m['route_recall_micro']=route_num/max(1,den);m['pool_recall_micro']=pool_num/max(1,den);m['avg_candidates']=float(np.mean(cands)) if cands else 0
+    return m
+
+ds=load_beir_directory(ROOT,'test')
+packs={};times=[]
+for i,qid in enumerate(ds.qrels):
+    t=time.perf_counter();packs[qid]=prepare(ds.queries[qid]);times.append((time.perf_counter()-t)*1000)
+    if (i+1)%10==0:print('prepared',i+1,'/',len(ds.qrels),flush=True)
+res={'dataset':'TREC-COVID','timing':{'prepare_median_ms':float(np.median(times)),'prepare_p95_ms':float(np.percentile(times,95))},'variants':{}}
+res['variants']['current_z']=evaluate(ds,packs,plain)
+print('current_z',res['variants']['current_z'],flush=True)
+# high-quality branch diagnostics
+for topN in [10,20,30,50]:
+    for pure in [True,False]:
+        if pure:
+            name=f'hq{topN}_purediv_oneper'; kw={'topN':topN,'lam':1.0,'pure_div':True}
+            m=evaluate(ds,packs,rank_hq_oneper,**kw);res['variants'][name]=m;print(name,m,flush=True)
+        else:
+            for lam in [0.1,0.25,0.5,1.0]:
+                name=f'hq{topN}_qplusdiv_l{lam:g}_oneper';kw={'topN':topN,'lam':lam,'pure_div':False}
+                m=evaluate(ds,packs,rank_hq_oneper,**kw);res['variants'][name]=m;print(name,m,flush=True)
+# soft doc selection, diversity bonus only from HQ branches
+for topN in [10,20,30,50]:
+    for lam in [0.05,0.1,0.25,0.5,1.0]:
+        name=f'hq{topN}_softdoc_l{lam:g}'
+        m=evaluate(ds,packs,rank_hq_softdoc,topN=topN,lam=lam);res['variants'][name]=m;print(name,m,flush=True)
+
+out='/mnt/data/treccovid_hq_branch_results.json'
+json.dump(res,open(out,'w'),indent=2)
+print('saved',out,flush=True)

experiments/beir/treccovid_idf_power_exact_history.py

@@ -0,0 +1,261 @@
+from __future__ import annotations
+import sys,time,json,math,os
+import numpy as np
+sys.path.insert(0,'/mnt/data/work_code/geomretrieval_msmarco_scale_codebase/original_v0')
+from geomretrieval import GeometricIndex, load_beir_directory, evaluate_run
+
+IDX='/mnt/data/treccovid_geom_index'
+ROOT='/mnt/data/work_treccovid/trec-covid'
+idx=GeometricIndex.load(IDX); M=idx.vocab_size
+P=2000; GAMMA=.25; LAM_M=.125; PRE_B=.2; FINAL_B=.1; ALPHA=.25
+WLEX=4.0; WSEM=.3; WRARE=1.0; SEMK=16; EPS=1e-8
+IDF_POWER=2
+
+
+def zscore(x):
+    x=np.asarray(x,np.float32)
+    if not len(x): return x
+    sd=float(x.std())
+    return np.zeros_like(x) if sd<1e-8 else (x-float(x.mean()))/sd
+
+def minmax_hi(x):
+    x=np.asarray(x,np.float32)
+    if not len(x): return x
+    mn=float(x.min()); mx=float(x.max()); den=mx-mn
+    return np.ones_like(x) if den<1e-8 else (x-mn)/den
+
+def topk_large(score,k):
+    n=len(score); k=min(k,n)
+    if k<=0:return np.empty(0,np.int64)
+    if n<=k:return np.argsort(score)[::-1]
+    ii=np.argpartition(score,-k)[-k:]
+    return ii[np.argsort(score[ii])[::-1]]
+
+def center_sparse(j):
+    t=idx.center_terms[j]; v=idx.center_values[j]; ok=t>=0
+    t=t[ok].astype(np.int32); v=v[ok].astype(np.float32)
+    n=float(np.linalg.norm(v))
+    if n>0:v=v/n
+    oo=np.argsort(t)
+    return t[oo],v[oo]
+
+def spdot(a_t,a_v,b_t,b_v):
+    i=j=0;s=0.0
+    while i<len(a_t) and j<len(b_t):
+        if a_t[i]==b_t[j]:s+=float(a_v[i])*float(b_v[j]);i+=1;j+=1
+        elif a_t[i]<b_t[j]:i+=1
+        else:j+=1
+    return s
+
+def prepare(text):
+    q=idx._query_vector(text)
+    if q.nnz==0:return None
+    qd=np.zeros(M,np.float32); qd[q.indices]=q.data
+    rt,rv,qt=idx._expanded_route(q)
+    if not len(rt):return None
+    rd=np.zeros(M,np.float32);rd[rt]=rv
+    pieces=[]
+    for j in rt:
+        a,b=idx.branch_offsets[j],idx.branch_offsets[j+1]
+        if b>a:pieces.append(idx.branch_order[a:b])
+    if not pieces:return None
+    fp=np.concatenate(pieces).astype(np.int64,copy=False)
+    docs=(fp//idx.config.F).astype(np.int64); slots=(fp%idx.config.F).astype(np.int64)
+    br=idx.branches[docs,slots]
+    terms=idx.res_terms[docs,slots];valid=terms>=0;safe=np.where(valid,terms,0);qv=qd[safe]
+    local=np.sum(idx.res_reliability[docs,slots].astype(np.float32)*(qv-idx.res_center_values[docs,slots])*idx.res_signs[docs,slots].astype(np.float32)*valid,axis=1)
+    sig=np.sum((qv*qv)*valid,axis=1)
+    cons=idx.memberships[docs,slots]*rd[br]
+    branch_ev=(cons*local*np.power(np.maximum(sig,0),GAMMA)).astype(np.float32)  # E_dj exactly
+    base=cons*local
+    ud,inv=np.unique(docs,return_inverse=True)
+    tail=np.bincount(inv,weights=branch_ev,minlength=len(ud)).astype(np.float32)
+    tail += LAM_M*np.bincount(inv,weights=cons,minlength=len(ud)).astype(np.float32)
+    # dominant routed branch retained for diagnostics
+    bestv=np.full(len(ud),-1e30,np.float32);db=np.full(len(ud),-1,np.int32)
+    for p,u in enumerate(inv):
+        if cons[p]>bestv[u]:bestv[u]=cons[p];db[u]=int(br[p])
+    # frozen early lexical rescue
+    qlex=np.zeros(M,np.float32);qlex[q.indices]=idx.idf[q.indices]
+    lex1=np.zeros(len(ud),np.float32)
+    for i,d in enumerate(ud):
+        a,b=idx.support_indptr[d],idx.support_indptr[d+1];sup=idx.support_indices[a:b]
+        raw=float(qlex[sup].sum());den=(1-PRE_B)+PRE_B*(float(idx.doc_lengths[d])/idx.avg_doc_length)
+        lex1[i]=raw/(den if den>0 else 1.)
+    pre=zscore(tail)+zscore(lex1)
+    sel=topk_large(pre,P)
+    dd=ud[sel];ts=tail[sel];db=db[sel]
+    # mapping routed-doc local index -> pool local index
+    poolpos=np.full(len(ud),-1,np.int32); poolpos[sel]=np.arange(len(sel),dtype=np.int32)
+    mp=poolpos[inv]
+    keep=mp>=0
+    mem_pool=mp[keep].astype(np.int32)
+    mem_br=br[keep].astype(np.int32)
+    mem_ev=branch_ev[keep].astype(np.float32)
+    # final current features
+    semvec=np.zeros(M,np.float32)
+    for t,amp in zip(q.indices,q.data):
+        a,b=idx.A.indptr[t],idx.A.indptr[t+1];nb=idx.A.indices[a:b][:SEMK];sv=idx.A.data[a:b][:SEMK]
+        if len(nb):semvec[nb]+=float(amp)*sv*idx.idf[nb]
+    qset=set(map(int,q.indices));rare=set(map(int,q.indices[np.argsort(idx.idf[q.indices])[::-1]][:3]));nq=max(1,len(q.indices))
+    lx=np.zeros(len(dd),np.float32);sm=np.zeros(len(dd),np.float32);qc=np.zeros(len(dd),np.float32);r3=np.zeros(len(dd),np.float32)
+    for i,d in enumerate(dd):
+        a,b=idx.support_indptr[d],idx.support_indptr[d+1];sup=idx.support_indices[a:b]
+        sm[i]=float(semvec[sup].sum())
+        match=[int(t) for t in sup if int(t) in qset]
+        raw=sum(float(idx.idf[t])**IDF_POWER for t in match);den=(1-FINAL_B)+FINAL_B*(float(idx.doc_lengths[d])/idx.avg_doc_length)
+        lx[i]=raw/(den if den>0 else 1.);qc[i]=len(match);r3[i]=sum(t in rare for t in match)
+    cov=qc/nq;ladj=lx*np.power(np.maximum(cov,1e-6),ALPHA);rarecov=r3/max(1,min(3,nq))
+    base_score=zscore(ts)+WLEX*zscore(ladj)+WSEM*zscore(sm)+WRARE*zscore(rarecov)
+
+    # Build H_j = mean of top 3 E_dj among selected pool documents for branch j.
+    # Multiple memberships of same doc+branch should not occur; if they do, keep max.
+    branch_pairs={}
+    for pi,b,e in zip(mem_pool,mem_br,mem_ev):
+        key=(int(b),int(pi))
+        if key not in branch_pairs or e>branch_pairs[key]: branch_pairs[key]=float(e)
+    byb={}
+    for (b,pi),e in branch_pairs.items(): byb.setdefault(b,[]).append((e,pi))
+    H={}; bestdoc={}; docs_by_branch={}
+    for b,vals in byb.items():
+        vals.sort(key=lambda x:x[0],reverse=True)
+        top=vals[:3]
+        H[b]=float(np.mean([e for e,_ in top]))
+        bestdoc[b]=int(max(vals,key=lambda x: float(base_score[x[1]]))[1])  # best final-relevance doc in branch
+        docs_by_branch[b]=np.asarray([pi for _,pi in vals],dtype=np.int32)
+    ub=np.asarray(sorted(H.keys()),dtype=np.int32)
+    h=np.asarray([H[int(b)] for b in ub],dtype=np.float32)
+    hnorm=minmax_hi(h)
+    bmap={int(b):i for i,b in enumerate(ub)}
+    reps=[center_sparse(int(b)) for b in ub]
+    C=np.eye(len(ub),dtype=np.float32)
+    for i in range(len(ub)):
+        for j in range(i+1,len(ub)):
+            C[i,j]=C[j,i]=spdot(*reps[i],*reps[j])
+    return {'docs':dd,'base':base_score,'tail':ts,'lex':ladj,'sem':sm,'rare':rarecov,
+            'route_docs':ud,'branches_dom':db,'ub':ub,'H':h,'Hn':hnorm,'bmap':bmap,'cos':C,
+            'bestdoc':bestdoc,'docs_by_branch':docs_by_branch}
+
+def plain(p,k=100):
+    oo=np.argsort(p['base'])[::-1][:k]
+    return p['docs'][oo].tolist()
+
+def Dvec(p, selected_bidx):
+    C=p['cos']
+    if not selected_bidx:return np.zeros(len(C),np.float32)
+    si=np.asarray(selected_bidx,np.int32)
+    mumun=float(np.mean(C[np.ix_(si,si)]))
+    return 1.0+mumun-2.0*np.mean(C[:,si],axis=1)
+
+def select_hq_branches(p, topN=20, lam=1.0, nsel=10, pure_div=False):
+    if len(p['ub'])==0:return []
+    # eligible branches are the top-N robust-quality H_j branches
+    order=np.argsort(p['H'])[::-1]
+    elig=order[:min(topN,len(order))]
+    # first branch = highest H_j
+    selected=[int(elig[0])]
+    remaining=set(map(int,elig[1:]))
+    while remaining and len(selected)<min(nsel,len(elig)):
+        rem=np.asarray(sorted(remaining),dtype=np.int32)
+        D=Dvec(p,selected)
+        dnorm=minmax_hi(D[rem])
+        if pure_div:
+            val=dnorm
+        else:
+            h=p['Hn'][rem]
+            val=h+float(lam)*dnorm
+        pick=int(rem[int(np.argmax(val))])
+        selected.append(pick); remaining.remove(pick)
+    return selected
+
+def rank_hq_oneper(p,topN=20,lam=1.0,pure_div=False,k=100):
+    # one best final-score document from each selected high-quality/diverse branch for top 10
+    sb=select_hq_branches(p,topN,lam,10,pure_div)
+    chosen=[]; used=set()
+    for bi in sb:
+        b=int(p['ub'][bi]); pi=int(p['bestdoc'][b])
+        if pi not in used: chosen.append(pi); used.add(pi)
+    # if fewer than 10, fill by ordinary score
+    for pi in np.argsort(p['base'])[::-1]:
+        pi=int(pi)
+        if len(chosen)>=10:break
+        if pi not in used: chosen.append(pi);used.add(pi)
+    # rest by ordinary score
+    for pi in np.argsort(p['base'])[::-1]:
+        pi=int(pi)
+        if len(chosen)>=k:break
+        if pi not in used: chosen.append(pi);used.add(pi)
+    return p['docs'][np.asarray(chosen[:k],dtype=np.int64)].tolist()
+
+def rank_hq_softdoc(p,topN=20,lam=.25,k=100):
+    # restrict diversity bonus to high-quality branches; repeated branches allowed.
+    # docs outside HQ set retain pure relevance and are still eligible.
+    base=p['base']; n=len(base); order=np.argsort(base)[::-1]
+    first=int(order[0]); chosen=[first]; used={first}
+    elig_order=np.argsort(p['H'])[::-1][:min(topN,len(p['H']))]
+    eligset=set(map(int,elig_order))
+    # branch memberships for each pool doc: use all high-quality branches the doc belongs to
+    doc_hq=[[] for _ in range(n)]
+    for bi in elig_order:
+        b=int(p['ub'][bi])
+        for pi in p['docs_by_branch'][b]: doc_hq[int(pi)].append(int(bi))
+    # selected branch representation starts with highest-quality HQ branch supporting first, if any
+    selected=[]
+    if doc_hq[first]:
+        selected=[max(doc_hq[first], key=lambda bi: float(p['H'][bi]))]
+    for _ in range(1,min(10,k,n)):
+        rem=np.asarray([i for i in range(n) if i not in used],dtype=np.int32)
+        if not len(rem):break
+        D=Dvec(p,selected) if selected else np.zeros(len(p['ub']),np.float32)
+        # normalize only across eligible branches
+        if len(elig_order):
+            ed=minmax_hi(D[elig_order]); dn={int(bi):float(v) for bi,v in zip(elig_order,ed)}
+        else: dn={}
+        # relevance minmax across remaining top pool; high = good
+        rn=minmax_hi(base[rem])
+        bonus=np.zeros(len(rem),np.float32)
+        for k2,pi in enumerate(rem):
+            if doc_hq[int(pi)]: bonus[k2]=max(dn.get(bi,0.0) for bi in doc_hq[int(pi)])
+        val=rn+float(lam)*bonus
+        pi=int(rem[int(np.argmax(val))]); chosen.append(pi); used.add(pi)
+        if doc_hq[pi]:
+            # add the supporting HQ branch with max diversity, ties quality
+            bi=max(doc_hq[pi],key=lambda x:(dn.get(x,0.0),float(p['H'][x])))
+            selected.append(int(bi))
+    for pi in order:
+        pi=int(pi)
+        if len(chosen)>=k:break
+        if pi not in used:chosen.append(pi);used.add(pi)
+    return p['docs'][np.asarray(chosen[:k],dtype=np.int64)].tolist()
+
+def evaluate(ds,packs,ranker,**kw):
+    run={};route_num=pool_num=den=0;cands=[]
+    for qid,p in packs.items():
+        rr=[] if p is None else ranker(p,**kw)
+        run[str(qid)]=[str(idx.doc_ids[int(d)]) for d in rr]
+        if p is not None:
+            route={str(idx.doc_ids[int(d)]) for d in p['route_docs']};pool={str(idx.doc_ids[int(d)]) for d in p['docs']}
+            pos={str(d) for d,v in ds.qrels[qid].items() if v>0};den+=len(pos);route_num+=sum(d in route for d in pos);pool_num+=sum(d in pool for d in pos);cands.append(len(route))
+    m=evaluate_run(run,ds.qrels,ks=(10,100),ndcg_k=10,mrr_k=10,exp_gain=False)
+    m['route_recall_micro']=route_num/max(1,den);m['pool_recall_micro']=pool_num/max(1,den);m['avg_candidates']=float(np.mean(cands)) if cands else 0
+    return m
+
+
+ds=load_beir_directory(ROOT,'test')
+allres={'dataset':'TREC-COVID','experiment':'Final whole-document binary lexical IDF power; all else fixed','variants':{}}
+for power in [2,3,4]:
+    IDF_POWER=power
+    packs={};times=[]
+    for i,qid in enumerate(ds.qrels):
+        t=time.perf_counter(); packs[qid]=prepare(ds.queries[qid]); times.append((time.perf_counter()-t)*1000)
+    plain_m=evaluate(ds,packs,plain)
+    hq_m=evaluate(ds,packs,rank_hq_softdoc,topN=10,lam=.1)
+    allres['variants'][f'idf{power}_plain']=plain_m
+    allres['variants'][f'idf{power}_hqdiv']=hq_m
+    allres.setdefault('timing',{})[f'idf{power}_prepare_median_ms']=float(np.median(times))
+    allres['timing'][f'idf{power}_prepare_p95_ms']=float(np.percentile(times,95))
+    print('POWER',power,'PLAIN',plain_m,flush=True)
+    print('POWER',power,'HQDIV',hq_m,flush=True)
+out='/mnt/data/treccovid_idf_power_2_3_4.json'
+json.dump(allres,open(out,'w'),indent=2)
+print('saved',out,flush=True)

experiments/beir/treccovid_local_baselines_exact_history.py

@@ -0,0 +1,40 @@
+import sys,time,json,math
+import numpy as np
+from scipy import sparse
+from sklearn.feature_extraction.text import CountVectorizer
+sys.path.insert(0,'/mnt/data/work_code/geomretrieval_msmarco_scale_codebase/original_v0')
+from geomretrieval import GeometricIndex, load_beir_directory, evaluate_run
+ROOT='/mnt/data/work_treccovid/trec-covid'; IDX='/mnt/data/treccovid_geom_index'
+ds=load_beir_directory(ROOT,'test'); idx=GeometricIndex.load(IDX)
+# Exact TF-IDF cosine
+run={}; times=[]
+for qid in ds.qrels:
+    q=idx._query_vector(ds.queries[qid])
+    t=time.perf_counter(); s=np.asarray(idx.X @ q.T).ravel(); times.append((time.perf_counter()-t)*1000)
+    k=min(100,len(s)); ii=np.argpartition(s,-k)[-k:]; ii=ii[np.argsort(s[ii])[::-1]]
+    run[str(qid)]=[str(idx.doc_ids[int(i)]) for i in ii]
+mtf=evaluate_run(run,ds.qrels,ks=(10,100),ndcg_k=10,mrr_k=10,exp_gain=False)
+mtf['median_ms']=float(np.median(times)); mtf['p95_ms']=float(np.percentile(times,95))
+print('TFIDF',mtf,flush=True)
+# Count matrix with frozen vocabulary/tokenizer
+vec=CountVectorizer(vocabulary=idx.vectorizer.vocabulary_,lowercase=idx.config.lowercase,token_pattern=idx.config.token_pattern,dtype=np.float32)
+t=time.perf_counter(); C=vec.transform(ds.corpus_texts).tocsr(); build=time.perf_counter()-t
+length=np.asarray(C.sum(axis=1)).ravel().astype(np.float32); avdl=float(length.mean()); Cc=C.tocsc(); N=C.shape[0]
+df=np.diff(Cc.indptr).astype(np.float64); idf=np.log((N-df+0.5)/(df+0.5)+1.0).astype(np.float32)
+k1=.9;b=.4
+run={};times=[]
+for qid in ds.qrels:
+    q=vec.transform([ds.queries[qid]]).tocsr(); terms=q.indices
+    t=time.perf_counter(); score=np.zeros(N,np.float32)
+    for term in terms:
+        a,bb=Cc.indptr[term],Cc.indptr[term+1]; docs=Cc.indices[a:bb]; tf=Cc.data[a:bb]
+        den=tf+k1*(1-b+b*length[docs]/avdl)
+        score[docs]+=idf[term]*(tf*(k1+1)/den)
+    times.append((time.perf_counter()-t)*1000)
+    k=min(100,N);ii=np.argpartition(score,-k)[-k:];ii=ii[np.argsort(score[ii])[::-1]]
+    run[str(qid)]=[str(idx.doc_ids[int(i)]) for i in ii]
+mb=evaluate_run(run,ds.qrels,ks=(10,100),ndcg_k=10,mrr_k=10,exp_gain=False)
+mb['median_ms_effectiveness_impl']=float(np.median(times));mb['p95_ms_effectiveness_impl']=float(np.percentile(times,95));mb['count_build_s']=build
+print('BM25',mb,flush=True)
+out={'tfidf':mtf,'bm25':mb}
+json.dump(out,open('/mnt/data/treccovid_local_baselines.json','w'),indent=2)

experiments/beir/treccovid_pool_sweep_exact_history.py

@@ -0,0 +1,265 @@
+from __future__ import annotations
+import sys,time,json,math,os
+import numpy as np
+sys.path.insert(0,'/mnt/data/work_code/geomretrieval_msmarco_scale_codebase/original_v0')
+from geomretrieval import GeometricIndex, load_beir_directory, evaluate_run
+
+IDX='/mnt/data/treccovid_geom_index'
+ROOT='/mnt/data/work_treccovid/trec-covid'
+idx=GeometricIndex.load(IDX); M=idx.vocab_size
+P=int(os.environ.get("POOL_P","100")); GAMMA=.25; LAM_M=.125; PRE_B=.2; FINAL_B=.1; ALPHA=.25
+WLEX=4.0; WSEM=.3; WRARE=1.0; SEMK=16; EPS=1e-8
+
+
+def zscore(x):
+    x=np.asarray(x,np.float32)
+    if not len(x): return x
+    sd=float(x.std())
+    return np.zeros_like(x) if sd<1e-8 else (x-float(x.mean()))/sd
+
+def minmax_hi(x):
+    x=np.asarray(x,np.float32)
+    if not len(x): return x
+    mn=float(x.min()); mx=float(x.max()); den=mx-mn
+    return np.ones_like(x) if den<1e-8 else (x-mn)/den
+
+def topk_large(score,k):
+    n=len(score); k=min(k,n)
+    if k<=0:return np.empty(0,np.int64)
+    if n<=k:return np.argsort(score)[::-1]
+    ii=np.argpartition(score,-k)[-k:]
+    return ii[np.argsort(score[ii])[::-1]]
+
+def center_sparse(j):
+    t=idx.center_terms[j]; v=idx.center_values[j]; ok=t>=0
+    t=t[ok].astype(np.int32); v=v[ok].astype(np.float32)
+    n=float(np.linalg.norm(v))
+    if n>0:v=v/n
+    oo=np.argsort(t)
+    return t[oo],v[oo]
+
+def spdot(a_t,a_v,b_t,b_v):
+    i=j=0;s=0.0
+    while i<len(a_t) and j<len(b_t):
+        if a_t[i]==b_t[j]:s+=float(a_v[i])*float(b_v[j]);i+=1;j+=1
+        elif a_t[i]<b_t[j]:i+=1
+        else:j+=1
+    return s
+
+def prepare(text):
+    q=idx._query_vector(text)
+    if q.nnz==0:return None
+    qd=np.zeros(M,np.float32); qd[q.indices]=q.data
+    rt,rv,qt=idx._expanded_route(q)
+    if not len(rt):return None
+    rd=np.zeros(M,np.float32);rd[rt]=rv
+    pieces=[]
+    for j in rt:
+        a,b=idx.branch_offsets[j],idx.branch_offsets[j+1]
+        if b>a:pieces.append(idx.branch_order[a:b])
+    if not pieces:return None
+    fp=np.concatenate(pieces).astype(np.int64,copy=False)
+    docs=(fp//idx.config.F).astype(np.int64); slots=(fp%idx.config.F).astype(np.int64)
+    br=idx.branches[docs,slots]
+    terms=idx.res_terms[docs,slots];valid=terms>=0;safe=np.where(valid,terms,0);qv=qd[safe]
+    local=np.sum(idx.res_reliability[docs,slots].astype(np.float32)*(qv-idx.res_center_values[docs,slots])*idx.res_signs[docs,slots].astype(np.float32)*valid,axis=1)
+    sig=np.sum((qv*qv)*valid,axis=1)
+    cons=idx.memberships[docs,slots]*rd[br]
+    branch_ev=(cons*local*np.power(np.maximum(sig,0),GAMMA)).astype(np.float32)  # E_dj exactly
+    base=cons*local
+    ud,inv=np.unique(docs,return_inverse=True)
+    tail=np.bincount(inv,weights=branch_ev,minlength=len(ud)).astype(np.float32)
+    tail += LAM_M*np.bincount(inv,weights=cons,minlength=len(ud)).astype(np.float32)
+    # dominant routed branch retained for diagnostics
+    bestv=np.full(len(ud),-1e30,np.float32);db=np.full(len(ud),-1,np.int32)
+    for p,u in enumerate(inv):
+        if cons[p]>bestv[u]:bestv[u]=cons[p];db[u]=int(br[p])
+    # frozen early lexical rescue
+    qlex=np.zeros(M,np.float32);qlex[q.indices]=idx.idf[q.indices]
+    lex1=np.zeros(len(ud),np.float32)
+    for i,d in enumerate(ud):
+        a,b=idx.support_indptr[d],idx.support_indptr[d+1];sup=idx.support_indices[a:b]
+        raw=float(qlex[sup].sum());den=(1-PRE_B)+PRE_B*(float(idx.doc_lengths[d])/idx.avg_doc_length)
+        lex1[i]=raw/(den if den>0 else 1.)
+    pre=zscore(tail)+zscore(lex1)
+    sel=topk_large(pre,P)
+    dd=ud[sel];ts=tail[sel];db=db[sel]
+    # mapping routed-doc local index -> pool local index
+    poolpos=np.full(len(ud),-1,np.int32); poolpos[sel]=np.arange(len(sel),dtype=np.int32)
+    mp=poolpos[inv]
+    keep=mp>=0
+    mem_pool=mp[keep].astype(np.int32)
+    mem_br=br[keep].astype(np.int32)
+    mem_ev=branch_ev[keep].astype(np.float32)
+    # final current features
+    semvec=np.zeros(M,np.float32)
+    for t,amp in zip(q.indices,q.data):
+        a,b=idx.A.indptr[t],idx.A.indptr[t+1];nb=idx.A.indices[a:b][:SEMK];sv=idx.A.data[a:b][:SEMK]
+        if len(nb):semvec[nb]+=float(amp)*sv*idx.idf[nb]
+    qset=set(map(int,q.indices));rare=set(map(int,q.indices[np.argsort(idx.idf[q.indices])[::-1]][:3]));nq=max(1,len(q.indices))
+    lx=np.zeros(len(dd),np.float32);sm=np.zeros(len(dd),np.float32);qc=np.zeros(len(dd),np.float32);r3=np.zeros(len(dd),np.float32)
+    for i,d in enumerate(dd):
+        a,b=idx.support_indptr[d],idx.support_indptr[d+1];sup=idx.support_indices[a:b]
+        sm[i]=float(semvec[sup].sum())
+        match=[int(t) for t in sup if int(t) in qset]
+        raw=sum(float(idx.idf[t])**2 for t in match);den=(1-FINAL_B)+FINAL_B*(float(idx.doc_lengths[d])/idx.avg_doc_length)
+        lx[i]=raw/(den if den>0 else 1.);qc[i]=len(match);r3[i]=sum(t in rare for t in match)
+    cov=qc/nq;ladj=lx*np.power(np.maximum(cov,1e-6),ALPHA);rarecov=r3/max(1,min(3,nq))
+    base_score=zscore(ts)+WLEX*zscore(ladj)+WSEM*zscore(sm)+WRARE*zscore(rarecov)
+
+    # Build H_j = mean of top 3 E_dj among selected pool documents for branch j.
+    # Multiple memberships of same doc+branch should not occur; if they do, keep max.
+    branch_pairs={}
+    for pi,b,e in zip(mem_pool,mem_br,mem_ev):
+        key=(int(b),int(pi))
+        if key not in branch_pairs or e>branch_pairs[key]: branch_pairs[key]=float(e)
+    byb={}
+    for (b,pi),e in branch_pairs.items(): byb.setdefault(b,[]).append((e,pi))
+    H={}; bestdoc={}; docs_by_branch={}
+    for b,vals in byb.items():
+        vals.sort(key=lambda x:x[0],reverse=True)
+        top=vals[:3]
+        H[b]=float(np.mean([e for e,_ in top]))
+        bestdoc[b]=int(max(vals,key=lambda x: float(base_score[x[1]]))[1])  # best final-relevance doc in branch
+        docs_by_branch[b]=np.asarray([pi for _,pi in vals],dtype=np.int32)
+    ub=np.asarray(sorted(H.keys()),dtype=np.int32)
+    h=np.asarray([H[int(b)] for b in ub],dtype=np.float32)
+    hnorm=minmax_hi(h)
+    bmap={int(b):i for i,b in enumerate(ub)}
+    reps=[center_sparse(int(b)) for b in ub]
+    C=np.eye(len(ub),dtype=np.float32)
+    for i in range(len(ub)):
+        for j in range(i+1,len(ub)):
+            C[i,j]=C[j,i]=spdot(*reps[i],*reps[j])
+    return {'docs':dd,'base':base_score,'tail':ts,'lex':ladj,'sem':sm,'rare':rarecov,
+            'route_docs':ud,'branches_dom':db,'ub':ub,'H':h,'Hn':hnorm,'bmap':bmap,'cos':C,
+            'bestdoc':bestdoc,'docs_by_branch':docs_by_branch}
+
+def plain(p,k=100):
+    oo=np.argsort(p['base'])[::-1][:k]
+    return p['docs'][oo].tolist()
+
+def Dvec(p, selected_bidx):
+    C=p['cos']
+    if not selected_bidx:return np.zeros(len(C),np.float32)
+    si=np.asarray(selected_bidx,np.int32)
+    mumun=float(np.mean(C[np.ix_(si,si)]))
+    return 1.0+mumun-2.0*np.mean(C[:,si],axis=1)
+
+def select_hq_branches(p, topN=20, lam=1.0, nsel=10, pure_div=False):
+    if len(p['ub'])==0:return []
+    # eligible branches are the top-N robust-quality H_j branches
+    order=np.argsort(p['H'])[::-1]
+    elig=order[:min(topN,len(order))]
+    # first branch = highest H_j
+    selected=[int(elig[0])]
+    remaining=set(map(int,elig[1:]))
+    while remaining and len(selected)<min(nsel,len(elig)):
+        rem=np.asarray(sorted(remaining),dtype=np.int32)
+        D=Dvec(p,selected)
+        dnorm=minmax_hi(D[rem])
+        if pure_div:
+            val=dnorm
+        else:
+            h=p['Hn'][rem]
+            val=h+float(lam)*dnorm
+        pick=int(rem[int(np.argmax(val))])
+        selected.append(pick); remaining.remove(pick)
+    return selected
+
+def rank_hq_oneper(p,topN=20,lam=1.0,pure_div=False,k=100):
+    # one best final-score document from each selected high-quality/diverse branch for top 10
+    sb=select_hq_branches(p,topN,lam,10,pure_div)
+    chosen=[]; used=set()
+    for bi in sb:
+        b=int(p['ub'][bi]); pi=int(p['bestdoc'][b])
+        if pi not in used: chosen.append(pi); used.add(pi)
+    # if fewer than 10, fill by ordinary score
+    for pi in np.argsort(p['base'])[::-1]:
+        pi=int(pi)
+        if len(chosen)>=10:break
+        if pi not in used: chosen.append(pi);used.add(pi)
+    # rest by ordinary score
+    for pi in np.argsort(p['base'])[::-1]:
+        pi=int(pi)
+        if len(chosen)>=k:break
+        if pi not in used: chosen.append(pi);used.add(pi)
+    return p['docs'][np.asarray(chosen[:k],dtype=np.int64)].tolist()
+
+def rank_hq_softdoc(p,topN=20,lam=.25,k=100):
+    # restrict diversity bonus to high-quality branches; repeated branches allowed.
+    # docs outside HQ set retain pure relevance and are still eligible.
+    base=p['base']; n=len(base); order=np.argsort(base)[::-1]
+    first=int(order[0]); chosen=[first]; used={first}
+    elig_order=np.argsort(p['H'])[::-1][:min(topN,len(p['H']))]
+    eligset=set(map(int,elig_order))
+    # branch memberships for each pool doc: use all high-quality branches the doc belongs to
+    doc_hq=[[] for _ in range(n)]
+    for bi in elig_order:
+        b=int(p['ub'][bi])
+        for pi in p['docs_by_branch'][b]: doc_hq[int(pi)].append(int(bi))
+    # selected branch representation starts with highest-quality HQ branch supporting first, if any
+    selected=[]
+    if doc_hq[first]:
+        selected=[max(doc_hq[first], key=lambda bi: float(p['H'][bi]))]
+    for _ in range(1,min(10,k,n)):
+        rem=np.asarray([i for i in range(n) if i not in used],dtype=np.int32)
+        if not len(rem):break
+        D=Dvec(p,selected) if selected else np.zeros(len(p['ub']),np.float32)
+        # normalize only across eligible branches
+        if len(elig_order):
+            ed=minmax_hi(D[elig_order]); dn={int(bi):float(v) for bi,v in zip(elig_order,ed)}
+        else: dn={}
+        # relevance minmax across remaining top pool; high = good
+        rn=minmax_hi(base[rem])
+        bonus=np.zeros(len(rem),np.float32)
+        for k2,pi in enumerate(rem):
+            if doc_hq[int(pi)]: bonus[k2]=max(dn.get(bi,0.0) for bi in doc_hq[int(pi)])
+        val=rn+float(lam)*bonus
+        pi=int(rem[int(np.argmax(val))]); chosen.append(pi); used.add(pi)
+        if doc_hq[pi]:
+            # add the supporting HQ branch with max diversity, ties quality
+            bi=max(doc_hq[pi],key=lambda x:(dn.get(x,0.0),float(p['H'][x])))
+            selected.append(int(bi))
+    for pi in order:
+        pi=int(pi)
+        if len(chosen)>=k:break
+        if pi not in used:chosen.append(pi);used.add(pi)
+    return p['docs'][np.asarray(chosen[:k],dtype=np.int64)].tolist()
+
+def evaluate(ds,packs,ranker,**kw):
+    run={};route_num=pool_num=den=0;cands=[]
+    for qid,p in packs.items():
+        rr=[] if p is None else ranker(p,**kw)
+        run[str(qid)]=[str(idx.doc_ids[int(d)]) for d in rr]
+        if p is not None:
+            route={str(idx.doc_ids[int(d)]) for d in p['route_docs']};pool={str(idx.doc_ids[int(d)]) for d in p['docs']}
+            pos={str(d) for d,v in ds.qrels[qid].items() if v>0};den+=len(pos);route_num+=sum(d in route for d in pos);pool_num+=sum(d in pool for d in pos);cands.append(len(route))
+    m=evaluate_run(run,ds.qrels,ks=(10,100),ndcg_k=10,mrr_k=10,exp_gain=False)
+    m['route_recall_micro']=route_num/max(1,den);m['pool_recall_micro']=pool_num/max(1,den);m['avg_candidates']=float(np.mean(cands)) if cands else 0
+    return m
+
+
+ds=load_beir_directory(ROOT,'test')
+packs={}; prep=[]
+for i,qid in enumerate(ds.qrels):
+    t=time.perf_counter(); packs[qid]=prepare(ds.queries[qid]); prep.append((time.perf_counter()-t)*1000)
+    if (i+1)%10==0: print('prepared',i+1,flush=True)
+
+def eval_timed(name,fn,**kw):
+    # rank timing only on prepared packs
+    rt=[]
+    for qid,p in packs.items():
+        t=time.perf_counter(); _=[] if p is None else fn(p,**kw); rt.append((time.perf_counter()-t)*1000)
+    m=evaluate(ds,packs,fn,**kw)
+    m['rank_median_ms']=float(np.median(rt)); m['rank_p95_ms']=float(np.percentile(rt,95))
+    print(name,m,flush=True); return m
+
+res={'dataset':'TREC-COVID','P':P,'branch_quality':'mean top-3 E_dj among P pool docs; E_dj=m_dj*rho_q(j)*L_dj*C_dj^gamma',
+     'selection':'top-10 branches by H_j; soft document diversity lambda_D=0.1; IDF^2 final lexical term',
+     'timing':{'prepare_median_ms':float(np.median(prep)),'prepare_p95_ms':float(np.percentile(prep,95))},'variants':{}}
+res['variants']['current_z']=eval_timed('current_z',plain)
+res['variants']['hq10_softdoc_l0.1']=eval_timed('hq10_softdoc_l0.1',rank_hq_softdoc,topN=10,lam=0.1)
+out=f'/mnt/data/treccovid_p{P}_sweep_result.json'
+json.dump(res,open(out,'w'),indent=2)
+print('saved',out,flush=True)

experiments/msmarco_scale/bench_fast.py

@@ -0,0 +1,7 @@
+import sys,time
+sys.path.insert(0,'/mnt/data')
+from msmarco_full_search_fast import FullIndex,load_query_texts
+ids=['300674','125705','94798','9083','174249']; txt=load_query_texts(ids); idx=FullIndex(); print('loaded')
+for rep in range(2):
+ for q in ids:
+  t=time.perf_counter(); p=idx.prepare(txt[q],20); r=idx.rank_h(p,0,100); print(rep,q,(time.perf_counter()-t)*1000,p['candidate_memberships'],p['candidate_docs'],r[:5],flush=True)

experiments/msmarco_scale/bench_post.py

@@ -0,0 +1,11 @@
+import sys,time,json, numpy as np
+sys.path.insert(0,'/mnt/data')
+from msmarco_full_search_post import FullIndex, load_query_texts
+ids=['300674','125705','94798','9083','174249']
+txt=load_query_texts(ids)
+idx=FullIndex(); print('loaded')
+# compile/warm
+for rep in range(2):
+ for q in ids:
+  t=time.perf_counter(); p=idx.prepare(txt[q],hmax=20); r=idx.rank_h(p,0,100); dt=(time.perf_counter()-t)*1000
+  print(rep,q,dt,p['candidate_memberships'],p['candidate_docs'],r[:5],flush=True)

experiments/msmarco_scale/build_branch_sorted_layout.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+import numpy as np,time,json,os
+IDX=Path('/mnt/data/msmarco_scale_work/full_index'); N=8_841_823; F=4; S=16
+bo=np.memmap(IDX/'branch_order.u32',np.uint32,'r'); n=len(bo)
+mem=np.memmap(IDX/'memberships.f32',np.float32,'r',shape=(N,F)); rt=np.memmap(IDX/'res_terms.u16',np.uint16,'r',shape=(N,F,S)); sb=np.memmap(IDX/'signbits.u16',np.uint16,'r',shape=(N,F))
+pd=np.memmap(IDX/'post_doc.u32',np.uint32,'w+',shape=(n,)); pm=np.memmap(IDX/'post_membership.f32',np.float32,'w+',shape=(n,)); pr=np.memmap(IDX/'post_res_terms.u16',np.uint16,'w+',shape=(n,S)); ps=np.memmap(IDX/'post_signbits.u16',np.uint16,'w+',shape=(n,))
+t=time.time(); block=500_000
+for a in range(0,n,block):
+ b=min(n,a+block); fp=np.asarray(bo[a:b],np.uint32); docs=fp//F; slots=(fp%F).astype(np.uint8)
+ pd[a:b]=docs; pm[a:b]=mem[docs,slots]; pr[a:b]=rt[docs,slots]; ps[a:b]=sb[docs,slots]
+ if (a//block)%10==0: print(a,b,'/',n,'sec',time.time()-t,flush=True)
+pd.flush();pm.flush();pr.flush();ps.flush()
+print('DONE',n,'seconds',time.time()-t,flush=True)

experiments/msmarco_scale/build_global_support.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+import numpy as np, json, time, os
+I=Path('/mnt/data/msmarco_scale_work/full_index'); N=8841823
+total=0; metas=[]
+for sid in range(36):
+ m=json.load(open(I/f'shard_{sid:04d}.json')); metas.append(m); total+=int(m['nnz'])
+print('total',total,flush=True)
+ids=np.memmap(I/'support_all.u16',np.uint16,'w+',shape=(total,))
+ip=np.memmap(I/'support_all_indptr.u32',np.uint32,'w+',shape=(N+1,))
+pos=0; dpos=0; t=time.time(); ip[0]=0
+for sid,m in enumerate(metas):
+ n=int(m['n']); nn=int(m['nnz'])
+ si=np.memmap(I/f'support_{sid:04d}.u16',np.uint16,'r',shape=(nn,)); sp=np.memmap(I/f'support_indptr_{sid:04d}.u32',np.uint32,'r',shape=(n+1,))
+ ids[pos:pos+nn]=si
+ ip[dpos+1:dpos+n+1]=np.asarray(sp[1:],np.uint64)+pos
+ pos+=nn; dpos+=n
+ print(sid,n,nn,pos,dpos,time.time()-t,flush=True)
+ids.flush();ip.flush(); print('done',pos,dpos,time.time()-t,flush=True)

experiments/msmarco_scale/compare_fast_post.py

@@ -0,0 +1,14 @@
+import sys,numpy as np,pandas as pd
+sys.path.insert(0,'/mnt/data')
+import msmarco_full_search_post as slow
+import msmarco_full_search_fast as fast
+tr=pd.read_csv('/mnt/data/dev.tsv',sep='\t',usecols=['query-id']); ids=[str(x) for x in np.unique(tr['query-id'].to_numpy())[:10]]; del tr
+txt=fast.load_query_texts(ids)
+a=slow.FullIndex(); b=fast.FullIndex()
+for q in ids:
+ pa=a.prepare(txt[q],20); pb=b.prepare(txt[q],20)
+ for h in [0,1,5,10,20]:
+  ra=a.rank_h(pa,h,100); rb=b.rank_h(pb,h,100)
+  if ra!=rb:
+   print('MISMATCH',q,h,next((i for i,(x,y) in enumerate(zip(ra,rb)) if x!=y),None)); break
+ else: print('OK',q)

experiments/msmarco_scale/msmarco_allroute_diag.py

@@ -0,0 +1,20 @@
+import sys,time,numpy as np,pandas as pd,json
+sys.path.insert(0,'/mnt/data')
+from msmarco_full_search_fastp import FullIndex,load_query_texts,qrels_from_tsv,eval_run,ROOT,WORK,zscore
+NS=500; BIG=1_000_000
+LAM=[2.5,5.0]
+idx=FullIndex(); print('loaded',flush=True)
+tr=pd.read_csv(ROOT/'train.tsv',sep='\t',usecols=['query-id']); uq=np.unique(tr['query-id'].to_numpy()); rng=np.random.default_rng(20260815); ids=[str(x) for x in rng.choice(uq,size=1000,replace=False)[:NS]]; del tr
+texts=load_query_texts(ids); qrels=qrels_from_tsv(ROOT/'train.tsv',ids,positive_only=True)
+w=idx.prepare(texts[ids[0]],hmax=1,pool_max=BIG); del w
+runs={l:{} for l in LAM}; times=[]; cands=[]
+for z,qid in enumerate(ids):
+ t=time.perf_counter(); pp=idx.prepare(texts[qid],hmax=1,pool_max=BIG); times.append((time.perf_counter()-t)*1000)
+ if pp is None:
+  for l in LAM:runs[l][qid]=[]
+ else:
+  docs=pp['cand_docs']; cands.append(len(docs)); zt=zscore(pp['cand_tail']); zl=zscore(pp['lex']); zs=zscore(pp['sem'])
+  for l in LAM:
+   sc=zt+l*zl+0.05*zs; ix=np.argpartition(sc,-min(100,len(sc)))[-min(100,len(sc)):]; ix=ix[np.argsort(sc[ix])[::-1]]; runs[l][qid]=[int(x) for x in docs[ix]]
+ if (z+1)%50==0: print(z+1,'median_ms',np.median(times),'p95',np.percentile(times,95),'avgcand',np.mean(cands),flush=True)
+for l in LAM: print('LAM',l,eval_run(runs[l],qrels),flush=True)

experiments/msmarco_scale/msmarco_amplitude_diag_stage1.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+import sys,time,json,gzip,pickle
+from pathlib import Path
+import numpy as np,pandas as pd
+from numba import set_num_threads
+sys.path.insert(0,'/mnt/data')
+import msmarco_early_lex_validation_fast as e
+import msmarco_full_search_uniform1m as m
+
+ROOT=m.ROOT; WORK=m.WORK; idx=e.idx; P=2000; M=m.M
+set_num_threads(5)
+OUT=WORK/'amplitude_diag'; OUT.mkdir(exist_ok=True)
+
+def topk_desc(score,k):
+    n=len(score); k=min(k,n)
+    if n<=k: return np.argsort(score)[::-1]
+    ii=np.argpartition(score,-k)[-k:]
+    return ii[np.argsort(score[ii])[::-1]]
+
+# exact same deterministic validation query IDs
+tr=pd.read_csv(ROOT/'train.tsv',sep='\t',usecols=['query-id'])
+uq=np.unique(tr['query-id'].to_numpy()); del tr
+rng=np.random.default_rng(20260815)
+ids=[str(x) for x in rng.choice(uq,size=1000,replace=False)]
+texts=m.load_query_texts(ids)
+qrels=m.qrels_from_tsv(ROOT/'train.tsv',ids,positive_only=True)
+
+# Warm up
+p=e.prepare_all(texts[ids[0]]); del p
+
+# Freeze current direct eta=1 pools. Store the existing final-score components too.
+docs2k=np.empty((len(ids),P),np.uint32)
+tail2k=np.empty((len(ids),P),np.float32)
+lex2k=np.empty((len(ids),P),np.float32)
+sem2k=np.empty((len(ids),P),np.float32)
+valid=np.zeros(len(ids),np.int32)
+route_relhit=pool_relhit=den=0
+start=time.time(); prep=[]
+for qi,qid in enumerate(ids):
+    t=time.perf_counter(); p=e.prepare_all(texts[qid]); prep.append((time.perf_counter()-t)*1000)
+    if p is None: continue
+    sel=topk_desc(m.zscore(p['tail']) + m.zscore(p['lex']), P)  # eta=1
+    k=len(sel); valid[qi]=k
+    docs2k[qi,:k]=p['ud'][sel]; tail2k[qi,:k]=p['tail'][sel]; lex2k[qi,:k]=p['lex'][sel]; sem2k[qi,:k]=p['sem'][sel]
+    if k<P:
+        docs2k[qi,k:]=np.uint32(0); tail2k[qi,k:]=0; lex2k[qi,k:]=0; sem2k[qi,k:]=0
+    rels=[int(d) for d,r in qrels[qid].items() if r>0]; den+=len(rels)
+    ud=p['ud']; poolset=set(map(int,p['ud'][sel].tolist()))
+    for d in rels:
+        kk=np.searchsorted(ud,d); route_relhit += int(kk<len(ud) and int(ud[kk])==d); pool_relhit += int(d in poolset)
+    if (qi+1)%100==0: print('pool',qi+1,'median_ms',float(np.median(prep)),'route',route_relhit/den,'pool',pool_relhit/den,flush=True)
+
+np.savez_compressed(OUT/'fixed_eta1_pools.npz', qids=np.asarray(ids), valid=valid, docs=docs2k, tail=tail2k, lex=lex2k, sem=sem2k)
+union=np.unique(np.concatenate([docs2k[i,:valid[i]] for i in range(len(ids))]))
+np.save(OUT/'union_docs.npy',union)
+meta={'n_queries':len(ids),'P':P,'union_docs':int(len(union)),'route_relevant_recall':route_relhit/den,'pool_relevant_recall':pool_relhit/den,'median_prepare_ms':float(np.median(prep)),'seconds':time.time()-start}
+json.dump(meta,open(OUT/'stage1_meta.json','w'),indent=2)
+print('DONE',meta,flush=True)

experiments/msmarco_scale/msmarco_amplitude_diag_stage2.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+import sys,time,json,gzip
+from pathlib import Path
+import numpy as np
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.preprocessing import normalize
+sys.path.insert(0,'/mnt/data')
+import msmarco_full_search_uniform1m as m
+ROOT=m.ROOT; WORK=m.WORK; OUT=WORK/'amplitude_diag'; IDX=m.IDX
+idx=m.FullIndex()
+union=np.load(OUT/'union_docs.npy',mmap_mode='r')
+# exact support counts from existing binary support index
+sup_ip=idx.sup_ip; sup_ids=idx.sup_ids
+counts=(np.asarray(sup_ip[union.astype(np.int64)+1],dtype=np.uint64)-np.asarray(sup_ip[union.astype(np.int64)],dtype=np.uint64))
+uip=np.empty(len(union)+1,np.uint64); uip[0]=0; np.cumsum(counts,out=uip[1:]); nnz=int(uip[-1])
+np.save(OUT/'exact_tfidf_indptr.npy',uip)
+data=np.memmap(OUT/'exact_tfidf_data.f32',np.float32,'w+',shape=(nnz,))
+cv=idx.cvq; idf=idx.idf
+# Locate all 36 uploaded shards
+shards=[]
+for sid in range(36):
+    a=ROOT/f'corpus_{sid:04d}.jsonl.gz'; b=ROOT/f'corpus_{sid:04d}.jsonl(1).gz'
+    p=a if a.exists() else b
+    if not p.exists(): raise FileNotFoundError((a,b))
+    shards.append(p)
+
+BATCH=5000; texts=[]; rows=[]; start=time.time(); found=0; verified=0
+
+def flush():
+    global texts,rows,found,verified
+    if not rows:return
+    X=cv.transform(texts).tocsr().astype(np.float32)
+    X.data*=idf[X.indices]; normalize(X,norm='l2',axis=1,copy=False)
+    for bi,ur in enumerate(rows):
+        doc=int(union[ur]); ga=int(sup_ip[doc]); gb=int(sup_ip[doc+1]); expected=np.asarray(sup_ids[ga:gb],dtype=np.int32)
+        a=int(X.indptr[bi]); b=int(X.indptr[bi+1]); got=X.indices[a:b]
+        if len(got)!=len(expected) or not np.array_equal(got,expected):
+            raise RuntimeError(f'support mismatch doc={doc} expected={len(expected)} got={len(got)}')
+        ua=int(uip[ur]); ub=int(uip[ur+1]); data[ua:ub]=X.data[a:b]
+        verified+=1
+    found+=len(rows); texts=[]; rows=[]
+
+p_union=0
+for sid,path in enumerate(shards):
+    lo=sid*250000; hi=min((sid+1)*250000,m.N)
+    # target union row range for this shard
+    r0=int(np.searchsorted(union,lo)); r1=int(np.searchsorted(union,hi))
+    if r0==r1:
+        continue
+    targets=np.asarray(union[r0:r1],dtype=np.uint32); ti=0
+    with gzip.open(path,'rt',encoding='utf-8') as f:
+        for local,line in enumerate(f):
+            d=lo+local
+            if ti>=len(targets): break
+            td=int(targets[ti])
+            if d<td: continue
+            if d!=td: raise RuntimeError((sid,d,td))
+            o=json.loads(line); oid=int(o['_id'])
+            if oid!=d: raise RuntimeError(f'id mismatch line {d} json {oid}')
+            texts.append(((o.get('title') or '')+' '+(o.get('text') or '')).strip()); rows.append(r0+ti); ti+=1
+            if len(rows)>=BATCH: flush()
+    if ti!=len(targets): raise RuntimeError(f'shard {sid} found {ti}/{len(targets)}')
+    flush(); data.flush()
+    print('shard',sid,'selected',len(targets),'total_found',found,'elapsed',time.time()-start,flush=True)
+flush(); data.flush()
+meta={'union_docs':int(len(union)),'nnz':nnz,'avg_nnz':float(nnz/len(union)),'verified_docs':verified,'seconds':time.time()-start}
+json.dump(meta,open(OUT/'stage2_meta.json','w'),indent=2)
+print('DONE',meta,flush=True)

experiments/msmarco_scale/msmarco_amplitude_diag_stage3.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+import sys,json,math,time
+from pathlib import Path
+import numpy as np,pandas as pd
+from numba import njit,set_num_threads
+sys.path.insert(0,'/mnt/data')
+import msmarco_full_search_uniform1m as m
+
+ROOT=m.ROOT; WORK=m.WORK; OUT=WORK/'amplitude_diag'; IDX=m.IDX; GEOM=m.GEOM
+N=m.N; M=m.M; F=4; S=16; P=2000
+set_num_threads(5)
+idx=m.FullIndex()
+
+z=np.load(OUT/'fixed_eta1_pools.npz',allow_pickle=False)
+qids=[str(x) for x in z['qids'].tolist()]; valid=z['valid'].astype(np.int32); docs=z['docs']; tail=z['tail']; lex=z['lex']; sem=z['sem']
+union=np.load(OUT/'union_docs.npy',mmap_mode='r'); uip=np.load(OUT/'exact_tfidf_indptr.npy',mmap_mode='r'); exact=np.memmap(OUT/'exact_tfidf_data.f32',np.float32,'r',shape=(int(uip[-1]),))
+# document-order geometry arrays
+base=WORK/'full_index'
+branches=np.memmap(base/'branches.u16',np.uint16,'r',shape=(N,F))
+memberships=np.memmap(base/'memberships.f32',np.float32,'r',shape=(N,F))
+res_terms=np.memmap(IDX/'res_terms.u16',np.uint16,'r',shape=(N,F,S))
+# query texts/qrels
+texts=m.load_query_texts(qids); qrels=m.qrels_from_tsv(ROOT/'train.tsv',qids,positive_only=True)
+
+@njit(cache=False)
+def bsearch_u16(arr,a,b,t):
+    lo=np.int64(a); hi=np.int64(b)
+    while lo<hi:
+        mid=np.int64((lo+hi)//2)
+        x=int(arr[mid])
+        if x<t: lo=mid+1
+        else: hi=mid
+    if lo<b and int(arr[lo])==t:return lo
+    return -1
+
+@njit(cache=False)
+def center_lookup(ctrow,cvrow,t):
+    lo=0; hi=len(ctrow)
+    while lo<hi:
+        md=(lo+hi)//2; x=int(ctrow[md])
+        if x==65535 or x>=t: hi=md
+        else: lo=md+1
+    if lo<len(ctrow) and int(ctrow[lo])==t:return float(cvrow[lo])
+    return 0.0
+
+@njit(cache=False)
+def rel_lookup(rp,ri,rv,j,t):
+    lo=np.int64(rp[j]); hi=np.int64(rp[j+1]); end=hi
+    while lo<hi:
+        md=np.int64((lo+hi)//2); x=int(ri[md])
+        if x<t: lo=md+1
+        else: hi=md
+    if lo<end and int(ri[lo])==t:return float(rv[lo])
+    return 1.0
+
+@njit(cache=False)
+def score_pool(cdocs, union, uip, exact, sup_ip, sup_ids, branches, memberships, res_terms,
+               qdense, route_dense, ct, cv, rp, ri, rv):
+    n=len(cdocs); tfcos=np.zeros(n,np.float32); amp_tail=np.zeros(n,np.float32)
+    for zz in range(n):
+        d=int(cdocs[zz])
+        ur=np.searchsorted(union,np.uint32(d))
+        if ur>=len(union) or int(union[ur])!=d: continue
+        ga=int(sup_ip[d]); gb=int(sup_ip[d+1]); ua=int(uip[ur])
+        # exact normalized tf-idf cosine
+        s=0.0
+        for kk in range(ga,gb):
+            t=int(sup_ids[kk]); s += float(exact[ua+(kk-ga)])*float(qdense[t])
+        tfcos[zz]=s
+        # exact retained residual amplitudes, same current gamma=.25 and lambdaM=.125
+        tsum=0.0; csum=0.0
+        for f in range(F):
+            j=int(branches[d,f])
+            if j==65535: continue
+            rho=float(route_dense[j])
+            if rho<=0.0: continue
+            mem=float(memberships[d,f]); local=0.0; sig=0.0
+            for r in range(S):
+                t=int(res_terms[d,f,r])
+                if t==65535: continue
+                pos=bsearch_u16(sup_ids,ga,gb,t)
+                if pos<0: continue
+                xv=float(exact[ua+(pos-ga)])
+                cen=center_lookup(ct[j],cv[j],t)
+                rel=rel_lookup(rp,ri,rv,j,t)
+                qv=float(qdense[t]); rr=xv-cen
+                local += rel*(qv-cen)*rr
+                sig += qv*qv
+            c=mem*rho
+            tsum += c*local*(sig**0.25 if sig>0 else 0.0)
+            csum += c
+        amp_tail[zz]=tsum + 0.125*csum
+    return tfcos,amp_tail
+
+# feature matrices for reproducibility
+TF=np.zeros((len(qids),P),np.float32); AMP=np.zeros((len(qids),P),np.float32)
+start=time.time()
+for qi,qid in enumerate(qids):
+    k=int(valid[qi]); q=idx.query_vec(texts[qid]); qd=np.zeros(M,np.float32); qd[q.indices]=q.data; _,rd=idx.route(q)
+    tf,amp=score_pool(docs[qi,:k],union,uip,exact,idx.sup_ip,idx.sup_ids,branches,memberships,res_terms,qd,rd,idx.ct,idx.cv,idx.rp,idx.ri,idx.rv)
+    TF[qi,:k]=tf; AMP[qi,:k]=amp
+    if (qi+1)%100==0: print('features',qi+1,'elapsed',time.time()-start,flush=True)
+np.save(OUT/'exact_tfidf_cos.npy',TF); np.save(OUT/'exact_residual_amp_tail.npy',AMP)
+
+def rank_score(score,k=100):
+    if len(score)<=k:return np.argsort(score)[::-1]
+    ii=np.argpartition(score,-k)[-k:]; return ii[np.argsort(score[ii])[::-1]]
+
+def evaluate(kind, a=0.0, x=0.0, use_cur=True, use_amp=False):
+    run={}
+    for qi,qid in enumerate(qids):
+        k=int(valid[qi]); dd=docs[qi,:k]
+        if kind=='tfidf_only': sc=TF[qi,:k]
+        elif kind=='amp_only': sc=AMP[qi,:k]
+        elif kind=='binary_only': sc=lex[qi,:k]
+        else:
+            sc=np.zeros(k,np.float32)
+            if use_cur: sc += m.zscore(tail[qi,:k])
+            if use_amp: sc += np.float32(a)*m.zscore(AMP[qi,:k])
+            sc += np.float32(4.0)*m.zscore(lex[qi,:k]) + np.float32(.1)*m.zscore(sem[qi,:k])
+            if x!=0: sc += np.float32(x)*m.zscore(TF[qi,:k])
+        oo=rank_score(sc,100); run[qid]=[int(v) for v in dd[oo]]
+    return m.eval_run(run,qrels)
+
+rows=[]
+for kind in ['binary_only','tfidf_only','amp_only']:
+    met=evaluate(kind); rows.append({'model':kind,**met}); print(kind,met,flush=True)
+# Baseline locked final score and additions of exact tfidf
+met=evaluate('fusion',0,0,True,False); rows.append({'model':'current_final','amp_coef':0,'tfidf_coef':0,**met}); print('current',met,flush=True)
+for x in [0.125,0.25,0.5,1.0,2.0,4.0,8.0]:
+    met=evaluate('fusion',0,x,True,False); rows.append({'model':'current_plus_tfidf','amp_coef':0,'tfidf_coef':x,**met}); print('tf',x,met,flush=True)
+# Replace current sign-tail by amplitude-tail
+for x in [0.0,0.25,0.5,1.0,2.0,4.0]:
+    met=evaluate('fusion',1.0,x,False,True); rows.append({'model':'amp_tail_plus_final','amp_coef':1.0,'tfidf_coef':x,**met}); print('amp_replace tf',x,met,flush=True)
+# retain current tail and add amplitude as extra feature, plus optional exact tfidf
+for a in [0.125,0.25,0.5,1.0,2.0,4.0]:
+  for x in [0.0,0.25,0.5,1.0,2.0]:
+    met=evaluate('fusion',a,x,True,True); rows.append({'model':'current_plus_amp_plus_tfidf','amp_coef':a,'tfidf_coef':x,**met})
+rows_sorted=sorted(rows,key=lambda r:(r['nDCG@10'],r['MRR@10'],r['R@100']),reverse=True)
+out={'protocol':'same fixed eta=1 P=2000 pools from deterministic 1000 TRAIN validation; raw corpus reread only to reconstruct exact amplitudes; no candidate-generation changes','rows':rows_sorted,'best':rows_sorted[0],'feature_seconds':time.time()-start}
+json.dump(out,open(OUT/'amplitude_diagnostic_results.json','w'),indent=2)
+print('BEST',rows_sorted[0],flush=True)
+print('TOP10')
+for r in rows_sorted[:10]:print(r,flush=True)

experiments/msmarco_scale/msmarco_best_all_dev.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+import sys,time,json
+import numpy as np,pandas as pd
+sys.path.insert(0,'/mnt/data')
+import msmarco_best_tail_core as b
+import msmarco_full_search_uniform1m as m
+ROOT=m.ROOT; WORK=m.WORK; idx=b.idx
+LLEX=np.float32(4.0); LSEM=np.float32(0.1)
+
+def rank(p,k=100):
+    if p is None:return []
+    docs=p['cand_docs'][:b.P]; ts=p['cand_tail'][:b.P]; lx=p['lex'][:b.P]; sm=p['sem'][:b.P]
+    fin=m.zscore(ts)+LLEX*m.zscore(lx)+LSEM*m.zscore(sm); oo=np.argsort(fin)[::-1][:k]
+    return [int(x) for x in docs[oo]]
+
+df=pd.read_csv(ROOT/'dev.tsv',sep='\t',usecols=['query-id']); ids=[str(x) for x in np.unique(df['query-id'].to_numpy())]; del df
+texts=m.load_query_texts(ids); qrels=m.qrels_from_tsv(ROOT/'dev.tsv',ids,positive_only=True)
+_=b.prepare(texts[ids[0]])
+run={}; times=[]; routehit=0; poolhit=0; den=0; cands=[]
+for z,qid in enumerate(ids):
+    t=time.perf_counter(); p=b.prepare(texts[qid]); run[qid]=rank(p); times.append((time.perf_counter()-t)*1000)
+    rels=[int(d) for d,r in qrels[qid].items() if r>0]; den+=len(rels)
+    if p:
+        cands.append(p['candidate_docs']); ud=p['ud']; pool=p['cand_docs'][:b.P]
+        for d in rels:
+            kk=np.searchsorted(ud,d); routehit+=int(kk<len(ud) and int(ud[kk])==d); poolhit+=int(np.any(pool==d))
+    if (z+1)%500==0: print('dev',z+1,'median',float(np.median(times)),'p95',float(np.percentile(times,95)),flush=True)
+met=m.eval_run(run,qrels)
+out={'protocol':'all params locked from TRAIN validation: gamma_tail=.25 lambda_M=.125 h=0 lambda_lex=4 lambda_sem=.1 P=2000; full DEV untouched','params':{'gamma_tail':0.25,'lambda_M':0.125,'h':0,'lambda_lex':4.0,'lambda_sem':0.1,'P':2000,'S':16},'dev_metrics':met,'route_relevant_recall':routehit/den,'pool_relevant_recall':poolhit/den,'timing':{'median_ms':float(np.median(times)),'p95_ms':float(np.percentile(times,95)),'mean_ms':float(np.mean(times)),'qps':1000/float(np.mean(times)),'avg_candidate_docs':float(np.mean(cands))}}
+json.dump(out,open(WORK/'best_all_dev_results.json','w'),indent=2); print('DEV',met,flush=True); print('SUMMARY',out,flush=True)

experiments/msmarco_scale/msmarco_best_tail_core.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+import sys,time,json,math
+from pathlib import Path
+import numpy as np,pandas as pd
+from numba import njit,prange,set_num_threads
+sys.path.insert(0,'/mnt/data')
+import msmarco_full_search_uniform1m as m
+ROOT=m.ROOT; WORK=m.WORK; M=m.M; S=m.S; P=2000
+GAMMA=np.float32(0.25); LAM=np.float32(0.125); HGRID=list(range(0,11))
+set_num_threads(5); idx=m.FullIndex(); print('loaded',idx.meta,flush=True)
+
+@njit(parallel=True,cache=False)
+def score_components(rslot,mem,rt,sbits,q_dense,rho,cent_local,rel_local):
+    K=len(rslot); base=np.zeros(K,np.float32); sig=np.zeros(K,np.float32); cons=np.zeros(K,np.float32)
+    for z in prange(K):
+        u=int(rslot[z]); local=0.0; sg=0.0; bits=sbits[z]
+        for r in range(S):
+            t=int(rt[z,r])
+            if t==65535: continue
+            qv=q_dense[t]; cen=cent_local[u,t]; rel=rel_local[u,t]; rel=1.0 if rel==0.0 else rel
+            sgn=1.0 if ((bits>>r)&1)!=0 else -1.0
+            local += rel*(qv-cen)*sgn; sg += qv*qv
+        c=mem[z]*rho[u]; base[z]=c*local; sig[z]=sg; cons[z]=c
+    return base,sig,cons
+
+def prepare(text):
+    q=idx.query_vec(text); qd=np.zeros(M,np.float32); qd[q.indices]=q.data; rterms,rd=idx.route(q)
+    spans=[(int(j),int(idx.offs[j]),int(idx.offs[j+1])) for j in rterms if idx.offs[j+1]>idx.offs[j]]
+    if not spans:return None
+    docs=np.concatenate([np.asarray(idx.pd[a:b]) for j,a,b in spans]).astype(np.uint32,copy=False)
+    mm=np.concatenate([np.asarray(idx.pm[a:b]) for j,a,b in spans]).astype(np.float32,copy=False)
+    rt=np.concatenate([np.asarray(idx.pr[a:b]) for j,a,b in spans]).astype(np.uint16,copy=False)
+    sb=np.concatenate([np.asarray(idx.ps[a:b]) for j,a,b in spans]).astype(np.uint16,copy=False)
+    nr=len(spans); cent=np.zeros((nr,M),np.float32); rel=np.zeros((nr,M),np.float32); rho=np.empty(nr,np.float32)
+    for u,(j,a,b) in enumerate(spans):
+        rowt=np.asarray(idx.ct[j]); ok=rowt!=65535; tids=rowt[ok].astype(np.int32,copy=False); cent[u,tids]=np.asarray(idx.cv[j])[ok]
+        ra=int(idx.rp[j]); rb=int(idx.rp[j+1]); rel[u,np.asarray(idx.ri[ra:rb],np.int32)]=np.asarray(idx.rv[ra:rb]); rho[u]=rd[j]
+    rslot=np.concatenate([np.full(b-a,u,dtype=np.uint8) for u,(j,a,b) in enumerate(spans)])
+    base,sig,cons=score_components(rslot,mm,rt,sb,qd,rho,cent,rel)
+    ud,inv=np.unique(docs,return_inverse=True)
+    head=np.bincount(inv,weights=base*np.sqrt(sig),minlength=len(ud)).astype(np.float32)
+    tail=np.bincount(inv,weights=base*np.power(sig,GAMMA,dtype=np.float32),minlength=len(ud)).astype(np.float32)+LAM*np.bincount(inv,weights=cons,minlength=len(ud)).astype(np.float32)
+    hmax=max(HGRID); hw=min(len(head),max(1,hmax)); hi=np.argpartition(head,-hw)[-hw:] if len(head)>hw else np.arange(len(head)); ho=hi[np.argsort(head[hi])[::-1]]
+    want=min(len(tail),P+hmax+8); ci=np.argpartition(tail,-want)[-want:] if len(tail)>want else np.arange(len(tail)); co=ci[np.argsort(tail[ci])[::-1]]
+    cand_docs=ud[co]; cand_tail=tail[co]
+    lexvec=np.zeros(M,np.float32); lexvec[q.indices]=idx.idf[q.indices]; semvec=np.zeros(M,np.float32)
+    for t,amp in zip(q.indices,q.data):
+        a,b=idx.A.indptr[t],idx.A.indptr[t+1]; nb=idx.A.indices[a:b][:m.SEMK]; sv=idx.A.data[a:b][:m.SEMK]; semvec[nb]+=float(amp)*sv*idx.idf[nb]
+    lex,sem=m.score_support_pool(cand_docs,idx.sup_ip,idx.sup_ids,lexvec,semvec,idx.dl,idx.avgdl)
+    return {'ud':ud,'head_order':ho,'cand_docs':cand_docs,'cand_tail':cand_tail,'lex':lex,'sem':sem,'candidate_docs':len(ud),'candidate_memberships':len(docs)}
+
+def rank_h(p,h,k=100):
+    if p is None:return []
+    ud=p['ud']; frozen=ud[p['head_order'][:min(h,len(ud))]] if h else np.empty(0,np.uint32); fs=set(map(int,frozen.tolist()))
+    keep=np.asarray([int(d) not in fs for d in p['cand_docs']],bool); docs=p['cand_docs'][keep][:P]; ts=p['cand_tail'][keep][:P]; lx=p['lex'][keep][:P]; sm=p['sem'][keep][:P]
+    final=m.zscore(ts)+m.LAMBDA_LEX*m.zscore(lx)+m.LAMBDA_SEM*m.zscore(sm); oo=np.argsort(final)[::-1]
+    return [int(x) for x in np.concatenate([frozen,docs[oo]])[:k]]
+

experiments/msmarco_scale/msmarco_best_tail_dev.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+import sys,time,json
+import numpy as np,pandas as pd
+sys.path.insert(0,'/mnt/data')
+import msmarco_best_tail_core as b
+import msmarco_full_search_uniform1m as m
+ROOT=m.ROOT; WORK=m.WORK
+idx=b.idx
+
+df=pd.read_csv(ROOT/'dev.tsv',sep='\t',usecols=['query-id']); ids=[str(x) for x in np.unique(df['query-id'].to_numpy())]; del df
+texts=m.load_query_texts(ids); qrels=m.qrels_from_tsv(ROOT/'dev.tsv',ids,positive_only=True)
+_=b.prepare(texts[ids[0]])
+run={}; times=[]; cands=[]; routehit=0; poolhit=0; den=0
+for z,qid in enumerate(ids):
+    t=time.perf_counter(); p=b.prepare(texts[qid]); run[qid]=b.rank_h(p,0,100); times.append((time.perf_counter()-t)*1000)
+    rels=[int(d) for d,r in qrels[qid].items() if r>0]; den+=len(rels)
+    if p:
+        cands.append(p['candidate_docs']); ud=p['ud']; pool=p['cand_docs'][:b.P]
+        for d in rels:
+            k=np.searchsorted(ud,d); routehit+=int(k<len(ud) and int(ud[k])==d); poolhit+=int(np.any(pool==d))
+    if (z+1)%250==0: print('dev',z+1,'median',float(np.median(times)),'p95',float(np.percentile(times,95)),'route',routehit/max(1,den),'pool',poolhit/max(1,den),flush=True)
+met=m.eval_run(run,qrels)
+out={'protocol':'gamma_tail=0.25, lambda_M=0.125, h=0 locked from deterministic 1000-query TRAIN validation; full DEV untouched','gamma_tail':0.25,'lambda_M':0.125,'h':0,'P':b.P,'dev_metrics':met,'route_relevant_recall':routehit/den,'pool_relevant_recall':poolhit/den,'timing':{'median_ms':float(np.median(times)),'p95_ms':float(np.percentile(times,95)),'mean_ms':float(np.mean(times)),'qps':1000/float(np.mean(times)),'avg_candidate_docs':float(np.mean(cands))}}
+json.dump(out,open(WORK/'best_tail_dev_results.json','w'),indent=2); print('DEV',met,flush=True); print('SUMMARY',out,flush=True)

experiments/msmarco_scale/msmarco_best_tail_eval.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+import sys,time,json,math
+from pathlib import Path
+import numpy as np,pandas as pd
+from numba import njit,prange,set_num_threads
+sys.path.insert(0,'/mnt/data')
+import msmarco_full_search_uniform1m as m
+ROOT=m.ROOT; WORK=m.WORK; M=m.M; S=m.S; P=2000
+GAMMA=np.float32(0.25); LAM=np.float32(0.125); HGRID=list(range(0,11))
+set_num_threads(5); idx=m.FullIndex(); print('loaded',idx.meta,flush=True)
+
+@njit(parallel=True,cache=False)
+def score_components(rslot,mem,rt,sbits,q_dense,rho,cent_local,rel_local):
+    K=len(rslot); base=np.zeros(K,np.float32); sig=np.zeros(K,np.float32); cons=np.zeros(K,np.float32)
+    for z in prange(K):
+        u=int(rslot[z]); local=0.0; sg=0.0; bits=sbits[z]
+        for r in range(S):
+            t=int(rt[z,r])
+            if t==65535: continue
+            qv=q_dense[t]; cen=cent_local[u,t]; rel=rel_local[u,t]; rel=1.0 if rel==0.0 else rel
+            sgn=1.0 if ((bits>>r)&1)!=0 else -1.0
+            local += rel*(qv-cen)*sgn; sg += qv*qv
+        c=mem[z]*rho[u]; base[z]=c*local; sig[z]=sg; cons[z]=c
+    return base,sig,cons
+
+def prepare(text):
+    q=idx.query_vec(text); qd=np.zeros(M,np.float32); qd[q.indices]=q.data; rterms,rd=idx.route(q)
+    spans=[(int(j),int(idx.offs[j]),int(idx.offs[j+1])) for j in rterms if idx.offs[j+1]>idx.offs[j]]
+    if not spans:return None
+    docs=np.concatenate([np.asarray(idx.pd[a:b]) for j,a,b in spans]).astype(np.uint32,copy=False)
+    mm=np.concatenate([np.asarray(idx.pm[a:b]) for j,a,b in spans]).astype(np.float32,copy=False)
+    rt=np.concatenate([np.asarray(idx.pr[a:b]) for j,a,b in spans]).astype(np.uint16,copy=False)
+    sb=np.concatenate([np.asarray(idx.ps[a:b]) for j,a,b in spans]).astype(np.uint16,copy=False)
+    nr=len(spans); cent=np.zeros((nr,M),np.float32); rel=np.zeros((nr,M),np.float32); rho=np.empty(nr,np.float32)
+    for u,(j,a,b) in enumerate(spans):
+        rowt=np.asarray(idx.ct[j]); ok=rowt!=65535; tids=rowt[ok].astype(np.int32,copy=False); cent[u,tids]=np.asarray(idx.cv[j])[ok]
+        ra=int(idx.rp[j]); rb=int(idx.rp[j+1]); rel[u,np.asarray(idx.ri[ra:rb],np.int32)]=np.asarray(idx.rv[ra:rb]); rho[u]=rd[j]
+    rslot=np.concatenate([np.full(b-a,u,dtype=np.uint8) for u,(j,a,b) in enumerate(spans)])
+    base,sig,cons=score_components(rslot,mm,rt,sb,qd,rho,cent,rel)
+    ud,inv=np.unique(docs,return_inverse=True)
+    head=np.bincount(inv,weights=base*np.sqrt(sig),minlength=len(ud)).astype(np.float32)
+    tail=np.bincount(inv,weights=base*np.power(sig,GAMMA,dtype=np.float32),minlength=len(ud)).astype(np.float32)+LAM*np.bincount(inv,weights=cons,minlength=len(ud)).astype(np.float32)
+    hmax=max(HGRID); hw=min(len(head),max(1,hmax)); hi=np.argpartition(head,-hw)[-hw:] if len(head)>hw else np.arange(len(head)); ho=hi[np.argsort(head[hi])[::-1]]
+    want=min(len(tail),P+hmax+8); ci=np.argpartition(tail,-want)[-want:] if len(tail)>want else np.arange(len(tail)); co=ci[np.argsort(tail[ci])[::-1]]
+    cand_docs=ud[co]; cand_tail=tail[co]
+    lexvec=np.zeros(M,np.float32); lexvec[q.indices]=idx.idf[q.indices]; semvec=np.zeros(M,np.float32)
+    for t,amp in zip(q.indices,q.data):
+        a,b=idx.A.indptr[t],idx.A.indptr[t+1]; nb=idx.A.indices[a:b][:m.SEMK]; sv=idx.A.data[a:b][:m.SEMK]; semvec[nb]+=float(amp)*sv*idx.idf[nb]
+    lex,sem=m.score_support_pool(cand_docs,idx.sup_ip,idx.sup_ids,lexvec,semvec,idx.dl,idx.avgdl)
+    return {'ud':ud,'head_order':ho,'cand_docs':cand_docs,'cand_tail':cand_tail,'lex':lex,'sem':sem,'candidate_docs':len(ud),'candidate_memberships':len(docs)}
+
+def rank_h(p,h,k=100):
+    if p is None:return []
+    ud=p['ud']; frozen=ud[p['head_order'][:min(h,len(ud))]] if h else np.empty(0,np.uint32); fs=set(map(int,frozen.tolist()))
+    keep=np.asarray([int(d) not in fs for d in p['cand_docs']],bool); docs=p['cand_docs'][keep][:P]; ts=p['cand_tail'][keep][:P]; lx=p['lex'][keep][:P]; sm=p['sem'][keep][:P]
+    final=m.zscore(ts)+m.LAMBDA_LEX*m.zscore(lx)+m.LAMBDA_SEM*m.zscore(sm); oo=np.argsort(final)[::-1]
+    return [int(x) for x in np.concatenate([frozen,docs[oo]])[:k]]
+
+tr=pd.read_csv(ROOT/'train.tsv',sep='\t',usecols=['query-id']); uq=np.unique(tr['query-id'].to_numpy()); rng=np.random.default_rng(20260815); ids=[str(x) for x in rng.choice(uq,size=1000,replace=False)]; del tr
+texts=m.load_query_texts(ids); qrels=m.qrels_from_tsv(ROOT/'train.tsv',ids,positive_only=True)
+_=prepare(texts[ids[0]])
+runs={h:{} for h in HGRID}; times=[]; cands=[]; poolhit=0; routehit=0; den=0
+for z,qid in enumerate(ids):
+    t=time.perf_counter(); p=prepare(texts[qid]); times.append((time.perf_counter()-t)*1000)
+    rels=[int(d) for d,r in qrels[qid].items() if r>0]; den+=len(rels)
+    if p:
+        cands.append(p['candidate_docs']); ud=p['ud']; pool=p['cand_docs'][:P]
+        for d in rels:
+            k=np.searchsorted(ud,d); routehit+=int(k<len(ud) and int(ud[k])==d); poolhit+=int(np.any(pool==d))
+    for h in HGRID:runs[h][qid]=rank_h(p,h,100)
+    if (z+1)%100==0: print('q',z+1,'median',float(np.median(times)),'route',routehit/max(1,den),'pool',poolhit/max(1,den),flush=True)
+rows={}
+for h in HGRID:
+    met=m.eval_run(runs[h],qrels); rows[h]=met; print('H',h,met,flush=True)
+best=max(rows,key=lambda h:(rows[h]['nDCG@10'],rows[h]['MRR@10'],rows[h]['R@100']))
+out={'gamma_tail':float(GAMMA),'lambda_M':float(LAM),'P':P,'hgrid':rows,'best_h':int(best),'route_relevant_recall':routehit/den,'pool_relevant_recall':poolhit/den,'median_ms':float(np.median(times)),'p95_ms':float(np.percentile(times,95)),'avg_candidate_docs':float(np.mean(cands))}
+json.dump(out,open(WORK/'best_tail_validation.json','w'),indent=2); print('BEST',best,rows[best],flush=True); print('summary',out,flush=True)

experiments/msmarco_scale/msmarco_branch_coherence_multifold.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+import sys,time,json
+import numpy as np,pandas as pd
+from numba import njit,prange,set_num_threads
+sys.path.insert(0,'/mnt/data')
+import msmarco_early_lex_validation_fast as e
+import msmarco_full_search_uniform1m as m
+import msmarco_best_tail_core as b
+
+ROOT=m.ROOT; WORK=m.WORK; idx=e.idx; M=m.M; P=2000; S=m.S
+set_num_threads(5)
+WEIGHTS=[-2.0,-1.0,-0.5,-0.25,0.0,0.25,0.5,1.0]
+FINAL_B=np.float32(0.1); LEX_ALPHA=np.float32(0.25); WLEX=np.float32(4.0); WSEM=np.float32(0.3)
+
+def topk_desc(score,k):
+    n=len(score); k=min(k,n)
+    if n<=k:return np.argsort(score)[::-1]
+    ii=np.argpartition(score,-k)[-k:]
+    return ii[np.argsort(score[ii])[::-1]]
+
+@njit(parallel=True,cache=False)
+def selected_lex_features(dd,ip,ids,lexvec,dl,avgdl):
+    n=len(dd); lx=np.zeros(n,np.float32); qc=np.zeros(n,np.float32)
+    for z in prange(n):
+        d=int(dd[z]); a=int(ip[d]); bb=int(ip[d+1]); raw=0.0; c=0.0
+        for k in range(a,bb):
+            t=int(ids[k]); v=lexvec[t]
+            if v>0:
+                raw += v; c += 1.0
+        ratio=float(dl[d])/avgdl; den=(1.0-FINAL_B)+FINAL_B*ratio
+        lx[z]=raw/(den if den>0 else 1.0); qc[z]=c
+    return lx,qc
+
+@njit(cache=False)
+def find_doc(pd,a,bb,d):
+    lo=np.int64(a); hi=np.int64(bb)
+    while lo<hi:
+        md=(lo+hi)//2; x=int(pd[md])
+        if x<d: lo=md+1
+        else: hi=md
+    if lo<bb and int(pd[lo])==d:return lo
+    return -1
+
+@njit(parallel=True,cache=False)
+def coherence_features(dd,rterms,rd,offs,pd,pm,pr,ps,qd,ct,cv,rp,ri,rv):
+    n=len(dd); geom=np.zeros(n,np.float32); gabs=np.zeros(n,np.float32)
+    for zz in prange(n):
+        d=int(dd[zz]); gs=0.0; ab=0.0
+        for jj in range(len(rterms)):
+            j=int(rterms[jj]); a=int(offs[j]); bb=int(offs[j+1]); p=find_doc(pd,a,bb,d)
+            if p<0: continue
+            c=float(pm[p])*float(rd[j]); local=0.0; sig=0.0; bits=int(ps[p])
+            for r in range(S):
+                t=int(pr[p,r])
+                if t==65535: continue
+                qv=float(qd[t]); cen=float(m.lookup_center(ct[j],cv[j],t)); rel=float(m.lookup_rel(rp,ri,rv,j,t)); sgn=1.0 if ((bits>>r)&1) else -1.0
+                local += rel*(qv-cen)*sgn; sig += qv*qv
+            g=c*local*(sig**0.25 if sig>0 else 0.0)
+            gs += g; ab += abs(g)
+        geom[zz]=gs; gabs[zz]=ab
+    return geom,gabs
+
+def rank100(score):
+    n=len(score); k=min(100,n)
+    if n<=k: oo=np.argsort(score)[::-1]
+    else:
+        ii=np.argpartition(score,-k)[-k:]; oo=ii[np.argsort(score[ii])[::-1]]
+    return oo
+
+# Exact original fold-0 IDs, plus four new disjoint deterministic folds.
+z0=np.load(WORK/'amplitude_diag'/'fixed_eta1_pools.npz',allow_pickle=False)
+fold0=[str(x) for x in z0['qids'].tolist()]
+tr=pd.read_csv(ROOT/'train.tsv',sep='\t',usecols=['query-id'])
+uq=np.unique(tr['query-id'].to_numpy()); del tr
+f0set=set(int(x) for x in fold0)
+remaining=np.asarray([x for x in uq if int(x) not in f0set])
+rng=np.random.default_rng(20260816)
+extra=rng.choice(remaining,size=4000,replace=False)
+folds=[fold0]+[[str(x) for x in extra[i*1000:(i+1)*1000]] for i in range(4)]
+allids=[q for f in folds for q in f]
+texts=m.load_query_texts(allids)
+qrels_all=m.qrels_from_tsv(ROOT/'train.tsv',allids,positive_only=True)
+
+# warmup
+_=selected_lex_features(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.zeros(M,np.float32),idx.dl,idx.avgdl)
+q0=idx.query_vec(texts[allids[0]]); qd0=np.zeros(M,np.float32); qd0[q0.indices]=q0.data; rt0,rd0=idx.route(q0)
+_=coherence_features(np.array([0],np.uint32),rt0,rd0,idx.offs,idx.pd,idx.pm,idx.pr,idx.ps,qd0,idx.ct,idx.cv,idx.rp,idx.ri,idx.rv)
+_=e.prepare_all(texts[allids[0]])
+
+runs=[{w:{} for w in WEIGHTS} for _ in folds]
+times=[]
+start=time.time()
+for fi,ids in enumerate(folds):
+    print('FOLD',fi,'START',flush=True)
+    for qi,qid in enumerate(ids):
+        t0=time.perf_counter(); p=e.prepare_all(texts[qid])
+        if p is None:
+            for w in WEIGHTS:runs[fi][w][qid]=[]
+            continue
+        sel=topk_desc(m.zscore(p['tail'])+m.zscore(p['lex']),P)
+        dd=p['ud'][sel]; ts=p['tail'][sel]; sm=p['sem'][sel]
+        q=idx.query_vec(texts[qid]); lexvec=np.zeros(M,np.float32); lexvec[q.indices]=idx.idf[q.indices]
+        lx,qc=selected_lex_features(dd,idx.sup_ip,idx.sup_ids,lexvec,idx.dl,idx.avgdl)
+        cov=qc/max(1,len(q.indices)); ladj=lx*np.power(np.maximum(cov,1e-6),LEX_ALPHA)
+        qd=np.zeros(M,np.float32); qd[q.indices]=q.data; rterms,rd=idx.route(q)
+        geom,gabs=coherence_features(dd,rterms,rd,idx.offs,idx.pd,idx.pm,idx.pr,idx.ps,qd,idx.ct,idx.cv,idx.rp,idx.ri,idx.rv)
+        coh=geom/np.maximum(gabs,1e-6)
+        base=m.zscore(ts)+WLEX*m.zscore(ladj)+WSEM*m.zscore(sm)
+        for w in WEIGHTS:
+            sc=base+np.float32(w)*coh
+            oo=rank100(sc); runs[fi][w][qid]=[int(x) for x in dd[oo]]
+        times.append((time.perf_counter()-t0)*1000)
+        if (qi+1)%250==0:
+            print('fold',fi,'q',qi+1,'median_ms',float(np.median(times[-250:])),flush=True)
+
+rows=[]
+for fi,ids in enumerate(folds):
+    qr={q:qrels_all[q] for q in ids}
+    for w in WEIGHTS:
+        met=m.eval_run(runs[fi][w],qr); rows.append({'fold':fi,'weight':w,**met})
+        print('METRIC fold',fi,'w',w,'ndcg',met['nDCG@10'],'mrr',met['MRR@10'],'r100',met['R@100'],flush=True)
+summary=[]
+for w in WEIGHTS:
+    rr=[r for r in rows if r['weight']==w]
+    nd=np.asarray([r['nDCG@10'] for r in rr]); mr=np.asarray([r['MRR@10'] for r in rr]); r100=np.asarray([r['R@100'] for r in rr])
+    # Improvement relative to w=0 computed fold-wise.
+    base=[next(x for x in rows if x['fold']==fi and x['weight']==0.0) for fi in range(5)]
+    delta=np.asarray([rr[fi]['nDCG@10']-base[fi]['nDCG@10'] for fi in range(5)])
+    summary.append({'weight':w,'mean_nDCG@10':float(nd.mean()),'std_nDCG@10':float(nd.std(ddof=1)),'mean_MRR@10':float(mr.mean()),'mean_R@100':float(r100.mean()),'mean_delta_nDCG_vs_base':float(delta.mean()),'min_delta_nDCG_vs_base':float(delta.min()),'positive_folds':int(np.sum(delta>0)),'fold_deltas':delta.tolist()})
+summary.sort(key=lambda x:(x['positive_folds'],x['min_delta_nDCG_vs_base'],x['mean_delta_nDCG_vs_base']),reverse=True)
+out={'protocol':'5 disjoint 1000-query TRAIN folds; fold0 is original validation; folds1-4 are new deterministic samples; same eta=1 P=2000 pools and structural lexical b=.1 alpha=.25 wl4 raw-sem .3; branch coherence only','weights':WEIGHTS,'fold_rows':rows,'summary_ranked_for_robustness':summary,'timing':{'median_ms':float(np.median(times)),'p95_ms':float(np.percentile(times,95)),'seconds':time.time()-start}}
+path=WORK/'branch_coherence_multifold.json'; json.dump(out,open(path,'w'),indent=2)
+print('SUMMARY'); [print(x) for x in summary]; print('SAVED',path,flush=True)

experiments/msmarco_scale/msmarco_branch_features.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+import sys,time,json
+from pathlib import Path
+import numpy as np
+from numba import njit,prange,set_num_threads
+sys.path.insert(0,'/mnt/data')
+import msmarco_full_search_uniform1m as m
+import msmarco_best_tail_core as b
+ROOT=m.ROOT; WORK=m.WORK; OUT=WORK/'structural_fusion'; OUT.mkdir(exist_ok=True); idx=b.idx; set_num_threads(5); M=m.M; S=m.S
+z=np.load(WORK/'amplitude_diag'/'fixed_eta1_pools.npz',allow_pickle=False); qids=[str(x) for x in z['qids'].tolist()]; valid=z['valid'].astype(np.int32); docs=z['docs']; texts=m.load_query_texts(qids)
+@njit(cache=False)
+def find_doc(pd,a,bb,d):
+ lo=np.int64(a); hi=np.int64(bb)
+ while lo<hi:
+  md=(lo+hi)//2; x=int(pd[md])
+  if x<d: lo=md+1
+  else: hi=md
+ if lo<bb and int(pd[lo])==d:return lo
+ return -1
+@njit(parallel=True,cache=False)
+def pool_features(dd,rterms,rd,offs,pd,pm,pr,ps,qd,ct,cv,rp,ri,rv):
+ n=len(dd); geom=np.zeros(n,np.float32); cons=np.zeros(n,np.float32); bc=np.zeros(n,np.float32); gabs=np.zeros(n,np.float32); gmax=np.zeros(n,np.float32); cmax=np.zeros(n,np.float32); pos=np.zeros(n,np.float32); neg=np.zeros(n,np.float32)
+ for zz in prange(n):
+  d=int(dd[zz]); gs=0.; cs=0.; cnt=0.; ab=0.; mx=-1e30; cm=0.; pp=0.; nn=0.
+  for jj in range(len(rterms)):
+   j=int(rterms[jj]); a=int(offs[j]); bb=int(offs[j+1]); p=find_doc(pd,a,bb,d)
+   if p<0: continue
+   cnt+=1.; c=float(pm[p])*float(rd[j]); local=0.; sig=0.; bits=int(ps[p])
+   for r in range(S):
+    t=int(pr[p,r])
+    if t==65535: continue
+    qv=float(qd[t]); cen=float(m.lookup_center(ct[j],cv[j],t)); rel=float(m.lookup_rel(rp,ri,rv,j,t)); sgn=1. if ((bits>>r)&1) else -1.
+    local += rel*(qv-cen)*sgn; sig += qv*qv
+   g=c*local*(sig**0.25 if sig>0 else 0.)
+   gs+=g; cs+=c; ab+=abs(g); mx=max(mx,g); cm=max(cm,c); pp+=1. if g>0 else 0.; nn+=1. if g<0 else 0.
+  geom[zz]=gs; cons[zz]=cs; bc[zz]=cnt; gabs[zz]=ab; gmax[zz]=0 if mx<-1e20 else mx; cmax[zz]=cm; pos[zz]=pp; neg[zz]=nn
+ return geom,cons,bc,gabs,gmax,cmax,pos,neg
+# warmup
+q=idx.query_vec(texts[qids[0]]); qd=np.zeros(M,np.float32); qd[q.indices]=q.data; rt,rd=idx.route(q); _=pool_features(docs[0,:1],rt,rd,idx.offs,idx.pd,idx.pm,idx.pr,idx.ps,qd,idx.ct,idx.cv,idx.rp,idx.ri,idx.rv)
+shape=docs.shape; names=['geom','cons','branch_count','geom_abs','geom_max','cons_max','pos_count','neg_count']; arr={n:np.zeros(shape,np.float32) for n in names}; times=[]; errs=[]
+for i,qid in enumerate(qids):
+ k=int(valid[i]);
+ if not k:continue
+ q=idx.query_vec(texts[qid]); qd=np.zeros(M,np.float32); qd[q.indices]=q.data; rt,rd=idx.route(q); t=time.perf_counter(); vals=pool_features(docs[i,:k],rt,rd,idx.offs,idx.pd,idx.pm,idx.pr,idx.ps,qd,idx.ct,idx.cv,idx.rp,idx.ri,idx.rv); times.append((time.perf_counter()-t)*1000)
+ for nm,v in zip(names,vals): arr[nm][i,:k]=v
+ # reconstructed tail consistency
+ recon=vals[0]+.125*vals[1]; errs.append(float(np.max(np.abs(recon-z['tail'][i,:k]))))
+ if (i+1)%200==0:print(i+1,'median_ms',float(np.median(times)),'max_tail_err',max(errs),flush=True)
+np.savez_compressed(OUT/'branch_features.npz',qids=np.asarray(qids),valid=valid,**arr)
+meta={'protocol':'fixed eta=1 P=2000 validation pools; branch-level features recovered from current sorted branch postings only','features':names,'median_ms':float(np.median(times)),'p95_ms':float(np.percentile(times,95)),'max_tail_reconstruction_error':max(errs)}; json.dump(meta,open(OUT/'branch_feature_meta.json','w'),indent=2); print('DONE',meta,flush=True)

experiments/msmarco_scale/msmarco_branch_fusion_sweep.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+import sys,json
+import numpy as np
+sys.path.insert(0,'/mnt/data')
+import msmarco_full_search_uniform1m as m
+ROOT=m.ROOT; WORK=m.WORK; OUT=WORK/'structural_fusion'
+z=np.load(WORK/'amplitude_diag'/'fixed_eta1_pools.npz',allow_pickle=False); c=np.load(OUT/'coordination_features.npz',allow_pickle=False); g=np.load(OUT/'branch_features.npz',allow_pickle=False)
+qids=[str(x) for x in z['qids'].tolist()]; valid=z['valid'].astype(int); docs=z['docs']; T=z['tail']; SM=z['sem']; RAW=c['rawlex']; LF=c['lenfac']; QC=c['qcount']; QT=c['qterms'].astype(int)
+G=g['geom']; C=g['cons']; BC=g['branch_count']; GA=g['geom_abs']; GM=g['geom_max']; CM=g['cons_max']; PC=g['pos_count']; NC=g['neg_count']; qrels=m.qrels_from_tsv(ROOT/'train.tsv',qids,positive_only=True)
+def Z(x):return m.zscore(x)
+def top100(sc):
+ n=len(sc); k=min(100,n); ii=np.argpartition(sc,-k)[-k:] if n>k else np.arange(n); return ii[np.argsort(sc[ii])[::-1]]
+def common(i,k):
+ ratio=(LF[i,:k]-.8)/.2; lx=RAW[i,:k]/np.maximum(.9+.1*ratio,1e-6); cov=QC[i,:k]/max(1,QT[i]); ladj=lx*np.power(np.maximum(cov,1e-6),.25); return 4*Z(ladj)+.3*Z(SM[i,:k])
+def evalx(name,fn):
+ run={}
+ for i,qid in enumerate(qids):
+  k=valid[i]; sc=fn(i,k); oo=top100(sc); run[qid]=[int(x) for x in docs[i,oo]]
+ r={'name':name,**m.eval_run(run,qrels)}; print(name,round(r['nDCG@10'],6),round(r['MRR@10'],6),round(r['R@100'],6),flush=True); return r
+rows=[]; rows.append(evalx('struct_base',lambda i,k:Z(T[i,:k])+common(i,k)))
+# separate geometry and consensus
+for wc in [-2.,-1.,-.5,-.25,0.,.0625,.125,.25,.5,1.,2.,4.]: rows.append(evalx(f'split_wc{wc}',lambda i,k,wc=wc: Z(G[i,:k])+wc*Z(C[i,:k])+common(i,k)))
+# add extra consensus to current tail
+for w in [-2.,-1.,-.5,-.25,.25,.5,1.,2.]: rows.append(evalx(f'base_plus_cons{w}',lambda i,k,w=w: Z(T[i,:k])+common(i,k)+w*Z(C[i,:k])))
+# branch-count/diversity one-at-a-time
+for nm,X in [('bc',BC),('gabs',GA),('gmax',GM),('cmax',CM)]:
+ for w in [-1.,-.5,-.25,.25,.5,1.]: rows.append(evalx(f'base_{nm}_{w}',lambda i,k,w=w,X=X: Z(T[i,:k])+common(i,k)+w*Z(X[i,:k])))
+# coherence and positive fraction, bounded structural signals
+for w in [-2.,-1.,-.5,-.25,.25,.5,1.,2.]:
+ rows.append(evalx(f'coherence_{w}',lambda i,k,w=w: Z(T[i,:k])+common(i,k)+w*(G[i,:k]/np.maximum(GA[i,:k],1e-6))))
+ rows.append(evalx(f'posfrac_{w}',lambda i,k,w=w: Z(T[i,:k])+common(i,k)+w*(PC[i,:k]/np.maximum(PC[i,:k]+NC[i,:k],1.0))))
+# concentration penalty/bonus: max branch / total absolute evidence
+for w in [-1.,-.5,-.25,.25,.5,1.]: rows.append(evalx(f'concentration_{w}',lambda i,k,w=w: Z(T[i,:k])+common(i,k)+w*(GM[i,:k]/np.maximum(GA[i,:k],1e-6))))
+rows.sort(key=lambda r:(r['nDCG@10'],r['MRR@10'],r['R@100']),reverse=True); out={'protocol':'fixed eta=1 P=2000 TRAIN validation; branch-level structure from current index only; structural lexical base b=.1 alpha=.25 wl4 ws=.3','baseline':next(r for r in rows if r['name']=='struct_base'),'best':rows[0],'top25':rows[:25],'n_models':len(rows)}; json.dump(out,open(OUT/'branch_fusion_sweep.json','w'),indent=2); print('BEST',rows[0]); print('TOP10'); [print(r) for r in rows[:10]]

experiments/msmarco_scale/msmarco_build_geometry.py

@@ -0,0 +1,214 @@
+from __future__ import annotations
+import gzip,json,pickle,time,re,gc,os
+from pathlib import Path
+import numpy as np
+from scipy import sparse
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.preprocessing import normalize
+from numba import njit, prange, set_num_threads
+
+ROOT=Path('/mnt/data'); WORK=ROOT/'msmarco_scale_work'; GEOM=WORK/'geometry_1m'; GEOM.mkdir(parents=True,exist_ok=True)
+N_CAL=1_000_000; M=50_000; F=4; B=64; S=16; L=12; TAU=20.; BETA=-.2; EPS=1e-6
+GRAPH_TAU=10.; ASSOC_K=64; ROUTE_K=32
+SENT=np.uint16(65535)
+set_num_threads(5)
+
+def load_vocab():
+ with gzip.open(WORK/'final_vocab_50k.pkl.gz','rb') as g: z=pickle.load(g)
+ terms=z['terms'].tolist(); idf=np.asarray(z['idf'],np.float32)
+ return terms,idf,{t:i for i,t in enumerate(terms)}
+
+def shard_path(i):
+ hits=list(ROOT.glob(f'corpus_{i:04d}.jsonl*.gz')); assert len(hits)==1,(i,hits); return hits[0]
+
+def tfidf_shard(p,vocab,idf):
+ texts=[]
+ with gzip.open(p,'rt',encoding='utf-8') as f:
+  for line in f:
+   o=json.loads(line); texts.append(((o.get('title') or '')+' '+(o.get('text') or '')).strip())
+ cv=CountVectorizer(vocabulary=vocab,lowercase=True,token_pattern=r'(?u)\b\w\w+\b',dtype=np.int32)
+ X=cv.transform(texts).tocsr().astype(np.float32)
+ X.data *= idf[X.indices]
+ normalize(X,norm='l2',axis=1,copy=False)
+ X.sort_indices()
+ return X
+
+@njit(parallel=True,cache=False)
+def topk_memberships(indptr,indices,data,F):
+ N=indptr.size-1
+ branches=np.full((N,F),np.uint16(65535),np.uint16)
+ mem=np.zeros((N,F),np.float32)
+ topL=np.full((N,12),np.uint16(65535),np.uint16)
+ for d in prange(N):
+  a=indptr[d]; b=indptr[d+1]
+  # top 12 descending insertion
+  vals=np.zeros(12,np.float32); tids=np.full(12,np.uint16(65535),np.uint16)
+  for p in range(a,b):
+   v=data[p]; t=np.uint16(indices[p])
+   # locate insertion descending
+   pos=12
+   for r in range(12):
+    if v>vals[r]: pos=r; break
+   if pos<12:
+    for r in range(11,pos,-1): vals[r]=vals[r-1]; tids[r]=tids[r-1]
+    vals[pos]=v; tids[pos]=t
+  den=0.0
+  for s in range(F): den += vals[s]
+  if den>0:
+   for s in range(F):
+    branches[d,s]=tids[s]; mem[d,s]=vals[s]/den
+  for s in range(12): topL[d,s]=tids[s]
+ return branches,mem,topL
+
+@njit(cache=False)
+def lookup_center(ct,cv,t):
+ lo=0; hi=ct.size
+ while lo<hi:
+  mid=(lo+hi)//2; x=ct[mid]
+  if x==65535 or x>=t: hi=mid
+  else: lo=mid+1
+ if lo<ct.size and ct[lo]==t: return cv[lo]
+ return 0.0
+
+@njit(parallel=True,cache=False)
+def residual_codes(indptr,indices,data,branches,center_terms,center_values,S):
+ N=indptr.size-1; F=branches.shape[1]
+ rt=np.full((N,F,S),np.uint16(65535),np.uint16)
+ rs=np.zeros((N,F,S),np.int8)
+ for d in prange(N):
+  a=indptr[d]; b=indptr[d+1]
+  for sl in range(F):
+   j=int(branches[d,sl])
+   if j==65535: continue
+   best=np.zeros(S,np.float32); bt=np.full(S,np.uint16(65535),np.uint16); bs=np.zeros(S,np.int8)
+   for p in range(a,b):
+    t=np.uint16(indices[p]); r=data[p]-lookup_center(center_terms[j],center_values[j],t); ar=abs(r)
+    # replace current minimum
+    mi=0; mv=best[0]
+    for q in range(1,S):
+     if best[q]<mv: mi=q; mv=best[q]
+    if ar>mv:
+     best[mi]=ar; bt[mi]=t; bs[mi]=1 if r>=0 else -1
+   # sort retained residuals descending by magnitude for determinism
+   for x in range(S):
+    mx=x
+    for y in range(x+1,S):
+     if best[y]>best[mx]: mx=y
+    if mx!=x:
+     tv=best[x]; best[x]=best[mx]; best[mx]=tv
+     tt=bt[x]; bt[x]=bt[mx]; bt[mx]=tt
+     ss=bs[x]; bs[x]=bs[mx]; bs[mx]=ss
+   for q in range(S): rt[d,sl,q]=bt[q]; rs[d,sl,q]=bs[q]
+ return rt,rs
+
+
+def prune_rows(mat,k):
+ rows=[]; cols=[]; vals=[]; mat=mat.tocsr()
+ for r in range(mat.shape[0]):
+  a,b=mat.indptr[r],mat.indptr[r+1]; idx=mat.indices[a:b]; dat=mat.data[a:b]
+  if len(dat)==0: continue
+  kk=min(k,len(dat)); pick=np.argpartition(dat,-kk)[-kk:]; pick=pick[np.argsort(dat[pick])[::-1]]
+  rows.extend([r]*kk); cols.extend(idx[pick].tolist()); vals.extend(dat[pick].astype(np.float32).tolist())
+ return sparse.csr_matrix((np.asarray(vals,np.float32),(np.asarray(rows,np.int32),np.asarray(cols,np.int32))),shape=mat.shape)
+
+if __name__=='__main__':
+ t_all=time.time(); terms,idf,vocab=load_vocab(); np.save(GEOM/'idf.npy',idf); 
+ with gzip.open(GEOM/'terms.pkl.gz','wb',compresslevel=1) as g: pickle.dump(terms,g,protocol=5)
+ print('GEOMETRY calibration on first 1,000,000 passages; lexical basis from all 8.84M',flush=True)
+ # X calibration
+ xcache=GEOM/'cal_X.npz'
+ if xcache.exists():
+  X=sparse.load_npz(xcache).tocsr(); print(' X checkpoint loaded',X.shape,X.nnz,flush=True)
+ else:
+  xs=[]
+  for sid in range(4):
+   t=time.time(); Xs=tfidf_shard(shard_path(sid),vocab,idf); xs.append(Xs); print(' tfidf shard',sid,Xs.shape,Xs.nnz,'sec',time.time()-t,flush=True)
+  X=sparse.vstack(xs,format='csr'); del xs; gc.collect(); print(' X',X.shape,X.nnz,flush=True); sparse.save_npz(xcache,X,compressed=False); print(' X checkpoint saved',flush=True)
+ # branches/topL
+ if (GEOM/'cal_branches.npy').exists() and (GEOM/'cal_memberships.npy').exists() and (GEOM/'cal_topL.npy').exists():
+  branches=np.load(GEOM/'cal_branches.npy'); mem=np.load(GEOM/'cal_memberships.npy'); topL=np.load(GEOM/'cal_topL.npy'); print(' membership checkpoint loaded',flush=True)
+ else:
+  t=time.time(); branches,mem,topL=topk_memberships(X.indptr.astype(np.int64),X.indices.astype(np.int32),X.data.astype(np.float32),F); print(' memberships sec',time.time()-t,flush=True)
+  np.save(GEOM/'cal_branches.npy',branches); np.save(GEOM/'cal_memberships.npy',mem); np.save(GEOM/'cal_topL.npy',topL); print(' membership checkpoint saved',flush=True)
+ # centers exact using sparse algebra
+ if (GEOM/'center_terms.npy').exists() and (GEOM/'center_values.npy').exists():
+  center_terms=np.load(GEOM/'center_terms.npy'); center_values=np.load(GEOM/'center_values.npy'); print(' centers checkpoint loaded',flush=True)
+ else:
+  t=time.time(); wr=np.repeat(np.arange(N_CAL,dtype=np.int32),F); wc=branches.ravel().astype(np.int32); wd=mem.ravel(); valid=wc!=65535
+  W=sparse.csr_matrix((wd[valid],(wr[valid],wc[valid])),shape=(N_CAL,M),dtype=np.float32); del wr,wc,wd,valid
+  mass=np.asarray(W.sum(axis=0)).ravel().astype(np.float32)
+  center_terms=np.full((M,B),SENT,np.uint16); center_values=np.zeros((M,B),np.float32)
+  block=512
+  for start in range(0,M,block):
+   end=min(M,start+block); C=(W[:,start:end].T@X).tocsr()
+   for local in range(end-start):
+    j=start+local
+    if mass[j]<=0: continue
+    a,b=C.indptr[local],C.indptr[local+1]; idx=C.indices[a:b]; dat=C.data[a:b]/mass[j]
+    if len(dat)==0: continue
+    kk=min(B,len(dat)); pick=np.argpartition(dat,-kk)[-kk:]; ii=idx[pick]; vv=dat[pick]; oo=np.argsort(ii); ii=ii[oo]; vv=vv[oo]
+    center_terms[j,:kk]=ii.astype(np.uint16); center_values[j,:kk]=vv.astype(np.float32)
+   if start%4096==0: print(' centers',end,'/',M,flush=True)
+  np.save(GEOM/'center_terms.npy',center_terms); np.save(GEOM/'center_values.npy',center_values); del W,mass,C; gc.collect(); print(' centers sec',time.time()-t,flush=True)
+ # residuals
+ if (GEOM/'cal_res_terms.npy').exists() and (GEOM/'cal_res_signs.npy').exists():
+  rt=np.load(GEOM/'cal_res_terms.npy',mmap_mode='r'); rs=np.load(GEOM/'cal_res_signs.npy',mmap_mode='r'); print(' residual checkpoint loaded',flush=True)
+ else:
+  t=time.time(); rt,rs=residual_codes(X.indptr.astype(np.int64),X.indices.astype(np.int32),X.data.astype(np.float32),branches,center_terms,center_values,S); print(' residual sec',time.time()-t,flush=True); np.save(GEOM/'cal_res_terms.npy',rt); np.save(GEOM/'cal_res_signs.npy',rs); print(' residual checkpoint saved',flush=True)
+ # reliability global
+ total_memberships=int(np.sum(branches!=SENT)); gcnt=np.zeros(M,np.float64); gsum=np.zeros(M,np.float64)
+ for d0 in range(0,N_CAL,50_000):
+  tt=rt[d0:d0+50_000].ravel(); zz=rs[d0:d0+50_000].ravel().astype(np.float64); ok=tt!=SENT
+  gcnt += np.bincount(tt[ok].astype(np.int64),minlength=M)
+  gsum += np.bincount(tt[ok].astype(np.int64),weights=zz[ok],minlength=M)
+ ge2=gcnt/max(1,total_memberships); ge1=gsum/max(1,total_memberships); gvar=np.maximum(ge2-ge1*ge1,0.)
+ # branch order calibration
+ flat=branches.ravel(); valid=np.flatnonzero(flat!=SENT); order=valid[np.argsort(flat[valid],kind='stable')]; sorted_br=flat[order].astype(np.int64); counts=np.bincount(sorted_br,minlength=M); offs=np.zeros(M+1,np.int64); np.cumsum(counts,out=offs[1:])
+ f_rt=rt.reshape(N_CAL*F,S); f_rs=rs.reshape(N_CAL*F,S)
+ # Memory-bounded reliability CSR. Upper bound is one entry per residual occurrence.
+ max_rel=N_CAL*F*S
+ rel_i=np.memmap(GEOM/'rel_indices.u16',dtype=np.uint16,mode='w+',shape=(max_rel,))
+ rel_v=np.memmap(GEOM/'rel_data.f32',dtype=np.float32,mode='w+',shape=(max_rel,))
+ rel_p=np.zeros(M+1,np.uint64); pos_rel=0
+ t=time.time()
+ for j in range(M):
+  a,b=offs[j],offs[j+1]; mpos=order[a:b]; nj=len(mpos)
+  if nj>0:
+   tj=f_rt[mpos].ravel(); sj=f_rs[mpos].ravel().astype(np.float64); ok=tj!=SENT
+   if np.any(ok):
+    u,inv=np.unique(tj[ok],return_inverse=True); cnt=np.bincount(inv).astype(np.float64); sm=np.bincount(inv,weights=sj[ok]).astype(np.float64)
+    e2=cnt/nj; e1=sm/nj; lv=np.maximum(e2-e1*e1,0.); shr=(cnt/(cnt+TAU))*lv+(TAU/(cnt+TAU))*gvar[u.astype(np.int64)]; w=np.power(shr+EPS,BETA)
+    if len(w) and np.isfinite(w).all() and w.mean()>0: w=w/w.mean()
+    nrel=len(u); rel_i[pos_rel:pos_rel+nrel]=u.astype(np.uint16); rel_v[pos_rel:pos_rel+nrel]=w.astype(np.float32); pos_rel+=nrel
+  rel_p[j+1]=pos_rel
+  if j%5000==0 and j: print(' reliability branch',j,'pairs',pos_rel,flush=True)
+ rel_i.flush(); rel_v.flush(); np.save(GEOM/'rel_indptr.npy',rel_p); np.save(GEOM/'global_sign_var.npy',gvar.astype(np.float32));
+ with open(GEOM/'rel_meta.json','w') as f: json.dump({'nnz':int(pos_rel),'max_entries':int(max_rel)},f)
+ print(' reliability nnz',pos_rel,'sec',time.time()-t,flush=True)
+ del rt,rs,order,flat,valid,sorted_br,counts,offs,f_rt,f_rs,rel_i,rel_v,rel_p; gc.collect()
+ # graph exact from calibration topL: n_i and unordered pair counts
+ t=time.time(); flatL=topL.ravel(); good=flatL!=SENT; ni=np.bincount(flatL[good].astype(np.int64),minlength=M).astype(np.float64); del flatL,good
+ maxpairs=N_CAL*66; pairkeys=np.full(maxpairs,np.uint32(0xffffffff),np.uint32); pos=0
+ # vectorized per pair position across documents: only 66 loops, each handles 1m rows
+ for a in range(L):
+  ia=topL[:,a]
+  for b in range(a+1,L):
+   ib=topL[:,b]; ok=(ia!=SENT)&(ib!=SENT); n=int(ok.sum())
+   x=ia[ok].astype(np.uint32); y=ib[ok].astype(np.uint32); lo=np.minimum(x,y); hi=np.maximum(x,y); pairkeys[pos:pos+n]=(lo<<16)|hi; pos+=n
+ print(' pair occurrences',pos,'sorting...',flush=True); keys=pairkeys[:pos]; keys.sort(); del pairkeys,topL; gc.collect()
+ # run-length encode sorted keys without np.unique's large extra sort
+ change=np.empty(len(keys),dtype=bool); change[0]=True; change[1:]=keys[1:]!=keys[:-1]; starts=np.flatnonzero(change); ukeys=keys[starts].copy(); cnt=np.diff(np.append(starts,len(keys))).astype(np.float32); del keys,change,starts; gc.collect(); print(' unique pairs',len(ukeys),flush=True)
+ ii=(ukeys>>16).astype(np.int32); jj=(ukeys & np.uint32(65535)).astype(np.int32); nij=cnt.astype(np.float64); ppmi=np.log((nij*float(N_CAL)+1e-12)/(ni[ii]*ni[jj]+1e-12)); ppmi=np.maximum(ppmi,0.); score=(nij/(nij+GRAPH_TAU))*ppmi; mask=score>0; ii=ii[mask]; jj=jj[mask]; sv=score[mask].astype(np.float32); del ukeys,cnt,nij,ppmi,score,mask; gc.collect(); print(' positive pair edges',len(sv),flush=True)
+ rows=np.concatenate([ii,jj]); cols=np.concatenate([jj,ii]); vals=np.concatenate([sv,sv]); del ii,jj,sv; Afull=sparse.csr_matrix((vals,(rows,cols)),shape=(M,M)); del rows,cols,vals; gc.collect(); A=prune_rows(Afull,ASSOC_K); del Afull; gc.collect(); sparse.save_npz(GEOM/'assoc_ppmi.npz',A,compressed=True); print(' A nnz',A.nnz,flush=True)
+ An=normalize(A,norm='l2',axis=1,copy=True); gr=[]; gc2=[]; gv=[]; bs=256
+ for start in range(0,M,bs):
+  end=min(M,start+bs); sim=(An[start:end]@An.T).tocsr()
+  for local in range(end-start):
+   i=start+local; a,b=sim.indptr[local],sim.indptr[local+1]; js=sim.indices[a:b]; vv2=sim.data[a:b]; mk=(js!=i)&(vv2>0); js=js[mk]; vv2=vv2[mk]
+   if len(vv2)==0: continue
+   kk=min(ROUTE_K,len(vv2)); pk=np.argpartition(vv2,-kk)[-kk:]; pk=pk[np.argsort(vv2[pk])[::-1]]; gr.extend([i]*kk); gc2.extend(js[pk].tolist()); gv.extend(vv2[pk].astype(np.float32).tolist())
+  if start%4096==0: print(' G',end,'/',M,flush=True)
+ G=sparse.csr_matrix((np.asarray(gv,np.float32),(np.asarray(gr,np.int32),np.asarray(gc2,np.int32))),shape=(M,M)); sparse.save_npz(GEOM/'context_similarity.npz',G,compressed=True); print(' G nnz',G.nnz,'graph sec',time.time()-t,flush=True)
+ # Save metadata
+ with open(GEOM/'meta.json','w') as f: json.dump({'calibration_docs':N_CAL,'full_corpus_docs':8_841_823,'F':F,'B':B,'S':S,'L':L,'tau':TAU,'beta':BETA,'graph_tau':GRAPH_TAU,'assoc_k':ASSOC_K,'route_k':ROUTE_K,'build_seconds':time.time()-t_all},f,indent=2)
+ print('GEOMETRY DONE total sec',time.time()-t_all,flush=True)

experiments/msmarco_scale/msmarco_build_geometry_uniform1m.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+import gzip,json,pickle,time,gc
+from pathlib import Path
+import numpy as np
+from scipy import sparse
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.preprocessing import normalize
+from numba import set_num_threads
+import sys
+sys.path.insert(0,'/mnt/data')
+import msmarco_build_geometry as base
+
+ROOT=Path('/mnt/data'); WORK=ROOT/'msmarco_scale_work'; GEOM=WORK/'geometry_uniform1m'; GEOM.mkdir(parents=True,exist_ok=True)
+N=8_841_823; N_CAL=1_000_000; M=50_000; F=4; B=64; S=16; L=12
+TAU=20.; BETA=-.2; EPS=1e-6; GRAPH_TAU=10.; ASSOC_K=64; ROUTE_K=32
+SENT=np.uint16(65535); SEED=20260815
+set_num_threads(5)
+
+def load_vocab():
+    with gzip.open(WORK/'final_vocab_50k.pkl.gz','rb') as g: z=pickle.load(g)
+    terms=z['terms'].tolist(); idf=np.asarray(z['idf'],np.float32)
+    return terms,idf,{t:i for i,t in enumerate(terms)}
+
+def shard_path(i):
+    hits=list(ROOT.glob(f'corpus_{i:04d}.jsonl*.gz')); assert len(hits)==1,(i,hits); return hits[0]
+
+def selected_tfidf_shard(sid, wanted_local, vocab, idf):
+    wanted=np.asarray(wanted_local,np.int64)
+    texts=[]; p=0
+    if wanted.size==0:
+        return sparse.csr_matrix((0,M),dtype=np.float32)
+    with gzip.open(shard_path(sid),'rt',encoding='utf-8') as f:
+        for i,line in enumerate(f):
+            if p>=wanted.size: break
+            if i==wanted[p]:
+                o=json.loads(line); texts.append(((o.get('title') or '')+' '+(o.get('text') or '')).strip()); p+=1
+    assert p==wanted.size,(sid,p,wanted.size)
+    cv=CountVectorizer(vocabulary=vocab,lowercase=True,token_pattern=r'(?u)\b\w\w+\b',dtype=np.int32)
+    X=cv.transform(texts).tocsr().astype(np.float32); X.data*=idf[X.indices]; normalize(X,norm='l2',axis=1,copy=False); X.sort_indices()
+    return X
+
+def prune_rows(mat,k): return base.prune_rows(mat,k)
+
+if __name__=='__main__':
+    t_all=time.time(); terms,idf,vocab=load_vocab(); np.save(GEOM/'idf.npy',idf)
+    with gzip.open(GEOM/'terms.pkl.gz','wb',compresslevel=1) as g: pickle.dump(terms,g,protocol=5)
+    sp=GEOM/'sample_ids.npy'
+    if sp.exists(): sample=np.load(sp)
+    else:
+        rng=np.random.default_rng(SEED); sample=np.sort(rng.choice(N,size=N_CAL,replace=False).astype(np.int64)); np.save(sp,sample)
+    assert len(sample)==N_CAL and sample[0]>=0 and sample[-1]<N
+    print('UNIFORM GEOMETRY calibration: deterministic 1,000,000-sample across 8,841,823 passages; seed',SEED,flush=True)
+    print(' sample id range',int(sample[0]),int(sample[-1]),'mean',float(sample.mean()),flush=True)
+    xcache=GEOM/'cal_X.npz'
+    if xcache.exists():
+        X=sparse.load_npz(xcache).tocsr(); print(' X checkpoint loaded',X.shape,X.nnz,flush=True)
+    else:
+        xs=[]
+        for sid in range(36):
+            lo=sid*250_000; hi=min(N,lo+250_000); a=np.searchsorted(sample,lo); b=np.searchsorted(sample,hi); local=sample[a:b]-lo
+            t=time.time(); Xs=selected_tfidf_shard(sid,local,vocab,idf); xs.append(Xs)
+            print(' tfidf selected shard',sid,'n',Xs.shape[0],'nnz',Xs.nnz,'sec',time.time()-t,flush=True)
+        X=sparse.vstack(xs,format='csr'); del xs; gc.collect(); assert X.shape[0]==N_CAL
+        print(' X',X.shape,X.nnz,flush=True); sparse.save_npz(xcache,X,compressed=False); print(' X checkpoint saved',flush=True)
+    # memberships and topL
+    t=time.time(); branches,mem,topL=base.topk_memberships(X.indptr.astype(np.int64),X.indices.astype(np.int32),X.data.astype(np.float32),F)
+    print(' memberships sec',time.time()-t,flush=True); np.save(GEOM/'cal_branches.npy',branches); np.save(GEOM/'cal_memberships.npy',mem); np.save(GEOM/'cal_topL.npy',topL)
+    # centers
+    t=time.time(); wr=np.repeat(np.arange(N_CAL,dtype=np.int32),F); wc=branches.ravel().astype(np.int32); wd=mem.ravel(); valid=wc!=65535
+    W=sparse.csr_matrix((wd[valid],(wr[valid],wc[valid])),shape=(N_CAL,M),dtype=np.float32); del wr,wc,wd,valid
+    mass=np.asarray(W.sum(axis=0)).ravel().astype(np.float32)
+    center_terms=np.full((M,B),SENT,np.uint16); center_values=np.zeros((M,B),np.float32)
+    block=512
+    for start in range(0,M,block):
+        end=min(M,start+block); C=(W[:,start:end].T@X).tocsr()
+        for local in range(end-start):
+            j=start+local
+            if mass[j]<=0: continue
+            a,b=C.indptr[local],C.indptr[local+1]; idx=C.indices[a:b]; dat=C.data[a:b]/mass[j]
+            if len(dat)==0: continue
+            kk=min(B,len(dat)); pick=np.argpartition(dat,-kk)[-kk:]; ii=idx[pick]; vv=dat[pick]; oo=np.argsort(ii); ii=ii[oo]; vv=vv[oo]
+            center_terms[j,:kk]=ii.astype(np.uint16); center_values[j,:kk]=vv.astype(np.float32)
+        if start%4096==0: print(' centers',end,'/',M,flush=True)
+    np.save(GEOM/'center_terms.npy',center_terms); np.save(GEOM/'center_values.npy',center_values); del W,mass,C; gc.collect(); print(' centers sec',time.time()-t,flush=True)
+    # calibration residuals
+    t=time.time(); rt,rs=base.residual_codes(X.indptr.astype(np.int64),X.indices.astype(np.int32),X.data.astype(np.float32),branches,center_terms,center_values,S)
+    print(' residual sec',time.time()-t,flush=True); np.save(GEOM/'cal_res_terms.npy',rt); np.save(GEOM/'cal_res_signs.npy',rs)
+    # reliability
+    total_memberships=int(np.sum(branches!=SENT)); gcnt=np.zeros(M,np.float64); gsum=np.zeros(M,np.float64)
+    for d0 in range(0,N_CAL,50_000):
+        tt=rt[d0:d0+50_000].ravel(); zz=rs[d0:d0+50_000].ravel().astype(np.float64); ok=tt!=SENT
+        gcnt += np.bincount(tt[ok].astype(np.int64),minlength=M); gsum += np.bincount(tt[ok].astype(np.int64),weights=zz[ok],minlength=M)
+    ge2=gcnt/max(1,total_memberships); ge1=gsum/max(1,total_memberships); gvar=np.maximum(ge2-ge1*ge1,0.)
+    flat=branches.ravel(); valid=np.flatnonzero(flat!=SENT); order=valid[np.argsort(flat[valid],kind='stable')]; sorted_br=flat[order].astype(np.int64); counts=np.bincount(sorted_br,minlength=M); offs=np.zeros(M+1,np.int64); np.cumsum(counts,out=offs[1:])
+    f_rt=rt.reshape(N_CAL*F,S); f_rs=rs.reshape(N_CAL*F,S)
+    max_rel=N_CAL*F*S; rel_i=np.memmap(GEOM/'rel_indices.u16',dtype=np.uint16,mode='w+',shape=(max_rel,)); rel_v=np.memmap(GEOM/'rel_data.f32',dtype=np.float32,mode='w+',shape=(max_rel,)); rel_p=np.zeros(M+1,np.uint64); pos_rel=0; t=time.time()
+    for j in range(M):
+        a,b=offs[j],offs[j+1]; mpos=order[a:b]; nj=len(mpos)
+        if nj>0:
+            tj=f_rt[mpos].ravel(); sj=f_rs[mpos].ravel().astype(np.float64); ok=tj!=SENT
+            if np.any(ok):
+                u,inv=np.unique(tj[ok],return_inverse=True); cnt=np.bincount(inv).astype(np.float64); sm=np.bincount(inv,weights=sj[ok]).astype(np.float64)
+                e2=cnt/nj; e1=sm/nj; lv=np.maximum(e2-e1*e1,0.); shr=(cnt/(cnt+TAU))*lv+(TAU/(cnt+TAU))*gvar[u.astype(np.int64)]; w=np.power(shr+EPS,BETA)
+                if len(w) and np.isfinite(w).all() and w.mean()>0: w=w/w.mean()
+                nrel=len(u); rel_i[pos_rel:pos_rel+nrel]=u.astype(np.uint16); rel_v[pos_rel:pos_rel+nrel]=w.astype(np.float32); pos_rel+=nrel
+        rel_p[j+1]=pos_rel
+        if j%5000==0 and j: print(' reliability branch',j,'pairs',pos_rel,flush=True)
+    rel_i.flush(); rel_v.flush(); np.save(GEOM/'rel_indptr.npy',rel_p); np.save(GEOM/'global_sign_var.npy',gvar.astype(np.float32))
+    with open(GEOM/'rel_meta.json','w') as f: json.dump({'nnz':int(pos_rel),'max_entries':int(max_rel)},f)
+    print(' reliability nnz',pos_rel,'sec',time.time()-t,flush=True)
+    del rt,rs,order,flat,valid,sorted_br,counts,offs,f_rt,f_rs,rel_i,rel_v,rel_p; gc.collect()
+    # graph from same uniform calibration sample
+    t=time.time(); flatL=topL.ravel(); good=flatL!=SENT; ni=np.bincount(flatL[good].astype(np.int64),minlength=M).astype(np.float64); del flatL,good
+    maxpairs=N_CAL*66; pairkeys=np.full(maxpairs,np.uint32(0xffffffff),np.uint32); pos=0
+    for a in range(L):
+        ia=topL[:,a]
+        for b in range(a+1,L):
+            ib=topL[:,b]; ok=(ia!=SENT)&(ib!=SENT); n=int(ok.sum()); x=ia[ok].astype(np.uint32); y=ib[ok].astype(np.uint32); lo=np.minimum(x,y); hi=np.maximum(x,y); pairkeys[pos:pos+n]=(lo<<16)|hi; pos+=n
+    print(' pair occurrences',pos,'sorting...',flush=True); keys=pairkeys[:pos]; keys.sort(); del pairkeys,topL; gc.collect()
+    change=np.empty(len(keys),dtype=bool); change[0]=True; change[1:]=keys[1:]!=keys[:-1]; starts=np.flatnonzero(change); ukeys=keys[starts].copy(); cnt=np.diff(np.append(starts,len(keys))).astype(np.float32); del keys,change,starts; gc.collect(); print(' unique pairs',len(ukeys),flush=True)
+    ii=(ukeys>>16).astype(np.int32); jj=(ukeys & np.uint32(65535)).astype(np.int32); nij=cnt.astype(np.float64); ppmi=np.log((nij*float(N_CAL)+1e-12)/(ni[ii]*ni[jj]+1e-12)); ppmi=np.maximum(ppmi,0.); score=(nij/(nij+GRAPH_TAU))*ppmi; mask=score>0; ii=ii[mask]; jj=jj[mask]; sv=score[mask].astype(np.float32); del ukeys,cnt,nij,ppmi,score,mask; gc.collect(); print(' positive pair edges',len(sv),flush=True)
+    rows=np.concatenate([ii,jj]); cols=np.concatenate([jj,ii]); vals=np.concatenate([sv,sv]); del ii,jj,sv; Afull=sparse.csr_matrix((vals,(rows,cols)),shape=(M,M)); del rows,cols,vals; gc.collect(); A=prune_rows(Afull,ASSOC_K); del Afull; gc.collect(); sparse.save_npz(GEOM/'assoc_ppmi.npz',A,compressed=True); print(' A nnz',A.nnz,flush=True)
+    An=normalize(A,norm='l2',axis=1,copy=True); gr=[]; gc2=[]; gv=[]; bs=256
+    for start in range(0,M,bs):
+        end=min(M,start+bs); sim=(An[start:end]@An.T).tocsr()
+        for local in range(end-start):
+            i=start+local; a,b=sim.indptr[local],sim.indptr[local+1]; js=sim.indices[a:b]; vv2=sim.data[a:b]; mk=(js!=i)&(vv2>0); js=js[mk]; vv2=vv2[mk]
+            if len(vv2)==0: continue
+            kk=min(ROUTE_K,len(vv2)); pk=np.argpartition(vv2,-kk)[-kk:]; pk=pk[np.argsort(vv2[pk])[::-1]]; gr.extend([i]*kk); gc2.extend(js[pk].tolist()); gv.extend(vv2[pk].astype(np.float32).tolist())
+        if start%4096==0: print(' G',end,'/',M,flush=True)
+    G=sparse.csr_matrix((np.asarray(gv,np.float32),(np.asarray(gr,np.int32),np.asarray(gc2,np.int32))),shape=(M,M)); sparse.save_npz(GEOM/'context_similarity.npz',G,compressed=True); print(' G nnz',G.nnz,'graph sec',time.time()-t,flush=True)
+    with open(GEOM/'meta.json','w') as f: json.dump({'calibration_docs':N_CAL,'calibration':'deterministic uniform sample without replacement','seed':SEED,'full_corpus_docs':N,'F':F,'B':B,'S':S,'L':L,'tau':TAU,'beta':BETA,'graph_tau':GRAPH_TAU,'assoc_k':ASSOC_K,'route_k':ROUTE_K,'build_seconds':time.time()-t_all},f,indent=2)
+    print('UNIFORM GEOMETRY DONE total sec',time.time()-t_all,flush=True)

experiments/msmarco_scale/msmarco_build_s32_reliability.py

@@ -0,0 +1,36 @@
+from pathlib import Path
+import json,time,gc,os
+import numpy as np
+from scipy import sparse
+import sys
+sys.path.insert(0,'/mnt/data')
+import msmarco_build_geometry as base
+W=Path('/mnt/data/msmarco_scale_work'); SRC=W/'geometry_uniform1m'; G=W/'geometry_uniform1m_s32'; G.mkdir(exist_ok=True)
+N=1_000_000; M=50_000; F=4; S=32; TAU=20.; BETA=-.2; EPS=1e-6; SENT=np.uint16(65535)
+# geometry-independent files are symlinked
+for name in ['idf.npy','terms.pkl.gz','center_terms.npy','center_values.npy','assoc_ppmi.npz','context_similarity.npz','sample_ids.npy','cal_X.npz','cal_branches.npy','cal_memberships.npy','cal_topL.npy']:
+ p=G/name
+ if not p.exists(): p.symlink_to(SRC/name)
+X=sparse.load_npz(SRC/'cal_X.npz').tocsr(); branches=np.load(SRC/'cal_branches.npy'); ct=np.load(SRC/'center_terms.npy',mmap_mode='r'); cv=np.load(SRC/'center_values.npy',mmap_mode='r')
+t=time.time(); rt,rs=base.residual_codes(X.indptr.astype(np.int64),X.indices.astype(np.int32),X.data.astype(np.float32),branches,ct,cv,S); print('s32 residual sec',time.time()-t,flush=True); np.save(G/'cal_res_terms.npy',rt); np.save(G/'cal_res_signs.npy',rs)
+# reliability exact same estimator with S32 observations
+total_memberships=int(np.sum(branches!=SENT)); gcnt=np.zeros(M,np.float64); gsum=np.zeros(M,np.float64)
+for d0 in range(0,N,50_000):
+ tt=rt[d0:d0+50_000].ravel(); zz=rs[d0:d0+50_000].ravel().astype(np.float64); ok=tt!=SENT
+ gcnt += np.bincount(tt[ok].astype(np.int64),minlength=M); gsum += np.bincount(tt[ok].astype(np.int64),weights=zz[ok],minlength=M)
+ge2=gcnt/max(1,total_memberships); ge1=gsum/max(1,total_memberships); gvar=np.maximum(ge2-ge1*ge1,0.)
+flat=branches.ravel(); valid=np.flatnonzero(flat!=SENT); order=valid[np.argsort(flat[valid],kind='stable')]; sorted_br=flat[order].astype(np.int64); counts=np.bincount(sorted_br,minlength=M); offs=np.zeros(M+1,np.int64); np.cumsum(counts,out=offs[1:]); f_rt=rt.reshape(N*F,S); f_rs=rs.reshape(N*F,S)
+max_rel=N*F*S; rel_i=np.memmap(G/'rel_indices.u16',np.uint16,'w+',shape=(max_rel,)); rel_v=np.memmap(G/'rel_data.f32',np.float32,'w+',shape=(max_rel,)); rel_p=np.zeros(M+1,np.uint64); pos=0; t=time.time()
+for j in range(M):
+ a,b=offs[j],offs[j+1]; mpos=order[a:b]; nj=len(mpos)
+ if nj:
+  tj=f_rt[mpos].ravel(); sj=f_rs[mpos].ravel().astype(np.float64); ok=tj!=SENT
+  if np.any(ok):
+   u,inv=np.unique(tj[ok],return_inverse=True); cnt=np.bincount(inv).astype(np.float64); sm=np.bincount(inv,weights=sj[ok]).astype(np.float64); e2=cnt/nj; e1=sm/nj; lv=np.maximum(e2-e1*e1,0.); shr=(cnt/(cnt+TAU))*lv+(TAU/(cnt+TAU))*gvar[u.astype(np.int64)]; ww=np.power(shr+EPS,BETA)
+   if len(ww) and np.isfinite(ww).all() and ww.mean()>0: ww=ww/ww.mean()
+   n=len(u); rel_i[pos:pos+n]=u.astype(np.uint16); rel_v[pos:pos+n]=ww.astype(np.float32); pos+=n
+ rel_p[j+1]=pos
+ if j and j%5000==0: print('rel',j,pos,flush=True)
+rel_i.flush(); rel_v.flush(); np.save(G/'rel_indptr.npy',rel_p); np.save(G/'global_sign_var.npy',gvar.astype(np.float32)); json.dump({'nnz':int(pos),'max_entries':int(max_rel)},open(G/'rel_meta.json','w'))
+meta=json.load(open(SRC/'meta.json')); meta['S']=32; meta['capacity_test']='same uniform1m centers and graph; only residual width/reliability changed 16->32'; json.dump(meta,open(G/'meta.json','w'),indent=2)
+print('S32 REL DONE nnz',pos,'sec',time.time()-t,flush=True)

experiments/msmarco_scale/msmarco_coordination_features.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+import sys,time,json
+from pathlib import Path
+import numpy as np
+from numba import njit,prange,set_num_threads
+sys.path.insert(0,'/mnt/data')
+import msmarco_full_search_uniform1m as m
+ROOT=m.ROOT; WORK=m.WORK; OUT=WORK/'structural_fusion'; OUT.mkdir(exist_ok=True); set_num_threads(5)
+z=np.load(WORK/'amplitude_diag'/'fixed_eta1_pools.npz',allow_pickle=False); qids=[str(x) for x in z['qids'].tolist()]; valid=z['valid'].astype(np.int32); docs=z['docs']; idx=m.FullIndex(); M=m.M
+texts=m.load_query_texts(qids)
+@njit(parallel=True,cache=False)
+def extras(dd,ip,ids,lexvec,dl,avgdl):
+ n=len(dd); cnt=np.zeros(n,np.float32); raw=np.zeros(n,np.float32); lf=np.zeros(n,np.float32)
+ for z in prange(n):
+  d=int(dd[z]); a=int(ip[d]); b=int(ip[d+1]); c=0.0; r=0.0
+  for k in range(a,b):
+   t=int(ids[k]); v=lexvec[t]
+   if v>0: c+=1.; r+=v
+  cnt[z]=c; raw[z]=r; lf[z]=(1.0-m.LENGTH_B)+m.LENGTH_B*(float(dl[d])/avgdl)
+ return cnt,raw,lf
+_=extras(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.zeros(M,np.float32),idx.dl,idx.avgdl)
+COUNT=np.zeros_like(z['tail'],np.float32); RAW=np.zeros_like(COUNT); LF=np.zeros_like(COUNT); QTERMS=np.zeros(len(qids),np.int16); times=[]
+for i,qid in enumerate(qids):
+ k=int(valid[i]);
+ if not k:continue
+ q=idx.query_vec(texts[qid]); QTERMS[i]=len(q.indices); lv=np.zeros(M,np.float32); lv[q.indices]=idx.idf[q.indices]
+ t=time.perf_counter(); c,r,l=extras(docs[i,:k],idx.sup_ip,idx.sup_ids,lv,idx.dl,idx.avgdl); times.append((time.perf_counter()-t)*1000); COUNT[i,:k]=c; RAW[i,:k]=r; LF[i,:k]=l
+ if (i+1)%200==0: print(i+1,float(np.median(times)),flush=True)
+np.savez_compressed(OUT/'coordination_features.npz',qids=np.asarray(qids),valid=valid,qcount=COUNT,rawlex=RAW,lenfac=LF,qterms=QTERMS)
+print('DONE',float(np.median(times)),float(np.percentile(times,95)),flush=True)

experiments/msmarco_scale/msmarco_coordination_sweep.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+import sys,json,math
+from pathlib import Path
+import numpy as np
+sys.path.insert(0,'/mnt/data')
+import msmarco_full_search_uniform1m as m
+ROOT=m.ROOT; WORK=m.WORK; OUT=WORK/'structural_fusion'; OUT.mkdir(exist_ok=True)
+z=np.load(WORK/'amplitude_diag'/'fixed_eta1_pools.npz',allow_pickle=False); c=np.load(OUT/'coordination_features.npz',allow_pickle=False)
+qids=[str(x) for x in z['qids'].tolist()]; valid=z['valid'].astype(int); docs=z['docs']; T=z['tail']; L=z['lex']; S=z['sem']; QC=c['qcount']; RAW=c['rawlex']; LF=c['lenfac']; QT=c['qterms'].astype(int)
+qrels=m.qrels_from_tsv(ROOT/'train.tsv',qids,positive_only=True)
+
+def top100(sc):
+ n=len(sc); kk=min(100,n)
+ if n<=kk:return np.argsort(sc)[::-1]
+ ii=np.argpartition(sc,-kk)[-kk:]; return ii[np.argsort(sc[ii])[::-1]]
+
+def eval_model(name, scorer):
+ run={}
+ for i,qid in enumerate(qids):
+  k=valid[i]
+  if k<=0: run[qid]=[]; continue
+  sc=scorer(i,k); oo=top100(sc); run[qid]=[int(x) for x in docs[i,oo]]
+ met=m.eval_run(run,qrels); row={'name':name,**met}; print(name,round(met['nDCG@10'],6),round(met['MRR@10'],6),round(met['R@100'],6),flush=True); return row
+
+def Z(x): return m.zscore(x)
+rows=[]
+rows.append(eval_model('baseline',lambda i,k:Z(T[i,:k])+4*Z(L[i,:k])+.1*Z(S[i,:k])))
+# recover doc length ratio from current b=.2 denominator LF=.8+.2*r
+# stage 1: length correction b only, current fusion weights
+for bb in [0.,.05,.1,.15,.2,.3,.4,.5,.75,1.]:
+ def f(i,k,bb=bb):
+  r=(LF[i,:k]-.8)/.2; den=(1-bb)+bb*r; lx=RAW[i,:k]/np.maximum(den,1e-6); return Z(T[i,:k])+4*Z(lx)+.1*Z(S[i,:k])
+ rows.append(eval_model(f'length_b{bb}',f))
+# choose best length b by nDCG
+lenrows=[r for r in rows if r['name'].startswith('length_b')]; bestb=float(max(lenrows,key=lambda r:(r['nDCG@10'],r['MRR@10'],r['R@100']))['name'].split('length_b')[1]); print('BEST_B',bestb,flush=True)
+# stage 2: weights at best b
+for wl in [2.,3.,4.,5.,6.,8.,10.,12.]:
+ for ws in [0.,.05,.1,.2,.3]:
+  def f(i,k,bb=bestb,wl=wl,ws=ws):
+   r=(LF[i,:k]-.8)/.2; lx=RAW[i,:k]/np.maximum((1-bb)+bb*r,1e-6); return Z(T[i,:k])+wl*Z(lx)+ws*Z(S[i,:k])
+  rows.append(eval_model(f'bestb_wl{wl}_ws{ws}',f))
+weightrows=[r for r in rows if r['name'].startswith('bestb_')]; bestw=max(weightrows,key=lambda r:(r['nDCG@10'],r['MRR@10'],r['R@100'])); import re
+mt=re.search(r'wl([0-9.]+)_ws([0-9.]+)',bestw['name']); bestwl=float(mt.group(1)); bestws=float(mt.group(2)); print('BEST_W',bestwl,bestws,flush=True)
+# stage 3: add coordination count z-score
+for wc in [-2.,-1.,-.5,-.25,0.,.125,.25,.5,1.,2.,4.]:
+ def f(i,k,wc=wc,bb=bestb,wl=bestwl,ws=bestws):
+  r=(LF[i,:k]-.8)/.2; lx=RAW[i,:k]/np.maximum((1-bb)+bb*r,1e-6); return Z(T[i,:k])+wl*Z(lx)+ws*Z(S[i,:k])+wc*Z(QC[i,:k])
+ rows.append(eval_model(f'coord_wc{wc}',f))
+# stage 4: coordination-adjusted lexical score lx*(coverage)^alpha; keep weights and also tune lex weight modestly
+for alpha in [.125,.25,.5,1.,1.5,2.]:
+ for wl in [bestwl*.75,bestwl,bestwl*1.25]:
+  def f(i,k,alpha=alpha,wl=wl,bb=bestb,ws=bestws):
+   r=(LF[i,:k]-.8)/.2; lx=RAW[i,:k]/np.maximum((1-bb)+bb*r,1e-6); cov=QC[i,:k]/max(1,QT[i]); ladj=lx*np.power(np.maximum(cov,1e-6),alpha); return Z(T[i,:k])+wl*Z(ladj)+ws*Z(S[i,:k])
+  rows.append(eval_model(f'coordlex_a{alpha}_wl{wl}',f))
+# stage 5: exact all-query-terms and high-coverage bonuses (z of binary masks)
+for thr in [.5,.67,.75,.8,1.0]:
+ for wb in [.125,.25,.5,1.,2.]:
+  def f(i,k,thr=thr,wb=wb,bb=bestb,wl=bestwl,ws=bestws):
+   r=(LF[i,:k]-.8)/.2; lx=RAW[i,:k]/np.maximum((1-bb)+bb*r,1e-6); cov=QC[i,:k]/max(1,QT[i]); bonus=(cov>=thr).astype(np.float32); return Z(T[i,:k])+wl*Z(lx)+ws*Z(S[i,:k])+wb*bonus
+  rows.append(eval_model(f'covbonus_thr{thr}_wb{wb}',f))
+rows.sort(key=lambda r:(r['nDCG@10'],r['MRR@10'],r['R@100']),reverse=True)
+out={'protocol':'same fixed eta=1 P=2000 TRAIN validation pools; only existing-index lexical/coordination structure; no candidate changes','baseline':next(r for r in rows if r['name']=='baseline'),'best':rows[0],'top30':rows[:30],'best_length_b':bestb,'best_weight_base':bestw,'n_models':len(rows)}
+json.dump(out,open(OUT/'coordination_sweep.json','w'),indent=2); print('===BEST==='); print(json.dumps(rows[0],indent=2)); print('TOP10'); [print(r) for r in rows[:10]]

experiments/msmarco_scale/msmarco_covbonus_sweep.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+import sys,json
+from pathlib import Path
+import numpy as np
+sys.path.insert(0,'/mnt/data')
+import msmarco_full_search_uniform1m as m
+ROOT=m.ROOT; WORK=m.WORK; OUT=WORK/'structural_fusion'
+z=np.load(WORK/'amplitude_diag'/'fixed_eta1_pools.npz',allow_pickle=False); c=np.load(OUT/'coordination_features.npz',allow_pickle=False)
+qids=[str(x) for x in z['qids'].tolist()]; valid=z['valid'].astype(int); docs=z['docs']; T=z['tail']; S=z['sem']; RAW=c['rawlex']; LF=c['lenfac']; QC=c['qcount']; QT=c['qterms'].astype(int); qrels=m.qrels_from_tsv(ROOT/'train.tsv',qids,positive_only=True)
+def top100(sc):
+ n=len(sc); kk=min(100,n); ii=np.argpartition(sc,-kk)[-kk:] if n>kk else np.arange(n); return ii[np.argsort(sc[ii])[::-1]]
+def evalx(name,fn):
+ run={}
+ for i,qid in enumerate(qids):
+  k=valid[i]; sc=fn(i,k); oo=top100(sc); run[qid]=[int(x) for x in docs[i,oo]]
+ r={'name':name,**m.eval_run(run,qrels)}; print(name,r['nDCG@10'],r['MRR@10'],r['R@100'],flush=True); return r
+def Z(x):return m.zscore(x)
+def base(i,k,alpha=.25):
+ ratio=(LF[i,:k]-.8)/.2; lx=RAW[i,:k]/np.maximum(.9+.1*ratio,1e-6); cov=QC[i,:k]/max(1,QT[i]); ladj=lx*np.power(np.maximum(cov,1e-6),alpha); return Z(T[i,:k])+4*Z(ladj)+.3*Z(S[i,:k]),cov
+rows=[]
+rows.append(evalx('struct_base',lambda i,k:base(i,k)[0]))
+for thr in [.4,.5,.6,.67,.75,.8,.9,1.0]:
+ for wb in [.05,.1,.2,.3,.5,.75,1.0]:
+  rows.append(evalx(f'bonus_t{thr}_w{wb}',lambda i,k,thr=thr,wb=wb: base(i,k)[0]+wb*(base(i,k)[1]>=thr).astype(np.float32)))
+rows.sort(key=lambda r:(r['nDCG@10'],r['MRR@10'],r['R@100']),reverse=True); out={'protocol':'fixed direct eta=1 P=2000 validation pool; structural base b=.1 alpha=.25 wl=4 ws=.3 plus coverage threshold bonus','best':rows[0],'top20':rows[:20]}; json.dump(out,open(OUT/'coverage_bonus_sweep.json','w'),indent=2); print('BEST',rows[0])

experiments/msmarco_scale/msmarco_dev_fast.py

@@ -0,0 +1,27 @@
+import sys,time,json,numpy as np,pandas as pd
+sys.path.insert(0,'/mnt/data')
+from msmarco_full_search_fast import FullIndex,load_query_texts,qrels_from_tsv,eval_run,ROOT,WORK,P
+BEST_H=0
+idx=FullIndex(); print('loaded',idx.meta,flush=True)
+df=pd.read_csv(ROOT/'dev.tsv',sep='\t',usecols=['query-id']); ids=[str(x) for x in np.unique(df['query-id'].to_numpy())]; del df
+texts=load_query_texts(ids); qrels=qrels_from_tsv(ROOT/'dev.tsv',ids,positive_only=True)
+# warm compile/pages, not timed
+w=idx.prepare(texts[ids[0]],hmax=1); idx.rank_h(w,0,100); del w
+run={}; times=[]; cands=[]; mems=[]
+route_num=pool_num=rel_den=0
+for z,qid in enumerate(ids):
+ t=time.perf_counter(); pp=idx.prepare(texts[qid],hmax=1); rank=idx.rank_h(pp,BEST_H,100); dt=(time.perf_counter()-t)*1000
+ run[qid]=rank; times.append(dt); cands.append(pp['candidate_docs'] if pp else 0); mems.append(pp['candidate_memberships'] if pp else 0)
+ rel=[int(d) for d,r in qrels[qid].items() if r>0]; rel_den+=len(rel)
+ if pp is not None:
+  ud=pp['ud']; pool=pp['cand_docs'][:P]
+  for d in rel:
+   k=np.searchsorted(ud,d); route_num += int(k<len(ud) and int(ud[k])==d); pool_num += int(np.any(pool==d))
+ if (z+1)%500==0:
+  print('dev',z+1,'median_ms',float(np.median(times)),'p95_ms',float(np.percentile(times,95)),'avgcand',float(np.mean(cands)),'route_rel',route_num/rel_den,'pool_rel',pool_num/rel_den,flush=True)
+m=eval_run(run,qrels)
+timing={'median_ms':float(np.median(times)),'p95_ms':float(np.percentile(times,95)),'mean_ms':float(np.mean(times)),'qps':1000/float(np.mean(times)),'avg_candidate_docs':float(np.mean(cands)),'median_candidate_docs':float(np.median(cands)),'avg_candidate_memberships':float(np.mean(mems))}
+stages={'routed_relevant_recall':route_num/rel_den,'pool_P2000_relevant_recall':pool_num/rel_den,'final_R100':m['R@100'],'total_positive_qrels':rel_den}
+out={'protocol':'h=0 selected on deterministic 1000-query TRAIN validation sweep; full 6980-query DEV untouched','best_h':0,'dev_metrics':m,'timing':timing,'stage_diagnostics':stages,'index_meta':idx.meta,'geometry_note':'full 8.84M vocabulary/IDF; geometric codebook calibrated on first 1M passages','physical_optimizations':'branch-sorted postings; query-local dense center/reliability lookup; global compact support CSR; ranking verified identical on regression queries'}
+with open(WORK/'full_msmarco_dev_fast_results.json','w') as f: json.dump(out,f,indent=2)
+print('DEV_METRICS',m,flush=True); print('TIMING',timing,flush=True); print('STAGES',stages,flush=True); print('saved',WORK/'full_msmarco_dev_fast_results.json',flush=True)

experiments/msmarco_scale/msmarco_early_lex_dev.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+import sys,time,json
+import numpy as np,pandas as pd
+from numba import set_num_threads
+sys.path.insert(0,'/mnt/data')
+import msmarco_best_tail_core as b
+import msmarco_full_search_uniform1m as m
+ROOT=m.ROOT; WORK=m.WORK; idx=b.idx; M=m.M; P=2000
+ETA=np.float32(1.0); QUOTA=500; LLEX=np.float32(4.0); LSEM=np.float32(0.1)
+set_num_threads(5)
+
+def topk_desc(score,k):
+ n=len(score); k=min(k,n)
+ if k<=0:return np.empty(0,np.int64)
+ if n>k:
+  ii=np.argpartition(score,-k)[-k:]
+  return ii[np.argsort(score[ii])[::-1]]
+ return np.argsort(score)[::-1]
+
+def quota_select(tail,lex,lq=500):
+ n=len(tail); k=min(P,n); gq=k-min(lq,k); gt=topk_desc(tail,gq)
+ if gq==k:return gt
+ lex_order=topk_desc(lex,min(n,2*P)); chosen=np.zeros(n,np.uint8); chosen[gt]=1; out=np.empty(k,np.int64); out[:gq]=gt; z=gq
+ for ii in lex_order:
+  if chosen[ii]==0:
+   chosen[ii]=1; out[z]=ii; z+=1
+   if z==k:return out
+ # fallback
+ for ii in np.argsort(lex)[::-1]:
+  if chosen[ii]==0:
+   out[z]=ii; z+=1
+   if z==k:return out
+ return out[:z]
+
+def prepare_geometry_lex(text):
+ q=idx.query_vec(text); qd=np.zeros(M,np.float32); qd[q.indices]=q.data; rterms,rd=idx.route(q)
+ spans=[(int(j),int(idx.offs[j]),int(idx.offs[j+1])) for j in rterms if idx.offs[j+1]>idx.offs[j]]
+ if not spans:return None
+ docs=np.concatenate([np.asarray(idx.pd[a:bb]) for j,a,bb in spans]).astype(np.uint32,copy=False)
+ mm=np.concatenate([np.asarray(idx.pm[a:bb]) for j,a,bb in spans]).astype(np.float32,copy=False)
+ rt=np.concatenate([np.asarray(idx.pr[a:bb]) for j,a,bb in spans]).astype(np.uint16,copy=False)
+ sb=np.concatenate([np.asarray(idx.ps[a:bb]) for j,a,bb in spans]).astype(np.uint16,copy=False)
+ nr=len(spans); cent=np.zeros((nr,M),np.float32); rel=np.zeros((nr,M),np.float32); rho=np.empty(nr,np.float32)
+ for u,(j,a,bb) in enumerate(spans):
+  rowt=np.asarray(idx.ct[j]); ok=rowt!=65535; tids=rowt[ok].astype(np.int32,copy=False); cent[u,tids]=np.asarray(idx.cv[j])[ok]
+  ra=int(idx.rp[j]); rb=int(idx.rp[j+1]); rel[u,np.asarray(idx.ri[ra:rb],np.int32)]=np.asarray(idx.rv[ra:rb]); rho[u]=rd[j]
+ rslot=np.concatenate([np.full(bb-a,u,dtype=np.uint8) for u,(j,a,bb) in enumerate(spans)])
+ base,sig,cons=b.score_components(rslot,mm,rt,sb,qd,rho,cent,rel)
+ ud,inv=np.unique(docs,return_inverse=True)
+ tail=np.bincount(inv,weights=base*np.power(sig,b.GAMMA,dtype=np.float32),minlength=len(ud)).astype(np.float32)+b.LAM*np.bincount(inv,weights=cons,minlength=len(ud)).astype(np.float32)
+ lexvec=np.zeros(M,np.float32); lexvec[q.indices]=idx.idf[q.indices]; zero=np.zeros(M,np.float32)
+ lex,_=m.score_support_pool(ud,idx.sup_ip,idx.sup_ids,lexvec,zero,idx.dl,idx.avgdl)
+ semvec=np.zeros(M,np.float32)
+ for t,amp in zip(q.indices,q.data):
+  a,bb=idx.A.indptr[t],idx.A.indptr[t+1]; nb=idx.A.indices[a:bb][:m.SEMK]; sv=idx.A.data[a:bb][:m.SEMK]; semvec[nb]+=float(amp)*sv*idx.idf[nb]
+ return {'ud':ud,'tail':tail,'lex':lex,'semvec':semvec,'candidate_memberships':len(docs)}
+
+def rank_selected(p,sel):
+ docs=p['ud'][sel]; ts=p['tail'][sel]; lx=p['lex'][sel]; zero=np.zeros(M,np.float32)
+ _,sem=m.score_support_pool(docs,idx.sup_ip,idx.sup_ids,zero,p['semvec'],idx.dl,idx.avgdl)
+ fin=m.zscore(ts)+LLEX*m.zscore(lx)+LSEM*m.zscore(sem); oo=np.argsort(fin)[::-1][:100]
+ return [int(x) for x in docs[oo]]
+
+def select_direct(p):return topk_desc(m.zscore(p['tail'])+ETA*m.zscore(p['lex']),P)
+
+df=pd.read_csv(ROOT/'dev.tsv',sep='\t',usecols=['query-id']); ids=[str(x) for x in np.unique(df['query-id'].to_numpy())]; del df
+texts=m.load_query_texts(ids); qrels=m.qrels_from_tsv(ROOT/'dev.tsv',ids,positive_only=True)
+p=prepare_geometry_lex(texts[ids[0]]); sd=select_direct(p); _=rank_selected(p,sd); del p
+runD={}; runQ={}; timesD=[]; routehit=poolD=poolQ=den=0; cands=[]
+for z,qid in enumerate(ids):
+ t=time.perf_counter(); p=prepare_geometry_lex(texts[qid])
+ if p is None: runD[qid]=[]; runQ[qid]=[]; continue
+ sd=select_direct(p); rd=rank_selected(p,sd); timesD.append((time.perf_counter()-t)*1000); runD[qid]=rd
+ sq=quota_select(p['tail'],p['lex'],QUOTA); runQ[qid]=rank_selected(p,sq)
+ ud=p['ud']; cands.append(len(ud)); rels=[int(d) for d,r in qrels[qid].items() if r>0]; den+=len(rels); setD=set(map(int,sd)); setQ=set(map(int,sq))
+ for d in rels:
+  kk=np.searchsorted(ud,d); ok=kk<len(ud) and int(ud[kk])==d; routehit+=int(ok)
+  if ok: poolD+=int(int(kk) in setD); poolQ+=int(int(kk) in setQ)
+ if (z+1)%500==0:print('dev',z+1,'median_direct_ms',float(np.median(timesD)),'route',routehit/max(1,den),'poolD',poolD/max(1,den),'poolQ',poolQ/max(1,den),flush=True)
+metD=m.eval_run(runD,qrels); metQ=m.eval_run(runQ,qrels)
+out={'protocol':'shortlist strategy locked on deterministic TRAIN validation; DEV untouched','selected':{'strategy':'direct early lexical fusion','eta':1.0,'P':2000,'gamma_tail':0.25,'lambda_M':0.125,'lambda_lex_final':4.0,'lambda_sem_final':0.1,'h':0},'secondary_validation_fixed_comparator':{'strategy':'quota rescue','lex_quota':500},'direct_dev_metrics':metD,'quota500_dev_metrics':metQ,'route_relevant_recall':routehit/den,'direct_pool_relevant_recall':poolD/den,'quota_pool_relevant_recall':poolQ/den,'direct_timing':{'median_ms':float(np.median(timesD)),'p95_ms':float(np.percentile(timesD,95)),'mean_ms':float(np.mean(timesD)),'qps':1000/float(np.mean(timesD)),'avg_candidate_docs':float(np.mean(cands))}}
+json.dump(out,open(WORK/'early_lex_dev_results.json','w'),indent=2); print('DIRECT_DEV',metD,flush=True); print('QUOTA_DEV',metQ,flush=True); print('SUMMARY',out,flush=True)

experiments/msmarco_scale/msmarco_early_lex_direct.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+import sys,time,json
+import numpy as np,pandas as pd
+from numba import set_num_threads
+sys.path.insert(0,'/mnt/data')
+import msmarco_best_tail_core as b
+import msmarco_full_search_uniform1m as m
+ROOT=m.ROOT; WORK=m.WORK; idx=b.idx; M=m.M; P=2000
+LLEX=np.float32(4.0); LSEM=np.float32(0.1)
+ETAS=[0.0,0.125,0.25,0.5,1.0,2.0,4.0]
+set_num_threads(5)
+
+def topk_desc(score,k):
+ n=len(score); k=min(k,n)
+ if n>k:
+  ii=np.argpartition(score,-k)[-k:]
+  return ii[np.argsort(score[ii])[::-1]]
+ return np.argsort(score)[::-1]
+
+def prepare_all(text):
+ q=idx.query_vec(text); qd=np.zeros(M,np.float32); qd[q.indices]=q.data; rterms,rd=idx.route(q)
+ spans=[(int(j),int(idx.offs[j]),int(idx.offs[j+1])) for j in rterms if idx.offs[j+1]>idx.offs[j]]
+ if not spans:return None
+ docs=np.concatenate([np.asarray(idx.pd[a:bb]) for j,a,bb in spans]).astype(np.uint32,copy=False)
+ mm=np.concatenate([np.asarray(idx.pm[a:bb]) for j,a,bb in spans]).astype(np.float32,copy=False)
+ rt=np.concatenate([np.asarray(idx.pr[a:bb]) for j,a,bb in spans]).astype(np.uint16,copy=False)
+ sb=np.concatenate([np.asarray(idx.ps[a:bb]) for j,a,bb in spans]).astype(np.uint16,copy=False)
+ nr=len(spans); cent=np.zeros((nr,M),np.float32); rel=np.zeros((nr,M),np.float32); rho=np.empty(nr,np.float32)
+ for u,(j,a,bb) in enumerate(spans):
+  rowt=np.asarray(idx.ct[j]); ok=rowt!=65535; tids=rowt[ok].astype(np.int32,copy=False); cent[u,tids]=np.asarray(idx.cv[j])[ok]
+  ra=int(idx.rp[j]); rb=int(idx.rp[j+1]); rel[u,np.asarray(idx.ri[ra:rb],np.int32)]=np.asarray(idx.rv[ra:rb]); rho[u]=rd[j]
+ rslot=np.concatenate([np.full(bb-a,u,dtype=np.uint8) for u,(j,a,bb) in enumerate(spans)])
+ base,sig,cons=b.score_components(rslot,mm,rt,sb,qd,rho,cent,rel)
+ ud,inv=np.unique(docs,return_inverse=True)
+ tail=np.bincount(inv,weights=base*np.power(sig,b.GAMMA,dtype=np.float32),minlength=len(ud)).astype(np.float32)+b.LAM*np.bincount(inv,weights=cons,minlength=len(ud)).astype(np.float32)
+ lexvec=np.zeros(M,np.float32); lexvec[q.indices]=idx.idf[q.indices]; semvec=np.zeros(M,np.float32)
+ for t,amp in zip(q.indices,q.data):
+  a,bb=idx.A.indptr[t],idx.A.indptr[t+1]; nb=idx.A.indices[a:bb][:m.SEMK]; sv=idx.A.data[a:bb][:m.SEMK]; semvec[nb]+=float(amp)*sv*idx.idf[nb]
+ lex,sem=m.score_support_pool(ud,idx.sup_ip,idx.sup_ids,lexvec,semvec,idx.dl,idx.avgdl)
+ return ud,tail,lex,sem
+
+def rank(ud,tail,lex,sem,sel):
+ fin=m.zscore(tail[sel])+LLEX*m.zscore(lex[sel])+LSEM*m.zscore(sem[sel]); oo=np.argsort(fin)[::-1][:100]; return [int(x) for x in ud[sel[oo]]]
+
+tr=pd.read_csv(ROOT/'train.tsv',sep='\t',usecols=['query-id']); uq=np.unique(tr['query-id'].to_numpy()); rng=np.random.default_rng(20260815); ids=[str(x) for x in rng.choice(uq,size=1000,replace=False)]; del tr
+texts=m.load_query_texts(ids); qrels=m.qrels_from_tsv(ROOT/'train.tsv',ids,positive_only=True)
+_=prepare_all(texts[ids[0]])
+runs={e:{} for e in ETAS}; pool={e:0 for e in ETAS}; den=route=0; times=[]; strategy_times=[]
+for z,qid in enumerate(ids):
+ t=time.perf_counter(); p=prepare_all(texts[qid]); times.append((time.perf_counter()-t)*1000)
+ if p is None:
+  for e in ETAS:runs[e][qid]=[]
+  continue
+ ud,tail,lex,sem=p; rels=[int(d) for d,r in qrels[qid].items() if r>0]; den+=len(rels); relset=set()
+ for d in rels:
+  kk=np.searchsorted(ud,d); ok=kk<len(ud) and int(ud[kk])==d; route+=int(ok)
+  if ok:relset.add(int(kk))
+ zt=m.zscore(tail); zl=m.zscore(lex)
+ st=time.perf_counter()
+ for e in ETAS:
+  sel=topk_desc(zt+np.float32(e)*zl,P); pool[e]+=sum(int(i) in relset for i in sel); runs[e][qid]=rank(ud,tail,lex,sem,sel)
+ strategy_times.append((time.perf_counter()-st)*1000)
+ if (z+1)%100==0:print('q',z+1,'prepare',float(np.median(times)),'strategies',float(np.median(strategy_times)),flush=True)
+rows=[]
+for e in ETAS:
+ met=m.eval_run(runs[e],qrels); row={'eta':e,'pool_relevant_recall':pool[e]/den,**met}; rows.append(row); print('DIRECT',row,flush=True)
+rows.sort(key=lambda r:(r['nDCG@10'],r['MRR@10'],r['R@100']),reverse=True)
+out={'rows':rows,'best':rows[0],'route_relevant_recall':route/den,'timing':{'median_prepare_alllexsem_ms':float(np.median(times)),'p95_prepare_ms':float(np.percentile(times,95)),'median_all_eta_strategy_ms':float(np.median(strategy_times))}}
+json.dump(out,open(WORK/'early_lex_direct_validation.json','w'),indent=2); print('BEST',rows[0]); print('TIMING',out['timing'])

experiments/msmarco_scale/msmarco_early_lex_quota.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+import sys,time,json
+import numpy as np,pandas as pd
+from numba import set_num_threads
+sys.path.insert(0,'/mnt/data')
+import msmarco_best_tail_core as b
+import msmarco_full_search_uniform1m as m
+ROOT=m.ROOT; WORK=m.WORK; idx=b.idx; M=m.M; P=2000
+LLEX=np.float32(4.0); LSEM=np.float32(0.1)
+QUOTAS=[0,100,250,500,750,1000,1250,1500,1750,2000]
+set_num_threads(5)
+
+def topk_desc(score,k):
+ n=len(score); k=min(k,n)
+ if k<=0:return np.empty(0,np.int64)
+ if n>k:
+  ii=np.argpartition(score,-k)[-k:]
+  return ii[np.argsort(score[ii])[::-1]]
+ return np.argsort(score)[::-1]
+
+def prepare_all(text):
+ q=idx.query_vec(text); qd=np.zeros(M,np.float32); qd[q.indices]=q.data; rterms,rd=idx.route(q)
+ spans=[(int(j),int(idx.offs[j]),int(idx.offs[j+1])) for j in rterms if idx.offs[j+1]>idx.offs[j]]
+ if not spans:return None
+ docs=np.concatenate([np.asarray(idx.pd[a:bb]) for j,a,bb in spans]).astype(np.uint32,copy=False)
+ mm=np.concatenate([np.asarray(idx.pm[a:bb]) for j,a,bb in spans]).astype(np.float32,copy=False)
+ rt=np.concatenate([np.asarray(idx.pr[a:bb]) for j,a,bb in spans]).astype(np.uint16,copy=False)
+ sb=np.concatenate([np.asarray(idx.ps[a:bb]) for j,a,bb in spans]).astype(np.uint16,copy=False)
+ nr=len(spans); cent=np.zeros((nr,M),np.float32); rel=np.zeros((nr,M),np.float32); rho=np.empty(nr,np.float32)
+ for u,(j,a,bb) in enumerate(spans):
+  rowt=np.asarray(idx.ct[j]); ok=rowt!=65535; tids=rowt[ok].astype(np.int32,copy=False); cent[u,tids]=np.asarray(idx.cv[j])[ok]
+  ra=int(idx.rp[j]); rb=int(idx.rp[j+1]); rel[u,np.asarray(idx.ri[ra:rb],np.int32)]=np.asarray(idx.rv[ra:rb]); rho[u]=rd[j]
+ rslot=np.concatenate([np.full(bb-a,u,dtype=np.uint8) for u,(j,a,bb) in enumerate(spans)])
+ base,sig,cons=b.score_components(rslot,mm,rt,sb,qd,rho,cent,rel)
+ ud,inv=np.unique(docs,return_inverse=True)
+ tail=np.bincount(inv,weights=base*np.power(sig,b.GAMMA,dtype=np.float32),minlength=len(ud)).astype(np.float32)+b.LAM*np.bincount(inv,weights=cons,minlength=len(ud)).astype(np.float32)
+ lexvec=np.zeros(M,np.float32); lexvec[q.indices]=idx.idf[q.indices]; semvec=np.zeros(M,np.float32)
+ for t,amp in zip(q.indices,q.data):
+  a,bb=idx.A.indptr[t],idx.A.indptr[t+1]; nb=idx.A.indices[a:bb][:m.SEMK]; sv=idx.A.data[a:bb][:m.SEMK]; semvec[nb]+=float(amp)*sv*idx.idf[nb]
+ lex,sem=m.score_support_pool(ud,idx.sup_ip,idx.sup_ids,lexvec,semvec,idx.dl,idx.avgdl)
+ return ud,tail,lex,sem
+
+def rank(ud,tail,lex,sem,sel):
+ fin=m.zscore(tail[sel])+LLEX*m.zscore(lex[sel])+LSEM*m.zscore(sem[sel]); oo=np.argsort(fin)[::-1][:100]; return [int(x) for x in ud[sel[oo]]]
+
+def quota_select(tail_order,lex_order,n,lq):
+ k=min(P,n); lq=min(lq,k); gq=k-lq
+ if lq==0:return tail_order[:k]
+ out=np.empty(k,np.int64); chosen=np.zeros(n,np.uint8); z=0
+ if gq:
+  g=tail_order[:gq]; out[:gq]=g; chosen[g]=1; z=gq
+ # lex_order contains at least 2P top lexical docs; this is enough unless overlap is pathological.
+ for ii in lex_order:
+  if chosen[ii]==0:
+   out[z]=ii; chosen[ii]=1; z+=1
+   if z==k:return out
+ # Fallback should essentially never fire; preserve exactness if it does.
+ full=np.argsort(lex)[::-1]
+ for ii in full:
+  if chosen[ii]==0:
+   out[z]=ii; chosen[ii]=1; z+=1
+   if z==k:return out
+ return out[:z]
+
+tr=pd.read_csv(ROOT/'train.tsv',sep='\t',usecols=['query-id']); uq=np.unique(tr['query-id'].to_numpy()); rng=np.random.default_rng(20260815); ids=[str(x) for x in rng.choice(uq,size=1000,replace=False)]; del tr
+texts=m.load_query_texts(ids); qrels=m.qrels_from_tsv(ROOT/'train.tsv',ids,positive_only=True)
+_=prepare_all(texts[ids[0]])
+runs={q:{} for q in QUOTAS}; pool={q:0 for q in QUOTAS}; den=route=0; times=[]; stimes=[]
+for z,qid in enumerate(ids):
+ t=time.perf_counter(); p=prepare_all(texts[qid]); times.append((time.perf_counter()-t)*1000)
+ if p is None:
+  for qv in QUOTAS:runs[qv][qid]=[]
+  continue
+ ud,tail,lex,sem=p; rels=[int(d) for d,r in qrels[qid].items() if r>0]; den+=len(rels); relset=set()
+ for d in rels:
+  kk=np.searchsorted(ud,d); ok=kk<len(ud) and int(ud[kk])==d; route+=int(ok)
+  if ok:relset.add(int(kk))
+ st=time.perf_counter(); tail_order=topk_desc(tail,P); lex_order=topk_desc(lex,min(len(lex),2*P))
+ for qv in QUOTAS:
+  sel=quota_select(tail_order,lex_order,len(ud),qv); pool[qv]+=sum(int(i) in relset for i in sel); runs[qv][qid]=rank(ud,tail,lex,sem,sel)
+ stimes.append((time.perf_counter()-st)*1000)
+ if (z+1)%100==0:print('q',z+1,'prepare',float(np.median(times)),'strategies',float(np.median(stimes)),flush=True)
+rows=[]
+for qv in QUOTAS:
+ met=m.eval_run(runs[qv],qrels); row={'lex_quota':qv,'pool_relevant_recall':pool[qv]/den,**met}; rows.append(row); print('QUOTA',row,flush=True)
+rows.sort(key=lambda r:(r['nDCG@10'],r['MRR@10'],r['R@100']),reverse=True)
+out={'rows':rows,'best':rows[0],'route_relevant_recall':route/den,'timing':{'median_prepare_alllexsem_ms':float(np.median(times)),'p95_prepare_ms':float(np.percentile(times,95)),'median_all_quota_strategy_ms':float(np.median(stimes))}}
+json.dump(out,open(WORK/'early_lex_quota_validation.json','w'),indent=2); print('BEST',rows[0]); print('TIMING',out['timing'])

experiments/msmarco_scale/msmarco_early_lex_validation.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+import sys,time,json
+import numpy as np, pandas as pd
+from numba import set_num_threads
+sys.path.insert(0,'/mnt/data')
+import msmarco_best_tail_core as b
+import msmarco_full_search_uniform1m as m
+
+ROOT=m.ROOT; WORK=m.WORK; idx=b.idx; M=m.M; P=2000
+LLEX=np.float32(4.0); LSEM=np.float32(0.1)
+ETAS=[0.0,0.0625,0.125,0.25,0.5,1.0,2.0,4.0,8.0]
+LEX_QUOTAS=[0,100,250,500,750,1000,1250,1500,1750,2000]
+set_num_threads(5)
+
+def topk_desc(score,k):
+    n=len(score); k=min(k,n)
+    if k<=0:return np.empty(0,np.int64)
+    if n>k:
+        ii=np.argpartition(score,-k)[-k:]
+        return ii[np.argsort(score[ii])[::-1]]
+    return np.argsort(score)[::-1]
+
+def prepare_all(text):
+    q=idx.query_vec(text); qd=np.zeros(M,np.float32); qd[q.indices]=q.data; rterms,rd=idx.route(q)
+    spans=[(int(j),int(idx.offs[j]),int(idx.offs[j+1])) for j in rterms if idx.offs[j+1]>idx.offs[j]]
+    if not spans:return None
+    docs=np.concatenate([np.asarray(idx.pd[a:bb]) for j,a,bb in spans]).astype(np.uint32,copy=False)
+    mm=np.concatenate([np.asarray(idx.pm[a:bb]) for j,a,bb in spans]).astype(np.float32,copy=False)
+    rt=np.concatenate([np.asarray(idx.pr[a:bb]) for j,a,bb in spans]).astype(np.uint16,copy=False)
+    sb=np.concatenate([np.asarray(idx.ps[a:bb]) for j,a,bb in spans]).astype(np.uint16,copy=False)
+    nr=len(spans); cent=np.zeros((nr,M),np.float32); rel=np.zeros((nr,M),np.float32); rho=np.empty(nr,np.float32)
+    for u,(j,a,bb) in enumerate(spans):
+        rowt=np.asarray(idx.ct[j]); ok=rowt!=65535; tids=rowt[ok].astype(np.int32,copy=False); cent[u,tids]=np.asarray(idx.cv[j])[ok]
+        ra=int(idx.rp[j]); rb=int(idx.rp[j+1]); rel[u,np.asarray(idx.ri[ra:rb],np.int32)]=np.asarray(idx.rv[ra:rb]); rho[u]=rd[j]
+    rslot=np.concatenate([np.full(bb-a,u,dtype=np.uint8) for u,(j,a,bb) in enumerate(spans)])
+    base,sig,cons=b.score_components(rslot,mm,rt,sb,qd,rho,cent,rel)
+    ud,inv=np.unique(docs,return_inverse=True)
+    tail=np.bincount(inv,weights=base*np.power(sig,b.GAMMA,dtype=np.float32),minlength=len(ud)).astype(np.float32)+b.LAM*np.bincount(inv,weights=cons,minlength=len(ud)).astype(np.float32)
+    lexvec=np.zeros(M,np.float32); lexvec[q.indices]=idx.idf[q.indices]
+    # Whole-document lexical + tiny semantic score for every routed document.
+    # This is used only to amortize the validation sweep; the locked deployable
+    # implementation below computes semantics only for the selected P.
+    semvec=np.zeros(M,np.float32)
+    for t,amp in zip(q.indices,q.data):
+        a,bb=idx.A.indptr[t],idx.A.indptr[t+1]; nb=idx.A.indices[a:bb][:m.SEMK]; sv=idx.A.data[a:bb][:m.SEMK]
+        semvec[nb]+=float(amp)*sv*idx.idf[nb]
+    lex,sem=m.score_support_pool(ud,idx.sup_ip,idx.sup_ids,lexvec,semvec,idx.dl,idx.avgdl)
+    return {'ud':ud,'tail':tail,'lex':lex,'sem':sem,'candidate_docs':len(ud),'candidate_memberships':len(docs)}
+
+def final_rank(p, sel_idx, k=100):
+    docs=p['ud'][sel_idx]; ts=p['tail'][sel_idx]; lx=p['lex'][sel_idx]; sm=p['sem'][sel_idx]
+    fin=m.zscore(ts)+LLEX*m.zscore(lx)+LSEM*m.zscore(sm)
+    oo=np.argsort(fin)[::-1][:k]
+    return [int(x) for x in docs[oo]]
+
+def select_direct(p,eta):
+    zt=m.zscore(p['tail']); zl=m.zscore(p['lex']); return topk_desc(zt+np.float32(eta)*zl,P)
+
+def select_quota(p,lq):
+    # Exactly P slots: preserve P-lq strongest geometric docs, then add strongest
+    # lexical docs not already admitted. If duplicates cause shortage, continue
+    # down the lexical ordering until P unique docs are selected.
+    n=len(p['ud']); k=min(P,n); gq=max(0,k-min(int(lq),k))
+    gt=topk_desc(p['tail'],gq)
+    if len(gt)==k:return gt
+    chosen=np.zeros(n,np.uint8); chosen[gt]=1
+    lo=np.argsort(p['lex'])[::-1]
+    out=np.empty(k,np.int64); out[:len(gt)]=gt; z=len(gt)
+    for ii in lo:
+        if chosen[ii]==0:
+            chosen[ii]=1; out[z]=ii; z+=1
+            if z==k:break
+    return out[:z]
+
+# deterministic validation split already used elsewhere
+tr=pd.read_csv(ROOT/'train.tsv',sep='\t',usecols=['query-id']); uq=np.unique(tr['query-id'].to_numpy()); rng=np.random.default_rng(20260815); ids=[str(x) for x in rng.choice(uq,size=1000,replace=False)]; del tr
+texts=m.load_query_texts(ids); qrels=m.qrels_from_tsv(ROOT/'train.tsv',ids,positive_only=True)
+# warm up both support kernels and geometric kernel
+pp=prepare_all(texts[ids[0]]); _=final_rank(pp,select_direct(pp,0.0)); del pp
+runsD={e:{} for e in ETAS}; runsQ={q:{} for q in LEX_QUOTAS}
+poolhitD={e:0 for e in ETAS}; poolhitQ={q:0 for q in LEX_QUOTAS}; den=0; routehit=0
+times=[]; cands=[]
+for z,qid in enumerate(ids):
+    t=time.perf_counter(); p=prepare_all(texts[qid]); prepms=(time.perf_counter()-t)*1000; times.append(prepms)
+    rels=[int(d) for d,r in qrels[qid].items() if r>0]; den+=len(rels)
+    if p is None:
+        for e in ETAS:runsD[e][qid]=[]
+        for q in LEX_QUOTAS:runsQ[q][qid]=[]
+        continue
+    cands.append(p['candidate_docs']); ud=p['ud']
+    rel_idx=[]
+    for d in rels:
+        kk=np.searchsorted(ud,d); ok=(kk<len(ud) and int(ud[kk])==d); routehit+=int(ok)
+        if ok: rel_idx.append(int(kk))
+    relset=set(rel_idx)
+    for e in ETAS:
+        sel=select_direct(p,e); poolhitD[e]+=sum(int(i) in relset for i in sel); runsD[e][qid]=final_rank(p,sel)
+    for qv in LEX_QUOTAS:
+        sel=select_quota(p,qv); poolhitQ[qv]+=sum(int(i) in relset for i in sel); runsQ[qv][qid]=final_rank(p,sel)
+    if (z+1)%100==0:
+        print('q',z+1,'median_prepare_ms',float(np.median(times)),'route',routehit/max(1,den),flush=True)
+
+rowsD=[]
+for e in ETAS:
+    met=m.eval_run(runsD[e],qrels); row={'eta':e,'pool_relevant_recall':poolhitD[e]/den,**met}; rowsD.append(row); print('DIRECT',row,flush=True)
+rowsQ=[]
+for qv in LEX_QUOTAS:
+    met=m.eval_run(runsQ[qv],qrels); row={'lex_quota':qv,'pool_relevant_recall':poolhitQ[qv]/den,**met}; rowsQ.append(row); print('QUOTA',row,flush=True)
+rowsD.sort(key=lambda r:(r['nDCG@10'],r['MRR@10'],r['R@100']),reverse=True)
+rowsQ.sort(key=lambda r:(r['nDCG@10'],r['MRR@10'],r['R@100']),reverse=True)
+out={'protocol':'deterministic 1000 TRAIN validation; geometry/tail fixed gamma=.25 lambdaM=.125 S=16 P=2000 h=0; final lambda_lex=4 lambda_sem=.1 locked; whole-document lexical enters routed->P selection','direct_rows':rowsD,'quota_rows':rowsQ,'best_direct':rowsD[0],'best_quota':rowsQ[0],'route_relevant_recall':routehit/den,'timing_prepare_alllex':{'median_ms':float(np.median(times)),'p95_ms':float(np.percentile(times,95)),'mean_ms':float(np.mean(times)),'avg_candidate_docs':float(np.mean(cands))}}
+json.dump(out,open(WORK/'early_lex_validation.json','w'),indent=2)
+print('BEST_DIRECT',rowsD[0],flush=True); print('BEST_QUOTA',rowsQ[0],flush=True); print('TIMING',out['timing_prepare_alllex'],flush=True)

experiments/msmarco_scale/msmarco_early_lex_validation_fast.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+import sys,time,json
+import numpy as np,pandas as pd
+from numba import set_num_threads
+sys.path.insert(0,'/mnt/data')
+import msmarco_best_tail_core as b
+import msmarco_full_search_uniform1m as m
+ROOT=m.ROOT; WORK=m.WORK; idx=b.idx; M=m.M; P=2000
+LLEX=np.float32(4.0); LSEM=np.float32(0.1)
+ETAS=[0.0,0.0625,0.125,0.25,0.5,1.0,2.0,4.0,8.0]
+LEX_QUOTAS=[0,100,250,500,750,1000,1250,1500,1750,2000]
+set_num_threads(5)
+
+def topk_desc(score,k):
+ n=len(score); k=min(k,n)
+ if k<=0:return np.empty(0,np.int64)
+ if n>k:
+  ii=np.argpartition(score,-k)[-k:]
+  return ii[np.argsort(score[ii])[::-1]]
+ return np.argsort(score)[::-1]
+
+def prepare_all(text):
+ q=idx.query_vec(text); qd=np.zeros(M,np.float32); qd[q.indices]=q.data; rterms,rd=idx.route(q)
+ spans=[(int(j),int(idx.offs[j]),int(idx.offs[j+1])) for j in rterms if idx.offs[j+1]>idx.offs[j]]
+ if not spans:return None
+ docs=np.concatenate([np.asarray(idx.pd[a:bb]) for j,a,bb in spans]).astype(np.uint32,copy=False)
+ mm=np.concatenate([np.asarray(idx.pm[a:bb]) for j,a,bb in spans]).astype(np.float32,copy=False)
+ rt=np.concatenate([np.asarray(idx.pr[a:bb]) for j,a,bb in spans]).astype(np.uint16,copy=False)
+ sb=np.concatenate([np.asarray(idx.ps[a:bb]) for j,a,bb in spans]).astype(np.uint16,copy=False)
+ nr=len(spans); cent=np.zeros((nr,M),np.float32); rel=np.zeros((nr,M),np.float32); rho=np.empty(nr,np.float32)
+ for u,(j,a,bb) in enumerate(spans):
+  rowt=np.asarray(idx.ct[j]); ok=rowt!=65535; tids=rowt[ok].astype(np.int32,copy=False); cent[u,tids]=np.asarray(idx.cv[j])[ok]
+  ra=int(idx.rp[j]); rb=int(idx.rp[j+1]); rel[u,np.asarray(idx.ri[ra:rb],np.int32)]=np.asarray(idx.rv[ra:rb]); rho[u]=rd[j]
+ rslot=np.concatenate([np.full(bb-a,u,dtype=np.uint8) for u,(j,a,bb) in enumerate(spans)])
+ base,sig,cons=b.score_components(rslot,mm,rt,sb,qd,rho,cent,rel)
+ ud,inv=np.unique(docs,return_inverse=True)
+ tail=np.bincount(inv,weights=base*np.power(sig,b.GAMMA,dtype=np.float32),minlength=len(ud)).astype(np.float32)+b.LAM*np.bincount(inv,weights=cons,minlength=len(ud)).astype(np.float32)
+ lexvec=np.zeros(M,np.float32); lexvec[q.indices]=idx.idf[q.indices]
+ semvec=np.zeros(M,np.float32)
+ for t,amp in zip(q.indices,q.data):
+  a,bb=idx.A.indptr[t],idx.A.indptr[t+1]; nb=idx.A.indices[a:bb][:m.SEMK]; sv=idx.A.data[a:bb][:m.SEMK]; semvec[nb]+=float(amp)*sv*idx.idf[nb]
+ # One CSR scan per routed doc supplies both validation features.
+ lex,sem=m.score_support_pool(ud,idx.sup_ip,idx.sup_ids,lexvec,semvec,idx.dl,idx.avgdl)
+ return {'ud':ud,'tail':tail,'lex':lex,'sem':sem,'candidate_docs':len(ud),'candidate_memberships':len(docs)}
+
+def final_rank(p,sel,k=100):
+ docs=p['ud'][sel]; fin=m.zscore(p['tail'][sel])+LLEX*m.zscore(p['lex'][sel])+LSEM*m.zscore(p['sem'][sel]); oo=np.argsort(fin)[::-1][:k]; return [int(x) for x in docs[oo]]
+
+def quota_from_orders(tail_order,lex_order,n,lq):
+ k=min(P,n); gq=max(0,k-min(lq,k)); out=np.empty(k,np.int64); z=0; chosen=np.zeros(n,np.uint8)
+ if gq:
+  g=tail_order[:gq]; out[:gq]=g; chosen[g]=1; z=gq
+  if z==k: return out
+ for ii in lex_order:
+  if chosen[ii]==0:
+   chosen[ii]=1; out[z]=ii; z+=1
+   if z==k:break
+ return out[:z]
+
+tr=pd.read_csv(ROOT/'train.tsv',sep='\t',usecols=['query-id']); uq=np.unique(tr['query-id'].to_numpy()); rng=np.random.default_rng(20260815); ids=[str(x) for x in rng.choice(uq,size=1000,replace=False)]; del tr
+texts=m.load_query_texts(ids); qrels=m.qrels_from_tsv(ROOT/'train.tsv',ids,positive_only=True)
+p=prepare_all(texts[ids[0]]); _=final_rank(p,topk_desc(p['tail'],P)); del p
+runsD={e:{} for e in ETAS}; runsQ={q:{} for q in LEX_QUOTAS}; poolD={e:0 for e in ETAS}; poolQ={q:0 for q in LEX_QUOTAS}; den=routehit=0; times=[]; cands=[]
+for z,qid in enumerate(ids):
+ t=time.perf_counter(); p=prepare_all(texts[qid]); times.append((time.perf_counter()-t)*1000)
+ rels=[int(d) for d,r in qrels[qid].items() if r>0]; den+=len(rels)
+ if p is None:
+  for e in ETAS:runsD[e][qid]=[]
+  for qv in LEX_QUOTAS:runsQ[qv][qid]=[]
+  continue
+ cands.append(p['candidate_docs']); ud=p['ud']; relset=set()
+ for d in rels:
+  kk=np.searchsorted(ud,d); ok=(kk<len(ud) and int(ud[kk])==d); routehit+=int(ok)
+  if ok: relset.add(int(kk))
+ zt=m.zscore(p['tail']); zl=m.zscore(p['lex'])
+ for e in ETAS:
+  sel=topk_desc(zt+np.float32(e)*zl,P); poolD[e]+=sum(int(i) in relset for i in sel); runsD[e][qid]=final_rank(p,sel)
+ tail_order=topk_desc(p['tail'],P); lex_order=np.argsort(p['lex'])[::-1]
+ for qv in LEX_QUOTAS:
+  sel=quota_from_orders(tail_order,lex_order,len(ud),qv); poolQ[qv]+=sum(int(i) in relset for i in sel); runsQ[qv][qid]=final_rank(p,sel)
+ if (z+1)%100==0:print('q',z+1,'median_prepare',float(np.median(times)),'route',routehit/den,flush=True)
+rowsD=[]
+for e in ETAS:
+ met=m.eval_run(runsD[e],qrels); row={'eta':e,'pool_relevant_recall':poolD[e]/den,**met}; rowsD.append(row); print('DIRECT',row,flush=True)
+rowsQ=[]
+for qv in LEX_QUOTAS:
+ met=m.eval_run(runsQ[qv],qrels); row={'lex_quota':qv,'pool_relevant_recall':poolQ[qv]/den,**met}; rowsQ.append(row); print('QUOTA',row,flush=True)
+rowsD.sort(key=lambda r:(r['nDCG@10'],r['MRR@10'],r['R@100']),reverse=True); rowsQ.sort(key=lambda r:(r['nDCG@10'],r['MRR@10'],r['R@100']),reverse=True)
+out={'protocol':'same deterministic 1000 TRAIN validation; gamma=.25 lambdaM=.125 S=16 P=2000 h=0; final lambda_lex=4 lambda_sem=.1 locked; lexical support injected before P selection','direct_rows':rowsD,'quota_rows':rowsQ,'best_direct':rowsD[0],'best_quota':rowsQ[0],'route_relevant_recall':routehit/den,'timing_validation_amortized':{'median_prepare_ms':float(np.median(times)),'p95_prepare_ms':float(np.percentile(times,95)),'avg_candidate_docs':float(np.mean(cands))}}
+json.dump(out,open(WORK/'early_lex_validation.json','w'),indent=2); print('BEST_DIRECT',rowsD[0],flush=True); print('BEST_QUOTA',rowsQ[0],flush=True); print('TIMING',out['timing_validation_amortized'],flush=True)

experiments/msmarco_scale/msmarco_encode_full.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+import gzip,json,pickle,time,re,gc,os
+from pathlib import Path
+import numpy as np
+from scipy import sparse
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.preprocessing import normalize
+from numba import njit, prange, set_num_threads
+
+ROOT=Path('/mnt/data'); WORK=ROOT/'msmarco_scale_work'; GEOM=WORK/'geometry_1m'; IDX=WORK/'full_index'; IDX.mkdir(parents=True,exist_ok=True)
+N=8_841_823; M=50_000; F=4; S=16; SENT=np.uint16(65535)
+set_num_threads(5)
+TOKEN_RE=re.compile(r'(?u)\b\w\w+\b')
+
+def shard_path(i):
+ hits=list(ROOT.glob(f'corpus_{i:04d}.jsonl*.gz')); assert len(hits)==1,(i,hits); return hits[0]
+
+def load_vocab():
+ with gzip.open(WORK/'final_vocab_50k.pkl.gz','rb') as g: z=pickle.load(g)
+ terms=z['terms'].tolist(); idf=np.asarray(z['idf'],np.float32); return terms,idf,{t:i for i,t in enumerate(terms)}
+
+@njit(cache=False)
+def lookup_center(ct,cv,t):
+ lo=0; hi=ct.size
+ while lo<hi:
+  mid=(lo+hi)//2; x=ct[mid]
+  if x==65535 or x>=t: hi=mid
+  else: lo=mid+1
+ if lo<ct.size and ct[lo]==t: return cv[lo]
+ return 0.0
+
+@njit(parallel=True,cache=False)
+def encode_kernel(indptr,indices,data,center_terms,center_values):
+ n=indptr.size-1
+ branches=np.full((n,F),SENT,np.uint16); mem=np.zeros((n,F),np.float32)
+ rt=np.full((n,F,S),SENT,np.uint16); signbits=np.zeros((n,F),np.uint16)
+ for d in prange(n):
+  a=indptr[d]; b=indptr[d+1]
+  # top4 document coordinates
+  tv=np.zeros(F,np.float32); tt=np.full(F,SENT,np.uint16)
+  for p in range(a,b):
+   v=data[p]; t=np.uint16(indices[p]); pos=F
+   for r in range(F):
+    if v>tv[r]: pos=r; break
+   if pos<F:
+    for r in range(F-1,pos,-1): tv[r]=tv[r-1]; tt[r]=tt[r-1]
+    tv[pos]=v; tt[pos]=t
+  den=0.0
+  for s in range(F): den+=tv[s]
+  if den<=0: continue
+  for s in range(F): branches[d,s]=tt[s]; mem[d,s]=tv[s]/den
+  # residual codes per fuzzy branch
+  for sl in range(F):
+   j=int(tt[sl])
+   if j==65535: continue
+   best=np.zeros(S,np.float32); bt=np.full(S,SENT,np.uint16); bp=np.zeros(S,np.uint8)
+   for p in range(a,b):
+    t=np.uint16(indices[p]); r=data[p]-lookup_center(center_terms[j],center_values[j],t); ar=abs(r)
+    mi=0; mv=best[0]
+    for q in range(1,S):
+     if best[q]<mv: mi=q; mv=best[q]
+    if ar>mv:
+     best[mi]=ar; bt[mi]=t; bp[mi]=1 if r>=0 else 0
+   # sort descending to stabilize
+   for x in range(S):
+    mx=x
+    for y in range(x+1,S):
+     if best[y]>best[mx]: mx=y
+    if mx!=x:
+     z=best[x]; best[x]=best[mx]; best[mx]=z
+     zt=bt[x]; bt[x]=bt[mx]; bt[mx]=zt
+     zp=bp[x]; bp[x]=bp[mx]; bp[mx]=zp
+   bits=np.uint16(0)
+   for q in range(S):
+    rt[d,sl,q]=bt[q]
+    if bt[q]!=SENT and bp[q]: bits |= np.uint16(1<<q)
+   signbits[d,sl]=bits
+ return branches,mem,rt,signbits
+
+if __name__=='__main__':
+ terms,idf,vocab=load_vocab(); center_terms=np.load(GEOM/'center_terms.npy',mmap_mode='r'); center_values=np.load(GEOM/'center_values.npy',mmap_mode='r')
+ # Global disk-backed arrays
+ branches=np.memmap(IDX/'branches.u16',dtype=np.uint16,mode='w+',shape=(N,F)); branches[:]=SENT
+ memberships=np.memmap(IDX/'memberships.f32',dtype=np.float32,mode='w+',shape=(N,F)); memberships[:]=0
+ res_terms=np.memmap(IDX/'res_terms.u16',dtype=np.uint16,mode='w+',shape=(N,F,S)); res_terms[:]=SENT
+ signbits=np.memmap(IDX/'signbits.u16',dtype=np.uint16,mode='w+',shape=(N,F)); signbits[:]=0
+ doc_lengths=np.memmap(IDX/'doc_lengths.u16',dtype=np.uint16,mode='w+',shape=(N,)); doc_lengths[:]=0
+ cv=CountVectorizer(vocabulary=vocab,lowercase=True,token_pattern=r'(?u)\b\w\w+\b',dtype=np.int32)
+ total_len=0; t_all=time.time(); offset=0
+ for sid in range(36):
+  t=time.time(); texts=[]; lens=[]
+  with gzip.open(shard_path(sid),'rt',encoding='utf-8') as f:
+   for line in f:
+    o=json.loads(line); tx=((o.get('title') or '')+' '+(o.get('text') or '')).strip(); texts.append(tx); lens.append(min(65535,len(TOKEN_RE.findall(tx.lower()))))
+  n=len(texts); X=cv.transform(texts).tocsr().astype(np.float32); X.data *= idf[X.indices]; normalize(X,norm='l2',axis=1,copy=False); X.sort_indices()
+  br,mm,rt,sb=encode_kernel(X.indptr.astype(np.int64),X.indices.astype(np.int32),X.data.astype(np.float32),center_terms,center_values)
+  sl=slice(offset,offset+n); branches[sl]=br; memberships[sl]=mm; res_terms[sl]=rt; signbits[sl]=sb; doc_lengths[sl]=np.asarray(lens,np.uint16); total_len += int(np.sum(lens,dtype=np.int64))
+  # whole-document binary support, one pair of files per corpus shard
+  X.indices.astype(np.uint16).tofile(IDX/f'support_{sid:04d}.u16')
+  X.indptr.astype(np.uint32).tofile(IDX/f'support_indptr_{sid:04d}.u32')
+  with open(IDX/f'shard_{sid:04d}.json','w') as f: json.dump({'offset':offset,'n':n,'nnz':int(X.nnz),'seconds':time.time()-t},f)
+  offset+=n; branches.flush(); memberships.flush(); res_terms.flush(); signbits.flush(); doc_lengths.flush()
+  print(f'[{sid+1:02d}/36] n={n:,} nnz={X.nnz:,} offset={offset:,} sec={time.time()-t:.1f}',flush=True)
+  del texts,lens,X,br,mm,rt,sb; gc.collect()
+ assert offset==N,(offset,N)
+ avg=total_len/N
+ # Build branch postings by a global stable sort over 35.4M uint16 branch IDs.
+ print('building branch postings...',flush=True); t=time.time(); flat=np.memmap(IDX/'branches.u16',dtype=np.uint16,mode='r',shape=(N*F,)); order=np.argsort(flat,kind='stable'); sorted_br=flat[order]; nvalid=int(np.searchsorted(sorted_br,SENT,side='left'))
+ bo=np.memmap(IDX/'branch_order.u32',dtype=np.uint32,mode='w+',shape=(nvalid,)); bo[:]=order[:nvalid].astype(np.uint32); bo.flush(); counts=np.bincount(sorted_br[:nvalid].astype(np.int64),minlength=M); offsets=np.zeros(M+1,np.uint64); np.cumsum(counts,dtype=np.uint64,out=offsets[1:]); np.save(IDX/'branch_offsets.npy',offsets); print('postings valid memberships',nvalid,'sec',time.time()-t,flush=True)
+ with open(IDX/'meta.json','w') as f: json.dump({'N':N,'M':M,'F':F,'S':S,'avg_doc_length':avg,'build_seconds':time.time()-t_all,'geometry':'geometry_1m_fullcorpus_vocab'},f,indent=2)
+ print('FULL INDEX DONE avgdl',avg,'total sec',time.time()-t_all,flush=True)

experiments/msmarco_scale/msmarco_encode_resume.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+import sys, gzip, json, pickle, time, re, gc, os
+from pathlib import Path
+from concurrent.futures import ProcessPoolExecutor, as_completed
+import multiprocessing as mp
+import numpy as np
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.preprocessing import normalize
+from numba import set_num_threads
+sys.path.insert(0,'/mnt/data')
+import msmarco_encode_full as base
+
+ROOT=Path('/mnt/data'); WORK=ROOT/'msmarco_scale_work'; GEOM=WORK/'geometry_1m'; IDX=WORK/'full_index'
+N=8_841_823; M=50_000; F=4; S=16
+TOKEN_RE=re.compile(r'(?u)\b\w\w+\b')
+
+def shard_path(i):
+ hits=list(ROOT.glob(f'corpus_{i:04d}.jsonl*.gz')); assert len(hits)==1,(i,hits); return hits[0]
+
+def load_vocab():
+ with gzip.open(WORK/'final_vocab_50k.pkl.gz','rb') as g:z=pickle.load(g)
+ terms=z['terms'].tolist(); idf=np.asarray(z['idf'],np.float32); return idf,{t:i for i,t in enumerate(terms)}
+
+def work(sid):
+ set_num_threads(1)
+ t=time.time(); idf,vocab=load_vocab(); center_terms=np.load(GEOM/'center_terms.npy',mmap_mode='r'); center_values=np.load(GEOM/'center_values.npy',mmap_mode='r')
+ branches=np.memmap(IDX/'branches.u16',np.uint16,'r+',shape=(N,F)); memberships=np.memmap(IDX/'memberships.f32',np.float32,'r+',shape=(N,F)); rtg=np.memmap(IDX/'res_terms.u16',np.uint16,'r+',shape=(N,F,S)); sbg=np.memmap(IDX/'signbits.u16',np.uint16,'r+',shape=(N,F)); dlg=np.memmap(IDX/'doc_lengths.u16',np.uint16,'r+',shape=(N,))
+ texts=[]; lens=[]
+ with gzip.open(shard_path(sid),'rt',encoding='utf-8') as f:
+  for line in f:
+   o=json.loads(line); tx=((o.get('title') or '')+' '+(o.get('text') or '')).strip(); texts.append(tx); lens.append(min(65535,len(TOKEN_RE.findall(tx.lower()))))
+ n=len(texts); cv=CountVectorizer(vocabulary=vocab,lowercase=True,token_pattern=r'(?u)\b\w\w+\b',dtype=np.int32); X=cv.transform(texts).tocsr().astype(np.float32); X.data*=idf[X.indices]; normalize(X,norm='l2',axis=1,copy=False); X.sort_indices()
+ br,mm,rt,sb=base.encode_kernel(X.indptr.astype(np.int64),X.indices.astype(np.int32),X.data.astype(np.float32),center_terms,center_values)
+ offset=sid*250_000; sl=slice(offset,offset+n); branches[sl]=br; memberships[sl]=mm; rtg[sl]=rt; sbg[sl]=sb; dlg[sl]=np.asarray(lens,np.uint16)
+ X.indices.astype(np.uint16).tofile(IDX/f'support_{sid:04d}.u16'); X.indptr.astype(np.uint32).tofile(IDX/f'support_indptr_{sid:04d}.u32')
+ branches.flush(); memberships.flush(); rtg.flush(); sbg.flush(); dlg.flush()
+ secs=time.time()-t
+ with open(IDX/f'shard_{sid:04d}.json','w') as f:json.dump({'offset':offset,'n':n,'nnz':int(X.nnz),'seconds':secs},f)
+ return sid,n,int(X.nnz),secs
+
+if __name__=='__main__':
+ missing=[i for i in range(36) if not (IDX/f'shard_{i:04d}.json').exists()]
+ print('missing',missing,flush=True); t0=time.time()
+ with ProcessPoolExecutor(max_workers=3, mp_context=mp.get_context('spawn')) as ex:
+  fs={ex.submit(work,i):i for i in missing}; done=0
+  for f in as_completed(fs):
+   sid,n,nnz,sec=f.result(); done+=1; print(f'[{done:02d}/{len(missing):02d}] shard {sid:04d} n={n:,} nnz={nnz:,} sec={sec:.1f}',flush=True)
+ print('encoding complete sec',time.time()-t0,flush=True)
+ # validate all shards and calculate avg dl
+ metas=[]
+ for i in range(36):
+  with open(IDX/f'shard_{i:04d}.json') as f:metas.append(json.load(f))
+ assert sum(x['n'] for x in metas)==N
+ dl=np.memmap(IDX/'doc_lengths.u16',np.uint16,'r',shape=(N,)); avg=float(np.mean(dl,dtype=np.float64));
+ # postings
+ print('building postings',flush=True); t=time.time(); flat=np.memmap(IDX/'branches.u16',np.uint16,'r',shape=(N*F,)); order=np.argsort(flat,kind='stable'); sorted_br=flat[order]; nvalid=int(np.searchsorted(sorted_br,np.uint16(65535),side='left')); bo=np.memmap(IDX/'branch_order.u32',np.uint32,'w+',shape=(nvalid,)); bo[:]=order[:nvalid].astype(np.uint32); bo.flush(); counts=np.bincount(sorted_br[:nvalid].astype(np.int64),minlength=M); offs=np.zeros(M+1,np.uint64); np.cumsum(counts,dtype=np.uint64,out=offs[1:]); np.save(IDX/'branch_offsets.npy',offs); print('postings',nvalid,'sec',time.time()-t,flush=True)
+ with open(IDX/'meta.json','w') as f:json.dump({'N':N,'M':M,'F':F,'S':S,'avg_doc_length':avg,'build_seconds_resume':time.time()-t0,'geometry':'geometry_1m_fullcorpus_vocab'},f,indent=2)
+ print('FULL INDEX DONE avgdl',avg,'total sec',time.time()-t0,flush=True)

experiments/msmarco_scale/msmarco_encode_s32.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+import gzip,json,pickle,time
+from pathlib import Path
+from concurrent.futures import ProcessPoolExecutor,as_completed
+import multiprocessing as mp
+import numpy as np
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.preprocessing import normalize
+from numba import njit,prange,set_num_threads
+ROOT=Path('/mnt/data'); W=ROOT/'msmarco_scale_work'; G=W/'geometry_uniform1m_s32'; OLD=W/'full_index'; NEW=W/'full_index_uniform1m_s32'; NEW.mkdir(exist_ok=True)
+N=8_841_823; M=50_000; F=4; S=32; SENT=np.uint16(65535)
+
+def shard_path(i):
+ hits=list(ROOT.glob(f'corpus_{i:04d}.jsonl*.gz')); assert len(hits)==1; return hits[0]
+def load_vocab():
+ with gzip.open(W/'final_vocab_50k.pkl.gz','rb') as g:z=pickle.load(g)
+ terms=z['terms'].tolist(); idf=np.asarray(z['idf'],np.float32); return idf,{t:i for i,t in enumerate(terms)}
+@njit(cache=False)
+def lookup(ct,cv,t):
+ lo=0; hi=ct.size
+ while lo<hi:
+  mid=(lo+hi)//2; x=ct[mid]
+  if x==65535 or x>=t: hi=mid
+  else: lo=mid+1
+ if lo<ct.size and ct[lo]==t:return cv[lo]
+ return 0.0
+@njit(parallel=True,cache=False)
+def kernel(indptr,indices,data,ct,cv):
+ n=indptr.size-1; br=np.full((n,F),SENT,np.uint16); rt=np.full((n,F,S),SENT,np.uint16); sb=np.zeros((n,F),np.uint32)
+ for d in prange(n):
+  a=indptr[d]; b=indptr[d+1]; tv=np.zeros(F,np.float32); tt=np.full(F,SENT,np.uint16)
+  for p in range(a,b):
+   v=data[p]; t=np.uint16(indices[p]); pos=F
+   for r in range(F):
+    if v>tv[r]:pos=r;break
+   if pos<F:
+    for r in range(F-1,pos,-1):tv[r]=tv[r-1];tt[r]=tt[r-1]
+    tv[pos]=v;tt[pos]=t
+  den=0.0
+  for s in range(F):den+=tv[s]
+  if den<=0:continue
+  for s in range(F):br[d,s]=tt[s]
+  for sl in range(F):
+   j=int(tt[sl]); best=np.zeros(S,np.float32); bt=np.full(S,SENT,np.uint16); bp=np.zeros(S,np.uint8)
+   for p in range(a,b):
+    t=np.uint16(indices[p]); rr=data[p]-lookup(ct[j],cv[j],t); ar=abs(rr); mi=0; mv=best[0]
+    for q in range(1,S):
+     if best[q]<mv:mi=q;mv=best[q]
+    if ar>mv:best[mi]=ar;bt[mi]=t;bp[mi]=1 if rr>=0 else 0
+   for x in range(S):
+    mx=x
+    for y in range(x+1,S):
+     if best[y]>best[mx]:mx=y
+    if mx!=x:
+     zz=best[x];best[x]=best[mx];best[mx]=zz; zt=bt[x];bt[x]=bt[mx];bt[mx]=zt; zp=bp[x];bp[x]=bp[mx];bp[mx]=zp
+   bits=np.uint32(0)
+   for q in range(S):
+    rt[d,sl,q]=bt[q]
+    if bt[q]!=SENT and bp[q]:bits|=np.uint32(1)<<np.uint32(q)
+   sb[d,sl]=bits
+ return br,rt,sb
+
+def work(sid):
+ set_num_threads(1); t=time.time(); idf,vocab=load_vocab(); ct=np.load(G/'center_terms.npy',mmap_mode='r'); cvv=np.load(G/'center_values.npy',mmap_mode='r'); oldbr=np.memmap(OLD/'branches.u16',np.uint16,'r',shape=(N,F)); rtg=np.memmap(NEW/'res_terms.u16',np.uint16,'r+',shape=(N,F,S)); sbg=np.memmap(NEW/'signbits.u32',np.uint32,'r+',shape=(N,F))
+ texts=[]
+ with gzip.open(shard_path(sid),'rt',encoding='utf-8') as f:
+  for line in f:
+   o=json.loads(line);texts.append(((o.get('title') or '')+' '+(o.get('text') or '')).strip())
+ cv=CountVectorizer(vocabulary=vocab,lowercase=True,token_pattern=r'(?u)\b\w\w+\b',dtype=np.int32);X=cv.transform(texts).tocsr().astype(np.float32);X.data*=idf[X.indices];normalize(X,norm='l2',axis=1,copy=False);X.sort_indices(); br,rt,sb=kernel(X.indptr.astype(np.int64),X.indices.astype(np.int32),X.data.astype(np.float32),ct,cvv)
+ n=len(texts);off=sid*250_000;sl=slice(off,off+n);mism=int(np.sum(br!=np.asarray(oldbr[sl])));assert mism==0,(sid,mism);rtg[sl]=rt;sbg[sl]=sb;rtg.flush();sbg.flush();sec=time.time()-t;json.dump({'offset':off,'n':n,'nnz':int(X.nnz),'seconds':sec,'branch_mismatches':mism},open(NEW/f'shard_{sid:04d}.json','w'));return sid,n,sec
+if __name__=='__main__':
+ if not (NEW/'res_terms.u16').exists():a=np.memmap(NEW/'res_terms.u16',np.uint16,'w+',shape=(N,F,S));a[:]=SENT;a.flush();del a
+ if not (NEW/'signbits.u32').exists():a=np.memmap(NEW/'signbits.u32',np.uint32,'w+',shape=(N,F));a[:]=0;a.flush();del a
+ done={int(p.stem.split('_')[1]) for p in NEW.glob('shard_*.json')};missing=[i for i in range(36) if i not in done];print('missing',missing,flush=True);t=time.time()
+ with ProcessPoolExecutor(max_workers=3,mp_context=mp.get_context('spawn')) as ex:
+  fs=[ex.submit(work,i) for i in missing]
+  for k,fu in enumerate(as_completed(fs),1):sid,n,sec=fu.result();print(f'[{k:02d}/{len(missing):02d}] shard {sid:04d} n={n:,} sec={sec:.1f}',flush=True)
+ print('S32 ENCODE DONE',time.time()-t,flush=True)

experiments/msmarco_scale/msmarco_encode_s32_1w.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+import gzip,json,pickle,time
+from pathlib import Path
+from concurrent.futures import ProcessPoolExecutor,as_completed
+import multiprocessing as mp
+import numpy as np
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.preprocessing import normalize
+from numba import njit,prange,set_num_threads
+ROOT=Path('/mnt/data'); W=ROOT/'msmarco_scale_work'; G=W/'geometry_uniform1m_s32'; OLD=W/'full_index'; NEW=W/'full_index_uniform1m_s32'; NEW.mkdir(exist_ok=True)
+N=8_841_823; M=50_000; F=4; S=32; SENT=np.uint16(65535)
+
+def shard_path(i):
+ hits=list(ROOT.glob(f'corpus_{i:04d}.jsonl*.gz')); assert len(hits)==1; return hits[0]
+def load_vocab():
+ with gzip.open(W/'final_vocab_50k.pkl.gz','rb') as g:z=pickle.load(g)
+ terms=z['terms'].tolist(); idf=np.asarray(z['idf'],np.float32); return idf,{t:i for i,t in enumerate(terms)}
+@njit(cache=False)
+def lookup(ct,cv,t):
+ lo=0; hi=ct.size
+ while lo<hi:
+  mid=(lo+hi)//2; x=ct[mid]
+  if x==65535 or x>=t: hi=mid
+  else: lo=mid+1
+ if lo<ct.size and ct[lo]==t:return cv[lo]
+ return 0.0
+@njit(parallel=True,cache=False)
+def kernel(indptr,indices,data,ct,cv):
+ n=indptr.size-1; br=np.full((n,F),SENT,np.uint16); rt=np.full((n,F,S),SENT,np.uint16); sb=np.zeros((n,F),np.uint32)
+ for d in prange(n):
+  a=indptr[d]; b=indptr[d+1]; tv=np.zeros(F,np.float32); tt=np.full(F,SENT,np.uint16)
+  for p in range(a,b):
+   v=data[p]; t=np.uint16(indices[p]); pos=F
+   for r in range(F):
+    if v>tv[r]:pos=r;break
+   if pos<F:
+    for r in range(F-1,pos,-1):tv[r]=tv[r-1];tt[r]=tt[r-1]
+    tv[pos]=v;tt[pos]=t
+  den=0.0
+  for s in range(F):den+=tv[s]
+  if den<=0:continue
+  for s in range(F):br[d,s]=tt[s]
+  for sl in range(F):
+   j=int(tt[sl]); best=np.zeros(S,np.float32); bt=np.full(S,SENT,np.uint16); bp=np.zeros(S,np.uint8)
+   for p in range(a,b):
+    t=np.uint16(indices[p]); rr=data[p]-lookup(ct[j],cv[j],t); ar=abs(rr); mi=0; mv=best[0]
+    for q in range(1,S):
+     if best[q]<mv:mi=q;mv=best[q]
+    if ar>mv:best[mi]=ar;bt[mi]=t;bp[mi]=1 if rr>=0 else 0
+   for x in range(S):
+    mx=x
+    for y in range(x+1,S):
+     if best[y]>best[mx]:mx=y
+    if mx!=x:
+     zz=best[x];best[x]=best[mx];best[mx]=zz; zt=bt[x];bt[x]=bt[mx];bt[mx]=zt; zp=bp[x];bp[x]=bp[mx];bp[mx]=zp
+   bits=np.uint32(0)
+   for q in range(S):
+    rt[d,sl,q]=bt[q]
+    if bt[q]!=SENT and bp[q]:bits|=np.uint32(1)<<np.uint32(q)
+   sb[d,sl]=bits
+ return br,rt,sb
+
+def work(sid):
+ set_num_threads(1); t=time.time(); idf,vocab=load_vocab(); ct=np.load(G/'center_terms.npy',mmap_mode='r'); cvv=np.load(G/'center_values.npy',mmap_mode='r'); oldbr=np.memmap(OLD/'branches.u16',np.uint16,'r',shape=(N,F)); rtg=np.memmap(NEW/'res_terms.u16',np.uint16,'r+',shape=(N,F,S)); sbg=np.memmap(NEW/'signbits.u32',np.uint32,'r+',shape=(N,F))
+ texts=[]
+ with gzip.open(shard_path(sid),'rt',encoding='utf-8') as f:
+  for line in f:
+   o=json.loads(line);texts.append(((o.get('title') or '')+' '+(o.get('text') or '')).strip())
+ cv=CountVectorizer(vocabulary=vocab,lowercase=True,token_pattern=r'(?u)\b\w\w+\b',dtype=np.int32);X=cv.transform(texts).tocsr().astype(np.float32);X.data*=idf[X.indices];normalize(X,norm='l2',axis=1,copy=False);X.sort_indices(); br,rt,sb=kernel(X.indptr.astype(np.int64),X.indices.astype(np.int32),X.data.astype(np.float32),ct,cvv)
+ n=len(texts);off=sid*250_000;sl=slice(off,off+n);mism=int(np.sum(br!=np.asarray(oldbr[sl])));assert mism==0,(sid,mism);rtg[sl]=rt;sbg[sl]=sb;rtg.flush();sbg.flush();sec=time.time()-t;json.dump({'offset':off,'n':n,'nnz':int(X.nnz),'seconds':sec,'branch_mismatches':mism},open(NEW/f'shard_{sid:04d}.json','w'));return sid,n,sec
+if __name__=='__main__':
+ if not (NEW/'res_terms.u16').exists():a=np.memmap(NEW/'res_terms.u16',np.uint16,'w+',shape=(N,F,S));a[:]=SENT;a.flush();del a
+ if not (NEW/'signbits.u32').exists():a=np.memmap(NEW/'signbits.u32',np.uint32,'w+',shape=(N,F));a[:]=0;a.flush();del a
+ done={int(p.stem.split('_')[1]) for p in NEW.glob('shard_*.json')};missing=[i for i in range(36) if i not in done];print('missing',missing,flush=True);t=time.time()
+ with ProcessPoolExecutor(max_workers=1,mp_context=mp.get_context('spawn')) as ex:
+  fs=[ex.submit(work,i) for i in missing]
+  for k,fu in enumerate(as_completed(fs),1):sid,n,sec=fu.result();print(f'[{k:02d}/{len(missing):02d}] shard {sid:04d} n={n:,} sec={sec:.1f}',flush=True)
+ print('S32 ENCODE DONE',time.time()-t,flush=True)

experiments/msmarco_scale/msmarco_encode_s32_1w5t.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+import gzip,json,pickle,time
+from pathlib import Path
+from concurrent.futures import ProcessPoolExecutor,as_completed
+import multiprocessing as mp
+import numpy as np
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.preprocessing import normalize
+from numba import njit,prange,set_num_threads
+ROOT=Path('/mnt/data'); W=ROOT/'msmarco_scale_work'; G=W/'geometry_uniform1m_s32'; OLD=W/'full_index'; NEW=W/'full_index_uniform1m_s32'; NEW.mkdir(exist_ok=True)
+N=8_841_823; M=50_000; F=4; S=32; SENT=np.uint16(65535)
+
+def shard_path(i):
+ hits=list(ROOT.glob(f'corpus_{i:04d}.jsonl*.gz')); assert len(hits)==1; return hits[0]
+def load_vocab():
+ with gzip.open(W/'final_vocab_50k.pkl.gz','rb') as g:z=pickle.load(g)
+ terms=z['terms'].tolist(); idf=np.asarray(z['idf'],np.float32); return idf,{t:i for i,t in enumerate(terms)}
+@njit(cache=False)
+def lookup(ct,cv,t):
+ lo=0; hi=ct.size
+ while lo<hi:
+  mid=(lo+hi)//2; x=ct[mid]
+  if x==65535 or x>=t: hi=mid
+  else: lo=mid+1
+ if lo<ct.size and ct[lo]==t:return cv[lo]
+ return 0.0
+@njit(parallel=True,cache=False)
+def kernel(indptr,indices,data,ct,cv):
+ n=indptr.size-1; br=np.full((n,F),SENT,np.uint16); rt=np.full((n,F,S),SENT,np.uint16); sb=np.zeros((n,F),np.uint32)
+ for d in prange(n):
+  a=indptr[d]; b=indptr[d+1]; tv=np.zeros(F,np.float32); tt=np.full(F,SENT,np.uint16)
+  for p in range(a,b):
+   v=data[p]; t=np.uint16(indices[p]); pos=F
+   for r in range(F):
+    if v>tv[r]:pos=r;break
+   if pos<F:
+    for r in range(F-1,pos,-1):tv[r]=tv[r-1];tt[r]=tt[r-1]
+    tv[pos]=v;tt[pos]=t
+  den=0.0
+  for s in range(F):den+=tv[s]
+  if den<=0:continue
+  for s in range(F):br[d,s]=tt[s]
+  for sl in range(F):
+   j=int(tt[sl]); best=np.zeros(S,np.float32); bt=np.full(S,SENT,np.uint16); bp=np.zeros(S,np.uint8)
+   for p in range(a,b):
+    t=np.uint16(indices[p]); rr=data[p]-lookup(ct[j],cv[j],t); ar=abs(rr); mi=0; mv=best[0]
+    for q in range(1,S):
+     if best[q]<mv:mi=q;mv=best[q]
+    if ar>mv:best[mi]=ar;bt[mi]=t;bp[mi]=1 if rr>=0 else 0
+   for x in range(S):
+    mx=x
+    for y in range(x+1,S):
+     if best[y]>best[mx]:mx=y
+    if mx!=x:
+     zz=best[x];best[x]=best[mx];best[mx]=zz; zt=bt[x];bt[x]=bt[mx];bt[mx]=zt; zp=bp[x];bp[x]=bp[mx];bp[mx]=zp
+   bits=np.uint32(0)
+   for q in range(S):
+    rt[d,sl,q]=bt[q]
+    if bt[q]!=SENT and bp[q]:bits|=np.uint32(1)<<np.uint32(q)
+   sb[d,sl]=bits
+ return br,rt,sb
+
+def work(sid):
+ set_num_threads(5); t=time.time(); idf,vocab=load_vocab(); ct=np.load(G/'center_terms.npy',mmap_mode='r'); cvv=np.load(G/'center_values.npy',mmap_mode='r'); oldbr=np.memmap(OLD/'branches.u16',np.uint16,'r',shape=(N,F)); rtg=np.memmap(NEW/'res_terms.u16',np.uint16,'r+',shape=(N,F,S)); sbg=np.memmap(NEW/'signbits.u32',np.uint32,'r+',shape=(N,F))
+ texts=[]
+ with gzip.open(shard_path(sid),'rt',encoding='utf-8') as f:
+  for line in f:
+   o=json.loads(line);texts.append(((o.get('title') or '')+' '+(o.get('text') or '')).strip())
+ cv=CountVectorizer(vocabulary=vocab,lowercase=True,token_pattern=r'(?u)\b\w\w+\b',dtype=np.int32);X=cv.transform(texts).tocsr().astype(np.float32);X.data*=idf[X.indices];normalize(X,norm='l2',axis=1,copy=False);X.sort_indices(); br,rt,sb=kernel(X.indptr.astype(np.int64),X.indices.astype(np.int32),X.data.astype(np.float32),ct,cvv)
+ n=len(texts);off=sid*250_000;sl=slice(off,off+n);mism=int(np.sum(br!=np.asarray(oldbr[sl])));assert mism==0,(sid,mism);rtg[sl]=rt;sbg[sl]=sb;rtg.flush();sbg.flush();sec=time.time()-t;json.dump({'offset':off,'n':n,'nnz':int(X.nnz),'seconds':sec,'branch_mismatches':mism},open(NEW/f'shard_{sid:04d}.json','w'));return sid,n,sec
+if __name__=='__main__':
+ if not (NEW/'res_terms.u16').exists():a=np.memmap(NEW/'res_terms.u16',np.uint16,'w+',shape=(N,F,S));a[:]=SENT;a.flush();del a
+ if not (NEW/'signbits.u32').exists():a=np.memmap(NEW/'signbits.u32',np.uint32,'w+',shape=(N,F));a[:]=0;a.flush();del a
+ done={int(p.stem.split('_')[1]) for p in NEW.glob('shard_*.json')};missing=[i for i in range(36) if i not in done];print('missing',missing,flush=True);t=time.time()
+ with ProcessPoolExecutor(max_workers=1,mp_context=mp.get_context('spawn')) as ex:
+  fs=[ex.submit(work,i) for i in missing]
+  for k,fu in enumerate(as_completed(fs),1):sid,n,sec=fu.result();print(f'[{k:02d}/{len(missing):02d}] shard {sid:04d} n={n:,} sec={sec:.1f}',flush=True)
+ print('S32 ENCODE DONE',time.time()-t,flush=True)

experiments/msmarco_scale/msmarco_encode_s32_2w.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+import gzip,json,pickle,time
+from pathlib import Path
+from concurrent.futures import ProcessPoolExecutor,as_completed
+import multiprocessing as mp
+import numpy as np
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.preprocessing import normalize
+from numba import njit,prange,set_num_threads
+ROOT=Path('/mnt/data'); W=ROOT/'msmarco_scale_work'; G=W/'geometry_uniform1m_s32'; OLD=W/'full_index'; NEW=W/'full_index_uniform1m_s32'; NEW.mkdir(exist_ok=True)
+N=8_841_823; M=50_000; F=4; S=32; SENT=np.uint16(65535)
+
+def shard_path(i):
+ hits=list(ROOT.glob(f'corpus_{i:04d}.jsonl*.gz')); assert len(hits)==1; return hits[0]
+def load_vocab():
+ with gzip.open(W/'final_vocab_50k.pkl.gz','rb') as g:z=pickle.load(g)
+ terms=z['terms'].tolist(); idf=np.asarray(z['idf'],np.float32); return idf,{t:i for i,t in enumerate(terms)}
+@njit(cache=False)
+def lookup(ct,cv,t):
+ lo=0; hi=ct.size
+ while lo<hi:
+  mid=(lo+hi)//2; x=ct[mid]
+  if x==65535 or x>=t: hi=mid
+  else: lo=mid+1
+ if lo<ct.size and ct[lo]==t:return cv[lo]
+ return 0.0
+@njit(parallel=True,cache=False)
+def kernel(indptr,indices,data,ct,cv):
+ n=indptr.size-1; br=np.full((n,F),SENT,np.uint16); rt=np.full((n,F,S),SENT,np.uint16); sb=np.zeros((n,F),np.uint32)
+ for d in prange(n):
+  a=indptr[d]; b=indptr[d+1]; tv=np.zeros(F,np.float32); tt=np.full(F,SENT,np.uint16)
+  for p in range(a,b):
+   v=data[p]; t=np.uint16(indices[p]); pos=F
+   for r in range(F):
+    if v>tv[r]:pos=r;break
+   if pos<F:
+    for r in range(F-1,pos,-1):tv[r]=tv[r-1];tt[r]=tt[r-1]
+    tv[pos]=v;tt[pos]=t
+  den=0.0
+  for s in range(F):den+=tv[s]
+  if den<=0:continue
+  for s in range(F):br[d,s]=tt[s]
+  for sl in range(F):
+   j=int(tt[sl]); best=np.zeros(S,np.float32); bt=np.full(S,SENT,np.uint16); bp=np.zeros(S,np.uint8)
+   for p in range(a,b):
+    t=np.uint16(indices[p]); rr=data[p]-lookup(ct[j],cv[j],t); ar=abs(rr); mi=0; mv=best[0]
+    for q in range(1,S):
+     if best[q]<mv:mi=q;mv=best[q]
+    if ar>mv:best[mi]=ar;bt[mi]=t;bp[mi]=1 if rr>=0 else 0
+   for x in range(S):
+    mx=x
+    for y in range(x+1,S):
+     if best[y]>best[mx]:mx=y
+    if mx!=x:
+     zz=best[x];best[x]=best[mx];best[mx]=zz; zt=bt[x];bt[x]=bt[mx];bt[mx]=zt; zp=bp[x];bp[x]=bp[mx];bp[mx]=zp
+   bits=np.uint32(0)
+   for q in range(S):
+    rt[d,sl,q]=bt[q]
+    if bt[q]!=SENT and bp[q]:bits|=np.uint32(1)<<np.uint32(q)
+   sb[d,sl]=bits
+ return br,rt,sb
+
+def work(sid):
+ set_num_threads(1); t=time.time(); idf,vocab=load_vocab(); ct=np.load(G/'center_terms.npy',mmap_mode='r'); cvv=np.load(G/'center_values.npy',mmap_mode='r'); oldbr=np.memmap(OLD/'branches.u16',np.uint16,'r',shape=(N,F)); rtg=np.memmap(NEW/'res_terms.u16',np.uint16,'r+',shape=(N,F,S)); sbg=np.memmap(NEW/'signbits.u32',np.uint32,'r+',shape=(N,F))
+ texts=[]
+ with gzip.open(shard_path(sid),'rt',encoding='utf-8') as f:
+  for line in f:
+   o=json.loads(line);texts.append(((o.get('title') or '')+' '+(o.get('text') or '')).strip())
+ cv=CountVectorizer(vocabulary=vocab,lowercase=True,token_pattern=r'(?u)\b\w\w+\b',dtype=np.int32);X=cv.transform(texts).tocsr().astype(np.float32);X.data*=idf[X.indices];normalize(X,norm='l2',axis=1,copy=False);X.sort_indices(); br,rt,sb=kernel(X.indptr.astype(np.int64),X.indices.astype(np.int32),X.data.astype(np.float32),ct,cvv)
+ n=len(texts);off=sid*250_000;sl=slice(off,off+n);mism=int(np.sum(br!=np.asarray(oldbr[sl])));assert mism==0,(sid,mism);rtg[sl]=rt;sbg[sl]=sb;rtg.flush();sbg.flush();sec=time.time()-t;json.dump({'offset':off,'n':n,'nnz':int(X.nnz),'seconds':sec,'branch_mismatches':mism},open(NEW/f'shard_{sid:04d}.json','w'));return sid,n,sec
+if __name__=='__main__':
+ if not (NEW/'res_terms.u16').exists():a=np.memmap(NEW/'res_terms.u16',np.uint16,'w+',shape=(N,F,S));a[:]=SENT;a.flush();del a
+ if not (NEW/'signbits.u32').exists():a=np.memmap(NEW/'signbits.u32',np.uint32,'w+',shape=(N,F));a[:]=0;a.flush();del a
+ done={int(p.stem.split('_')[1]) for p in NEW.glob('shard_*.json')};missing=[i for i in range(36) if i not in done];print('missing',missing,flush=True);t=time.time()
+ with ProcessPoolExecutor(max_workers=2,mp_context=mp.get_context('spawn')) as ex:
+  fs=[ex.submit(work,i) for i in missing]
+  for k,fu in enumerate(as_completed(fs),1):sid,n,sec=fu.result();print(f'[{k:02d}/{len(missing):02d}] shard {sid:04d} n={n:,} sec={sec:.1f}',flush=True)
+ print('S32 ENCODE DONE',time.time()-t,flush=True)