Spaces:
Running
Running
Download python/borderland_eval/archive_study.py from FatUnc6969/borderland-rl: direct link, hf CLI and curl.
- Browser
- Download file 19.5 kB
-
https://huggingface.co/spaces/FatUnc6969/borderland-rl/resolve/main/python/borderland_eval/archive_study.py
- Command line
-
hf download hf://spaces/FatUnc6969/borderland-rl/python/borderland_eval/archive_study.py
-
curl -L -o archive_study.py https://huggingface.co/spaces/FatUnc6969/borderland-rl/resolve/main/python/borderland_eval/archive_study.py
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') | |
| class StudyPlan: | |
| source_hash: str | |
| train_roots: tuple[int, ...] | |
| development_roots: tuple[int, ...] | |
| confirmation_roots: tuple[int, ...] | |
| initializations: tuple[int, ...] | |
| pilot_only: bool = True | |
| 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() | |