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-30 03:57:57 -04:00 • committed by GitHub
parent 5315f0a236
commit cdb842fe97
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 79 additions and 81 deletions
Download patch file Download diff file Expand all files Collapse all files

50
Code/S_add_snap_expr_on_pareto.py
View file

@ -91,28 +91,28 @@ def add_snap_expr_on_pareto(pathdir, filename, math_expr, PA, DR_file=""):
except: except:
continue 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
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 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)):
try: # try:
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)
new_numbers = zeroSnap(eq_numbers,w+1) # new_numbers = zeroSnap(eq_numbers,w+1)
for kk in range(len(new_numbers)): # for kk in range(len(new_numbers)):
eq_numbers[new_numbers[kk][0]] = new_numbers[kk][1] # eq_numbers[new_numbers[kk][0]] = new_numbers[kk][1]
jj = 0 # jj = 0
for parm in unsnapped_param_dict: # for parm in unsnapped_param_dict:
if parm!="p": # if parm!="p":
eq = eq.subs(parm, eq_numbers[jj]) # eq = eq.subs(parm, eq_numbers[jj])
jj = jj + 1 # jj = jj + 1
zero_snapped_expr = zero_snapped_expr + [eq] # zero_snapped_expr = zero_snapped_expr + [eq]
except: # except:
continue # 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
@ -142,9 +142,9 @@ def add_snap_expr_on_pareto(pathdir, filename, math_expr, PA, DR_file=""):
except: except:
continue 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) # snapped_expr = np.append(snapped_expr,rational_snapped_expr)
for i in range(len(snapped_expr)): for i in range(len(snapped_expr)):
try: try:
# Calculate the error of the new, snapped expression # Calculate the error of the new, snapped expression

110
Code/S_add_snap_expr_on_pareto_polyfit.py
View file

@ -68,31 +68,30 @@ def add_snap_expr_on_pareto_polyfit(pathdir, filename, math_expr, PA):
eq = parse_expr(str(math_expr)) eq = parse_expr(str(math_expr))
expr = eq 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 zero snap one parameter at a time
# zero_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 = zeroSnap(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
# 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
eq_numbers = [subexpression for subexpression in preorder_traversal(expr) if is_atomic_number(subexpression)]
# Do zero snap one parameter at a time
zero_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 = zeroSnap(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
zero_snapped_expr = zero_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)]
@ -117,47 +116,46 @@ def add_snap_expr_on_pareto_polyfit(pathdir, filename, math_expr, PA):
# 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
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) # 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)
new_numbers = rationalSnap(eq_numbers,w+1) # new_numbers = rationalSnap(eq_numbers,w+1)
for kk in range(len(new_numbers)): # for kk in range(len(new_numbers)):
eq_numbers_snap[new_numbers[kk][0]] = new_numbers[kk][1][1:3] # eq_numbers_snap[new_numbers[kk][0]] = new_numbers[kk][1][1:3]
jj = 0 # jj = 0
for parm in unsnapped_param_dict: # for parm in unsnapped_param_dict:
if parm!="p": # 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
try: # snapped_expr = np.append(integer_snapped_expr,zero_snapped_expr)
eq = eq.subs(parm, Rational(eq_numbers_snap[jj][0],eq_numbers_snap[jj][1])) # snapped_expr = np.append(snapped_expr,rational_snapped_expr)
except:
eq = eq.subs(parm, eq_numbers_snap[jj])
jj = jj + 1
rational_snapped_expr = rational_snapped_expr + [eq]
except:
continue
snapped_expr = np.append(integer_snapped_expr,zero_snapped_expr) for i in range(len(integer_snapped_expr)):
snapped_expr = np.append(snapped_expr,rational_snapped_expr)
for i in range(len(snapped_expr)):
try: try:
# Calculate the error of the new, snapped expression # 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(pathdir,filename,str(integer_snapped_expr[i]))
# Calculate the complexity of the new, snapped expression # Calculate the complexity of the new, snapped expression
expr = simplify(powsimp(snapped_expr[i])) expr = simplify(powsimp(integer_snapped_expr[i]))
for s in (expr.free_symbols): for s in (expr.free_symbols):
s = symbols(str(s), real = True) s = symbols(str(s), real = True)
expr = simplify(parse_expr(str(snapped_expr[i]),locals())) expr = simplify(parse_expr(str(integer_snapped_expr[i]),locals()))
expr = intify(expr) expr = intify(expr)
is_atomic_number = lambda expr: expr.is_Atom and expr.is_number is_atomic_number = lambda expr: expr.is_Atom and expr.is_number