PointerNet_TSP.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import tsp_env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "hidden_size = 128\n",
    "embedding_size = 128\n",
    "max_time_steps = 10; input_size = 2;\n",
    "batch_size = 128\n",
    "initialization_stddev = 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "enc_inputs = tf.placeholder(tf.float32, [batch_size, max_time_steps, input_size])\n",
    "W_embed = tf.Variable(tf.random_normal([embedding_size, input_size],\n",
    "                                       stddev=initialization_stddev))\n",
    "embedded_inputs = tf.einsum('kl,itl->itk', W_embed, enc_inputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "with tf.variable_scope(\"encoder\"):\n",
    "    enc_rnn_cell = tf.nn.rnn_cell.LSTMCell(hidden_size)\n",
    "    enc_outputs, enc_final_state = tf.nn.dynamic_rnn(cell=enc_rnn_cell, \n",
    "                                                     inputs=embedded_inputs,\n",
    "                                                     dtype=tf.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def attention_mask(W_ref, W_q, v, enc_outputs, query, already_played_actions=None, \n",
    "                   already_played_penalty=1e6):\n",
    "    with tf.variable_scope(\"attention_mask\"):\n",
    "        u_i0s = tf.einsum('kl,itl->itk', W_ref, enc_outputs)\n",
    "        u_i1s = tf.expand_dims(tf.einsum('kl,il->ik', W_q, query), 1)\n",
    "        u_is = tf.einsum('k,itk->it', v, tf.tanh(u_i0s + u_i1s)) - already_played_penalty * already_played_actions\n",
    "        return u_is, tf.nn.softmax(u_is)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.variable_scope(\"decoder\"):\n",
    "    decoder_cell = tf.nn.rnn_cell.LSTMCell(hidden_size)\n",
    "    decoder_state = [enc_final_state]\n",
    "    first_decoder_input = tf.tile(tf.Variable(tf.random_normal([1, embedding_size]), \n",
    "                                      name='first_decoder_input'), [batch_size, 1])\n",
    "    \n",
    "    decoder_targets = tf.placeholder(dtype=tf.int32, shape=[batch_size, max_time_steps])\n",
    "    \n",
    "    with tf.variable_scope(\"attention_weights\", reuse=True):\n",
    "        W_ref = tf.Variable(tf.random_normal([embedding_size, embedding_size],\n",
    "                                             stddev=initialization_stddev),\n",
    "                           name='W_ref')\n",
    "        W_q = tf.Variable(tf.random_normal([embedding_size, embedding_size],\n",
    "                                           stddev=initialization_stddev),\n",
    "                         name='W_q')\n",
    "        v = tf.Variable(tf.random_normal([embedding_size], stddev=initialization_stddev),\n",
    "                        name='v')\n",
    "    \n",
    "    # Training chain\n",
    "    loss = 0\n",
    "    decoder_input = first_decoder_input\n",
    "    decoder_state = enc_final_state\n",
    "    already_played_actions = tf.zeros(shape=[batch_size, max_time_steps], dtype=tf.float32)\n",
    "    decoder_inputs = [decoder_input]\n",
    "    for t in range(max_time_steps):\n",
    "        dec_cell_output, decoder_state = decoder_cell(inputs=decoder_input, \n",
    "                                          state=decoder_state)\n",
    "        attn_logits, _ = attention_mask(W_ref, W_q, v, enc_outputs, dec_cell_output,\n",
    "                                        already_played_actions=already_played_actions,\n",
    "                                        already_played_penalty=1e6)\n",
    "        loss += tf.reduce_sum(tf.nn.softmax_cross_entropy_with_logits(labels=tf.one_hot(decoder_targets[:, t],\n",
    "                                                                          depth=max_time_steps),\n",
    "                                                        logits=attn_logits))\n",
    "        loss_summary_sy = tf.summary.scalar('training_loss', loss)\n",
    "\n",
    "        # Teacher forcing of the next input\n",
    "        decoder_input = tf.einsum('itk,it->ik', embedded_inputs,\n",
    "                                  tf.one_hot(decoder_targets[:, t], depth=max_time_steps))\n",
    "        decoder_inputs.append(decoder_input)\n",
    "        already_played_actions += tf.one_hot(decoder_targets[:, t], depth=max_time_steps)\n",
    "    \n",
    "    # Inference chain\n",
    "    decoder_input = first_decoder_input\n",
    "    decoder_state = enc_final_state\n",
    "    decoder_outputs = []\n",
    "    already_played_actions = tf.zeros(shape=[batch_size, max_time_steps], dtype=tf.float32)\n",
    "    for t in range(max_time_steps):\n",
    "        dec_cell_output, decoder_state = decoder_cell(inputs=decoder_input,\n",
    "                                                      state=decoder_state)\n",
    "        _, attn_mask = attention_mask(W_ref, W_q, v, enc_outputs, dec_cell_output,\n",
    "                                      already_played_actions=already_played_actions,\n",
    "                                      already_played_penalty=1e6)\n",
    "        decoder_outputs.append(tf.argmax(attn_mask, axis=1))\n",
    "        decoder_input = tf.einsum('itk,it->ik', embedded_inputs, attn_mask)\n",
    "        already_played_actions += tf.one_hot(decoder_outputs[-1], depth=max_time_steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = tf.train.AdamOptimizer(1e-2)\n",
    "train_op = optimizer.minimize(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate a batch of data\n",
    "def generate_batch(n_cities, batch_size):\n",
    "    inputs_list = []; labels_list = []\n",
    "    env = tsp_env.TSP_env(n_cities, use_alternative_state=True)\n",
    "    for i in range(batch_size):\n",
    "        env.reset()\n",
    "        s = env.reset()\n",
    "        coords = s.reshape([4, n_cities])[:2, ].T\n",
    "        inputs_list.append(coords)\n",
    "        labels_list.append(env.optimal_solution()[1])\n",
    "    return np.array(inputs_list), np.array(labels_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "sess = tf.InteractiveSession()\n",
    "tf.global_variables_initializer().run()\n",
    "log_files_name = 'PointerNet-TSP5'\n",
    "writer = tf.summary.FileWriter('/tmp/' + log_files_name, sess.graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1932.71\n",
      "1.84706581207\n",
      "1164.02\n",
      "1.43337082941\n",
      "843.223\n",
      "1.23827504926\n",
      "516.45\n",
      "1.08655902801\n",
      "539.293\n",
      "1.05318710247\n",
      "442.764\n",
      "1.07505060358\n",
      "441.321\n",
      "1.05859506978\n",
      "429.605\n",
      "1.09639691263\n",
      "414.12\n",
      "1.06063726765\n",
      "407.63\n",
      "1.06324440677\n",
      "406.542\n",
      "1.0674630074\n",
      "394.631\n",
      "1.06518062815\n",
      "433.739\n",
      "1.05594344493\n",
      "403.762\n",
      "1.05361630671\n",
      "368.75\n",
      "1.06584705366\n",
      "449.005\n",
      "1.05865283626\n",
      "370.119\n",
      "1.05501567571\n",
      "394.252\n",
      "1.0631991011\n",
      "363.634\n",
      "1.04804667828\n",
      "424.288\n",
      "1.05605431789\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f3d3cc9a908>]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYEAAAD8CAYAAACRkhiPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f3d475d9588>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_cities = 10\n",
    "\n",
    "loss_vals = []\n",
    "mean_approx_ratios = []\n",
    "for i in range(2000):\n",
    "    inputs_batch, labels_batch = generate_batch(n_cities, batch_size)\n",
    "    loss_summary, loss_val, _ = sess.run([loss_summary_sy, loss, train_op], feed_dict={enc_inputs: inputs_batch, \n",
    "                                                        decoder_targets: labels_batch})\n",
    "    loss_vals.append(loss_val)\n",
    "    \n",
    "    # Add training loss to tensorboard logs\n",
    "    if i % 100 == 0:\n",
    "        writer.add_summary(loss_summary, i)\n",
    "        writer.flush()\n",
    "        print(loss_vals[-1])\n",
    "        \n",
    "    # Test accuracy\n",
    "    if i % 100 == 0:\n",
    "        envs = []\n",
    "        inputs_list = []\n",
    "        optimal_rewards = []\n",
    "        optimal_tours = []\n",
    "        # Generate and initialize a batch of environments\n",
    "        for i in range(batch_size):\n",
    "            envs.append(tsp_env.TSP_env(n_cities, use_alternative_state=True))\n",
    "            envs[-1].reset()\n",
    "            inputs_list.append(envs[-1].nodes)\n",
    "            optimal_solution = envs[-1].optimal_solution()\n",
    "            optimal_rewards.append(optimal_solution[0])\n",
    "            optimal_tours.append(optimal_solution[1])\n",
    "        inputs_batch = np.array(inputs_list)\n",
    "        # Use the PointerNet on this test batch and get its predictions\n",
    "        predicted_outputs = np.array(sess.run(decoder_outputs, \n",
    "                                              feed_dict={enc_inputs: inputs_batch})).T\n",
    "        # Compute the rewards corresponding to the predicted tours\n",
    "        rewards = []\n",
    "        for i in range(batch_size):\n",
    "            for action in predicted_outputs[i]:\n",
    "                envs[i].step(action)\n",
    "            rewards.append(envs[i].accumulated_reward())\n",
    "        # Get the approximation ratio of the predictions\n",
    "        approximation_ratios = np.array(rewards) / np.array(optimal_rewards)\n",
    "        mean_approx_ratios.append(np.mean(approximation_ratios))\n",
    "        print(mean_approx_ratios[-1])\n",
    "\n",
    "# Plot the training losses\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.plot(loss_vals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}