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))
