Download annotations/annotation_100/MPSC/src/_evaluation.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 6.5 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_100/MPSC/src/_evaluation.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_100/MPSC/src/_evaluation.py
-
curl -L -o _evaluation.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_100/MPSC/src/_evaluation.py
6.5 kB
| # Copyright (c) Microsoft Corporation. | |
| # Licensed under the MIT license. | |
| # Copied from CodeT (https://github.com/microsoft/CodeT/tree/main/CodeT) | |
| import statistics | |
| import numpy as np | |
| from collections import defaultdict | |
| import logging | |
| from typing import List, Union | |
| from math import comb | |
| import itertools | |
| logging.basicConfig( | |
| format="SystemLog: [%(asctime)s][%(name)s][%(levelname)s] - %(message)s", | |
| datefmt="%Y-%m-%d %H:%M:%S", | |
| level=logging.INFO, | |
| ) | |
| logger = logging.getLogger(__name__) | |
| def _dictionized_ground_truth_results(ground_truth_exec_results): | |
| ground_truth_results_by_task_and_solution = defaultdict(defaultdict) | |
| for result in ground_truth_exec_results: | |
| ground_truth_results_by_task_and_solution[result['task_id']][result['completion']] = result['passed'] | |
| return ground_truth_results_by_task_and_solution | |
| def _turn_solution_scores_into_choose_count(sorted_solution_scores, topk): | |
| # sorted_solution_scores: list of (solution, score) | |
| # if wrapped, sorted_solution_scores is list of ([solutions], score) | |
| # return list of (solution, choose_count) | |
| wrapped = True if type(sorted_solution_scores[0][0]) == list else False # Unwrapped for our method | |
| result = [] | |
| if wrapped: | |
| last_score = sorted_solution_scores[0][1] | |
| merged_solutions_and_score = [sorted_solution_scores[0]] | |
| for solutions, score in sorted_solution_scores[1:]: | |
| if score == last_score: | |
| last_solutions = merged_solutions_and_score[-1][0] | |
| merged_solutions_and_score[-1] = (last_solutions + solutions, score) | |
| else: | |
| merged_solutions_and_score.append((solutions, score)) | |
| last_score = score | |
| for solutions_and_score in merged_solutions_and_score: | |
| result.append((solutions_and_score[0], 1)) # choose one from solutions_and_score | |
| else: | |
| topk_scores = sorted(list(set([i[1] for i in sorted_solution_scores])), reverse=True) | |
| for score in topk_scores: | |
| solutions = [s[0] for s in sorted_solution_scores if s[1] == score] # solutions with `score` | |
| result.append((solutions, 1)) # append a tuple of (solutions, choose_count) | |
| if len(result) >= topk: | |
| return result[:topk] | |
| else: | |
| intial_choose_count = [1]*len(result) | |
| for i in range(topk-len(result)): | |
| intial_choose_count[i%len(result)] += 1 | |
| for i, choose_count in enumerate(intial_choose_count): | |
| result[i] = (result[i][0], choose_count) | |
| return result | |
| def get_result_of_sorted_solutions(ground_truth_results_list, sorted_solutions_by_task, topks=[1,2,10]): | |
| # sorted_solutions_by_task {task_id: [([solutions], score), ...]} | |
| def _count_correct(solutions: list, ground_truth_results: dict) -> int: | |
| return sum([ground_truth_results[s] for s in solutions]) | |
| ground_truth_results = _dictionized_ground_truth_results(ground_truth_results_list) | |
| topk_results = dict() | |
| for topk in topks: | |
| random_pass_at_k_by_task = pass_at_K_by_task(ground_truth_results_list, k=topk) | |
| pass_rates = [] | |
| for task_id in ground_truth_results.keys(): | |
| all_wrong_probability = 1 | |
| if task_id in sorted_solutions_by_task and sorted_solutions_by_task[task_id]: | |
| solutions_and_probability = _turn_solution_scores_into_choose_count(sorted_solutions_by_task[task_id], topk) | |
| for solutions, choose_count in solutions_and_probability: | |
| current_wrong_prob = _estimator(len(solutions), _count_correct(solutions, ground_truth_results[task_id]), 1) | |
| repeat_current_wrong_prob = pow(current_wrong_prob, choose_count) | |
| all_wrong_probability *= repeat_current_wrong_prob | |
| pass_rates.append(1-all_wrong_probability) | |
| else: | |
| pass_rates.append(random_pass_at_k_by_task[task_id]) | |
| # the avg rate of all tasks | |
| topk_results[f'pass@{topk}'] = round(statistics.mean(pass_rates), 4) | |
| logger.info(topk_results) | |
| def pass_at_K_by_task(results, k): | |
| result_dict = defaultdict(list) | |
| for line in results: | |
| result_dict[line['task_id']].append(line['passed']) | |
| result = dict() | |
| for task_id in result_dict.keys(): | |
| total = len(result_dict[task_id]) | |
| correct = sum(result_dict[task_id]) | |
| score = _estimate_pass_at_k(total, [correct], k)[0] | |
| result[task_id] = score | |
| return result | |
| def pass_at_K(results, k = [1, 10, 100]): | |
| def _turn_list_into_dict(result_lines): | |
| result_dict = defaultdict(list) | |
| for line in result_lines: | |
| result_dict[line['task_id']].append(line['passed']) | |
| return result_dict | |
| # Calculate pass@k. | |
| total, correct = [], [] | |
| for passed in _turn_list_into_dict(results).values(): | |
| total.append(len(passed)) | |
| correct.append(sum(passed)) | |
| total = np.array(total) | |
| correct = np.array(correct) | |
| ks = k | |
| pass_at_k = {f"pass@{k}": round(_estimate_pass_at_k(total, correct, k).mean(), 4) | |
| for k in ks if (total >= k).all()} | |
| logger.info(pass_at_k) | |
| def _estimator(n: int, c: int, k: int) -> float: | |
| """ | |
| Calculates comb(n - c, k) / comb(n, k). | |
| """ | |
| if n - c < k: | |
| return 0 | |
| return np.prod(1.0 - k / np.arange(n - c + 1, n + 1)) | |
| def _estimate_pass_at_k( | |
| num_samples: Union[int, List[int], np.ndarray], | |
| num_correct: Union[List[int], np.ndarray], | |
| k: int | |
| ) -> np.ndarray: | |
| """ | |
| Estimates pass@k of each problem and returns them in an array. | |
| """ | |
| if isinstance(num_samples, int): | |
| num_samples_it = itertools.repeat(num_samples, len(num_correct)) | |
| else: | |
| assert len(num_samples) == len(num_correct) | |
| num_samples_it = iter(num_samples) | |
| return np.array([1.0 - _estimator(int(n), int(c), k) for n, c in zip(num_samples_it, num_correct)]) | |
| def hypergeometric_distribution(n, c, k, t): | |
| if t > c or t > k or k-t > n-c: | |
| return 0 | |
| return comb(c, t) * comb(n - c, k - t) / comb(n, k) | |
| def _estimate_precision_at_k( | |
| num_samples: Union[List[int], np.ndarray], | |
| num_correct: Union[List[int], np.ndarray], | |
| k: int | |
| ) -> np.ndarray: | |
| """ | |
| Estimates precision@k of each problem and returns them in an array. | |
| """ | |
| return np.array([sum([t / k * hypergeometric_distribution(int(n), int(c), k, t) for t in range(0, k+1)]) for n, c in zip(num_samples, num_correct)]) | |