def get_error(self, T_star, X_star, Y_star, C_star, U_star, V_star, P_star, it): snap = np.array([random.randint(0, 200)]) t_test = T_star[:, snap] x_test = X_star[:, snap] y_test = Y_star[:, snap] c_test = C_star[:, snap] u_test = U_star[:, snap] v_test = V_star[:, snap] p_test = P_star[:, snap] # Prediction c_pred, u_pred, v_pred, p_pred = self.predict(t_test, x_test, y_test) # Error error_c = relative_error(c_pred, torch.from_numpy(c_test).float()) error_u = relative_error(u_pred, torch.from_numpy(u_test).float()) error_v = relative_error(v_pred, torch.from_numpy(v_test).float()) error_p = relative_error( p_pred - torch.mean(p_pred), torch.from_numpy(p_test - np.mean(p_test)).float()) self.dm.update_error(error_c, error_u, error_v, error_p, it) print('Error: c: %e, u: %e, v: %e, p: %e' % (error_c, error_u, error_v, error_p))
# Test Data snap = np.array([100]) t_test = T_star[:, snap] x_test = X_star[:, snap] y_test = Y_star[:, snap] c_test = C_star[:, snap] u_test = U_star[:, snap] v_test = V_star[:, snap] p_test = P_star[:, snap] # Prediction c_pred, u_pred, v_pred, p_pred = model.predict(t_test, x_test, y_test) # Error error_c = relative_error(c_pred, c_test) error_u = relative_error(u_pred, u_test) error_v = relative_error(v_pred, v_test) error_p = relative_error(p_pred - np.mean(p_pred), p_test - np.mean(p_test)) print('Error c: %e' % (error_c)) print('Error u: %e' % (error_u)) print('Error v: %e' % (error_v)) print('Error p: %e' % (error_p)) ################# Save Data ########################### C_pred = 0 * C_star U_pred = 0 * U_star V_pred = 0 * V_star
def main(): batch_size = 10000 layers = [3] + 10 * [4 * 50] + [4] # Load Data data = scipy.io.loadmat('../Data/Cylinder2D_flower.mat') t_star = data['t_star'] # T x 1 x_star = data['x_star'] # N x 1 y_star = data['y_star'] # N x 1 T = t_star.shape[0] N = x_star.shape[0] U_star = data['U_star'] # N x T V_star = data['V_star'] # N x T P_star = data['P_star'] # N x T C_star = data['C_star'] # N x T # Rearrange Data T_star = np.tile(t_star, (1, N)).T # N x T X_star = np.tile(x_star, (1, T)) # N x T Y_star = np.tile(y_star, (1, T)) # N x T ###################################################################### ######################## Training Data ############################### ###################################################################### T_data = 101 N_data = 15000 idx_t = np.concatenate([ np.array([0]), np.random.choice(T - 2, T_data - 2, replace=False) + 1, np.array([T - 1]) ]) idx_x = np.random.choice(N, N_data, replace=False) t_data = T_star[:, idx_t][idx_x, :].flatten()[:, None] x_data = X_star[:, idx_t][idx_x, :].flatten()[:, None] y_data = Y_star[:, idx_t][idx_x, :].flatten()[:, None] c_data = C_star[:, idx_t][idx_x, :].flatten()[:, None] T_eqns = T N_eqns = N idx_t = np.concatenate([ np.array([0]), np.random.choice(T - 2, T_eqns - 2, replace=False) + 1, np.array([T - 1]) ]) idx_x = np.random.choice(N, N_eqns, replace=False) t_eqns = T_star[:, idx_t][idx_x, :].flatten()[:, None] x_eqns = X_star[:, idx_t][idx_x, :].flatten()[:, None] y_eqns = Y_star[:, idx_t][idx_x, :].flatten()[:, None] # add noise noise = float(sys.argv[1]) c_data = c_data + noise * np.std(c_data) * np.random.randn( c_data.shape[0], c_data.shape[1]) # Training model = HFM(t_data, x_data, y_data, c_data, t_eqns, x_eqns, y_eqns, layers, batch_size, Pec=100, Rey=100) model.train(total_time=40, learning_rate=1e-3) # Test Data snap = np.array([100]) t_test = T_star[:, snap] x_test = X_star[:, snap] y_test = Y_star[:, snap] c_test = C_star[:, snap] u_test = U_star[:, snap] v_test = V_star[:, snap] p_test = P_star[:, snap] # Prediction c_pred, u_pred, v_pred, p_pred = model.predict(t_test, x_test, y_test) # Error error_c = relative_error(c_pred, c_test) error_u = relative_error(u_pred, u_test) error_v = relative_error(v_pred, v_test) error_p = relative_error(p_pred - np.mean(p_pred), p_test - np.mean(p_test)) print('Error c: %e' % (error_c)) print('Error u: %e' % (error_u)) print('Error v: %e' % (error_v)) print('Error p: %e' % (error_p)) ################# Save Data ########################### C_pred = 0 * C_star U_pred = 0 * U_star V_pred = 0 * V_star P_pred = 0 * P_star for snap in range(0, t_star.shape[0]): t_test = T_star[:, snap:snap + 1] x_test = X_star[:, snap:snap + 1] y_test = Y_star[:, snap:snap + 1] c_test = C_star[:, snap:snap + 1] u_test = U_star[:, snap:snap + 1] v_test = V_star[:, snap:snap + 1] p_test = P_star[:, snap:snap + 1] # Prediction c_pred, u_pred, v_pred, p_pred = model.predict(t_test, x_test, y_test) C_pred[:, snap:snap + 1] = c_pred U_pred[:, snap:snap + 1] = u_pred V_pred[:, snap:snap + 1] = v_pred P_pred[:, snap:snap + 1] = p_pred # Error error_c = relative_error(c_pred, c_test) error_u = relative_error(u_pred, u_test) error_v = relative_error(v_pred, v_test) error_p = relative_error(p_pred - np.mean(p_pred), p_test - np.mean(p_test)) print('Error c: %e' % (error_c)) print('Error u: %e' % (error_u)) print('Error v: %e' % (error_v)) print('Error p: %e' % (error_p)) scipy.io.savemat( '../Results/Cylinder2D_flower_results_%.2f_noise_%s.mat' % (noise, time.strftime('%d_%m_%Y')), { 'C_pred': C_pred, 'U_pred': U_pred, 'V_pred': V_pred, 'P_pred': P_pred })
def main(): batch_size = 10000 layers = [3] + 10 * [4 * 50] + [4] workdir = os.getcwd() test_info = '0' parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument("--T", type=int, default=201) parser.add_argument("--N", type=int, default=30189) parser.add_argument("--mode", type=str, default='train') parser.add_argument("--test_info", type=str, default='1') parser.add_argument("--model_path", type=str, default='/'.join(workdir.split('/')[:-1]) + '/Model/test_{}/'.format(test_info)) parser.add_argument("--data", type=str, default='../Data/Cylinder2D.mat') parser.add_argument("--time", type=int, default=60) parser.add_argument("--lr", type=float, default=1e-3) args = parser.parse_args() T_data = args.T N_data = args.N Running_Mode = args.mode model_path = args.model_path if Running_Mode == 'input': if not os.path.exists(model_path): raise EnvironmentError('Model path not exist, Please check!') datafile = args.data total_time = args.time learning_rate = args.lr origin_fname = (datafile.split('/')[-1]).split('.')[0] test_info = args.test_info # Load Data data = scipy.io.loadmat(datafile) t_star = data['t_star'] # T x 1 x_star = data['x_star'] # N x 1 y_star = data['y_star'] # N x 1 T = t_star.shape[0] N = x_star.shape[0] U_star = data['U_star'] # N x T V_star = data['V_star'] # N x T P_star = data['P_star'] # N x T C_star = data['C_star'] # N x T # Rearrange Data T_star = np.tile(t_star, (1, N)).T # N x T X_star = np.tile(x_star, (1, T)) # N x T Y_star = np.tile(y_star, (1, T)) # N x T # T_data = int(sys.argv[1]) # N_data = int(sys.argv[2]) # Running_Mode=sys.argv[3] if Running_Mode not in ['train', 'input']: raise ValueError('Wrong Running mode, please check!') ###################################################################### ######################## Training Data ############################### ###################################################################### idx_t = np.concatenate([ np.array([0]), np.random.choice(T - 2, T_data - 2, replace=False) + 1, np.array([T - 1]) ]) idx_x = np.random.choice(N, N_data, replace=False) t_data = T_star[:, idx_t][idx_x, :].flatten()[:, None] x_data = X_star[:, idx_t][idx_x, :].flatten()[:, None] y_data = Y_star[:, idx_t][idx_x, :].flatten()[:, None] c_data = C_star[:, idx_t][idx_x, :].flatten()[:, None] T_eqns = T N_eqns = N idx_t = np.concatenate([ np.array([0]), np.random.choice(T - 2, T_eqns - 2, replace=False) + 1, np.array([T - 1]) ]) idx_x = np.random.choice(N, N_eqns, replace=False) t_eqns = T_star[:, idx_t][idx_x, :].flatten()[:, None] x_eqns = X_star[:, idx_t][idx_x, :].flatten()[:, None] y_eqns = Y_star[:, idx_t][idx_x, :].flatten()[:, None] # Training model = C2P(t_data, x_data, y_data, c_data, t_eqns, x_eqns, y_eqns, layers, batch_size, Pec=100, Rey=100) print('-----Model Class set Completed-----') # Training parameters if Running_Mode == 'train': print('Working on [TRAIN] mode:\nTraning time:{}h.................'. format(Running_Mode, round(total_time / 3600.0))) model.train(total_time=total_time, learning_rate=learning_rate, test_info=test_info) #Weighs output if Running_Mode != 'input': print('Working on [{}] mode:Weighs saving.............') fname = 'test_model.ckpt' filepath = '/'.join( workdir.split('/')[:-1]) + '/Model/test_{}'.format(test_info) file = filepath + '/' + fname model.w_extract(save_file=file) tr_record = '/home/ljj/PycharmWork/CtoP/Results/tr_record.txt' with open(tr_record, "a") as f: f.write( 'Model Saved:{}.\n'.format(file) + '---------------------------------------------------------\n' + ' \n') print( '--------------------------Model Train Completed--------------------------' ) # Weighs input if Running_Mode == 'input': print('Working on [INPUT] mode:Weighs loading.............') model.w_input(model_path=model_path) # Test Data snap = np.array([100]) t_test = T_star[:, snap] x_test = X_star[:, snap] y_test = Y_star[:, snap] c_test = C_star[:, snap] u_test = U_star[:, snap] v_test = V_star[:, snap] p_test = P_star[:, snap] # Prediction c_pred, u_pred, v_pred, p_pred = model.predict(t_test, x_test, y_test) # Error error_c = relative_error(c_pred, c_test) error_u = relative_error(u_pred, u_test) error_v = relative_error(v_pred, v_test) error_p = relative_error(p_pred - np.mean(p_pred), p_test - np.mean(p_test)) print('Error c: %e' % (error_c)) print('Error u: %e' % (error_u)) print('Error v: %e' % (error_v)) print('Error p: %e' % (error_p)) ################# Save Data ########################### C_pred = 0 * C_star U_pred = 0 * U_star V_pred = 0 * V_star P_pred = 0 * P_star L2c = 0 * C_star L2u = 0 * U_star L2v = 0 * V_star L2p = 0 * P_star for snap in range(0, t_star.shape[0]): t_test = T_star[:, snap:snap + 1] x_test = X_star[:, snap:snap + 1] y_test = Y_star[:, snap:snap + 1] c_test = C_star[:, snap:snap + 1] u_test = U_star[:, snap:snap + 1] v_test = V_star[:, snap:snap + 1] p_test = P_star[:, snap:snap + 1] # Prediction c_pred, u_pred, v_pred, p_pred = model.predict(t_test, x_test, y_test) C_pred[:, snap:snap + 1] = c_pred U_pred[:, snap:snap + 1] = u_pred V_pred[:, snap:snap + 1] = v_pred P_pred[:, snap:snap + 1] = p_pred # Error error_c = relative_error(c_pred, c_test) error_u = relative_error(u_pred, u_test) error_v = relative_error(v_pred, v_test) error_p = relative_error(p_pred - np.mean(p_pred), p_test - np.mean(p_test)) L2c[:, snap:snap + 1] = error_c L2u[:, snap:snap + 1] = error_u L2v[:, snap:snap + 1] = error_v L2p[:, snap:snap + 1] = error_p # print('Error c: %e' % (error_c)) # print('Error u: %e' % (error_u)) # print('Error v: %e' % (error_v)) # print('Error p: %e' % (error_p)) savemat_path = '/'.join(workdir.split('/')[:-1]) + '/Results' if not os.path.exists(savemat_path): os.makedirs(savemat_path) savemat_name = 'C2P_result_{}_{}_test{}.mat'.format( origin_fname, Running_Mode, test_info) savefile = savemat_path + '/' + savemat_name scipy.io.savemat( savefile, { 'C_pred': C_pred, 'U_pred': U_pred, 'V_pred': V_pred, 'P_pred': P_pred, 'Error c': L2c, 'Error u': L2u, 'Error v': L2v, 'Error p': L2p }) print('---------------Mission accomplished:{}.-----------------------'. format(savemat_name))
sx_test = Sx_star[:, snap] sy_test = Sy_star[:, snap] sz_test = Sz_star[:, snap] # Prediction c_pred, u_pred, v_pred, w_pred, p_pred = model.predict( t_test, x_test, y_test, z_test) # Shear sx_pred, sy_pred, sz_pred = model.predict_shear(t_test[0] + 0.0 * xb_star, xb_star, yb_star, zb_star, nx_star, ny_star, nz_star) # Error error_c = relative_error(c_pred, c_test) error_u = relative_error(u_pred, u_test) error_v = relative_error(v_pred, v_test) error_w = relative_error(w_pred, w_test) error_p = relative_error(p_pred - np.mean(p_pred), p_test - np.mean(p_test)) print('Error c: %e' % (error_c)) print('Error u: %e' % (error_u)) print('Error v: %e' % (error_v)) print('Error w: %e' % (error_w)) print('Error p: %e' % (error_p)) sys.stdout.flush() # Error error_sx = relative_error(sx_pred, sx_test)
c_test = C_star[:, snap:snap + 1] u_test = U_star[:, snap:snap + 1] v_test = V_star[:, snap:snap + 1] p_test = P_star[:, snap:snap + 1] # Prediction c_pred, u_pred, v_pred, p_pred = model.predict(t_test, x_test, y_test) C_pred[:, snap:snap + 1] = c_pred.detach().numpy() U_pred[:, snap:snap + 1] = u_pred.detach().numpy() V_pred[:, snap:snap + 1] = v_pred.detach().numpy() P_pred[:, snap:snap + 1] = p_pred.detach().numpy() # Error error_c = relative_error(c_pred, torch.from_numpy(c_test).float()) error_u = relative_error(u_pred, torch.from_numpy(u_test).float()) error_v = relative_error(v_pred, torch.from_numpy(v_test).float()) error_p = relative_error( p_pred - torch.mean(p_pred), torch.from_numpy(p_test - np.mean(p_test)).float()) print('Error: c: %e, u: %e, v: %e, p: %e' % (error_c, error_u, error_v, error_p)) scipy.io.savemat( ('../Results/Cylinder2D_flower_results_%d_%d_%s_' + version + '.mat') % (T_data, N_data, time.strftime('%d_%m_%Y')), { 'C_pred': C_pred, 'U_pred': U_pred, 'V_pred': V_pred,
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()
# Test Data snap = np.array([100]) t_test = T_star[:, snap] x_test = X_star[:, snap] y_test = Y_star[:, snap] c_test = C_star[:, snap] u_test = U_star[:, snap] v_test = V_star[:, snap] p_test = P_star[:, snap] # Prediction c_pred, u_pred, v_pred, p_pred = model.predict(t_test, x_test, y_test) # Error error_c = relative_error(c_pred, c_test) error_u = relative_error(u_pred, u_test) error_v = relative_error(v_pred, v_test) error_p = relative_error(p_pred - np.mean(p_pred, axis=0, keepdims=True), p_test - np.mean(p_test, axis=0, keepdims=True)) print('Error c: %e' % (error_c)) print('Error u: %e' % (error_u)) print('Error v: %e' % (error_v)) print('Error p: %e' % (error_p)) ################# Save Data ########################### C_pred = 0 * C_star U_pred = 0 * U_star V_pred = 0 * V_star