afdee1c/symbolic-regression
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add files via upload

Browse source
This commit is contained in:
Silviu Marian Udrescu 2020-04-21 02:26:25 -04:00 • committed by GitHub
parent 1c7765c961
commit 8f1cbc7a7e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 96 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

44
Code/S_add_bf_on_numbers_on_pareto.py
View file

@ -73,29 +73,33 @@ def add_bf_on_numbers_on_pareto(pathdir, filename, PA, math_expr):
# Do bf on one parameter at a time # Do bf on one parameter at a time
bf_on_numbers_expr = [] bf_on_numbers_expr = []
for w in range(len(eq_numbers)): for w in range(len(eq_numbers)):
param_dict = {} try:
unsnapped_param_dict = {'p':1} param_dict = {}
eq_ = unsnap_recur(expr,param_dict,unsnapped_param_dict) unsnapped_param_dict = {'p':1}
eq = eq_ eq_ = unsnap_recur(expr,param_dict,unsnapped_param_dict)
np.savetxt(pathdir+"number_for_bf_%s.txt" %w, [eq_numbers[w]])
brute_force_number(pathdir,"number_for_bf_%s.txt" %w)
# Load the predictions made by the bf code
bf_numbers = np.loadtxt("results.dat",usecols=(1,),dtype="str")
new_numbers = copy.deepcopy(eq_numbers)
# replace the number under consideration by all the proposed bf numbers
for kk in range(len(bf_numbers)):
eq = eq_ eq = eq_
new_numbers[w] = parse_expr(RPN_to_eq(bf_numbers[kk]))
jj = 0 np.savetxt(pathdir+"number_for_bf_%s.txt" %w, [eq_numbers[w]])
for parm in unsnapped_param_dict: brute_force_number(pathdir,"number_for_bf_%s.txt" %w)
if parm!="p": # Load the predictions made by the bf code
eq = eq.subs(parm, new_numbers[jj]) bf_numbers = np.loadtxt("results.dat",usecols=(1,),dtype="str")
jj = jj + 1 new_numbers = copy.deepcopy(eq_numbers)
# replace the number under consideration by all the proposed bf numbers
for kk in range(len(bf_numbers)):
eq = eq_
new_numbers[w] = parse_expr(RPN_to_eq(bf_numbers[kk]))
jj = 0
for parm in unsnapped_param_dict:
if parm!="p":
eq = eq.subs(parm, new_numbers[jj])
jj = jj + 1
bf_on_numbers_expr = bf_on_numbers_expr + [eq]
except:
continue
bf_on_numbers_expr = bf_on_numbers_expr + [eq]
for i in range(len(bf_on_numbers_expr)): for i in range(len(bf_on_numbers_expr)):
try: try:
# Calculate the error of the new, snapped expression # Calculate the error of the new, snapped expression

89
Code/S_add_snap_expr_on_pareto.py
View file

