Download annotations/annotation_100/MPSC/src/graph.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 19.7 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_100/MPSC/src/graph.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_100/MPSC/src/graph.py
-
curl -L -o graph.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_100/MPSC/src/graph.py
19.7 kB
| import json | |
| import concurrent | |
| import os | |
| import numpy as np | |
| from functools import partial | |
| from enum import Enum, auto | |
| from tqdm import tqdm | |
| from collections import defaultdict | |
| from multiprocessing import Pool | |
| import copy | |
| from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction | |
| from utils import * | |
| from _evaluation import _turn_solution_scores_into_choose_count, _estimator, _estimate_pass_at_k | |
| from evaluation import original_pass_at_k, sorted_pass_at_k_top_hat_n | |
| class InitMethod(Enum): | |
| UNIFORM = auto() | |
| LEXICAL = auto() | |
| SEMANTIC = auto() # Ranked by weighted cardinality of consensus set | |
| class VertexType(Enum): | |
| code = auto() | |
| spec = auto() | |
| testcase = auto() | |
| class VertexGroup: | |
| def __init__(self, task_id, data_type, vertex_type: VertexType): | |
| self.data_type = data_type | |
| self.task_id = task_id | |
| self.type = vertex_type | |
| self.vertex_group = [] | |
| def init_vertex_group(task_id, data_type, vertex_type: VertexType, max_num: int): | |
| if vertex_type == VertexType.code: | |
| return CodeVertexGroup(task_id, data_type, max_num) | |
| elif vertex_type == VertexType.spec: | |
| return SpecVertexGroup(task_id, data_type, max_num) | |
| elif vertex_type == VertexType.testcase: | |
| return TestcaseVertexGroup(task_id, data_type, max_num) | |
| def get_uniform_s0(self): | |
| return np.ones(len(self.vertex_group)) / len(self.vertex_group) | |
| def get_lexical_s0(self): | |
| def bleu_score(hypothesis, reference): | |
| smoothing = SmoothingFunction() | |
| return sentence_bleu([reference.split()], hypothesis.split(), smoothing_function=smoothing.method1) | |
| # calculate risk matrix with bleu score | |
| risk = np.ones((len(self.vertex_group), len(self.vertex_group))) | |
| for i in range(len(self.vertex_group) - 1): | |
| for j in range(i + 1, len(self.vertex_group)): | |
| risk[i][j] = bleu_score(self.vertex_group[i], self.vertex_group[j]) | |
| risk[j][i] = risk[i][j] | |
| # calculate lexical s0 | |
| return np.array([np.sum(risk[i]) for i in range(len(self.vertex_group))]) / len(self.vertex_group) | |
| def __len__(self): | |
| return len(self.vertex_group) | |
| class CodeVertexGroup(VertexGroup): | |
| def __init__(self, task_id, data_type, max_num): | |
| super().__init__(task_id, data_type, VertexType.code) | |
| # load code data | |
| data = CODE_VERTEX_GROUP_DATA | |
| for item in data: | |
| if item['task_id'] == task_id: | |
| break | |
| else: | |
| raise Exception(f"Cannot find code of task_id {task_id}") | |
| self.vertex_group = item['completions'][:max_num] | |
| class SpecVertexGroup(VertexGroup): | |
| def __init__(self, task_id, data_type, max_num): | |
| super().__init__(task_id, data_type, VertexType.spec) | |
| # load spec data | |
| data = SPEC_VERTEX_GROUP_DATA | |
| for item in data: | |
| if item['task_id'] == task_id: | |
| break | |
| else: | |
| raise Exception(f"Cannot find spec of task_id {task_id}") | |
| self.vertex_group = item['spec_code_choices'][:max_num] | |
| class TestcaseVertexGroup(VertexGroup): | |
| def __init__(self, task_id, data_type, max_num): | |
| super().__init__(task_id, data_type, VertexType.testcase) | |
| # load testcase data | |
| data = TESTCASE_VERTEX_GROUP_DATA | |
| for item in data: | |
| if item['task_id'] == task_id: | |
| break | |
| else: | |
| raise Exception(f"Cannot find testcase of task_id {task_id}") | |
| self.vertex_group = item['tc_input_output'][:max_num] | |
| def get_lexical_s0(self): | |
| # calculate risk matrix with bleu score | |
| risk = np.ones((len(self.vertex_group), len(self.vertex_group))) | |
| for i in range(len(self.vertex_group) - 1): | |
| for j in range(i + 1, len(self.vertex_group)): | |
| risk[i][j] = self.vertex_group[i] == self.vertex_group[j] | |
| risk[j][i] = risk[i][j] | |
| # calculate lexical s0 | |
| return np.array([np.sum(risk[i]) for i in range(len(self.vertex_group))]) / len(self.vertex_group) | |
| class EdgeGroup: | |
| def __init__(self, task_id, data_type, vertex_group1, vertex_group2): | |
| self.data_type = data_type | |
| self.task_id = task_id | |
| self.vertex_group1 = vertex_group1 | |
| self.vertex_group2 = vertex_group2 | |
| def init_edge_group(task_id, data_type, vertex_group1, vertex_group2): | |
| if isinstance(vertex_group1, CodeVertexGroup) and isinstance(vertex_group2, SpecVertexGroup): | |
| return CodeSpecEdgeGroup(task_id, data_type, vertex_group1, vertex_group2) | |
| elif isinstance(vertex_group1, CodeVertexGroup) and isinstance(vertex_group2, TestcaseVertexGroup): | |
| return CodeTestcaseEdgeGroup(task_id, data_type, vertex_group1, vertex_group2) | |
| elif isinstance(vertex_group1, SpecVertexGroup) and isinstance(vertex_group2, TestcaseVertexGroup): | |
| return SpecTestcaseEdgeGroup(task_id, data_type, vertex_group1, vertex_group2) | |
| def get_adj_matrix(self): | |
| return self.adj_matrix | |
| class CodeSpecEdgeGroup(EdgeGroup): | |
| def __init__(self, task_id, data_type, vertex_group1, vertex_group2): | |
| super().__init__(task_id, data_type, vertex_group1, vertex_group2) | |
| # load verification results | |
| data = CODE_SPEC_EDGE_GROUP_DATA | |
| verification_results = [] | |
| for item in data: | |
| if item['task_id'] == task_id: | |
| verification_results.append(item) | |
| if len(verification_results) == 0: | |
| raise Exception(f"Cannot find code-spec verification result of task_id {task_id}") | |
| # create nested dict for verification results | |
| # indexed by code str and spec str | |
| code_spec_res = defaultdict(dict) | |
| for item in verification_results: | |
| code_str = item['solution'] | |
| spec_str = item['spec'] | |
| code_spec_res[code_str][spec_str] = sum(item['result']) / len(item['result']) # average over all casual inputs | |
| # calculate adjacency matrix | |
| self.adj_matrix = np.zeros((len(vertex_group1), len(vertex_group2))) | |
| for i in range(len(vertex_group1)): | |
| for j in range(len(vertex_group2)): | |
| code_str = vertex_group1.vertex_group[i] | |
| spec_str = vertex_group2.vertex_group[j] | |
| if code_str in code_spec_res and spec_str in code_spec_res[code_str]: | |
| self.adj_matrix[i][j] = code_spec_res[code_str][spec_str] | |
| else: | |
| self.adj_matrix[i][j] = 0 | |
| print("Some code-spec pair is not found in verification results") | |
| class CodeTestcaseEdgeGroup(EdgeGroup): | |
| def __init__(self, task_id, data_type, vertex_group1, vertex_group2): | |
| super().__init__(task_id, data_type, vertex_group1, vertex_group2) | |
| # load verification results | |
| data = CODE_TESTCASE_EDGE_GROUP_DATA | |
| verification_results = [] | |
| for item in data: | |
| if item['task_id'] == task_id: | |
| verification_results.append(item) | |
| if len(verification_results) == 0: | |
| raise Exception(f"Cannot find code-testcase verification result of task_id {task_id}") | |
| # create nested dict for verification results | |
| # indexed by code str and testcase idx | |
| code_testcase_res = defaultdict(dict) | |
| for item in verification_results: | |
| code_str = item['code'] | |
| for i, res in enumerate(item['result']): | |
| code_testcase_res[code_str][i] = float(res) | |
| # calculate adjacency matrix | |
| self.adj_matrix = np.zeros((len(vertex_group1), len(vertex_group2))) | |
| for i in range(len(vertex_group1)): | |
| for j in range(len(vertex_group2)): | |
| code_str = vertex_group1.vertex_group[i] | |
| testcase_idx = j | |
| if code_str in code_testcase_res and testcase_idx in code_testcase_res[code_str]: | |
| self.adj_matrix[i][j] = code_testcase_res[code_str][testcase_idx] | |
| else: | |
| self.adj_matrix[i][j] = 0 | |
| print("Some code-testcase pair is not found in verification results") | |
| class SpecTestcaseEdgeGroup(EdgeGroup): | |
| def __init__(self, task_id, data_type, vertex_group1, vertex_group2): | |
| super().__init__(task_id, data_type, vertex_group1, vertex_group2) | |
| # load verification results | |
| data = SPEC_TESTCASE_EDGE_GROUP_DATA | |
| verification_results = [] | |
| for item in data: | |
| if item['task_id'] == task_id: | |
| verification_results.append(item) | |
| if len(verification_results) == 0: | |
| raise Exception(f"Cannot find spec-testcase verification result of task_id {task_id}") | |
| # create nested dict for verification results | |
| # indexed by spec str and testcase idx | |
| spec_testcase_res = defaultdict(dict) | |
| for item in verification_results: | |
| spec_str = item['spec'] | |
| for i, res in enumerate(item['result']): | |
| spec_testcase_res[spec_str][i] = float(res) | |
| # calculate adjacency matrix | |
| self.adj_matrix = np.zeros((len(vertex_group1), len(vertex_group2))) | |
| for i in range(len(vertex_group1)): | |
| for j in range(len(vertex_group2)): | |
| spec_str = vertex_group1.vertex_group[i] | |
| testcase_idx = j | |
| if spec_str in spec_testcase_res and testcase_idx in spec_testcase_res[spec_str]: | |
| self.adj_matrix[i][j] = spec_testcase_res[spec_str][testcase_idx] | |
| else: | |
| self.adj_matrix[i][j] = 0 | |
| print("Some spec-testcase pair is not found in verification results") | |
| class NPartiteGraph: | |
| def __init__(self, task_id: int, data_type, vertex_type_lst, max_iter=5000, init_method=InitMethod.LEXICAL): | |
| self.data_type = data_type | |
| self.task_id = task_id | |
| self.vertex_type_lst = vertex_type_lst | |
| self.max_iter = max_iter | |
| # load vertex data | |
| self.vertex_group_lst = [] | |
| self.vertex_type2idx_range = {} # Each vertex type is assigned a range of indices in the `self.score_vector` | |
| for vt in VertexType: | |
| for used_vt, max_num in vertex_type_lst: | |
| if vt == used_vt: | |
| break | |
| else: | |
| continue | |
| self.vertex_group_lst.append(VertexGroup.init_vertex_group(task_id, data_type, vt, max_num)) | |
| self.vertex_type2idx_range[vt] = (sum([len(vg) for vg in self.vertex_group_lst[:-1]]), sum([len(vg) for vg in self.vertex_group_lst])) | |
| # calculate adjacency matrix | |
| self.edge_group_lst = defaultdict(dict) | |
| for i in range(len(self.vertex_group_lst)): | |
| for j in range(i+1, len(self.vertex_group_lst)): | |
| eg = EdgeGroup.init_edge_group(task_id, data_type, self.vertex_group_lst[i], self.vertex_group_lst[j]) | |
| self.edge_group_lst[i][j] = eg | |
| # concatenate all edges into a adjancency matrix | |
| num_vertex = sum([len(vg) for vg in self.vertex_group_lst]) | |
| self.adj_matrix = np.empty((0, num_vertex), dtype=np.float32) | |
| for i in range(len(self.vertex_group_lst)): | |
| matrix_lst = [] | |
| if i > 0: | |
| tmp = np.concatenate([self.edge_group_lst[j][i].get_adj_matrix().T for j in range(i)], axis=1) | |
| matrix_lst.append(tmp) | |
| tmp = np.zeros((len(self.vertex_group_lst[i]), len(self.vertex_group_lst[i]))) | |
| matrix_lst.append(tmp) | |
| if i < len(self.vertex_group_lst) - 1: | |
| tmp = np.concatenate([eg.get_adj_matrix() for eg in self.edge_group_lst[i].values()], axis=1) | |
| matrix_lst.append(tmp) | |
| self.adj_matrix = np.concatenate([self.adj_matrix, np.concatenate(matrix_lst, axis=1)], axis=0) | |
| # calculate transition matrix | |
| self.degree_vector = np.sum(self.adj_matrix, axis=1) | |
| self.mask_vector = np.where(self.degree_vector == 0, 1, 0) | |
| masked_degree_vector = np.where(self.degree_vector == 0, 1, self.degree_vector) #avoid division by zero | |
| masked_norm_vector = np.power(masked_degree_vector, -1/2) | |
| norm_vector = np.where(self.mask_vector, 0, masked_norm_vector) | |
| norm_matrix = np.diag(norm_vector) | |
| self.transition_matrix = np.matmul(norm_matrix, np.matmul(self.adj_matrix, norm_matrix)) | |
| # initialize s0 vector | |
| self.s0 = None | |
| self.initialize_s0(init_method) | |
| # mask then normalize s0 | |
| self.s0 = np.where(self.mask_vector, 0, self.s0) | |
| for b,e in self.vertex_type2idx_range.values(): | |
| total = np.sum(self.s0[b:e]) | |
| if total != 0: | |
| self.s0[b:e] = self.s0[b:e] / total | |
| # initialize score | |
| self.score_vector = copy.deepcopy(self.s0) | |
| # dynamic alpha (see Appendix) | |
| num_edges = 0 | |
| for i in range(len(self.vertex_group_lst)): | |
| for j in range(i+1, len(self.vertex_group_lst)): | |
| num_edges += len(self.vertex_group_lst[i]) * len(self.vertex_group_lst[j]) | |
| mean_edge_weight = np.sum(self.adj_matrix) / 2 / num_edges | |
| self.alpha = 0.01 if mean_edge_weight < 0.16 else 0.95 | |
| def fit(self): | |
| iter_left = self.max_iter | |
| prev_score = None | |
| while (prev_score is None or np.linalg.norm(self.score_vector - prev_score) > 1e-6) and iter_left > 0: | |
| prev_score = self.score_vector | |
| self.score_vector = self.alpha * np.matmul(self.transition_matrix, self.score_vector) + (1-self.alpha) * self.s0 | |
| iter_left -= 1 | |
| if iter_left == 0: | |
| print(f"Warning: Does not converge in {self.max_iter} iterations") | |
| return self.max_iter-iter_left | |
| def get_sorted_partition_score(self, vertex_type: VertexType): | |
| """ | |
| Return a list of (vertex_string, score) tuples, sorted by score in descending order | |
| """ | |
| for vg in self.vertex_group_lst: | |
| if vg.type == vertex_type: | |
| break | |
| vertex_string_lst = vg.vertex_group | |
| # Assign vertices without any edges to 0 score | |
| score_vector = self.score_vector.copy() | |
| score_vector[self.mask_vector == 1] = 0 | |
| score_lst = score_vector[self.vertex_type2idx_range[vertex_type][0]:self.vertex_type2idx_range[vertex_type][1]].tolist() | |
| assert len(vertex_string_lst) == len(score_lst) | |
| return sorted(zip(vertex_string_lst, score_lst), key=lambda x: x[1], reverse=True) | |
| def initialize_s0(self, init_method=InitMethod.UNIFORM): | |
| if init_method == InitMethod.UNIFORM: | |
| self.s0 = np.concatenate([vg.get_uniform_s0() for vg in self.vertex_group_lst], axis=0) | |
| elif init_method == InitMethod.LEXICAL: | |
| self.s0 = np.concatenate([vg.get_lexical_s0() for vg in self.vertex_group_lst], axis=0) | |
| elif init_method == InitMethod.SEMANTIC: | |
| adj_matrix = self.adj_matrix.copy() | |
| s0_lst = [] | |
| for b,e in self.vertex_type2idx_range.values(): | |
| unique_rows, counts = np.unique(adj_matrix[b:e], axis=0, return_counts=True) | |
| # score = np.log(counts + 1) | |
| score = counts | |
| for tmpb, tmpe in self.vertex_type2idx_range.values(): | |
| # skip the diagonal block or the missing block | |
| if tmpb == b or tmpb == tmpe: | |
| continue | |
| sum_weight = unique_rows[:,tmpb:tmpe].sum(axis=1) + 1 # add 1 to avoid 0 | |
| normalized_weight = sum_weight / (tmpe - tmpb) # normalize to keep weight from different vertex types comparable | |
| score = score * normalized_weight # score of vertex i is calculated as: \Product_t #Agreement of i with type t vertices | |
| idx_lst = [] | |
| for row in adj_matrix[b:e]: | |
| idx = np.where((unique_rows == row).all(axis=1)) | |
| assert len(idx) == 1 | |
| idx_lst.append(idx[0][0]) | |
| assert np.array_equal(unique_rows[idx[0][0]], row) | |
| s0 = score[idx_lst] | |
| total = np.sum(s0) | |
| if total != 0: | |
| s0 = s0 / total | |
| s0_lst.append(s0) | |
| self.s0 = np.concatenate(s0_lst, axis=0) | |
| def process_fn(task_id, data_type, vertex_type_lst, init_method): | |
| graph = NPartiteGraph(task_id=task_id, data_type=data_type, vertex_type_lst=vertex_type_lst, init_method=init_method) | |
| num_iteration = graph.fit() | |
| code_score = graph.get_sorted_partition_score(VertexType.code) | |
| return task_id, code_score, num_iteration | |
| def get_code_sorted(data_type, vertex_type_lst, init_method): | |
| # print("Start processing {} ......".format(data_type)) | |
| dataset = load_jsonl(f"../data/{data_type}.jsonl") | |
| task_ids_lst = [item['task_id'] for item in dataset] | |
| code_score_dict = {} | |
| fn = partial(process_fn, data_type=data_type, vertex_type_lst=vertex_type_lst, init_method=init_method) | |
| code_score_dict = {} | |
| # for task_id in tqdm(task_ids_lst): | |
| # rtn = fn(task_id) | |
| # code_score_dict[rtn[0]] = rtn[1] | |
| import time | |
| start_time = time.time() | |
| num_iteration = [] | |
| with concurrent.futures.ProcessPoolExecutor() as executor: | |
| futures = [executor.submit(fn, task_id) for task_id in task_ids_lst] | |
| for future in tqdm(concurrent.futures.as_completed(futures), total=len(futures)): | |
| res = future.result() | |
| code_score_dict[res[0]] = res[1] | |
| num_iteration.append(res[2]) | |
| end_time = time.time() | |
| print(f"Avg Time: {(end_time - start_time) / len(task_ids_lst)} seconds") | |
| # save sorted code | |
| dump_pickle(code_score_dict, f"../save/{data_type}/code_sorted_npartite.pkl") | |
| if __name__ == '__main__': | |
| os.chdir(os.path.dirname(os.path.abspath(__file__))) | |
| for data_type, isplus in [("human_eval", False), ("human_eval", True), ("CodeContests", False), ("mbpp", False)]: | |
| print(f"==== {data_type}{'+' if isplus else ''} ====") | |
| # baseline pass@k without sorting | |
| pass_origin = [str(x) for x in original_pass_at_k(data_type, isplus).values()] | |
| print("Baseline: pass@1/2/5: ", '/'.join(pass_origin)) | |
| vertex_type_lst = [(VertexType.code, 200), (VertexType.spec, 50), (VertexType.testcase, 100)] | |
| CODE_VERTEX_GROUP_DATA = load_jsonl(f"../save/{data_type}/solutions.jsonl") | |
| SPEC_VERTEX_GROUP_DATA = load_jsonl(f"../save/{data_type}/specs.jsonl") | |
| TESTCASE_VERTEX_GROUP_DATA = load_pickle(f"../save/{data_type}/test_cases.pkl") | |
| CODE_SPEC_EDGE_GROUP_DATA = load_pickle(f"../save/{data_type}/code_spec_res.pkl") | |
| CODE_TESTCASE_EDGE_GROUP_DATA = load_pickle(f"../save/{data_type}/code_testcase_res.pkl") | |
| SPEC_TESTCASE_EDGE_GROUP_DATA = load_pickle(f"../save/{data_type}/spec_testcase_res.pkl") | |
| init_method = InitMethod.LEXICAL | |
| get_code_sorted(data_type, vertex_type_lst, init_method) | |
| pass_tophatn = [str(x) for x in sorted_pass_at_k_top_hat_n(data_type, isplus).values()] | |
| print("MPSC-Lexical: pass@1/2/5: ", '/'.join(pass_tophatn)) | |
| init_method = InitMethod.SEMANTIC | |
| get_code_sorted(data_type, vertex_type_lst, init_method) | |
| pass_tophatn = [str(x) for x in sorted_pass_at_k_top_hat_n(data_type, isplus).values()] | |
| print("MPSC-Semantic: pass@1/2/5: ", '/'.join(pass_tophatn)) |