Digital Drosophila Archive
155 lines
10 KiB
Python
155 lines
10 KiB
Python
"""Aggregate and seal descriptive accounting without learning promotion."""
|
||
import numpy as np
|
||
import pandas as pd
|
||
from context import ROOT, MODEL, EXP, AG, AG_MODEL, read, save, digest, check, integrity, seal
|
||
from accounting import bit_equal
|
||
|
||
|
||
def summarize():
|
||
inventory = read(EXP / 'protocol/inventory.json')
|
||
expected_inventory = [(name, 0, 'fixture') for name in read(AG_MODEL / 'config.json')['fixtures']]
|
||
for row in read(AG / 'protocol/calibration-cases.json'):
|
||
expected_inventory.append((row['name'], 0, 'calibration'))
|
||
if row['seed'] == 51101:
|
||
expected_inventory.append((row['name'], 1, 'calibration'))
|
||
identities = [(r['case'], r['repeat'], r['kind']) for r in inventory]
|
||
assert len(identities) == len(set(identities)) == 80 and identities == expected_inventory
|
||
reports = []
|
||
modes = {}
|
||
for item in inventory:
|
||
folder = EXP / 'trials' / (item['case'] + '-r' + str(item['repeat']))
|
||
result = read(folder / 'summary.json')
|
||
assert result['pass_all'] and all(result['exact'].values())
|
||
assert result['ledger_roundoff_bound_pass'] and result['steps'] > 0
|
||
for name, sha in result['input_sha256'].items():
|
||
assert digest(ROOT / item['source'] / name) == sha
|
||
# Re-read saved numeric evidence; a successful receipt alone is not proof.
|
||
spec = read(AG / 'cases' / item['case'] / 'spec.json')
|
||
assert (result['case'], result['repeat'], result['kind']) == (item['case'], item['repeat'], item['kind'])
|
||
assert result['steps'] == spec['steps'] and result['duration_ms'] == spec['duration_ms']
|
||
assert result['mode'] == spec.get('mode') and result['seed'] == spec.get('seed')
|
||
assert result['odor_id'] == spec.get('odor_id')
|
||
nodes = np.load(spec['graph_dir'] + '/nodes.npy', mmap_mode='r')
|
||
kc = np.load(AG / 'apl-bundle/kc_globals.npy', mmap_mode='r')
|
||
targets, positions, _ = np.intersect1d(nodes, kc, assume_unique=True, return_indices=True)
|
||
table = pd.read_parquet(folder / 'per-kc.parquet')
|
||
with np.load(folder / 'replay-final.npz') as actual, np.load(ROOT / item['source'] / 'state.npz') as expected:
|
||
assert bit_equal(actual['target_globals'], targets)
|
||
for key in ('v', 'g', 'ref', 'counts'):
|
||
assert bit_equal(actual[key], expected[key][positions]), key
|
||
event_mask = np.isin(expected['neuron_idx'], targets)
|
||
for key in ('step', 'neuron_idx'):
|
||
assert bit_equal(actual[key], expected[key][event_mask]), key
|
||
assert bit_equal(table.neuron_idx.to_numpy(), targets)
|
||
assert bit_equal(table.spike_count.to_numpy(), actual['counts'])
|
||
assert bit_equal(table.first_spike_tick.to_numpy(), actual['first_spike'])
|
||
assert np.isfinite(table.select_dtypes(include='number').to_numpy()).all()
|
||
assert (table.g_ledger_residual_V.abs() <= table.g_ledger_bound_V).all()
|
||
reports.append(result)
|
||
if item['kind'] != 'calibration' or item['repeat'] != 0:
|
||
continue
|
||
modes.setdefault(result['mode'], []).append(result)
|
||
aggregate = {}
|
||
for mode, rows in modes.items():
|
||
assert len(rows) == 30
|
||
group_totals = {}
|
||
for group in rows[0]['strata']['all']['source_groups']:
|
||
group_totals[group] = {metric: sum(r['strata']['all']['source_groups'][group][metric] for r in rows)
|
||
for metric in rows[0]['strata']['all']['source_groups'][group]}
|
||
active = np.array([r['KC_active'] for r in rows], dtype=np.int64)
|
||
strata = {}
|
||
for stratum in ('all', 'ever_active', 'never_active'):
|
||
strata[stratum] = {metric: sum(r['strata'][stratum]['metrics_sum'][metric] for r in rows)
|
||
for metric in rows[0]['strata'][stratum]['metrics_sum']}
|
||
strata[stratum].update(neuron_trial_count=sum(r['strata'][stratum]['neurons'] for r in rows),
|
||
no_accepted_exc_neuron_trials=sum(r['strata'][stratum]['no_accepted_exc_neurons'] for r in rows),
|
||
no_accepted_ALPN_exc_neuron_trials=sum(r['strata'][stratum]['no_accepted_ALPN_exc_neurons'] for r in rows),
|
||
has_exc_but_never_active_neuron_trials=sum(r['strata'][stratum]['has_exc_but_never_active'] for r in rows))
|
||
aggregate[mode] = dict(trials=30, KC_active_mean=float(active.mean()),
|
||
KC_active_min=int(active.min()), KC_active_max=int(active.max()),
|
||
KC_active_fraction_mean=float(active.mean() / 4064), source_groups=group_totals,
|
||
strata=strata,
|
||
input_totals={key: sum(r['input'][key] for r in rows) for key in
|
||
('requests', 'accepted', 'rejected', 'design_target_PN_spikes', 'non_design_ALPN_spikes')},
|
||
min_max_design_targets=[min(r['input']['odor_design_target_count'] for r in rows),
|
||
max(r['input']['odor_design_target_count'] for r in rows)],
|
||
neuron_trial_not_unique_neuron_counts=True)
|
||
flat = []
|
||
for row in reports:
|
||
if row['kind'] == 'calibration' and row['repeat'] == 0:
|
||
flat.append(dict(case=row['case'], mode=row['mode'], seed=row['seed'], odor_id=row['odor_id'],
|
||
KC_active=row['KC_active'], KC_spikes=row['KC_spikes'],
|
||
requests=row['input']['requests'], accepted_requests=row['input']['accepted'],
|
||
ALPN_actual_spikes=row['input']['actual_spikes_by_source_group']['ALPN'],
|
||
no_exc_neurons=row['strata']['all']['no_accepted_exc_neurons'],
|
||
no_ALPN_exc_neurons=row['strata']['all']['no_accepted_ALPN_exc_neurons'],
|
||
APL_sum_SI=row['strata']['all']['metrics_sum']['APL_write_SI'],
|
||
APL_ref_sum_SI=row['strata']['all']['metrics_sum']['APL_write_ref_SI'],
|
||
maximum_ledger_error_V=row['ledger_max_abs_error_V'],
|
||
source_shadow_max_residual_V=row['source_shadow_max_residual_V']))
|
||
assert len(reports) == 80 and len(flat) == 60 and len(aggregate) == 2
|
||
return reports, aggregate, flat
|
||
|
||
|
||
def main():
|
||
check()
|
||
assert not (EXP / 'audit/failure.json').exists(), 'Preserved failure cannot be promoted'
|
||
completed = read(EXP / 'audit/completed.json')
|
||
assert completed['pass_all'] and len(completed['trials']) == 80 and len(completed['repeat_checks']) == 12
|
||
inventory = read(EXP / 'protocol/inventory.json')
|
||
expected_ids = {(r['case'], r['repeat']) for r in inventory}
|
||
actual_ids = [(r['case'], r['repeat']) for r in completed['trials']]
|
||
assert len(actual_ids) == len(set(actual_ids)) == 80 and set(actual_ids) == expected_ids
|
||
assert all(r['pass_all'] for r in completed['trials'])
|
||
repeat_ids = [r['case'] for r in completed['repeat_checks']]
|
||
assert len(repeat_ids) == len(set(repeat_ids)) == 12
|
||
assert set(repeat_ids) == {r['case'] for r in inventory if r['repeat'] == 1}
|
||
assert all(r['pass_all'] and all(r['checks'].values()) for r in completed['repeat_checks'])
|
||
reports, aggregate, flat = summarize()
|
||
pd.DataFrame(flat).to_csv(EXP / 'audit/calibration-drive-summary.csv', index=False)
|
||
after = integrity()
|
||
save(EXP / 'regression/old-integrity-after.json', after)
|
||
prior_five = read(AG / 'regression/frozen-five.json')
|
||
assert prior_five['pass_all']
|
||
result = dict(status='PASS-CONDITIONAL-KC-DRIVE-AUDIT', reconstructed_trials=80,
|
||
fixture_full_target_history_trials=8, CAL_final_and_event_trials=72, exact_accounting_repeats=12,
|
||
modes=aggregate, max_ledger_residual_V=max(r['ledger_max_abs_error_V'] for r in reports),
|
||
max_source_shadow_residual_V=max(r['source_shadow_max_residual_V'] for r in reports),
|
||
max_source_area_residual_V_ms=max(r['source_area_max_residual_V_ms'] for r in reports),
|
||
CPU_accounting_wall_sum_seconds=sum(r['CPU_audit_wall_seconds'] for r in reports),
|
||
old_integrity_pass=all(r['pass'] for r in after.values()),
|
||
frozen_five_reexecuted_this_audit=False, previous_sealed_five_reference_pass=True,
|
||
previous_five_reference_sha256=digest(AG / 'regression/frozen-five.json'),
|
||
previous_CAL_failure_not_changed=True, new_brain_simulation=False, GPU_used=False,
|
||
training=False, heldout_access=False, candidate_generated=False, learning_achieved=False,
|
||
APL_causal_failure_claim=False, counterfactual_tested=False,
|
||
limitations=['Logged upstream and APL are conditioning inputs, not independent components',
|
||
'CAL has no independently saved per-tick KC state histories; only events and final states checked',
|
||
'Source state lanes are non-feedback linear bookkeeping under observed reset/availability',
|
||
'First-spike APL/ref mechanisms cannot establish whole-network counterfactual causality',
|
||
'Counts pooled across trials are neuron-trial counts, not distinct neuron identities'],
|
||
payload_bytes_before_manifest=sum(p.stat().st_size for p in EXP.rglob('*') if p.is_file()))
|
||
assert result['payload_bytes_before_manifest'] < 2 * 1024 ** 3
|
||
save(EXP / 'audit/final-status.json', result)
|
||
lines = ['# Phase 4AH — conditional KC drive audit', '', 'Status: `'+result['status']+'`.', '',
|
||
'80 existing records reconstructed; 8 fixture pre/post histories and 72 CAL event/final states exact.',
|
||
'12 repeated CAL records produced identical accounting. No new brain simulation, GPU use, tuning or learning.',
|
||
'Full prior frozen integrity passed. Five reference simulations were not rerun; the sealed prior PASS is referenced by SHA.',
|
||
'Previous CAL failure remains unchanged. Conditional replay is not an APL-removal counterfactual.', '',
|
||
'|Mode|Mean active KC fraction|Requests|Accepted requests|ALPN accepted excitatory increment sum (V)|APL write sum (V)|',
|
||
'|---|---:|---:|---:|---:|---:|']
|
||
for mode, row in aggregate.items():
|
||
lines.append(f"|{mode}|{row['KC_active_fraction_mean']:.8f}|{row['input_totals']['requests']}|{row['input_totals']['accepted']}|{row['source_groups']['ALPN']['accepted_exc_SI']:.9g}|{row['strata']['all']['APL_write_SI']:.9g}|")
|
||
lines += ['', 'Increment sums span 30 trials × 4064 KC × time; not instantaneous conductance or causal percentages.',
|
||
'See audit/final-status.json, audit/calibration-drive-summary.csv and trials/*/per-kc.parquet for detailed evidence.']
|
||
with (EXP / 'REPORT.md').open('x') as f:
|
||
f.write('\n'.join(lines) + '\n')
|
||
check()
|
||
seal(MODEL)
|
||
seal(EXP)
|
||
print(result['status'], flush=True)
|
||
|
||
|
||
if __name__ == '__main__':
|
||
main()
|