17-5-17-DL-Tute-Tensorflow-MNIST.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 1 Loading independices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf # Call tensorflow which is used for running datasets, construct, train and evaluation results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "? input_data\n",
    "#mnist = input_data.read_data_sets(\"MNIST_data/\", one_hot=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 2 Loading  3 data sets, Training, Test, Validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MNIST training number of training datasets: 55000\n",
      "MNIST training number of labels: 55000\n",
      "MNIST validation number of datasets: 5000\n",
      "MNIST validation number of labels: 5000\n",
      "MNIST test number of training data: 10000\n",
      "MNIST test number of labels: 10000\n",
      "MNIST training data set pixel size 784\n"
     ]
    }
   ],
   "source": [
    "print(\"MNIST training number of training datasets:\", len(mnist.train.images))\n",
    "print(\"MNIST training number of labels:\", len(mnist.train.labels))\n",
    "print(\"MNIST validation number of datasets:\", len(mnist.validation.images))\n",
    "print(\"MNIST validation number of labels:\", len(mnist.validation.labels))\n",
    "print(\"MNIST test number of training data:\", len(mnist.test.images))\n",
    "print(\"MNIST test number of labels:\", len(mnist.test.labels))\n",
    "print(\"MNIST training data set pixel size\", (mnist.test.images[0].size))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 3 Initialize placeholder and variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = tf.placeholder(tf.float32, [None, 784]) # create 2d tensor of floating points, None denotes batch of any size\n",
    "                                            # 784 denotes dimensionality, 28 by 28 pixel \n",
    "W = tf.Variable(tf.zeros([784, 10])) # initialize weights variables to zero, 784 features and 10 outputs\n",
    "b = tf.Variable(tf.zeros([10])) # initialize bias varibale to zero, 10 classess\n",
    "\n",
    "y = tf.nn.softmax(tf.matmul(x, W) + b)  # Implement the model, multiply the vectorized input images x by the weight matrix W, add the bias b\n",
    "y_ = tf.placeholder(tf.float32, [None, 10]) # Intitate placeholder for loss function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 4 Construct 1 layer linear regression model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1])) # loss function \n",
    "train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy) # Implement backpropagation algorithm as SGD\n",
    "# 0.5 is the learning rate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Step 5 Train constructed regression model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sess = tf.InteractiveSession() # launch model in interactive mode\n",
    "tf.global_variables_initializer().run() # initialize variables\n",
    "for _ in range(1000): # run the training step 1000 times\n",
    "  batch_xs, batch_ys = mnist.train.next_batch(100) # \n",
    "  sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 6 Evaluate results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test datasets accuracy: 0.919\n"
     ]
    }
   ],
   "source": [
    "correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1)) \n",
    "# tf.argmax gives index of highest entry, tf.equal check whether prediction matches the ground truth \n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # ? \n",
    "print(\"Test datasets accuracy:\", sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels})) # print accuracy based on test data"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}