File size: 7,939 Bytes
00f7555 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 | 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<<a)
return qt,qw,qb
class FinalOptimizedIndex(FastScaleIndex):
def search_optimized(self,text,P,gate=None,wcode=.25):
t0=time.perf_counter();self.token+=1;token=self.token
q=self.qvec(text)
if q.nnz==0:return [],{'total_ms':(time.perf_counter()-t0)*1000,'route_docs':0,'gate_docs':0}
qd=np.zeros(e.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 [],{'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)
|