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 from sympy import Symbol if isinstance(expr, sympy.numbers.Float) or isinstance( expr, sympy.numbers.Integer) or isinstance( expr, sympy.numbers.Rational) or isinstance( expr, sympy.numbers.Pi): used_param_names = list( param_dict.keys()) + list(unsnapped_param_dict) unsnapped_param_name = get_next_available_key(used_param_names, "p", is_underscore=False) unsnapped_param_dict[unsnapped_param_name] = float(expr) unsnapped_expr = Symbol(unsnapped_param_name) return unsnapped_expr elif isinstance(expr, sympy.symbol.Symbol): return expr else: unsnapped_sub_expr_list = [] for sub_expr in expr.args: unsnapped_sub_expr = unsnap_recur(sub_expr, param_dict, unsnapped_param_dict) unsnapped_sub_expr_list.append(unsnapped_sub_expr) return expr.func(*unsnapped_sub_expr_list) def get_next_available_key(iterable, key, midfix="", suffix="", is_underscore=True): """Get the next available key that does not collide with the keys in the dictionary.""" if key + suffix not in iterable: return key + suffix else: i = 0 underscore = "_" if is_underscore else "" while "{}{}{}{}{}".format(key, underscore, midfix, i, suffix) in iterable: i += 1 new_key = "{}{}{}{}{}".format(key, underscore, midfix, i, suffix) return new_key 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 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 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 # 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: 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] 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, rational_snapped_expr) # snapped_expr = np.append(snapped_expr,rational_snapped_expr) 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(input_data, str(snapped_expr[i])) # Calculate the complexity of the new, snapped expression expr = snapped_expr[i] for s in (expr.free_symbols): s = symbols(str(s), real=True) 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)
def add_snap_expr_on_pareto(pathdir, filename, math_expr, PA, DR_file=""): def unsnap_recur(expr, param_dict, unsnapped_param_dict): """Recursively transform each numerical value into a learnable parameter.""" import sympy from sympy import Symbol if isinstance(expr, sympy.numbers.Float) or isinstance( expr, sympy.numbers.Integer) or isinstance( expr, sympy.numbers.Rational) or isinstance( expr, sympy.numbers.Pi): used_param_names = list( param_dict.keys()) + list(unsnapped_param_dict) unsnapped_param_name = get_next_available_key(used_param_names, "p", is_underscore=False) unsnapped_param_dict[unsnapped_param_name] = float(expr) unsnapped_expr = Symbol(unsnapped_param_name) return unsnapped_expr elif isinstance(expr, sympy.symbol.Symbol): return expr else: unsnapped_sub_expr_list = [] for sub_expr in expr.args: unsnapped_sub_expr = unsnap_recur(sub_expr, param_dict, unsnapped_param_dict) unsnapped_sub_expr_list.append(unsnapped_sub_expr) return expr.func(*unsnapped_sub_expr_list) def get_next_available_key(iterable, key, midfix="", suffix="", is_underscore=True): """Get the next available key that does not collide with the keys in the dictionary.""" if key + suffix not in iterable: return key + suffix else: i = 0 underscore = "_" if is_underscore else "" while "{}{}{}{}{}".format(key, underscore, midfix, i, suffix) in iterable: i += 1 new_key = "{}{}{}{}{}".format(key, underscore, midfix, i, suffix) return new_key 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)] # # # 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 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, rational_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(snapped_expr[i])) # Calculate the complexity of the new, snapped expression expr = simplify(powsimp(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 = 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) ] if DR_file == "": snapped_complexity = 0 for j in numbers_expr: snapped_complexity = snapped_complexity + get_number_DL_snapped( float(j)) 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)) # If a bf file is provided, replace the variables with the actual ones before calculating the complexity else: dr_data = np.loadtxt(DR_file, dtype="str", delimiter=",") expr = str(expr) old_vars = ["x%s" % k for k in range(len(dr_data) - 3)] for i_dr in range(len(old_vars)): expr = expr.replace(old_vars[i_dr], "(" + dr_data[i_dr + 2] + ")") expr = "(" + dr_data[1] + ")*(" + expr + ")" 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) snapped_complexity = 0 for j in numbers_expr: snapped_complexity = snapped_complexity + get_number_DL_snapped( float(j)) 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)