FatUnc6969's picture
Publish reviewed Borderland recovery research artifact
a8aea51 verified
Raw History Blame Contribute Delete
13.5 kB
from __future__ import annotations
import argparse
import json
import os
from pathlib import Path
import sys
def _print(value):
print(json.dumps(value, indent=2, ensure_ascii=False, allow_nan=False))
def _output(value, directory, filename):
if directory:
target = Path(directory)
target.mkdir(parents=True, exist_ok=True)
(target / filename).write_text(json.dumps(value, indent=2, ensure_ascii=False, allow_nan=False) + '\n')
def _suite_summary(suite):
return {'core_pass': suite['core_pass'],
'configuration': suite['configuration'],
'public_reference_pass': suite['public_reference_pass'],
'certificate_status': suite['certificate_status'],
'privileged_reference_status': suite['privileged_reference']['status'],
'policies': [{key: row[key] for key in ('name', 'scope', 'dependency_metrics', 'notebook_quality', 'denominator', 'escapes', 'escape_rate', 'categories')}
for row in suite['policies']],
'certificates': [{'pass': row.get('pass', False), 'scope': row.get('scope'), 'failures': row.get('failures', [])}
for row in suite['certificates']],
'limitations': suite.get('limitations', [])}
def _training_summary(result):
def metrics(value):
if isinstance(value, dict):
return {key: metrics(item) for key, item in value.items() if key != 'episodes'}
return value
summary = {key: result[key] for key in ('learner', 'compressor', 'initial_checksum', 'final_checksum',
'rl_updates', 'nonzero_rl_updates', 'imitation_updates', 'limits')}
for key in ('full_campaign', 'valve_checkpoint_curriculum'):
section = result[key]
summary[key] = {name: value for name, value in section.items() if name not in {'before', 'after', 'training'}}
for name in ('before', 'after'):
summary[key][name] = metrics(section[name])
return summary
def _hierarchical_training_summary(result):
summary = {key: result[key] for key in ('learner', 'compressor', 'training_seed', 'initial_checksum',
'final_checksum', 'rl_updates', 'nonzero_rl_updates',
'imitation_updates', 'configuration_hash', 'run_configuration',
'run_configuration_hash', 'split_hashes', 'source_hash', 'engine_hash', 'limits')}
for name in ('before', 'after'):
summary[name] = {key: value for key, value in result[name].items() if key != 'episodes'}
summary['ablations'] = {phase: {key: value for key, value in metrics.items() if key != 'episodes'}
for phase, metrics in result['ablations'].items()}
return summary
def _play(seed, archive_workload, generation_version=3, notebook_bytes=768, memory_profile='static'):
from borderland import Campaign
campaign = Campaign.generated(seed, archive_workload=archive_workload,
generation_version=generation_version, notebook_bytes=notebook_bytes, memory_profile=memory_profile)
transition = campaign.reset()
while True:
data = transition.to_dict()
observation = data['observation']
print(f"\nGame {observation['phase']} | charge {observation['charge']} | tick {observation['tick']} | {data['outcome']}")
for rule in observation['rules']:
print(rule)
_print(observation['board'])
if transition.done:
return 0 if transition.outcome == 'escaped' else 1
actions = data['legal_actions']
for index, action in enumerate(actions, 1):
print(f"{index}. {action['tag']} {json.dumps(action['arguments'], ensure_ascii=False)}")
try:
command = input('Action number, notes TEXT, or quit: ').strip()
except (EOFError, KeyboardInterrupt):
print()
return 0
if command == 'quit':
return 0
if command.startswith('notes '):
transition = campaign.replace_notebook(command[6:], expected_revision=transition.revision)
elif command.isdigit() and 1 <= int(command) <= len(actions):
transition = campaign.step(actions[int(command) - 1], expected_revision=transition.revision)
else:
print('Choose a displayed action number.')
continue
if transition.error:
print(transition.to_dict()['error']['message'])
def main(argv=None):
arguments = sys.argv[1:] if argv is None else argv
if arguments and arguments[0] == 'native-campaign':
from borderland_eval.native_campaign import main as campaign_main
return campaign_main(arguments[1:])
parser = argparse.ArgumentParser(prog='borderland', description='A seven-game campaign with shared charge and bounded memory.')
commands = parser.add_subparsers(dest='command', required=True)
verify = commands.add_parser('verify', help='Run offline campaign checks and the bounded twin certificate.')
verify.add_argument('--output')
verify.add_argument('--generation-version', type=int, choices=(2,3), default=3)
verify.add_argument('--notebook-bytes', type=int, default=768)
verify.add_argument('--memory-profile', choices=('static','commissioning'), default='static')
evaluate = commands.add_parser('evaluate', help='Run offline reference and baseline comparisons.')
evaluate.add_argument('--seeds', type=int, default=8, metavar='N')
evaluate.add_argument('--start-seed', type=int, default=0)
evaluate.add_argument('--output')
evaluate.add_argument('--generation-version', type=int, choices=(2,3), default=2)
evaluate.add_argument('--archive-workload', choices=('compact','standard','extended'), default='standard')
evaluate.add_argument('--notebook-bytes', type=int, default=768)
evaluate.add_argument('--memory-profile', choices=('static','commissioning'), default='static')
train = commands.add_parser('train', help='Train a local non-LLM policy with reward-dependent updates.')
train.add_argument('--learner', choices=('sparse', 'hierarchical'), default='sparse')
train.add_argument('--episodes', type=int, default=400)
train.add_argument('--seed', type=int, default=0)
train.add_argument('--output', default='artifacts/training')
play = commands.add_parser('play', help='Play a campaign in the terminal.')
play.add_argument('--seed', type=int, default=0)
server = commands.add_parser('serve', help='Open the local playable facility interface.')
server.add_argument('--host', default='127.0.0.1')
server.add_argument('--port', type=int, default=8765)
live = commands.add_parser('live', help='Run an explicitly enabled provider evaluation.')
live.add_argument('--seed', type=int, default=0)
live.add_argument('--provider', choices=['reflection', 'huggingface'], default=os.environ.get('BORDERLAND_PROVIDER', 'reflection'))
live.add_argument('--effort', choices=['low', 'medium', 'high', 'xhigh', 'max'], default='high')
live.add_argument('--output', default='artifacts/live')
for command in (play,live,server):
command.add_argument('--archive-workload', choices=('compact','standard','extended'), default='standard')
command.add_argument('--generation-version', type=int, choices=(2,3), default=3)
command.add_argument('--notebook-bytes', type=int, default=768)
command.add_argument('--memory-profile', choices=('static','commissioning'), default='static')
args = parser.parse_args(argv)
try:
if args.command in {'play','live','serve','verify','evaluate'} and args.generation_version == 2 and args.memory_profile != 'static':
parser.error('Commissioning requires generation three.')
if args.command in {'play','live','serve','evaluate'} and (args.notebook_bytes < 0 or
(args.generation_version == 2 and args.notebook_bytes != 768)):
parser.error('Custom nonnegative notebook bytes require generation three.')
if args.command == 'serve':
if not 0 <= args.port <= 65535:
parser.error('--port must be between 0 and 65535')
from borderland_web.server import serve
serve(args.host, args.port, args.archive_workload,
generation_version=args.generation_version, notebook_bytes=args.notebook_bytes, memory_profile=args.memory_profile)
return 0
if args.command == 'play':
return _play(args.seed,args.archive_workload,args.generation_version,args.notebook_bytes,args.memory_profile)
if args.command == 'evaluate':
if not 1 <= args.seeds <= 10000:
parser.error('--seeds must be between 1 and 10000')
if args.start_seed < 0:
parser.error('--start-seed must be nonnegative')
from borderland_eval.suite import run_suite
result = run_suite(list(range(args.start_seed, args.start_seed + args.seeds)), output_dir=args.output,
generation_version=args.generation_version, archive_workload=args.archive_workload,
notebook_bytes=args.notebook_bytes, memory_profile=args.memory_profile)
_print({**_suite_summary(result), 'output': args.output})
return 0
if args.command == 'train':
if not 1 <= args.episodes <= 1000000:
parser.error('--episodes must be between 1 and 1000000')
if args.learner == 'hierarchical':
if not 0 <= args.seed < 2**63:
parser.error('--seed must be between 0 and 2**63 - 1')
from borderland_eval.hierarchical_training import train_hierarchical
result = train_hierarchical(args.output, episodes=args.episodes, seed=args.seed)
summary = _hierarchical_training_summary(result)
else:
from borderland_eval.training import train_local
result = train_local(args.output, episodes=args.episodes, seed=args.seed)
summary = _training_summary(result)
_print({**summary, 'output': args.output})
return 0
if args.command == 'verify':
if args.generation_version == 3:
from borderland_eval.research import smoke
receipts = [smoke(seed, 3, args.notebook_bytes, args.memory_profile) for seed in (100000,100001,100002,100003)]
result = {'passed': all(row['passed'] for row in receipts), 'generation_version':3,
'scope':'Four scripted public-reference development campaigns and exact private replay. This is not Beam evaluation or an environment-quality verdict.',
'campaigns':receipts}
_output(result, args.output, 'verification.json')
_print(result)
return 0 if result['passed'] else 1
from borderland_eval.suite import run_suite
from borderland_verify.certificates import certify_twins
suite = run_suite([0, 1, 2, 3], output_dir=args.output)
certificate = certify_twins(17)
passed = certificate.get('pass', False) and suite.get('core_pass', False)
result = {'passed': bool(passed), 'suite': suite, 'certificate': certificate}
_output(result, args.output, 'verification.json')
_print({'passed': bool(passed), 'suite': _suite_summary(suite),
'final_valve_certificate': {'pass': certificate.get('pass', False), 'scope': certificate.get('scope'),
'bound': certificate.get('fixed_memoryless_bound'), 'failures': certificate.get('failures', [])},
'output': args.output})
return 0 if passed else 1
if os.environ.get('BORDERLAND_LIVE_ENABLED', '').lower() not in {'1', 'true', 'yes'}:
print('Live evaluation is disabled. Set BORDERLAND_LIVE_ENABLED=1 only after confirming authorized provider access.', file=sys.stderr)
return 2
from borderland_eval.provider import run_live
config = {'generation_version':args.generation_version,'notebook_bytes':args.notebook_bytes,'archive_workload':args.archive_workload,'memory_profile':args.memory_profile,'live_enabled': True, 'free_access_verified': os.environ.get('BORDERLAND_FREE_ACCESS_VERIFIED', '').lower() in {'1', 'true', 'yes'}, 'provider': args.provider, 'effort': args.effort,
'model': os.environ.get('BORDERLAND_MODEL', ''), 'api_base': os.environ.get('BORDERLAND_API_BASE', ''),
'api_key': os.environ.get('BORDERLAND_API_KEY') or os.environ.get('HF_TOKEN' if args.provider == 'huggingface' else 'REFLECTION_API_KEY', ''),
'max_attempts': 128, 'cash_cap_usd': 0.0}
result = run_live(args.seed, config, args.output)
_print({key: value for key, value in result.items() if key not in {'attempts', 'assistant_claims'}} | {'output': args.output})
return 0
except (OSError, ValueError, ImportError) as exc:
print(f'{args.command} failed: {type(exc).__name__}. Check the local setup and command arguments.', file=sys.stderr)
return 1
if __name__ == '__main__':
raise SystemExit(main())