def transfrom_data(NUM_TEST_PER_EPOCH): g2=tf.Graph() g3=tf.Graph() encoded_data=[] original_data=[] val_data=[] val_original=[] train_loader,val_loader= get_data(BATCH_SIZE,BATCH_SIZE) trainiter = iter(train_loader) testiter = iter(val_loader) with g2.as_default(): with tf.Session() as sess2: sargan_model=SARGAN(img_size, BATCH_SIZE, img_channel=1) sargan_saver= tf.train.Saver() sargan_saver = tf.train.import_meta_graph(trained_model_path2+'/sargan_mnist.meta'); sargan_saver.restore(sess2,tf.train.latest_checkpoint(trained_model_path2)); for i in range(NUM_ITERATION): features2, labels = next(trainiter) features2 = features2.data.numpy().transpose(0,2,3,1) features=np.zeros([len(features2),img_size[0],img_size[1],1]) original_images=np.zeros([len(features2),img_size[0],img_size[1],1]) for k in range(len(features)): features[k]=add_gaussian_noise(features2[k], sd=np.random.uniform(NOISE_STD_RANGE[0], NOISE_STD_RANGE[1])) original_images[k,:,:,0]=features2[k,:,:,0] processed_batch=sess2.run(sargan_model.gen_img,feed_dict={sargan_model.image: features, sargan_model.cond: features}) encoded_data.append(processed_batch) original_data.append(original_images) for i in range(NUM_TEST_PER_EPOCH): features2, labels = next(testiter) features2 = features2.data.numpy().transpose(0,2,3,1) features=np.zeros([len(features2),img_size[0],img_size[1],1]) original_images=np.zeros([len(features2),img_size[0],img_size[1],1]) for k in range(len(features)): features[k]=add_gaussian_noise(features2[k], sd=np.random.uniform(NOISE_STD_RANGE[0], NOISE_STD_RANGE[1])) original_images[k,:,:,0]=features2[k,:,:,0] processed_batch=sess2.run(sargan_model.gen_img,feed_dict={sargan_model.image: features, sargan_model.cond: features}) val_original.append(original_images) val_data.append(processed_batch) with g3.as_default(): with tf.Session() as sess3: sargan_model2=SARGAN(img_size, BATCH_SIZE, img_channel=1) sargan_saver2= tf.train.Saver() sargan_saver2 = tf.train.import_meta_graph(trained_model_path3+'/sargan_mnist.meta'); sargan_saver2.restore(sess3,tf.train.latest_checkpoint(trained_model_path3)); for i in range(NUM_ITERATION): encoded_data[i]=sess3.run(sargan_model2.gen_img,feed_dict={sargan_model2.image: encoded_data[i], sargan_model2.cond: encoded_data[i]}) for i in range(NUM_TEST_PER_EPOCH): val_data[i]=sess3.run(sargan_model2.gen_img,feed_dict={sargan_model2.image: val_data[i], sargan_model2.cond: val_data[i]}) return encoded_data, original_data ,val_data, val_original
def transfrom_data(NUM_TEST_PER_EPOCH): encoded_data=[] original_data=[] train_loader= get_data(BATCH_SIZE) trainiter = iter(train_loader) for i in range(NUM_ITERATION): features2, labels = next(trainiter) features2 = np.array(tf.keras.applications.resnet.preprocess_input(features2.data.numpy().transpose(0,2,3,1)*255)) features=np.zeros([len(features2),img_size[0],img_size[1],img_size[2]]) features[:,:,:,0]=(features2[:,:,:,1]) features=np.clip(features+116.779,0,255)/255 original_images=np.copy(features) for k in range(len(features)): features[k]=add_gaussian_noise(features[k], sd=np.random.uniform(NOISE_STD_RANGE[0], NOISE_STD_RANGE[1])) encoded_data.append(np.copy(features)) original_data.append(np.copy(original_images)) gpu_options = tf.GPUOptions(allow_growth=True, visible_device_list=str(GPU_ID)) config = tf.ConfigProto(gpu_options=gpu_options) gx1 = tf.Graph() with gx1.as_default(): with tf.Session(config=config) as sess1: sargan_model1=SARGAN(img_size, BATCH_SIZE, img_channel=1) sargan_saver1= tf.train.Saver() sargan_saver1 = tf.train.import_meta_graph(trained_model_path1+'/sargan_mnist.meta'); sargan_saver1.restore(sess1,tf.train.latest_checkpoint(trained_model_path1)); for ibatch in range(NUM_TEST_PER_EPOCH): processed_batch=sess1.run(sargan_model1.gen_img,feed_dict={sargan_model1.image: encoded_data[ibatch], sargan_model1.cond: encoded_data[ibatch]}) encoded_data[ibatch]=(np.copy(processed_batch)) return encoded_data, original_data
def transfrom_data(NUM_TEST_PER_EPOCH): g2 = tf.Graph() encoded_data = [] original_data = [] val_data = [] val_original = [] train_loader, val_loader = get_data(BATCH_SIZE, BATCH_SIZE) trainiter = iter(train_loader) testiter = iter(val_loader) with g2.as_default(): with tf.Session() as sess2: for i in range(NUM_ITERATION): features2, labels = next(trainiter) features2 = features2.data.numpy().transpose(0, 2, 3, 1) features = np.zeros( [len(features2), img_size[0], img_size[1], 1]) original_images = np.zeros( [len(features2), img_size[0], img_size[1], 1]) for k in range(len(features)): features[k] = add_gaussian_noise(features2[k], sd=np.random.uniform( NOISE_STD_RANGE[0], NOISE_STD_RANGE[1])) original_images[k, :, :, 0] = features2[k, :, :, 0] encoded_data.append(features) original_data.append(original_images) for i in range(NUM_TEST_PER_EPOCH): features2, labels = next(testiter) features2 = features2.data.numpy().transpose(0, 2, 3, 1) features = np.zeros( [len(features2), img_size[0], img_size[1], 1]) original_images = np.zeros( [len(features2), img_size[0], img_size[1], 1]) for k in range(len(features)): features[k] = add_gaussian_noise(features2[k], sd=np.random.uniform( NOISE_STD_RANGE[0], NOISE_STD_RANGE[1])) original_images[k, :, :, 0] = features2[k, :, :, 0] val_data.append(features) val_original.append(original_images) return encoded_data, original_data, val_data, val_original
def blur(batch): #sargan model #reshaping the images to a square newbatch=batch.reshape([len(batch),img_size[0],img_size[1],img_size[2]]) #upping the size of the image#corrupting corruptedbatch=np.zeros([len(newbatch),img_size[0],img_size[1],img_size[2]]) for i in range(len(newbatch)): corruptedbatch[i]=gaussian_filter(np.array([add_gaussian_noise(newbatch[i], sd=np.random.uniform(NOISE_STD_RANGE[0], NOISE_STD_RANGE[1]))]), sigma=2)[0] return corruptedbatch
def get_processed_data(x_batch, img_size, image_index): NOISE_STD_RANGE = [0.0, 0.02] x_batch = np.expand_dims( add_gaussian_noise(x_batch, sd=NOISE_STD_RANGE[1]), 4) channel1 = [] channel2 = [] channel3 = [] num_batches = math.floor(len(x_batch) / 64) differnce = len(x_batch) - num_batches * 64 num_batches2 = num_batches batch1 = np.zeros([64, img_size[0], img_size[1], img_size[2]]) for i in range(num_batches): channel1.append(np.copy(x_batch[(64 * i):(64 * i + 64), :, :, 0])) channel2.append(np.copy(x_batch[(64 * i):(64 * i + 64), :, :, 1])) channel3.append(np.copy(x_batch[(64 * i):(64 * i + 64), :, :, 2])) if (differnce != 0): batch1[0:differnce, :, :, :] = x_batch[(64 * num_batches):( 64 * num_batches + differnce), :, :, 0] channel1.append(np.copy(batch1)) batch1[0:differnce, :, :, :] = x_batch[(64 * num_batches):( 64 * num_batches + differnce), :, :, 1] channel2.append(np.copy(batch1)) batch1[0:differnce, :, :, :] = x_batch[(64 * num_batches):( 64 * num_batches + differnce), :, :, 2] channel3.append(np.copy(batch1)) num_batches2 += 1 channel1, im11, im21, im31, im41 = get_channel1(channel1, img_size, num_batches2, image_index) channel2, im12, im22, im32, im42 = get_channel2(channel2, img_size, num_batches2, image_index) channel3, im13, im23, im33, im43 = get_channel3(channel3, img_size, num_batches2, image_index) im1 = np.stack((im13, im12, im11), axis=2) im2 = np.stack((im23, im22, im21), axis=2) im3 = np.stack((im33, im32, im31), axis=2) im4 = np.stack((im43, im42, im41), axis=2) next_batch = np.zeros([len(x_batch), img_size[0], img_size[1], 3]) for i in range(num_batches): next_batch[(64 * i):(64 * i + 64), :, :, 0] = np.copy(channel1[i][:, :, :, 0]) next_batch[(64 * i):(64 * i + 64), :, :, 1] = np.copy(channel2[i][:, :, :, 0]) next_batch[(64 * i):(64 * i + 64), :, :, 2] = np.copy(channel3[i][:, :, :, 0]) if (differnce != 0): next_batch[(64 * num_batches):(64 * num_batches + differnce), :, :, 0] = np.copy(channel1[num_batches][0:differnce, :, :, 0]) next_batch[(64 * num_batches):(64 * num_batches + differnce), :, :, 1] = np.copy(channel2[num_batches][0:differnce, :, :, 0]) next_batch[(64 * num_batches):(64 * num_batches + differnce), :, :, 2] = np.copy(channel3[num_batches][0:differnce, :, :, 0]) return next_batch, im1, im2, im3, im4
def transfrom_data(NUM_TEST_PER_EPOCH): encoded_data=[] original_data=[] train_loader= get_data(BATCH_SIZE) trainiter = iter(train_loader) for i in range(NUM_ITERATION): features2, labels = next(trainiter) features2 = np.array(tf.keras.applications.resnet.preprocess_input(features2.data.numpy().transpose(0,2,3,1)*255)) features=np.zeros([len(features2),img_size[0],img_size[1],img_size[2]]) features[:,:,:,0]=(features2[:,:,:,0]) features=np.clip(features+103.939,0,255)/255 original_images=np.copy(features) for k in range(len(features)): features[k]=add_gaussian_noise(features[k], sd=np.random.uniform(NOISE_STD_RANGE[0], NOISE_STD_RANGE[1])) encoded_data.append(np.copy(features)) original_data.append(np.copy(original_images)) return encoded_data, original_data
def evaluate_checkpoint(filename): #sys.stdout = open(os.devnull, 'w') #Different graphs for all the models gx1 = tf.Graph() gx2 = tf.Graph() gx3 = tf.Graph() gx4 = tf.Graph() with tf.Session() as sess: # Restore the checkpoint saver.restore(sess, filename) # Iterate over the samples batch-by-batch #number of batches num_batches = int(math.ceil(num_eval_examples / eval_batch_size)) x_blur_list4 = [] x_adv_list4 = [] #Storing y values train_loader = get_data(BATCH_SIZE) trainiter = iter(cycle(train_loader)) for ibatch in range(num_batches): x_batch2, y_batch = next(trainiter) x_batch2 = np.array(x_batch2.data.numpy().transpose(0, 2, 3, 1)) x_batch = np.zeros([len(x_batch2), img_size[0] * img_size[1]]) x_batch3 = np.zeros([img_size[0], img_size[1]]) x_batch3[:, :] = x_batch2[0, :, :, 0] * 255 nextimage = Image.fromarray(x_batch3.astype(np.uint8)) nextimage.save("MNIST_NATURALX0", "JPEG") for i in range(len(x_batch2)): x_batch[i] = x_batch2[i].reshape([img_size[0] * img_size[1]]) x_batch_adv = attack.perturb(x_batch, y_batch, sess) x_batch2 = np.zeros( [len(x_batch), img_size[0], img_size[1], img_size[2]]) x_batch_adv2 = np.zeros( [len(x_batch), img_size[0], img_size[1], img_size[2]]) for k in range(len(x_batch)): x_batch2[k] = add_gaussian_noise( x_batch[k].reshape([img_size[0], img_size[1], img_size[2]]), sd=np.random.uniform(NOISE_STD_RANGE[1], NOISE_STD_RANGE[1])) x_batch_adv2[k] = add_gaussian_noise(x_batch_adv[k].reshape( [img_size[0], img_size[1], img_size[2]]), sd=np.random.uniform( NOISE_STD_RANGE[1], NOISE_STD_RANGE[1])) x_blur_list4.append(x_batch2) x_adv_list4.append(x_batch_adv2) x_batch3 = np.zeros([img_size[0], img_size[1]]) x_batch3[:, :] = x_blur_list4[0][0, :, :, 0] * 255 nextimage = Image.fromarray(x_batch3.astype(np.uint8)) nextimage.save("MNIST_BLURX0", "JPEG") x_batch3 = np.zeros([img_size[0], img_size[1]]) x_batch3[:, :] = x_adv_list4[0][0, :, :, 0] * 255 nextimage = Image.fromarray(x_batch3.astype(np.uint8)) nextimage.save("MNIST_ADVX0", "JPEG") #Running through first autoencoder with gx1.as_default(): with tf.Session() as sess2: sargan_model = SARGAN(img_size, BATCH_SIZE, img_channel=1) sargan_saver = tf.train.Saver() sargan_saver = tf.train.import_meta_graph(trained_model_path + '/sargan_mnist.meta') sargan_saver.restore( sess2, tf.train.latest_checkpoint(trained_model_path)) for ibatch in range(num_batches): processed_batch = sess2.run(sargan_model.gen_img, feed_dict={ sargan_model.image: x_adv_list4[ibatch], sargan_model.cond: x_adv_list4[ibatch] }) x_adv_list4[ibatch] = processed_batch blurred_batch = sess2.run(sargan_model.gen_img, feed_dict={ sargan_model.image: x_blur_list4[ibatch], sargan_model.cond: x_blur_list4[ibatch] }) x_blur_list4[ibatch] = blurred_batch x_batch3[:, :] = x_blur_list4[0][0, :, :, 0] * 255 nextimage = Image.fromarray(x_batch3.astype(np.uint8)) nextimage.save("MNIST_BLURX1", "JPEG") x_batch3 = np.zeros([img_size[0], img_size[1]]) x_batch3[:, :] = x_adv_list4[0][0, :, :, 0] * 255 nextimage = Image.fromarray(x_batch3.astype(np.uint8)) nextimage.save("MNIST_ADVX1", "JPEG") with gx2.as_default(): with tf.Session() as sessx2: sargan_model2 = SARGAN(img_size, BATCH_SIZE, img_channel=1) sargan_saver2 = tf.train.Saver() sargan_saver2 = tf.train.import_meta_graph(trained_model_path2 + '/sargan_mnist.meta') sargan_saver2.restore( sessx2, tf.train.latest_checkpoint(trained_model_path2)) for ibatch in range(num_batches): processed_batch = sessx2.run(sargan_model2.gen_img, feed_dict={ sargan_model2.image: x_adv_list4[ibatch], sargan_model2.cond: x_adv_list4[ibatch] }) x_adv_list4[ibatch] = (processed_batch) blurred_batch = sessx2.run(sargan_model2.gen_img, feed_dict={ sargan_model2.image: x_blur_list4[ibatch], sargan_model2.cond: x_blur_list4[ibatch] }) x_blur_list4[ibatch] = (blurred_batch) x_batch3 = np.zeros([img_size[0], img_size[1]]) x_batch3[:, :] = x_blur_list4[0][0, :, :, 0] * 255 nextimage = Image.fromarray(x_batch3.astype(np.uint8)) nextimage.save("MNIST_BLURX2", "JPEG") x_batch3 = np.zeros([img_size[0], img_size[1]]) x_batch3[:, :] = x_adv_list4[0][0, :, :, 0] * 255 nextimage = Image.fromarray(x_batch3.astype(np.uint8)) nextimage.save("MNIST_ADVX2", "JPEG") with gx3.as_default(): with tf.Session() as sessx3: sargan_model3 = SARGAN(img_size, BATCH_SIZE, img_channel=1) sargan_saver3 = tf.train.Saver() sargan_saver3 = tf.train.import_meta_graph(trained_model_path3 + '/sargan_mnist.meta') sargan_saver3.restore( sessx3, tf.train.latest_checkpoint(trained_model_path3)) for ibatch in range(num_batches): processed_batch = sessx3.run(sargan_model3.gen_img, feed_dict={ sargan_model3.image: x_adv_list4[ibatch], sargan_model3.cond: x_adv_list4[ibatch] }) x_adv_list4[ibatch] = processed_batch blurred_batch = sessx3.run(sargan_model3.gen_img, feed_dict={ sargan_model3.image: x_blur_list4[ibatch], sargan_model3.cond: x_blur_list4[ibatch] }) x_blur_list4[ibatch] = blurred_batch x_batch3 = np.zeros([img_size[0], img_size[1]]) x_batch3[:, :] = x_blur_list4[0][0, :, :, 0] * 255 nextimage = Image.fromarray(x_batch3.astype(np.uint8)) nextimage.save("MNIST_BLURX3", "JPEG") x_batch3 = np.zeros([img_size[0], img_size[1]]) x_batch3[:, :] = x_adv_list4[0][0, :, :, 0] * 255 nextimage = Image.fromarray(x_batch3.astype(np.uint8)) nextimage.save("MNIST_ADVX3", "JPEG") #Final autoencoder setup with gx4.as_default(): with tf.Session() as sessx4: sargan_model4 = SARGAN(img_size, BATCH_SIZE, img_channel=1) sargan_saver4 = tf.train.Saver() sargan_saver4 = tf.train.import_meta_graph(trained_model_path4 + '/sargan_mnist.meta') sargan_saver4.restore( sessx4, tf.train.latest_checkpoint(trained_model_path4)) for ibatch in range(num_batches): processed_batch = sessx4.run(sargan_model4.gen_img, feed_dict={ sargan_model4.image: x_adv_list4[ibatch], sargan_model4.cond: x_adv_list4[ibatch] }) x_adv_list4[ibatch] = processed_batch.reshape( [len(x_batch), img_size[0] * img_size[1]]) x_batch3 = np.zeros([img_size[0], img_size[1]]) x_batch3[:, :] = processed_batch[0, :, :, 0] * 255 nextimage = Image.fromarray(x_batch3.astype(np.uint8)) nextimage.save("MNIST_ADVX4", "JPEG") blurred_batch = sessx4.run(sargan_model4.gen_img, feed_dict={ sargan_model4.image: x_blur_list4[ibatch], sargan_model4.cond: x_blur_list4[ibatch] }) x_blur_list4[ibatch] = blurred_batch.reshape( [len(x_batch), img_size[0] * img_size[1]]) x_batch3 = np.zeros([img_size[0], img_size[1]]) x_batch3[:, :] = blurred_batch[0, :, :, 0] * 255 nextimage = Image.fromarray(x_batch3.astype(np.uint8)) nextimage.save("MNIST_BLURX4", "JPEG")
def main(args): image_number = 0 model = SARGAN(img_size, BATCH_SIZE, img_channel=img_size[2]) with tf.variable_scope("d_opt", reuse=tf.AUTO_REUSE): d_opt = tf.train.AdamOptimizer(learning_rate=LEARNING_RATE).minimize( model.d_loss, var_list=model.d_vars) with tf.variable_scope("g_opt", reuse=tf.AUTO_REUSE): g_opt = tf.train.AdamOptimizer(learning_rate=LEARNING_RATE).minimize( model.g_loss, var_list=model.g_vars) saver = tf.train.Saver(max_to_keep=20) gpu_options = tf.GPUOptions(allow_growth=True, visible_device_list=str(GPU_ID)) config = tf.ConfigProto(gpu_options=gpu_options) progress_bar = tqdm(range(MAX_EPOCH), unit="epoch") #list of loss values each item is the loss value of one ieteration train_d_loss_values = [] train_g_loss_values = [] #test_imgs, test_classes = get_data(test_filename) #imgs, classes = get_data(train_filename) with tf.Session(config=config) as sess: sess.run(tf.global_variables_initializer()) #copies = imgs.astype('float32') #test_copies = test_imgs.astype('float32') for epoch in progress_bar: train_loader, val_loader = get_data_loader(BATCH_SIZE, BATCH_SIZE) counter = 0 epoch_start_time = time.time() #shuffle(copies) #divide the images into equal sized batches #image_batches = np.array(list(chunks(copies, BATCH_SIZE))) trainiter = iter(train_loader) for i in range(NUM_ITERATION): #getting a batch from the training data #one_batch_of_imgs = image_batches[i] features2, labels = next(trainiter) features2 = features2.data.numpy().transpose(0, 2, 3, 1) * 255 features = np.zeros( [len(features2), img_size[0], img_size[1], 1]) for i in range(len(features2)): nextimage = Image.fromarray( (features2[i]).astype(np.uint8)) nextimage = nextimage.convert('L') features[i, :, :, 0] = np.array(nextimage, dtype='float32') / 255 #copy the batch features_copy = features.copy() #corrupt the images corrupted_batch = np.array([ add_gaussian_noise(image, sd=np.random.uniform( NOISE_STD_RANGE[1], NOISE_STD_RANGE[1])) for image in features_copy ]) for i in range(len(corrupted_batch)): corrupted_batch[i] = gaussian_filter(corrupted_batch[i], sigma=1) _, m = sess.run([d_opt, model.d_loss], feed_dict={ model.image: features, model.cond: corrupted_batch }) _, M = sess.run([g_opt, model.g_loss], feed_dict={ model.image: features, model.cond: corrupted_batch }) train_d_loss_values.append(m) train_g_loss_values.append(M) #print some notifications counter += 1 if counter % 25 == 0: print("\rEpoch [%d], Iteration [%d]: time: %4.4f, d_loss: %.8f, g_loss: %.8f" \ % (epoch, counter, time.time() - epoch_start_time, m, M)) # save the trained network if epoch % SAVE_EVERY_EPOCH == 0: save_path = saver.save(sess, (trained_model_path + "/sargan_mnist")) print("\n\nModel saved in file: %s\n\n" % save_path) ''' +\ "%s_model_%s.ckpt" % ( experiment_name, epoch+1))''' ##### TESTING FOR CURRUNT EPOCH testiter = iter(val_loader) NUM_TEST_PER_EPOCH = 1 #test_batches = np.array(list(chunks(test_copies, BATCH_SIZE))) #test_images = test_batches[0] sum_psnr = 0 list_images = [] for j in range(NUM_TEST_PER_EPOCH): features2, labels = next(trainiter) features2 = features2.data.numpy().transpose(0, 2, 3, 1) * 255 features = np.zeros( [len(features2), img_size[0], img_size[1], 1]) for i in range(len(features2)): nextimage = Image.fromarray( (features2[i]).astype(np.uint8)) nextimage = nextimage.convert('L') features[i, :, :, 0] = np.array(nextimage, dtype='float32') / 255 batch_copy = features.copy() #corrupt the images corrupted_batch = np.array([ add_gaussian_noise(image, sd=np.random.uniform( NOISE_STD_RANGE[0], NOISE_STD_RANGE[1])) for image in batch_copy ]) for i in range(len(corrupted_batch)): corrupted_batch[i] = gaussian_filter(corrupted_batch[i], sigma=1) gen_imgs = sess.run(model.gen_img, feed_dict={ model.image: features, model.cond: corrupted_batch }) print(features.shape, gen_imgs.shape) #if j %17 == 0: # only save 3 images 0, 17, 34 list_images.append( (features[0], corrupted_batch[0], gen_imgs[0])) list_images.append( (features[17], corrupted_batch[17], gen_imgs[17])) list_images.append( (features[34], corrupted_batch[34], gen_imgs[34])) for i in range(len(gen_imgs)): current_img = features[i] recovered_img = gen_imgs[i] sum_psnr += ski_me.compare_psnr(current_img, recovered_img, 1) #psnr_value = ski_mem.compare_psnr(test_img, gen_img, 1) #sum_psnr += psnr_value average_psnr = sum_psnr / 50 epoch_running_time = time.time() - epoch_start_time ############### SEND EMAIL ############## rows = 1 cols = 3 display_mean = np.array([0.485, 0.456, 0.406]) display_std = np.array([0.229, 0.224, 0.225]) if epoch % SAVE_EVERY_EPOCH == 0: #image = std * image + mean imgs_1 = list_images[0] imgs_2 = list_images[1] imgs_3 = list_images[2] imgs_1 = display_std * imgs_1 + display_mean imgs_2 = display_std * imgs_2 + display_mean imgs_3 = display_std * imgs_3 + display_mean fig = plt.figure(figsize=(14, 4)) ax = fig.add_subplot(rows, cols, 1) ax.imshow(imgs_1[0]) ax.set_title("Original", color='grey') ax = fig.add_subplot(rows, cols, 2) ax.imshow(imgs_1[1]) ax.set_title("Corrupted", color='grey') ax = fig.add_subplot(rows, cols, 3) ax.imshow(imgs_1[2]) ax.set_title("Recovered", color='grey') plt.tight_layout() #sample_test_file_1 = os.path.join(output_path, '%s_epoch_%s_batchsize_%s_1.jpg' % (experiment_name, epoch, BATCH_SIZE)) sample_test_file_1 = os.path.join( output_path, 'image_%d_1.jpg' % image_number) plt.savefig(sample_test_file_1, dpi=300) fig = plt.figure(figsize=(14, 4)) ax = fig.add_subplot(rows, cols, 1) ax.imshow(imgs_2[0]) ax.set_title("Original", color='grey') ax = fig.add_subplot(rows, cols, 2) ax.imshow(imgs_2[1]) ax.set_title("Corrupted", color='grey') ax = fig.add_subplot(rows, cols, 3) ax.imshow(imgs_2[2]) ax.set_title("Recovered", color='grey') plt.tight_layout() #sample_test_file_2 = os.path.join(output_path, '%s_epoch_%s_batchsize_%s_2.jpg' % (experiment_name, epoch, BATCH_SIZE)) sample_test_file_2 = os.path.join( output_path, 'image_%d_2.jpg' % image_number) plt.savefig(sample_test_file_2, dpi=300) fig = plt.figure(figsize=(14, 4)) ax = fig.add_subplot(rows, cols, 1) ax.imshow(imgs_3[0]) ax.set_title("Original", color='grey') ax = fig.add_subplot(rows, cols, 2) ax.imshow(imgs_3[1]) ax.set_title("Corrupted", color='grey') ax = fig.add_subplot(rows, cols, 3) ax.imshow(imgs_3[2]) ax.set_title("Recovered", color='grey') plt.tight_layout() #sample_test_file_3 = os.path.join(output_path, '%s_epoch_%s_batchsize_%s_3.jpg' % (experiment_name, epoch, BATCH_SIZE)) sample_test_file_3 = os.path.join( output_path, 'image_%d_3.jpg' % image_number) image_number += 1 plt.savefig(sample_test_file_3, dpi=300) plt.close("all")
def evaluate_checkpoint(filename): #sys.stdout = open(os.devnull, 'w') #Different graphs for all the models gx1 = tf.Graph() gx2 = tf.Graph() gx3 = tf.Graph() gx4 = tf.Graph() g3 = tf.Graph() with tf.Session() as sess: # Restore the checkpoint saver.restore(sess, filename) # Iterate over the samples batch-by-batch #number of batches num_batches = int(math.ceil(num_eval_examples / eval_batch_size)) - 1 total_xent_nat = 0. total_xent_corr = 0. total_corr_nat = 0. total_corr_corr = 0. total_corr_adv = np.zeros([4]).astype(dtype='float32') total_corr_blur = np.zeros([4]).astype(dtype='float32') total_xent_adv = np.zeros([4]).astype(dtype='float32') total_xent_blur = np.zeros([4]).astype(dtype='float32') #storing the various images x_batch_list = [] x_corr_list = [] x_blur_list1 = [] x_adv_list1 = [] x_blur_list2 = [] x_adv_list2 = [] x_blur_list3 = [] x_adv_list3 = [] x_blur_list4 = [] x_adv_list4 = [] #Storing y values y_batch_list = [] train_loader = get_data(BATCH_SIZE) trainiter = iter(cycle(train_loader)) for ibatch in range(num_batches): x_batch2, y_batch = next(trainiter) y_batch_list.append(y_batch) x_batch2 = np.array(x_batch2.data.numpy().transpose(0, 2, 3, 1)) x_batch = np.zeros([len(x_batch2), img_size[0] * img_size[1]]) for i in range(len(x_batch2)): x_batch[i] = x_batch2[i].reshape([img_size[0] * img_size[1]]) x_batch_adv = attack.perturb(x_batch, y_batch, sess) x_batch2 = np.zeros( [len(x_batch), img_size[0], img_size[1], img_size[2]]) x_batch_adv2 = np.zeros( [len(x_batch), img_size[0], img_size[1], img_size[2]]) for k in range(len(x_batch)): x_batch2[k] = add_gaussian_noise( x_batch[k].reshape([img_size[0], img_size[1], img_size[2]]), sd=np.random.uniform(NOISE_STD_RANGE[1], NOISE_STD_RANGE[1])) x_batch_adv2[k] = add_gaussian_noise(x_batch_adv[k].reshape( [img_size[0], img_size[1], img_size[2]]), sd=np.random.uniform( NOISE_STD_RANGE[1], NOISE_STD_RANGE[1])) x_batch_list.append(x_batch) x_corr_list.append(x_batch_adv) x_blur_list4.append(x_batch2) x_adv_list4.append(x_batch_adv2) #Running through first autoencoder with gx1.as_default(): with tf.Session() as sess2: sargan_model = SARGAN(img_size, BATCH_SIZE, img_channel=1) sargan_saver = tf.train.Saver() sargan_saver = tf.train.import_meta_graph(trained_model_path + '/sargan_mnist.meta') sargan_saver.restore( sess2, tf.train.latest_checkpoint(trained_model_path)) for ibatch in range(num_batches): processed_batch = sess2.run(sargan_model.gen_img, feed_dict={ sargan_model.image: x_adv_list4[ibatch], sargan_model.cond: x_adv_list4[ibatch] }) x_adv_list4[ibatch] = processed_batch blurred_batch = sess2.run(sargan_model.gen_img, feed_dict={ sargan_model.image: x_blur_list4[ibatch], sargan_model.cond: x_blur_list4[ibatch] }) x_blur_list4[ibatch] = blurred_batch #adding images to first autoencoder data set x_blur_list1.append( blurred_batch.reshape( [len(x_batch), img_size[0] * img_size[1]])) x_adv_list1.append( processed_batch.reshape( [len(x_batch), img_size[0] * img_size[1]])) psnr = 0 for jj in range(num_batches): next_psnr = 0 psnr_value = (tf.image.psnr(np.array(x_batch_list[jj]).reshape( [64, img_size[0], img_size[1], img_size[2]]), np.array(x_adv_list4[jj]).reshape([ 64, img_size[0], img_size[1], img_size[2] ]), max_val=1)) psnr_value = sess2.run(psnr_value) for i in range(64): next_psnr += psnr_value[i] psnr += next_psnr / 64 psnr /= num_batches print("Not actual PSNR= ", psnr, "\n\n\n") with gx2.as_default(): with tf.Session() as sessx2: sargan_model2 = SARGAN(img_size, BATCH_SIZE, img_channel=1) sargan_saver2 = tf.train.Saver() sargan_saver2 = tf.train.import_meta_graph(trained_model_path2 + '/sargan_mnist.meta') sargan_saver2.restore( sessx2, tf.train.latest_checkpoint(trained_model_path2)) for ibatch in range(num_batches): processed_batch = sessx2.run(sargan_model2.gen_img, feed_dict={ sargan_model2.image: x_adv_list4[ibatch], sargan_model2.cond: x_adv_list4[ibatch] }) x_adv_list4[ibatch] = (processed_batch) blurred_batch = sessx2.run(sargan_model2.gen_img, feed_dict={ sargan_model2.image: x_blur_list4[ibatch], sargan_model2.cond: x_blur_list4[ibatch] }) x_blur_list4[ibatch] = (blurred_batch) #adding images to second autoencoder data set x_blur_list2.append( blurred_batch.reshape( [len(x_batch), img_size[0] * img_size[1]])) x_adv_list2.append( processed_batch.reshape( [len(x_batch), img_size[0] * img_size[1]])) with gx3.as_default(): with tf.Session() as sessx3: sargan_model3 = SARGAN(img_size, BATCH_SIZE, img_channel=1) sargan_saver3 = tf.train.Saver() sargan_saver3 = tf.train.import_meta_graph(trained_model_path3 + '/sargan_mnist.meta') sargan_saver3.restore( sessx3, tf.train.latest_checkpoint(trained_model_path3)) for ibatch in range(num_batches): processed_batch = sessx3.run(sargan_model3.gen_img, feed_dict={ sargan_model3.image: x_adv_list4[ibatch], sargan_model3.cond: x_adv_list4[ibatch] }) x_adv_list4[ibatch] = processed_batch blurred_batch = sessx3.run(sargan_model3.gen_img, feed_dict={ sargan_model3.image: x_blur_list4[ibatch], sargan_model3.cond: x_blur_list4[ibatch] }) x_blur_list4[ibatch] = blurred_batch #adding images to third autoencoder data set x_blur_list3.append( blurred_batch.reshape( [len(x_batch), img_size[0] * img_size[1]])) x_adv_list3.append( processed_batch.reshape( [len(x_batch), img_size[0] * img_size[1]])) #Final autoencoder setup with gx4.as_default(): with tf.Session() as sessx4: sargan_model4 = SARGAN(img_size, BATCH_SIZE, img_channel=1) sargan_saver4 = tf.train.Saver() sargan_saver4 = tf.train.import_meta_graph(trained_model_path4 + '/sargan_mnist.meta') sargan_saver4.restore( sessx4, tf.train.latest_checkpoint(trained_model_path4)) for ibatch in range(num_batches): processed_batch = sessx4.run(sargan_model4.gen_img, feed_dict={ sargan_model4.image: x_adv_list4[ibatch], sargan_model4.cond: x_adv_list4[ibatch] }) x_adv_list4[ibatch] = processed_batch.reshape( [len(x_batch), img_size[0] * img_size[1]]) blurred_batch = sessx4.run(sargan_model4.gen_img, feed_dict={ sargan_model4.image: x_blur_list4[ibatch], sargan_model4.cond: x_blur_list4[ibatch] }) x_blur_list4[ibatch] = blurred_batch.reshape( [len(x_batch), img_size[0] * img_size[1]]) psnr = 0 for jj in range(num_batches): next_psnr = 0 psnr_value = (tf.image.psnr(np.array(x_batch_list[jj]).reshape( [64, img_size[0], img_size[1], img_size[2]]), np.array(x_adv_list4[jj]).reshape([ 64, img_size[0], img_size[1], img_size[2] ]), max_val=1)) psnr_value = sessx4.run(psnr_value) for i in range(64): next_psnr += psnr_value[i] psnr += next_psnr / 64 psnr /= num_batches print("\n\nPSNR= ", psnr, "\n\n") with g3.as_default(): model3 = Model() saver2 = tf.train.Saver() with tf.Session() as sess3: saver2.restore(sess3, filename) for ibatch in range(num_batches): cur_xent_adv = np.zeros([4]).astype(dtype='float32') cur_xent_blur = np.zeros([4]).astype(dtype='float32') cur_corr_adv = np.zeros([4]).astype(dtype='float32') cur_corr_blur = np.zeros([4]).astype(dtype='float32') dict_nat = { model3.x_input: x_batch_list[ibatch], model3.y_input: y_batch_list[ibatch] } dict_corr = { model3.x_input: x_corr_list[ibatch], model3.y_input: y_batch_list[ibatch] } #First autoencoder dictionary dict_adv1 = { model3.x_input: x_adv_list1[ibatch], model3.y_input: y_batch_list[ibatch] } dict_blur1 = { model3.x_input: x_blur_list1[ibatch], model3.y_input: y_batch_list[ibatch] } #Second autoencoder dictionary dict_adv2 = { model3.x_input: x_adv_list2[ibatch], model3.y_input: y_batch_list[ibatch] } dict_blur2 = { model3.x_input: x_blur_list2[ibatch], model3.y_input: y_batch_list[ibatch] } #Third autoencoder dictionary dict_adv3 = { model3.x_input: x_adv_list3[ibatch], model3.y_input: y_batch_list[ibatch] } dict_blur3 = { model3.x_input: x_blur_list3[ibatch], model3.y_input: y_batch_list[ibatch] } #Fourth autoencoder dictionary dict_adv4 = { model3.x_input: x_adv_list4[ibatch], model3.y_input: y_batch_list[ibatch] } dict_blur4 = { model3.x_input: x_blur_list4[ibatch], model3.y_input: y_batch_list[ibatch] } #Regular Images cur_corr_nat, cur_xent_nat = sess3.run( [model3.num_correct, model3.xent], feed_dict=dict_nat) cur_corr_corr, cur_xent_corr = sess3.run( [model3.num_correct, model3.xent], feed_dict=dict_corr) #First autoencoder dictionary cur_corr_blur[0], cur_xent_blur[0] = sess3.run( [model3.num_correct, model3.xent], feed_dict=dict_blur1) cur_corr_adv[0], cur_xent_adv[0] = sess3.run( [model3.num_correct, model3.xent], feed_dict=dict_adv1) #Second autoencoder dictionary cur_corr_blur[1], cur_xent_blur[1] = sess3.run( [model3.num_correct, model3.xent], feed_dict=dict_blur2) cur_corr_adv[1], cur_xent_adv[1] = sess3.run( [model3.num_correct, model3.xent], feed_dict=dict_adv2) #Third autoencoder dictionary cur_corr_blur[2], cur_xent_blur[2] = sess3.run( [model3.num_correct, model3.xent], feed_dict=dict_blur3) cur_corr_adv[2], cur_xent_adv[2] = sess3.run( [model3.num_correct, model3.xent], feed_dict=dict_adv3) #Fourth autoencoder dictionary cur_corr_blur[3], cur_xent_blur[3] = sess3.run( [model3.num_correct, model3.xent], feed_dict=dict_blur4) cur_corr_adv[3], cur_xent_adv[3] = sess3.run( [model3.num_correct, model3.xent], feed_dict=dict_adv4) #Natural total_corr_nat += cur_corr_nat total_corr_corr += cur_corr_corr total_xent_nat += cur_xent_nat total_xent_corr += cur_xent_corr #running accuracy total_corr_adv += cur_corr_adv total_corr_blur += cur_corr_blur total_xent_adv += cur_xent_adv total_xent_blur += cur_xent_blur #Regual images avg_xent_nat = total_xent_nat / num_eval_examples avg_xent_corr = total_xent_corr / num_eval_examples acc_nat = total_corr_nat / num_eval_examples acc_corr = total_corr_corr / num_eval_examples #Total accuracy acc_adv = total_corr_adv / num_eval_examples acc_blur = total_corr_blur / num_eval_examples avg_xent_adv = total_xent_adv / num_eval_examples avg_xent_blur = total_xent_blur / num_eval_examples #sys.stdout = sys.__stdout__ print("No Autoencoder") print('natural: {:.2f}%'.format(100 * acc_nat)) print('Corrupted: {:.2f}%'.format(100 * acc_corr)) print('avg nat loss: {:.4f}'.format(avg_xent_nat)) print('avg corr loss: {:.4f} \n'.format(avg_xent_corr)) print("First Autoencoder") print('natural with blur: {:.2f}%'.format(100 * acc_blur[0])) print('adversarial: {:.2f}%'.format(100 * acc_adv[0])) print('avg nat with blur loss: {:.4f}'.format(avg_xent_blur[0])) print('avg adv loss: {:.4f} \n'.format(avg_xent_adv[0])) print("Second Autoencoder") print('natural with blur: {:.2f}%'.format(100 * acc_blur[1])) print('adversarial: {:.2f}%'.format(100 * acc_adv[1])) print('avg nat with blur loss: {:.4f}'.format(avg_xent_blur[1])) print('avg adv loss: {:.4f} \n'.format(avg_xent_adv[1])) print("Third Autoencoder") print('natural with blur: {:.2f}%'.format(100 * acc_blur[2])) print('adversarial: {:.2f}%'.format(100 * acc_adv[2])) print('avg nat with blur loss: {:.4f}'.format(avg_xent_blur[2])) print('avg adv loss: {:.4f} \n'.format(avg_xent_adv[2])) print("Fourth Autoencoder") print('natural with blur: {:.2f}%'.format(100 * acc_blur[3])) print('adversarial: {:.2f}%'.format(100 * acc_adv[3])) print('avg nat with blur loss: {:.4f}'.format(avg_xent_blur[3])) print('avg adv loss: {:.4f} \n'.format(avg_xent_adv[3]))
def get_processed_data(x_batch, img_size, GPU_ID): NOISE_STD_RANGE = [0.0, 0.02] x_batch = np.expand_dims( add_gaussian_noise(x_batch, sd=NOISE_STD_RANGE[1]), 4) channel1 = [] channel2 = [] channel3 = [] num_batches = math.floor(len(x_batch) / 64) differnce = len(x_batch) - num_batches * 64 num_batches2 = num_batches batch1 = np.zeros([64, img_size[0], img_size[1], img_size[2]]) for i in range(num_batches): channel1.append(np.copy(x_batch[(64 * i):(64 * i + 64), :, :, 0])) channel2.append(np.copy(x_batch[(64 * i):(64 * i + 64), :, :, 1])) channel3.append(np.copy(x_batch[(64 * i):(64 * i + 64), :, :, 2])) if (differnce != 0): batch1[0:differnce, :, :, :] = x_batch[(64 * num_batches):( 64 * num_batches + differnce), :, :, 0] channel1.append(np.copy(batch1)) batch1[0:differnce, :, :, :] = x_batch[(64 * num_batches):( 64 * num_batches + differnce), :, :, 1] channel2.append(np.copy(batch1)) batch1[0:differnce, :, :, :] = x_batch[(64 * num_batches):( 64 * num_batches + differnce), :, :, 2] channel3.append(np.copy(batch1)) num_batches2 += 1 blur_batch11, blur_batch21, blur_batch31, blur_batch41 = get_channel1( channel1, img_size, num_batches2, GPU_ID) blur_batch12, blur_batch22, blur_batch32, blur_batch42 = get_channel2( channel2, img_size, num_batches2, GPU_ID) blur_batch13, blur_batch23, blur_batch33, blur_batch43 = get_channel3( channel3, img_size, num_batches2, GPU_ID) next_batch1 = np.zeros([len(x_batch), img_size[0], img_size[1], 3]) next_batch2 = np.zeros([len(x_batch), img_size[0], img_size[1], 3]) next_batch3 = np.zeros([len(x_batch), img_size[0], img_size[1], 3]) next_batch4 = np.zeros([len(x_batch), img_size[0], img_size[1], 3]) for i in range(num_batches): next_batch1[(64 * i):(64 * i + 64), :, :, 0] = np.copy(blur_batch11[i][:, :, :, 0]) next_batch1[(64 * i):(64 * i + 64), :, :, 1] = np.copy(blur_batch12[i][:, :, :, 0]) next_batch1[(64 * i):(64 * i + 64), :, :, 2] = np.copy(blur_batch13[i][:, :, :, 0]) next_batch2[(64 * i):(64 * i + 64), :, :, 0] = np.copy(blur_batch21[i][:, :, :, 0]) next_batch2[(64 * i):(64 * i + 64), :, :, 1] = np.copy(blur_batch22[i][:, :, :, 0]) next_batch2[(64 * i):(64 * i + 64), :, :, 2] = np.copy(blur_batch23[i][:, :, :, 0]) next_batch3[(64 * i):(64 * i + 64), :, :, 0] = np.copy(blur_batch31[i][:, :, :, 0]) next_batch3[(64 * i):(64 * i + 64), :, :, 1] = np.copy(blur_batch32[i][:, :, :, 0]) next_batch3[(64 * i):(64 * i + 64), :, :, 2] = np.copy(blur_batch33[i][:, :, :, 0]) next_batch4[(64 * i):(64 * i + 64), :, :, 0] = np.copy(blur_batch41[i][:, :, :, 0]) next_batch4[(64 * i):(64 * i + 64), :, :, 1] = np.copy(blur_batch42[i][:, :, :, 0]) next_batch4[(64 * i):(64 * i + 64), :, :, 2] = np.copy(blur_batch43[i][:, :, :, 0]) if (differnce != 0): next_batch1[(64 * num_batches):(64 * num_batches + differnce), :, :, 0] = np.copy(blur_batch11[num_batches][0:differnce, :, :, 0]) next_batch1[(64 * num_batches):(64 * num_batches + differnce), :, :, 1] = np.copy(blur_batch12[num_batches][0:differnce, :, :, 0]) next_batch1[(64 * num_batches):(64 * num_batches + differnce), :, :, 2] = np.copy(blur_batch13[num_batches][0:differnce, :, :, 0]) next_batch2[(64 * num_batches):(64 * num_batches + differnce), :, :, 0] = np.copy(blur_batch21[num_batches][0:differnce, :, :, 0]) next_batch2[(64 * num_batches):(64 * num_batches + differnce), :, :, 1] = np.copy(blur_batch22[num_batches][0:differnce, :, :, 0]) next_batch2[(64 * num_batches):(64 * num_batches + differnce), :, :, 2] = np.copy(blur_batch23[num_batches][0:differnce, :, :, 0]) next_batch3[(64 * num_batches):(64 * num_batches + differnce), :, :, 0] = np.copy(blur_batch31[num_batches][0:differnce, :, :, 0]) next_batch3[(64 * num_batches):(64 * num_batches + differnce), :, :, 1] = np.copy(blur_batch32[num_batches][0:differnce, :, :, 0]) next_batch3[(64 * num_batches):(64 * num_batches + differnce), :, :, 2] = np.copy(blur_batch33[num_batches][0:differnce, :, :, 0]) next_batch4[(64 * num_batches):(64 * num_batches + differnce), :, :, 0] = np.copy(blur_batch41[num_batches][0:differnce, :, :, 0]) next_batch4[(64 * num_batches):(64 * num_batches + differnce), :, :, 1] = np.copy(blur_batch42[num_batches][0:differnce, :, :, 0]) next_batch4[(64 * num_batches):(64 * num_batches + differnce), :, :, 2] = np.copy(blur_batch43[num_batches][0:differnce, :, :, 0]) return next_batch1, next_batch2, next_batch3, next_batch4
def main(args): image_number = 0 model = SARGAN(img_size, BATCH_SIZE, img_channel=1) with tf.variable_scope("d_opt", reuse=tf.AUTO_REUSE): d_opt = tf.train.AdamOptimizer(learning_rate=LEARNING_RATE).minimize( model.d_loss, var_list=model.d_vars) with tf.variable_scope("g_opt", reuse=tf.AUTO_REUSE): g_opt = tf.train.AdamOptimizer(learning_rate=LEARNING_RATE).minimize( model.g_loss, var_list=model.g_vars) saver = tf.train.Saver(max_to_keep=20) gpu_options = tf.GPUOptions(allow_growth=True, visible_device_list=str(GPU_ID)) config = tf.ConfigProto(gpu_options=gpu_options) progress_bar = tqdm(range(MAX_EPOCH), unit="epoch") #list of loss values each item is the loss value of one ieteration train_d_loss_values = [] train_g_loss_values = [] #test_imgs, test_classes = get_data(test_filename) #imgs, classes = get_data(train_filename) with tf.Session(config=config) as sess: sess.run(tf.global_variables_initializer()) #copies = imgs.astype('float32') #test_copies = test_imgs.astype('float32') for epoch in progress_bar: train_loader, val_loader = get_data_loader(BATCH_SIZE, BATCH_SIZE) counter = 0 epoch_start_time = time.time() #shuffle(copies) #divide the images into equal sized batches #image_batches = np.array(list(chunks(copies, BATCH_SIZE))) trainiter = iter(train_loader) for i in range(NUM_ITERATION): #getting a batch from the training data #one_batch_of_imgs = image_batches[i] features, labels = next(trainiter) features = features.data.numpy().transpose(0, 2, 3, 1) #copy the batch features_copy = features.copy() #corrupt the images corrupted_batch = np.array([ add_gaussian_noise(image / 1.5, sd=np.random.uniform( NOISE_STD_RANGE[0], NOISE_STD_RANGE[1])) for image in features_copy ]) for i in range(len(corrupted_batch)): corrupted_batch[i] = gaussian_filter(corrupted_batch[i], sigma=1) corrupted_batch = np.array([ add_gaussian_noise(image, sd=np.random.uniform( NOISE_STD_RANGE[0], NOISE_STD_RANGE[1] / 2)) for image in corrupted_batch ]) _, m = sess.run([d_opt, model.d_loss], feed_dict={ model.image: features, model.cond: corrupted_batch }) _, M = sess.run([g_opt, model.g_loss], feed_dict={ model.image: features, model.cond: corrupted_batch }) train_d_loss_values.append(m) train_g_loss_values.append(M) #print some notifications counter += 1 if counter % 25 == 0: print("\rEpoch [%d], Iteration [%d]: time: %4.4f, d_loss: %.8f, g_loss: %.8f" \ % (epoch, counter, time.time() - epoch_start_time, m, M)) # save the trained network if epoch % SAVE_EVERY_EPOCH == 0: save_path = saver.save(sess, (trained_model_path + "/sargan_mnist")) print("\n\nModel saved in file: %s\n\n" % save_path) ''' +\ "%s_model_%s.ckpt" % ( experiment_name, epoch+1))''' ##### TESTING FOR CURRUNT EPOCH testiter = iter(val_loader) NUM_TEST_PER_EPOCH = 1 #test_batches = np.array(list(chunks(test_copies, BATCH_SIZE))) #test_images = test_batches[0] sum_psnr = 0 list_images = [] for j in range(NUM_TEST_PER_EPOCH): features, labels = next(testiter) features = features.data.numpy() features = features.transpose(0, 2, 3, 1) batch_copy = features.copy() #corrupt the images corrupted_batch = np.array([ add_gaussian_noise(image / 1.5, sd=np.random.uniform( NOISE_STD_RANGE[0], NOISE_STD_RANGE[1])) for image in batch_copy ]) for i in range(len(corrupted_batch)): corrupted_batch[i] = gaussian_filter(corrupted_batch[i], sigma=1) corrupted_batch = np.array([ add_gaussian_noise(image, sd=np.random.uniform( NOISE_STD_RANGE[0], NOISE_STD_RANGE[1] / 2)) for image in corrupted_batch ]) gen_imgs = sess.run(model.gen_img, feed_dict={ model.image: features, model.cond: corrupted_batch }) #if j %17 == 0: # only save 3 images 0, 17, 34 list_images.append( (features[0], corrupted_batch[0], gen_imgs[0])) list_images.append( (features[17], corrupted_batch[17], gen_imgs[17])) list_images.append( (features[34], corrupted_batch[34], gen_imgs[34])) for i in range(len(gen_imgs)): current_img = features[i] recovered_img = gen_imgs[i] sum_psnr += ski_me.compare_psnr(current_img, recovered_img, 2) #psnr_value = ski_mem.compare_psnr(test_img, gen_img, 1) #sum_psnr += psnr_value average_psnr = sum_psnr / 50 epoch_running_time = time.time() - epoch_start_time ############### SEND EMAIL ############## rows = 1 cols = 3 display_mean = np.array([0, 0, 0]) display_std = np.array([1, 1, 1]) if epoch % SAVE_EVERY_EPOCH == 0: #image = std * image + mean imgs_1 = list_images[0] imgs_2 = list_images[1] imgs_3 = list_images[2] imgs_1 = display_std * imgs_1 + display_mean imgs_2 = display_std * imgs_2 + display_mean imgs_3 = display_std * imgs_3 + display_mean fig = plt.figure(figsize=(14, 4)) ax = fig.add_subplot(rows, cols, 1) ax.imshow(imgs_1[0]) ax.set_title("Original", color='grey') ax = fig.add_subplot(rows, cols, 2) ax.imshow(imgs_1[1]) ax.set_title("Corrupted", color='grey') ax = fig.add_subplot(rows, cols, 3) ax.imshow(imgs_1[2]) ax.set_title("Recovered", color='grey') plt.tight_layout() #sample_test_file_1 = os.path.join(output_path, '%s_epoch_%s_batchsize_%s_1.jpg' % (experiment_name, epoch, BATCH_SIZE)) sample_test_file_1 = os.path.join( output_path, 'image_%d_1.jpg' % image_number) plt.savefig(sample_test_file_1, dpi=300) fig = plt.figure(figsize=(14, 4)) ax = fig.add_subplot(rows, cols, 1) ax.imshow(imgs_2[0]) ax.set_title("Original", color='grey') ax = fig.add_subplot(rows, cols, 2) ax.imshow(imgs_2[1]) ax.set_title("Corrupted", color='grey') ax = fig.add_subplot(rows, cols, 3) ax.imshow(imgs_2[2]) ax.set_title("Recovered", color='grey') plt.tight_layout() #sample_test_file_2 = os.path.join(output_path, '%s_epoch_%s_batchsize_%s_2.jpg' % (experiment_name, epoch, BATCH_SIZE)) sample_test_file_2 = os.path.join( output_path, 'image_%d_2.jpg' % image_number) plt.savefig(sample_test_file_2, dpi=300) fig = plt.figure(figsize=(14, 4)) ax = fig.add_subplot(rows, cols, 1) ax.imshow(imgs_3[0]) ax.set_title("Original", color='grey') ax = fig.add_subplot(rows, cols, 2) ax.imshow(imgs_3[1]) ax.set_title("Corrupted", color='grey') ax = fig.add_subplot(rows, cols, 3) ax.imshow(imgs_3[2]) ax.set_title("Recovered", color='grey') plt.tight_layout() #sample_test_file_3 = os.path.join(output_path, '%s_epoch_%s_batchsize_%s_3.jpg' % (experiment_name, epoch, BATCH_SIZE)) sample_test_file_3 = os.path.join( output_path, 'image_%d_3.jpg' % image_number) image_number += 1 plt.savefig(sample_test_file_3, dpi=300) '''attachments = [sample_test_file_1, sample_test_file_2, sample_test_file_3] email_alert_subject = "Epoch %s %s SARGAN" % (epoch+1, experiment_name.upper()) email_alert_text = """ Epoch [{}/{}] EXPERIMENT PARAMETERS: Learning rate: {} Batch size: {} Max epoch number: {} Training iterations each epoch: {} noise standard deviation: {} Running time: {:.2f} [s] AVERAGE PSNR VALUE ON 50 TEST IMAGES: {} """.format(epoch + 1, MAX_EPOCH, LEARNING_RATE, BATCH_SIZE, MAX_EPOCH, NUM_ITERATION, ((NOISE_STD_RANGE[0] + NOISE_STD_RANGE[1])/2), epoch_running_time, average_psnr) if epoch % SAVE_EVERY_EPOCH == 0: send_images_via_email(email_alert_subject, email_alert_text, attachments, sender_email="*****@*****.**", recipient_emails=["*****@*****.**"])''' plt.close("all")
def evaluate_checkpoint(filename): #sys.stdout = open(os.devnull, 'w') g2 = tf.Graph() gx2 = tf.Graph() gx3 = tf.Graph() gx4 = tf.Graph() g3 = tf.Graph() loop_list_adv = np.zeros([2, number_of_runs]) loop_list_auto = np.zeros([2, number_of_runs]) epsilonc = starting_pert with tf.Session() as sess: # Restore the checkpoint saver.restore(sess, tf.train.latest_checkpoint(model_dir)) # Iterate over the samples batch-by-batch num_batches = int(math.ceil(num_eval_examples / eval_batch_size)) x_corr_list = [] x_adv_list = [] y_batch_list = [] train_loader = get_data(BATCH_SIZE) trainiter = iter(cycle(train_loader)) for ibatch in range(num_batches): x_batch2, y_batch = next(trainiter) y_batch_list.append(y_batch) x_batch2 = np.array(x_batch2.data.numpy().transpose(0, 2, 3, 1)) x_batch = np.zeros([len(x_batch2), img_size[0] * img_size[1]]) for i in range(len(x_batch2)): x_batch[i] = x_batch2[i].reshape([img_size[0] * img_size[1]]) x_batch_adv = attacks[ibatch].perturb(x_batch, y_batch, sess) x_batch_adv2 = np.zeros( [len(x_batch), img_size[0], img_size[1], img_size[2]]) for k in range(len(x_batch)): x_batch_adv2[k] = add_gaussian_noise(x_batch_adv[k].reshape( [img_size[0], img_size[1], img_size[2]]), sd=np.random.uniform( NOISE_STD_RANGE[1], NOISE_STD_RANGE[1])) x_corr_list.append(x_batch_adv) x_adv_list.append(x_batch_adv2) with g2.as_default(): with tf.Session() as sess2: sargan_model = SARGAN(img_size, BATCH_SIZE, img_channel=1) sargan_saver = tf.train.Saver() sargan_saver = tf.train.import_meta_graph(trained_model_path + '/sargan_mnist.meta') sargan_saver.restore( sess2, tf.train.latest_checkpoint(trained_model_path)) for ibatch in range(num_batches): processed_batch = sess2.run(sargan_model.gen_img, feed_dict={ sargan_model.image: x_adv_list[ibatch], sargan_model.cond: x_adv_list[ibatch] }) x_adv_list[ibatch] = processed_batch with gx2.as_default(): with tf.Session() as sessx2: sargan_model2 = SARGAN(img_size, BATCH_SIZE, img_channel=1) sargan_saver2 = tf.train.Saver() sargan_saver2 = tf.train.import_meta_graph(trained_model_path2 + '/sargan_mnist.meta') sargan_saver2.restore( sessx2, tf.train.latest_checkpoint(trained_model_path2)) for ibatch in range(num_batches): processed_batch = sessx2.run(sargan_model2.gen_img, feed_dict={ sargan_model2.image: x_adv_list[ibatch], sargan_model2.cond: x_adv_list[ibatch] }) x_adv_list[ibatch] = (processed_batch) with gx3.as_default(): with tf.Session() as sessx3: sargan_model3 = SARGAN(img_size, BATCH_SIZE, img_channel=1) sargan_saver3 = tf.train.Saver() sargan_saver3 = tf.train.import_meta_graph(trained_model_path3 + '/sargan_mnist.meta') sargan_saver3.restore( sessx3, tf.train.latest_checkpoint(trained_model_path3)) for ibatch in range(num_batches): processed_batch = sessx3.run(sargan_model3.gen_img, feed_dict={ sargan_model3.image: x_adv_list[ibatch], sargan_model3.cond: x_adv_list[ibatch] }) x_adv_list[ibatch] = processed_batch with gx4.as_default(): with tf.Session() as sessx4: sargan_model4 = SARGAN(img_size, BATCH_SIZE, img_channel=1) sargan_saver4 = tf.train.Saver() sargan_saver4 = tf.train.import_meta_graph(trained_model_path4 + '/sargan_mnist.meta') sargan_saver4.restore( sessx4, tf.train.latest_checkpoint(trained_model_path4)) for ibatch in range(num_batches): processed_batch = sessx4.run(sargan_model4.gen_img, feed_dict={ sargan_model4.image: x_adv_list[ibatch], sargan_model4.cond: x_adv_list[ibatch] }) x_adv_list[ibatch] = processed_batch.reshape( [len(x_batch), img_size[0] * img_size[1]]) with g3.as_default(): model3 = Model() saver2 = tf.train.Saver() with tf.Session() as sess3: saver2.restore(sess3, filename) for ibatch in range(num_batches): dict_corr = { model3.x_input: x_corr_list[ibatch], model3.y_input: y_batch_list[ibatch] } dict_adv = { model3.x_input: x_adv_list[ibatch], model3.y_input: y_batch_list[ibatch] } cur_corr_corr, cur_xent_corr = sess3.run( [model3.num_correct, model3.xent], feed_dict=dict_corr) cur_corr_adv, cur_xent_adv = sess3.run( [model3.num_correct, model3.xent], feed_dict=dict_adv) loop_list_adv[0, ibatch] = epsilonc loop_list_adv[1, ibatch] = cur_corr_adv / eval_batch_size loop_list_auto[0, ibatch] = epsilonc loop_list_auto[1, ibatch] = cur_corr_corr / eval_batch_size epsilonc += change '''summary = tf.Summary(value=[ tf.Summary.Value(tag='xent adv eval', simple_value= avg_xent_adv), tf.Summary.Value(tag='xent adv', simple_value= avg_xent_adv), tf.Summary.Value(tag='xent nat', simple_value= avg_xent_nat), tf.Summary.Value(tag='accuracy adv eval', simple_value= acc_adv), tf.Summary.Value(tag='accuracy adv', simple_value= acc_adv), tf.Summary.Value(tag='accuracy nat', simple_value= acc_nat)]) summary_writer.add_summary(summary, global_step.eval(sess3))''' #sys.stdout = sys.__stdout__ return loop_list_adv, loop_list_auto