diff --git a/docs/BASELINE_SUITE.md b/docs/BASELINE_SUITE.md new file mode 100644 index 0000000000000000000000000000000000000000..60f9f7969bf9dc1f830146fa9c2496257522f0ef --- /dev/null +++ b/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. diff --git a/docs/LITERATURE_AND_SPEED.md b/docs/LITERATURE_AND_SPEED.md new file mode 100644 index 0000000000000000000000000000000000000000..97402d7be339ddb5125a4bebbf45107e1cc249c6 --- /dev/null +++ b/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.** diff --git a/docs/METHOD.md b/docs/METHOD.md new file mode 100644 index 0000000000000000000000000000000000000000..f915fff03c1b71f883dfaeb81b7f9feb057bfc10 --- /dev/null +++ b/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**. diff --git a/docs/RAG_PROTOCOL.md b/docs/RAG_PROTOCOL.md new file mode 100644 index 0000000000000000000000000000000000000000..c7f61873709e9c9e89d5ca6bfb91001d48fdca0f --- /dev/null +++ b/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. diff --git a/docs/REPRODUCIBILITY.md b/docs/REPRODUCIBILITY.md new file mode 100644 index 0000000000000000000000000000000000000000..76264288e51c10a4a25f73488be0b5e4c203c345 --- /dev/null +++ b/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. diff --git a/docs/images/scifact_pool_sweep.png b/docs/images/scifact_pool_sweep.png new file mode 100644 index 0000000000000000000000000000000000000000..918bb35f78e4bcdacbf03bf1b147ee0f4699c5ea --- /dev/null +++ b/docs/images/scifact_pool_sweep.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b1b557dfa9735a945ed90ecca0bc8a3c4b7b6c5c868b244319564193b52a1cca +size 85797 diff --git a/docs/images/treccovid_pool_sweep.png b/docs/images/treccovid_pool_sweep.png new file mode 100644 index 0000000000000000000000000000000000000000..721fa2170ef0525dd17dc0af1c6031a4d1a22d00 --- /dev/null +++ b/docs/images/treccovid_pool_sweep.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:45cd761e476585ed66c2f556dda1f6c3f41e952990aba2b4896afe86ba6450ce +size 93418 diff --git a/docs/images/treccovid_speed_pool.png b/docs/images/treccovid_speed_pool.png new file mode 100644 index 0000000000000000000000000000000000000000..3662adfd8e971f94460e7a91e2c0735bdb5ac1dc --- /dev/null +++ b/docs/images/treccovid_speed_pool.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:69ac0bdc2e42aba38b97af2d0f2f742a2d4868bbc3cf29b55498570b6dc93597 +size 66092 diff --git a/experiments/beir/run_pool_sweep.py b/experiments/beir/run_pool_sweep.py new file mode 100644 index 0000000000000000000000000000000000000000..3e28809d73604618f643d9e2f2afee779811795c --- /dev/null +++ b/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() diff --git a/experiments/beir/run_rag_top10.py b/experiments/beir/run_rag_top10.py new file mode 100644 index 0000000000000000000000000000000000000000..2b4564e4b5ec39362d04f4384ea88046ccabf8f9 --- /dev/null +++ b/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() diff --git a/experiments/beir/scifact_pool_sweep_exact_history.py b/experiments/beir/scifact_pool_sweep_exact_history.py new file mode 100644 index 0000000000000000000000000000000000000000..863689c6ac6e18a219eaf019d0883dba74d1d5d6 --- /dev/null +++ b/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 ia: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)=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) diff --git a/experiments/beir/treccovid_collision_diag_exact_history.py b/experiments/beir/treccovid_collision_diag_exact_history.py new file mode 100644 index 0000000000000000000000000000000000000000..0d8e622d9b0da0b55a6203faff2936958872a6bb --- /dev/null +++ b/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<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< 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) diff --git a/experiments/beir/treccovid_hq_branch_exact_history.py b/experiments/beir/treccovid_hq_branch_exact_history.py new file mode 100644 index 0000000000000000000000000000000000000000..e8e6e19e5bdd8639978702310549ff56b43d242a --- /dev/null +++ b/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 ia: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)=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) diff --git a/experiments/beir/treccovid_idf_power_exact_history.py b/experiments/beir/treccovid_idf_power_exact_history.py new file mode 100644 index 0000000000000000000000000000000000000000..be6329b4d952818ff3b178dc4a38f83fb9d8660d --- /dev/null +++ b/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 ia: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)=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) diff --git a/experiments/beir/treccovid_local_baselines_exact_history.py b/experiments/beir/treccovid_local_baselines_exact_history.py new file mode 100644 index 0000000000000000000000000000000000000000..f67b3e3818e43accee5ebc7fe3ae72addc2cac0a --- /dev/null +++ b/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) diff --git a/experiments/beir/treccovid_pool_sweep_exact_history.py b/experiments/beir/treccovid_pool_sweep_exact_history.py new file mode 100644 index 0000000000000000000000000000000000000000..c62491aedac35f4949de5e3f79528558b23f081b --- /dev/null +++ b/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 ia: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)=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) diff --git a/experiments/msmarco_scale/bench_fast.py b/experiments/msmarco_scale/bench_fast.py new file mode 100644 index 0000000000000000000000000000000000000000..f32259a527ac283b08cf3ba78a470904e091ac16 --- /dev/null +++ b/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) diff --git a/experiments/msmarco_scale/bench_post.py b/experiments/msmarco_scale/bench_post.py new file mode 100644 index 0000000000000000000000000000000000000000..2b37c11470cd4bfd082001fd2b3bb3c9cde8dc62 --- /dev/null +++ b/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) diff --git a/experiments/msmarco_scale/build_branch_sorted_layout.py b/experiments/msmarco_scale/build_branch_sorted_layout.py new file mode 100644 index 0000000000000000000000000000000000000000..f1e616201e2fa4fb65945fcdf6dfea5801189f68 --- /dev/null +++ b/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) diff --git a/experiments/msmarco_scale/build_global_support.py b/experiments/msmarco_scale/build_global_support.py new file mode 100644 index 0000000000000000000000000000000000000000..31f8bf2cdba3c88cc144361edcb5da8b13d921ac --- /dev/null +++ b/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) diff --git a/experiments/msmarco_scale/compare_fast_post.py b/experiments/msmarco_scale/compare_fast_post.py new file mode 100644 index 0000000000000000000000000000000000000000..2bfba82fbb33ed4accbf5afce20155e8e356d242 --- /dev/null +++ b/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) diff --git a/experiments/msmarco_scale/msmarco_allroute_diag.py b/experiments/msmarco_scale/msmarco_allroute_diag.py new file mode 100644 index 0000000000000000000000000000000000000000..5ca7e3daa0de858b35ebc7a44392dd7034de2098 --- /dev/null +++ b/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) diff --git a/experiments/msmarco_scale/msmarco_amplitude_diag_stage1.py b/experiments/msmarco_scale/msmarco_amplitude_diag_stage1.py new file mode 100644 index 0000000000000000000000000000000000000000..0eaa45d7d4a89b9342a0f6653cf2abfdcbec1a50 --- /dev/null +++ b/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 k0]; 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(targets): break + td=int(targets[ti]) + if d=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) diff --git a/experiments/msmarco_scale/msmarco_amplitude_diag_stage3.py b/experiments/msmarco_scale/msmarco_amplitude_diag_stage3.py new file mode 100644 index 0000000000000000000000000000000000000000..80f475cfd8a6a7922be85006cbb6d3522f8a4134 --- /dev/null +++ b/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=t: hi=md + else: lo=md+1 + if lo=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) diff --git a/experiments/msmarco_scale/msmarco_best_all_dev.py b/experiments/msmarco_scale/msmarco_best_all_dev.py new file mode 100644 index 0000000000000000000000000000000000000000..d11ba8fc5c373bc91257dd5c9669c5eb8adcf75e --- /dev/null +++ b/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>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]] + diff --git a/experiments/msmarco_scale/msmarco_best_tail_dev.py b/experiments/msmarco_scale/msmarco_best_tail_dev.py new file mode 100644 index 0000000000000000000000000000000000000000..22b6ab5e6bf1c8b88b89a793f8b991623786a703 --- /dev/null +++ b/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>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(k0: + 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>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) diff --git a/experiments/msmarco_scale/msmarco_branch_features.py b/experiments/msmarco_scale/msmarco_branch_features.py new file mode 100644 index 0000000000000000000000000000000000000000..3fb43c92ad268c1f14fc66e95297bb3c8e7e7ece --- /dev/null +++ b/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>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) diff --git a/experiments/msmarco_scale/msmarco_branch_fusion_sweep.py b/experiments/msmarco_scale/msmarco_branch_fusion_sweep.py new file mode 100644 index 0000000000000000000000000000000000000000..1c9dab5d08073dc7f06fab1911b2621478fed534 --- /dev/null +++ b/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]] diff --git a/experiments/msmarco_scale/msmarco_build_geometry.py b/experiments/msmarco_scale/msmarco_build_geometry.py new file mode 100644 index 0000000000000000000000000000000000000000..a4e9acd7ba5e5a02338d0e12a1d75ba0f0eebeda --- /dev/null +++ b/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=t: hi=mid + else: lo=mid+1 + if lomv: + 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) diff --git a/experiments/msmarco_scale/msmarco_build_geometry_uniform1m.py b/experiments/msmarco_scale/msmarco_build_geometry_uniform1m.py new file mode 100644 index 0000000000000000000000000000000000000000..3ba01fad322df23597d4d12b246eccb1538181c3 --- /dev/null +++ b/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]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) diff --git a/experiments/msmarco_scale/msmarco_build_s32_reliability.py b/experiments/msmarco_scale/msmarco_build_s32_reliability.py new file mode 100644 index 0000000000000000000000000000000000000000..2defead33a6c720ed78eb700ae3460b51cf8f5f0 --- /dev/null +++ b/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) diff --git a/experiments/msmarco_scale/msmarco_coordination_features.py b/experiments/msmarco_scale/msmarco_coordination_features.py new file mode 100644 index 0000000000000000000000000000000000000000..82a32cccdf6818a8df9ece07e84a51304004ac9b --- /dev/null +++ b/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) diff --git a/experiments/msmarco_scale/msmarco_coordination_sweep.py b/experiments/msmarco_scale/msmarco_coordination_sweep.py new file mode 100644 index 0000000000000000000000000000000000000000..9d171dd3e8c8621ea7abf7ddacacc01a26aa8f15 --- /dev/null +++ b/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]] diff --git a/experiments/msmarco_scale/msmarco_covbonus_sweep.py b/experiments/msmarco_scale/msmarco_covbonus_sweep.py new file mode 100644 index 0000000000000000000000000000000000000000..a81916c5a7b8668ab02be623b98df20a3bde5132 --- /dev/null +++ b/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]) diff --git a/experiments/msmarco_scale/msmarco_dev_fast.py b/experiments/msmarco_scale/msmarco_dev_fast.py new file mode 100644 index 0000000000000000000000000000000000000000..d9c08b7ea33473914d2133a714ddbcb5055038cd --- /dev/null +++ b/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(kk: + 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=kkk: + 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=kkk: + 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=kkk: + 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=(kkP 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) diff --git a/experiments/msmarco_scale/msmarco_early_lex_validation_fast.py b/experiments/msmarco_scale/msmarco_early_lex_validation_fast.py new file mode 100644 index 0000000000000000000000000000000000000000..230a2431348fb507ded67292ad2e60ca7bdd9a0e --- /dev/null +++ b/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=t: hi=mid + else: lo=mid+1 + if lotv[r]: pos=r; break + if posmv: + 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<=t: hi=mid + else: lo=mid+1 + if lotv[r]:pos=r;break + if posmv: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)<=t: hi=mid + else: lo=mid+1 + if lotv[r]:pos=r;break + if posmv: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)<=t: hi=mid + else: lo=mid+1 + if lotv[r]:pos=r;break + if posmv: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)<=t: hi=mid + else: lo=mid+1 + if lotv[r]:pos=r;break + if posmv: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)<0: + raw += v; cnt += 1 + sm += semvec[t] + denom=(1.0-m.LENGTH_B)+m.LENGTH_B*(float(dl[d])/avgdl) + rawlex[z]=raw; lex[z]=raw/(denom if denom>0 else 1.0); sem[z]=sm; qcount[z]=cnt; lenfac[z]=denom + return lex,rawlex,sem,qcount,lenfac + +def topk(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 validation 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); qids=[str(x) for x in rng.choice(uq,size=1000,replace=False)] +texts=m.load_query_texts(qids) +# allocate fixed P arrays +shape=(len(qids),P) +docsO=np.zeros(shape,np.uint32); valid=np.zeros(len(qids),np.int32) +features={k:np.zeros(shape,dtype) for k,dtype in [ + ('geom',np.float32),('cons',np.float32),('tail',np.float32),('lex',np.float32),('rawlex',np.float32),('sem',np.float32),('qcount',np.float32),('lenfac',np.float32),('branch_count',np.float32),('max_cons',np.float32),('max_geom',np.float32)]} +qterms=np.zeros(len(qids),np.int16) +prep=[] +# warmup +_=support_features(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.zeros(M,np.float32),np.zeros(M,np.float32),idx.dl,idx.avgdl) +for qi,qid in enumerate(qids): + t0=time.perf_counter(); text=texts[qid] + q=idx.query_vec(text); qd=np.zeros(M,np.float32); qd[q.indices]=q.data; qterms[qi]=len(q.indices) + 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: continue + dmem=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,consmem=b.score_components(rslot,mm,rt,sb,qd,rho,cent,rel) + ud,inv=np.unique(dmem,return_inverse=True) + geom=np.bincount(inv,weights=base*np.power(sig,b.GAMMA,dtype=np.float32),minlength=len(ud)).astype(np.float32) + cons=np.bincount(inv,weights=consmem,minlength=len(ud)).astype(np.float32) + tail=geom+b.LAM*cons + bc=np.bincount(inv,minlength=len(ud)).astype(np.float32) + # max per-document membership-level contributions, preserved as structural evidence + mxcon=np.full(len(ud),-np.inf,np.float32); np.maximum.at(mxcon,inv,consmem); mxcon[~np.isfinite(mxcon)]=0 + memgeom=base*np.power(sig,b.GAMMA,dtype=np.float32); mxg=np.full(len(ud),-np.inf,np.float32); np.maximum.at(mxg,inv,memgeom); mxg[~np.isfinite(mxg)]=0 + # support features for all routed docs, needed for eta=1 selection + lexvec=np.zeros(M,np.float32); lexvec[q.indices]=idx.idf[q.indices] + semvec=np.zeros(M,np.float32) + for tt,amp in zip(q.indices,q.data): + a,bb=idx.A.indptr[tt],idx.A.indptr[tt+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] + lx,rlx,sm,qc,lf=support_features(ud,idx.sup_ip,idx.sup_ids,lexvec,semvec,idx.dl,idx.avgdl) + sel=topk(m.zscore(tail)+m.zscore(lx),P) # locked eta=1 + k=len(sel); valid[qi]=k; docsO[qi,:k]=ud[sel] + for name,arr in [('geom',geom),('cons',cons),('tail',tail),('lex',lx),('rawlex',rlx),('sem',sm),('qcount',qc.astype(np.float32)),('lenfac',lf),('branch_count',bc),('max_cons',mxcon),('max_geom',mxg)]: features[name][qi,:k]=arr[sel] + prep.append((time.perf_counter()-t0)*1000) + if (qi+1)%100==0: print('q',qi+1,'median',float(np.median(prep)),flush=True) + +save={'qids':np.asarray(qids),'valid':valid,'docs':docsO,'qterms':qterms}|features +np.savez_compressed(OUT/'fixed_eta1_structural_features.npz',**save) +meta={'protocol':'same deterministic 1000 TRAIN validation and locked eta=1 P=2000 pools; features use only current index','features':list(features),'median_prepare_ms':float(np.median(prep)),'p95_prepare_ms':float(np.percentile(prep,95))} +json.dump(meta,open(OUT/'structural_feature_meta.json','w'),indent=2); print('DONE',meta,flush=True) diff --git a/experiments/msmarco_scale/msmarco_extract_structural_features_fast.py b/experiments/msmarco_scale/msmarco_extract_structural_features_fast.py new file mode 100644 index 0000000000000000000000000000000000000000..fe55dc714bedcef9dacfeb73604241e93108cc6e --- /dev/null +++ b/experiments/msmarco_scale/msmarco_extract_structural_features_fast.py @@ -0,0 +1,55 @@ +from __future__ import annotations +import sys,time,json +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_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 +OUT=WORK/'structural_fusion'; OUT.mkdir(exist_ok=True); set_num_threads(5) + +@njit(parallel=True,cache=False) +def selected_support_extra(cand_docs,ip,ids,lexvec,dl,avgdl): + n=len(cand_docs); rawlex=np.zeros(n,np.float32); qcount=np.zeros(n,np.float32); lenfac=np.zeros(n,np.float32) + for z in prange(n): + d=int(cand_docs[z]); a=int(ip[d]); bb=int(ip[d+1]); raw=0.0; cnt=0.0 + for k in range(a,bb): + t=int(ids[k]); v=lexvec[t] + if v>0: raw+=v; cnt+=1.0 + rawlex[z]=raw; qcount[z]=cnt; lenfac[z]=(1.0-m.LENGTH_B)+m.LENGTH_B*(float(dl[d])/avgdl) + return rawlex,qcount,lenfac + +def topk(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]] + +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); qids=[str(x) for x in rng.choice(uq,size=1000,replace=False)]; texts=m.load_query_texts(qids) +shape=(len(qids),P); docsO=np.zeros(shape,np.uint32); valid=np.zeros(len(qids),np.int32); qterms=np.zeros(len(qids),np.int16) +fnames=['geom','cons','tail','lex','rawlex','sem','qcount','lenfac','branch_count'] +feat={k:np.zeros(shape,np.float32) for k in fnames}; prep=[] +_=selected_support_extra(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.zeros(M,np.float32),idx.dl,idx.avgdl) +for qi,qid in enumerate(qids): + t0=time.perf_counter(); q=idx.query_vec(texts[qid]); qd=np.zeros(M,np.float32); qd[q.indices]=q.data; qterms[qi]=len(q.indices); 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: continue + dmem=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,consmem=b.score_components(rslot,mm,rt,sb,qd,rho,cent,rel) + ud,inv=np.unique(dmem,return_inverse=True); geom=np.bincount(inv,weights=base*np.power(sig,b.GAMMA,dtype=np.float32),minlength=len(ud)).astype(np.float32); cons=np.bincount(inv,weights=consmem,minlength=len(ud)).astype(np.float32); tail=geom+b.LAM*cons; bc=np.bincount(inv,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 tt,amp in zip(q.indices,q.data): + a,bb=idx.A.indptr[tt],idx.A.indptr[tt+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] + lx,sm=m.score_support_pool(ud,idx.sup_ip,idx.sup_ids,lexvec,semvec,idx.dl,idx.avgdl) + sel=topk(m.zscore(tail)+m.zscore(lx),P); k=len(sel); valid[qi]=k; dd=ud[sel]; docsO[qi,:k]=dd + raw,qc,lf=selected_support_extra(dd,idx.sup_ip,idx.sup_ids,lexvec,idx.dl,idx.avgdl) + vals={'geom':geom[sel],'cons':cons[sel],'tail':tail[sel],'lex':lx[sel],'rawlex':raw,'sem':sm[sel],'qcount':qc,'lenfac':lf,'branch_count':bc[sel]} + for nm,v in vals.items(): feat[nm][qi,:k]=v + prep.append((time.perf_counter()-t0)*1000) + if (qi+1)%100==0: print('q',qi+1,'median',float(np.median(prep)),flush=True) +np.savez_compressed(OUT/'fixed_eta1_structural_features.npz',qids=np.asarray(qids),valid=valid,docs=docsO,qterms=qterms,**feat) +meta={'protocol':'same deterministic 1000 TRAIN validation, eta=1 P=2000 pools; index-only features','features':fnames,'median_ms':float(np.median(prep)),'p95_ms':float(np.percentile(prep,95))}; json.dump(meta,open(OUT/'structural_feature_meta.json','w'),indent=2); print('DONE',meta,flush=True) diff --git a/experiments/msmarco_scale/msmarco_final_test_once.py b/experiments/msmarco_scale/msmarco_final_test_once.py new file mode 100644 index 0000000000000000000000000000000000000000..40c1bc4a226d15e7f3085fa833ace4f3f35d8a70 --- /dev/null +++ b/experiments/msmarco_scale/msmarco_final_test_once.py @@ -0,0 +1,100 @@ +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_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); FINAL_B=np.float32(0.1); ALPHA=np.float32(0.25); WLEX=np.float32(4.0); WSEM=np.float32(0.3); WRARE=np.float32(1.0) +set_num_threads(5) + +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 final_features(dd,ip,ids,qmask,rarerank,idf,semvec,dl,avgdl): + n=len(dd); lx=np.zeros(n,np.float32); sm=np.zeros(n,np.float32); qc=np.zeros(n,np.float32); r3=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.; ss=0.; c=0.; rr3=0. + for k in range(a,bb): + t=int(ids[k]); ss+=semvec[t] + if qmask[t]: + x=float(idf[t]); raw+=x*x; c+=1. + if int(rarerank[t])>0: rr3+=1. + ratio=float(dl[d])/avgdl; den=(1.0-FINAL_B)+FINAL_B*ratio + if den<=0:den=1. + lx[z]=raw/den; sm[z]=ss; qc[z]=c; r3[z]=rr3 + return lx,sm,qc,r3 + +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: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) + # Frozen early rescue: p=1 binary IDF, eta=1, package's weak b=.2 length correction. + lexvec=np.zeros(M,np.float32); lexvec[q.indices]=idx.idf[q.indices]; zero=np.zeros(M,np.float32) + oldlex,_=m.score_support_pool(ud,idx.sup_ip,idx.sup_ids,lexvec,zero,idx.dl,idx.avgdl) + sel=topk_desc(m.zscore(tail)+ETA*m.zscore(oldlex),P); dd=ud[sel]; ts=tail[sel] + 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] + qmask=np.zeros(M,np.uint8); qmask[q.indices]=1; rarerank=np.zeros(M,np.uint8) + ordq=q.indices[np.argsort(idx.idf[q.indices])[::-1]] + for r,t in enumerate(ordq[:3],start=1): rarerank[t]=r + lx,sm,qc,r3=final_features(dd,idx.sup_ip,idx.sup_ids,qmask,rarerank,idx.idf,semvec,idx.dl,idx.avgdl) + cov=qc/max(1,len(q.indices)); ladj=lx*np.power(np.maximum(cov,1e-6),ALPHA); rarecov=r3/max(1,min(3,len(q.indices))) + fin=m.zscore(ts)+WLEX*m.zscore(ladj)+WSEM*m.zscore(sm)+WRARE*m.zscore(rarecov) + oo=np.argsort(fin)[::-1][:100] + return [int(x) for x in dd[oo]],ud,sel + +def eval_beir(run,qrels): + metrics={'nDCG@10':[],'nDCG@10_expGain_diag':[],'MRR@10':[],'P@10':[],'R@10':[],'R@100':[],'Hit@10':[],'Hit@100':[]} + for qid,qr in qrels.items(): + rank=run.get(qid,[]); pos={int(d) for d,r in qr.items() if float(r)>0}; n=max(1,len(pos)) + h10=sum(d in pos for d in rank[:10]); h100=sum(d in pos for d in rank[:100]) + metrics['P@10'].append(h10/10); metrics['R@10'].append(h10/n); metrics['R@100'].append(h100/n); metrics['Hit@10'].append(float(h10>0)); metrics['Hit@100'].append(float(h100>0)) + rr=0. + for i,d in enumerate(rank[:10],1): + if d in pos: rr=1/i; break + metrics['MRR@10'].append(rr) + obs=[float(qr.get(str(d),qr.get(d,0.0))) for d in rank[:10]] + ideal=sorted([float(r) for r in qr.values()],reverse=True)[:10] + dcg_lin=sum(float(r)/math.log2(i+2) for i,r in enumerate(obs)); idcg_lin=sum(float(r)/math.log2(i+2) for i,r in enumerate(ideal)) + dcg_exp=sum((2.0**float(r)-1.0)/math.log2(i+2) for i,r in enumerate(obs)); idcg_exp=sum((2.0**float(r)-1.0)/math.log2(i+2) for i,r in enumerate(ideal)) + metrics['nDCG@10'].append(dcg_lin/idcg_lin if idcg_lin else 0.0) + metrics['nDCG@10_expGain_diag'].append(dcg_exp/idcg_exp if idcg_exp else 0.0) + return {k:float(np.mean(v)) for k,v in metrics.items()} | {'n_queries':len(qrels)} + +# TEST IDs and full graded qrels (including zero judgments for nDCG ideal ordering). +tdf=pd.read_csv(ROOT/'test.tsv',sep='\t'); ids=[str(x) for x in np.unique(tdf['query-id'].to_numpy())]; del tdf +texts=m.load_query_texts(ids); qrels=m.qrels_from_tsv(ROOT/'test.tsv',ids,positive_only=False) +missing=[q for q in ids if q not in texts] +if missing: raise RuntimeError(f'missing query texts {missing}') +# Warmup excluded. +_=final_features(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.zeros(M,np.uint8),np.zeros(M,np.uint8),idx.idf,np.zeros(M,np.float32),idx.dl,idx.avgdl); _=prepare(texts[ids[0]]) +run={}; times=[]; routehit=poolhit=den=0; cands=[] +for z,qid in enumerate(ids): + t=time.perf_counter(); out=prepare(texts[qid]); times.append((time.perf_counter()-t)*1000) + if out is None: run[qid]=[]; continue + rank,ud,sel=out; run[qid]=rank; cands.append(len(ud)); rels=[int(d) for d,r in qrels[qid].items() if float(r)>0]; den+=len(rels); pooldocs=set(map(int,ud[sel].tolist())) + for d in rels: + kk=np.searchsorted(ud,d); ok=kk0 and rr<=5: mask |= (1 << (rr-1)) + lex2raw[z]=s2; cnt[z]=min(c,255); sem[z]=ss; raremask[z]=mask + return lex2raw,cnt,sem,raremask + +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: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) + # Current validated early rescue: binary-IDF p=1, default b=.2, eta=1. + lexvec=np.zeros(M,np.float32); lexvec[q.indices]=idx.idf[q.indices]; zero=np.zeros(M,np.float32) + oldlex,_=m.score_support_pool(ud,idx.sup_ip,idx.sup_ids,lexvec,zero,idx.dl,idx.avgdl) + sel=topk_desc(m.zscore(tail)+m.zscore(oldlex),P); dd=ud[sel]; ts=tail[sel] + 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] + qmask=np.zeros(M,np.uint8); qmask[q.indices]=1; rarerank=np.zeros(M,np.uint8) + ordq=q.indices[np.argsort(idx.idf[q.indices])[::-1]] + for r,t in enumerate(ordq[:5],start=1): rarerank[t]=r + lex2raw,cnt,sem,raremask=selected_features(dd,idx.sup_ip,idx.sup_ids,qmask,rarerank,idx.idf,semvec) + return dd,ts,lex2raw,cnt,sem,raremask,len(q.indices),len(ud) + +# Exactly the five folds already used in previous robustness experiments. +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 +f0=set(int(x) for x in fold0); rem=np.asarray([x for x in uq if int(x) not in f0]); rng=np.random.default_rng(20260816); extra=rng.choice(rem,size=4000,replace=False) +folds=[fold0]+[[str(x) for x in extra[i*1000:(i+1)*1000]] for i in range(4)] +qids=np.asarray([q for f in folds for q in f],dtype='U32'); fold_id=np.repeat(np.arange(5,dtype=np.uint8),1000) +texts=m.load_query_texts(qids.tolist()) +NQ=len(qids); shape=(NQ,P) +docs=np.memmap(OUT/'docs.u32',np.uint32,'w+',shape=shape); docs[:]=np.uint32(0xffffffff) +tail=np.memmap(OUT/'tail.f32',np.float32,'w+',shape=shape); tail[:]=0 +lex2=np.memmap(OUT/'lex2raw.f32',np.float32,'w+',shape=shape); lex2[:]=0 +sem=np.memmap(OUT/'sem.f32',np.float32,'w+',shape=shape); sem[:]=0 +cnt=np.memmap(OUT/'cnt.u8',np.uint8,'w+',shape=shape); cnt[:]=0 +rm=np.memmap(OUT/'raremask.u8',np.uint8,'w+',shape=shape); rm[:]=0 +nvalid=np.zeros(NQ,np.uint16); qlen=np.zeros(NQ,np.uint16); cand=np.zeros(NQ,np.uint32); times=[] +_=selected_features(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.zeros(M,np.uint8),np.zeros(M,np.uint8),idx.idf,np.zeros(M,np.float32)); _=prepare(texts[qids[0]]) +start=time.time() +for i,qid in enumerate(qids): + t=time.perf_counter(); out=prepare(texts[qid]); times.append((time.perf_counter()-t)*1000) + if out is not None: + dd,ts,lx,cc,ss,rr,ql,cd=out; n=min(P,len(dd)); docs[i,:n]=dd[:n]; tail[i,:n]=ts[:n]; lex2[i,:n]=lx[:n]; cnt[i,:n]=cc[:n]; sem[i,:n]=ss[:n]; rm[i,:n]=rr[:n]; nvalid[i]=n; qlen[i]=ql; cand[i]=cd + if (i+1)%250==0: print('CACHE',i+1,'median250',float(np.median(times[-250:])), 'elapsed',time.time()-start,flush=True) +for a in [docs,tail,lex2,sem,cnt,rm]: a.flush() +np.savez(OUT/'meta.npz',qids=qids,fold_id=fold_id,nvalid=nvalid,qlen=qlen,candidate_docs=cand) +meta={'protocol':'five fixed disjoint 1000-query TRAIN folds; current validated early rescue eta=1 p=1 P=2000; cached final-stage features','n_queries':NQ,'P':P,'timing':{'median_ms':float(np.median(times)),'p95_ms':float(np.percentile(times,95)),'seconds':time.time()-start},'files':{'docs':'docs.u32','tail':'tail.f32','lex2raw':'lex2raw.f32','sem':'sem.f32','cnt':'cnt.u8','raremask':'raremask.u8','meta':'meta.npz'}} +json.dump(meta,open(OUT/'cache_manifest.json','w'),indent=2) +print('DONE',json.dumps(meta,indent=2),flush=True) diff --git a/experiments/msmarco_scale/msmarco_finish_train_tune.py b/experiments/msmarco_scale/msmarco_finish_train_tune.py new file mode 100644 index 0000000000000000000000000000000000000000..7a1570c5e25c805815413a2cb90cea1b8826a24f --- /dev/null +++ b/experiments/msmarco_scale/msmarco_finish_train_tune.py @@ -0,0 +1,129 @@ +from __future__ import annotations +import json, math, time +from pathlib import Path +import numpy as np, pandas as pd +from numba import njit,set_num_threads +ROOT=Path('/mnt/data'); WORK=ROOT/'msmarco_scale_work'; C=WORK/'finish_train_cache'; P=2000; NQ=5000 +meta=np.load(C/'meta.npz',allow_pickle=False); qids=meta['qids'].astype(str); fold_id=meta['fold_id']; nvalid=meta['nvalid'].astype(np.int32); qlen=meta['qlen'].astype(np.int32) +docs=np.memmap(C/'docs.u32',np.uint32,'r',shape=(NQ,P)); tail=np.memmap(C/'tail.f32',np.float32,'r',shape=(NQ,P)); lex2=np.memmap(C/'lex2raw.f32',np.float32,'r',shape=(NQ,P)); sem=np.memmap(C/'sem.f32',np.float32,'r',shape=(NQ,P)); cnt=np.memmap(C/'cnt.u8',np.uint8,'r',shape=(NQ,P)); rm=np.memmap(C/'raremask.u8',np.uint8,'r',shape=(NQ,P)) +IDX=WORK/'full_index_uniform1m'; N=8841823; dl=np.memmap(IDX/'doc_lengths.u16',np.uint16,'r',shape=(N,)); avgdl=float(json.load(open(IDX/'meta.json'))['avg_doc_length']) +# relevance padded (TRAIN is binary, max 7 positives/query) +df=pd.read_csv(ROOT/'train.tsv',sep='\t'); wanted={q:i for i,q in enumerate(qids)}; rel_lists=[[] for _ in range(NQ)] +for q,d,s in zip(df['query-id'].astype(str),df['corpus-id'],df['score']): + i=wanted.get(q) + if i is not None and float(s)>0: rel_lists[i].append(int(d)) +maxr=max(map(len,rel_lists)); rel=np.full((NQ,maxr),np.uint32(0xffffffff),np.uint32); nr=np.zeros(NQ,np.int32) +for i,r in enumerate(rel_lists): nr[i]=len(r); rel[i,:len(r)]=r +set_num_threads(5) + +@njit(cache=False) +def popcnt5(x): + c=0 + for b in range(5): c += (x>>b)&1 + return c + +@njit(cache=False) +def eval_params(docs,tail,lex2,sem,cnt,rm,nvalid,qlen,dl,avgdl,rel,nr,fold_id,b,alpha,wlex,wsem,rarek,wrare): + # sums: ndcg,mrr,p10,r10,r100,hit10,hit100,count per fold + sums=np.zeros((5,8),np.float64) + for qi in range(docs.shape[0]): + n=int(nvalid[qi]); f=int(fold_id[qi]); ql=max(1,int(qlen[qi])); nrel=max(1,int(nr[qi])) + if n<=0: + sums[f,7]+=1.0 + continue + # component means + mt=0.; ml=0.; ms=0.; mr=0. + # scratch raw lexical and rare values + lv=np.empty(n,np.float32); rv=np.empty(n,np.float32) + masklim=(1<0 else 0 + denomrare=max(1,min(rarek,ql)) if rarek>0 else 1 + for j in range(n): + d=int(docs[qi,j]); den=(1.0-b)+b*(float(dl[d])/avgdl) + if den<=0: den=1.0 + cov=float(cnt[qi,j])/ql + if cov<1e-6: cov=1e-6 + l=float(lex2[qi,j])/den*(cov**alpha) + if rarek>0: + rr=popcnt5(int(rm[qi,j]) & masklim)/denomrare + else: rr=0.0 + lv[j]=l; rv[j]=rr; mt+=float(tail[qi,j]); ml+=l; ms+=float(sem[qi,j]); mr+=rr + mt/=n; ml/=n; ms/=n; mr/=n + vt=0.; vl=0.; vs=0.; vr=0. + for j in range(n): + x=float(tail[qi,j])-mt; vt+=x*x + x=float(lv[j])-ml; vl+=x*x + x=float(sem[qi,j])-ms; vs+=x*x + x=float(rv[j])-mr; vr+=x*x + st=math.sqrt(vt/n)+1e-8; sl=math.sqrt(vl/n)+1e-8; ss=math.sqrt(vs/n)+1e-8; sr=math.sqrt(vr/n)+1e-8 + sc=np.empty(n,np.float32) + for j in range(n): + zt=(float(tail[qi,j])-mt)/st; zl=(float(lv[j])-ml)/sl; zs=(float(sem[qi,j])-ms)/ss + zr=0.0 if rarek<=0 or sr<1e-7 else (float(rv[j])-mr)/sr + sc[j]=zt+wlex*zl+wsem*zs+wrare*zr + order=np.argsort(sc)[::-1] + h10=0; h100=0; rrmetric=0.; dc=0. + for rnk in range(min(100,n)): + d=int(docs[qi,order[rnk]]); hit=False + for k in range(int(nr[qi])): + if d==int(rel[qi,k]): hit=True; break + if hit: + h100+=1 + if rnk<10: + h10+=1; dc += 1.0/math.log2(rnk+2.0) + if rrmetric==0.: rrmetric=1.0/(rnk+1.0) + ideal=0. + for rnk in range(min(10,int(nr[qi]))): ideal += 1.0/math.log2(rnk+2.0) + ndcg=dc/ideal if ideal>0 else 0. + sums[f,0]+=ndcg; sums[f,1]+=rrmetric; sums[f,2]+=h10/10.; sums[f,3]+=h10/nrel; sums[f,4]+=h100/nrel; sums[f,5]+=1.0 if h10>0 else 0.; sums[f,6]+=1.0 if h100>0 else 0.; sums[f,7]+=1. + return sums + +def metrics(s): + out=[] + for f in range(5): + n=s[f,7]; out.append({'fold':f,'nDCG@10':float(s[f,0]/n),'MRR@10':float(s[f,1]/n),'P@10':float(s[f,2]/n),'R@10':float(s[f,3]/n),'R@100':float(s[f,4]/n),'Hit@10':float(s[f,5]/n),'Hit@100':float(s[f,6]/n)}) + return out + +def run_grid(name,params,baseline_key=None): + rows=[]; start=time.time() + for z,p in enumerate(params): + s=eval_params(docs,tail,lex2,sem,cnt,rm,nvalid,qlen,dl,avgdl,rel,nr,fold_id,*p['args']); fm=metrics(s); nd=np.array([x['nDCG@10'] for x in fm]); mr=np.array([x['MRR@10'] for x in fm]); r100=np.array([x['R@100'] for x in fm]); row={**p['meta'],'fold_metrics':fm,'mean_nDCG@10':float(nd.mean()),'mean_MRR@10':float(mr.mean()),'mean_R@100':float(r100.mean())}; rows.append(row); print(name,z+1,'/',len(params),p['meta'],'mean',row['mean_nDCG@10'],flush=True) + # deltas vs designated current baseline + if baseline_key is not None: + base=next(r for r in rows if all(r.get(k)==v for k,v in baseline_key.items())); bnd=np.array([x['nDCG@10'] for x in base['fold_metrics']]) + for r in rows: + d=np.array([x['nDCG@10'] for x in r['fold_metrics']])-bnd; r['mean_delta_vs_baseline']=float(d.mean()); r['min_delta_vs_baseline']=float(d.min()); r['positive_folds_vs_baseline']=int((d>0).sum()); r['fold_deltas_vs_baseline']=d.tolist() + path=WORK/f'finish_{name}.json'; json.dump({'name':name,'rows':rows,'seconds':time.time()-start},open(path,'w'),indent=2); print('SAVED',path,flush=True) + return rows + +# JIT +_=eval_params(docs[:1],tail[:1],lex2[:1],sem[:1],cnt[:1],rm[:1],nvalid[:1],qlen[:1],dl,avgdl,rel[:1],nr[:1],fold_id[:1],.1,.25,4.,.3,3,1.) +# A: length/coordination robustness, current rest fixed. +A=[] +for bb in [0.0,0.05,0.1,0.15,0.2]: + for aa in [0.0,0.125,0.25,0.375,0.5]: A.append({'args':(bb,aa,4.,.3,3,1.),'meta':{'b':bb,'alpha':aa}}) +ra=run_grid('length_coord_multifold',A,{'b':0.1,'alpha':0.25}) +# choose by all-fold robustness first; otherwise max mean. +cand=[r for r in ra if r.get('positive_folds_vs_baseline',0)==5 and r.get('min_delta_vs_baseline',-1)>0] +if cand: besta=max(cand,key=lambda r:(r['mean_nDCG@10'],r['min_delta_vs_baseline'])) +else: besta=max(ra,key=lambda r:r['mean_nDCG@10']) +bb=float(besta['b']); aa=float(besta['alpha']); print('SELECT_A',bb,aa,besta['mean_nDCG@10'],flush=True) +# B: final weights around current. +B=[] +for wl in [3.,4.,5.,6.]: + for ws in [0.,0.1,0.2,0.3,0.4,0.5]: B.append({'args':(bb,aa,wl,ws,3,1.),'meta':{'wlex':wl,'wsem':ws}}) +rb=run_grid('final_weights_multifold',B,{'wlex':4.0,'wsem':0.3}) +cand=[r for r in rb if r.get('positive_folds_vs_baseline',0)==5 and r.get('min_delta_vs_baseline',-1)>0] +if cand: bestb=max(cand,key=lambda r:(r['mean_nDCG@10'],r['min_delta_vs_baseline'])) +else: bestb=max(rb,key=lambda r:r['mean_nDCG@10']) +wl=float(bestb['wlex']); ws=float(bestb['wsem']); print('SELECT_B',wl,ws,bestb['mean_nDCG@10'],flush=True) +# C: rare conjunction depth/weight, include current. +C=[] +for k in [2,3,4,5]: + for wr in [0.5,0.75,1.0,1.25,1.5]: C.append({'args':(bb,aa,wl,ws,k,wr),'meta':{'rarek':k,'wrare':wr}}) +rc=run_grid('rare_final_multifold',C,{'rarek':3,'wrare':1.0}) +cand=[r for r in rc if r.get('positive_folds_vs_baseline',0)==5 and r.get('min_delta_vs_baseline',-1)>0] +if cand: bestc=max(cand,key=lambda r:(r['mean_nDCG@10'],r['min_delta_vs_baseline'])) +else: bestc=max(rc,key=lambda r:r['mean_nDCG@10']) +k=int(bestc['rarek']); wr=float(bestc['wrare']); print('SELECT_C',k,wr,bestc['mean_nDCG@10'],flush=True) +final={'protocol':'finish remaining TRAIN-only development on five fixed disjoint 1000-query folds; no DEV/test selection','selected':{'final_length_b':bb,'coordination_alpha':aa,'lambda_lex':wl,'lambda_sem':ws,'rare_topk':k,'rare_weight':wr,'final_idf_power':2.0,'preselection_eta':1.0,'preselection_idf_power':1.0,'P':2000,'gamma_tail':0.25,'lambda_M':0.125,'h':0,'S':16},'stageA_selected':besta,'stageB_selected':bestb,'stageC_selected':bestc} +json.dump(final,open(WORK/'finish_train_selected.json','w'),indent=2); print('FINAL_SELECTED',json.dumps(final['selected'],indent=2),flush=True) diff --git a/experiments/msmarco_scale/msmarco_full_search.py b/experiments/msmarco_scale/msmarco_full_search.py new file mode 100644 index 0000000000000000000000000000000000000000..4d7ad1635d76780d2c92ae688c60bed07cf1bdd2 --- /dev/null +++ b/experiments/msmarco_scale/msmarco_full_search.py @@ -0,0 +1,162 @@ +from __future__ import annotations +import gzip,json,pickle,time,math,random +from pathlib import Path +import numpy as np +import pandas as pd +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' +N=8_841_823; M=50_000; F=4; S=16; SENT=np.uint16(65535) +ROUTE_ALPHA=.10; ROUTE_BUDGET=32; GAMMA_HEAD=.5; GAMMA_TAIL=1.; LAMBDA_M=2.; P=2000; LAMBDA_LEX=2.5; LENGTH_B=.2; SEMK=16; LAMBDA_SEM=.05 +HGRID=list(range(0,11))+[15,20] +set_num_threads(5) + +@njit(cache=False) +def lookup_center(ct,cv,t): + lo=0; hi=ct.size + while lo=t: hi=mid + else: lo=mid+1 + if lo=t: hi=mid + else: lo=mid+1 + if lo>r)&1)!=0 else -1.0 + local += rel*(qv-cen)*sgn; sig += qv*qv + rho=route_dense[j]; m=mem[z] + hc[z]=m*rho*local*(sig**0.5 if sig>0 else 0.0) + tc[z]=m*rho*local*sig + cc[z]=m*rho + return hc,tc,cc + +def zscore(x): + x=np.asarray(x,np.float32); s=float(x.std()); return np.zeros_like(x) if s<1e-8 else (x-float(x.mean()))/(s+1e-8) + +def dcg(vals): + return sum((2.0**float(r)-1.0)/math.log2(i+2) for i,r in enumerate(vals)) + +def eval_run(run,qrels): + metrics={'nDCG@10':[],'MRR@10':[],'P@10':[],'R@10':[],'R@100':[],'Hit@10':[],'Hit@100':[]} + for qid,qr in qrels.items(): + rank=run[qid]; pos={int(d) for d,r in qr.items() if r>0}; n=max(1,len(pos)) + h10=sum(d in pos for d in rank[:10]); h100=sum(d in pos for d in rank[:100]); metrics['P@10'].append(h10/10); metrics['R@10'].append(h10/n); metrics['R@100'].append(h100/n); metrics['Hit@10'].append(float(h10>0)); metrics['Hit@100'].append(float(h100>0)) + rr=0 + for i,d in enumerate(rank[:10],1): + if d in pos: rr=1/i; break + metrics['MRR@10'].append(rr) + obs=[float(qr.get(str(d),qr.get(d,0.0))) for d in rank[:10]]; ideal=sorted([float(r) for r in qr.values()],reverse=True)[:10]; idc=dcg(ideal); metrics['nDCG@10'].append(dcg(obs)/idc if idc else 0) + return {k:float(np.mean(v)) for k,v in metrics.items()} | {'n_queries':len(qrels)} + +class FullIndex: + def __init__(self): + with gzip.open(WORK/'final_vocab_50k.pkl.gz','rb') as g: z=pickle.load(g) + self.terms=z['terms'].tolist(); self.idf=np.asarray(z['idf'],np.float32); self.vocab={t:i for i,t in enumerate(self.terms)} + self.cvq=CountVectorizer(vocabulary=self.vocab,lowercase=True,token_pattern=r'(?u)\b\w\w+\b',dtype=np.int32) + self.ct=np.load(GEOM/'center_terms.npy',mmap_mode='r'); self.cv=np.load(GEOM/'center_values.npy',mmap_mode='r'); self.A=sparse.load_npz(GEOM/'assoc_ppmi.npz').tocsr(); self.G=sparse.load_npz(GEOM/'context_similarity.npz').tocsr(); self.rp=np.load(GEOM/'rel_indptr.npy',mmap_mode='r'); _rm=json.load(open(GEOM/'rel_meta.json')); _rn=int(_rm['nnz']); self.ri=np.memmap(GEOM/'rel_indices.u16',np.uint16,'r',shape=(_rn,)); self.rv=np.memmap(GEOM/'rel_data.f32',np.float32,'r',shape=(_rn,)) + self.branches=np.memmap(IDX/'branches.u16',np.uint16,'r',shape=(N,F)); self.mem=np.memmap(IDX/'memberships.f32',np.float32,'r',shape=(N,F)); self.rt=np.memmap(IDX/'res_terms.u16',np.uint16,'r',shape=(N,F,S)); self.sb=np.memmap(IDX/'signbits.u16',np.uint16,'r',shape=(N,F)); self.dl=np.memmap(IDX/'doc_lengths.u16',np.uint16,'r',shape=(N,)); self.bo=np.memmap(IDX/'branch_order.u32',np.uint32,'r'); self.offs=np.load(IDX/'branch_offsets.npy',mmap_mode='r') + with open(IDX/'meta.json') as f: self.meta=json.load(f) + self.avgdl=float(self.meta['avg_doc_length']); self.sup=[] + for sid in range(36): + with open(IDX/f'shard_{sid:04d}.json') as f: sm=json.load(f) + ii=np.memmap(IDX/f'support_{sid:04d}.u16',np.uint16,'r',shape=(sm['nnz'],)); ip=np.memmap(IDX/f'support_indptr_{sid:04d}.u32',np.uint32,'r',shape=(sm['n']+1,)); self.sup.append((sm['offset'],sm['n'],ip,ii)) + def query_vec(self,text): + q=self.cvq.transform([text]).tocsr().astype(np.float32); q.data*=self.idf[q.indices]; normalize(q,norm='l2',axis=1,copy=False); return q + def route(self,q): + qt=q.indices; qv=q.data; dense=np.zeros(M,np.float32); dense[qt]=qv + for t,v in zip(qt,qv): + a,b=self.G.indptr[t],self.G.indptr[t+1]; dense[self.G.indices[a:b]] += ROUTE_ALPHA*float(v)*self.G.data[a:b] + nz=np.flatnonzero(dense>0); orig=set(map(int,qt.tolist())) + if len(nz)>ROUTE_BUDGET: + inf=np.asarray([i for i in nz if int(i) not in orig],np.int32); budget=max(0,ROUTE_BUDGET-len(orig)) + if budget and len(inf)>budget: inf=inf[np.argpartition(dense[inf],-budget)[-budget:]] + elif budget==0: inf=np.empty(0,np.int32) + nz=np.concatenate([np.asarray(sorted(orig),np.int32),inf]) + nz=nz[np.argsort(dense[nz])[::-1]]; return nz.astype(np.int32),dense + def support(self,d): + sid=min(35,int(d)//250_000); off,n,ip,ii=self.sup[sid]; ld=int(d)-off; a=int(ip[ld]); b=int(ip[ld+1]); return ii[a:b] + def prepare(self,text,hmax=20): + q=self.query_vec(text); qd=np.zeros(M,np.float32); qd[q.indices]=q.data; rterms,rd=self.route(q) + pieces=[self.bo[int(self.offs[j]):int(self.offs[j+1])] for j in rterms if self.offs[j+1]>self.offs[j]] + if not pieces: return None + fp=np.concatenate(pieces).astype(np.uint32,copy=False); docs=(fp//F).astype(np.uint32); slots=(fp%F).astype(np.uint8); br=self.branches[docs,slots]; mm=self.mem[docs,slots]; rt=self.rt[docs,slots]; sb=self.sb[docs,slots] + hc,tc,cc=score_memberships(br,mm,rt,sb,qd,rd,self.ct,self.cv,self.rp,self.ri,self.rv) + ud,inv=np.unique(docs,return_inverse=True); head=np.bincount(inv,weights=hc,minlength=len(ud)).astype(np.float32); tail=np.bincount(inv,weights=tc,minlength=len(ud)).astype(np.float32)+LAMBDA_M*np.bincount(inv,weights=cc,minlength=len(ud)).astype(np.float32) + ho=np.argsort(head)[::-1]; cheap=np.argsort(tail)[::-1]; want=min(len(cheap),P+hmax+8); cand_idx=cheap[:want]; cand_docs=ud[cand_idx]; cand_tail=tail[cand_idx] + lexvec=np.zeros(M,np.float32); lexvec[q.indices]=self.idf[q.indices]; semvec=np.zeros(M,np.float32) + for t,amp in zip(q.indices,q.data): + a,b=self.A.indptr[t],self.A.indptr[t+1]; nb=self.A.indices[a:b][:SEMK]; sv=self.A.data[a:b][:SEMK]; semvec[nb]+=float(amp)*sv*self.idf[nb] + lex=np.zeros(want,np.float32); sem=np.zeros(want,np.float32) + for i,d in enumerate(cand_docs): + sp=self.support(int(d)); lex[i]=float(lexvec[sp].sum()); denom=(1-LENGTH_B)+LENGTH_B*(float(self.dl[int(d)])/self.avgdl); lex[i]/=denom if denom>0 else 1.; sem[i]=float(semvec[sp].sum()) + return {'ud':ud,'head':head,'head_order':ho,'tail':tail,'cheap_order':cheap,'cand_docs':cand_docs,'cand_tail':cand_tail,'lex':lex,'sem':sem,'candidate_memberships':len(fp),'candidate_docs':len(ud)} + def rank_h(self,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())) + # Candidate rerank arrays were computed for top P+hmax; exclude frozen and take P. + 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=zscore(ts)+LAMBDA_LEX*zscore(lx)+LAMBDA_SEM*zscore(sm); oo=np.argsort(final)[::-1]; taildocs=docs[oo] + ranked=np.concatenate([frozen,taildocs])[:k]; return [int(x) for x in ranked] + +def load_query_texts(want): + want=set(map(str,want)); out={} + with open(ROOT/'queries.jsonl','r',encoding='utf-8') as f: + for line in f: + o=json.loads(line); qid=str(o['_id']) + if qid in want: out[qid]=o.get('text','') or '' + return out + +def qrels_from_tsv(path,qids=None,positive_only=False): + df=pd.read_csv(path,sep='\t'); qset=None if qids is None else set(map(str,qids)); out={} + for q,d,s in zip(df['query-id'],df['corpus-id'],df['score']): + q=str(q) + if qset is not None and q not in qset: continue + if positive_only and float(s)<=0: continue + out.setdefault(q,{})[str(d)]=float(s) + return out + +if __name__=='__main__': + idx=FullIndex(); print('loaded full index',idx.meta,flush=True) + # validation: deterministic 1000 train queries, selected without touching dev qrels + 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); val_ids=[str(x) for x in rng.choice(uq,size=1000,replace=False)]; del tr + devdf=pd.read_csv(ROOT/'dev.tsv',sep='\t',usecols=['query-id']); dev_ids=[str(x) for x in np.unique(devdf['query-id'].to_numpy())]; del devdf + texts=load_query_texts(val_ids+dev_ids); valq=qrels_from_tsv(ROOT/'train.tsv',val_ids,positive_only=True); devq=qrels_from_tsv(ROOT/'dev.tsv',dev_ids,positive_only=True) + # Prepare validation queries once, sweep h without repeating retrieval. + pre={}; times=[]; cands=[] + for z,qid in enumerate(val_ids): + t=time.perf_counter(); pre[qid]=idx.prepare(texts[qid],hmax=max(HGRID)); times.append((time.perf_counter()-t)*1000); p=pre[qid]; cands.append(p['candidate_docs'] if p else 0) + if (z+1)%100==0: print('val prepared',z+1,'median ms',float(np.median(times)),'avg candidates',float(np.mean(cands)),flush=True) + rows=[] + for h in HGRID: + run={qid:idx.rank_h(pre[qid],h,100) for qid in val_ids}; m=eval_run(run,valq); rows.append((h,m)); print('H',h,m,flush=True) + best=max(rows,key=lambda x:(x[1]['nDCG@10'],x[1]['MRR@10'],x[1]['R@100']))[0]; print('BEST_H',best,flush=True) + # Release validation intermediates before full dev. + del pre + run={}; times=[]; cands=[] + for z,qid in enumerate(dev_ids): + t=time.perf_counter(); p=idx.prepare(texts[qid],hmax=best); run[qid]=idx.rank_h(p,best,100); times.append((time.perf_counter()-t)*1000); cands.append(p['candidate_docs'] if p else 0) + if (z+1)%250==0: print('dev',z+1,'median',float(np.median(times)),'p95',float(np.percentile(times,95)),'avgcand',float(np.mean(cands)),flush=True) + m=eval_run(run,devq); 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))} + out={'best_h':best,'validation':{str(h):mm for h,mm in rows},'dev_metrics':m,'timing':timing,'index_meta':idx.meta} + with open(WORK/'full_msmarco_results.json','w') as f: json.dump(out,f,indent=2) + print('DEV_METRICS',m,flush=True); print('TIMING',timing,flush=True); print('saved',WORK/'full_msmarco_results.json',flush=True) diff --git a/experiments/msmarco_scale/msmarco_full_search_fast.py b/experiments/msmarco_scale/msmarco_full_search_fast.py new file mode 100644 index 0000000000000000000000000000000000000000..6441e6904b53118b5190d322d5bc4a3357e5ab14 --- /dev/null +++ b/experiments/msmarco_scale/msmarco_full_search_fast.py @@ -0,0 +1,230 @@ +from __future__ import annotations +import gzip,json,pickle,time,math,random +from pathlib import Path +import numpy as np +import pandas as pd +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' +N=8_841_823; M=50_000; F=4; S=16; SENT=np.uint16(65535) +ROUTE_ALPHA=.10; ROUTE_BUDGET=32; GAMMA_HEAD=.5; GAMMA_TAIL=1.; LAMBDA_M=2.; P=2000; LAMBDA_LEX=2.5; LENGTH_B=.2; SEMK=16; LAMBDA_SEM=.05 +HGRID=list(range(0,11))+[15,20] +set_num_threads(5) + +@njit(cache=False) +def lookup_center(ct,cv,t): + lo=0; hi=ct.size + while lo=t: hi=mid + else: lo=mid+1 + if lo=t: hi=mid + else: lo=mid+1 + if lo>r)&1)!=0 else -1.0 + local += rel*(qv-cen)*sgn; sig += qv*qv + rho=route_dense[j]; m=mem[z] + hc[z]=m*rho*local*(sig**0.5 if sig>0 else 0.0) + tc[z]=m*rho*local*sig + cc[z]=m*rho + return hc,tc,cc + +@njit(parallel=True,cache=False) +def score_memberships_local(rslot,mem,rt,sbits,q_dense,rho,cent_local,rel_local): + K=len(rslot); hc=np.zeros(K,np.float32); tc=np.zeros(K,np.float32); cc=np.zeros(K,np.float32) + for z in prange(K): + u=int(rslot[z]); local=0.0; sig=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; sig += qv*qv + rh=rho[u]; m=mem[z] + hc[z]=m*rh*local*(sig**0.5 if sig>0 else 0.0) + tc[z]=m*rh*local*sig + cc[z]=m*rh + return hc,tc,cc + +@njit(parallel=True,cache=False) +def score_support_pool(cand_docs,ip,ids,lexvec,semvec,dl,avgdl): + n=len(cand_docs); lex=np.zeros(n,np.float32); sem=np.zeros(n,np.float32) + for z in prange(n): + d=int(cand_docs[z]); a=int(ip[d]); b=int(ip[d+1]); lx=0.0; sm=0.0 + for k in range(a,b): + t=int(ids[k]); lx+=lexvec[t]; sm+=semvec[t] + denom=(1.0-LENGTH_B)+LENGTH_B*(float(dl[d])/avgdl) + lex[z]=lx/(denom if denom>0 else 1.0); sem[z]=sm + return lex,sem + +@njit(cache=False) +def aggregate_by_doc(docs,hc,tc,cc,mark,head_acc,tail_acc,gen): + # Dense generation-mark accumulator avoids sorting every membership record. + # The returned document IDs are sorted afterwards to preserve deterministic + # tie behaviour of the original np.unique path. + seen=np.empty(len(docs),np.uint32); nseen=0 + for z in range(len(docs)): + d=int(docs[z]) + if mark[d]!=gen: + mark[d]=gen; head_acc[d]=0.0; tail_acc[d]=0.0; seen[nseen]=d; nseen+=1 + head_acc[d]+=float(hc[z]) + tail_acc[d]+=float(tc[z])+LAMBDA_M*float(cc[z]) + return seen[:nseen] + +def zscore(x): + x=np.asarray(x,np.float32); s=float(x.std()); return np.zeros_like(x) if s<1e-8 else (x-float(x.mean()))/(s+1e-8) + +def dcg(vals): + return sum((2.0**float(r)-1.0)/math.log2(i+2) for i,r in enumerate(vals)) + +def eval_run(run,qrels): + metrics={'nDCG@10':[],'MRR@10':[],'P@10':[],'R@10':[],'R@100':[],'Hit@10':[],'Hit@100':[]} + for qid,qr in qrels.items(): + rank=run[qid]; pos={int(d) for d,r in qr.items() if r>0}; n=max(1,len(pos)) + h10=sum(d in pos for d in rank[:10]); h100=sum(d in pos for d in rank[:100]); metrics['P@10'].append(h10/10); metrics['R@10'].append(h10/n); metrics['R@100'].append(h100/n); metrics['Hit@10'].append(float(h10>0)); metrics['Hit@100'].append(float(h100>0)) + rr=0 + for i,d in enumerate(rank[:10],1): + if d in pos: rr=1/i; break + metrics['MRR@10'].append(rr) + obs=[float(qr.get(str(d),qr.get(d,0.0))) for d in rank[:10]]; ideal=sorted([float(r) for r in qr.values()],reverse=True)[:10]; idc=dcg(ideal); metrics['nDCG@10'].append(dcg(obs)/idc if idc else 0) + return {k:float(np.mean(v)) for k,v in metrics.items()} | {'n_queries':len(qrels)} + +class FullIndex: + def __init__(self): + with gzip.open(WORK/'final_vocab_50k.pkl.gz','rb') as g: z=pickle.load(g) + self.terms=z['terms'].tolist(); self.idf=np.asarray(z['idf'],np.float32); self.vocab={t:i for i,t in enumerate(self.terms)} + self.cvq=CountVectorizer(vocabulary=self.vocab,lowercase=True,token_pattern=r'(?u)\b\w\w+\b',dtype=np.int32) + self.ct=np.load(GEOM/'center_terms.npy',mmap_mode='r'); self.cv=np.load(GEOM/'center_values.npy',mmap_mode='r'); self.A=sparse.load_npz(GEOM/'assoc_ppmi.npz').tocsr(); self.G=sparse.load_npz(GEOM/'context_similarity.npz').tocsr(); self.rp=np.load(GEOM/'rel_indptr.npy',mmap_mode='r'); _rm=json.load(open(GEOM/'rel_meta.json')); _rn=int(_rm['nnz']); self.ri=np.memmap(GEOM/'rel_indices.u16',np.uint16,'r',shape=(_rn,)); self.rv=np.memmap(GEOM/'rel_data.f32',np.float32,'r',shape=(_rn,)) + self.dl=np.memmap(IDX/'doc_lengths.u16',np.uint16,'r',shape=(N,)); self.offs=np.load(IDX/'branch_offsets.npy',mmap_mode='r'); _np=int(self.offs[-1]); self.pd=np.memmap(IDX/'post_doc.u32',np.uint32,'r',shape=(_np,)); self.pm=np.memmap(IDX/'post_membership.f32',np.float32,'r',shape=(_np,)); self.pr=np.memmap(IDX/'post_res_terms.u16',np.uint16,'r',shape=(_np,S)); self.ps=np.memmap(IDX/'post_signbits.u16',np.uint16,'r',shape=(_np,)) + with open(IDX/'meta.json') as f: self.meta=json.load(f) + self.avgdl=float(self.meta['avg_doc_length']); self.sup_ip=np.memmap(IDX/'support_all_indptr.u32',np.uint32,'r',shape=(N+1,)); self.sup_ids=np.memmap(IDX/'support_all.u16',np.uint16,'r',shape=(329617090,)) + def query_vec(self,text): + q=self.cvq.transform([text]).tocsr().astype(np.float32); q.data*=self.idf[q.indices]; normalize(q,norm='l2',axis=1,copy=False); return q + def route(self,q): + qt=q.indices; qv=q.data; dense=np.zeros(M,np.float32); dense[qt]=qv + for t,v in zip(qt,qv): + a,b=self.G.indptr[t],self.G.indptr[t+1]; dense[self.G.indices[a:b]] += ROUTE_ALPHA*float(v)*self.G.data[a:b] + nz=np.flatnonzero(dense>0); orig=set(map(int,qt.tolist())) + if len(nz)>ROUTE_BUDGET: + inf=np.asarray([i for i in nz if int(i) not in orig],np.int32); budget=max(0,ROUTE_BUDGET-len(orig)) + if budget and len(inf)>budget: inf=inf[np.argpartition(dense[inf],-budget)[-budget:]] + elif budget==0: inf=np.empty(0,np.int32) + nz=np.concatenate([np.asarray(sorted(orig),np.int32),inf]) + nz=nz[np.argsort(dense[nz])[::-1]]; return nz.astype(np.int32),dense + def support(self,d): + a=int(self.sup_ip[int(d)]); b=int(self.sup_ip[int(d)+1]); return self.sup_ids[a:b] + def prepare(self,text,hmax=20): + q=self.query_vec(text); qd=np.zeros(M,np.float32); qd[q.indices]=q.data; rterms,rd=self.route(q) + spans=[(int(j),int(self.offs[j]),int(self.offs[j+1])) for j in rterms if self.offs[j+1]>self.offs[j]] + if not spans: return None + docs=np.concatenate([np.asarray(self.pd[a:b]) for j,a,b in spans]).astype(np.uint32,copy=False) + mm=np.concatenate([np.asarray(self.pm[a:b]) for j,a,b in spans]).astype(np.float32,copy=False) + rt=np.concatenate([np.asarray(self.pr[a:b]) for j,a,b in spans]).astype(np.uint16,copy=False) + sb=np.concatenate([np.asarray(self.ps[a:b]) for j,a,b in spans]).astype(np.uint16,copy=False) + # Query-local dense lookup tables: only <=32 routed branches are materialized. + # This replaces millions of tiny binary searches into center/reliability CSR rows. + nr=len(spans); cent_local=np.zeros((nr,M),np.float32); rel_local=np.zeros((nr,M),np.float32); rho=np.empty(nr,np.float32) + for u,(j,a,b) in enumerate(spans): + rowt=np.asarray(self.ct[j]); ok=rowt!=65535; ids=rowt[ok].astype(np.int32,copy=False); cent_local[u,ids]=np.asarray(self.cv[j])[ok] + ra=int(self.rp[j]); rb=int(self.rp[j+1]); rel_local[u,np.asarray(self.ri[ra:rb],np.int32)]=np.asarray(self.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)]) + hc,tc,cc=score_memberships_local(rslot,mm,rt,sb,qd,rho,cent_local,rel_local) + ud,inv=np.unique(docs,return_inverse=True) + head=np.bincount(inv,weights=hc,minlength=len(ud)).astype(np.float32) + tail=np.bincount(inv,weights=tc,minlength=len(ud)).astype(np.float32)+LAMBDA_M*np.bincount(inv,weights=cc,minlength=len(ud)).astype(np.float32) + # Only the top hmax head documents and top P+hmax tail documents are ever used. + # Partial selection avoids O(C log C) full sorts when C is 10^5--10^6. + hwant=min(len(head),max(1,hmax)) + if len(head)>hwant: + hi=np.argpartition(head,-hwant)[-hwant:]; ho=hi[np.argsort(head[hi])[::-1]] + else: ho=np.argsort(head)[::-1] + want=min(len(tail),P+hmax+8) + if len(tail)>want: + ci=np.argpartition(tail,-want)[-want:]; cheap=ci[np.argsort(tail[ci])[::-1]] + else: cheap=np.argsort(tail)[::-1] + cand_idx=cheap[:want]; cand_docs=ud[cand_idx]; cand_tail=tail[cand_idx] + lexvec=np.zeros(M,np.float32); lexvec[q.indices]=self.idf[q.indices]; semvec=np.zeros(M,np.float32) + for t,amp in zip(q.indices,q.data): + a,b=self.A.indptr[t],self.A.indptr[t+1]; nb=self.A.indices[a:b][:SEMK]; sv=self.A.data[a:b][:SEMK]; semvec[nb]+=float(amp)*sv*self.idf[nb] + lex,sem=score_support_pool(cand_docs,self.sup_ip,self.sup_ids,lexvec,semvec,self.dl,self.avgdl) + return {'ud':ud,'head_order':ho,'cand_docs':cand_docs,'cand_tail':cand_tail,'lex':lex,'sem':sem,'candidate_memberships':len(docs),'candidate_docs':len(ud)} + def rank_h(self,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())) + # Candidate rerank arrays were computed for top P+hmax; exclude frozen and take P. + 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=zscore(ts)+LAMBDA_LEX*zscore(lx)+LAMBDA_SEM*zscore(sm); oo=np.argsort(final)[::-1]; taildocs=docs[oo] + ranked=np.concatenate([frozen,taildocs])[:k]; return [int(x) for x in ranked] + +def load_query_texts(want): + want=set(map(str,want)); out={} + with open(ROOT/'queries.jsonl','r',encoding='utf-8') as f: + for line in f: + o=json.loads(line); qid=str(o['_id']) + if qid in want: out[qid]=o.get('text','') or '' + return out + +def qrels_from_tsv(path,qids=None,positive_only=False): + df=pd.read_csv(path,sep='\t'); qset=None if qids is None else set(map(str,qids)); out={} + for q,d,s in zip(df['query-id'],df['corpus-id'],df['score']): + q=str(q) + if qset is not None and q not in qset: continue + if positive_only and float(s)<=0: continue + out.setdefault(q,{})[str(d)]=float(s) + return out + +if __name__=='__main__': + idx=FullIndex(); print('loaded full index',idx.meta,flush=True) + # Validation protocol: tune h on a deterministic 1000-query sample from TRAIN, + # then lock h and evaluate the entire 6,980-query DEV split untouched. + 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); val_ids=[str(x) for x in rng.choice(uq,size=1000,replace=False)]; del tr + devdf=pd.read_csv(ROOT/'dev.tsv',sep='\t',usecols=['query-id']); dev_ids=[str(x) for x in np.unique(devdf['query-id'].to_numpy())]; del devdf + texts=load_query_texts(val_ids+dev_ids); valq=qrels_from_tsv(ROOT/'train.tsv',val_ids,positive_only=True); devq=qrels_from_tsv(ROOT/'dev.tsv',dev_ids,positive_only=True) + missing=[q for q in val_ids+dev_ids if q not in texts] + if missing: raise RuntimeError(f'missing query texts: {missing[:10]} ({len(missing)} total)') + # JIT and I/O warmup; excluded from timing. + _w=idx.prepare(texts[val_ids[0]],hmax=max(HGRID)); _=idx.rank_h(_w,0,100); del _w + # Prepare each validation query ONCE, immediately materialize all h rankings, + # and discard the large candidate arrays. This keeps RAM bounded at scale. + vruns={h:{} for h in HGRID}; times=[]; cands=[]; memc=[] + for z,qid in enumerate(val_ids): + t=time.perf_counter(); pp=idx.prepare(texts[qid],hmax=max(HGRID)); times.append((time.perf_counter()-t)*1000) + cands.append(pp['candidate_docs'] if pp else 0); memc.append(pp['candidate_memberships'] if pp else 0) + for h in HGRID: vruns[h][qid]=idx.rank_h(pp,h,100) + if (z+1)%100==0: print('val',z+1,'median_ms',float(np.median(times)),'p95_ms',float(np.percentile(times,95)),'avg_candidate_docs',float(np.mean(cands)),flush=True) + rows=[] + for h in HGRID: + mm=eval_run(vruns[h],valq); rows.append((h,mm)); print('H',h,mm,flush=True) + best=max(rows,key=lambda x:(x[1]['nDCG@10'],x[1]['MRR@10'],x[1]['R@100']))[0]; print('BEST_H',best,flush=True) + val_timing={'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)),'avg_candidate_memberships':float(np.mean(memc))} + del vruns + # Full untouched DEV evaluation with h locked. + run={}; times=[]; cands=[]; memc=[] + for z,qid in enumerate(dev_ids): + t=time.perf_counter(); pp=idx.prepare(texts[qid],hmax=max(best,1)); run[qid]=idx.rank_h(pp,best,100); times.append((time.perf_counter()-t)*1000); cands.append(pp['candidate_docs'] if pp else 0); memc.append(pp['candidate_memberships'] if pp else 0) + if (z+1)%250==0: print('dev',z+1,'median_ms',float(np.median(times)),'p95_ms',float(np.percentile(times,95)),'avg_candidate_docs',float(np.mean(cands)),flush=True) + mm=eval_run(run,devq); 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(memc))} + out={'protocol':'h tuned on deterministic 1000-query TRAIN sample; full DEV untouched','best_h':best,'validation':{str(h):vv for h,vv in rows},'validation_timing':val_timing,'dev_metrics':mm,'timing':timing,'index_meta':idx.meta,'geometry_note':'full 8.84M vocabulary/IDF; geometric codebook calibrated on first 1M passages'} + with open(WORK/'full_msmarco_results.json','w') as f: json.dump(out,f,indent=2) + print('DEV_METRICS',mm,flush=True); print('TIMING',timing,flush=True); print('saved',WORK/'full_msmarco_results.json',flush=True) diff --git a/experiments/msmarco_scale/msmarco_full_search_fastp.py b/experiments/msmarco_scale/msmarco_full_search_fastp.py new file mode 100644 index 0000000000000000000000000000000000000000..35683c4b1d63c06a25cfc64e567bcefe1b123bde --- /dev/null +++ b/experiments/msmarco_scale/msmarco_full_search_fastp.py @@ -0,0 +1,198 @@ +from __future__ import annotations +import gzip,json,pickle,time,math,random +from pathlib import Path +import numpy as np +import pandas as pd +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' +N=8_841_823; M=50_000; F=4; S=16; SENT=np.uint16(65535) +ROUTE_ALPHA=.10; ROUTE_BUDGET=32; GAMMA_HEAD=.5; GAMMA_TAIL=1.; LAMBDA_M=2.; P=2000; LAMBDA_LEX=2.5; LENGTH_B=.2; SEMK=16; LAMBDA_SEM=.05 +HGRID=list(range(0,11))+[15,20] +set_num_threads(5) + +@njit(cache=False) +def lookup_center(ct,cv,t): + lo=0; hi=ct.size + while lo=t: hi=mid + else: lo=mid+1 + if lo=t: hi=mid + else: lo=mid+1 + if lo>r)&1)!=0 else -1.0 + local += rel*(qv-cen)*sgn; sig += qv*qv + rho=route_dense[j]; m=mem[z] + hc[z]=m*rho*local*(sig**0.5 if sig>0 else 0.0) + tc[z]=m*rho*local*sig + cc[z]=m*rho + return hc,tc,cc + +@njit(parallel=True,cache=False) +def score_memberships_local(rslot,mem,rt,sbits,q_dense,rho,cent_local,rel_local): + K=len(rslot); hc=np.zeros(K,np.float32); tc=np.zeros(K,np.float32); cc=np.zeros(K,np.float32) + for z in prange(K): + u=int(rslot[z]); local=0.0; sig=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; sig += qv*qv + rh=rho[u]; m=mem[z] + hc[z]=m*rh*local*(sig**0.5 if sig>0 else 0.0) + tc[z]=m*rh*local*sig + cc[z]=m*rh + return hc,tc,cc + +@njit(parallel=True,cache=False) +def score_support_pool(cand_docs,ip,ids,lexvec,semvec,dl,avgdl): + n=len(cand_docs); lex=np.zeros(n,np.float32); sem=np.zeros(n,np.float32) + for z in prange(n): + d=int(cand_docs[z]); a=int(ip[d]); b=int(ip[d+1]); lx=0.0; sm=0.0 + for k in range(a,b): + t=int(ids[k]); lx+=lexvec[t]; sm+=semvec[t] + denom=(1.0-LENGTH_B)+LENGTH_B*(float(dl[d])/avgdl) + lex[z]=lx/(denom if denom>0 else 1.0); sem[z]=sm + return lex,sem + +@njit(cache=False) +def aggregate_by_doc(docs,hc,tc,cc,mark,head_acc,tail_acc,gen): + # Dense generation-mark accumulator avoids sorting every membership record. + # The returned document IDs are sorted afterwards to preserve deterministic + # tie behaviour of the original np.unique path. + seen=np.empty(len(docs),np.uint32); nseen=0 + for z in range(len(docs)): + d=int(docs[z]) + if mark[d]!=gen: + mark[d]=gen; head_acc[d]=0.0; tail_acc[d]=0.0; seen[nseen]=d; nseen+=1 + head_acc[d]+=float(hc[z]) + tail_acc[d]+=float(tc[z])+LAMBDA_M*float(cc[z]) + return seen[:nseen] + +def zscore(x): + x=np.asarray(x,np.float32); s=float(x.std()); return np.zeros_like(x) if s<1e-8 else (x-float(x.mean()))/(s+1e-8) + +def dcg(vals): + return sum((2.0**float(r)-1.0)/math.log2(i+2) for i,r in enumerate(vals)) + +def eval_run(run,qrels): + metrics={'nDCG@10':[],'MRR@10':[],'P@10':[],'R@10':[],'R@100':[],'Hit@10':[],'Hit@100':[]} + for qid,qr in qrels.items(): + rank=run[qid]; pos={int(d) for d,r in qr.items() if r>0}; n=max(1,len(pos)) + h10=sum(d in pos for d in rank[:10]); h100=sum(d in pos for d in rank[:100]); metrics['P@10'].append(h10/10); metrics['R@10'].append(h10/n); metrics['R@100'].append(h100/n); metrics['Hit@10'].append(float(h10>0)); metrics['Hit@100'].append(float(h100>0)) + rr=0 + for i,d in enumerate(rank[:10],1): + if d in pos: rr=1/i; break + metrics['MRR@10'].append(rr) + obs=[float(qr.get(str(d),qr.get(d,0.0))) for d in rank[:10]]; ideal=sorted([float(r) for r in qr.values()],reverse=True)[:10]; idc=dcg(ideal); metrics['nDCG@10'].append(dcg(obs)/idc if idc else 0) + return {k:float(np.mean(v)) for k,v in metrics.items()} | {'n_queries':len(qrels)} + +class FullIndex: + def __init__(self): + with gzip.open(WORK/'final_vocab_50k.pkl.gz','rb') as g: z=pickle.load(g) + self.terms=z['terms'].tolist(); self.idf=np.asarray(z['idf'],np.float32); self.vocab={t:i for i,t in enumerate(self.terms)} + self.cvq=CountVectorizer(vocabulary=self.vocab,lowercase=True,token_pattern=r'(?u)\b\w\w+\b',dtype=np.int32) + self.ct=np.load(GEOM/'center_terms.npy',mmap_mode='r'); self.cv=np.load(GEOM/'center_values.npy',mmap_mode='r'); self.A=sparse.load_npz(GEOM/'assoc_ppmi.npz').tocsr(); self.G=sparse.load_npz(GEOM/'context_similarity.npz').tocsr(); self.rp=np.load(GEOM/'rel_indptr.npy',mmap_mode='r'); _rm=json.load(open(GEOM/'rel_meta.json')); _rn=int(_rm['nnz']); self.ri=np.memmap(GEOM/'rel_indices.u16',np.uint16,'r',shape=(_rn,)); self.rv=np.memmap(GEOM/'rel_data.f32',np.float32,'r',shape=(_rn,)) + self.dl=np.memmap(IDX/'doc_lengths.u16',np.uint16,'r',shape=(N,)); self.offs=np.load(IDX/'branch_offsets.npy',mmap_mode='r'); _np=int(self.offs[-1]); self.pd=np.memmap(IDX/'post_doc.u32',np.uint32,'r',shape=(_np,)); self.pm=np.memmap(IDX/'post_membership.f32',np.float32,'r',shape=(_np,)); self.pr=np.memmap(IDX/'post_res_terms.u16',np.uint16,'r',shape=(_np,S)); self.ps=np.memmap(IDX/'post_signbits.u16',np.uint16,'r',shape=(_np,)) + with open(IDX/'meta.json') as f: self.meta=json.load(f) + self.avgdl=float(self.meta['avg_doc_length']); self.sup_ip=np.memmap(IDX/'support_all_indptr.u32',np.uint32,'r',shape=(N+1,)); self.sup_ids=np.memmap(IDX/'support_all.u16',np.uint16,'r',shape=(329617090,)) + def query_vec(self,text): + q=self.cvq.transform([text]).tocsr().astype(np.float32); q.data*=self.idf[q.indices]; normalize(q,norm='l2',axis=1,copy=False); return q + def route(self,q): + qt=q.indices; qv=q.data; dense=np.zeros(M,np.float32); dense[qt]=qv + for t,v in zip(qt,qv): + a,b=self.G.indptr[t],self.G.indptr[t+1]; dense[self.G.indices[a:b]] += ROUTE_ALPHA*float(v)*self.G.data[a:b] + nz=np.flatnonzero(dense>0); orig=set(map(int,qt.tolist())) + if len(nz)>ROUTE_BUDGET: + inf=np.asarray([i for i in nz if int(i) not in orig],np.int32); budget=max(0,ROUTE_BUDGET-len(orig)) + if budget and len(inf)>budget: inf=inf[np.argpartition(dense[inf],-budget)[-budget:]] + elif budget==0: inf=np.empty(0,np.int32) + nz=np.concatenate([np.asarray(sorted(orig),np.int32),inf]) + nz=nz[np.argsort(dense[nz])[::-1]]; return nz.astype(np.int32),dense + def support(self,d): + a=int(self.sup_ip[int(d)]); b=int(self.sup_ip[int(d)+1]); return self.sup_ids[a:b] + def prepare(self,text,hmax=20,pool_max=P): + q=self.query_vec(text); qd=np.zeros(M,np.float32); qd[q.indices]=q.data; rterms,rd=self.route(q) + spans=[(int(j),int(self.offs[j]),int(self.offs[j+1])) for j in rterms if self.offs[j+1]>self.offs[j]] + if not spans: return None + docs=np.concatenate([np.asarray(self.pd[a:b]) for j,a,b in spans]).astype(np.uint32,copy=False) + mm=np.concatenate([np.asarray(self.pm[a:b]) for j,a,b in spans]).astype(np.float32,copy=False) + rt=np.concatenate([np.asarray(self.pr[a:b]) for j,a,b in spans]).astype(np.uint16,copy=False) + sb=np.concatenate([np.asarray(self.ps[a:b]) for j,a,b in spans]).astype(np.uint16,copy=False) + # Query-local dense lookup tables: only <=32 routed branches are materialized. + # This replaces millions of tiny binary searches into center/reliability CSR rows. + nr=len(spans); cent_local=np.zeros((nr,M),np.float32); rel_local=np.zeros((nr,M),np.float32); rho=np.empty(nr,np.float32) + for u,(j,a,b) in enumerate(spans): + rowt=np.asarray(self.ct[j]); ok=rowt!=65535; ids=rowt[ok].astype(np.int32,copy=False); cent_local[u,ids]=np.asarray(self.cv[j])[ok] + ra=int(self.rp[j]); rb=int(self.rp[j+1]); rel_local[u,np.asarray(self.ri[ra:rb],np.int32)]=np.asarray(self.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)]) + hc,tc,cc=score_memberships_local(rslot,mm,rt,sb,qd,rho,cent_local,rel_local) + ud,inv=np.unique(docs,return_inverse=True) + head=np.bincount(inv,weights=hc,minlength=len(ud)).astype(np.float32) + tail=np.bincount(inv,weights=tc,minlength=len(ud)).astype(np.float32)+LAMBDA_M*np.bincount(inv,weights=cc,minlength=len(ud)).astype(np.float32) + # Only the top hmax head documents and top P+hmax tail documents are ever used. + # Partial selection avoids O(C log C) full sorts when C is 10^5--10^6. + hwant=min(len(head),max(1,hmax)) + if len(head)>hwant: + hi=np.argpartition(head,-hwant)[-hwant:]; ho=hi[np.argsort(head[hi])[::-1]] + else: ho=np.argsort(head)[::-1] + want=min(len(tail),pool_max+hmax+8) + if len(tail)>want: + ci=np.argpartition(tail,-want)[-want:]; cheap=ci[np.argsort(tail[ci])[::-1]] + else: cheap=np.argsort(tail)[::-1] + cand_idx=cheap[:want]; cand_docs=ud[cand_idx]; cand_tail=tail[cand_idx] + lexvec=np.zeros(M,np.float32); lexvec[q.indices]=self.idf[q.indices]; semvec=np.zeros(M,np.float32) + for t,amp in zip(q.indices,q.data): + a,b=self.A.indptr[t],self.A.indptr[t+1]; nb=self.A.indices[a:b][:SEMK]; sv=self.A.data[a:b][:SEMK]; semvec[nb]+=float(amp)*sv*self.idf[nb] + lex,sem=score_support_pool(cand_docs,self.sup_ip,self.sup_ids,lexvec,semvec,self.dl,self.avgdl) + return {'ud':ud,'head_order':ho,'cand_docs':cand_docs,'cand_tail':cand_tail,'lex':lex,'sem':sem,'candidate_memberships':len(docs),'candidate_docs':len(ud)} + def rank_h(self,p,h,k=100,pool=P): + 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())) + # Candidate rerank arrays were computed for top P+hmax; exclude frozen and take P. + keep=np.asarray([int(d) not in fs for d in p['cand_docs']],bool); docs=p['cand_docs'][keep][:pool]; ts=p['cand_tail'][keep][:pool]; lx=p['lex'][keep][:pool]; sm=p['sem'][keep][:pool] + final=zscore(ts)+LAMBDA_LEX*zscore(lx)+LAMBDA_SEM*zscore(sm); oo=np.argsort(final)[::-1]; taildocs=docs[oo] + ranked=np.concatenate([frozen,taildocs])[:k]; return [int(x) for x in ranked] + +def load_query_texts(want): + want=set(map(str,want)); out={} + with open(ROOT/'queries.jsonl','r',encoding='utf-8') as f: + for line in f: + o=json.loads(line); qid=str(o['_id']) + if qid in want: out[qid]=o.get('text','') or '' + return out + +def qrels_from_tsv(path,qids=None,positive_only=False): + df=pd.read_csv(path,sep='\t'); qset=None if qids is None else set(map(str,qids)); out={} + for q,d,s in zip(df['query-id'],df['corpus-id'],df['score']): + q=str(q) + if qset is not None and q not in qset: continue + if positive_only and float(s)<=0: continue + out.setdefault(q,{})[str(d)]=float(s) + return out + +if __name__=='__main__': + print('import this module from a sweep script') diff --git a/experiments/msmarco_scale/msmarco_full_search_post.py b/experiments/msmarco_scale/msmarco_full_search_post.py new file mode 100644 index 0000000000000000000000000000000000000000..4823d38a2af406f1358de27415f954e84ef7473c --- /dev/null +++ b/experiments/msmarco_scale/msmarco_full_search_post.py @@ -0,0 +1,201 @@ +from __future__ import annotations +import gzip,json,pickle,time,math,random +from pathlib import Path +import numpy as np +import pandas as pd +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' +N=8_841_823; M=50_000; F=4; S=16; SENT=np.uint16(65535) +ROUTE_ALPHA=.10; ROUTE_BUDGET=32; GAMMA_HEAD=.5; GAMMA_TAIL=1.; LAMBDA_M=2.; P=2000; LAMBDA_LEX=2.5; LENGTH_B=.2; SEMK=16; LAMBDA_SEM=.05 +HGRID=list(range(0,11))+[15,20] +set_num_threads(5) + +@njit(cache=False) +def lookup_center(ct,cv,t): + lo=0; hi=ct.size + while lo=t: hi=mid + else: lo=mid+1 + if lo=t: hi=mid + else: lo=mid+1 + if lo>r)&1)!=0 else -1.0 + local += rel*(qv-cen)*sgn; sig += qv*qv + rho=route_dense[j]; m=mem[z] + hc[z]=m*rho*local*(sig**0.5 if sig>0 else 0.0) + tc[z]=m*rho*local*sig + cc[z]=m*rho + return hc,tc,cc + +@njit(cache=False) +def aggregate_by_doc(docs,hc,tc,cc,mark,head_acc,tail_acc,gen): + # Dense generation-mark accumulator avoids sorting every membership record. + # The returned document IDs are sorted afterwards to preserve deterministic + # tie behaviour of the original np.unique path. + seen=np.empty(len(docs),np.uint32); nseen=0 + for z in range(len(docs)): + d=int(docs[z]) + if mark[d]!=gen: + mark[d]=gen; head_acc[d]=0.0; tail_acc[d]=0.0; seen[nseen]=d; nseen+=1 + head_acc[d]+=float(hc[z]) + tail_acc[d]+=float(tc[z])+LAMBDA_M*float(cc[z]) + return seen[:nseen] + +def zscore(x): + x=np.asarray(x,np.float32); s=float(x.std()); return np.zeros_like(x) if s<1e-8 else (x-float(x.mean()))/(s+1e-8) + +def dcg(vals): + return sum((2.0**float(r)-1.0)/math.log2(i+2) for i,r in enumerate(vals)) + +def eval_run(run,qrels): + metrics={'nDCG@10':[],'MRR@10':[],'P@10':[],'R@10':[],'R@100':[],'Hit@10':[],'Hit@100':[]} + for qid,qr in qrels.items(): + rank=run[qid]; pos={int(d) for d,r in qr.items() if r>0}; n=max(1,len(pos)) + h10=sum(d in pos for d in rank[:10]); h100=sum(d in pos for d in rank[:100]); metrics['P@10'].append(h10/10); metrics['R@10'].append(h10/n); metrics['R@100'].append(h100/n); metrics['Hit@10'].append(float(h10>0)); metrics['Hit@100'].append(float(h100>0)) + rr=0 + for i,d in enumerate(rank[:10],1): + if d in pos: rr=1/i; break + metrics['MRR@10'].append(rr) + obs=[float(qr.get(str(d),qr.get(d,0.0))) for d in rank[:10]]; ideal=sorted([float(r) for r in qr.values()],reverse=True)[:10]; idc=dcg(ideal); metrics['nDCG@10'].append(dcg(obs)/idc if idc else 0) + return {k:float(np.mean(v)) for k,v in metrics.items()} | {'n_queries':len(qrels)} + +class FullIndex: + def __init__(self): + with gzip.open(WORK/'final_vocab_50k.pkl.gz','rb') as g: z=pickle.load(g) + self.terms=z['terms'].tolist(); self.idf=np.asarray(z['idf'],np.float32); self.vocab={t:i for i,t in enumerate(self.terms)} + self.cvq=CountVectorizer(vocabulary=self.vocab,lowercase=True,token_pattern=r'(?u)\b\w\w+\b',dtype=np.int32) + self.ct=np.load(GEOM/'center_terms.npy',mmap_mode='r'); self.cv=np.load(GEOM/'center_values.npy',mmap_mode='r'); self.A=sparse.load_npz(GEOM/'assoc_ppmi.npz').tocsr(); self.G=sparse.load_npz(GEOM/'context_similarity.npz').tocsr(); self.rp=np.load(GEOM/'rel_indptr.npy',mmap_mode='r'); _rm=json.load(open(GEOM/'rel_meta.json')); _rn=int(_rm['nnz']); self.ri=np.memmap(GEOM/'rel_indices.u16',np.uint16,'r',shape=(_rn,)); self.rv=np.memmap(GEOM/'rel_data.f32',np.float32,'r',shape=(_rn,)) + self.dl=np.memmap(IDX/'doc_lengths.u16',np.uint16,'r',shape=(N,)); self.offs=np.load(IDX/'branch_offsets.npy',mmap_mode='r'); _np=int(self.offs[-1]); self.pd=np.memmap(IDX/'post_doc.u32',np.uint32,'r',shape=(_np,)); self.pm=np.memmap(IDX/'post_membership.f32',np.float32,'r',shape=(_np,)); self.pr=np.memmap(IDX/'post_res_terms.u16',np.uint16,'r',shape=(_np,S)); self.ps=np.memmap(IDX/'post_signbits.u16',np.uint16,'r',shape=(_np,)) + with open(IDX/'meta.json') as f: self.meta=json.load(f) + self.avgdl=float(self.meta['avg_doc_length']); self.sup=[] + for sid in range(36): + with open(IDX/f'shard_{sid:04d}.json') as f: sm=json.load(f) + ii=np.memmap(IDX/f'support_{sid:04d}.u16',np.uint16,'r',shape=(sm['nnz'],)); ip=np.memmap(IDX/f'support_indptr_{sid:04d}.u32',np.uint32,'r',shape=(sm['n']+1,)); self.sup.append((sm['offset'],sm['n'],ip,ii)) + def query_vec(self,text): + q=self.cvq.transform([text]).tocsr().astype(np.float32); q.data*=self.idf[q.indices]; normalize(q,norm='l2',axis=1,copy=False); return q + def route(self,q): + qt=q.indices; qv=q.data; dense=np.zeros(M,np.float32); dense[qt]=qv + for t,v in zip(qt,qv): + a,b=self.G.indptr[t],self.G.indptr[t+1]; dense[self.G.indices[a:b]] += ROUTE_ALPHA*float(v)*self.G.data[a:b] + nz=np.flatnonzero(dense>0); orig=set(map(int,qt.tolist())) + if len(nz)>ROUTE_BUDGET: + inf=np.asarray([i for i in nz if int(i) not in orig],np.int32); budget=max(0,ROUTE_BUDGET-len(orig)) + if budget and len(inf)>budget: inf=inf[np.argpartition(dense[inf],-budget)[-budget:]] + elif budget==0: inf=np.empty(0,np.int32) + nz=np.concatenate([np.asarray(sorted(orig),np.int32),inf]) + nz=nz[np.argsort(dense[nz])[::-1]]; return nz.astype(np.int32),dense + def support(self,d): + sid=min(35,int(d)//250_000); off,n,ip,ii=self.sup[sid]; ld=int(d)-off; a=int(ip[ld]); b=int(ip[ld+1]); return ii[a:b] + def prepare(self,text,hmax=20): + q=self.query_vec(text); qd=np.zeros(M,np.float32); qd[q.indices]=q.data; rterms,rd=self.route(q) + spans=[(int(j),int(self.offs[j]),int(self.offs[j+1])) for j in rterms if self.offs[j+1]>self.offs[j]] + if not spans: return None + docs=np.concatenate([np.asarray(self.pd[a:b]) for j,a,b in spans]).astype(np.uint32,copy=False) + mm=np.concatenate([np.asarray(self.pm[a:b]) for j,a,b in spans]).astype(np.float32,copy=False) + rt=np.concatenate([np.asarray(self.pr[a:b]) for j,a,b in spans]).astype(np.uint16,copy=False) + sb=np.concatenate([np.asarray(self.ps[a:b]) for j,a,b in spans]).astype(np.uint16,copy=False) + br=np.concatenate([np.full(b-a,j,dtype=np.uint16) for j,a,b in spans]) + hc,tc,cc=score_memberships(br,mm,rt,sb,qd,rd,self.ct,self.cv,self.rp,self.ri,self.rv) + ud,inv=np.unique(docs,return_inverse=True) + head=np.bincount(inv,weights=hc,minlength=len(ud)).astype(np.float32) + tail=np.bincount(inv,weights=tc,minlength=len(ud)).astype(np.float32)+LAMBDA_M*np.bincount(inv,weights=cc,minlength=len(ud)).astype(np.float32) + # Only the top hmax head documents and top P+hmax tail documents are ever used. + # Partial selection avoids O(C log C) full sorts when C is 10^5--10^6. + hwant=min(len(head),max(1,hmax)) + if len(head)>hwant: + hi=np.argpartition(head,-hwant)[-hwant:]; ho=hi[np.argsort(head[hi])[::-1]] + else: ho=np.argsort(head)[::-1] + want=min(len(tail),P+hmax+8) + if len(tail)>want: + ci=np.argpartition(tail,-want)[-want:]; cheap=ci[np.argsort(tail[ci])[::-1]] + else: cheap=np.argsort(tail)[::-1] + cand_idx=cheap[:want]; cand_docs=ud[cand_idx]; cand_tail=tail[cand_idx] + lexvec=np.zeros(M,np.float32); lexvec[q.indices]=self.idf[q.indices]; semvec=np.zeros(M,np.float32) + for t,amp in zip(q.indices,q.data): + a,b=self.A.indptr[t],self.A.indptr[t+1]; nb=self.A.indices[a:b][:SEMK]; sv=self.A.data[a:b][:SEMK]; semvec[nb]+=float(amp)*sv*self.idf[nb] + lex=np.zeros(want,np.float32); sem=np.zeros(want,np.float32) + for i,d in enumerate(cand_docs): + sp=self.support(int(d)); lex[i]=float(lexvec[sp].sum()); denom=(1-LENGTH_B)+LENGTH_B*(float(self.dl[int(d)])/self.avgdl); lex[i]/=denom if denom>0 else 1.; sem[i]=float(semvec[sp].sum()) + return {'ud':ud,'head_order':ho,'cand_docs':cand_docs,'cand_tail':cand_tail,'lex':lex,'sem':sem,'candidate_memberships':len(docs),'candidate_docs':len(ud)} + def rank_h(self,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())) + # Candidate rerank arrays were computed for top P+hmax; exclude frozen and take P. + 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=zscore(ts)+LAMBDA_LEX*zscore(lx)+LAMBDA_SEM*zscore(sm); oo=np.argsort(final)[::-1]; taildocs=docs[oo] + ranked=np.concatenate([frozen,taildocs])[:k]; return [int(x) for x in ranked] + +def load_query_texts(want): + want=set(map(str,want)); out={} + with open(ROOT/'queries.jsonl','r',encoding='utf-8') as f: + for line in f: + o=json.loads(line); qid=str(o['_id']) + if qid in want: out[qid]=o.get('text','') or '' + return out + +def qrels_from_tsv(path,qids=None,positive_only=False): + df=pd.read_csv(path,sep='\t'); qset=None if qids is None else set(map(str,qids)); out={} + for q,d,s in zip(df['query-id'],df['corpus-id'],df['score']): + q=str(q) + if qset is not None and q not in qset: continue + if positive_only and float(s)<=0: continue + out.setdefault(q,{})[str(d)]=float(s) + return out + +if __name__=='__main__': + idx=FullIndex(); print('loaded full index',idx.meta,flush=True) + # Validation protocol: tune h on a deterministic 1000-query sample from TRAIN, + # then lock h and evaluate the entire 6,980-query DEV split untouched. + 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); val_ids=[str(x) for x in rng.choice(uq,size=1000,replace=False)]; del tr + devdf=pd.read_csv(ROOT/'dev.tsv',sep='\t',usecols=['query-id']); dev_ids=[str(x) for x in np.unique(devdf['query-id'].to_numpy())]; del devdf + texts=load_query_texts(val_ids+dev_ids); valq=qrels_from_tsv(ROOT/'train.tsv',val_ids,positive_only=True); devq=qrels_from_tsv(ROOT/'dev.tsv',dev_ids,positive_only=True) + missing=[q for q in val_ids+dev_ids if q not in texts] + if missing: raise RuntimeError(f'missing query texts: {missing[:10]} ({len(missing)} total)') + # JIT and I/O warmup; excluded from timing. + _w=idx.prepare(texts[val_ids[0]],hmax=max(HGRID)); _=idx.rank_h(_w,0,100); del _w + # Prepare each validation query ONCE, immediately materialize all h rankings, + # and discard the large candidate arrays. This keeps RAM bounded at scale. + vruns={h:{} for h in HGRID}; times=[]; cands=[]; memc=[] + for z,qid in enumerate(val_ids): + t=time.perf_counter(); pp=idx.prepare(texts[qid],hmax=max(HGRID)); times.append((time.perf_counter()-t)*1000) + cands.append(pp['candidate_docs'] if pp else 0); memc.append(pp['candidate_memberships'] if pp else 0) + for h in HGRID: vruns[h][qid]=idx.rank_h(pp,h,100) + if (z+1)%100==0: print('val',z+1,'median_ms',float(np.median(times)),'p95_ms',float(np.percentile(times,95)),'avg_candidate_docs',float(np.mean(cands)),flush=True) + rows=[] + for h in HGRID: + mm=eval_run(vruns[h],valq); rows.append((h,mm)); print('H',h,mm,flush=True) + best=max(rows,key=lambda x:(x[1]['nDCG@10'],x[1]['MRR@10'],x[1]['R@100']))[0]; print('BEST_H',best,flush=True) + val_timing={'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)),'avg_candidate_memberships':float(np.mean(memc))} + del vruns + # Full untouched DEV evaluation with h locked. + run={}; times=[]; cands=[]; memc=[] + for z,qid in enumerate(dev_ids): + t=time.perf_counter(); pp=idx.prepare(texts[qid],hmax=max(best,1)); run[qid]=idx.rank_h(pp,best,100); times.append((time.perf_counter()-t)*1000); cands.append(pp['candidate_docs'] if pp else 0); memc.append(pp['candidate_memberships'] if pp else 0) + if (z+1)%250==0: print('dev',z+1,'median_ms',float(np.median(times)),'p95_ms',float(np.percentile(times,95)),'avg_candidate_docs',float(np.mean(cands)),flush=True) + mm=eval_run(run,devq); 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(memc))} + out={'protocol':'h tuned on deterministic 1000-query TRAIN sample; full DEV untouched','best_h':best,'validation':{str(h):vv for h,vv in rows},'validation_timing':val_timing,'dev_metrics':mm,'timing':timing,'index_meta':idx.meta,'geometry_note':'full 8.84M vocabulary/IDF; geometric codebook calibrated on first 1M passages'} + with open(WORK/'full_msmarco_results.json','w') as f: json.dump(out,f,indent=2) + print('DEV_METRICS',mm,flush=True); print('TIMING',timing,flush=True); print('saved',WORK/'full_msmarco_results.json',flush=True) diff --git a/experiments/msmarco_scale/msmarco_full_search_uniform1m.py b/experiments/msmarco_scale/msmarco_full_search_uniform1m.py new file mode 100644 index 0000000000000000000000000000000000000000..40ec531085ce880724a645ee1885cd7bda6e7f0a --- /dev/null +++ b/experiments/msmarco_scale/msmarco_full_search_uniform1m.py @@ -0,0 +1,230 @@ +from __future__ import annotations +import gzip,json,pickle,time,math,random +from pathlib import Path +import numpy as np +import pandas as pd +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_uniform1m'; IDX=WORK/'full_index_uniform1m' +N=8_841_823; M=50_000; F=4; S=16; SENT=np.uint16(65535) +ROUTE_ALPHA=.10; ROUTE_BUDGET=32; GAMMA_HEAD=.5; GAMMA_TAIL=1.; LAMBDA_M=2.; P=2000; LAMBDA_LEX=2.5; LENGTH_B=.2; SEMK=16; LAMBDA_SEM=.05 +HGRID=list(range(0,11))+[15,20] +set_num_threads(5) + +@njit(cache=False) +def lookup_center(ct,cv,t): + lo=0; hi=ct.size + while lo=t: hi=mid + else: lo=mid+1 + if lo=t: hi=mid + else: lo=mid+1 + if lo>r)&1)!=0 else -1.0 + local += rel*(qv-cen)*sgn; sig += qv*qv + rho=route_dense[j]; m=mem[z] + hc[z]=m*rho*local*(sig**0.5 if sig>0 else 0.0) + tc[z]=m*rho*local*sig + cc[z]=m*rho + return hc,tc,cc + +@njit(parallel=True,cache=False) +def score_memberships_local(rslot,mem,rt,sbits,q_dense,rho,cent_local,rel_local): + K=len(rslot); hc=np.zeros(K,np.float32); tc=np.zeros(K,np.float32); cc=np.zeros(K,np.float32) + for z in prange(K): + u=int(rslot[z]); local=0.0; sig=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; sig += qv*qv + rh=rho[u]; m=mem[z] + hc[z]=m*rh*local*(sig**0.5 if sig>0 else 0.0) + tc[z]=m*rh*local*sig + cc[z]=m*rh + return hc,tc,cc + +@njit(parallel=True,cache=False) +def score_support_pool(cand_docs,ip,ids,lexvec,semvec,dl,avgdl): + n=len(cand_docs); lex=np.zeros(n,np.float32); sem=np.zeros(n,np.float32) + for z in prange(n): + d=int(cand_docs[z]); a=int(ip[d]); b=int(ip[d+1]); lx=0.0; sm=0.0 + for k in range(a,b): + t=int(ids[k]); lx+=lexvec[t]; sm+=semvec[t] + denom=(1.0-LENGTH_B)+LENGTH_B*(float(dl[d])/avgdl) + lex[z]=lx/(denom if denom>0 else 1.0); sem[z]=sm + return lex,sem + +@njit(cache=False) +def aggregate_by_doc(docs,hc,tc,cc,mark,head_acc,tail_acc,gen): + # Dense generation-mark accumulator avoids sorting every membership record. + # The returned document IDs are sorted afterwards to preserve deterministic + # tie behaviour of the original np.unique path. + seen=np.empty(len(docs),np.uint32); nseen=0 + for z in range(len(docs)): + d=int(docs[z]) + if mark[d]!=gen: + mark[d]=gen; head_acc[d]=0.0; tail_acc[d]=0.0; seen[nseen]=d; nseen+=1 + head_acc[d]+=float(hc[z]) + tail_acc[d]+=float(tc[z])+LAMBDA_M*float(cc[z]) + return seen[:nseen] + +def zscore(x): + x=np.asarray(x,np.float32); s=float(x.std()); return np.zeros_like(x) if s<1e-8 else (x-float(x.mean()))/(s+1e-8) + +def dcg(vals): + return sum((2.0**float(r)-1.0)/math.log2(i+2) for i,r in enumerate(vals)) + +def eval_run(run,qrels): + metrics={'nDCG@10':[],'MRR@10':[],'P@10':[],'R@10':[],'R@100':[],'Hit@10':[],'Hit@100':[]} + for qid,qr in qrels.items(): + rank=run[qid]; pos={int(d) for d,r in qr.items() if r>0}; n=max(1,len(pos)) + h10=sum(d in pos for d in rank[:10]); h100=sum(d in pos for d in rank[:100]); metrics['P@10'].append(h10/10); metrics['R@10'].append(h10/n); metrics['R@100'].append(h100/n); metrics['Hit@10'].append(float(h10>0)); metrics['Hit@100'].append(float(h100>0)) + rr=0 + for i,d in enumerate(rank[:10],1): + if d in pos: rr=1/i; break + metrics['MRR@10'].append(rr) + obs=[float(qr.get(str(d),qr.get(d,0.0))) for d in rank[:10]]; ideal=sorted([float(r) for r in qr.values()],reverse=True)[:10]; idc=dcg(ideal); metrics['nDCG@10'].append(dcg(obs)/idc if idc else 0) + return {k:float(np.mean(v)) for k,v in metrics.items()} | {'n_queries':len(qrels)} + +class FullIndex: + def __init__(self): + with gzip.open(WORK/'final_vocab_50k.pkl.gz','rb') as g: z=pickle.load(g) + self.terms=z['terms'].tolist(); self.idf=np.asarray(z['idf'],np.float32); self.vocab={t:i for i,t in enumerate(self.terms)} + self.cvq=CountVectorizer(vocabulary=self.vocab,lowercase=True,token_pattern=r'(?u)\b\w\w+\b',dtype=np.int32) + self.ct=np.load(GEOM/'center_terms.npy',mmap_mode='r'); self.cv=np.load(GEOM/'center_values.npy',mmap_mode='r'); self.A=sparse.load_npz(GEOM/'assoc_ppmi.npz').tocsr(); self.G=sparse.load_npz(GEOM/'context_similarity.npz').tocsr(); self.rp=np.load(GEOM/'rel_indptr.npy',mmap_mode='r'); _rm=json.load(open(GEOM/'rel_meta.json')); _rn=int(_rm['nnz']); self.ri=np.memmap(GEOM/'rel_indices.u16',np.uint16,'r',shape=(_rn,)); self.rv=np.memmap(GEOM/'rel_data.f32',np.float32,'r',shape=(_rn,)) + self.dl=np.memmap(IDX/'doc_lengths.u16',np.uint16,'r',shape=(N,)); self.offs=np.load(IDX/'branch_offsets.npy',mmap_mode='r'); _np=int(self.offs[-1]); self.pd=np.memmap(IDX/'post_doc.u32',np.uint32,'r',shape=(_np,)); self.pm=np.memmap(IDX/'post_membership.f32',np.float32,'r',shape=(_np,)); self.pr=np.memmap(IDX/'post_res_terms.u16',np.uint16,'r',shape=(_np,S)); self.ps=np.memmap(IDX/'post_signbits.u16',np.uint16,'r',shape=(_np,)) + with open(IDX/'meta.json') as f: self.meta=json.load(f) + self.avgdl=float(self.meta['avg_doc_length']); self.sup_ip=np.memmap(IDX/'support_all_indptr.u32',np.uint32,'r',shape=(N+1,)); self.sup_ids=np.memmap(IDX/'support_all.u16',np.uint16,'r',shape=(329617090,)) + def query_vec(self,text): + q=self.cvq.transform([text]).tocsr().astype(np.float32); q.data*=self.idf[q.indices]; normalize(q,norm='l2',axis=1,copy=False); return q + def route(self,q): + qt=q.indices; qv=q.data; dense=np.zeros(M,np.float32); dense[qt]=qv + for t,v in zip(qt,qv): + a,b=self.G.indptr[t],self.G.indptr[t+1]; dense[self.G.indices[a:b]] += ROUTE_ALPHA*float(v)*self.G.data[a:b] + nz=np.flatnonzero(dense>0); orig=set(map(int,qt.tolist())) + if len(nz)>ROUTE_BUDGET: + inf=np.asarray([i for i in nz if int(i) not in orig],np.int32); budget=max(0,ROUTE_BUDGET-len(orig)) + if budget and len(inf)>budget: inf=inf[np.argpartition(dense[inf],-budget)[-budget:]] + elif budget==0: inf=np.empty(0,np.int32) + nz=np.concatenate([np.asarray(sorted(orig),np.int32),inf]) + nz=nz[np.argsort(dense[nz])[::-1]]; return nz.astype(np.int32),dense + def support(self,d): + a=int(self.sup_ip[int(d)]); b=int(self.sup_ip[int(d)+1]); return self.sup_ids[a:b] + def prepare(self,text,hmax=20): + q=self.query_vec(text); qd=np.zeros(M,np.float32); qd[q.indices]=q.data; rterms,rd=self.route(q) + spans=[(int(j),int(self.offs[j]),int(self.offs[j+1])) for j in rterms if self.offs[j+1]>self.offs[j]] + if not spans: return None + docs=np.concatenate([np.asarray(self.pd[a:b]) for j,a,b in spans]).astype(np.uint32,copy=False) + mm=np.concatenate([np.asarray(self.pm[a:b]) for j,a,b in spans]).astype(np.float32,copy=False) + rt=np.concatenate([np.asarray(self.pr[a:b]) for j,a,b in spans]).astype(np.uint16,copy=False) + sb=np.concatenate([np.asarray(self.ps[a:b]) for j,a,b in spans]).astype(np.uint16,copy=False) + # Query-local dense lookup tables: only <=32 routed branches are materialized. + # This replaces millions of tiny binary searches into center/reliability CSR rows. + nr=len(spans); cent_local=np.zeros((nr,M),np.float32); rel_local=np.zeros((nr,M),np.float32); rho=np.empty(nr,np.float32) + for u,(j,a,b) in enumerate(spans): + rowt=np.asarray(self.ct[j]); ok=rowt!=65535; ids=rowt[ok].astype(np.int32,copy=False); cent_local[u,ids]=np.asarray(self.cv[j])[ok] + ra=int(self.rp[j]); rb=int(self.rp[j+1]); rel_local[u,np.asarray(self.ri[ra:rb],np.int32)]=np.asarray(self.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)]) + hc,tc,cc=score_memberships_local(rslot,mm,rt,sb,qd,rho,cent_local,rel_local) + ud,inv=np.unique(docs,return_inverse=True) + head=np.bincount(inv,weights=hc,minlength=len(ud)).astype(np.float32) + tail=np.bincount(inv,weights=tc,minlength=len(ud)).astype(np.float32)+LAMBDA_M*np.bincount(inv,weights=cc,minlength=len(ud)).astype(np.float32) + # Only the top hmax head documents and top P+hmax tail documents are ever used. + # Partial selection avoids O(C log C) full sorts when C is 10^5--10^6. + hwant=min(len(head),max(1,hmax)) + if len(head)>hwant: + hi=np.argpartition(head,-hwant)[-hwant:]; ho=hi[np.argsort(head[hi])[::-1]] + else: ho=np.argsort(head)[::-1] + want=min(len(tail),P+hmax+8) + if len(tail)>want: + ci=np.argpartition(tail,-want)[-want:]; cheap=ci[np.argsort(tail[ci])[::-1]] + else: cheap=np.argsort(tail)[::-1] + cand_idx=cheap[:want]; cand_docs=ud[cand_idx]; cand_tail=tail[cand_idx] + lexvec=np.zeros(M,np.float32); lexvec[q.indices]=self.idf[q.indices]; semvec=np.zeros(M,np.float32) + for t,amp in zip(q.indices,q.data): + a,b=self.A.indptr[t],self.A.indptr[t+1]; nb=self.A.indices[a:b][:SEMK]; sv=self.A.data[a:b][:SEMK]; semvec[nb]+=float(amp)*sv*self.idf[nb] + lex,sem=score_support_pool(cand_docs,self.sup_ip,self.sup_ids,lexvec,semvec,self.dl,self.avgdl) + return {'ud':ud,'head_order':ho,'cand_docs':cand_docs,'cand_tail':cand_tail,'lex':lex,'sem':sem,'candidate_memberships':len(docs),'candidate_docs':len(ud)} + def rank_h(self,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())) + # Candidate rerank arrays were computed for top P+hmax; exclude frozen and take P. + 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=zscore(ts)+LAMBDA_LEX*zscore(lx)+LAMBDA_SEM*zscore(sm); oo=np.argsort(final)[::-1]; taildocs=docs[oo] + ranked=np.concatenate([frozen,taildocs])[:k]; return [int(x) for x in ranked] + +def load_query_texts(want): + want=set(map(str,want)); out={} + with open(ROOT/'queries.jsonl','r',encoding='utf-8') as f: + for line in f: + o=json.loads(line); qid=str(o['_id']) + if qid in want: out[qid]=o.get('text','') or '' + return out + +def qrels_from_tsv(path,qids=None,positive_only=False): + df=pd.read_csv(path,sep='\t'); qset=None if qids is None else set(map(str,qids)); out={} + for q,d,s in zip(df['query-id'],df['corpus-id'],df['score']): + q=str(q) + if qset is not None and q not in qset: continue + if positive_only and float(s)<=0: continue + out.setdefault(q,{})[str(d)]=float(s) + return out + +if __name__=='__main__': + idx=FullIndex(); print('loaded full index',idx.meta,flush=True) + # Validation protocol: tune h on a deterministic 1000-query sample from TRAIN, + # then lock h and evaluate the entire 6,980-query DEV split untouched. + 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); val_ids=[str(x) for x in rng.choice(uq,size=1000,replace=False)]; del tr + devdf=pd.read_csv(ROOT/'dev.tsv',sep='\t',usecols=['query-id']); dev_ids=[str(x) for x in np.unique(devdf['query-id'].to_numpy())]; del devdf + texts=load_query_texts(val_ids+dev_ids); valq=qrels_from_tsv(ROOT/'train.tsv',val_ids,positive_only=True); devq=qrels_from_tsv(ROOT/'dev.tsv',dev_ids,positive_only=True) + missing=[q for q in val_ids+dev_ids if q not in texts] + if missing: raise RuntimeError(f'missing query texts: {missing[:10]} ({len(missing)} total)') + # JIT and I/O warmup; excluded from timing. + _w=idx.prepare(texts[val_ids[0]],hmax=max(HGRID)); _=idx.rank_h(_w,0,100); del _w + # Prepare each validation query ONCE, immediately materialize all h rankings, + # and discard the large candidate arrays. This keeps RAM bounded at scale. + vruns={h:{} for h in HGRID}; times=[]; cands=[]; memc=[] + for z,qid in enumerate(val_ids): + t=time.perf_counter(); pp=idx.prepare(texts[qid],hmax=max(HGRID)); times.append((time.perf_counter()-t)*1000) + cands.append(pp['candidate_docs'] if pp else 0); memc.append(pp['candidate_memberships'] if pp else 0) + for h in HGRID: vruns[h][qid]=idx.rank_h(pp,h,100) + if (z+1)%100==0: print('val',z+1,'median_ms',float(np.median(times)),'p95_ms',float(np.percentile(times,95)),'avg_candidate_docs',float(np.mean(cands)),flush=True) + rows=[] + for h in HGRID: + mm=eval_run(vruns[h],valq); rows.append((h,mm)); print('H',h,mm,flush=True) + best=max(rows,key=lambda x:(x[1]['nDCG@10'],x[1]['MRR@10'],x[1]['R@100']))[0]; print('BEST_H',best,flush=True) + val_timing={'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)),'avg_candidate_memberships':float(np.mean(memc))} + del vruns + # Full untouched DEV evaluation with h locked. + run={}; times=[]; cands=[]; memc=[] + for z,qid in enumerate(dev_ids): + t=time.perf_counter(); pp=idx.prepare(texts[qid],hmax=max(best,1)); run[qid]=idx.rank_h(pp,best,100); times.append((time.perf_counter()-t)*1000); cands.append(pp['candidate_docs'] if pp else 0); memc.append(pp['candidate_memberships'] if pp else 0) + if (z+1)%250==0: print('dev',z+1,'median_ms',float(np.median(times)),'p95_ms',float(np.percentile(times,95)),'avg_candidate_docs',float(np.mean(cands)),flush=True) + mm=eval_run(run,devq); 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(memc))} + out={'protocol':'h tuned on deterministic 1000-query TRAIN sample; full DEV untouched','best_h':best,'validation':{str(h):vv for h,vv in rows},'validation_timing':val_timing,'dev_metrics':mm,'timing':timing,'index_meta':idx.meta,'geometry_note':'full 8.84M vocabulary/IDF; geometric codebook calibrated on deterministic uniform 1M passages across full corpus'} + with open(WORK/'full_msmarco_uniform1m_results.json','w') as f: json.dump(out,f,indent=2) + print('DEV_METRICS',mm,flush=True); print('TIMING',timing,flush=True); print('saved',WORK/'full_msmarco_uniform1m_results.json',flush=True) diff --git a/experiments/msmarco_scale/msmarco_full_search_uniform1m_s32.py b/experiments/msmarco_scale/msmarco_full_search_uniform1m_s32.py new file mode 100644 index 0000000000000000000000000000000000000000..0ab54517bdb71284991d8276fa71df610b780a35 --- /dev/null +++ b/experiments/msmarco_scale/msmarco_full_search_uniform1m_s32.py @@ -0,0 +1,230 @@ +from __future__ import annotations +import gzip,json,pickle,time,math,random +from pathlib import Path +import numpy as np +import pandas as pd +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_uniform1m_s32'; IDX=WORK/'full_index_uniform1m_s32_post' +N=8_841_823; M=50_000; F=4; S=32; SENT=np.uint16(65535) +ROUTE_ALPHA=.10; ROUTE_BUDGET=32; GAMMA_HEAD=.5; GAMMA_TAIL=1.; LAMBDA_M=2.; P=2000; LAMBDA_LEX=2.5; LENGTH_B=.2; SEMK=16; LAMBDA_SEM=.05 +HGRID=list(range(0,11))+[15,20] +set_num_threads(5) + +@njit(cache=False) +def lookup_center(ct,cv,t): + lo=0; hi=ct.size + while lo=t: hi=mid + else: lo=mid+1 + if lo=t: hi=mid + else: lo=mid+1 + if lo>r)&1)!=0 else -1.0 + local += rel*(qv-cen)*sgn; sig += qv*qv + rho=route_dense[j]; m=mem[z] + hc[z]=m*rho*local*(sig**0.5 if sig>0 else 0.0) + tc[z]=m*rho*local*sig + cc[z]=m*rho + return hc,tc,cc + +@njit(parallel=True,cache=False) +def score_memberships_local(rslot,mem,rt,sbits,q_dense,rho,cent_local,rel_local): + K=len(rslot); hc=np.zeros(K,np.float32); tc=np.zeros(K,np.float32); cc=np.zeros(K,np.float32) + for z in prange(K): + u=int(rslot[z]); local=0.0; sig=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; sig += qv*qv + rh=rho[u]; m=mem[z] + hc[z]=m*rh*local*(sig**0.5 if sig>0 else 0.0) + tc[z]=m*rh*local*sig + cc[z]=m*rh + return hc,tc,cc + +@njit(parallel=True,cache=False) +def score_support_pool(cand_docs,ip,ids,lexvec,semvec,dl,avgdl): + n=len(cand_docs); lex=np.zeros(n,np.float32); sem=np.zeros(n,np.float32) + for z in prange(n): + d=int(cand_docs[z]); a=int(ip[d]); b=int(ip[d+1]); lx=0.0; sm=0.0 + for k in range(a,b): + t=int(ids[k]); lx+=lexvec[t]; sm+=semvec[t] + denom=(1.0-LENGTH_B)+LENGTH_B*(float(dl[d])/avgdl) + lex[z]=lx/(denom if denom>0 else 1.0); sem[z]=sm + return lex,sem + +@njit(cache=False) +def aggregate_by_doc(docs,hc,tc,cc,mark,head_acc,tail_acc,gen): + # Dense generation-mark accumulator avoids sorting every membership record. + # The returned document IDs are sorted afterwards to preserve deterministic + # tie behaviour of the original np.unique path. + seen=np.empty(len(docs),np.uint32); nseen=0 + for z in range(len(docs)): + d=int(docs[z]) + if mark[d]!=gen: + mark[d]=gen; head_acc[d]=0.0; tail_acc[d]=0.0; seen[nseen]=d; nseen+=1 + head_acc[d]+=float(hc[z]) + tail_acc[d]+=float(tc[z])+LAMBDA_M*float(cc[z]) + return seen[:nseen] + +def zscore(x): + x=np.asarray(x,np.float32); s=float(x.std()); return np.zeros_like(x) if s<1e-8 else (x-float(x.mean()))/(s+1e-8) + +def dcg(vals): + return sum((2.0**float(r)-1.0)/math.log2(i+2) for i,r in enumerate(vals)) + +def eval_run(run,qrels): + metrics={'nDCG@10':[],'MRR@10':[],'P@10':[],'R@10':[],'R@100':[],'Hit@10':[],'Hit@100':[]} + for qid,qr in qrels.items(): + rank=run[qid]; pos={int(d) for d,r in qr.items() if r>0}; n=max(1,len(pos)) + h10=sum(d in pos for d in rank[:10]); h100=sum(d in pos for d in rank[:100]); metrics['P@10'].append(h10/10); metrics['R@10'].append(h10/n); metrics['R@100'].append(h100/n); metrics['Hit@10'].append(float(h10>0)); metrics['Hit@100'].append(float(h100>0)) + rr=0 + for i,d in enumerate(rank[:10],1): + if d in pos: rr=1/i; break + metrics['MRR@10'].append(rr) + obs=[float(qr.get(str(d),qr.get(d,0.0))) for d in rank[:10]]; ideal=sorted([float(r) for r in qr.values()],reverse=True)[:10]; idc=dcg(ideal); metrics['nDCG@10'].append(dcg(obs)/idc if idc else 0) + return {k:float(np.mean(v)) for k,v in metrics.items()} | {'n_queries':len(qrels)} + +class FullIndex: + def __init__(self): + with gzip.open(WORK/'final_vocab_50k.pkl.gz','rb') as g: z=pickle.load(g) + self.terms=z['terms'].tolist(); self.idf=np.asarray(z['idf'],np.float32); self.vocab={t:i for i,t in enumerate(self.terms)} + self.cvq=CountVectorizer(vocabulary=self.vocab,lowercase=True,token_pattern=r'(?u)\b\w\w+\b',dtype=np.int32) + self.ct=np.load(GEOM/'center_terms.npy',mmap_mode='r'); self.cv=np.load(GEOM/'center_values.npy',mmap_mode='r'); self.A=sparse.load_npz(GEOM/'assoc_ppmi.npz').tocsr(); self.G=sparse.load_npz(GEOM/'context_similarity.npz').tocsr(); self.rp=np.load(GEOM/'rel_indptr.npy',mmap_mode='r'); _rm=json.load(open(GEOM/'rel_meta.json')); _rn=int(_rm['nnz']); self.ri=np.memmap(GEOM/'rel_indices.u16',np.uint16,'r',shape=(_rn,)); self.rv=np.memmap(GEOM/'rel_data.f32',np.float32,'r',shape=(_rn,)) + self.dl=np.memmap(IDX/'doc_lengths.u16',np.uint16,'r',shape=(N,)); self.offs=np.load(IDX/'branch_offsets.npy',mmap_mode='r'); _np=int(self.offs[-1]); self.pd=np.memmap(IDX/'post_doc.u32',np.uint32,'r',shape=(_np,)); self.pm=np.memmap(IDX/'post_membership.f32',np.float32,'r',shape=(_np,)); self.pr=np.memmap(IDX/'post_res_terms.u16',np.uint16,'r',shape=(_np,S)); self.ps=np.memmap(IDX/'post_signbits.u32',np.uint32,'r',shape=(_np,)) + with open(IDX/'meta.json') as f: self.meta=json.load(f) + self.avgdl=float(self.meta['avg_doc_length']); self.sup_ip=np.memmap(IDX/'support_all_indptr.u32',np.uint32,'r',shape=(N+1,)); self.sup_ids=np.memmap(IDX/'support_all.u16',np.uint16,'r',shape=(329617090,)) + def query_vec(self,text): + q=self.cvq.transform([text]).tocsr().astype(np.float32); q.data*=self.idf[q.indices]; normalize(q,norm='l2',axis=1,copy=False); return q + def route(self,q): + qt=q.indices; qv=q.data; dense=np.zeros(M,np.float32); dense[qt]=qv + for t,v in zip(qt,qv): + a,b=self.G.indptr[t],self.G.indptr[t+1]; dense[self.G.indices[a:b]] += ROUTE_ALPHA*float(v)*self.G.data[a:b] + nz=np.flatnonzero(dense>0); orig=set(map(int,qt.tolist())) + if len(nz)>ROUTE_BUDGET: + inf=np.asarray([i for i in nz if int(i) not in orig],np.int32); budget=max(0,ROUTE_BUDGET-len(orig)) + if budget and len(inf)>budget: inf=inf[np.argpartition(dense[inf],-budget)[-budget:]] + elif budget==0: inf=np.empty(0,np.int32) + nz=np.concatenate([np.asarray(sorted(orig),np.int32),inf]) + nz=nz[np.argsort(dense[nz])[::-1]]; return nz.astype(np.int32),dense + def support(self,d): + a=int(self.sup_ip[int(d)]); b=int(self.sup_ip[int(d)+1]); return self.sup_ids[a:b] + def prepare(self,text,hmax=20): + q=self.query_vec(text); qd=np.zeros(M,np.float32); qd[q.indices]=q.data; rterms,rd=self.route(q) + spans=[(int(j),int(self.offs[j]),int(self.offs[j+1])) for j in rterms if self.offs[j+1]>self.offs[j]] + if not spans: return None + docs=np.concatenate([np.asarray(self.pd[a:b]) for j,a,b in spans]).astype(np.uint32,copy=False) + mm=np.concatenate([np.asarray(self.pm[a:b]) for j,a,b in spans]).astype(np.float32,copy=False) + rt=np.concatenate([np.asarray(self.pr[a:b]) for j,a,b in spans]).astype(np.uint16,copy=False) + sb=np.concatenate([np.asarray(self.ps[a:b]) for j,a,b in spans]).astype(np.uint16,copy=False) + # Query-local dense lookup tables: only <=32 routed branches are materialized. + # This replaces millions of tiny binary searches into center/reliability CSR rows. + nr=len(spans); cent_local=np.zeros((nr,M),np.float32); rel_local=np.zeros((nr,M),np.float32); rho=np.empty(nr,np.float32) + for u,(j,a,b) in enumerate(spans): + rowt=np.asarray(self.ct[j]); ok=rowt!=65535; ids=rowt[ok].astype(np.int32,copy=False); cent_local[u,ids]=np.asarray(self.cv[j])[ok] + ra=int(self.rp[j]); rb=int(self.rp[j+1]); rel_local[u,np.asarray(self.ri[ra:rb],np.int32)]=np.asarray(self.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)]) + hc,tc,cc=score_memberships_local(rslot,mm,rt,sb,qd,rho,cent_local,rel_local) + ud,inv=np.unique(docs,return_inverse=True) + head=np.bincount(inv,weights=hc,minlength=len(ud)).astype(np.float32) + tail=np.bincount(inv,weights=tc,minlength=len(ud)).astype(np.float32)+LAMBDA_M*np.bincount(inv,weights=cc,minlength=len(ud)).astype(np.float32) + # Only the top hmax head documents and top P+hmax tail documents are ever used. + # Partial selection avoids O(C log C) full sorts when C is 10^5--10^6. + hwant=min(len(head),max(1,hmax)) + if len(head)>hwant: + hi=np.argpartition(head,-hwant)[-hwant:]; ho=hi[np.argsort(head[hi])[::-1]] + else: ho=np.argsort(head)[::-1] + want=min(len(tail),P+hmax+8) + if len(tail)>want: + ci=np.argpartition(tail,-want)[-want:]; cheap=ci[np.argsort(tail[ci])[::-1]] + else: cheap=np.argsort(tail)[::-1] + cand_idx=cheap[:want]; cand_docs=ud[cand_idx]; cand_tail=tail[cand_idx] + lexvec=np.zeros(M,np.float32); lexvec[q.indices]=self.idf[q.indices]; semvec=np.zeros(M,np.float32) + for t,amp in zip(q.indices,q.data): + a,b=self.A.indptr[t],self.A.indptr[t+1]; nb=self.A.indices[a:b][:SEMK]; sv=self.A.data[a:b][:SEMK]; semvec[nb]+=float(amp)*sv*self.idf[nb] + lex,sem=score_support_pool(cand_docs,self.sup_ip,self.sup_ids,lexvec,semvec,self.dl,self.avgdl) + return {'ud':ud,'head_order':ho,'cand_docs':cand_docs,'cand_tail':cand_tail,'lex':lex,'sem':sem,'candidate_memberships':len(docs),'candidate_docs':len(ud)} + def rank_h(self,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())) + # Candidate rerank arrays were computed for top P+hmax; exclude frozen and take P. + 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=zscore(ts)+LAMBDA_LEX*zscore(lx)+LAMBDA_SEM*zscore(sm); oo=np.argsort(final)[::-1]; taildocs=docs[oo] + ranked=np.concatenate([frozen,taildocs])[:k]; return [int(x) for x in ranked] + +def load_query_texts(want): + want=set(map(str,want)); out={} + with open(ROOT/'queries.jsonl','r',encoding='utf-8') as f: + for line in f: + o=json.loads(line); qid=str(o['_id']) + if qid in want: out[qid]=o.get('text','') or '' + return out + +def qrels_from_tsv(path,qids=None,positive_only=False): + df=pd.read_csv(path,sep='\t'); qset=None if qids is None else set(map(str,qids)); out={} + for q,d,s in zip(df['query-id'],df['corpus-id'],df['score']): + q=str(q) + if qset is not None and q not in qset: continue + if positive_only and float(s)<=0: continue + out.setdefault(q,{})[str(d)]=float(s) + return out + +if __name__=='__main__': + idx=FullIndex(); print('loaded full index',idx.meta,flush=True) + # Validation protocol: tune h on a deterministic 1000-query sample from TRAIN, + # then lock h and evaluate the entire 6,980-query DEV split untouched. + 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); val_ids=[str(x) for x in rng.choice(uq,size=1000,replace=False)]; del tr + devdf=pd.read_csv(ROOT/'dev.tsv',sep='\t',usecols=['query-id']); dev_ids=[str(x) for x in np.unique(devdf['query-id'].to_numpy())]; del devdf + texts=load_query_texts(val_ids+dev_ids); valq=qrels_from_tsv(ROOT/'train.tsv',val_ids,positive_only=True); devq=qrels_from_tsv(ROOT/'dev.tsv',dev_ids,positive_only=True) + missing=[q for q in val_ids+dev_ids if q not in texts] + if missing: raise RuntimeError(f'missing query texts: {missing[:10]} ({len(missing)} total)') + # JIT and I/O warmup; excluded from timing. + _w=idx.prepare(texts[val_ids[0]],hmax=max(HGRID)); _=idx.rank_h(_w,0,100); del _w + # Prepare each validation query ONCE, immediately materialize all h rankings, + # and discard the large candidate arrays. This keeps RAM bounded at scale. + vruns={h:{} for h in HGRID}; times=[]; cands=[]; memc=[] + for z,qid in enumerate(val_ids): + t=time.perf_counter(); pp=idx.prepare(texts[qid],hmax=max(HGRID)); times.append((time.perf_counter()-t)*1000) + cands.append(pp['candidate_docs'] if pp else 0); memc.append(pp['candidate_memberships'] if pp else 0) + for h in HGRID: vruns[h][qid]=idx.rank_h(pp,h,100) + if (z+1)%100==0: print('val',z+1,'median_ms',float(np.median(times)),'p95_ms',float(np.percentile(times,95)),'avg_candidate_docs',float(np.mean(cands)),flush=True) + rows=[] + for h in HGRID: + mm=eval_run(vruns[h],valq); rows.append((h,mm)); print('H',h,mm,flush=True) + best=max(rows,key=lambda x:(x[1]['nDCG@10'],x[1]['MRR@10'],x[1]['R@100']))[0]; print('BEST_H',best,flush=True) + val_timing={'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)),'avg_candidate_memberships':float(np.mean(memc))} + del vruns + # Full untouched DEV evaluation with h locked. + run={}; times=[]; cands=[]; memc=[] + for z,qid in enumerate(dev_ids): + t=time.perf_counter(); pp=idx.prepare(texts[qid],hmax=max(best,1)); run[qid]=idx.rank_h(pp,best,100); times.append((time.perf_counter()-t)*1000); cands.append(pp['candidate_docs'] if pp else 0); memc.append(pp['candidate_memberships'] if pp else 0) + if (z+1)%250==0: print('dev',z+1,'median_ms',float(np.median(times)),'p95_ms',float(np.percentile(times,95)),'avg_candidate_docs',float(np.mean(cands)),flush=True) + mm=eval_run(run,devq); 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(memc))} + out={'protocol':'h tuned on deterministic 1000-query TRAIN sample; full DEV untouched','best_h':best,'validation':{str(h):vv for h,vv in rows},'validation_timing':val_timing,'dev_metrics':mm,'timing':timing,'index_meta':idx.meta,'geometry_note':'full 8.84M vocabulary/IDF; uniform 1M centers/graph; residual width and reliability S=32 capacity test'} + with open(WORK/'full_msmarco_uniform1m_s32_results.json','w') as f: json.dump(out,f,indent=2) + print('DEV_METRICS',mm,flush=True); print('TIMING',timing,flush=True); print('saved',WORK/'full_msmarco_uniform1m_s32_results.json',flush=True) diff --git a/experiments/msmarco_scale/msmarco_gamma_lambda_diag.py b/experiments/msmarco_scale/msmarco_gamma_lambda_diag.py new file mode 100644 index 0000000000000000000000000000000000000000..3679b82b33b8e615847b9e7ff2fd6e659c71e2bd --- /dev/null +++ b/experiments/msmarco_scale/msmarco_gamma_lambda_diag.py @@ -0,0 +1,114 @@ +from __future__ import annotations +import sys,time,json +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 +GAMMAS=np.array([0.0,0.25,0.5,0.75,1.0,1.25,1.5,2.0],np.float32) +LAMBDAS=np.array([0.0,0.125,0.25,0.5,1.0,2.0,4.0],np.float32) +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 components(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) + cdoc=np.bincount(inv,weights=cons,minlength=len(ud)).astype(np.float32) + locals=[] + for ga in GAMMAS: + w=base if ga==0 else base*np.power(sig,ga,dtype=np.float32) + locals.append(np.bincount(inv,weights=w,minlength=len(ud)).astype(np.float32)) + return ud,locals,cdoc,len(docs) + +# exact deterministic validation ids; first 300 for grid, all 1000 for finalists +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 +_=components(texts[ids[0]]) + +# Stage A: 300-query grid by pool relevant recall +hits=np.zeros((len(GAMMAS),len(LAMBDAS)),np.int64); den=0; route_hit=0; times=[] +for z,qid in enumerate(ids[:300]): + t=time.perf_counter(); c=components(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 c is None: continue + ud,locals,cdoc,nmem=c + relpos=[] + for d in rels: + k=np.searchsorted(ud,d); ok=(kwant: top=np.argpartition(tail,-want)[-want:] + else: top=np.arange(len(tail)) + # membership mask avoids repeated np.any scans + mark=np.zeros(len(ud),np.uint8); mark[top]=1 + for k in relpos: + if k>=0: hits[gi,li]+=int(mark[k]) + if (z+1)%50==0: print('grid',z+1,'median_ms',float(np.median(times)),'route',route_hit/max(1,den),flush=True) +rec=hits/max(1,den) +flat=[] +for gi,ga in enumerate(GAMMAS): + for li,la in enumerate(LAMBDAS): flat.append((float(rec[gi,li]),float(ga),float(la))) +flat.sort(reverse=True) +print('TOP GRID',flat[:12],flush=True) +# include historical and take unique top 6 +final=[] +for _,ga,la in flat: + x=(ga,la) + if x not in final: final.append(x) + if len(final)>=6: break +if (1.0,2.0) not in final: final.append((1.0,2.0)) + +# Stage B: exact all-1000 pool recall for finalists +fh={x:0 for x in final}; den=0; rh=0; times2=[]; avgc=[] +for z,qid in enumerate(ids): + t=time.perf_counter(); c=components(texts[qid]); times2.append((time.perf_counter()-t)*1000) + rels=[int(d) for d,r in qrels[qid].items() if r>0]; den+=len(rels) + if c is None: continue + ud,locals,cdoc,nmem=c; avgc.append(len(ud)) + relpos=[] + for d in rels: + k=np.searchsorted(ud,d); ok=(kwant else np.arange(len(tail)); mark=np.zeros(len(ud),np.uint8); mark[top]=1 + for k in relpos: + if k>=0: fh[(ga,la)]+=int(mark[k]) + if (z+1)%100==0: print('final',z+1,'median_ms',float(np.median(times2)),'route',rh/max(1,den),flush=True) +rows=[] +for ga,la in final: + rows.append({'gamma':ga,'lambda_M':la,'pool_relevant_recall':fh[(ga,la)]/den}); print('FINAL',rows[-1],flush=True) +rows.sort(key=lambda x:x['pool_relevant_recall'],reverse=True) +out={'stageA_top':flat[:20],'finalists':rows,'route_relevant_recall':rh/den,'median_component_ms':float(np.median(times2)),'avg_candidate_docs':float(np.mean(avgc)),'protocol':'gamma/lambda_M pool shortlist diagnostic; deterministic TRAIN validation sample; P=2000'} +json.dump(out,open(WORK/'gamma_lambda_pool_diag.json','w'),indent=2) +print('BEST',rows[0],flush=True) diff --git a/experiments/msmarco_scale/msmarco_idf2_best_dev.py b/experiments/msmarco_scale/msmarco_idf2_best_dev.py new file mode 100644 index 0000000000000000000000000000000000000000..a40e09c254875d496470bdb6f29350209de1eabc --- /dev/null +++ b/experiments/msmarco_scale/msmarco_idf2_best_dev.py @@ -0,0 +1,60 @@ +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_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); FINAL_B=np.float32(0.1); ALPHA=np.float32(0.25); WLEX=np.float32(4.0); WSEM=np.float32(0.3) +set_num_threads(5) +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_final_features_idf2(dd,ip,ids,qmask,idf,semvec,dl,avgdl): + n=len(dd); lx=np.zeros(n,np.float32); sm=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; s=0.0; c=0.0 + for k in range(a,bb): + t=int(ids[k]); s+=semvec[t] + if qmask[t]: + x=float(idf[t]); raw+=x*x; 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); sm[z]=s; qc[z]=c + return lx,sm,qc +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: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) + # Early rescue remains the validated IDF^1 whole-document score with b=.2. + lexvec=np.zeros(M,np.float32); lexvec[q.indices]=idx.idf[q.indices]; zero=np.zeros(M,np.float32); oldlex,_=m.score_support_pool(ud,idx.sup_ip,idx.sup_ids,lexvec,zero,idx.dl,idx.avgdl) + sel=topk_desc(m.zscore(tail)+ETA*m.zscore(oldlex),P); dd=ud[sel]; ts=tail[sel] + 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] + qmask=np.zeros(M,np.uint8); qmask[q.indices]=1 + lx,sm,qc=selected_final_features_idf2(dd,idx.sup_ip,idx.sup_ids,qmask,idx.idf,semvec,idx.dl,idx.avgdl) + cov=qc/max(1,len(q.indices)); ladj=lx*np.power(np.maximum(cov,1e-6),ALPHA) + fin=m.zscore(ts)+WLEX*m.zscore(ladj)+WSEM*m.zscore(sm); oo=np.argsort(fin)[::-1][:100] + return [int(x) for x in dd[oo]],ud,sel +_=selected_final_features_idf2(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.zeros(M,np.uint8),idx.idf,np.zeros(M,np.float32),idx.dl,idx.avgdl) +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); _=prepare(texts[ids[0]]) +run={}; times=[]; routehit=poolhit=den=0; cands=[] +for z,qid in enumerate(ids): + t=time.perf_counter(); out=prepare(texts[qid]); times.append((time.perf_counter()-t)*1000) + if out is None: run[qid]=[]; continue + rank,ud,sel=out; run[qid]=rank; cands.append(len(ud)); rels=[int(d) for d,r in qrels[qid].items() if r>0]; den+=len(rels); pooldocs=set(map(int,ud[sel].tolist())) + for d in rels: + kk=np.searchsorted(ud,d); ok=kk0: rr3+=1. + ratio=float(dl[d])/avgdl; den=(1.0-FINAL_B)+FINAL_B*ratio + if den<=0:den=1. + lx[z]=raw/den; sm[z]=ss; qc[z]=c; r3[z]=rr3 + return lx,sm,qc,r3 +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: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); oldlex,_=m.score_support_pool(ud,idx.sup_ip,idx.sup_ids,lexvec,zero,idx.dl,idx.avgdl) + sel=topk_desc(m.zscore(tail)+ETA*m.zscore(oldlex),P); dd=ud[sel]; ts=tail[sel] + 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] + qmask=np.zeros(M,np.uint8); qmask[q.indices]=1; rarerank=np.zeros(M,np.uint8); ordq=q.indices[np.argsort(idx.idf[q.indices])[::-1]] + for r,t in enumerate(ordq[:3],start=1):rarerank[t]=r + lx,sm,qc,r3=final_features(dd,idx.sup_ip,idx.sup_ids,qmask,rarerank,idx.idf,semvec,idx.dl,idx.avgdl); cov=qc/max(1,len(q.indices)); ladj=lx*np.power(np.maximum(cov,1e-6),ALPHA); rarecov=r3/max(1,min(3,len(q.indices))) + fin=m.zscore(ts)+WLEX*m.zscore(ladj)+WSEM*m.zscore(sm)+WRARE*m.zscore(rarecov); oo=np.argsort(fin)[::-1][:100] + return [int(x) for x in dd[oo]],ud,sel +_=final_features(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.zeros(M,np.uint8),np.zeros(M,np.uint8),idx.idf,np.zeros(M,np.float32),idx.dl,idx.avgdl) +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); _=prepare(texts[ids[0]]) +run={}; times=[]; routehit=poolhit=den=0; cands=[] +for z,qid in enumerate(ids): + t=time.perf_counter(); out=prepare(texts[qid]); times.append((time.perf_counter()-t)*1000) + if out is None:run[qid]=[];continue + rank,ud,sel=out;run[qid]=rank;cands.append(len(ud));rels=[int(d) for d,r in qrels[qid].items() if r>0];den+=len(rels);pooldocs=set(map(int,ud[sel].tolist())) + for d in rels: + kk=np.searchsorted(ud,d);ok=kkidx.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)]) + hc,tc,cc=m.score_memberships_local(rslot,mm,rt,sb,qd,rho,cent,rel) + ud,inv=np.unique(docs,return_inverse=True) + head=np.bincount(inv,weights=hc,minlength=len(ud)).astype(np.float32) + local=np.bincount(inv,weights=tc,minlength=len(ud)).astype(np.float32) + cons=np.bincount(inv,weights=cc,minlength=len(ud)).astype(np.float32) + # lexical vectors independent of lambda + 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] + ho=np.argsort(head)[::-1][:max(HGRID)] if max(HGRID)>0 else np.empty(0,np.int64) + return q,ud,head,local,cons,lexvec,semvec,ho,len(docs) + +runs={(la,h):{} for la in LAMBDAS for h in HGRID}; pool_hit={la:0 for la in LAMBDAS}; rel_den=0; route_hit=0; times=[]; cand_counts=[] +# warm JIT +_ = components(texts[ids[0]]) +for z,qid in enumerate(ids): + t0=time.perf_counter(); c=components(texts[qid]); + if c is None: + for key in runs:runs[key][qid]=[] + continue + q,ud,head,local,cons,lexvec,semvec,ho,nmem=c; cand_counts.append(len(ud)) + rels=[int(d) for d,r in qrels[qid].items() if r>0]; rel_den+=len(rels) + for d in rels: + k=np.searchsorted(ud,d); route_hit+=int(kwant: + ci=np.argpartition(tail,-want)[-want:]; oo=ci[np.argsort(tail[ci])[::-1]] + else: oo=np.argsort(tail)[::-1] + pools[la]=(ud[oo],tail[oo]); union.append(ud[oo]) + udocs=np.unique(np.concatenate(union)); lx,sm=m.score_support_pool(udocs,idx.sup_ip,idx.sup_ids,lexvec,semvec,idx.dl,idx.avgdl) + # udocs sorted, so searchsorted maps pool docs + for la in LAMBDAS: + docs,ts=pools[la] + # pool recall before final rerank at h=0 definition + p0=docs[:P] + for d in rels: pool_hit[la]+=int(np.any(p0==d)) + pos=np.searchsorted(udocs,docs); lxx=lx[pos]; smm=sm[pos] + for h in HGRID: + frozen=ud[ho[:h]] 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 docs],bool); dd=docs[keep][:P]; tt=ts[keep][:P]; ll=lxx[keep][:P]; ss=smm[keep][:P] + fin=m.zscore(tt)+m.LAMBDA_LEX*m.zscore(ll)+m.LAMBDA_SEM*m.zscore(ss); oo=np.argsort(fin)[::-1]; rank=np.concatenate([frozen,dd[oo]])[:100] + runs[(la,h)][qid]=[int(x) for x in rank] + times.append((time.perf_counter()-t0)*1000) + if (z+1)%100==0: print('q',z+1,'median_ms',float(np.median(times)),'route',route_hit/max(1,rel_den),flush=True) + +rows=[] +for la in LAMBDAS: + for h in HGRID: + met=m.eval_run(runs[(la,h)],qrels); met['pool_relevant_recall']=pool_hit[la]/rel_den; rows.append({'lambda_M':la,'h':h,**met}); print('LAM',la,'H',h,met,'pool',pool_hit[la]/rel_den,flush=True) +best=max(rows,key=lambda r:(r['nDCG@10'],r['MRR@10'],r['R@100'])) +out={'protocol':'uniform-1M geometry; deterministic 1000 TRAIN validation; joint diagnostic sweep lambda_M and h','route_relevant_recall':route_hit/rel_den,'timing_median_ms':float(np.median(times)),'avg_candidate_docs':float(np.mean(cand_counts)),'rows':rows,'best':best} +json.dump(out,open(WORK/'lambdaM_uniform1m_diag.json','w'),indent=2); print('BEST',best,flush=True) diff --git a/experiments/msmarco_scale/msmarco_lambda_diag.py b/experiments/msmarco_scale/msmarco_lambda_diag.py new file mode 100644 index 0000000000000000000000000000000000000000..01aebda2b84af9821a734cb73ef0e9b4a26658ed --- /dev/null +++ b/experiments/msmarco_scale/msmarco_lambda_diag.py @@ -0,0 +1,28 @@ +import sys,time,numpy as np,pandas as pd,json +sys.path.insert(0,'/mnt/data') +import msmarco_full_search_fastp as m +from msmarco_full_search_fastp import FullIndex,load_query_texts,qrels_from_tsv,eval_run,ROOT,WORK,zscore +P=8000; NS=1000 +LAM=[0,0.25,0.5,1,2.5,5,10,25] +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=NS,replace=False)]; 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=P); del w +runs={x:{} for x in LAM}; purelex={}; puretail={}; times=[] +for z,qid in enumerate(ids): + t=time.perf_counter(); pp=idx.prepare(texts[qid],hmax=1,pool_max=P); times.append((time.perf_counter()-t)*1000) + if pp is None: + for lam in LAM: runs[lam][qid]=[] + purelex[qid]=[]; puretail[qid]=[] + else: + docs=pp['cand_docs'][:P]; zt=zscore(pp['cand_tail'][:P]); zl=zscore(pp['lex'][:P]); zs=zscore(pp['sem'][:P]) + for lam in LAM: + score=zt+lam*zl+0.05*zs; oo=np.argsort(score)[::-1][:100]; runs[lam][qid]=[int(x) for x in docs[oo]] + purelex[qid]=[int(x) for x in docs[np.argsort(zl)[::-1][:100]]] + puretail[qid]=[int(x) for x in docs[np.argsort(zt)[::-1][:100]]] + if (z+1)%100==0: print('q',z+1,'med',np.median(times),flush=True) +res={} +for lam in LAM: + res[str(lam)]=eval_run(runs[lam],qrels); print('LAM',lam,res[str(lam)],flush=True) +res['purelex']=eval_run(purelex,qrels); res['puretail']=eval_run(puretail,qrels); print('PURELEX',res['purelex'],flush=True); print('PURETAIL',res['puretail'],flush=True) +json.dump({'P':P,'results':res,'timing':{'median':float(np.median(times)),'p95':float(np.percentile(times,95))}},open(WORK/'lambda_diag.json','w'),indent=2) diff --git a/experiments/msmarco_scale/msmarco_lex_idf_highpower_multifold.py b/experiments/msmarco_scale/msmarco_lex_idf_highpower_multifold.py new file mode 100644 index 0000000000000000000000000000000000000000..37ad88ae39769d7ccb55970b644e7e66d5b0e3cd --- /dev/null +++ b/experiments/msmarco_scale/msmarco_lex_idf_highpower_multifold.py @@ -0,0 +1,75 @@ +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_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 +set_num_threads(5) +POWERS=[1.5,2.0,2.5,3.0,4.0] +FINAL_B=np.float32(0.1); 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_features(dd,ip,ids,qmask,idf,semvec,dl,avgdl): + n=len(dd); sp=np.zeros((5,n),np.float32); cnt=np.zeros(n,np.float32); sem=np.zeros(n,np.float32) + for z in prange(n): + d=int(dd[z]); a=int(ip[d]); bb=int(ip[d+1]); c=0.; ss=0.; a15=0.; a2=0.; a25=0.; a3=0.; a4=0. + for k in range(a,bb): + t=int(ids[k]); ss+=semvec[t] + if qmask[t]: + x=float(idf[t]); r=np.sqrt(x); x2=x*x + a15+=x*r; a2+=x2; a25+=x2*r; a3+=x2*x; a4+=x2*x2; c+=1. + ratio=float(dl[d])/avgdl; den=(1.0-FINAL_B)+FINAL_B*ratio + if den<=0:den=1. + sp[0,z]=a15/den; sp[1,z]=a2/den; sp[2,z]=a25/den; sp[3,z]=a3/den; sp[4,z]=a4/den; cnt[z]=c; sem[z]=ss + return sp,cnt,sem +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: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); oldlex,_=m.score_support_pool(ud,idx.sup_ip,idx.sup_ids,lexvec,zero,idx.dl,idx.avgdl) + sel=topk_desc(m.zscore(tail)+m.zscore(oldlex),P); dd=ud[sel]; ts=tail[sel] + 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] + qmask=np.zeros(M,np.uint8); qmask[q.indices]=1; sp,cnt,sem=selected_features(dd,idx.sup_ip,idx.sup_ids,qmask,idx.idf,semvec,idx.dl,idx.avgdl); cov=cnt/max(1,len(q.indices)); cadj=np.power(np.maximum(cov,1e-6),ALPHA) + scores=[m.zscore(ts)+WLEX*m.zscore(sp[i]*cadj)+WSEM*m.zscore(sem) for i in range(5)] + return dd,scores +def top100(sc): + n=len(sc); k=min(100,n) + if n<=k:return np.argsort(sc)[::-1] + ii=np.argpartition(sc,-k)[-k:]; return ii[np.argsort(sc[ii])[::-1]] +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 +f0=set(int(x) for x in fold0); rem=np.asarray([x for x in uq if int(x) not in f0]); rng=np.random.default_rng(20260816); extra=rng.choice(rem,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) +_=selected_features(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.zeros(M,np.uint8),idx.idf,np.zeros(M,np.float32),idx.dl,idx.avgdl); _=prepare(texts[allids[0]]) +rows=[]; times=[]; start=time.time() +for fi,ids in enumerate(folds): + runs=[{} for _ in POWERS]; print('FOLD',fi,'START',flush=True) + for qi,qid in enumerate(ids): + t=time.perf_counter(); out=prepare(texts[qid]); times.append((time.perf_counter()-t)*1000) + if out is None: + for r in runs:r[qid]=[] + continue + dd,scores=out + for pi,sc in enumerate(scores): + oo=top100(sc); runs[pi][qid]=[int(x) for x in dd[oo]] + if (qi+1)%250==0:print('fold',fi,'q',qi+1,'median_ms',float(np.median(times[-250:])),flush=True) + qr={q:qrels_all[q] for q in ids} + for pi,p in enumerate(POWERS): + met=m.eval_run(runs[pi],qr); row={'fold':fi,'idf_power':p,**met}; rows.append(row); print('METRIC',fi,p,met['nDCG@10'],met['MRR@10'],met['R@100'],flush=True) +summary=[]; base=[next(r for r in rows if r['fold']==fi and r['idf_power']==2.0) for fi in range(5)] +for p in POWERS: + rr=[r for r in rows if r['idf_power']==p]; delta=np.asarray([rr[fi]['nDCG@10']-base[fi]['nDCG@10'] for fi in range(5)]); summary.append({'idf_power':p,'mean_nDCG@10':float(np.mean([r['nDCG@10'] for r in rr])),'mean_MRR@10':float(np.mean([r['MRR@10'] for r in rr])),'mean_R@100':float(np.mean([r['R@100'] for r in rr])),'mean_delta_nDCG_vs_p2':float(delta.mean()),'min_delta_nDCG_vs_p2':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_p2'],x['mean_delta_nDCG_vs_p2']),reverse=True); out={'protocol':'5 disjoint 1000-query TRAIN folds; preselection fixed p1 eta1; final b=.1 coord .25 wl4 sem .3; high-IDF exponent extension','powers':POWERS,'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/'lex_idf_highpower_multifold.json'; json.dump(out,open(path,'w'),indent=2); print('SUMMARY'); [print(x) for x in summary]; print('SAVED',path,flush=True) diff --git a/experiments/msmarco_scale/msmarco_lex_idf_power_multifold.py b/experiments/msmarco_scale/msmarco_lex_idf_power_multifold.py new file mode 100644 index 0000000000000000000000000000000000000000..38dc466f5bff26ea447c175edfeb34a09dd4ceae --- /dev/null +++ b/experiments/msmarco_scale/msmarco_lex_idf_power_multifold.py @@ -0,0 +1,98 @@ +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_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 +set_num_threads(5) +POWERS=[0.5,0.75,1.0,1.25,1.5,2.0] +FINAL_B=np.float32(0.1); 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_features(dd,ip,ids,qmask,idf,semvec,dl,avgdl): + n=len(dd); sp=np.zeros((6,n),np.float32); cnt=np.zeros(n,np.float32); sem=np.zeros(n,np.float32) + for z in prange(n): + d=int(dd[z]); a=int(ip[d]); bb=int(ip[d+1]); c=0.0; sm=0.0 + s0=0.; s1=0.; s2=0.; s3=0.; s4=0.; s5=0. + for k in range(a,bb): + t=int(ids[k]); sm += semvec[t] + if qmask[t]: + x=float(idf[t]); rt=np.sqrt(x); qrt=np.sqrt(rt) + s0 += rt # p=.5 + s1 += rt*qrt # p=.75 + s2 += x # p=1 + s3 += x*qrt # p=1.25 + s4 += x*rt # p=1.5 + s5 += x*x # p=2 + c += 1.0 + ratio=float(dl[d])/avgdl; den=(1.0-FINAL_B)+FINAL_B*ratio + if den<=0: den=1.0 + sp[0,z]=s0/den; sp[1,z]=s1/den; sp[2,z]=s2/den; sp[3,z]=s3/den; sp[4,z]=s4/den; sp[5,z]=s5/den + cnt[z]=c; sem[z]=sm + return sp,cnt,sem + +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: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); oldlex,_=m.score_support_pool(ud,idx.sup_ip,idx.sup_ids,lexvec,zero,idx.dl,idx.avgdl) + sel=topk_desc(m.zscore(tail)+m.zscore(oldlex),P); dd=ud[sel]; ts=tail[sel] + 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] + qmask=np.zeros(M,np.uint8); qmask[q.indices]=1 + sp,cnt,sem=selected_features(dd,idx.sup_ip,idx.sup_ids,qmask,idx.idf,semvec,idx.dl,idx.avgdl) + cov=cnt/max(1,len(q.indices)); cadj=np.power(np.maximum(cov,1e-6),ALPHA) + scores=[] + for pi in range(6): scores.append(m.zscore(ts)+WLEX*m.zscore(sp[pi]*cadj)+WSEM*m.zscore(sem)) + return dd,scores + +def top100(sc): + n=len(sc); k=min(100,n) + if n<=k:return np.argsort(sc)[::-1] + ii=np.argpartition(sc,-k)[-k:]; return ii[np.argsort(sc[ii])[::-1]] + +# Same five disjoint TRAIN folds as branch robustness experiment. +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) +_=selected_features(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.zeros(M,np.uint8),idx.idf,np.zeros(M,np.float32),idx.dl,idx.avgdl); _=prepare(texts[allids[0]]) +runs=[[{} for _ in POWERS] 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): + t=time.perf_counter(); out=prepare(texts[qid]); times.append((time.perf_counter()-t)*1000) + if out is None: + for pi in range(len(POWERS)): runs[fi][pi][qid]=[] + continue + dd,scores=out + for pi,sc in enumerate(scores): + oo=top100(sc); runs[fi][pi][qid]=[int(x) for x in dd[oo]] + 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 pi,p in enumerate(POWERS): + met=m.eval_run(runs[fi][pi],qr); rows.append({'fold':fi,'idf_power':p,**met}); print('METRIC',fi,p,met['nDCG@10'],met['MRR@10'],met['R@100'],flush=True) +summary=[] +for p in POWERS: + rr=[r for r in rows if r['idf_power']==p]; base=[next(x for x in rows if x['fold']==fi and x['idf_power']==1.0) for fi in range(5)]; delta=np.asarray([rr[fi]['nDCG@10']-base[fi]['nDCG@10'] for fi in range(5)]) + summary.append({'idf_power':p,'mean_nDCG@10':float(np.mean([r['nDCG@10'] for r in rr])),'mean_MRR@10':float(np.mean([r['MRR@10'] for r in rr])),'mean_R@100':float(np.mean([r['R@100'] for r in rr])),'mean_delta_nDCG_vs_p1':float(delta.mean()),'min_delta_nDCG_vs_p1':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_p1'],x['mean_delta_nDCG_vs_p1']),reverse=True) +out={'protocol':'5 disjoint 1000-query TRAIN folds; same eta=1 P=2000 tail and structural final b=.1 coordination alpha=.25 wl4 raw-sem .3; only binary lexical IDF exponent varied','powers':POWERS,'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/'lex_idf_power_multifold.json'; json.dump(out,open(path,'w'),indent=2); print('SUMMARY'); [print(x) for x in summary]; print('SAVED',path,flush=True) diff --git a/experiments/msmarco_scale/msmarco_p_sweep.py b/experiments/msmarco_scale/msmarco_p_sweep.py new file mode 100644 index 0000000000000000000000000000000000000000..8b61ab0a277ced2483fc5c0f4c33d7b0731eed78 --- /dev/null +++ b/experiments/msmarco_scale/msmarco_p_sweep.py @@ -0,0 +1,28 @@ +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 +PGRID=[500,1000,2000,4000,8000,16000] +MAXP=max(PGRID); NS=1000 +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=NS,replace=False)]; del tr +texts=load_query_texts(ids); qrels=qrels_from_tsv(ROOT/'train.tsv',ids,positive_only=True) +# warm +w=idx.prepare(texts[ids[0]],hmax=1,pool_max=MAXP); idx.rank_h(w,0,100,pool=2000); del w +runs={p:{} for p in PGRID}; pool_hit={p:0 for p in PGRID}; route_hit=0; den=0; times=[]; cands=[] +for z,qid in enumerate(ids): + t=time.perf_counter(); pp=idx.prepare(texts[qid],hmax=1,pool_max=MAXP); times.append((time.perf_counter()-t)*1000); cands.append(pp['candidate_docs'] if pp else 0) + rel=[int(d) for d,r in qrels[qid].items() if r>0]; den+=len(rel) + if pp: + ud=pp['ud'] + for d in rel: + k=np.searchsorted(ud,d); route_hit+=int(kidx.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) + qmask=np.zeros(M,np.uint8); qmask[q.indices]=1 + l1,l2=routed_lex12(ud,idx.sup_ip,idx.sup_ids,qmask,idx.idf,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 q,ud,tail,l1,l2,qmask,semvec + +def final_rank(q,ud,tail,sel,qmask,semvec): + dd=ud[sel]; ts=tail[sel]; lx,sm,cnt=final_features_idf2(dd,idx.sup_ip,idx.sup_ids,qmask,idx.idf,semvec,idx.dl,idx.avgdl); cov=cnt/max(1,len(q.indices)); ladj=lx*np.power(np.maximum(cov,1e-6),ALPHA); fin=m.zscore(ts)+WLEX*m.zscore(ladj)+WSEM*m.zscore(sm); oo=topk_desc(fin,100); return [int(x) for x in dd[oo]] + +# Same five TRAIN 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) +_=routed_lex12(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.zeros(M,np.uint8),idx.idf,idx.dl,idx.avgdl); _=final_features_idf2(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.zeros(M,np.uint8),idx.idf,np.zeros(M,np.float32),idx.dl,idx.avgdl); _=prepare_route(texts[allids[0]]) +rows=[]; times=[]; start=time.time() +for fi,ids in enumerate(folds): + runs={model:{} for model in MODELS}; pool={model:0 for model in MODELS}; den=routehit=0 + print('FOLD',fi,'START',flush=True) + for qi,qid in enumerate(ids): + t=time.perf_counter(); p=prepare_route(texts[qid]); times.append((time.perf_counter()-t)*1000) + rels=[int(d) for d,r in qrels_all[qid].items() if r>0]; den+=len(rels) + if p is None: + for model in MODELS:runs[model][qid]=[] + continue + q,ud,tail,l1,l2,qmask,semvec=p; relset=set() + for d in rels: + kk=np.searchsorted(ud,d); ok=kk0)),'fold_deltas':delta.tolist()}) +summary.sort(key=lambda x:(x['positive_folds'],x['min_delta_nDCG_vs_p1_eta1'],x['mean_delta_nDCG_vs_p1_eta1']),reverse=True) +out={'protocol':'5 disjoint 1000-query TRAIN folds; final rule fixed to validated IDF^2 b=.1 coord .25 wl4 sem .3; only early lexical rescue IDF power and eta varied','models':MODELS,'fold_rows':rows,'summary_ranked_for_robustness':summary,'timing':{'median_route_ms':float(np.median(times)),'p95_route_ms':float(np.percentile(times,95)),'seconds':time.time()-start}} +path=WORK/'prelex_idf2_multifold.json'; json.dump(out,open(path,'w'),indent=2); print('SUMMARY'); [print(x) for x in summary]; print('SAVED',path,flush=True) diff --git a/experiments/msmarco_scale/msmarco_preselection_finalists_validation.py b/experiments/msmarco_scale/msmarco_preselection_finalists_validation.py new file mode 100644 index 0000000000000000000000000000000000000000..790aee53e82110d9c426a2ea0e3f3ebd5be8cb14 --- /dev/null +++ b/experiments/msmarco_scale/msmarco_preselection_finalists_validation.py @@ -0,0 +1,58 @@ +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_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; set_num_threads(5) +CONFIGS=[('base',.2,1.),('b15e4',.15,4.),('b20e3',.2,3.),('b20e4',.2,4.)] +FINAL_B=.1; ALPHA=.25; WLEX=4.; WSEM=.3 + +def topk(score,k): + n=len(score); k=min(k,n); ii=np.argpartition(score,-k)[-k:] if n>k else np.arange(n); return ii[np.argsort(score[ii])[::-1]] +@njit(parallel=True,cache=False) +def finalfeat(dd,ip,ids,lexvec,semvec,dl,avgdl): + n=len(dd); lx=np.zeros(n,np.float32); sm=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.; s=0.; c=0. + for kk in range(a,bb): + t=int(ids[kk]); v=lexvec[t] + if v>0: raw+=v; c+=1 + s+=semvec[t] + r=float(dl[d])/avgdl; den=(1-FINAL_B)+FINAL_B*r; lx[z]=raw/den; sm[z]=s; qc[z]=c + return lx,sm,qc + +def prep(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): + row=np.asarray(idx.ct[j]); ok=row!=65535; tids=row[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); lex02,_=m.score_support_pool(ud,idx.sup_ip,idx.sup_ids,lexvec,zero,idx.dl,idx.avgdl); ratio=np.asarray(idx.dl[ud],np.float32)/idx.avgdl; raw=lex02*((1-.2)+.2*ratio) + 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 q,ud,tail,raw,ratio,lexvec,semvec + +def rank_cfg(p,preb,eta): + q,ud,tail,raw,ratio,lexvec,semvec=p; prelex=raw/np.maximum((1-preb)+preb*ratio,1e-6); sel=topk(m.zscore(tail)+eta*m.zscore(prelex),P); dd=ud[sel]; lx,sm,qc=finalfeat(dd,idx.sup_ip,idx.sup_ids,lexvec,semvec,idx.dl,idx.avgdl); cov=qc/max(1,len(q.indices)); ladj=lx*np.power(np.maximum(cov,1e-6),ALPHA); fin=m.zscore(tail[sel])+WLEX*m.zscore(ladj)+WSEM*m.zscore(sm); oo=np.argsort(fin)[::-1][:100]; return [int(x) for x in dd[oo]],sel + +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); qids=[str(x) for x in rng.choice(uq,size=1000,replace=False)]; texts=m.load_query_texts(qids); qrels=m.qrels_from_tsv(ROOT/'train.tsv',qids,positive_only=True) +_=finalfeat(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.zeros(M,np.float32),np.zeros(M,np.float32),idx.dl,idx.avgdl); _=prep(texts[qids[0]]) +runs={n:{} for n,_,_ in CONFIGS}; hits={n:0 for n,_,_ in CONFIGS}; den=0; times=[] +for zi,qid in enumerate(qids): + t=time.perf_counter(); p=prep(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 n,_,_ in CONFIGS:runs[n][qid]=[] + continue + ud=p[1] + for n,bb,eta in CONFIGS: + rank,sel=rank_cfg(p,bb,eta); runs[n][qid]=rank; pool=set(map(int,ud[sel].tolist())); hits[n]+=sum(d in pool for d in rels) + if (zi+1)%100==0:print('q',zi+1,'medianprep',float(np.median(times)),flush=True) +rows=[] +for n,bb,eta in CONFIGS: + met=m.eval_run(runs[n],qrels); row={'name':n,'pre_b':bb,'eta':eta,'pool_relevant_recall':hits[n]/den,**met}; rows.append(row); print(row,flush=True) +rows.sort(key=lambda r:(r['nDCG@10'],r['MRR@10'],r['R@100']),reverse=True); out={'protocol':'preselection finalists selected from pool-survival validation, then structural final rule b=.1 alpha=.25 wl4 ws.3 evaluated on same deterministic TRAIN validation','rows':rows,'best':rows[0]}; json.dump(out,open(WORK/'preselection_finalists_validation.json','w'),indent=2); print('BEST',rows[0]) diff --git a/experiments/msmarco_scale/msmarco_preselection_length_sweep.py b/experiments/msmarco_scale/msmarco_preselection_length_sweep.py new file mode 100644 index 0000000000000000000000000000000000000000..4623c421a01d8a5713fcf9979c3f52acc1713f32 --- /dev/null +++ b/experiments/msmarco_scale/msmarco_preselection_length_sweep.py @@ -0,0 +1,32 @@ +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_early_lex_validation_fast as e +import msmarco_full_search_uniform1m as m +ROOT=m.ROOT; WORK=m.WORK; idx=e.idx; P=2000; set_num_threads(5) +BS=[0.,.05,.1,.15,.2,.3,.4]; ETAS=[.125,.25,.5,.75,1.,1.5,2.,3.,4.] +def topk(score,k): + n=len(score); k=min(k,n); ii=np.argpartition(score,-k)[-k:] if n>k else np.arange(n); return ii +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); qids=[str(x) for x in rng.choice(uq,size=1000,replace=False)]; texts=m.load_query_texts(qids); qrels=m.qrels_from_tsv(ROOT/'train.tsv',qids,positive_only=True) +hit={(b,eta):0 for b in BS for eta in ETAS}; den=route=0; times=[] +_=e.prepare_all(texts[qids[0]]) +for qi,qid in enumerate(qids): + t=time.perf_counter(); p=e.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: continue + ud=p['ud']; relidx=[] + for d in rels: + k=np.searchsorted(ud,d); ok=kidx.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); oldlex,_=m.score_support_pool(ud,idx.sup_ip,idx.sup_ids,lexvec,zero,idx.dl,idx.avgdl) + sel=topk_desc(m.zscore(tail)+m.zscore(oldlex),P); dd=ud[sel]; ts=tail[sel] + 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] + qmask=np.zeros(M,np.uint8); qmask[q.indices]=1; rarerank=np.zeros(M,np.uint8) + ordq=q.indices[np.argsort(idx.idf[q.indices])[::-1]] + for r,t in enumerate(ordq[:3],start=1): rarerank[t]=r + lx,cnt,sem,r1,r2,r3=selected_features(dd,idx.sup_ip,idx.sup_ids,qmask,rarerank,idx.idf,semvec,idx.dl,idx.avgdl); cov=cnt/max(1,len(q.indices)); ladj=lx*np.power(np.maximum(cov,1e-6),ALPHA); basefin=m.zscore(ts)+WLEX*m.zscore(ladj)+WSEM*m.zscore(sem) + rare=[None,r1/max(1,min(1,len(q.indices))),r2/max(1,min(2,len(q.indices))),r3/max(1,min(3,len(q.indices)))] + scores=[basefin] + for name,k,w in MODELS[1:]: scores.append(basefin+np.float32(w)*m.zscore(rare[k])) + return dd,scores +def top100(sc): + n=len(sc); k=min(100,n) + if n<=k:return np.argsort(sc)[::-1] + ii=np.argpartition(sc,-k)[-k:]; return ii[np.argsort(sc[ii])[::-1]] +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 +f0=set(int(x) for x in fold0); rem=np.asarray([x for x in uq if int(x) not in f0]); rng=np.random.default_rng(20260816); extra=rng.choice(rem,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) +_=selected_features(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.zeros(M,np.uint8),np.zeros(M,np.uint8),idx.idf,np.zeros(M,np.float32),idx.dl,idx.avgdl); _=prepare(texts[allids[0]]) +rows=[]; times=[]; start=time.time() +for fi,ids in enumerate(folds): + runs=[{} for _ in MODELS]; print('FOLD',fi,'START',flush=True) + for qi,qid in enumerate(ids): + t=time.perf_counter(); out=prepare(texts[qid]); times.append((time.perf_counter()-t)*1000) + if out is None: + for r in runs:r[qid]=[] + continue + dd,scores=out + for mi,sc in enumerate(scores): + oo=top100(sc); runs[mi][qid]=[int(x) for x in dd[oo]] + if (qi+1)%250==0:print('fold',fi,'q',qi+1,'median_ms',float(np.median(times[-250:])),flush=True) + qr={q:qrels_all[q] for q in ids} + for mi,(name,k,w) in enumerate(MODELS): + met=m.eval_run(runs[mi],qr); row={'fold':fi,'name':name,'topk':k,'weight':w,**met}; rows.append(row); print('METRIC',fi,name,met['nDCG@10'],met['MRR@10'],met['R@100'],flush=True) +summary=[]; base=[next(r for r in rows if r['fold']==fi and r['name']=='base') for fi in range(5)] +for name,k,w in MODELS: + rr=[r for r in rows if r['name']==name]; delta=np.asarray([rr[fi]['nDCG@10']-base[fi]['nDCG@10'] for fi in range(5)]); summary.append({'name':name,'topk':k,'weight':w,'mean_nDCG@10':float(np.mean([r['nDCG@10'] for r in rr])),'mean_MRR@10':float(np.mean([r['MRR@10'] for r in rr])),'mean_R@100':float(np.mean([r['R@100'] for r in rr])),'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; preselection p1 eta1; final IDF^2 b=.1 coord .25 wl4 sem .3 fixed; bounded coverage of top-1/top-2/top-3 IDF query terms added','models':MODELS,'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/'rare_conjunction_multifold.json'; json.dump(out,open(path,'w'),indent=2); print('SUMMARY'); [print(x) for x in summary[:10]]; print('SAVED',path,flush=True) diff --git a/experiments/msmarco_scale/msmarco_reorder_s32.py b/experiments/msmarco_scale/msmarco_reorder_s32.py new file mode 100644 index 0000000000000000000000000000000000000000..3f64947f3bede9c846a2b361de13509806389634 --- /dev/null +++ b/experiments/msmarco_scale/msmarco_reorder_s32.py @@ -0,0 +1,29 @@ +from pathlib import Path +from concurrent.futures import ProcessPoolExecutor,as_completed +import multiprocessing as mp,time,os +import numpy as np +W=Path('/mnt/data/msmarco_scale_work'); OLD=W/'full_index'; SRC=W/'full_index_uniform1m_s32'; NEW=W/'full_index_uniform1m_s32_post' +NEW.mkdir(exist_ok=True) +N=8_841_823; F=4; S=32 +npost=int(np.load(OLD/'branch_offsets.npy',mmap_mode='r')[-1]) + +def job(a,b): + t=time.time(); bo=np.memmap(OLD/'branch_order.u32',np.uint32,'r',shape=(npost,)); rt=np.memmap(SRC/'res_terms.u16',np.uint16,'r',shape=(N,F,S)); sb=np.memmap(SRC/'signbits.u32',np.uint32,'r',shape=(N,F)); pr=np.memmap(NEW/'post_res_terms.u16',np.uint16,'r+',shape=(npost,S)); ps=np.memmap(NEW/'post_signbits.u32',np.uint32,'r+',shape=(npost,)) + block=250_000 + for x in range(a,b,block): + y=min(b,x+block); fp=np.asarray(bo[x:y],np.uint32); docs=fp//F; slots=(fp%F).astype(np.uint8); pr[x:y]=rt[docs,slots]; ps[x:y]=sb[docs,slots] + pr.flush(); ps.flush(); return a,b,time.time()-t + +if __name__=='__main__': + if not (NEW/'post_res_terms.u16').exists(): np.memmap(NEW/'post_res_terms.u16',np.uint16,'w+',shape=(npost,S)).flush() + if not (NEW/'post_signbits.u32').exists(): np.memmap(NEW/'post_signbits.u32',np.uint32,'w+',shape=(npost,)).flush() + for name in ['branch_offsets.npy','post_doc.u32','post_membership.f32','doc_lengths.u16','support_all_indptr.u32','support_all.u16','meta.json']: + dst=NEW/name + if not dst.exists(): dst.symlink_to(OLD/name) + bounds=np.linspace(0,npost,13,dtype=np.int64); chunks=[(int(bounds[i]),int(bounds[i+1])) for i in range(12)] + t=time.time() + with ProcessPoolExecutor(max_workers=3,mp_context=mp.get_context('spawn')) as ex: + fs=[ex.submit(job,a,b) for a,b in chunks] + for k,fu in enumerate(as_completed(fs),1): + a,b,sec=fu.result(); print(f'[{k:02d}/12] {a:,}:{b:,} sec={sec:.1f}',flush=True) + print('S32 REORDER DONE npost',npost,'sec',time.time()-t,flush=True) diff --git a/experiments/msmarco_scale/msmarco_reorder_uniform.py b/experiments/msmarco_scale/msmarco_reorder_uniform.py new file mode 100644 index 0000000000000000000000000000000000000000..c7bfe7c425e41865fa2ee0bb924f2d3be684ddf6 --- /dev/null +++ b/experiments/msmarco_scale/msmarco_reorder_uniform.py @@ -0,0 +1,29 @@ +from pathlib import Path +from concurrent.futures import ProcessPoolExecutor,as_completed +import multiprocessing as mp,time,os,json +import numpy as np +WORK=Path('/mnt/data/msmarco_scale_work'); OLD=WORK/'full_index'; NEW=WORK/'full_index_uniform1m' +N=8_841_823; F=4; S=16 +npost=int(np.load(OLD/'branch_offsets.npy',mmap_mode='r')[-1]) + +def job(a,b): + t=time.time(); bo=np.memmap(OLD/'branch_order.u32',np.uint32,'r',shape=(npost,)); rt=np.memmap(NEW/'res_terms.u16',np.uint16,'r',shape=(N,F,S)); sb=np.memmap(NEW/'signbits.u16',np.uint16,'r',shape=(N,F)); pr=np.memmap(NEW/'post_res_terms.u16',np.uint16,'r+',shape=(npost,S)); ps=np.memmap(NEW/'post_signbits.u16',np.uint16,'r+',shape=(npost,)) + block=500_000 + for x in range(a,b,block): + y=min(b,x+block); fp=np.asarray(bo[x:y],np.uint32); docs=fp//F; slots=(fp%F).astype(np.uint8); pr[x:y]=rt[docs,slots]; ps[x:y]=sb[docs,slots] + pr.flush(); ps.flush(); return a,b,time.time()-t + +if __name__=='__main__': + if not (NEW/'post_res_terms.u16').exists(): np.memmap(NEW/'post_res_terms.u16',np.uint16,'w+',shape=(npost,S)).flush() + if not (NEW/'post_signbits.u16').exists(): np.memmap(NEW/'post_signbits.u16',np.uint16,'w+',shape=(npost,)).flush() + # create symlinks to geometry-independent structures + for name in ['branch_offsets.npy','post_doc.u32','post_membership.f32','doc_lengths.u16','support_all_indptr.u32','support_all.u16','meta.json']: + dst=NEW/name + if not dst.exists(): dst.symlink_to(OLD/name) + bounds=np.linspace(0,npost,13,dtype=np.int64); chunks=[(int(bounds[i]),int(bounds[i+1])) for i in range(12)] + t=time.time(); + with ProcessPoolExecutor(max_workers=3,mp_context=mp.get_context('spawn')) as ex: + fs=[ex.submit(job,a,b) for a,b in chunks] + for k,fu in enumerate(as_completed(fs),1): + a,b,sec=fu.result(); print(f'[{k:02d}/12] {a:,}:{b:,} sec={sec:.1f}',flush=True) + print('REORDER DONE npost',npost,'sec',time.time()-t,flush=True) diff --git a/experiments/msmarco_scale/msmarco_scale_exact_vocab.py b/experiments/msmarco_scale/msmarco_scale_exact_vocab.py new file mode 100644 index 0000000000000000000000000000000000000000..d1510d9dd870cb0fdba9269b453fc7280821458e --- /dev/null +++ b/experiments/msmarco_scale/msmarco_scale_exact_vocab.py @@ -0,0 +1,64 @@ +from __future__ import annotations +import gzip,json,pickle,time,re +from pathlib import Path +from concurrent.futures import ProcessPoolExecutor, as_completed +import numpy as np +from sklearn.feature_extraction.text import CountVectorizer + +ROOT=Path('/mnt/data'); OUT=ROOT/'msmarco_scale_work'; EXACT=OUT/'exact_candidate_counts'; EXACT.mkdir(parents=True,exist_ok=True) +WORKERS=3; N_DOCS=8_841_823; FINAL_K=50_000 +pat=re.compile(r'corpus_(\d{4})') + +def shard_paths(): + out={} + for p in ROOT.glob('corpus_*.jsonl*.gz'): + m=pat.search(p.name) + if m: out[int(m.group(1))]=p + return [out[i] for i in sorted(out)] + +def load_candidates(): + with gzip.open(OUT/'global_candidates_200k.pkl.gz','rb') as g: cand=pickle.load(g) + # Candidate vocabulary MUST be alphabetically indexed before the sklearn-style + # max_features frequency limit is applied. + terms=sorted([t for t,_ in cand]) + return terms,{t:i for i,t in enumerate(terms)} + +def one(arg): + sid,p=arg; dst=EXACT/f'counts_{sid:04d}.npz' + if dst.exists(): return sid,'cached' + terms,vocab=load_candidates() + 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() + tf=np.asarray(X.sum(axis=0)).ravel().astype(np.int64) + # exact document frequency among candidate terms + X.data[:] = 1 + df=np.asarray(X.sum(axis=0)).ravel().astype(np.int64) + np.savez(dst,tf=tf,df=df) + return sid, X.nnz + +if __name__=='__main__': + terms,vocab=load_candidates(); M=len(terms); print('exact candidate terms',M,flush=True) + paths=shard_paths(); t0=time.time() + with ProcessPoolExecutor(max_workers=WORKERS) as ex: + futs={ex.submit(one,(i,p)):i for i,p in enumerate(paths)}; done=0 + for fut in as_completed(futs): + sid,x=fut.result(); done+=1; print(f'[{done:02d}/36] shard {sid:04d}: {x}',flush=True) + print('pass seconds',time.time()-t0,flush=True) + tf=np.zeros(M,np.int64); df=np.zeros(M,np.int64) + for sid in range(36): + z=np.load(EXACT/f'counts_{sid:04d}.npz'); tf+=z['tf']; df+=z['df'] + # sklearn CountVectorizer(max_features=K) indexes features alphabetically first, + # then takes (-tf).argsort()[:K]. Replicate that selection. + keep=(-tf).argsort()[:FINAL_K] + keep=np.sort(keep) # final vocabulary coordinates remain alphabetical + final_terms=np.asarray(terms,dtype=object)[keep] + final_tf=tf[keep]; final_df=df[keep] + idf=(np.log((1.0+N_DOCS)/(1.0+final_df.astype(np.float64)))+1.0).astype(np.float32) + with gzip.open(OUT/'final_vocab_50k.pkl.gz','wb',compresslevel=1) as g: + pickle.dump({'terms':final_terms,'tf':final_tf,'df':final_df,'idf':idf,'N':N_DOCS},g,protocol=5) + print('final vocab',len(final_terms), 'df range',int(final_df.min()),int(final_df.max()),flush=True) + print('top tf terms',sorted(zip(final_terms.tolist(),final_tf.tolist()), key=lambda x:x[1], reverse=True)[:20],flush=True) diff --git a/experiments/msmarco_scale/msmarco_scale_vocab.py b/experiments/msmarco_scale/msmarco_scale_vocab.py new file mode 100644 index 0000000000000000000000000000000000000000..5e08d87936308b663ea82c7a7b69d12ff166e3d0 --- /dev/null +++ b/experiments/msmarco_scale/msmarco_scale_vocab.py @@ -0,0 +1,66 @@ +from __future__ import annotations +import gzip, json, pickle, time, re +from pathlib import Path +from concurrent.futures import ProcessPoolExecutor, as_completed +from collections import Counter +import numpy as np +from sklearn.feature_extraction.text import CountVectorizer + +ROOT=Path('/mnt/data') +OUT=ROOT/'msmarco_scale_work' +LOC=OUT/'local_vocab' +LOC.mkdir(parents=True,exist_ok=True) +LOCAL_K=150_000 +WORKERS=3 +pat=re.compile(r'corpus_(\d{4})') + +def shard_paths(): + out={} + for p in ROOT.glob('corpus_*.jsonl*.gz'): + m=pat.search(p.name) + if m: out[int(m.group(1))]=p + return [out[i] for i in sorted(out)] + +def process_one(arg): + sid,p=arg + dst=LOC/f'vocab_{sid:04d}.pkl.gz' + if dst.exists(): return sid, 'cached', dst.stat().st_size + t=time.time(); 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(max_features=LOCAL_K,min_df=1,lowercase=True, + token_pattern=r'(?u)\b\w\w+\b',dtype=np.int32) + X=cv.fit_transform(texts) + terms=cv.get_feature_names_out() + tf=np.asarray(X.sum(axis=0)).ravel().astype(np.int64) + with gzip.open(dst,'wb',compresslevel=1) as g: + pickle.dump((terms,tf),g,protocol=5) + return sid, time.time()-t, dst.stat().st_size + +if __name__=='__main__': + paths=shard_paths() + assert len(paths)==36, len(paths) + print('PASS1 local heavy hitters: shards=',len(paths),'workers=',WORKERS,flush=True) + t0=time.time() + with ProcessPoolExecutor(max_workers=WORKERS) as ex: + futs={ex.submit(process_one,(i,p)):i for i,p in enumerate(paths)} + done=0 + for fut in as_completed(futs): + sid,secs,sz=fut.result(); done+=1 + print(f'[{done:02d}/36] shard {sid:04d}: {secs} file={sz/2**20:.1f} MiB',flush=True) + print('local pass seconds',time.time()-t0,flush=True) + + print('MERGE local candidates',flush=True) + c=Counter() + for sid in range(36): + with gzip.open(LOC/f'vocab_{sid:04d}.pkl.gz','rb') as g: + terms,tf=pickle.load(g) + c.update(dict(zip(terms.tolist(),tf.tolist()))) + if sid%4==3: print(' merged',sid+1,'union',len(c),flush=True) + cand=c.most_common(200_000) + with gzip.open(OUT/'global_candidates_200k.pkl.gz','wb',compresslevel=1) as g: + pickle.dump(cand,g,protocol=5) + print('candidate union',len(c),'saved',len(cand),flush=True) + print('top20',cand[:20],flush=True) diff --git a/experiments/msmarco_scale/msmarco_semantic_coord_features.py b/experiments/msmarco_scale/msmarco_semantic_coord_features.py new file mode 100644 index 0000000000000000000000000000000000000000..c2219f73c097863d02b54019c808a01b9138ebe0 --- /dev/null +++ b/experiments/msmarco_scale/msmarco_semantic_coord_features.py @@ -0,0 +1,46 @@ +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'; idx=b.idx; set_num_threads(5); KSEM=m.SEMK +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 contains(ids,a,bb,t): + lo=np.int64(a); hi=np.int64(bb) + while lo0: cnt+=1.; mx=max(mx,local) + total += local + ssum[z]=total; qcount[z]=cnt; smax[z]=mx + return ssum,qcount,smax +shape=docs.shape; SS=np.zeros(shape,np.float32); QC=np.zeros(shape,np.float32); MX=np.zeros(shape,np.float32); QT=np.zeros(len(qids),np.int16); times=[]; errs=[] +# warmup dummy +_=semcoord(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.array([0],np.int32),np.array([1],np.float32),np.full((1,KSEM),-1,np.int32),np.zeros((1,KSEM),np.float32)) +for i,qid in enumerate(qids): + k=int(valid[i]); + if not k:continue + q=idx.query_vec(texts[qid]); qt=q.indices.astype(np.int32); qa=q.data.astype(np.float32); QT[i]=len(qt); nbr=np.full((len(qt),KSEM),-1,np.int32); nw=np.zeros((len(qt),KSEM),np.float32) + for u,(t,amp) in enumerate(zip(qt,qa)): + a,bb=idx.A.indptr[t],idx.A.indptr[t+1]; nb=idx.A.indices[a:bb][:KSEM]; sv=idx.A.data[a:bb][:KSEM]; l=len(nb); nbr[u,:l]=nb; nw[u,:l]=np.float32(amp)*sv*idx.idf[nb] + t0=time.perf_counter(); ss,qc,mx=semcoord(docs[i,:k],idx.sup_ip,idx.sup_ids,qt,qa,nbr,nw); times.append((time.perf_counter()-t0)*1000); SS[i,:k]=ss; QC[i,:k]=qc; MX[i,:k]=mx; errs.append(float(np.max(np.abs(ss-z['sem'][i,:k])))) + if (i+1)%200==0:print(i+1,'median',float(np.median(times)),'max_sem_err',max(errs),flush=True) +np.savez_compressed(OUT/'semantic_coord_features.npz',qids=np.asarray(qids),valid=valid,sem_sum=SS,sem_qcount=QC,sem_maxterm=MX,qterms=QT) +meta={'protocol':'fixed eta=1 P=2000 validation pools; semantic support decomposed by original query term using existing A graph and binary support only','median_ms':float(np.median(times)),'p95_ms':float(np.percentile(times,95)),'max_sem_reconstruction_error':max(errs)}; json.dump(meta,open(OUT/'semantic_coord_meta.json','w'),indent=2); print('DONE',meta,flush=True) diff --git a/experiments/msmarco_scale/msmarco_semcoord_best_dev.py b/experiments/msmarco_scale/msmarco_semcoord_best_dev.py new file mode 100644 index 0000000000000000000000000000000000000000..3ba797f89706e5494b6386db35b58655bd636e53 --- /dev/null +++ b/experiments/msmarco_scale/msmarco_semcoord_best_dev.py @@ -0,0 +1,80 @@ +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_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); FINAL_B=np.float32(0.1); LEX_ALPHA=np.float32(0.25); WLEX=np.float32(4.0); SEM_ALPHA=np.float32(0.5); WSEM=np.float32(1.0); KSEM=m.SEMK +set_num_threads(5) +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 contains(ids,a,bb,t): + lo=np.int64(a); hi=np.int64(bb) + while lo0: cnt+=1.0 + total += local + ssum[z]=total; qcount[z]=cnt + return ssum,qcount +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: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); oldlex,_=m.score_support_pool(ud,idx.sup_ip,idx.sup_ids,lexvec,zero,idx.dl,idx.avgdl) + sel=topk_desc(m.zscore(tail)+ETA*m.zscore(oldlex),P); dd=ud[sel]; ts=tail[sel] + lx,qc=selected_lex_features(dd,idx.sup_ip,idx.sup_ids,lexvec,idx.dl,idx.avgdl); lcov=qc/max(1,len(q.indices)); ladj=lx*np.power(np.maximum(lcov,1e-6),LEX_ALPHA) + nbr=np.full((len(q.indices),KSEM),-1,np.int32); nw=np.zeros((len(q.indices),KSEM),np.float32) + for u,(t,amp) in enumerate(zip(q.indices,q.data)): + a,bb=idx.A.indptr[t],idx.A.indptr[t+1]; nb=idx.A.indices[a:bb][:KSEM]; sv=idx.A.data[a:bb][:KSEM]; l=len(nb); nbr[u,:l]=nb; nw[u,:l]=np.float32(amp)*sv*idx.idf[nb] + ssum,sqc=semcoord(dd,idx.sup_ip,idx.sup_ids,nbr,nw); scov=sqc/max(1,len(q.indices)); sadj=ssum*np.power(np.maximum(scov,1e-6),SEM_ALPHA) + fin=m.zscore(ts)+WLEX*m.zscore(ladj)+WSEM*m.zscore(sadj); oo=np.argsort(fin)[::-1][:100] + return [int(x) for x in dd[oo]],ud,sel +_=selected_lex_features(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.zeros(M,np.float32),idx.dl,idx.avgdl); _=semcoord(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.full((1,KSEM),-1,np.int32),np.zeros((1,KSEM),np.float32)) +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); _=prepare(texts[ids[0]]) +run={}; times=[]; routehit=poolhit=den=0; cands=[] +for z,qid in enumerate(ids): + t=time.perf_counter(); out=prepare(texts[qid]); times.append((time.perf_counter()-t)*1000) + if out is None: run[qid]=[]; continue + rank,ud,sel=out; run[qid]=rank; cands.append(len(ud)); rels=[int(d) for d,r in qrels[qid].items() if r>0]; den+=len(rels); pooldocs=set(map(int,ud[sel].tolist())) + for d in rels: + kk=np.searchsorted(ud,d); ok=kkk else np.arange(n); return ii[np.argsort(sc[ii])[::-1]] +def lexical(i,k): + ratio=(LF[i,:k]-.8)/.2; lx=RAW[i,:k]/np.maximum(.9+.1*ratio,1e-6); cov=LQC[i,:k]/max(1,LQT[i]); return lx*np.power(np.maximum(cov,1e-6),.25) +def evalx(name,fn): + run={} + for i,qid in enumerate(qids): + k=valid[i]; oo=top100(fn(i,k)); 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('base_sem_raw_.3',lambda i,k:Z(T[i,:k])+4*Z(lexical(i,k))+.3*Z(SEM[i,:k]))) +# semantic coverage-adjusted sum +for a in [.125,.25,.5,1.,1.5,2.]: + for ws in [.1,.2,.3,.5,.75,1.,1.5]: + rows.append(evalx(f'semcoord_a{a}_w{ws}',lambda i,k,a=a,ws=ws: Z(T[i,:k])+4*Z(lexical(i,k))+ws*Z(SEM[i,:k]*np.power(np.maximum(SQC[i,:k]/max(1,SQT[i]),1e-6),a)))) +# separate semantic coverage bonus +for ws in [.1,.2,.3,.5]: + for wc in [-1.,-.5,-.25,.1,.25,.5,1.,2.]: + rows.append(evalx(f'semraw_w{ws}_cov{wc}',lambda i,k,ws=ws,wc=wc: Z(T[i,:k])+4*Z(lexical(i,k))+ws*Z(SEM[i,:k])+wc*(SQC[i,:k]/max(1,SQT[i])))) +# max-per-query-term semantic evidence as extra confidence +for wm in [-.5,-.25,.1,.25,.5,1.]: rows.append(evalx(f'semmax_{wm}',lambda i,k,wm=wm: Z(T[i,:k])+4*Z(lexical(i,k))+.3*Z(SEM[i,:k])+wm*Z(SMX[i,:k]))) +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; final lexical structure b=.1 alpha=.25 wl4; semantic support decomposed by original query-term coverage using current graph only','baseline':next(r for r in rows if r['name']=='base_sem_raw_.3'),'best':rows[0],'top25':rows[:25],'n_models':len(rows)}; json.dump(out,open(OUT/'semantic_coord_sweep.json','w'),indent=2); print('BEST',rows[0]); print('TOP10'); [print(r) for r in rows[:10]] diff --git a/experiments/msmarco_scale/msmarco_structural_157_dev.py b/experiments/msmarco_scale/msmarco_structural_157_dev.py new file mode 100644 index 0000000000000000000000000000000000000000..78ff1401566bedf96d66259c2796e27709f8a39c --- /dev/null +++ b/experiments/msmarco_scale/msmarco_structural_157_dev.py @@ -0,0 +1,63 @@ +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_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); FINAL_B=np.float32(0.1); ALPHA=np.float32(0.25); WLEX=np.float32(5.0); WSEM=np.float32(0.75) +set_num_threads(5) + +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_final_features(dd,ip,ids,lexvec,semvec,dl,avgdl): + n=len(dd); lx=np.zeros(n,np.float32); sm=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; s=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 + s+=semvec[t] + ratio=float(dl[d])/avgdl; den=(1.0-FINAL_B)+FINAL_B*ratio + lx[z]=raw/(den if den>0 else 1.0); sm[z]=s; qc[z]=c + return lx,sm,qc + +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: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); oldlex,_=m.score_support_pool(ud,idx.sup_ip,idx.sup_ids,lexvec,zero,idx.dl,idx.avgdl) + sel=topk_desc(m.zscore(tail)+ETA*m.zscore(oldlex),P); dd=ud[sel]; ts=tail[sel] + 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] + lx,sm,qc=selected_final_features(dd,idx.sup_ip,idx.sup_ids,lexvec,semvec,idx.dl,idx.avgdl) + cov=qc/max(1,len(q.indices)); ladj=lx*np.power(np.maximum(cov,1e-6),ALPHA) + fin=m.zscore(ts)+WLEX*m.zscore(ladj)+WSEM*m.zscore(sm); oo=np.argsort(fin)[::-1][:100] + return [int(x) for x in dd[oo]],ud,sel + +_=selected_final_features(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.zeros(M,np.float32),np.zeros(M,np.float32),idx.dl,idx.avgdl) +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) +_=prepare(texts[ids[0]]) +run={}; times=[]; routehit=poolhit=den=0; cands=[] +for z,qid in enumerate(ids): + t=time.perf_counter(); out=prepare(texts[qid]); times.append((time.perf_counter()-t)*1000) + if out is None: run[qid]=[]; continue + rank,ud,sel=out; run[qid]=rank; cands.append(len(ud)); rels=[int(d) for d,r in qrels[qid].items() if r>0]; den+=len(rels); pooldocs=set(map(int,ud[sel].tolist())) + for d in rels: + kk=np.searchsorted(ud,d); ok=kk0: raw+=v; c+=1.0 + s+=semvec[t] + ratio=float(dl[d])/avgdl; den=(1.0-FINAL_B)+FINAL_B*ratio + lx[z]=raw/(den if den>0 else 1.0); sm[z]=s; qc[z]=c + return lx,sm,qc + +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: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); oldlex,_=m.score_support_pool(ud,idx.sup_ip,idx.sup_ids,lexvec,zero,idx.dl,idx.avgdl) + sel=topk_desc(m.zscore(tail)+ETA*m.zscore(oldlex),P); dd=ud[sel]; ts=tail[sel] + 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] + lx,sm,qc=selected_final_features(dd,idx.sup_ip,idx.sup_ids,lexvec,semvec,idx.dl,idx.avgdl) + cov=qc/max(1,len(q.indices)); ladj=lx*np.power(np.maximum(cov,1e-6),ALPHA) + fin=m.zscore(ts)+WLEX*m.zscore(ladj)+WSEM*m.zscore(sm); oo=np.argsort(fin)[::-1][:100] + return [int(x) for x in dd[oo]],ud,sel + +_=selected_final_features(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.zeros(M,np.float32),np.zeros(M,np.float32),idx.dl,idx.avgdl) +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) +_=prepare(texts[ids[0]]) +run={}; times=[]; routehit=poolhit=den=0; cands=[] +for z,qid in enumerate(ids): + t=time.perf_counter(); out=prepare(texts[qid]); times.append((time.perf_counter()-t)*1000) + if out is None: run[qid]=[]; continue + rank,ud,sel=out; run[qid]=rank; cands.append(len(ud)); rels=[int(d) for d,r in qrels[qid].items() if r>0]; den+=len(rels); pooldocs=set(map(int,ud[sel].tolist())) + for d in rels: + kk=np.searchsorted(ud,d); ok=kk0 + NPOS[i]=max(1,sum(float(r)>0 for r in qrels[qid].values())) + ideal=sorted(grades,reverse=True)[:10]; IDCG[i]=sum((2**r-1)/math.log2(j+2) for j,r in enumerate(ideal)) or 1.0 +# transforms +ZT=np.zeros_like(T); ZL=np.zeros_like(L); ZS=np.zeros_like(S); PT=np.zeros_like(T); PL=np.zeros_like(L); PS=np.zeros_like(S); RRT=np.zeros_like(T); RRL=np.zeros_like(L); RRS=np.zeros_like(S) +for i,k in enumerate(valid): + if not k: continue + for X,Z,PCT,RR in [(T,ZT,PT,RRT),(L,ZL,PL,RRL),(S,ZS,PS,RRS)]: + x=X[i,:k].astype(np.float64); sd=x.std(); Z[i,:k]=0 if sd<1e-8 else ((x-x.mean())/(sd+1e-8)).astype(np.float32) + r=rankdata(-x,method='average').astype(np.float32); RR[i,:k]=r; PCT[i,:k]=(k-r)/max(1,k-1) +# invalid trailing slots: force score low in evaluator by mask +VALID=np.arange(P)[None,:] < valid[:,None] +disc10=(1/np.log2(np.arange(2,12))).astype(np.float64) + +def evaluate(name, score): + sc=np.asarray(score,np.float32).copy(); sc[~VALID]=-np.inf + # top 100 sorted + ix=np.argpartition(sc,-100,axis=1)[:,-100:] + vals=np.take_along_axis(sc,ix,axis=1); ord=np.argsort(vals,axis=1)[:,::-1]; top100=np.take_along_axis(ix,ord,axis=1) + rel100=np.take_along_axis(REL,top100,axis=1); pos100=rel100>0; rel10=rel100[:,:10]; pos10=pos100[:,:10] + dcg=((2.0**rel10-1.0)*disc10).sum(axis=1); nd=(dcg/IDCG).mean() + any10=pos10.any(axis=1); first=np.argmax(pos10,axis=1); rr=np.where(any10,1.0/(first+1),0.0).mean() + h10=pos10.sum(axis=1); h100=pos100.sum(axis=1) + return {'name':name,'nDCG@10':float(nd),'MRR@10':float(rr),'P@10':float((h10/10).mean()),'R@10':float((h10/NPOS).mean()),'R@100':float((h100/NPOS).mean()),'Hit@10':float(any10.mean()),'Hit@100':float(pos100.any(axis=1).mean()),'n_queries':nq} +rows=[] +def add(name,score): + r=evaluate(name,score); rows.append(r); print(name,round(r['nDCG@10'],6),round(r['MRR@10'],6),round(r['R@100'],6),flush=True) + +add('baseline_z_1_4_.1',ZT+4*ZL+.1*ZS) +# robust clip: focused grid +for c in [0.75,1.,1.5,2.,3.,4.]: + for wl in [3.,4.,5.,6.,8.]: + for ws in [0.,.1,.25]: add(f'clip_c{c}_wl{wl}_ws{ws}',np.clip(ZT,-c,c)+wl*np.clip(ZL,-c,c)+ws*np.clip(ZS,-c,c)) +# tanh +for ss in [.75,1.,1.5,2.,3.]: + for wl in [3.,4.,5.,6.,8.]: + for ws in [0.,.1,.25]: add(f'tanh_s{ss}_wl{wl}_ws{ws}',np.tanh(ZT/ss)+wl*np.tanh(ZL/ss)+ws*np.tanh(ZS/ss)) +# percentile +for wt in [.25,.5,1.,2.]: + for wl in [1.,2.,4.,8.,12.]: + for ws in [0.,.1,.25,.5]: add(f'percent_wt{wt}_wl{wl}_ws{ws}',wt*PT+wl*PL+ws*PS) +# RRF focused +for K in [10.,30.,60.,100.,200.]: + for wt in [.5,1.,2.]: + for wl in [1.,2.,4.,8.]: + for ws in [0.,.1,.25,.5]: add(f'rrf_K{int(K)}_wt{wt}_wl{wl}_ws{ws}',wt/(K+RRT)+wl/(K+RRL)+ws/(K+RRS)) +# interactions on z: lexical-tail agreement and absolute gaps +for inter in [-1.,-.5,-.25,.25,.5,1.]: + for wl in [3.,4.,5.]: + add(f'zprod_i{inter}_wl{wl}',ZT+wl*ZL+.1*ZS+inter*(ZT*ZL)) +# min/consensus bonus using percentiles +for c in [.25,.5,1.,2.]: + for wl in [2.,4.,6.]: add(f'consensus_min_c{c}_wl{wl}',PT+wl*PL+.1*PS+c*np.minimum(PT,PL)) +rows.sort(key=lambda r:(r['nDCG@10'],r['MRR@10'],r['R@100']),reverse=True) +out={'protocol':'fixed eta=1 P=2000 validation pools; structural fusion only, no index/candidate changes','baseline':next(x for x in rows if x['name']=='baseline_z_1_4_.1'),'best':rows[0],'top30':rows[:30],'n_formulas':len(rows)} +json.dump(out,open(OUT/'structural_fusion_fast.json','w'),indent=2) +print('=== BEST ==='); print(json.dumps(rows[0],indent=2)); print('TOP10'); [print(r) for r in rows[:10]] diff --git a/experiments/msmarco_scale/msmarco_structural_fusion_sweep.py b/experiments/msmarco_scale/msmarco_structural_fusion_sweep.py new file mode 100644 index 0000000000000000000000000000000000000000..0875f41366030896e66a8ee20280af8035ed1080 --- /dev/null +++ b/experiments/msmarco_scale/msmarco_structural_fusion_sweep.py @@ -0,0 +1,90 @@ +from __future__ import annotations +import sys, json, math, time +from pathlib import Path +import numpy as np +import pandas as pd +from scipy.stats import rankdata +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) +qids=[str(x) for x in z['qids'].tolist()]; valid=z['valid']; docs=z['docs']; tail=z['tail']; lex=z['lex']; sem=z['sem'] +qrels=m.qrels_from_tsv(ROOT/'train.tsv',qids,positive_only=True) + +# Per-query transformed arrays cached in RAM. 1000 x 2000 float32 each. +NQ=len(qids); P=docs.shape[1] +ZT=np.zeros((NQ,P),np.float32); ZL=np.zeros_like(ZT); ZS=np.zeros_like(ZT) +PT=np.zeros_like(ZT); PL=np.zeros_like(ZT); PS=np.zeros_like(ZT) +RRT=np.zeros_like(ZT); RRL=np.zeros_like(ZT); RRS=np.zeros_like(ZT) +for i in range(NQ): + k=int(valid[i]) + if not k: continue + for raw,outz,outp,outr in [(tail[i,:k],ZT[i,:k],PT[i,:k],RRT[i,:k]),(lex[i,:k],ZL[i,:k],PL[i,:k],RRL[i,:k]),(sem[i,:k],ZS[i,:k],PS[i,:k],RRS[i,:k])]: + outz[:] = m.zscore(raw) + # average rank under ties, best score rank=1 + r=rankdata(-np.asarray(raw,dtype=np.float64), method='average') + # percentile quality: best near 1, worst near 0 + outp[:] = (k-r)/(max(1,k-1)) + outr[:] = r + if (i+1)%200==0: print('transform',i+1,flush=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_formula(name, fn): + run={} + for i,qid in enumerate(qids): + k=int(valid[i]); + if not k: run[qid]=[]; continue + sc=fn(i,k) + oo=top100(sc) + run[qid]=[int(x) for x in docs[i,oo]] + met=m.eval_run(run,qrels); return {'name':name,**met} + +rows=[] +# exact baseline +rows.append(eval_formula('baseline_z_1_4_.1', lambda i,k: ZT[i,:k]+4*ZL[i,:k]+.1*ZS[i,:k])) + +# 1) clipped-z robust fusion. Preserve lexical dominance but sweep saturation. +for c in [0.5,1.0,1.5,2.0,3.0,4.0,6.0]: + for wl in [2.0,3.0,4.0,5.0,6.0,8.0]: + for ws in [0.0,0.05,0.1,0.25]: + rows.append(eval_formula(f'clip_c{c}_wl{wl}_ws{ws}', lambda i,k,c=c,wl=wl,ws=ws: np.clip(ZT[i,:k],-c,c)+wl*np.clip(ZL[i,:k],-c,c)+ws*np.clip(ZS[i,:k],-c,c))) + +# 2) tanh saturation. scale controls saturation speed. +for s in [0.5,1.0,2.0,4.0]: + for wl in [2.0,3.0,4.0,5.0,6.0,8.0]: + for ws in [0.0,0.1,0.25]: + rows.append(eval_formula(f'tanh_s{s}_wl{wl}_ws{ws}', lambda i,k,s=s,wl=wl,ws=ws: np.tanh(ZT[i,:k]/s)+wl*np.tanh(ZL[i,:k]/s)+ws*np.tanh(ZS[i,:k]/s))) + +# 3) percentile/Borda fusion (tie-aware) +for wt in [0.25,0.5,1.0,2.0]: + for wl in [1.0,2.0,4.0,8.0]: + for ws in [0.0,0.1,0.25,0.5,1.0]: + rows.append(eval_formula(f'percent_wt{wt}_wl{wl}_ws{ws}', lambda i,k,wt=wt,wl=wl,ws=ws: wt*PT[i,:k]+wl*PL[i,:k]+ws*PS[i,:k])) + +# 4) Reciprocal rank fusion, tie-aware ranks. +for K in [10.,20.,50.,100.,200.,500.]: + for wt in [0.5,1.0,2.0]: + for wl in [1.0,2.0,4.0,8.0]: + for ws in [0.0,0.1,0.25,0.5,1.0]: + rows.append(eval_formula(f'rrf_K{int(K)}_wt{wt}_wl{wl}_ws{ws}', lambda i,k,K=K,wt=wt,wl=wl,ws=ws: wt/(K+RRT[i,:k])+wl/(K+RRL[i,:k])+ws/(K+RRS[i,:k]))) + +# 5) Agreement/product-like: weighted log percentile with epsilon, promotes candidates jointly strong. +for eps in [0.01,0.05,0.1,0.2]: + for wt in [0.25,0.5,1.0]: + for wl in [1.0,2.0,4.0]: + rows.append(eval_formula(f'logrank_eps{eps}_wt{wt}_wl{wl}', lambda i,k,eps=eps,wt=wt,wl=wl: wt*np.log(eps+PT[i,:k])+wl*np.log(eps+PL[i,:k])+.1*np.log(eps+PS[i,:k]))) + +rows.sort(key=lambda r:(r['nDCG@10'],r['MRR@10'],r['R@100']), reverse=True) +out={'protocol':'fixed eta=1 P=2000 pools; deterministic 1000 TRAIN validation; no index/candidate changes; structural decision-rule sweep only','baseline':next(r for r in rows if r['name']=='baseline_z_1_4_.1'),'best':rows[0],'top25':rows[:25],'n_formulas':len(rows)} +json.dump(out,open(OUT/'structural_fusion_sweep.json','w'),indent=2) +print('BASE',out['baseline']) +print('BEST',out['best']) +print('TOP10') +for r in rows[:10]: print(r) +print('N',len(rows)) diff --git a/experiments/msmarco_scale/msmarco_tail_weight_sweep.py b/experiments/msmarco_scale/msmarco_tail_weight_sweep.py new file mode 100644 index 0000000000000000000000000000000000000000..af4aefba35bd1a886cda3bba66c6c86710e0b9d5 --- /dev/null +++ b/experiments/msmarco_scale/msmarco_tail_weight_sweep.py @@ -0,0 +1,27 @@ +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) +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); qrels=m.qrels_from_tsv(ROOT/'train.tsv',qids,positive_only=True) +WTS=[-1.,-.5,-.25,0.,.1,.25,.5,.75,1.,1.25,1.5,2.,3.,4.]; WLS=[2.,3.,4.,5.,6.,8.]; WSS=[0.,.1,.2,.3,.5,.75] +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 eval_cfg(wt,wl,ws): + run={} + for i,qid in enumerate(qids): + k=valid[i]; 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); sc=wt*Z(T[i,:k])+wl*Z(ladj)+ws*Z(SM[i,:k]); oo=top100(sc); run[qid]=[int(x) for x in docs[i,oo]] + return m.eval_run(run,qrels) +# stage1 vary tail at current lexical/sem +rows=[] +for wt in WTS: + met=eval_cfg(wt,4.,.3); r={'wt':wt,'wl':4.,'ws':.3,**met}; rows.append(r); print('T',r,flush=True) +bestwt=max(rows,key=lambda r:(r['nDCG@10'],r['MRR@10'],r['R@100']))['wt']; print('BESTWT',bestwt,flush=True) +# stage2 tune ratios around selected tail; avoid huge cartesian by using chosen wt only +for wl in WLS: + for ws in WSS: + met=eval_cfg(bestwt,wl,ws); r={'wt':bestwt,'wl':wl,'ws':ws,**met}; rows.append(r); print('W',r,flush=True) +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; final b=.1 coordination alpha=.25; tune final geometry/lexical/semantic trust only','best':rows[0],'top20':rows[:20],'stage1_best_wt':bestwt}; json.dump(out,open(OUT/'tail_weight_sweep.json','w'),indent=2); print('BEST',rows[0]) diff --git a/experiments/msmarco_scale/msmarco_test_baseline_compare.py b/experiments/msmarco_scale/msmarco_test_baseline_compare.py new file mode 100644 index 0000000000000000000000000000000000000000..21ee278516b7fa763ceaaf1b8c55ea82df066207 --- /dev/null +++ b/experiments/msmarco_scale/msmarco_test_baseline_compare.py @@ -0,0 +1,100 @@ +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_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); FINAL_B=np.float32(0.1); ALPHA=np.float32(0.25); WLEX=np.float32(4.0); WSEM=np.float32(0.3); WRARE=np.float32(1.0) +set_num_threads(5) + +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 final_features(dd,ip,ids,qmask,rarerank,idf,semvec,dl,avgdl): + n=len(dd); lx=np.zeros(n,np.float32); sm=np.zeros(n,np.float32); qc=np.zeros(n,np.float32); r3=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.; ss=0.; c=0.; rr3=0. + for k in range(a,bb): + t=int(ids[k]); ss+=semvec[t] + if qmask[t]: + x=float(idf[t]); raw+=x*x; c+=1. + if int(rarerank[t])>0: rr3+=1. + ratio=float(dl[d])/avgdl; den=(1.0-FINAL_B)+FINAL_B*ratio + if den<=0:den=1. + lx[z]=raw/den; sm[z]=ss; qc[z]=c; r3[z]=rr3 + return lx,sm,qc,r3 + +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: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) + # Frozen early rescue: p=1 binary IDF, eta=1, package's weak b=.2 length correction. + lexvec=np.zeros(M,np.float32); lexvec[q.indices]=idx.idf[q.indices]; zero=np.zeros(M,np.float32) + oldlex,_=m.score_support_pool(ud,idx.sup_ip,idx.sup_ids,lexvec,zero,idx.dl,idx.avgdl) + sel=topk_desc(m.zscore(tail)+ETA*m.zscore(oldlex),P); dd=ud[sel]; ts=tail[sel] + 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] + qmask=np.zeros(M,np.uint8); qmask[q.indices]=1; rarerank=np.zeros(M,np.uint8) + ordq=q.indices[np.argsort(idx.idf[q.indices])[::-1]] + for r,t in enumerate(ordq[:3],start=1): rarerank[t]=r + lx,sm,qc,r3=final_features(dd,idx.sup_ip,idx.sup_ids,qmask,rarerank,idx.idf,semvec,idx.dl,idx.avgdl) + cov=qc/max(1,len(q.indices)); ladj=lx*np.power(np.maximum(cov,1e-6),ALPHA); rarecov=r3/max(1,min(3,len(q.indices))) + fin=m.zscore(ts)+WLEX*m.zscore(ladj)+WSEM*m.zscore(sm)+WRARE*m.zscore(rarecov) + oo=np.argsort(fin)[::-1][:1000] + return [int(x) for x in dd[oo]],ud,sel + +def eval_beir(run,qrels): + metrics={'nDCG@10':[],'nDCG@10_expGain_diag':[],'MRR@10':[],'P@10':[],'R@10':[],'R@100':[],'R@1000':[],'Hit@10':[],'Hit@100':[],'Hit@1000':[]} + for qid,qr in qrels.items(): + rank=run.get(qid,[]); pos={int(d) for d,r in qr.items() if float(r)>=2.0}; n=max(1,len(pos)) + h10=sum(d in pos for d in rank[:10]); h100=sum(d in pos for d in rank[:100]); h1000=sum(d in pos for d in rank[:1000]) + metrics['P@10'].append(h10/10); metrics['R@10'].append(h10/n); metrics['R@100'].append(h100/n); metrics['R@1000'].append(h1000/n); metrics['Hit@10'].append(float(h10>0)); metrics['Hit@100'].append(float(h100>0)); metrics['Hit@1000'].append(float(h1000>0)) + rr=0. + for i,d in enumerate(rank[:10],1): + if d in pos: rr=1/i; break + metrics['MRR@10'].append(rr) + obs=[float(qr.get(str(d),qr.get(d,0.0))) for d in rank[:10]] + ideal=sorted([float(r) for r in qr.values()],reverse=True)[:10] + dcg_lin=sum(float(r)/math.log2(i+2) for i,r in enumerate(obs)); idcg_lin=sum(float(r)/math.log2(i+2) for i,r in enumerate(ideal)) + dcg_exp=sum((2.0**float(r)-1.0)/math.log2(i+2) for i,r in enumerate(obs)); idcg_exp=sum((2.0**float(r)-1.0)/math.log2(i+2) for i,r in enumerate(ideal)) + metrics['nDCG@10'].append(dcg_lin/idcg_lin if idcg_lin else 0.0) + metrics['nDCG@10_expGain_diag'].append(dcg_exp/idcg_exp if idcg_exp else 0.0) + return {k:float(np.mean(v)) for k,v in metrics.items()} | {'n_queries':len(qrels)} + +# TEST IDs and full graded qrels (including zero judgments for nDCG ideal ordering). +tdf=pd.read_csv(ROOT/'test.tsv',sep='\t'); ids=[str(x) for x in np.unique(tdf['query-id'].to_numpy())]; del tdf +texts=m.load_query_texts(ids); qrels=m.qrels_from_tsv(ROOT/'test.tsv',ids,positive_only=False) +missing=[q for q in ids if q not in texts] +if missing: raise RuntimeError(f'missing query texts {missing}') +# Warmup excluded. +_=final_features(np.array([0],np.uint32),idx.sup_ip,idx.sup_ids,np.zeros(M,np.uint8),np.zeros(M,np.uint8),idx.idf,np.zeros(M,np.float32),idx.dl,idx.avgdl); _=prepare(texts[ids[0]]) +run={}; times=[]; routehit=poolhit=den=0; cands=[] +for z,qid in enumerate(ids): + t=time.perf_counter(); out=prepare(texts[qid]); times.append((time.perf_counter()-t)*1000) + if out is None: run[qid]=[]; continue + rank,ud,sel=out; run[qid]=rank; cands.append(len(ud)); rels=[int(d) for d,r in qrels[qid].items() if float(r)>=2.0]; den+=len(rels); pooldocs=set(map(int,ud[sel].tolist())) + for d in rels: + kk=np.searchsorted(ud,d); ok=kk top-10` benchmark was produced. + +It is preserved for provenance, not used to generate `RESULTS_FINAL_6DATASETS.md`. Its original one-off scale harness imported `eval_scale_rag` and `opt_two_variants` from an experiment working directory; those two transient modules did not survive as standalone files. The reusable/frozen benchmark implementation is therefore the package code in `geomretrieval/`, especially `geomretrieval/rag_top10.py`, plus the runners in `experiments/beir/` and the full-scale scripts in `experiments/msmarco_scale/`. + +The recovered optimization branch introduced: + +1. O(K) generation-stamp aggregation instead of `np.unique` sorting. +2. A pre-lexical tail gate `min(route_docs, max(10000, 40*P))`. +3. Query-conditioned 16-coordinate residual-code sign matching with default weight `wcode=0.25`. + +Recorded post-benchmark outputs are stored in `results/final_100_to_10/nq_two_optimizations_merged.json` and `hotpotqa_two_optimizations_merged.json`. diff --git a/experiments/postbenchmark_optimizations/final_two_optimizations_ARCHIVE.py b/experiments/postbenchmark_optimizations/final_two_optimizations_ARCHIVE.py new file mode 100644 index 0000000000000000000000000000000000000000..bb8a5896f1a80705d5fc6d07e350b355c057a45b --- /dev/null +++ b/experiments/postbenchmark_optimizations/final_two_optimizations_ARCHIVE.py @@ -0,0 +1,113 @@ +from __future__ import annotations +import sys,time,json,math,argparse,gc +from pathlib import Path +import numpy as np +from numba import njit,set_num_threads +set_num_threads(5) +sys.path.insert(0,'/mnt/data/exp') +import eval_scale_rag as e +from opt_two_variants import FastScaleIndex, agg_stamp + +@njit(cache=True) +def compact_pool_evidence_and_code(docs,rslot,mem,rt,sbits,ev,spanbr,rho,poolmap,poolstamp,token,nmax,qct,qcw,qcbits): + cap=nmax*e.F + mp=np.empty(cap,np.int32);mb=np.empty(cap,np.int32);me=np.empty(cap,np.float32);cm=np.zeros(nmax,np.float32);n=0 + for z in range(len(docs)): + d=np.int64(docs[z]) + if poolstamp[d]!=token: continue + pi=poolmap[d] + if pi<0 or pi>=nmax: continue + u=np.int64(rslot[z]); b=spanbr[u] + mp[n]=pi;mb[n]=b;me[n]=ev[z];n+=1 + bits=np.uint16(sbits[z]);s=0.;den=0. + for a in range(e.S): + qt=np.int64(qct[u,a]) + if qt==65535: continue + w=qcw[u,a];den+=w + for r in range(e.S): + if np.int64(rt[z,r])==qt: + qs=1 if ((qcbits[u]>>a)&1)!=0 else -1 + ds=1 if ((bits>>r)&1)!=0 else -1 + s += w*(1. if qs==ds else -1.) + break + if den>0.: cm[pi]+=mem[z]*rho[u]*(s/den) + return mp[:n],mb[:n],me[:n],cm + +def qcodes_sparse(idx,spans,q,qd,rel): + nr=len(spans);qt=np.full((nr,e.S),65535,np.uint16);qw=np.zeros((nr,e.S),np.float32);qb=np.zeros(nr,np.uint16) + qterms=np.asarray(q.indices,np.int32) + for u,(j,_,_) in enumerate(spans): + rowt=np.asarray(idx.ct[j]);ok=rowt!=e.SENT;cids=rowt[ok].astype(np.int32,copy=False) + cvals=np.asarray(idx.cv[j],np.float32)[ok] + cand=np.unique(np.concatenate([cids,qterms])) + # center lookup only for <=80 coordinates + cvmap={int(t):float(v) for t,v in zip(cids,cvals)} + diff=np.asarray([float(qd[t])-cvmap.get(int(t),0.0) for t in cand],np.float32);aa=np.abs(diff) + if len(cand)>e.S: + ii=np.argpartition(aa,-e.S)[-e.S:];ii=ii[np.argsort(aa[ii])[::-1]] + else:ii=np.argsort(aa)[::-1] + for a,k in enumerate(ii[:e.S]): + t=int(cand[k]);qt[u,a]=t;rr=float(rel[u,t]) if rel[u,t]!=0 else 1.0;qw[u,a]=float(aa[k])*rr + if diff[k]>=0: qb[u]|=np.uint16(1<self.offs[j]] + if not spans:return [],{'total_ms':(time.perf_counter()-t0)*1000,'route_docs':0,'gate_docs':0} + docs=np.concatenate([np.asarray(self.pd[a:b]) for j,a,b in spans]).astype(np.uint32,copy=False) + mem=np.concatenate([np.asarray(self.pm[a:b]) for j,a,b in spans]).astype(np.float32,copy=False) + rt=np.concatenate([np.asarray(self.pr[a:b]) for j,a,b in spans]).astype(np.uint16,copy=False) + sb=np.concatenate([np.asarray(self.ps[a:b]) for j,a,b in spans]).astype(np.uint16,copy=False) + nr=len(spans);cent=np.zeros((nr,e.M),np.float32);rel=np.zeros((nr,e.M),np.float32);rho=np.empty(nr,np.float32);spanbr=np.empty(nr,np.int32);rs=[] + for u,(j,a,b) in enumerate(spans): + spanbr[u]=j;rowt=np.asarray(self.ct[j]);ok=rowt!=e.SENT;ids=rowt[ok].astype(np.int32,copy=False);cent[u,ids]=np.asarray(self.cv[j])[ok] + ra=int(self.rp[j]);rb=int(self.rp[j+1]);rel[u,np.asarray(self.ri[ra:rb],np.int32)]=np.asarray(self.rv[ra:rb]);rho[u]=rd[j];rs.append(np.full(b-a,u,dtype=np.uint8)) + rslot=np.concatenate(rs);ev,cons=e.score_memberships_local(rslot,mem,rt,sb,qd,rho,cent,rel) + # Optimization 1a: O(K) stamp aggregation instead of np.unique sort. + n=agg_stamp(docs,ev,cons,self.stamp,self.taila,self.consa,self.touched,token) + ud=np.asarray(self.touched[:n],np.uint32).copy();tail=(self.taila[ud]+e.LAM_M*self.consa[ud]).astype(np.float32) + # Optimization 1b: small tail gate before whole-chunk lexical scan. + if gate is None: gate=min(len(ud),max(10000,40*int(P))) + if len(ud)>gate: + gi=e.topk_sorted(tail,gate);cand=ud[gi];ct=tail[gi] + else:cand=ud;ct=tail + qlex=np.zeros(e.M,np.float32);qlex[q.indices]=self.idf[q.indices];lex1=e.score_pre(cand,self.ip,self.ids,qlex,self.dl,self.avgdl) + pre=e.zscore(ct)+e.zscore(lex1);sel=e.topk_sorted(pre,P);pooldocs=cand[sel];pooltail=ct[sel] + # exact pool map with stamps + self.poolstamp[pooldocs]=token;self.poolmap[pooldocs]=np.arange(len(pooldocs),dtype=np.int32) + # Optimization 2: query-conditioned full 16-coordinate residual-code match. + qct,qcw,qcb=qcodes_sparse(self,spans,q,qd,rel) + mp,mb,me,cm=compact_pool_evidence_and_code(docs,rslot,mem,rt,sb,ev,spanbr,rho,self.poolmap,self.poolstamp,token,len(pooldocs),qct,qcw,qcb) + semv=np.zeros(e.M,np.float32) + for t,amp in zip(q.indices,q.data): + a,b=self.A.indptr[t],self.A.indptr[t+1];nb=self.A.indices[a:b][:e.SEMK];sv=self.A.data[a:b][:e.SEMK] + if len(nb):semv[nb]+=float(amp)*sv*self.idf[nb] + lex2v=np.zeros(e.M,np.float32);lex2v[q.indices]=self.idf[q.indices]**2;qmask=np.zeros(e.M,np.float32);qmask[q.indices]=1.;rarem=np.zeros(e.M,np.float32);rareidx=q.indices[np.argsort(self.idf[q.indices])[::-1]][:e.RAREK];rarem[rareidx]=1. + p={'q':q,'pooldocs':pooldocs,'pooltail':pooltail,'mem_pool':mp,'mem_branch':mb,'mem_ev':me,'semv':semv,'lex2v':lex2v,'qmask':qmask,'rarem':rarem,'ressem_signed':cm,'route_docs':ud} + r,rtm=self.rank_variant(p,P,wres=wcode,absres=False) + return r,{'total_ms':(time.perf_counter()-t0)*1000,'rank_ms':rtm['rank_ms'],'route_docs':len(ud),'gate_docs':len(cand),'pool_size':len(pooldocs)} + +def full_run(dataset,work,qpath,rpath,P,outfile,gate=None,wcode=.25,start=0,limit=None): + gc.disable() + idx=FinalOptimizedIndex(work,dataset);qr=e.load_qrels(rpath);qids=sorted(qr);qs=e.load_queries(qpath,qids);sub=qids[start:] if limit is None else qids[start:start+limit] + # compile/warm + if sub:idx.search_optimized(qs[sub[0]],P,gate,wcode) + run={};times=[];routes=[];gates=[] + for z,qid in enumerate(sub): + r,t=idx.search_optimized(qs[qid],P,gate,wcode);run[qid]=r;times.append(t['total_ms']);routes.append(t['route_docs']);gates.append(t['gate_docs']) + if (z+1)%250==0: + print(dataset,'done',z+1,'med_ms',float(np.median(times)),'route_med',float(np.median(routes)),flush=True) + Path(outfile+'.checkpoint').write_text(json.dumps({'done':z+1,'run':run,'times':times,'routes':routes,'gates':gates})) + qrs={q:qr[q] for q in sub};m=e.metrics_for(run,qrs);a=np.asarray(times) + m.update({'median_ms':float(np.median(a)),'p95_ms':float(np.percentile(a,95)),'mean_ms':float(np.mean(a)),'qps':float(1000/np.mean(a)),'median_route_docs':float(np.median(routes)),'median_gate_docs':float(np.median(gates)),'P':P,'wcode':wcode,'gate_rule':'min(route,max(10000,40P))' if gate is None else gate}) + out={'dataset':dataset,'metrics':m,'run':run};Path(outfile).write_text(json.dumps(out,indent=2));print(json.dumps(m,indent=2));return out + +if __name__=='__main__': + ap=argparse.ArgumentParser();ap.add_argument('dataset',choices=['nq','hotpot']);ap.add_argument('--limit',type=int,default=None);ap.add_argument('--out',required=True);a=ap.parse_args() + if a.dataset=='nq':full_run('nq','/mnt/data/exp/nq_work','/mnt/data/queries(3).jsonl','/mnt/data/test(3).tsv',100,a.out,limit=a.limit) + else:full_run('hotpot','/mnt/data/exp/hotpot_work','/mnt/data/queries(2).jsonl','/mnt/data/test(2).tsv',500,a.out,limit=a.limit) diff --git a/figures/fig01_positioning_low_cost.png b/figures/fig01_positioning_low_cost.png new file mode 100644 index 0000000000000000000000000000000000000000..667218604d5b5ca35a0160ca4822b509cc2f5e63 --- /dev/null +++ b/figures/fig01_positioning_low_cost.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:19045799bf28fc030a90e71c3c61c8bf02860271aac714468231b78db47c07fe +size 366702 diff --git a/figures/fig02_offline_index_pipeline.png b/figures/fig02_offline_index_pipeline.png new file mode 100644 index 0000000000000000000000000000000000000000..91a58d3552b6f8419a9bdc6f741b481c1cd2e337 --- /dev/null +++ b/figures/fig02_offline_index_pipeline.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:12fe3a942bebe026c4e2429fe93119b0b5a597873c75a760c92fa3bdbeaeedc4 +size 245476 diff --git a/figures/fig03_querytime_pipeline.png b/figures/fig03_querytime_pipeline.png new file mode 100644 index 0000000000000000000000000000000000000000..bac9365c4d35950127574dce6c0b2e77054152d0 --- /dev/null +++ b/figures/fig03_querytime_pipeline.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f6c32ca8583a5e458359ae0f6ca98d28047192a6c9fb74656b75b72a3ee0c962 +size 303290 diff --git a/figures/fig04_storage_budget.png b/figures/fig04_storage_budget.png new file mode 100644 index 0000000000000000000000000000000000000000..32622944c732df8a04eafd821a9a9147fb1f4402 --- /dev/null +++ b/figures/fig04_storage_budget.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f19b3833a423631522d12ab759590a91e17fb09f41cd98af28d9c847d3c065af +size 225928 diff --git a/figures/fig05_query_complexity.png b/figures/fig05_query_complexity.png new file mode 100644 index 0000000000000000000000000000000000000000..1640aa82e278528af55332a6c8e9a44bec13194e --- /dev/null +++ b/figures/fig05_query_complexity.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0e02d5a1d4c1c43771e0c8b913d3d428fb93bbcd4175ed3d7d08696c1771f5d9 +size 238417 diff --git a/figures/fig06_hardware_story.png b/figures/fig06_hardware_story.png new file mode 100644 index 0000000000000000000000000000000000000000..f09b77311884976dc4f2ef51fb3071a019675a04 --- /dev/null +++ b/figures/fig06_hardware_story.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:11ce7608555d17493b24626cf4765102309b08ad66f79f2e37c0020d8313cb16 +size 271458 diff --git a/figures/fig07_shortlist_sweep.png b/figures/fig07_shortlist_sweep.png new file mode 100644 index 0000000000000000000000000000000000000000..07a4b7fded52556f88a2e7ac6780df8274d2985e --- /dev/null +++ b/figures/fig07_shortlist_sweep.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2d253fbe10eb0bd89729d2ae4cadffeb18acc00970937e02879e94a612fe59db +size 203910 diff --git a/figures/fig08_six_dataset_heatmap.png b/figures/fig08_six_dataset_heatmap.png new file mode 100644 index 0000000000000000000000000000000000000000..ea77b246f9831a8654faed86740ec51c52d42f70 --- /dev/null +++ b/figures/fig08_six_dataset_heatmap.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:df9aebd43ae13bbead2d9d5319667d8eef59b76b4c675b3b45b3eb76dff077d6 +size 189811 diff --git a/figures/fig09_scifact_quality_latency.png b/figures/fig09_scifact_quality_latency.png new file mode 100644 index 0000000000000000000000000000000000000000..7abb9df4850f176b586104ac0acb236c790e94d7 --- /dev/null +++ b/figures/fig09_scifact_quality_latency.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:36db863813e83f504d107265747812514882767092284153f086f78f3d94f34c +size 189175 diff --git a/figures/fig10_repository_map.png b/figures/fig10_repository_map.png new file mode 100644 index 0000000000000000000000000000000000000000..4fece6e8cbec8e825e1678693ecfe55bccb2000f --- /dev/null +++ b/figures/fig10_repository_map.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:74f278355a84231cd094d6a75687076aea5eb94100e056db25f566b53232774a +size 235530