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_