examples/image-metrics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Image Metrics Example\n",
    "Adapted from [SciKit-Image: Structural similarity index](http://scikit-image.org/docs/dev/auto_examples/plot_ssim.html).\n",
    "\n",
    "**Note:**\n",
    "*There seem to be some minor numerical instabilities on GPU.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Force matplotlib to use inline rendering\n",
    "%matplotlib inline\n",
    "\n",
    "import os\n",
    "import sys\n",
    "\n",
    "# add path to libraries for ipython\n",
    "sys.path.append(os.path.expanduser(\"~/libs\"))\n",
    "\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import tensorlight as light\n",
    "\n",
    "from skimage import data, img_as_float\n",
    "from scipy.misc import imresize\n",
    "\n",
    "DATA_ROOT = \"data\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Demo using SINGLE images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = data.camera()\n",
    "img = img_as_float(image)\n",
    "rows, cols = img.shape\n",
    "\n",
    "noise = np.ones_like(img) * 0.2 * (img.max() - img.min())\n",
    "noise[np.random.random(size=noise.shape) > 0.5] *= -1\n",
    "\n",
    "# a) Noise\n",
    "img_noise = img + noise\n",
    "img_noise[img_noise > 1.0] = 1.0\n",
    "img_noise[img_noise < 0.0] = 0.0\n",
    "\n",
    "# b) Constant noise\n",
    "img_const = img + abs(noise)\n",
    "img_const[img_const > 1.0] = 1.0\n",
    "\n",
    "# c) Scaled (center)\n",
    "img_scaled = imresize(img, (rows, int(cols * 1.15)))\n",
    "s = img_scaled.shape\n",
    "border = (s[1] - s[0]) // 2\n",
    "img_scaled = img_scaled[:, border:s[0]+border]\n",
    "img_scaled = img_as_float(img_scaled)\n",
    "\n",
    "# d) Scaled (left part)\n",
    "img_scaled_left = imresize(img, (rows, int(cols * 1.1)))\n",
    "img_scaled_left = img_scaled_left[:, 0:cols]\n",
    "img_scaled_left = img_as_float(img_scaled_left)\n",
    "\n",
    "# e) Gaussian light blur\n",
    "img_blur1 = light.utils.image.gaussian_blur(img, sigma=1.0)\n",
    "\n",
    "# f) Gaussian medium blur\n",
    "img_blur2 = light.utils.image.gaussian_blur(img, sigma=2.5)\n",
    "\n",
    "# g) Gaussian strong blur\n",
    "img_blur3 = light.utils.image.gaussian_blur(img, sigma=5.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "light.visualization.display_array(img)\n",
    "light.visualization.display_array(img_noise)\n",
    "light.visualization.display_array(img_const)\n",
    "light.visualization.display_array(img_scaled)\n",
    "light.visualization.display_array(img_scaled_left)\n",
    "light.visualization.display_array(img_blur1)\n",
    "light.visualization.display_array(img_blur2)\n",
    "light.visualization.display_array(img_blur3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image1 = tf.placeholder(tf.float32, shape=[rows, cols])\n",
    "image2 = tf.placeholder(tf.float32, shape=[rows, cols])\n",
    "\n",
    "def image_to_4d(image):\n",
    "    image = tf.expand_dims(image, 0) # BATCH_SIZE = 1\n",
    "    image = tf.expand_dims(image, -1) # CHANNELS = 1\n",
    "    return image\n",
    "\n",
    "image4d_1 = image_to_4d(image1)\n",
    "image4d_2 = image_to_4d(image2)\n",
    "\n",
    "# optional: resize:\n",
    "image4d_1 = tf.image.resize_images(image4d_1, size=[32, 32])\n",
    "image4d_2 = tf.image.resize_images(image4d_2, size=[32, 32])\n",
    "\n",
    "ssim_index = light.loss.ssim(image4d_1, image4d_2)\n",
    "msssim_index = light.loss.ms_ssim(image4d_1, image4d_2, patch_size=5, level_weights=[1/3.0, 1/3.0, 1/3.0])\n",
    "ssssim_index = light.loss.ss_ssim(image4d_1, image4d_2)\n",
    "\n",
    "mse = light.loss.mse(image4d_1, image4d_2)\n",
    "rmse = light.loss.rmse(image4d_1, image4d_2)\n",
    "mae = light.loss.mae(image4d_1, image4d_2)\n",
    "rmae = light.loss.rmae(image4d_1, image4d_2)\n",
    "bce = light.loss.bce(image4d_1, image4d_2)\n",
    "\n",
    "gdl = light.loss.gdl(image4d_1, image4d_2)\n",
    "mgdl = light.loss.mgdl(image4d_1, image4d_2)\n",
    "\n",
    "psnr = light.image.psnr(image4d_1, image4d_2)\n",
    "sdiff = light.image.sharp_diff(image4d_1, image4d_2)\n",
    "\n",
    "light.hardware.set_cuda_devices([5])\n",
    "config = tf.ConfigProto()\n",
    "config.gpu_options.allow_growth = True\n",
    "with tf.Session(config=config) as sess:\n",
    "    mse_none = sess.run(mse,\n",
    "                        feed_dict={image1: img, image2: img})\n",
    "    mse_noise = sess.run(mse,\n",
    "                         feed_dict={image1: img, image2: img_noise})\n",
    "    mse_const = sess.run(mse,\n",
    "                         feed_dict={image1: img, image2: img_const})\n",
    "    mse_scaled = sess.run(mse,\n",
    "                          feed_dict={image1: img, image2: img_scaled})\n",
    "    mse_scaled_left = sess.run(mse,\n",
    "                               feed_dict={image1: img, image2: img_scaled_left})\n",
    "    mse_blur1 = sess.run(mse,\n",
    "                         feed_dict={image1: img, image2: img_blur1})\n",
    "    mse_blur2 = sess.run(mse,\n",
    "                         feed_dict={image1: img, image2: img_blur2})\n",
    "    mse_blur3 = sess.run(mse,\n",
    "                         feed_dict={image1: img, image2: img_blur3})\n",
    "    \n",
    "    rmse_none = sess.run(rmse,\n",
    "                         feed_dict={image1: img, image2: img})\n",
    "    rmse_noise = sess.run(rmse,\n",
    "                          feed_dict={image1: img, image2: img_noise})\n",
    "    rmse_const = sess.run(rmse,\n",
    "                          feed_dict={image1: img, image2: img_const})\n",
    "    rmse_scaled = sess.run(rmse,\n",
    "                           feed_dict={image1: img, image2: img_scaled})\n",
    "    rmse_scaled_left = sess.run(rmse,\n",
    "                                feed_dict={image1: img, image2: img_scaled_left})\n",
    "    rmse_blur1 = sess.run(rmse,\n",
    "                          feed_dict={image1: img, image2: img_blur1})\n",
    "    rmse_blur2 = sess.run(rmse,\n",
    "                          feed_dict={image1: img, image2: img_blur2})\n",
    "    rmse_blur3 = sess.run(rmse,\n",
    "                          feed_dict={image1: img, image2: img_blur3})\n",
    "    \n",
    "    mae_none = sess.run(mae,\n",
    "                        feed_dict={image1: img, image2: img})\n",
    "    mae_noise = sess.run(mae,\n",
    "                         feed_dict={image1: img, image2: img_noise})\n",
    "    mae_const = sess.run(mae,\n",
    "                         feed_dict={image1: img, image2: img_const})\n",
    "    mae_scaled = sess.run(mae,\n",
    "                          feed_dict={image1: img, image2: img_scaled})\n",
    "    mae_scaled_left = sess.run(mae,\n",
    "                               feed_dict={image1: img, image2: img_scaled_left})\n",
    "    mae_blur1 = sess.run(mae,\n",
    "                         feed_dict={image1: img, image2: img_blur1})\n",
    "    mae_blur2 = sess.run(mae,\n",
    "                         feed_dict={image1: img, image2: img_blur2})\n",
    "    mae_blur3 = sess.run(mae,\n",
    "                         feed_dict={image1: img, image2: img_blur3})\n",
    "    \n",
    "    rmae_none = sess.run(rmae,\n",
    "                         feed_dict={image1: img, image2: img})\n",
    "    rmae_noise = sess.run(rmae,\n",
    "                          feed_dict={image1: img, image2: img_noise})\n",
    "    rmae_const = sess.run(rmae,\n",
    "                          feed_dict={image1: img, image2: img_const})\n",
    "    rmae_scaled = sess.run(rmae,\n",
    "                           feed_dict={image1: img, image2: img_scaled})\n",
    "    rmae_scaled_left = sess.run(rmae,\n",
    "                                feed_dict={image1: img, image2: img_scaled_left})\n",
    "    rmae_blur1 = sess.run(rmae,\n",
    "                          feed_dict={image1: img, image2: img_blur1})\n",
    "    rmae_blur2 = sess.run(rmae,\n",
    "                          feed_dict={image1: img, image2: img_blur2})\n",
    "    rmae_blur3 = sess.run(rmae,\n",
    "                          feed_dict={image1: img, image2: img_blur3})\n",
    "    \n",
    "    bce_none = sess.run(rmae,\n",
    "                        feed_dict={image1: img, image2: img})\n",
    "    bce_noise = sess.run(rmae,\n",
    "                         feed_dict={image1: img, image2: img_noise})\n",
    "    bce_const = sess.run(rmae,\n",
    "                         feed_dict={image1: img, image2: img_const})\n",
    "    bce_scaled = sess.run(rmae,\n",
    "                          feed_dict={image1: img, image2: img_scaled})\n",
    "    bce_scaled_left = sess.run(rmae,\n",
    "                               feed_dict={image1: img, image2: img_scaled_left})\n",
    "    bce_blur1 = sess.run(rmae,\n",
    "                         feed_dict={image1: img, image2: img_blur1})\n",
    "    bce_blur2 = sess.run(rmae,\n",
    "                         feed_dict={image1: img, image2: img_blur2})\n",
    "    bce_blur3 = sess.run(rmae,\n",
    "                         feed_dict={image1: img, image2: img_blur3})\n",
    "    \n",
    "\n",
    "    ssim_none = sess.run(ssim_index,\n",
    "                         feed_dict={image1: img, image2: img})\n",
    "    ssim_noise = sess.run(ssim_index,\n",
    "                          feed_dict={image1: img, image2: img_noise})\n",
    "    ssim_const = sess.run(ssim_index,\n",
    "                          feed_dict={image1: img, image2: img_const})\n",
    "    ssim_scaled = sess.run(ssim_index,\n",
    "                           feed_dict={image1: img, image2: img_scaled})\n",
    "    ssim_scaled_left = sess.run(ssim_index,\n",
    "                                feed_dict={image1: img, image2: img_scaled_left})\n",
    "    ssim_blur1 = sess.run(ssim_index,\n",
    "                          feed_dict={image1: img, image2: img_blur1})\n",
    "    ssim_blur2 = sess.run(ssim_index,\n",
    "                          feed_dict={image1: img, image2: img_blur2})\n",
    "    ssim_blur3 = sess.run(ssim_index,\n",
    "                          feed_dict={image1: img, image2: img_blur3})\n",
    "\n",
    "    msssim_none = sess.run(msssim_index,\n",
    "                           feed_dict={image1: img, image2: img})\n",
    "    msssim_noise = sess.run(msssim_index,\n",
    "                            feed_dict={image1: img, image2: img_noise})\n",
    "    msssim_const = sess.run(msssim_index,\n",
    "                            feed_dict={image1: img, image2: img_const})\n",
    "    msssim_scaled = sess.run(msssim_index,\n",
    "                             feed_dict={image1: img, image2: img_scaled})\n",
    "    msssim_scaled_left = sess.run(msssim_index,\n",
    "                                  feed_dict={image1: img, image2: img_scaled_left})\n",
    "    msssim_blur1 = sess.run(msssim_index,\n",
    "                            feed_dict={image1: img, image2: img_blur1})\n",
    "    msssim_blur2 = sess.run(msssim_index,\n",
    "                            feed_dict={image1: img, image2: img_blur2})\n",
    "    msssim_blur3 = sess.run(msssim_index,\n",
    "                            feed_dict={image1: img, image2: img_blur3})\n",
    "    \n",
    "    ssssim_none = sess.run(ssssim_index,\n",
    "                           feed_dict={image1: img, image2: img})\n",
    "    ssssim_noise = sess.run(ssssim_index,\n",
    "                            feed_dict={image1: img, image2: img_noise})\n",
    "    ssssim_const = sess.run(ssssim_index,\n",
    "                            feed_dict={image1: img, image2: img_const})\n",
    "    ssssim_scaled = sess.run(ssssim_index,\n",
    "                             feed_dict={image1: img, image2: img_scaled})\n",
    "    ssssim_scaled_left = sess.run(ssssim_index,\n",
    "                                  feed_dict={image1: img, image2: img_scaled_left})\n",
    "    ssssim_blur1 = sess.run(ssssim_index,\n",
    "                            feed_dict={image1: img, image2: img_blur1})\n",
    "    ssssim_blur2 = sess.run(ssssim_index,\n",
    "                            feed_dict={image1: img, image2: img_blur2})\n",
    "    ssssim_blur3 = sess.run(ssssim_index,\n",
    "                            feed_dict={image1: img, image2: img_blur3})\n",
    "    \n",
    "    gdl_none = sess.run(gdl,\n",
    "                        feed_dict={image1: img, image2: img})\n",
    "    gdl_noise = sess.run(gdl,\n",
    "                         feed_dict={image1: img, image2: img_noise})\n",
    "    gdl_const = sess.run(gdl,\n",
    "                         feed_dict={image1: img, image2: img_const})\n",
    "    gdl_scaled = sess.run(gdl,\n",
    "                          feed_dict={image1: img, image2: img_scaled})\n",
    "    gdl_scaled_left = sess.run(gdl,\n",
    "                               feed_dict={image1: img, image2: img_scaled_left})\n",
    "    gdl_blur1 = sess.run(gdl,\n",
    "                         feed_dict={image1: img, image2: img_blur1})\n",
    "    gdl_blur2 = sess.run(gdl,\n",
    "                         feed_dict={image1: img, image2: img_blur2})\n",
    "    gdl_blur3 = sess.run(gdl,\n",
    "                         feed_dict={image1: img, image2: img_blur3})\n",
    "    \n",
    "    mgdl_none = sess.run(mgdl,\n",
    "                         feed_dict={image1: img, image2: img})\n",
    "    mgdl_noise = sess.run(mgdl,\n",
    "                          feed_dict={image1: img, image2: img_noise})\n",
    "    mgdl_const = sess.run(mgdl,\n",
    "                          feed_dict={image1: img, image2: img_const})\n",
    "    mgdl_scaled = sess.run(mgdl,\n",
    "                           feed_dict={image1: img, image2: img_scaled})\n",
    "    mgdl_scaled_left = sess.run(mgdl,\n",
    "                                feed_dict={image1: img, image2: img_scaled_left})\n",
    "    mgdl_blur1 = sess.run(mgdl,\n",
    "                          feed_dict={image1: img, image2: img_blur1})\n",
    "    mgdl_blur2 = sess.run(mgdl,\n",
    "                          feed_dict={image1: img, image2: img_blur2})\n",
    "    mgdl_blur3 = sess.run(mgdl,\n",
    "                          feed_dict={image1: img, image2: img_blur3})\n",
    "    \n",
    "    psnr_none = sess.run(psnr,\n",
    "                         feed_dict={image1: img, image2: img})\n",
    "    psnr_noise = sess.run(psnr,\n",
    "                          feed_dict={image1: img, image2: img_noise})\n",
    "    psnr_const = sess.run(psnr,\n",
    "                          feed_dict={image1: img, image2: img_const})\n",
    "    psnr_scaled = sess.run(psnr,\n",
    "                           feed_dict={image1: img, image2: img_scaled})\n",
    "    psnr_scaled_left = sess.run(psnr,\n",
    "                                feed_dict={image1: img, image2: img_scaled_left})\n",
    "    psnr_blur1 = sess.run(psnr,\n",
    "                          feed_dict={image1: img, image2: img_blur1})\n",
    "    psnr_blur2 = sess.run(psnr,\n",
    "                          feed_dict={image1: img, image2: img_blur2})\n",
    "    psnr_blur3 = sess.run(psnr,\n",
    "                          feed_dict={image1: img, image2: img_blur3})\n",
    "    \n",
    "    sdiff_none = sess.run(sdiff,\n",
    "                          feed_dict={image1: img, image2: img})\n",
    "    sdiff_noise = sess.run(sdiff,\n",
    "                           feed_dict={image1: img, image2: img_noise})\n",
    "    sdiff_const = sess.run(sdiff,\n",
    "                           feed_dict={image1: img, image2: img_const})\n",
    "    sdiff_scaled = sess.run(sdiff,\n",
    "                            feed_dict={image1: img, image2: img_scaled})\n",
    "    sdiff_scaled_left = sess.run(sdiff,\n",
    "                                 feed_dict={image1: img, image2: img_scaled_left})\n",
    "    sdiff_blur1 = sess.run(sdiff,\n",
    "                           feed_dict={image1: img, image2: img_blur1})\n",
    "    sdiff_blur2 = sess.run(sdiff,\n",
    "                           feed_dict={image1: img, image2: img_blur2})\n",
    "    sdiff_blur3 = sess.run(sdiff,\n",
    "                           feed_dict={image1: img, image2: img_blur3})\n",
    "\n",
    "    \n",
    "def print_result(title, mse, rmse, mae, rmae, bce, ssim, msssim, ssssim, gdl, mgdl, psnr, sdiff):\n",
    "    print('### {}:'.format(title))\n",
    "    print('MSE: {}'.format(mse))\n",
    "    print('RMSE: {}'.format(rmse))\n",
    "    print('MAE: {}'.format(mae))\n",
    "    print('RMAE: {}'.format(rmae))\n",
    "    print('BCE: {}'.format(bce))\n",
    "    print('SSIM: {}'.format(ssim))\n",
    "    print('SS-SSIM: {}'.format(ssssim))\n",
    "    print('MS-SSIM: {}'.format(msssim))\n",
    "    print('GDL: {}'.format(gdl))\n",
    "    print('MGDL: {}'.format(mgdl))\n",
    "    print('PSNR: {}'.format(psnr))\n",
    "    print('SHARP DIFF: {}'.format(sdiff))\n",
    "    print\n",
    "    \n",
    "print_result('None',\n",
    "             mse_none, rmse_none, mae_none, rmae_none, bce_none,\n",
    "             ssim_none, msssim_none, ssssim_none,\n",
    "             gdl_none, mgdl_none, psnr_none, sdiff_none)\n",
    "print_result('Noise',\n",
    "             mse_noise, rmse_noise, mae_noise, rmae_noise, bce_noise,\n",
    "             ssim_noise, msssim_noise, ssssim_noise,\n",
    "             gdl_noise, mgdl_noise, psnr_noise, sdiff_noise)\n",
    "print_result('Constant noise',\n",
    "             mse_const, rmse_const, mae_const, rmae_const, bce_const,\n",
    "             ssim_const, msssim_const, ssssim_const,\n",
    "             gdl_const, mgdl_const, psnr_const, sdiff_const)\n",
    "print_result('Scaled (center)',\n",
    "             mse_scaled, rmse_scaled, mae_scaled, rmae_scaled, bce_scaled,\n",
    "             ssim_scaled, msssim_scaled, ssssim_scaled,\n",
    "             gdl_scaled, mgdl_scaled, psnr_scaled, sdiff_scaled)\n",
    "print_result('Scaled (left)',\n",
    "             mse_scaled_left, rmse_scaled_left, mae_scaled_left, rmae_scaled_left, bce_scaled_left,\n",
    "             ssim_scaled_left, msssim_scaled_left, ssssim_scaled_left,\n",
    "             gdl_scaled_left, mgdl_scaled_left, psnr_scaled_left, sdiff_scaled_left)\n",
    "print_result('Blur (low)',\n",
    "             mse_blur1, rmse_blur1, mae_blur1, rmae_blur1, bce_blur1,\n",
    "             ssim_blur1, msssim_blur1, ssssim_blur1,\n",
    "             gdl_blur1, mgdl_blur1, psnr_blur1, sdiff_blur1)\n",
    "print_result('Blur (medium)',\n",
    "             mse_blur2, rmse_blur2, mae_blur2, rmae_blur2, bce_blur2,\n",
    "             ssim_blur2, msssim_blur2, ssssim_blur2,\n",
    "             gdl_blur2, mgdl_blur2, psnr_blur2, sdiff_blur2)\n",
    "print_result('Blur (high)',\n",
    "             mse_blur3, rmse_blur3, mae_blur3, rmae_blur3, bce_blur3,\n",
    "             ssim_blur3, msssim_blur3, ssssim_blur3,\n",
    "             gdl_blur3, mgdl_blur3, psnr_blur3, sdiff_blur3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Test using BATCHES of images (MNIST)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 4\n",
    "FRAME_SIZE = 64\n",
    "FRAME_CHANNELS = 1\n",
    "\n",
    "dataset_train = light.datasets.moving_mnist.MovingMNISTTrainDataset(DATA_ROOT, input_shape=[1,64,64,1])\n",
    "\n",
    "image1 = tf.placeholder(tf.float32, shape=[None, FRAME_SIZE, FRAME_SIZE, FRAME_CHANNELS])\n",
    "image2 = tf.placeholder(tf.float32, shape=[None, FRAME_SIZE, FRAME_SIZE, FRAME_CHANNELS])\n",
    "\n",
    "ssim_loss = light.loss.ssim(image1, image2)\n",
    "\n",
    "# when len(levels_weights) >= 3 and patch_size = 7:\n",
    "# ==> can produce NaN here, because a 64x64 image is too small\n",
    "msssim_loss = light.loss.ms_ssim(image1, image2, patch_size=7, level_weights=[0.2, 0.4, 0.4])\n",
    "\n",
    "ssssim_loss = light.loss.ss_ssim(image1, image2, level=2)\n",
    "\n",
    "rmse_loss = light.loss.rmse(image1, image2)\n",
    "\n",
    "gdl_value = light.loss.gdl(image1, image2)\n",
    "mgdl_value = light.loss.mgdl(image1, image2)\n",
    "\n",
    "psnr_value = light.image.psnr(image1, image2, max_value=255.0)\n",
    "sdiff_value = light.image.sharp_diff(image1, image2, max_value=255.0)\n",
    "\n",
    "config = tf.ConfigProto()\n",
    "config.gpu_options.allow_growth = True\n",
    "with tf.Session(config=config) as sess:\n",
    "    \n",
    "    def get_batch_without_time_dim():\n",
    "        dataset_train.reset()\n",
    "        b_x, _ = dataset_train.get_batch(BATCH_SIZE)\n",
    "        b_x = np.squeeze(b_x, (1,))\n",
    "        return b_x\n",
    "        \n",
    "    batch = get_batch_without_time_dim()\n",
    "    batch_rescaled = batch * 255 # because (MS-)SSIM expects scale [0-255]\n",
    "    \n",
    "    ssim = sess.run(ssim_loss,\n",
    "                    feed_dict={image1: batch_rescaled, image2: batch_rescaled})\n",
    "    msssim = sess.run(msssim_loss,\n",
    "                       feed_dict={image1: batch_rescaled, image2: batch_rescaled})\n",
    "    ssssim = sess.run(ssssim_loss,\n",
    "                       feed_dict={image1: batch_rescaled, image2: batch_rescaled})\n",
    "    rmse = sess.run(rmse_loss,\n",
    "                    feed_dict={image1: batch, image2: batch})\n",
    "    \n",
    "    gdl = sess.run(gdl_value,\n",
    "                   feed_dict={image1: batch_rescaled, image2: batch_rescaled})\n",
    "    mgdl = sess.run(mgdl_value,\n",
    "                    feed_dict={image1: batch_rescaled, image2: batch_rescaled})\n",
    "    \n",
    "    psnr = sess.run(psnr_value,\n",
    "                    feed_dict={image1: batch_rescaled, image2: batch_rescaled})\n",
    "    sdiff = sess.run(sdiff_value,\n",
    "                    feed_dict={image1: batch_rescaled, image2: batch_rescaled})\n",
    "    \n",
    "    print \"### Same image:\"\n",
    "    print('RMSE: {}'.format(rmse))\n",
    "    print('SSIM: {}'.format(ssim))\n",
    "    print('SS-SSIM: {}'.format(ssssim))\n",
    "    print('MS-SSIM: {}'.format(msssim))\n",
    "    print('GDL: {}'.format(gdl))\n",
    "    print('MGDL: {}'.format(mgdl))\n",
    "    print('PSNR: {}'.format(psnr))\n",
    "    print('SHARP-DIFF: {}'.format(sdiff))\n",
    "    \n",
    "    batch_a = get_batch_without_time_dim()\n",
    "    batch_b = get_batch_without_time_dim()\n",
    "    batch_a_rescaled = batch_a \n",
    "    batch_b_rescaled = batch_b\n",
    "    \n",
    "    light.visualization.display_batch(batch_a_rescaled)\n",
    "    light.visualization.display_batch(batch_b_rescaled)\n",
    "    \n",
    "    ssim = sess.run(ssim_loss,\n",
    "                    feed_dict={image1: batch_a_rescaled, image2: batch_b_rescaled})\n",
    "    msssim = sess.run(msssim_loss,\n",
    "                      feed_dict={image1: batch_a_rescaled, image2: batch_b_rescaled})\n",
    "    ssssim = sess.run(ssssim_loss,\n",
    "                      feed_dict={image1: batch_a_rescaled, image2: batch_b_rescaled})\n",
    "    rmse = sess.run(rmse_loss,\n",
    "                    feed_dict={image1: batch_a, image2: batch_b})\n",
    "    \n",
    "    gdl = sess.run(gdl_value,\n",
    "                   feed_dict={image1: batch_a_rescaled, image2: batch_b_rescaled})\n",
    "    mgdl = sess.run(mgdl_value,\n",
    "                    feed_dict={image1: batch_a_rescaled, image2: batch_b_rescaled})\n",
    "    \n",
    "    psnr = sess.run(psnr_value,\n",
    "                    feed_dict={image1: batch_a_rescaled, image2: batch_b_rescaled})\n",
    "    sdiff = sess.run(sdiff_value,\n",
    "                    feed_dict={image1: batch_a_rescaled, image2: batch_b_rescaled})\n",
    "\n",
    "    \n",
    "    print \"### Different images:\"\n",
    "    print('RMSE: {}'.format(rmse))\n",
    "    print('SSIM: {}'.format(ssim))\n",
    "    print('SS-SSIM: {}'.format(ssssim))\n",
    "    print('MS-SSIM: {}'.format(msssim))\n",
    "    print('GDL: {}'.format(gdl))\n",
    "    print('MGDL: {}'.format(mgdl))\n",
    "    print('PSNR: {}'.format(psnr))\n",
    "    print('SHARP-DIFF: {}'.format(sdiff))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Compare results on RGB and gray-scale images\n",
    "\n",
    "Remarks: Some metrics to not support color-images, such as SSIM. But variants like CSSIM exist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image1 = tf.placeholder(tf.float32, shape=[None, 250, 250, 3])\n",
    "image2 = tf.placeholder(tf.float32, shape=[None, 250, 250, 3])\n",
    "\n",
    "gray_image1 = tf.image.rgb_to_grayscale(image1)\n",
    "gray_image2 = tf.image.rgb_to_grayscale(image2)\n",
    "\n",
    "mse_color = light.loss.mse(image1, image2)\n",
    "mse_gray = light.loss.mse(gray_image1, gray_image2)\n",
    "\n",
    "ssim_gray = light.image.ssim(gray_image1, gray_image2, L=1.0)\n",
    "\n",
    "msssim_gray = light.image.ms_ssim(gray_image1, gray_image2, L=1.0)\n",
    "\n",
    "mgdl_color = light.loss.mgdl(image1, image2)\n",
    "mgdl_gray = light.loss.mgdl(gray_image1, gray_image2)\n",
    "\n",
    "psnr_color = light.image.psnr(image1, image2, max_value=1.0)\n",
    "psnr_gray = light.image.psnr(gray_image1, gray_image2, max_value=1.0)\n",
    "\n",
    "sdiff_color = light.image.sharp_diff(image1, image2, max_value=1.0)\n",
    "sdiff_gray = light.image.sharp_diff(gray_image1, gray_image2, max_value=1.0)\n",
    "\n",
    "config = tf.ConfigProto()\n",
    "config.gpu_options.allow_growth = True\n",
    "with tf.Session(config=config) as sess:\n",
    "    # reads image as uint8\n",
    "    rgb = light.utils.image.read(\"assets/example250x250.png\")\n",
    "    rgb_blur = light.utils.image.gaussian_blur(rgb, 2.0)\n",
    "    \n",
    "    # cast to scale [0, 1] as float32\n",
    "    rgb = rgb / 255.0\n",
    "    rgb_blur = rgb_blur / 255.0 \n",
    "    \n",
    "    # batch-size=1\n",
    "    rgb = np.expand_dims(rgb, 0)\n",
    "    rgb_blur = np.expand_dims(rgb_blur, 0)\n",
    "    \n",
    "    gray, gray_blur = sess.run([gray_image1, gray_image2], feed_dict={image1: rgb, image2: rgb_blur})\n",
    "    \n",
    "    msec, mseg = sess.run([mse_color, mse_gray], feed_dict={image1: rgb, image2: rgb_blur})\n",
    "    \n",
    "    ssimg = sess.run(ssim_gray, feed_dict={image1: rgb, image2: rgb_blur})\n",
    "    ssimc = None\n",
    "    \n",
    "    msssimg = sess.run(msssim_gray, feed_dict={image1: rgb, image2: rgb_blur})\n",
    "    msssimc = None\n",
    "    \n",
    "    mgdlc, mgdlg = sess.run([mgdl_color, mgdl_gray], feed_dict={image1: rgb, image2: rgb_blur})\n",
    "    \n",
    "    psnrc, psnrg = sess.run([psnr_color, psnr_gray], feed_dict={image1: rgb, image2: rgb_blur})\n",
    "    \n",
    "    sdiffc, sdiffg = sess.run([sdiff_color, sdiff_gray], feed_dict={image1: rgb, image2: rgb_blur})\n",
    "    \n",
    "    \n",
    "print(rgb.shape)\n",
    "print(rgb_blur.shape)\n",
    "print(gray.shape)\n",
    "print(gray_blur.shape)\n",
    "    \n",
    "light.visualization.display_array(rgb[0])\n",
    "light.visualization.display_array(rgb_blur[0])\n",
    "light.visualization.display_array(gray[0])\n",
    "light.visualization.display_array(gray_blur[0])\n",
    "\n",
    "def print_result(title, mse, ssim, msssim, mgdl, psnr, sdiff):\n",
    "    print('### {} ###'.format(title))\n",
    "    print('MSE: {}'.format(mse))\n",
    "    print('SSIM: {}'.format(ssim))\n",
    "    print('MS-SSIM: {}'.format(msssim))\n",
    "    print('MGDL: {}'.format(mgdl))\n",
    "    print('PSNR: {}'.format(psnr))\n",
    "    print('SHARP DIFF: {}'.format(sdiff))\n",
    "    print\n",
    "\n",
    "print_result(\"Gray\", mseg, ssimg, msssimg, mgdlg, psnrg, sdiffg)\n",
    "print_result(\"Color\", msec, ssimc, msssimc, mgdlc, psnrc, sdiffc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}