def train(discriminator,
generator,
show_every=25,
num_epochs=20,
save_every=2000):
start_t = time.time()
iter_count = 0
discriminator.add_optimizer()
generator.add_optimizer()
for epoch in range(num_epochs):
for x, _ in loader_train:
if len(x) != batch_size:
continue
discriminator.optimizer.zero_grad()
real_data = Variable(x).type(torch.FloatTensor)
logits_real = discriminator.forward(real_data).type(
torch.FloatTensor)
g_fake_seed = Variable(sample_noise(batch_size, noise_dim)).type(
torch.FloatTensor)
fake_images = generator.forward(g_fake_seed)
logits_fake = discriminator.forward(fake_images.detach())
d_total_error = discriminator.loss(logits_real, logits_fake)
d_total_error.backward()
discriminator.optimizer.step()
generator.optimizer.zero_grad()
g_fake_seed = Variable(sample_noise(batch_size, noise_dim)).type(
torch.FloatTensor)
fake_images = generator.forward(g_fake_seed)
gen_logits_fake = discriminator.forward(fake_images)
g_loss = generator.loss(gen_logits_fake)
g_loss.backward()
generator.optimizer.step()
if (iter_count % show_every == 0):
checkpt_t = time.time()
print("time : {:.2f} sec".format(checkpt_t - start_t))
print('Iter: {}, D: {:.4}, G:{:.4}'.format(
iter_count, d_total_error.data[0], g_loss.data[0]))
print("real logits average ", torch.mean(logits_real).data)
print("average output generator : ",
torch.mean(fake_images).data)
print("fake logits average ", torch.mean(gen_logits_fake).data)
imgs = fake_images[:16].data.numpy()
show_images(imgs,
iter_num=iter_count,
save=True,
show=False,
model=generator.label)
iter_count += 1
if iter_count % save_every == 0:
torch.save(
discriminator, 'results/weights/discriminator' +
discriminator.label + '.pt')
torch.save(
generator,
'results/weights/generator' + generator.label + '.pt')
def train(discriminator,
generator,
show_every=250,
num_epochs=100,
save_every=2000):
iter_count = 0
dis_optimizer = optimizer_dis(discriminator)
gen_optimizer = optimizer_gen(generator)
for epoch in range(num_epochs):
for x, _ in loader_train:
if len(x) != batch_size:
continue
dis_optimizer.zero_grad()
real_data = Variable(x).type(torch.FloatTensor)
logits_real = discriminator(
2 * (real_data.view(batch_size, -1) - 0.5)).type(
torch.FloatTensor)
# g_fake_seed = Variable(sample_noise(batch_size, noise_dim)).type(torch.FloatTensor)
# fake_images = generator(g_fake_seed)
for _ in range(5):
g_fake_seed = Variable(sample_noise(
batch_size, noise_dim)).type(torch.FloatTensor)
fake_images = generator(g_fake_seed)
logits_fake = discriminator(fake_images.detach().view(
batch_size, -1))
d_total_error = discriminator_loss(logits_real, logits_fake)
d_total_error.backward(retain_graph=True)
dis_optimizer.step()
# weight clipping
for p in discriminator.parameters():
p.data.clamp_(-0.01, 0.01)
gen_optimizer.zero_grad()
gen_logits_fake = discriminator(fake_images.view(batch_size, -1))
g_loss = generator_loss(gen_logits_fake)
g_loss.backward()
gen_optimizer.step()
if iter_count % show_every == 0:
print('Iter: {}, D: {:.4}, G:{:.4}'.format(
iter_count, d_total_error.data[0], g_loss.data[0]))
imgs_numpy = fake_images.data.cpu().numpy()
show_images(imgs_numpy[0:16],
iter_count,
save=True,
model=generator.label)
iter_count += 1
if iter_count % save_every == 0:
torch.save(
discriminator, 'results/weights/discriminator' +
discriminator.label + '.pt')
torch.save(
generator,
'results/weights/generator' + generator.label + '.pt')
iter_count += 1
def train(discriminator,
generator,
show_every=25,
num_epochs=10,
resume=False,
save_every=2000):
iter_count = 0
dis_optimizer = optimizer_discriminator(discriminator)
gen_optimizer = optimizer_generator(generator)
for epoch in range(num_epochs):
for x, _ in loader_train:
if len(x) != batch_size:
continue
if iter_count == 0:
weights_average = {}
weights_average_gen = {}
for name, value in discriminator.state_dict().items():
weights_average[name] = torch.mean(value)
for name, value in generator.state_dict().items():
weights_average_gen[name] = torch.mean(value)
print("Average value of initialized weights dis : \n",
weights_average)
print("Average value of initialized weights gen : \n",
weights_average_gen)
dis_optimizer.zero_grad()
real_data = Variable(x).type(torch.FloatTensor)
logits_real = discriminator(
2 * (real_data.view(batch_size, -1) - 0.5)).type(
torch.FloatTensor)
g_fake_seed = Variable(sample_noise(batch_size, noise_dim)).type(
torch.FloatTensor)
fake_images = generator(g_fake_seed).detach()
logits_fake = discriminator(fake_images.view(batch_size, -1))
d_total_error = discriminator_loss(logits_real, logits_fake)
d_total_error.backward()
dis_optimizer.step()
gen_optimizer.zero_grad()
g_fake_seed = Variable(sample_noise(batch_size, noise_dim)).type(
torch.FloatTensor)
fake_images = generator(g_fake_seed)
gen_logits_fake = discriminator(fake_images.view(batch_size, -1))
g_loss = generator_loss(gen_logits_fake)
g_loss.backward()
gen_optimizer.step()
if (iter_count % show_every == 0):
print('Iter: {}, D: {:.4}, G:{:.4}'.format(
iter_count, d_total_error.data[0], g_loss.data[0]))
imgs = fake_images[:16].data.numpy()
show_images(imgs,
iter_num=iter_count,
save=True,
show=False,
model=generator.label)
iter_count += 1
if iter_count % save_every == 0:
torch.save(
discriminator, 'results/weights/discriminator' +
discriminator.label + '.pt')
torch.save(
generator,
'results/weights/generator' + generator.label + '.pt')