our_metric_proposal.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from numpy.random import randn\n",
    "from numpy.random import randint\n",
    "import os\n",
    "import cv2\n",
    "import pandas as pd\n",
    "import gzip\n",
    "from tensorflow.keras import backend as K\n",
    "import tensorflow as tf \n",
    "from matplotlib import pyplot as plt\n",
    "from tensorflow.keras.preprocessing.image import load_img\n",
    "from tensorflow.keras.datasets.mnist import load_data\n",
    "from tensorflow.keras.models import load_model\n",
    "from tensorflow.keras.preprocessing.image import img_to_array\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Input\n",
    "from tensorflow.keras.layers import Dense\n",
    "from tensorflow.keras.layers import Reshape\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Flatten\n",
    "from tensorflow.keras.layers import Conv2D\n",
    "from tensorflow.keras.layers import Conv2DTranspose\n",
    "from tensorflow.keras.layers import LeakyReLU\n",
    "from tensorflow.keras.layers import Dropout\n",
    "from tensorflow.keras.layers import Embedding\n",
    "from tensorflow.keras.layers import Concatenate\n",
    "from tensorflow.python.keras.utils import conv_utils\n",
    "from tensorflow.keras.initializers import RandomNormal\n",
    "import random \n",
    "\n",
    "import numpy as np\n",
    "from numpy.random import randn\n",
    "from numpy.random import randint\n",
    "import os\n",
    "import cv2\n",
    "import pandas as pd\n",
    "import gzip\n",
    "from tensorflow.keras import backend as K\n",
    "import tensorflow as tf \n",
    "from matplotlib import pyplot as plt\n",
    "from tensorflow.keras.preprocessing.image import load_img\n",
    "from tensorflow.keras.datasets.mnist import load_data\n",
    "from tensorflow.keras.models import load_model\n",
    "from tensorflow.keras.preprocessing.image import img_to_array\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Layer\n",
    "from tensorflow.keras.layers import Input\n",
    "from tensorflow.keras.layers import Dense\n",
    "from tensorflow.keras.layers import Reshape\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Flatten\n",
    "from tensorflow.keras.layers import Conv2D\n",
    "from tensorflow.keras.layers import Conv2DTranspose\n",
    "from tensorflow.keras.layers import LeakyReLU, ReLU\n",
    "from tensorflow.keras.layers import Dropout\n",
    "from tensorflow.keras.layers import Embedding\n",
    "from tensorflow.keras.layers import Concatenate\n",
    "from tensorflow.python.keras.utils import conv_utils\n",
    "from tensorflow.keras.initializers import RandomNormal\n",
    "import random \n",
    "from tensorflow.keras.layers import Conv2D, Input, Dense, Activation, Reshape, GlobalAveragePooling2D, UpSampling2D, LeakyReLU, Dropout, BatchNormalization\n",
    "\n",
    "######################################## RANDOM SEED:\n",
    "random.seed(13)\n",
    "\n",
    "#epsilon set according to BIGGAN https://arxiv.org/pdf/1809.11096.pdf\n",
    "\n",
    "def _l2normalizer(v, epsilon=1e-4):\n",
    "    return v / (K.sum(v**2)**0.5 + epsilon)\n",
    "\n",
    "\n",
    "def power_iteration(W, u, rounds=1):\n",
    "    '''\n",
    "    Accroding the paper, we only need to do power iteration one time.\n",
    "    '''\n",
    "    _u = u\n",
    "\n",
    "    for i in range(rounds):\n",
    "        _v = _l2normalizer(K.dot(_u, W))\n",
    "        _u = _l2normalizer(K.dot(_v, K.transpose(W)))\n",
    "\n",
    "    W_sn = K.sum(K.dot(_u, W) * _v)\n",
    "    return W_sn, _u, _v\n",
    "\n",
    "\"\"\"\n",
    "Convolution 2D with spectral normalization\n",
    "\"\"\"\n",
    "class SNConv2D(Conv2D):\n",
    "    def __init__(self, filters, spectral_normalization=True, **kwargs):\n",
    "        self.spectral_normalization = spectral_normalization\n",
    "        super(SNConv2D, self).__init__(filters, **kwargs)\n",
    "\n",
    "    def build(self, input_shape):\n",
    "        # Create a trainable weight variable for this layer.\n",
    "\n",
    "        self.u = self.add_weight(name='u', shape=(1, self.filters),\n",
    "                                 initializer='uniform', trainable=False)\n",
    "        super(SNConv2D, self).build(input_shape)\n",
    "        # Be sure to call this at the end\n",
    "\n",
    "    def compute_spectral_normal(self, training=True):\n",
    "        # Spectrally Normalized Weight\n",
    "        if self.spectral_normalization:\n",
    "            # Get kernel tensor shape [kernel_h, kernel_w, in_channels, out_channels]\n",
    "            W_shape = self.kernel.shape.as_list()\n",
    "\n",
    "            # Flatten the Tensor\n",
    "            # [out_channels, N]\n",
    "            W_mat = K.reshape(self.kernel, [W_shape[-1], -1])\n",
    "\n",
    "            W_sn, u, v = power_iteration(W_mat, self.u)\n",
    "\n",
    "            if training:\n",
    "                # Update estimated 1st singular vector\n",
    "                self.u.assign(u)\n",
    "\n",
    "            return self.kernel / W_sn\n",
    "        else:\n",
    "            return self.kernel\n",
    "\n",
    "    def call(self, inputs, training=None):\n",
    "\n",
    "        outputs = K.conv2d(inputs,\n",
    "                           self.compute_spectral_normal(training=training),\n",
    "                           strides=self.strides, padding=self.padding,\n",
    "                           data_format=self.data_format,\n",
    "                           dilation_rate=self.dilation_rate)\n",
    "\n",
    "        if self.use_bias:\n",
    "            outputs = K.bias_add(outputs, self.bias,\n",
    "                                 data_format=self.data_format)\n",
    "\n",
    "        if self.activation is not None:\n",
    "            return self.activation(outputs)\n",
    "        return outputs\n",
    "\n",
    "    def compute_output_shape(self, input_shape):\n",
    "        return super(SNConv2D, self).compute_output_shape(input_shape)\n",
    "\n",
    "\"\"\"\n",
    "Transposed Convolution 2D with spectral normalization\n",
    "\"\"\"\n",
    "class SNConv2DTranspose(Conv2DTranspose):\n",
    "    def __init__(self, spectral_normalization=True, **kwargs):\n",
    "        self.spectral_normalization = spectral_normalization\n",
    "        super(SNConv2DTranspose, self).__init__(**kwargs)\n",
    "\n",
    "    def build(self, input_shape):\n",
    "        # Create a trainable weight variable for this layer.\n",
    "        self.u = self.add_weight(name='u', shape=(1, self.filters),\n",
    "                                 initializer='uniform', trainable=False)\n",
    "        super(SNConv2DTranspose, self).build(input_shape)\n",
    "        # Be sure to call this at the end\n",
    "\n",
    "    def compute_spectral_normal(self, training=True):\n",
    "        # Spectrally Normalized Weight\n",
    "        if self.spectral_normalization:\n",
    "            # Get kernel tensor shape [kernel_h, kernel_w, in_channels, out_channels]\n",
    "            W_shape = self.kernel.shape.as_list()\n",
    "\n",
    "            # Flatten the Tensor\n",
    "            # [out_channels, N]\n",
    "            W_mat = K.reshape(self.kernel, [W_shape[-2], -1])\n",
    "\n",
    "            W_sn, u, v = power_iteration(W_mat, self.u)\n",
    "\n",
    "            if training:\n",
    "                # Update estimated 1st singular vector\n",
    "                self.u.assign(u)\n",
    "\n",
    "            return self.kernel / W_sn\n",
    "        else:\n",
    "            return self.kernel\n",
    "\n",
    "    def call(self, inputs, training=None):\n",
    "        input_shape = K.shape(inputs)\n",
    "        batch_size = input_shape[0]\n",
    "        if self.data_format == 'channels_first':\n",
    "            h_axis, w_axis = 2, 3\n",
    "        else:\n",
    "            h_axis, w_axis = 1, 2\n",
    "\n",
    "        height, width = input_shape[h_axis], input_shape[w_axis]\n",
    "        kernel_h, kernel_w = self.kernel_size\n",
    "        stride_h, stride_w = self.strides\n",
    "        out_pad_h = out_pad_w = None\n",
    "\n",
    "        # Infer the dynamic output shape:\n",
    "        out_height = conv_utils.deconv_output_length(\n",
    "            height, kernel_h, self.padding, stride=stride_h)\n",
    "        out_width = conv_utils.deconv_output_length(\n",
    "            width, kernel_w, self.padding, stride=stride_w)\n",
    "        if self.data_format == 'channels_first':\n",
    "            output_shape = (batch_size, self.filters, out_height, out_width)\n",
    "        else:\n",
    "            output_shape = (batch_size, out_height, out_width, self.filters)\n",
    "\n",
    "        outputs = K.conv2d_transpose(\n",
    "            inputs,\n",
    "            self.compute_spectral_normal(training=training),\n",
    "            output_shape,\n",
    "            self.strides,\n",
    "            padding=self.padding,\n",
    "            data_format=self.data_format\n",
    "        )\n",
    "\n",
    "        if self.use_bias:\n",
    "            outputs = K.bias_add(outputs, self.bias,\n",
    "                                 data_format=self.data_format)\n",
    "\n",
    "        if self.activation is not None:\n",
    "            return self.activation(outputs)\n",
    "        return outputs\n",
    "\n",
    "    def compute_output_shape(self, input_shape):\n",
    "        return super(SNConv2DTranspose, self).compute_output_shape(input_shape)\n",
    "\n",
    "    \n",
    "# define the standalone discriminator model\n",
    "# A best practice involves using an embedding\n",
    "# layer followed by a fully connected layer with a linear activation that scales the embedding to\n",
    "# the size of the image before concatenating it in the model as an additional channel or feature\n",
    "# map. A version of this recommendation was described in the 2015 paper titled Deep Generative\n",
    "# Image Models using a Laplacian Pyramid of Adversarial Networks.\n",
    "    \n",
    "def define_CNN(in_shape=(64,64,3)): # HERE\n",
    "\n",
    "    \n",
    "    # input layer:\n",
    "    in_image = Input(shape=in_shape) ##\n",
    "\n",
    "        \n",
    "    # kernel initializer:\n",
    "    init = RandomNormal(stddev=0.02)\n",
    "    ##\n",
    "    # downsample to 32x32\n",
    "    fe = SNConv2D(128, kernel_size=4, strides=(4,4), padding='same', kernel_initializer=init, spectral_normalization=True)(in_image) ##in_image\n",
    "    fe = LeakyReLU(alpha=0.2)(fe)\n",
    "    fe = Dropout(0.5)(fe)\n",
    "    # downsample to 16x16\n",
    "    fe = SNConv2D(128, kernel_size=4, strides=(4,4), padding='same', kernel_initializer=init, spectral_normalization=True)(fe)\n",
    "    fe = LeakyReLU(alpha=0.2)(fe)\n",
    "    fe = Dropout(0.5)(fe)\n",
    "    # downsample to 8x8\n",
    "    fe = SNConv2D(128, kernel_size=4, strides=(4,4), padding='same', kernel_initializer=init, spectral_normalization=True)(fe)\n",
    "    fe = LeakyReLU(alpha=0.2)(fe)\n",
    "    fe = Dropout(0.5)(fe)\n",
    "    # downsample to 4x4\n",
    "    fe = SNConv2D(128, kernel_size=4, strides=(2,2), padding='same', kernel_initializer=init, spectral_normalization=True)(fe)\n",
    "    fe = LeakyReLU(alpha=0.2)(fe)\n",
    "    fe = Dropout(0.5)(fe)\n",
    "    # downsample 2x2\n",
    "    fe = SNConv2D(128, kernel_size=4, strides=(2,2), padding='same',kernel_initializer=init, spectral_normalization=True)(fe)\n",
    "    fe = LeakyReLU(alpha=0.2)(fe)\n",
    "    fe = Dropout(0.5)(fe)\n",
    "    \n",
    "    # flatten feature maps\n",
    "    fe = Flatten()(fe)\n",
    "    \n",
    "    # output about fake/real image:\n",
    "    out = Dense(1, activation='sigmoid')(fe)\n",
    "    model = Model(inputs=in_image, outputs=out)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "from scipy.ndimage.interpolation import map_coordinates\n",
    "from scipy.ndimage.filters import gaussian_filter\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "def elastic_transform(image, alpha, sigma, random_state=None):\n",
    "    \"\"\"\n",
    "       Elastic deformation of images as described in [Simard2003]_.\n",
    "    .. [Simard2003] Simard, Steinkraus and Platt, \"Best Practices for\n",
    "       Convolutional Neural Networks applied to Visual Document Analysis\", in\n",
    "       Proc. of the International Conference on Document Analysis and\n",
    "       Recognition, 2003.\n",
    "    \"\"\"\n",
    "    if random_state is None:\n",
    "        random_state = np.random.RandomState(None)\n",
    "\n",
    "    shape = image.shape\n",
    "    dx = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode=\"constant\", cval=0) * alpha\n",
    "    dy = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode=\"constant\", cval=0) * alpha\n",
    "    dz = np.zeros_like(dx)\n",
    "\n",
    "    x, y, z = np.meshgrid(np.arange(shape[0]), np.arange(shape[1]), np.arange(shape[2]))\n",
    "    #print(x.shape)\n",
    "    indices = np.reshape(y+dy, (-1, 1)), np.reshape(x+dx, (-1, 1)), np.reshape(z, (-1, 1))\n",
    "\n",
    "    distored_image = map_coordinates(image, indices, order=1, mode='reflect')\n",
    "    return distored_image.reshape(image.shape)\n",
    "\n",
    "def load_images(dataset, images_directory, img_shape):\n",
    "    X = []\n",
    "    for i, myid in enumerate(dataset):\n",
    "        image = load_img(images_directory + \"/\" + myid, target_size=img_shape[:2])\n",
    "        image = (img_to_array(image) - 127.5) / 127.5 # from [0, 255] to [-1, 1]\n",
    "        image = image[25:153, 45:173]\n",
    "        image = cv2.resize(src=image, dsize=(64, 64))\n",
    "        X.append(image)\n",
    "    X = np.array(X)\n",
    "    return X\n",
    "\n",
    "\n",
    "######### LOAD DATASET:\n",
    "def load_dataset(how_many, images_directory = 'img_align_celeba_nozip', img_shape = (178, 218, 3)):  \n",
    "\n",
    "    RandomListOfIntegers = [random.randint(0,202598) for iter in range(how_many)]\n",
    "    celeba_img = np.sort(os.listdir(images_directory))\n",
    "    images_id = celeba_img[RandomListOfIntegers]\n",
    "    images = load_images(images_id, images_directory, img_shape)\n",
    "    labels = np.zeros(how_many)\n",
    "    dataset = [images, labels]\n",
    "    return dataset\n",
    "\n",
    "# plot of generated images\n",
    "def plot_images(examples, n_test_images):\n",
    "    # plot images\n",
    "    for i in range(n_test_images):\n",
    "        # define subplot\n",
    "        plt.subplot(n_test_images/4, 4, 1 + i)\n",
    "        # turn off axis\n",
    "        plt.axis('off')\n",
    "        # plot raw pixel data\n",
    "        plt.imshow(examples[i, :, :])\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "############### PARAMETERS:\n",
    "how_many = 10000 ############################ number of images to use for training\n",
    "\n",
    "n_classes=2 # just 2 possible value for each attribute\n",
    "\n",
    "################# MODELS:\n",
    "# create the discriminator\n",
    "model = define_CNN()\n",
    "#d_model.summary()\n",
    "\n",
    "real_dataset = load_dataset(how_many)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test the elastic deformation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "deformed_images=[]\n",
    "for i in range(len(real_dataset[0])):\n",
    "    img = real_dataset[0][i,:,:]\n",
    "    deformed_img = elastic_transform(img,5,0.9)\n",
    "    deformed_images.append(deformed_img)\n",
    "    \n",
    "deformed_images = np.array(deformed_images)\n",
    "labels = np.ones(how_many)\n",
    "deformed_dataset = [deformed_images, labels]\n",
    "\n",
    "plot_images(deformed_images,8)\n",
    "plot_images(real_dataset[0],8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "dataset = [np.concatenate([real_dataset[0],deformed_dataset[0]]), np.concatenate([real_dataset[1],deformed_dataset[1]])] \n",
    "new_dataset = copy.deepcopy(dataset)\n",
    "indexes = [ i for i in range(how_many*2)]\n",
    "random.shuffle(indexes)\n",
    "for i in range(how_many*2):\n",
    "    new_dataset[0][i] = dataset[0][indexes[i]]\n",
    "    new_dataset[1][i] = dataset[1][indexes[i]]\n",
    "\n",
    "train_data = dataset[0][:int((how_many*2)*3/4)]\n",
    "#print(train_data.shape)\n",
    "train_labels = dataset[1][:int((how_many*2)*3/4)]\n",
    "#print(train_labels.shape)\n",
    "\n",
    "test_data = dataset[0][int((how_many*2)*3/4)+1:]\n",
    "#print(test_data.shape)\n",
    "test_labels = dataset[1][int((how_many*2)*3/4)+1:]\n",
    "#print(test_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 15000 samples, validate on 4999 samples\n",
      "Epoch 1/100\n",
      "15000/15000 [==============================] - 29s 2ms/sample - loss: 0.6755 - accuracy: 0.6363 - val_loss: 1.0246 - val_accuracy: 0.0000e+00\n",
      "Epoch 2/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6408 - accuracy: 0.6667 - val_loss: 1.0832 - val_accuracy: 0.0000e+00\n",
      "Epoch 3/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6400 - accuracy: 0.6667 - val_loss: 1.0653 - val_accuracy: 0.0000e+00\n",
      "Epoch 4/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6412 - accuracy: 0.6667 - val_loss: 1.0392 - val_accuracy: 0.0000e+00\n",
      "Epoch 5/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6376 - accuracy: 0.6667 - val_loss: 1.0452 - val_accuracy: 0.0000e+00\n",
      "Epoch 6/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6381 - accuracy: 0.6667 - val_loss: 1.0517 - val_accuracy: 0.0000e+00\n",
      "Epoch 7/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6385 - accuracy: 0.6667 - val_loss: 1.0508 - val_accuracy: 0.0000e+00\n",
      "Epoch 8/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6384 - accuracy: 0.6667 - val_loss: 1.0490 - val_accuracy: 0.0000e+00\n",
      "Epoch 9/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6368 - accuracy: 0.6667 - val_loss: 1.0851 - val_accuracy: 0.0000e+00\n",
      "Epoch 10/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6383 - accuracy: 0.6667 - val_loss: 1.0369 - val_accuracy: 0.0000e+00\n",
      "Epoch 11/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6360 - accuracy: 0.6667 - val_loss: 1.0697 - val_accuracy: 0.0000e+00\n",
      "Epoch 12/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6355 - accuracy: 0.6667 - val_loss: 1.0538 - val_accuracy: 0.0000e+00\n",
      "Epoch 13/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6343 - accuracy: 0.6667 - val_loss: 1.1127 - val_accuracy: 0.0000e+00\n",
      "Epoch 14/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6338 - accuracy: 0.6667 - val_loss: 1.0446 - val_accuracy: 0.0000e+00\n",
      "Epoch 15/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6305 - accuracy: 0.6667 - val_loss: 1.0757 - val_accuracy: 0.0000e+00\n",
      "Epoch 16/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6273 - accuracy: 0.6667 - val_loss: 1.0470 - val_accuracy: 0.0000e+00\n",
      "Epoch 17/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6259 - accuracy: 0.6667 - val_loss: 1.0311 - val_accuracy: 0.0000e+00\n",
      "Epoch 18/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6204 - accuracy: 0.6667 - val_loss: 1.0328 - val_accuracy: 0.0000e+00\n",
      "Epoch 19/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6130 - accuracy: 0.6667 - val_loss: 1.0185 - val_accuracy: 0.0000e+00\n",
      "Epoch 20/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.6052 - accuracy: 0.6667 - val_loss: 0.9970 - val_accuracy: 0.0000e+00\n",
      "Epoch 21/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.5957 - accuracy: 0.6667 - val_loss: 0.9699 - val_accuracy: 0.0018\n",
      "Epoch 22/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.5858 - accuracy: 0.6673 - val_loss: 0.9014 - val_accuracy: 0.1136\n",
      "Epoch 23/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.5755 - accuracy: 0.6721 - val_loss: 0.9228 - val_accuracy: 0.1942\n",
      "Epoch 24/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.5627 - accuracy: 0.6832 - val_loss: 0.9009 - val_accuracy: 0.3123\n",
      "Epoch 25/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.5544 - accuracy: 0.6933 - val_loss: 0.8285 - val_accuracy: 0.4733\n",
      "Epoch 26/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.5416 - accuracy: 0.7020 - val_loss: 0.7685 - val_accuracy: 0.5947\n",
      "Epoch 27/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.5283 - accuracy: 0.7201 - val_loss: 0.7460 - val_accuracy: 0.6323\n",
      "Epoch 28/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.5145 - accuracy: 0.7341 - val_loss: 0.7388 - val_accuracy: 0.6429\n",
      "Epoch 29/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.5042 - accuracy: 0.7468 - val_loss: 0.6577 - val_accuracy: 0.7323\n",
      "Epoch 30/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.4910 - accuracy: 0.7509 - val_loss: 0.6352 - val_accuracy: 0.7469\n",
      "Epoch 31/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.4762 - accuracy: 0.7694 - val_loss: 0.5526 - val_accuracy: 0.8130\n",
      "Epoch 32/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.4573 - accuracy: 0.7801 - val_loss: 0.6027 - val_accuracy: 0.7556\n",
      "Epoch 33/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.4458 - accuracy: 0.7893 - val_loss: 0.5033 - val_accuracy: 0.8314\n",
      "Epoch 34/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.4361 - accuracy: 0.7992 - val_loss: 0.5882 - val_accuracy: 0.7558\n",
      "Epoch 35/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.4233 - accuracy: 0.8053 - val_loss: 0.4763 - val_accuracy: 0.8364\n",
      "Epoch 36/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.4148 - accuracy: 0.8116 - val_loss: 0.4623 - val_accuracy: 0.8402\n",
      "Epoch 37/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.4029 - accuracy: 0.8156 - val_loss: 0.4340 - val_accuracy: 0.8588\n",
      "Epoch 38/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.3947 - accuracy: 0.8213 - val_loss: 0.4216 - val_accuracy: 0.8634\n",
      "Epoch 39/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.3843 - accuracy: 0.8309 - val_loss: 0.3868 - val_accuracy: 0.8824\n",
      "Epoch 40/100\n",
      "15000/15000 [==============================] - 23047s 2s/sample - loss: 0.3753 - accuracy: 0.8339 - val_loss: 0.3953 - val_accuracy: 0.8698\n",
      "Epoch 41/100\n",
      "15000/15000 [==============================] - 19s 1ms/sample - loss: 0.3683 - accuracy: 0.8347 - val_loss: 0.4174 - val_accuracy: 0.8484\n",
      "Epoch 42/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.3610 - accuracy: 0.8439 - val_loss: 0.3321 - val_accuracy: 0.9088\n",
      "Epoch 43/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.3516 - accuracy: 0.8491 - val_loss: 0.3197 - val_accuracy: 0.9098\n",
      "Epoch 44/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.3523 - accuracy: 0.8467 - val_loss: 0.4053 - val_accuracy: 0.8544\n",
      "Epoch 45/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.3405 - accuracy: 0.8521 - val_loss: 0.3954 - val_accuracy: 0.8602\n",
      "Epoch 46/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.3342 - accuracy: 0.8552 - val_loss: 0.3315 - val_accuracy: 0.8886\n",
      "Epoch 47/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.3284 - accuracy: 0.8601 - val_loss: 0.2900 - val_accuracy: 0.9126\n",
      "Epoch 48/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.3267 - accuracy: 0.8593 - val_loss: 0.2972 - val_accuracy: 0.9124\n",
      "Epoch 49/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.3172 - accuracy: 0.8649 - val_loss: 0.3115 - val_accuracy: 0.9014\n",
      "Epoch 50/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.3171 - accuracy: 0.8655 - val_loss: 0.3083 - val_accuracy: 0.9020\n",
      "Epoch 51/100\n",
      "15000/15000 [==============================] - 17s 1ms/sample - loss: 0.3134 - accuracy: 0.8700 - val_loss: 0.3234 - val_accuracy: 0.8886\n",
      "Epoch 52/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.3068 - accuracy: 0.8701 - val_loss: 0.3355 - val_accuracy: 0.8802\n",
      "Epoch 53/100\n",
      "15000/15000 [==============================] - 17s 1ms/sample - loss: 0.2973 - accuracy: 0.8751 - val_loss: 0.2473 - val_accuracy: 0.9248\n",
      "Epoch 54/100\n",
      "15000/15000 [==============================] - 17s 1ms/sample - loss: 0.2920 - accuracy: 0.8779 - val_loss: 0.2681 - val_accuracy: 0.9154\n",
      "Epoch 55/100\n",
      "15000/15000 [==============================] - 17s 1ms/sample - loss: 0.2905 - accuracy: 0.8784 - val_loss: 0.2760 - val_accuracy: 0.9082\n",
      "Epoch 56/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.2867 - accuracy: 0.8839 - val_loss: 0.2866 - val_accuracy: 0.9006\n",
      "Epoch 57/100\n",
      "15000/15000 [==============================] - 17s 1ms/sample - loss: 0.2827 - accuracy: 0.8819 - val_loss: 0.2780 - val_accuracy: 0.9058\n",
      "Epoch 58/100\n",
      "15000/15000 [==============================] - 17s 1ms/sample - loss: 0.2759 - accuracy: 0.8879 - val_loss: 0.2546 - val_accuracy: 0.9184\n",
      "Epoch 59/100\n",
      "15000/15000 [==============================] - 18s 1ms/sample - loss: 0.2728 - accuracy: 0.8899 - val_loss: 0.3146 - val_accuracy: 0.8870\n",
      "Epoch 60/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.2701 - accuracy: 0.8913 - val_loss: 0.2284 - val_accuracy: 0.9286\n",
      "Epoch 61/100\n",
      "15000/15000 [==============================] - 17s 1ms/sample - loss: 0.2669 - accuracy: 0.8902 - val_loss: 0.2646 - val_accuracy: 0.9062\n",
      "Epoch 62/100\n",
      "15000/15000 [==============================] - 17s 1ms/sample - loss: 0.2592 - accuracy: 0.8943 - val_loss: 0.2279 - val_accuracy: 0.9266\n",
      "Epoch 63/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.2586 - accuracy: 0.8961 - val_loss: 0.2021 - val_accuracy: 0.9406\n",
      "Epoch 64/100\n",
      "15000/15000 [==============================] - 17s 1ms/sample - loss: 0.2508 - accuracy: 0.8993 - val_loss: 0.1605 - val_accuracy: 0.9594\n",
      "Epoch 65/100\n",
      "15000/15000 [==============================] - 17s 1ms/sample - loss: 0.2461 - accuracy: 0.9004 - val_loss: 0.2198 - val_accuracy: 0.9286\n",
      "Epoch 66/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.2442 - accuracy: 0.9020 - val_loss: 0.1601 - val_accuracy: 0.9592\n",
      "Epoch 67/100\n",
      "15000/15000 [==============================] - 17s 1ms/sample - loss: 0.2443 - accuracy: 0.8988 - val_loss: 0.1759 - val_accuracy: 0.9496\n",
      "Epoch 68/100\n",
      "15000/15000 [==============================] - 17s 1ms/sample - loss: 0.2374 - accuracy: 0.9018 - val_loss: 0.1450 - val_accuracy: 0.9640\n",
      "Epoch 69/100\n",
      "15000/15000 [==============================] - 18s 1ms/sample - loss: 0.2285 - accuracy: 0.9106 - val_loss: 0.2645 - val_accuracy: 0.9044\n",
      "Epoch 70/100\n",
      "15000/15000 [==============================] - 17s 1ms/sample - loss: 0.2278 - accuracy: 0.9093 - val_loss: 0.1759 - val_accuracy: 0.9496\n",
      "Epoch 71/100\n",
      "15000/15000 [==============================] - 17s 1ms/sample - loss: 0.2282 - accuracy: 0.9095 - val_loss: 0.1563 - val_accuracy: 0.9574\n",
      "Epoch 72/100\n",
      "15000/15000 [==============================] - 17s 1ms/sample - loss: 0.2254 - accuracy: 0.9099 - val_loss: 0.1570 - val_accuracy: 0.9562\n",
      "Epoch 73/100\n",
      "15000/15000 [==============================] - 17s 1ms/sample - loss: 0.2220 - accuracy: 0.9118 - val_loss: 0.1682 - val_accuracy: 0.9510\n",
      "Epoch 74/100\n",
      "15000/15000 [==============================] - 20s 1ms/sample - loss: 0.2128 - accuracy: 0.9167 - val_loss: 0.1759 - val_accuracy: 0.9426\n",
      "Epoch 75/100\n",
      "15000/15000 [==============================] - 25s 2ms/sample - loss: 0.2090 - accuracy: 0.9181 - val_loss: 0.1708 - val_accuracy: 0.9472\n",
      "Epoch 76/100\n",
      "15000/15000 [==============================] - 24s 2ms/sample - loss: 0.2065 - accuracy: 0.9200 - val_loss: 0.1666 - val_accuracy: 0.9490\n",
      "Epoch 77/100\n",
      "15000/15000 [==============================] - 25s 2ms/sample - loss: 0.2033 - accuracy: 0.9189 - val_loss: 0.1498 - val_accuracy: 0.9576\n",
      "Epoch 78/100\n",
      "15000/15000 [==============================] - 24s 2ms/sample - loss: 0.2052 - accuracy: 0.9186 - val_loss: 0.1301 - val_accuracy: 0.9666\n",
      "Epoch 79/100\n",
      "15000/15000 [==============================] - 24s 2ms/sample - loss: 0.1987 - accuracy: 0.9237 - val_loss: 0.2053 - val_accuracy: 0.9266\n",
      "Epoch 80/100\n",
      "15000/15000 [==============================] - 24s 2ms/sample - loss: 0.2011 - accuracy: 0.9211 - val_loss: 0.1375 - val_accuracy: 0.9602\n",
      "Epoch 81/100\n",
      "15000/15000 [==============================] - 23s 2ms/sample - loss: 0.1885 - accuracy: 0.9285 - val_loss: 0.1368 - val_accuracy: 0.9588\n",
      "Epoch 82/100\n",
      "15000/15000 [==============================] - 19s 1ms/sample - loss: 0.1856 - accuracy: 0.9284 - val_loss: 0.1367 - val_accuracy: 0.9612\n",
      "Epoch 83/100\n",
      "15000/15000 [==============================] - 19s 1ms/sample - loss: 0.1901 - accuracy: 0.9265 - val_loss: 0.1198 - val_accuracy: 0.9694\n",
      "Epoch 84/100\n",
      "15000/15000 [==============================] - 19s 1ms/sample - loss: 0.1798 - accuracy: 0.9310 - val_loss: 0.1386 - val_accuracy: 0.9576\n",
      "Epoch 85/100\n",
      "15000/15000 [==============================] - 18s 1ms/sample - loss: 0.1791 - accuracy: 0.9304 - val_loss: 0.1129 - val_accuracy: 0.9702\n",
      "Epoch 86/100\n",
      "15000/15000 [==============================] - 19s 1ms/sample - loss: 0.1746 - accuracy: 0.9330 - val_loss: 0.1464 - val_accuracy: 0.9524\n",
      "Epoch 87/100\n",
      "15000/15000 [==============================] - 19s 1ms/sample - loss: 0.1780 - accuracy: 0.9292 - val_loss: 0.1310 - val_accuracy: 0.9614\n",
      "Epoch 88/100\n",
      "15000/15000 [==============================] - 19s 1ms/sample - loss: 0.1698 - accuracy: 0.9359 - val_loss: 0.1219 - val_accuracy: 0.9658\n",
      "Epoch 89/100\n",
      "15000/15000 [==============================] - 19s 1ms/sample - loss: 0.1693 - accuracy: 0.9349 - val_loss: 0.1233 - val_accuracy: 0.9644\n",
      "Epoch 90/100\n",
      "15000/15000 [==============================] - 19s 1ms/sample - loss: 0.1618 - accuracy: 0.9391 - val_loss: 0.1368 - val_accuracy: 0.9588\n",
      "Epoch 91/100\n",
      "15000/15000 [==============================] - 19s 1ms/sample - loss: 0.1652 - accuracy: 0.9367 - val_loss: 0.1321 - val_accuracy: 0.9610\n",
      "Epoch 92/100\n",
      "15000/15000 [==============================] - 19s 1ms/sample - loss: 0.1606 - accuracy: 0.9373 - val_loss: 0.0893 - val_accuracy: 0.9784\n",
      "Epoch 93/100\n",
      "15000/15000 [==============================] - 19s 1ms/sample - loss: 0.1598 - accuracy: 0.9405 - val_loss: 0.0972 - val_accuracy: 0.9744\n",
      "Epoch 94/100\n",
      "15000/15000 [==============================] - 18s 1ms/sample - loss: 0.1533 - accuracy: 0.9433 - val_loss: 0.1374 - val_accuracy: 0.9582\n",
      "Epoch 95/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.1518 - accuracy: 0.9436 - val_loss: 0.0785 - val_accuracy: 0.9816\n",
      "Epoch 96/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.1471 - accuracy: 0.9454 - val_loss: 0.0980 - val_accuracy: 0.9736\n",
      "Epoch 97/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.1466 - accuracy: 0.9438 - val_loss: 0.1199 - val_accuracy: 0.9628\n",
      "Epoch 98/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.1435 - accuracy: 0.9467 - val_loss: 0.1325 - val_accuracy: 0.9542\n",
      "Epoch 99/100\n",
      "15000/15000 [==============================] - 16s 1ms/sample - loss: 0.1426 - accuracy: 0.9462 - val_loss: 0.0694 - val_accuracy: 0.9826\n",
      "Epoch 100/100\n",
      "15000/15000 [==============================] - 17s 1ms/sample - loss: 0.1354 - accuracy: 0.9491 - val_loss: 0.1072 - val_accuracy: 0.9676\n",
      "Test loss: 0.10718404499142856\n",
      "Test accuracy: 0.9675935\n"
     ]
    }
   ],
   "source": [
    "# divide dataset into this number of batches:\n",
    "batch_size = 32 # number of images per batch\n",
    "9\n",
    "n_epochs = 100\n",
    "\n",
    "opt = Adam(lr=0.00001, beta_1=0.9)\n",
    "model.compile(loss=[\"binary_crossentropy\"], optimizer=opt, metrics=['accuracy'])\n",
    "\n",
    "model.fit(train_data, train_labels, batch_size=batch_size, epochs= n_epochs, verbose=1, validation_data=(test_data, test_labels))\n",
    "\n",
    "score = model.evaluate(test_data, test_labels, verbose=0)\n",
    "print('Test loss:', score[0])\n",
    "print('Test accuracy:', score[1])\n",
    "\n",
    "model.save('quality_index_model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.0174883 ]\n",
      " [0.35710692]\n",
      " [0.001876  ]\n",
      " [0.00166079]\n",
      " [0.12455353]\n",
      " [0.00492913]\n",
      " [0.00546196]\n",
      " [0.00564307]\n",
      " [0.00985871]\n",
      " [0.00724415]]\n",
      "[[0.92441773]\n",
      " [0.9816787 ]\n",
      " [0.9224082 ]\n",
      " [0.9305568 ]\n",
      " [0.9508183 ]\n",
      " [0.9666634 ]\n",
      " [0.45275873]\n",
      " [0.96568584]\n",
      " [0.99101347]\n",
      " [0.9744109 ]]\n",
      " closer to 1 means detected as deformed, closer to 0 means detected ad original\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.models import load_model\n",
    "quality_model = load_model('quality_index_model.h5', custom_objects={'SNConv2DTranspose':SNConv2DTranspose, 'SNConv2D': SNConv2D})\n",
    "\n",
    "prediction = model.predict(real_dataset[0][0:10])\n",
    "print(prediction)\n",
    "\n",
    "prediction = model.predict(deformed_dataset[0][0:10])\n",
    "print(prediction)\n",
    "\n",
    "print(\" closer to 1 means detected as deformed, closer to 0 means detected ad original\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " closer to 1 means detected as deformed, closer to 0 means detected ad original\n",
      "[[0.17932907]\n",
      " [0.02543494]\n",
      " [0.00110149]\n",
      " [0.01818246]\n",
      " [0.00119638]\n",
      " [0.02828401]\n",
      " [0.00065315]\n",
      " [0.09194243]]\n"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "\n",
    "images= []\n",
    "for i in range(8):\n",
    "    \n",
    "\n",
    "    img=cv2.imread(\"test_image\" + str(i) + \".jpg\")\n",
    "    img=cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "    #print(raw_image)\n",
    "    img = np.array(img ,dtype='float32')\n",
    "    #plt.imshow(img_cvt)\n",
    "    #plt.show()\n",
    "    img =  (img - 127.5) / 127.5 # from [0, 255] to [-1, 1]\n",
    "    images.append(img)\n",
    "    \n",
    "plot_images(np.array(images),8)\n",
    "predictions = model.predict(np.array(images, dtype='float32'))\n",
    "print(\" closer to 1 means detected as deformed, closer to 0 means detected ad original\")\n",
    "print(predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# compare with FID:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from numpy.random import randn\n",
    "from numpy.random import randint\n",
    "import os\n",
    "import cv2\n",
    "import pandas as pd\n",
    "import gzip\n",
    "from tensorflow.keras import backend as K\n",
    "import tensorflow as tf \n",
    "from matplotlib import pyplot as plt\n",
    "from tensorflow.keras.preprocessing.image import load_img\n",
    "from tensorflow.keras.datasets.mnist import load_data\n",
    "from tensorflow.keras.models import load_model\n",
    "from tensorflow.keras.preprocessing.image import img_to_array\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Layer\n",
    "from tensorflow.keras.layers import Input\n",
    "from tensorflow.keras.layers import Dense\n",
    "from tensorflow.keras.layers import Reshape\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Flatten\n",
    "from tensorflow.keras.layers import Conv2D\n",
    "from tensorflow.keras.layers import Conv2DTranspose\n",
    "from tensorflow.keras.layers import LeakyReLU, ReLU\n",
    "from tensorflow.keras.layers import Dropout\n",
    "from tensorflow.keras.layers import Embedding\n",
    "from tensorflow.keras.layers import Concatenate\n",
    "from tensorflow.python.keras.utils import conv_utils\n",
    "from tensorflow.keras.initializers import RandomNormal\n",
    "import random \n",
    "from tensorflow.keras.layers import Conv2D, Input, Dense, Activation, Reshape, GlobalAveragePooling2D, UpSampling2D, LeakyReLU, Dropout, BatchNormalization\n",
    "\n",
    "#epsilon set according to BIGGAN https://arxiv.org/pdf/1809.11096.pdf\n",
    "\n",
    "def _l2normalizer(v, epsilon=1e-4):\n",
    "    return v / (K.sum(v**2)**0.5 + epsilon)\n",
    "\n",
    "\n",
    "def power_iteration(W, u, rounds=1):\n",
    "    '''\n",
    "    Accroding the paper, we only need to do power iteration one time.\n",
    "    '''\n",
    "    _u = u\n",
    "\n",
    "    for i in range(rounds):\n",
    "        _v = _l2normalizer(K.dot(_u, W))\n",
    "        _u = _l2normalizer(K.dot(_v, K.transpose(W)))\n",
    "\n",
    "    W_sn = K.sum(K.dot(_u, W) * _v)\n",
    "    return W_sn, _u, _v\n",
    "\n",
    "\"\"\"\n",
    "Convolution 2D with spectral normalization\n",
    "\"\"\"\n",
    "class SNConv2D(Conv2D):\n",
    "    def __init__(self, filters, spectral_normalization=True, **kwargs):\n",
    "        self.spectral_normalization = spectral_normalization\n",
    "        super(SNConv2D, self).__init__(filters, **kwargs)\n",
    "\n",
    "    def build(self, input_shape):\n",
    "        # Create a trainable weight variable for this layer.\n",
    "\n",
    "        self.u = self.add_weight(name='u', shape=(1, self.filters),\n",
    "                                 initializer='uniform', trainable=False)\n",
    "        super(SNConv2D, self).build(input_shape)\n",
    "        # Be sure to call this at the end\n",
    "\n",
    "    def compute_spectral_normal(self, training=True):\n",
    "        # Spectrally Normalized Weight\n",
    "        if self.spectral_normalization:\n",
    "            # Get kernel tensor shape [kernel_h, kernel_w, in_channels, out_channels]\n",
    "            W_shape = self.kernel.shape.as_list()\n",
    "\n",
    "            # Flatten the Tensor\n",
    "            # [out_channels, N]\n",
    "            W_mat = K.reshape(self.kernel, [W_shape[-1], -1])\n",
    "\n",
    "            W_sn, u, v = power_iteration(W_mat, self.u)\n",
    "\n",
    "            if training:\n",
    "                # Update estimated 1st singular vector\n",
    "                self.u.assign(u)\n",
    "\n",
    "            return self.kernel / W_sn\n",
    "        else:\n",
    "            return self.kernel\n",
    "\n",
    "    def call(self, inputs, training=None):\n",
    "\n",
    "        outputs = K.conv2d(inputs,\n",
    "                           self.compute_spectral_normal(training=training),\n",
    "                           strides=self.strides, padding=self.padding,\n",
    "                           data_format=self.data_format,\n",
    "                           dilation_rate=self.dilation_rate)\n",
    "\n",
    "        if self.use_bias:\n",
    "            outputs = K.bias_add(outputs, self.bias,\n",
    "                                 data_format=self.data_format)\n",
    "\n",
    "        if self.activation is not None:\n",
    "            return self.activation(outputs)\n",
    "        return outputs\n",
    "\n",
    "    def compute_output_shape(self, input_shape):\n",
    "        return super(SNConv2D, self).compute_output_shape(input_shape)\n",
    "\n",
    "\"\"\"\n",
    "Transposed Convolution 2D with spectral normalization\n",
    "\"\"\"\n",
    "class SNConv2DTranspose(Conv2DTranspose):\n",
    "    def __init__(self, spectral_normalization=True, **kwargs):\n",
    "        self.spectral_normalization = spectral_normalization\n",
    "        super(SNConv2DTranspose, self).__init__(**kwargs)\n",
    "\n",
    "    def build(self, input_shape):\n",
    "        # Create a trainable weight variable for this layer.\n",
    "        self.u = self.add_weight(name='u', shape=(1, self.filters),\n",
    "                                 initializer='uniform', trainable=False)\n",
    "        super(SNConv2DTranspose, self).build(input_shape)\n",
    "        # Be sure to call this at the end\n",
    "\n",
    "    def compute_spectral_normal(self, training=True):\n",
    "        # Spectrally Normalized Weight\n",
    "        if self.spectral_normalization:\n",
    "            # Get kernel tensor shape [kernel_h, kernel_w, in_channels, out_channels]\n",
    "            W_shape = self.kernel.shape.as_list()\n",
    "\n",
    "            # Flatten the Tensor\n",
    "            # [out_channels, N]\n",
    "            W_mat = K.reshape(self.kernel, [W_shape[-2], -1])\n",
    "\n",
    "            W_sn, u, v = power_iteration(W_mat, self.u)\n",
    "\n",
    "            if training:\n",
    "                # Update estimated 1st singular vector\n",
    "                self.u.assign(u)\n",
    "\n",
    "            return self.kernel / W_sn\n",
    "        else:\n",
    "            return self.kernel\n",
    "\n",
    "    def call(self, inputs, training=None):\n",
    "        input_shape = K.shape(inputs)\n",
    "        batch_size = input_shape[0]\n",
    "        if self.data_format == 'channels_first':\n",
    "            h_axis, w_axis = 2, 3\n",
    "        else:\n",
    "            h_axis, w_axis = 1, 2\n",
    "\n",
    "        height, width = input_shape[h_axis], input_shape[w_axis]\n",
    "        kernel_h, kernel_w = self.kernel_size\n",
    "        stride_h, stride_w = self.strides\n",
    "        out_pad_h = out_pad_w = None\n",
    "\n",
    "        # Infer the dynamic output shape:\n",
    "        out_height = conv_utils.deconv_output_length(\n",
    "            height, kernel_h, self.padding, stride=stride_h)\n",
    "        out_width = conv_utils.deconv_output_length(\n",
    "            width, kernel_w, self.padding, stride=stride_w)\n",
    "        if self.data_format == 'channels_first':\n",
    "            output_shape = (batch_size, self.filters, out_height, out_width)\n",
    "        else:\n",
    "            output_shape = (batch_size, out_height, out_width, self.filters)\n",
    "\n",
    "        outputs = K.conv2d_transpose(\n",
    "            inputs,\n",
    "            self.compute_spectral_normal(training=training),\n",
    "            output_shape,\n",
    "            self.strides,\n",
    "            padding=self.padding,\n",
    "            data_format=self.data_format\n",
    "        )\n",
    "\n",
    "        if self.use_bias:\n",
    "            outputs = K.bias_add(outputs, self.bias,\n",
    "                                 data_format=self.data_format)\n",
    "\n",
    "        if self.activation is not None:\n",
    "            return self.activation(outputs)\n",
    "        return outputs\n",
    "\n",
    "    def compute_output_shape(self, input_shape):\n",
    "        return super(SNConv2DTranspose, self).compute_output_shape(input_shape)\n",
    "    \n",
    "class PixelNormalization(Layer):\n",
    "    def __init__(self, **kwargs):\n",
    "        super(PixelNormalization, self).__init__(**kwargs)\n",
    "\n",
    "    def call(self, inputs):\n",
    "        # Calculate square pixel values\n",
    "        values = inputs**2.0\n",
    "        # Calculate the mean pixel values\n",
    "        mean_values = tf.keras.backend.mean(values, axis=-1, keepdims=True)\n",
    "        # Ensure the mean is not zero\n",
    "        mean_values += 1.0e-8\n",
    "        # Calculate the sqrt of the mean squared value (L2 norm)\n",
    "        l2 = tf.keras.backend.sqrt(mean_values)\n",
    "        # Normalize values by the l2 norm\n",
    "        normalized = inputs / l2\n",
    "        return normalized\n",
    "\n",
    "    def compute_output_shape(self, input_shape):\n",
    "        return input_shape\n",
    "    \n",
    "class MinibatchStdev(Layer):\n",
    "    # initialize the layer\n",
    "    def __init__(self, **kwargs):\n",
    "        super(MinibatchStdev, self).__init__(**kwargs)\n",
    "\n",
    "    # perform the operation\n",
    "    def call(self, inputs):\n",
    "        # calculate the mean value for each pixel across channels\n",
    "        mean = tf.keras.backend.mean(inputs, axis=0, keepdims=True)\n",
    "        # calculate the squared differences between pixel values and mean\n",
    "        squ_diffs = tf.keras.backend.square(inputs - mean)\n",
    "        # calculate the average of the squared differences (variance)\n",
    "        mean_sq_diff = tf.keras.backend.mean(squ_diffs, axis=0, keepdims=True)\n",
    "        # add a small value to avoid a blow-up when we calculate stdev\n",
    "        mean_sq_diff += 1e-8\n",
    "        # square root of the variance (stdev)\n",
    "        stdev = tf.keras.backend.sqrt(mean_sq_diff)\n",
    "        # calculate the mean standard deviation across each pixel coord\n",
    "        mean_pix = tf.keras.backend.mean(stdev, keepdims=True)\n",
    "        # scale this up to be the size of one input feature map for each sample\n",
    "        shape = tf.keras.backend.shape(inputs)\n",
    "        output = tf.keras.backend.tile(mean_pix, (shape[0], shape[1], shape[2], 1))\n",
    "        # concatenate with the output\n",
    "        combined = tf.keras.backend.concatenate([inputs, output], axis=-1)\n",
    "        return combined\n",
    "\n",
    "    # define the output shape of the layer\n",
    "    def compute_output_shape(self, input_shape):\n",
    "        # create a copy of the input shape as a list\n",
    "        input_shape = list(input_shape)\n",
    "        # add one to the channel dimension (assume channels-last)\n",
    "        input_shape[-1] += 1\n",
    "        # convert list to a tuple\n",
    "        return tuple(input_shape)\n",
    "    \n",
    "def generate_latent_points(latent_dim, n_samples, n_attr, n_classes=2): # two calsses: 0 and 1\n",
    "    # generate points in the latent space\n",
    "    x_input = randn(latent_dim * n_samples)\n",
    "    # reshape into a batch of inputs for the network\n",
    "    z_input = x_input.reshape(n_samples, latent_dim)\n",
    "    # generate labels\n",
    "    labels = np.random.randint(n_classes, size=(n_samples, n_attr))\n",
    "    return [z_input, labels]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "5\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "10\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "15\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "20\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "25\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "30\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "35\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "40\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "45\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "50\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "55\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "60\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "65\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "70\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "75\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "80\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "85\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "90\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "95\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "100\n",
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.models import load_model\n",
    "quality_model = load_model('quality_index_model10k100epo_5_0.9.h5', custom_objects={'SNConv2DTranspose':SNConv2DTranspose, 'SNConv2D': SNConv2D})\n",
    "quality_scores =[]\n",
    "\n",
    "n_images = 10000\n",
    "\n",
    "latent_points, labels = generate_latent_points(128, n_images, 40)\n",
    "\n",
    "i=1\n",
    "while i <= 100:\n",
    "    print(i)\n",
    "    gan_model = load_model('GAN models/gan_generator' + str(i)+ 'epoch.h5', custom_objects={'SNConv2DTranspose':SNConv2DTranspose, 'SNConv2D': SNConv2D, 'PixelNormalization':PixelNormalization})\n",
    "    images = gan_model.predict(latent_points)    \n",
    "    predictions = quality_model.predict(np.array(images, dtype='float32'))\n",
    "    mean_prediction = np.mean(np.array(predictions))\n",
    "    quality_scores.append(mean_prediction)\n",
    "    if i==1:\n",
    "        i =5\n",
    "    else:\n",
    "        i = i+5\n",
    "    \n",
    "\n",
    "\n",
    "quality_scores = np.array(quality_scores)\n",
    "quality_scores = quality_scores/np.max(quality_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x228415cdec8>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "x = [1,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100]\n",
    "ax.plot(x, quality_scores,'b')\n",
    "FID_scores = np.array([69,30,20,19,17,15,13.2,13,12.9,12.8,12.7,12.5,12.3,12.1,12.2,11.9,12,11.7,11.6,11.4,11.3]) # computed in another file\n",
    "FID_scores = FID_scores /np.max(FID_scores)\n",
    "ax.plot(x, FID_scores, 'r')\n",
    "ax.legend(['our_metric','FID'])\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}