TensorFlow.ipynb

{"cells":[
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "# TensorFlow deep NN\n#### A high-level tutorial into Deep Learning using MNIST data and TensorFlow library."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "import numpy as np\nimport pandas as pd\n\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport matplotlib.cm as cm\n\nimport tensorflow as tf\n\n# settings\nLEARNING_RATE = 1e-4\n# set to 20000 on local environment to get 0.99 accuracy\nTRAINING_ITERATIONS = 2500        \n    \nDROPOUT = 0.5\nBATCH_SIZE = 50\n\n# set to 0 to train on all available data\nVALIDATION_SIZE = 2000\n\n# image number to output\nIMAGE_TO_DISPLAY = 10"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "## Data preparation\nTo start, we read provided data. The *train.csv* file contains 42000 rows and 785 columns. Each row represents an image of a handwritten digit and a label with the value of this digit."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# read training data from CSV file \ndata = pd.read_csv('../input/train.csv')\n\nprint('data({0[0]},{0[1]})'.format(data.shape))\nprint (data.head())"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "Every image is a \"stretched\" array of pixel values."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "images = data.iloc[:,1:].values\nimages = images.astype(np.float)\n\n# convert from [0:255] => [0.0:1.0]\nimages = np.multiply(images, 1.0 / 255.0)\n\nprint('images({0[0]},{0[1]})'.format(images.shape))"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "In this case it's 784 pixels => 28 * 28px"
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "image_size = images.shape[1]\nprint ('image_size => {0}'.format(image_size))\n\n# in this case all images are square\nimage_width = image_height = np.ceil(np.sqrt(image_size)).astype(np.uint8)\n\nprint ('image_width => {0}\\nimage_height => {1}'.format(image_width,image_height))"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "To output one of the images, we reshape this long string of pixels into a 2-dimensional array, which is basically a grayscale image."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# display image\ndef display(img):\n    \n    # (784) => (28,28)\n    one_image = img.reshape(image_width,image_height)\n    \n    plt.axis('off')\n    plt.imshow(one_image, cmap=cm.binary)\n\n# output image     \ndisplay(images[IMAGE_TO_DISPLAY])"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "The corresponding labels are numbers between 0 and 9, describing which digit a given image is of."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "labels_flat = data[[0]].values.ravel()\n\nprint('labels_flat({0})'.format(len(labels_flat)))\nprint ('labels_flat[{0}] => {1}'.format(IMAGE_TO_DISPLAY,labels_flat[IMAGE_TO_DISPLAY]))"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "In this case, there are ten different digits/labels/classes."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "labels_count = np.unique(labels_flat).shape[0]\n\nprint('labels_count => {0}'.format(labels_count))"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "For most classification problems \"one-hot vectors\" are used. A one-hot vector is a vector that contains a single element equal to 1 and the rest of the elements equal to 0. In this case, the *nth* digit is represented as a zero vector with 1 in the *nth* position."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# convert class labels from scalars to one-hot vectors\n# 0 => [1 0 0 0 0 0 0 0 0 0]\n# 1 => [0 1 0 0 0 0 0 0 0 0]\n# ...\n# 9 => [0 0 0 0 0 0 0 0 0 1]\ndef dense_to_one_hot(labels_dense, num_classes):\n    num_labels = labels_dense.shape[0]\n    index_offset = np.arange(num_labels) * num_classes\n    labels_one_hot = np.zeros((num_labels, num_classes))\n    labels_one_hot.flat[index_offset + labels_dense.ravel()] = 1\n    return labels_one_hot\n\nlabels = dense_to_one_hot(labels_flat, labels_count)\nlabels = labels.astype(np.uint8)\n\nprint('labels({0[0]},{0[1]})'.format(labels.shape))\nprint ('labels[{0}] => {1}'.format(IMAGE_TO_DISPLAY,labels[IMAGE_TO_DISPLAY]))"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "Lastly we set aside data for validation. It's essential in machine learning to have a separate dataset which doesn't take part in the training and is used to make sure that what we've learned can actually be generalised."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# split data into training & validation\nvalidation_images = images[:VALIDATION_SIZE]\nvalidation_labels = labels[:VALIDATION_SIZE]\n\ntrain_images = images[VALIDATION_SIZE:]\ntrain_labels = labels[VALIDATION_SIZE:]\n\n\nprint('train_images({0[0]},{0[1]})'.format(train_images.shape))\nprint('validation_images({0[0]},{0[1]})'.format(validation_images.shape))"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "*Data is ready. The neural network structure is next.*\n## TensorFlow graph\nTensorFlow does its heavy lifting outside Python. Therefore, instead of running every single operation independently, TensorFlow allows users to build a whole graph of interacting operations and then runs the workflow in a separate process at once.\n#### Helper functions\nFor this NN model, a lot of weights and biases are created. Generally, weights should be initialised with a small amount of noise for symmetry breaking, and to prevent 0 gradients. \n\nSince we are using [ReLU](https://en.wikipedia.org/wiki/Rectifier_(neural_networks) neurones (ones that contain rectifier function *f(x)=max(0,x)*), it is also good practice to initialise them with a slightly positive initial bias to avoid \"dead neurones\"."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# weight initialization\ndef weight_variable(shape):\n    initial = tf.truncated_normal(shape, stddev=0.1)\n    return tf.Variable(initial)\n\ndef bias_variable(shape):\n    initial = tf.constant(0.1, shape=shape)\n    return tf.Variable(initial)"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "For this problem we use zero padded [convolutions](https://en.wikipedia.org/wiki/Convolutional_neural_network#Convolutional_layer) so that the output is the same size as the input. Stride/step in this case is equal to 1.\n\nIn general, convolution layer is used to get the features of the data.  In the case of digit recognition - a shape of each digit.  It uses learnable kernels/filters each of which corresponds to one particular shape pattern. The number of the filter can differ for other problems."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# convolution\ndef conv2d(x, W):\n    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "[Pooling](https://en.wikipedia.org/wiki/Convolutional_neural_network#Pooling_layer) is plain max pooling over 2x2 blocks.\n\nPooling is used for downsampling of the data. 2x2 max-pooling splits the image into square 2-pixel blocks and only keeps maximum value for each of those blocks. "
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# pooling\n# [[0,3],\n#  [4,2]] => 4\n\n# [[0,1],\n#  [1,1]] => 1\n\ndef 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": "markdown",
  "metadata": {},
  "source": "*We'll get back to convolutions and pooling in more detail below.*\n\nThe good thing about neural networks that any NN can be used as a layer in a large multilayer NN meaning that output of one can be used as input for another. This sequential approach can create very sophisticated NN with multiple layers. They are also called Deep Neural Networks.\n\nIn this case, we use two convolution layers with pooling in between them, then densely connected layer followed by dropout and lastly readout layer."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# input & output of NN\n\n# images\nx = tf.placeholder('float', shape=[None, image_size])\n# labels\ny_ = tf.placeholder('float', shape=[None, labels_count])"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "The first layer is a convolution, followed by max pooling. The convolution computes 32 features for each 5x5 patch. Its weight tensor has a shape of [5, 5, 1, 32]. The first two dimensions are the patch size, the next is the number of input channels (1 means that images are grayscale), and the last is the number of output channels. There is also a bias vector with a component for each output channel.\n\nTo apply the layer, we reshape the input data to a 4d tensor, with the first dimension corresponding to the number of images, second and third - to image width and height, and the final dimension - to the number of colour channels.\n\nAfter the convolution, pooling reduces the size of the output from 28x28 to 14x14."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# first convolutional layer\nW_conv1 = weight_variable([5, 5, 1, 32])\nb_conv1 = bias_variable([32])\n\n# (40000,784) => (40000,28,28,1)\nimage = tf.reshape(x, [-1,image_width , image_height,1])\n#print (image.get_shape()) # =>(40000,28,28,1)\n\n\nh_conv1 = tf.nn.relu(conv2d(image, W_conv1) + b_conv1)\n#print (h_conv1.get_shape()) # => (40000, 28, 28, 32)\nh_pool1 = max_pool_2x2(h_conv1)\n#print (h_pool1.get_shape()) # => (40000, 14, 14, 32)\n\n\n# Prepare for visualization\n# display 32 fetures in 4 by 8 grid\nlayer1 = tf.reshape(h_conv1, (-1, image_height, image_width, 4 ,8))  \n\n# reorder so the channels are in the first dimension, x and y follow.\nlayer1 = tf.transpose(layer1, (0, 3, 1, 4,2))\n\nlayer1 = tf.reshape(layer1, (-1, image_height*4, image_width*8)) "
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "The second layer has 64 features for each 5x5 patch. Its weight tensor has a shape of [5, 5, 32, 64]. The first two dimensions are the patch size, the next is the number of input channels (32 channels correspond to 32 featured that we got from previous convolutional layer), and the last is the number of output channels. There is also a bias vector with a component for each output channel.\n\nBecause the image is down-sampled by pooling to 14x14 size second convolutional layer picks up more general characteristics of the images. Filters cover more space of the picture. Therefore, it is adjusted for more generic features while the first layer finds smaller details."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# second convolutional layer\nW_conv2 = weight_variable([5, 5, 32, 64])\nb_conv2 = bias_variable([64])\n\nh_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)\n#print (h_conv2.get_shape()) # => (40000, 14,14, 64)\nh_pool2 = max_pool_2x2(h_conv2)\n#print (h_pool2.get_shape()) # => (40000, 7, 7, 64)\n\n# Prepare for visualization\n# display 64 fetures in 4 by 16 grid\nlayer2 = tf.reshape(h_conv2, (-1, 14, 14, 4 ,16))  \n\n# reorder so the channels are in the first dimension, x and y follow.\nlayer2 = tf.transpose(layer2, (0, 3, 1, 4,2))\n\nlayer2 = tf.reshape(layer2, (-1, 14*4, 14*16)) "
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "Now that the image size is reduced to 7x7, we add a [fully-connected layer](https://en.wikipedia.org/wiki/Convolutional_neural_network#Fully_Connected_layer) with 1024 neurones to allow processing on the entire image (each of the neurons of the fully connected layer is connected to all the activations/outpus of the previous layer)"
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# densely connected layer\nW_fc1 = weight_variable([7 * 7 * 64, 1024])\nb_fc1 = bias_variable([1024])\n\n# (40000, 7, 7, 64) => (40000, 3136)\nh_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])\n\nh_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)\n#print (h_fc1.get_shape()) # => (40000, 1024)"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "To prevent overfitting, we  apply [dropout](https://en.wikipedia.org/wiki/Convolutional_neural_network#Dropout) before the readout layer.\n\nDropout removes some nodes from the network at each training stage. Each of the nodes is either kept in the network with probability *keep_prob* or dropped with probability *1 - keep_prob*. After the training stage is over the nodes are returned to the NN with their original weights."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# dropout\nkeep_prob = tf.placeholder('float')\nh_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "Finally, we add a softmax layer, the same one if we use just a  simple [softmax regression](https://en.wikipedia.org/wiki/Softmax_function)."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# readout layer for deep net\nW_fc2 = weight_variable([1024, labels_count])\nb_fc2 = bias_variable([labels_count])\n\ny = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)\n\n#print (y.get_shape()) # => (40000, 10)"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "To evaluate network performance we use [cross-entropy](https://en.wikipedia.org/wiki/Cross_entropy) and to minimise it [ADAM optimiser](http://arxiv.org/pdf/1412.6980v8.pdf) is used. \n\nADAM optimiser is a gradient based optimization algorithm, based on adaptive estimates, it's more sophisticated than steepest gradient descent and is well suited for problems with large data or many parameters."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# cost function\ncross_entropy = -tf.reduce_sum(y_*tf.log(y))\n\n\n# optimisation function\ntrain_step = tf.train.AdamOptimizer(LEARNING_RATE).minimize(cross_entropy)\n\n# evaluation\ncorrect_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))\n\naccuracy = tf.reduce_mean(tf.cast(correct_prediction, 'float'))"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "To predict values from test data, highest probability is picked from \"one-hot vector\" indicating that chances of  an image being one of the digits are highest."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# prediction function\n#[0.1, 0.9, 0.2, 0.1, 0.1 0.3, 0.5, 0.1, 0.2, 0.3] => 1\npredict = tf.argmax(y,1)"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "*Finally neural network structure is defined and TensorFlow graph is ready for training.*\n## Train, validate and predict\n#### Helper functions\n\nIdeally, we should use all data for every step of the training, but that's expensive. So, instead, we use small \"batches\" of random data. \n\nThis method is called [stochastic training](https://en.wikipedia.org/wiki/Stochastic_gradient_descent). It is cheaper, faster and gives much of the same result."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "epochs_completed = 0\nindex_in_epoch = 0\nnum_examples = train_images.shape[0]\n\n# serve data by batches\ndef next_batch(batch_size):\n    \n    global train_images\n    global train_labels\n    global index_in_epoch\n    global epochs_completed\n    \n    start = index_in_epoch\n    index_in_epoch += batch_size\n    \n    # when all trainig data have been already used, it is reorder randomly    \n    if index_in_epoch > num_examples:\n        # finished epoch\n        epochs_completed += 1\n        # shuffle the data\n        perm = np.arange(num_examples)\n        np.random.shuffle(perm)\n        train_images = train_images[perm]\n        train_labels = train_labels[perm]\n        # start next epoch\n        start = 0\n        index_in_epoch = batch_size\n        assert batch_size <= num_examples\n    end = index_in_epoch\n    return train_images[start:end], train_labels[start:end]"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "Now when all operations for every variable are defined in TensorFlow graph all computations will be performed outside Python environment."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# start TensorFlow session\ninit = tf.initialize_all_variables()\nsess = tf.InteractiveSession()\n\nsess.run(init)"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "Each step of the loop, we get a \"batch\" of data points from the training set and feed it to the graph to replace the placeholders.  In this case, it's:  *x, y* and *dropout.*\n\nAlso, once in a while, we check training accuracy on an upcoming \"batch\".\n\nOn the local environment, we recommend [saving training progress](https://www.tensorflow.org/versions/master/api_docs/python/state_ops.html#Saver), so it can be recovered for further training, debugging or evaluation."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# visualisation variables\ntrain_accuracies = []\nvalidation_accuracies = []\nx_range = []\n\ndisplay_step=1\n\nfor i in range(TRAINING_ITERATIONS):\n\n    #get new batch\n    batch_xs, batch_ys = next_batch(BATCH_SIZE)        \n\n    # check progress on every 1st,2nd,...,10th,20th,...,100th... step\n    if i%display_step == 0 or (i+1) == TRAINING_ITERATIONS:\n        \n        train_accuracy = accuracy.eval(feed_dict={x:batch_xs, \n                                                  y_: batch_ys, \n                                                  keep_prob: 1.0})       \n        if(VALIDATION_SIZE):\n            validation_accuracy = accuracy.eval(feed_dict={ x: validation_images[0:BATCH_SIZE], \n                                                            y_: validation_labels[0:BATCH_SIZE], \n                                                            keep_prob: 1.0})                                  \n            print('training_accuracy / validation_accuracy => %.2f / %.2f for step %d'%(train_accuracy, validation_accuracy, i))\n            \n            validation_accuracies.append(validation_accuracy)\n            \n        else:\n             print('training_accuracy => %.4f for step %d'%(train_accuracy, i))\n        train_accuracies.append(train_accuracy)\n        x_range.append(i)\n        \n        # increase display_step\n        if i%(display_step*10) == 0 and i:\n            display_step *= 10\n    # train on batch\n    sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys, keep_prob: DROPOUT})"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "After training is done, it's good to check accuracy on data that wasn't used in training."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# check final accuracy on validation set  \nif(VALIDATION_SIZE):\n    validation_accuracy = accuracy.eval(feed_dict={x: validation_images, \n                                                   y_: validation_labels, \n                                                   keep_prob: 1.0})\n    print('validation_accuracy => %.4f'%validation_accuracy)\n    plt.plot(x_range, train_accuracies,'-b', label='Training')\n    plt.plot(x_range, validation_accuracies,'-g', label='Validation')\n    plt.legend(loc='lower right', frameon=False)\n    plt.ylim(ymax = 1.1, ymin = 0.7)\n    plt.ylabel('accuracy')\n    plt.xlabel('step')\n    plt.show()"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "When, we're happy with the outcome, we read test data from *test.csv* and predict labels for provided images.\n\nTest data contains only images and labels are missing. Otherwise, the structure is similar to training data.\n\nPredicted labels are stored into CSV file for future submission."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "# read test data from CSV file \ntest_images = pd.read_csv('../input/test.csv').values\ntest_images = test_images.astype(np.float)\n\n# convert from [0:255] => [0.0:1.0]\ntest_images = np.multiply(test_images, 1.0 / 255.0)\n\nprint('test_images({0[0]},{0[1]})'.format(test_images.shape))\n\n\n# predict test set\n#predicted_lables = predict.eval(feed_dict={x: test_images, keep_prob: 1.0})\n\n# using batches is more resource efficient\npredicted_lables = np.zeros(test_images.shape[0])\nfor i in range(0,test_images.shape[0]//BATCH_SIZE):\n    predicted_lables[i*BATCH_SIZE : (i+1)*BATCH_SIZE] = predict.eval(feed_dict={x: test_images[i*BATCH_SIZE : (i+1)*BATCH_SIZE], \n                                                                                keep_prob: 1.0})\n\n\nprint('predicted_lables({0})'.format(len(predicted_lables)))\n\n# output test image and prediction\ndisplay(test_images[IMAGE_TO_DISPLAY])\nprint ('predicted_lables[{0}] => {1}'.format(IMAGE_TO_DISPLAY,predicted_lables[IMAGE_TO_DISPLAY]))\n\n# save results\nnp.savetxt('submission_softmax.csv', \n           np.c_[range(1,len(test_images)+1),predicted_lables], \n           delimiter=',', \n           header = 'ImageId,Label', \n           comments = '', \n           fmt='%d')"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "## Appendix\nAs it was mentioned before, it is good to output some variables for a better understanding of the process. \n\nHere we pull an output of the first convolution layer from TensorFlow graph. 32 features are transformed into an image grid, and it's quite interesting to see how filters picked by NN outline characteristics of different digits."
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "layer1_grid = layer1.eval(feed_dict={x: test_images[IMAGE_TO_DISPLAY:IMAGE_TO_DISPLAY+1], keep_prob: 1.0})\nplt.axis('off')\nplt.imshow(layer1_grid[0], cmap=cm.seismic )"
 },
 {
  "cell_type": "code",
  "execution_count": null,
  "metadata": {
   "collapsed": false
  },
  "outputs": [],
  "source": "sess.close()"
 },
 {
  "cell_type": "markdown",
  "metadata": {},
  "source": "## Reference\n- [Deep MNIST for Experts](https://www.tensorflow.org/versions/master/tutorials/mnist/pros/index.html#deep-mnist-for-experts)\n- [A Convolutional Network implementation example using TensorFlow library](https://github.com/aymericdamien/TensorFlow-Examples/blob/master/notebooks/3%20-%20Neural%20Networks/convolutional_network.ipynb)\n- [Digit recognizer in Python using CNN](https://www.kaggle.com/kobakhit/digit-recognizer/digit-recognizer-in-python-using-cnn)\n- [Deep Learning in a Nutshell: Core Concepts](http://devblogs.nvidia.com/parallelforall/deep-learning-nutshell-core-concepts/)"
 }
],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"}}, "nbformat": 4, "nbformat_minor": 0}