# nt_config, Struct(), True, log_train_epoch) # l1, l2 = self.get_params(numpy=True) # self.logger.log_train_end(tf_epochs, f"l1 = {l1:5f} l2 = {l2:8f}") def predict(self, X_star): u_star = self.model(X_star) f_star = self.f_model(X_star) return u_star.numpy(), f_star.numpy() #%% TRAINING THE MODEL # Getting the data path = os.path.join(eqnPath, "data", "burgers_shock.mat") x, t, X, T, Exact_u, X_star, u_star, \ X_u_train, u_train, ub, lb = prep_data(path, hp["N_u"], noise=0.0) lambdas_star = (1.0, 0.01/np.pi) # Creating the model logger = Logger(hp) pinn = BurgersInformedNN(hp, logger, ub, lb) # Defining the error function and training def error(): l1, l2 = pinn.get_params(numpy=True) l1_star, l2_star = lambdas_star error_lambda_1 = np.abs(l1 - l1_star) / l1_star error_lambda_2 = np.abs(l2 - l2_star) / l2_star return (error_lambda_1 + error_lambda_2) / 2 logger.set_error_fn(error) pinn.fit(X_u_train, u_train)
def get_params(self, numpy=False): return self.nu def predict(self, X_star): u_star = self.model(X_star) f_star = self.f_model() return u_star.numpy(), f_star.numpy() # %% TRAINING THE MODEL # Getting the data path = os.path.join(eqnPath, "data", "burgers_shock.mat") x, t, X, T, Exact_u, X_star, u_star, \ X_u_train, u_train, X_f, ub, lb = prep_data( path, hp["N_u"], hp["N_f"], noise=0.0) # Creating the model logger = Logger(hp) pinn = BurgersInformedNN(hp, logger, X_f, ub, lb, nu=0.01/np.pi) # Defining the error function for the logger and training def error(): u_pred, _ = pinn.predict(X_star) return np.linalg.norm(u_star - u_pred, 2) / np.linalg.norm(u_star, 2) logger.set_error_fn(error) pinn.fit(X_u_train, u_train) # Getting the model predictions
from inf_cont_burgers import hp, u_pred, u_star N_u = ["N_u"] N_f = ["N_f"] layers = ["layers"] tf_epochs = ["tf_epochs"] nt_epochs = ["nt_epochs"] N_u_pinn = N_u durationPinn = time.time() - startPinn errorPinn = np.linalg.norm(u_star - u_pred, 2) / np.linalg.norm(u_star, 2) print("Error PINN: ", errorPinn) print("Time PINN: ", durationPinn) #%% Different data sizes on Plain NN Model path = os.path.join(appDataPath, "burgers_shock.mat") x, t, X, T, Exact_u, X_star, u_star, \ X_u_train, u_train, ub, lb = prep_data(path, N_u, noise=0.0) model = tf.keras.Sequential() model.add(tf.keras.layers.InputLayer(input_shape=(layers[0],))) model.add(tf.keras.layers.Lambda( lambda X: 2.0*(X - lb)/(ub - lb) - 1.0)) for width in layers[1:]: model.add(tf.keras.layers.Dense( width, activation=tf.nn.tanh, kernel_initializer='glorot_normal')) model.compile(optimizer="adam", loss="mse") initial_w = model.get_weights() errors = [] durations = [] N_u_sizes = [50, 200, 400, 1000, 2000]
# as prediction and uncertainty U_pred = np.mean(samples_mean, axis=1) U_pred = griddata(XT, U_pred.flatten(), (X, T), method='cubic') Sigma_pred = np.var(samples_mean, axis=1) Sigma_pred = griddata(XT, Sigma_pred.flatten(), (X, T), method='cubic') return U_pred, Sigma_pred # %% TRAINING THE MODEL # Getting the data path = os.path.join(eqnPath, "data", "burgers_shock.mat") x, t, X, T, Exact_u, X_star, u_star, X_u_train, u_train, \ X_f, ub, lb = prep_data(path, hp["N_i"], hp["N_b"], hp["N_f"], noise=hp["noise"], noise_is_gaussian=hp["noise_is_gaussian"]) # Creating the model logger = Logger(hp) pinn = BurgersInformedNN(hp, logger, X_f, ub, lb) # Defining the error function for the logger def error(): return 0.0 U_pred, _ = pinn.predict(X_star, X, T) return np.linalg.norm(Exact_u-U_pred, 2)/np.linalg.norm(Exact_u, 2)
from custom_lbfgs import lbfgs, Struct from burgersutil import prep_data, Logger, plot_ide_cont_results, appDataPath #%% PINN Model to benchmark # Creating the model and training from ide_cont_burgers import N_u, layers, tf_epochs, nt_epochs, u_pred, u_star, lambda_1_pred, lambda_2_pred print("Error PINN: ", np.linalg.norm(u_star - u_pred, 2) / np.linalg.norm(u_star, 2)) #%% GETTING THE DATA path = os.path.join(appDataPath, "burgers_shock.mat") x, t, X, T, Exact_u, X_star, u_star, \ X_u_train, u_train, ub, lb = prep_data(path, N_u, noise=0.0) lambdas_star = (1.0, 0.01 / np.pi) fig = plt.figure() ax = Axes3D(fig) ax.scatter(X_u_train[:, 0], X_u_train[:, 1], u_train) plt.show() #%% Plain NN Model model = tf.keras.Sequential() model.add(tf.keras.layers.InputLayer(input_shape=(layers[0], ))) model.add(tf.keras.layers.Lambda(lambda X: 2.0 * (X - lb) / (ub - lb) - 1.0)) for width in layers[1:]: model.add( tf.keras.layers.Dense(width, activation=tf.nn.tanh,
#%% TRAINING THE MODEL # Setup lb = np.array([-1.0]) ub = np.array([1.0]) idx_t_0 = 10 idx_t_1 = 90 nu = 0.01 / np.pi # Getting the data path = os.path.join(eqnPath, "data", "burgers_shock.mat") x, t, dt, \ Exact_u, x_0, u_0, x_1, x_star, u_star, \ IRK_weights, IRK_times = prep_data(path, N_n=hp["N_n"], q=hp["q"], lb=lb, ub=ub, noise=0.0, idx_t_0=idx_t_0, idx_t_1=idx_t_1) # Creating the model logger = Logger(hp) pinn = BurgersInformedNN(hp, logger, dt, x_1, lb, ub, nu, IRK_weights, IRK_times) # Defining the error function for the logger and training def error(): u_pred = pinn.predict(x_star) return np.linalg.norm(u_pred - u_star, 2) / np.linalg.norm(u_star, 2) logger.set_error_fn(error)
return U_0_star, U_1_star #%% TRAINING THE MODEL # Setup lb = np.array([-1.0]) ub = np.array([1.0]) idx_t_0 = 10 skip = 80 idx_t_1 = idx_t_0 + skip # Getting the data path = os.path.join(eqnPath, "data", "burgers_shock.mat") x_0, u_0, x_1, u_1, x_star, t_star, dt, q, \ Exact_u, IRK_alpha, IRK_beta = prep_data(path, N_0=hp["N_0"], N_1=hp["N_1"], lb=lb, ub=ub, noise=0.0, idx_t_0=idx_t_0, idx_t_1=idx_t_1) lambdas_star = (1.0, 0.01 / np.pi) # Setting the output layer dynamically hp["layers"][-1] = q # Creating the model logger = Logger(frequency=10) pinn = BurgersInformedNN(hp, logger, dt, lb, ub, q, IRK_alpha, IRK_beta) # Defining the error function and training def error(): l1, l2 = pinn.get_params(numpy=True) l1_star, l2_star = lambdas_star error_lambda_1 = np.abs(l1 - l1_star) / l1_star