| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| import json, time, os, math, traceback, gc, subprocess, hashlib, ctypes |
| import torch, torch.nn as nn, torch.nn.functional as Fnn |
| import torch.nn.functional as F |
|
|
| t0=time.time() |
| DIR=r"C:\Shadow\Dissector\D0_PROGRAM\CONSTRUCTIVE" |
| SMOKE=os.environ.get("V7_SMOKE")=="1" |
| LOG=open(os.path.join(DIR,"_v7.log"),"a",encoding="utf-8") |
| def logln(s): |
| s=str(s); LOG.write(f"[V7 {round(time.time()-t0,1):8.1f}s] "+s+"\n"); LOG.flush() |
| try: print(s,flush=True) |
| except Exception: pass |
| def el(): return round(time.time()-t0,1) |
| logln("="*100); logln(f"V7 START smoke={SMOKE} torch={torch.__version__}") |
| try: |
| ctypes.windll.kernel32.SetPriorityClass(ctypes.windll.kernel32.GetCurrentProcess(),0x4000) |
| logln("[ops] priority BelowNormal set") |
| except Exception as e: logln(f"[ops] priority set failed: {e}") |
| torch.set_num_threads(6) |
|
|
| |
| EPS_KL=0.1871; CERT_BLOCK=512; IND_SEG=64; MB=4; CAP_CHUNK=16 |
| VOCAB_SANS_SPECIALS=50256; REGIMES=["prose","code","repetition"] |
| FRESH_LO,FRESH_HI=24576,32768 |
| REP_SEED=3; SEED_J=20260705 |
| B2b=2; B5=5 |
| |
| MLP_H=768; ATTN_DM=256; ATTN_HEADS=4; ATTN_NBLK=(1 if SMOKE else 2); ATTN_MLP=2 |
| STEPS=40 if SMOKE else 4000; CKPT_STEPS=20 if SMOKE else 500; LR=1e-3 |
| FT_STEPS=20 if SMOKE else 300; FT_LR=3e-4 |
| N_TRAIN=8 if SMOKE else 96; N_HOLD2=4 if SMOKE else 16; N_SACRED=4 if SMOKE else 16 |
| TRAIN_SEED0=7000; HOLD2_SEED0=8000 |
| P_TRAIN=(64,384); P_WITHIN=(384,512); P_REPERA=(64,512) |
| |
| WALL_S4_B5=3.46003; FLOOR_B5_RECAL=0.1279 |
| S9X_SACRED=0.11172; S9X_HOLD2=0.1317; W0_B5_BANK=1.5949 |
| V6_R48_REP={8:0.04536,9:0.05499,10:0.07573,11:0.13158}; B12_R48_BANK=0.18155 |
| DEC_V6_SHA="a2d384d29c27fb91" |
| |
| ARMA_CELLS=[(7,"code"),(12,"prose")] if SMOKE else \ |
| [(4,"code"),(5,"code"),(6,"code"),(7,"code"),(8,"code"),(9,"code"),(10,"code"),(11,"code"),(12,"prose")] |
| RANKS_ARMA=[20] if SMOKE else [20,48] |
| S7_IS_R20={8,9,10,11,12} |
| TOL_S4=2e-3; TOL_R20=3e-3 |
| |
| ARMB_BOUNDS=[6] if SMOKE else [6,7] |
| WALL_B={6:0.84522,7:1.43786} |
| |
| C1_NB=2 if SMOKE else 5; C1_NBLK=4 if SMOKE else 16; C1_SEED0=9000; C1_SEEDSTEP=100 |
| SOFT_COMPUTE_S=6.0*3600; HARD_WALL_S=int(11.5*3600) |
|
|
| RESULT_JSON=os.path.join(DIR,"_v7_result_SMOKE.json" if SMOKE else "_v7_result.json") |
| BASES_PT=os.path.join(DIR,"_v7_bases_SMOKE.pt" if SMOKE else "_v7_bases.pt") |
| torch.manual_seed(1234) |
|
|
| PEN=("FINDINGS_PEN_CONSTRUCTIVE_2026-06-28.md :: 'V7 -- THE FINISH-LINE RUN (FOLD THE CODE COLUMN + " |
| "THE ONSET QUESTION + DISCHARGE THE ASTERISK) -- GAP-SCAN + PRE-REGISTRATION (2026-07-05 ~22:35)'") |
| res={"experiment":"V7 finish-line run: Arm A folded r48 at code b4..b11 + prose_b12 (Arm-B recipe " |
| "verbatim, replay-gated); Arm B onset surrogate at BUS[6]/BUS[7] (contracts CT-A/CT-B/CT-C, " |
| "linear-first ladder, SACRED held-out-period falsifier); Arm C1 frozen decoder_v6 across 5 " |
| "fresh held-out batches; Arm C2 front-door ablation; verdict recompute BOTH meters recal primary", |
| "date":"2026-07-05","propose_only":True,"pre_registration":PEN, |
| "config":{"n_train":N_TRAIN,"n_hold2":N_HOLD2,"n_sacred":N_SACRED,"steps":STEPS,"lr":LR, |
| "arma_cells":[f"{r}_b{b}" for (b,r) in ARMA_CELLS],"ranks_arma":RANKS_ARMA, |
| "armb_bounds":ARMB_BOUNDS,"walls_b":WALL_B,"c1_batches":C1_NB,"c1_seed0":C1_SEED0, |
| "precision":"fp32","tf32":"off","attn":"eager","seed":1234,"smoke":SMOKE}, |
| "gpu_free_checks":[],"instrument_discrepancy":[], |
| "gates":{},"c1":{},"armA":{},"c2":{},"armB":{},"verdict":{},"status":"INIT"} |
|
|
| def sha256(path): |
| try: |
| h=hashlib.sha256() |
| with open(path,"rb") as f: |
| for chunk in iter(lambda:f.read(1<<20),b""): h.update(chunk) |
| return h.hexdigest()[:16] |
| except Exception as e: return f"ERR:{e}" |
| def write_json(): |
| res["elapsed_s"]=el(); tmp=RESULT_JSON+".tmp" |
| with open(tmp,"w",encoding="utf-8") as f: json.dump(res,f,indent=1,default=str) |
| os.replace(tmp,RESULT_JSON) |
| BASES={} |
| def save_bases(): |
| tmp=BASES_PT+".tmp"; torch.save(BASES,tmp); os.replace(tmp,BASES_PT) |
|
|
| |
| if os.path.exists(RESULT_JSON): |
| try: |
| prev=json.load(open(RESULT_JSON,encoding="utf-8")) |
| for k in ("gates","c1","armA","c2","armB","verdict","gpu_free_checks","instrument_discrepancy"): |
| if prev.get(k): res[k]=prev[k] |
| logln(f"*** RESUME *** prior elapsed={prev.get('elapsed_s')}") |
| except Exception as e: logln(f"resume load fail {e}") |
| if os.path.exists(BASES_PT): |
| try: BASES=torch.load(BASES_PT,map_location="cpu",weights_only=False); logln(f"*** RESUME bases {sorted(map(str,BASES.keys()))[:24]}") |
| except Exception as e: logln(f"bases load fail {e}"); BASES={} |
| write_json() |
|
|
| |
| def gpu_free_check(tag): |
| rec={"tag":tag,"t":el(),"foreign":[]} |
| try: |
| out=subprocess.run(["nvidia-smi","--query-compute-apps=pid,process_name,used_memory","--format=csv,noheader"], |
| capture_output=True,text=True,timeout=30).stdout |
| me=os.getpid() |
| for line in out.strip().splitlines(): |
| p=[x.strip() for x in line.split(",")] |
| if len(p)>=3 and p[0].isdigit() and int(p[0])!=me and "python" in p[1].lower(): rec["foreign"].append(line) |
| except Exception as e: rec["error"]=str(e) |
| waited=0 |
| while rec["foreign"] and waited<600: |
| logln(f"[gpu {tag}] FOREIGN {rec['foreign']} wait60"); time.sleep(60); waited+=60 |
| try: |
| out=subprocess.run(["nvidia-smi","--query-compute-apps=pid,process_name,used_memory","--format=csv,noheader"], |
| capture_output=True,text=True,timeout=30).stdout |
| me=os.getpid(); rec["foreign"]=[] |
| for line in out.strip().splitlines(): |
| p=[x.strip() for x in line.split(",")] |
| if len(p)>=3 and p[0].isdigit() and int(p[0])!=me and "python" in p[1].lower(): rec["foreign"].append(line) |
| except Exception: break |
| rec["waited_s"]=waited; rec["clear"]=not rec["foreign"] |
| if rec["foreign"]: |
| res["instrument_discrepancy"].append({"stage":tag,"name":"gpu_free_check","why":str(rec["foreign"])}) |
| res["gpu_free_checks"].append(rec); write_json(); logln(f"[gpu {tag}] clear={rec['clear']}"); return rec["clear"] |
| def free(): gc.collect(); torch.cuda.empty_cache() |
|
|
| |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
| M={"m":None} |
| def ensure_model(): |
| if M["m"] is not None: return |
| if not torch.cuda.is_available(): raise RuntimeError("CUDA not available") |
| torch.backends.cuda.matmul.allow_tf32=False; torch.backends.cudnn.allow_tf32=False |
| tok=AutoTokenizer.from_pretrained("gpt2") |
| model=AutoModelForCausalLM.from_pretrained("gpt2",dtype=torch.float32,attn_implementation="eager").to('cuda').eval() |
| model.requires_grad_(False) |
| M["m"]=model; M["tok"]=tok; M["blocks"]=list(model.transformer.h); M["drop"]=model.transformer.drop |
| M["d"]=model.config.n_embd; M["nL"]=model.config.n_layer; M["nH"]=model.config.n_head |
| M["wte"]=model.transformer.wte.weight |
| res["gpt2_meta"]={"n_layer":M["nL"],"d":M["d"],"n_head":M["nH"],"precision":"fp32","tf32":"off","attn":"eager"} |
| logln(f"[gpt2] loaded fp32 eager nL={M['nL']} d={M['d']} nH={M['nH']}") |
|
|
| def load_wiki_text(): |
| from datasets import load_dataset |
| ds=load_dataset("wikitext","wikitext-2-raw-v1",split="test") |
| return "\n".join(t for t in ds["text"] if t and t.strip()) |
| def load_code_text(): |
| from datasets import load_dataset |
| ds=load_dataset("openai_humaneval")["test"] |
| return "".join(ds[i]["prompt"]+ds[i]["canonical_solution"] for i in range(len(ds))) |
| def build_dind(n_blocks,block,seed): |
| g=torch.Generator().manual_seed(seed) |
| seg=torch.randint(0,VOCAB_SANS_SPECIALS,(n_blocks,IND_SEG),generator=g) |
| return seg.repeat(1,block//IND_SEG) |
| def build_dind_seeds(seed0,n): |
| rows=[build_dind(1,CERT_BLOCK,seed0+i) for i in range(n)] |
| return torch.cat(rows,0) |
| def ids_window(all_ids,lo,hi,what): |
| if len(all_ids)<hi: raise RuntimeError(f"{what}: {len(all_ids)}<{hi}") |
| n=(hi-lo)//CERT_BLOCK; return torch.tensor(all_ids[lo:hi],dtype=torch.long).view(n,CERT_BLOCK) |
|
|
| |
| ROOMS=[2,5,3,4,6] |
| J1_BANKED={0:{"m_star":3.32735,"prose":0.1856,"code":0.21775,"repetition":1.20131}, |
| 1:{"m_star":28.40602,"prose":0.18318,"code":0.2236,"repetition":0.13455}, |
| 2:{"m_star":17.07425,"prose":0.19183,"code":0.24188,"repetition":0.16051}, |
| 3:{"m_star":20.74943,"prose":0.18862,"code":0.22101,"repetition":0.51223}, |
| 4:{"m_star":24.94407,"prose":0.18712,"code":0.19473,"repetition":0.41945}, |
| 5:{"m_star":28.10003,"prose":0.18355,"code":0.19684,"repetition":0.12231}, |
| 6:{"m_star":33.41676,"prose":0.18273,"code":0.18646,"repetition":0.07765}, |
| 7:{"m_star":39.73945,"prose":0.19098,"code":0.19793,"repetition":0.0997}, |
| 8:{"m_star":47.25844,"prose":0.18865,"code":0.17497,"repetition":0.08828}, |
| 9:{"m_star":56.20007,"prose":0.18491,"code":0.15937,"repetition":0.11206}, |
| 10:{"m_star":69.79249,"prose":0.18621,"code":0.15106,"repetition":0.11632}, |
| 11:{"m_star":84.81515,"prose":0.18521,"code":0.1388,"repetition":0.08944}, |
| 12:{"m_star":96.58652,"prose":0.18978,"code":0.13981,"repetition":0.07056}} |
| def load_objects(): |
| dv=torch.load(os.path.join(DIR,"decoder_v0_tensors.pt"),map_location="cpu",weights_only=False) |
| C=dv["C"].float(); Qu=dv["Q_union"].float(); Qh=dv["host_Q"].float() |
| hopW=dv["hop_W"].float(); hopc=dv["hop_c"].float() |
| t15=torch.load(os.path.join(DIR,"_t15_bases.pt"),map_location="cpu",weights_only=False) |
| t10=torch.load(os.path.join(DIR,"_t10_bases.pt"),map_location="cpu",weights_only=False) |
| Qa=t10["Q_attn"].float(); Qm=t10["Q_mlp"].float() |
| o1=torch.load(os.path.join(DIR,"_open1_bases.pt"),map_location="cpu",weights_only=False) |
| mu=o1["mu"].float(); B2=o1["B2"].float(); U=o1["U"].float() |
| o2=torch.load(os.path.join(DIR,"_open2_bases.pt"),map_location="cpu",weights_only=False) |
| WF3=o2["W_F3"].float(); cF3=o2["c_F3"].float(); WF1=o2["W_F1"].float() |
| v1=torch.load(os.path.join(DIR,"decoder_v1_tensors.pt"),map_location="cpu",weights_only=False) |
| wte_W=v1["wte_W"].float(); wte_c=v1["wte_c"].float() |
| Q35v1=v1["Q35"].float(); B2v1=v1["B2"].float(); muv1=v1["mu"].float() |
| def md(a,b): return float((a.float()-b.float()).abs().max()) |
| cm={"C_vs_t15":md(C,t15["core_j0_5basis"]),"Qu_vs_t10":md(Qu,t10["Q_union"]), |
| "WF1_vs_hopW":md(WF1,hopW),"B2_vs_v1":md(B2,B2v1),"mu_vs_v1":md(mu,muv1)} |
| orthC=float((C.t()@C-torch.eye(C.shape[1])).norm()) |
| orthB2=float((B2.t()@B2-torch.eye(B2.shape[1])).norm()) |
| p4=json.load(open(os.path.join(DIR,"_open4_probe.json"),encoding="utf-8")) |
| frozen=[(r["room"],r["dim"]) for r in p4["selection"]["corridor_distinct"]] |
| seen=[]; kept=[] |
| for b in ROOMS: |
| for i in range(16): |
| u=U[b][:,i]; best=0.0 |
| for (kb,ki,v) in seen: |
| dd=abs(float(u@v)) |
| if dd>best: best=dd |
| if best<=0.8: kept.append((b,i)) |
| seen.append((b,i,u)) |
| corr_match=bool(kept==frozen) |
| V35=torch.stack([U[r][:,d_] for (r,d_) in frozen],1) |
| Rr=V35-B2@(B2.t()@V35); Q35,_=torch.linalg.qr(Rr,mode='reduced') |
| q35orth=float((Q35.t()@Q35-torch.eye(Q35.shape[1])).norm()) |
| maxB2tQ35=float((B2.t()@Q35).abs().max()) |
| q35_vs_v1=md(Q35,Q35v1) |
| o5=json.load(open(os.path.join(DIR,"_open5_result.json"),encoding="utf-8")) |
| floors={int(b):{"prose":0.1871,"code":o5["J1"]["floors"][str(b)]["code"], |
| "repetition":o5["J1"]["floors"][str(b)]["repetition"]} for b in range(13)} |
| mstars={int(b):o5["J1"]["floors"][str(b)]["m_star"] for b in range(13)} |
| p6=json.load(open(os.path.join(DIR,"_open6_probe.json"),encoding="utf-8")) |
| floors_match=all(abs(floors[b][r]-p6["frozen"]["floors"][str(b)][r])==0.0 |
| for b in range(13) for r in REGIMES) |
| bank_match=all(abs(J1_BANKED[b]["m_star"]-mstars[b])==0.0 and |
| abs(J1_BANKED[b]["code"]-floors[b]["code"])==0.0 and |
| abs(J1_BANKED[b]["repetition"]-floors[b]["repetition"])==0.0 for b in range(13)) |
| m0a_ok=(all(v==0.0 for v in cm.values()) and orthC<=1e-4 and orthB2<=1e-3 and corr_match |
| and q35orth<=1e-3 and maxB2tQ35<=1e-3 and floors_match and q35_vs_v1<=1e-5 and bank_match) |
| res["gates"]["M0a"]={"content_match":cm,"core_orth":orthC,"B2_orth":orthB2, |
| "corridor_recompute_match":corr_match,"Q35_orth":q35orth,"maxB2tQ35":maxB2tQ35, |
| "Q35_vs_v1":q35_vs_v1,"floors_match_frozen":floors_match,"j1_bank_match":bank_match, |
| "n_corridor":len(frozen),"pass":bool(m0a_ok)} |
| if not m0a_ok: res["instrument_discrepancy"].append({"stage":"M0a","name":"content_or_selection","why":res["gates"]["M0a"]}) |
| logln(f"[M0a] cm={cm} corr_match={corr_match} floors_match={floors_match} bank={bank_match} -> {'PASS' if m0a_ok else 'FAIL'}") |
| write_json() |
| src_sha={f:sha256(os.path.join(DIR,f)) for f in ("decoder_v1_tensors.pt","decoder_v3_tensors.pt", |
| "decoder_v6_tensors.pt","decoder_v6.json","_open1_bases.pt","_open5_result.json", |
| "_v5_floors_recal.json","_v3_result.json","_v6_result.json")} |
| return dict(C=C,mu=mu,B2=B2,U=U,V35=V35,Q35=Q35,frozen=frozen,floors=floors,mstars=mstars, |
| wte_W=wte_W,wte_c=wte_c,src_sha=src_sha) |
|
|
| |
| def capture_h_all(ids_cpu,chunk,tag,which=None): |
| model=M["m"]; nL=M["nL"]; N=ids_cpu.shape[0] |
| which=which if which is not None else list(range(nL+1)) |
| buf={}; handles=[] |
| def mk(key): |
| def h(mod,inp,out): buf[key]=(out[0] if isinstance(out,tuple) else out).detach() |
| return h |
| handles.append(M["drop"].register_forward_hook(mk(0))) |
| for L in range(nL): handles.append(M["blocks"][L].register_forward_hook(mk(L+1))) |
| acc={b:[] for b in which} |
| with torch.no_grad(): |
| for c0 in range(0,N,chunk): |
| c1=min(N,c0+chunk); _=model(ids_cpu[c0:c1].to('cuda'),use_cache=False) |
| for b in which: acc[b].append(buf[b].reshape(-1,M["d"]).cpu()) |
| for hd in handles: hd.remove() |
| H={b:torch.cat(acc[b],0) for b in which} |
| return H |
| def fkl(yt,yp): |
| logp=Fnn.log_softmax(yt,-1); p=logp.exp(); lp=Fnn.log_softmax(yp,-1) |
| return (p*(logp-lp)).sum(-1) |
| class InjectHook: |
| def __init__(self,block): |
| self.on=False; self.add=None; self.handle=block.register_forward_hook(self._h) |
| def _h(self,mod,inp,out): |
| if not self.on: return None |
| hs=out[0] if isinstance(out,tuple) else out; hs2=hs+self.add |
| return (hs2,)+tuple(out[1:]) if isinstance(out,tuple) else hs2 |
| def close(self): self.handle.remove() |
| def clean_logits(ids_cpu): |
| model=M["m"]; N=ids_cpu.shape[0]; outs=[] |
| with torch.no_grad(): |
| for s0 in range(0,N,MB): |
| s1=min(N,s0+MB); outs.append(model(ids_cpu[s0:s1].to('cuda'),use_cache=False).logits.detach()) |
| return outs |
| def inject_kl_full(ids_cpu,injhook,delta_full_g,Yclean,want_dl=False): |
| model=M["m"]; N=ids_cpu.shape[0]; tot=0.0; cnt=0; ci=0; dl=0.0 |
| with torch.no_grad(): |
| for s0 in range(0,N,MB): |
| s1=min(N,s0+MB) |
| injhook.add=delta_full_g[s0:s1]; injhook.on=True |
| lg=model(ids_cpu[s0:s1].to('cuda'),use_cache=False).logits; injhook.on=False; injhook.add=None |
| if want_dl: dl=max(dl,float((lg.float()-Yclean[ci].float()).abs().max())) |
| kl=fkl(Yclean[ci].float(),lg.float()); tot+=kl.sum().item(); cnt+=kl.numel(); ci+=1 |
| del lg |
| return (tot/max(1,cnt),dl) if want_dl else tot/max(1,cnt) |
| def inject_kl_pidx(ids_cpu,injhook,delta_full_g,Yclean,pidx): |
| model=M["m"]; N=ids_cpu.shape[0]; tot=0.0; cnt=0; ci=0 |
| with torch.no_grad(): |
| for s0 in range(0,N,MB): |
| s1=min(N,s0+MB) |
| injhook.add=delta_full_g[s0:s1]; injhook.on=True |
| lg=model(ids_cpu[s0:s1].to('cuda'),use_cache=False).logits; injhook.on=False; injhook.add=None |
| kl=fkl(Yclean[ci].float(),lg.float())[:,pidx]; tot+=kl.sum().item(); cnt+=kl.numel(); ci+=1 |
| del lg |
| return tot/max(1,cnt) |
|
|
| |
| class LinearRung(nn.Module): |
| def __init__(self,fin,d): super().__init__(); self.w=nn.Linear(fin,d) |
| def forward(self,x): return self.w(x) |
| class MLPRung(nn.Module): |
| def __init__(self,fin,h,d): super().__init__(); self.f1=nn.Linear(fin,h); self.act=nn.GELU(); self.f2=nn.Linear(h,d) |
| def forward(self,x): return self.f2(self.act(self.f1(x))) |
| class AttnBlock(nn.Module): |
| def __init__(self,dm,nh,mlp): |
| super().__init__(); self.ln1=nn.LayerNorm(dm); self.attn=nn.MultiheadAttention(dm,nh,batch_first=True) |
| self.ln2=nn.LayerNorm(dm); self.mlp=nn.Sequential(nn.Linear(dm,dm*mlp),nn.GELU(),nn.Linear(dm*mlp,dm)) |
| def forward(self,x,mask): |
| q=self.ln1(x); a,_=self.attn(q,q,q,attn_mask=mask,need_weights=False) |
| x=x+a; x=x+self.mlp(self.ln2(x)); return x |
| class AttnRung(nn.Module): |
| def __init__(self,fin,dm,nh,nblk,mlp,d,seqlen): |
| super().__init__(); self.inp=nn.Linear(fin,dm); self.pos=nn.Parameter(torch.zeros(1,seqlen,dm)) |
| self.blocks=nn.ModuleList([AttnBlock(dm,nh,mlp) for _ in range(nblk)]); self.out=nn.Linear(dm,d) |
| def forward(self,x): |
| T=x.shape[1]; h=self.inp(x)+self.pos[:,:T] |
| mask=torch.triu(torch.full((T,T),float('-inf'),device=x.device),diagonal=1) |
| for b in self.blocks: h=b(h,mask) |
| return self.out(h) |
| def n_params(m): return int(sum(p.numel() for p in m.parameters())) |
| RUNG_SEED={"L0":11,"L1":22,"L2":33} |
| def make_rung(name,fin,seqlen): |
| if name=="L0": return LinearRung(fin,M["d"]) |
| if name=="L1": return MLPRung(fin,MLP_H,M["d"]) |
| if name=="L2": return AttnRung(fin,ATTN_DM,ATTN_HEADS,ATTN_NBLK,ATTN_MLP,M["d"],seqlen) |
| raise ValueError(name) |
|
|
| |
| |
| |
| try: |
| ensure_model() |
| O=load_objects() |
| if not res["gates"]["M0a"]["pass"]: |
| res["status"]="STOPPED-GATE"; write_json(); raise RuntimeError("FB: M0a breach -> STOP") |
| d=M["d"]; nL=M["nL"] |
| B2_g=O["B2"].to('cuda'); Q35_g=O["Q35"].to('cuda'); span5=torch.cat([B2_g,Q35_g],1) |
| mu_all=O["mu"] |
| wteW_g=O["wte_W"].to('cuda'); wtec_g=O["wte_c"].to('cuda') |
| wte_g=M["wte"].detach().float() |
| def proj_compl(x): return x-(x@span5)@span5.t() |
| def s4_delta(Xc,b,Ecur_all): |
| b2P=(Xc@B2_g)@B2_g.t(); q35P=(Xc@Q35_g)@Q35_g.t() |
| yhat=Ecur_all@wteW_g[b].t()+wtec_g[b] |
| y2=yhat-(yhat@B2_g)@B2_g.t(); y4=y2-(y2@Q35_g)@Q35_g.t() |
| return b2P+q35P+y4-Xc |
|
|
| |
| dv6_sha=sha256(os.path.join(DIR,"decoder_v6_tensors.pt")) |
| dv6_ok=(dv6_sha==DEC_V6_SHA) |
| if not dv6_ok: |
| res["instrument_discrepancy"].append({"stage":"gates","name":"decoder_v6_hash","why":dv6_sha}) |
| dv6=torch.load(os.path.join(DIR,"decoder_v6_tensors.pt"),map_location="cpu",weights_only=False) |
| v6L0=LinearRung(1537,d).to('cuda').eval() |
| v6L0.load_state_dict({k:v.to('cuda') for k,v in dv6["surrogate_state_dict"].items()}) |
| sc6_mean=dv6["surrogate_scaler_mean"].to('cuda'); sc6_std=dv6["surrogate_scaler_std"].to('cuda') |
| Vk=dv6["m0_repera_Vk_recal"].to('cuda').float() |
| v5b=torch.load(os.path.join(DIR,"_v5_bases.pt"),map_location="cpu",weights_only=False) |
| cos_vk=float((Vk[:,0]@v5b["m0_repera_Vk_recal"].to('cuda').float()[:,0]).abs()) |
| res["gates"]["decoder_v6"]={"sha":dv6_sha,"sha_ok":bool(dv6_ok),"rung":dv6.get("surrogate_rung"), |
| "vk_cos_vs_v5":round(cos_vk,6)} |
| write_json(); logln(f"[gates] decoder_v6 sha={dv6_sha} ok={dv6_ok} vk_cos={cos_vk:.6f}") |
| if not dv6_ok: raise RuntimeError("FB: frozen decoder_v6 hash mismatch -> STOP") |
|
|
| |
| frec=json.load(open(os.path.join(DIR,"_v5_floors_recal.json"),encoding="utf-8")) |
| floors_leg={int(b):{k:float(v) for k,v in frec["floors_legacy"][str(b)].items()} for b in range(13)} |
| floors_rec={int(b):{k:(float(v) if v is not None else None) for k,v in frec["floors_recal"][str(b)].items()} for b in range(13)} |
| RECAL_OK=(not frec.get("quarantined")) and frec.get("sg_early_ok") and frec.get("repl_all") |
| v3=json.load(open(os.path.join(DIR,"_v3_result.json"),encoding="utf-8")) |
| v3cells=v3["cells"] |
| logln(f"[floors] RECAL_OK={RECAL_OK} rep_b6={floors_rec[6]['repetition']} rep_b7={floors_rec[7]['repetition']}") |
|
|
| WIKI=M["tok"](load_wiki_text(),return_tensors=None,add_special_tokens=False)["input_ids"] |
| CIDS=M["tok"](load_code_text(),return_tensors=None,add_special_tokens=False)["input_ids"] |
| IDS_SACRED=build_dind(N_SACRED,CERT_BLOCK,REP_SEED) |
| IDS_TRAIN=build_dind_seeds(TRAIN_SEED0,N_TRAIN) |
| IDS_HOLD2=build_dind_seeds(HOLD2_SEED0,N_HOLD2) |
|
|
| |
| CAPB=[2,5,6,7] |
| CAPS={} |
| CAP_IDS={"train":IDS_TRAIN,"sacred":IDS_SACRED,"hold2":IDS_HOLD2} |
| def get_cap(name): |
| if name not in CAPS: CAPS[name]=capture_feats_multi(CAP_IDS[name],name) |
| return CAPS[name] |
| def capture_feats_multi(ids_cpu,tag): |
| model=M["m"]; N=ids_cpu.shape[0]; buf={} |
| def mkh(key,idx): |
| def h(mod,inp,out): buf[key]=(out[0] if isinstance(out,tuple) else out).detach() |
| return h |
| hh=[M['blocks'][bb-1].register_forward_hook(mkh(f'h{bb}',bb)) for bb in CAPB] |
| hh.append(M['blocks'][0].mlp.register_forward_hook( |
| lambda m,i,o: buf.__setitem__('wm0',o.detach()))) |
| acc={f'h{bb}':[] for bb in CAPB}; acc['wm0']=[] |
| with torch.no_grad(): |
| for c0 in range(0,N,CAP_CHUNK): |
| c1=min(N,c0+CAP_CHUNK); _=model(ids_cpu[c0:c1].to('cuda'),use_cache=False) |
| for k in acc: acc[k].append(buf[k].reshape(-1,d).cpu()) |
| for x in hh: x.remove() |
| logln(f"[feats {tag}] N={N} captured {list(acc.keys())}") |
| return {k:torch.cat(v) for k,v in acc.items()} |
| def base_feats(cap,ids_cpu): |
| |
| x2=cap['h2'].to('cuda')-mu_all[B2b].to('cuda') |
| ecur=wte_g[ids_cpu.reshape(-1).to('cuda')] |
| s=cap['wm0'].to('cuda')@Vk |
| return x2,ecur,s |
| def obj_at(cap,b): |
| return proj_compl(cap[f'h{b}'].to('cuda')-mu_all[b].to('cuda')) |
| def obj5hat_of(x2,ecur,s): |
| f6=torch.cat([x2,ecur,s],1) |
| with torch.no_grad(): |
| oh=proj_compl(v6L0((f6-sc6_mean)/sc6_std)) |
| return oh |
| def contract_feats(ct,cap,ids_cpu,extra=None): |
| x2,ecur,s=base_feats(cap,ids_cpu) |
| if ct=="CTB": return torch.cat([x2,ecur,s],1) |
| if ct=="CTA": return torch.cat([x2,ecur,s,obj5hat_of(x2,ecur,s)],1) |
| if ct=="C2": return torch.cat([x2,ecur],1) |
| if ct=="CTC": |
| o5=obj5hat_of(x2,ecur,s) |
| return torch.cat([x2,ecur,s,o5,extra],1) |
| raise ValueError(ct) |
| CT_FIN={"CTB":1537,"CTA":2305,"C2":1536,"CTC":3073} |
|
|
| def substitution_kl_at(b,oh,obj_g,ids_cpu,Ycl,injhook,want_behav=False): |
| N=ids_cpu.shape[0] |
| delta=(oh-obj_g).reshape(N,CERT_BLOCK,d).clone(); delta[:, :IND_SEG, :]=0.0 |
| pidx_rep=torch.arange(IND_SEG,CERT_BLOCK) |
| kl_rep=inject_kl_pidx(ids_cpu,injhook,delta,Ycl,pidx_rep) |
| kl_all,dl=inject_kl_full(ids_cpu,injhook,delta,Ycl,want_dl=True) |
| out={"kl_rep":round(kl_rep,5),"kl_all":round(kl_all,5),"max_dlogit":round(dl,5)} |
| if want_behav: out["behav"]=behav_meter(oh,obj_g,ids_cpu,Ycl,injhook) |
| return out |
| def behav_meter(oh,obj_g,ids_cpu,Ycl,injhook): |
| N=ids_cpu.shape[0] |
| delta=(oh-obj_g).reshape(N,CERT_BLOCK,d).clone(); delta[:, :IND_SEG, :]=0.0 |
| pc=0.0;ps=0.0;ac=0.0;as_=0.0;cnt=0;ci=0 |
| with torch.no_grad(): |
| for s0 in range(0,N,MB): |
| s1=min(N,s0+MB) |
| injhook.add=delta[s0:s1]; injhook.on=True |
| lg=M["m"](ids_cpu[s0:s1].to('cuda'),use_cache=False).logits.float(); injhook.on=False; injhook.add=None |
| yc=Ycl[ci].float() |
| nxt=ids_cpu[s0:s1,IND_SEG+1:CERT_BLOCK].to('cuda') |
| lc=yc[:,IND_SEG:CERT_BLOCK-1]; lsb=lg[:,IND_SEG:CERT_BLOCK-1] |
| pcl=Fnn.softmax(lc,-1).gather(-1,nxt[...,None]).squeeze(-1) |
| psb=Fnn.softmax(lsb,-1).gather(-1,nxt[...,None]).squeeze(-1) |
| pc+=float(pcl.sum()); ps+=float(psb.sum()) |
| ac+=float((lc.argmax(-1)==nxt).sum()); as_+=float((lsb.argmax(-1)==nxt).sum()) |
| cnt+=nxt.numel(); ci+=1; del lg |
| pc/=cnt; ps/=cnt; ac/=cnt; as_/=cnt |
| return {"p_true_clean":round(pc,5),"p_true_sub":round(ps,5),"copy_fidelity_ratio":round(ps/max(pc,1e-9),4), |
| "argmax_copy_clean":round(ac,4),"argmax_copy_sub":round(as_,4),"n":cnt} |
| def r2_of(oh,obj_g,N): |
| m=torch.zeros(N,CERT_BLOCK,dtype=torch.bool); m[:,IND_SEG:CERT_BLOCK]=True; m=m.reshape(-1).to('cuda') |
| e=((oh[m]-obj_g[m])**2).sum(); v=((obj_g[m]-obj_g[m].mean(0))**2).sum() |
| return float(1-(e/v.clamp(min=1e-9))) |
|
|
| |
| |
| |
| if not res["gates"].get("b5"): |
| gpu_free_check("gates-b5") |
| logln("==== GATES: b5 identity / S4 replay / SILENT on SACRED ====") |
| cap_s=get_cap("sacred") |
| Xc5=cap_s['h5'].to('cuda')-mu_all[B5].to('cuda'); obj_s5=proj_compl(Xc5) |
| N=IDS_SACRED.shape[0]; Ycl_s=clean_logits(IDS_SACRED) |
| inj5=InjectHook(M["blocks"][B5-1]) |
| zero=torch.zeros(N,CERT_BLOCK,d,device='cuda') |
| kl_id,dl_id=inject_kl_full(IDS_SACRED,inj5,zero,Ycl_s,want_dl=True) |
| Ecur=wte_g[IDS_SACRED.reshape(-1).to('cuda')] |
| kl_S4=inject_kl_full(IDS_SACRED,inj5,s4_delta(Xc5,B5,Ecur).reshape(N,CERT_BLOCK,d),Ycl_s) |
| dsil=(-obj_s5).reshape(N,CERT_BLOCK,d).clone(); dsil[:, :IND_SEG, :]=0.0 |
| kl_sil_rep=inject_kl_pidx(IDS_SACRED,inj5,dsil,Ycl_s,torch.arange(IND_SEG,CERT_BLOCK)) |
| s4_ok=(abs(kl_S4-WALL_S4_B5)<=TOL_S4 and kl_id==0.0 and dl_id==0.0) if not SMOKE else (kl_id==0.0) |
| if not s4_ok: res["instrument_discrepancy"].append({"stage":"gates-b5","name":"S4/identity","why":{"S4":kl_S4,"id":kl_id,"dl":dl_id}}) |
| |
| x2,ecur,s=base_feats(cap_s,IDS_SACRED) |
| oh5=obj5hat_of(x2,ecur,s) |
| sub=substitution_kl_at(B5,oh5,obj_s5,IDS_SACRED,Ycl_s,inj5) |
| s9x_ok=(abs(sub["kl_rep"]-S9X_SACRED)<=TOL_S4) if not SMOKE else True |
| if not s9x_ok: res["instrument_discrepancy"].append({"stage":"gates-b5","name":"S9x_replay","why":sub}) |
| inj5.close() |
| res["gates"]["b5"]={"identity_kl":kl_id,"identity_dlogit":dl_id,"S4_replay":round(kl_S4,5), |
| "S4_banked":WALL_S4_B5,"S4_ok":bool(s4_ok),"silent_rep":round(kl_sil_rep,5), |
| "S9x_replay":sub["kl_rep"],"S9x_banked":S9X_SACRED,"S9x_ok":bool(s9x_ok)} |
| write_json() |
| logln(f"[gates-b5] id={kl_id}/{dl_id} S4={kl_S4:.5f}(bk {WALL_S4_B5}) sil={kl_sil_rep:.5f} " |
| f"S9x={sub['kl_rep']:.5f}(bk {S9X_SACRED}) -> {'OK' if (s4_ok and s9x_ok) else 'FAIL'}") |
| del Xc5,obj_s5,Ycl_s,zero,Ecur,x2,ecur,s,oh5; free() |
|
|
| |
| |
| |
| if not res["c1"].get("done") and el()<HARD_WALL_S: |
| gpu_free_check("c1") |
| logln("==== ARM C1: frozen decoder_v6 across fresh held-out batches ====") |
| rows=res["c1"].get("rows",{}) |
| inj5=InjectHook(M["blocks"][B5-1]) |
| for j in range(C1_NB): |
| key=f"batch{j}" |
| if rows.get(key,{}).get("done"): continue |
| seed0=C1_SEED0+C1_SEEDSTEP*j |
| ids=build_dind_seeds(seed0,C1_NBLK) |
| cap=capture_feats_multi(ids,f"c1-{j}") |
| x2,ecur,s=base_feats(cap,ids) |
| oh=obj5hat_of(x2,ecur,s); obj=obj_at(cap,B5) |
| Ycl=clean_logits(ids) |
| kl_id,_=inject_kl_full(ids,inj5,torch.zeros(ids.shape[0],CERT_BLOCK,d,device='cuda'),Ycl,want_dl=True) |
| sub=substitution_kl_at(B5,oh,obj,ids,Ycl,inj5) |
| rows[key]={"done":True,"seed0":seed0,"n_blocks":int(ids.shape[0]),"identity_kl":kl_id, |
| "kl_rep":sub["kl_rep"],"kl_all":sub["kl_all"],"r2":round(r2_of(oh,obj,ids.shape[0]),4)} |
| res["c1"]["rows"]=rows; write_json() |
| logln(f"[c1 {key}] seed0={seed0} kl_rep={sub['kl_rep']:.5f} r2={rows[key]['r2']}") |
| del cap,x2,ecur,s,oh,obj,Ycl; free() |
| inj5.close() |
| vals=sorted(rows[f"batch{j}"]["kl_rep"] for j in range(C1_NB) if rows.get(f"batch{j}",{}).get("done")) |
| if len(vals)==C1_NB: |
| med=vals[len(vals)//2] if len(vals)%2==1 else 0.5*(vals[len(vals)//2-1]+vals[len(vals)//2]) |
| mx=max(vals) |
| if med<=FLOOR_B5_RECAL and mx<=2*FLOOR_B5_RECAL: band="DISCHARGED" |
| elif med<=S9X_HOLD2 and mx<=2*FLOOR_B5_RECAL: band="HOLDS-THIN" |
| else: band="FAILS" |
| res["c1"].update({"done":True,"values":vals,"median":round(med,5),"max":round(mx,5), |
| "floor":FLOOR_B5_RECAL,"H_V7_C1":band, |
| "bands":"DISCHARGED med<=0.1279 & max<=0.2558 / HOLDS-THIN med<=0.1317 & max<=0.2558 / FAILS", |
| "bet":"DISCHARGED 55 / HOLDS-THIN 30 / FAILS 15"}) |
| write_json(); logln(f"[C1] values={vals} median={med:.5f} max={mx:.5f} -> H-V7-C1={band}") |
|
|
| |
| |
| |
| if not res["armA"].get("done") and el()<HARD_WALL_S: |
| gpu_free_check("armA") |
| logln("==== ARM A: folded r-cap reads, code column + prose_b12 ====") |
| STREAMS_A={"prose":ids_window(WIKI,FRESH_LO,FRESH_HI,"fresh prose")[:N_SACRED], |
| "repetition":IDS_SACRED} |
| try: STREAMS_A["code"]=ids_window(CIDS,FRESH_LO,FRESH_HI,"fresh code")[:N_SACRED] |
| except Exception as e: logln(f"[armA] code load failed {e}") |
| bounds_needed=sorted({b for (b,_) in ARMA_CELLS}) |
| if not SMOKE and len(STREAMS_A)!=3: |
| res["instrument_discrepancy"].append({"stage":"armA","name":"stream_count","why":list(STREAMS_A)}) |
| |
| |
| caps={} |
| for reg in REGIMES: |
| if reg not in STREAMS_A: continue |
| caps[reg]=capture_h_all(STREAMS_A[reg],CAP_CHUNK,f"armA-{reg}",which=bounds_needed) |
| Ycl_cache={} |
| arma=res["armA"].get("cells",{}) |
| for (b,reg) in ARMA_CELLS: |
| key=f"{reg}_b{b}" |
| if arma.get(key,{}).get("done"): continue |
| if el()>HARD_WALL_S: break |
| gram=torch.zeros(d,d,dtype=torch.float64); ntok=0 |
| B2d=B2_g.double() |
| for reg2 in REGIMES: |
| if reg2 not in caps: continue |
| h=caps[reg2][b].to('cuda').double(); rr=h-mu_all[b].to('cuda').double(); rr=rr-(rr@B2d)@B2d.t() |
| gram+=(rr.t()@rr).cpu().double(); ntok+=rr.shape[0]; del h,rr; free() |
| G=gram/max(1,ntok); evals,evecs=torch.linalg.eigh(G); evals=evals.clamp(min=0) |
| order=torch.argsort(evals,descending=True); V=evecs[:,order].float().to('cuda') |
| ids_t=STREAMS_A[reg]; NHt=ids_t.shape[0] |
| if reg not in Ycl_cache: Ycl_cache[reg]=clean_logits(ids_t) |
| Yct=Ycl_cache[reg] |
| Xc=caps[reg][b].to('cuda')-mu_all[b].to('cuda') |
| Ecur_all=wte_g[ids_t.reshape(-1).to('cuda')] |
| inj=InjectHook(M["blocks"][b-1]) |
| kl_idb=inject_kl_full(ids_t,inj,torch.zeros(NHt,CERT_BLOCK,d,device='cuda'),Yct) |
| b2P=(Xc@B2_g)@B2_g.t(); q35P=(Xc@Q35_g)@Q35_g.t() |
| yhat=Ecur_all@wteW_g[b].t()+wtec_g[b]; y2=yhat-(yhat@B2_g)@B2_g.t(); y4=y2-(y2@Q35_g)@Q35_g.t() |
| |
| kl_s4c=inject_kl_full(ids_t,inj,(b2P+q35P+y4-Xc).reshape(NHt,CERT_BLOCK,d),Yct) |
| bank_s4=v3cells[key]["KL"]["S4"]; bank_s7=v3cells[key]["KL"]["S7"] |
| s4_ok=(abs(kl_s4c-bank_s4)<=TOL_S4) if not SMOKE else True |
| replay_fail=[] |
| if not s4_ok: replay_fail.append({"leg":"S4","kl":kl_s4c,"banked":bank_s4}) |
| curve={} |
| for rk in RANKS_ARMA: |
| Ok=V[:, :rk]; Op=Ok-span5@(span5.t()@Ok) |
| Usvd,Ssvd,_=torch.linalg.svd(Op,full_matrices=False); keep=Ssvd>1e-2; O_r=Usvd[:,keep].contiguous() |
| net=int(O_r.shape[1]) |
| oP=(Xc@O_r)@O_r.t(); yk=y4-(y4@O_r)@O_r.t() |
| kl=inject_kl_full(ids_t,inj,(b2P+q35P+oP+yk-Xc).reshape(NHt,CERT_BLOCK,d),Yct) |
| ok=True |
| if rk==20 and b in S7_IS_R20 and not SMOKE: |
| ok=(abs(kl-bank_s7)<=TOL_R20) |
| if not ok: replay_fail.append({"leg":"r20","kl":kl,"banked":bank_s7}) |
| curve[str(rk)]={"net_dims":net,"KL":round(kl,5),"replay_ok":bool(ok),"total_unnamed_folded":14+net} |
| if rk==48: BASES[f"O_r48_{key}"]=O_r.cpu().contiguous(); save_bases() |
| logln(f"[armA {key} r{rk}] net={net} KL={kl:.5f} (S7 bank {bank_s7}) ok={ok}") |
| inj.close() |
| if replay_fail: res["instrument_discrepancy"].append({"stage":"armA-replay","name":key,"why":replay_fail}) |
| kl48=curve.get("48",{}).get("KL") |
| fl_rec=floors_rec[b][reg] if reg!="prose" else 0.1871 |
| fl_leg=floors_leg[b][reg] |
| gates_ok=bool(kl_idb==0.0 and s4_ok and not replay_fail) |
| closes=bool(kl48 is not None and fl_rec is not None and kl48<=fl_rec and gates_ok and RECAL_OK) |
| arma[key]={"done":True,"identity_kl":kl_idb,"S4_replay":round(kl_s4c,5),"S4_banked":bank_s4, |
| "S7_banked":bank_s7,"curve":curve,"KL_r48":kl48,"gates_ok":gates_ok, |
| "floor_recal":fl_rec,"floor_legacy":fl_leg, |
| "H_V7_A":("CLOSES-RECAL" if closes else "STAYS"), |
| "legacy_leg":{"KL":kl48,"floor":fl_leg,"pass":bool(kl48 is not None and kl48<=fl_leg)}} |
| res["armA"]["cells"]=arma; write_json() |
| logln(f"[armA {key}] r48={kl48} vs recal {fl_rec} legacy {fl_leg} -> {arma[key]['H_V7_A']}") |
| del V,G,evecs,evals,Xc,Ecur_all,b2P,q35P,yhat,y2,y4; free() |
| res["armA"]["done"]=True; write_json() |
| del Ycl_cache; free() |
|
|
| |
| |
| |
| need_train=(not res["c2"].get("done")) or (not res["armB"].get("done")) |
| if need_train and el()<HARD_WALL_S: |
| gpu_free_check("capture-train") |
| cap_tr=get_cap("train"); cap_sac=get_cap("sacred"); cap_h2=get_cap("hold2") |
| Ntr=IDS_TRAIN.shape[0] |
| maskrows=torch.zeros(Ntr,CERT_BLOCK,dtype=torch.bool); maskrows[:,P_TRAIN[0]:P_TRAIN[1]]=True |
| mrow=maskrows.reshape(-1); mrow_g=mrow.to('cuda'); mask_blk=maskrows.to('cuda') |
| mwith=torch.zeros(Ntr,CERT_BLOCK,dtype=torch.bool); mwith[:,P_WITHIN[0]:P_WITHIN[1]]=True |
| mwith_g=mwith.reshape(-1).to('cuda') |
| BCHUNK=8 if SMOKE else 32 |
|
|
| def make_scaler(feats_g,tag): |
| skey=f"scaler_{tag}" |
| if skey in BASES: |
| return BASES[skey]["mean"].to('cuda'),BASES[skey]["std"].to('cuda') |
| tr_rep=feats_g[mrow_g] |
| m_=tr_rep.mean(0,keepdim=True); s_=tr_rep.std(0,keepdim=True).clamp(min=1e-6) |
| BASES[skey]={"mean":m_.cpu(),"std":s_.cpu()}; save_bases() |
| return m_,s_ |
|
|
| def train_rung_v7(name,fin,feats_tr_g,obj_tr_g,seed,shuffle,tag): |
| torch.manual_seed(seed) |
| model=make_rung(name,fin,CERT_BLOCK).to('cuda').train() |
| opt=torch.optim.Adam(model.parameters(),lr=LR) |
| losses=[] |
| feats_rep=feats_tr_g[mrow_g]; obj_rep=obj_tr_g[mrow_g] |
| if name=="L2": |
| tgt=obj_tr_g.reshape(Ntr,CERT_BLOCK,d) |
| if shuffle: |
| idx=torch.randperm(int(mrow.sum()),device='cuda') |
| permd=obj_rep[idx] |
| tgt=tgt.clone(); tgt.reshape(-1,d)[mrow_g]=permd |
| n_elem=float(mask_blk.sum().item()*d) |
| fblk=feats_tr_g.reshape(Ntr,CERT_BLOCK,fin) |
| else: |
| tgt=obj_rep |
| if shuffle: |
| idx=torch.randperm(tgt.shape[0],device='cuda'); tgt=tgt[idx] |
| for step in range(STEPS): |
| opt.zero_grad(set_to_none=True) |
| if name=="L2": |
| acc=0.0 |
| for c0 in range(0,Ntr,BCHUNK): |
| c1=min(Ntr,c0+BCHUNK) |
| raw=model(fblk[c0:c1]) |
| oh=proj_compl(raw.reshape(-1,d)).reshape(c1-c0,CERT_BLOCK,d) |
| err=(oh-tgt[c0:c1])[mask_blk[c0:c1]] |
| loss=(err*err).sum()/n_elem |
| loss.backward(); acc+=float(loss.item()) |
| losses.append(acc) |
| else: |
| raw=model(feats_rep) |
| oh=proj_compl(raw) |
| err=oh-tgt; loss=(err*err).mean() |
| loss.backward(); losses.append(float(loss.item())) |
| opt.step() |
| if (step+1)%CKPT_STEPS==0 or step==STEPS-1: |
| BASES[f"sd_{tag}"]={k:v.detach().cpu() for k,v in model.state_dict().items()} |
| BASES[f"step_{tag}"]=step+1; save_bases() |
| logln(f"[train {tag}] step {step+1}/{STEPS} loss={losses[-1]:.5f}") |
| return model.eval(),losses |
|
|
| def rung_predict(model,name,fin,feats_g,N): |
| with torch.no_grad(): |
| if name=="L2": raw=model(feats_g.reshape(N,CERT_BLOCK,fin)).reshape(-1,d) |
| else: raw=model(feats_g) |
| return proj_compl(raw) |
|
|
| YCL={"sacred":None,"hold2":None} |
| def ycl(setname,ids_cpu): |
| |
| if setname=="train": return clean_logits(ids_cpu) |
| if YCL[setname] is None: YCL[setname]=clean_logits(ids_cpu) |
| return YCL[setname] |
|
|
| |
| def certify_rung(b,name,ct,mr,mt,feats_by_set,obj_by_set,injb,fl_rec,tag): |
| fin=CT_FIN[ct] |
| oh_s=rung_predict(mr,name,fin,feats_by_set["sacred"],N_SACRED) |
| sub_s=substitution_kl_at(b,oh_s,obj_by_set["sacred"],IDS_SACRED,ycl("sacred",IDS_SACRED),injb,want_behav=True) |
| r2_s=r2_of(oh_s,obj_by_set["sacred"],N_SACRED) |
| oh_h=rung_predict(mr,name,fin,feats_by_set["hold2"],N_HOLD2) |
| sub_h=substitution_kl_at(b,oh_h,obj_by_set["hold2"],IDS_HOLD2,ycl("hold2",IDS_HOLD2),injb) |
| r2_h=r2_of(oh_h,obj_by_set["hold2"],N_HOLD2) |
| |
| oh_t=rung_predict(mr,name,fin,feats_by_set["train"],Ntr) |
| dW=(oh_t-obj_by_set["train"]).reshape(Ntr,CERT_BLOCK,d).clone(); dW[:, :P_WITHIN[0], :]=0.0 |
| kl_within=inject_kl_pidx(IDS_TRAIN,injb,dW,ycl("train",IDS_TRAIN),torch.arange(P_WITHIN[0],CERT_BLOCK)) |
| del dW,oh_t; free() |
| |
| oh_tw=rung_predict(mt,name,fin,feats_by_set["sacred"],N_SACRED) |
| sub_tw=substitution_kl_at(b,oh_tw,obj_by_set["sacred"],IDS_SACRED,ycl("sacred",IDS_SACRED),injb) |
| r2_tw=r2_of(oh_tw,obj_by_set["sacred"],N_SACRED) |
| real_kl=sub_s["kl_rep"]; twin_kl=sub_tw["kl_rep"] |
| beats=bool(real_kl<=0.5*twin_kl); cert=bool(real_kl<=fl_rec and beats) |
| return {"rung":name,"contract":ct,"params":n_params(mr), |
| "SACRED_kl_rep":real_kl,"SACRED_kl_all":sub_s["kl_all"],"SACRED_r2":round(r2_s,4), |
| "SACRED_behav":sub_s.get("behav"), |
| "HOLD2_kl_rep":sub_h["kl_rep"],"HOLD2_r2":round(r2_h,4), |
| "WITHIN_kl_rep":round(kl_within,5),"twin_kl_rep":twin_kl,"twin_r2":round(r2_tw,4), |
| "beats_twin_2x":beats,"certified":cert,"floor":fl_rec} |
|
|
| |
| |
| |
| if not res["c2"].get("done") and el()<HARD_WALL_S: |
| gpu_free_check("c2") |
| logln("==== ARM C2: front-door ablation (drop m0 k*=1 coeff) at b5 ====") |
| ct="C2"; fin=CT_FIN[ct] |
| f_tr=contract_feats(ct,cap_tr,IDS_TRAIN) |
| scm,scs=make_scaler(f_tr,"c2_b5") |
| f_tr=(f_tr-scm)/scs |
| obj_tr5=obj_at(cap_tr,B5) |
| seed=20260707+10000*B5+1000*3+RUNG_SEED["L0"] |
| if res["c2"].get("trained") and f"sd_c2_L0_real" in BASES: |
| mr=make_rung("L0",fin,CERT_BLOCK).to('cuda').eval(); mr.load_state_dict({k:v.to('cuda') for k,v in BASES["sd_c2_L0_real"].items()}) |
| mt=make_rung("L0",fin,CERT_BLOCK).to('cuda').eval(); mt.load_state_dict({k:v.to('cuda') for k,v in BASES["sd_c2_L0_twin"].items()}) |
| tr_curves=res["c2"].get("curves",{}) |
| else: |
| mr,lr_=train_rung_v7("L0",fin,f_tr,obj_tr5,seed,False,"c2_L0_real") |
| mt,lt_=train_rung_v7("L0",fin,f_tr,obj_tr5,seed+1,True,"c2_L0_twin") |
| tr_curves={"final_loss_real":round(lr_[-1],6),"final_loss_twin":round(lt_[-1],6)} |
| res["c2"]["trained"]=True; res["c2"]["curves"]=tr_curves; write_json() |
| f_sac=(contract_feats(ct,cap_sac,IDS_SACRED)-scm)/scs |
| f_h2=(contract_feats(ct,cap_h2,IDS_HOLD2)-scm)/scs |
| feats_by_set={"train":f_tr,"sacred":f_sac,"hold2":f_h2} |
| obj_by_set={"train":obj_tr5,"sacred":obj_at(cap_sac,B5),"hold2":obj_at(cap_h2,B5)} |
| injb=InjectHook(M["blocks"][B5-1]) |
| rec=certify_rung(B5,"L0",ct,mr,mt,feats_by_set,obj_by_set,injb,FLOOR_B5_RECAL,"c2") |
| injb.close() |
| kl=rec["SACRED_kl_rep"] |
| if kl<=FLOOR_B5_RECAL: band="FRONT-DOOR-NOT-NEEDED" |
| elif kl<=0.9*W0_B5_BANK: band="FRONT-DOOR-HELPS" |
| else: band="FRONT-DOOR-ESSENTIAL" |
| res["c2"].update({"done":True,"rec":rec,"H_V7_C2":band,"delta_vs_full_contract":round(kl-S9X_SACRED,5), |
| "bands":"NOT-NEEDED <=0.1279 / HELPS <=1.43541 (0.9*W0 1.5949) / ESSENTIAL else", |
| "bet":"HELPS 50 / NOT-NEEDED 30 / ESSENTIAL 20"}) |
| write_json(); logln(f"[C2] SACRED kl_rep={kl:.5f} (full-contract bank {S9X_SACRED}) -> {band}") |
| del f_tr,f_sac,f_h2,obj_tr5,mr,mt,feats_by_set,obj_by_set; free() |
|
|
| |
| |
| |
| if not res["armB"].get("done") and el()<HARD_WALL_S: |
| armb=res["armB"].get("bounds",{}) |
| b6_cert_rung=None |
| for b in ARMB_BOUNDS: |
| brec=armb.get(str(b),{}) |
| if brec.get("done"): |
| if b==6 and brec.get("H_V7_B","").startswith("CERTIFIES") and (brec.get("best") or {}).get("rung")=="L0": |
| b6_cert_rung=(brec["best"]["rung"],brec["best"]["contract"]) |
| continue |
| if el()>HARD_WALL_S: break |
| gpu_free_check(f"armB-b{b}") |
| logln(f"==== ARM B: onset surrogate at BUS[{b}] ====") |
| fl_rec=floors_rec[b]["repetition"]; fl_leg=floors_leg[b]["repetition"]; wall=WALL_B[b] |
| injb=InjectHook(M["blocks"][b-1]) |
| |
| if not brec.get("gates"): |
| obj_s=obj_at(cap_sac,b); Nc=N_SACRED |
| Ys=ycl("sacred",IDS_SACRED) |
| kl_id,dl_id=inject_kl_full(IDS_SACRED,injb,torch.zeros(Nc,CERT_BLOCK,d,device='cuda'),Ys,want_dl=True) |
| Xcb=cap_sac[f'h{b}'].to('cuda')-mu_all[b].to('cuda') |
| Ecur=wte_g[IDS_SACRED.reshape(-1).to('cuda')] |
| kl_s4b=inject_kl_full(IDS_SACRED,injb,s4_delta(Xcb,b,Ecur).reshape(Nc,CERT_BLOCK,d),Ys) |
| dsil=(-obj_s).reshape(Nc,CERT_BLOCK,d).clone(); dsil[:, :IND_SEG, :]=0.0 |
| kl_sil=inject_kl_pidx(IDS_SACRED,injb,dsil,Ys,torch.arange(IND_SEG,CERT_BLOCK)) |
| s4ok=(abs(kl_s4b-wall)<=TOL_S4 and kl_id==0.0 and dl_id==0.0) if not SMOKE else (kl_id==0.0) |
| if not s4ok: res["instrument_discrepancy"].append({"stage":f"armB-b{b}","name":"S4/identity","why":{"S4":kl_s4b,"id":kl_id}}) |
| brec["gates"]={"identity_kl":kl_id,"identity_dlogit":dl_id,"S4_replay":round(kl_s4b,5), |
| "S4_banked":wall,"S4_ok":bool(s4ok),"silent_rep":round(kl_sil,5)} |
| armb[str(b)]=brec; res["armB"]["bounds"]=armb; write_json() |
| logln(f"[armB b{b} gates] id={kl_id}/{dl_id} S4={kl_s4b:.5f}(bk {wall}) sil={kl_sil:.5f} ok={s4ok}") |
| del obj_s,Xcb,Ecur,dsil; free() |
| W0b=brec["gates"]["silent_rep"] |
| obj_by_set={"train":obj_at(cap_tr,b),"sacred":obj_at(cap_sac,b),"hold2":obj_at(cap_h2,b)} |
| attempts=brec.get("attempts",{}) |
| def feats_sets(ct,extra_by_set=None): |
| f_tr=contract_feats(ct,cap_tr,IDS_TRAIN,(extra_by_set or {}).get("train")) |
| scm,scs=make_scaler(f_tr,f"{ct}_b{b}") |
| return {"train":(f_tr-scm)/scs, |
| "sacred":(contract_feats(ct,cap_sac,IDS_SACRED,(extra_by_set or {}).get("sacred"))-scm)/scs, |
| "hold2":(contract_feats(ct,cap_h2,IDS_HOLD2,(extra_by_set or {}).get("hold2"))-scm)/scs} |
| def run_attempt(name,ct,extra_by_set=None): |
| akey=f"{name}_{ct}" |
| if attempts.get(akey,{}).get("done"): return attempts[akey] |
| fin=CT_FIN[ct] |
| fb=feats_sets(ct,extra_by_set) |
| seedbase=20260707+10000*b+1000*{"CTA":0,"CTB":1,"CTC":2}[ct]+RUNG_SEED[name] |
| tag=f"b{b}_{akey}" |
| if f"sd_{tag}_real" in BASES and attempts.get(akey,{}).get("trained"): |
| mr=make_rung(name,fin,CERT_BLOCK).to('cuda').eval(); mr.load_state_dict({k:v.to('cuda') for k,v in BASES[f"sd_{tag}_real"].items()}) |
| mt=make_rung(name,fin,CERT_BLOCK).to('cuda').eval(); mt.load_state_dict({k:v.to('cuda') for k,v in BASES[f"sd_{tag}_twin"].items()}) |
| curves=attempts[akey].get("curves",{}) |
| else: |
| mr,lr_=train_rung_v7(name,fin,fb["train"],obj_by_set["train"],seedbase,False,f"{tag}_real") |
| mt,lt_=train_rung_v7(name,fin,fb["train"],obj_by_set["train"],seedbase+1,True,f"{tag}_twin") |
| curves={"final_loss_real":round(lr_[-1],6),"final_loss_twin":round(lt_[-1],6)} |
| attempts[akey]={"trained":True,"curves":curves}; brec["attempts"]=attempts |
| armb[str(b)]=brec; res["armB"]["bounds"]=armb; write_json() |
| |
| with torch.no_grad(): |
| ohtr=rung_predict(mr,name,fin,fb["train"],Ntr) |
| def r2m(mask): |
| e=((ohtr[mask]-obj_by_set["train"][mask])**2).sum() |
| v=((obj_by_set["train"][mask]-obj_by_set["train"][mask].mean(0))**2).sum() |
| return float(1-(e/v.clamp(min=1e-9))) |
| r2tr=r2m(mrow_g); r2wi=r2m(mwith_g) |
| del ohtr; free() |
| rec=certify_rung(b,name,ct,mr,mt,fb,obj_by_set,injb,fl_rec,tag) |
| rec.update({"done":True,"curves":curves,"r2_train":round(r2tr,4),"r2_within":round(r2wi,4), |
| "legacy_pass":bool(rec["SACRED_kl_rep"]<=fl_leg)}) |
| attempts[akey]=rec; brec["attempts"]=attempts |
| armb[str(b)]=brec; res["armB"]["bounds"]=armb; write_json() |
| logln(f"[armB b{b} {akey}] SACRED={rec['SACRED_kl_rep']:.5f} (fl {fl_rec}, twin {rec['twin_kl_rep']:.5f}, " |
| f"W0 {W0b}) r2={rec['SACRED_r2']} hold2={rec['HOLD2_kl_rep']:.5f} within={rec['WITHIN_kl_rep']:.5f} cert={rec['certified']}") |
| del mr,mt,fb; free() |
| return attempts[akey] |
| |
| a1=run_attempt("L0","CTA"); a2=run_attempt("L0","CTB") |
| cert_recs=[r for r in (a2,a1) if r.get("certified")] |
| ladder_note="L0-only (linear favored)" |
| if not cert_recs and not SMOKE and el()<HARD_WALL_S: |
| a3=run_attempt("L1","CTA"); ladder_note="L0 failed -> L1" |
| if a3.get("certified"): cert_recs=[a3] |
| elif el()<HARD_WALL_S: |
| a4=run_attempt("L2","CTA"); ladder_note="L0,L1 failed -> L2" |
| if a4.get("certified"): cert_recs=[a4] |
| if b==7 and not cert_recs and b6_cert_rung is not None and not SMOKE and el()<HARD_WALL_S: |
| |
| n6,c6=b6_cert_rung; fin6=CT_FIN[c6] |
| m6=make_rung(n6,fin6,CERT_BLOCK).to('cuda').eval() |
| m6.load_state_dict({k:v.to('cuda') for k,v in BASES[f"sd_b6_{n6}_{c6}_real"].items()}) |
| sc6m=BASES[f"scaler_{c6}_b6"]["mean"].to('cuda'); sc6s=BASES[f"scaler_{c6}_b6"]["std"].to('cuda') |
| def obj6hat(cap,ids): |
| fx=contract_feats(c6,cap,ids) |
| return rung_predict(m6,n6,fin6,(fx-sc6m)/sc6s,ids.shape[0]) |
| extra={"train":obj6hat(cap_tr,IDS_TRAIN),"sacred":obj6hat(cap_sac,IDS_SACRED), |
| "hold2":obj6hat(cap_h2,IDS_HOLD2)} |
| a5=run_attempt("L0","CTC",extra); ladder_note+=" -> CT-C" |
| if a5.get("certified"): cert_recs=[a5] |
| del m6,extra; free() |
| |
| done_recs=[r for r in attempts.values() if r.get("done")] |
| best=min(done_recs,key=lambda r:r["SACRED_kl_rep"]) if done_recs else None |
| if cert_recs: |
| best=cert_recs[0] |
| band="CERTIFIES" if best["rung"]=="L0" else "CERTIFIES-NONLINEAR" |
| elif best is not None: |
| kl=best["SACRED_kl_rep"] |
| if kl<=0.9*wall and kl<best["twin_kl_rep"] and kl<0.9*W0b: band="PARTIAL" |
| else: band="FAILS-HONESTLY" |
| else: band="NOT-RUN" |
| brec.update({"done":True,"H_V7_B":band,"ladder":ladder_note, |
| "best":{"rung":best["rung"],"contract":best["contract"],"SACRED_kl_rep":best["SACRED_kl_rep"], |
| "twin":best["twin_kl_rep"],"HOLD2":best["HOLD2_kl_rep"]} if best else None, |
| "floor_recal":fl_rec,"floor_legacy":fl_leg,"wall_S4":wall,"silent":W0b, |
| "bands":"CERTIFIES <=floor & <=0.5*twin / PARTIAL <=0.9*wall & <twin & <0.9*silent / FAILS-HONESTLY", |
| "bet":("FAILS 45 / CERT 35 / PARTIAL 20" if b==6 else "FAILS 55 / CERT 25 / PARTIAL 20")}) |
| |
| if band=="PARTIAL" and best and best["SACRED_kl_rep"]<=2*fl_rec and not brec.get("finetune") and el()<HARD_WALL_S: |
| logln(f"==== armB b{b} FAILURE BRANCH: KL-finetune {best['rung']}_{best['contract']} ====") |
| name,ct=best["rung"],best["contract"]; fin=CT_FIN[ct] |
| mF=make_rung(name,fin,CERT_BLOCK).to('cuda').train() |
| mF.load_state_dict({k:v.to('cuda') for k,v in BASES[f"sd_b{b}_{name}_{ct}_real"].items()}) |
| fb=feats_sets(ct) |
| optf=torch.optim.Adam(mF.parameters(),lr=FT_LR) |
| fbk=fb["train"].reshape(Ntr,CERT_BLOCK,fin); obk=obj_by_set["train"].reshape(Ntr,CERT_BLOCK,d) |
| yc_cache=ycl("train",IDS_TRAIN); fl_curve=[] |
| for st in range(FT_STEPS): |
| optf.zero_grad(set_to_none=True); lo=0.0 |
| for ci,s0 in enumerate(range(0,Ntr,MB)): |
| s1=min(Ntr,s0+MB) |
| if name=="L2": raw=mF(fbk[s0:s1]).reshape(-1,d) |
| else: raw=mF(fbk[s0:s1].reshape(-1,fin)) |
| oh=proj_compl(raw); objc=obk[s0:s1].reshape(-1,d) |
| delta=(oh-objc).reshape(s1-s0,CERT_BLOCK,d).clone(); delta[:, :IND_SEG, :]=0.0 |
| injb.add=delta; injb.on=True |
| lg=M["m"](IDS_TRAIN[s0:s1].to('cuda'),use_cache=False).logits; injb.on=False; injb.add=None |
| yc=yc_cache[ci].float() |
| logp=Fnn.log_softmax(yc,-1); p=logp.exp(); lp=Fnn.log_softmax(lg.float(),-1) |
| kl=(p*(logp-lp)).sum(-1)[:,IND_SEG:CERT_BLOCK].mean() |
| (kl*(s1-s0)/Ntr).backward(); lo+=float(kl.item())*(s1-s0)/Ntr |
| optf.step(); fl_curve.append(lo) |
| if (st+1)%max(1,FT_STEPS//10)==0: logln(f"[FT b{b}] step {st+1}/{FT_STEPS} trainKL={lo:.5f}") |
| mF.eval() |
| oh_s=rung_predict(mF,name,fin,fb["sacred"],N_SACRED) |
| sub_s=substitution_kl_at(b,oh_s,obj_by_set["sacred"],IDS_SACRED,ycl("sacred",IDS_SACRED),injb,want_behav=True) |
| ftc=bool(sub_s["kl_rep"]<=fl_rec) |
| BASES[f"sd_b{b}_{name}_{ct}_ft"]={k:v.detach().cpu() for k,v in mF.state_dict().items()}; save_bases() |
| brec["finetune"]={"rung":name,"contract":ct,"SACRED_kl_rep":sub_s["kl_rep"], |
| "certified_via_ft":ftc,"behav":sub_s.get("behav")} |
| if ftc: |
| brec["H_V7_B"]="CERTIFIES-VIA-KL-FINETUNE" |
| brec["best"]={"rung":name,"contract":ct,"SACRED_kl_rep":sub_s["kl_rep"], |
| "twin":best["twin_kl_rep"],"HOLD2":None,"via":"KL-finetune"} |
| del mF,fb,fbk,obk; free() |
| armb[str(b)]=brec; res["armB"]["bounds"]=armb; write_json() |
| logln(f"[armB b{b}] H-V7-B={brec['H_V7_B']} best={brec.get('best')}") |
| if b==6 and brec["H_V7_B"].startswith("CERTIFIES") and brec.get("best",{}) and brec["best"].get("rung")=="L0": |
| b6_cert_rung=(brec["best"]["rung"],brec["best"]["contract"]) |
| injb.close() |
| del obj_by_set; free() |
| res["armB"]["done"]=True; write_json() |
| YCL={"train":None,"sacred":None,"hold2":None}; free() |
|
|
| |
| |
| |
| if not SMOKE and not res["verdict"].get("done"): |
| allcells=[(r,b) for r in REGIMES for b in range(nL+1)] |
| c1band=res["c1"].get("H_V7_C1") |
| armaC=res["armA"].get("cells",{}) |
| armbB=res["armB"].get("bounds",{}) |
| def vgrain(key): |
| cell=v3cells[key]; kl=cell["KL"]["S7"]; grain="S7" |
| if key=="repetition_b5": |
| if c1band=="FAILS": kl=WALL_S4_B5; grain="S4-wall(C1-FAILS,rescoped)" |
| else: kl=S9X_SACRED; grain="S9x-surrogate(L0,V6,C1-"+str(c1band)+")" |
| for bb in (6,7): |
| if key==f"repetition_b{bb}": |
| rec=armbB.get(str(bb),{}) |
| if rec.get("H_V7_B","").startswith("CERTIFIES") and rec.get("best"): |
| kl=rec["best"]["SACRED_kl_rep"]; grain=f"S9x-onset({rec['best']['rung']},{rec['best']['contract']})" |
| for bb in (8,9,10,11): |
| if key==f"repetition_b{bb}": kl=V6_R48_REP[bb]; grain="S7-r48-folded(carried V6)" |
| if key=="repetition_b12": kl=B12_R48_BANK; grain="S7-r48-folded(carried V5)" |
| rec=armaC.get(key) |
| if rec and rec.get("done") and rec.get("gates_ok") and rec.get("KL_r48") is not None: |
| kl=rec["KL_r48"]; grain="S7-r48-folded(V7)" |
| return kl,grain |
| tables={} |
| for meter in ("legacy","recal"): |
| tab={}; N_open=0; N_grain=0; gaps=[] |
| for (r,b) in allcells: |
| key=f"{r}_b{b}"; cell=v3cells[key] |
| if meter=="legacy": fl=floors_leg[b][r] |
| else: |
| fl=floors_rec[b].get(r) if r!="prose" else 0.1871 |
| if fl is None or not RECAL_OK: fl=floors_leg[b][r] |
| kl,grain=vgrain(key) |
| p_open=bool(cell["KL"]["S2w"]<=fl); p_grain=bool(kl<=fl) |
| if p_open: N_open+=1 |
| if p_grain: N_grain+=1 |
| else: gaps.append({"cell":key,"grain":grain,"KL":round(kl,5),"floor":round(fl,5), |
| "excess_nats":round(kl-fl,5),"ratio":round(kl/fl,2)}) |
| tab[key]={"KL":round(kl,5),"grain":grain,"floor":round(fl,5),"pass_open":p_open,"pass_grain":p_grain} |
| gaps.sort(key=lambda x:-x["excess_nats"]) |
| tables[meter]={"cells":tab,"N_open":N_open,"N_grain":N_grain,"gap_cells":len(gaps), |
| "unexplained_nats":round(sum(g["excess_nats"] for g in gaps),3),"gap_table":gaps} |
| primary="recal" if RECAL_OK else "legacy" |
| pt=tables[primary] |
| if pt["N_open"]==39: Ha="OPEN" |
| elif pt["N_grain"]==39: Ha="OPEN-AT-GRAIN" |
| else: Ha="NOT-YET" |
| res["verdict"]={"done":True,"H_V7_VERDICT":Ha,"primary_meter":primary,"tables":tables, |
| "c1_band":c1band,"c2_band":res["c2"].get("H_V7_C2"), |
| "armA_closures":{k:v.get("H_V7_A") for k,v in armaC.items()}, |
| "armB_bands":{k:v.get("H_V7_B") for k,v in armbB.items()}, |
| "verdict_bet":"NOT-YET 90 / OPEN-AT-GRAIN 9 / OPEN 1","g_room":0.8614, |
| "escalation":("band MET -> program-complete recommendation + STOP, Will ratifies" if Ha=="OPEN-AT-GRAIN" |
| else "NOT-YET -> gap tables (both meters) + fork if onset-only + STOP, Will decides")} |
| write_json() |
| logln(f"[VERDICT] primary={primary} H-V7={Ha} | recal N_grain={tables['recal']['N_grain']} " |
| f"gaps={tables['recal']['gap_cells']} unexpl={tables['recal']['unexplained_nats']} | " |
| f"legacy N_grain={tables['legacy']['N_grain']} gaps={tables['legacy']['gap_cells']} " |
| f"unexpl={tables['legacy']['unexplained_nats']}") |
|
|
| |
| certB=[bb for bb in ("6","7") if res["armB"].get("bounds",{}).get(bb,{}).get("H_V7_B","").startswith("CERTIFIES")] |
| if not SMOKE and certB and not res.get("v7_frozen"): |
| v7T=dict(dv6) |
| for bb in certB: |
| rec=res["armB"]["bounds"][bb]["best"] |
| name,ct=rec["rung"],rec["contract"] |
| sdk=f"sd_b{bb}_{name}_{ct}_"+("ft" if rec.get("via")=="KL-finetune" else "real") |
| v7T[f"onset_b{bb}_rung"]=name; v7T[f"onset_b{bb}_contract"]=ct |
| v7T[f"onset_b{bb}_state_dict"]=BASES[sdk] |
| v7T[f"onset_b{bb}_scaler_mean"]=BASES[f"scaler_{ct}_b{bb}"]["mean"] |
| v7T[f"onset_b{bb}_scaler_std"]=BASES[f"scaler_{ct}_b{bb}"]["std"] |
| for k in list(BASES.keys()): |
| if str(k).startswith("O_r48_"): v7T[k]=BASES[k] |
| tmp=os.path.join(DIR,"decoder_v7_tensors.pt.tmp"); torch.save(v7T,tmp); os.replace(tmp,os.path.join(DIR,"decoder_v7_tensors.pt")) |
| cfg={"version":"DECODER_V7 1.0 (2026-07-05)","propose_only":True,"pre_registration":PEN, |
| "assembly":"decoder_v6 + S9x onset rung(s) at BUS[6]/BUS[7] (certified on held-out periods) + V7 folded r48 reads", |
| "onset":{bb:res["armB"]["bounds"][bb]["best"] for bb in certB}, |
| "source_sha256":O["src_sha"]} |
| tmp=os.path.join(DIR,"decoder_v7.json.tmp") |
| with open(tmp,"w",encoding="utf-8") as f: json.dump(cfg,f,indent=1,default=str) |
| os.replace(tmp,os.path.join(DIR,"decoder_v7.json")) |
| res["v7_frozen"]={"tensors_sha":sha256(os.path.join(DIR,"decoder_v7_tensors.pt")), |
| "json_sha":sha256(os.path.join(DIR,"decoder_v7.json"))} |
| write_json(); logln(f"[FREEZE] DECODER_V7 frozen: {res['v7_frozen']}") |
|
|
| |
| if SMOKE: |
| sm={"M0a":res["gates"]["M0a"]["pass"],"dec_v6":res["gates"]["decoder_v6"]["sha_ok"], |
| "b5_gates_id":res["gates"].get("b5",{}).get("identity_kl"), |
| "c1":bool(res["c1"].get("done")),"armA":bool(res["armA"].get("done")), |
| "c2":bool(res["c2"].get("done")),"armB":bool(res["armB"].get("done"))} |
| ok=(res["gates"]["M0a"]["pass"] and res["gates"]["decoder_v6"]["sha_ok"] |
| and res["gates"].get("b5",{}).get("identity_kl")==0.0 |
| and all(bool(sm[k]) for k in ("c1","armA","c2","armB"))) |
| res["S_smoke"]=sm; res["status"]="SMOKE-"+("OK" if ok else "FAIL") |
| logln(f"[SMOKE] {json.dumps(sm)} -> {res['status']}") |
| else: |
| done=(bool(res["c1"].get("done")) and bool(res["armA"].get("done")) |
| and bool(res["c2"].get("done")) and bool(res["armB"].get("done")) and bool(res["verdict"].get("done"))) |
| res["status"]=("COMPLETE" if (done and not res["instrument_discrepancy"]) else |
| ("COMPLETE-WITH-DISCREPANCY" if done else "PARTIAL")) |
| save_bases(); write_json() |
| if M["m"] is not None: del M["m"]; M["m"]=None; free() |
| except Exception as e: |
| res["fatal_error"]={"error":str(e),"trace":traceback.format_exc()} |
| logln(f"FATAL {e}\n{traceback.format_exc()}"); res.setdefault("status","FATAL") |
| write_json() |
| logln(f"V7 END status={res.get('status')} elapsed={el()}s") |
| open(os.path.join(DIR,"_v7_smoke_gpu.done" if SMOKE else "_v7_gpu.done"),"w").write(str(res.get("status","?"))+"\n") |
| logln("*** V7_"+("SMOKE_" if SMOKE else "")+"DONE ***"); LOG.flush(); LOG.close(); print("done") |
|
|
