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()