Add files via upload

Author: missionfission

Checkpoints/-47999.index

@@ -0,0 +1,6 @@
+model_checkpoint_path: "-47999"
+all_model_checkpoint_paths: "-47199"
+all_model_checkpoint_paths: "-47399"
+all_model_checkpoint_paths: "-47599"
+all_model_checkpoint_paths: "-47799"
+all_model_checkpoint_paths: "-47999"

Checkpoints/-47999.meta

@@ -0,0 +1,37 @@
+import tensorflow as tf
+
+from utils import *
+
+import tensorflow.contrib.slim as slim
+
+def conv_layer(input_image, ksize, in_channels, out_channels, stride, scope_name, activation_function=lrelu, reuse=False):
+    with tf.variable_scope(scope_name, reuse=reuse):
+        filter = tf.Variable(tf.random_normal([ksize, ksize, in_channels, out_channels], stddev=0.03))
+        output = tf.nn.conv2d(input_image, filter, strides=[1, stride, stride, 1], padding='SAME')
+        output = slim.batch_norm(output)
+        if activation_function:
+            output = activation_function(output)
+        return output, filter
+
+def resize_deconvolution_layer(input_tensor, new_shape, scope_name):
+    with tf.variable_scope(scope_name):
+        output = tf.image.resize_images(input_tensor, (new_shape[1], new_shape[2]), method=1)
+        output, unused_weights = conv_layer(output, 3, new_shape[3]*2, new_shape[3], 1, scope_name+"_deconv")
+        return output
+
+def deconvolution_layer(input_tensor, new_shape, scope_name):
+    return resize_deconvolution_layer(input_tensor, new_shape, scope_name)
+
+def residual_layer(input_image, ksize, in_channels, out_channels, stride, scope_name):
+    with tf.variable_scope(scope_name):
+        output, filter = conv_layer(input_image, ksize, in_channels, out_channels, stride, scope_name+"_conv1")
+        output, filter = conv_layer(output, ksize, out_channels, out_channels, stride, scope_name+"_conv2")
+        output = tf.add(output, tf.identity(input_image))
+        return output, filter
+
+def transpose_deconvolution_layer(input_tensor, used_weights, new_shape, stride, scope_name):
+    with tf.varaible_scope(scope_name):
+        output = tf.nn.conv2d_transpose(input_tensor, used_weights, output_shape=new_shape, strides=[1, stride, stride, 1], padding='SAME')
+        output = tf.nn.relu(output)
+        return output
+

Checkpoints/checkpoint

@@ -0,0 +1,35 @@
+import cv2
+import numpy as np
+import glob
+import os
+
+img_dir='/media/khushal/679f068d-921b-4d14-890f-3081c1728f98/Rephrase/rephrase_data/test/*'
+deg_dir='/media/khushal/679f068d-921b-4d14-890f-3081c1728f98/Rephrase/rephrase_data/degrade_test/'
+
+  
+def degrade(input_path: str, output_path: str) -> None:
+        """Load image at `input_path`, distort and save as `output_path`"""
+        SHIFT = 2
+        image = cv2.imread(input_path)
+        orig_img=image
+        to_swap = np.random.choice([False, True], image.shape[:2], p=[.8, .2])
+        swap_indices = np.where(to_swap[:-SHIFT] & ~to_swap[SHIFT:])
+        swap_vals = image[swap_indices[0] + SHIFT, swap_indices[1]]
+        image[swap_indices[0] + SHIFT, swap_indices[1]] = image[swap_indices]
+        image[swap_indices] = swap_vals
+        cv2.imwrite(output_path, image)
+
+
+imgtypes= glob.glob(img_dir)
+base_imgtypes=[os.path.basename(f) for f in imgtypes]
+print(base_imgtypes)
+for i in range(83):
+        # os.makedirs(deg_dir+base_imgtypes[i])
+        class_img=glob.glob(imgtypes[i]+"/*.jpg")
+        img_name=[os.path.basename(f) for f in class_img]
+        # print(img_name)
+        for j in range(len(class_img)):
+                f=class_img[j]
+                degrade(f,deg_dir+base_imgtypes[i]+"/"+img_name[j])
+        # print(len(class_img))
+

output_small/out_0.png

