Settings.py

""""""""""""""""""""""""""""""""" 
This file is for modifying.
Do not run this file.

For running: RegressorTest.py
For modifying: Settings.py
"""""""""""""""""""""""""""""""""
import numpy as np
import tensorflow as tf

"""""""""""""""""""""""""""
Settings that can change
"""""""""""""""""""""""""""
# Determines complexity of tree
n_tree_layers = 3

# Allowable operators for tree nodes
# function_set = ['id', 'mul', 'sqrt', 'sin', 'div', 'log']
function_set = ["id", "mul", "sin", "sqrt"]

num_features = 1
num_dims_per_feature = 1
n_dims_in_output = 1

train_scope = [0, 5]
test_scope = [y * 2 for y in train_scope]

num_train_repeat_processes = 5
num_train_steps_in_repeat_mode = 8000

"""""""""""""""""""""""""""
Display and log settings
"""""""""""""""""""""""""""

show_output = False
keep_logs = False
output_freq = 49000
plot_frequency = 500000
save_all_formulas = False

max_formula_output_length = 400

"""""""""""""""""""""""""""
Tree settings
"""""""""""""""""""""""""""
use_both_for_unary = True
non_const = False
use_leaf_sm = False


"""""""""""""""""""""""""""
Domain parameters
"""""""""""""""""""""""""""

fpe_example = 0

max_x = np.pi

train_scope2 = [0, 5]
test_scope2 = test_scope.copy()  # [0, 5]

avoid_zero = False
# if fpe_example == 4:
#     avoid_zero = True


"""""""""""""""""""""""""""
Define the ODE here
"""""""""""""""""""""""""""
# options: mode = "sr", "de", "lr"
mode = "de"

# This is the "g" function that defines the ODE problem.
def implicit_function(full_x, y, y_p, y_pp):
    # Implicit function is 0 if we are doing symbolic regression
    if mode == "sr":
        return y * 0.0

    y_p1 = y_p[0]
    y_p2 = y_p[1]
    y_p3 = y_p[2]

    y_pp1 = y_pp[0]
    y_pp2 = y_pp[1]
    y_pp12 = y_pp[2]

    x = tf.reshape(full_x[:, 0, 0], [-1, 1, 1])
    t = tf.reshape(full_x[:, 0, -1], [-1, 1, 1])
    if num_features > 1:
        w = tf.reshape(full_x[:, 0, 1], [-1, 1, 1])

    ret_val = None

    """ Lane-Emden Equation """
    # emden_m = 0
    # ret_val = y_pp1 + 2.0 * tf.math.divide_no_nan(y_p1, x)
    # ret_val += y ** emden_m

    """ Bell curve integral """
    # ret_val = tf.math.exp(-1.0 * tf.square(x)) - y_p1

    """ One dimensional wave equation """
    # c = 1.0
    # ret_val = y_pp2 - c**2 * y_pp1

    """ One dimensional heat equation """
    # c = 1.0
    # ret_val = y_p2 - c**2 * y_pp1 - tf.math.cos(x)

    """ Inhomogeneous wave equation """
    # ret_val = y_pp1 - y_pp2 - 2

    """ Two dimensional Laplace equation """
    # ret_val = y_pp2 + y_pp1

    ret_val = y_p1 - 2 * x



    """ FP Eqn """
    if fpe_example == 1:
        # Example 1
        a = -1.0
        a_p = 0.0
        b = 1.0
        b_p = 0.0
        b_pp = 0.0
    elif fpe_example == 2:
        # Example 2
        a = x
        a_p = 1.0
        b = tf.math.square(x) / 2
        b_p = x
        b_pp = 1.0
    elif fpe_example == 3:
        # Example 3
        a = -1.0 - x
        a_p = -1.0
        b = tf.multiply(x ** 2, tf.math.exp(t))
        b_p = 2 * x * tf.math.exp(t)
        b_pp = 2 * tf.math.exp(t)
    elif fpe_example == 4:
        # Example 4
        a = 4.0 * tf.math.divide_no_nan(y, x) - x / 3.0
        a_p = 4.0 * (tf.math.divide_no_nan(y_p1, x) - tf.math.divide_no_nan(y, x ** 2)) - 1.0 / 3
        b = y
        b_p = y_p1
        b_pp = y_pp1
    elif fpe_example == 6:
        # Example 5
        a = 0.0
        a_p = 0.0
        b = 0.5
        b_p = 0.0
        b_pp = 0.0

    if fpe_example > 0:
        t1 = tf.multiply(y, b_pp - a_p)
        t2 = tf.multiply(y_p1, 2 * b_p - a)
        t3 = tf.multiply(y_pp1, b)
        # print("a: {}".format(a.shape))
        # print("a_p: {}".format(a_p.shape))
        # print("b: {}".format(a.shape))
        # print("b_p: {}".format(b_p.shape))
        # print("b_pp: {}".format(b_pp.shape))
        # print("t1: {}".format(t1.shape))
        # print("t2: {}".format(t2.shape))
        # print("t3: {}".format(t3.shape))

        ret_val = y_p2 - (t1 + t2 + t3)

    if fpe_example == 3:
        ret_val = y_p2 - ((x + 1) * y_p1 + x ** 2 * tf.math.exp(t) * y_pp1)

    if fpe_example == 4:
        t1 = y * (y_pp1 * x ** 2 - 4 * y_p1 * x + 4 * y + x * x / 3.0)
        t2 = y_p1 * (2 * x * y_p1 - 4 * x * y + x * x * x / 3.0)
        t3 = x ** 2 * y_pp1 * y
        ret_val = y_p2 * x * x - (t1 + t2 + t3)

    if fpe_example == 5:
        ret_val = y_p3 - (-2 * y + 3 * x * y_p1 - w * y_p2 + x ** 2 * y_pp1 + w ** 2 * y_pp2 + 2 * y_pp12)

    return ret_val

