File size: 14,218 Bytes
a8aea51
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
from __future__ import annotations

import argparse
import json
import random
import time
from collections import Counter as Counts, deque
from dataclasses import asdict
from pathlib import Path

from borderland import Campaign
from borderland.domain import canonical
from borderland.replay import source_hash
from borderland_eval.archive_cases import BoundExceeded, Counter, Execution, PublicEvidence, PublicRecord, digest
from borderland_eval.archive_learning import ArchivePolicy
from borderland_eval.archive_study import new_output, save_verified, write_json
from borderland_eval.context import actor_transition, actor_view
from borderland_verify.causal_reference import CausalReference


ASSISTANCE = dict(outside_archive='scripted_public_CausalReference',
                  exploration='scripted_public_CausalReference', selections='all_eight_frozen_ArchivePolicy',
                  proof_filing_bind='scripted_executor_without_selection_replacement',
                  notebook='scripted_CausalReference.notebook_after_valid_bind',
                  derived_facts='CausalReference._compile_public_Infrastructure',
                  recovery='existing_public_reference_audits_at_actual_cost')


def implementation_hash():
    root = Path(__file__).parent.parent
    names = ('borderland_eval/archive_transfer.py', 'borderland_eval/archive_cases.py',
             'borderland_eval/archive_learning.py', 'borderland_eval/archive_study.py',
             'borderland_eval/context.py', 'borderland_verify/causal_reference.py')
    return digest({name: (root / name).read_text() for name in names})


class TransferController:
    def __init__(self, weights, rng=None):
        self.policy = ArchivePolicy(weights)
        self.reference = CausalReference()
        self.rng = random.Random(0) if rng is None else rng
        self.pending = deque()
        self.decisions = ()

    def evidence(self):
        reference = self.reference
        records = []
        for record in reference.records.values():
            packet = asdict(record)
            if record.id in reference.ratings:
                packet['ratings'] = [int(value) for value in reference.ratings[record.id]]
            records.append(PublicRecord(record.id, record.service, record.supersedes,
                                        record.applies_channel, record.applies_bit, canonical(packet)))
        return PublicEvidence(tuple((name, *values) for name, values in reference.calibrations.items()),
                              tuple(sorted(records, key=lambda record: record.id)), ())

    def command(self, current):
        observation, board = self.reference._ingest(current)
        phase = observation['phase']
        if phase == 3 and len(self.reference.seen_pages) == 3 * len(board['slots']):
            if not self.decisions:
                evidence = self.evidence()
                if len(evidence.services) != 8:
                    raise ValueError('standard Archive requires eight services')
                self.decisions = tuple(self.policy.decide(evidence, service, self.rng, greedy=True)
                                       for service in evidence.services)
                records = {record.id: record for record in evidence.records}
                selected = [records[decision.candidates[decision.selected]] for decision in self.decisions]
                for record in selected:
                    if record.supersedes is not None:
                        self.pending.append(('action', dict(tag='compare_seal', arguments=dict(
                            left_id=record.supersedes, right_id=record.id)), 'scripted_proof_executor'))
                    self.pending.append(('action', dict(tag='file_record', arguments=dict(record_id=record.id)),
                                         'scripted_filing_executor'))
                self.pending.append(('action', dict(tag='bind_docket', arguments=dict(
                    record_ids=sorted(record.id for record in selected))), 'scripted_bind_executor'))
            if not self.pending:
                raise ValueError('failed bind cannot receive replacement selections')
            return self.pending.popleft()
        if phase >= 4:
            note = self.reference.notebook(current)
            if note is not None:
                return 'note', note, 'scripted_public_notebook_author'
        action = self.reference.choose(current)
        return 'action', action.to_dict(), 'scripted_public_reference'


