Spaces:
Sleeping
Sleeping
| import pandas as pd | |
| import numpy as np | |
| import re | |
| from prompt import algebric_prompt, python_prompt | |
| from utils import generate_response, run_code | |
| def generate_algebric_template(question): | |
| var_names = [chr(i) for i in range(ord('A'), ord('Z') + 1)] | |
| pattern = re.compile(r"[-+]?\d*\.\d+|\d+") | |
| var_map = {} | |
| matches = re.findall(pattern, question) | |
| for i, num in enumerate(matches): | |
| var_name = var_names[i] | |
| question = question.replace(num, var_name) | |
| var_map[var_name] = float(num) | |
| return question, var_map | |
| def generate_algebric_expression(question, param): | |
| question = question.strip() | |
| query = algebric_prompt.format(question=question).strip() + "\n" | |
| response = generate_response(query, param) | |
| expression = response.split(f"#Ques: {question}")[-1].strip() | |
| return expression.split("Answer = ")[-1] | |
| def generate_python_code(question, equation, param): | |
| query = python_prompt.format(question=question.strip(), expression=equation.strip()).strip() + "\n" | |
| response = generate_response(query, param) | |
| function_code = response.split("# Function for above expression is:")[-1].strip() | |
| return function_code | |
| def run(question, random_candidates, hps): | |
| question, var_map = generate_algebric_template(question) | |
| # generating the random candidates for arguments | |
| random_mapping = pd.DataFrame(columns=list(var_map.keys())) | |
| for _ in range(random_candidates): | |
| random_mapping.loc[len(random_mapping)] = np.random.randint(1, 100, (len(random_mapping.columns),)) | |
| candidates = [] | |
| acc = [] | |
| # accumulating results | |
| N = len(hps) | |
| for i in range(N): | |
| expression = generate_algebric_expression(question, hps[i]) | |
| code = generate_python_code(question, expression, hps[i]) | |
| candidates.append((expression, code)) | |
| current_acc = 0 | |
| try: | |
| for idx in range(5): | |
| arguments = random_mapping.iloc[idx].to_list() | |
| # running expression | |
| exp = expression | |
| temp_code = code | |
| for k, v in zip(list(var_map.keys()), arguments): | |
| exp = exp.replace(k, str(v)) | |
| exp = "print(" + exp + ")" | |
| if "input(" in exp or "input(" in temp_code: | |
| acc.append(0) | |
| continue | |
| exp_ans = run_code(exp) | |
| # running code | |
| parameters = temp_code.split("\n")[0].split("def solution")[-1][1:-2].split(",") | |
| if '' in parameters: | |
| parameters.remove('') | |
| arguments = [(param.strip(), int(random_mapping.iloc[idx][param.strip()])) for param in parameters] | |
| arg_string = "" | |
| for param, val in arguments: | |
| arg_string += f"{param}={val}," | |
| func_call = f"\nprint(solution({arg_string[:-1]}))" | |
| temp_code += func_call | |
| code_ans = run_code(temp_code) | |
| current_acc += int(exp_ans == code_ans) | |
| # reverting the changes | |
| exp = expression | |
| temp_code = code | |
| except Exception as ex: | |
| pass | |
| acc.append(current_acc) | |
| candidate_index = np.argmax(acc) | |
| top_candidate = candidates[candidate_index] | |
| return top_candidate, var_map | |
| def solve_mp(question): | |
| hps = [0.9, 0.95] | |
| (expression, code), var_map = run(question, 5, hps) | |
| exp_op = None | |
| code_op = None | |
| try: | |
| # expression output | |
| for k, v in var_map.items(): | |
| expression = expression.replace(k, str(v)) | |
| expression = "print(" + expression + ")" | |
| print(expression) | |
| if "input(" in expression: | |
| raise Exception | |
| exp_op = run_code(expression) | |
| except: | |
| print("expression cannot be executed", expression) | |
| try: | |
| # code output | |
| parameters = code.split("\n")[0].split("def solution")[-1][1:-2].split(",") | |
| if '' in parameters: | |
| parameters.remove('') | |
| arguments = [(param.strip(), int(var_map[param.strip()])) for param in parameters] | |
| arg_string = "" | |
| for param, val in arguments: | |
| arg_string += f"{param}={val}," | |
| func_call = f"\nprint(solution({arg_string[:-1]}))" | |
| code += func_call | |
| if "input(" in code: | |
| print("code cannot be executed") | |
| raise Exception | |
| code_op = run_code(code) | |
| except: | |
| return None, None, code, expression | |
| return exp_op, code_op, code, expression | |