MNIST/mnist-predict-from-model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def weight_variable(shape, data=None):\n",
    "    initial = data.reshape(shape) if data is not None else tf.truncated_normal(shape, stddev=0.1)\n",
    "    return tf.Variable(initial)\n",
    "\n",
    "def bias_variable(shape, data=None):\n",
    "    initial = data.reshape(shape) if data is not None else tf.constant(0.1, shape=shape)\n",
    "    return tf.Variable(initial)\n",
    "    \n",
    "def conv2d(x, W):\n",
    "    return tf.nn.conv2d(x, W, strides=[1,1,1,1], padding='SAME')\n",
    "\n",
    "def max_pool_2x2(x):\n",
    "    return tf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting data/train-images-idx3-ubyte.gz\n",
      "Extracting data/train-labels-idx1-ubyte.gz\n",
      "Extracting data/t10k-images-idx3-ubyte.gz\n",
      "Extracting data/t10k-labels-idx1-ubyte.gz\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "mnist = input_data.read_data_sets(\"data/\", one_hot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def load(name):\n",
    "    return np.fromfile(name, dtype=np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "modeldir = 'model-bnns'\n",
    "model_names = ['h1w-5x5x1x32', 'h1b-32', 'h2w-5x5x32x64', 'h2b-64',\n",
    "               'h3w-3136x1024', 'h3b-1024', 'h4w-1024x10', 'h4b-10']\n",
    "model = [load(os.path.join(modeldir, 'model-' + n)) for n in model_names]\n",
    "\n",
    "model[0] = model[0].reshape((32,1,5,5)).transpose((2,3,1,0))\n",
    "model[2] = model[2].reshape((64,32,5,5)).transpose((2,3,1,0))\n",
    "model[4] = model[4].reshape((1024,64,7,7)).transpose((2,3,1,0))\n",
    "model[6] = model[6].reshape((10,1024)).transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = tf.placeholder(tf.float32, [None, 784])\n",
    "y_ = tf.placeholder(tf.float32, [None, 10])\n",
    "\n",
    "x_image = tf.reshape(x, [-1, 28, 28, 1])\n",
    "\n",
    "W_conv1 = weight_variable([5, 5, 1, 32], model[0])\n",
    "b_conv1 = bias_variable([32], model[1])\n",
    "h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)\n",
    "h_pool1 = max_pool_2x2(h_conv1)\n",
    "\n",
    "W_conv2 = weight_variable([5, 5, 32, 64], model[2])\n",
    "b_conv2 = bias_variable([64], model[3])\n",
    "h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)\n",
    "h_pool2 = max_pool_2x2(h_conv2)\n",
    "\n",
    "W_fc1 = weight_variable([7 * 7 * 64, 1024], model[4])\n",
    "b_fc1 = bias_variable([1024], model[5])\n",
    "h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])\n",
    "h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)\n",
    "\n",
    "W_fc2 = weight_variable([1024, 10], model[6])\n",
    "b_fc2 = bias_variable([10], model[7])\n",
    "\n",
    "y_conv = tf.nn.softmax(tf.matmul(h_fc1, W_fc2) + b_fc2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'recognized 7, actual 7'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample = mnist.test.images[0:1].copy()\n",
    "actual = mnist.test.labels[0].argmax()\n",
    "\n",
    "init = tf.initialize_all_variables()\n",
    "with tf.Session() as ses:\n",
    "    ses.run(init)\n",
    "    predict = tf.argmax(y_conv, 1)\n",
    "    recognized = ses.run(predict, feed_dict = {x: sample})\n",
    "\n",
    "'recognized %d, actual %d' % (recognized, actual)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}