Calculate Inception score

README.md

@@ -7,6 +7,12 @@ Code for my Master thesis on "Capsule Layer as a Discriminator in Generative Adv
 * Image outputs
 * Metrics visualization
 
+***
+
+But first you may want to install [Miniconda](https://conda.io/miniconda.html) and corresponding dependencies from environment.yml:
+`conda env create -f environment.yml` within the project directory as well as install [required tools for GPU computing](https://www.tensorflow.org/install/install_windows#requirements_to_run_tensorflow_with_gpu_support). If no GPU is going to be used - delete the `tensorflow-gpu` line from environment.yml.
+
+
 ### Generated images
 ![MNIST_output](/out_metrics/mnist_output_sample.png?raw=true)
 ![CIFAR10_output](/out_metrics/cifar10_output_sample.png?raw=true)

inception_score.ipynb

@@ -0,0 +1,263 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from __future__ import absolute_import\n",
+    "from __future__ import division\n",
+    "from __future__ import print_function\n",
+    "\n",
+    "import os.path\n",
+    "import sys\n",
+    "import tarfile\n",
+    "\n",
+    "import numpy as np\n",
+    "from six.moves import urllib\n",
+    "import tensorflow as tf\n",
+    "from tqdm import tqdm\n",
+    "import glob\n",
+    "import scipy.misc\n",
+    "import math\n",
+    "import sys\n",
+    "\n",
+    "import skimage\n",
+    "from skimage import data, color, exposure\n",
+    "from skimage.transform import resize\n",
+    "import matplotlib.pyplot as plt\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "MODEL_DIR = '/tmp/imagenet'\n",
+    "DATA_URL = 'http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz'\n",
+    "softmax = None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Call this function with list of images. Each of elements should be a \n",
+    "# numpy array with values ranging from 0 to 255.\n",
+    "def get_inception_score(images, splits=10):\n",
+    "    assert(type(images) == list)\n",
+    "    assert(type(images[0]) == np.ndarray)\n",
+    "    #assert(len(images[0].shape) == 3)\n",
+    "    #assert(np.max(images[0]) > 10)\n",
+    "    #assert(np.min(images[0]) >= 0.0)\n",
+    "    inps = []\n",
+    "    for img in images:\n",
+    "        img = img.astype(np.float32)\n",
+    "        inps.append(np.expand_dims(img, 0))\n",
+    "    bs = 100\n",
+    "    with tf.Session() as sess:\n",
+    "        preds = []\n",
+    "        n_batches = int(math.ceil(float(len(inps)) / float(bs)))\n",
+    "        for i in range(n_batches):\n",
+    "            sys.stdout.write(\".\")\n",
+    "            sys.stdout.flush()\n",
+    "            inp = inps[(i * bs):min((i + 1) * bs, len(inps))]\n",
+    "            inp = np.concatenate(inp, 0)\n",
+    "            pred = sess.run(softmax, {'ExpandDims:0': inp})\n",
+    "            preds.append(pred)\n",
+    "        preds = np.concatenate(preds, 0)\n",
+    "        scores = []\n",
+    "        for i in range(splits):\n",
+    "            part = preds[(i * preds.shape[0] // splits):((i + 1) * preds.shape[0] // splits), :]\n",
+    "            kl = part * (np.log(part) - np.log(np.expand_dims(np.mean(part, 0), 0)))\n",
+    "            kl = np.mean(np.sum(kl, 1))\n",
+    "            scores.append(np.exp(kl))\n",
+    "        return np.mean(scores), np.std(scores)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This function is called automatically.\n",
+    "def _init_inception():\n",
+    "    global softmax\n",
+    "    if not os.path.exists(MODEL_DIR):\n",
+    "        os.makedirs(MODEL_DIR)\n",
+    "    filename = DATA_URL.split('/')[-1]\n",
+    "    filepath = os.path.join(MODEL_DIR, filename)\n",
+    "    if not os.path.exists(filepath):\n",
+    "        def _progress(count, block_size, total_size):\n",
+    "            sys.stdout.write('\\r>> Downloading %s %.1f%%' % (\n",
+    "                filename, float(count * block_size) / float(total_size) * 100.0))\n",
+    "        sys.stdout.flush()\n",
+    "        filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\n",
+    "        print()\n",
+    "        statinfo = os.stat(filepath)\n",
+    "        print('Succesfully downloaded', filename, statinfo.st_size, 'bytes.')\n",
+    "    tarfile.open(filepath, 'r:gz').extractall(MODEL_DIR)\n",
+    "    with tf.gfile.FastGFile(os.path.join(\n",
+    "        MODEL_DIR, 'classify_image_graph_def.pb'), 'rb') as f:\n",
+    "        graph_def = tf.GraphDef()\n",
+    "        graph_def.ParseFromString(f.read())\n",
+    "        _ = tf.import_graph_def(graph_def, name='')\n",
+    "    # Works with an arbitrary minibatch size.\n",
+    "    with tf.Session() as sess:\n",
+    "        pool3 = sess.graph.get_tensor_by_name('pool_3:0')\n",
+    "        ops = pool3.graph.get_operations()\n",
+    "        for op_idx, op in enumerate(ops):\n",
+    "            for o in op.outputs:\n",
+    "                shape = o.get_shape()\n",
+    "                shape = [s.value for s in shape]\n",
+    "                new_shape = []\n",
+    "                for j, s in enumerate(shape):\n",
+    "                    if s == 1 and j == 0:\n",
+    "                        new_shape.append(None)\n",
+    "                    else:\n",
+    "                        new_shape.append(s)\n",
+    "                o._shape = tf.TensorShape(new_shape)\n",
+    "        w = sess.graph.get_operation_by_name(\"softmax/logits/MatMul\").inputs[1]\n",
+    "        logits = tf.matmul(tf.squeeze(pool3), w)\n",
+    "        softmax = tf.nn.softmax(logits)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "_init_inception()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Import CIFAR10 dataset to get the Inception Score"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_cifar10  = []\n",
+    "\n",
+    "cifar10_imgs = glob.glob(\"./cifar10_inception_score_samples/*.png\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|                                                  | 0/121 [00:00<?, ?it/s]C:\\Users\\husey_000\\Miniconda3\\envs\\capsule-gans\\lib\\site-packages\\skimage\\transform\\_warps.py:84: UserWarning: The default mode, 'constant', will be changed to 'reflect' in skimage 0.15.\n",
+      "  warn(\"The default mode, 'constant', will be changed to 'reflect' in \"\n",
+      "100%|███████████████████████████████████████| 121/121 [00:00<00:00, 139.70it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0xec2b443198>"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0xec26f6af98>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# load CIFAR10 sample images\n",
+    "for img in tqdm(cifar10_imgs):\n",
+    "    img = skimage.io.imread(img)[:, :, :3]\n",
+    "    X_cifar10.append(resize(img, (32, 32, 3)))\n",
+    "    \n",
+    "plt.imshow(X_cifar10[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "."
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(1.0015844, 0.00045226174)"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# cifar10 inception score (mean, standard dev)\n",
+    "get_inception_score(X_cifar10[:-60], 10)"
+   ]
+  }
+ ],
+ "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.5.0"
+  },
+  "widgets": {
+   "state": {},
+   "version": "1.1.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}