@@ -0,0 +1,32 @@
+import numpy as np
+import tensorflow as tf
+import tensorflow.contrib.slim as slim
+from utils import *
+from conv_helper import *
+
+
+def generator(input):
+    conv1, conv1_weights = conv_layer(input, 9, 3, 32, 1, "g_conv1")
+    conv2, conv2_weights = conv_layer(conv1, 3, 32, 64, 1, "g_conv2")
+    conv3, conv3_weights = conv_layer(conv2, 3, 64, 128, 1, "g_conv3")
+
+    res1, res1_weights = residual_layer(conv3, 3, 128, 128, 1, "g_res1")
+    # res2, res2_weights = residual_layer(res1, 3, 128, 128, 1, "g_res2")
+    # res3, res3_weights = residual_layer(res2, 3, 128, 128, 1, "g_res3")
+    deconv1 = deconvolution_layer(res1, [BATCH_SIZE, 128, 128, 64], 'g_deconv1')
+    deconv2 = deconvolution_layer(deconv1, [BATCH_SIZE, 256, 256, 32], "g_deconv2")
+    deconv2 = deconv2 + conv1
+    conv4, conv4_weights = conv_layer(deconv2, 9, 32, 3, 1, "g_conv5", activation_function=tf.nn.tanh)
+    conv4 = conv4 + input
+    return conv4
+
+def discriminator(input, reuse=False):
+    conv1, conv1_weights = conv_layer(input, 4, 3, 48, 2, "d_conv1", reuse=reuse)
+    conv2, conv2_weights = conv_layer(conv1, 4, 48, 96, 2, "d_conv2", reuse=reuse)
+    conv3, conv3_weights = conv_layer(conv2, 4, 96, 192, 2, "d_conv3", reuse=reuse)
+    conv4, conv4_weights = conv_layer(conv3, 4, 192, 384, 2, "d_conv4", reuse=reuse)
+    conv5, conv5_weights = conv_layer(conv4, 4, 384, 1, 2, "d_conv5", reuse=reuse)
+    conv6, conv6_weights = conv_layer(conv5, 4, 1, 1, 2, "d_conv6", reuse=reuse)
+    avgpool = tf.nn.avg_pool(conv6, ksize=(1,4,4,1), strides=(1,1,1,1), padding='VALID')
+    out=tf.nn.sigmoid(avgpool)
+    return out

output_small/out_1.png

@@ -0,0 +1,55 @@
+import time
+import os
+import re
+import sys
+import glob
+import scipy.misc
+from itertools import cycle
+import cv2
+
+import tensorflow as tf
+import numpy as np
+
+from utils import *
+from model import *
+font                   = cv2.FONT_HERSHEY_SIMPLEX
+bottomLeftCornerOfText = (10,250)
+fontScale              = 1
+fontColor              = (255,255,255)
+lineType               = 2
+
+
+from skimage import measure
+TESTING_SET_DIR= '../rephrase_data/degrade_test/'
+GROUNDTRUTH_TEST_SET_DIR='../rephrase_data/test/'
+OUT_DIR='../rephrase_data/output_small/'
+BATCH_SIZE = 20
+def test():
+    tf.reset_default_graph()
+
+    global_step = tf.Variable(0, dtype=tf.int32, trainable=False, name='global_step')
+    gen_in = tf.placeholder(shape=[None, BATCH_SHAPE[1], BATCH_SHAPE[2], BATCH_SHAPE[3]], dtype=tf.float32, name='generated_image')
+    real_in = tf.placeholder(shape=[None, BATCH_SHAPE[1], BATCH_SHAPE[2], BATCH_SHAPE[3]], dtype=tf.float32, name='groundtruth_image')
+    Gz = generator(gen_in)  
+    init = tf.global_variables_initializer()
+    with tf.Session() as sess:
+        sess.run(init)
+        saver = initialize(sess)
+        initial_step = global_step.eval()
+        start_time = time.time()
+        initial_step = 0
+        total_iteration = 2  
+        for index in range(initial_step, total_iteration):
+            test_batch=next(test_pool)
+            test_image = (test_batch)*std+mean
+            ground_test_batch=next(ground_test_pool) 
+            out_image = sess.run(Gz, feed_dict={gen_in: test_batch})
+            out_image = (out_image)*std+mean
+            for j in range(20):
+                img_save=np.hstack((test_image[j],out_image[j],ground_test_batch[j]))
+                cv2.putText(img_save,'Distorted         Generated       GroundTruth', bottomLeftCornerOfText,  font,   fontScale, fontColor, lineType)
+                cv2.imwrite(OUT_DIR+'out_%d.png' % (20*index+j), img_save)
+
+testing_dataset_init()
+testing_truth_dataset_init()
+test()

output_small/out_10.png

