Download src/evaluation.py from ManavSinghal157/NoFunEval: direct link, hf CLI and curl.
- Browser
- Download file 17.5 kB
-
https://huggingface.co/datasets/ManavSinghal157/NoFunEval/resolve/refs%2Fpr%2F1/src/evaluation.py
- Command line
-
hf download hf://datasets/ManavSinghal157/NoFunEval@refs/pr/1/src/evaluation.py
-
curl -L -o evaluation.py https://huggingface.co/datasets/ManavSinghal157/NoFunEval/resolve/refs%2Fpr%2F1/src/evaluation.py
17.5 kB
| import os | |
| import csv | |
| import time | |
| import argparse | |
| import jsonlines | |
| import pandas as pd | |
| from statistics import mean | |
| from jinja2 import Environment, FileSystemLoader | |
| from utils import pass_at_k_continuous_vals, diff_bleu, post_process_generations, statistical_significance_test, remove_comments, remove_blank_lines,get_files_with_syntax_errors | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument("--data_subset", type = str, default = "latency", help = "latency/resource_util/runtime_efficiency/maintenance/security") | |
| parser.add_argument("--model", type = str, default = "wizardcoder", help = "model name") | |
| parser.add_argument("--model_path", type = str, required = True, help = "HF path for OS models") | |
| parser.add_argument("--prompt", type = str, default = "base_prompt", help = "base_prompt/coding_concepts/chain_of_thought/one-shot") | |
| parser.add_argument("--num_samples", type = int, default = 1, help = "Number of samples") | |
| parser.add_argument("--score_k", type = str, default = "1,5,10,20", help = "K value for score@k (should not be greater than num_samples and can be comma-separated)") | |
| parser.add_argument("--metric", type = str, default = "runtime", help = "runtime/diffbleu/codeql-diffbleu") | |
| args = parser.parse_args() | |
| args.model = args.model_path.split("/")[-1] | |
| generations_path = os.path.join("generations", "edit", args.data_subset, args.model, args.prompt, f"{args.num_samples}_samples", "generated_outputs.jsonl") | |
| if(args.metric == "classification"): | |
| generations_path = os.path.join("generations", "classification", args.data_subset, os.path.split(args.model_path)[1], args.prompt, f"{args.num_samples}_samples", "generated_outputs.jsonl") | |
| left_predictions = [] | |
| right_predictions = [] | |
| left_labels = [] | |
| right_labels = [] | |
| with jsonlines.open(generations_path) as reader: | |
| for generation in reader: | |
| left_predictions.append(generation['left_output']) | |
| left_labels.append(generation['classification_left_label']) | |
| right_predictions.append(generation['right_output']) | |
| right_labels.append(generation['classification_right_label']) | |
| left_accuracy = sum([1 if prediction == label else 0 for prediction, label in zip(left_predictions, left_labels)]) / len(left_labels) | |
| left_consistency = sum([1 if prediction is not None else 0 for prediction in left_predictions]) / len(left_predictions) | |
| right_accuracy = sum([1 if prediction == label else 0 for prediction, label in zip(right_predictions, right_labels)]) / len(right_labels) | |
| right_consistency = sum([1 if prediction is not None else 0 for prediction in right_predictions]) / len(right_predictions) | |
| joint_accuracy = [1 if left_prediction == left_label and | |
| right_prediction == right_label else 0 | |
| for left_prediction, left_label, right_prediction, right_label | |
| in zip(left_predictions, left_labels, right_predictions, right_labels)] | |
| joint_accuracy = sum(joint_accuracy) / len(joint_accuracy) | |
| result_string = {"Model":args.model, "left_accuracy":round((left_accuracy*100),1), "right_accuracy":round((right_accuracy*100),1), "joint_accuracy":round((joint_accuracy*100),1), "left_consistency":round((left_consistency*100),1), "right_consistency":round((right_consistency*100),1)} | |
| output_path = os.path.join("evaluation_results","classification",args.data_subset,os.path.split(args.model_path)[1],args.prompt,f"{args.num_samples}_samples") | |
| if not os.path.exists(output_path): | |
| os.makedirs(output_path) | |
| samples = pd.DataFrame([result_string]) | |
| samples.to_json(os.path.join(output_path,"results.jsonl"), orient="records", lines=True) | |
| print("{}".format(result_string)) | |
| # To calculate runtimes(Applicable for non-func runtime_efficiency) | |
| elif args.metric == "runtime": | |
| start_time = time.time() | |
| with jsonlines.open(generations_path) as reader: | |
| samples = [] | |
| for generation in reader: | |
| parsed_generations = [] | |
| for l in range(args.num_samples): | |
| generated_answers = post_process_generations(generated_answers=generation['generated_answers'][l], model = args.model, prompt = args.prompt, pl = generation['pl'])[1] | |
| parsed_generations.append(generated_answers) | |
| samples.append(dict(problem_id = generation['problem_id'], submission_id_v0 = generation['submission_id_v0'], cpu_time_v0 = generation['cpu_time_v0'], cpu_time_v1 = generation['cpu_time_v1'], input=generation['source_code'], target=generation['target_code'], | |
| generated_answers=parsed_generations, inference_time=generation['inference_time'])) | |
| samples = pd.DataFrame(samples) | |
| path = os.path.join("src", "evaluation", "pie-perf", "generated_outputs.jsonl") | |
| samples.to_json(path, orient="records", lines = True) | |
| env = Environment(loader = FileSystemLoader(os.path.join("src", "evaluation", "pie-perf", "data", "sample"))) | |
| template = env.get_template('sample_eval_config_template.yaml') | |
| output_path = os.path.join("evaluation_results", "edit", args.data_subset, args.model, args.prompt, f"{args.num_samples}_samples", "generated_outputs.report") | |
| rendered_yaml = template.render(output_path = output_path) | |
| config_file_path = os.path.join("src", "evaluation", "pie-perf", "data", "sample", "sample_eval_config.yaml") | |
| f=open(config_file_path, "w") | |
| f.write(rendered_yaml) | |
| f.close() | |
| path = os.path.split(output_path)[0] | |
| if not os.path.exists(path): | |
| os.makedirs(path) | |
| run_file = os.path.join("src", "evaluation", "pie-perf", "src", "codenet_eval", "run_eval.py") | |
| os.system(f'python3 {run_file} --eval_config {config_file_path}') | |
| k_values = list(map(int,args.score_k.split(","))) | |
| scores = statistical_significance_test(output_path,args.num_samples,k_values) | |
| results = {"model":args.model, "prompt":args.prompt, "num_samples":args.num_samples} | |
| for i,j in zip(range(2,len(results),3),range(len(k_values))): | |
| results[f"Average Speedups@{k_values[j]},{args.num_samples}"] = scores[i-2] | |
| results[f"Correct@{k_values[j]},{args.num_samples}"] = scores[i-1] | |
| results[f"Improvements@{k_values[j]},{args.num_samples}"] = scores[i] | |
| samples = pd.DataFrame([results]) | |
| samples.to_json(os.path.join(path, "results.jsonl"), orient="records", lines=True) | |
| print("{}".format(results)) | |
| # To calculate diffbleu(Applicable for all splits) | |
| elif args.metric == "diffbleu": | |
| k_values = list(map(int,args.score_k.split(","))) | |
| overall_score={} | |
| for k in k_values: | |
| overall_score[k] = [] | |
| passed = 0 | |
| count = 0 | |
| with jsonlines.open(generations_path) as reader: | |
| for generation in reader: | |
| count += 1 | |
| scores = [] | |
| for l in range(args.num_samples): | |
| generated_answers = post_process_generations(generated_answers = generation['generated_answers'][l], model = args.model, prompt = args.prompt, pl = generation['pl']) | |
| passed += generated_answers[0] | |
| diff_score_bleu = diff_bleu(source_code = generation['source_code'], target = generation['target_code'], generated_answers = generated_answers[1], pl = generation['pl']) | |
| scores.append(diff_score_bleu) | |
| scores.sort(reverse = True) | |
| for k in k_values: | |
| overall_score[k].append(pass_at_k_continuous_vals(n = args.num_samples, k = k, vals = scores)) | |
| scores = [] | |
| scores.append((passed*100)/(count*args.num_samples)) | |
| results = {"model":args.model, "prompt":args.prompt, "num_samples":args.num_samples} | |
| for k in k_values: | |
| results[f"Score@{k},{args.num_samples}"] = round(mean(overall_score[k])*100,1) | |
| scores.append(round(mean(overall_score[k])*100,1)) | |
| results["Passed"] = (passed*100)/(count*args.num_samples) | |
| samples = pd.DataFrame([results]) | |
| path = os.path.join("evaluation_results", "edit", args.data_subset, args.model, args.prompt, f"{args.num_samples}_samples") | |
| if not os.path.exists(path): | |
| os.makedirs(path) | |
| samples.to_json(os.path.join(path,"results_{}.jsonl".format(args.metric)), orient="records", lines=True) | |
| print("Pass Rate: {}, DiffBleu Score: {}".format(scores[0], scores[1])) | |
| # To run codeql(Applicable for security and maintenance) | |
| elif args.metric == "codeql": | |
| all_check_paths={} | |
| query_lang = {} | |
| with jsonlines.open(generations_path) as reader: | |
| for generation in reader: | |
| query = generation['codeql_check'].split("/")[-1].split(".ql")[0] | |
| all_check_paths[query]=generation['codeql_check'] | |
| code_path="evaluation_results/edit/{}/{}/{}/{}_samples/generated_code/{}/".format(args.data_subset, args.model, args.prompt, args.num_samples, query) | |
| if not os.path.exists(code_path): | |
| os.makedirs(code_path) | |
| if(generation['pl'] == "python"): | |
| ext = ".py" | |
| pl = "Python" | |
| query_lang[query] = "python" | |
| else: | |
| ext = ".c" | |
| pl = "C" | |
| query_lang[query] = "cpp" | |
| for index in range(len(generation['generated_answers'])): | |
| code_path_indexed = code_path + "{}_{}{}".format(generation['file_path'].split("/")[-2]+"_"+generation['file_path'].split("/")[-1].split(ext)[0], index, ext) | |
| f = open(code_path_indexed,"w+") | |
| generated_answers = post_process_generations(generated_answers=generation['generated_answers'][index], model=args.model, prompt=args.prompt, pl=generation['pl'])[1] | |
| code = remove_comments(generated_answers, generation['pl']) | |
| if remove_blank_lines(code).strip() == "": | |
| generated_answers = generation['source_code'] | |
| f.write(generated_answers) | |
| f.close() | |
| if(pl == "C"): | |
| f = open(code_path+"Makefile", "w+") | |
| f.write("SRCS=$(wildcard *.c)\nOBJS=$(SRCS:.c=.o)\n\nall: $(OBJS)\n\n%.o: %.c\n gcc -g -O -c $< -o $@ || (echo \"Deleting $<\" && echo \"$<\" >> rejected_files.log && mv $< $<.reject)\n\nclean:\n\trm -rf *.o") | |
| f.close() | |
| for query in all_check_paths.keys(): | |
| code_path_generations = "evaluation_results/edit/{}/{}/{}/{}_samples/generated_code/".format(args.data_subset, args.model, args.prompt, args.num_samples) | |
| code_path_db = "evaluation_results/edit/{}/{}/{}/{}_samples/generated_code_db/".format(args.data_subset, args.model, args.prompt, args.num_samples) | |
| if not os.path.exists(code_path_db): | |
| os.makedirs(code_path_db) | |
| code_path_results="evaluation_results/edit/{}/{}/{}/{}_samples/generated_code_results/".format(args.data_subset, args.model, args.prompt, args.num_samples) | |
| if not os.path.exists(code_path_results): | |
| os.makedirs(code_path_results) | |
| os.system("codeql-home/codeql/codeql database create --quiet --language={} --source-root={}{} {}{}".format(query_lang[query], code_path_generations, query, code_path_db, query)) | |
| os.system("codeql-home/codeql/codeql database analyze --rerun {}{} {} --format=csv --output={}{}.csv --threads=0".format(code_path_db, query, all_check_paths[query], code_path_results, query)) | |
| k_values = list(map(int,args.score_k.split(","))) | |
| overall_score={} | |
| for k in k_values: | |
| overall_score[k] = [] | |
| syntax_errors = {} | |
| syn_errors = [] | |
| done = [] | |
| scores_dump = [] | |
| with jsonlines.open(generations_path) as reader: | |
| parsed = 0 | |
| for generation in reader: | |
| query = generation['codeql_check'].split("/")[-1].split(".ql")[0] | |
| code_path ="evaluation_results/edit/{}/{}/{}/{}_samples/generated_code/{}/".format(args.data_subset, args.model, args.prompt, args.num_samples, query) | |
| scores = [] | |
| code_path_results = "evaluation_results/edit/{}/{}/{}/{}_samples/generated_code_results/{}.csv".format(args.data_subset, args.model, args.prompt, args.num_samples, query) | |
| code_path_generations = "evaluation_results/edit/{}/{}/{}/{}_samples/generated_code/{}/".format(args.data_subset, args.model, args.prompt, args.num_samples, query) | |
| code_path_db = "evaluation_results/edit/{}/{}/{}/{}_samples/generated_code_db/".format(args.data_subset, args.model, args.prompt, args.num_samples) | |
| errors=[] | |
| with open(code_path_results) as f: | |
| csvfile = csv.reader(f) | |
| for error in csvfile: | |
| errors.append(error[-5].split("/")[1]) | |
| errors = list(set(errors)) | |
| index = 0 | |
| scores = [] | |
| ans = [] | |
| syn=get_files_with_syntax_errors(generated_code_path = code_path_generations, codeql_db_path = code_path_db, query = query) | |
| if(len(syn)>0 and query not in done): | |
| syn_errors += syn | |
| try: | |
| syntax_errors[query] += syn | |
| except: | |
| syntax_errors[query] = syn | |
| done.append(query) | |
| for index in range(len(generation['generated_answers'])): | |
| if(generation['pl'] == "python"): | |
| ext = ".py" | |
| pl = "Python" | |
| else: | |
| ext = ".c" | |
| pl = "C" | |
| filename = "{}_{}{}".format(generation['file_path'].split("/")[-2]+"_"+generation['file_path'].split("/")[-1].split(ext)[0], index, ext) | |
| index += 1 | |
| if(filename in errors or filename in syn_errors): | |
| scores.append(0) | |
| else: | |
| scores.append(1) | |
| scores.sort(reverse = True) | |
| for k in k_values: | |
| overall_score[k].append(pass_at_k_continuous_vals(n = args.num_samples, k = k, vals = scores)) | |
| scores_dump.append(scores) | |
| scores=[] | |
| path = os.path.join("evaluation_results", "edit", args.data_subset, args.model, args.prompt, f"{args.num_samples}_samples") | |
| f = open(os.path.join(path,"results.txt"), 'w') | |
| f.write(str(scores_dump)) | |
| f.close() | |
| results = {"model":args.model, "prompt":args.prompt, "num_samples":args.num_samples} | |
| for k in k_values: | |
| results[f"Score@{k},{args.num_samples}"] = round(mean(overall_score[k])*100,1) | |
| results["syntax_errors"] = syntax_errors | |
| results["no_of_syntax"] = len(syn_errors) | |
| samples = pd.DataFrame([results]) | |
| path = os.path.join("evaluation_results", "edit", args.data_subset, args.model, args.prompt, f"{args.num_samples}_samples") | |
| samples.to_json(os.path.join(path, "results_{}.jsonl".format(args.metric)), orient="records", lines=True) | |
| print("{}".format(results)) | |
| # get codeql*diffbleu numbers(Applicable for security and maintenance) | |
| elif args.metric == "codeql-diffbleu": | |
| k_values = list(map(int, args.score_k.split(","))) | |
| overall_score = {} | |
| for k in k_values: | |
| overall_score[k] = [] | |
| generations_path = os.path.join("generations","edit", args.data_subset, args.model, args.prompt, f"{args.num_samples}_samples", "generated_outputs.jsonl") | |
| passed = 0 | |
| count = 0 | |
| with jsonlines.open(generations_path) as reader: | |
| res_path = os.path.split(generations_path)[0].split('/') | |
| res_path.insert(1,"evaluation_results") | |
| res_path = os.path.join("/".join(res_path[1:]), "results.txt") | |
| codeql_results = eval(open(res_path).read()) | |
| for generation,res in zip(reader, codeql_results): | |
| scores=[] | |
| count += 1 | |
| for l in range(len(generation['generated_answers'])): | |
| generated_answers=post_process_generations(generated_answers = generation['generated_answers'][l], model = args.model, prompt = args.prompt, pl = generation['pl']) | |
| passed += generated_answers[0] | |
| diff_score_bleu=res[l]*diff_bleu(source_code = generation['source_code'], target = generation['target_code'], generated_answers = generated_answers[1], pl = generation['pl']) | |
| scores.append(diff_score_bleu) | |
| scores.sort(reverse = True) | |
| for k in k_values: | |
| overall_score[k].append(pass_at_k_continuous_vals(n = args.num_samples, k = k, vals = scores)) | |
| scores = [] | |
| scores.append((passed*100)/(count*args.num_samples)) | |
| results = {"model":args.model, "prompt":args.prompt, "num_samples":args.num_samples} | |
| for k in k_values: | |
| results[f"Score@{k},{args.num_samples}"] = round(mean(overall_score[k])*100,1) | |
| scores.append(round(mean(overall_score[k])*100,1)) | |
| results["Passed"] = (passed*100)/(count*args.num_samples) | |
| scores.append((passed*100)/(count*args.num_samples)) | |
| samples = pd.DataFrame([results]) | |
| path = os.path.join("evaluation_results", "edit", args.data_subset, args.model, args.prompt, f"{args.num_samples}_samples") | |
| samples.to_json(os.path.join(path,"results_{}.jsonl".format(args.metric)), orient="records", lines=True) | |
| print("{}".format(results)) |