From a96e7f321aa401ed2ca5154d2d1bcef922a9eb11 Mon Sep 17 00:00:00 2001 From: Silviu Marian Udrescu Date: Sat, 20 Jun 2020 19:30:25 -0400 Subject: [PATCH] Add files via upload --- Code/RPN_to_pytorch.py | 9 +-- Code/S_add_bf_on_numbers_on_pareto.py | 5 +- Code/S_add_snap_expr_on_pareto.py | 95 +++++++++++------------ Code/S_add_snap_expr_on_pareto_polyfit.py | 86 ++++++++++---------- Code/S_add_sym_on_pareto.py | 3 - Code/S_combine_pareto.py | 6 +- Code/S_final_gd.py | 9 +-- Code/S_run_aifeynman.py | 19 +++-- Code/S_run_bf_polyfit.py | 14 ++-- Code/S_snap.py | 6 +- 10 files changed, 119 insertions(+), 133 deletions(-) diff --git a/Code/RPN_to_pytorch.py b/Code/RPN_to_pytorch.py index fb3b971..e37e151 100644 --- a/Code/RPN_to_pytorch.py +++ b/Code/RPN_to_pytorch.py @@ -22,8 +22,7 @@ from S_get_number_DL_snapped import get_number_DL_snapped from S_get_symbolic_expr_error import get_symbolic_expr_error # parameters: path to data, RPN expression (obtained from bf) -def RPN_to_pytorch(pathdir,filename, math_expr, lr = 1e-2, N_epochs = 500): - data_file = pathdir + filename +def RPN_to_pytorch(data, math_expr, lr = 1e-2, N_epochs = 500): param_dict = {} unsnapped_param_dict = {'p':1} @@ -59,10 +58,6 @@ def RPN_to_pytorch(pathdir,filename, math_expr, lr = 1e-2, N_epochs = 500): new_key = "{}{}{}{}{}".format(key, underscore, midfix, i, suffix) return new_key - # Load the actual data - - data = np.loadtxt(data_file) - # Turn BF expression to pytorch expression eq = parse_expr(math_expr) eq = unsnap_recur(eq,param_dict,unsnapped_param_dict) @@ -135,7 +130,7 @@ def RPN_to_pytorch(pathdir,filename, math_expr, lr = 1e-2, N_epochs = 500): if n_operations!=0 or n_variables!=0: complexity = complexity + (n_variables+n_operations)*np.log2((n_variables+n_operations)) - error = get_symbolic_expr_error(pathdir,filename,str(eq)) + error = get_symbolic_expr_error(data,str(eq)) return error, complexity, eq diff --git a/Code/S_add_bf_on_numbers_on_pareto.py b/Code/S_add_bf_on_numbers_on_pareto.py index 1ecae27..c4f9e3f 100644 --- a/Code/S_add_bf_on_numbers_on_pareto.py +++ b/Code/S_add_bf_on_numbers_on_pareto.py @@ -29,7 +29,8 @@ from RPN_to_eq import RPN_to_eq from S_get_number_DL_snapped import get_number_DL_snapped # parameters: path to data, math (not RPN) expression -def add_bf_on_numbers_on_pareto(pathdir, filename, PA, math_expr): +def add_bf_on_numbers_on_pareto(pathdir, filename, PA, math_expr): + input_data = np.loadtxt(pathdir+filename) def unsnap_recur(expr, param_dict, unsnapped_param_dict): """Recursively transform each numerical value into a learnable parameter.""" import sympy @@ -100,7 +101,7 @@ def add_bf_on_numbers_on_pareto(pathdir, filename, PA, math_expr): for i in range(len(bf_on_numbers_expr)): try: # Calculate the error of the new, snapped expression - snapped_error = get_symbolic_expr_error(pathdir,filename,str(bf_on_numbers_expr[i])) + snapped_error = get_symbolic_expr_error(input_data,str(bf_on_numbers_expr[i])) # Calculate the complexity of the new, snapped expression expr = simplify(powsimp(bf_on_numbers_expr[i])) is_atomic_number = lambda expr: expr.is_Atom and expr.is_number diff --git a/Code/S_add_snap_expr_on_pareto.py b/Code/S_add_snap_expr_on_pareto.py index f7dd3d4..9e65ca1 100644 --- a/Code/S_add_snap_expr_on_pareto.py +++ b/Code/S_add_snap_expr_on_pareto.py @@ -33,6 +33,7 @@ def intify(expr): # parameters: path to data, math (not RPN) expression def add_snap_expr_on_pareto(pathdir, filename, math_expr, PA, DR_file=""): + input_data = np.loadtxt(pathdir+filename) def unsnap_recur(expr, param_dict, unsnapped_param_dict): """Recursively transform each numerical value into a learnable parameter.""" import sympy @@ -68,29 +69,6 @@ def add_snap_expr_on_pareto(pathdir, filename, math_expr, PA, DR_file=""): eq = parse_expr(str(math_expr)) expr = eq - # Get the numbers appearing in the expression - is_atomic_number = lambda expr: expr.is_Atom and expr.is_number - eq_numbers = [subexpression for subexpression in preorder_traversal(expr) if is_atomic_number(subexpression)] - - # Do integer snap one parameter at a time - integer_snapped_expr = [] - for w in range(len(eq_numbers)): - try: - param_dict = {} - unsnapped_param_dict = {'p':1} - eq = unsnap_recur(expr,param_dict,unsnapped_param_dict) - new_numbers = integerSnap(eq_numbers,w+1) - for kk in range(len(new_numbers)): - eq_numbers[new_numbers[kk][0]] = new_numbers[kk][1] - jj = 0 - for parm in unsnapped_param_dict: - if parm!="p": - eq = eq.subs(parm, eq_numbers[jj]) - jj = jj + 1 - integer_snapped_expr = integer_snapped_expr + [eq] - except: - continue - # # Get the numbers appearing in the expression # is_atomic_number = lambda expr: expr.is_Atom and expr.is_number # eq_numbers = [subexpression for subexpression in preorder_traversal(expr) if is_atomic_number(subexpression)] @@ -114,31 +92,52 @@ def add_snap_expr_on_pareto(pathdir, filename, math_expr, PA, DR_file=""): # except: # continue - # Get the numbers appearing in the expression - is_atomic_number = lambda expr: expr.is_Atom and expr.is_number + + is_atomic_number = lambda expr:expr.is_Atom and expr.is_number eq_numbers = [subexpression for subexpression in preorder_traversal(expr) if is_atomic_number(subexpression)] - # Do rational snap one parameter at a time - rational_snapped_expr = [] + # Do integer snap one parameter at a time + integer_snapped_expr = [] for w in range(len(eq_numbers)): try: - eq_numbers_snap = copy.deepcopy(eq_numbers) param_dict = {} unsnapped_param_dict = {'p':1} eq = unsnap_recur(expr,param_dict,unsnapped_param_dict) + del unsnapped_param_dict["p"] + temp_unsnapped_param_dict = copy.deepcopy(unsnapped_param_dict) + new_numbers = integerSnap(eq_numbers,w+1) + new_numbers = {"p"+str(k): v for k, v in new_numbers.items()} + temp_unsnapped_param_dict.update(new_numbers) + #for kk in range(len(new_numbers)): + # eq_numbers[new_numbers[kk][0]] = new_numbers[kk][1] + new_eq = re.sub(r"(p\d*)",r"{\1}",str(eq)) + new_eq = new_eq.format_map(temp_unsnapped_param_dict) + integer_snapped_expr = integer_snapped_expr + [parse_expr(new_eq)] + except: + continue + + + + is_atomic_number = lambda expr: expr.is_Atom and expr.is_number + eq_numbers = [subexpression for subexpression in preorder_traversal(expr) if is_atomic_number(subexpression)] + + # Do rational snap one parameter at a time + rational_snapped_expr = [] + for w in range(len(eq_numbers)): + try: + param_dict = {} + unsnapped_param_dict = {'p':1} + eq = unsnap_recur(expr,param_dict,unsnapped_param_dict) + del unsnapped_param_dict["p"] + temp_unsnapped_param_dict = copy.deepcopy(unsnapped_param_dict) new_numbers = rationalSnap(eq_numbers,w+1) - for kk in range(len(new_numbers)): - eq_numbers_snap[new_numbers[kk][0]] = new_numbers[kk][1][1:3] - jj = 0 - for parm in unsnapped_param_dict: - if parm!="p": - - try: - eq = eq.subs(parm, Rational(eq_numbers_snap[jj][0],eq_numbers_snap[jj][1])) - except: - eq = eq.subs(parm, eq_numbers_snap[jj]) - jj = jj + 1 - rational_snapped_expr = rational_snapped_expr + [eq] + new_numbers = {"p"+str(k): v for k, v in new_numbers.items()} + temp_unsnapped_param_dict.update(new_numbers) + #for kk in range(len(new_numbers)): + # eq_numbers_snap[new_numbers[kk][0]] = new_numbers[kk][1][1:3] + new_eq = re.sub(r"(p\d*)",r"{\1}",str(eq)) + new_eq = new_eq.format_map(temp_unsnapped_param_dict) + rational_snapped_expr = rational_snapped_expr + [parse_expr(new_eq)] except: continue @@ -148,13 +147,13 @@ def add_snap_expr_on_pareto(pathdir, filename, math_expr, PA, DR_file=""): for i in range(len(snapped_expr)): try: # Calculate the error of the new, snapped expression - snapped_error = get_symbolic_expr_error(pathdir,filename,str(snapped_expr[i])) + snapped_error = get_symbolic_expr_error(input_data,str(snapped_expr[i])) # Calculate the complexity of the new, snapped expression - expr = simplify(powsimp(snapped_expr[i])) + #expr = simplify(powsimp(snapped_expr[i])) + expr = snapped_expr[i] for s in (expr.free_symbols): s = symbols(str(s), real = True) - expr = simplify(parse_expr(str(snapped_expr[i]),locals())) - #print("expr 0", expr) + expr = parse_expr(str(snapped_expr[i]),locals()) expr = intify(expr) is_atomic_number = lambda expr: expr.is_Atom and expr.is_number numbers_expr = [subexpression for subexpression in preorder_traversal(expr) if is_atomic_number(subexpression)] @@ -169,7 +168,7 @@ def add_snap_expr_on_pareto(pathdir, filename, math_expr, PA, DR_file=""): if n_operations!=0 or n_variables!=0: snapped_complexity = snapped_complexity + (n_variables+n_operations)*np.log2((n_variables+n_operations)) - # If a bf file is provided, replace the variables with the actual ones before calculating the complexity + # If a da file is provided, replace the variables with the actual ones before calculating the complexity else: dr_data = np.loadtxt(DR_file,dtype="str",delimiter=",") @@ -182,10 +181,8 @@ def add_snap_expr_on_pareto(pathdir, filename, math_expr, PA, DR_file=""): expr = parse_expr(expr) for s in (expr.free_symbols): s = symbols(str(s), real = True) - expr = simplify(parse_expr(str(expr),locals())) - #print("expr 1", expr) - #expr = intify(expr) - #print("expr 2", expr) + #expr = simplify(parse_expr(str(expr),locals())) + expr = parse_expr(str(expr),locals()) snapped_complexity = 0 for j in numbers_expr: snapped_complexity = snapped_complexity + get_number_DL_snapped(float(j)) diff --git a/Code/S_add_snap_expr_on_pareto_polyfit.py b/Code/S_add_snap_expr_on_pareto_polyfit.py index 45ddbac..f08ee48 100644 --- a/Code/S_add_snap_expr_on_pareto_polyfit.py +++ b/Code/S_add_snap_expr_on_pareto_polyfit.py @@ -23,6 +23,8 @@ from sympy import preorder_traversal, count_ops from sympy.abc import x,y from sympy.parsing.sympy_parser import parse_expr from sympy import Symbol, lambdify, N, simplify, powsimp, Rational, symbols, S, Float +import time +import re from S_get_number_DL_snapped import get_number_DL_snapped @@ -33,6 +35,7 @@ def intify(expr): # parameters: path to data, math (not RPN) expression def add_snap_expr_on_pareto_polyfit(pathdir, filename, math_expr, PA): + input_data = np.loadtxt(pathdir+filename) def unsnap_recur(expr, param_dict, unsnapped_param_dict): """Recursively transform each numerical value into a learnable parameter.""" import sympy @@ -95,85 +98,80 @@ def add_snap_expr_on_pareto_polyfit(pathdir, filename, math_expr, PA): is_atomic_number = lambda expr:expr.is_Atom and expr.is_number eq_numbers = [subexpression for subexpression in preorder_traversal(expr) if is_atomic_number(subexpression)] - # Do integer snap one parameter at a time + # Do integer snap one parameter at a time integer_snapped_expr = [] for w in range(len(eq_numbers)): try: param_dict = {} unsnapped_param_dict = {'p':1} eq = unsnap_recur(expr,param_dict,unsnapped_param_dict) + del unsnapped_param_dict["p"] + temp_unsnapped_param_dict = copy.deepcopy(unsnapped_param_dict) new_numbers = integerSnap(eq_numbers,w+1) - for kk in range(len(new_numbers)): - eq_numbers[new_numbers[kk][0]] = new_numbers[kk][1] - jj = 0 - for parm in unsnapped_param_dict: - if parm!="p": - eq = eq.subs(parm, eq_numbers[jj]) - jj = jj + 1 - integer_snapped_expr = integer_snapped_expr + [eq] + new_numbers = {"p"+str(k): v for k, v in new_numbers.items()} + temp_unsnapped_param_dict.update(new_numbers) + #for kk in range(len(new_numbers)): + # eq_numbers[new_numbers[kk][0]] = new_numbers[kk][1] + new_eq = re.sub(r"(p\d*)",r"{\1}",str(eq)) + new_eq = new_eq.format_map(temp_unsnapped_param_dict) + integer_snapped_expr = integer_snapped_expr + [parse_expr(new_eq)] except: continue # Get the numbers appearing in the expression -# is_atomic_number = lambda expr: expr.is_Atom and expr.is_number -# eq_numbers = [subexpression for subexpression in preorder_traversal(expr) if is_atomic_number(subexpression)] + is_atomic_number = lambda expr: expr.is_Atom and expr.is_number + eq_numbers = [subexpression for subexpression in preorder_traversal(expr) if is_atomic_number(subexpression)] -# # Do rational snap one parameter at a time -# rational_snapped_expr = [] -# for w in range(len(eq_numbers)): -# try: -# eq_numbers_snap = copy.deepcopy(eq_numbers) -# param_dict = {} -# unsnapped_param_dict = {'p':1} -# eq = unsnap_recur(expr,param_dict,unsnapped_param_dict) -# new_numbers = rationalSnap(eq_numbers,w+1) -# for kk in range(len(new_numbers)): -# eq_numbers_snap[new_numbers[kk][0]] = new_numbers[kk][1][1:3] -# jj = 0 -# for parm in unsnapped_param_dict: -# if parm!="p": -# -# try: -# eq = eq.subs(parm, Rational(eq_numbers_snap[jj][0],eq_numbers_snap[jj][1])) -# except: -# eq = eq.subs(parm, eq_numbers_snap[jj]) -# jj = jj + 1 -# rational_snapped_expr = rational_snapped_expr + [eq] -# except: -# continue + # Do rational snap one parameter at a time + rational_snapped_expr = [] + for w in range(len(eq_numbers)): + try: + param_dict = {} + unsnapped_param_dict = {'p':1} + eq = unsnap_recur(expr,param_dict,unsnapped_param_dict) + del unsnapped_param_dict["p"] + temp_unsnapped_param_dict = copy.deepcopy(unsnapped_param_dict) + new_numbers = rationalSnap(eq_numbers,w+1) + new_numbers = {"p"+str(k): v for k, v in new_numbers.items()} + temp_unsnapped_param_dict.update(new_numbers) + #for kk in range(len(new_numbers)): + # eq_numbers_snap[new_numbers[kk][0]] = new_numbers[kk][1][1:3] + new_eq = re.sub(r"(p\d*)",r"{\1}",str(eq)) + new_eq = new_eq.format_map(temp_unsnapped_param_dict) + rational_snapped_expr = rational_snapped_expr + [parse_expr(new_eq)] + except: + continue -# snapped_expr = np.append(integer_snapped_expr,zero_snapped_expr) + snapped_expr = np.append(integer_snapped_expr,rational_snapped_expr) # snapped_expr = np.append(snapped_expr,rational_snapped_expr) - for i in range(len(integer_snapped_expr)): + integer_snapped_expr = snapped_expr + + for i in range(len(snapped_expr)): try: - # Calculate the error of the new, snapped expression - snapped_error = get_symbolic_expr_error(pathdir,filename,str(integer_snapped_expr[i])) + snapped_error = get_symbolic_expr_error(input_data,str(snapped_expr[i])) # Calculate the complexity of the new, snapped expression - expr = simplify(powsimp(integer_snapped_expr[i])) + expr = snapped_expr[i] for s in (expr.free_symbols): s = symbols(str(s), real = True) - expr = simplify(parse_expr(str(integer_snapped_expr[i]),locals())) + expr = parse_expr(str(snapped_expr[i]),locals()) expr = intify(expr) - is_atomic_number = lambda expr: expr.is_Atom and expr.is_number numbers_expr = [subexpression for subexpression in preorder_traversal(expr) if is_atomic_number(subexpression)] - snapped_complexity = 0 for j in numbers_expr: snapped_complexity = snapped_complexity + get_number_DL_snapped(float(j)) - # Add the complexity due to symbols n_variables = len(expr.free_symbols) n_operations = len(count_ops(expr,visual=True).free_symbols) if n_operations!=0 or n_variables!=0: snapped_complexity = snapped_complexity + (n_variables+n_operations)*np.log2((n_variables+n_operations)) - PA.add(Point(x=snapped_complexity, y=snapped_error, data=str(expr))) except: continue + return(PA) diff --git a/Code/S_add_sym_on_pareto.py b/Code/S_add_sym_on_pareto.py index bcd7dc4..75bb613 100644 --- a/Code/S_add_sym_on_pareto.py +++ b/Code/S_add_sym_on_pareto.py @@ -1,9 +1,6 @@ # Combines 2 pareto fromtier obtained from the separability test into a new one. from get_pareto import Point, ParetoSet -from RPN_to_pytorch import RPN_to_pytorch -from RPN_to_eq import RPN_to_eq -from S_get_symbolic_expr_error import get_symbolic_expr_error from sympy.parsing.sympy_parser import parse_expr import numpy as np import matplotlib.pyplot as plt diff --git a/Code/S_combine_pareto.py b/Code/S_combine_pareto.py index 93c0627..2412ea7 100644 --- a/Code/S_combine_pareto.py +++ b/Code/S_combine_pareto.py @@ -1,8 +1,6 @@ # Combines 2 pareto fromtier obtained from the separability test into a new one. from get_pareto import Point, ParetoSet -from RPN_to_pytorch import RPN_to_pytorch -from RPN_to_eq import RPN_to_eq from S_get_symbolic_expr_error import get_symbolic_expr_error from sympy.parsing.sympy_parser import parse_expr import numpy as np @@ -12,7 +10,7 @@ from os import path from sympy import Symbol, lambdify, N from get_pareto import Point, ParetoSet -def combine_pareto(pathdir,filename,PA1,PA2,idx_list_1,idx_list_2,PA,sep_type = "+"): +def combine_pareto(input_data,PA1,PA2,idx_list_1,idx_list_2,PA,sep_type = "+"): possible_vars = ["x%s" %i for i in np.arange(0,30,1)] PA1 = np.array(PA1.get_pareto_points()).astype('str') PA2 = np.array(PA2.get_pareto_points()).astype('str') @@ -28,7 +26,7 @@ def combine_pareto(pathdir,filename,PA1,PA2,idx_list_1,idx_list_2,PA,sep_type = for k in range(len(idx_list_2)-1,-1,-1): exp2 = exp2.replace(possible_vars[k],possible_vars[idx_list_2[k]]) new_eq = "(" + exp1 + ")" + sep_type + "(" + exp2 + ")" - PA.add(Point(x=complexity,y=get_symbolic_expr_error(pathdir,filename,new_eq),data=new_eq)) + PA.add(Point(x=complexity,y=get_symbolic_expr_error(input_data,new_eq),data=new_eq)) except: continue return PA diff --git a/Code/S_final_gd.py b/Code/S_final_gd.py index d73def2..b4c95a4 100644 --- a/Code/S_final_gd.py +++ b/Code/S_final_gd.py @@ -22,8 +22,7 @@ from S_get_number_DL_snapped import get_number_DL_snapped from S_get_symbolic_expr_error import get_symbolic_expr_error # parameters: path to data, RPN expression (obtained from bf) -def final_gd(pathdir,filename, math_expr, lr = 1e-2, N_epochs = 5000): - data_file = pathdir + filename +def final_gd(data, math_expr, lr = 1e-2, N_epochs = 5000): param_dict = {} unsnapped_param_dict = {'p':1} @@ -59,10 +58,6 @@ def final_gd(pathdir,filename, math_expr, lr = 1e-2, N_epochs = 5000): new_key = "{}{}{}{}{}".format(key, underscore, midfix, i, suffix) return new_key - # Load the actual data - - data = np.loadtxt(data_file) - # Turn BF expression to pytorch expression eq = parse_expr(math_expr) eq = unsnap_recur(eq,param_dict,unsnapped_param_dict) @@ -146,7 +141,7 @@ def final_gd(pathdir,filename, math_expr, lr = 1e-2, N_epochs = 5000): if n_operations!=0 or n_variables!=0: complexity = complexity + (n_variables+n_operations)*np.log2((n_variables+n_operations)) - error = get_symbolic_expr_error(pathdir,filename,str(eq)) + error = get_symbolic_expr_error(data,str(eq)) return error, complexity, eq diff --git a/Code/S_run_aifeynman.py b/Code/S_run_aifeynman.py index 0cce00b..01b715c 100644 --- a/Code/S_run_aifeynman.py +++ b/Code/S_run_aifeynman.py @@ -33,7 +33,8 @@ def run_AI_all(pathdir,filename,BF_try_time=60,BF_ops_file_type="14ops", polyfit # load the data for different checks data = np.loadtxt(pathdir+filename) - + PA = get_atan(pathdir,"results/mystery_world_atan/",filename,BF_try_time,BF_ops_file_type, PA, polyfit_deg) + ''' # Run bf and polyfit PA = run_bf_polyfit(pathdir,pathdir,filename,BF_try_time,BF_ops_file_type, PA, polyfit_deg) @@ -49,7 +50,7 @@ def run_AI_all(pathdir,filename,BF_try_time=60,BF_ops_file_type="14ops", polyfit PA = get_sqrt(pathdir,"results/mystery_world_sqrt/",filename,BF_try_time,BF_ops_file_type, PA, polyfit_deg) PA = get_squared(pathdir,"results/mystery_world_squared/",filename,BF_try_time,BF_ops_file_type, PA, polyfit_deg) PA = get_tan(pathdir,"results/mystery_world_tan/",filename,BF_try_time,BF_ops_file_type, PA, polyfit_deg) - + ''' ############################################################################################################################# # check if the NN is trained. If it is not, train it on the data. print("Checking for symmetry \n", filename) @@ -120,7 +121,8 @@ def run_AI_all(pathdir,filename,BF_try_time=60,BF_ops_file_type="14ops", polyfit PA1 = run_AI_all(new_pathdir1,new_filename1,BF_try_time,BF_ops_file_type, polyfit_deg, NN_epochs, PA1_) PA2_ = ParetoSet() PA2 = run_AI_all(new_pathdir2,new_filename2,BF_try_time,BF_ops_file_type, polyfit_deg, NN_epochs, PA2_) - PA = combine_pareto(pathdir,filename,PA1,PA2,separability_plus_result[1],separability_plus_result[2],PA,"+") + combine_pareto_data = np.loadtxt(pathdir+filename) + PA = combine_pareto(combine_pareto_data,PA1,PA2,separability_plus_result[1],separability_plus_result[2],PA,"+") return PA elif idx_min == 5: @@ -129,7 +131,8 @@ def run_AI_all(pathdir,filename,BF_try_time=60,BF_ops_file_type="14ops", polyfit PA1 = run_AI_all(new_pathdir1,new_filename1,BF_try_time,BF_ops_file_type, polyfit_deg, NN_epochs, PA1_) PA2_ = ParetoSet() PA2 = run_AI_all(new_pathdir2,new_filename2,BF_try_time,BF_ops_file_type, polyfit_deg, NN_epochs, PA2_) - PA = combine_pareto(pathdir,filename,PA1,PA2,separability_multiply_result[1],separability_multiply_result[2],PA,"*") + combine_pareto_data = np.loadtxt(pathdir+filename) + PA = combine_pareto(combine_pareto_data,PA1,PA2,separability_multiply_result[1],separability_multiply_result[2],PA,"*") return PA else: return PA @@ -181,10 +184,11 @@ def run_aifeynman(pathdir,filename,BF_try_time,BF_ops_file_type, polyfit_deg=3, PA_list = PA.get_pareto_points() np.savetxt("results/solution_first_snap_%s.txt" %filename,PA_list,fmt="%s") - # Run gradient descent on the data one more time + # Run gradient descent on the data one more time + final_gd_data = np.loadtxt(pathdir+filename) for i in range(len(PA_list)): try: - gd_update = final_gd(pathdir,filename,PA_list[i][-1]) + gd_update = final_gd(final_gd_data,PA_list[i][-1]) PA.add(Point(x=gd_update[1],y=gd_update[0],data=gd_update[2])) except: continue @@ -206,8 +210,9 @@ def run_aifeynman(pathdir,filename,BF_try_time,BF_ops_file_type, polyfit_deg=3, # Try the found expressions on the test data if DR_file=="" and test_data.size != 0: test_errors = [] + input_test_data = np.loadtxt(pathdir+filename+"_test") for i in range(len(list_dt)): - test_errors = test_errors + [get_symbolic_expr_error(pathdir,filename+"_test",str(list_dt[i][-1]))] + test_errors = test_errors + [get_symbolic_expr_error(input_test_data,str(list_dt[i][-1]))] test_errors = np.array(test_errors) # Save all the data to file save_data = np.column_stack((test_errors,log_err,log_err_all,list_dt)) diff --git a/Code/S_run_bf_polyfit.py b/Code/S_run_bf_polyfit.py index 795e653..1aec89d 100644 --- a/Code/S_run_bf_polyfit.py +++ b/Code/S_run_bf_polyfit.py @@ -6,7 +6,6 @@ from RPN_to_eq import RPN_to_eq import numpy as np import matplotlib.pyplot as plt from S_brute_force import brute_force -from S_combine_pareto import combine_pareto from S_get_number_DL_snapped import get_number_DL_snapped from sympy.parsing.sympy_parser import parse_expr from sympy import preorder_traversal, count_ops @@ -19,7 +18,7 @@ from os import path def run_bf_polyfit(pathdir,pathdir_transformed,filename,BF_try_time,BF_ops_file_type, PA, polyfit_deg=3, output_type=""): - + input_data = np.loadtxt(pathdir_transformed+filename) ############################################################################################################################# # run BF on the data (+) @@ -65,7 +64,7 @@ def run_bf_polyfit(pathdir,pathdir_transformed,filename,BF_try_time,BF_ops_file_ eqn = "atan(" + prefactors[i] + "+" + RPN_to_eq(express[i]) + ")" eqns = eqns + [eqn] - errors = errors + [get_symbolic_expr_error(pathdir,filename,eqn)] + errors = errors + [get_symbolic_expr_error(input_data,eqn)] expr = parse_expr(eqn) is_atomic_number = lambda expr: expr.is_Atom and expr.is_number numbers_expr = [subexpression for subexpression in preorder_traversal(expr) if is_atomic_number(subexpression)] @@ -92,7 +91,7 @@ def run_bf_polyfit(pathdir,pathdir_transformed,filename,BF_try_time,BF_ops_file_ # run gradient descent of BF output parameters and add the results to the Pareto plot for i in range(len(express)): try: - bf_gd_update = RPN_to_pytorch(pathdir,filename,eqns[i]) + bf_gd_update = RPN_to_pytorch(input_data,eqns[i]) PA.add(Point(x=bf_gd_update[1],y=bf_gd_update[0],data=bf_gd_update[2])) except: continue @@ -143,7 +142,7 @@ def run_bf_polyfit(pathdir,pathdir_transformed,filename,BF_try_time,BF_ops_file_ eqn = "atan(" + prefactors[i] + "*" + RPN_to_eq(express[i]) + ")" eqns = eqns + [eqn] - errors = errors + [get_symbolic_expr_error(pathdir,filename,eqn)] + errors = errors + [get_symbolic_expr_error(input_data,eqn)] expr = parse_expr(eqn) is_atomic_number = lambda expr: expr.is_Atom and expr.is_number numbers_expr = [subexpression for subexpression in preorder_traversal(expr) if is_atomic_number(subexpression)] @@ -171,12 +170,13 @@ def run_bf_polyfit(pathdir,pathdir_transformed,filename,BF_try_time,BF_ops_file_ # run gradient descent of BF output parameters and add the results to the Pareto plot for i in range(len(express)): try: - bf_gd_update = RPN_to_pytorch(pathdir,filename,eqns[i]) + bf_gd_update = RPN_to_pytorch(input_data,eqns[i]) PA.add(Point(x=bf_gd_update[1],y=bf_gd_update[0],data=bf_gd_update[2])) except: continue except: pass + ############################################################################################################################# # run polyfit on the data print("Checking polyfit \n") @@ -210,7 +210,7 @@ def run_bf_polyfit(pathdir,pathdir_transformed,filename,BF_try_time,BF_ops_file_ elif output_type=="tan": eqn = "atan(" + eqn + ")" - polyfit_err = get_symbolic_expr_error(pathdir,filename,eqn) + polyfit_err = get_symbolic_expr_error(input_data,eqn) expr = parse_expr(eqn) is_atomic_number = lambda expr: expr.is_Atom and expr.is_number numbers_expr = [subexpression for subexpression in preorder_traversal(expr) if is_atomic_number(subexpression)] diff --git a/Code/S_snap.py b/Code/S_snap.py index 7cff0d2..9fd96e4 100644 --- a/Code/S_snap.py +++ b/Code/S_snap.py @@ -60,14 +60,14 @@ def integerSnap(p, top=1): p = np.array(p) metric = np.abs(p - np.round(p.astype(np.double))) chosen = np.argsort(metric)[:top] - return list(zip(chosen, np.round(p.astype(np.double))[chosen])) + return dict(list(zip(chosen, np.round(p.astype(np.double))[chosen]))) def zeroSnap(p, top=1): p = np.array(p) metric = np.abs(p) chosen = np.argsort(metric)[:top] - return list(zip(chosen, np.zeros(len(chosen)))) + return dict(list(zip(chosen, np.zeros(len(chosen))))) def rationalSnap(p, top=1): @@ -75,4 +75,4 @@ def rationalSnap(p, top=1): p = np.array(p) snaps = np.array(list(bestApproximation(x,100) for x in p)) chosen = np.argsort(snaps[:, 3])[:top] - return list(zip(chosen, snaps[chosen, 0:3])) + return dict(list(zip(chosen, snaps[chosen, 0:3])))