@@ -0,0 +1,79 @@
+import time
+
+import tensorflow as tf
+import numpy as np
+import matplotlib.pyplot as plt
+from utils import *
+from model import *
+
+from skimage import measure
+
+from tensorflow.python.client import device_lib 
+
+
+def train():
+    tf.reset_default_graph()
+
+    global_step = tf.Variable(0, dtype=tf.int32, trainable=False, name='global_step')
+
+    gen_in = tf.placeholder(shape=[None, BATCH_SHAPE[1], BATCH_SHAPE[2], BATCH_SHAPE[3]], dtype=tf.float32, name='generated_image')
+    real_in = tf.placeholder(shape=[None, BATCH_SHAPE[1], BATCH_SHAPE[2], BATCH_SHAPE[3]], dtype=tf.float32, name='groundtruth_image')
+    Gz = generator(gen_in)
+    Dx = discriminator(real_in)
+    Dg = discriminator(Gz, reuse=True)
+    lr_v = tf.Variable(lr_init)
+    real_in_bgr = tf.map_fn(lambda img: RGB_TO_BGR(img), real_in)
+    Gz_bgr = tf.map_fn(lambda img: RGB_TO_BGR(img), Gz)
+
+    psnr=0
+    ssim=0
+    d_loss = -tf.reduce_mean(tf.log(1-Dx) + tf.log(Dg)) * ADVERSARIAL_LOSS_FACTOR
+    g_loss = ADVERSARIAL_LOSS_FACTOR * -tf.reduce_mean(tf.log(1-Dg)) +  PIXEL_LOSS_FACTOR * (get_pixel_loss(real_in, Gz)) 
+    t_vars = tf.trainable_variables()
+    d_vars = [var for var in t_vars if 'd_' in var.name]
+    g_vars = [var for var in t_vars if 'g_' in var.name]
+
+    d_solver = tf.train.AdamOptimizer(4*lr_v).minimize(d_loss, var_list=d_vars, global_step=global_step)
+    g_solver = tf.train.AdamOptimizer(lr_v).minimize(g_loss, var_list=g_vars)
+
+
+    init = tf.global_variables_initializer()
+    with tf.Session() as sess:
+        sess.run(init)
+
+        saver = initialize(sess)
+        initial_step = global_step.eval()
+
+        start_time = time.time()
+        n_batches = 200
+        total_iteration = n_batches * N_EPOCHS
+        # print([n.attr['_output_shapes'] for n in tf.get_default_graph().as_graph_def(add_shapes=True).node])
+        for index in range(initial_step, total_iteration):
+            training_batch = load_next_training_batch()
+            groundtruth_batch = load_next_groundtruth_batch()
+            
+            _, d_loss_cur = sess.run([d_solver, d_loss], feed_dict={gen_in: training_batch, real_in: groundtruth_batch})
+            _, g_loss_cur = sess.run([g_solver, g_loss], feed_dict={gen_in: training_batch, real_in: groundtruth_batch})
+
+            if(index + 1) % SKIP_STEP == 0:
+
+                saver.save(sess, CKPT_DIR, index)
+                image = sess.run(Gz, feed_dict={gen_in: training_batch})
+                labels = sess.run(Dx, feed_dict={real_in : groundtruth_batch})
+                labels_2 = sess.run(Dx, feed_dict={real_in : image})
+                # new_lr_decay = lr_decay**(index // SKIP_STEP)
+                # lr_v.assign(lr_init * new_lr_decay)
+                img_save=(image[1]+1)/2
+                cv2.imwrite(IMG_DIR+'val_%d.png' % (index+1), img_save*255)
+                print(np.sum((labels>0.5)),np.sum((labels_2<0.5)))
+                print(
+                    "Step {}/{} Gen Loss: ".format(index + 1, total_iteration) + str(g_loss_cur)+ " Disc Loss: " + str(
+                        d_loss_cur))
+
+
+
+if __name__=='__main__':
+    # print(device_lib.list_local_devices())
+    training_dataset_init()
+    groundtruth_dataset_init()
+    train()

output_small/out_11.png

