def main(): iters = 0 costs = [] for epoch in range(num_epochs): costs_per_epoch = [] real_eegs.shuffle() for i, eegs in enumerate(real_eegs): if (eegs.shape[0] != batch_size): continue eegs = normalize(eegs) iters += 1 optim.zero_grad() # eeg = estimated_eegs[i] eeg = Variable(eegs) if cuda: eeg = eeg.cuda() # eeg *= 1e5 *4 x_prime = net(eeg) cost = critereon(x_prime, eeg) * 1e3 cost.backward() optim.step() costs_per_epoch += [cost.item()] if iters % print_iter == 0: avg_cost_epoch = sum(costs_per_epoch) / len(costs_per_epoch) print("[Iter: " + str(iters) + "] [Epoch: " + str(epoch) + "] [Avg cost in epoch %f ] [Loss: %f]" % (avg_cost_epoch, cost.item())) save_EEG(eeg.cpu().detach().view(batch_size, 1004, 44).numpy(), 44, 200, "./reonconstructed_eegs/E-orginal-" + str(epoch)) save_EEG( x_prime.cpu().detach().view(batch_size, 1004, 44).numpy(), 44, 200, "./reonconstructed_eegs/E-generated-" + str(epoch)) avg_cost_epoch = sum(costs_per_epoch) / len(costs_per_epoch) costs += [avg_cost_epoch] np.save("./reonconstructed_eegs/convVAE-lr1e-4-N4390-C44-L1004-E", np.asarray(costs))
def main(): iters = 0 for iteration in range(ITERS): real_eegs.shuffle() for i in range(len(real_eegs)): if (real_eegs[i].shape[0] != BATCH_SIZE): continue iters += 1 ############################ # (1) Update D network ########################### for p in netD.parameters(): # reset requires_grad p.requires_grad = True # they are set to False below in netG update: # for p in netG.parameters(): # p.requires_grad = False # to avoid computation for iter_d in range(CRITIC_ITERS): real = real_eegs[random.randint(0, len(real_eegs) - 2)] if USE_CUDA: real = real.cuda() real_v = autograd.Variable(real) optimizerD.zero_grad() # train with real D_real = netD(real_v) D_real = D_real.mean() D_real.backward(mone) # train with fake # noise = netG.generate_noise(BATCH_SIZE, LENGTH, NUM_NODES) noise = noise_gen_G(BATCH_SIZE, LENGTH, NUM_NODES) if USE_CUDA: noise = [x.cuda() for x in noise] noise_v = [autograd.Variable(x) for x in noise] if (len(noise) == 1): #not conditional fake = autograd.Variable(netG(noise_v[0]).data) if (len(noise) == 2): #conditional with 1 Y fake = autograd.Variable(netG(noise_v[0], noise_v[1]).data) if (len(noise) == 3): #conditional with 2 Ys fake = autograd.Variable( netG(noise_v[0], noise_v[1], noise_v[2]).data) D_fake = netD(fake) D_fake = D_fake.mean() D_fake.backward(one) # train with gradient penalty gradient_penalty = calc_gradient_penalty( netD, real_v.data, fake.data) #gradient_penalty.backward() D_cost = D_fake - D_real + gradient_penalty Wasserstein_D = D_real - D_fake optimizerD.step() ############################ # (2) Update G network ########################### for p in netD.parameters(): p.requires_grad = False # to avoid computation # for p in netG.parameters(): # p.requires_grad = True optimizerG.zero_grad() # noise = netG.generate_noise(BATCH_SIZE, LENGTH, NUM_NODES) noise = noise_gen_G(BATCH_SIZE, LENGTH, NUM_NODES) if USE_CUDA: noise = [x.cuda() for x in noise] noise_v = [autograd.Variable(x) for x in noise] if (len(noise) == 1): #not conditional fake = autograd.Variable(netG(noise_v[0]).data) if (len(noise) == 2): #conditional with 1 Y fake = autograd.Variable(netG(noise_v[0], noise_v[1]).data) if (len(noise) == 3): #conditional with 2 Ys fake = autograd.Variable( netG(noise_v[0], noise_v[1], noise_v[2]).data) G = netD(fake) G = G.mean() G.requires_grad = True G.backward(mone) G_cost = -G optimizerG.step() # if (iters % 1000 == 0): # save_EEG(fake.cpu().detach().numpy(), NUM_NODES, 200, "./generated_eegs/generated-iter"+ str(iters) + "-fake-rG-long") # print("Epoch", iteration) # print("G_cost" , G_cost) # print("D_cost", D_cost) save_EEG( fake.cpu().detach().numpy(), NUM_NODES, 200, "./generated_eegs/generated-" + str(iteration) + "-fake-rcG-short") # save_EEG(real.cpu().detach().numpy(), NUM_NODES, 200, "./generated_eegs/generated-" + str(iteration-1) + "-real-rG-long-norm") print("Epoch", iteration) print("G_cost", G_cost) print("D_cost", D_cost)
def main(): iters = 0 for iteration in range(ITERS): real_eegs.shuffle() for i in range(len(real_eegs)): if (real_eegs[i].shape[0] != BATCH_SIZE): continue iters += 1 ############################ # (1) Update D network ########################### for p in netD.parameters(): # reset requires_grad p.requires_grad = True # they are set to False below in netG update: # for p in netG.parameters(): # p.requires_grad = False # to avoid computation optimizerD.zero_grad() inputv = autograd.Variable(real_eegs[i]) if USE_CUDA: inputv = inputv.cuda() unl_output = netD(inputv) loss_unl_real = -torch.mean(LSE(unl_output), 0) + torch.mean( F.softplus(LSE(unl_output), 1), 0) # train with fake # noise = netG.generate_noise(BATCH_SIZE, LENGTH, NUM_NODES) noise = noise_gen_G(BATCH_SIZE, LENGTH, NUM_NODES) if USE_CUDA: noise = [x.cuda() for x in noise] noise_v = [autograd.Variable(x) for x in noise] if (len(noise) == 1): #not conditional fake = autograd.Variable(netG(noise_v[0]).data) if (len(noise) == 2): #conditional with 1 Y fake = autograd.Variable(netG(noise_v[0], noise_v[1]).data) if (len(noise) == 3): #conditional with 2 Ys fake = autograd.Variable( netG(noise_v[0], noise_v[1], noise_v[2]).data) unl_output = netD( fake.detach() ) #fake images are separated from the graph #results will never gradient(be updated), so G will not be updated loss_unl_fake = torch.mean(F.softplus(LSE(unl_output), 1), 0) loss_D = loss_unl_real + loss_unl_fake loss_D.backward( ) # because detach(), backward() will not influence netG optimizerD.step() ############################ # (2) Update G network ########################### for p in netD.parameters(): p.requires_grad = False # to avoid computation # for p in netG.parameters(): # p.requires_grad = True optimizerG.zero_grad() # noise = netG.generate_noise(BATCH_SIZE, LENGTH, NUM_NODES) noise = noise_gen_G(BATCH_SIZE, LENGTH, NUM_NODES) if USE_CUDA: noise = [x.cuda() for x in noise] noise_v = [autograd.Variable(x) for x in noise] if (len(noise) == 1): #not conditional fake = autograd.Variable(netG(noise_v[0]).data) if (len(noise) == 2): #conditional with 1 Y fake = autograd.Variable(netG(noise_v[0], noise_v[1]).data) if (len(noise) == 3): #conditional with 2 Ys fake = autograd.Variable( netG(noise_v[0], noise_v[1], noise_v[2]).data) inputv = autograd.Variable(real_eegs[i]) feature_real, _ = netD(inputv, matching=True) feature_fake, output = netD(fake, matching=True) feature_real = torch.mean(feature_real, 0) feature_fake = torch.mean(feature_fake, 0) loss_G = criterionG(feature_fake, feature_real.detach()) optimizerG.step() # if (iters % 1000 == 0): # save_EEG(fake.cpu().detach().numpy(), NUM_NODES, 200, "./generated_eegs/generated-iter"+ str(iters) + "-fake-rG-long") # print("Epoch", iteration) # print("G_cost" , G_cost) # print("D_cost", D_cost) save_EEG( fake.cpu().detach().numpy(), NUM_NODES, 200, "./generated_eegs/generated-" + str(iteration) + "-fake-cG-matching-minB") # save_EEG(real.cpu().detach().numpy(), NUM_NODES, 200, "./generated_eegs/generated-" + str(iteration-1) + "-real-rG-long-norm") print("Epoch", iteration) print("G_cost", loss_G) print("D_cost", loss_D)
cleaned_noisy = Variable(cleaner(gen_imgs), requires_grad=True) cleaned_clean = Variable(cleaner(estimated), requires_grad=True) noisy_loss = torch.dist(cleaned_noisy, estimated) clean_loss = torch.dist(cleaned_clean, estimated) cleaner_loss = noisy_loss + clean_loss # print("cleaner loss", cleaner_loss) cleaner_loss.backward() optimizer_C.step() iter += 1 if iter % print_iter == 0: print( "[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f] [C Loss: %f]" % (epoch, n_epochs, i, len(real_eegs), d_loss.item(), g_loss.item(), clean_loss.item())) print("cleaner loss", clean_loss) save_EEG(gen_imgs.cpu().detach().view(batch_size, 1004, 44).numpy(), 44, 200, "./generated_eegs/generated-" + str(epoch) + "-fake-conv-add-cg") save_EEG( estimated.cpu().detach().view(batch_size, 1004, 44).numpy(), 44, 200, "./generated_eegs/generated-" + str(epoch) + "-estimated-conv-add-cg") save_EEG( cleaned_noisy.cpu().detach().view(batch_size, 1004, 44).numpy(), 44, 200, "./generated_eegs/generated-" + str(epoch) + "-cleaned-conv-add-cg") print("Save @ Epoch", epoch) # batches_done = epoch * len(dataloader) + i # if batches_done % sample_interval == 0: # save_image(gen_imgs.data[:25], 'images/%d.png' % batches_done, nrow=5, normalize=True)
fake_validity) + lambda_gp * gradient_penalty #g_loss = adversarial_loss(discriminator(gen_imgs), valid) d_loss.backward() optimizer_D.step() # --------------------- # Train Generator # --------------------- if i % n_critic == 0: optimizer_G.zero_grad() # Measure discriminator's ability to classify real from generated samples fake_imgs = generator(z) fake_validity = discriminator(fake_imgs) g_loss = -torch.mean(fake_validity) g_loss.backward() optimizer_G.step() print( "[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f]" % (epoch, n_epochs, i, len(real_eegs), d_loss.item(), g_loss.item())) save_EEG(gen_imgs.cpu().detach().view(batch_size, 1004, 44).numpy(), 44, 200, "./generated_eegs/generated-" + str(epoch) + "-fake-conv-wgp") # batches_done = epoch * len(dataloader) + i # if batches_done % sample_interval == 0: # save_image(gen_imgs.data[:25], 'images/%d.png' % batches_done, nrow=5, normalize=True)