Freeze H2 graph-token implementation and nonzero gradient CPU acceptance
This commit is contained in:
1 parent
c1e2077e8a
commit
7054acdbe0
9 files changed
+1516
No files matched your search
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"status": "PASS",
|
||||
"returncode": 0,
|
||||
"stop_reason": null,
|
||||
"cpu_seconds": 5.141596,
|
||||
"wall_seconds": 5.269344478030689,
|
||||
"peak_tree_rss_bytes": 539783168,
|
||||
"peak_process_count": 1,
|
||||
"monitor_errors": [],
|
||||
"max_poll_gap_seconds": 0.4821044849813916,
|
||||
"reaped_orphan_cpu_seconds": 0.0,
|
||||
"limits": {
|
||||
"cpu_seconds": 60,
|
||||
"wall_seconds": 90,
|
||||
"rss_bytes": 2147483648,
|
||||
"disk_bytes": 67108864
|
||||
},
|
||||
"retry": false,
|
||||
"gpu_visible": false
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
{
|
||||
"pid": 581270,
|
||||
"unix": 1794900741.331274,
|
||||
"guard_pid": 581269
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
test_failed_worker_recorded_peak_rejected (__main__.Acceptance) ... ok
|
||||
test_fixed_schedule_and_all_node_weighting (__main__.Acceptance) ... ok
|
||||
test_full_chunk_nonzero_gradient_optimizer_and_detach_negative (__main__.Acceptance) ... ok
|
||||
test_model_message_component_isolation (__main__.Acceptance) ... ok
|
||||
test_node_permutation_and_raw_id_query_recovery (__main__.Acceptance) ... ok
|
||||
test_receiver_across_chunks_uses_sums (__main__.Acceptance) ... ok
|
||||
test_true_tet_edges_no_air_and_scale_once (__main__.Acceptance) ... ok
|
||||
test_zero_head_exact_FP64_skip (__main__.Acceptance) ... ok
|
||||
|
||||
----------------------------------------------------------------------
|
||||
Ran 8 tests in 1.314s
|
||||
|
||||
OK
|
||||
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"status": "PASS",
|
||||
"returncode": 0,
|
||||
"stop_reason": null,
|
||||
"cpu_seconds": 5.141596,
|
||||
"wall_seconds": 5.269344478030689,
|
||||
"peak_tree_rss_bytes": 539783168,
|
||||
"peak_process_count": 1,
|
||||
"monitor_errors": [],
|
||||
"max_poll_gap_seconds": 0.4821044849813916,
|
||||
"reaped_orphan_cpu_seconds": 0.0,
|
||||
"limits": {
|
||||
"cpu_seconds": 60,
|
||||
"wall_seconds": 90,
|
||||
"rss_bytes": 2147483648,
|
||||
"disk_bytes": 67108864
|
||||
},
|
||||
"retry": false,
|
||||
"gpu_visible": false
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
{
|
||||
"command": [
|
||||
"/home/frank14f/optane/MeltMind/artifacts/gre24-reproduction-2026-11-15/environment/venv/bin/python",
|
||||
"tools/test_phase2_h2.py",
|
||||
"artifacts/phase2-h2-acceptance-2026-11-17/attempt-01"
|
||||
],
|
||||
"limits": {
|
||||
"cpu_seconds": 60,
|
||||
"wall_seconds": 90,
|
||||
"rss_bytes": 2147483648,
|
||||
"disk_bytes": 67108864
|
||||
},
|
||||
"unix": 1794900741.3294325
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,13 @@
|
||||
{
|
||||
"status": "CPU_MODEL_ACCEPTANCE_PASS",
|
||||
"code_sha256": {
|
||||
"tools/phase2_h2_model.py": "fab2470dd0654ca74c3b7d893f35ad1f3ae6c5c08ffe334ef6312cf6ec87892a",
|
||||
"tools/test_phase2_h2.py": "a8e1d8dccecee3aaab6aca8bfe5706664930b752dfbaf09c19817e550316e63c"
|
||||
},
|
||||
"gradient_max_absolute": 2.086162567138672e-07,
|
||||
"update_max_absolute": 3.725290298461914e-07,
|
||||
"min_nonzero_path_gradient_norm": 0.0004382907063700259,
|
||||
"tests": 8,
|
||||
"guard_cpu_seconds": 5.141596,
|
||||
"not_gpu_acceptance": true
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
"""H2-GEO reviewed fixed FP32 graph/token recipe; no data or launches."""
|
||||
import math
|
||||
import numpy as np
|
||||
import torch
|
||||
from torch import nn
|
||||
from torch.utils.checkpoint import checkpoint
|
||||
|
||||
EDGE_CHUNK=65536
|
||||
NODE_CHUNK=8192
|
||||
ATOL=3e-5
|
||||
RTOL=3e-4
|
||||
|
||||
def lr_epoch(epoch):
|
||||
if not 1<=epoch<=200:raise ValueError('Fixed 1-based epochs 1..200')
|
||||
if epoch<=10:return 1e-4+(epoch-1)*9e-4/9
|
||||
return 1e-5+(1e-3-1e-5)*(1+math.cos(math.pi*(epoch-10)/190))/2
|
||||
|
||||
def namespace_components(part_ids,local_ids):
|
||||
keys=list(zip(part_ids,local_ids));lookup={k:i for i,k in enumerate(sorted(set(keys)))}
|
||||
return np.array([lookup[k] for k in keys],np.int64)
|
||||
|
||||
def edge_attributes(points,mass,receiver,sender):
|
||||
x=np.asarray(points,np.float64);m=np.asarray(mass,np.float64)
|
||||
if not np.isfinite(x).all() or not np.isfinite(m).all() or np.any(m<=0):raise ValueError('Invalid geometry/mass')
|
||||
center=np.sum(x*m[:,None],axis=0)/m.sum()
|
||||
rg=float(np.sqrt(np.sum(m*np.sum((x-center)**2,axis=1))/m.sum()))
|
||||
if not math.isfinite(rg) or rg<=0:raise ValueError('Invalid mass Rg')
|
||||
xi=(x-center)/rg;delta=xi[sender]-xi[receiver];length=np.linalg.norm(delta,axis=1)
|
||||
if np.any(length<=0):raise ValueError('Nonpositive true edge')
|
||||
return np.column_stack([delta,length]).astype(np.float32),rg
|
||||
|
||||
class GeoBlock(nn.Module):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.local_norm=nn.LayerNorm(64);self.global_norm=nn.LayerNorm(64);self.ffn_norm=nn.LayerNorm(64)
|
||||
self.edge=nn.Sequential(nn.Linear(4,16),nn.GELU(),nn.Linear(16,1),nn.Softplus())
|
||||
self.local_value=nn.Linear(64,64,bias=False)
|
||||
self.assignment=nn.Linear(64,64);self.global_value=nn.Linear(64,64,bias=False)
|
||||
self.attention=nn.MultiheadAttention(64,4,dropout=0,batch_first=True)
|
||||
self.ffn=nn.Sequential(nn.Linear(64,128),nn.GELU(),nn.Linear(128,64))
|
||||
|
||||
def local(self,h,m,receiver,sender,attributes,edge_chunk):
|
||||
values=self.local_value(h);num=h.new_zeros(h.shape);den=h.new_zeros((len(h),1))
|
||||
for lo in range(0,len(sender),edge_chunk):
|
||||
hi=lo+edge_chunk;r=receiver[lo:hi];s=sender[lo:hi]
|
||||
weight=self.edge(attributes[lo:hi])*m[s,None]
|
||||
num.index_add_(0,r,weight*values[s]);den.index_add_(0,r,weight)
|
||||
occupied=torch.bincount(receiver,minlength=len(h))>0
|
||||
if not bool(torch.isfinite(den).all()) or bool((den[occupied]<=0).any()):raise ValueError('Invalid local denominator')
|
||||
safe=torch.where(occupied[:,None],den,torch.ones_like(den))
|
||||
return num/safe
|
||||
|
||||
def global_message(self,h,m,components,node_chunk,detach_global=False):
|
||||
out=h.new_zeros(h.shape)
|
||||
for ids in components:
|
||||
numerator=h.new_zeros((64,64));denominator=h.new_zeros((64,1));chunks=[]
|
||||
for lo in range(0,len(ids),node_chunk):
|
||||
ix=ids[lo:lo+node_chunk];hh=h[ix]
|
||||
assignment=torch.softmax(self.assignment(hh),dim=-1)
|
||||
weighted=assignment*m[ix,None]
|
||||
numerator=numerator+weighted.T@self.global_value(hh)
|
||||
denominator=denominator+weighted.sum(0)[:,None]
|
||||
chunks.append((ix,assignment))
|
||||
if not bool(torch.isfinite(denominator).all()) or bool((denominator<=0).any()):raise ValueError('Invalid token denominator')
|
||||
z=numerator/denominator
|
||||
if detach_global:z=z.detach() # Only the synthetic negative control enables this.
|
||||
z=self.attention(z[None],z[None],z[None],need_weights=False)[0][0]
|
||||
for ix,assignment in chunks:out.index_copy_(0,ix,assignment@z)
|
||||
return out
|
||||
|
||||
def forward(self,h,m,receiver,sender,attributes,components,edge_chunk,node_chunk,detach_global=False):
|
||||
h=h+self.local(self.local_norm(h),m,receiver,sender,attributes,edge_chunk)
|
||||
h=h+self.global_message(self.global_norm(h),m,components,node_chunk,detach_global)
|
||||
return h+self.ffn(self.ffn_norm(h))
|
||||
|
||||
class H2Geo(nn.Module):
|
||||
def __init__(self):
|
||||
super().__init__();self.encoder=nn.Sequential(nn.Linear(19,64),nn.GELU(),nn.Linear(64,64))
|
||||
self.blocks=nn.ModuleList([GeoBlock() for _ in range(4)])
|
||||
self.head=nn.Sequential(nn.Linear(83,64),nn.GELU(),nn.Linear(64,1))
|
||||
nn.init.zeros_(self.head[-1].weight);nn.init.zeros_(self.head[-1].bias)
|
||||
|
||||
def forward(self,x,m,receiver,sender,attributes,component_ids,*,edge_chunk=EDGE_CHUNK,node_chunk=NODE_CHUNK,checkpoint_blocks=True,detach_global=False):
|
||||
if x.dtype!=torch.float32 or m.dtype!=torch.float32 or attributes.dtype!=torch.float32:raise ValueError('Only FP32 model/aggregations')
|
||||
if not bool(torch.isfinite(m).all()) or bool((m<=0).any()):raise ValueError('Nonpositive mass; no epsilon')
|
||||
if bool((component_ids[receiver]!=component_ids[sender]).any()):raise ValueError('Cross-component edge')
|
||||
components=[torch.nonzero(component_ids==c,as_tuple=True)[0] for c in torch.unique(component_ids)]
|
||||
h=self.encoder(x)
|
||||
for block in self.blocks:
|
||||
def run(v,b=block):return b(v,m,receiver,sender,attributes,components,edge_chunk,node_chunk,detach_global)
|
||||
h=checkpoint(run,h,use_reentrant=False,preserve_rng_state=False) if checkpoint_blocks and self.training and torch.is_grad_enabled() else run(h)
|
||||
outputs=[]
|
||||
for lo in range(0,len(x),node_chunk):outputs.append(self.head(torch.cat([h[lo:lo+node_chunk],x[lo:lo+node_chunk]],dim=-1))[:,0])
|
||||
return torch.cat(outputs)
|
||||
|
||||
def optimizer(model):
|
||||
decay=[];no_decay=[]
|
||||
for name,p in model.named_parameters():
|
||||
(no_decay if name.endswith('bias') or p.ndim==1 else decay).append(p)
|
||||
return torch.optim.AdamW([dict(params=decay,weight_decay=1e-4),dict(params=no_decay,weight_decay=0.)],lr=lr_epoch(1),betas=(.9,.999),eps=1e-8)
|
||||
|
||||
def weighted_loss(prediction,target,parts,part_nodes,total_nodes):
|
||||
if len(prediction)!=part_nodes or prediction.shape!=target.shape:raise ValueError('Full part loss shape')
|
||||
return torch.mean((prediction-target)**2)*(parts*part_nodes/total_nodes)
|
||||
|
||||
def comparison(a,b):
|
||||
a=a.detach();b=b.detach();difference=float((a-b).abs().max());scale=float(a.abs().max())
|
||||
return dict(max_absolute=difference,reference_scale=scale,relative_to_scale=difference/max(scale,1e-30),passed=difference<=ATOL+RTOL*scale)
|
||||
@@ -0,0 +1,106 @@
|
||||
"""CPU-only nonzero-gradient, component isolation and resource acceptance."""
|
||||
import copy
|
||||
import json
|
||||
from pathlib import Path
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
import unittest
|
||||
import numpy as np
|
||||
import torch
|
||||
from phase2_h2_model import H2Geo,GeoBlock,optimizer,weighted_loss,comparison,edge_attributes,namespace_components,lr_epoch,ATOL,RTOL
|
||||
from phase2_h1_topology import graph
|
||||
from phase2_residual_math import residual_target,decode_seconds
|
||||
from s2_main_memory_guard import PeakRecords,VRAM_BYTES
|
||||
|
||||
EVIDENCE={}
|
||||
torch.set_num_threads(1)
|
||||
|
||||
def fixture():
|
||||
torch.manual_seed(41)
|
||||
x=torch.randn(12,19);m=torch.linspace(.3,3.1,12)
|
||||
edges=[(i,j) for base in [0,6] for i in range(base,base+6) for j in range(base,base+6) if i!=j]
|
||||
r=torch.tensor([i for i,j in edges]);s=torch.tensor([j for i,j in edges]);a=torch.randn(len(edges),4)
|
||||
a[:,3]=a[:,:3].norm(dim=1);comp=torch.tensor([0]*6+[1]*6)
|
||||
return x,m,r,s,a,comp
|
||||
|
||||
def nonzero_model():
|
||||
torch.manual_seed(0);model=H2Geo()
|
||||
with torch.no_grad():model.head[-1].weight.copy_(torch.linspace(-.13,.17,64)[None]);model.head[-1].bias.fill_(.027)
|
||||
return model
|
||||
|
||||
class Acceptance(unittest.TestCase):
|
||||
def test_zero_head_exact_FP64_skip(self):
|
||||
model=H2Geo();p=model(*fixture());np.testing.assert_array_equal(p.detach().numpy(),0)
|
||||
f=np.linspace(0,1,12,dtype=np.float64)+np.arange(12)*1e-17;c=1.1712345678912345;t=.237
|
||||
np.testing.assert_array_equal(decode_seconds(p.detach().numpy(),f,c,t),c*f*t)
|
||||
y=np.linspace(0,1.4,12);np.testing.assert_array_equal(residual_target(y,f,c,fit_dtype='float32'),(y-c*f).astype(np.float32))
|
||||
|
||||
def test_full_chunk_nonzero_gradient_optimizer_and_detach_negative(self):
|
||||
data=fixture();target=torch.linspace(-.4,.9,12);full=nonzero_model();chunk=copy.deepcopy(full);bad=copy.deepcopy(full)
|
||||
opt1=optimizer(full);opt2=optimizer(chunk)
|
||||
a=full(*data,edge_chunk=10000,node_chunk=10000,checkpoint_blocks=False)
|
||||
b=chunk(*data,edge_chunk=7,node_chunk=2,checkpoint_blocks=True)
|
||||
loss1=weighted_loss(a,target,7,12,103);loss2=weighted_loss(b,target,7,12,103)
|
||||
loss1.backward();loss2.backward();e=dict(output=comparison(a,b),loss=comparison(loss1,loss2),gradients={},nonzero_paths={},updates={})
|
||||
for (name,p),(other,q) in zip(full.named_parameters(),chunk.named_parameters()):
|
||||
self.assertEqual(name,other);self.assertIsNotNone(p.grad);self.assertIsNotNone(q.grad)
|
||||
e['gradients'][name]=comparison(p.grad,q.grad)
|
||||
for block in [0,1,2,3]:
|
||||
for suffix in ['edge.0.weight','local_value.weight','assignment.weight','global_value.weight']:
|
||||
name=f'blocks.{block}.{suffix}';g=dict(full.named_parameters())[name].grad;norm=float(g.norm());e['nonzero_paths'][name]=norm;self.assertGreater(norm,1e-9)
|
||||
self.assertTrue(e['output']['passed'] and e['loss']['passed']);self.assertTrue(all(x['passed'] for x in e['gradients'].values()))
|
||||
torch.nn.utils.clip_grad_norm_(full.parameters(),1.);torch.nn.utils.clip_grad_norm_(chunk.parameters(),1.);opt1.step();opt2.step()
|
||||
for (name,p),(_,q) in zip(full.named_parameters(),chunk.named_parameters()):e['updates'][name]=comparison(p,q)
|
||||
self.assertTrue(all(x['passed'] for x in e['updates'].values()))
|
||||
wrong=bad(*data,edge_chunk=7,node_chunk=2,checkpoint_blocks=True,detach_global=True);weighted_loss(wrong,target,7,12,103).backward()
|
||||
names=[f'blocks.{i}.global_value.weight' for i in range(4)]
|
||||
e['detach_negative']={n:dict(reference_norm=e['nonzero_paths'][n],bad_has_gradient=dict(bad.named_parameters())[n].grad is not None) for n in names}
|
||||
self.assertTrue(all(not v['bad_has_gradient'] for v in e['detach_negative'].values()));EVIDENCE['nonzero_full_chunk']=e
|
||||
|
||||
def test_receiver_across_chunks_uses_sums(self):
|
||||
block=GeoBlock();h=torch.arange(6,dtype=torch.float32)[:,None].expand(-1,64);m=torch.tensor([1.,2.,4.,8.,3.,7.])
|
||||
r=torch.tensor([0,0,0,0,0]);s=torch.arange(1,6);a=torch.zeros(5,4)
|
||||
with torch.no_grad():block.local_value.weight.copy_(torch.eye(64))
|
||||
value=block.local(h,m,r,s,a,2);expected=(m[1:]*torch.arange(1,6)).sum()/m[1:].sum()
|
||||
torch.testing.assert_close(value[0],expected.expand(64));torch.testing.assert_close(value[1:],torch.zeros(5,64))
|
||||
constant=block.local(torch.ones_like(h)*3,m,r,s,a,2);torch.testing.assert_close(constant[0],torch.full((64,),3.))
|
||||
|
||||
def test_model_message_component_isolation(self):
|
||||
data=fixture();block=nonzero_model().blocks[0];h=torch.randn(12,64);changed=h.clone();changed[6:]+=torch.arange(64)*10
|
||||
args=(data[1],data[2],data[3],data[4],[torch.arange(6),torch.arange(6,12)],7,2)
|
||||
torch.testing.assert_close(block(h,*args)[:6],block(changed,*args)[:6],rtol=0,atol=0)
|
||||
ids=namespace_components(['a']*6+['b']*6,[0]*12);np.testing.assert_array_equal(ids,[0]*6+[1]*6)
|
||||
|
||||
def test_node_permutation_and_raw_id_query_recovery(self):
|
||||
data=fixture();model=nonzero_model().eval();x,m,r,s,a,c=data
|
||||
perm=torch.tensor([7,2,11,0,9,6,4,1,8,10,5,3]);inverse=torch.argsort(perm)
|
||||
p=model(*data,checkpoint_blocks=False);q=model(x[perm],m[perm],inverse[r],inverse[s],a,c[perm],edge_chunk=7,node_chunk=2,checkpoint_blocks=False)
|
||||
torch.testing.assert_close(p,q[inverse],atol=ATOL,rtol=RTOL)
|
||||
raw=np.arange(12)*7+3;query=raw[[2,5,9]];np.testing.assert_array_equal(np.searchsorted(raw,query),[2,5,9])
|
||||
|
||||
def test_true_tet_edges_no_air_and_scale_once(self):
|
||||
x=np.array([[0,0,0],[1,0,0],[0,1,0],[0,0,1],[.01,.01,.01],[1.01,.01,.01],[.01,1.01,.01],[.01,.01,1.01]])
|
||||
t=np.array([[0,1,2,3],[4,5,6,7]]);g=graph(x,t);r=np.repeat(np.arange(8),np.diff(g.indptr));s=g.indices
|
||||
self.assertEqual(g.nnz,24);self.assertFalse(np.any((r<4)!=(s<4)))
|
||||
m=np.arange(1,9);a,rg=edge_attributes(x,m,r,s);aa,rr=edge_attributes(x*13+4,m,r,s)
|
||||
np.testing.assert_allclose(a,aa,rtol=1e-6,atol=1e-7);self.assertAlmostEqual(rr/rg,13)
|
||||
np.testing.assert_allclose(a[:,:3],((x[s]-x[r])/rg).astype(np.float32),rtol=1e-6,atol=1e-7)
|
||||
|
||||
def test_failed_worker_recorded_peak_rejected(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
p=Path(temp)/'failure.json';p.write_text(json.dumps(dict(status='FAILED',peak_allocated_bytes=1,peak_reserved_bytes=VRAM_BYTES+1)))
|
||||
tracker=PeakRecords();self.assertTrue(tracker.scan(temp));p.unlink();self.assertTrue(tracker.scan(temp));self.assertEqual(tracker.maxima['peak_reserved_bytes'],VRAM_BYTES+1)
|
||||
|
||||
def test_fixed_schedule_and_all_node_weighting(self):
|
||||
self.assertAlmostEqual(lr_epoch(1),1e-4);self.assertAlmostEqual(lr_epoch(10),1e-3);self.assertAlmostEqual(lr_epoch(200),1e-5)
|
||||
self.assertTrue(all(lr_epoch(i+1)<lr_epoch(i) for i in range(10,200)))
|
||||
a=torch.tensor([1.,2.]);b=torch.tensor([3.,4.,5.]);z=lambda x:torch.zeros_like(x)
|
||||
loss=(weighted_loss(a,z(a),2,2,5)+weighted_loss(b,z(b),2,3,5))/2
|
||||
torch.testing.assert_close(loss,torch.cat([a,b]).square().mean())
|
||||
|
||||
if __name__=='__main__':
|
||||
out=Path(sys.argv[1]);out.mkdir(parents=True,exist_ok=True);start=time.process_time()
|
||||
suite=unittest.defaultTestLoader.loadTestsFromTestCase(Acceptance);r=unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
(out/'synthetic-details.json').write_text(json.dumps(dict(status='PASS' if r.wasSuccessful() else 'FAIL',tests=r.testsRun,failures=len(r.failures),errors=len(r.errors),cpu_seconds=time.process_time()-start,atol=ATOL,rtol=RTOL,evidence=EVIDENCE),indent=2)+'\n')
|
||||
raise SystemExit(0 if r.wasSuccessful() else 1)
|
||||
Reference in new issue
Block a user