Files
MeltMind/tools/phase2_h1_clock_manifest.py
T

140 lines
7.7 KiB
Python

"""Freeze H1 clock membership/weights from metadata only; never load arrays."""
import csv
from fractions import Fraction
import hashlib
import json
from pathlib import Path
import time
ROOT = Path(__file__).resolve().parents[1]
OUT = ROOT / 'artifacts/phase2-h1-planning-2026-11-17/clock-freeze-v1'
def main():
start = time.process_time()
sources = {}
def read(relative):
p = ROOT / relative
raw = p.read_bytes()
sources[str(relative)] = hashlib.sha256(raw).hexdigest()
return json.loads(raw)
grouped = read('artifacts/r4bc-execution-2026-11-16/contract.json')
oldmodels = read('artifacts/r4bc-execution-2026-11-16/models-terminal.json')
vr = Path('artifacts/gre24-v4-reproduction-2026-11-16/protocol')
splits = read(vr/'splits.json')
prep = read(vr/'preparation-freeze.json')
training = read(vr/'training-contract.json')
assert training['xgb_threads'] == 8
assert len(grouped['parts']) == 552
assert len({r['component_id'] for r in grouped['parts']}) == 204
assert len(prep['successful']) == 615
parts = {'grouped': {}, 'v4_random': {}}
cells = []; weights = []
def register(protocol, case, cache, group):
hashes = cache['output_sha256']
required = ('seconds.npy', 'target.npy', 'raw_ids.npy', 'Vf.npy', 'features.npy', 'mass.npy', 'Df.npy')
assert all(name in hashes for name in required)
parts[protocol][case] = dict(case=case, output=cache['output'], nodes=cache['nodes'],
t_set=cache['t_scale_seconds'], clock_group=group, output_sha256=hashes,
endpoint='max(seconds.npy on retained-tet raw_ids) / t_set')
for r in grouped['parts']:
assert r['nodes'] == r['v5_cache']['nodes']
assert r['preparation']['t_set'] == r['v5_cache']['t_scale_seconds']
register('grouped', r['case'], r['v5_cache'], r['component_id'])
for case, cache in prep['successful'].items():
# The frozen original random protocol has no component membership.
assert not any(k in cache for k in ('component_id', 'component_key', 'clock_group'))
register('v4_random', case, cache, 'part:'+case)
def cell(protocol, fold, pool, learning, test, seed, threads, baseline, original_access):
assert learning and len(learning) == len(set(learning))
assert len(test) == len(set(test)) and not set(learning).intersection(test)
assert [r['case'] for r in original_access] == learning
groups = {}
for case in learning:
group = parts[protocol][case]['clock_group']
groups.setdefault(group, []).append(case)
G = len(groups); total = Fraction(0)
key = f'{protocol}-fold{fold}-pool{pool}'
for group in sorted(groups):
n = len(groups[group]); weight = Fraction(1, G*n)
for case in groups[group]:
total += weight
weights.append(dict(cell=key, protocol=protocol, fold=fold, pool=pool,
case=case, clock_group=group, group_count=G, parts_in_group=n,
numerator=weight.numerator, denominator=weight.denominator,
weight_float=float(weight), original_role='learning' if protocol=='grouped' else 'train'))
assert total == 1
cells.append(dict(index=len(cells), cell=key, protocol=protocol, fold=fold, pool=pool,
seed=seed, threads=threads, learning=learning, test=test,
learning_parts=len(learning), test_parts=len(test), clock_groups=G,
learning_nodes=sum(parts[protocol][case]['nodes'] for case in learning),
baseline_model=baseline, clock_value=None, clock_status='NOT_EVALUATED_METADATA_ONLY',
exact_weight_sum='1/1', original_fit_access_order_match=True))
for pool in (100, 50, 25):
for fold in range(5):
roles = {r['case']: next(a for a in r['assignments'] if a['fold']==fold) for r in grouped['parts']}
learning = sorted(case for case,a in roles.items() if a['role']=='learning' and str(pool) in a['learning_pools'])
test = sorted(case for case,a in roles.items() if a['role']=='test')
# Clock groups cannot leak across held-out roles in this protocol.
seen = {}
for case,a in roles.items():
group = parts['grouped'][case]['clock_group']
seen.setdefault(group,set()).add(a['role'])
assert all(len(v)==1 for v in seen.values())
model = next(m for m in oldmodels['models'] if m['arm']=='A' and m['fold']==fold and m['pool']==pool)
assert model['status']=='PASS'
oldout = Path(model['model_path']).parent.relative_to(ROOT)
access = read(oldout/'access.json'); result = read(oldout/'result.json')
assert all(r['role']=='learning' and r['full'] for r in access)
assert result['learning_parts']==len(learning)
assert result['learning_nodes']==sum(parts['grouped'][case]['nodes'] for case in learning)
cell('grouped',fold,pool,learning,test,0,1,
dict(path=model['model_path'],sha256=model['model_sha256'],format='joblib'),access)
for split in splits:
fold=split['index']; learning=[x for x in split['train'] if x in prep['successful']]
test=[x for x in split['test'] if x in prep['successful']]
result=read(vr/f'fits/split-{fold}/GBRT/result.json')
access=read(vr/f'fits/split-{fold}/GBRT/training-target-access.json')
assert all(r['role']=='train' for r in access)
assert result['train_geometries']==len(learning)
assert result['train_nodes']==sum(parts['v4_random'][case]['nodes'] for case in learning)
assert set(split['fnn_validation']).issubset(split['train'])
assert result['parameters']['n_jobs']==8
cell('v4_random',fold,100,learning,test,split['seed'],8,
dict(path=result['checkpoint'],sha256=result['checkpoint_sha256'],format='ubj'),access)
cells[-1]['included_original_fnn_validation']=sorted(set(split['fnn_validation']) & set(learning))
cells[-1]['excluded_original_train_preparation_failures']=[x for x in split['train'] if x not in prep['successful']]
# No overwrite of an existing fixed review packet.
OUT.mkdir(parents=True, exist_ok=False)
fields=list(weights[0])
with (OUT/'clock-weights.csv').open('w',newline='') as stream:
writer=csv.DictWriter(stream,fieldnames=fields);writer.writeheader();writer.writerows(weights)
payload=dict(version='phase2-h1-clock-membership-v1', status='FROZEN_FOR_MAIN_REVIEW_NOT_EXECUTION_APPROVAL',
c_policy=dict(grouped='original component_id; 1/(learning component count * learning parts in component)',
v4_random='no component key in original protocol; part:<original case>, equal successful original GBRT train parts'),
cells=cells, parts=parts, source_sha256=sources,
target_arrays_read=False, feature_arrays_read=False, clock_values_computed=False,
fit_started=False, new_decodes=0)
(OUT/'membership-and-sources.json').write_text(json.dumps(payload,indent=2)+'\n')
receipt=dict(status='PASS_METADATA_INVARIANTS', cells=len(cells), weight_rows=len(weights),
grouped_parts=552, grouped_components=204, v4_successful_parts=615,
exact_weight_sums=True, original_access_order_match=True, learning_test_disjoint=True,
grouped_component_role_isolation=True, target_arrays_read=False, feature_arrays_read=False,
cpu_seconds=time.process_time()-start,
files={p.name:hashlib.sha256(p.read_bytes()).hexdigest() for p in OUT.iterdir()})
(OUT/'receipt.json').write_text(json.dumps(receipt,indent=2)+'\n')
print(json.dumps(receipt))
if __name__=='__main__':
main()