def run_campaign(seed, weights, action_seed, condition, output, *, command_limit=300, seconds=60):
    if condition not in ('retained', 'erased') or type(command_limit) is not int or not 1 <= command_limit <= 300:
        raise ValueError('retained or erased condition and command limit within 1..300 required')
    if type(seconds) not in (int, float) or not 0 < seconds <= 60:
        raise ValueError('seconds must be finite and within 0..60 exclusive of zero')
    frozen = ArchivePolicy(weights).weights
    destination = new_output(output)
    hashes = dict(source_hash=source_hash(), implementation_hash=implementation_hash())
    execution = Execution(Campaign.generated(seed, generation_version=3, memory_profile='commissioning',
                          archive_workload='standard', notebook_bytes=768), Counter(command_limit, seconds))
    current = execution.campaign.reset()
    controller = TransferController(frozen, random.Random(action_seed))
    decisions, resets, boundary, boundary_public = [], 0, None, None
    status = 'running'

    def spend(kind, payload, role):
        nonlocal current
        before = current
        count = len(execution.commands)
        try:
            current = execution.command(kind, payload, role)
        except ValueError:
            current = execution.campaign.observe()
            raise
        finally:
            if len(execution.commands) > count:
                execution.commands[-1].update(phase_before=int(before.observation.phase),
                                             phase_after=int(current.observation.phase),
                                             charge_before=before.observation.charge,
                                             charge_after=current.observation.charge,
                                             notebook_bytes=len(current.observation.notebook['text'].encode()))

    try:
        while not current.done:
            execution.counter.check()
            kind, payload, role = controller.command(actor_transition(current))
            if controller.decisions and not decisions:
                decisions = [asdict(decision) for decision in controller.decisions]
            spend(kind, payload, role)
            if kind == 'action' and payload['tag'] == 'bind_docket' and int(current.observation.phase) != 4:
                status = 'bind_failed'
                break
            if current.context_reset:
                if int(current.observation.phase) != 6 or boundary is not None:
                    raise ValueError('unexpected Blackout boundary')
                boundary = len(execution.commands)
                boundary_public = actor_view(current)
                controller = TransferController(frozen)
                resets += 1
                if condition == 'erased':
                    spend('note', '', 'lawful_boundary_notebook_erasure')
        else:
            status = 'engine_' + current.outcome
    except (BoundExceeded, ValueError, RuntimeError, StopIteration, KeyError) as error:
        status = str(error) if isinstance(error, BoundExceeded) else 'controller_' + type(error).__name__
        failure = str(error)
    else:
        failure = None
    if hashes != dict(source_hash=source_hash(), implementation_hash=implementation_hash()):
        raise ValueError('source changed during transfer trial')
    commands = execution.commands
    report = dict(**hashes, seed=seed, action_seed=action_seed, condition=condition, weights=frozen,
                  status=status, failure=failure, outcome=current.outcome, verified_escape=current.outcome == 'escaped',
                  terminal=current.done, command_limit=command_limit, seconds_limit=seconds,
                  elapsed_seconds=time.monotonic() - execution.counter.started,
                  actual_commands=execution.counter.used, commands=commands, decisions=decisions,
                  controller_resets=resets, boundary_index=boundary, boundary_public=boundary_public,
                  prefix_hash=digest(commands[:boundary] if boundary is not None else commands),
                  public_stats=dict(phase=int(current.observation.phase), charge=current.observation.charge,
                                    tick=current.observation.tick,
                                    actions=sum(command['kind'] == 'action' for command in commands),
                                    note_writes=sum(command['kind'] == 'note' for command in commands),
                                    audits=sum(command['kind'] == 'action' and command['input']['tag'] == 'audit_service'
                                               for command in commands),
                                    roles=dict(Counts(command['role'] for command in commands))),
                  assistance=ASSISTANCE, replay_witness=save_verified(execution, destination / 'private.jsonl'))
    write_json(destination / 'receipt.json', report)
    return report


