From 1b8643dd9db34cf041d7060ad6801bdd6b9d3268 Mon Sep 17 00:00:00 2001 From: Silviu Marian Udrescu Date: Sat, 25 Apr 2020 16:06:05 -0400 Subject: [PATCH] Add files via upload --- Code/S_add_snap_expr_on_pareto_polyfit.py | 71 +++++++++++++++++++---- 1 file changed, 61 insertions(+), 10 deletions(-) diff --git a/Code/S_add_snap_expr_on_pareto_polyfit.py b/Code/S_add_snap_expr_on_pareto_polyfit.py index 7ee62b3..7f9a3f2 100644 --- a/Code/S_add_snap_expr_on_pareto_polyfit.py +++ b/Code/S_add_snap_expr_on_pareto_polyfit.py @@ -9,10 +9,6 @@ import torch.nn.functional as F import torch.optim as optim import torch.utils.data as utils from torch.autograd import Variable -from sklearn.metrics import roc_curve, auc -from sklearn.preprocessing import label_binarize -from sklearn.manifold import TSNE -import seaborn as sns import copy import warnings warnings.filterwarnings("ignore") @@ -71,6 +67,7 @@ def add_snap_expr_on_pareto_polyfit(pathdir, filename, math_expr, PA): 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 @@ -94,17 +91,73 @@ def add_snap_expr_on_pareto_polyfit(pathdir, filename, math_expr, PA): 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 + eq_numbers = [subexpression for subexpression in preorder_traversal(expr) if is_atomic_number(subexpression)] - for i in range(len(zero_snapped_expr)): + # 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)] + + # 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 + + snapped_expr = np.append(integer_snapped_expr,zero_snapped_expr) + snapped_expr = np.append(snapped_expr,rational_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(zero_snapped_expr[i])) + snapped_error = get_symbolic_expr_error(pathdir,filename,str(snapped_expr[i])) # Calculate the complexity of the new, snapped expression - expr = simplify(powsimp(zero_snapped_expr[i])) + expr = simplify(powsimp(snapped_expr[i])) for s in (expr.free_symbols): s = symbols(str(s), real = True) - expr = simplify(parse_expr(str(zero_snapped_expr[i]),locals())) + expr = simplify(parse_expr(str(snapped_expr[i]),locals())) expr = intify(expr) is_atomic_number = lambda expr: expr.is_Atom and expr.is_number @@ -122,8 +175,6 @@ def add_snap_expr_on_pareto_polyfit(pathdir, filename, math_expr, PA): PA.add(Point(x=snapped_complexity, y=snapped_error, data=str(expr))) except: - print("error") - print("") continue return(PA)