From 8f719ba7c095446695900eaba9281707de9d95a9 Mon Sep 17 00:00:00 2001 From: Loveiswar Date: Wed, 19 Dec 2018 02:05:39 +0530 Subject: [PATCH] Add MNIST Conv ANOVA --- mnist_conv.ipynb | 2685 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2685 insertions(+) create mode 100644 mnist_conv.ipynb diff --git a/mnist_conv.ipynb b/mnist_conv.ipynb new file mode 100644 index 0000000..795a1d9 --- /dev/null +++ b/mnist_conv.ipynb @@ -0,0 +1,2685 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled10.ipynb", + "version": "0.3.2", + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "accelerator": "TPU" + }, + "cells": [ + { + "metadata": { + "id": "1-2lSANbgKOE", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "import tensorflow as tf\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "from tensorflow.examples.tutorials.mnist import input_data\n" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "RIaH4VSBg1js", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "from tqdm import tqdm" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "4tUYCv9hgO8m", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "mnist = input_data.read_data_sets(\"MNIST_data/\", one_hot=True)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "H9jw6hTQgcpa", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "outputId": "a2d5ce90-dcc4-4486-80b5-ca76f99bbe1c" + }, + "cell_type": "code", + "source": [ + "#printing sample image and its corresponding label\n", + "plt.imshow(np.reshape((mnist.train.images[2]) , (28,28)))\n", + "plt.show()\n", + "print(\"Corresponding one hot label of the image \" + str( mnist.train.labels[2]))" + ], + "execution_count": 4, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD4CAYAAADFJPs2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAADg5JREFUeJzt3W+sVPWdx/E3Iqi5llJWt1RiNK7N\nN1v1gXVjYLO0dKvS1V0lkcYoMVLExViMydpEav2HD9ZaNRrBFJsuS8NaUowGsBrTym6qT/wTszbW\nND+tGh6Iyr+0KKxX5LIP7kDuHWbOnDt3zsxcf+/XE+f8fnPO/XLMZ87/85t06NAhJH2+HdPrAiRV\nz6BLGTDoUgYMupQBgy5l4Ngu/R1P7UvVm9Sso+2gR8SDwGyGQ3xTSumVdpclqVpt7bpHxDeBr6aU\n5gDXAg93tCpJHdXuMfq3gU0AKaU/Al+KiGkdq0pSR7Ub9JnAzhHTO2ttkvpQp866Nz0JIKn32g36\ndkZvwU8B3h9/OZKq0G7QfwMsBIiIrwPbU0ofdawqSR01qd2n1yLix8A3gCHg+yml3xd83evoUvWa\nHkK3HfQxMuhS9ZoG3VtgpQwYdCkDBl3KgEGXMmDQpQwYdCkDBl3KgEGXMmDQpQwYdCkDBl3KgEGX\nMmDQpQwYdCkDBl3KgEGXMmDQpQwYdCkDBl3KgEGXMmDQpQwYdCkDBl3KgEGXMmDQpQwYdCkDBl3K\ngEGXMmDQpQwYdCkDx7YzU0TMAx4H3qg1vZ5SurFTRUnqrLaCXvO7lNLCjlUiqTLuuksZGM8W/WsR\nsQWYAaxMKf22QzVJ6rBJhw4dGvNMETEL+AdgI3AG8D/AmSmlT5vMMvY/ImmsJjXtaCfo9SLiZeCK\nlNK7Tb5i0KXqNQ16W8foEbEoIn5Q+zwT+DLwXnu1Sapau7vuXwB+CUwHpjJ8jP5MwSxu0dtw8ODB\nUdOTJ08e1bZgwYKm8z799NOFy271/33GjBmF/e++O3rnbdq0aezdu3fUtLqu6Ra9rZNxKaWPgH9p\nuxxJXeXlNSkDBl3KgEGXMmDQpQwYdCkD47kFVuNUf/ms3s033zxq+qGHHhrV1uoSWpElS5YU9t9+\n++2F/SeeeGKptl7Yt2/fqOmBgYEjbQMDA70oqefcoksZMOhSBgy6lAGDLmXAoEsZMOhSBgy6lIGO\nvHiiBB9TbWDt2rWF/UuXLh01PTQ0xDHHlPttvuOOOwr7b7vttsL+Y4/t31ss7r333sL++++/f9T0\nzp07OfnkkwFYvXp14bxXXHHF+Irrrc6+eELSxGLQpQwYdCkDBl3KgEGXMmDQpQwYdCkDXkev0Acf\nfFDYf+aZZxb279+/f9R0/XX0olcq79mzp3DZZa/H98K2bdsK+88///zC/p07d46aHrneNmzYUDiv\n19ElTVgGXcqAQZcyYNClDBh0KQMGXcqAQZcy0L8PHX8O3HPPPYX99dfJ6zV6Jnxk20svvdR03n6+\nTt5Kq+fN66+T15syZUrTtvnz57df2ARWKugRcTawGXgwpbQ6Ik4F1gOTgfeBq1NKg9WVKWk8Wv7s\nR8QAsArYOqL5buCRlNJc4E9A8bAfknqqzP7dIHAxsH1E2zxgS+3zU8AFnS1LUieVvtc9Iu4CdtV2\n3XeklP661v43wPqU0t8XzJ7lve5SlzW9170TJ+OaLjx3N910U2H/qlWrCvvrT8Z9+umnTJ069cj0\n66+/3nTeiChRYX+64YYbCvvXrFlT2F9/Mm5wcJDjjjsOgA8//LBw3unTp5eocOJp99TsxxFxQu3z\nLEbv1kvqM+0G/Tng8trny4FnO1OOpCq03HWPiPOAB4DTgQMRsRBYBKyLiGXANuAXVRY5Ub3wwgvj\nmv+qq64qbBvP7vnQ0FBhf6ux2+tNmTKFAwcOlPru7t27C/s3b948pr9db9myZU3bPq+75q20DHpK\n6VWGz7LXu7Dj1UiqxMS9fUpSaQZdyoBBlzJg0KUMGHQpAz6m2scGB49+ILBRWyOtXpl8yy23FPZv\n3Lix1N85bGho6MjdZ1U75ZRTCvtvvfXWUm05cYsuZcCgSxkw6FIGDLqUAYMuZcCgSxkw6FIGHDa5\nQlu3bi3sv/DC4gcAW71h5tJLL20676ZNmwqX3eox1bGqH9K5Sg8//HBh//Lly7tSRx9y2GQpZwZd\nyoBBlzJg0KUMGHQpAwZdyoBBlzLg8+gVeuutt8Y1/2effVbY9uSTT7a97Isuuqiwv9Grpkdq9Lz7\nypUrj3y+88472yushDlz5lS27M8rt+hSBgy6lAGDLmXAoEsZMOhSBgy6lAGDLmXA6+gVanUt+vjj\njx/zMteuXVvqewsWLCjsnzZtWmF/q2fLG9Uxa9as1oWVcMkllxT2n3vuuR35OzkpFfSIOBvYDDyY\nUlodEeuA84DDA13fl1J6upoSJY1Xy6BHxACwCqh/XcoPU0q/rqQqSR1V5hh9ELgY2F5xLZIqUvqd\ncRFxF7BrxK77TGAqsANYnlLaVTB7lu+Mk7qs6Tvj2j0Ztx7YnVJ6LSJWAHcB2b6Rr5m9e/cW9o/1\noZTFixezbt26Ut/t9sm4JUuWjGpbunRpiwqba3UybvPmzYX93XpJ5UTSVtBTSiOP17cAP+1MOZKq\n0NZPX0Q8ERFn1CbnAX/oWEWSOq7MWffzgAeA04EDEbGQ4bPwv4qI/cDHwPeqLHKiarV7vHjx4jEv\ns515qtDo39bq31tWq7HM3TUfu5ZBTym9yvBWu94THa9GUiX8aZQyYNClDBh0KQMGXcqAQZcy4GOq\nakv9kM7N2hppdXns1FNPbasmNecWXcqAQZcyYNClDBh0KQMGXcqAQZcyYNClDJR+ldQ4+Sqpz5nZ\ns2ePmn7xxRdHtb388stN573yyisLl/3YY4+Nr7h8NX2VlFt0KQMGXcqAQZcyYNClDBh0KQMGXcqA\nQZcy4PPoauiTTz4p7N+16+gRuBq1NbJixYq2alL73KJLGTDoUgYMupQBgy5lwKBLGTDoUgYMupQB\nr6Orobfffruw/5133ilsmzJlStN5OzW8ssorFfSI+Akwt/b9e4BXgPXAZOB94OqU0mBVRUoan5a7\n7hHxLeDslNIc4DvAQ8DdwCMppbnAn4AllVYpaVzKHKM/D3y39vnPwAAwD9hSa3sKuKDjlUnqmJa7\n7imlg8C+2uS1wDPA/BG76juAr1RTnnrlrLPOKuwfGhoq1ab+UPpkXERcxnDQLwLeGtHV9IV0mrje\neOONwv5zzjln1PTQ0NCowROLTsa9+eabhcs+7bTTSlSosSh1eS0i5gM/Av4ppfQX4OOIOKHWPQvY\nXlF9kjqg5RY9Ir4I3AdckFLaU2t+Drgc+K/af5+trEL1xKJFi8Y1//Tp05v2ucXuvjK77lcAJwEb\nI+Jw2zXAzyNiGbAN+EU15UnqhDIn434G/KxB14WdL0dSFbwFVsqAQZcyYNClDBh0KQMGXcqAj6mq\nof37949r/rlz53aoEnWCW3QpAwZdyoBBlzJg0KUMGHQpAwZdyoBBlzLgdXRVYvLkyb0uQSO4RZcy\nYNClDBh0KQMGXcqAQZcyYNClDBh0KQNeR1clNm3a1LRvzZo1hfNef/31nS4ne27RpQwYdCkDBl3K\ngEGXMmDQpQwYdCkDBl3KQKnr6BHxE2Bu7fv3AJcC5wG7a1+5L6X0dCUVqidWrlxZ2H/jjTce1TZj\nxowjn/fs2dN0Xp9V776WQY+IbwFnp5TmRMRfAf8L/Dfww5TSr6suUNL4ldmiPw+8XPv8Z2AA8CdZ\nmkAmHTp0qPSXI+JfGd6FPwjMBKYCO4DlKaVdBbOW/yOS2jWpWUfpe90j4jLgWuAi4O+A3Sml1yJi\nBXAXsHycRaqPbNiwobC//hh9165dnHTSSUemi47RH3300cJlX3fddSUq1FiUPRk3H/gR8J2U0l+A\nrSO6twA/raA2SR3S8vJaRHwRuA/455TSnlrbExFxRu0r84A/VFahpHFreYxeOy6/C3hzRPN/Mryr\nvh/4GPheSmlHwWI8Rpeq1/QYfUwn48bBoEvVaxp074yTMmDQpQwYdCkDBl3KgEGXMmDQpQwYdCkD\nBl3KgEGXMmDQpQwYdCkDBl3KgEGXMmDQpQx0a9jkpo/PSaqeW3QpAwZdyoBBlzJg0KUMGHQpAwZd\nyoBBlzLQrevoR0TEg8Bshl8BfVNK6ZVu19BIRMwDHgfeqDW9nlI6emzgLoqIs4HNwIMppdURcSqw\nnuFBLt8Hrk4pDfZJbevok6G0Gwzz/Qp9sN56Ofx4V4MeEd8EvlobgvlvgbXAnG7W0MLvUkoLe10E\nQEQMAKsYPfzV3cAjKaXHI+LfgSX0YDisJrVBHwyl3WSY7630eL31evjxbu+6fxvYBJBS+iPwpYiY\n1uUaJopB4GJg+4i2eQyPdQfwFHBBl2s6rFFt/eJ54Lu1z4eH+Z5H79dbo7q6Nvx4t3fdZwKvjpje\nWWvb2+U6mvlaRGwBZgArU0q/7VUhKaXPgM8iYmTzwIhdzh3AV7peGE1rA1geEf9GuaG0q6rtILCv\nNnkt8Awwv9frrUldB+nSOuv1ybh+ugf+LWAlcBlwDfAfETG1tyUV6qd1B8PHwCtSSv8IvMbweH09\nM2KY7/rhvHu63urq6to66/YWfTvDW/DDTmH45EjPpZTeA35Vm3w7Ij4AZgHv9q6qo3wcESeklP6P\n4dr6Ztc5pdQ3Q2nXD/MdEX2x3no5/Hi3t+i/ARYCRMTXge0ppY+6XENDEbEoIn5Q+zwT+DLwXm+r\nOspzwOW1z5cDz/awllH6ZSjtRsN80wfrrdfDj3drNNUjIuLHwDeAIeD7KaXfd7WAJiLiC8AvgenA\nVIaP0Z/pYT3nAQ8ApwMHGP7RWQSsA44HtjE8XPWBPqltFbCC8kNpV1Vbo2G+rwF+Tg/XW4eGH29b\n14Muqft6fTJOUhcYdCkDBl3KgEGXMmDQpQwYdCkDBl3KwP8DgU2nltHKsXcAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "Corresponding one hot label of the image [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n" + ], + "name": "stdout" + } + ] + }, + { + "metadata": { + "id": "6DoOSJAfghfg", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "#image_size = 28\n", + "#labels_size = 10\n", + "learning_rate = [1e-4, 1e-3, 2e-4, 2e-3, 3e-4, 3e-3, 6e-3, 2e-2, 1e-1, 1]\n", + "#steps_number = 1000\n", + "#batch_size = 100" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "TwkTO3SggkWl", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "def create_placeholders():\n", + " x = tf.placeholder(tf.float32, shape = [None, 784])\n", + " y_ = tf.placeholder(tf.float32, shape = [None, 10])\n", + " return x , y_" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "pfJ0YTGugnBU", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "#Function for initializing weights\n", + "def weight_variable(shape, i):\n", + " \n", + " initial = tf.get_variable(name = \"W\" + str(i) , shape = shape, initializer = tf.contrib.layers.xavier_initializer())\n", + " return initial\n", + "\n", + "#Function for bias\n", + "def bias_variable(shape):\n", + " \n", + " initial = tf.constant(0.1, shape=shape)\n", + " return tf.Variable(initial) \n", + " \n", + "#Function for convolution with stride = s and same padding!!!!! For example stride = 1 =>[1,1,1,1]\n", + "def conv2d(x, W, s):\n", + " \n", + " return tf.nn.conv2d(input = x, filter = W, padding = \"SAME\", strides = s)\n", + "\n", + "#Function of max pooling over 2*2 block \n", + "def max_pooling_2x2(x):\n", + " \n", + " return tf.nn.max_pool(x, ksize = [1,2,2,1], strides = [1,2,2,1] ,padding = \"SAME\")" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "o4q8-f44gqHQ", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "\n", + "# The architecture is similar to https://www.tensorflow.org/get_started/mnist/pros without applying the batch normalization\n", + "x, y_ = create_placeholders()\n", + "\n", + "# Input layer where single input image shape is (1,784)\n", + "x_image = tf.reshape(x, [-1,28,28,1])\n", + "\n", + "# Convolution layer 1 - 32 x 5 x 5 \n", + "# Conv -> Relu -> Max_pool\n", + "W_conv1 = weight_variable([5, 5, 1, 32], 1)\n", + "b_conv1 = bias_variable([32])\n", + "x_conv1 = conv2d(x_image, W_conv1, [1,1,1,1]) + b_conv1\n", + "y1 = tf.nn.relu(x_conv1)\n", + "x_pool1 = max_pooling_2x2(y1)\n", + "\n", + "# Conv layer 2 - 64 x 5 x 5\n", + "# Conv -> Relu -> Max_pool\n", + "W_conv2 = weight_variable([5, 5, 32, 64], 2)\n", + "b_conv2 = bias_variable([64])\n", + "x_conv2 = conv2d(x_pool1, W_conv2, [1,1,1,1]) + b_conv2\n", + "y2 = tf.nn.relu(x_conv2)\n", + "x_pool2 = max_pooling_2x2(y2)\n", + "\n", + "# Flatten \n", + "\n", + "x_flat = tf.contrib.layers.flatten(x_pool2) #tf.reshape(x_pool2, [-1, 7 * 7 * 64])\n", + "\n", + "# Dense fully connected layer\n", + "x_fc1 = tf.contrib.layers.fully_connected(x_flat, num_outputs = 1024 , activation_fn= tf.nn.relu ) #Tensorflow here takes care of the bias\n", + "\n", + "#Here try 1 without Dropout\n", + "\n", + "#Classification Layer\n", + "y_conv = tf.contrib.layers.fully_connected(x_fc1, num_outputs = 10, activation_fn= None) #Tensorflow here takes care of the bias" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "QR39bJ4kgs6R", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 153 + }, + "outputId": "b4cf41d6-296a-4092-80e3-4dab1c49a59f" + }, + "cell_type": "code", + "source": [ + "\n", + "# Probabilities output from model\n", + "y = tf.nn.softmax(y_conv)\n", + "\n", + "#compute cost\n", + "cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels = y_, logits=y_conv))\n", + "#train step\n", + "train_step0 = tf.train.AdamOptimizer(learning_rate[0]).minimize(cross_entropy)\n", + "train_step1 = tf.train.AdamOptimizer(learning_rate[1]).minimize(cross_entropy)\n", + "train_step2 = tf.train.AdamOptimizer(learning_rate[2]).minimize(cross_entropy)\n", + "train_step3 = tf.train.AdamOptimizer(learning_rate[3]).minimize(cross_entropy)\n", + "train_step4 = tf.train.AdamOptimizer(learning_rate[4]).minimize(cross_entropy)\n", + "train_step5 = tf.train.AdamOptimizer(learning_rate[5]).minimize(cross_entropy)\n", + "train_step6 = tf.train.AdamOptimizer(learning_rate[6]).minimize(cross_entropy)\n", + "train_step7 = tf.train.AdamOptimizer(learning_rate[7]).minimize(cross_entropy)\n", + "train_step8 = tf.train.AdamOptimizer(learning_rate[8]).minimize(cross_entropy)\n", + "train_step9 = tf.train.AdamOptimizer(learning_rate[9]).minimize(cross_entropy)" + ], + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From :4: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "\n", + "Future major versions of TensorFlow will allow gradients to flow\n", + "into the labels input on backprop by default.\n", + "\n", + "See `tf.nn.softmax_cross_entropy_with_logits_v2`.\n", + "\n" + ], + "name": "stdout" + } + ] + }, + { + "metadata": { + "id": "WtGWUN0tgvFN", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1)) #Returns the index with the largest value across axes of a tensor.\n", + "accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "BYN6M_5Kg8qB", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 535 + }, + "outputId": "2c9a6b19-0029-499a-f481-05c0f2c2a7b5" + }, + "cell_type": "code", + "source": [ + "#0\n", + "sess = tf.InteractiveSession()\n", + "sess.run(tf.global_variables_initializer())\n", + "epochs_vector = []\n", + "accuracy_vector = []\n", + "batch_size = 100\n", + "\n", + "for i in tqdm(range(100)):\n", + " batch = mnist.train.next_batch(batch_size)\n", + " train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1]}) #t.eval() is a shortcut for calling tf.get_default_session().run(t)\n", + " if(i % 10 == 0):\n", + " print(\"Epoch %d, training accuracy %g\"%(i, train_accuracy))\n", + " epochs_vector.append(i)\n", + " accuracy_vector.append(train_accuracy)\n", + " train_step0.run(feed_dict={x: batch[0], y_: batch[1]}) #op.run() is a shortcut for calling tf.get_default_session().run(op)\n", + "\n", + "plt.title('Accuracy vs epochs learning rate={} and batch size={}'.format(learning_rate[0], batch_size))\n", + "plt.xlabel(\"epochs\")\n", + "plt.ylabel(\"accuracy\")\n", + "plt.plot(epochs_vector, accuracy_vector)\n", + "plt.show()\n", + "sess.close()\n" + ], + "execution_count": 55, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py:1702: UserWarning: An interactive session is already active. This can cause out-of-memory errors in some cases. You must explicitly call `InteractiveSession.close()` to release resources held by the other session(s).\n", + " warnings.warn('An interactive session is already active. This can '\n", + " 0%| | 0/100 [00:00" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "metadata": { + "id": "s76tMNb3g_A2", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 535 + }, + "outputId": "a953be60-75da-48f5-9211-d1469f5009d8" + }, + "cell_type": "code", + "source": [ + "#1\n", + "sess = tf.InteractiveSession()\n", + "sess.run(tf.global_variables_initializer())\n", + "epochs_vector = []\n", + "accuracy_vector = []\n", + "batch_size = 100\n", + "\n", + "for i in tqdm(range(100)):\n", + " batch = mnist.train.next_batch(batch_size)\n", + " train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1]}) #t.eval() is a shortcut for calling tf.get_default_session().run(t)\n", + " if(i % 10 == 0):\n", + " print(\"Epoch %d, training accuracy %g\"%(i, train_accuracy))\n", + " epochs_vector.append(i)\n", + " accuracy_vector.append(train_accuracy)\n", + " train_step1.run(feed_dict={x: batch[0], y_: batch[1]}) #op.run() is a shortcut for calling tf.get_default_session().run(op)\n", + "\n", + "plt.title('Accuracy vs epochs learning rate={} and batch size={}'.format(learning_rate[1], batch_size))\n", + "plt.xlabel(\"epochs\")\n", + "plt.ylabel(\"accuracy\")\n", + "plt.plot(epochs_vector, accuracy_vector)\n", + "plt.show()\n", + "sess.close()" + ], + "execution_count": 56, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py:1702: UserWarning: An interactive session is already active. This can cause out-of-memory errors in some cases. You must explicitly call `InteractiveSession.close()` to release resources held by the other session(s).\n", + " warnings.warn('An interactive session is already active. This can '\n", + " 0%| | 0/100 [00:00" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "metadata": { + "id": "541FO95pj0Ng", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 535 + }, + "outputId": "29dcef76-8181-479c-aff2-281703c1acad" + }, + "cell_type": "code", + "source": [ + "#2\n", + "sess = tf.InteractiveSession()\n", + "sess.run(tf.global_variables_initializer())\n", + "epochs_vector = []\n", + "accuracy_vector = []\n", + "batch_size = 100\n", + "\n", + "for i in tqdm(range(100)):\n", + " batch = mnist.train.next_batch(batch_size)\n", + " train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1]}) #t.eval() is a shortcut for calling tf.get_default_session().run(t)\n", + " if(i % 10 == 0):\n", + " print(\"Epoch %d, training accuracy %g\"%(i, train_accuracy))\n", + " epochs_vector.append(i)\n", + " accuracy_vector.append(train_accuracy)\n", + " train_step2.run(feed_dict={x: batch[0], y_: batch[1]}) #op.run() is a shortcut for calling tf.get_default_session().run(op)\n", + "\n", + "plt.title('Accuracy vs epochs learning rate={} and batch size={}'.format(learning_rate[2], batch_size))\n", + "plt.xlabel(\"epochs\")\n", + "plt.ylabel(\"accuracy\")\n", + "plt.plot(epochs_vector, accuracy_vector)\n", + "plt.show()\n", + "sess.close()" + ], + "execution_count": 57, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py:1702: UserWarning: An interactive session is already active. This can cause out-of-memory errors in some cases. You must explicitly call `InteractiveSession.close()` to release resources held by the other session(s).\n", + " warnings.warn('An interactive session is already active. This can '\n", + " 0%| | 0/100 [00:00" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "metadata": { + "id": "mhSxhtrUkJQT", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 535 + }, + "outputId": "3645f56f-e8ed-41bd-e56d-576daecbd096" + }, + "cell_type": "code", + "source": [ + "#3\n", + "sess = tf.InteractiveSession()\n", + "sess.run(tf.global_variables_initializer())\n", + "epochs_vector = []\n", + "accuracy_vector = []\n", + "batch_size = 100\n", + "\n", + "for i in tqdm(range(100)):\n", + " batch = mnist.train.next_batch(batch_size)\n", + " train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1]}) #t.eval() is a shortcut for calling tf.get_default_session().run(t)\n", + " if(i % 10 == 0):\n", + " print(\"Epoch %d, training accuracy %g\"%(i, train_accuracy))\n", + " epochs_vector.append(i)\n", + " accuracy_vector.append(train_accuracy)\n", + " train_step3.run(feed_dict={x: batch[0], y_: batch[1]}) #op.run() is a shortcut for calling tf.get_default_session().run(op)\n", + "\n", + "plt.title('Accuracy vs epochs learning rate={} and batch size={}'.format(learning_rate[3], batch_size))\n", + "plt.xlabel(\"epochs\")\n", + "plt.ylabel(\"accuracy\")\n", + "plt.plot(epochs_vector, accuracy_vector)\n", + "plt.show()\n", + "sess.close()\n" + ], + "execution_count": 58, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py:1702: UserWarning: An interactive session is already active. This can cause out-of-memory errors in some cases. You must explicitly call `InteractiveSession.close()` to release resources held by the other session(s).\n", + " warnings.warn('An interactive session is already active. This can '\n", + " 0%| | 0/100 [00:00" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "metadata": { + "id": "29QXNrr1m2Xp", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 535 + }, + "outputId": "f420ad0d-c81b-4dc0-fa6f-46bed310e896" + }, + "cell_type": "code", + "source": [ + "#4\n", + "sess = tf.InteractiveSession()\n", + "sess.run(tf.global_variables_initializer())\n", + "epochs_vector = []\n", + "accuracy_vector = []\n", + "batch_size = 100\n", + "\n", + "for i in tqdm(range(100)):\n", + " batch = mnist.train.next_batch(batch_size)\n", + " train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1]}) #t.eval() is a shortcut for calling tf.get_default_session().run(t)\n", + " if(i % 10 == 0):\n", + " print(\"Epoch %d, training accuracy %g\"%(i, train_accuracy))\n", + " epochs_vector.append(i)\n", + " accuracy_vector.append(train_accuracy)\n", + " train_step4.run(feed_dict={x: batch[0], y_: batch[1]}) #op.run() is a shortcut for calling tf.get_default_session().run(op)\n", + "\n", + "plt.title('Accuracy vs epochs learning rate={} and batch size={}'.format(learning_rate[4], batch_size))\n", + "plt.xlabel(\"epochs\")\n", + "plt.ylabel(\"accuracy\")\n", + "plt.plot(epochs_vector, accuracy_vector)\n", + "plt.show()\n", + "sess.close()\n" + ], + "execution_count": 59, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py:1702: UserWarning: An interactive session is already active. This can cause out-of-memory errors in some cases. You must explicitly call `InteractiveSession.close()` to release resources held by the other session(s).\n", + " warnings.warn('An interactive session is already active. This can '\n", + " 0%| | 0/100 [00:00" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "metadata": { + "id": "8oGF82M9ppAa", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 535 + }, + "outputId": "ee506b45-ed1b-40f7-9bc5-3c9830a2a878" + }, + "cell_type": "code", + "source": [ + "#5\n", + "sess = tf.InteractiveSession()\n", + "sess.run(tf.global_variables_initializer())\n", + "epochs_vector = []\n", + "accuracy_vector = []\n", + "batch_size = 100\n", + "\n", + "for i in tqdm(range(100)):\n", + " batch = mnist.train.next_batch(batch_size)\n", + " train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1]}) #t.eval() is a shortcut for calling tf.get_default_session().run(t)\n", + " if(i % 10 == 0):\n", + " print(\"Epoch %d, training accuracy %g\"%(i, train_accuracy))\n", + " epochs_vector.append(i)\n", + " accuracy_vector.append(train_accuracy)\n", + " train_step5.run(feed_dict={x: batch[0], y_: batch[1]}) #op.run() is a shortcut for calling tf.get_default_session().run(op)\n", + "\n", + "plt.title('Accuracy vs epochs learning rate={} and batch size={}'.format(learning_rate[5], batch_size))\n", + "plt.xlabel(\"epochs\")\n", + "plt.ylabel(\"accuracy\")\n", + "plt.plot(epochs_vector, accuracy_vector)\n", + "plt.show()\n", + "sess.close()" + ], + "execution_count": 60, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py:1702: UserWarning: An interactive session is already active. This can cause out-of-memory errors in some cases. You must explicitly call `InteractiveSession.close()` to release resources held by the other session(s).\n", + " warnings.warn('An interactive session is already active. This can '\n", + " 0%| | 0/100 [00:00" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "metadata": { + "id": "UDolLBTK7kgs", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 535 + }, + "outputId": "d699c50b-c387-435d-832d-300cd2251dbc" + }, + "cell_type": "code", + "source": [ + "#6\n", + "sess = tf.InteractiveSession()\n", + "sess.run(tf.global_variables_initializer())\n", + "epochs_vector = []\n", + "accuracy_vector = []\n", + "batch_size = 100\n", + "\n", + "for i in tqdm(range(100)):\n", + " batch = mnist.train.next_batch(batch_size)\n", + " train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1]}) #t.eval() is a shortcut for calling tf.get_default_session().run(t)\n", + " if(i % 10 == 0):\n", + " print(\"Epoch %d, training accuracy %g\"%(i, train_accuracy))\n", + " epochs_vector.append(i)\n", + " accuracy_vector.append(train_accuracy)\n", + " train_step6.run(feed_dict={x: batch[0], y_: batch[1]}) #op.run() is a shortcut for calling tf.get_default_session().run(op)\n", + "\n", + "plt.title('Accuracy vs epochs learning rate={} and batch size={}'.format(learning_rate[6], batch_size))\n", + "plt.xlabel(\"epochs\")\n", + "plt.ylabel(\"accuracy\")\n", + "plt.plot(epochs_vector, accuracy_vector)\n", + "plt.show()\n", + "sess.close()\n" + ], + "execution_count": 61, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py:1702: UserWarning: An interactive session is already active. This can cause out-of-memory errors in some cases. You must explicitly call `InteractiveSession.close()` to release resources held by the other session(s).\n", + " warnings.warn('An interactive session is already active. This can '\n", + " 0%| | 0/100 [00:00" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "metadata": { + "id": "ch4H3ZDK7mnN", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 535 + }, + "outputId": "e8bc598b-feb3-493f-cdfe-158cff86556d" + }, + "cell_type": "code", + "source": [ + "#7\n", + "sess = tf.InteractiveSession()\n", + "sess.run(tf.global_variables_initializer())\n", + "epochs_vector = []\n", + "accuracy_vector = []\n", + "batch_size = 100\n", + "\n", + "for i in tqdm(range(100)):\n", + " batch = mnist.train.next_batch(batch_size)\n", + " train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1]}) #t.eval() is a shortcut for calling tf.get_default_session().run(t)\n", + " if(i % 10 == 0):\n", + " print(\"Epoch %d, training accuracy %g\"%(i, train_accuracy))\n", + " epochs_vector.append(i)\n", + " accuracy_vector.append(train_accuracy)\n", + " train_step7.run(feed_dict={x: batch[0], y_: batch[1]}) #op.run() is a shortcut for calling tf.get_default_session().run(op)\n", + "\n", + "plt.title('Accuracy vs epochs learning rate={} and batch size={}'.format(learning_rate[7], batch_size))\n", + "plt.xlabel(\"epochs\")\n", + "plt.ylabel(\"accuracy\")\n", + "plt.plot(epochs_vector, accuracy_vector)\n", + "plt.show()\n", + "sess.close()" + ], + "execution_count": 62, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py:1702: UserWarning: An interactive session is already active. This can cause out-of-memory errors in some cases. You must explicitly call `InteractiveSession.close()` to release resources held by the other session(s).\n", + " warnings.warn('An interactive session is already active. This can '\n", + " 0%| | 0/100 [00:00" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "metadata": { + "id": "JtY6Sy3o7nfB", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 535 + }, + "outputId": "ff087daf-6e61-4a6c-b4c3-a067c3a056b2" + }, + "cell_type": "code", + "source": [ + "#8\n", + "sess = tf.InteractiveSession()\n", + "sess.run(tf.global_variables_initializer())\n", + "epochs_vector = []\n", + "accuracy_vector = []\n", + "batch_size = 100\n", + "\n", + "for i in tqdm(range(100)):\n", + " batch = mnist.train.next_batch(batch_size)\n", + " train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1]}) #t.eval() is a shortcut for calling tf.get_default_session().run(t)\n", + " if(i % 10 == 0):\n", + " print(\"Epoch %d, training accuracy %g\"%(i, train_accuracy))\n", + " epochs_vector.append(i)\n", + " accuracy_vector.append(train_accuracy)\n", + " train_step8.run(feed_dict={x: batch[0], y_: batch[1]}) #op.run() is a shortcut for calling tf.get_default_session().run(op)\n", + "\n", + "plt.title('Accuracy vs epochs learning rate={} and batch size={}'.format(learning_rate[8], batch_size))\n", + "plt.xlabel(\"epochs\")\n", + "plt.ylabel(\"accuracy\")\n", + "plt.plot(epochs_vector, accuracy_vector)\n", + "plt.show()\n", + "sess.close()" + ], + "execution_count": 63, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py:1702: UserWarning: An interactive session is already active. This can cause out-of-memory errors in some cases. You must explicitly call `InteractiveSession.close()` to release resources held by the other session(s).\n", + " warnings.warn('An interactive session is already active. This can '\n", + " 0%| | 0/100 [00:00" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "metadata": { + "id": "00TdL1O17o8_", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 535 + }, + "outputId": "e63d378e-9782-4538-dddd-038a164210a8" + }, + "cell_type": "code", + "source": [ + "#9\n", + "sess = tf.InteractiveSession()\n", + "sess.run(tf.global_variables_initializer())\n", + "epochs_vector = []\n", + "accuracy_vector = []\n", + "batch_size = 100\n", + "\n", + "for i in tqdm(range(100)):\n", + " batch = mnist.train.next_batch(batch_size)\n", + " train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1]}) #t.eval() is a shortcut for calling tf.get_default_session().run(t)\n", + " if(i % 10 == 0):\n", + " print(\"Epoch %d, training accuracy %g\"%(i, train_accuracy))\n", + " epochs_vector.append(i)\n", + " accuracy_vector.append(train_accuracy)\n", + " train_step9.run(feed_dict={x: batch[0], y_: batch[1]}) #op.run() is a shortcut for calling tf.get_default_session().run(op)\n", + "\n", + "plt.title('Accuracy vs epochs learning rate={} and batch size={}'.format(learning_rate[9], batch_size))\n", + "plt.xlabel(\"epochs\")\n", + "plt.ylabel(\"accuracy\")\n", + "plt.plot(epochs_vector, accuracy_vector)\n", + "plt.show()\n", + "sess.close()" + ], + "execution_count": 64, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py:1702: UserWarning: An interactive session is already active. This can cause out-of-memory errors in some cases. You must explicitly call `InteractiveSession.close()` to release resources held by the other session(s).\n", + " warnings.warn('An interactive session is already active. This can '\n", + " 0%| | 0/100 [00:00" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "metadata": { + "id": "fsqMeTEByRK3", + "colab_type": "text" + }, + "cell_type": "markdown", + "source": [ + "**Varying Batch Size**" + ] + }, + { + "metadata": { + "id": "cMgMMutL-bqh", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 535 + }, + "outputId": "1df38270-72b0-46cb-acf3-3adcca63f112" + }, + "cell_type": "code", + "source": [ + "#10\n", + "sess = tf.InteractiveSession()\n", + "sess.run(tf.global_variables_initializer())\n", + "epochs_vector = []\n", + "accuracy_vector = []\n", + "batch_size = 50\n", + "\n", + "for i in tqdm(range(100)):\n", + " batch = mnist.train.next_batch(batch_size)\n", + " train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1]}) #t.eval() is a shortcut for calling tf.get_default_session().run(t)\n", + " if(i % 10 == 0):\n", + " print(\"Epoch %d, training accuracy %g\"%(i, train_accuracy))\n", + " epochs_vector.append(i)\n", + " accuracy_vector.append(train_accuracy)\n", + " train_step0.run(feed_dict={x: batch[0], y_: batch[1]}) #op.run() is a shortcut for calling tf.get_default_session().run(op)\n", + "\n", + "plt.title('Accuracy vs epochs learning rate={} and batch size={}'.format(learning_rate[0], batch_size))\n", + "plt.xlabel(\"epochs\")\n", + "plt.ylabel(\"accuracy\")\n", + "plt.plot(epochs_vector, accuracy_vector)\n", + "plt.show()\n", + "sess.close()" + ], + "execution_count": 65, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py:1702: UserWarning: An interactive session is already active. This can cause out-of-memory errors in some cases. You must explicitly call `InteractiveSession.close()` to release resources held by the other session(s).\n", + " warnings.warn('An interactive session is already active. This can '\n", + " 0%| | 0/100 [00:00" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "metadata": { + "id": "xJtdE60MIsCH", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 535 + }, + "outputId": "4124cd69-6698-47c9-baf0-4a00bd87862d" + }, + "cell_type": "code", + "source": [ + "#11\n", + "sess = tf.InteractiveSession()\n", + "sess.run(tf.global_variables_initializer())\n", + "epochs_vector = []\n", + "accuracy_vector = []\n", + "batch_size = 10\n", + "\n", + "for i in tqdm(range(100)):\n", + " batch = mnist.train.next_batch(batch_size)\n", + " train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1]}) #t.eval() is a shortcut for calling tf.get_default_session().run(t)\n", + " if(i % 10 == 0):\n", + " print(\"Epoch %d, training accuracy %g\"%(i, train_accuracy))\n", + " epochs_vector.append(i)\n", + " accuracy_vector.append(train_accuracy)\n", + " train_step0.run(feed_dict={x: batch[0], y_: batch[1]}) #op.run() is a shortcut for calling tf.get_default_session().run(op)\n", + "\n", + "plt.title('Accuracy vs epochs learning rate={} and batch size={}'.format(learning_rate[0], batch_size))\n", + "plt.xlabel(\"epochs\")\n", + "plt.ylabel(\"accuracy\")\n", + "plt.plot(epochs_vector, accuracy_vector)\n", + "plt.show()\n", + "sess.close()" + ], + "execution_count": 66, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py:1702: UserWarning: An interactive session is already active. This can cause out-of-memory errors in some cases. You must explicitly call `InteractiveSession.close()` to release resources held by the other session(s).\n", + " warnings.warn('An interactive session is already active. This can '\n", + " 1%| | 1/100 [00:00<00:24, 4.01it/s]" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Epoch 0, training accuracy 0.1\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + " 13%|█▎ | 13/100 [00:01<00:08, 10.74it/s]" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Epoch 10, training accuracy 0.2\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + " 23%|██▎ | 23/100 [00:01<00:05, 13.70it/s]" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Epoch 20, training accuracy 0.1\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + " 33%|███▎ | 33/100 [00:02<00:04, 14.15it/s]" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Epoch 30, training accuracy 0.4\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + " 43%|████▎ | 43/100 [00:03<00:03, 14.26it/s]" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Epoch 40, training accuracy 0.3\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + " 53%|█████▎ | 53/100 [00:03<00:03, 14.27it/s]" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Epoch 50, training accuracy 0.5\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + " 63%|██████▎ | 63/100 [00:04<00:02, 14.19it/s]" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Epoch 60, training accuracy 0.2\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + " 73%|███████▎ | 73/100 [00:05<00:01, 14.27it/s]" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Epoch 70, training accuracy 0.7\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + " 83%|████████▎ | 83/100 [00:06<00:01, 14.24it/s]" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Epoch 80, training accuracy 0.6\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + " 93%|█████████▎| 93/100 [00:06<00:00, 14.24it/s]" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Epoch 90, training accuracy 0.6\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [00:07<00:00, 13.78it/s]\n" + ], + "name": "stderr" + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEVCAYAAADpbDJPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + } + ] + } + ] +} \ No newline at end of file