"""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()