Tensorflow Example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Resources\n",
    "\n",
    "* [Beginnner tutorial](https://www.tensorflow.org/get_started/mnist/beginners)\n",
    "* Convolutional networks in TF: [overview of CNNs and how they work in TF](https://www.tensorflow.org/tutorials/layers) and [short version](https://www.tensorflow.org/get_started/mnist/pros)\n",
    "* [ConvNetJS](https://cs.stanford.edu/people/karpathy/convnetjs/demo/mnist.html): good for visualising weights. The network configuration is pasted below\n",
    "* [FastAI Course](http://course.fast.ai/): Not Tensorflow (uses Theano and Keras)\n",
    "\n",
    "NB: I installed TensorFlow with pip in a virtualenv on OSX; I had problems with `protobuf` and had to remove it from the pip virtualenv and use Homebrew to install it instead. To make Homebrew packages available in the virtualenv install, put the `.pth` file the `protobuf` brew recipe generates in the `site-packages` directory of the virtual environment.\n",
    "\n",
    "ConvnetJS settings for the CNN defined below:\n",
    "\n",
    "    layer_defs = [];\n",
    "    layer_defs.push({type:'input', out_sx:24, out_sy:24, out_depth:1});\n",
    "    layer_defs.push({type:'conv', sx:5, filters:32, stride:1, pad:2, activation:'relu'});\n",
    "    layer_defs.push({type:'pool', sx:2, stride:2});\n",
    "    layer_defs.push({type:'conv', sx:5, filters:64, stride:1, pad:2, activation:'relu'});\n",
    "    layer_defs.push({type:'pool', sx:2, stride:2});\n",
    "    layer_defs.push({type:'softmax', num_classes:10});\n",
    "\n",
    "    net = new convnetjs.Net();\n",
    "    net.makeLayers(layer_defs);\n",
    "\n",
    "    trainer = new convnetjs.SGDTrainer(net, {method:'adadelta', batch_size:20, l2_decay:0.001});\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic softmax regression\n",
    "\n",
    "From [this guide in the TensorFlow docs](https://www.tensorflow.org/get_started/mnist/pros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loading the data, already partitioned into training and test sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting MNIST_data/train-images-idx3-ubyte.gz\n",
      "Extracting MNIST_data/train-labels-idx1-ubyte.gz\n",
      "Extracting MNIST_data/t10k-images-idx3-ubyte.gz\n",
      "Extracting MNIST_data/t10k-labels-idx1-ubyte.gz\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "mnist = input_data.read_data_sets('MNIST_data', one_hot=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "sess = tf.InteractiveSession()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We flatten the 28x28 images into a 784 element vector with greyscale pixel values and regress that to a 10-element vector where each element has a probability of class membership assigned to it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = tf.placeholder(tf.float32, shape=[None, 784])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "y_ = tf.placeholder(tf.float32, shape=[None, 10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "W = tf.Variable(tf.zeros([784,10]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b = tf.Variable(tf.zeros([10]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sess.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "y = tf.matmul(x,W) + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_,logits=y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for _ in range(100):\n",
    "    batch = mnist.train.next_batch(100)\n",
    "    train_step.run(feed_dict={x:batch[0],y_:batch[1]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "correct = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "accuracy = tf.reduce_mean(tf.cast(correct,tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8856\n"
     ]
    }
   ],
   "source": [
    "print(accuracy.eval(feed_dict={x:mnist.test.images,y_: mnist.test.labels}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Convolutional Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def weight_variable(shape):\n",
    "    initial = tf.truncated_normal(shape,stddev=0.1)\n",
    "    return tf.Variable(initial)\n",
    "\n",
    "def bias_variable(shape):\n",
    "    initial = tf.constant(0.1, shape=shape)\n",
    "    return tf.Variable(initial)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "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')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Layer 1: 5x5 convolution, 32 output layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "W_conv1 = weight_variable([5,5,1,32])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b_conv1 = bias_variable([32])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x_image = tf.reshape(x,[-1,28,28,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This gives us 32 28x28 images for a single example. We shrink that by pooling adjacent cells into 32 smaller 14x14 images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "h_pool1 = max_pool_2x2(h_conv1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Layer 2: 5x5 convolution, 64 output layers, 14x14 outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "W_conv2 = weight_variable([5,5,32,64])\n",
    "b_conv2 = bias_variable([64])\n",
    "h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)\n",
    "h_pool2 = max_pool_2x2(h_conv2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again we shrink this down, giving us 64 7x7 images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we lay the images out into a long vector of 3136 values and map them to 1024 values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "W_fc1 = weight_variable([7*7*64, 1024])\n",
    "b_fc1 = bias_variable([1024])\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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We add dropout for scalablility (also good for overfitting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "keep_prob = tf.placeholder(tf.float32)\n",
    "h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we go from 1024 values to 10 - these 10 are our labels so we'll have a vector of class probabilities (eventually)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "W_fc2 = weight_variable([1024,10])\n",
    "b_fc2 = bias_variable([10])\n",
    "y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to minimise the difference between the predicted outputs and the actual outputs, using softmax ($\\mathrm{arg} \\max \\frac{e^x}{\\sum_{x' \\in X}e^{x'}}$)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The optimiser uses gradients which are magically computed from the graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're minimising loss which is abstract, so we calculate the accuracy (mean proportion of predicted == value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sess.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loading and training is handled by the `mnist` package - presumably it's straight forward to implement an iterator for your own data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 0 Training accuracy is 0.04\n",
      "Step 100 Training accuracy is 0.86\n",
      "Step 200 Training accuracy is 1\n",
      "Step 300 Training accuracy is 0.92\n",
      "Step 400 Training accuracy is 0.94\n",
      "Step 500 Training accuracy is 0.94\n",
      "Step 600 Training accuracy is 0.96\n",
      "Step 700 Training accuracy is 0.96\n",
      "Step 800 Training accuracy is 0.92\n",
      "Step 900 Training accuracy is 0.92\n",
      "Test Accuracy:0.9635\n"
     ]
    }
   ],
   "source": [
    "for i in range(1000):\n",
    "    batch = mnist.train.next_batch(50)\n",
    "    if i % 100 == 0:\n",
    "        train_accuracy = accuracy.eval(feed_dict ={x:batch[0],y_:batch[1],keep_prob:1.0})\n",
    "        print(\"Step %d Training accuracy is %g\"%(i,train_accuracy))\n",
    "    train_step.run(feed_dict={x:batch[0],y_:batch[1],keep_prob:0.5})\n",
    "\n",
    "print(\"Test Accuracy:%g\"%accuracy.eval(feed_dict={x:mnist.test.images,y_:mnist.test.labels,keep_prob:1.0}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy:0.9635\n"
     ]
    }
   ],
   "source": [
    "print(\"Test Accuracy:%g\"%accuracy.eval(feed_dict={x:mnist.test.images,y_:mnist.test.labels,keep_prob:1.0}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"<tf.Variable 'Variable_8:0' shape=(1024, 10) dtype=float32_ref>\""
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(W_fc2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<tf.Variable 'Variable:0' shape=(784, 10) dtype=float32_ref>,\n",
       " <tf.Variable 'Variable_1:0' shape=(10,) dtype=float32_ref>,\n",
       " <tf.Variable 'Variable_2:0' shape=(5, 5, 1, 32) dtype=float32_ref>,\n",
       " <tf.Variable 'Variable_3:0' shape=(32,) dtype=float32_ref>,\n",
       " <tf.Variable 'Variable_4:0' shape=(5, 5, 32, 64) dtype=float32_ref>,\n",
       " <tf.Variable 'Variable_5:0' shape=(64,) dtype=float32_ref>,\n",
       " <tf.Variable 'Variable_6:0' shape=(3136, 1024) dtype=float32_ref>,\n",
       " <tf.Variable 'Variable_7:0' shape=(1024,) dtype=float32_ref>,\n",
       " <tf.Variable 'Variable_8:0' shape=(1024, 10) dtype=float32_ref>,\n",
       " <tf.Variable 'Variable_9:0' shape=(10,) dtype=float32_ref>]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.trainable_variables()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the `run` function of the session to evaluate a variable and get its contents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "weights_c1 = sess.run(W_conv1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 5, 1, 32)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weights_c1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.060706105"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weights_c1[(4,4,0,4)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAxYWsB5J+a1mf7cGlyRJkiRJkiQpvP8DIQyJrT7jMr0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114e0d250>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10eb94290>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nNbgkSZIkSZIkSfH9H1k6YpB7EkzYAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114f12790>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nuTW4JEmSJEmSJEnx/R+fCmVVY1qqaAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10eb30650>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nlyRJkiRJkiQpvv8DL5yQF4NhbD8AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114e8ce10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114e55b50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x104387890>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114e06cd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114e8ccd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10ec15ed0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nLg0uSZIkSZIkSVJ8/wdb9JwLxtaJugAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114f43a90>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nqZYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11089ef10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nlvvavNmwAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114f12790>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114e39a10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nNlLcPZMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114c7f210>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nhfc/+xx5cNe7FqsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x115001e50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114e65210>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114f54dd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nuDS4JEmSJEmSJEnx/R+YwJ9wpLpmqQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114e06cd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAACzdJREFUeJzt3W1sXXUdwPFvt24MMgWRh8EeLIJTQMIYaGBOd0FBRMCo\nMUoCGl4obwhEDBpNlM6oEKOCBiWGDcKD4AsgwIaGCO4OFnQBaeNgA8fDEKbbDIPpHCjS+uJ/u3al\n7T1nPafn3l+/n+Sm5d7D6S+Eb8/DPT0XJEmSJEmSJEmSJEmSstkEfLTqIYaZBdwLbAb6gHnDXp8N\n3AO8DLwIXDSh0wmAKVUPoDH1Nx5V6RzhuT7gN8BnR/l3bgWeBQ4BPgn8AKiVMZzUrp4HThvh+QOA\nlcA2YDuwgrSlBPgc8Niw5S8D7m58vw/wI+AFYAtwHTCj8VoNeAn4OvB34KYxZuvkrVvsmY3nDhry\n3C+Bm8dYj0rgFrs9TQGWk6KaB7wGXNt47V7gCOB9Q5a/gMFIrwKOAo5vfJ0NfGfIsocC72isN+9u\ndMewrwOzvj/neqTQRttiD7eAtOUecB3wvcb3xzZem0YKbifw7iHLngI81/i+BvwHmJ7hZ460xQZ4\nGPgZac9gIelYe0OG9UmTxmhh70faxd0E7Gg83mRwS3kyg7FeRQod0nFvH/DKkMerwD8br9dIu+JZ\njBb2PNKhwTbgD8BPgQcyrlOaFEYL+9vAKlKokLbYfex5aPUU8BHSsfSixnNTgH8Dh43y82qkM9lZ\njBb2cLcB38+4ThXEY+zWN510cmvg0Uk6SfUaaUt9IHDFCP/eLaTj7v8CjzSe6wOuB64BDm48Nxs4\nI+dMA7MM/x7Ssf3bGnOfD5wO/CTn+qXQnifFOPTxXdIWdxXwL9KW+SukXfGhv6jnNZ4bHv0+pC3o\ns6RfDOuBixuv1YC/ZphrYJY3h3wdcClpN3wn8BDpOFtSQfYlHTsfWfUgkopzGZ60Uos5k7SLuRH4\nRsWzZHEDsBVYV/UgDZtIu/HHj7HMXNLu/JPAE8Al5Y81LjOAtUAv6fDhymrHyWUq0EN6t2DSmgo8\nA3SR3nvtBY6ucqAMPgycQOuEncUs0tl0SCfjnqb1/zvv1/jaCfwRWFzhLHlcBvyKdPHQhGjFs+If\nJIW9CXgD+DXwqSoHyuBh0nvC7WQL6ZcmpBNdG4DDqxsnk12Nr9NJG4DtYyzbKuYAZwHL2POKvFK1\nYtiz2fO91JcYvA5a5egi7XGsrXiOZqaQfhltJR1GrK92nEyuBi4nvXswYVox7Cr/mmkymgncQXqb\namfFszTTRzp8mEO6+KZW6TTNnU1666+HCdxaQ2uGvZl0YmfAXLJf5qh8pgF3kv7U8u4my7aSHcB9\nwElVD9LEIuBc0onM20lXEU7av3TrJF080UU6lmqHk2eQ5m2nk2cdpP/Jrq56kIwOIv25KqT36B+i\n9W5CMZYlTPKz4gCfIJ2lfQb4ZsWzZHE78DfSX0a9CFxY7TiZLCbt2vaSdhV7SG8ztqrjgMdJ8/6Z\ndNzaTpYwgWfFJUmSJEmSJEmaPMZ9NcxRSw7tf2b11iJmkZTbu4AX3tJxEZe59f+i/0sFrOatVnb3\ncnb3guYL5vQgHyt8nQDru+/imO7PlLLuO9eeX8p6ub4bvtxdyqqvOLmcqyjrlHct6dIR7zI1XnXK\nnJgROm7FS0oljZNhSwG1dNjza7OqHiGXg2vtcEn7MAtrVU+QW1fVA+TWNeE/0bAL1JZhn1ireoLc\nuqoeILeuCf+JLR22pL1j2FJAhi0FZNhSQIYtBWTYUkCGLQVk2FJAhi0FZNhSQIYtBWTYUkBZwm63\nz6qWJr1mYU8FriXFfQxwHu3xcTvSpNYs7Hb8rGpp0msWtp9VLbWhziavZ/qs6pXdvbu/n1+b1XY3\nSJDax6bGY2zNws70WdVl3ElU0ki62POOLKtHXKrZrvhjwHsY/Kzqz+NHgUotr9kW+3/AxcD9pDPk\ny4ENZQ8laXyahQ3w28ZDUpvwyjMpIMOWAjJsKSDDlgIybCkgw5YCMmwpIMOWAjJsKSDDlgIybCkg\nw5YCMmwpIMOWAjJsKSDDlgIybCmgjgLW0c+aTDczbR2vVz1Afvsv3lL1CLm9euFhVY+Q2/zbepsv\n1EI2diyAETp2iy0FZNhSQIYtBWTYUkCGLQVk2FJAhi0FZNhSQIYtBWTYUkCGLQVk2FJAhi0FZNhS\nQIYtBWTYUkCGLQWUJewbgK3AupJnkVSQLGHfCJxZ9iCSipMl7IeBV8oeRFJxPMaWAjJsKaDOQtay\nvHvw+xNqsLBWyGol7WlX/VFeqz/WdLms9xXvAlYAx43wmvcVnwDeV3xiTKb7it8OPALMB14ELix0\nMkmFy7Irfl7pU0gqlCfPpIAMWwrIsKWADFsKyLClgAxbCsiwpYAMWwrIsKWADFsKyLClgAxbCsiw\npYAMWwrIsKWADFsKyLClgAxbCqiQu5QeePLmIlYzYbZ3rqp6hNxe/fQFVY+Q28q7Tqt6hNw+zv1V\nj5DLxlGed4stBWTYUkCGLQVk2FJAhi0FZNhSQIYtBWTYUkCGLQVk2FJAhi0FZNhSQIYtBWTYUkCG\nLQVk2FJAhi0FlCXsucAq4EngCeCSUieSNG5Zbo30BvBVoBeYCfwJ+B2wocS5JI1Dli32FlLUADtJ\nQR9e2kSSxi3vMXYXcAKwtvhRJBUlz11KZwJ3AJeStty77Vr6493fT1tyCtNqiwoZTtKeXqo/y+b6\nc02Xyxr2NOBO4Fbg7uEv7nfF13INJ2nvzKkdyZzakbv/+dGlD4y4XJZd8Q5gObAeuKaI4SSVK0vY\nHwLOB04FehqPM8scStL4ZNkVX4MXskhtxWClgAxbCsiwpYAMWwrIsKWADFsKyLClgAxbCsiwpYAM\nWwrIsKWADFsKyLClgAxbCsiwpYAMWwrIsKWA8tyldFQvL5tTxGomzJr+hVWPkN/RVQ+Q3zkdP6x6\nhNz6151U9Qi5XDvK826xpYAMWwrIsKWADFsKyLClgAxbCsiwpYAMWwrIsKWADFsKyLClgAxbCsiw\npYAMWwrIsKWADFsKyLClgAxbCihL2DOAtUAvsB64stSJJI1blnuevQ6cCuxqLL8GWNz4KqkFZd0V\n39X4Oh2YCmwvZxxJRcga9hTSrvhWYBVpl1xSi8p6++E+YAGwP3A/UAPqAy92rxhcsDYfau8tajxJ\nQ9UfTY9m8t5XfAdwH3ASQ8M+J+daJO2V2gfSY8DS60ZeLsuu+EHAAY3v9wVOB3rGNZ2kUmXZYh8G\n3ET6JTAFuAV4sMyhJI1PlrDXAW34mTjS5OWVZ1JAhi0FZNhSQIYtBWTYUkCGLQVk2FJAhi0FZNhS\nQIYtBWTYUkCGLQVk2FJAhi0FZNhSQIYtBWTYUkB5b2Y4oo4H+otYzYQ546J7qh4ht3dueLnqEfL7\n+YlVT5DfjqoHKIZbbCkgw5YCMmwpIMOWAjJsKSDDlgIybCkgw5YCMmwpIMOWAjJsKSDDlgIybCkg\nw5YCMmwpIMOWAjJsKaCsYU8FeoAVJc4iqSBZw74UWA+01z2QpEkqS9hzgLOAZUBHueNIKkKWsK8G\nLgf6Sp5FUkGa3aX0bGAb6fi6NupST3YPfn9wDQ4ZfVFJe6/+ONR7mi/XLOxFwLmkXfEZwNuBm4Ev\n7rHUsd17MaKkvGoL02PA0htHXq7Zrvi3gLnAEcAXgN8zPGpJLSfv+9ieFZfaQJ5PAlndeEhqcV55\nJgVk2FJAhi0FZNhSQIYtBWTYUkCGLQVk2FJAhi0FZNhSQIYtBWTYUkCGLQVk2FJArR32tnrVE+Sy\nvb6u6hFy21p/quoR8vtLveoJcqk/PvE/s7XD/ke96gly2V5/ouoRcttWf7rqEfLbWK96glyy3KOs\naK0dtqS9YthSQEV8AEAdWFLAeiTlt5qxbg0uSZIkSZIkSVJ4/wfl153L/4keoAAAAABJRU5ErkJg\ngg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10dba1dd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nmF/CfiQVt5w9vDW4JEmSJEmSJEnx/Q/GI5DgIB1stQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x104387890>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114c9b850>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAACyZJREFUeJzt3X2MHHUdgPHn2isUUpAaBKE90lYEKjSAqQYQ7FLFVOQl\nxBDEiIZ/NCYEIgZFjLL1JWDQgIaEKG/yooiB8CYSItCrbZBG8BoKrby11aNIMQGLiC9Azz9+c9z1\nenc7w83c7H7v+SSTXW4m0y+EpzM7O7cLkiRJkiRJkiRJkiRJ+WwGPlb3ECN8ClgNvAL8DbgamDVs\n/Q+Bp4FXgQ3AWZM9oGBa3QNoXAPZUpfuUX62J/AdYD9gITAHuGzY+teAk7LtvgD8GDi62jGlzrIJ\nWDrKz/cCfgO8BLwM3EMKDOB04NER258P3Jk935V0VP0L8CJwFTAzW9cAnge+Rjoa35BjxtOAx8dZ\nf1f252sSecTuTNOAa4EDsuXfwJXZuruB+cAhw7Y/i6FILwUOBA7PHucA3x627b7A7Gy/X8oxyxLg\niTHW7QZ8aJz10pQ01hF7pCNIR+5BVwHfy54fmq2bAXSRTpUXDNv2aGBj9rwB/BfYJed8J2T7PnCM\n9TcAv825L2nKGCvs3YGfki6ubcuWt0jhAhzFUKyXkkIH2AfYTrrwNbj8g3ShC4ZOxfM4ivRS4Pgx\n1l8G/JEdL6xJYuywvwWsIIUK6Yi9nR1fWv0Z+CjptfQx2c+mAf8iXfgaTQPozzHXkcBW4MQx1i8n\nve6enWNf0pSzCVhGurg1uHQDPyCd4u4KvBu4g53D/iYprmdG7PMK4FbgPdk/zwE+kT1v0Drsw0hR\nnz7G+m+Q3u7at8V+pClrEynY4cvgW00rgH+SjsxfJJ2KDw/7gOxnF4/Y567A94HnSKfw64FzsnUN\n4K8tZroOeDP7sweXdcPWbyddzBu+/sLW/6qS8tiN9Nr5fXUPIqk85wMP1D2ENNwy0inmM8DXa54l\nj+tIrzvXtdpwkmwmncYfPs42PaTT+SdJ7zOfW/1YEzITWAOsJb18uKTecQqZDvSRbiSasqYDzwLz\nSO+9riXdutjOjiNdKW6XsPN4L+lqOqS3pJ6i/f877549dgOPAMfWOEsR5wO/IN08NCna8c6zD5PC\n3gy8AfwKOLXOgXJYRXpPuJO8SPpLE9JNKxuA/esbJ5fXs8ddSAeAl8fZtl3MJb0teA1D9xlUrh3D\nnsOOb7k8z9B90KrGPNIZx5qa52hlGukvo62klxHr6x0nl8uBC0jvFkyadgy7zt9mmopmAbcB55GO\n3O1sO+nlw1zSzTeNWqdp7STS3Xl9TOLRGtoz7C2kCzuDesh/m6OKmQHcDtzM0G9/dYJtwL3A4roH\naeEY4BTShcxbSHcR3ljrRDXqJt08MY/0WqoTLp5BmreTLp51kf4nu7zuQXLam/TrqpDeo/897fch\nFONZwhS/Kg7wSdJV2mdJtyi2u1uAF0i/GdUPnF3vOLkcSzq1XUs6Vewjvc3YrhYBfyLN+zjpdWsn\nWcIkXhWXJEmSJEmSJGnqmPjdMLOWDPDayhJGkVTUnCXz2LJy804dl3Gb2wCLK7oLdEsT5jTL329V\nn+dxaxPOaFay659/+oxK9ntH8wlOax5Wyb7fYnol+72ruY5Tm4sq2fc6yt/vH5oPcHTz46XvF+CK\nrotglI7b8ZZSSRNk2FJA7R32Ho26Jyjm0EbdExR2SGOf1hu1mYM7bOa5jQWtNypZe4e9Z6PuCYo5\nrFH3BIUt7LBIAA5pdNYnG/cYtqQyGLYUkGFLARm2FJBhSwEZthSQYUsBGbYUkGFLARm2FJBhSwEZ\nthRQnrA77buqpSmvVdjTgStJcX8AOJPO+LodaUprFXYnfle1NOW1CtvvqpY6UHeL9fk+pXBLc+j5\nHo3O+4AEqUP0927k+d6NLbdrFXa+76qu4pNEJe2kp7Fgh09kWbP8oVG3a3Uq/ijwfoa+q/oM/CpQ\nqe21OmK/CZwD3E+6Qn4tsKHqoSRNTKuwAe7LFkkdwjvPpIAMWwrIsKWADFsKyLClgAxbCsiwpYAM\nWwrIsKWADFsKyLClgAxbCsiwpYAMWwrIsKWADFsKyLClgLpK2MfA0oF7StjN5Hnw7pPrHqG4c+oe\noLir+1tv024+XvcABWUfa7hTxx6xpYAMWwrIsKWADFsKyLClgAxbCsiwpYAMWwrIsKWADFsKyLCl\ngAxbCsiwpYAMWwrIsKWADFsKyLClgPKEfR2wFVhX8SySSpIn7OuBZVUPIqk8ecJeBbxS9SCSyuNr\nbCkgw5YC6i5jJxubv3z7+ezGImY3FpWxW0kjPJItrZQS9oLmZ8vYjaQWjsqWQT8ZY7s8p+K3AA8D\nBwH9wNkTG01S1fIcsc+sfApJpfLimRSQYUsBGbYUkGFLARm2FJBhSwEZthSQYUsBGbYUkGFLARm2\nFJBhSwEZthSQYUsBGbYUkGFLARm2FJBhSwF1lbCPgYtL2MlkWjywtO4RCju569d1j1DY5oGFdY9Q\nWH/X3+seoZDj0sNOHXvElgIybCkgw5YCMmwpIMOWAjJsKSDDlgIybCkgw5YCMmwpIMOWAjJsKSDD\nlgIybCkgw5YCMmwpIMOWAsoTdg+wAngSeAI4t9KJJE1Yd45t3gC+AqwFZgGPAb8DNlQ4l6QJyHPE\nfpEUNcBrpKD3r2wiSRNW9DX2POBIYE35o0gqS55T8UGzgNuA80hH7rf1Dns+L1skla8vW1rJG/YM\n4HbgZuDOkSsbuceSNBFHZsug68fYLs+peBdwLbAeuGKCc0maBHnC/gjwOeB4hs4EllU5lKSJyXMq\nvhpvZJE6isFKARm2FJBhSwEZthSQYUsBGbYUkGFLARm2FJBhSwEZthSQYUsBGbYUkGFLARm2FJBh\nSwEZthSQYUsBdZWwjwH4WQm7mTzfHXiq7hEKm9H1o7pHKOxCLq57hMIGblpe9wiFdJ2VHkb+3CO2\nFJBhSwEZthSQYUsBGbYUkGFLARm2FJBhSwEZthSQYUsBGbYUkGFLARm2FJBhSwEZthSQYUsBGbYU\nkGFLAeUJeyawBlgLrAcuqXQiSRPWnWOb/wDHA69n268Gjs0eJbWhvKfir2ePuwDTgZerGUdSGfKG\nPY10Kr4VWEE6JZfUpvKcigNsB44A3gXcDzSA3qHVdw/b9OBskVS23g1paSVv2IO2AfcCi9kh7FMK\n7kbSO9FYmJZBy+8Yfbs8p+J7A3tlz3cDTgD6JjSdpErlOWLvB9xA+ktgGnAT8GCVQ0mamDxhrwM+\nWPUgksrjnWdSQIYtBWTYUkCGLQVk2FJAhi0FZNhSQIYtBWTYUkCGLQVk2FJAhi0FZNhSQIYtBWTY\nUkCGLQVk2FJART/McFRfHdhaxm4mzXGsqnuEwh4b+HLdIxT2v23L6x6hsK6bB+oeoaCuUX/qEVsK\nyLClgAxbCsiwpYAMWwrIsKWADFsKyLClgAxbCsiwpYAMWwrIsKWADFsKyLClgAxbCsiwpYAMWwoo\nb9jTgT7gngpnkVSSvGGfB6wHOu1zY6QpKU/Yc4ETgWsY6wOWJLWVPGFfDlwAbK94FkklafUppScB\nL5FeXzfG2ujh5kNvP+9pzKenMb+M2SSN9HQvPNPbcrNWYR8DnEI6FZ8J7AncCHx+h42aS9/JiJKK\nOqiRlkH3jf4Rz61OxS8CeoD5wGeAhxgRtaT2U/R9bK+KSx2gyDeBrMwWSW3OO8+kgAxbCsiwpYAM\nWwrIsKWADFsKyLClgAxbCsiwpYAMWwrIsKWADFsKyLClgAxbCqitw+7v3VT3CIX09b5a9wiFPdu7\npe4RClu5qu4JCnq6d9L/SMMu0doODPu53hfqHqGwlavrnqCgHJ9RVra2DlvSO2PYUkBlfAFAL7Ck\nhP1IKm4l43w0uCRJkiRJkiRJ8f0fLY+ZAKJmrkAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114e65210>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114e52f50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114c93e10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nJEmSJEmS4vs/jImG9YBhko0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114e0d250>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114f43a90>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nBJUpbKgYNgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114e39a10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11089e650>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n6tbgkiRJkiRJkiSF93+o5nhTTTQhZQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114c42750>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10eccdb10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAEHCAYAAACdq7vAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114e52f50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline \n",
    "#plt.figure(1)\n",
    "\n",
    "for layer in range(0,32):\n",
    "#    plt.subplot(211 + layer)\n",
    "    plt.matshow(weights_c1[:,:,0,layer])\n",
    "    plt.title(\"Layer %d\"%(layer))\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method run in module tensorflow.python.client.session:\n",
      "\n",
      "run(self, fetches, feed_dict=None, options=None, run_metadata=None) method of tensorflow.python.client.session.InteractiveSession instance\n",
      "    Runs operations and evaluates tensors in `fetches`.\n",
      "    \n",
      "    This method runs one \"step\" of TensorFlow computation, by\n",
      "    running the necessary graph fragment to execute every `Operation`\n",
      "    and evaluate every `Tensor` in `fetches`, substituting the values in\n",
      "    `feed_dict` for the corresponding input values.\n",
      "    \n",
      "    The `fetches` argument may be a single graph element, or an arbitrarily\n",
      "    nested list, tuple, namedtuple, dict, or OrderedDict containing graph\n",
      "    elements at its leaves.  A graph element can be one of the following types:\n",
      "    \n",
      "    * An @{tf.Operation}.\n",
      "      The corresponding fetched value will be `None`.\n",
      "    * A @{tf.Tensor}.\n",
      "      The corresponding fetched value will be a numpy ndarray containing the\n",
      "      value of that tensor.\n",
      "    * A @{tf.SparseTensor}.\n",
      "      The corresponding fetched value will be a\n",
      "      @{tf.SparseTensorValue}\n",
      "      containing the value of that sparse tensor.\n",
      "    * A `get_tensor_handle` op.  The corresponding fetched value will be a\n",
      "      numpy ndarray containing the handle of that tensor.\n",
      "    * A `string` which is the name of a tensor or operation in the graph.\n",
      "    \n",
      "    The value returned by `run()` has the same shape as the `fetches` argument,\n",
      "    where the leaves are replaced by the corresponding values returned by\n",
      "    TensorFlow.\n",
      "    \n",
      "    Example:\n",
      "    \n",
      "    ```python\n",
      "       a = tf.constant([10, 20])\n",
      "       b = tf.constant([1.0, 2.0])\n",
      "       # 'fetches' can be a singleton\n",
      "       v = session.run(a)\n",
      "       # v is the numpy array [10, 20]\n",
      "       # 'fetches' can be a list.\n",
      "       v = session.run([a, b])\n",
      "       # v is a Python list with 2 numpy arrays: the 1-D array [10, 20] and the\n",
      "       # 1-D array [1.0, 2.0]\n",
      "       # 'fetches' can be arbitrary lists, tuples, namedtuple, dicts:\n",
      "       MyData = collections.namedtuple('MyData', ['a', 'b'])\n",
      "       v = session.run({'k1': MyData(a, b), 'k2': [b, a]})\n",
      "       # v is a dict with\n",
      "       # v['k1'] is a MyData namedtuple with 'a' (the numpy array [10, 20]) and\n",
      "       # 'b' (the numpy array [1.0, 2.0])\n",
      "       # v['k2'] is a list with the numpy array [1.0, 2.0] and the numpy array\n",
      "       # [10, 20].\n",
      "    ```\n",
      "    \n",
      "    The optional `feed_dict` argument allows the caller to override\n",
      "    the value of tensors in the graph. Each key in `feed_dict` can be\n",
      "    one of the following types:\n",
      "    \n",
      "    * If the key is a @{tf.Tensor}, the\n",
      "      value may be a Python scalar, string, list, or numpy ndarray\n",
      "      that can be converted to the same `dtype` as that\n",
      "      tensor. Additionally, if the key is a\n",
      "      @{tf.placeholder}, the shape of\n",
      "      the value will be checked for compatibility with the placeholder.\n",
      "    * If the key is a\n",
      "      @{tf.SparseTensor},\n",
      "      the value should be a\n",
      "      @{tf.SparseTensorValue}.\n",
      "    * If the key is a nested tuple of `Tensor`s or `SparseTensor`s, the value\n",
      "      should be a nested tuple with the same structure that maps to their\n",
      "      corresponding values as above.\n",
      "    \n",
      "    Each value in `feed_dict` must be convertible to a numpy array of the dtype\n",
      "    of the corresponding key.\n",
      "    \n",
      "    The optional `options` argument expects a [`RunOptions`] proto. The options\n",
      "    allow controlling the behavior of this particular step (e.g. turning tracing\n",
      "    on).\n",
      "    \n",
      "    The optional `run_metadata` argument expects a [`RunMetadata`] proto. When\n",
      "    appropriate, the non-Tensor output of this step will be collected there. For\n",
      "    example, when users turn on tracing in `options`, the profiled info will be\n",
      "    collected into this argument and passed back.\n",
      "    \n",
      "    Args:\n",
      "      fetches: A single graph element, a list of graph elements,\n",
      "        or a dictionary whose values are graph elements or lists of graph\n",
      "        elements (described above).\n",
      "      feed_dict: A dictionary that maps graph elements to values\n",
      "        (described above).\n",
      "      options: A [`RunOptions`] protocol buffer\n",
      "      run_metadata: A [`RunMetadata`] protocol buffer\n",
      "    \n",
      "    Returns:\n",
      "      Either a single value if `fetches` is a single graph element, or\n",
      "      a list of values if `fetches` is a list, or a dictionary with the\n",
      "      same keys as `fetches` if that is a dictionary (described above).\n",
      "    \n",
      "    Raises:\n",
      "      RuntimeError: If this `Session` is in an invalid state (e.g. has been\n",
      "        closed).\n",
      "      TypeError: If `fetches` or `feed_dict` keys are of an inappropriate type.\n",
      "      ValueError: If `fetches` or `feed_dict` keys are invalid or refer to a\n",
      "        `Tensor` that doesn't exist.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sess.run)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 2
}