# 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