ProtoNet-Omniglot.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.6/importlib/_bootstrap.py:219: RuntimeWarning: compiletime version 3.5 of module 'tensorflow.python.framework.fast_tensor_util' does not match runtime version 3.6\n",
      "  return f(*args, **kwds)\n",
      "/opt/anaconda3/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "from __future__ import print_function\n",
    "from PIL import Image\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import os\n",
    "import glob\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def conv_block(inputs, out_channels, name='conv'):\n",
    "    with tf.variable_scope(name):\n",
    "        conv = tf.layers.conv2d(inputs, out_channels, kernel_size=3, padding='SAME')\n",
    "        conv = tf.contrib.layers.batch_norm(conv, updates_collections=None, decay=0.99, scale=True, center=True)\n",
    "        conv = tf.nn.relu(conv)\n",
    "        conv = tf.contrib.layers.max_pool2d(conv, 2)\n",
    "        return conv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def encoder(x, h_dim, z_dim, reuse=False):\n",
    "    with tf.variable_scope('encoder', reuse=reuse):\n",
    "        net = conv_block(x, h_dim, name='conv_1')\n",
    "        net = conv_block(net, h_dim, name='conv_2')\n",
    "        net = conv_block(net, h_dim, name='conv_3')\n",
    "        net = conv_block(net, z_dim, name='conv_4')\n",
    "        net = tf.contrib.layers.flatten(net)\n",
    "        return net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def euclidean_distance(a, b):\n",
    "    # a.shape = N x D\n",
    "    # b.shape = M x D\n",
    "    N, D = tf.shape(a)[0], tf.shape(a)[1]\n",
    "    M = tf.shape(b)[0]\n",
    "    a = tf.tile(tf.expand_dims(a, axis=1), (1, M, 1))\n",
    "    b = tf.tile(tf.expand_dims(b, axis=0), (N, 1, 1))\n",
    "    return tf.reduce_mean(tf.square(a - b), axis=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "n_epochs = 20\n",
    "n_episodes = 100\n",
    "n_way = 60\n",
    "n_shot = 5\n",
    "n_query = 5\n",
    "n_examples = 20\n",
    "im_width, im_height, channels = 28, 28, 1\n",
    "h_dim = 64\n",
    "z_dim = 64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4112, 20, 28, 28)\n"
     ]
    }
   ],
   "source": [
    "# Load Train Dataset\n",
    "root_dir = './data/omniglot'\n",
    "train_split_path = os.path.join(root_dir, 'splits', 'train.txt')\n",
    "with open(train_split_path, 'r') as train_split:\n",
    "    train_classes = [line.rstrip() for line in train_split.readlines()]\n",
    "n_classes = len(train_classes)\n",
    "train_dataset = np.zeros([n_classes, n_examples, im_height, im_width], dtype=np.float32)\n",
    "for i, tc in enumerate(train_classes):\n",
    "    alphabet, character, rotation = tc.split('/')\n",
    "    rotation = float(rotation[3:])\n",
    "    im_dir = os.path.join(root_dir, 'data', alphabet, character)\n",
    "    im_files = sorted(glob.glob(os.path.join(im_dir, '*.png')))\n",
    "    for j, im_file in enumerate(im_files):\n",
    "        im = 1. - np.array(Image.open(im_file).rotate(rotation).resize((im_width, im_height)), np.float32, copy=False)\n",
    "        train_dataset[i, j] = im\n",
    "print(train_dataset.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = tf.placeholder(tf.float32, [None, None, im_height, im_width, channels])\n",
    "q = tf.placeholder(tf.float32, [None, None, im_height, im_width, channels])\n",
    "x_shape = tf.shape(x)\n",
    "q_shape = tf.shape(q)\n",
    "num_classes, num_support = x_shape[0], x_shape[1]\n",
    "num_queries = q_shape[1]\n",
    "y = tf.placeholder(tf.int64, [None, None])\n",
    "y_one_hot = tf.one_hot(y, depth=num_classes)\n",
    "emb_x = encoder(tf.reshape(x, [num_classes * num_support, im_height, im_width, channels]), h_dim, z_dim)\n",
    "emb_dim = tf.shape(emb_x)[-1]\n",
    "emb_x = tf.reduce_mean(tf.reshape(emb_x, [num_classes, num_support, emb_dim]), axis=1)\n",
    "emb_q = encoder(tf.reshape(q, [num_classes * num_queries, im_height, im_width, channels]), h_dim, z_dim, reuse=True)\n",
    "dists = euclidean_distance(emb_q, emb_x)\n",
    "log_p_y = tf.reshape(tf.nn.log_softmax(-dists), [num_classes, num_queries, -1])\n",
    "ce_loss = -tf.reduce_mean(tf.reshape(tf.reduce_sum(tf.multiply(y_one_hot, log_p_y), axis=-1), [-1]))\n",
    "acc = tf.reduce_mean(tf.to_float(tf.equal(tf.argmax(log_p_y, axis=-1), y)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train_op = tf.train.AdamOptimizer().minimize(ce_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sess = tf.InteractiveSession()\n",
    "init_op = tf.global_variables_initializer()\n",
    "sess.run(init_op)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[epoch 1/20, episode 50/100] => loss: 2.05681, acc: 0.69667\n",
      "[epoch 1/20, episode 100/100] => loss: 1.31057, acc: 0.84333\n",
      "[epoch 2/20, episode 50/100] => loss: 0.95323, acc: 0.85667\n",
      "[epoch 2/20, episode 100/100] => loss: 0.77123, acc: 0.90667\n",
      "[epoch 3/20, episode 50/100] => loss: 0.56138, acc: 0.93333\n",
      "[epoch 3/20, episode 100/100] => loss: 0.56206, acc: 0.91667\n",
      "[epoch 4/20, episode 50/100] => loss: 0.41580, acc: 0.95000\n",
      "[epoch 4/20, episode 100/100] => loss: 0.32341, acc: 0.95333\n",
      "[epoch 5/20, episode 50/100] => loss: 0.21081, acc: 0.98667\n",
      "[epoch 5/20, episode 100/100] => loss: 0.23478, acc: 0.97333\n",
      "[epoch 6/20, episode 50/100] => loss: 0.18931, acc: 0.96000\n",
      "[epoch 6/20, episode 100/100] => loss: 0.25989, acc: 0.93333\n",
      "[epoch 7/20, episode 50/100] => loss: 0.16271, acc: 0.97667\n",
      "[epoch 7/20, episode 100/100] => loss: 0.18911, acc: 0.96000\n",
      "[epoch 8/20, episode 50/100] => loss: 0.19383, acc: 0.96333\n",
      "[epoch 8/20, episode 100/100] => loss: 0.16333, acc: 0.96333\n",
      "[epoch 9/20, episode 50/100] => loss: 0.13290, acc: 0.98000\n",
      "[epoch 9/20, episode 100/100] => loss: 0.12453, acc: 0.98000\n",
      "[epoch 10/20, episode 50/100] => loss: 0.15873, acc: 0.97000\n",
      "[epoch 10/20, episode 100/100] => loss: 0.14228, acc: 0.97000\n",
      "[epoch 11/20, episode 50/100] => loss: 0.09097, acc: 0.98333\n",
      "[epoch 11/20, episode 100/100] => loss: 0.10532, acc: 0.98333\n",
      "[epoch 12/20, episode 50/100] => loss: 0.16229, acc: 0.95667\n",
      "[epoch 12/20, episode 100/100] => loss: 0.13725, acc: 0.97333\n",
      "[epoch 13/20, episode 50/100] => loss: 0.08362, acc: 0.98000\n",
      "[epoch 13/20, episode 100/100] => loss: 0.14789, acc: 0.97667\n",
      "[epoch 14/20, episode 50/100] => loss: 0.10677, acc: 0.98667\n",
      "[epoch 14/20, episode 100/100] => loss: 0.06838, acc: 0.98667\n",
      "[epoch 15/20, episode 50/100] => loss: 0.10952, acc: 0.98667\n",
      "[epoch 15/20, episode 100/100] => loss: 0.07136, acc: 0.98667\n",
      "[epoch 16/20, episode 50/100] => loss: 0.10298, acc: 0.97333\n",
      "[epoch 16/20, episode 100/100] => loss: 0.04288, acc: 0.99333\n",
      "[epoch 17/20, episode 50/100] => loss: 0.12377, acc: 0.97333\n",
      "[epoch 17/20, episode 100/100] => loss: 0.07907, acc: 0.98333\n",
      "[epoch 18/20, episode 50/100] => loss: 0.09200, acc: 0.99333\n",
      "[epoch 18/20, episode 100/100] => loss: 0.09606, acc: 0.98667\n",
      "[epoch 19/20, episode 50/100] => loss: 0.08441, acc: 0.98000\n",
      "[epoch 19/20, episode 100/100] => loss: 0.06932, acc: 0.97667\n",
      "[epoch 20/20, episode 50/100] => loss: 0.07246, acc: 0.98333\n",
      "[epoch 20/20, episode 100/100] => loss: 0.07372, acc: 0.99000\n"
     ]
    }
   ],
   "source": [
    "for ep in range(n_epochs):\n",
    "    for epi in range(n_episodes):\n",
    "        epi_classes = np.random.permutation(n_classes)[:n_way]\n",
    "        support = np.zeros([n_way, n_shot, im_height, im_width], dtype=np.float32)\n",
    "        query = np.zeros([n_way, n_query, im_height, im_width], dtype=np.float32)\n",
    "        for i, epi_cls in enumerate(epi_classes):\n",
    "            selected = np.random.permutation(n_examples)[:n_shot + n_query]\n",
    "            support[i] = train_dataset[epi_cls, selected[:n_shot]]\n",
    "            query[i] = train_dataset[epi_cls, selected[n_shot:]]\n",
    "        support = np.expand_dims(support, axis=-1)\n",
    "        query = np.expand_dims(query, axis=-1)\n",
    "        labels = np.tile(np.arange(n_way)[:, np.newaxis], (1, n_query)).astype(np.uint8)\n",
    "        _, ls, ac = sess.run([train_op, ce_loss, acc], feed_dict={x: support, q: query, y:labels})\n",
    "        if (epi+1) % 50 == 0:\n",
    "            print('[epoch {}/{}, episode {}/{}] => loss: {:.5f}, acc: {:.5f}'.format(ep+1, n_epochs, epi+1, n_episodes, ls, ac))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1692, 20, 28, 28)\n"
     ]
    }
   ],
   "source": [
    "# Load Test Dataset\n",
    "root_dir = './data/omniglot'\n",
    "test_split_path = os.path.join(root_dir, 'splits', 'test.txt')\n",
    "with open(test_split_path, 'r') as test_split:\n",
    "    test_classes = [line.rstrip() for line in test_split.readlines()]\n",
    "n_test_classes = len(test_classes)\n",
    "test_dataset = np.zeros([n_test_classes, n_examples, im_height, im_width], dtype=np.float32)\n",
    "for i, tc in enumerate(test_classes):\n",
    "    alphabet, character, rotation = tc.split('/')\n",
    "    rotation = float(rotation[3:])\n",
    "    im_dir = os.path.join(root_dir, 'data', alphabet, character)\n",
    "    im_files = sorted(glob.glob(os.path.join(im_dir, '*.png')))\n",
    "    for j, im_file in enumerate(im_files):\n",
    "        im = 1. - np.array(Image.open(im_file).rotate(rotation).resize((im_width, im_height)), np.float32, copy=False)\n",
    "        test_dataset[i, j] = im\n",
    "print(test_dataset.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "n_test_episodes = 1000\n",
    "n_test_way = 20\n",
    "n_test_shot = 5\n",
    "n_test_query = 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing...\n",
      "[test episode 50/1000] => loss: 0.03256, acc: 0.99667\n",
      "[test episode 100/1000] => loss: 0.12023, acc: 0.98000\n",
      "[test episode 150/1000] => loss: 0.07153, acc: 0.98000\n",
      "[test episode 200/1000] => loss: 0.05016, acc: 0.99000\n",
      "[test episode 250/1000] => loss: 0.10391, acc: 0.97333\n",
      "[test episode 300/1000] => loss: 0.16047, acc: 0.94667\n",
      "[test episode 350/1000] => loss: 0.09679, acc: 0.96333\n",
      "[test episode 400/1000] => loss: 0.04228, acc: 0.99000\n",
      "[test episode 450/1000] => loss: 0.04014, acc: 0.98667\n",
      "[test episode 500/1000] => loss: 0.11133, acc: 0.96333\n",
      "[test episode 550/1000] => loss: 0.06174, acc: 0.99000\n",
      "[test episode 600/1000] => loss: 0.04588, acc: 0.99000\n",
      "[test episode 650/1000] => loss: 0.07874, acc: 0.97667\n",
      "[test episode 700/1000] => loss: 0.09997, acc: 0.96333\n",
      "[test episode 750/1000] => loss: 0.06412, acc: 0.98333\n",
      "[test episode 800/1000] => loss: 0.03532, acc: 0.99000\n",
      "[test episode 850/1000] => loss: 0.03986, acc: 0.99333\n",
      "[test episode 900/1000] => loss: 0.04442, acc: 0.99000\n",
      "[test episode 950/1000] => loss: 0.06309, acc: 0.99000\n",
      "[test episode 1000/1000] => loss: 0.04308, acc: 0.99333\n",
      "Average Test Accuracy: 0.98281\n"
     ]
    }
   ],
   "source": [
    "print('Testing...')\n",
    "avg_acc = 0.\n",
    "for epi in range(n_test_episodes):\n",
    "    epi_classes = np.random.permutation(n_test_classes)[:n_test_way]\n",
    "    support = np.zeros([n_test_way, n_test_shot, im_height, im_width], dtype=np.float32)\n",
    "    query = np.zeros([n_test_way, n_test_query, im_height, im_width], dtype=np.float32)\n",
    "    for i, epi_cls in enumerate(epi_classes):\n",
    "        selected = np.random.permutation(n_examples)[:n_test_shot + n_test_query]\n",
    "        support[i] = test_dataset[epi_cls, selected[:n_test_shot]]\n",
    "        query[i] = test_dataset[epi_cls, selected[n_test_shot:]]\n",
    "    support = np.expand_dims(support, axis=-1)\n",
    "    query = np.expand_dims(query, axis=-1)\n",
    "    labels = np.tile(np.arange(n_test_way)[:, np.newaxis], (1, n_test_query)).astype(np.uint8)\n",
    "    ls, ac = sess.run([ce_loss, acc], feed_dict={x: support, q: query, y:labels})\n",
    "    avg_acc += ac\n",
    "    if (epi+1) % 50 == 0:\n",
    "        print('[test episode {}/{}] => loss: {:.5f}, acc: {:.5f}'.format(epi+1, n_test_episodes, ls, ac))\n",
    "avg_acc /= n_test_episodes\n",
    "print('Average Test Accuracy: {:.5f}'.format(avg_acc))"
   ]
  },
  {
   "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.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}