readme update

Author: shivangi-aneja

README.md

@@ -1,8 +1,10 @@
-# Advanced Deep Learning Practical Course : Realistic Composite Image Creation Using GANs
+# Deep Image Compositing : Realistic Composite Image Creation Using GANs
+
+This work has been accepted at 3rd BAI Workshop, NeurIPS Conference 2019. Find the attached poster (here)[https://www.academia.edu/40947406/Deep_Image_Compositing].
 
 ## 1. How To train the model
 
-```bash
+```
 usage: main.py [-h] [-d DATASET] [--data-dirpath DATA_DIRPATH]
                [--n-workers N_WORKERS] [--gpu GPU] [-rs RANDOM_SEED]
                [-dr DISCRIMINATOR] [-gr GENERATOR]  [-d_lr D_LR]  [-g_lr G_LR]
@@ -51,13 +53,13 @@ optional arguments:
 ```
 
 ### Sample Command for training
-```bash
+```
 python main.py -b 5 --gpu 1 -d_lr 1e-7 -g_lr 1e-5 -m pix2pix_patch_hue_total -e 1000 -tf tf_logs/pix2pix_patch_hue_total -rl l1 -dr patch -gr skip2
 ```
 
 ## 2. How To generate results on the model
 
-```bash
+```
 usage: evaluate_models.py [-h] [-d DATASET] [--data-dirpath DATA_DIRPATH]
                [--n-workers N_WORKERS] [--gpu GPU] [-rs RANDOM_SEED]
                [-dr DISCRIMINATOR] [-gr GENERATOR]  [-d_lr D_LR]  [-g_lr G_LR]

calc_metrics.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+ Main file to train and evaluate the models
+"""
+
+from deep_adversarial_network.metrics.metric_eval import *
+from PIL import Image
+import numpy as np
+import os
+from skimage.measure import compare_ssim as ssim
+
+
+def main():
+    """
+    main function that parses the arguments and trains
+    :param args: arguments related
+    :return: None
+    """
+    mse_avg_total = 0.
+    psnr_avg_total = 0.
+    ssim_avg_total = 0.
+    vif_avg_total = 0.
+
+    image_list = ['4','36','39','70','121','149']
+    for img in image_list:
+
+        gt_image =  Image.open(os.getcwd()+'/metrics/gt/gt_'+img+'.png')
+        gt_image = np.array(gt_image)
+        test_image = Image.open(os.getcwd() + '/metrics/ours/ht_' + img + '.png')
+        test_image = np.array(test_image)
+
+        mse_avg_iter, psnr_avg_iter = calc_mse_psnr_img(test_image, gt_image)
+        #tv_avg_iter = get_total_variation(tf.convert_to_tensor(test_image))
+        ssim_avg_iter = ssim(test_image,gt_image,multichannel=True)
+        vif_avg_iter = calc_vif_img(test_image, gt_image)
+
+        mse_avg_total += mse_avg_iter
+        psnr_avg_total += psnr_avg_iter
+        #tv_avg_total += tv_avg_iter
+        ssim_avg_total += ssim_avg_iter
+        vif_avg_total += vif_avg_iter
+
+    mse_avg_total /= len(image_list)
+    psnr_avg_total /= len(image_list)
+    ssim_avg_total /= len(image_list)
+    vif_avg_total /= len(image_list)
+
+    print("MSE : %.3f, PSNR : %.3f, SSIM : %.3f  VIF: %3F" % (
+        mse_avg_total, psnr_avg_total, ssim_avg_total, vif_avg_total))
+
+
+if __name__ == '__main__':
+    main()

deep_adversarial_network/metrics/metric_eval.py

@@ -88,6 +88,67 @@ def calc_vif(img_list1, img_list2):
     return vifp/num_imgs
 
 
+def calc_vif_img(img1, img2):
+    """
+    Calculate VIF for a set of Images
+    :param img_list1: Test Image
+    :param img_list2: Ground Truth Image
+    :return: VIF
+    """
+
+    sigma_nsq = 2
+    eps = 1e-10
+
+    num = 0.0
+    den = 0.0
+    vifp = 0.
+    ref = img1
+    dist = img2
+    for scale in range(1, 5):
+
+        N = 2 ** (4 - scale + 1) + 1
+        sd = N / 5.0
+
+        if scale > 1:
+            ref = scipy.ndimage.gaussian_filter(ref, sd)
+            dist = scipy.ndimage.gaussian_filter(dist, sd)
+            ref = ref[::2, ::2]
+            dist = dist[::2, ::2]
+
+        mu1 = scipy.ndimage.gaussian_filter(ref, sd)
+        mu2 = scipy.ndimage.gaussian_filter(dist, sd)
+        mu1_sq = mu1 * mu1
+        mu2_sq = mu2 * mu2
+        mu1_mu2 = mu1 * mu2
+        sigma1_sq = scipy.ndimage.gaussian_filter(ref * ref, sd) - mu1_sq
+        sigma2_sq = scipy.ndimage.gaussian_filter(dist * dist, sd) - mu2_sq
+        sigma12 = scipy.ndimage.gaussian_filter(ref * dist, sd) - mu1_mu2
+
+        sigma1_sq[sigma1_sq < 0] = 0
+        sigma2_sq[sigma2_sq < 0] = 0
+
+        g = sigma12 / (sigma1_sq + eps)
+        sv_sq = sigma2_sq - g * sigma12
+
+        g[sigma1_sq < eps] = 0
+        sv_sq[sigma1_sq < eps] = sigma2_sq[sigma1_sq < eps]
+        sigma1_sq[sigma1_sq < eps] = 0
+
+        g[sigma2_sq < eps] = 0
+        sv_sq[sigma2_sq < eps] = 0
+
+        sv_sq[g < 0] = sigma2_sq[g < 0]
+        g[g < 0] = 0
+        sv_sq[sv_sq <= eps] = eps
+
+        num += np.sum(np.log10(1 + g * g * sigma1_sq / (sv_sq + sigma_nsq)))
+        den += np.sum(np.log10(1 + sigma1_sq / sigma_nsq))
+
+    vifp += num / den
+
+    return vifp
+
+
 def calc_mse_psnr(img_list1, img_list2):
     """
     Calculate MSE and PSNR for a set of Images
@@ -119,6 +180,26 @@ def calc_mse_psnr(img_list1, img_list2):
     return  total_mse/num_imgs, total_psnr/num_imgs
 
 
+def calc_mse_psnr_img(img1, img2):
+    """
+    Calculate MSE and PSNR for a set of Images
+    :param img_list1: Image List1
+    :param img_list2: Image List2
+    :return: MSE, PSNR
+    """
+    mse_val = calc_mse(img1,img2)
+    if mse_val == 0.:
+        psnr = 100
+    else:
+        # im1 = tf.image.convert_image_dtype(img_list1[i], tf.float32)
+        # im2 = tf.image.convert_image_dtype(img_list2[i], tf.float32)
+        # psnr = tf.image.psnr(im1, im2, max_val=255)
+        psnr = 20 * math.log10(PIXEL_MAX / math.sqrt(mse_val))
+
+
+    return  mse_val, psnr
+
+
 def d_accuracy(real_prob, fake_prob):
     """
     Calculate Discriminator Accuracy