def attack_all(self, models, samples=500, pixels=(1,3,5), targeted=False, maxiter=75, popsize=400, verbose=False): results = [] for model in models: model_results = [] valid_imgs = self.correct_imgs[self.correct_imgs.name == model.name].img img_samples = np.random.choice(valid_imgs, samples) for pixel_count in pixels: for i,img in enumerate(img_samples): print(model.name, '- image', img, '-', i+1, '/', len(img_samples)) targets = [None] if not targeted else range(10) for target in targets: if (targeted): print('Attacking with target', class_names[target]) if (target == self.y_test[img,0]): continue result = self.attack(img, model, target, pixel_count, maxiter=maxiter, popsize=popsize, verbose=verbose) model_results.append(result) results += model_results helper.checkpoint(results, targeted) return results
def attack_all(self, models, samples=10000, pixels=(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), targeted=False, maxiter=75, popsize=400, verbose=False): results = [] for model in models: model_results = [] valid_imgs = self.correct_imgs[self.correct_imgs.name == model.name].img img_samples = np.random.choice(valid_imgs, samples) #img_samples = valid_imgs for pixel_count in pixels: for i, img in enumerate(img_samples): print(model.name, '- image', img, '-', i + 1, '/', len(img_samples)) targets = [None] if not targeted else range(10) for target in targets: if (targeted): # print('Attacking with target', class_names[target]) if (target == self.y_test[img, 0]): continue result = self.attack(img, model, target, pixel_count, maxiter=maxiter, popsize=popsize, verbose=verbose) # print('------------------------------------qzh') # print(result) # print('------------------------------------qzh') model_results.append(result) results += model_results helper.checkpoint(results, targeted) return results
def attack_all(self, models, samples=500, pixels=(1, 3, 5), targeted=False, maxiter=75, popsize=400, info='', verbose=False): """ @models: list of models to evaluate @samples: how many random samples to take from provided data @pixels: iterable controlling what attack sizes to iterate through @targeted: boolean, whether you want to test targeted attacks or not @maxiter: maximum iterations on the optimization @popsize: population size at each iteration of the optimization @info: string to attach to results pickle filename @verbose: bool, controls printing """ results = [] for model in models: model_results = [] valid_imgs = self.correct_imgs[self.correct_imgs.name == model.name].img img_samples = np.random.choice(valid_imgs, samples) for pixel_count in pixels: for i, img in enumerate(img_samples): print(model.name, '- image', img, '-', i + 1, '/', len(img_samples)) targets = [None] if not targeted else range(10) for target in targets: if (targeted): print('Attacking with target', class_names[target]) if (target == self.y_test[img, 0]): continue result = self.attack(img, model, target, pixel_count, maxiter=maxiter, popsize=popsize, verbose=verbose) model_results.append(result) results += model_results helper.checkpoint(results, targeted, info) return results
def training_loop(dataloader_RGB, dataloader_Depth, test_dataloader_RGB, test_dataloader_Depth, n_epochs=1000): print_every = 10 losses = [] test_iter_RGB = iter(test_dataloader_RGB) test_iter_Depth = iter(test_dataloader_Depth) fixed_RGB = test_iter_RGB.next()[0] fixed_Depth = test_iter_Depth.next()[0] fixed_RGB = scale(fixed_RGB) fixed_Depth = scale(fixed_Depth) iter_RGB = iter(dataloader_RGB) iter_Depth = iter(dataloader_Depth) batches_per_epoch = min(len(iter_RGB), len(iter_Depth)) for epoch in range(1, n_epochs + 1): if epoch % batches_per_epoch == 0: iter_RGB = iter(dataloader_RGB) iter_Depth = iter(dataloader_Depth) images_RGB, _ = iter_RGB.next() images_RGB = scale(images_RGB) images_Depth, _ = iter_Depth.next() images_Depth = scale(images_Depth) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") images_RGB = images_RGB.to(device) images_Depth = images_Depth.to(device) #-------------------------------------Discriminator Training-----------------------------------------------------# # optimizers are initialized to zero so that they don't carry forward the errors form previous epochs. Basically to # to avoid any accumulation optimizer_disc_A.zero_grad() # Discriminator-A is initially checked for its performance with real image out_RGB = disc_A(images_RGB) disc_A_real_loss = real_mse_loss(out_RGB) # A fake image is generated by the generator to check the Discriminator's performance with fake image fake_RGB = gen_B2A(images_Depth) out_RGB = disc_A(fake_RGB) disc_A_fake_loss = fake_mse_loss(out_RGB) # Losses produced while the above operations are added which is the total loss of the Discriminator-A. It is backpropogated disc_A_loss = disc_A_real_loss + disc_A_fake_loss disc_A_loss.backward() optimizer_disc_A.step() # Same operations as mentioned above are now performed on Discriminator-B optimizer_disc_B.zero_grad() out_Depth = disc_B(images_Depth) disc_B_real_loss = real_mse_loss(out_Depth) fake_Depth = gen_A2B(images_RGB) out_Depth = disc_B(fake_Depth) disc_B_fake_loss = fake_mse_loss(out_Depth) disc_B_loss = disc_B_real_loss + disc_B_fake_loss disc_B_loss.backward() optimizer_disc_B.step() #------------------------------------------Generator Training---------------------------------------------------# optimizer_gen.zero_grad() # An image is produced from the generator (in this case generator-B2A is being trained) is produced to check how well it can fake_RGB = gen_B2A(images_Depth) # The generated image is then fed to discrminator to check the fakeness and the MSE loss is received out_RGB = disc_A(fake_RGB) gen_B2A_loss = real_mse_loss(out_RGB) # To check the consistency, the generated image is fed to other generator(A2B in this case) and reconstructed image is received reconstructed_Depth = gen_A2B(fake_RGB) # Reconstruction loss is received by comparing two images as mentioned in step(4) of training generators reconstructed_Depth_loss = cycle_consistency_loss(images_Depth, reconstructed_Depth, lambda_weight=10) # Same operations are done, but this time to train gen_A2B fake_Depth = gen_A2B(images_RGB) out_Depth = disc_B(fake_Depth) gen_A2B_loss = real_mse_loss(out_Depth) reconstructed_RGB = gen_B2A(fake_Depth) reconstructed_RGB_loss = cycle_consistency_loss(images_RGB, reconstructed_RGB, lambda_weight=10) # Losses from both the generators are received and propogated backwards g_total_loss = gen_B2A_loss + gen_A2B_loss + reconstructed_Depth_loss + reconstructed_RGB_loss g_total_loss.backward() optimizer_gen.step() # Weight decay as mentioned earlier learningRate_scheduler_gen.step() learningRate_scheduler_disc_A.step() learningRate_scheduler_disc_B.step() if epoch % print_every == 0: losses.append( (disc_A_loss.item(), disc_B_loss.item(), g_total_loss.item())) print( 'Epoch [{:5d}/{:5d}] | d_X_loss: {:6.4f} | d_Y_loss: {:6.4f} | g_total_loss: {:6.4f}' .format(epoch, n_epochs, disc_A_loss.item(), disc_B_loss.item(), g_total_loss.item())) # A training sample is saved every given time to check the performance of our network sample_every = 100 if epoch % sample_every == 0: gen_B2A.eval() gen_A2B.eval() save_samples(epoch, fixed_Depth, fixed_RGB, gen_B2A, gen_A2B, batch_size=16) gen_B2A.train() gen_A2B.train() # Models are saved after every given number of epochs checkpoint_every = 1000 # Save the model parameters if epoch % checkpoint_every == 0: checkpoint(epoch, gen_A2B, gen_B2A, disc_A, disc_B) return losses
torchvision.utils.save_image(grid_image, path) print('Saved {}'.format(path)) Y_fake = G_YtoX(images_Y) grid_image_real = torchvision.utils.make_grid( images_Y.cpu()) grid_image_fake = torchvision.utils.make_grid(Y_fake.cpu()) grid_image = torch.cat((grid_image_real, grid_image_fake), 1) path = filename + '_' + 'YtoX.jpg' torchvision.utils.save_image(grid_image, path) print('Saved {}'.format(path)) # save models after certein epoch if epoch > 2: helper.checkpoint(epoch, idx, G_XtoY, G_YtoX, D_X, D_Y, save_path) # Print the log info if epoch % print_every == 0: losses.append((epoch_d_x_loss, epoch_d_y_loss, epoch_g_total_loss)) print( 'Epoch [{:5d}/{:5d}] | d_X_loss: {:6.4f} | d_Y_loss: {:6.4f} | g_total_loss: {:6.4f}' .format(epoch, n_epochs, epoch_d_x_loss, epoch_d_y_loss, epoch_g_total_loss)) # update scheduler if is_scheduler: g_lr_scheduler.step() d_x_lr_scheduler.step() d_y_lr_scheduler.step()