Add files via upload

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):
+def RPN_to_pytorch(data, math_expr, lr = 1e-2, N_epochs = 500):
-    data_file = pathdir + filename
     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
 
 

Code/S_add_bf_on_numbers_on_pareto.py

@@ -30,6 +30,7 @@ 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):
+    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

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,7 +92,32 @@ 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
+    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)
+            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)]
 
@@ -122,23 +125,19 @@ def add_snap_expr_on_pareto(pathdir, filename, math_expr, PA, DR_file=""):
     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)
+            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)):
+            new_numbers = {"p"+str(k): v for k, v in new_numbers.items()}
-                eq_numbers_snap[new_numbers[kk][0]] = new_numbers[kk][1][1:3]
+            temp_unsnapped_param_dict.update(new_numbers)
-            jj = 0
+            #for kk in range(len(new_numbers)):                                                                                                                                   
-            for parm in unsnapped_param_dict:
+            #    eq_numbers_snap[new_numbers[kk][0]] = new_numbers[kk][1][1:3]                                                                                                    
-                if parm!="p":
+            new_eq = re.sub(r"(p\d*)",r"{\1}",str(eq))
-                    
+            new_eq = new_eq.format_map(temp_unsnapped_param_dict)
-                    try:
+            rational_snapped_expr = rational_snapped_expr + [parse_expr(new_eq)]
-                        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
 
@@ -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()))
+            expr =  parse_expr(str(snapped_expr[i]),locals())
-            #print("expr 0", expr)
             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()))
+                #expr =  simplify(parse_expr(str(expr),locals()))
-                #print("expr 1", expr)
+                expr =  parse_expr(str(expr),locals())      
-                #expr = intify(expr)
-                #print("expr 2", expr)
                 snapped_complexity = 0
                 for j in numbers_expr:
                     snapped_complexity = snapped_complexity + get_number_DL_snapped(float(j))

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
@@ -102,78 +105,73 @@ def add_snap_expr_on_pareto_polyfit(pathdir, filename, math_expr, PA):
             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)):
+            new_numbers = {"p"+str(k): v for k, v in new_numbers.items()}
-                eq_numbers[new_numbers[kk][0]] = new_numbers[kk][1]
+            temp_unsnapped_param_dict.update(new_numbers) 
-            jj = 0
+            #for kk in range(len(new_numbers)):
-            for parm in unsnapped_param_dict:
+            #    eq_numbers[new_numbers[kk][0]] = new_numbers[kk][1]
-                if parm!="p":
+            new_eq = re.sub(r"(p\d*)",r"{\1}",str(eq))
-                    eq = eq.subs(parm, eq_numbers[jj])
+            new_eq = new_eq.format_map(temp_unsnapped_param_dict)
-                    jj = jj + 1
+            integer_snapped_expr = integer_snapped_expr + [parse_expr(new_eq)]
-            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
+    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)]
+    eq_numbers = [subexpression for subexpression in preorder_traversal(expr) if is_atomic_number(subexpression)]
 
-#    # Do rational snap one parameter at a time
+    # Do rational snap one parameter at a time
-#    rational_snapped_expr = []
+    rational_snapped_expr = []
-#    for w in range(len(eq_numbers)):
+    for w in range(len(eq_numbers)):
-#        try:
+        try:
-#            eq_numbers_snap = copy.deepcopy(eq_numbers)
+            param_dict = {}
-#            param_dict = {}
+            unsnapped_param_dict = {'p':1}
-#            unsnapped_param_dict = {'p':1}
+            eq = unsnap_recur(expr,param_dict,unsnapped_param_dict)
-#            eq = unsnap_recur(expr,param_dict,unsnapped_param_dict)
+            del unsnapped_param_dict["p"]
-#            new_numbers = rationalSnap(eq_numbers,w+1)
+            temp_unsnapped_param_dict = copy.deepcopy(unsnapped_param_dict)
-#            for kk in range(len(new_numbers)):
+            new_numbers = rationalSnap(eq_numbers,w+1)
-#                eq_numbers_snap[new_numbers[kk][0]] = new_numbers[kk][1][1:3]
+            new_numbers = {"p"+str(k): v for k, v in new_numbers.items()}
-#            jj = 0
+            temp_unsnapped_param_dict.update(new_numbers)
-#            for parm in unsnapped_param_dict:
+            #for kk in range(len(new_numbers)):
-#                if parm!="p":
+            #    eq_numbers_snap[new_numbers[kk][0]] = new_numbers[kk][1][1:3]
-#
+            new_eq = re.sub(r"(p\d*)",r"{\1}",str(eq))
-#                    try:
+            new_eq = new_eq.format_map(temp_unsnapped_param_dict)
-#                        eq = eq.subs(parm, Rational(eq_numbers_snap[jj][0],eq_numbers_snap[jj][1]))
+            rational_snapped_expr = rational_snapped_expr + [parse_expr(new_eq)]
-#                    except:
+        except:
-#                        eq = eq.subs(parm, eq_numbers_snap[jj])
+            continue
-#                    jj = jj + 1
-#            rational_snapped_expr = rational_snapped_expr + [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
-        try:
 
+    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)
         
         

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

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

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):
+def final_gd(data, math_expr, lr = 1e-2, N_epochs = 5000):
-    data_file = pathdir + filename
     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
 
 

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
@@ -182,9 +185,10 @@ def run_aifeynman(pathdir,filename,BF_try_time,BF_ops_file_type, polyfit_deg=3,
     np.savetxt("results/solution_first_snap_%s.txt" %filename,PA_list,fmt="%s")
     
     # 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))

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)]

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])))