def exact_Kolmogorov_expression(n_dim, theta, Orders, Orders_out, const_, r=1):
Thetas, Thetas_out = get_theta_parameters(theta.reshape((-1, )), Orders,
Orders_out, n_dim)
symbols_ = 'X0 '
for m in range(n_dim - 1):
if m < n_dim - 2:
symbols_ += 'X' + str(m + 1) + ' '
else:
symbols_ += 'X' + str(m + 1)
dims_ = symbols(symbols_)
inner_funcs = [
MeijerG(theta=Thetas[k], order=Orders[k]) for k in range(n_dim)
]
outer_funcs = MeijerG(theta=Thetas_out[0], order=Orders_out[0])
out_expr_ = 0
x = symbols('x')
for v in range(n_dim):
out_expr_ += sympify(str(re(inner_funcs[v].expression()))).subs(
x, dims_[v])
out_expr_ = simplify(
sympify(str(re(outer_funcs.expression()))).subs(x, out_expr_))
final_expr = simplify(sympify(str(const_ / (const_ + out_expr_))))
return final_expr, dims_
def Kolmogorov_expression(n_dim, Thetas, Orders, Thetas_out, Orders_out, r=1):
symbols_ = 'X0 '
for m in range(n_dim - 1):
if m < n_dim - 2:
symbols_ += 'X' + str(m + 1) + ' '
else:
symbols_ += 'X' + str(m + 1)
dims_ = symbols(symbols_)
inner_funcs = [
MeijerG(theta=Thetas[k], order=Orders[k]) for k in range(n_dim)
]
outer_funcs = MeijerG(theta=Thetas_out[0], order=Orders_out[0])
out_expr_ = 0
x = symbols('x')
for v in range(n_dim):
out_expr_ += sympify(str(re(inner_funcs[v].approx_expression()))).subs(
x, dims_[v])
out_expr_ = simplify(
sympify(str(re(outer_funcs.expression()))).subs(x, out_expr_))
return out_expr_, dims_
def Loss(theta):
G = MeijerG(theta=theta, order=G_order)
loss_ = np.mean((f(X) - G.evaluate(X))**2)
print("Expression:", G.expression())
print("Loss:", loss_)
return loss_
def loss(theta):
# Computes the loss for a new term of parameter theta
residual_list = self.current_resi
theta_g, v_, w_ = split_theta(theta)
meijer_g_ = MeijerG(theta=theta_g, order=g_order)
Y = w_ * meijer_g_.evaluate(ReLU(np.matmul(X, v_)
/ (np.sqrt(self.dim_x) * np.linalg.norm(v_))))
loss_ = np.mean((Y - residual_list) ** 2)
# print("Loss: ", loss_)
return loss_
def mse_loss(theta):
# Computes the MSE loss
theta_in, theta_out, eps, ksi = unpack_theta(theta, g_in_order, g_out_order)
G_in = MeijerG(theta=theta_in, order=g_in_order)
G_out = MeijerG(theta=theta_out, order=g_out_order)
X_flat = X.flatten()
Arg_flat = np.array([x + eps*i for i in range(2*dim_x+1) for x in X_flat])
Im_flat = G_in.evaluate(sigmoid(Arg_flat))
Im_inj = np.array([ksi**((j+1)%(dim_x+1)) * Im_flat[j]
for j in range(len(Im_flat))]).reshape(2*dim_x+1, n_points, dim_x) # i,n,j
Im_in = np.sum(Im_inj, axis=2)
Add_in = np.array([[i for _ in range(n_points)] for i in range(2*dim_x+1)])
Arg_in = Im_in + Add_in
Arg_flat = Arg_in.flatten()
Im_flat = G_out.evaluate(sigmoid(Arg_flat))
Y_in = Im_flat.reshape(2*dim_x+1, n_points)
Y_est = np.sum(Y_in, axis=0)
Y_true = np.apply_along_axis(f, 1, X)
loss = np.mean((Y_est-Y_true)**2)
print("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
print("Loss : ", loss)
print("Expression for G_in : ", G_in.expression())
print("Expression for G_out : ", G_out.expression())
print("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
return loss
def get_inner_outer_functions(n_dim, theta, Orders, Orders_out):
theta = theta.reshape((-1, ))
Thetas, Thetas_out = get_theta_parameters(theta,
Orders,
Orders_out,
n_dim=n_dim)
inner_funcs = [
MeijerG(theta=Thetas[k], order=Orders[k]) for k in range(n_dim)
]
outer_funcs = MeijerG(theta=Thetas_out[0], order=Orders_out[0])
return inner_funcs, outer_funcs
def tune_new_term(self, X, g_order, theta_0):
# Tunes a new term for the model for f with a Meijer G-function of order g_order
def split_theta(theta):
# Splits theta in the Meijer G-function part, the vector part and the weight part
_, _, p, q = g_order
theta_g = np.concatenate((theta[:p + q], np.array([1.0])))
theta_v = theta[p + q:-1]
theta_w = theta[-1]
return theta_g, theta_v, theta_w
def loss(theta):
# Computes the loss for a new term of parameter theta
residual_list = self.current_resi
theta_g, v_, w_ = split_theta(theta)
meijer_g_ = MeijerG(theta=theta_g, order=g_order)
Y = w_ * meijer_g_.evaluate(ReLU(np.matmul(X, v_)
/ (np.sqrt(self.dim_x) * np.linalg.norm(v_))))
loss_ = np.mean((Y - residual_list) ** 2)
# print("Loss: ", loss_)
return loss_
new_theta, new_loss = self.optimize_CG(loss, theta_0)
new_theta_meijer, new_v, new_w = split_theta(new_theta)
new_meijerg = MeijerG(theta=new_theta_meijer, order=g_order)
return new_meijerg, new_v, new_w, new_loss
def symbolic_modeling(f, G_order, theta_0, npoints, xrange):
X = np.linspace(xrange[0], xrange[1], npoints)
def Loss(theta):
G = MeijerG(theta=theta, order=G_order)
loss_ = np.mean((f(X) - G.evaluate(X))**2)
print("Expression:", G.expression())
print("Loss:", loss_)
return loss_
theta_opt, Loss_ = Optimize(Loss, theta_0)
symbolic_model = MeijerG(theta=theta_opt, order=G_order)
return symbolic_model, Loss_
def get_exact_Kolmogorov_expression(self, theta):
Thetas, Thetas_out = get_theta_parameters(theta.reshape(
(-1, )), self.Orders_in, self.Orders_out, self.n_dim)
Thetas_in_0, Thetas_out_0 = get_theta_parameters(
self.theta_0.reshape((-1, )), self.Orders_in, self.Orders_out,
self.n_dim)
symbols_ = 'X0 '
for m in range(self.single_dim - 1):
if m < self.single_dim - 2:
symbols_ += 'X' + str(m + 1) + ' '
else:
symbols_ += 'X' + str(m + 1)
dims_ = symbols(symbols_)
inner_funcs = [
MeijerG(theta=Thetas[k], order=self.Orders_in[k])
for k in range(self.n_dim)
]
outer_funcs = MeijerG(theta=Thetas_out[0], order=self.Orders_out[0])
inner_fun_0 = [
MeijerG(theta=Thetas_in_0[k], order=self.Orders_in[k])
for k in range(self.n_dim)
]
out_expr_ = 0
x = symbols('x')
for v in range(self.n_dim):
if v < self.single_dim:
if v not in self.zero_locs:
out_expr_ += sympify(str(re(
inner_funcs[v].expression()))).subs(x, dims_[v])
else:
if v not in self.zero_locs:
dim_0 = self.dim_combins[self.single_dim +
(v - self.single_dim)][0]
dim_1 = self.dim_combins[self.single_dim +
(v - self.single_dim)][1]
out_expr_ += sympify(str(re(
inner_funcs[v].expression()))).subs(
x, dims_[dim_0] * dims_[dim_1])
out_expr_ = simplify(
sympify(str(re(outer_funcs.expression()))).subs(x, out_expr_))
final_expr = simplify(
sympify(str(self.init_scale / (self.init_scale + out_expr_))))
return final_expr, dims_