"""""""""""""""""""""""""""
Initial values
"""""""""""""""""""""""""""
# initialize_ops are given in bottom-up order.
initialize_ops = np.zeros([2 ** n_tree_layers - 1])
# initialize_ops = ["mul", "mul", "id"]
# if fpe_example in [1, 2, 3, 5]:
#     initialize_ops = ["id", "exp", "mul"]
# elif fpe_example in [4]:
#     initialize_ops = ["mul", "exp", "mul"]


# initialize_ops = ["exp", "sin", "mul"]
#
min_x = 0
max_t = 5
min_t = 0
n_bc_points = 5

# Initial values for (x, y)

fixed_x = []
fixed_y = []
# for i in range(n_bc_points):
#     t_i = i * (max_t - min_t)/n_bc_points + min_t
#     fixed_x.append([0, t_i])
#     # fixed_y.append(0)
#     fixed_y.append(1 - np.exp(-1 * t_i))
#     fixed_x.append([np.pi, t_i])
#     fixed_y.append(np.exp(-1 * t_i) - 1)
# fixed_y.append(0)



# Initial values for (x, y')
fixed_x_p1 = []
fixed_y_p1 = []
fixed_x_p2 = []
fixed_y_p2 = []

if mode == "de":
    if fpe_example != 5:
        for i in range(n_bc_points):
            x_i = i * (max_x - min_x) / (n_bc_points - 1) + min_x
            fixed_x.append([x_i, 0])
            if fpe_example in [1, 2, 5]:
                fixed_y.append(x_i)
            elif fpe_example == 3:
                fixed_y.append(x_i + 1)
            elif fpe_example == 4:
                fixed_y.append(x_i ** 2)
            # fixed_y.append(0)
            # fixed_y.append(x_i + np.cos(x_i))
            # fixed_x_p2.append([x_i, 0])
            # fixed_y_p2.append(np.sin(x_i))

    if fpe_example == 5:
        for i in range(n_bc_points):
            x_i = i * (max_x - min_x) / (n_bc_points - 1) + min_x
            for j in range(n_bc_points):
                w_j = j * (max_x - min_x) / (n_bc_points - 1) + min_x

                fixed_x.append([x_i, w_j, 0])
                fixed_y.append(x_i)

# print("IVP (x, y):\n{}".format([(fixed_x[i], fixed_y[i]) for i in range(len(fixed_x))]))
# print("IVP (x, y_p1):\n{}".format([(fixed_x_p1[i], fixed_y_p1[i]) for i in range(len(fixed_x_p1))]))
# print("IVP (x, y_p2):\n{}".format([(fixed_x_p2[i], fixed_y_p2[i]) for i in range(len(fixed_x_p2))]))

# Weight to give IVP error
ivp_lambda = 10


"""""""""""""""""""""""""""
Training hyperparameters
"""""""""""""""""""""""""""
quick_train_fraction = 0.7

# Probably don't need to change any of the ones below
max_training_batch_size = 1000
t1_fraction = 5/20
t2_fraction = 15 / 20

train_N = 5000
test_N = 1000

eps = 1e-4
big_eps = 1e-3
d_eps = 2.0e-2
learn_rate = 0.001
w_matrix_stddev = 0.1
init_weight_value = 5