Files
MeltMind/tools/test_phase2_h2.py
T

107 lines
7.4 KiB
Python

"""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)