commit 7f5d07930fe0820668da8dd8b5ef4a06fcca435e Author: Sam Greydanus Date: Sun Feb 19 16:11:57 2017 -0500 first commit diff --git a/README.md b/README.md new file mode 100644 index 0000000..51d048f --- /dev/null +++ b/README.md @@ -0,0 +1,24 @@ +DNC: Differentiable Neural Computer +======= + +Implements DeepMind's third nature paper, [Hybrid computing using a neural network with dynamic external memory](http://www.nature.com/nature/journal/v538/n7626/full/nature20101.html) by Graves et. al. + +![DNC schema](copy/static/dnc_schema.png?raw=true) + +Based on the paper's appendix, I sketched the [computational graph](https://docs.google.com/drawings/d/1Fc9eOH1wPw0PbBHWkEH39jik7h7HT9BWAE8ZhSr4hJc/edit?usp=sharing) + +_This is a work in progress_ +-------- +I have a general framework and a couple Jupyter notebooks for debugging. This is not a finished project. It's still very much in the dev stage. I need to: +1. write unit tests +2. improve documentation/comments +3. run it on more difficult tasks +4. add some nice visualizations + + +Dependencies +-------- +* All code is written in python 2.7. You will need: + * Numpy + * Matplotlib + * [TensorFlow r1.0](https://www.tensorflow.org/api_docs/python/) \ No newline at end of file diff --git a/copy/.ipynb_checkpoints/copy-checkpoint.ipynb b/copy/.ipynb_checkpoints/copy-checkpoint.ipynb new file mode 100644 index 0000000..54d3cc9 --- /dev/null +++ b/copy/.ipynb_checkpoints/copy-checkpoint.ipynb @@ -0,0 +1,217 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Differentiable Neural Computer\n", + "**Sam Greydanus $\\cdot$ February 2017 $\\cdot$ MIT License.**\n", + "\n", + "Represents the state of the art in differentiable memory. Inspired by this [Nature paper](http://www.nature.com/nature/journal/v538/n7626/full/nature20101.html). Some ideas taken from [this Gihub repo](https://github.com/Mostafa-Samir/DNC-tensorflow)\n", + "\n", + "\"DNC" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "import numpy as np\n", + "import sys\n", + "\n", + "from dnc.dnc import DNC\n", + "from nn_controller import NNController" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "length = 10\n", + "xydim = 6\n", + "tf.app.flags.DEFINE_integer(\"xlen\", xydim, \"Input dimension\")\n", + "tf.app.flags.DEFINE_integer(\"ylen\", xydim, \"output dimension\")\n", + "tf.app.flags.DEFINE_integer(\"max_sequence_length\", 2*length+1, \"Maximum sequence length\")\n", + "tf.app.flags.DEFINE_integer(\"length\", length, \"Maximum sequence length\")\n", + "tf.app.flags.DEFINE_integer(\"batch_size\", 2, \"Size of batch in minibatch gradient descent\")\n", + "\n", + "tf.app.flags.DEFINE_integer(\"R\", 1, \"Number of DNC read heads\")\n", + "tf.app.flags.DEFINE_integer(\"W\", 10, \"Word length for DNC memory\")\n", + "tf.app.flags.DEFINE_integer(\"N\", 15, \"Number of words the DNC memory can store\")\n", + "\n", + "tf.app.flags.DEFINE_integer(\"print_every\", 100, \"Print training info after this number of train steps\")\n", + "tf.app.flags.DEFINE_integer(\"iterations\", 100000, \"Number of training iterations\")\n", + "tf.app.flags.DEFINE_float(\"lr\", 1e-4, \"Learning rate (alpha) for the model\")\n", + "tf.app.flags.DEFINE_float(\"momentum\", .9, \"Momentum for RMSProp\")\n", + "tf.app.flags.DEFINE_integer(\"save_every\", 0, \"Save model after this number of train steps\")\n", + "tf.app.flags.DEFINE_string(\"save_dir\", \"models\", \"Directory in which to save checkpoints\")\n", + "tf.app.flags.DEFINE_string(\"log_dir\", \"logs\", \"Directory in which to save logs\")\n", + "FLAGS = tf.app.flags.FLAGS" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def generate_data(batch_size, length, dim):\n", + " X, y = np.zeros((batch_size, 2 * length + 1, dim)), np.zeros((batch_size, 2 * length + 1, dim))\n", + " sequence = np.random.binomial(1, 0.5, (batch_size, length, dim - 1))\n", + "\n", + " X[:, :length, :dim - 1] = sequence\n", + " X[:, length, -1] = 1 # end symbol\n", + " y[:, length + 1:, :dim - 1] = sequence\n", + " \n", + " return X, y\n", + "\n", + "def binary_cross_entropy(y_hat, y):\n", + " return tf.reduce_mean(-y*tf.log(y_hat) - (1-y)*tf.log(1-y_hat))\n", + "\n", + "def llprint(message):\n", + " sys.stdout.write(message)\n", + " sys.stdout.flush()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "building graph...\n", + "computing gradients...\n", + "init variables... \n", + "starting to train...\n", + "\n", + "Iteration 0/100000\n", + "\tloss: 0.6899\n", + "Iteration 100/100000\n", + "\tloss: 0.6738\n", + "Iteration 200/100000\n", + "\tloss: 0.4000\n", + "Iteration 300/100000\n", + "\tloss: 0.2642\n", + "Iteration 400/100000\n", + "\tloss: 0.2544\n", + "Iteration 500/100000\n", + "\tloss: 0.2533\n", + "Iteration 600/100000\n", + "\tloss: 0.2539\n", + "Iteration 700/100000\n", + "\tloss: 0.2570\n", + "Iteration 800/100000\n", + "\tloss: 0.2507\n", + "Iteration 900/100000\n", + "\tloss: 0.2462\n", + "Iteration 1000/100000\n", + "\tloss: 0.2464\n", + "Iteration 1100/100000\n", + "\tloss: 0.2491\n", + "Iteration 1200/100000\n", + "\tloss: 0.2412\n", + "Iteration 1300/100000\n", + "\tloss: 0.2340\n", + "Iteration 1400/100000\n", + "\tloss: 0.2343\n", + "Iteration 1500/100000\n", + "\tloss: 0.2303\n", + "Iteration 1600/100000\n", + "\tloss: 0.2196\n", + "Iteration 1700/100000\n", + "\tloss: 0.2305\n", + "Iteration 1800/100000\n", + "\tloss: 0.2237\n", + "Iteration 1854/100000" + ] + } + ], + "source": [ + "graph = tf.Graph()\n", + "with graph.as_default():\n", + " with tf.Session(graph=graph) as session:\n", + " llprint(\"building graph...\\n\")\n", + " optimizer = tf.train.RMSPropOptimizer(FLAGS.lr, momentum=FLAGS.momentum)\n", + " dnc = DNC(NNController, FLAGS)\n", + "\n", + " # define loss\n", + " y_hat, _ = dnc.get_outputs()\n", + " y_hat = tf.clip_by_value(tf.sigmoid(y_hat), 1e-6, 1. - 1e-6)\n", + " loss = binary_cross_entropy(y_hat, dnc.y)\n", + " \n", + " llprint(\"computing gradients...\\n\")\n", + " gradients = optimizer.compute_gradients(loss)\n", + " grad_op = optimizer.apply_gradients(gradients)\n", + " \n", + " llprint(\"init variables... \\n\")\n", + " session.run(tf.global_variables_initializer())\n", + " llprint(\"starting to train...\\n\\n\")\n", + "\n", + " loss_history = []\n", + "\n", + " for i in xrange(FLAGS.iterations + 1):\n", + " llprint(\"\\rIteration {}/{}\".format(i, FLAGS.iterations))\n", + "\n", + " random_length = np.random.randint(1, FLAGS.length + 1)\n", + " X, y = generate_data(FLAGS.batch_size, random_length, FLAGS.xlen)\n", + "\n", + " fetch = [loss, grad_op]\n", + " feed = {dnc.X: X, dnc.y: y, dnc.tsteps: 2 * random_length + 1}\n", + " \n", + " step_loss, _ = session.run(fetch, feed_dict=feed)\n", + "\n", + " loss_history.append(step_loss)\n", + "\n", + " if i % 100 == 0:\n", + " llprint(\"\\n\\tloss: {:03.4f}\\n\".format(np.mean(loss_history)))\n", + " loss_history = []" + ] + }, + { + "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.10" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/copy/.ipynb_checkpoints/debug-checkpoint.ipynb b/copy/.ipynb_checkpoints/debug-checkpoint.ipynb new file mode 100644 index 0000000..59ce53d --- /dev/null +++ b/copy/.ipynb_checkpoints/debug-checkpoint.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/copy/.ipynb_checkpoints/visualization-checkpoint.ipynb b/copy/.ipynb_checkpoints/visualization-checkpoint.ipynb new file mode 100755 index 0000000..1a13098 --- /dev/null +++ b/copy/.ipynb_checkpoints/visualization-checkpoint.ipynb @@ -0,0 +1,610 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import itertools\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.patches as mpatches\n", + "import matplotlib.gridspec as gridspec\n", + "from mpl_toolkits.axes_grid1 import make_axes_locatable\n", + "\n", + "from dnc.dnc import DNC\n", + "from feedforward_controller import FeedforwardController\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = (10, 15)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def generate_data(batch_size, length, size):\n", + "\n", + " input_data = np.zeros((batch_size, 2 * length + 1, size), dtype=np.float32)\n", + " target_output = np.zeros((batch_size, 2 * length + 1, size), dtype=np.float32)\n", + "\n", + " sequence = np.random.binomial(1, 0.5, (batch_size, length, size - 1))\n", + "\n", + " input_data[:, :length, :size - 1] = sequence\n", + " input_data[:, length, -1] = 1 # the end symbol\n", + " target_output[:, length + 1:, :size - 1] = sequence\n", + " \n", + " return input_data, target_output" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def binary_cross_entropy(predictions, targets):\n", + "\n", + " return tf.reduce_mean(\n", + " -1 * targets * tf.log(predictions) - (1 - targets) * tf.log(1 - predictions)\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def visualize_op(input_series, dnc_output, memory_view):\n", + " \n", + " gs = gridspec.GridSpec(48, 1, hspace=0)\n", + "\n", + " ww_strip = np.squeeze(memory_view['write_weightings'])\n", + " rw_strip = np.squeeze(memory_view['read_weightings'])\n", + " colored_write = np.zeros((ww_strip.shape[0], ww_strip.shape[1], 3))\n", + " colored_read = np.zeros((rw_strip.shape[0], rw_strip.shape[1], 3))\n", + " for i in range(ww_strip.shape[0]):\n", + " for j in range(ww_strip.shape[1]):\n", + " colored_read[i, j] = [rw_strip[i,j], 0., 0.]\n", + " colored_write[i, j] = [0., ww_strip[i,j], 0.]\n", + " \n", + " free_strip = np.vstack([np.squeeze(memory_view['free_gates'])] * 5)\n", + " allocation_strip = np.vstack([np.squeeze(memory_view['allocation_gates'])] * 5)\n", + "\n", + "\n", + " iax = plt.subplot(gs[0:5, 0])\n", + " oax = plt.subplot(gs[7:12, 0])\n", + " memax = plt.subplot(gs[14:24, 0])\n", + " fax = plt.subplot(gs[26:31, 0])\n", + " aax = plt.subplot(gs[31:36, 0])\n", + " uax = plt.subplot(gs[38:, 0])\n", + "\n", + " iax.grid(True, color='gray')\n", + " oax.grid(True, color='gray')\n", + " memax.grid(True, color='gray', axis='x')\n", + " fax.grid(True, color='gray')\n", + " aax.grid(True, color='gray')\n", + " uax.grid(True, color='gray', axis='x')\n", + " \n", + " iax.imshow(np.squeeze(input_series.T), cmap=plt.cm.gray, interpolation='nearest')\n", + " iax.set_ylabel(\"Inputs\")\n", + " iax.set_yticks([])\n", + " iax.set_xticks([-0.5, 5.5, 10.5, 16.5, 21.5, 27.5, 32.5, 38.5, 43.5])\n", + " iax.set_xticklabels([0, 6, 11, 17, 22, 28, 33, 39, 44])\n", + "\n", + " oax.imshow(np.squeeze(dnc_output.T), cmap=plt.cm.gray, interpolation='nearest')\n", + " oax.set_ylabel(\"Outputs\")\n", + " oax.set_yticks([])\n", + " oax.set_xticks([-0.5, 5.5, 10.5, 16.5, 21.5, 27.5, 32.5, 38.5, 43.5])\n", + " oax.set_xticklabels([0, 6, 11, 17, 22, 28, 33, 39, 44])\n", + "\n", + " memax.imshow(np.transpose(colored_write + colored_read, [1, 0, 2]), interpolation='nearest')\n", + " memax.set_ylabel(\"Memory Location\")\n", + " memax.set_xticks([-0.5, 5.5, 10.5, 16.5, 21.5, 27.5, 32.5, 38.5, 43.5])\n", + " memax.set_xticklabels([0, 6, 11, 17, 22, 28, 33, 39, 44])\n", + " write_legend = mpatches.Rectangle((1,1), 1, 1, color='green', label='Write Head')\n", + " read_legend = mpatches.Rectangle((1,1), 1, 1, color='red', label='Read Head')\n", + " memax.legend(bbox_to_anchor=(0.21, -0.1), handles=[write_legend, read_legend])\n", + "\n", + " fax.imshow(free_strip, cmap=plt.cm.gray, interpolation='nearest')\n", + " fax.set_ylabel(\"Free Gate\")\n", + " fax.set_yticks([])\n", + " fax.set_xticks([-0.5, 5.5, 10.5, 16.5, 21.5, 27.5, 32.5, 38.5, 43.5])\n", + " fax.set_xticklabels([0, 6, 11, 17, 22, 28, 33, 39, 44])\n", + "\n", + " aax.imshow(allocation_strip, cmap=plt.cm.gray, interpolation='nearest')\n", + " aax.set_ylabel(\"Alloc. Gate\")\n", + " aax.set_yticks([])\n", + " aax.set_xticks([-0.5, 5.5, 10.5, 16.5, 21.5, 27.5, 32.5, 38.5, 43.5])\n", + " aax.set_xticklabels([0, 6, 11, 17, 22, 28, 33, 39, 44])\n", + "\n", + " uax.imshow(np.squeeze(memory_view['usage_vectors'].T), cmap=plt.cm.gray, interpolation='nearest')\n", + " uax.set_ylabel(\"Memory Locations Usage\")\n", + " uax.set_xticks([-0.5, 5.5, 10.5, 16.5, 21.5, 27.5, 32.5, 38.5, 43.5])\n", + " uax.set_xticklabels([0, 6, 11, 17, 22, 28, 33, 39, 44])\n", + " uax.set_xlabel(\"Time\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dynamic Memory Mechanisms\n", + "\n", + "## Trained on Length-2 Series" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "ckpts_dir = os.path.join(os.path.dirname(\"__file__\"), 'checkpoints')\n", + "\n", + "tf.reset_default_graph()\n", + "session = tf.InteractiveSession()\n", + "\n", + "ncomputer = DNC(\n", + " FeedforwardController,\n", + " input_size=6,\n", + " output_size=6,\n", + " max_sequence_length=44,\n", + " memory_words_num=10,\n", + " memory_word_size=10,\n", + " memory_read_heads=1,\n", + " batch_size=1\n", + ")\n", + "\n", + "ncomputer.restore(session, ckpts_dir, 'model-series-2')" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "outputs, memory_views = ncomputer.get_outputs()\n", + "squashed_output = tf.sigmoid(outputs)\n", + "clipped_output = tf.clip_by_value(squashed_output, 1e-6, 1. - 1e-6)\n", + "\n", + "loss = binary_cross_entropy(clipped_output, ncomputer.target_output)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Accuracy on Length-4 Series" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Avg. Accuracy: 0.0040\n", + "Avg. Loss: 0.5917\n" + ] + } + ], + "source": [ + "losses = []\n", + "matches = []\n", + "inputs = []\n", + "outputs = []\n", + "views = []\n", + "\n", + "for i in range(1000):\n", + " \n", + " in_sequences = []\n", + " out_sequences = []\n", + " \n", + " for k in range(4):\n", + " input_data, target_output = generate_data(1, 5, 6)\n", + " in_sequences.append(input_data)\n", + " out_sequences.append(target_output)\n", + " \n", + " one_big_input = np.concatenate(in_sequences, axis=1)\n", + " one_big_output = np.concatenate(out_sequences, axis=1)\n", + "\n", + " l, o, v = session.run([\n", + " loss,\n", + " squashed_output,\n", + " memory_views\n", + " ], feed_dict={\n", + " ncomputer.input_data: one_big_input,\n", + " ncomputer.target_output: one_big_output,\n", + " ncomputer.sequence_length: 44\n", + " })\n", + " \n", + " losses.append(l)\n", + " inputs.append(one_big_input)\n", + " outputs.append(o)\n", + " views.append(v)\n", + " matches.append(np.allclose(one_big_output, np.around(o)))\n", + "\n", + "print \"Avg. Accuracy: %.4f\" % (np.mean(matches))\n", + "print \"Avg. Loss: %.4f\" % (np.mean(losses))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualization on Length-4 Series\n", + "\n", + "#### Best (aka, least loss) Run" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.00142152\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlwAAANTCAYAAAB7PcPRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nPRTmA0XFjQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "best_indx = np.argmin(losses)\n", + "print losses[best_indx]\n", + "best_input, best_output, best_memview = inputs[best_indx], outputs[best_indx], views[best_indx]\n", + "\n", + "visualize_op(best_input, best_output, best_memview)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Trained on Length-4 Series" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "ckpts_dir = os.path.join(os.path.dirname(\"__file__\"), 'checkpoints')\n", + "\n", + "tf.reset_default_graph()\n", + "session = tf.InteractiveSession()\n", + "\n", + "ncomputer = DNC(\n", + " FeedforwardController,\n", + " input_size=6,\n", + " output_size=6,\n", + " max_sequence_length=44,\n", + " memory_words_num=10,\n", + " memory_word_size=10,\n", + " memory_read_heads=1,\n", + " batch_size=1\n", + ")\n", + "\n", + "ncomputer.restore(session, ckpts_dir, 'model-series-4')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "outputs, memory_views = ncomputer.get_outputs()\n", + "squashed_output = tf.sigmoid(outputs)\n", + "clipped_output = tf.clip_by_value(squashed_output, 1e-6, 1. - 1e-6)\n", + "\n", + "loss = binary_cross_entropy(clipped_output, ncomputer.target_output)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Accuracy on Length-4 Series" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Avg. Accuracy: 1.0000\n", + "Avg. Loss: 0.0000\n" + ] + } + ], + "source": [ + "losses = []\n", + "matches = []\n", + "inputs = []\n", + "outputs = []\n", + "views = []\n", + "\n", + "for i in range(1000):\n", + " \n", + " in_sequences = []\n", + " out_sequences = []\n", + " \n", + " for k in range(4):\n", + " input_data, target_output = generate_data(1, 5, 6)\n", + " in_sequences.append(input_data)\n", + " out_sequences.append(target_output)\n", + " \n", + " one_big_input = np.concatenate(in_sequences, axis=1)\n", + " one_big_output = np.concatenate(out_sequences, axis=1)\n", + "\n", + " l, o, v = session.run([\n", + " loss,\n", + " squashed_output,\n", + " memory_views\n", + " ], feed_dict={\n", + " ncomputer.input_data: one_big_input,\n", + " ncomputer.target_output: one_big_output,\n", + " ncomputer.sequence_length: 44\n", + " })\n", + " \n", + " losses.append(l)\n", + " inputs.append(one_big_input)\n", + " outputs.append(o)\n", + " views.append(v)\n", + " matches.append(np.allclose(one_big_output, np.around(o)))\n", + "\n", + "print \"Avg. Accuracy: %.4f\" % (np.mean(matches))\n", + "print \"Avg. Loss: %.4f\" % (np.mean(losses))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualization on Length-4 Series\n", + "\n", + "#### Best Run" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlwAAANTCAYAAAB7PcPRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n5oTLzMzMrGVOuMzMzMxa9v8BO4zJ+nvf/FAAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "in_sequences = []\n", + "out_sequences = []\n", + " \n", + "for k in range(4):\n", + " input_data, target_output = generate_data(1, 5, 6)\n", + " in_sequences.append(input_data)\n", + " out_sequences.append(target_output)\n", + " \n", + "one_big_input = np.concatenate(in_sequences, axis=1)\n", + "one_big_output = np.concatenate(out_sequences, axis=1)\n", + "\n", + "l, o, v = session.run([\n", + " loss,\n", + " squashed_output,\n", + " memory_views\n", + "], feed_dict={\n", + " ncomputer.input_data: one_big_input,\n", + " ncomputer.target_output: one_big_output,\n", + " ncomputer.sequence_length: 44\n", + "})\n", + "\n", + "visualize_op(one_big_input, o, v)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generalization and Memory Scalability" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def llprint(message):\n", + " sys.stdout.write(message)\n", + " sys.stdout.flush()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Finished 64/64" + ] + } + ], + "source": [ + "ckpts_dir = os.path.join(os.path.dirname(\"__file__\"), 'checkpoints')\n", + "\n", + "word_counts = [10, 15, 20, 25, 30, 35, 40, 45]\n", + "sequnce_lengthes = [5, 10, 15, 20, 25, 30, 35, 40]\n", + "\n", + "pairs = list(itertools.product(word_counts, sequnce_lengthes))\n", + "fraction_correct = np.zeros((8, 8))\n", + "count_done = 0\n", + "\n", + "llprint(\"Finished 0/64\")\n", + "\n", + "for i, seq_size in enumerate(sequnce_lengthes):\n", + " for j, mem_size in enumerate(word_counts):\n", + " \n", + " graph = tf.Graph()\n", + " with graph.as_default():\n", + " with tf.Session(graph=graph) as session:\n", + " \n", + " ncomputer = DNC(FeedforwardController, 6, 6, 2 * seq_size + 1, mem_size, 10, 1, 1)\n", + " ncomputer.restore(session, ckpts_dir, 'model-single-10')\n", + " \n", + " output,_ = ncomputer.get_outputs()\n", + " squashed_output = tf.sigmoid(output)\n", + " \n", + " matches = []\n", + " for k in range(100):\n", + " input_data, target_output = generate_data(1, seq_size, 6)\n", + " dnc_output = session.run(squashed_output, feed_dict={\n", + " ncomputer.input_data: input_data,\n", + " ncomputer.sequence_length: 2 * seq_size + 1\n", + " })\n", + " \n", + " matches.append(np.array_equal(np.around(dnc_output), target_output))\n", + " \n", + " fraction_correct[i, j] = np.mean(matches)\n", + " \n", + " count_done += 1\n", + " llprint(\"\\rFinished %d/64\" % count_done)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAn8AAAI8CAYAAACAgs05AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nLZkvfgcAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "imax = ax.imshow(fraction_correct, cmap=plt.cm.coolwarm)\n", + "\n", + "ax.set_ylabel('Sequence Lengths')\n", + "ax.set_yticks([0, 1, 2, 3, 4, 5, 6, 7])\n", + "ax.set_yticklabels(['5', '10', '15', '20', '25', '30', '35', '40'])\n", + "\n", + "ax.set_xlabel('Memory Locations')\n", + "ax.set_xticks([0, 1, 2, 3, 4, 5, 6, 7])\n", + "ax.set_xticklabels(['10', '15', '20', '25', '30', '35', '40', '45'])\n", + "\n", + "ax.grid(True)\n", + "\n", + "divider = make_axes_locatable(ax)\n", + "cbar_ax = divider.append_axes(\"right\", size=\"5%\", pad=0.1)\n", + "\n", + "fig.colorbar(imax, cax=cbar_ax, ticks=[0, 0.2, 0.4, 0.6, 0.8, 1], label='Fraction Correct')" + ] + } + ], + "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.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/copy/copy.ipynb b/copy/copy.ipynb new file mode 100644 index 0000000..4aee19d --- /dev/null +++ b/copy/copy.ipynb @@ -0,0 +1,254 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Differentiable Neural Computer\n", + "\n", + "\"DNC\n", + "\n", + "**Sam Greydanus $\\cdot$ February 2017 $\\cdot$ MIT License.**\n", + "\n", + "Represents the state of the art in differentiable memory. Inspired by this [Nature paper](http://www.nature.com/nature/journal/v538/n7626/full/nature20101.html). Some ideas taken from [this Gihub repo](https://github.com/Mostafa-Samir/DNC-tensorflow)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "import numpy as np\n", + "import sys\n", + "\n", + "from dnc.dnc import DNC\n", + "from nn_controller import NNController" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "length = 10\n", + "xydim = 6\n", + "tf.app.flags.DEFINE_integer(\"xlen\", xydim, \"Input dimension\")\n", + "tf.app.flags.DEFINE_integer(\"ylen\", xydim, \"output dimension\")\n", + "tf.app.flags.DEFINE_integer(\"max_sequence_length\", 2*length+1, \"Maximum sequence length\")\n", + "tf.app.flags.DEFINE_integer(\"length\", length, \"Maximum sequence length\")\n", + "tf.app.flags.DEFINE_integer(\"batch_size\", 2, \"Size of batch in minibatch gradient descent\")\n", + "\n", + "tf.app.flags.DEFINE_integer(\"R\", 1, \"Number of DNC read heads\")\n", + "tf.app.flags.DEFINE_integer(\"W\", 10, \"Word length for DNC memory\")\n", + "tf.app.flags.DEFINE_integer(\"N\", 15, \"Number of words the DNC memory can store\")\n", + "\n", + "tf.app.flags.DEFINE_integer(\"print_every\", 100, \"Print training info after this number of train steps\")\n", + "tf.app.flags.DEFINE_integer(\"iterations\", 100000, \"Number of training iterations\")\n", + "tf.app.flags.DEFINE_float(\"lr\", 1e-4, \"Learning rate (alpha) for the model\")\n", + "tf.app.flags.DEFINE_float(\"momentum\", .9, \"Momentum for RMSProp\")\n", + "tf.app.flags.DEFINE_integer(\"save_every\", 0, \"Save model after this number of train steps\")\n", + "tf.app.flags.DEFINE_string(\"save_dir\", \"models\", \"Directory in which to save checkpoints\")\n", + "tf.app.flags.DEFINE_string(\"log_dir\", \"logs\", \"Directory in which to save logs\")\n", + "FLAGS = tf.app.flags.FLAGS" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def generate_data(batch_size, length, dim):\n", + " X, y = np.zeros((batch_size, 2 * length + 1, dim)), np.zeros((batch_size, 2 * length + 1, dim))\n", + " sequence = np.random.binomial(1, 0.5, (batch_size, length, dim - 1))\n", + "\n", + " X[:, :length, :dim - 1] = sequence\n", + " X[:, length, -1] = 1 # end symbol\n", + " y[:, length + 1:, :dim - 1] = sequence\n", + " \n", + " return X, y\n", + "\n", + "def binary_cross_entropy(y_hat, y):\n", + " return tf.reduce_mean(-y*tf.log(y_hat) - (1-y)*tf.log(1-y_hat))\n", + "\n", + "def llprint(message):\n", + " sys.stdout.write(message)\n", + " sys.stdout.flush()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "building graph...\n", + "computing gradients...\n", + "init variables... \n", + "starting to train...\n", + "\n", + "Iteration 0/100000\n", + "\tloss: 0.6899\n", + "Iteration 100/100000\n", + "\tloss: 0.6738\n", + "Iteration 200/100000\n", + "\tloss: 0.4000\n", + "Iteration 300/100000\n", + "\tloss: 0.2642\n", + "Iteration 400/100000\n", + "\tloss: 0.2544\n", + "Iteration 500/100000\n", + "\tloss: 0.2533\n", + "Iteration 600/100000\n", + "\tloss: 0.2539\n", + "Iteration 700/100000\n", + "\tloss: 0.2570\n", + "Iteration 800/100000\n", + "\tloss: 0.2507\n", + "Iteration 900/100000\n", + "\tloss: 0.2462\n", + "Iteration 1000/100000\n", + "\tloss: 0.2464\n", + "Iteration 1100/100000\n", + "\tloss: 0.2491\n", + "Iteration 1200/100000\n", + "\tloss: 0.2412\n", + "Iteration 1300/100000\n", + "\tloss: 0.2340\n", + "Iteration 1400/100000\n", + "\tloss: 0.2343\n", + "Iteration 1500/100000\n", + "\tloss: 0.2303\n", + "Iteration 1600/100000\n", + "\tloss: 0.2196\n", + "Iteration 1700/100000\n", + "\tloss: 0.2305\n", + "Iteration 1800/100000\n", + "\tloss: 0.2237\n", + "Iteration 1900/100000\n", + "\tloss: 0.2082\n", + "Iteration 2000/100000\n", + "\tloss: 0.2180\n", + "Iteration 2100/100000\n", + "\tloss: 0.2105\n", + "Iteration 2200/100000\n", + "\tloss: 0.1964\n", + "Iteration 2300/100000\n", + "\tloss: 0.1891\n", + "Iteration 2400/100000\n", + "\tloss: 0.1780\n", + "Iteration 2500/100000\n", + "\tloss: 0.0984\n", + "Iteration 2600/100000\n", + "\tloss: 0.0283\n", + "Iteration 2700/100000\n", + "\tloss: 0.0027\n", + "Iteration 2800/100000\n", + "\tloss: 0.0000\n", + "Iteration 2822/100000" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0mfeed\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0mdnc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdnc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdnc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtsteps\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mrandom_length\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 32\u001b[0;31m \u001b[0mstep_loss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msession\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfetch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfeed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 33\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[0mloss_history\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep_loss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python2.7/site-packages/tensorflow/python/client/session.pyc\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m 765\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 766\u001b[0m result = self._run(None, fetches, feed_dict, options_ptr,\n\u001b[0;32m--> 767\u001b[0;31m run_metadata_ptr)\n\u001b[0m\u001b[1;32m 768\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mrun_metadata\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 769\u001b[0m \u001b[0mproto_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf_session\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTF_GetBuffer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_metadata_ptr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python2.7/site-packages/tensorflow/python/client/session.pyc\u001b[0m in \u001b[0;36m_run\u001b[0;34m(self, handle, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m 963\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfinal_fetches\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mfinal_targets\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 964\u001b[0m results = self._do_run(handle, final_targets, final_fetches,\n\u001b[0;32m--> 965\u001b[0;31m feed_dict_string, options, run_metadata)\n\u001b[0m\u001b[1;32m 966\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 967\u001b[0m \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python2.7/site-packages/tensorflow/python/client/session.pyc\u001b[0m in \u001b[0;36m_do_run\u001b[0;34m(self, handle, target_list, fetch_list, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m 1013\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mhandle\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1014\u001b[0m return self._do_call(_run_fn, self._session, feed_dict, fetch_list,\n\u001b[0;32m-> 1015\u001b[0;31m target_list, options, run_metadata)\n\u001b[0m\u001b[1;32m 1016\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1017\u001b[0m return self._do_call(_prun_fn, self._session, handle, feed_dict,\n", + "\u001b[0;32m/usr/local/lib/python2.7/site-packages/tensorflow/python/client/session.pyc\u001b[0m in \u001b[0;36m_do_call\u001b[0;34m(self, fn, *args)\u001b[0m\n\u001b[1;32m 1020\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_do_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1021\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1022\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1023\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0merrors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mOpError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1024\u001b[0m \u001b[0mmessage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcompat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_text\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmessage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python2.7/site-packages/tensorflow/python/client/session.pyc\u001b[0m in \u001b[0;36m_run_fn\u001b[0;34m(session, feed_dict, fetch_list, target_list, options, run_metadata)\u001b[0m\n\u001b[1;32m 1002\u001b[0m return tf_session.TF_Run(session, options,\n\u001b[1;32m 1003\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfetch_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget_list\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1004\u001b[0;31m status, run_metadata)\n\u001b[0m\u001b[1;32m 1005\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1006\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_prun_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msession\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhandle\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfetch_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "graph = tf.Graph()\n", + "with graph.as_default():\n", + " with tf.Session(graph=graph) as session:\n", + " llprint(\"building graph...\\n\")\n", + " optimizer = tf.train.RMSPropOptimizer(FLAGS.lr, momentum=FLAGS.momentum)\n", + " dnc = DNC(NNController, FLAGS)\n", + "\n", + " # define loss\n", + " y_hat, _ = dnc.get_outputs()\n", + " y_hat = tf.clip_by_value(tf.sigmoid(y_hat), 1e-6, 1. - 1e-6)\n", + " loss = binary_cross_entropy(y_hat, dnc.y)\n", + " \n", + " llprint(\"computing gradients...\\n\")\n", + " gradients = optimizer.compute_gradients(loss)\n", + " grad_op = optimizer.apply_gradients(gradients)\n", + " \n", + " llprint(\"init variables... \\n\")\n", + " session.run(tf.global_variables_initializer())\n", + " llprint(\"starting to train...\\n\\n\")\n", + "\n", + " loss_history = []\n", + "\n", + " for i in xrange(FLAGS.iterations + 1):\n", + " llprint(\"\\rIteration {}/{}\".format(i, FLAGS.iterations))\n", + "\n", + " random_length = np.random.randint(1, FLAGS.length + 1)\n", + " X, y = generate_data(FLAGS.batch_size, random_length, FLAGS.xlen)\n", + "\n", + " fetch = [loss, grad_op]\n", + " feed = {dnc.X: X, dnc.y: y, dnc.tsteps: 2 * random_length + 1}\n", + " \n", + " step_loss, _ = session.run(fetch, feed_dict=feed)\n", + "\n", + " loss_history.append(step_loss)\n", + "\n", + " if i % 100 == 0:\n", + " llprint(\"\\n\\tloss: {:03.4f}\\n\".format(np.mean(loss_history)))\n", + " loss_history = []" + ] + }, + { + "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.10" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/copy/dnc/__init__.py b/copy/dnc/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/copy/dnc/__init__.pyc b/copy/dnc/__init__.pyc new file mode 100644 index 0000000..0b8af21 Binary files /dev/null and b/copy/dnc/__init__.pyc differ diff --git a/copy/dnc/controller.py b/copy/dnc/controller.py new file mode 100755 index 0000000..fe245a8 --- /dev/null +++ b/copy/dnc/controller.py @@ -0,0 +1,161 @@ +# Differentiable Neural Computer +# inspired by (http://www.nature.com/nature/journal/v538/n7626/full/nature20101.html) +# some ideas taken from https://github.com/Mostafa-Samir/DNC-tensorflow +# Sam Greydanus. February 2017. MIT License. + +import tensorflow as tf +import numpy as np + +class Controller(): + def __init__(self, FLAGS): + ''' + An interface that defines how the neural network "controller" interacts with the DNC + Parameters: + ---------- + FLAGS: a set of TensorFlow FlagValues which must include + FLAGS.xlen: the length of the input vector of the controller + FLAGS.ylen: the length of the output vector of the controller + FLAGS.batch_size: the number of batches + FLAGS.R: the number of DNC read heads + FLAGS.W: the DNC "word length" (length of each DNC memory vector) + + Returns: Tensor (batch_size, nn_output_size) + ''' + + self.xlen = FLAGS.xlen + self.ylen = FLAGS.ylen + self.batch_size = FLAGS.batch_size + self.R = R = FLAGS.R + self.W = W = FLAGS.W + + self.chi_dim = self.xlen + self.W * self.R + self.zeta_dim = W*R + 3*W + 5*R + 3 + self.r_dim = W*R + + # define network vars + self.params = {} + with tf.name_scope("controller"): + self.init_controller_params() + self.controller_dim = self.get_controller_dim() + + init = tf.truncated_normal_initializer(stddev=0.075, dtype=tf.float32) + self.params['W_z'] = tf.get_variable("W_z", [self.controller_dim, self.zeta_dim], initializer=init) + self.params['W_v'] = tf.get_variable("W_v", [self.controller_dim, self.ylen], initializer=init) + self.params['W_r'] = tf.get_variable("W_r", [self.r_dim, self.ylen], initializer=init) + + def init_controller_params(self): + ''' + Initializes all the parameters of the neural network controller + ''' + raise NotImplementedError("init_controller_params does not exist") + + def nn_step(self, chi, state): + ''' + Performs the feedforward step of the controller in order to get the DNC interface vector, zeta + Parameters: + ---------- + chi: Tensor (batch_size, chi_dim) + the input concatenated with the previous output of the DNC + state: LSTMStateTensor or another type of state tensor + Returns: Tuple + zeta_hat: Tensor (batch_size, controller_dim) + next_state: LSTMStateTensor or another type of state tensor + ''' + raise NotImplementedError("nn_step does not exist") + + def zero_state(self): + ''' + Returns the initial state of the controller. If the controller is not recurrent, it still needs to return a dummy value + Returns: LSTMStateTensor or another type of state tensor + nn_state: LSTMStateTensor or another type of state tensor + ''' + raise NotImplementedError("get_state does not exist") + + def get_controller_dim(self): + ''' + Feeds zeros through the controller and obtains an output in order to find the controller's output dimension + Returns: int + controller_dim: the output dimension of the controller + ''' + test_chi = tf.zeros([self.batch_size, self.chi_dim]) + nn_output, nn_state = self.nn_step(test_chi, state=None) + return nn_output.get_shape().as_list()[-1] + + def prepare_interface(self, zeta_hat): + ''' + Packages the interface vector, zeta, as a dictionary of variables as described in the DNC Nature paper + Parameters: + ---------- + zeta_hat: Tensor (batch_size, zeta_dim) + the interface vector before processing, zeta_hat + Returns: dict + zeta: variable names (string) mapping to tensors (Tensor) + ''' + zeta = {} + R, W = self.R, self.W + splits = np.cumsum([0,W*R,R,W,1,W,W,R,1,1,3*R]) + vs = [zeta_hat[:, splits[i]:splits[i+1]] for i in range(len(splits)-1)] + + kappa_r = tf.reshape(vs[0], (-1, W, R)) + beta_r = tf.reshape(vs[1], (-1, R)) + kappa_w = tf.reshape(vs[2], (-1, W, 1)) + beta_w = tf.reshape(vs[3], (-1, 1)) + e = tf.reshape(vs[4], (-1, W)) + v = tf.reshape(vs[5], (-1, W)) + f = tf.reshape(vs[6], (-1, R)) + g_a = vs[7] + g_w = vs[8] + pi = tf.reshape(vs[9], (-1, 3, R)) + + zeta['kappa_r'] = kappa_r + zeta['beta_r'] = 1 + tf.nn.softplus(beta_r) + zeta['kappa_w'] = kappa_w + zeta['beta_w'] = 1 + tf.nn.softplus(beta_w) + zeta['e'] = tf.nn.sigmoid(e) + zeta['v'] = v + zeta['f'] = tf.nn.sigmoid(f) + zeta['g_a'] = tf.nn.sigmoid(g_a) + zeta['g_w'] = tf.nn.sigmoid(g_w) + zeta['pi'] = tf.nn.softmax(pi, 1) + + return zeta + + def step(self, X, r_prev, state): + ''' + The sum of operations executed by the Controller at a given time step before interfacing with the DNC + Parameters: + ---------- + X: Tensor (batch_size, chi_dim) + the input for this time step + r_prev: previous output of the DNC + state: LSTMStateTensor or another type of state tensor + Returns: Tuple + v: Tensor (batch_size, ylen) + The controller's output (eventually added elementwise to the DNC output) + zeta: The processed interface vector which the network will use to interact with the DNC + nn_state: LSTMStateTensor or another type of state tensor + ''' + r_prev = tf.reshape(r_prev, (-1, self.r_dim)) # flatten + chi = tf.concat([X, r_prev], 1) + nn_output, nn_state = self.nn_step(chi, state) + + v = tf.matmul(nn_output, self.params['W_v']) + zeta_hat = tf.matmul(nn_output, self.params['W_z']) + zeta = self.prepare_interface(zeta_hat) + return v, zeta, nn_state + + def next_y_hat(self, v, r): + ''' + The sum of operations executed by the Controller at a given time step after interacting with the DNC + Parameters: + ---------- + v: Tensor (batch_size, ylen) + The controller's output (added elementwise to the DNC output) + r_prev: the current output of the DNC + Returns: Tensor (batch_size, ylen) + y_hat: Tensor (batch_size, controller_dim) + The DNC's ouput + ''' + r = tf.reshape(r, (-1, self.W * self.R)) # flatten + y_hat = v + tf.matmul(r, self.params['W_r']) + return y_hat diff --git a/copy/dnc/controller.pyc b/copy/dnc/controller.pyc new file mode 100644 index 0000000..ccaafc7 Binary files /dev/null and b/copy/dnc/controller.pyc differ diff --git a/copy/dnc/dnc.py b/copy/dnc/dnc.py new file mode 100755 index 0000000..67f5195 --- /dev/null +++ b/copy/dnc/dnc.py @@ -0,0 +1,150 @@ +# Differentiable Neural Computer +# inspired by (http://www.nature.com/nature/journal/v538/n7626/full/nature20101.html) +# some ideas taken from https://github.com/Mostafa-Samir/DNC-tensorflow +# Sam Greydanus. February 2017. MIT License. + +import tensorflow as tf +import numpy as np +from memory import Memory + +import os + +class DNC: + def __init__(self, make_controller, FLAGS): + ''' + Builds a TensorFlow graph for the Differentiable Neural Computer. Uses TensorArrays and a while loop for efficiency + Parameters: + ---------- + make_controller: Controller + An object class which inherits from the Controller class. We build the object in this function + FLAGS: a set of TensorFlow FlagValues which must include + FLAGS.xlen: the length of the input vector of the controller + FLAGS.ylen: the length of the output vector of the controller + FLAGS.batch_size: the number of batches + FLAGS.R: the number of DNC read heads + FLAGS.W: the DNC "word length" (length of each DNC memory vector) + FLAGS.N: the number of DNC word vectors (corresponds to memory size) + ''' + self.xlen = xlen = FLAGS.xlen + self.ylen = ylen = FLAGS.ylen + self.batch_size = batch_size = FLAGS.batch_size + self.R = R = FLAGS.R + self.W = W = FLAGS.W + self.N = N = FLAGS.N + + # create 1) the DNC's memory and 2) the DNC's controller + self.memory = Memory(R, W, N, batch_size) + self.controller = make_controller(FLAGS) + + # input data placeholders + self.X = tf.placeholder(tf.float32, [batch_size, None, xlen], name='X') + self.y = tf.placeholder(tf.float32, [batch_size, None, ylen], name='y') + self.tsteps = tf.placeholder(tf.int32, name='tsteps') + + self.X_tensor_array = self.unstack_time_dim(self.X) + + # initialize states + nn_state = self.controller.zero_state() + dnc_state = self.memory.zero_state() + + # values for which we want a history + self.hist_keys = ['y_hat', 'f', 'g_a', 'g_w', 'w_r', 'w_w', 'u'] + dnc_hist = [tf.TensorArray(tf.float32, self.tsteps) for _ in range(len(self.hist_keys))] + + # loop through time + with tf.variable_scope("while_loop") as scope: + time = tf.constant(0, dtype=tf.int32) + + output = tf.while_loop( + cond=lambda time, *_: time < self.tsteps, + body=self.step, + loop_vars=(time, nn_state, dnc_state, dnc_hist), + ) + (_, next_nn_state, next_dnc_state, dnc_hist) = output + + # write down the history + with tf.control_dependencies(next_dnc_state): + self.dnc_hist = {self.hist_keys[i]: self.stack_time_dim(v) for i, v in enumerate(dnc_hist)} # convert to dict + + def step(self, time, nn_state, dnc_state, dnc_hist): + ''' + Performs the feedforward step of the DNC in order to get the DNC output + Parameters: + ---------- + time: Constant 1-D Tensor + the current time step of the model + nn_state: LSTMStateTensor or another type of state tensor + for the controller network + dnc_state: Tuple + set of 7 Tensors which define the current state of the DNC (M, u, p, L, w_w, w_r, r) ...see paper + dnc_hist: Tuple + set of 7 TensorArrays which track the historical states of the DNC (y_hat, f, g_a, g_w, w_r, w_w, u). Good for visualization + Returns: Tuple + same as input parameters, but updated for the current time step + ''' + + # map from tuple to dict for readability + dnc_state = {self.memory.state_keys[i]: v for i, v in enumerate(dnc_state)} + dnc_hist = {self.hist_keys[i]: v for i, v in enumerate(dnc_hist)} + + # one full pass! + X_t = self.X_tensor_array.read(time) + v, zeta, next_nn_state = self.controller.step(X_t, dnc_state['r'], nn_state) + next_dnc_state = self.memory.step(zeta, dnc_state) + y_hat = self.controller.next_y_hat(v, next_dnc_state['r']) + + dnc_hist['y_hat'] = dnc_hist['y_hat'].write(time, y_hat) + dnc_hist['f'] = dnc_hist['f'].write(time, zeta['f']) + dnc_hist['g_a'] = dnc_hist['g_a'].write(time, zeta['g_a']) + dnc_hist['g_w'] = dnc_hist['g_w'].write(time, zeta['g_w']) + dnc_hist['w_r'] = dnc_hist['w_r'].write(time, next_dnc_state['w_r']) + dnc_hist['w_w'] = dnc_hist['w_w'].write(time, next_dnc_state['w_w']) + dnc_hist['u'] = dnc_hist['u'].write(time, next_dnc_state['u']) + + # map from dict to tuple for tf.while_loop :/ + next_dnc_state = [next_dnc_state[k] for k in self.memory.state_keys] + dnc_hist = [dnc_hist[k] for k in self.hist_keys] + + time += 1 + return time, next_nn_state, next_dnc_state, dnc_hist + + def get_outputs(self): + ''' + Allows user to access the output of the DNC after all time steps have been executed + Returns: tuple + y_hat: Tensor (batch_size, controller_dim) + The DNC's ouput + dnc_hist: Tuple + Set of Tensors which contain values of (y_hat, f, g_a, g_w, w_r, w_w, u) respectively for all time steps + ''' + return self.dnc_hist['y_hat'], self.dnc_hist + + def stack_time_dim(self, v): + ''' + Stacks a TensorArray along its time dimension, then transposes so that the time dimension is at index [1] + Parameters: + ---------- + v: TensorArray [(batch_size, ...), ...] + An array of n-dimensional tensor where for each, the first dimension is the batch dimension + Returns: Tensor (batch_size, ylen) + u: Tensor (batch_size, tsteps, ...) + The stacked tensor with index [1] as the time dimension + ''' + stacked = v.stack() + return tf.transpose(stacked, [1,0] + range(2, len(stacked.get_shape())) ) + + def unstack_time_dim(self, v): + ''' + Unstacks a TensorArray along its time dimension + Parameters: + ---------- + v: Tensor (batch_size, tsteps, ...) + An n-dimensional tensor where dim[0] is the batch dimension and dim[1] is the time dimension + Returns: TensorArray [(batch_size, ...) ...] + u: Tensor (batch_size, tsteps, ...) + An array of n-dimensional tensor where, for each, the first dimension is the batch dimension + ''' + array = tf.TensorArray(dtype=v.dtype, size=self.tsteps) + make_time_dim_first = [1, 0] + range(2, len(v.get_shape())) + v_T = tf.transpose(v, make_time_dim_first) + return array.unstack(v_T) diff --git a/copy/dnc/dnc.pyc b/copy/dnc/dnc.pyc new file mode 100644 index 0000000..f0378d2 Binary files /dev/null and b/copy/dnc/dnc.pyc differ diff --git a/copy/dnc/memory.py b/copy/dnc/memory.py new file mode 100755 index 0000000..009ec8b --- /dev/null +++ b/copy/dnc/memory.py @@ -0,0 +1,250 @@ +# Differentiable Neural Computer +# inspired by (http://www.nature.com/nature/journal/v538/n7626/full/nature20101.html) +# some ideas taken from https://github.com/Mostafa-Samir/DNC-tensorflow +# Sam Greydanus. February 2017. MIT License. + +import tensorflow as tf +import numpy as np + +class Memory(): + def __init__(self, R, W, N, batch_size): + ''' + Defines how the interface vector zeta interacts with the memory state of the DNC + Parameters: + ---------- + R: the number of DNC read heads + W: the DNC "word length" (length of each DNC memory vector) + N: the number of DNC word vectors (corresponds to memory size) + batch_size: the number of batches + ''' + + self.R = R + self.W = W + self.N = N + self.batch_size = batch_size + + # when we go from 2D indexes to a flat 1D vector, we need to reindex using these shifts + ix_flat_shifts = tf.constant(np.cumsum([0] + [N] * (batch_size - 1)), dtype=tf.int32) + self.ix_flat_shifts = tf.expand_dims(ix_flat_shifts, [1]) + + # N x N identity matrix + self.I = tf.eye(N) + self.eps = 1e-6 + self.state_keys = ['M', 'u', 'p', 'L', 'w_w', 'w_r', 'r'] + + def zero_state(self): + ''' + Supplies the initial state of the DNC's memory vector + + Returns: Tuple(7) + dnc_state: contains initial values for (M, u, p, L, w_w, w_r, r) respectively. According to the DNC paper: + M: (batch_size, N, W) the memory vector + u: (batch_size, N) the usage vector + p: (batch_size, N) the precedence weighting (helps update L) + L: (batch_size, N, N) the temporal linkage matrix (helps DNC remember what order things were written) + w_w: (batch_size, N) the write weighting - says where the DNC wrote word last time step + w_r: (batch_size, N, R )the read vector - says which word vectors the DNC accessed last time step + ''' + return [ + tf.fill([self.batch_size, self.N, self.W], self.eps), # M + tf.zeros([self.batch_size, self.N, ]), # u + tf.zeros([self.batch_size, self.N, ]), # p + tf.zeros([self.batch_size, self.N, self.N]), # L + tf.fill([self.batch_size, self.N, ], self.eps), # w_w + tf.fill([self.batch_size, self.N, self.R], self.eps), # w_r + tf.fill([self.batch_size, self.W, self.R], self.eps), # r + ] + + def content_addressing(self, M, kappa, beta): + ''' + Computes the probabilities that each word vector in memory was the target of a given key (see paper) + ''' + norm_M = tf.nn.l2_normalize(M, 2) + norm_kappa = tf.nn.l2_normalize(kappa, 1) + similiarity = tf.matmul(norm_M, norm_kappa) + + return tf.nn.softmax(similiarity * tf.expand_dims(beta, 1), 1) + + def update_u(self, u, w_r, w_w, f): + ''' + Computes the new usage vector. This tells the DNC which memory slots are being used and which are free (see paper) + ''' + f = tf.expand_dims(f, 1) # need to match w_r dimensions + psi = tf.reduce_prod(1 - w_r * f, 2) # psi tells us what usage to reserve + next_u = (u + w_w - u * w_w) * psi # update u based on what we wrote last time + return next_u + + def get_allocation(self, next_u): + ''' + Computes the allocation vector. This tells the DNC where it COULD write its next memory (see paper) + ''' + u_sorted, u_ix = tf.nn.top_k(-1 * next_u, self.N) # sort by descending usage + u_sorted = -1 * u_sorted + a_sorted = (1 - u_sorted) * tf.cumprod(u_sorted, axis=1, exclusive=True) # classic DNC cumprod + + # indexing wizardry to account for multiple batches + ix_flat = u_ix + self.ix_flat_shifts + ix_flat = tf.reshape(ix_flat, (-1,)) + flat_array = tf.TensorArray(tf.float32, self.batch_size * self.N) + + a_scattered = flat_array.scatter(ix_flat, tf.reshape(a_sorted, (-1,))) # undo the sort + a = a_scattered.stack() # put back into a Tensor + return tf.reshape(a, (self.batch_size, self.N)) + + def update_w_w(self, c_w, a, g_w, g_a): + ''' + Computes the new write weighting. This tells the DNC where (and if) it will write its next memory (see paper) + ''' + c_w = tf.squeeze(c_w) # want c_w as a (batched) vector + next_w_w = g_w * (g_a * a + (1 - g_a) * c_w) # apply the allocation and write gates + return next_w_w + + def update_M(self, M, w_w, v, e): + ''' + Computes the new memry matrix. This is where the DNC actually stores memories (see paper) + ''' + # expand data to force matmul to behave as an outer product + w_w = tf.expand_dims(w_w, 2) + v = tf.expand_dims(v, 1) + e = tf.expand_dims(e, 1) + + # think of the memory update as a bunch of elementwise interpolations + M_erase = M * (1 - tf.matmul(w_w, e)) + M_write = tf.matmul(w_w, v) + next_M = M_erase + M_write + return next_M + + def update_p(self, p, w_w): + ''' + Updates the precedence vector. This tells the DNC how much each location was the last one written to (see paper) + ''' + interpolate = 1 - tf.reduce_sum(w_w, 1, keep_dims=True) + next_p = interpolate * p + w_w + return next_p + + def update_L(self, p, L, w_w): + ''' + Updates the temoral linkage matrix. This tells the DNC what order it has written things to memory (see paper) + ''' + w_w = tf.expand_dims(w_w, 2) + p = tf.expand_dims(p, 1) + + # compute "outer sum" of w_w + c_w_w = tf.reshape(w_w, (-1, self.N, 1)) + U = tf.tile(c_w_w,[1, 1, self.N]) + w_w_outer_sum = U + tf.transpose(U, [0, 2, 1]) + + next_L = (1 - w_w_outer_sum) * L + tf.matmul(w_w, p) # update L + return (1 - self.I) * next_L # get rid of links to self + + def get_bf_w(self, w_r, L): + ''' + Gets the write locations immediately before and after a given write location. This lets the DNC traverse memories in order (see paper) + ''' + f_w = tf.matmul(L, w_r) + b_w = tf.matmul(L, w_r, adjoint_a=True) # transpose the first argument + return f_w, b_w + + def update_w_r(self, c_w, f_w, b_w, pi): + ''' + Updates the read weighting. This tells the DNC's read heads which memories to extract (see paper) + ''' + backward = tf.expand_dims(pi[:, 0, :], 1) * b_w + content = tf.expand_dims(pi[:, 1, :], 1) * c_w + forward = tf.expand_dims(pi[:, 2, :], 1) * f_w + next_w_r = backward + content + forward + return next_w_r + + def update_r(self, M, w_r): + ''' + Gets the DNC's output. This vector contains the outputs of the DNC's read heads (see paper) + ''' + return tf.matmul(M, w_r, adjoint_a=True) # transpose the first argument + + def write(self, zeta, state): + ''' + Performs a write action on the DNC's memory + Parameters: + ---------- + zeta: dict + variable names (string) mapping to tensors (Tensor) includes: + 'kappa_r': (batch_size, W, R) read key (there are R of them) + 'beta_r': (batch_size, R) read strength + 'kappa_w': (batch_size, W, 1) write key + 'beta_w': (batch_size, 1) write strength + 'e': (batch_size, W) erase vector + 'v': (batch_size, W) write vector + 'f': (batch_size, R) free gates (R of them) + 'g_a': (batch_size, 1) allocation gate + 'g_w': (batch_size, 1) write gate + 'pi': (batch_size, 3, R) read modes (backward, content, forward) + ... see paper for more info + state: dict + contains initial values for (M, u, p, L, w_w, w_r, r) respectively. According to the DNC paper: + M: (batch_size, N, W) the memory vector + u: (batch_size, N) the usage vector + p: (batch_size, N) the precedence weighting (helps update L) + L: (batch_size, N, N) the temporal linkage matrix (helps DNC remember what order things were written) + w_w: (batch_size, N) the write weighting - says where the DNC wrote word last time step + w_r: (batch_size, N, R )the read vector - says which word vectors the DNC accessed last time step + Returns: Tuple(5) + next_u: Tensor + next_w_w: Tensor + next_M: Tensor + next_L: Tensor + next_pL Tensor + ''' + c_w = self.content_addressing(state['M'], zeta['kappa_w'], zeta['beta_w']) + next_u = self.update_u(state['u'], state['w_r'], state['w_w'], zeta['f']) + + a = self.get_allocation(next_u) + next_w_w = self.update_w_w(c_w, a, zeta['g_w'], zeta['g_a']) + next_M = self.update_M(state['M'], next_w_w, zeta['v'], zeta['e']) + next_L = self.update_L(state['p'], state['L'], next_w_w) + next_p = self.update_p(state['p'], next_w_w) + + return next_u, next_w_w, next_M, next_L, next_p + + def read(self, zeta, state): + ''' + Performs a read action on the DNC's memory + Parameters: + ---------- + zeta: dict + variable names (string) mapping to tensors (Tensor) includes: + 'kappa_r': (batch_size, W, R) read key (there are R of them) + 'beta_r': (batch_size, R) read strength + 'kappa_w': (batch_size, W, 1) write key + 'beta_w': (batch_size, 1) write strength + 'e': (batch_size, W) erase vector + 'v': (batch_size, W) write vector + 'f': (batch_size, R) free gates (R of them) + 'g_a': (batch_size, 1) allocation gate + 'g_w': (batch_size, 1) write gate + 'pi': (batch_size, 3, R) read modes (backward, content, forward) + ... see paper for more info + state: dict + contains initial values for (M, u, p, L, w_w, w_r, r) respectively. According to the DNC paper: + M: (batch_size, N, W) the memory vector + u: (batch_size, N) the usage vector + p: (batch_size, N) the precedence weighting (helps update L) + L: (batch_size, N, N) the temporal linkage matrix (helps DNC remember what order things were written) + w_w: (batch_size, N) the write weighting - says where the DNC wrote word last time step + w_r: (batch_size, N, R )the read vector - says which word vectors the DNC accessed last time step + Returns: Tuple(2) + next_w_r: Tensor + next_r: Tensor + ''' + c_w = self.content_addressing(state['M'], zeta['kappa_r'], zeta['beta_r']) + f_w, b_w = self.get_bf_w(state['w_r'], state['L']) + next_w_r = self.update_w_r(c_w, f_w, b_w, zeta['pi']) + next_r = self.update_r(state['M'], next_w_r) + return next_w_r, next_r + + def step(self, zeta, state): + ''' + Combines the read and write operations into a single memory update step. + ''' + state['u'], state['w_w'], state['M'], state['L'], state['p'] = self.write(zeta, state) + state['w_r'], state['r'] = self.read(zeta, state) + return state \ No newline at end of file diff --git a/copy/dnc/memory.pyc b/copy/dnc/memory.pyc new file mode 100644 index 0000000..ffd2588 Binary files /dev/null and b/copy/dnc/memory.pyc differ diff --git a/copy/nn_controller.py b/copy/nn_controller.py new file mode 100755 index 0000000..6501f92 --- /dev/null +++ b/copy/nn_controller.py @@ -0,0 +1,30 @@ +import numpy as np +import tensorflow as tf +from dnc.controller import Controller +from tensorflow.contrib.rnn.python.ops.core_rnn_cell import LSTMStateTuple + + +""" +A 2-Layer feedforward neural network with 128, 256 nodes respectively +""" + +class NNController(Controller): + + def init_controller_params(self): + init = tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32) + + self.params['W1'] = tf.get_variable("W1", [self.chi_dim, 128], initializer=init) + self.params['b1'] = tf.get_variable("b1", [128], initializer=init) + self.params['W2'] = tf.get_variable("W2", [128, 256], initializer=init) + self.params['b2'] = tf.get_variable("b2", [256], initializer=init) + + + def nn_step(self, X, state): + z1 = tf.matmul(X, self.params['W1']) + self.params['b1'] + h1 = tf.nn.relu(z1) + z2 = tf.matmul(h1, self.params['W2']) + self.params['b2'] + h2 = tf.nn.relu(z2) + return h2, state + + def zero_state(self): + return LSTMStateTuple(tf.zeros(1), tf.zeros(1)) diff --git a/copy/nn_controller.pyc b/copy/nn_controller.pyc new file mode 100644 index 0000000..edfa65e Binary files /dev/null and b/copy/nn_controller.pyc differ diff --git a/copy/static/dnc_schema.png b/copy/static/dnc_schema.png new file mode 100644 index 0000000..5212a7d Binary files /dev/null and b/copy/static/dnc_schema.png differ diff --git a/dnc/__init__.py b/dnc/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/dnc/__init__.pyc b/dnc/__init__.pyc new file mode 100644 index 0000000..0b8af21 Binary files /dev/null and b/dnc/__init__.pyc differ diff --git a/dnc/controller.py b/dnc/controller.py new file mode 100755 index 0000000..fe245a8 --- /dev/null +++ b/dnc/controller.py @@ -0,0 +1,161 @@ +# Differentiable Neural Computer +# inspired by (http://www.nature.com/nature/journal/v538/n7626/full/nature20101.html) +# some ideas taken from https://github.com/Mostafa-Samir/DNC-tensorflow +# Sam Greydanus. February 2017. MIT License. + +import tensorflow as tf +import numpy as np + +class Controller(): + def __init__(self, FLAGS): + ''' + An interface that defines how the neural network "controller" interacts with the DNC + Parameters: + ---------- + FLAGS: a set of TensorFlow FlagValues which must include + FLAGS.xlen: the length of the input vector of the controller + FLAGS.ylen: the length of the output vector of the controller + FLAGS.batch_size: the number of batches + FLAGS.R: the number of DNC read heads + FLAGS.W: the DNC "word length" (length of each DNC memory vector) + + Returns: Tensor (batch_size, nn_output_size) + ''' + + self.xlen = FLAGS.xlen + self.ylen = FLAGS.ylen + self.batch_size = FLAGS.batch_size + self.R = R = FLAGS.R + self.W = W = FLAGS.W + + self.chi_dim = self.xlen + self.W * self.R + self.zeta_dim = W*R + 3*W + 5*R + 3 + self.r_dim = W*R + + # define network vars + self.params = {} + with tf.name_scope("controller"): + self.init_controller_params() + self.controller_dim = self.get_controller_dim() + + init = tf.truncated_normal_initializer(stddev=0.075, dtype=tf.float32) + self.params['W_z'] = tf.get_variable("W_z", [self.controller_dim, self.zeta_dim], initializer=init) + self.params['W_v'] = tf.get_variable("W_v", [self.controller_dim, self.ylen], initializer=init) + self.params['W_r'] = tf.get_variable("W_r", [self.r_dim, self.ylen], initializer=init) + + def init_controller_params(self): + ''' + Initializes all the parameters of the neural network controller + ''' + raise NotImplementedError("init_controller_params does not exist") + + def nn_step(self, chi, state): + ''' + Performs the feedforward step of the controller in order to get the DNC interface vector, zeta + Parameters: + ---------- + chi: Tensor (batch_size, chi_dim) + the input concatenated with the previous output of the DNC + state: LSTMStateTensor or another type of state tensor + Returns: Tuple + zeta_hat: Tensor (batch_size, controller_dim) + next_state: LSTMStateTensor or another type of state tensor + ''' + raise NotImplementedError("nn_step does not exist") + + def zero_state(self): + ''' + Returns the initial state of the controller. If the controller is not recurrent, it still needs to return a dummy value + Returns: LSTMStateTensor or another type of state tensor + nn_state: LSTMStateTensor or another type of state tensor + ''' + raise NotImplementedError("get_state does not exist") + + def get_controller_dim(self): + ''' + Feeds zeros through the controller and obtains an output in order to find the controller's output dimension + Returns: int + controller_dim: the output dimension of the controller + ''' + test_chi = tf.zeros([self.batch_size, self.chi_dim]) + nn_output, nn_state = self.nn_step(test_chi, state=None) + return nn_output.get_shape().as_list()[-1] + + def prepare_interface(self, zeta_hat): + ''' + Packages the interface vector, zeta, as a dictionary of variables as described in the DNC Nature paper + Parameters: + ---------- + zeta_hat: Tensor (batch_size, zeta_dim) + the interface vector before processing, zeta_hat + Returns: dict + zeta: variable names (string) mapping to tensors (Tensor) + ''' + zeta = {} + R, W = self.R, self.W + splits = np.cumsum([0,W*R,R,W,1,W,W,R,1,1,3*R]) + vs = [zeta_hat[:, splits[i]:splits[i+1]] for i in range(len(splits)-1)] + + kappa_r = tf.reshape(vs[0], (-1, W, R)) + beta_r = tf.reshape(vs[1], (-1, R)) + kappa_w = tf.reshape(vs[2], (-1, W, 1)) + beta_w = tf.reshape(vs[3], (-1, 1)) + e = tf.reshape(vs[4], (-1, W)) + v = tf.reshape(vs[5], (-1, W)) + f = tf.reshape(vs[6], (-1, R)) + g_a = vs[7] + g_w = vs[8] + pi = tf.reshape(vs[9], (-1, 3, R)) + + zeta['kappa_r'] = kappa_r + zeta['beta_r'] = 1 + tf.nn.softplus(beta_r) + zeta['kappa_w'] = kappa_w + zeta['beta_w'] = 1 + tf.nn.softplus(beta_w) + zeta['e'] = tf.nn.sigmoid(e) + zeta['v'] = v + zeta['f'] = tf.nn.sigmoid(f) + zeta['g_a'] = tf.nn.sigmoid(g_a) + zeta['g_w'] = tf.nn.sigmoid(g_w) + zeta['pi'] = tf.nn.softmax(pi, 1) + + return zeta + + def step(self, X, r_prev, state): + ''' + The sum of operations executed by the Controller at a given time step before interfacing with the DNC + Parameters: + ---------- + X: Tensor (batch_size, chi_dim) + the input for this time step + r_prev: previous output of the DNC + state: LSTMStateTensor or another type of state tensor + Returns: Tuple + v: Tensor (batch_size, ylen) + The controller's output (eventually added elementwise to the DNC output) + zeta: The processed interface vector which the network will use to interact with the DNC + nn_state: LSTMStateTensor or another type of state tensor + ''' + r_prev = tf.reshape(r_prev, (-1, self.r_dim)) # flatten + chi = tf.concat([X, r_prev], 1) + nn_output, nn_state = self.nn_step(chi, state) + + v = tf.matmul(nn_output, self.params['W_v']) + zeta_hat = tf.matmul(nn_output, self.params['W_z']) + zeta = self.prepare_interface(zeta_hat) + return v, zeta, nn_state + + def next_y_hat(self, v, r): + ''' + The sum of operations executed by the Controller at a given time step after interacting with the DNC + Parameters: + ---------- + v: Tensor (batch_size, ylen) + The controller's output (added elementwise to the DNC output) + r_prev: the current output of the DNC + Returns: Tensor (batch_size, ylen) + y_hat: Tensor (batch_size, controller_dim) + The DNC's ouput + ''' + r = tf.reshape(r, (-1, self.W * self.R)) # flatten + y_hat = v + tf.matmul(r, self.params['W_r']) + return y_hat diff --git a/dnc/controller.pyc b/dnc/controller.pyc new file mode 100644 index 0000000..ccaafc7 Binary files /dev/null and b/dnc/controller.pyc differ diff --git a/dnc/dnc.py b/dnc/dnc.py new file mode 100755 index 0000000..67f5195 --- /dev/null +++ b/dnc/dnc.py @@ -0,0 +1,150 @@ +# Differentiable Neural Computer +# inspired by (http://www.nature.com/nature/journal/v538/n7626/full/nature20101.html) +# some ideas taken from https://github.com/Mostafa-Samir/DNC-tensorflow +# Sam Greydanus. February 2017. MIT License. + +import tensorflow as tf +import numpy as np +from memory import Memory + +import os + +class DNC: + def __init__(self, make_controller, FLAGS): + ''' + Builds a TensorFlow graph for the Differentiable Neural Computer. Uses TensorArrays and a while loop for efficiency + Parameters: + ---------- + make_controller: Controller + An object class which inherits from the Controller class. We build the object in this function + FLAGS: a set of TensorFlow FlagValues which must include + FLAGS.xlen: the length of the input vector of the controller + FLAGS.ylen: the length of the output vector of the controller + FLAGS.batch_size: the number of batches + FLAGS.R: the number of DNC read heads + FLAGS.W: the DNC "word length" (length of each DNC memory vector) + FLAGS.N: the number of DNC word vectors (corresponds to memory size) + ''' + self.xlen = xlen = FLAGS.xlen + self.ylen = ylen = FLAGS.ylen + self.batch_size = batch_size = FLAGS.batch_size + self.R = R = FLAGS.R + self.W = W = FLAGS.W + self.N = N = FLAGS.N + + # create 1) the DNC's memory and 2) the DNC's controller + self.memory = Memory(R, W, N, batch_size) + self.controller = make_controller(FLAGS) + + # input data placeholders + self.X = tf.placeholder(tf.float32, [batch_size, None, xlen], name='X') + self.y = tf.placeholder(tf.float32, [batch_size, None, ylen], name='y') + self.tsteps = tf.placeholder(tf.int32, name='tsteps') + + self.X_tensor_array = self.unstack_time_dim(self.X) + + # initialize states + nn_state = self.controller.zero_state() + dnc_state = self.memory.zero_state() + + # values for which we want a history + self.hist_keys = ['y_hat', 'f', 'g_a', 'g_w', 'w_r', 'w_w', 'u'] + dnc_hist = [tf.TensorArray(tf.float32, self.tsteps) for _ in range(len(self.hist_keys))] + + # loop through time + with tf.variable_scope("while_loop") as scope: + time = tf.constant(0, dtype=tf.int32) + + output = tf.while_loop( + cond=lambda time, *_: time < self.tsteps, + body=self.step, + loop_vars=(time, nn_state, dnc_state, dnc_hist), + ) + (_, next_nn_state, next_dnc_state, dnc_hist) = output + + # write down the history + with tf.control_dependencies(next_dnc_state): + self.dnc_hist = {self.hist_keys[i]: self.stack_time_dim(v) for i, v in enumerate(dnc_hist)} # convert to dict + + def step(self, time, nn_state, dnc_state, dnc_hist): + ''' + Performs the feedforward step of the DNC in order to get the DNC output + Parameters: + ---------- + time: Constant 1-D Tensor + the current time step of the model + nn_state: LSTMStateTensor or another type of state tensor + for the controller network + dnc_state: Tuple + set of 7 Tensors which define the current state of the DNC (M, u, p, L, w_w, w_r, r) ...see paper + dnc_hist: Tuple + set of 7 TensorArrays which track the historical states of the DNC (y_hat, f, g_a, g_w, w_r, w_w, u). Good for visualization + Returns: Tuple + same as input parameters, but updated for the current time step + ''' + + # map from tuple to dict for readability + dnc_state = {self.memory.state_keys[i]: v for i, v in enumerate(dnc_state)} + dnc_hist = {self.hist_keys[i]: v for i, v in enumerate(dnc_hist)} + + # one full pass! + X_t = self.X_tensor_array.read(time) + v, zeta, next_nn_state = self.controller.step(X_t, dnc_state['r'], nn_state) + next_dnc_state = self.memory.step(zeta, dnc_state) + y_hat = self.controller.next_y_hat(v, next_dnc_state['r']) + + dnc_hist['y_hat'] = dnc_hist['y_hat'].write(time, y_hat) + dnc_hist['f'] = dnc_hist['f'].write(time, zeta['f']) + dnc_hist['g_a'] = dnc_hist['g_a'].write(time, zeta['g_a']) + dnc_hist['g_w'] = dnc_hist['g_w'].write(time, zeta['g_w']) + dnc_hist['w_r'] = dnc_hist['w_r'].write(time, next_dnc_state['w_r']) + dnc_hist['w_w'] = dnc_hist['w_w'].write(time, next_dnc_state['w_w']) + dnc_hist['u'] = dnc_hist['u'].write(time, next_dnc_state['u']) + + # map from dict to tuple for tf.while_loop :/ + next_dnc_state = [next_dnc_state[k] for k in self.memory.state_keys] + dnc_hist = [dnc_hist[k] for k in self.hist_keys] + + time += 1 + return time, next_nn_state, next_dnc_state, dnc_hist + + def get_outputs(self): + ''' + Allows user to access the output of the DNC after all time steps have been executed + Returns: tuple + y_hat: Tensor (batch_size, controller_dim) + The DNC's ouput + dnc_hist: Tuple + Set of Tensors which contain values of (y_hat, f, g_a, g_w, w_r, w_w, u) respectively for all time steps + ''' + return self.dnc_hist['y_hat'], self.dnc_hist + + def stack_time_dim(self, v): + ''' + Stacks a TensorArray along its time dimension, then transposes so that the time dimension is at index [1] + Parameters: + ---------- + v: TensorArray [(batch_size, ...), ...] + An array of n-dimensional tensor where for each, the first dimension is the batch dimension + Returns: Tensor (batch_size, ylen) + u: Tensor (batch_size, tsteps, ...) + The stacked tensor with index [1] as the time dimension + ''' + stacked = v.stack() + return tf.transpose(stacked, [1,0] + range(2, len(stacked.get_shape())) ) + + def unstack_time_dim(self, v): + ''' + Unstacks a TensorArray along its time dimension + Parameters: + ---------- + v: Tensor (batch_size, tsteps, ...) + An n-dimensional tensor where dim[0] is the batch dimension and dim[1] is the time dimension + Returns: TensorArray [(batch_size, ...) ...] + u: Tensor (batch_size, tsteps, ...) + An array of n-dimensional tensor where, for each, the first dimension is the batch dimension + ''' + array = tf.TensorArray(dtype=v.dtype, size=self.tsteps) + make_time_dim_first = [1, 0] + range(2, len(v.get_shape())) + v_T = tf.transpose(v, make_time_dim_first) + return array.unstack(v_T) diff --git a/dnc/dnc.pyc b/dnc/dnc.pyc new file mode 100644 index 0000000..f0378d2 Binary files /dev/null and b/dnc/dnc.pyc differ diff --git a/dnc/memory.py b/dnc/memory.py new file mode 100755 index 0000000..009ec8b --- /dev/null +++ b/dnc/memory.py @@ -0,0 +1,250 @@ +# Differentiable Neural Computer +# inspired by (http://www.nature.com/nature/journal/v538/n7626/full/nature20101.html) +# some ideas taken from https://github.com/Mostafa-Samir/DNC-tensorflow +# Sam Greydanus. February 2017. MIT License. + +import tensorflow as tf +import numpy as np + +class Memory(): + def __init__(self, R, W, N, batch_size): + ''' + Defines how the interface vector zeta interacts with the memory state of the DNC + Parameters: + ---------- + R: the number of DNC read heads + W: the DNC "word length" (length of each DNC memory vector) + N: the number of DNC word vectors (corresponds to memory size) + batch_size: the number of batches + ''' + + self.R = R + self.W = W + self.N = N + self.batch_size = batch_size + + # when we go from 2D indexes to a flat 1D vector, we need to reindex using these shifts + ix_flat_shifts = tf.constant(np.cumsum([0] + [N] * (batch_size - 1)), dtype=tf.int32) + self.ix_flat_shifts = tf.expand_dims(ix_flat_shifts, [1]) + + # N x N identity matrix + self.I = tf.eye(N) + self.eps = 1e-6 + self.state_keys = ['M', 'u', 'p', 'L', 'w_w', 'w_r', 'r'] + + def zero_state(self): + ''' + Supplies the initial state of the DNC's memory vector + + Returns: Tuple(7) + dnc_state: contains initial values for (M, u, p, L, w_w, w_r, r) respectively. According to the DNC paper: + M: (batch_size, N, W) the memory vector + u: (batch_size, N) the usage vector + p: (batch_size, N) the precedence weighting (helps update L) + L: (batch_size, N, N) the temporal linkage matrix (helps DNC remember what order things were written) + w_w: (batch_size, N) the write weighting - says where the DNC wrote word last time step + w_r: (batch_size, N, R )the read vector - says which word vectors the DNC accessed last time step + ''' + return [ + tf.fill([self.batch_size, self.N, self.W], self.eps), # M + tf.zeros([self.batch_size, self.N, ]), # u + tf.zeros([self.batch_size, self.N, ]), # p + tf.zeros([self.batch_size, self.N, self.N]), # L + tf.fill([self.batch_size, self.N, ], self.eps), # w_w + tf.fill([self.batch_size, self.N, self.R], self.eps), # w_r + tf.fill([self.batch_size, self.W, self.R], self.eps), # r + ] + + def content_addressing(self, M, kappa, beta): + ''' + Computes the probabilities that each word vector in memory was the target of a given key (see paper) + ''' + norm_M = tf.nn.l2_normalize(M, 2) + norm_kappa = tf.nn.l2_normalize(kappa, 1) + similiarity = tf.matmul(norm_M, norm_kappa) + + return tf.nn.softmax(similiarity * tf.expand_dims(beta, 1), 1) + + def update_u(self, u, w_r, w_w, f): + ''' + Computes the new usage vector. This tells the DNC which memory slots are being used and which are free (see paper) + ''' + f = tf.expand_dims(f, 1) # need to match w_r dimensions + psi = tf.reduce_prod(1 - w_r * f, 2) # psi tells us what usage to reserve + next_u = (u + w_w - u * w_w) * psi # update u based on what we wrote last time + return next_u + + def get_allocation(self, next_u): + ''' + Computes the allocation vector. This tells the DNC where it COULD write its next memory (see paper) + ''' + u_sorted, u_ix = tf.nn.top_k(-1 * next_u, self.N) # sort by descending usage + u_sorted = -1 * u_sorted + a_sorted = (1 - u_sorted) * tf.cumprod(u_sorted, axis=1, exclusive=True) # classic DNC cumprod + + # indexing wizardry to account for multiple batches + ix_flat = u_ix + self.ix_flat_shifts + ix_flat = tf.reshape(ix_flat, (-1,)) + flat_array = tf.TensorArray(tf.float32, self.batch_size * self.N) + + a_scattered = flat_array.scatter(ix_flat, tf.reshape(a_sorted, (-1,))) # undo the sort + a = a_scattered.stack() # put back into a Tensor + return tf.reshape(a, (self.batch_size, self.N)) + + def update_w_w(self, c_w, a, g_w, g_a): + ''' + Computes the new write weighting. This tells the DNC where (and if) it will write its next memory (see paper) + ''' + c_w = tf.squeeze(c_w) # want c_w as a (batched) vector + next_w_w = g_w * (g_a * a + (1 - g_a) * c_w) # apply the allocation and write gates + return next_w_w + + def update_M(self, M, w_w, v, e): + ''' + Computes the new memry matrix. This is where the DNC actually stores memories (see paper) + ''' + # expand data to force matmul to behave as an outer product + w_w = tf.expand_dims(w_w, 2) + v = tf.expand_dims(v, 1) + e = tf.expand_dims(e, 1) + + # think of the memory update as a bunch of elementwise interpolations + M_erase = M * (1 - tf.matmul(w_w, e)) + M_write = tf.matmul(w_w, v) + next_M = M_erase + M_write + return next_M + + def update_p(self, p, w_w): + ''' + Updates the precedence vector. This tells the DNC how much each location was the last one written to (see paper) + ''' + interpolate = 1 - tf.reduce_sum(w_w, 1, keep_dims=True) + next_p = interpolate * p + w_w + return next_p + + def update_L(self, p, L, w_w): + ''' + Updates the temoral linkage matrix. This tells the DNC what order it has written things to memory (see paper) + ''' + w_w = tf.expand_dims(w_w, 2) + p = tf.expand_dims(p, 1) + + # compute "outer sum" of w_w + c_w_w = tf.reshape(w_w, (-1, self.N, 1)) + U = tf.tile(c_w_w,[1, 1, self.N]) + w_w_outer_sum = U + tf.transpose(U, [0, 2, 1]) + + next_L = (1 - w_w_outer_sum) * L + tf.matmul(w_w, p) # update L + return (1 - self.I) * next_L # get rid of links to self + + def get_bf_w(self, w_r, L): + ''' + Gets the write locations immediately before and after a given write location. This lets the DNC traverse memories in order (see paper) + ''' + f_w = tf.matmul(L, w_r) + b_w = tf.matmul(L, w_r, adjoint_a=True) # transpose the first argument + return f_w, b_w + + def update_w_r(self, c_w, f_w, b_w, pi): + ''' + Updates the read weighting. This tells the DNC's read heads which memories to extract (see paper) + ''' + backward = tf.expand_dims(pi[:, 0, :], 1) * b_w + content = tf.expand_dims(pi[:, 1, :], 1) * c_w + forward = tf.expand_dims(pi[:, 2, :], 1) * f_w + next_w_r = backward + content + forward + return next_w_r + + def update_r(self, M, w_r): + ''' + Gets the DNC's output. This vector contains the outputs of the DNC's read heads (see paper) + ''' + return tf.matmul(M, w_r, adjoint_a=True) # transpose the first argument + + def write(self, zeta, state): + ''' + Performs a write action on the DNC's memory + Parameters: + ---------- + zeta: dict + variable names (string) mapping to tensors (Tensor) includes: + 'kappa_r': (batch_size, W, R) read key (there are R of them) + 'beta_r': (batch_size, R) read strength + 'kappa_w': (batch_size, W, 1) write key + 'beta_w': (batch_size, 1) write strength + 'e': (batch_size, W) erase vector + 'v': (batch_size, W) write vector + 'f': (batch_size, R) free gates (R of them) + 'g_a': (batch_size, 1) allocation gate + 'g_w': (batch_size, 1) write gate + 'pi': (batch_size, 3, R) read modes (backward, content, forward) + ... see paper for more info + state: dict + contains initial values for (M, u, p, L, w_w, w_r, r) respectively. According to the DNC paper: + M: (batch_size, N, W) the memory vector + u: (batch_size, N) the usage vector + p: (batch_size, N) the precedence weighting (helps update L) + L: (batch_size, N, N) the temporal linkage matrix (helps DNC remember what order things were written) + w_w: (batch_size, N) the write weighting - says where the DNC wrote word last time step + w_r: (batch_size, N, R )the read vector - says which word vectors the DNC accessed last time step + Returns: Tuple(5) + next_u: Tensor + next_w_w: Tensor + next_M: Tensor + next_L: Tensor + next_pL Tensor + ''' + c_w = self.content_addressing(state['M'], zeta['kappa_w'], zeta['beta_w']) + next_u = self.update_u(state['u'], state['w_r'], state['w_w'], zeta['f']) + + a = self.get_allocation(next_u) + next_w_w = self.update_w_w(c_w, a, zeta['g_w'], zeta['g_a']) + next_M = self.update_M(state['M'], next_w_w, zeta['v'], zeta['e']) + next_L = self.update_L(state['p'], state['L'], next_w_w) + next_p = self.update_p(state['p'], next_w_w) + + return next_u, next_w_w, next_M, next_L, next_p + + def read(self, zeta, state): + ''' + Performs a read action on the DNC's memory + Parameters: + ---------- + zeta: dict + variable names (string) mapping to tensors (Tensor) includes: + 'kappa_r': (batch_size, W, R) read key (there are R of them) + 'beta_r': (batch_size, R) read strength + 'kappa_w': (batch_size, W, 1) write key + 'beta_w': (batch_size, 1) write strength + 'e': (batch_size, W) erase vector + 'v': (batch_size, W) write vector + 'f': (batch_size, R) free gates (R of them) + 'g_a': (batch_size, 1) allocation gate + 'g_w': (batch_size, 1) write gate + 'pi': (batch_size, 3, R) read modes (backward, content, forward) + ... see paper for more info + state: dict + contains initial values for (M, u, p, L, w_w, w_r, r) respectively. According to the DNC paper: + M: (batch_size, N, W) the memory vector + u: (batch_size, N) the usage vector + p: (batch_size, N) the precedence weighting (helps update L) + L: (batch_size, N, N) the temporal linkage matrix (helps DNC remember what order things were written) + w_w: (batch_size, N) the write weighting - says where the DNC wrote word last time step + w_r: (batch_size, N, R )the read vector - says which word vectors the DNC accessed last time step + Returns: Tuple(2) + next_w_r: Tensor + next_r: Tensor + ''' + c_w = self.content_addressing(state['M'], zeta['kappa_r'], zeta['beta_r']) + f_w, b_w = self.get_bf_w(state['w_r'], state['L']) + next_w_r = self.update_w_r(c_w, f_w, b_w, zeta['pi']) + next_r = self.update_r(state['M'], next_w_r) + return next_w_r, next_r + + def step(self, zeta, state): + ''' + Combines the read and write operations into a single memory update step. + ''' + state['u'], state['w_w'], state['M'], state['L'], state['p'] = self.write(zeta, state) + state['w_r'], state['r'] = self.read(zeta, state) + return state \ No newline at end of file diff --git a/dnc/memory.pyc b/dnc/memory.pyc new file mode 100644 index 0000000..ffd2588 Binary files /dev/null and b/dnc/memory.pyc differ