Add files via upload

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")
@@ -72,6 +68,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
     eq_numbers = [subexpression for subexpression in preorder_traversal(expr) if is_atomic_number(subexpression)]
@@ -95,16 +92,72 @@ def add_snap_expr_on_pareto_polyfit(pathdir, filename, math_expr, PA):
         except:
             continue
     
-    for i in range(len(zero_snapped_expr)):
+    # 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)]
+
+    # 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)