| """Pipeline v18 Spearman core and preserved equal-pair auxiliary grader.""" |
| import argparse |
| import copy |
| import hashlib |
| import json |
| import math |
| from pathlib import Path |
|
|
| import original_grade as old |
|
|
| TaskError = old.TaskError |
|
|
|
|
| def bounded(value): |
| if not math.isfinite(value) or not -1 - 1e-12 <= value <= 1 + 1e-12: |
| raise TaskError('Spearman outside its finite range') |
| return min(1.0, max(-1.0, value)) |
|
|
|
|
| def average_ranks(values): |
| if len(values) < 2 or any(isinstance(x, bool) or not isinstance(x, (int, float)) |
| or not math.isfinite(x) for x in values): |
| raise TaskError('Invalid measurements') |
| ordered = sorted(range(len(values)), key=values.__getitem__) |
| ranks = [0.0] * len(values) |
| start = 0 |
| while start < len(values): |
| stop = start + 1 |
| while stop < len(values) and values[ordered[stop]] == values[ordered[start]]: |
| stop += 1 |
| mean_rank = (start + 1 + stop) / 2 |
| for index in ordered[start:stop]: |
| ranks[index] = mean_rank |
| start = stop |
| return ranks |
|
|
|
|
| def spearman(values, predicted_positions): |
| ranks = average_ranks(values) |
| n = len(values) |
| if sorted(predicted_positions) != list(range(n)): |
| raise ValueError('Not a complete permutation') |
| predicted_ranks = [p + 1 for p in predicted_positions] |
| true_mean = math.fsum(ranks) / n |
| predicted_mean = math.fsum(predicted_ranks) / n |
| x = [r - true_mean for r in ranks] |
| y = [p - predicted_mean for p in predicted_ranks] |
| denominator = math.sqrt(math.fsum(r * r for r in x) * math.fsum(p * p for p in y)) |
| if denominator <= 0: |
| raise TaskError('Undefined Spearman for constant results') |
| return bounded(math.fsum(r * p for r, p in zip(x, y)) / denominator) |
|
|
|
|
| def promote_contract(contract): |
| value = copy.deepcopy(contract) |
| value.update(scoring_method='spearman', primary_score='task_spearman', |
| spearman_range=[-1, 1], spearman_tie_method='average', |
| spearman_undefined_policy='task_error', |
| secondary_scoring_method='equal_pair_inversion_random95', |
| ranking_reward_range=[0, 1]) |
| return value |
|
|
|
|
| def auxiliary_view(contract): |
| expected = {'scoring_method': 'spearman', 'primary_score': 'task_spearman', |
| 'spearman_range': [-1, 1], 'spearman_tie_method': 'average', |
| 'spearman_undefined_policy': 'task_error', |
| 'secondary_scoring_method': 'equal_pair_inversion_random95', |
| 'ranking_reward_range': [0, 1]} |
| if any(contract.get(k) != v for k, v in expected.items()): |
| raise TaskError('Invalid dual-score contract') |
| value = copy.deepcopy(contract) |
| value['scoring_method'] = value.pop('secondary_scoring_method') |
| for key in ('primary_score', 'spearman_range', 'spearman_tie_method', |
| 'spearman_undefined_policy', 'ranking_reward_range'): |
| value.pop(key) |
| return value |
|
|
|
|
| def scoring_bindings(contract, answers): |
| return {'contract_sha256': old.canonical_sha(contract), |
| 'answers_sha256': old.canonical_sha(answers), |
| 'grader_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), |
| 'auxiliary_grader_sha256': hashlib.sha256(Path(old.__file__).read_bytes()).hexdigest()} |
|
|
|
|
| def validate(contract, answers, baseline): |
| auxiliary = auxiliary_view(contract) |
| old.validate_task(auxiliary, answers) |
| if baseline.get('bindings') != scoring_bindings(contract, answers): |
| raise TaskError('Dual-score baseline hash mismatch') |
| old_baseline = {'q': baseline.get('q'), 'bindings': old.scoring_bindings(auxiliary, answers)} |
| old.validate_baseline(auxiliary, answers, old_baseline) |
| hidden = {g['group_id']: {i['item_id']: i['mean'] for i in g['items']} for g in answers['groups']} |
| for g in contract['groups']: |
| spearman([hidden[g['group_id']][i] for i in g['item_ids']], list(range(len(g['item_ids'])))) |
| return auxiliary, old_baseline, hidden |
|
|
|
|
| def add_core(contract, report, hidden): |
| report['scoring_method'] = 'spearman' |
| report['primary_score'] = 'task_spearman' |
| report['secondary_scoring_method'] = 'equal_pair_inversion_random95' |
| report['official_reward'] = None |
| report['official_ranking_reward'] = None |
| if not report['groups']: |
| report['task_spearman'] = -1.0 |
| report['core_penalty_reason'] = 'whole_task_format_error' |
| report['groups'] = [{'group_id': g['group_id'], 'group_weight': g['group_weight'], |
| 'group_spearman_g': None, 'spearman_for_aggregation': -1.0, |
| 'group_pair_accuracy': 0.0, 'status': 'whole_task_format_error'} |
| for g in contract['groups']] |
| return report |
| for g in report['groups']: |
| if g['status'] != 'valid': |
| rho = None |
| else: |
| item_ids = next(c['item_ids'] for c in contract['groups'] if c['group_id'] == g['group_id']) |
| positions = {item_id: i for i, item_id in enumerate(g['order'])} |
| rho = spearman([hidden[g['group_id']][i] for i in item_ids], [positions[i] for i in item_ids]) |
| g['group_spearman_g'] = rho |
| g['spearman_for_aggregation'] = -1.0 if rho is None else rho |
| report['task_spearman'] = bounded(math.fsum(g['group_weight'] * g['spearman_for_aggregation'] |
| for g in report['groups'])) |
| return report |
|
|
|
|
| def grade_submission(contract, answers, submission, baseline): |
| auxiliary, old_baseline, hidden = validate(contract, answers, baseline) |
| report = old.grade_submission(auxiliary, answers, submission, old_baseline) |
| report['random_q95'] = baseline['q'] |
| return add_core(contract, report, hidden) |
|
|
|
|
| def grade_file(contract, answers, path, baseline): |
| auxiliary, old_baseline, hidden = validate(contract, answers, baseline) |
| return add_core(contract, old.grade_file(auxiliary, answers, path, old_baseline), hidden) |
|
|
|
|
| def official_scores(report, compliance, execution, memory=False): |
| if compliance == 'cheating': |
| return -1.0, 0.0 |
| if compliance != 'compliant' or execution != 'completed': |
| return None, None |
| return report['task_spearman'], report['ranking_reward'] |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument('--interface', choices=['txt', 'json'], default='txt') |
| parser.add_argument('--root', type=Path, default=Path('/tests')) |
| parser.add_argument('--submission', type=Path, default=Path('/logs/artifacts/rankings.json')) |
| parser.add_argument('--output', type=Path, default=Path('/logs/verifier')) |
| args = parser.parse_args() |
| args.output.mkdir(parents=True, exist_ok=True) |
| for name in ('reward.txt', 'reward.json', 'report.json', 'evaluator_error.json'): |
| (args.output / name).unlink(missing_ok=True) |
| try: |
| contract, answers, baseline = [old.load_json((args.root / f'{name}.json').read_bytes()) |
| for name in ('contract', 'answers', 'random_baseline')] |
| report = grade_file(contract, answers, args.submission, baseline) |
| except (TaskError, old.SubmissionError, OSError, ValueError, KeyError, TypeError) as error: |
| old.dump(args.output / 'evaluator_error.json', {'status': 'task_error', 'error': str(error)}) |
| raise SystemExit(2) from error |
| old.dump(args.output / 'report.json', report) |
| if args.interface == 'txt': |
| (args.output / 'reward.txt').write_text(str(report['task_spearman']) + '\n') |
| else: |
| old.dump(args.output / 'reward.json', {'reward': report['task_spearman'], |
| 'ranking_reward': report['ranking_reward']}) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
