def __init__(self, data, c_data, eqns, layers, Pec, Rey): # specs & flow properties self.Pec = Pec self.Rey = Rey # data [self.data, self.c_data, self.eqns] = [data, c_data, eqns] # physics "uninformed" neural networks self.net = neural_net(layers, data, USE_CUDA, device) self.net.load_state_dict(torch.load(name, map_location=device)) print("Previous state loaded.") if (USE_CUDA): self.net.to(device)
def __init__(self, data, c_data, eqns, layers, Pec, Rey): # specs & flow properties self.layers = layers self.Pec = Pec self.Rey = Rey # data [self.data, self.c_data, self.eqns] = [data, c_data, eqns] # dat manager util self.dm = dataManager(using_visdom, version) # physics "uninformed" neural networks self.net = neural_net(self.layers, data, USE_CUDA, device) #self.net.load_state_dict(torch.load("../Results/model_updating_v10.pth")) #print("loading v10") self.net.to(device)
def __init__(self, t_data, x_data, y_data, c_data, t_eqns, x_eqns, y_eqns, t_inlet, x_inlet, y_inlet, u_inlet, v_inlet, t_cyl, x_cyl, y_cyl, layers, batch_size, Pec, Rey): # specs self.layers = layers self.batch_size = batch_size # flow properties self.Pec = Pec self.Rey = Rey # data [self.t_data, self.x_data, self.y_data, self.c_data] = [t_data, x_data, y_data, c_data] [self.t_eqns, self.x_eqns, self.y_eqns] = [t_eqns, x_eqns, y_eqns] [self.t_inlet, self.x_inlet, self.y_inlet, self.u_inlet, self.v_inlet] = [t_inlet, x_inlet, y_inlet, u_inlet, v_inlet] [self.t_cyl, self.x_cyl, self.y_cyl] = [t_cyl, x_cyl, y_cyl] # placeholders [self.t_data_tf, self.x_data_tf, self.y_data_tf, self.c_data_tf ] = [tf.placeholder(tf.float32, shape=[None, 1]) for _ in range(4)] [self.t_eqns_tf, self.x_eqns_tf, self.y_eqns_tf ] = [tf.placeholder(tf.float32, shape=[None, 1]) for _ in range(3)] [ self.t_inlet_tf, self.x_inlet_tf, self.y_inlet_tf, self.u_inlet_tf, self.v_inlet_tf ] = [tf.placeholder(tf.float32, shape=[None, 1]) for _ in range(5)] [self.t_cyl_tf, self.x_cyl_tf, self.y_cyl_tf ] = [tf.placeholder(tf.float32, shape=[None, 1]) for _ in range(3)] # physics "uninformed" neural networks self.net_cuvp = neural_net(self.t_data, self.x_data, self.y_data, layers=self.layers) [ self.c_data_pred, self.u_data_pred, self.v_data_pred, self.p_data_pred ] = self.net_cuvp(self.t_data_tf, self.x_data_tf, self.y_data_tf) # physics "uninformed" neural networks (data at the inlet) [_, self.u_inlet_pred, self.v_inlet_pred, _] = self.net_cuvp(self.t_inlet_tf, self.x_inlet_tf, self.y_inlet_tf) # physics "uninformed" neural networks (data on the cylinder) [_, self.u_cyl_pred, self.v_cyl_pred, _] = self.net_cuvp(self.t_cyl_tf, self.x_cyl_tf, self.y_cyl_tf) # physics "informed" neural networks [ self.c_eqns_pred, self.u_eqns_pred, self.v_eqns_pred, self.p_eqns_pred ] = self.net_cuvp(self.t_eqns_tf, self.x_eqns_tf, self.y_eqns_tf) [ self.e1_eqns_pred, self.e2_eqns_pred, self.e3_eqns_pred, self.e4_eqns_pred ] = Navier_Stokes_2D(self.c_eqns_pred, self.u_eqns_pred, self.v_eqns_pred, self.p_eqns_pred, self.t_eqns_tf, self.x_eqns_tf, self.y_eqns_tf, self.Pec, self.Rey) # gradients required for the lift and drag forces [ self.u_x_eqns_pred, self.v_x_eqns_pred, self.u_y_eqns_pred, self.v_y_eqns_pred ] = Gradient_Velocity_2D(self.u_eqns_pred, self.v_eqns_pred, self.x_eqns_tf, self.y_eqns_tf) # loss self.loss = mean_squared_error(self.c_data_pred, self.c_data_tf) + \ mean_squared_error(self.u_inlet_pred, self.u_inlet_tf) + \ mean_squared_error(self.v_inlet_pred, self.v_inlet_tf) + \ mean_squared_error(self.u_cyl_pred, 0.0) + \ mean_squared_error(self.v_cyl_pred, 0.0) + \ mean_squared_error(self.e1_eqns_pred, 0.0) + \ mean_squared_error(self.e2_eqns_pred, 0.0) + \ mean_squared_error(self.e3_eqns_pred, 0.0) + \ mean_squared_error(self.e4_eqns_pred, 0.0) # optimizers self.learning_rate = tf.placeholder(tf.float32, shape=[]) self.optimizer = tf.train.AdamOptimizer( learning_rate=self.learning_rate) self.train_op = self.optimizer.minimize(self.loss) self.sess = tf_session()
def __init__(self, t_data, x_data, y_data, c_data, t_eqns, x_eqns, y_eqns, layers, batch_size, Pec, Rey): # specs self.layers = layers self.batch_size = batch_size # flow properties self.Pec = Pec self.Rey = Rey # data [self.t_data, self.x_data, self.y_data, self.c_data] = [t_data, x_data, y_data, c_data] [self.t_eqns, self.x_eqns, self.y_eqns] = [t_eqns, x_eqns, y_eqns] # placeholders [self.t_data_tf, self.x_data_tf, self.y_data_tf, self.c_data_tf ] = [tf.placeholder(tf.float32, shape=[None, 1]) for _ in range(4)] [self.t_eqns_tf, self.x_eqns_tf, self.y_eqns_tf ] = [tf.placeholder(tf.float32, shape=[None, 1]) for _ in range(3)] # physics "uninformed" neural networks self.net_cuvp = neural_net(self.t_data, self.x_data, self.y_data, layers=self.layers) [ self.c_data_pred, self.u_data_pred, self.v_data_pred, self.p_data_pred ] = self.net_cuvp(self.t_data_tf, self.x_data_tf, self.y_data_tf) # physics "informed" neural networks [ self.c_eqns_pred, self.u_eqns_pred, self.v_eqns_pred, self.p_eqns_pred ] = self.net_cuvp(self.t_eqns_tf, self.x_eqns_tf, self.y_eqns_tf) [ self.e1_eqns_pred, self.e2_eqns_pred, self.e3_eqns_pred, self.e4_eqns_pred ] = Navier_Stokes_2D(self.c_eqns_pred, self.u_eqns_pred, self.v_eqns_pred, self.p_eqns_pred, self.t_eqns_tf, self.x_eqns_tf, self.y_eqns_tf, self.Pec, self.Rey) [ self.eps11dot_eqns_pred, self.eps12dot_eqns_pred, self.eps22dot_eqns_pred ] = Strain_Rate_2D(self.u_eqns_pred, self.v_eqns_pred, self.x_eqns_tf, self.y_eqns_tf) # loss self.loss = mean_squared_error(self.c_data_pred, self.c_data_tf) + \ mean_squared_error(self.e1_eqns_pred, 0.0) + \ mean_squared_error(self.e2_eqns_pred, 0.0) + \ mean_squared_error(self.e3_eqns_pred, 0.0) + \ mean_squared_error(self.e4_eqns_pred, 0.0) # optimizers self.learning_rate = tf.placeholder(tf.float32, shape=[]) self.optimizer = tf.train.AdamOptimizer( learning_rate=self.learning_rate) self.train_op = self.optimizer.minimize(self.loss) self.sess = tf_session()
def __init__(self, t_data, x_data, y_data, z_data, c_data, t_eqns, x_eqns, y_eqns, z_eqns, layers, batch_size, Pec, Rey): # specs self.layers = layers self.batch_size = batch_size # # flow properties # self.Pec = Pec # self.Rey = Rey # flow properties self.Pec = tf.Variable(Pec, dtype=tf.float32, trainable=True) self.Rey = tf.Variable(Rey, dtype=tf.float32, trainable=True) # data [self.t_data, self.x_data, self.y_data, self.z_data, self.c_data] = [t_data, x_data, y_data, z_data, c_data] [self.t_eqns, self.x_eqns, self.y_eqns, self.z_eqns] = [t_eqns, x_eqns, y_eqns, z_eqns] # placeholders [ self.t_data_tf, self.x_data_tf, self.y_data_tf, self.z_data_tf, self.c_data_tf ] = [ tf.compat.v1.placeholder(tf.float32, shape=[None, 1]) for _ in range(5) ] [self.t_eqns_tf, self.x_eqns_tf, self.y_eqns_tf, self.z_eqns_tf] = [ tf.compat.v1.placeholder(tf.float32, shape=[None, 1]) for _ in range(4) ] # physics "uninformed" neural networks self.net_cuvwp = neural_net(self.t_data, self.x_data, self.y_data, self.z_data, layers=self.layers) [ self.c_data_pred, self.u_data_pred, self.v_data_pred, self.w_data_pred, self.p_data_pred ] = self.net_cuvwp(self.t_data_tf, self.x_data_tf, self.y_data_tf, self.z_data_tf) # physics "informed" neural networks [ self.c_eqns_pred, self.u_eqns_pred, self.v_eqns_pred, self.w_eqns_pred, self.p_eqns_pred ] = self.net_cuvwp(self.t_eqns_tf, self.x_eqns_tf, self.y_eqns_tf, self.z_eqns_tf) [ self.e1_eqns_pred, self.e2_eqns_pred, self.e3_eqns_pred, self.e4_eqns_pred, self.e5_eqns_pred ] = Navier_Stokes_3D(self.c_eqns_pred, self.u_eqns_pred, self.v_eqns_pred, self.w_eqns_pred, self.p_eqns_pred, self.t_eqns_tf, self.x_eqns_tf, self.y_eqns_tf, self.z_eqns_tf, self.Pec, self.Rey) # loss self.loss = mean_squared_error(self.c_data_pred, self.c_data_tf) + \ mean_squared_error(self.e1_eqns_pred, 0.0) + \ mean_squared_error(self.e2_eqns_pred, 0.0) + \ mean_squared_error(self.e3_eqns_pred, 0.0) + \ mean_squared_error(self.e4_eqns_pred, 0.0) + \ mean_squared_error(self.e5_eqns_pred, 0.0) # optimizers self.learning_rate = tf.compat.v1.placeholder(tf.float32, shape=[]) self.optimizer = tf.compat.v1.train.AdamOptimizer( learning_rate=self.learning_rate) self.train_op = self.optimizer.minimize(self.loss) self.sess = tf_session()
def __init__(self, t_data, S_data, t_eqns, layers): self.D = S_data.shape[1] self.t_min = t_data.min(0) self.t_max = t_data.max(0) self.S_scale = tf.Variable(S_data.std(0), dtype=tf.float32, trainable=False) # data on all the species (only some are used as input) self.t_data, self.S_data = t_data, S_data self.t_eqns = t_eqns # layers self.layers = layers # self.J0 = tf.Variable(2.5, dtype=tf.float32, trainable=False) # self.k1 = tf.Variable(100.0, dtype=tf.float32, trainable=False) # self.k2 = tf.Variable(6.0, dtype=tf.float32, trainable=False) # self.k3 = tf.Variable(16.0, dtype=tf.float32, trainable=False) # self.k4 = tf.Variable(100.0, dtype=tf.float32, trainable=False) # self.k5 = tf.Variable(1.28, dtype=tf.float32, trainable=False) # self.k6 = tf.Variable(12.0, dtype=tf.float32, trainable=False) # self.k = tf.Variable(1.8, dtype=tf.float32, trainable=False) # self.kappa = tf.Variable(13.0, dtype=tf.float32, trainable=False) # self.q = tf.Variable(4.0, dtype=tf.float32, trainable=False) # self.K1 = tf.Variable(0.52, dtype=tf.float32, trainable=False) # self.psi = tf.Variable(0.1, dtype=tf.float32, trainable=False) # self.N = tf.Variable(1.0, dtype=tf.float32, trainable=False) # self.A = tf.Variable(4.0, dtype=tf.float32, trainable=False) self.logJ0 = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logk1 = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logk2 = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logk3 = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logk4 = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logk5 = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logk6 = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logk = tf.Variable(1.0, dtype=tf.float32, trainable=True) self.logkappa = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logq = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logK1 = tf.Variable(1.0, dtype=tf.float32, trainable=True) self.logpsi = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logN = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logA = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.var_list_eqns = [ self.logJ0, self.logk1, self.logk2, self.logk3, self.logk4, self.logk5, self.logk6, self.logk, self.logkappa, self.logq, self.logK1, self.logpsi, self.logN, self.logA ] self.J0 = tf.exp(self.logJ0) self.k1 = tf.exp(self.logk1) self.k2 = tf.exp(self.logk2) self.k3 = tf.exp(self.logk3) self.k4 = tf.exp(self.logk4) self.k5 = tf.exp(self.logk5) self.k6 = tf.exp(self.logk6) self.k = tf.exp(self.logk) self.kappa = tf.exp(self.logkappa) self.q = tf.exp(self.logq) self.K1 = tf.exp(self.logK1) self.psi = tf.exp(self.logpsi) self.N = tf.exp(self.logN) self.A = tf.exp(self.logA) # placeholders for data self.t_data_tf = tf.placeholder(tf.float32, shape=[None, 1]) self.S_data_tf = tf.placeholder(tf.float32, shape=[None, self.D]) self.t_eqns_tf = tf.placeholder(tf.float32, shape=[None, 1]) self.learning_rate = tf.placeholder(tf.float32, shape=[]) # physics uninformed neural networks self.net_sysbio = neural_net(layers=self.layers) self.H_data = 2.0 * (self.t_data_tf - self.t_min) / (self.t_max - self.t_min) - 1.0 self.S_data_pred = self.S_data[0, :] + self.S_scale * ( self.H_data + 1.0) * self.net_sysbio(self.H_data) # physics informed neural networks self.H_eqns = 2.0 * (self.t_eqns_tf - self.t_min) / (self.t_max - self.t_min) - 1.0 self.S_eqns_pred = self.S_data[0, :] + self.S_scale * ( self.H_eqns + 1.0) * self.net_sysbio(self.H_eqns) self.E_eqns_pred = self.SysODE(self.S_eqns_pred, self.t_eqns_tf) # self.S_scale = 0.9*self.S_scale + 0.1*tf.math.reduce_std(self.S_eqns_pred, 0) # scale_list = tf.unstack(self.S_scale) # scale_list[4:6] = self.S_data.std(0)[4:6] # self.S_scale = tf.stack(scale_list) # loss self.loss_data = mean_squared_error( self.S_data_tf[:, 4:6] / self.S_scale[4:6], self.S_data_pred[:, 4:6] / self.S_scale[4:6]) self.loss_eqns = mean_squared_error(0.0, self.E_eqns_pred / self.S_scale) self.loss_auxl = mean_squared_error( self.S_data_tf[-1, :] / self.S_scale[:], self.S_data_pred[-1, :] / self.S_scale[:]) self.loss = 0.95 * self.loss_data + 0.05 * self.loss_eqns + 0.05 * self.loss_auxl # optimizers self.optimizer = tf.train.AdamOptimizer( learning_rate=self.learning_rate) self.optimizer_para = tf.train.AdamOptimizer(learning_rate=0.001) self.train_op = self.optimizer.minimize(self.loss, var_list=[ self.net_sysbio.weights, self.net_sysbio.biases, self.net_sysbio.gammas ]) self.trainpara_op = self.optimizer_para.minimize( self.loss, var_list=self.var_list_eqns) self.sess = tf_session()
def __init__(self, t_data, S_data, t_eqns, layers, meal_tq): self.D = S_data.shape[1] self.t_min = t_data.min(0) self.t_max = t_data.max(0) # self.S_scale = tf.Variable(np.array(self.D*[1.0]), dtype=tf.float32, trainable=False) self.S_scale = S_data.std(0) # data on all the species (only some are used as input) self.t_data, self.S_data = t_data, S_data self.t_eqns = t_eqns # layers self.layers = layers self.mt = 2.0 * (meal_tq[0] - self.t_min) / (self.t_max - self.t_min) - 1.0 self.mq = meal_tq[1] # self.k = tf.Variable(1.0/120.0, dtype=tf.float32, trainable=False) self.Rm = tf.Variable(209.0 / 100.0, dtype=tf.float32, trainable=False) self.Vg = tf.Variable(10.0, dtype=tf.float32, trainable=False) self.C1 = tf.Variable(300.0 / 100.0, dtype=tf.float32, trainable=False) self.a1 = tf.Variable(6.6, dtype=tf.float32, trainable=False) # self.Ub = tf.Variable(72.0/100.0, dtype=tf.float32, trainable=False) # self.C2 = tf.Variable(144.0/100.0, dtype=tf.float32, trainable=False) # self.U0 = tf.Variable(4.0/100.0, dtype=tf.float32, trainable=False) # self.Um = tf.Variable(90.0/100.0, dtype=tf.float32, trainable=False) # self.C3 = tf.Variable(100.0/100.0, dtype=tf.float32, trainable=False) # self.C4 = tf.Variable(80.0/100.0, dtype=tf.float32, trainable=False) self.Vi = tf.Variable(11.0, dtype=tf.float32, trainable=False) self.E = tf.Variable(0.2, dtype=tf.float32, trainable=False) self.ti = tf.Variable(100.0, dtype=tf.float32, trainable=False) # self.beta = tf.Variable(1.772, dtype=tf.float32, trainable=False) # self.Rg = tf.Variable(180.0/100.0, dtype=tf.float32, trainable=False) # self.alpha = tf.Variable(7.5, dtype=tf.float32, trainable=False) self.Vp = tf.Variable(3.0, dtype=tf.float32, trainable=False) # self.C5 = tf.Variable(26.0/100.0, dtype=tf.float32, trainable=False) self.tp = tf.Variable(6.0, dtype=tf.float32, trainable=False) # self.td = tf.Variable(12.0, dtype=tf.float32, trainable=False) self.logk = tf.Variable(-6.0, dtype=tf.float32, trainable=True) # self.logRm = tf.Variable(0.0, dtype=tf.float32, trainable=True) # self.logVg = tf.Variable(0.0, dtype=tf.float32, trainable=True) # self.logC1 = tf.Variable(0.0, dtype=tf.float32, trainable=True) # self.loga1 = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logUb = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logC2 = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logU0 = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logUm = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logC3 = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logC4 = tf.Variable(0.0, dtype=tf.float32, trainable=True) # self.logVi = tf.Variable(0.0, dtype=tf.float32, trainable=True) # self.logE = tf.Variable(0.0, dtype=tf.float32, trainable=True) # self.logti = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logbeta = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logRg = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logalpha = tf.Variable(0.0, dtype=tf.float32, trainable=True) # self.logVp = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logC5 = tf.Variable(0.0, dtype=tf.float32, trainable=True) # self.logtp = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.logtd = tf.Variable(0.0, dtype=tf.float32, trainable=True) self.var_list_eqns = [ self.logk, self.logUb, self.logC2, self.logU0, self.logUm, self.logC3, self.logC4, self.logbeta, self.logRg, self.logalpha, self.logC5, self.logtd ] self.k = tf.exp(self.logk) # self.Rm = tf.exp(self.logRm) # self.Vg = tf.exp(self.logVg) # self.C1 = tf.exp(self.logC1) # self.a1 = tf.exp(self.loga1) self.Ub = tf.exp(self.logUb) self.C2 = tf.exp(self.logC2) self.U0 = tf.exp(self.logU0) self.Um = tf.exp(self.logUm) self.C3 = tf.exp(self.logC3) self.C4 = tf.exp(self.logC4) # self.Vi = tf.exp(self.logVi) # self.E = tf.exp(self.logE) # self.ti = tf.exp(self.logti) self.beta = tf.exp(self.logbeta) self.Rg = tf.exp(self.logRg) self.alpha = tf.exp(self.logalpha) # self.Vp = tf.exp(self.logVp) self.C5 = tf.exp(self.logC5) # self.tp = tf.exp(self.logtp) self.td = tf.exp(self.logtd) # placeholders for data self.t_data_tf = tf.placeholder(tf.float32, shape=[None, 1]) self.S_data_tf = tf.placeholder(tf.float32, shape=[None, self.D]) self.t_eqns_tf = tf.placeholder(tf.float32, shape=[None, 1]) self.mt_tf = tf.placeholder(tf.float32, shape=[None, self.mt.shape[1]]) self.mq_tf = tf.placeholder(tf.float32, shape=[None, self.mq.shape[1]]) self.learning_rate = tf.placeholder(tf.float32, shape=[]) # physics uninformed neural networks self.net_sysbio = neural_net(layers=self.layers) self.H_data = 2.0 * (self.t_data_tf - self.t_min) / (self.t_max - self.t_min) - 1.0 self.S_data_pred = self.S_data[0, :] + self.S_scale * ( self.H_data + 1.0) * self.net_sysbio(self.H_data) # physics informed neural networks self.H_eqns = 2.0 * (self.t_eqns_tf - self.t_min) / (self.t_max - self.t_min) - 1.0 self.S_eqns_pred = self.S_data[0, :] + self.S_scale * ( self.H_eqns + 1.0) * self.net_sysbio(self.H_eqns) self.E_eqns_pred, self.IG = self.SysODE(self.S_eqns_pred, self.t_eqns_tf, self.H_eqns, self.mt_tf, self.mq_tf) # Adaptive S_scale # self.S_scale = 0.9*self.S_scale + 0.1*tf.math.reduce_std(self.S_eqns_pred, 0) # scale_list = tf.unstack(self.S_scale) # scale_list[2] = self.S_data.std(0)[2] # self.S_scale = tf.stack(scale_list) # loss self.loss_data = mean_squared_error( self.S_data_tf[:, 2:3] / self.S_scale[2:3], self.S_data_pred[:, 2:3] / self.S_scale[2:3]) self.loss_eqns = mean_squared_error(0.0, self.E_eqns_pred / self.S_scale) self.loss_auxl = mean_squared_error( self.S_data_tf[-1, :] / self.S_scale, self.S_data_pred[-1, :] / self.S_scale) self.loss = 0.99 * self.loss_data + 0.01 * self.loss_eqns + 0.01 * self.loss_auxl # optimizers self.optimizer = tf.train.AdamOptimizer( learning_rate=self.learning_rate) self.optimizer_para = tf.train.AdamOptimizer(learning_rate=0.001) self.train_op = self.optimizer.minimize(self.loss, var_list=[ self.net_sysbio.weights, self.net_sysbio.biases, self.net_sysbio.gammas ]) self.trainpara_op = self.optimizer_para.minimize( self.loss, var_list=self.var_list_eqns) self.sess = tf_session()
def __init__(self, t_data, x_data, y_data, c_data, u_data, v_data, p_data, x_ref, y_ref, t_eqns, x_eqns, y_eqns, layers, batch_size, Pec, Rey): # specs self.layers = layers self.batch_size = batch_size # flow properties self.Pec = Pec self.Rey = Rey # data [self.t_data, self.x_data, self.y_data, self.c_data] = [t_data, x_data, y_data, c_data] [self.u_data, self.v_data, self.p_data] = [u_data, v_data, p_data] [self.x_ref, self.y_ref] = [x_ref, y_ref] [self.t_eqns, self.x_eqns, self.y_eqns] = [t_eqns, x_eqns, y_eqns] # placeholders [self.t_data_tf, self.x_data_tf, self.y_data_tf, self.c_data_tf ] = [tf.placeholder(tf.float32, shape=[None, 1]) for _ in range(4)] [self.u_data_tf, self.v_data_tf, self.p_data_tf ] = [tf.placeholder(tf.float32, shape=[None, 1]) for _ in range(3)] [self.t_eqns_tf, self.x_eqns_tf, self.y_eqns_tf ] = [tf.placeholder(tf.float32, shape=[None, 1]) for _ in range(3)] # physics "uninformed" neural networks self.net_cuvp = neural_net(self.t_data, self.x_data, self.y_data, layers=self.layers) [ self.c_data_pred, self.u_data_pred, self.v_data_pred, self.p_data_pred ] = self.net_cuvp(self.t_data_tf, self.x_data_tf, self.y_data_tf) [_, _, _, self.p_ref_pred] = self.net_cuvp(self.t_data_tf, self.x_data_tf * 0.0 + self.x_ref, self.y_data_tf * 0.0 + self.y_ref) # physics "informed" neural networks [ self.c_eqns_pred, self.u_eqns_pred, self.v_eqns_pred, self.p_eqns_pred ] = self.net_cuvp(self.t_eqns_tf, self.x_eqns_tf, self.y_eqns_tf) [ self.e1_eqns_pred, self.e2_eqns_pred, self.e3_eqns_pred, self.e4_eqns_pred ] = Navier_Stokes_2D(self.c_eqns_pred, self.u_eqns_pred, self.v_eqns_pred, self.p_eqns_pred, self.t_eqns_tf, self.x_eqns_tf, self.y_eqns_tf, self.Pec, self.Rey) # loss self.loss_c = mean_squared_error(self.c_data_pred, self.c_data_tf) self.loss_e1 = mean_squared_error(self.e1_eqns_pred, 0.0) self.loss_e2 = mean_squared_error(self.e2_eqns_pred, 0.0) self.loss_e3 = mean_squared_error(self.e3_eqns_pred, 0.0) self.loss_e4 = mean_squared_error(self.e4_eqns_pred, 0.0) self.loss = self.loss_c + \ self.loss_e1 + self.loss_e2 + \ self.loss_e3 + self.loss_e4 # relative L2 errors self.error_c = relative_error(self.c_data_pred, self.c_data_tf) self.error_u = relative_error(self.u_data_pred, self.u_data_tf) self.error_v = relative_error(self.v_data_pred, self.v_data_tf) self.error_p = relative_error(self.p_data_pred - self.p_ref_pred, self.p_data_tf) # convergence plots self.loss_history = [] self.loss_c_history = [] self.loss_e1_history = [] self.loss_e2_history = [] self.loss_e3_history = [] self.loss_e4_history = [] self.error_c_history = [] self.error_u_history = [] self.error_v_history = [] self.error_p_history = [] # optimizers self.learning_rate = tf.placeholder(tf.float32, shape=[]) self.optimizer = tf.train.AdamOptimizer( learning_rate=self.learning_rate) self.train_op = self.optimizer.minimize(self.loss) self.sess = tf_session()