mcy98's picture
Upload folder using huggingface_hub
d7ff85b verified
Raw History Blame Contribute Delete
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)])