def generate(model):
# Prepare a input
truncation = 0.4
batch_size = 10
class_vector = one_hot_from_names(['vase'], batch_size=batch_size)
noise_vector = truncated_noise_sample(truncation=truncation, batch_size=batch_size)
# All in tensors
noise_vector = torch.from_numpy(noise_vector)
class_vector = torch.from_numpy(class_vector)
# If you have a GPU, put everything on cuda
noise_vector = noise_vector.to('cuda')
class_vector = class_vector.to('cuda')
model.to('cuda')
# Generate an image
with torch.no_grad():
output = model(noise_vector, class_vector, truncation)
# If you have a GPU put back on CPU
output = output.to('cpu')
# If you have a sixtel compatible terminal you can display the images in the terminal
# (see https://github.com/saitoha/libsixel for details)
# display_in_terminal(output)
# Save results as png images
save_as_images(output, file_name='output/output')
def train(input, target, netG, model):
onehot_class_vector = torch.zeros(1, 1000)
onehot_class_vector[0][target] = 1
onehot_class_vector = onehot_class_vector.cuda()
netG.train()
model.train()
model = model.cuda()
netG = netG.cuda()
print('====> Test Image Norm & Restore')
input_interpolate = F.interpolate(input,
size=(512, 512),
mode='bilinear',
align_corners=True).cuda()
save_as_images(
_image_restore(input_interpolate).cpu().detach(),
'{0}/input_interpolate'.format(basic_path))
save_as_images(
_image_restore(_image_norm(
_image_restore(input_interpolate))).cpu().detach(),
'{0}/input_interpolate_restore'.format(basic_path))
save_images.save_images(_image_restore(input_interpolate).cpu().detach().numpy(), \
'{0}/input_interpolate'.format(basic_path))
save_images.save_images(_image_restore(_image_norm(_image_restore(input_interpolate))).cpu().detach().numpy(), \
'{0}/input_interpolate_restore'.format(basic_path))
# inputs = input.expand(args.aug_number, input.size(0), input.size(1), input.size(2)).cuda()
input = input.cuda()
print('input:', input.size())
_, feature_ini = model(input, isda=True)
'''
print('====> Preparing Covariance')
var_dir = './Covariance/' + str(target) + '_cov_imagenet' + '.csv'
print(var_dir)
var = np.loadtxt(var_dir, delimiter=' ')
CV = np.diag(var)
print('CV:', CV.shape)
'''
# augmentation高斯采样
feature_objective = torch.zeros(args.aug_number,
2048) # (aug_number, 2048)
'''
for i in range(args.aug_number):
aug_noise = np.random.multivariate_normal([0 for j in range(var.shape[0])], args.aug_alpha * CV)
aug_noise = torch.Tensor(aug_noise).cuda()
feature_objective[i] = feature_ini + aug_noise # feature_objective: \tilde{a_i}
print('feature_objective:', feature_objective.size())
'''
print('====> Start Training')
# z_trained = F_inverse(model, netG, input, class_vector, feature_ini, feature_objective)
F_inverse(model, netG, input, onehot_class_vector, feature_ini,
feature_objective)
'''fake_img_aug = netG(z_trained, class_vector).mul(0.5).add(0.5)
def interpolate(lin_noise_vector, lin_class_vector, glob_idx, num):
for i in range(num):
noise_vector = torch.from_numpy(lin_noise_vector[i])
class_vector = torch.from_numpy(lin_class_vector[i])
noise_vector = noise_vector.to(device)
class_vector = class_vector.to(device)
# Generate an image
with torch.no_grad():
output = model(noise_vector, class_vector, truncation)
# If you have a GPU put back on CPU
output = output.to('cpu')
save_as_images(output,
'{:0>4}'.format(str(glob_idx)),
path='images/Interpolation/')
glob_idx += 1
return glob_idx
def recover_latent(trial):
trueZ = truncated_noise_sample(truncation=truncation, batch_size=batches)
noise = truncated_noise_sample(truncation=maxNoise, batch_size=batches)
class_vec = one_hot_from_names(['fountain'], batch_size=batches)
z = torch.from_numpy(trueZ + noise)
print(z)
##print('diff:\n', z-trueZ)
opt = optim.Adam([z.requires_grad_()])
with torch.no_grad():
trueZImg = model(torch.from_numpy(trueZ), torch.from_numpy(class_vec),
truncation).requires_grad_()
zImg = model(z, torch.from_numpy(class_vec), truncation).requires_grad_()
zImg0 = zImg.clone()
i = 0
while (i < 5):
lf = nn.MSELoss()
loss = lf(zImg, trueZImg)
loss.backward()
opt.step()
opt.zero_grad()
i += 1
print(i, ': ImageMSE: ', mse_loss(zImg, trueZImg), '\sVecMSE: ',
mse_loss(z, torch.from_numpy(trueZ)))
zImg = model(z, torch.from_numpy(class_vec),
truncation).requires_grad_()
##with torch.no_grad():
##zImg = model(torch.from_numpy(z, class_vec, truncation)
trial = 1
#Save Images
saveOriginal = 'output/' + str(trial) + '_original'
saveNoisy = 'output/' + str(trial) + '_noisy'
saveFixed = 'output/' + str(trial) + '_fixed'
ensure_dir(saveOriginal)
save_as_images(trueZImg, saveOriginal)
ensure_dir(saveNoisy)
save_as_images(zImg0, saveNoisy)
ensure_dir(saveFixed)
save_as_images(zImg, saveFixed)
#Save vectors
saveOriginal = 'output/' + str(trial) + 'originalVec_.pt'
saveNoisy = 'output/' + str(trial) + '_noisyVec.pt'
saveFixed = 'output/' + str(trial) + '_fixedVec.pt'
ensure_dir(saveOriginal)
torch.save(trueZImg, saveOriginal)
ensure_dir(saveNoisy)
torch.save(zImg0, saveNoisy)
ensure_dir(saveFixed)
torch.save(zImg, saveFixed)
model = BigGAN.from_pretrained('biggan-deep-512')
# Prepare a input
truncation = 0.4
# class_vector = one_hot_from_names(['soap bubble', 'coffee', 'mushroom'], batch_size=3) # pip install nltk
class_vector = one_hot_from_int([445, 445, 445], batch_size=3)
noise_vector = truncated_noise_sample(truncation=truncation, batch_size=3)
# All in tensors
noise_vector = torch.from_numpy(noise_vector)
class_vector = torch.from_numpy(class_vector)
# If you have a GPU, put everything on cuda
noise_vector = noise_vector.to('cuda')
class_vector = class_vector.to('cuda')
model.to('cuda')
# Generate an image
with torch.no_grad():
output = model(noise_vector, class_vector, truncation)
# If you have a GPU put back on CPU
output = output.to('cpu')
# If you have a sixtel compatible terminal you can display the images in the terminal
# (see https://github.com/saitoha/libsixel for details)
# display_in_terminal(output)
# Save results as png images
save_as_images(output, file_name='image/')
def spacing_func(y, branch):
return (1 + branch * y * np.sqrt((2 - np.power(y, 2)).clip(0))) / 2
p_range = np.concatenate(
(spacing_func(np.linspace(1, np.sqrt(2), 10, endpoint=False), -1),
spacing_func(np.linspace(np.sqrt(2), 1, 10, endpoint=False), 1)))
# Creating mixed category vectors
nIm = len(classes) * len(p_range)
interp_class = torch.Tensor(nIm, class_vector.shape[1])
i = 0
for interp in range(len(classes)):
for p in p_range:
interp_class[i] = np.sqrt(1 - p) * class_vector[interp, :] + np.sqrt(
p) * class_vector[(interp + 1) % len(classes), :]
i += 1
# Sampling a single latent noise vector
noise_vector = torch.from_numpy(
np.repeat(truncated_noise_sample(truncation=truncation, seed=0),
nIm,
axis=0)).sin_()
# Generate images
with torch.no_grad():
output = model(noise_vector, interp_class, truncation)
# Save results as png images
save_as_images(output, file_name='output/out2')
# All in tensors
noise_vector = torch.from_numpy(noise_vector)
class_vector = torch.from_numpy(class_vector)
if torch.cuda.is_available():
# If you have a GPU, put everything on cuda
noise_vector = noise_vector.to('cuda')
class_vector = class_vector.to('cuda')
model.to('cuda')
# Generate an image
with torch.no_grad():
output = model(noise_vector, class_vector, truncation)
if torch.cuda.is_available():
# If you have a GPU put back on CPU
output = output.to('cpu')
try:
# If you have a sixtel compatible terminal you can display the images in the terminal
# (see https://github.com/saitoha/libsixel for details)
display_in_terminal(output)
except:
pass
try:
# Save results as png images
save_as_images(output)
except:
pass
class_vector = torch.from_numpy(class_vector)
# If you have a GPU, put everything on cuda
# noise_vector = noise_vector.to('cuda')
# class_vector = class_vector.to('cuda')
# model.to('cuda')
# Generate an image
with torch.no_grad():
output = model(noise_vector, class_vector, truncation)
# If you have a GPU put back on CPU
# output = output.to('cpu')
# Save results as png images
save_as_images(output, './Image/BigGANoutput')
save_as_images(output, './MiDaS/input/MidasInput')
# resize the Image to 160*256
img = cv2.imread('./MiDaS/input/MidasInput_0.png')
print(img.shape)
height, width = img.shape[:2]
size = (256, 160)
img = cv2.resize(img, size, interpolation=cv2.INTER_AREA)
print(img.shape)
cv2.imwrite('./MiDaS/input/MidasInput_0.png', img,
[int(cv2.IMWRITE_JPEG_QUALITY), 95])
#run Midas
os.system('python ./MiDaS/run.py')
class_vectors_ten = torch.from_numpy(class_vectors)
noise_vectors_ten = torch.from_numpy(noise_vectors)
# Put on cuda
class_vectors_cud = class_vectors_ten.to(device)
noise_vectors_cud = noise_vectors_ten.to(device)
# Generate images
with torch.no_grad():
output = model(noise_vectors_cud, class_vectors_cud, truncation)
# If you have a GPU put back on CPU
output = output.cpu()
# Save results as png images
save_as_images(output, file_name='Image', path='images/Main4/')
display(Image('./images/Main4/Image_0.png', width=200, height=200))
display(Image('./images/Main4/Image_1.png', width=200, height=200))
display(Image('./images/Main4/Image_2.png', width=200, height=200))
display(Image('./images/Main4/Image_3.png', width=200, height=200))
# create options recombinationa + lin vectors (class and noise)
###
# prompt user choice mating partner
inp = 0
parent_id = ["1", "2", "3", "s"]
while not inp in parent_id:
# interpolate per 3 images, adapted function interpolate (per frame?)
###
##nv4 = nv3.cos()
##nv5 = nv4.cos()
##nv2 = nv.tan()
##nv3 = nv2.tan()
##nv4 = nv3.tan()
##nv5 = nv4.tan()
##nv4 = nv.abs()/nv
##nv5 = nv4*-1
noise_vector = torch.cat((nv, nv2, nv3, nv4, nv5), 0)
class_vector = torch.cat((class_vector, class_vector, class_vector, class_vector, class_vector), 0)
# Generate an image
with torch.no_grad():
output = model(noise_vector, class_vector, truncation)
# If you have a sixtel compatible terminal you can display the images in the terminal
# (see https://github.com/saitoha/libsixel for details)
#display_in_terminal(output)
#Save results as png images
save_as_images(output, 'output/Static/static_0')
if not os.path.exists(directory):
os.makedirs(directory)
saveFile = str('output/RepJitterExp/')
if large_batches:
saveFile += str('_LargeBatches/')
saveFile += str(str(classnam.capitalize()) + '/')
if super_jitter:
saveFile += str('SuperJitter' + str(minJ) + '/')
saveFile += str(classnam + '_' + str(x))
ensure_dir(saveFile)
save_as_images(output, saveFile)
#Save pngs as a .gif
imgs = convert_to_images(output)
saveGIF = saveFile + '/anim.gif'
ensure_dir(saveGIF)
imgs[0].save(saveGIF,
save_all=True,
append_images=imgs[1:],
duration=100,
loop=0)
def F_inverse(model, netG, input, class_vector, features_ini,
feature_objective):
truncation = args.truncation
noise_vector = torch.tensor(
truncated_noise_sample(truncation=truncation,
batch_size=1,
seed=int(args.noise_seed))
# truncated_noise_sample(truncation=truncation, batch_size=1)
).cuda()
noise_vector = torch.nn.Parameter(noise_vector, requires_grad=True)
# noise_vector.requires_grad = True
print('Initial noise_vector:', noise_vector.size())
noise_vector_normalized = (noise_vector - noise_vector.mean()).div(
noise_vector.std())
fake_img = netG(noise_vector, class_vector, truncation)
# fake_img = netG(noise_vector_normalized, class_vector, truncation)
# save_images.save_images(fake_img.detach().cpu().numpy(), '{0}/step1_init_fake'.format(basic_path))
save_as_images(fake_img.detach().cpu().numpy(),
'{0}/step1_init_fake'.format(basic_path))
'''Step 1'''
mse_loss = torch.nn.MSELoss(reduction='sum')
opt1 = optim.SGD([{
'params': noise_vector
}],
lr=args.lr1,
momentum=0.9,
weight_decay=1e-4,
nesterov=True)
# opt1 = optim.Adam([{'params': noise_vector}], lr=args.lr1, weight_decay=1e-4)
for epoch in range(args.epoch1):
'''
if epoch == 800:
for paras in opt1.param_groups:
paras['lr'] /= 10
if epoch == 2000:
for paras in opt1.param_groups:
paras['lr'] /= 10
if epoch == 3500:
for paras in opt1.param_groups:
paras['lr'] /= 10
'''
# noise_vector_normalized = (noise_vector - noise_vector.mean()).div(noise_vector.std())
# fake_img = netG(noise_vector_normalized, class_vector, truncation) # TODO: 11.2 用是否用正则化的向量进行优化
fake_img = netG(noise_vector, class_vector,
truncation) # .mul(0.5).add(0.5) # 生成图像标准化，（0.5, 1）
# Biggan生成的是图像域标准照片，需要经过val上的预处理才可以参与训练
if epoch % 500 == 0:
# save_images.save_images(fake_img.detach().cpu(), '{0}/step1_epoch_{1}'.format(basic_path, epoch//500))
save_as_images(
fake_img.detach().cpu(),
'{0}/step1_epoch_{1}'.format(basic_path, epoch // 500))
features_ini = features_ini.cuda()
input = input.cuda() # input已经预处理
input_interpolate = F.interpolate(input,
size=(512, 512),
mode='bilinear',
align_corners=True).cuda()
# 224的图片进行双线性插值，用来reconstruct分辨率更高的图像; 输入到resnet的图像依然需要进行裁剪和归一化
# fake_img_norm: (bs, c, w, h)
# fake_img_norm = _image_norm(fake_img).cuda()
# 11.1 fake_img_norm需要进行val上的预处理才可以参与重构loss计算
# fake_img_norm = trans(convert_to_images(fake_img.cpu())[0]).cuda() # （224, 224)
# fake_img_PIL = save_images.save_images(fake_img, '', save_flag=False)
fake_img_PIL = convert_to_images(
fake_img.cpu())[0] # print('fake_img_PIL:', fake_img_PIL)
fake_img_norm = trans(fake_img_PIL).unsqueeze(0).cuda()
fake_img_norm_interpolate = F.interpolate(fake_img_norm,
size=(512, 512),
mode='bilinear',
align_corners=True).cuda()
_, feature_fake_img = model(fake_img_norm, isda=True)
# TODO: 11.1 待定loss2用224还是512
loss1 = torch.sum((feature_fake_img - features_ini).pow(2))
loss2 = args.eta * torch.sum((fake_img_norm - input).pow(2))
# loss2 = args.eta * torch.sum((fake_img_norm_interpolate - input_interpolate).pow(2))
# loss1 = mse_loss(feature_fake_img, features_ini)
# loss2 = args.eta * mse_loss(fake_img_norm, input)
# loss2 = args.eta * mse_loss(fake_img_norm_interpolate, input_interpolate)
loss_a = loss1 + loss2
opt1.zero_grad()
loss_a.backward(retain_graph=True) # retain_graph=True
opt1.step()
if epoch % 10 == 0:
print(
'Step1: Epoch: %d loss_step1_total: %.1f loss_1: %.5f loss_2: %.5f'
% (epoch, loss_a.data.item(), loss1.data.item(),
loss2.data.item()))
# 复制Step1的重构noise并保存
print('====> Save Reconstruct Noise Vector')
print('noise_vector:\n', noise_vector)
tmp = noise_vector.clone()
tmp = np.array(tmp.detach().cpu().numpy())
np.savetxt('{0}/class_{1}_noise_vector.csv'.format(basic_path, target),
tmp,
delimiter=' ')
'''Step 2'''
'''
def F_inverse(model, netG, input, class_vector, features_ini):
truncation = args.truncation
'''Step 1'''
'''
noise_vector = torch.nn.Parameter(torch.randn(1, 128, requires_grad=True).cuda())
# noise_vector = noise_vector.cuda()
noise_vector.requires_grad = True
print('Initial noise_vector:', noise_vector.size())
# noise_vector_normalized = (noise_vector - noise_vector.mean()).div(noise_vector.std())
# fake_img = netG(noise_vector_normalized, class_vector, truncation)
# fake_img = netG(noise_vector_normalized, class_vector, truncation)
# save_images.save_images(fake_img.detach().cpu(), '{0}/step1_init_fake'.format(basic_path))
# save_as_images(fake_img.detach().cpu(), '{0}/step1_init_fake'.format(basic_path))
mse_loss = torch.nn.MSELoss(reduction='sum')
# opt1 = optim.SGD([{'params': noise_vector}], lr=args.lr1, momentum=0.9, weight_decay=1e-4, nesterov=True)
opt1 = optim.Adam([{'params': noise_vector}], lr=args.lr1, weight_decay=1e-4)
for epoch in range(args.epoch1):
if epoch in args.schedule:
for paras in opt1.param_groups:
paras['lr'] /= 10
print(paras['lr'])
noise_vector_normalized = (noise_vector - noise_vector.mean()).div(noise_vector.std())
fake_img = netG(noise_vector_normalized, class_vector, truncation)
# fake_img = netG(noise_vector, class_vector, truncation) # .mul(0.5).add(0.5) # 生成图像标准化，（0.5, 1）
# Biggan生成的是图像域标准照片，需要经过val上的预处理才可以参与训练
if epoch % args.print_freq == 0:
# save_images.save_images(fake_img.detach().cpu().numpy(), '{0}/step1_epoch_{1}'.format(basic_path, epoch // 500))
save_as_images(fake_img.detach().cpu(), '{0}/step1_epoch_{1}'.format(basic_path, epoch // args.print_freq))
print(noise_vector)
features_ini = features_ini.cuda()
input = input.cuda() # input已经预处理
input_interpolate = F.interpolate(input, size=(args.size, args.size), mode='bilinear', align_corners=True).cuda()
# 224的图片进行双线性插值，用来reconstruct分辨率更高的图像; 输入到resnet的图像依然需要进行裁剪和归一化
# fake_img_norm: (bs, c, w, h)
# fake_img_norm = _image_norm(fake_img).cuda()
# 11.1 fake_img_norm需要进行val上的预处理才可以参与重构loss计算
# fake_img_norm = trans(convert_to_images(fake_img.cpu())[0]).cuda() # （224, 224)
# fake_img_PIL = save_images.save_images(fake_img, '', save_flag=False)
# fake_img_PIL = convert_to_images(fake_img.cpu())[0]
# fake_img_norm = trans(fake_img_PIL).unsqueeze(0).cuda()
# fake_img_norm_interpolate = F.interpolate(fake_img_norm, size=(args.size, args.size), mode='bilinear', align_corners=False).cuda()
fake_img_224 = F.interpolate(fake_img, size=(224, 224), mode='bilinear', align_corners=True)
fake_img_224.require_grad = True
fake_img_norm = (fake_img_224 - fake_img_224.mean()).div(fake_img_224.std())
fake_img_norm.require_grad = True
fake_img_norm = fake_img_norm.cuda()
_, feature_fake_img = model(fake_img_norm, isda=True)
v1, v2, v3, v4, _ = vgg(input)
f1, f2, f3, f4, _ = vgg(fake_img_norm)
# loss1 = torch.sum((feature_fake_img - features_ini).pow(2))
# loss2 = args.eta * torch.sum((fake_img_norm - input).pow(2))
# loss2 = args.eta * torch.sum((fake_img_norm_interpolate - input_interpolate).pow(2))
# loss1 = mse_loss(feature_fake_img, features_ini)
# loss2 = args.eta * mse_loss(fake_img_norm, input)
# loss2 = args.eta * mse_loss(fake_img_norm_interpolate, input_interpolate)
loss1 = 0
if '1' in args.loss_component:
loss1 += mse_loss(f1, v1)
if '2' in args.loss_component:
loss1 += mse_loss(f2, v2)
if '3' in args.loss_component:
loss1 += mse_loss(f3, v3)
if '4' in args.loss_component:
loss1 += mse_loss(f4, v4)
if 'r' in args.loss_component:
loss1 += mse_loss(feature_fake_img, features_ini)
loss2 = args.eta * mse_loss(fake_img_norm, input)
loss_a = loss1 + loss2
opt1.zero_grad()
loss_a.backward(retain_graph=True) # retain_graph=True
opt1.step()
if epoch % 10 == 0:
print('Step1: Epoch: %d loss_step1_total: %.5f loss_1: %.5f loss_2: %.5f' %
(epoch, loss_a.data.item(), loss1.data.item(), loss2.data.item()))
# print('grad:', noise_vector.grad)
# 复制Step1的重构noise并保存
print('====> Save Reconstruct Noise Vector')
print('noise_vector:\n', noise_vector)
tmp = noise_vector.clone()
tmp = np.array(tmp.detach().cpu().numpy())
np.savetxt('{0}/class_{1}_noise_vector.csv'.format(basic_path, target), tmp, delimiter=' ')
'''
'''Step 2'''
import csv
p = "./{0}/class_{1}_noise_vector.csv".format(args.recon_dir, target)
with open(p, encoding='utf-8') as f:
noise = np.loadtxt(f, delimiter=" ")
noise_vector = torch.tensor(noise).cuda()
print('Initial noise_vector:', noise_vector.size())
print("class_vector: ", class_vector.size())
noise_vector_batch = noise_vector.expand(args.aug_num, 128)
noise_vector_batch = torch.nn.Parameter(noise_vector_batch.cuda())
noise_vector_batch.requires_grad = True
class_vector_batch = class_vector.expand(args.aug_num, 1000).cuda()
feature_origin_batch = features_ini.expand(args.aug_num, feature_num).float().cuda()
feature_objective_batch = feature_origin_batch
print('noise_vector_batch: ', noise_vector_batch)
# print('class_vector_batch', class_vector_batch.size())
'''打印重构图片'''
noise_vector = noise_vector.view(1, -1)
noise_vector_normalized = (noise_vector - noise_vector.mean()) / noise_vector.std()
init_fake_img = netG(noise_vector_normalized, class_vector, truncation)
save_as_images(init_fake_img.detach().cpu(), '{0}/reconstruct'.format(basic_path))
q = "./Covariance/{0}_cov_imagenet.csv".format(target)
with open(q, encoding='utf-8') as f:
cov = np.loadtxt(f, delimiter="\n")
CV = np.diag(cov)
print("CV:", CV.shape)
print("====> Start Augmentating")
for i in range(args.aug_num):
aug_np = np.random.multivariate_normal([0 for ij in range(feature_num)], args.aug_alpha * CV)
aug = torch.Tensor(aug_np).float().cuda()
print("aug[{0}]:".format(i), aug.size())
print("feature_origin_batch[i].size(): ", feature_origin_batch[i].size())
feature_objective_batch[i] = (feature_origin_batch[i] + aug).detach()
print("====> End Augmentating")
mse_loss = torch.nn.MSELoss(reduction='sum')
# opt2 = optim.Adam([{'params': noise_vector_batch}], lr=args.lr2, weight_decay=1e-4)
opt2 = optim.SGD([{'params': noise_vector_batch}], lr=args.lr2, momentum=0.9, weight_decay=1e-4, nesterov=True)
for epoch in range(args.epoch2):
if epoch in args.schedule:
for paras in opt2.param_groups:
paras['lr'] /= 10
print("lr:", paras['lr'])
n_mean = noise_vector_batch.mean(axis=1).unsqueeze(1).expand(noise_vector_batch.size(0), noise_vector_batch.size(1))
n_std = noise_vector_batch.std(axis=1).unsqueeze(1).expand(noise_vector_batch.size(0), noise_vector_batch.size(1))
noise_vector_normalized_batch = (noise_vector_batch - n_mean) / n_std
fake_img_batch = netG(noise_vector_normalized_batch, class_vector_batch, truncation)
if epoch % args.print_freq == 0:
for i in range(fake_img_batch.size(0)):
save_as_images(fake_img_batch[i].unsqueeze(0).detach().cpu(),
'{0}/step2_epoch_{1}_img_{2}'.format(basic_path, epoch // args.print_freq, i))
print("noise_vector_batch:", noise_vector_batch)
fake_img_224 = F.interpolate(fake_img_batch, size=(224, 224), mode='bilinear', align_corners=True)
fake_img_224.require_grad = True
# f_mean = fake_img_224.mean(axis=1).unsqueeze(1).expand(fake_img_224.size(0), fake_img_224.size(1), fake_img_224.size(2), fake_img_224.size(3))
# f_std = fake_img_224.std(axis=1).unsqueeze(1).expand(fake_img_224.size(0), fake_img_224.size(1), fake_img_224.size(2), fake_img_224.size(3))
_fake_img_224 = fake_img_224.view(fake_img_224.size(0), -1)
f_mean = _fake_img_224.mean(axis=1).unsqueeze(-1).unsqueeze(-1).unsqueeze(-1).expand(fake_img_224.size(0), 3, 224, 224)
f_std = _fake_img_224.std(axis=1).unsqueeze(-1).unsqueeze(-1).unsqueeze(-1).expand(fake_img_224.size(0), 3, 224, 224)
fake_img_norm = (fake_img_224 - f_mean) / f_std
fake_img_norm = fake_img_norm.cuda()
fake_img_norm.require_grad = True
# print("fake_img_norm[0].mean(): ", fake_img_norm[0].mean())
# print("fake_img_norm[0].std()", fake_img_norm[0].std())
_, feature_fake_img_batch = model(fake_img_norm, isda=True)
loss_b = mse_loss(feature_fake_img_batch, feature_objective_batch)
opt2.zero_grad()
loss_b.backward(retain_graph=True)
opt2.step()
if epoch % 10 == 0:
# print('Step2: Epoch: %d loss_b: %.5f' % (epoch, loss_b.data.item()))
fd = open(loss_file, 'a+')
string = ('Step2: Epoch: {0}\t'
'loss_b {1}\t'.format(epoch, loss_b.data.item()))
print(string)
fd.write(string + '\n')
fd.close()
noise_vector_4 = noise_vector_4.to('cuda')
noise_vector = Variable(noise_vector, requires_grad=True)
class_vector = class_vector.to('cuda')
target_img = target_img.to('cuda')
model.to('cuda')
model.train()
# Generate an image
# with torch.no_grad():
output_tmp = model(noise_vector, class_vector, truncation)
output_tmp = output_tmp.to('cpu')
# output = target_img.to('cpu') # I checked the img, it is correct.
# Save results as png images
save_as_images(output_tmp, j=0)
output_tmp = model(noise_vector_2, class_vector, truncation)
output_tmp = output_tmp.to('cpu')
# output = target_img.to('cpu') # I checked the img, it is correct.
# Save results as png images
save_as_images(output_tmp, j=1)
output_tmp = model(noise_vector_3, class_vector, truncation)
output_tmp = output_tmp.to('cpu')
# output = target_img.to('cpu') # I checked the img, it is correct.
# Save results as png images
save_as_images(output_tmp, j=2)
def F_inverse(model, netG, input, class_vector, features_ini):
truncation = args.truncation
'''Step 1'''
noise_vector = torch.nn.Parameter(
torch.randn(1, 128, requires_grad=True).cuda())
# noise_vector = noise_vector.cuda()
noise_vector.requires_grad = True
print('Initial noise_vector:', noise_vector.size())
mse_loss = torch.nn.MSELoss(reduction='sum')
opt1 = optim.Adam([{
'params': noise_vector
}],
lr=args.lr1,
weight_decay=1e-4)
for epoch in range(args.epoch1):
if epoch in args.schedule1:
for paras in opt1.param_groups:
paras['lr'] /= 10
print(paras['lr'])
noise_vector_normalized = (noise_vector - noise_vector.mean()).div(
noise_vector.std())
fake_img = netG(noise_vector_normalized, class_vector, truncation)
if epoch % args.print_freq == 0:
save_as_images(
fake_img.detach().cpu(),
'{0}/step1_epoch_{1}'.format(basic_path,
epoch // args.print_freq))
features_ini = features_ini.cuda()
input = input.cuda()
input_interpolate = F.interpolate(input,
size=(args.size, args.size),
mode='bilinear',
align_corners=True).cuda()
fake_img_224 = F.interpolate(fake_img,
size=(224, 224),
mode='bilinear',
align_corners=True)
fake_img_224.require_grad = True
fake_img_norm = (fake_img_224 - fake_img_224.mean()).div(
fake_img_224.std())
fake_img_norm.require_grad = True
fake_img_norm = fake_img_norm.cuda()
_, feature_fake_img = model(fake_img_norm, isda=True)
loss1 = mse_loss(feature_fake_img, features_ini)
loss2 = args.eta * mse_loss(fake_img_norm, input)
loss_a = loss1 + loss2
opt1.zero_grad()
loss_a.backward(retain_graph=True) # retain_graph=True
opt1.step()
'''Step 2'''
noise_vector_batch = noise_vector.expand(args.aug_num, 128)
noise_vector_batch = torch.nn.Parameter(noise_vector_batch.cuda())
noise_vector_batch.requires_grad = True
class_vector_batch = class_vector.expand(args.aug_num, 1000).cuda()
feature_origin_batch = features_ini.expand(args.aug_num,
feature_num).float().cuda()
feature_objective_batch = feature_origin_batch
'''save the reconstructed image'''
noise_vector = noise_vector.view(1, -1)
noise_vector_normalized = (noise_vector -
noise_vector.mean()) / noise_vector.std()
init_fake_img = netG(noise_vector_normalized, class_vector, truncation)
save_as_images(init_fake_img.detach().cpu(),
'{0}/reconstruct'.format(basic_path))
q = "./Covariance/{0}_cov_imagenet.csv".format(target)
with open(q, encoding='utf-8') as f:
cov = np.loadtxt(f, delimiter="\n")
CV = np.diag(cov)
print("CV:", CV.shape)
print("====> Start Augmentating")
for i in range(args.aug_num):
aug_np = np.random.multivariate_normal(
[0 for ij in range(feature_num)], args.aug_alpha * CV)
aug = torch.Tensor(aug_np).float().cuda()
print("aug[{0}]:".format(i), aug.size())
print("feature_origin_batch[i].size(): ",
feature_origin_batch[i].size())
feature_objective_batch[i] = (feature_origin_batch[i] + aug).detach()
print("====> End Augmentating")
mse_loss = torch.nn.MSELoss(reduction='sum')
opt2 = optim.SGD([{
'params': noise_vector_batch
}],
lr=args.lr2,
momentum=0.9,
weight_decay=1e-4,
nesterov=True)
for epoch in range(args.epoch2):
if epoch in args.schedule2:
for paras in opt2.param_groups:
paras['lr'] /= 10
print("lr:", paras['lr'])
n_mean = noise_vector_batch.mean(axis=1).unsqueeze(1).expand(
noise_vector_batch.size(0), noise_vector_batch.size(1))
n_std = noise_vector_batch.std(axis=1).unsqueeze(1).expand(
noise_vector_batch.size(0), noise_vector_batch.size(1))
noise_vector_normalized_batch = (noise_vector_batch - n_mean) / n_std
fake_img_batch = netG(noise_vector_normalized_batch,
class_vector_batch, truncation)
if epoch % args.print_freq == 0:
for i in range(fake_img_batch.size(0)):
save_as_images(
fake_img_batch[i].unsqueeze(0).detach().cpu(),
'{0}/step2_epoch_{1}_img_{2}'.format(
basic_path, epoch // args.print_freq, i))
print("noise_vector_batch:", noise_vector_batch)
fake_img_224 = F.interpolate(fake_img_batch,
size=(224, 224),
mode='bilinear',
align_corners=True)
fake_img_224.require_grad = True
_fake_img_224 = fake_img_224.view(fake_img_224.size(0), -1)
f_mean = _fake_img_224.mean(
axis=1).unsqueeze(-1).unsqueeze(-1).unsqueeze(-1).expand(
fake_img_224.size(0), 3, 224, 224)
f_std = _fake_img_224.std(
axis=1).unsqueeze(-1).unsqueeze(-1).unsqueeze(-1).expand(
fake_img_224.size(0), 3, 224, 224)
fake_img_norm = (fake_img_224 - f_mean) / f_std
fake_img_norm = fake_img_norm.cuda()
fake_img_norm.require_grad = True
_, feature_fake_img_batch = model(fake_img_norm, isda=True)
loss_b = mse_loss(feature_fake_img_batch, feature_objective_batch)
opt2.zero_grad()
loss_b.backward(retain_graph=True)
opt2.step()
if epoch % 10 == 0:
# print('Step2: Epoch: %d loss_b: %.5f' % (epoch, loss_b.data.item()))
fd = open(loss_file, 'a+')
string = ('Step2: Epoch: {0}\t'
'loss_b {1}\t'.format(epoch, loss_b.data.item()))
print(string)
fd.write(string + '\n')
fd.close()
