Download 013/iterate.py from Eriksanchezolvera/cuerdas: direct link, hf CLI and curl.
- Browser
- Download file 4.34 kB
-
https://huggingface.co/Eriksanchezolvera/cuerdas/resolve/main/013/iterate.py
- Command line
-
hf download hf://Eriksanchezolvera/cuerdas/013/iterate.py
-
curl -L -o iterate.py https://huggingface.co/Eriksanchezolvera/cuerdas/resolve/main/013/iterate.py
4.34 kB
| # Iteraciones 013c+ : mismos splits que 013b. test dividido en test_dev (iteraciones) y test_fresh (solo ganador). | |
| import sys; exec(open('common.py').read()) | |
| FMT="natural_labeled"; pos=lambda m:len(ids(" "+FORMATS[FMT](m))) | |
| random.seed(7); ct=cov_test[:]; ut=unc_test[:]; random.shuffle(ct); random.shuffle(ut) | |
| dev=ct[:112]+ut[:268]; fresh=ct[112:]+ut[268:] | |
| cal_all=cov_cal+unc_cal | |
| _,TL=eval_text(FMT,cov_train,keep_logits=True) | |
| okT_cal,_=eval_text(FMT,cal_all); okT_dev,_=eval_text(FMT,dev) | |
| class Fact(nn.Module): # una ranura por campo, cada ranura depende SOLO de su campo (binding composicional por posición) | |
| def __init__(s,mode): | |
| super().__init__(); s.mode=mode; s.K=4 if mode=="fact4" else 1 | |
| s.tab=nn.ParameterList([nn.Parameter(E(ids(" "+L[0])[:1]).detach().repeat(len(L),1)+0.01*torch.randn(len(L),D)) for L in FL]) | |
| with torch.no_grad(): # init: embedding de la palabra del valor | |
| for f,L in enumerate(FL): | |
| for j,w in enumerate(L): s.tab[f][j]=E(ids(" "+w))[0] | |
| s.role=nn.Parameter(torch.zeros(4,D)) | |
| def forward(s,mb): | |
| v=torch.stack([s.tab[f][mb[:,f]]+s.role[f] for f in range(4)],1) | |
| return v if s.mode=="fact4" else v.sum(1,keepdim=True) | |
| class MLP(nn.Module): | |
| def __init__(s,K): super().__init__(); s.a=Adapter(K); s.K=K | |
| def forward(s,mb): return s.a(mb) | |
| def train(ad,steps,distill=True,Tk=2.0,bs=32): | |
| opt=torch.optim.AdamW(ad.parameters(),3e-3) | |
| for st_ in range(steps): | |
| b=random.sample(cov_train,bs); mb=torch.tensor(b); f=st_%4 | |
| v=ad(mb); B=len(b) | |
| lg=lm(inputs_embeds=torch.cat([E(PRE).expand(B,-1,-1),v,E(Q[f]).expand(B,-1,-1)],1)).logits[:,-1][:,cand[f]] | |
| loss=F.cross_entropy(lg,mb[:,f]) | |
| if distill: loss=loss+Tk*Tk*F.kl_div(F.log_softmax(lg/Tk,1),F.softmax(torch.stack([TL[m][f] for m in b])/Tk,1),reduction="batchmean") | |
| opt.zero_grad(); loss.backward(); opt.step() | |
| return ad.eval() | |
| def evaluate(name,ad,ms_cal,ms_test,okTc,okTt): | |
| okc,cc=eval_ad(ad,ms_cal); okt,ctt=eval_ad(ad,ms_test); K=ad.K | |
| def hyb(okA,conf,okT,ms,thr): | |
| s={m for m in ms if covered(m) and conf[m]>=thr} | |
| return sum((okA[m] if m in s else okT[m]) for m in ms)/len(ms), sum((K if m in s else pos(m)) for m in ms)/len(ms), len(s)/len(ms) | |
| bc=sum(okTc.values())/len(ms_cal); thr=1.01 | |
| for t in [i/100 for i in range(0,100,2)]: | |
| if bc-hyb(okc,cc,okTc,ms_cal,t)[0]<=0.01: thr=t; break | |
| ha,hp,hf=hyb(okt,ctt,okTt,ms_test,thr) | |
| U=[m for m in ms_test if not covered(m)]; C=[m for m in ms_test if covered(m)] | |
| tb=sum(okTt.values())/len(ms_test) | |
| r=dict(iter=name,K=K,text_acc=tb,text_pos=sum(map(pos,ms_test))/len(ms_test), | |
| native_acc_cov=sum(okt[m] for m in C)/len(C),native_acc_sysholdout=sum(okt[m] for m in U)/len(U), | |
| text_acc_sysholdout=sum(okTt[m] for m in U)/len(U),native_all_acc=sum(okt.values())/len(ms_test), | |
| gate_thr=thr,hyb_acc=ha,hyb_pos=hp,gate_native_frac=hf,hyb_deg_pp=100*(tb-ha), | |
| native_cal_sysholdout=sum(okc[m] for m in ms_cal if not covered(m))/max(1,len([m for m in ms_cal if not covered(m)]))) | |
| r["promising_native"]= (100*(r["text_acc_sysholdout"]-r["native_acc_sysholdout"])<=5) and K<=0.7*r["text_pos"] | |
| r["promising_hybrid_pos"]= hp<=0.7*r["text_pos"] and r["hyb_deg_pp"]<=2 and hf>=0.3 | |
| return r | |
| CFG={"013c":("fact4",200,True),"013d":("add1",200,True),"013e":("mlp1",200,True),"013f":("mlp4",200,True),"013g":("fact4",600,True)} | |
| order=sys.argv[1].split(",") | |
| for name in order: | |
| mode,steps,dis=CFG[name]; torch.manual_seed(0); random.seed(0) | |
| ad=Fact(mode) if mode in("fact4","add1") else MLP(int(mode[-1])) | |
| t0=time.time(); ad=train(ad,steps,dis) | |
| r=evaluate(name,ad,cal_all,dev,okT_cal,okT_dev); r.update(mode=mode,steps=steps,train_s=round(time.time()-t0),params=sum(p.numel() for p in ad.parameters())) | |
| open("iteraciones.jsonl","a").write(json.dumps(r)+"\n"); torch.save(ad.state_dict(),f"adapter_{name}.pt"); print(name,{k:(round(v,3) if isinstance(v,float) else v) for k,v in r.items()},flush=True) | |
| if r["promising_native"] or r["promising_hybrid_pos"]: | |
| okTf,_=eval_text(FMT,fresh); rf=evaluate(name+"_FRESH",ad,cal_all,fresh,okT_cal,okTf) | |
| open("iteraciones.jsonl","a").write(json.dumps(rf)+"\n"); print("FRESH",rf,flush=True); break | |
| print("DONE",flush=True) | |