| 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) |
| |
| 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)} |
|
|
| |
| 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}') |
| |
| _=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=kk<len(ud) and int(ud[kk])==d; routehit+=int(ok); poolhit+=int(ok and d in pooldocs) |
| print('test',z+1,'/',len(ids),'qid',qid,'ms',times[-1],flush=True) |
| met=eval_beir(run,qrels) |
| result={'protocol':'FINAL TEST ONCE after TRAIN-only five-fold lock; no test tuning','frozen_params':{'preselection_eta':1.0,'preselection_idf_power':1.0,'P':2000,'gamma_tail':0.25,'lambda_M':0.125,'final_idf_power':2.0,'final_length_b':0.1,'coordination_alpha':0.25,'lambda_lex':4.0,'lambda_sem':0.3,'rare_topk':3,'rare_coverage_weight':1.0,'h':0,'S':16},'test_metrics':met,'route_relevant_recall':routehit/max(1,den),'pool_relevant_recall':poolhit/max(1,den),'timing':{'median_ms':float(np.median(times)),'p95_ms':float(np.percentile(times,95)),'mean_ms':float(np.mean(times)),'qps':1000/float(np.mean(times)),'avg_candidate_docs':float(np.mean(cands))},'n_positive_judgments':int(den),'note':'nDCG@10 uses linear graded gain, matching trec_eval/BEIR convention; exponential-gain value retained only as diagnostic.'} |
| out=WORK/'FINAL_TEST_ONCE_results.json'; json.dump(result,open(out,'w'),indent=2); print('FINAL_RESULT',json.dumps(result,indent=2),flush=True); print('SAVED',out,flush=True) |
|
|
