Files
MeltMind/tools/test_s2_main_matrix.py

134 lines
9.3 KiB
Python

import json
from pathlib import Path
import tempfile
import unittest
from unittest.mock import patch
import numpy as np
import s2_main_data as data
import run_s2_main_matrix as matrix
from prepare_s2_main_matrix import build_runs
def fake_plan():
runs=[];blocks=[]
for i in range(45):
indices=[]
for arm in ['N','E']:
indices.append(len(runs));runs.append(dict(name=f'{i}-{arm}',arm=arm,cost_nodes=100))
blocks.append(dict(run_indices=indices))
return dict(runs=runs,blocks=blocks,limits=dict(aggregate_gpu_seconds=46*3600),gpu_uuids=['g0','g1','g2','g3'],gpu_cpu_affinities=[[0],[1],[2],[3]],roster_sha256='frozen')
class MatrixChecks(unittest.TestCase):
def test_real_roster_all_15_selections_match_frozen_counts(self):
r=json.loads(Path('artifacts/s2-main-preparation-2026-11-15/final-roster.json').read_text())
runs,blocks,cells=build_runs(r)
self.assertEqual((len(runs),len(blocks),len(cells)),(90,45,15))
for cell,count in zip(cells,r['fold_pool_counts']):
for role in ['learning','validation']:
self.assertEqual(len(cell['roles'][role+'_parts']),count[role]['parts'])
self.assertEqual(cell[role+'_nodes'],count[role]['nodes'])
self.assertFalse(set(cell['roles']['learning_parts'])&set(cell['roles']['sealed_test_parts']))
for block in blocks:
n,e=[runs[i] for i in block['run_indices']]
self.assertEqual((n['arm'],e['arm']),('N','E'))
self.assertEqual((n['fold'],n['pool'],n['seed']),(e['fold'],e['pool'],e['seed']))
def test_current_test_rejected_before_any_target_io_even_old_cache(self):
roles=dict(learning_parts=['learn'],validation_parts=['val'],sealed_test_parts=['test'])
with patch.object(data,'sha',side_effect=AssertionError('IO')),patch.object(data.Path,'mkdir',side_effect=AssertionError('IO')),patch.object(data,'read_non_test_fill_time',side_effect=AssertionError('decode')):
with self.assertRaises(PermissionError):data.ensure_targets(Path('/nonexistent'),{},dict(case='test'),roles,{'test':{}})
def test_current_fold_not_other_fold_controls_access(self):
r=dict(parts=[dict(case='a',included=True,assignments=[dict(fold=0,role='test',learning_pools=[]),dict(fold=1,role='learning',learning_pools=['25','50','100'])]),
dict(case='b',included=True,assignments=[dict(fold=0,role='learning',learning_pools=['25']),dict(fold=1,role='validation',learning_pools=[])]),
dict(case='c',included=True,assignments=[dict(fold=0,role='validation',learning_pools=[]),dict(fold=1,role='test',learning_pools=[])])])
a,_=data.select_cell(r,0,25);b,_=data.select_cell(r,1,25)
self.assertNotIn('a',a);self.assertIn('a',b);self.assertNotIn('c',b)
def test_lazy_targets_created_once_and_reused_only_after_role_check(self):
with tempfile.TemporaryDirectory() as t:
root=Path(t);prep=root/'geom';prep.mkdir();archive=root/'archive';archive.write_bytes(b'synthetic')
np.savez(prep/'geometry.npz',raw_node_ids=np.array([0,1,2]))
np.savez(prep/'queries.npz',anchor_ids=np.array([1,2]),eligible_s2=np.array([True,False]),multiplicity=np.array([1500,500]))
hashes={n:data.sha(prep/n) for n in ['geometry.npz','queries.npz']};st=archive.stat()
c=dict(archive=str(archive),archive_stat=dict(bytes=st.st_size,mtime_ns=st.st_mtime_ns,inode=st.st_ino),roster_sha256='fixed')
row=dict(case='a',preparation=dict(preparation_root=str(prep),output_sha256=hashes,t_set=2.))
roles=dict(fold=1,learning_parts=['a'],validation_parts=[],sealed_test_parts=[])
with patch.object(data,'read_non_test_fill_time',return_value=(np.array([0.,4.,8.]),dict(decoded_label_arrays=['Fill_time']))) as decode:
path,digest,mode=data.ensure_targets(root,c,row,roles,{})
path2,digest2,mode2=data.ensure_targets(root,c,row,roles,{})
self.assertEqual(decode.call_count,1);self.assertEqual((path,digest),(path2,digest2))
with np.load(path,allow_pickle=False) as z:
np.testing.assert_array_equal(z['target_t_star'],[2.]);np.testing.assert_array_equal(z['anchor_ids'],[1])
roles.update(learning_parts=[],sealed_test_parts=['a'])
with self.assertRaises(PermissionError):data.ensure_targets(root,c,row,roles,{})
self.assertEqual(decode.call_count,1)
def test_numerical_loop_unchanged_and_no_checkpoint_loading(self):
old=Path('tools/run_s2_pilot_training_v2.py').read_text();new=Path('tools/run_s2_main_training.py').read_text()
extract=lambda s:s[s.index(' for epoch in range(epoch_limit):'):s.index(' result=dict')]
self.assertEqual(extract(old),extract(new));self.assertNotIn('torch.load(',new);self.assertNotIn('load_state_dict(',new)
def test_budget_reservation_and_first_eight_dispatch_gate(self):
c=fake_plan();cap=c['limits']['aggregate_gpu_seconds']
self.assertFalse(matrix.can_dispatch(c,4,0,0,False))
self.assertTrue(matrix.can_dispatch(c,4,0,0,True))
self.assertFalse(matrix.can_dispatch(c,5,3,cap-4*matrix.BLOCK_WALL_CAP+1,True))
self.assertTrue(matrix.can_dispatch(c,5,3,cap-4*matrix.BLOCK_WALL_CAP,True))
def test_first_eight_projection_and_failed_cost_guard(self):
c=fake_plan();blocks=[dict(runs=[dict(index=i,status='PASS',cell_wall_seconds=100) for i in b['run_indices']]) for b in c['blocks'][:4]]
self.assertTrue(matrix.first_eight_projection(c,blocks,1000)['continue_within_cap'])
for b in blocks:
for r in b['runs']:r['cell_wall_seconds']=2000
self.assertFalse(matrix.first_eight_projection(c,blocks,16000)['continue_within_cap'])
for b in blocks:
for r in b['runs']:r['status']='NA'
self.assertFalse(matrix.first_eight_projection(c,blocks,1000)['continue_within_cap'])
def test_failed_N_does_not_retry_or_skip_paired_E(self):
with tempfile.TemporaryDirectory() as t:
root=Path(t);(root/'training-contract.json').write_text('{}');dest=root/'blocks'/'block-000';dest.mkdir(parents=True)
c=fake_plan();calls=[]
def guard(cell,name,uuid,wall,command,**kw):
calls.append(name);r=dict(status='STOPPED_OR_FAILED' if len(calls)==1 else 'PASS',stop_reason='synthetic_failure' if len(calls)==1 else None,returncode=1 if len(calls)==1 else 0,cpu_seconds=1)
(cell/(name+'-guard-receipt.json')).write_text(json.dumps(r))
return r,dict(checkpoint_sha256='fresh',standardizer_fingerprint='shared')
with patch.object(matrix.os,'sched_setaffinity'),patch.object(matrix.os,'sched_getaffinity',return_value={0}),patch.object(matrix,'recorded_wait',return_value=dict(status='IDLE_CONFIRMED')),patch.object(matrix,'guarded_worker',guard):
matrix.block_locked(root,c,c['blocks'][0],dest,0,0)
r=json.loads((dest/'terminal.json').read_text());self.assertEqual(calls,['0-N','0-E'])
self.assertEqual([x['status'] for x in r['runs']],['NA','PASS']);self.assertFalse(r['pair_valid'])
def test_full_fake_scheduler_barrier_unique_blocks_and_90_terminal(self):
with tempfile.TemporaryDirectory() as t:
root=Path(t);(root/'training-contract.json').write_text('{}');c=fake_plan();clock=[0.];spawned=[];peak=[0]
class Process:
def __init__(self,i):self.i=i;self.pid=1000000+i;self.polls=0
def poll(self):
self.polls+=1
if self.polls==1:return None
dest=root/'blocks'/f'block-{self.i:03d}'/'terminal.json'
dest.write_text(json.dumps(dict(block=self.i,runs=[dict(index=j,status='PASS',cell_wall_seconds=1) for j in c['blocks'][self.i]['run_indices']],pair_valid=True)))
return 0
def wait(self):return 0
def spawn(command,**kw):
i=int(command[-3])
if i>=4:self.assertTrue((root/'first-eight-checkpoint.json').exists())
p=Process(i);spawned.append(p);peak[0]=max(peak[0],sum(x.polls<2 for x in spawned));return p
with patch.object(matrix,'contract',return_value=c),patch.object(matrix.subprocess,'Popen',spawn),patch.object(matrix.time,'monotonic',side_effect=lambda:clock[0]),patch.object(matrix.time,'sleep',side_effect=lambda n:clock.__setitem__(0,clock[0]+1)),patch('builtins.print'):
self.assertEqual(matrix.run(root),0)
r=json.loads((root/'matrix-complete.json').read_text())
self.assertEqual(len(spawned),45);self.assertEqual(len({p.i for p in spawned}),45);self.assertLessEqual(peak[0],4)
self.assertEqual((r['passed'],r['NA']),(90,0));self.assertFalse(r['test_predictions']);self.assertTrue(r['r2_required_before_custody'])
def test_existing_start_marker_rejects_duplicate_matrix(self):
with tempfile.TemporaryDirectory() as t:
root=Path(t);(root/'matrix-started.json').write_text('{}')
with patch.object(matrix,'contract',return_value=fake_plan()),patch.object(matrix.subprocess,'Popen') as spawn:
with self.assertRaises(AssertionError):matrix.run(root)
spawn.assert_not_called()
if __name__=='__main__':unittest.main(verbosity=2)