@ -79,18 +79,21 @@ def add_snap_expr_on_pareto(pathdir, filename, math_expr, PA, DR_file=""):
# Do integer snap one parameter at a time # Do integer snap one parameter at a time
integer_snapped_expr = [] integer_snapped_expr = []
for w in range(len(eq_numbers)): for w in range(len(eq_numbers)):
param_dict = {} try:
unsnapped_param_dict = {'p':1} param_dict = {}
eq = unsnap_recur(expr,param_dict,unsnapped_param_dict) unsnapped_param_dict = {'p':1}
new_numbers = integerSnap(eq_numbers,w+1) eq = unsnap_recur(expr,param_dict,unsnapped_param_dict)
for kk in range(len(new_numbers)): new_numbers = integerSnap(eq_numbers,w+1)
eq_numbers[new_numbers[kk][0]] = new_numbers[kk][1] for kk in range(len(new_numbers)):
jj = 0 eq_numbers[new_numbers[kk][0]] = new_numbers[kk][1]
for parm in unsnapped_param_dict: jj = 0
if parm!="p": for parm in unsnapped_param_dict:
eq = eq.subs(parm, eq_numbers[jj]) if parm!="p":
jj = jj + 1 eq = eq.subs(parm, eq_numbers[jj])
integer_snapped_expr = integer_snapped_expr + [eq] jj = jj + 1
integer_snapped_expr = integer_snapped_expr + [eq]
except:
continue
# Get the numbers appearing in the expression # 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
@ -99,18 +102,21 @@ def add_snap_expr_on_pareto(pathdir, filename, math_expr, PA, DR_file=""):
# Do zero snap one parameter at a time # Do zero snap one parameter at a time
zero_snapped_expr = [] zero_snapped_expr = []
for w in range(len(eq_numbers)): for w in range(len(eq_numbers)):
param_dict = {} try:
unsnapped_param_dict = {'p':1} param_dict = {}
eq = unsnap_recur(expr,param_dict,unsnapped_param_dict) unsnapped_param_dict = {'p':1}
new_numbers = zeroSnap(eq_numbers,w+1) eq = unsnap_recur(expr,param_dict,unsnapped_param_dict)
for kk in range(len(new_numbers)): new_numbers = zeroSnap(eq_numbers,w+1)
eq_numbers[new_numbers[kk][0]] = new_numbers[kk][1] for kk in range(len(new_numbers)):
jj = 0 eq_numbers[new_numbers[kk][0]] = new_numbers[kk][1]
for parm in unsnapped_param_dict: jj = 0
if parm!="p": for parm in unsnapped_param_dict:
eq = eq.subs(parm, eq_numbers[jj]) if parm!="p":
jj = jj + 1 eq = eq.subs(parm, eq_numbers[jj])
zero_snapped_expr = zero_snapped_expr + [eq] jj = jj + 1
zero_snapped_expr = zero_snapped_expr + [eq]
except:
continue
# Get the numbers appearing in the expression # 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
@ -119,23 +125,26 @@ def add_snap_expr_on_pareto(pathdir, filename, math_expr, PA, DR_file=""):
# 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)):
eq_numbers_snap = copy.deepcopy(eq_numbers) try:
param_dict = {} eq_numbers_snap = copy.deepcopy(eq_numbers)
unsnapped_param_dict = {'p':1} param_dict = {}
eq = unsnap_recur(expr,param_dict,unsnapped_param_dict) unsnapped_param_dict = {'p':1}
new_numbers = rationalSnap(eq_numbers,w+1) eq = unsnap_recur(expr,param_dict,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] for kk in range(len(new_numbers)):
jj = 0 eq_numbers_snap[new_numbers[kk][0]] = new_numbers[kk][1][1:3]
for parm in unsnapped_param_dict: jj = 0
if parm!="p": for parm in unsnapped_param_dict:
if parm!="p":
try: try:
eq = eq.subs(parm, Rational(eq_numbers_snap[jj][0],eq_numbers_snap[jj][1])) eq = eq.subs(parm, Rational(eq_numbers_snap[jj][0],eq_numbers_snap[jj][1]))
except: except:
eq = eq.subs(parm, eq_numbers_snap[jj]) eq = eq.subs(parm, eq_numbers_snap[jj])
jj = jj + 1 jj = jj + 1
rational_snapped_expr = rational_snapped_expr + [eq] 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,zero_snapped_expr)
snapped_expr = np.append(snapped_expr,rational_snapped_expr) snapped_expr = np.append(snapped_expr,rational_snapped_expr)

27
Code/S_add_snap_expr_on_pareto_polyfit.py
View file

@ -79,18 +79,21 @@ def add_snap_expr_on_pareto_polyfit(pathdir, filename, math_expr, PA):
# Do zero snap one parameter at a time # Do zero snap one parameter at a time
zero_snapped_expr = [] zero_snapped_expr = []
for w in range(len(eq_numbers)): for w in range(len(eq_numbers)):
param_dict = {} try:
unsnapped_param_dict = {'p':1} param_dict = {}
eq = unsnap_recur(expr,param_dict,unsnapped_param_dict) unsnapped_param_dict = {'p':1}
new_numbers = zeroSnap(eq_numbers,w+1) eq = unsnap_recur(expr,param_dict,unsnapped_param_dict)
for kk in range(len(new_numbers)): new_numbers = zeroSnap(eq_numbers,w+1)
eq_numbers[new_numbers[kk][0]] = new_numbers[kk][1] for kk in range(len(new_numbers)):
jj = 0 eq_numbers[new_numbers[kk][0]] = new_numbers[kk][1]
for parm in unsnapped_param_dict: jj = 0
if parm!="p": for parm in unsnapped_param_dict:
eq = eq.subs(parm, eq_numbers[jj]) if parm!="p":
jj = jj + 1 eq = eq.subs(parm, eq_numbers[jj])
zero_snapped_expr = zero_snapped_expr + [eq] jj = jj + 1
zero_snapped_expr = zero_snapped_expr + [eq]
except:
continue
for i in range(len(zero_snapped_expr)): for i in range(len(zero_snapped_expr)):
try: try:

4
Code/S_final_gd.py
View file

@ -138,6 +138,10 @@ def final_gd(data_file, math_expr, lr = 1e-2, N_epochs = 5000):
else: else:
eq = eq.subs(parm, trainable_parameters[ii]) eq = eq.subs(parm, trainable_parameters[ii])
complexity = complexity + get_number_DL(trainable_parameters[ii].detach().numpy()) complexity = complexity + get_number_DL(trainable_parameters[ii].detach().numpy())
n_variables = len(eq.free_symbols)
n_operations = len(count_ops(eq,visual=True).free_symbols)
if n_operations!=0 or n_variables!=0:
complexity = complexity + (n_variables+n_operations)*np.log2((n_variables+n_operations))
ii = ii+1 ii = ii+1