def main(): torch.manual_seed(0) # データ生成 w_true = torch.tensor([1, 2, 3], dtype=torch.float) N = 100 X, y = prepare_data(N, w_true) # 重みの初期化 requires_grad=Trueにすると計算グラフ保持→逆伝播の計算ができる w = torch.randn(w_true.size(0), requires_grad=True) # 学習におけるハイパーパラメータ learning_rate = 0.1 num_epochs = 20 loss_list = [] for epoch in range(1, num_epochs + 1): w.grad = None y_pred = torch.mv(X, w) loss = torch.mean((y_pred - y)**2) loss.backward() loss_list.append(loss) # print(w.grad) w.data = w - learning_rate * w.grad.data print( f'Epoch{epoch}: loss={loss.item():.4f} w={w.data} dL/dw={w.grad.data}' ) plot_loss(loss_list)
def main(): torch.manual_seed(0) # データ生成 w_true = torch.tensor([1, 2, 3], dtype=torch.float) N = 100 X, y = prepare_data(N, w_true) # モデル構築 model = nn.Linear(in_features=3, out_features=1, bias=False) criterion = nn.MSELoss() optimizer = optim.SGD(model.parameters(), lr=0.1) # print(list(model.parameters())) # 重みは勝手に設定してくれる num_epochs = 10 loss_list = [] for epoch in range(1, num_epochs + 1): optimizer.zero_grad() y_pred = model(X) loss = criterion(y_pred.view_as(y), y) loss.backward() loss_list.append(loss.item()) optimizer.step() # plt.plot(y) # plt.plot(model(X).detach().numpy()) plot_loss(loss_list)
def main(): # Get wake solver wake_loss = get_Wake_Phase_loss(X_ph) wake_solver = get_Wake_Phase_solver(wake_loss) # Get sleep solver sleep_loss = get_Sleep_Phase_loss(X_ph, Z_ph) sleep_solver = get_Sleep_Phase_solver(sleep_loss) saver = tf.train.Saver() sess = tf.Session() sess.run(tf.global_variables_initializer()) train_loss = [] test_loss = [] for i in range(Total_Train_Step): if i % Train_Epoch_Step == 0: print(i) if i % (10 * Train_Epoch_Step) == 0: print("<<<<<<<<<<<<<<evaluation>>>>>>>>>>>>>>") print("Step:" + str(i)) train_L, test_L = evaluate(sess, X_ph) train_loss.append(train_L) test_loss.append(test_L) print('train_L: %f, test_L: %f' % (train_L, test_L)) ''' Wake phase ''' feed_dict = {X_ph: mnist.train.next_batch(batch_size)[0]} sess.run(wake_solver, feed_dict=feed_dict) ''' Sleep phase ''' X_samples_var, Z_samples_var = get_pxz_samples(sess) feed_dict = { X_ph: X_samples_var, Z_ph: Z_samples_var, } sess.run(sleep_solver, feed_dict=feed_dict) #Final evaluation print("<<<<<<<<<<<<<<evaluation>>>>>>>>>>>>>>") print("Step:" + str(i)) train_L, test_L = evaluate(sess, X_ph) train_loss.append(train_L) test_loss.append(test_L) print('train_L: %f, test_L: %f' % (train_L, test_L)) #plot result plot_result(sess) plot_loss(train_loss, test_loss, 'WakeSleep_loss') # save model save_path = saver.save(sess, "Model/ws_model.ckpt") print("Save the model in:" + str(save_path)) print("Begin visualization") visulazation(sess, X_ph)
def opcion_1(data): training, test = pre_proc(data, 70) entrada, salida = split_data(training, salida_columns) entrada_test, salida_test = split_data(test, salida_columns) topology = [entrada[0].size, 8, 4, salida[0].size] epochs = 500 learning_rate = 0.1 """Topology es una lista con la cantida de neuronas en cada capa act_f es la funcion de activacion que sera usada por cada capa """ print('Creando red neuronal de topologia: ', topology) nn = neuronal_network.Network(topology, Sigmoid, MSE) print('Iniciando entrenamiento...') error = nn.train(entrada, salida, learning_rate, epochs) plot_loss(error, error_path) print('Entrenamiento finalizado.') opcion_4(nn, entrada_test, salida_test) return nn, entrada_test, salida_test
def run(self, epoch=10, batch_size=150): data = self.data model = self.model print('Training...') print('===========') hist = model.fit(data.x_train, data.y_train, epochs=epoch, batch_size=batch_size, validation_data=(data.x_test, data.y_test), verbose=0) score, acc = model.evaluate(data.x_test, data.y_test, batch_size=batch_size) print('Test performance: %s (%.2f%%)' % (score, acc * 100)) plt.figure(figsize=(15, 5)) plt.subplot(121) plot_loss(hist) plt.subplot(122) plot_acc(hist) plt.show()
save_path = saver.save(sess, os.path.join(MODEL_DIR, 'model%d.ckpt' % i)) print('Model saved in path: %s' % save_path) # Save the loss every so often if i % INTV_SAVE == 0: np.savez(os.path.join(OUT_DIR, 'loss.npz'), train_MSE_loss=np.array(train_MSE_loss), dev_MSE_loss=np.array(dev_MSE_loss)) # Save the loss np.savez(os.path.join(OUT_DIR, 'loss.npz'), train_MSE_loss=np.array(train_MSE_loss), dev_MSE_loss=np.array(dev_MSE_loss)) # Save the final blended output, and make a graph of the loss. util.plot_loss(os.path.join(OUT_DIR, 'loss.npz'), 'MSE Loss During Training', os.path.join(OUT_DIR, 'loss_plot.png')) for i_test in range(N_TEST): util.postprocess_images_inpainting( os.path.join(OUT_DIR, 'test_img_%d.png' % i_test), last_output_PATH[i_test], os.path.join(OUT_DIR, 'out_blend_%d.png' % i_test), blend=True, mask=mask) util.postprocess_images_inpainting( os.path.join(OUT_DIR, 'test_img_%d.png' % i_test), last_output_PATH[i_test], os.path.join(OUT_DIR, 'out_paste_%d.png' % i_test), blend=False, mask=mask)
# Backpropage loss loss.backward() # Update weights optimizer.step() running_loss += loss.item() pbar.set_postfix({'loss': running_loss / (idx_batch + 1)}) pbar.update(BATCH_SIZE) val_loss = compute_loss(net, val_data, mean_squared_error) train_loss = compute_loss(net, train_dataloader, mean_squared_error) val_losses.append(val_loss) running_losses.append(train_loss) hist_loss[idx_epoch] = running_loss / len(train_dataloader) # plt.plot(hist_loss, 'o-') plot_loss(val_losses, running_losses) 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()
# # BCM_decay_rates = [0.1, 0.5, 0.9, 0.99] # for i in range(len(BCM_decay_rates)): # # print(hyperparameter value...) # run_args = tests.linear_target_BCM(seed=seed, BCM_decay_rate=BCM_decay_rates[i], BCM_sat_const=1) # run_args[0][0].set_name(run_args[0][0].get_name() + ", rate = {}".format(BCM_decay_rates[i])) # models += run_args[0] # losses += util.run(*run_args) # BCM_sat_consts = [0.8, 1, 5, 10, 100] # for i in range(len(BCM_sat_consts)): # run_args = tests.linear_target_BCM(seed=seed, BCM_decay_rate=0.9, BCM_sat_const=BCM_sat_consts[i]) # run_args[0][0].set_name(run_args[0][0].get_name() + ", k = {}".format(BCM_sat_consts[i])) # models += run_args[0] # losses += util.run(*run_args) util.plot_loss(losses, models) """ models = [] # basic GD model # not entirely clear what the original hyperparameters used were in Lillicrap paper for the linear target learning task in_size = 30 out_size = 10 units = (in_size, 20, out_size) layers = len(units) # learning rate of 0.005 (true rate unspecified) seems to give performance similar to Lillicrap et al # "Random synaptic feedback weights support error backpropagation for deep learning" Fig. 2 (a). lilli_GD = LillicrapModel(layers=layers, units=units, weight_init_range=(-0.01, 0.01), lr=0.005, decay_rate=0) models.append(lilli_GD)
loss_next = loss_prev loss.append(loss_next) # diff = loss_prev - loss_next # if diff > 0 and diff < eps: # break T *= decay_rate end = time.time() runtime = end - start losses[idx] = loss[-1] # # Plot loss plot_loss(loss, filename='../plots/nn_loss_sa_new.png', title='Training loss curve: simulated annealing') # Find accuracy on the test set y_pred = nn.predict(X_test) test_accuracy = accuracy_score(y_test, y_pred) print('Accuracy on test data using simulated annealing is %.2f%%' % (test_accuracy * 100)) test_accs[idx] = test_accuracy * 100 # # Timing information # print('Time taken to complete simulated annealing is %f seconds' % runtime) # Plot losses and test accuracies for different decay rates # fig, ax = plt.subplots() # plt.grid()
loss = local_loss(output, depth) val_loss += loss.item() val_losses_.append(val_loss / val_num) # save model torch.save(local_net, './models/local_net.pt') print(('epoch {}: train_loss = {}, validation loss = {}').format(e, train_loss, val_loss)) ###################################################### # visulizing the training result on val set # ###################################################### util.plot_loss(train_losses, val_losses) util.plot_loss(train_losses_, val_losses_) print("==========result visualized on validation set=============") rgb = list(dataloader_valid)[0][0].float().to(device) depth = list(dataloader_valid)[0][1].float().to(device) # results from global coarse network global_net.eval() with torch.no_grad(): global_output = global_net(rgb).unsqueeze(1) # results from local fine network local_net.eval() with torch.no_grad(): local_output = local_net(rgb, global_output)
if epoch % sample_interval == 0: # save the generator and discriminator self.generator.save(MODEL_DIR + "generator") self.discriminator.save(MODEL_DIR + "discriminator") # revert generated stft to wav file and save to output folder out = AUDIO_OUT_DIR + "epoch_" + str(epoch) + ".wav" try: y = util.audio_reconstruction(gen_matrix) scipy.io.wavfile.write(out, sampling_rate, y) except: print("Error in griffinlim at epoch", epoch) pass # save generated matrix to output folder out = STFT_OUT_DIR + "epoch_" + str(epoch) + ".npy" np.save(out, gen_matrix) # record loss and accuracy df = pd.DataFrame(losses, columns=['d_loss', 'd_acc', 'g_loss']) df.to_pickle("./output/loss.pkl") if __name__ == '__main__': gan = pianoGAN() gan.train(epochs=100, batch_size=32, sample_interval=1) gan.generator.save(MODEL_DIR + "generator") gan.discriminator.save(MODEL_DIR + "discriminator") util.plot_loss(("./output/loss.pkl"))
loss_A_B = -torch.mean(model.model_causal(x_transfer)) loss_B_A = -torch.mean(model.model_noncausal(x_transfer)) loss = loss_A_B + loss_B_A loss.backward() optimizer.step() model.save_weight_snapshot() for j in tqdm.trange(num_transfers, leave=False): model.load_weight_snapshot() pi_A_2 = np.random.dirichlet(np.ones(N)) x_val = generate_data_categorical(num_test, pi_A_2, pi_B_A) for i in range(num_episodes): x_transfer = generate_data_categorical(batch_size, pi_A_2, pi_B_A) model.zero_grad() loss_A_B = -torch.mean(model.model_causal(x_transfer)) loss_B_A = -torch.mean(model.model_noncausal(x_transfer)) loss = loss_A_B + loss_B_A with torch.no_grad(): val_loss_A_B = -torch.mean(model.model_causal(x_val)) val_loss_B_A = -torch.mean(model.model_noncausal(x_val)) ''' loss[num_mode, num_training, num_transfer, num_episodes] ''' losses[:, k, j, i] = [val_loss_A_B.item(), val_loss_B_A.item()] loss.backward() optimizer.step() plot_loss(losses, "baseline_loss_comparison.png")
causalPredA, causalPredAB, causalPred = model.model_causal(x_transfer) causalLoss = torch.mean(torch.norm(causalPred-torch.tensor(pi_all) + causalPredA-torch.tensor(pi_A_2), p=None)) nonCausalPred = model.model_noncausal(x_transfer) noncausalLoss = torch.mean(torch.norm(nonCausalPred-torch.tensor(pi_all), p=None)) with torch.no_grad(): valLossCausal = 0 valLossNoncausal = 0 for h in range(50): _, causalPredAB, causalPred = model.model_causal(x_val[h]) valLossCausal += torch.mean( torch.norm(causalPred-torch.tensor(pi_all), p=None)).item() # valLossCausal += torch.mean(torch.norm(causalPredAB-torch.tensor(pi_all), p=None)).item() nonCausalPred = model.model_noncausal(x_val[h]) valLossNoncausal += torch.mean(torch.norm(nonCausalPred-torch.tensor(pi_all), p=None)).item() ''' loss[num_mode, num_training, num_transfer, num_episodes] ''' losses[:, k, j, i] = [valLossCausal, valLossNoncausal] causalLoss.backward() noncausalLoss.backward() optimizer.step() plot_loss(losses, "NN_loss_comparison.png")
end = time.time() times[run] = end - start losses[run] = train_loss[-1] coefs.append(nn.coefs_) intercepts.append(nn.intercepts_) # # Plot loss curve # plot_loss(train_loss, filename='../plots/nn_loss_rhc.png', title='Training loss curve: randomized hill climbing') # Find best weights idx = np.argmin(losses) nn.coefs_ = coefs[idx] nn.intercepts_ = intercepts[idx] # Plot losses across runs plot_loss(losses, filename='../plots/nn_runs_rhc.png', title='Losses for different runs with RHC', xlabel='Run', ylabel='Loss') # Find accuracy on the test set y_pred = nn.predict(X_test) test_accuracy = accuracy_score(y_test, y_pred) print('Accuracy on test data using randomized hill climbing is %.2f%%' % (test_accuracy * 100)) # Timing information print('Average time per RHC run is %f seconds' % np.mean(times))
train_L: -166.858607, test_L: -166.136506, train_L: -166.465291, test_L: -166.491242, train_L: -169.692518, test_L: -170.524196, train_L: -167.140794, test_L: -168.268882, train_L: -166.100663, test_L: -166.391350, train_L: -165.440859, test_L: -166.046346, train_L: -164.590242, test_L: -164.878425, train_L: -166.897283, test_L: -167.043351, train_L: -166.755627, test_L: -166.524109, train_L: -166.775376, test_L: -166.936928, ''' train_L = [ -543.415492, -166.858607, -166.465291, -169.692518, -167.140794, -166.100663, -165.440859, -164.590242, -166.897283, -166.755627, -166.775376 ] test_L = [ -543.415603, -166.136506, -166.491242, -170.524196, -168.268882, -166.391350, -166.046346, -164.878425, -167.043351, -166.524109, -166.936928, ] plot_loss(train_L, test_L, 'Sleep_Wake_loss')
x_transfer = generate_data_categorical(batch_size, pi_A_1, pi_B_A, pi_C_B) model.zero_grad() loss_A_B = -torch.mean(model.model_causal(x_transfer)) loss_B_A = -torch.mean(model.model_noncausal(x_transfer)) loss_C_B = -torch.mean(model.model_noncausal(x_transfer)) loss = loss_A_B + loss_B_A + loss_C_B loss.backward() optimizer.step() model.save_weight_snapshot() for j in tqdm.trange(num_transfers, leave=False): model.load_weight_snapshot() pi_A_2 = np.random.dirichlet(np.ones(N)) x_val = generate_data_categorical(num_test, pi_A_2, pi_B_A, pi_C_B) for i in range(num_episodes): x_transfer = generate_data_categorical(batch_size, pi_A_2, pi_B_A, pi_C_B) model.zero_grad() loss_causal = -torch.mean(model.model_causal(x_transfer)) loss_noncausal = -torch.mean(model.model_noncausal(x_transfer)) loss = loss_causal + loss_noncausal with torch.no_grad(): val_loss_causal = -torch.mean(model.model_causal(x_val)) val_loss_noncausal = -torch.mean(model.model_noncausal(x_val)) losses[:, k, j, i] = [val_loss_causal.item(), val_loss_noncausal.item()] loss.backward() optimizer.step() plot_loss(losses, "three_variables_loss_comparison.png")
x_transfer = generate_data_categorical(batch_size, pi_A_1, pi_B_A, pi_C_B) model.zero_grad() loss = sum([-torch.mean(l) for l in model.compute_losses(x_transfer)]) loss.backward() optimizer.step() model.save_weight_snapshot() for j in tqdm.trange(num_transfers, leave=False): model.load_weight_snapshot() pi_A_2 = np.random.dirichlet(np.ones(N)) x_val = generate_data_categorical(num_test, pi_A_2, pi_B_A, pi_C_B) for i in range(num_episodes): x_transfer = generate_data_categorical(batch_size, pi_A_2, pi_B_A, pi_C_B) model.zero_grad() loss = sum( [-torch.mean(l) for l in model.compute_losses(x_transfer)]) with torch.no_grad(): val_loss = [ -torch.mean(l).item() for l in model.compute_losses(x_val) ] losses[:, k, j, i] = val_loss loss.backward() optimizer.step() plot_loss(losses, model, "loss_comparison_{}_models.png".format(model.n_models))