borderland-rl / python /borderland_eval /archive_study.py
FatUnc6969's picture
Publish reviewed Borderland recovery research artifact
a8aea51 verified
Raw History Blame Contribute Delete
19.5 kB
from __future__ import annotations
import argparse
import json
import random
from dataclasses import asdict, dataclass
from pathlib import Path
from borderland.domain import canonical
from borderland.replay import source_hash, verify_replay
from borderland_eval.archive_cases import (ArchiveCase, BoundExceeded, Counter, actor_packet,
digest, physical_projection, require_twins, surviving_projection)
from borderland_eval.archive_learning import (ArchivePolicy, FEATURES, execute_docket,
ownership, trial)
def implementation_hash():
return digest({name: Path(__file__).with_name(name).read_text() for name in
('archive_cases.py', 'archive_learning.py', 'archive_study.py')})
def write_json(path, value):
Path(path).write_text(canonical(value) + '\n')
@dataclass(frozen=True)
class StudyPlan:
source_hash: str
train_roots: tuple[int, ...]
development_roots: tuple[int, ...]
confirmation_roots: tuple[int, ...]
initializations: tuple[int, ...]
pilot_only: bool = True
@classmethod
def read(cls, path):
values = json.loads(Path(path).read_text())
required = {'source_hash', 'train_roots', 'development_roots', 'confirmation_roots', 'initializations'}
if not required <= set(values) or set(values) - required - {'pilot_only'}:
raise ValueError('plan keys differ from documented schema')
for key in required - {'source_hash'}:
if not isinstance(values[key], list) or any(type(value) is not int or value < 0 for value in values[key]):
raise ValueError('roots and initializations must be nonnegative integer lists')
values[key] = tuple(values[key])
plan = cls(**values)
plan.validate()
return plan
def validate(self):
if self.source_hash != source_hash():
raise ValueError('plan engine source mismatch')
if (len(self.train_roots), len(self.development_roots), len(self.confirmation_roots)) != (32, 8, 16):
raise ValueError('plan requires 32 training, 8 development and 16 confirmation root groups')
roots = self.train_roots + self.development_roots + self.confirmation_roots
if len(roots) != len(set(roots)) or any(type(root) is not int or root < 0 for root in roots):
raise ValueError('root groups must be distinct nonnegative integers')
if len(self.initializations) != 3 or len(set(self.initializations)) != 3 or any(type(seed) is not int or seed < 0 for seed in self.initializations):
raise ValueError('three distinct action RNG initializations required')
if type(self.pilot_only) is not bool:
raise ValueError('pilot_only must be boolean')
def new_output(path):
path = Path(path)
path.mkdir(parents=True, exist_ok=False, mode=0o700)
return path
def save_verified(execution, path):
execution.campaign.save_replay(path, visibility='private')
receipt = verify_replay(path)
if not receipt['verified']:
raise ValueError('private replay verification failed')
return dict(path=str(Path(path).resolve()), verification=receipt)
def probe(policy, evidence):
return [asdict(policy.decide(evidence, service, random.Random(0), greedy=True))
for service in evidence.services]
class ArchiveStudy:
def __init__(self, plan, output):
plan.validate()
self.plan = plan
self.output = Path(output)
def fit(self):
self.plan.validate()
output = new_output(self.output)
binding = dict(plan=asdict(self.plan), plan_hash=digest(asdict(self.plan)),
engine_hash=source_hash(), implementation_hash=implementation_hash(),
features=FEATURES, objective='actual_phase3_to4_binary_exit',
learning_rate=.15, gamma=1, baseline='previous_arithmetic_running_return_mean',
scope='assisted_applicability_only',
evaluation='frozen_greedy_randomized_ties_same_rule_initial_and_trained')
write_json(output / 'binding.json', binding)
summaries = []
for initialization in self.plan.initializations[:1] if self.plan.pilot_only else self.plan.initializations:
policy = ArchivePolicy()
rng = random.Random(initialization)
counter = Counter(8448, 60)
cases = {}
returns = []
status = 'running'
gate = None
first_probe = None
init_output = new_output(output / str(initialization))
with (init_output / 'episodes.jsonl').open('w') as stream:
for episode in range(32 if self.plan.pilot_only else 256):
root = self.plan.train_roots[(episode // 2) % len(self.plan.train_roots)]
parity = episode % 2
start_actions = counter.used
execution = None
receipt = dict(episode=episode, root=root, parity=parity, owned_count=ownership(episode))
try:
if source_hash() != binding['engine_hash'] or implementation_hash() != binding['implementation_hash']:
raise ValueError('source changed during study')
if (root, parity) in cases:
case = cases[root, parity]
execution = case.reconstruct(counter)
else:
case, execution = ArchiveCase.acquire(root, parity, counter)
cases[root, parity] = case
write_json(init_output / f'case-{root}-{parity}.json', case.recipe())
if first_probe is None:
first_probe = case.evidence
write_json(init_output / 'initial-probe.json', probe(policy, first_probe))
result, decisions = trial(execution, case.evidence, policy, ownership(episode), rng)
baseline = sum(returns) / len(returns) if returns else 0.0
receipt.update(result, update=policy.update(decisions, result['reward'], baseline))
if source_hash() != binding['engine_hash'] or implementation_hash() != binding['implementation_hash']:
raise ValueError('source changed during study')
returns.append(result['reward'])
if result['reward'] and not (init_output / 'success-witness.jsonl').exists():
receipt['replay_witness'] = save_verified(execution, init_output / 'success-witness.jsonl')
except (BoundExceeded, ValueError) as error:
status = str(error)
if execution is not None:
receipt.update(execution.trial_receipt)
receipt.update(failed=True, failure=status)
receipt.update(actual_actions=counter.used - start_actions, cumulative_actions=counter.used,
commands=counter.current_commands if execution is None else execution.commands)
stream.write(canonical(receipt) + '\n')
stream.flush()
if status != 'running':
break
if episode == 31:
before = probe(ArchivePolicy(), first_probe)
after = probe(policy, first_probe)
changed = any(a['probabilities'] != b['probabilities'] for a, b in zip(before, after))
gate = dict(passed=bool(sum(returns) and any(policy.weights) and changed),
successes=sum(returns), episodes=len(returns), actions=counter.used,
weights=policy.weights, probabilities_changed=changed)
try:
counter.check()
write_json(init_output / 'pilot-gate.json', gate)
counter.check()
except BoundExceeded as error:
status = str(error)
gate.update(passed=False, failure=status)
write_json(init_output / 'pilot-gate.json', gate)
if not gate['passed']:
if status == 'running':
status = 'pilot_signal_failed'
break
if not self.plan.pilot_only:
counter.limit = 67584
counter.seconds = 180
if status == 'running':
try:
counter.check()
except BoundExceeded as error:
status = str(error)
if self.plan.pilot_only:
gate.update(passed=False, failure=status)
write_json(init_output / 'pilot-gate.json', gate)
else:
status = 'pilot_complete' if self.plan.pilot_only else 'schedule_complete'
summary = dict(initialization=initialization, status=status, completed_episodes=len(returns),
successes=sum(returns), actual_actions=counter.used, weights=policy.weights,
initial_weights=(0.0,) * 5, pilot_gate=gate)
write_json(init_output / 'checkpoint.json', summary)
summaries.append(summary)
if status not in ('pilot_complete', 'schedule_complete'):
break
report = dict(binding=binding, initializations=summaries, confirmation_materialized=False,
complete=len(summaries) == (1 if self.plan.pilot_only else 3) and
all(row['status'] in ('pilot_complete', 'schedule_complete') for row in summaries))
write_json(output / 'report.json', report)
return report
def evaluate(self, output, split='development', freeze=None):
self.plan.validate()
if split not in ('development', 'confirmation'):
raise ValueError('evaluation split must be development or confirmation')
binding = json.loads((self.output / 'binding.json').read_text())
if (binding['implementation_hash'] != implementation_hash() or
binding.get('engine_hash') != source_hash() or
binding['plan_hash'] != digest(asdict(self.plan))):
raise ValueError('training binding differs from evaluation source or plan')
checkpoints = [json.loads((self.output / str(seed) / 'checkpoint.json').read_text()) for seed in self.plan.initializations]
if any(row['status'] != 'schedule_complete' for row in checkpoints):
raise ValueError('evaluation requires all three complete frozen schedules')
if split == 'confirmation':
if freeze is None:
raise ValueError('confirmation requires explicit prospective freeze file')
frozen = json.loads(Path(freeze).read_text())
expected = dict(implementation_hash=implementation_hash(), plan_hash=digest(asdict(self.plan)),
checkpoints_hash=digest(checkpoints))
if any(frozen.get(key) != value for key, value in expected.items()) or not frozen.get('analysis'):
raise ValueError('confirmation freeze does not match source, plan, checkpoints and analysis')
destination = new_output(output)
roots = self.plan.development_roots if split == 'development' else self.plan.confirmation_roots
rows = []
for root in roots:
for parity in (0, 1):
admission_counter = Counter(240, 60)
case, _ = ArchiveCase.acquire(root, parity, admission_counter)
write_json(destination / f'case-{root}-{parity}.json', case.recipe())
for checkpoint in checkpoints:
seed = checkpoint['initialization']
for label, weights in (('initial', checkpoint['initial_weights']), ('trained', checkpoint['weights'])):
counter = Counter(264, 60)
execution = case.reconstruct(counter)
result, _ = trial(execution, case.evidence, ArchivePolicy(weights), 8,
random.Random(seed), greedy=True)
if source_hash() != binding['engine_hash'] or implementation_hash() != binding['implementation_hash']:
raise ValueError('source changed during evaluation')
witness = save_verified(execution, destination / f'{root}-{parity}-{seed}-{label}.jsonl')
rows.append(dict(root=root, parity=parity, initialization=seed, policy=label,
actual_actions=counter.used, commands=execution.commands,
replay_witness=witness, **result))
report = dict(split=split, plan_hash=digest(asdict(self.plan)), rows=rows,
admission_actions=sum(len(json.loads((destination / f'case-{root}-{parity}.json').read_text())['prefix']) for root in roots for parity in (0, 1)),
assistance='scripted prefix, evidence retention, proof/file executor at all stages')
write_json(destination / 'evaluation.json', report)
return report
def prepare_packets(plan, output, roots):
plan.validate()
if any(root not in plan.development_roots for root in roots):
raise ValueError('offline preparation accepts explicit development roots only')
destination = new_output(output)
expected_implementation = implementation_hash()
receipts = []
for root in roots:
pair_output = new_output(destination / str(root))
cases = [ArchiveCase.acquire(root, parity, Counter(240, 60))[0] for parity in (0, 1)]
for parity, case in enumerate(cases):
write_json(pair_output / f'operator-case-{parity}.json', case.recipe())
if cases[0].evidence.records != cases[1].evidence.records or cases[0].evidence.history != cases[1].evidence.history:
raise ValueError('raw Archive packets differ between twins')
channel = cases[0].evidence.measurements[0][0]
if cases[0].evidence.bit(channel) == cases[1].evidence.bit(channel):
raise ValueError('target public bit did not change')
packets = []
physical = []
witnesses = []
branch_commands = []
for parity, case in enumerate(cases):
for treatment in ('correct', 'erased', 'foil'):
execution = case.reconstruct(Counter(264, 60))
note = json.loads(execution.campaign.observe().observation.notebook['text'])
note['m'][0][1] = ('?' if treatment == 'erased' else str(cases[1 - parity].evidence.bit(channel))
if treatment == 'foil' else str(case.evidence.bit(channel)))
text = canonical(note)
if len(text.encode()) != len(execution.campaign.observe().observation.notebook['text'].encode()):
raise ValueError('note treatments must use equal UTF-8 bytes')
note['v'] = 1
text = canonical(note)
execution.command('note', text, 'lawful_equal_byte_intervention')
packet = actor_packet(execution, case.evidence)
packets.append(packet)
physical.append(physical_projection(execution))
write_json(pair_output / f'actor-{parity}-{treatment}.json', packet)
witnesses.append(save_verified(execution, pair_output / f'prefix-{parity}-{treatment}.jsonl'))
if treatment in ('correct', 'foil'):
note_bits = {name: int(bit) for name, bit, _ in note['m']}
selected = {service: next(record.id for record in case.evidence.candidates(service)
if record.supersedes is not None and record.applies_bit == note_bits[record.applies_channel])
for service in case.evidence.services}
expected = int(treatment == 'correct')
if execute_docket(execution, case.evidence, selected, ()) != expected:
raise ValueError('public note witness disagrees with expected intervention outcome')
witnesses.append(save_verified(execution, pair_output / f'{treatment}-continuation-{parity}.jsonl'))
branch_commands.append(execution.counter.used)
for packet, state in zip(packets[1:], physical[1:]):
require_twins(packets[0], packet)
if state != physical[0]:
raise ValueError('private physical state mismatch outside notebook and revision')
receipt = dict(root=root, channel=channel, actor_packets=6,
target_services=sorted({record.subject for record in cases[0].evidence.records if record.applies_channel == channel}),
actual_preparation_commands=sum(len(case.prefix) for case in cases) +
sum(branch_commands),
surviving_projection_hash=digest(surviving_projection(packets[0])),
complete_projection_equal=True, private_physical_equal=True,
source_hash=source_hash(), implementation_hash=implementation_hash(),
witnesses=witnesses, readiness='offline_only')
if source_hash() != plan.source_hash or implementation_hash() != expected_implementation:
raise ValueError('source changed during offline preparation')
write_json(pair_output / 'admission.json', receipt)
receipts.append(receipt)
write_json(destination / 'preparation.json', receipts)
return receipts
def main():
parser = argparse.ArgumentParser(description='Assisted Archive applicability study. No provider calls.')
parser.add_argument('command', choices=('run', 'train', 'evaluate', 'prepare'))
parser.add_argument('--plan', required=True)
parser.add_argument('--output', required=True)
parser.add_argument('--training')
parser.add_argument('--split', choices=('development', 'confirmation'), default='development')
parser.add_argument('--freeze')
parser.add_argument('--roots', nargs='+', type=int)
args = parser.parse_args()
plan = StudyPlan.read(args.plan)
if args.command == 'prepare':
if args.roots is None:
parser.error('prepare requires explicit --roots from development_roots')
result = prepare_packets(plan, args.output, args.roots)
elif args.command == 'evaluate':
if args.training is None:
parser.error('evaluate requires --training')
result = ArchiveStudy(plan, args.training).evaluate(args.output, args.split, args.freeze)
else:
result = ArchiveStudy(plan, args.output).fit()
print(canonical(result if args.command != 'evaluate' else dict(split=args.split, episodes=len(result['rows']))))
if __name__ == '__main__':
main()