Add files via upload
This commit is contained in:
Silviu Marian Udrescu
GitHub
parent
7a0d782d51
commit
a96e7f321a
10 changed files with 119 additions and 133 deletions
|
|
@ -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
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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)):
|
||||
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))
|
||||
|
|
|
|||
|
|
@ -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)):
|
||||
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)
|
||||
# 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]
|
||||
# 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
|
||||
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)):
|
||||
try:
|
||||
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)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
|
|
|
|||
|
|
@ -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)]
|
||||
|
|
|
|||
|
|
@ -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])))
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue