def analize(XX, yy): y_pred = regr.predict(XX) # orig_y_true = scaler.inverse_transform(yy) # orig_y_pred = scaler.inverse_transform(y_pred) plot_result(yy, y_pred) full_report(yy, y_pred)
def analzie(data_set): ## Select training example y_true = data_set[:, -1, -1] predictions = lstm_model.predict(data_set[:, :, :-1]) y_pred = predictions[:, -1, -1] full_report(y_true, y_pred) plot_result(y_true, y_pred)
def analzie(data_set, save=False): ## Select training example y_true = data_set[:, -1, -1] predictions = lstm_model.predict(data_set[:, :, :-1]) y_pred = predictions[:, -1, -1] if save: np.save('lstm', y_pred) full_report(y_true, y_pred) plot_result(y_true, y_pred)
def analzie(data_loader): ## Select training example y_pred = [] y_true = [] for batch in data_loader: x = batch[:, :, :-1] y = batch[:, -1, -1] with torch.no_grad(): netout = net(x) true = y.cpu().numpy() y_true.extend(true) pred = netout[:, -1, -1] pred = pred.cpu().numpy() # print(pred) y_pred.extend(pred) y_true = np.array(y_true) y_pred = np.array(y_pred) # orig_y_true = scaler.inverse_transform(y_true) # orig_y_pred = scaler.inverse_transform(y_pred) full_report(y_true, y_pred) plot_result(y_true, y_pred)
hidden_layers = [width] * depth new_dir = "{}_{}_{}/N={}/{}_{}/".format(lower_bound, upper_bound, num_element, N, depth, width) dump_dir = working_dir + new_dir if not os.path.exists(dump_dir): os.makedirs(dump_dir) shutil.copy(working_dir + "paras.txt", dump_dir) model = CBSolutionNN(N, pivot, hidden_layers) start_time = time.time() epoch, loss_history = NNUtil.train(model, max_epoch) elapsed = time.time() - start_time print('Training time: %.4f' % elapsed) x_test, u_pred, u_truth = NNUtil.mnn_predict(model, num_tested_per_element) error_u = np.sqrt(np.square(u_pred - u_truth).mean()) print('Error u: %e' % error_u) prediction = np.hstack((u_truth, u_pred)) np.savetxt(dump_dir + 'result.csv', X=prediction, header="truth,prediction", delimiter=',') util.plot_result(epoch, loss_history, x_test, u_truth, u_pred, dump_dir, error_u)
for i in range(N_elem): tmp_data = np.zeros((N_pred, 1)) tmp_data[:, 0] = np.linspace(domain[i], domain[i + 1], N_pred) data_in.append(tmp_data) Soln = the_DNN.predict(data_in) A_in_data = np.concatenate(data_in, 0) # shape: (N_elem*N_pred, 1) pred_in_data = np.reshape(A_in_data, (N_elem * N_pred, )) A_soln = np.concatenate(Soln, 0) # shape: (N_elem*N_pred, 1) Soln_flat = np.reshape(A_soln, (N_elem * N_pred, )) Exact_soln = the_anal_soln(A_in_data) Exact_soln_flat = np.reshape(Exact_soln, (N_elem * N_pred, )) error_u = np.sqrt(np.square(Soln_flat - Exact_soln_flat).mean()) loss_history = np.log10(history.history['loss']) epoch = range(len(loss_history)) with open(dump_dir + "paras.txt", 'w') as writer: writer.writelines("N={}\ndepth={}\nwidth={}\nc={}\n".format( N_elem, depth, width, Ck_cont)) writer.writelines("max_epoch={}\nnum_tested_per_element={}\n".format( max_epoch, N_pred)) writer.writelines("%.2f\t" % point for point in domain) output_data(solution_file, pred_in_data, Soln_flat, Exact_soln_flat) util.plot_result(epoch, loss_history, pred_in_data, Exact_soln_flat, Soln_flat, dump_dir, error_u)
def analize(XX, yy): y_pred = regr.predict(XX) plot_result(yy, y_pred) full_report(yy, y_pred)
print('Training time: %.4f' % training_time) x_testing = np.linspace(lower_bound, upper_bound, num_testing).reshape( (-1, 1)) prediction, truth = model.test(x_testing) error_u = np.sqrt(np.square(prediction - truth).mean()) print('Error u: %e' % error_u) with open(dump_dir + "info.txt", 'w') as log: writing_items = [ ">>> Function <<<", "Interval = [%.2f, %.2f]" % (lower_bound, upper_bound), "Q = %d" % quad_order, "(a, w) = (%.2f, %.2f)" % (a, w), "\n>>> Network <<<", "Layers = %s" % str(layers), "Max_epochs = %d" % max_epoch, "Num_testing = %d" % num_testing, "Init_lr = %.2e" % init_lr, "Least_squared = %s" % least_squared, "Lambda = %.2f" % lam, "Loss_threshold = %.1e" % min_loss, "Adjusting_period = %d" % adjusting_epoch, "\n>>> Result <<<", "Training time: %.4fs" % training_time, "L2_error: %e" % error_u ] log.writelines("\n".join(writing_items)) util.plot_result(epoch_list, loss_history, x_testing, truth, prediction, dump_dir, error_u)
G_optimizer.step() train_hist['G_losses'].append(G_train_loss.data) G_losses.append(G_train_loss.data) num_iter += 1 epoch_end_time = time.time() per_epoch_ptime = epoch_end_time - epoch_start_time print('[%d/%d] - ptime: %.2f, loss_d: %.3f, loss_g: %.3f' % ((epoch + 1), opt.train_epoch, per_epoch_ptime, torch.mean(torch.FloatTensor(D_losses)), torch.mean(torch.FloatTensor(G_losses)))) fixed_p = root + 'Fixed_results/' + model + str(epoch + 1) + '.png' train_hist['per_epoch_ptimes'].append(per_epoch_ptime) end_time = time.time() total_ptime = end_time - start_time train_hist['total_ptime'].append(total_ptime) print('total training time: ', total_ptime) print("Avg one epoch ptime: %.2f, total %d epochs ptime: %.2f" % (torch.mean(torch.FloatTensor( train_hist['per_epoch_ptimes'])), opt.train_epoch, total_ptime)) print("Training finish!... save training results") torch.save(G.state_dict(), root + model + 'generator_param.pkl') torch.save(D.state_dict(), root + model + 'discriminator_param.pkl') util.plot_result(train_hist)