def require_pair(retained, erased):
    if retained['condition'] != 'retained' or erased['condition'] != 'erased':
        raise ValueError('retained and erased pair required')
    if any(retained[key] != erased[key] for key in ('seed', 'action_seed', 'weights', 'source_hash', 'implementation_hash')):
        raise ValueError('paired world, frozen weights and action RNG must match')
    left, right = retained['boundary_index'], erased['boundary_index']
    if left != right or canonical(retained['commands'][:left]) != canonical(erased['commands'][:right]):
        raise ValueError('preintervention command bytes differ')
    if canonical(retained['boundary_public']) != canonical(erased['boundary_public']):
        raise ValueError('preintervention public state differs')
    return dict(prefix_equal=True, boundary_reached=left is not None,
                prefix_commands=left if left is not None else retained['actual_commands'],
                prefix_hash=retained['prefix_hash'])


def evaluate(plan_path, weights_paths, output):
    plan = json.loads(Path(plan_path).read_text())
    checkpoints = [json.loads(Path(path).read_text()) for path in weights_paths]
    expected = dict(source_hash=source_hash(), implementation_hash=implementation_hash(), weights_hash=digest(checkpoints))
    if any(plan.get(key) != value for key, value in expected.items()) or not plan.get('analysis'):
        raise ValueError('prospective transfer freeze must match source, implementation, weights and analysis')
    roots = plan.get('roots')
    if not isinstance(roots, list) or not roots or any(type(root) is not int or root < 0 for root in roots) or len(set(roots)) != len(roots):
        raise ValueError('explicit distinct nonnegative root list required')
    for checkpoint in checkpoints:
        ArchivePolicy(checkpoint['initial_weights'])
        ArchivePolicy(checkpoint['weights'])
        if type(checkpoint['initialization']) is not int or checkpoint['initialization'] < 0:
            raise ValueError('nonnegative action RNG initialization required')
    if not checkpoints or len({checkpoint['initialization'] for checkpoint in checkpoints}) != len(checkpoints):
        raise ValueError('distinct frozen weight initializations required')
    destination = new_output(output)
    write_json(destination / 'binding.json', dict(plan=plan, checkpoints=checkpoints, assistance=ASSISTANCE))
    rows, pairs = [], []
    for root in roots:
        for parity in (0, 1):
            for checkpoint in checkpoints:
                initialization = checkpoint['initialization']
                trials = {}
                for policy, condition in (('initial', 'retained'), ('trained', 'retained'), ('trained', 'erased')):
                    weights = checkpoint['initial_weights' if policy == 'initial' else 'weights']
                    name = f'{root}-{parity}-{initialization}-{policy}-{condition}'
                    row = run_campaign(2 * root + parity, weights, initialization, condition, destination / name)
                    row.update(root=root, parity=parity, initialization=initialization, policy=policy)
                    rows.append(row)
                    trials[policy, condition] = row
                    write_json(destination / 'progress.json', dict(rows=rows, pairs=pairs))
                pair = require_pair(trials['trained', 'retained'], trials['trained', 'erased'])
                pairs.append(dict(root=root, parity=parity, initialization=initialization, **pair))
                write_json(destination / 'progress.json', dict(rows=rows, pairs=pairs))
    if expected != dict(source_hash=source_hash(), implementation_hash=implementation_hash(), weights_hash=digest(checkpoints)):
        raise ValueError('source changed during transfer evaluation')
    report = dict(**expected, plan_hash=digest(plan), rows=rows, pairs=pairs,
                  actual_commands=sum(row['actual_commands'] for row in rows),
                  root_commands={str(root): sum(row['actual_commands'] for row in rows if row['root'] == root) for root in roots},
                  assistance=ASSISTANCE, scope='frozen assisted Archive selection transfer; scripted notebook and suffix')
    write_json(destination / 'evaluation.json', report)
    return report


def main():
    parser = argparse.ArgumentParser(description='Frozen assisted Archive full campaign transfer. No provider calls.')
    parser.add_argument('--plan', required=True)
    parser.add_argument('--weights', nargs='+', required=True)
    parser.add_argument('--output', required=True)
    args = parser.parse_args()
    report = evaluate(args.plan, args.weights, args.output)
    print(canonical(dict(trials=len(report['rows']), actual_commands=report['actual_commands'])))


if __name__ == '__main__':
    main()