one = torch.FloatTensor([1])
mone = -1 * one
one_var = torch.autograd.Variable(one)
mone_var = torch.autograd.Variable(mone)
fix_noise = torch.FloatTensor(100, NOISE_DIM).normal_(0, 1)
fix_noise_var = torch.autograd.Variable(fix_noise)
if torch.cuda.is_available() > 0:
NetG = NetG.cuda()
NetD = NetD.cuda()
one_var = one_var.cuda()
mone_var = mone_var.cuda()
fix_noise_var = fix_noise_var.cuda()
bar = eup.ProgressBar(EPOCHS, len(train_loader), "D Loss:%.3f;G Loss:%.3f")
for epoch in range(1, EPOCHS + 1):
for index, (image, label) in enumerate(train_loader):
real = image
real_var = torch.autograd.Variable(real)
noise = torch.randn(real_var.size(0), NOISE_DIM)
noise_var = torch.autograd.Variable(noise)
if torch.cuda.is_available():
real_var = real_var.cuda()
noise_var = noise_var.cuda()
for parm in NetD.parameters():
parm.data.clamp_(-CLAMP_NUM, CLAMP_NUM)
NetD.zero_grad()
temp = torch.ones(NUM_CLASSES, 1) + i
Predict_y = torch.cat([Predict_y, temp], 0)
Predict_y = one_hot(Predict_y.long())
if torch.cuda.is_available():
NetD = NetD.cuda()
NetG = NetG.cuda()
predict_noise = predict_noise.cuda()
criterion.cuda()
Predict_y = Predict_y.cuda()
Predict_Noise_var = torch.autograd.Variable(predict_noise)
Predict_y_var = torch.autograd.Variable(Predict_y)
bar = eup.ProgressBar(EPOCHS, len(dataLoader), "D Loss:%.3f, G Loss:%.3f")
for epoch in range(1, EPOCHS + 1):
if epoch % 10 == 0:
optimizerG.param_groups[0]['lr'] /= 10
optimizerD.param_groups[0]['lr'] /= 10
for img_real, label_real in dataLoader:
mini_batch = label_real.shape[0]
label_true = torch.ones(mini_batch)
label_false = torch.zeros(mini_batch)
label = one_hot(label_real.long().squeeze())
noise = torch.FloatTensor(mini_batch, NOISE_DIM).normal_(0, 1)
if torch.cuda.is_available():
label_true = label_true.cuda()
values = fc_layer(values)
loss += kl_divergence(0.3, values)
for i in range(2):
fc_layer = list(autoencoder.decoder.children())[2 * i]
relu = list(autoencoder.decoder.children())[2 * i + 1]
values = fc_layer(values)
loss += kl_divergence(0.3, values)
return loss
model = autoencoder().cuda() if torch.cuda.is_available() else autoencoder()
criterion = torch.nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(),
lr=learning_rate,
weight_decay=1e-5)
proBar = eup.ProgressBar(num_epochs, len(dataloader), "loss:%.3f")
for epoch in range(1, num_epochs + 1):
for data in dataloader:
img, _ = data
img = img.view(img.size(0), -1)
img = torch.autograd.Variable(img).cuda() if torch.cuda.is_available(
) else torch.autograd.Variable(img)
# ===================forward=====================
output = model(img)
mse_loss = criterion(output, img)
kl_loss = sparse_loss(model, img)
loss = mse_loss + kl_loss * 1e-3
# ===================backward====================
optimizer.zero_grad()
loss.backward()
z = z.cuda()
z_test = z_test.cuda()
optimizerD = torch.optim.Adam(NetD.parameters(),lr=LEARNING_RATE_D,betas=(0.5,0.999), weight_decay=0)
optimizerG = torch.optim.Adam(NetG.parameters(),lr=LEARNING_RATE_G,betas=(0.5,0.999), weight_decay=0)
transform=tv.transforms.Compose([
tv.transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)) ,
tv.transforms.ToTensor(),
tv.transforms.Normalize([0.5]*3,[0.5]*3)
])
dataset = tv.datasets.ImageFolder(root=DATA_PATH, transform=transform)
dataloader = torch.utils.data.DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True)
bar = eup.ProgressBar(EPOCH, len(dataloader), "D Loss:%.3f;G Loss:%.3f")
for epoch in range(1, EPOCH + 1):
for i, data_batch in enumerate(dataloader, 0):
for p in NetD.parameters():
p.requires_grad = True
NetD.zero_grad()
images, labels = data_batch
current_batch_size = images.size(0)
images = images.cuda() if torch.cuda.is_available() else images
x.data.resize_as_(images).copy_(images)
y.data.resize_(current_batch_size).fill_(1)
y_pred = NetD(x)
errD_real = criterion(y_pred, y)
errD_real.backward()
D_real = y_pred.data.mean()
INPUT_IMAGE_PATH = "./inputs/Z.jpg"
density_img = si.imread(INPUT_IMAGE_PATH, True)
lut_2d = epnu.generate_lut(density_img)
visualizer = epnu.GANDemoVisualizer('GAN 2D Example Visualization of {}'.format(INPUT_IMAGE_PATH))
generator = SimpleMLP(input_size=z_dim, hidden_size=50, output_size=DIMENSION)
discriminator = SimpleMLP(input_size=DIMENSION, hidden_size=100, output_size=1)
if torch.cuda.is_available():
generator = generator.cuda()
discriminator = discriminator.cuda()
criterion = torch.nn.BCELoss()
d_optimizer = torch.optim.Adadelta(discriminator.parameters(), lr=1)
g_optimizer = torch.optim.Adadelta(generator.parameters(), lr=1)
proBar = eup.ProgressBar(1, iterations, "D Loss:(real/fake) %.3f/%.3f,G Loss:%.3f")
for train_iter in range(1, iterations + 1):
for d_index in range(3):
# 1. Train D on real+fake
discriminator.zero_grad()
# 1A: Train D on real
real_samples = epnu.sample_2d(lut_2d, bs)
d_real_data = torch.autograd.Variable(torch.Tensor(real_samples))
if torch.cuda.is_available() > 0:
d_real_data = d_real_data.cuda()
d_real_decision = discriminator(d_real_data)
labels = torch.autograd.Variable(torch.ones(bs))
if torch.cuda.is_available() > 0:
labels = labels.cuda()
