def main():
# load training data
trainset = Dataset('./data/brilliant_blue')
trainloader = torch.utils.data.DataLoader(
trainset, batch_size=batch_size, shuffle=True
)
# init netD and netG
netD = Discriminator().to(device)
netD.apply(weights_init)
netG = Generator(nz).to(device)
netG.apply(weights_init)
criterion = nn.BCELoss()
# used for visualzing training process
fixed_noise = torch.randn(16, nz, 1, device=device)
real_label = 1.
fake_label = 0.
optimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(beta1, 0.999))
optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))
for epoch in range(epoch_num):
for step, (data, _) in enumerate(trainloader):
real_cpu = data.to(device)
b_size = real_cpu.size(0)
# train netD
label = torch.full((b_size,), real_label,
dtype=torch.float, device=device)
netD.zero_grad()
output = netD(real_cpu).view(-1)
errD_real = criterion(output, label)
errD_real.backward()
D_x = output.mean().item()
# train netG
noise = torch.randn(b_size, nz, 1, device=device)
fake = netG(noise)
label.fill_(fake_label)
output = netD(fake.detach()).view(-1)
errD_fake = criterion(output, label)
errD_fake.backward()
D_G_z1 = output.mean().item()
errD = errD_real + errD_fake
optimizerD.step()
netG.zero_grad()
label.fill_(real_label)
output = netD(fake).view(-1)
errG = criterion(output, label)
errG.backward()
D_G_z2 = output.mean().item()
optimizerG.step()
print('[%d/%d][%d/%d]\tLoss_D: %.4f\tLoss_G: %.4f\tD(x): %.4f\tD(G(z)): %.4f / %.4f'
% (epoch, epoch_num, step, len(trainloader),
errD.item(), errG.item(), D_x, D_G_z1, D_G_z2))
# save training process
with torch.no_grad():
fake = netG(fixed_noise).detach().cpu()
f, a = plt.subplots(4, 4, figsize=(8, 8))
for i in range(4):
for j in range(4):
a[i][j].plot(fake[i * 4 + j].view(-1))
a[i][j].set_xticks(())
a[i][j].set_yticks(())
plt.savefig('./img/dcgan_epoch_%d.png' % epoch)
plt.close()
# save models
torch.save(netG, './nets/dcgan_netG.pkl')
torch.save(netD, './nets/dcgan_netD.pkl')
nearest_k = 5
print('dataloader size',len(dataloader.dataset))
for epoch in range(params['nepochs']):
for i, data in enumerate(dataloader, 0):
# Transfer data tensor to GPU/CPU (device)]\
real_data = data[0].to(device)
print('data type and len',type(real_data),len(real_data))
# Get batch size. Can be different from params['nbsize'] for last batch in epoch.
b_size = real_data.size(0)
# Make accumalated gradients of the discriminator zero.
netD.zero_grad()
# Create labels for the real data. (label=1)
label = torch.full((b_size, ), real_label, device=device)
#print("real",len(real_data))
output = netD(real_data).view(-1)
#print("output",len(output))
errD_real = criterion(output, label)
# Calculate gradients for backpropagation.
errD_real.backward()
D_x = output.mean().item()
# Sample random data from a unit normal distribution.
noise = torch.randn(b_size, params['nz'], 1, 1, device=device)
# Generate fake data (images).
fake_data = netG(noise)
def main():
# load training data
trainset = Dataset('./data/brilliant_blue')
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=batch_size,
shuffle=True)
# init netD and netG
netD = Discriminator().to(device)
netD.apply(weights_init)
netG = Generator(nz).to(device)
netG.apply(weights_init)
# used for visualizing training process
fixed_noise = torch.randn(16, nz, 1, device=device)
# optimizers
optimizerD = optim.RMSprop(netD.parameters(), lr=lr)
optimizerG = optim.RMSprop(netG.parameters(), lr=lr)
for epoch in range(epoch_num):
for step, (data, _) in enumerate(trainloader):
# training netD
real_cpu = data.to(device)
b_size = real_cpu.size(0)
netD.zero_grad()
noise = torch.randn(b_size, nz, 1, device=device)
fake = netG(noise)
loss_D = -torch.mean(netD(real_cpu)) + torch.mean(netD(fake))
loss_D.backward()
optimizerD.step()
for p in netD.parameters():
p.data.clamp_(-clip_value, clip_value)
if step % n_critic == 0:
# training netG
noise = torch.randn(b_size, nz, 1, device=device)
netG.zero_grad()
fake = netG(noise)
loss_G = -torch.mean(netD(fake))
netD.zero_grad()
netG.zero_grad()
loss_G.backward()
optimizerG.step()
if step % 5 == 0:
print('[%d/%d][%d/%d]\tLoss_D: %.4f\tLoss_G: %.4f' %
(epoch, epoch_num, step, len(trainloader), loss_D.item(),
loss_G.item()))
# save training process
with torch.no_grad():
fake = netG(fixed_noise).detach().cpu()
f, a = plt.subplots(4, 4, figsize=(8, 8))
for i in range(4):
for j in range(4):
a[i][j].plot(fake[i * 4 + j].view(-1))
a[i][j].set_xticks(())
a[i][j].set_yticks(())
plt.savefig('./img/wgan_epoch_%d.png' % epoch)
plt.close()
# save model
torch.save(netG, './nets/wgan_netG.pkl')
torch.save(netD, './nets/wgan_netD.pkl')
for epoch in range(num_epochs):
for batch_idx, (real, _) in enumerate(loader):
real = real.to(device)
noise = torch.randn((batch_size, z_dim, 1, 1)).to(device)
fake = gen(noise)
# Training Discriminator max log(D(x)) + log(1 - D(G(z)))
disc_real = disc(real).view(-1)
loss_disc_real = criterion(disc_real, torch.ones_like(disc_real))
disc_fake = disc(fake).view(-1)
loss_disc_fake = criterion(disc_fake, torch.zeros_like(disc_fake))
loss_disc = (loss_disc_real + loss_disc_fake) / 2
disc.zero_grad()
loss_disc.backward(retain_graph=True)
opt_disc.step()
# Training Generator min log(1 - D(G(z))) -> max log(D(G(z)))
output = disc(fake).view(-1)
loss_gen = criterion(output, torch.ones_like(output))
gen.zero_grad()
loss_gen.backward()
opt_gen.step()
if batch_idx % 200 == 0:
print(
"Epoch {}, Loss Discriminator: {}, Loss Generator: {}".format(
epoch, loss_disc, loss_gen))
gamma=0.1)
# step 5: iteration
img_list = []
G_losses = []
D_losses = []
iters = 0
for epoch in range(num_epochs):
for i, data in enumerate(train_loader):
############################
# (1) Update D network
###########################
net_d.zero_grad()
# create training data
real_img = data.to(device)
b_size = real_img.size(0)
# 根据 (b_size,) 构造矩阵，使用 real_idx填充
real_label = torch.full((b_size, ), real_idx, device=device)
noise = torch.randn(b_size, nz, 1, 1, device=device)
fake_img = net_g(noise)
fake_label = torch.full((b_size, ), fake_idx, device=device)
# train D with real img
out_d_real = net_d(real_img)
loss_d_real = criterion(out_d_real.view(-1), real_label)
def main():
# load training data
trainset = Dataset('./data/brilliant_blue')
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=batch_size,
shuffle=True)
# init netD and netG
netD = Discriminator().to(device)
netD.apply(weights_init)
netG = Generator(nz).to(device)
netG.apply(weights_init)
# used for visualizing training process
fixed_noise = torch.randn(16, nz, 1, device=device)
# optimizers
# optimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(beta1, beta2))
# optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, beta2))
optimizerD = optim.RMSprop(netD.parameters(), lr=lr)
optimizerG = optim.RMSprop(netG.parameters(), lr=lr)
for epoch in range(epoch_num):
for step, (data, _) in enumerate(trainloader):
# training netD
real_cpu = data.to(device)
b_size = real_cpu.size(0)
netD.zero_grad()
noise = torch.randn(b_size, nz, 1, device=device)
fake = netG(noise)
# gradient penalty
eps = torch.Tensor(b_size, 1, 1).uniform_(0, 1)
x_p = eps * data + (1 - eps) * fake
grad = autograd.grad(netD(x_p).mean(),
x_p,
create_graph=True,
retain_graph=True)[0].view(b_size, -1)
grad_norm = torch.norm(grad, 2, 1)
grad_penalty = p_coeff * torch.pow(grad_norm - 1, 2)
loss_D = torch.mean(netD(fake) - netD(real_cpu))
loss_D.backward()
optimizerD.step()
for p in netD.parameters():
p.data.clamp_(-0.01, 0.01)
if step % n_critic == 0:
# training netG
noise = torch.randn(b_size, nz, 1, device=device)
netG.zero_grad()
fake = netG(noise)
loss_G = -torch.mean(netD(fake))
netD.zero_grad()
netG.zero_grad()
loss_G.backward()
optimizerG.step()
if step % 5 == 0:
print('[%d/%d][%d/%d]\tLoss_D: %.4f\tLoss_G: %.4f' %
(epoch, epoch_num, step, len(trainloader), loss_D.item(),
loss_G.item()))
# save training process
with torch.no_grad():
fake = netG(fixed_noise).detach().cpu()
f, a = plt.subplots(4, 4, figsize=(8, 8))
for i in range(4):
for j in range(4):
a[i][j].plot(fake[i * 4 + j].view(-1))
a[i][j].set_xticks(())
a[i][j].set_yticks(())
plt.savefig('./img/wgan_gp_epoch_%d.png' % epoch)
plt.close()
# save model
torch.save(netG, './nets/wgan_gp_netG.pkl')
torch.save(netD, './nets/wgan_gp_netD.pkl')
def train():
os.makedirs('log', exist_ok=True)
ds = datasets.ImageFolder(root=data_root,
transform=transforms.Compose([
transforms.Resize(image_size),
transforms.CenterCrop(image_size),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
]))
dataloader = DataLoader(ds, batch_size=batch_size, shuffle=True)
net_g = Generator(n_latent_vector, n_g_filters).to(device)
net_g.apply(weight_init)
net_d = Discriminator(n_d_filters).to(device)
net_d.apply(weight_init)
if os.path.exists(model_save_path):
all_state_dict = torch.load(model_save_path)
net_d.load_state_dict(all_state_dict['d_state_dict'])
net_g.load_state_dict(all_state_dict['g_state_dict'])
print('model restored from {}'.format(model_save_path))
criterion = nn.BCELoss()
fixed_noise = torch.randn(1, n_latent_vector, 1, 1, device=device)
real_label = 1
fake_label = 0
optimizer_d = optim.Adam(net_d.parameters(), lr=lr, betas=(0.5, 0.999))
optimizer_g = optim.Adam(net_g.parameters(), lr=lr, betas=(0.5, 0.999))
print('start training...')
try:
for epoch in range(epochs):
for i, data in enumerate(dataloader, 0):
# update Discrinimator, maximize d loss
net_d.zero_grad()
real_cpu = data[0].to(device)
b_size = real_cpu.size(0)
label = torch.full((b_size,), real_label, device=device)
output = net_d(real_cpu).view(-1)
err_d_real = criterion(output, label)
err_d_real.backward()
d_x = output.mean().item()
# train with fake batch
noise = torch.randn(b_size, n_latent_vector, 1, 1, device=device)
fake = net_g(noise)
label.fill_(fake_label)
output = net_d(fake.detach()).view(-1)
err_d_fake = criterion(output, label)
err_d_fake.backward()
d_g_z1 = output.mean().item()
err_d = err_d_real + err_d_fake
optimizer_d.step()
# update Generator
net_g.zero_grad()
label.fill_(real_label)
output = net_d(fake).view(-1)
err_g = criterion(output, label)
err_g.backward()
d_g_z2 = output.mean().item()
optimizer_d.step()
if i % 50 == 0:
print(f'Epoch: {epoch}, loss_d: {err_d.item()}, loss_g: {err_g.item()}')
if epoch % 2 == 0 and epoch != 0:
with torch.no_grad():
fake = net_g(fixed_noise).detach().cpu().numpy()
print(fake.shape)
fake = np.transpose(np.squeeze(fake, axis=0), (1, 2, 0))
print(fake.shape)
cv2.imwrite('log/{}_fake.png'.format(epoch), fake)
print('record a fake image to local.')
except KeyboardInterrupt:
print('interrupted, try saving the model')
all_state_dict = {
'd_state_dict': net_d.state_dict(),
'g_state_dict': net_g.state_dict(),
}
torch.save(all_state_dict, model_save_path)
print('model saved...')