@@ -0,0 +1,126 @@
+import os
+import re
+import sys
+import glob
+import scipy.misc
+from itertools import cycle
+import cv2
+import numpy as np
+import tensorflow as tf
+lr_init = 0.00001
+lr_decay=0.1
+BATCH_SIZE = 8
+BATCH_SHAPE = [BATCH_SIZE, 256, 256, 3]
+SKIP_STEP = 200
+N_EPOCHS = 1000
+CKPT_DIR = './Checkpoints/'
+IMG_DIR = './Images/'
+GRAPH_DIR = './Graphs/'
+TRAINING_SET_DIR= '../rephrase_data/degrade/'
+GROUNDTRUTH_SET_DIR='../rephrase_data/train/'
+TESTING_SET_DIR= '../rephrase_data/degrade_test/'
+GROUNDTRUTH_TEST_SET_DIR='../rephrase_data/test/'
+OUT_DIR='../rephrase_data/output_small/'
+ADVERSARIAL_LOSS_FACTOR = 64
+PIXEL_LOSS_FACTOR = 0.1
+
+def initialize(sess):
+    saver = tf.train.Saver()
+    writer = tf.summary.FileWriter(GRAPH_DIR, sess.graph)
+
+    if not os.path.exists(CKPT_DIR):
+        os.makedirs(CKPT_DIR)
+    if not os.path.exists(IMG_DIR):
+        os.makedirs(IMG_DIR)
+
+    ckpt = tf.train.get_checkpoint_state(os.path.dirname(CKPT_DIR))
+    if ckpt and ckpt.model_checkpoint_path:
+        saver.restore(sess, ckpt.model_checkpoint_path)
+    return saver
+
+def load_next_training_batch():
+    batch = next(pool)
+    return batch
+
+def training_dataset_init():
+    filelist = glob.glob(TRAINING_SET_DIR + '/*/*.jpg')
+    batch = np.array([cv2.resize(cv2.imread(fname),(256,256)) for fname in filelist],dtype=float)
+    print(np.mean(batch,axis=(1,2,3)).shape)
+    batch-=np.mean(batch,axis=(1,2,3),keepdims=True)
+    batch/=batch.std(axis=(1,2,3),keepdims=True)
+    batch = np.array(split(batch, BATCH_SIZE))
+    global pool
+    pool = cycle(batch)
+
+
+def groundtruth_dataset_init():
+    filelist = glob.glob(GROUNDTRUTH_SET_DIR + '/*/*.jpg')
+    ground_batch = np.array([cv2.resize(cv2.imread(fname),(256,256)) for fname in filelist],dtype=float)
+    ground_batch-=np.mean(ground_batch,axis=(1,2,3),keepdims=True)
+    ground_batch/=ground_batch.std(axis=(1,2,3),keepdims=True)
+    ground_batch = np.array(split(ground_batch, BATCH_SIZE))
+    print(ground_batch.shape)
+    global ground_pool
+    ground_pool = cycle(ground_batch)
+
+
+def load_next_groundtruth_batch():
+    batch = next(ground_pool)
+    return batch
+
+def testing_dataset_init():
+    filelist = glob.glob(TESTING_SET_DIR + '/*/*.jpg')
+    print(len(filelist))
+    ground_batch = np.array([cv2.resize(cv2.imread(fname),(256,256)) for fname in filelist],dtype=float)
+    global mean, std
+    mean=np.mean(ground_batch,axis=(0,1,2,3),keepdims=True)
+    std=ground_batch.std(axis=(0,1,2,3),keepdims=True)
+    ground_batch-=mean
+    ground_batch/=std
+    print(mean,std)
+    ground_batch = np.array(split(ground_batch, BATCH_SIZE))
+    print(ground_batch.shape)
+    global test_pool
+    test_pool = cycle(ground_batch)
+
+def testing_truth_dataset_init():
+    filelist = glob.glob(GROUNDTRUTH_TEST_SET_DIR + '/*/*.jpg')
+    ground_batch = np.array([cv2.resize(cv2.imread(fname),(256,256)) for fname in filelist],dtype=float)
+    ground_batch = np.array(split(ground_batch, BATCH_SIZE))
+    print(ground_batch.shape)
+    global ground_test_pool
+    ground_test_pool = cycle(ground_batch)
+
+def tryint(s):
+    try:
+        return int(s)
+    except:
+        return s
+
+def alphanum_key(s):
+    """ Turn a string into a list of string and number chunks.
+        "z23a" -> ["z", 23, "a"]
+    """
+    return [ tryint(c) for c in re.split('([0-9]+)', s) ]
+
+
+def split(arr, size):
+    arrs = []
+    while len(arr) > size:
+        pice = arr[:size]
+        arrs.append(pice)
+        arr = arr[size:]
+    arrs.append(arr)
+    return arrs
+
+
+def lrelu(x, leak=0.2, name='lrelu'):
+    with tf.variable_scope(name):
+        return 0.6 * x + 0.4 * abs(x)
+
+def get_pixel_loss(target,prediction):
+    pixel_difference = target - prediction
+    pixel_loss = tf.nn.l2_loss(pixel_difference)
+    return pixel_loss
+
+