| from __future__ import annotations |
| import gzip,json,pickle,time,gc |
| from pathlib import Path |
| import numpy as np |
| from scipy import sparse |
| from sklearn.feature_extraction.text import CountVectorizer |
| from sklearn.preprocessing import normalize |
| from numba import set_num_threads |
| import sys |
| sys.path.insert(0,'/mnt/data') |
| import msmarco_build_geometry as base |
|
|
| ROOT=Path('/mnt/data'); WORK=ROOT/'msmarco_scale_work'; GEOM=WORK/'geometry_uniform1m'; GEOM.mkdir(parents=True,exist_ok=True) |
| N=8_841_823; N_CAL=1_000_000; M=50_000; F=4; B=64; S=16; L=12 |
| TAU=20.; BETA=-.2; EPS=1e-6; GRAPH_TAU=10.; ASSOC_K=64; ROUTE_K=32 |
| SENT=np.uint16(65535); SEED=20260815 |
| set_num_threads(5) |
|
|
| def load_vocab(): |
| with gzip.open(WORK/'final_vocab_50k.pkl.gz','rb') as g: z=pickle.load(g) |
| terms=z['terms'].tolist(); idf=np.asarray(z['idf'],np.float32) |
| return terms,idf,{t:i for i,t in enumerate(terms)} |
|
|
| def shard_path(i): |
| hits=list(ROOT.glob(f'corpus_{i:04d}.jsonl*.gz')); assert len(hits)==1,(i,hits); return hits[0] |
|
|
| def selected_tfidf_shard(sid, wanted_local, vocab, idf): |
| wanted=np.asarray(wanted_local,np.int64) |
| texts=[]; p=0 |
| if wanted.size==0: |
| return sparse.csr_matrix((0,M),dtype=np.float32) |
| with gzip.open(shard_path(sid),'rt',encoding='utf-8') as f: |
| for i,line in enumerate(f): |
| if p>=wanted.size: break |
| if i==wanted[p]: |
| o=json.loads(line); texts.append(((o.get('title') or '')+' '+(o.get('text') or '')).strip()); p+=1 |
| assert p==wanted.size,(sid,p,wanted.size) |
| cv=CountVectorizer(vocabulary=vocab,lowercase=True,token_pattern=r'(?u)\b\w\w+\b',dtype=np.int32) |
| X=cv.transform(texts).tocsr().astype(np.float32); X.data*=idf[X.indices]; normalize(X,norm='l2',axis=1,copy=False); X.sort_indices() |
| return X |
|
|
| def prune_rows(mat,k): return base.prune_rows(mat,k) |
|
|
| if __name__=='__main__': |
| t_all=time.time(); terms,idf,vocab=load_vocab(); np.save(GEOM/'idf.npy',idf) |
| with gzip.open(GEOM/'terms.pkl.gz','wb',compresslevel=1) as g: pickle.dump(terms,g,protocol=5) |
| sp=GEOM/'sample_ids.npy' |
| if sp.exists(): sample=np.load(sp) |
| else: |
| rng=np.random.default_rng(SEED); sample=np.sort(rng.choice(N,size=N_CAL,replace=False).astype(np.int64)); np.save(sp,sample) |
| assert len(sample)==N_CAL and sample[0]>=0 and sample[-1]<N |
| print('UNIFORM GEOMETRY calibration: deterministic 1,000,000-sample across 8,841,823 passages; seed',SEED,flush=True) |
| print(' sample id range',int(sample[0]),int(sample[-1]),'mean',float(sample.mean()),flush=True) |
| xcache=GEOM/'cal_X.npz' |
| if xcache.exists(): |
| X=sparse.load_npz(xcache).tocsr(); print(' X checkpoint loaded',X.shape,X.nnz,flush=True) |
| else: |
| xs=[] |
| for sid in range(36): |
| lo=sid*250_000; hi=min(N,lo+250_000); a=np.searchsorted(sample,lo); b=np.searchsorted(sample,hi); local=sample[a:b]-lo |
| t=time.time(); Xs=selected_tfidf_shard(sid,local,vocab,idf); xs.append(Xs) |
| print(' tfidf selected shard',sid,'n',Xs.shape[0],'nnz',Xs.nnz,'sec',time.time()-t,flush=True) |
| X=sparse.vstack(xs,format='csr'); del xs; gc.collect(); assert X.shape[0]==N_CAL |
| print(' X',X.shape,X.nnz,flush=True); sparse.save_npz(xcache,X,compressed=False); print(' X checkpoint saved',flush=True) |
| |
| t=time.time(); branches,mem,topL=base.topk_memberships(X.indptr.astype(np.int64),X.indices.astype(np.int32),X.data.astype(np.float32),F) |
| print(' memberships sec',time.time()-t,flush=True); np.save(GEOM/'cal_branches.npy',branches); np.save(GEOM/'cal_memberships.npy',mem); np.save(GEOM/'cal_topL.npy',topL) |
| |
| 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) |
| |
| t=time.time(); rt,rs=base.residual_codes(X.indptr.astype(np.int64),X.indices.astype(np.int32),X.data.astype(np.float32),branches,center_terms,center_values,S) |
| print(' residual sec',time.time()-t,flush=True); np.save(GEOM/'cal_res_terms.npy',rt); np.save(GEOM/'cal_res_signs.npy',rs) |
| |
| total_memberships=int(np.sum(branches!=SENT)); gcnt=np.zeros(M,np.float64); gsum=np.zeros(M,np.float64) |
| for d0 in range(0,N_CAL,50_000): |
| tt=rt[d0:d0+50_000].ravel(); zz=rs[d0:d0+50_000].ravel().astype(np.float64); ok=tt!=SENT |
| gcnt += np.bincount(tt[ok].astype(np.int64),minlength=M); gsum += np.bincount(tt[ok].astype(np.int64),weights=zz[ok],minlength=M) |
| ge2=gcnt/max(1,total_memberships); ge1=gsum/max(1,total_memberships); gvar=np.maximum(ge2-ge1*ge1,0.) |
| flat=branches.ravel(); valid=np.flatnonzero(flat!=SENT); order=valid[np.argsort(flat[valid],kind='stable')]; sorted_br=flat[order].astype(np.int64); counts=np.bincount(sorted_br,minlength=M); offs=np.zeros(M+1,np.int64); np.cumsum(counts,out=offs[1:]) |
| f_rt=rt.reshape(N_CAL*F,S); f_rs=rs.reshape(N_CAL*F,S) |
| max_rel=N_CAL*F*S; rel_i=np.memmap(GEOM/'rel_indices.u16',dtype=np.uint16,mode='w+',shape=(max_rel,)); rel_v=np.memmap(GEOM/'rel_data.f32',dtype=np.float32,mode='w+',shape=(max_rel,)); rel_p=np.zeros(M+1,np.uint64); pos_rel=0; t=time.time() |
| for j in range(M): |
| a,b=offs[j],offs[j+1]; mpos=order[a:b]; nj=len(mpos) |
| if nj>0: |
| tj=f_rt[mpos].ravel(); sj=f_rs[mpos].ravel().astype(np.float64); ok=tj!=SENT |
| if np.any(ok): |
| u,inv=np.unique(tj[ok],return_inverse=True); cnt=np.bincount(inv).astype(np.float64); sm=np.bincount(inv,weights=sj[ok]).astype(np.float64) |
| e2=cnt/nj; e1=sm/nj; lv=np.maximum(e2-e1*e1,0.); shr=(cnt/(cnt+TAU))*lv+(TAU/(cnt+TAU))*gvar[u.astype(np.int64)]; w=np.power(shr+EPS,BETA) |
| if len(w) and np.isfinite(w).all() and w.mean()>0: w=w/w.mean() |
| nrel=len(u); rel_i[pos_rel:pos_rel+nrel]=u.astype(np.uint16); rel_v[pos_rel:pos_rel+nrel]=w.astype(np.float32); pos_rel+=nrel |
| rel_p[j+1]=pos_rel |
| if j%5000==0 and j: print(' reliability branch',j,'pairs',pos_rel,flush=True) |
| rel_i.flush(); rel_v.flush(); np.save(GEOM/'rel_indptr.npy',rel_p); np.save(GEOM/'global_sign_var.npy',gvar.astype(np.float32)) |
| with open(GEOM/'rel_meta.json','w') as f: json.dump({'nnz':int(pos_rel),'max_entries':int(max_rel)},f) |
| print(' reliability nnz',pos_rel,'sec',time.time()-t,flush=True) |
| del rt,rs,order,flat,valid,sorted_br,counts,offs,f_rt,f_rs,rel_i,rel_v,rel_p; gc.collect() |
| |
| 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) |
|
|
