File size: 9,222 Bytes
4a372d3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""Explicit pinned fresh model slots; no retries or automatic resumption."""
import argparse
from datetime import datetime, timezone
import json
import os
from pathlib import Path
import subprocess
import sys

from .model import MODEL, LUNA, TERRA, settings, save
from .pool import verify_pool, sha
from . import presentation
from .participant import ACTION_REVISION

SLOTS = [('mini-1', MODEL), ('mini-2', MODEL), ('luna-1', LUNA), ('luna-2', LUNA)]

LABELS={MODEL:'mini',LUNA:'luna',TERRA:'terra'}

def selected_models(models=None):
    chosen=[MODEL,LUNA] if models is None else list(models)
    if not chosen or len(set(chosen))!=len(chosen) or any(m not in LABELS for m in chosen):
        raise ValueError('Select unique supported models')
    return chosen

def slots_for(attempts_per_model=2, models=None):
    if type(attempts_per_model) is not int or not 1<=attempts_per_model<=8:
        raise ValueError('Attempts per model must be 1..8')
    return [(f'{label}-{i}',model) for model in selected_models(models) for label in [LABELS[model]]
            for i in range(1,attempts_per_model+1)]


def coverage_keys(attempts, models=None):
    words={1:'one',2:'two',3:'three',4:'four',6:'six',8:'eight',16:'sixteen'}
    word=lambda n:words.get(n,str(n))
    return ('any_of_'+word(attempts*len(selected_models(models))), *[LABELS[m]+'_any_of_'+word(attempts) for m in selected_models(models)])


def protocol(pool, temperature=0, attempts_per_model=2, models=None, profile=ACTION_REVISION):
    manifest = verify_pool(pool)
    slots=slots_for(attempts_per_model,models)
    result={**({} if attempts_per_model==2 else {'attempts_per_model':attempts_per_model}), 'schema': 'agentgridworld.evaluation.v1' if attempts_per_model==2 else 'agentgridworld.evaluation.v2',
            'pool_manifest_sha256': sha(Path(pool)/'pool.json'),
            'task_ids': [r['id'] for r in manifest['tasks']],
            'slots': [{'id': name, 'model': model, 'settings': settings(model,temperature,action_only=profile==ACTION_REVISION)} for name, model in slots],
            'maximum_model_calls': len(slots)*manifest['maximum_model_calls_per_attempt'],
            'metric': 'mixed-model any-of-four compliant success; not a single-model pass@4 estimate' if attempts_per_model==2 else f'mixed-model any-of-{2*attempts_per_model} coverage; per-model any-of-{attempts_per_model} reported separately',
            'retry_policy': 'zero; interrupted slots preserved, no automatic retry'}

    if models is not None:
        result.update(schema='agentgridworld.evaluation.v3',models=selected_models(models),attempts_per_model=attempts_per_model,
                      metric=f'per-model any-of-{attempts_per_model} compliant success; mixed coverage reported separately')
    if profile != 'auto':
        result['presentation'] = profile
        result['presentation_profile_sha256'] = presentation.profile_sha256(profile)
    return result

def aggregate(plan, reviews):
    attempt_count=plan.get('attempts_per_model',2);models=plan.get('models');slots=slots_for(attempt_count,models)
    keys=coverage_keys(attempt_count,models)
    if [(s['id'],s['model']) for s in plan['slots']]!=slots or len(reviews)!=len(slots):
        raise ValueError('Exactly the pinned model slots are required')
    expected = set(plan['task_ids'])
    for slot, report in zip(plan['slots'], reviews):
        if (report['job'] != slot['id'] or not report['all_trials_verified']
                or report['pool_manifest_sha256'] != plan['pool_manifest_sha256']
                or len(report['tasks']) != len(expected)
                or {r['id'] for r in report['tasks']} != expected
                or any(r['model'] != slot['model'] for r in report['tasks'])):
            raise ValueError('Evaluation slot membership/model mismatch')
    rows = []
    for task in plan['task_ids']:
        attempts = [next(r for r in report['tasks'] if r['id'] == task) for report in reviews]
        if len({r['classification'] for r in attempts}) != 1:
            raise ValueError('Task classification changed')
        successes = [r['outcome']['success'] for r in attempts]
        rows.append({'id': task, 'environment': attempts[0]['environment'],
                     'classification': attempts[0]['classification'],
                     'successes': successes, keys[0]: any(successes),
                     **{key:any(successes[i*attempt_count:(i+1)*attempt_count]) for i,key in enumerate(keys[1:])},
                     'reported_rewards': [r['outcome']['reported_reward'] for r in attempts]})
    def summary(items):
        return {'tasks': len(items), **{k: sum(r[k] for r in items)
                for k in keys}}
    return {'schema': 'agentgridworld.evaluation.review.v3' if models is not None else 'agentgridworld.evaluation.review.v1' if attempt_count==2 else 'agentgridworld.evaluation.review.v2',
            'qualification': 'complete', 'protocol': plan,
            'episodes_verified': len(slots)*len(rows), 'all_tasks': summary(rows),
            'solvable_tasks': summary([r for r in rows if r['classification'] == 'possible']),
            'per_environment': {name: summary([r for r in rows if r['environment'] == name])
                                for name in sorted({r['environment'] for r in rows})},
            'per_slot': [{k:v for k,v in r.items() if k != 'tasks'} for r in reviews],
            'model_calls': sum(r['model_calls'] for r in reviews),
            'input_tokens': sum(r['input_tokens'] for r in reviews),
            'output_tokens': sum(r['output_tokens'] for r in reviews), 'tasks': rows}


def review_evaluation(pool, root):
    from .review import review
    root = Path(root)
    plan = json.loads((root/'protocol.json').read_text())
    if plan != protocol(pool,plan['slots'][0]['settings']['temperature'],plan.get('attempts_per_model',2),profile=plan.get('presentation','auto'),**({'models':plan['models']} if 'models' in plan else {})):
        raise ValueError('Protocol changed since launch')
    for slot in plan['slots']:
        binding=json.loads((root/'jobs'/(slot['id']+'.pool-binding.json')).read_text())
        if 'presentation' in plan and binding.get('presentation','base') != plan['presentation']:
            raise ValueError('Slot presentation differs from campaign protocol')
        if binding.get('settings')!=slot['settings']:
            raise ValueError('Slot sampling differs from campaign protocol')
    reviews = [review(pool, root/'jobs'/slot['id']) for slot in plan['slots']]
    return aggregate(plan, reviews), reviews


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--pool', type=Path, required=True)
    parser.add_argument('--output', type=Path)
    parser.add_argument('--review', type=Path)
    parser.add_argument('--env-file', type=Path)
    parser.add_argument('--modal-profile')
    parser.add_argument('--temperature',type=float,default=0)
    parser.add_argument('--attempts-per-model',type=int,default=2)
    parser.add_argument('--presentation',choices=presentation.PROFILES,default=ACTION_REVISION)
    parser.add_argument('--models',nargs='+',choices=list(LABELS))
    args = parser.parse_args()
    if bool(args.output) == bool(args.review):
        parser.error('Choose exactly one of --output or --review')
    pool = args.pool.resolve()
    if args.review:
        root = args.review.resolve()
        if (root/'summary.json').exists():
            raise FileExistsError('Review already recorded')
        result, reviews = review_evaluation(pool, root)
        for slot, report in zip(result['protocol']['slots'], reviews):
            save(root/(slot['id']+'.readback.json'), report)
        save(root/'summary.json', result)
        print(json.dumps({k:v for k,v in result.items() if k not in ('tasks','protocol','per_slot')}, indent=2))
        return
    root = args.output.resolve()
    root.mkdir(parents=True, exist_ok=False)
    plan = protocol(pool,args.temperature,args.attempts_per_model,args.models,profile=args.presentation)
    save(root/'protocol.json', plan)
    for slot in plan['slots']:
        command = [sys.executable, '-m', 'agentgridworld.run', '--pool', str(pool),
                   '--mode', 'model', '--model', slot['model'], '--job-name', slot['id'],
                   '--jobs-dir', str(root/'jobs')]
        if args.presentation != 'auto':command += ['--presentation',args.presentation]
        if args.env_file: command += ['--env-file', str(args.env_file.resolve())]
        if args.modal_profile: command += ['--modal-profile', args.modal_profile]
        if args.temperature!=0: command += ['--temperature',str(args.temperature)]
        print('Starting', slot['id'], flush=True)
        result = subprocess.run(command, env={**os.environ, 'PYTHONHASHSEED':'0'})
        save(root/(slot['id']+'.completion.json'), {'exit_code':result.returncode,
             'finished_at':datetime.now(timezone.utc).isoformat()})
        if result.returncode:
            raise SystemExit('Slot failed; evidence preserved. No automatic retry.')
    print(f'{len(plan["slots"])} slots finished; independent replay review is required.', flush=True)


if __name__ == '__main__': main()