Assignment03_Urveshkumar Koshti.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e880d1c6",
   "metadata": {},
   "source": [
    "# Assignment 3: Working with an ANN\n",
    "\n",
    "This assignment contributes (up to) 20 points (out of 100 possible) of the final grade.\n",
    "Please adhere the these rules while solving the assignment:\n",
    "* Please hand in only this jupyter notebook. If you work on your own computer make sure, it also works on the provided server.\n",
    "* Include the results, not only the code.\n",
    "* No changes above the respective task. The previous parts must not be changed for the current assignment. Use inheritance or copy the parts you want to change. But existing code can be called/used.\n",
    "* All explainintion/discussions in your own words.\n",
    "\n",
    "Some hints:\n",
    "* Start early, running the complete notebook can take hours\n",
    "* Too avoid having to \"babysit\" the notebook try to put each task in one single cell. So you do not need to pay attention when some intermediate results are finished, to be able to run the next cell before the \"idle timeout\" catches you.\n",
    "* Develop your code with a subset of the data, so you are quite confident, that the code executes completely.\n",
    "\n",
    "The assignment is based on the already known ANN (Week 10):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "d6a50870",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "# scipy.special for the sigmoid function expit()\n",
    "import scipy.special\n",
    "\n",
    "# class definition for the core structure\n",
    "class neuralNetwork:\n",
    "    \n",
    "    # initialise the neural network\n",
    "    def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):\n",
    "        # set number of nodes in each input, hidden, output layer\n",
    "        self.inodes = inputnodes\n",
    "        self.hnodes = hiddennodes\n",
    "        self.onodes = outputnodes\n",
    "        \n",
    "        # link weight matrices, wih and who\n",
    "        # weights inside the arrays are w_i_j, where link is from node i to node j in the next layer\n",
    "        # w11 w21\n",
    "        # w12 w22 etc \n",
    "        self.wih = numpy.random.normal(0.0, pow(self.inodes, -0.5), (self.hnodes, self.inodes))\n",
    "        self.who = numpy.random.normal(0.0, pow(self.hnodes, -0.5), (self.onodes, self.hnodes))\n",
    "\n",
    "        # learning rate\n",
    "        self.lr = learningrate\n",
    "        \n",
    "        # activation function is the sigmoid function\n",
    "        self.activation_function = lambda x: scipy.special.expit(x)\n",
    "        \n",
    "        pass\n",
    "\n",
    "\n",
    "    \n",
    "    # train the neural network\n",
    "    def train(self, inputs_list, targets_list):\n",
    "        # convert inputs list to 2d array\n",
    "        inputs = numpy.array(inputs_list, ndmin=2).T\n",
    "        targets = numpy.array(targets_list, ndmin=2).T\n",
    "        \n",
    "        # calculate signals into hidden layer\n",
    "        hidden_inputs = numpy.dot(self.wih, inputs)\n",
    "        # calculate the signals emerging from hidden layer\n",
    "        hidden_outputs = self.activation_function(hidden_inputs)\n",
    "        \n",
    "        # calculate signals into final output layer\n",
    "        final_inputs = numpy.dot(self.who, hidden_outputs)\n",
    "        # calculate the signals emerging from final output layer\n",
    "        final_outputs = self.activation_function(final_inputs)\n",
    "        \n",
    "        # output layer error is the (target - actual)\n",
    "        output_errors = targets - final_outputs\n",
    "        # hidden layer error is the output_errors, split by weights, recombined at hidden nodes\n",
    "        hidden_errors = numpy.dot(self.who.T, output_errors) \n",
    "        \n",
    "        # update the weights for the links between the hidden and output layers\n",
    "        self.who += self.lr * numpy.dot((output_errors * final_outputs * (1.0 - final_outputs)), numpy.transpose(hidden_outputs))\n",
    "        \n",
    "        # update the weights for the links between the input and hidden layers\n",
    "        self.wih += self.lr * numpy.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)), numpy.transpose(inputs))\n",
    "        \n",
    "        pass\n",
    "\n",
    "    \n",
    "    # query the neural network\n",
    "    def query(self, inputs_list):\n",
    "        # convert inputs list to 2d array\n",
    "        inputs = numpy.array(inputs_list, ndmin=2).T\n",
    "        \n",
    "        # calculate signals into hidden layer\n",
    "        hidden_inputs = numpy.dot(self.wih, inputs)\n",
    "        # calculate the signals emerging from hidden layer\n",
    "        hidden_outputs = self.activation_function(hidden_inputs)\n",
    "        \n",
    "        # calculate signals into final output layer\n",
    "        final_inputs = numpy.dot(self.who, hidden_outputs)\n",
    "        # calculate the signals emerging from final output layer\n",
    "        final_outputs = self.activation_function(final_inputs)\n",
    "        \n",
    "        return final_outputs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92cad158",
   "metadata": {},
   "source": [
    "## Task 1: Get & run the full data set (2 Point)\n",
    "\n",
    "Get the full MNIST training & test dataset. Then train and test the ANN with the same settings as in the exercise (784 input nodes, 200 hidden nodes, 10 output nodes, learning rate 0.1, 5 epoch).\n",
    "\n",
    "Code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "cbcfd488",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "def myfunction_task1(input_nodes, hidden_nodes, output_nodes, learning_rate, epochs, instance_name):\n",
    "    \n",
    "    t1 = time.time()                                                                # Starting time              \n",
    "    # number of input, hidden and output nodes\n",
    "    inp_nodes = input_nodes\n",
    "    hid_nodes = hidden_nodes\n",
    "    out_nodes = output_nodes\n",
    "\n",
    "    # learning rate\n",
    "    l_r = learning_rate                                                             # Learning rate value\n",
    "\n",
    "    # create instance of neural network\n",
    "    # I have used different name of every instance of neural network to prevent data overwriting!\n",
    "    instance_name = neuralNetwork(input_nodes,hidden_nodes,output_nodes, learning_rate)\n",
    "\n",
    "    # load the mnist training data CSV file into a list\n",
    "    training_data_file = open(\"mnist_train.csv\", 'r')\n",
    "    training_data_list = training_data_file.readlines()\n",
    "    training_data_file.close()\n",
    "\n",
    "\n",
    "    # train the neural network\n",
    "\n",
    "    # epochs is the number of times the training data set is used for training\n",
    "    epoch = 5                                          \n",
    "\n",
    "    for e in range(epochs):\n",
    "        # go through all records in the training data set\n",
    "        for record in training_data_list:\n",
    "            # split the record by the ',' commas\n",
    "            all_values = record.split(',')\n",
    "            # scale and shift the inputs\n",
    "            inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01\n",
    "            # create the target output values (all 0.01, except the desired label which is 0.99)\n",
    "            targets = numpy.zeros(output_nodes) + 0.01\n",
    "            # all_values[0] is the target label for this record\n",
    "            targets[int(all_values[0])] = 0.99\n",
    "            instance_name.train(inputs, targets)\n",
    "            pass\n",
    "        pass\n",
    "\n",
    "\n",
    "    # Loading the test data\n",
    "    # load the mnist test data CSV file into a list\n",
    "    test_data_file = open(\"mnist_test.csv\", 'r')\n",
    "    test_data_list = test_data_file.readlines()\n",
    "    test_data_file.close()\n",
    "\n",
    "    # scorecard for how well the network performs, initially empty\n",
    "    scorecard = []\n",
    "\n",
    "    # go through all the records in the test data set\n",
    "    for record in test_data_list:\n",
    "        # split the record by the ',' commas\n",
    "        all_values = record.split(',')\n",
    "        # correct answer is first value\n",
    "        correct_label = int(all_values[0])\n",
    "        # scale and shift the inputs\n",
    "        inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01\n",
    "        # query the network\n",
    "        outputs = instance_name.query(inputs)\n",
    "        # the index of the highest value corresponds to the label\n",
    "        label = numpy.argmax(outputs)\n",
    "        # append correct or incorrect to list\n",
    "        if (label == correct_label):\n",
    "            #print(f\"The number {label} was corrctly detected with a score of {outputs[label]}\")\n",
    "            # network's answer matches correct answer, add 1 to scorecard\n",
    "            scorecard.append(1)\n",
    "        else:\n",
    "            #print(f\"The number {label} was incorrctly detected with a score of {outputs[label]}, was {correct_label}\")\n",
    "            # network's answer doesn't match correct answer, add 0 to scorecard\n",
    "            scorecard.append(0)\n",
    "            pass\n",
    "\n",
    "        pass\n",
    "\n",
    "    # calculate the performance score, the fraction of correct answers\n",
    "    scorecard_array = numpy.asarray(scorecard)\n",
    "    print (\"Performance is = \", scorecard_array.sum() / scorecard_array.size)\n",
    "\n",
    "    t2 = time.time()                                                                    #Ending time\n",
    "    print('Time for the completing whole task:', round(t2-t1,2), 'seconds')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "aa0ac5f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performance is =  0.9714\n",
      "Time for the completing whole task: 292.12 seconds\n"
     ]
    }
   ],
   "source": [
    "myfunction_task1(784, 200, 10, 0.1, 5, 'n_1')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ea861c3",
   "metadata": {},
   "source": [
    "**Note:** I have made a function for task 1 'myfunction_task1' because I have used this task 1 function in Task 6 also to run it and compare the results with task 6 results. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91a4eccf",
   "metadata": {},
   "source": [
    "**Note:** All the examples in this Assignment were run on following configuration:\n",
    "intel(R) Core(TM) i7-10750H CPU @ 2.60GHz, 6 cores"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3f09f38",
   "metadata": {},
   "source": [
    "Please give a short explanation (in your own words) of the differences in the \"performance\" (proportion of correct classifications) compared with the smaller dataset in the exercise:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95984331",
   "metadata": {},
   "source": [
    "**ANSWER**\n",
    "\n",
    "(1) In smaller data, there was 0.6 performance rate whereas we got 0.9714 performance rate on larger data. Therefore, there is 62% increase in performance (proportion of correct classifications) when we use larger data.\n",
    "\n",
    "(2) Data size is a very crucial part of training neural networks. Larger datasets can help us better learn model parameters and improve the optimization process and imparts generalization. Because of large diversified data, this model is now more experienced and more generalized to new unseen data. Earlier it was only restricted to 600 therefore, it was not diversified. Large dataset helps us avoid overfitting and generalizes better as it captures the inherent data distribution more effectively."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49d71515",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "26d96003",
   "metadata": {},
   "source": [
    "## Task 2: Influence of the learning rate (2 Points)\n",
    "\n",
    "Test the influence of learning rates. Start with 0.01, 0.1, 0.2, 0.3, 0.4, 0.5, 0.7, 1.0. Other parameters are the same as in task 1.\n",
    "After the first (successful) run add two additional values to get a more detailed picture of the area with the best performance.\n",
    "Use a graph to visualize the result.\n",
    "\n",
    "Code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b9fb5fa9",
   "metadata": {},
   "outputs": [],
   "source": [
    "###Function to plot graphs\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def myplot_function(m, n, x, y, z):\n",
    "    plt.plot(m,n, marker = 'o')                 # m and n are given x and y values respectively\n",
    "    plt.xlabel(x)                               # x is a name of X axis of graph\n",
    "    plt.ylabel(y)                               # y is a name of Y axis of graph \n",
    "    plt.title(z)                                # z is a title of the graph  \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "bc54f5e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rates are: [0.01, 0.1, 0.2, 0.3, 0.4, 0.5, 0.7, 1.0]\n",
      "Performance scorecard is: [0.9529, 0.9743, 0.9693, 0.9565, 0.9554, 0.9343, 0.8933, 0.8412]\n",
      "our Maximum performance is 0.9743\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our maximum performance occurs at learning rate: 0.1 so we will put two additional values of learning rate around this in next cell.\n",
      "Time for the completing this task is: 2387.4115738868713 seconds\n"
     ]
    }
   ],
   "source": [
    "t3 = time.time()\n",
    "import matplotlib.pyplot as plt\n",
    "# number of input, hidden and output nodes\n",
    "input_nodes = 784\n",
    "hidden_nodes = 200\n",
    "output_nodes = 10\n",
    "\n",
    "learning_rate=[0.01, 0.1, 0.2, 0.3, 0.4, 0.5, 0.7, 1.0]                        # List of learning rate value           \n",
    "\n",
    "performace_scorecard = []\n",
    "\n",
    "for i in range(len(learning_rate)):\n",
    "    # create instance of neural network\n",
    "    # I have used different name of every instance of neural network to prevent data overwriting!\n",
    "    n_2 = neuralNetwork(input_nodes,hidden_nodes,output_nodes, learning_rate[i])\n",
    "\n",
    "    # load the mnist training data CSV file into a list\n",
    "    training_data_file = open(\"mnist_train.csv\", 'r')\n",
    "    training_data_list = training_data_file.readlines()\n",
    "    training_data_file.close()\n",
    "\n",
    "\n",
    "    # train the neural network\n",
    "\n",
    "    # epochs is the number of times the training data set is used for training\n",
    "    epochs = 5\n",
    "\n",
    "    for e in range(epochs):\n",
    "        # go through all records in the training data set\n",
    "        for record in training_data_list:\n",
    "            # split the record by the ',' commas\n",
    "            all_values = record.split(',')\n",
    "            # scale and shift the inputs\n",
    "            inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01\n",
    "            # create the target output values (all 0.01, except the desired label which is 0.99)\n",
    "            targets = numpy.zeros(output_nodes) + 0.01\n",
    "            # all_values[0] is the target label for this record\n",
    "            targets[int(all_values[0])] = 0.99\n",
    "            n_2.train(inputs, targets)\n",
    "            pass\n",
    "        pass\n",
    "\n",
    "    # Loading the test data\n",
    "    # load the mnist test data CSV file into a list\n",
    "    test_data_file = open(\"mnist_test.csv\", 'r')\n",
    "    test_data_list = test_data_file.readlines()\n",
    "    test_data_file.close()\n",
    "\n",
    "    # scorecard for how well the network performs, initially empty\n",
    "    scorecard = []\n",
    "\n",
    "    # go through all the records in the test data set\n",
    "    for record in test_data_list:\n",
    "        # split the record by the ',' commas\n",
    "        all_values = record.split(',')\n",
    "        # correct answer is first value\n",
    "        correct_label = int(all_values[0])\n",
    "        # scale and shift the inputs\n",
    "        inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01\n",
    "        # query the network\n",
    "        outputs = n_2.query(inputs)\n",
    "        # the index of the highest value corresponds to the label\n",
    "        label = numpy.argmax(outputs)\n",
    "        # append correct or incorrect to list\n",
    "        if (label == correct_label):\n",
    "            #print(f\"The number {label} was corrctly detected with a score of {outputs[label]}\")\n",
    "            # network's answer matches correct answer, add 1 to scorecard\n",
    "            scorecard.append(1)\n",
    "        else:\n",
    "            #print(f\"The number {label} was incorrctly detected with a score of {outputs[label]}, was {correct_label}\")\n",
    "            # network's answer doesn't match correct answer, add 0 to scorecard\n",
    "            scorecard.append(0)\n",
    "            pass\n",
    "\n",
    "        pass\n",
    "\n",
    "    # calculate the performance score, the fraction of correct answers\n",
    "    scorecard_array = numpy.asarray(scorecard)\n",
    "    #print (\"performance = \", scorecard_array.sum() / scorecard_array.size)\n",
    "    performance = scorecard_array.sum() / scorecard_array.size\n",
    "\n",
    "    performace_scorecard.append(performance)\n",
    "    \n",
    "print('Learning rates are:', learning_rate)\n",
    "print('Performance scorecard is:', performace_scorecard)\n",
    "\n",
    "max_value = max(performace_scorecard)\n",
    "print('our Maximum performance is', max_value)\n",
    "\n",
    "#Plotting a graph using 'myplot_function' function created above\n",
    "myplot_function(learning_rate, performace_scorecard, 'Learning rates', 'Performace', 'Learning rate Vs Performance graph!')\n",
    "\n",
    "max_value = max(performace_scorecard)\n",
    "max_index = performace_scorecard.index(max_value)\n",
    "print('Our maximum performance occurs at learning rate:', learning_rate[max_index], 'so we will put two additional values of learning rate around this in next cell.')\n",
    "\n",
    "t4 = time.time()\n",
    "print('Time for the completing this task is:', t4-t3, 'seconds')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b560011c",
   "metadata": {},
   "source": [
    "**Note:** I have not rounded the time upto 2 decimal because in these task, I have only checked the time for my personal interest. I have rounded the time upto 2 decimal in task 1, 4, 5, and 6 because of the importance of the time.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e0457747",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rates are: [0.01, 0.07, 0.1, 0.15, 0.2, 0.3, 0.4]\n",
      "Performance scorecard is: [0.9524, 0.9744, 0.9729, 0.972, 0.9685, 0.9588, 0.9479]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time for the task: 2124.470781326294 seconds\n"
     ]
    }
   ],
   "source": [
    "##### In this cell, two addtional learning rates are added around where maximum performance occured in above section.#####\n",
    "\n",
    "t5 = time.time()\n",
    "import matplotlib.pyplot as plt\n",
    "# number of input, hidden and output nodes\n",
    "input_nodes = 784\n",
    "hidden_nodes = 200\n",
    "output_nodes = 10\n",
    "\n",
    "learning_rate=[0.01, 0.07, 0.1, 0.15, 0.2, 0.3, 0.4]                       #0.07 and 0.15 are additional Learning rates\n",
    "# Learning rates '0.5', '0.7', '1.0' are removed due to low performance rates as already shown in Figure plotted above \n",
    "\n",
    "performace_scorecard_1 = []                                                # initializing 'performance_scorecard 'list which will store performance rate for this task\n",
    "\n",
    "for i in range(len(learning_rate)):\n",
    "    # create instance of neural network\n",
    "    # I have used different name of every instance of neural network to prevent data overwriting!\n",
    "    n_21 = neuralNetwork(input_nodes,hidden_nodes,output_nodes, learning_rate[i])\n",
    "\n",
    "    # load the mnist training data CSV file into a list\n",
    "    training_data_file = open(\"mnist_train.csv\", 'r')\n",
    "    training_data_list = training_data_file.readlines()\n",
    "    training_data_file.close()\n",
    "\n",
    "\n",
    "    # train the neural network\n",
    "\n",
    "    # epochs is the number of times the training data set is used for training\n",
    "    epochs = 5\n",
    "\n",
    "    for e in range(epochs):\n",
    "        # go through all records in the training data set\n",
    "        for record in training_data_list:\n",
    "            # split the record by the ',' commas\n",
    "            all_values = record.split(',')\n",
    "            # scale and shift the inputs\n",
    "            inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01\n",
    "            # create the target output values (all 0.01, except the desired label which is 0.99)\n",
    "            targets = numpy.zeros(output_nodes) + 0.01\n",
    "            # all_values[0] is the target label for this record\n",
    "            targets[int(all_values[0])] = 0.99\n",
    "            n_21.train(inputs, targets)\n",
    "            pass\n",
    "        pass\n",
    "\n",
    "    # Loading the test data\n",
    "    # load the mnist test data CSV file into a list\n",
    "    test_data_file = open(\"mnist_test.csv\", 'r')\n",
    "    test_data_list = test_data_file.readlines()\n",
    "    test_data_file.close()\n",
    "\n",
    "    # scorecard for how well the network performs, initially empty\n",
    "    scorecard = []\n",
    "\n",
    "    # go through all the records in the test data set\n",
    "    for record in test_data_list:\n",
    "        # split the record by the ',' commas\n",
    "        all_values = record.split(',')\n",
    "        # correct answer is first value\n",
    "        correct_label = int(all_values[0])\n",
    "        # scale and shift the inputs\n",
    "        inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01\n",
    "        # query the network\n",
    "        outputs = n_21.query(inputs)\n",
    "        # the index of the highest value corresponds to the label\n",
    "        label = numpy.argmax(outputs)\n",
    "        # append correct or incorrect to list\n",
    "        if (label == correct_label):\n",
    "            #print(f\"The number {label} was corrctly detected with a score of {outputs[label]}\")\n",
    "            # network's answer matches correct answer, add 1 to scorecard\n",
    "            scorecard.append(1)\n",
    "        else:\n",
    "            #print(f\"The number {label} was incorrctly detected with a score of {outputs[label]}, was {correct_label}\")\n",
    "            # network's answer doesn't match correct answer, add 0 to scorecard\n",
    "            scorecard.append(0)\n",
    "            pass\n",
    "\n",
    "        pass\n",
    "\n",
    "    # calculate the performance score, the fraction of correct answers\n",
    "    scorecard_array = numpy.asarray(scorecard)\n",
    "    #print (\"performance = \", scorecard_array.sum() / scorecard_array.size)\n",
    "    performance = scorecard_array.sum() / scorecard_array.size\n",
    "\n",
    "    performace_scorecard_1.append(performance)\n",
    "    \n",
    "print('Learning rates are:', learning_rate)\n",
    "print('Performance scorecard is:', performace_scorecard_1)\n",
    "\n",
    "#Plotting a graph using 'myplot_function' function created above\n",
    "myplot_function(learning_rate, performace_scorecard_1, 'Learning rates', 'Performace', 'Learning rate Vs Performance graph!')\n",
    "\n",
    "t6 = time.time()\n",
    "print('Time for the task:', t6-t5, 'seconds')  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d308a88b",
   "metadata": {},
   "source": [
    "Try to give a short hypothesis why it behaves as observed:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30dfbf87",
   "metadata": {},
   "source": [
    "**ANSWER:-**\n",
    "\n",
    "(1) The amount that the weights are updated during training is referred to as the step size or the “learning rate.” The learning rate hyperparameter controls the rate or speed at which the model learns. \n",
    "\n",
    "(2) In the first figure, our highest performance occurs at 0.1 and it starts decreasing. Therefore, in the next cell, two other learning rates 0.07 and 0.15 are added around 0.1 learning rate and later I cheked the performance. \n",
    "\n",
    "(3) In the second figure, now highest performance occurs at learning rate 0.07 and later, performance decreases gradually. Our worst performance, 0.9479 occurs on 0.4 learning rate. Second lowest performance occurs on 0.1 learning rate. \n",
    "\n",
    "(4) In first figure above, when learning rates increase from 0.07, performance decreases gradually. The reason behind it is, a learning rate that is too large will result in weight updates that will be too large and the performance of the model (such as its loss on the training dataset) will oscillate over training epochs. And large learning rate can cause the model to converge too quickly to a **suboptimal** solution. \n",
    "\n",
    "(5) In same Figure, When learning rate is below 0.07, that means on learning rate 0.01, performance decreases there also. This is because, a learning rate that is too small may never converge or may get stuck on a **suboptimal** solution."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "437da501",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b7166270",
   "metadata": {},
   "source": [
    "## Task 3: Influence of number of epochs (4 Point)\n",
    "\n",
    "Take five leaning rates from task 2, that had shown reasonable performance, and test each of them with 1, 3, 5, 10, 50 epochs.\n",
    "Visualize the results (e.g. a heatmap).\n",
    "\n",
    "Code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "2d9747a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.01 0.07 0.1  0.15 0.2  0.3  0.4 ]\n",
      "[0.9524 0.9744 0.9729 0.972  0.9685 0.9588 0.9479]\n",
      "Top 5 learning rates are [0.07, 0.1, 0.15, 0.2, 0.3] which we will use to run next cell below.\n"
     ]
    }
   ],
   "source": [
    "#Finding 5 learning rates which has highest performance from previous task\n",
    "\n",
    "import numpy as np\n",
    "lr = np.array(learning_rate)\n",
    "performance = np.array(performace_scorecard_1)\n",
    "print(lr)\n",
    "print(performance)\n",
    "a = 5\n",
    "\n",
    "indices = (-performance).argsort()[:a]\n",
    "\n",
    "learning_rate = []\n",
    "for i in range(len(indices)):\n",
    "    le_ra = lr[indices[i]]\n",
    "    learning_rate.append(le_ra)\n",
    "\n",
    "learning_rate.sort()\n",
    "    \n",
    "print('Top 5 learning rates are', learning_rate, 'which we will use to run next cell below.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "591679af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "performance scorecard for learning rate 0.07 is: [0.9489, 0.9736, 0.9768, 0.9755, 0.9708] for the Epoch 1, 3, 5, 10, 30 respectively\n",
      "performance scorecard for learning rate 0.1 is: [0.9545, 0.9719, 0.9752, 0.9725, 0.9645] for the Epoch 1, 3, 5, 10, 30 respectively\n",
      "performance scorecard for learning rate 0.15 is: [0.9595, 0.9707, 0.9723, 0.9702, 0.961] for the Epoch 1, 3, 5, 10, 30 respectively\n",
      "performance scorecard for learning rate 0.2 is: [0.9595, 0.9676, 0.9672, 0.9625, 0.9543] for the Epoch 1, 3, 5, 10, 30 respectively\n",
      "performance scorecard for learning rate 0.3 is: [0.9575, 0.9612, 0.9595, 0.9526, 0.9515] for the Epoch 1, 3, 5, 10, 30 respectively\n",
      "Time for the completing whole task: 15184.809830665588 seconds\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "t9 = time.time()\n",
    "# number of input, hidden and output nodes\n",
    "input_nodes = 784\n",
    "hidden_nodes = 200\n",
    "output_nodes = 10\n",
    "\n",
    "epoch_time_testing = []                                                          #to store all time values (in seconds) in a single row\n",
    "oneD_array = []                                                                  #to store all performance values in a single row\n",
    "for i in range(len(learning_rate)):\n",
    "    performance_scorecard_2 = []                                                 #to store performance values of every learningr rate in a single row\n",
    "     \n",
    "    # create instance of neural network\n",
    "    # I have used different name of every instance of neural network to prevent data overwriting!\n",
    "    n_3 = neuralNetwork(input_nodes,hidden_nodes,output_nodes, learning_rate[i])\n",
    "\n",
    "    # load the mnist training data CSV file into a list\n",
    "    training_data_file = open(\"mnist_train.csv\", 'r')\n",
    "    training_data_list = training_data_file.readlines()\n",
    "    training_data_file.close()\n",
    "\n",
    "\n",
    "    # train the neural network\n",
    "\n",
    "    # epochs is the number of times the training data set is used for training\n",
    "    # I have changed epoch from '50' to epoch '30' in the 'epoch_test_container' below because after epoch 30, performance is degrading already and 50 epochs consumes more time as well.\n",
    "    epoch_test_container = [1, 3, 5, 10, 30]                                     # initializing every Epochs values in a list     \n",
    "    for j in range(len(epoch_test_container)):\n",
    "        epochs = epoch_test_container[j]\n",
    "        t7 = time.time()\n",
    "        for e in range(epochs):\n",
    "            # go through all records in the training data set\n",
    "            for record in training_data_list:\n",
    "                # split the record by the ',' commas\n",
    "                all_values = record.split(',')\n",
    "                # scale and shift the inputs\n",
    "                inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01\n",
    "                # create the target output values (all 0.01, except the desired label which is 0.99)\n",
    "                targets = numpy.zeros(output_nodes) + 0.01\n",
    "                # all_values[0] is the target label for this record\n",
    "                targets[int(all_values[0])] = 0.99\n",
    "                n_3.train(inputs, targets)\n",
    "                pass\n",
    "            pass\n",
    "\n",
    "        # Loading the test data\n",
    "        # load the mnist test data CSV file into a list\n",
    "        test_data_file = open(\"mnist_test.csv\", 'r')\n",
    "        test_data_list = test_data_file.readlines()\n",
    "        test_data_file.close()\n",
    "\n",
    "        # scorecard for how well the network performs, initially empty\n",
    "        scorecard = []\n",
    "\n",
    "        # go through all the records in the test data set\n",
    "        for record in test_data_list:\n",
    "            # split the record by the ',' commas\n",
    "            all_values = record.split(',')\n",
    "            # correct answer is first value\n",
    "            correct_label = int(all_values[0])\n",
    "            # scale and shift the inputs\n",
    "            inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01\n",
    "            # query the network\n",
    "            outputs = n_3.query(inputs)\n",
    "            # the index of the highest value corresponds to the label\n",
    "            label = numpy.argmax(outputs)\n",
    "            # append correct or incorrect to list\n",
    "            if (label == correct_label):\n",
    "                #print(f\"The number {label} was corrctly detected with a score of {outputs[label]}\")\n",
    "                # network's answer matches correct answer, add 1 to scorecard\n",
    "                scorecard.append(1)\n",
    "            else:\n",
    "                #print(f\"The number {label} was incorrctly detected with a score of {outputs[label]}, was {correct_label}\")\n",
    "                # network's answer doesn't match correct answer, add 0 to scorecard\n",
    "                scorecard.append(0)\n",
    "                pass\n",
    "\n",
    "            pass\n",
    "        \n",
    "        # calculate the performance score, the fraction of correct answers\n",
    "        scorecard_array = numpy.asarray(scorecard)\n",
    "        #print (\"performance = \", scorecard_array.sum() / scorecard_array.size)\n",
    "\n",
    "        performance = scorecard_array.sum() / scorecard_array.size\n",
    "\n",
    "        oneD_array.append(performance)                                         # storing performance values in an array\n",
    "        performance_scorecard_2.append(performance)                            # storing performance values in a scorecard array\n",
    "        t8 = time.time()\n",
    "        epoch_time_testing.append(t8-t7)                                       # storing testing time in an array\n",
    "    \n",
    "    print('performance scorecard for learning rate', learning_rate[i], 'is:', performance_scorecard_2, 'for the Epoch 1, 3, 5, 10, 30 respectively')   #performance for epochs[1, 3, 5, 10, 30]\n",
    "\n",
    "t10 = time.time()\n",
    "print('Time for the completing whole task:', t10-t9, 'seconds')        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8f07e4b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataframe generated of performances from epochs and learning rates is as below\n",
      "           1       3       5      10      30\n",
      "0.07  0.9489  0.9736  0.9768  0.9755  0.9708\n",
      "0.10  0.9545  0.9719  0.9752  0.9725  0.9645\n",
      "0.15  0.9595  0.9707  0.9723  0.9702  0.9610\n",
      "0.20  0.9595  0.9676  0.9672  0.9625  0.9543\n",
      "0.30  0.9575  0.9612  0.9595  0.9526  0.9515\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "###....Plotting a Heatmap to visulize the results....###\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "my_array = np.array(oneD_array)                                                        #Converting OneD_array from List to numpy array\n",
    "twoD_array = my_array.reshape(5,5)                                                     #Converting FROM One dimensional array TO two Dimensional array\n",
    "#print('Two Dimensional Array for performances is:', twoD_array)\n",
    "df1 = pd.DataFrame(twoD_array)                                                         #Converting two dimensional array into a Panda's Dataframe\n",
    "df1.columns = ['1', '3', '5', '10', '30']                                              #Writing a column names in a obtained Dataframe \n",
    "df1.index = (learning_rate)                                                            #Making 'index' column with a values of learning rates \n",
    "print('Dataframe generated of performances from epochs and learning rates is as below')\n",
    "print(df1)\n",
    "\n",
    "plt.figure(figsize=(10,10))                                                            #Setting siez 10 X 10 of a Heatmap \n",
    "df_heatmap = sns.heatmap(df1, annot=True, cmap=\"Greens\")                               #Passing Dataframe in a Heatmap syntax\n",
    "plt.title('Heatmap of performance rates with respect to epochs and learning rates', fontsize = 15) # title with fontsize 20\n",
    "plt.xlabel('Epochs', fontsize = 20)                                                    # x-axis label with fontsize 15\n",
    "plt.ylabel('learning rates', fontsize = 20)                                            # y-axis label with fontsize 15\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f61155eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataframe generated of time (in seconds) taken by every epochs and learning rates is as below\n",
      "              1           3           5          10           30\n",
      "0.07  65.755208  193.881621  329.551640  646.044649  1936.669022\n",
      "0.10  66.721465  196.717407  324.353861  598.521381  1792.205680\n",
      "0.15  62.662712  184.246958  306.421028  609.586647  1831.129441\n",
      "0.20  62.968539  185.110576  306.824906  612.094738  1832.939854\n",
      "0.30  62.987599  185.337213  308.320397  614.116340  1868.230540\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "###....Plotting a Heatmap to visulize the time taken to find performance by every epoch and learning rate....###\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "epoch_array = np.array(epoch_time_testing)                                 #Converting 'epoch_array' from List to numpy array\n",
    "epoch_twoD_array = epoch_array.reshape(5,5)                                #Converting FROM numpy One dimensional arraY TO numpy  two Dimensional array\n",
    "df2 = pd.DataFrame(epoch_twoD_array)                                       #Converting two dimensional array into a Panda's Dataframe\n",
    "df2.columns = ['1', '3', '5', '10', '30']\n",
    "df2.index = (learning_rate)\n",
    "print('Dataframe generated of time (in seconds) taken by every epochs and learning rates is as below')\n",
    "print(df2)\n",
    "\n",
    "plt.figure(figsize=(10,10))\n",
    "df_heatmap = sns.heatmap(df2, annot=True, cmap=\"Greens\")\n",
    "plt.title('Heatmap of time (in seconds) taken by every epochs and learning rates', fontsize = 15) # title with fontsize 20\n",
    "plt.xlabel('Epochs', fontsize = 20) # x-axis label with fontsize 15\n",
    "plt.ylabel('learning rates', fontsize = 20) # y-axis label with fontsize 15\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa682182",
   "metadata": {},
   "source": [
    "Discuss the observed results:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c42312b3",
   "metadata": {},
   "source": [
    "**Observations:-**\n",
    "\n",
    "(1) I have chosen best 5 learning rate from task 3 and run this task using each learning rate with every epoch. \n",
    "\n",
    "(2) It can be noticed that, performance increases as number of epochs increases. As the heatmap of performance with respect to learning rate and epoch shows, our highest performance, 0.98 occurs at learning rate 0.07 learning rate with 5 and 10 epoch and 0.1 learning rate with 5 epoch. After 5 epoch, performance decreases again in epoch 10 except in learning rate 0.07 and in epoch 30. Worst performance, 0.95 can be seen in 0.07 learning rate & 1 epoch, 0.3 learning rate & 10 and 30 epoch, 0.2 learning rate and 30 epoch.\n",
    "\n",
    "(3) In the heatmap of performance with respect to learning rate and epoch, it can be seen that, epoch 10 takes almost double time to calculate than epoch 5 and still give same performance as epoch 5 gives. Therefore 0.07 learning rate and 5 epoch can be the best combination because it give highest performance in a comparatively less computing time.   "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23eed44c",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "65795816",
   "metadata": {},
   "source": [
    "## Task 4: Size of the hidden layer (3 Points)\n",
    "\n",
    "Get a good combination of learning rate and number of epochs from task 3 (good results, not too much computing time) and try at least 10 different sizes of the hidden layer in the range of 5 to 1000.\n",
    "Output the performance and the time the training and testing took.\n",
    "\n",
    "Code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0581f2a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---> From above task, we can clearly see that, we got our best performance rate 0.98 for learning rate 0.07 while using epochs\n",
    "# 5 and 10 and on 0.1 and 5 as learning rate and epoch respectively. \n",
    "\n",
    "# ---> We can see in the time plot above that program takes double time to execute it with epoch 10 than with epoch 5. Moreover,\n",
    "# epoch 5 & epoch 10 both are giving same performance rate (0.98). Therefore using epoch 5 is less time consuming.\n",
    "\n",
    "# ---> As our best combination, I have chosen 0.07 and 5 as learning rate and epoch respectively which I have used below in a task 4. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b6f70f6f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------------------------------------------------\n",
      "performance for Hidden nodes 5 is: 0.7173\n",
      "training time for Hidden nodes 5 is: 44.34 seconds\n",
      "testing time for Hidden nodes 5 is: 1.31 seconds\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "performance for Hidden nodes 50 is: 0.9589\n",
      "training time for Hidden nodes 50 is: 81.73 seconds\n",
      "testing time for Hidden nodes 50 is: 1.86 seconds\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "performance for Hidden nodes 150 is: 0.9719\n",
      "training time for Hidden nodes 150 is: 130.81 seconds\n",
      "testing time for Hidden nodes 150 is: 1.94 seconds\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "performance for Hidden nodes 300 is: 0.9736\n",
      "training time for Hidden nodes 300 is: 432.82 seconds\n",
      "testing time for Hidden nodes 300 is: 2.04 seconds\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "performance for Hidden nodes 400 is: 0.9759\n",
      "training time for Hidden nodes 400 is: 542.9 seconds\n",
      "testing time for Hidden nodes 400 is: 2.14 seconds\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "performance for Hidden nodes 500 is: 0.9765\n",
      "training time for Hidden nodes 500 is: 671.86 seconds\n",
      "testing time for Hidden nodes 500 is: 2.18 seconds\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "performance for Hidden nodes 600 is: 0.9756\n",
      "training time for Hidden nodes 600 is: 752.6 seconds\n",
      "testing time for Hidden nodes 600 is: 2.11 seconds\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "performance for Hidden nodes 700 is: 0.9745\n",
      "training time for Hidden nodes 700 is: 854.47 seconds\n",
      "testing time for Hidden nodes 700 is: 2.15 seconds\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "performance for Hidden nodes 800 is: 0.975\n",
      "training time for Hidden nodes 800 is: 984.0 seconds\n",
      "testing time for Hidden nodes 800 is: 2.22 seconds\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "performance for Hidden nodes 900 is: 0.9756\n",
      "training time for Hidden nodes 900 is: 1107.21 seconds\n",
      "testing time for Hidden nodes 900 is: 2.27 seconds\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "performance for Hidden nodes 1000 is: 0.9746\n",
      "training time for Hidden nodes 1000 is: 1226.89 seconds\n",
      "testing time for Hidden nodes 1000 is: 2.29 seconds\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "Summary of the task is as below,\n",
      "Learning rate is: 0.07\n",
      "Epichs is: 5\n",
      "Hidden nodes are: [5, 50, 150, 300, 400, 500, 600, 700, 800, 900, 1000]\n",
      "Performance scorecard is: [0.7173, 0.9589, 0.9719, 0.9736, 0.9759, 0.9765, 0.9756, 0.9745, 0.975, 0.9756, 0.9746]\n",
      "Training Time taken in seconds by Hidden layers according to different hidden nodes is: [44.34, 81.73, 130.81, 432.82, 542.9, 671.86, 752.6, 854.47, 984.0, 1107.21, 1226.89]\n",
      "Testing Time taken in seconds by Hidden layers according to different hidden nodes is: [1.31, 1.86, 1.94, 2.04, 2.14, 2.18, 2.11, 2.15, 2.22, 2.27, 2.29]\n",
      "Time for the completing whole task: 6852.31 seconds\n"
     ]
    }
   ],
   "source": [
    "#from above task (task 3), I have selected learning rate 0.07 and epoch 5 as a best combination.\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import time\n",
    "\n",
    "t11 = time.time()\n",
    "# number of input, hidden and output nodes\n",
    "input_nodes = 784\n",
    "output_nodes = 10\n",
    "\n",
    "hidden_nodes = [5, 50, 150, 300, 400, 500, 600, 700, 800, 900, 1000]       # Container of Hidden layers as List          \n",
    "oneDime_array_trainingt = []                                               # initialization of list, which will store training time\n",
    "oneDime_array_testingt = []                                                # initialization of list, which will store testing time\n",
    "performace_scorecard_3 = []                                                # initialization of list, which will performance rates\n",
    "\n",
    "for k in range(len(hidden_nodes)):\n",
    "    # learning rate\n",
    "    learning_rate = 0.07\n",
    "\n",
    "    # create instance of neural network\n",
    "    # I have used different name of every instance of neural network to prevent data overwriting!\n",
    "    n_4 = neuralNetwork(input_nodes,hidden_nodes[k],output_nodes, learning_rate)\n",
    "    \n",
    "    t13 = time.time()\n",
    "    # load the mnist training data CSV file into a list\n",
    "    training_data_file = open(\"mnist_train.csv\", 'r')\n",
    "    training_data_list = training_data_file.readlines()\n",
    "    training_data_file.close()\n",
    "\n",
    "\n",
    "    # train the neural network\n",
    "\n",
    "    # epochs is the number of times the training data set is used for training\n",
    "    epochs = 5\n",
    "\n",
    "    for e in range(epochs):\n",
    "        # go through all records in the training data set\n",
    "        for record in training_data_list:\n",
    "            # split the record by the ',' commas\n",
    "            all_values = record.split(',')\n",
    "            # scale and shift the inputs\n",
    "            inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01\n",
    "            # create the target output values (all 0.01, except the desired label which is 0.99)\n",
    "            targets = numpy.zeros(output_nodes) + 0.01\n",
    "            # all_values[0] is the target label for this record\n",
    "            targets[int(all_values[0])] = 0.99\n",
    "            n_4.train(inputs, targets)\n",
    "            pass\n",
    "        pass\n",
    "    t14 = time.time()\n",
    "    # Loading the test data\n",
    "    # load the mnist test data CSV file into a list\n",
    "    test_data_file = open(\"mnist_test.csv\", 'r')\n",
    "    test_data_list = test_data_file.readlines()\n",
    "    test_data_file.close()\n",
    "\n",
    "    # scorecard for how well the network performs, initially empty\n",
    "    scorecard = []\n",
    "\n",
    "    # go through all the records in the test data set\n",
    "    for record in test_data_list:\n",
    "        # split the record by the ',' commas\n",
    "        all_values = record.split(',')\n",
    "        # correct answer is first value\n",
    "        correct_label = int(all_values[0])\n",
    "        # scale and shift the inputs\n",
    "        inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01\n",
    "        # query the network\n",
    "        outputs = n_4.query(inputs)\n",
    "        # the index of the highest value corresponds to the label\n",
    "        label = numpy.argmax(outputs)\n",
    "        # append correct or incorrect to list\n",
    "        if (label == correct_label):\n",
    "            #print(f\"The number {label} was corrctly detected with a score of {outputs[label]}\")\n",
    "            # network's answer matches correct answer, add 1 to scorecard\n",
    "            scorecard.append(1)\n",
    "        else:\n",
    "            #print(f\"The number {label} was incorrctly detected with a score of {outputs[label]}, was {correct_label}\")\n",
    "            # network's answer doesn't match correct answer, add 0 to scorecard\n",
    "            scorecard.append(0)\n",
    "            pass\n",
    "\n",
    "        pass\n",
    "\n",
    "    # calculate the performance score, the fraction of correct answers\n",
    "    scorecard_array = numpy.asarray(scorecard)\n",
    "    performance = scorecard_array.sum() / scorecard_array.size\n",
    "    performace_scorecard_3.append(performance)\n",
    "    print('-------------------------------------------------------------------------------------------------------')\n",
    "    print (\"performance for Hidden nodes\",hidden_nodes[k], 'is:', performance)\n",
    "    t15 = time.time()\n",
    "    print('training time for Hidden nodes',hidden_nodes[k], 'is:', round(t14-t13,2), 'seconds')\n",
    "    oneDime_array_trainingt.append(round(t14-t13,2))\n",
    "    print('testing time for Hidden nodes',hidden_nodes[k], 'is:', round(t15-t14,2), 'seconds')\n",
    "    oneDime_array_testingt.append(round(t15-t14,2))\n",
    "    print('-------------------------------------------------------------------------------------------------------')\n",
    "\n",
    "print('Summary of the task is as below,')\n",
    "print('Learning rate is:', learning_rate)\n",
    "print('Epichs is:', epochs)\n",
    "print('Hidden nodes are:', hidden_nodes)\n",
    "print('Performance scorecard is:', performace_scorecard_3)\n",
    "print('Training Time taken in seconds by Hidden layers according to different hidden nodes is:', oneDime_array_trainingt)\n",
    "print('Testing Time taken in seconds by Hidden layers according to different hidden nodes is:', oneDime_array_testingt)\n",
    "\n",
    "t12 = time.time()\n",
    "print('Time for the completing whole task:', round(t12-t11,2), 'seconds')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "34ea09bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plotting the graph of Hidden nodes Vs Performance\n",
    "myplot_function(hidden_nodes, performace_scorecard_3, 'Hidden nodes', 'Performance', 'Hidden_nodes Vs Performance graph')\n",
    "\n",
    "# plotting the graph of Hidden nodes Vs Training time(seconds)\n",
    "myplot_function(hidden_nodes, oneDime_array_trainingt, 'Hidden nodes', 'Training time (seconds)', 'Hidden nodes Vs Training time graph')\n",
    "\n",
    "# plotting the graph of Hidden nodes Vs Testing time(seconds)\n",
    "myplot_function(hidden_nodes, oneDime_array_testingt, 'Hidden nodes', 'Testing time (seconds)', 'Hidden nodes Vs Testing time')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fcbcc5c",
   "metadata": {},
   "source": [
    "Discuss the tradeoff between the performance (accuracy) of the ANN and the performance (computing time) observed:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d407e80",
   "metadata": {},
   "source": [
    "**Observation, and concluded points:-**\n",
    "\n",
    "(1) It can be observed that, performance increases when hidden nodes increases. In 'Hidden nodes vs Performance graph' above, it can be seen that 0.7173 performance achieved when using 5 number of hidden nodes. Performance becomes heigher when we use high number of hidden nodes. Highest performance is achieved on 500 hidden nodes, 0.9765 and it gives other performance around 0.9750 for remaining hidden nodes.\n",
    "\n",
    "(2) Computing time (Testing and Training time) also increases when number of nodes increases as it can be seen in 'Hidden nodes Vs Training time graph' and 'Hidden nodes vs Testing time graph'.\n",
    "\n",
    "(3) As the results shows, maximum performance occurs by using 500 hidden nodes. It takes lot of time to compute the performances for hidden nodes morethan 500, still it gives lower performance than we obtained using 500. Thus, it has no advantage to use morethan 500 hidden nodes as it gives the best result in comparatively less computing time."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59f47725",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a808e46a",
   "metadata": {},
   "source": [
    "## Task 5: Other activation function (4 Points)\n",
    "\n",
    "Search for other possible activation functions and choose one (e.g. tanh). Implement this activation function in an ANN and compare it to our existing ANN using one set of parameters (utilize task 3 to chose a reasonable one).\n",
    "\n",
    "Code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4f480c02",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "\n",
    "# class definition for the core structure\n",
    "class neural_Network_:\n",
    "    \n",
    "    # initialise the neural network\n",
    "    def __init__(self, input_nodes, hidden_nodes, output_nodes, learning_rate_alpha):\n",
    "        # set number of nodes in each input, hidden, output layer\n",
    "        self.inpnodes = input_nodes\n",
    "        self.hidnodes = hidden_nodes\n",
    "        self.outnodes = output_nodes\n",
    "        \n",
    "        # link weight matrices, wih and who\n",
    "        # weights inside the arrays are w_i_j, where link is from node i to node j in the next layer\n",
    "        # w11 w21\n",
    "        # w12 w22 etc \n",
    "        self.winphid = numpy.random.normal(0.0, pow(self.inpnodes, -0.5), (self.hidnodes, self.inpnodes))\n",
    "        self.whidout = numpy.random.normal(0.0, pow(self.hidnodes, -0.5), (self.outnodes, self.hidnodes))\n",
    "\n",
    "        # learning rate\n",
    "        self.learningrate = learning_rate_alpha\n",
    "        \n",
    "        # activation function is the sigmoid function\n",
    "        #self.activation_func = lambda x: numpy.tanh(x)\n",
    "        \n",
    "        # ---> I have removed 'lambda x:' because 'numpy.tanh' is itself a function. Consequently this introduced an extra \n",
    "        # computational cost for absolutely no benefit. I have used 'numpy.tanh'.\n",
    "        self.activation_func = numpy.tanh\n",
    "        \n",
    "        pass\n",
    "\n",
    "\n",
    "    \n",
    "    # train the neural network\n",
    "    def train(self, inp_list, tar_list):\n",
    "        # convert inputs list to 2d array\n",
    "        inputs_i = numpy.array(inp_list, ndmin=2).T\n",
    "        targets_i = numpy.array(tar_list, ndmin=2).T\n",
    "        \n",
    "        # calculate signals into hidden layer\n",
    "        hid_inp = numpy.dot(self.winphid, inputs_i)\n",
    "        # calculate the signals emerging from hidden layer\n",
    "        hid_out = self.activation_func(hid_inp)\n",
    "        \n",
    "        # calculate signals into final output layer\n",
    "        final_inp = numpy.dot(self.whidout, hid_out)\n",
    "        # calculate the signals emerging from final output layer\n",
    "        final_out = self.activation_func(final_inp)\n",
    "        \n",
    "        # output layer error is the (target - actual)\n",
    "        out_err = targets_i - final_out\n",
    "        # hidden layer error is the output_errors, split by weights, recombined at hidden nodes\n",
    "        hid_err = numpy.dot(self.whidout.T, out_err) \n",
    "        \n",
    "        # update the weights for the links between the hidden and output layers\n",
    "        self.whidout += self.learningrate * numpy.dot(out_err * (1-(final_out)**2),numpy.transpose(hid_out))\n",
    "        \n",
    "        # update the weights for the links between the input and hidden layers\n",
    "        self.winphid += self.learningrate * numpy.dot(hid_err * (1-(hid_out)**2),numpy.transpose(inputs_i))\n",
    "        \n",
    "        pass\n",
    "\n",
    "    \n",
    "    # query the neural network\n",
    "    def query(self, inp_list):\n",
    "        # convert inputs list to 2d array\n",
    "        inputs_i = numpy.array(inp_list, ndmin=2).T\n",
    "        \n",
    "        # calculate signals into hidden layer\n",
    "        hid_inp = numpy.dot(self.winphid, inputs_i)\n",
    "        # calculate the signals emerging from hidden layer\n",
    "        hid_out = self.activation_func(hid_inp)\n",
    "        \n",
    "        # calculate signals into final output layer\n",
    "        final_inp = numpy.dot(self.whidout, hid_out)\n",
    "        # calculate the signals emerging from final output layer\n",
    "        final_out = self.activation_func(final_inp)\n",
    "        \n",
    "        return final_out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f6c2a62c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy\n",
    "\n",
    "def my_task5_function(inputnodes, hiddennodes, outputnodes, leanrningrate, epochsvalue, instance_name):\n",
    "    \n",
    "    t16 = time.time()\n",
    "    # number of input, hidden and output nodes\n",
    "    inp_nodes = inputnodes                                             # value of input layer nodes\n",
    "    hid_nodes = hiddennodes                                            # value of hidden layer nodes\n",
    "    out_nodes = outputnodes                                            # value of output layer nodes\n",
    "\n",
    "    # learning rate\n",
    "    my_task5_function.lr = leanrningrate                               # value of learning rate\n",
    "\n",
    "    # create instance of neural network\n",
    "    # I have used different name of every instance of neural network to prevent data overwriting!\n",
    "    instance_name = neural_Network_(inp_nodes,hid_nodes,out_nodes, leanrningrate)\n",
    "\n",
    "    # load the mnist training data CSV file into a list\n",
    "    training_data_file = open(\"mnist_train.csv\", 'r')\n",
    "    training_data_list = training_data_file.readlines()\n",
    "    training_data_file.close()\n",
    "\n",
    "\n",
    "    # train the neural network\n",
    "\n",
    "    # epochs is the number of times the training data set is used for training\n",
    "    epochs = epochsvalue                                               # value of epochs\n",
    "\n",
    "    for e in range(epochs):\n",
    "        # go through all records in the training data set\n",
    "        for record in training_data_list:\n",
    "            # split the record by the ',' commas\n",
    "            all_values = record.split(',')\n",
    "            # scale and shift the inputs\n",
    "            inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01\n",
    "            # create the target output values (all 0.01, except the desired label which is 0.99)\n",
    "            targets = numpy.zeros(out_nodes) + 0.01\n",
    "            # all_values[0] is the target label for this record\n",
    "            targets[int(all_values[0])] = 0.99\n",
    "            instance_name.train(inputs, targets)\n",
    "            pass\n",
    "        pass\n",
    "\n",
    "    # Loading the test data\n",
    "    # load the mnist test data CSV file into a list\n",
    "    test_data_file = open(\"mnist_test.csv\", 'r')\n",
    "    test_data_list = test_data_file.readlines()\n",
    "    test_data_file.close()\n",
    "\n",
    "    # scorecard for how well the network performs, initially empty\n",
    "    scorecard = []\n",
    "\n",
    "    # go through all the records in the test data set\n",
    "    for record in test_data_list:\n",
    "        # split the record by the ',' commas\n",
    "        all_values = record.split(',')\n",
    "        # correct answer is first value\n",
    "        correct_label = int(all_values[0])\n",
    "        # scale and shift the inputs\n",
    "        inputs_i = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01\n",
    "        # query the network\n",
    "        outputs_o = instance_name.query(inputs_i)\n",
    "        # the index of the highest value corresponds to the label\n",
    "        label = numpy.argmax(outputs_o)\n",
    "        # append correct or incorrect to list\n",
    "        if (label == correct_label):\n",
    "            #print(f\"The number {label} was corrctly detected with a score of {outputs_o[label]}\")\n",
    "            # network's answer matches correct answer, add 1 to scorecard\n",
    "            scorecard.append(1)\n",
    "        else:\n",
    "            #print(f\"The number {label} was incorrctly detected with a score of {outputs_o[label]}, was {correct_label}\")\n",
    "            # network's answer doesn't match correct answer, add 0 to scorecard\n",
    "            scorecard.append(0)\n",
    "            pass\n",
    "\n",
    "        pass\n",
    "\n",
    "    # calculate the performance score, the fraction of correct answers\n",
    "    scorecard_array = numpy.asarray(scorecard)\n",
    "    #func.variable = lr_alpha\n",
    "    my_task5_function.performance = scorecard_array.sum() / scorecard_array.size\n",
    "    print('Learning rate is:', my_task5_function.lr)\n",
    "    print (\"performance = \", my_task5_function.performance)\n",
    "\n",
    "    t17 =  time.time()\n",
    "    print (\"Time taken to complete task is = \", round(t17-t16,2), 'seconds')\n",
    "    return my_task5_function.lr, my_task5_function.performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "0c683fef",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate is: 0.07\n",
      "performance =  0.8678\n",
      "Time taken to complete task is =  311.58 seconds\n"
     ]
    }
   ],
   "source": [
    "# here I have choosed 0.07 as learning rate because I got my best performance on this learning rate as we saw in task 3.\n",
    "my_task5_function(784, 200, 10, 0.07, 5, 'n_5')                   # choosing learning rate 0.07\n",
    "first_lr = my_task5_function.lr                                   # catching value of learning rate from function\n",
    "first_per = my_task5_function.performance                         # catching value of performance from function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1412d8f",
   "metadata": {},
   "source": [
    "We got our performance for 3 layer ANN by using best combination we got from task 3. Now I want to check performance of 3 \n",
    "layer neural network using different learning rate **0.01 and 0.01** and want to compare the performance that I have done in cells below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "cef72b53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate is: 0.01\n",
      "performance =  0.9353\n",
      "Time taken to complete task is =  312.4 seconds\n"
     ]
    }
   ],
   "source": [
    "my_task5_function(784, 200, 10, 0.01, 5, 'n_6')                    # choosing learning rate 0.01\n",
    "# here I have choosed 0.07 as learning rate because I got my best performance on this learning rate as we saw in task 3.\n",
    "second_lr = my_task5_function.lr                                   # catching value of learning rate from function\n",
    "second_per = my_task5_function.performance                         # catching value of performance from function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "dfcde21e",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate is: 0.1\n",
      "performance =  0.2007\n",
      "Time taken to complete task is =  311.11 seconds\n"
     ]
    }
   ],
   "source": [
    "my_task5_function(784, 200, 10, 0.1, 5, 'n_7')                     # choosing learning rate 0.1\n",
    "# here I have choosed 0.07 as learning rate because I got my best performance on this learning rate as we saw in task 3.\n",
    "third_lr = my_task5_function.lr                                   # catching value of learning rate from function\n",
    "third_per = my_task5_function.performance                         # catching value of performance from function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "136569f6",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(first_lr, first_per, marker = 'o')                       # plotting a point of first learning rate and performance  \n",
    "plt.plot(second_lr,second_per, marker = 'o')                      # plotting a point of second learning rate and performance\n",
    "plt.plot(third_lr,third_per, marker = 'o')                        # plotting a point of third learning rate and performance\n",
    "plt.xlabel('Learning rate')                                       # defining x axis label                     \n",
    "plt.ylabel('Performancne')                                        # defining y axis label                        \n",
    "plt.title('Learning rate vs Performance using \"tanh\" activation function')               \n",
    "plt.xlim(0, 0.15), plt.ylim(0, 1)\n",
    "plt.legend([\"Learning rate= 0.07\", \"Learning rate= 0.01\", \"Learning rate= 0.1\"], loc =\"upper right\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "decc8e33",
   "metadata": {},
   "source": [
    "What are your observations?\n",
    "\n",
    "Was the comparison fair? If not explain what needed to be done to make the comparison fair."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ae011ad",
   "metadata": {},
   "source": [
    "**Observations:-**\n",
    "\n",
    "Activation function:-An activation function in a neural network defines how the weighted sum of the input is transformed into an output from a node or nodes in a layer of the network.\n",
    "\n",
    "I have taken 0.07 learning rate and 5 epochs for this task, because my maximum performance occurs at this combination. \n",
    "I have observed that, while using 'tanh' avtivation function and above parameters, performance is obtained 0.8678 which is less less than earlier 3 layer ANN with 'sigmoid' activation function which is 0.9768. Thus, comparision of both ANN, for this parameters, is not fair. \n",
    "\n",
    "**To make a Comparision fair:-**\n",
    "\n",
    "(1) Learning rate can be changed while using different activation function. Thus, it can give an improvement in the performance. For ex. I have changed learning rate 0.01 and 0.1 from 0.07 and it gives 0.9353, 0.2007 performance respectively for ANN using 'tanh'activation function. Here lower learning rates results into high performance and hence, it can be said that, different activation function requires different learning rate and epoch combination to make the performance better. \n",
    "\n",
    "(2) Another point is, we should check performance for every combination of learning rate and epoch and then we should findout our best combination according to the highest performance and time taken like we did in task 3. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c72d913e",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "cdc1c0ba",
   "metadata": {},
   "source": [
    "## Task 6: More Layer (5 Points)\n",
    "\n",
    "Add a second hidden layer to our (original) neural network.    \n",
    "Compare the ANN with at least 5 different eamples to a three layer network with the same (total) number of hidden nodes. Choose the other parameters from your experience.\n",
    "\n",
    "Code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "214e6c0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "# scipy.special for the sigmoid function expit()\n",
    "import scipy.special \n",
    "\n",
    "# class definition for the core structure\n",
    "class neuralNetwork2:\n",
    "    \n",
    "    # initialise the neural network\n",
    "    def __init__(self, inputnodes1, hiddennodes1, hiddennodes2, outputnodes1, learn_rate):\n",
    "        # set number of nodes in each input, hidden, output layer\n",
    "        self.ipnodes = inputnodes1\n",
    "        self.h1nodes = hiddennodes1\n",
    "        self.h2nodes = hiddennodes2\n",
    "        self.opnodes = outputnodes1\n",
    "        \n",
    "        # link weight matrices, wih and who\n",
    "        # weights inside the arrays are w_i_j, where link is from node i to node j in the next layer\n",
    "        # w11 w21\n",
    "        # w12 w22 etc \n",
    "        self.w_iphid1 = numpy.random.normal(0.0, pow(self.ipnodes, -0.5), (self.h1nodes, self.ipnodes))\n",
    "        self.w_hid1hid2 = numpy.random.normal(0.0, pow(self.h1nodes, -0.5), (self.h2nodes, self.h1nodes))\n",
    "        self.w_hid2op = numpy.random.normal(0.0, pow(self.h2nodes, -0.5), (self.opnodes, self.h2nodes))\n",
    "\n",
    "        # learning rate\n",
    "        self.learningrate1 = learn_rate\n",
    "        \n",
    "        # activation function is the sigmoid function\n",
    "        self.activation_function = lambda x: scipy.special.expit(x)\n",
    "        \n",
    "        pass\n",
    "\n",
    "\n",
    "    \n",
    "    # train the neural network\n",
    "    def train(self, ip_list, targetsvalue_list):\n",
    "        # convert inputs list to 2d array\n",
    "        ip_value = numpy.array(ip_list, ndmin=2).T\n",
    "        target_value = numpy.array(targetsvalue_list, ndmin=2).T\n",
    "        \n",
    "        # calculate signals into hidden layer1\n",
    "        hid1_ip = numpy.dot(self.w_iphid1, ip_value)\n",
    "        # calculate the signals emerging from hidden layer1\n",
    "        hid1_op = self.activation_function(hid1_ip)\n",
    "        \n",
    "        # calculate signals into hidden layer2\n",
    "        hid2_ip = numpy.dot(self.w_hid1hid2, hid1_op)\n",
    "        # calculate the signals emerging from hidden layer1\n",
    "        hid2_op = self.activation_function(hid2_ip)\n",
    "        \n",
    "        # calculate signals into final output layer\n",
    "        final_ip = numpy.dot(self.w_hid2op, hid2_op)\n",
    "        # calculate the signals emerging from final output layer\n",
    "        final_op = self.activation_function(final_ip)\n",
    "        \n",
    "        # output layer error is the (target - actual)\n",
    "        op_errors = target_value - final_op\n",
    "        \n",
    "        # hidden layer 2 error is the output_errors, split by weights, recombined at hidden nodes\n",
    "        hid2_errors = numpy.dot(self.w_hid2op.T, op_errors) \n",
    "        \n",
    "        # hidden layer 1 error is the output_errors, split by weights, recombined at hidden nodes\n",
    "        hid1_errors = numpy.dot(self.w_hid1hid2.T, hid2_errors)\n",
    "        \n",
    "        # update the weights for the links between the hidden layer 2 and output layers\n",
    "        self.w_hid2op += self.learningrate1 * numpy.dot((op_errors * final_op * (1.0 - final_op)), numpy.transpose(hid2_op))\n",
    "        \n",
    "        # update the weights for the links between the hidden layer 1 and hidden layer 2\n",
    "        self.w_hid1hid2 += self.learningrate1 * numpy.dot((hid2_errors * hid2_op * (1.0 - hid2_op)), numpy.transpose(hid1_op))\n",
    "        \n",
    "        # update the weights for the links between the input and hidden layers 1\n",
    "        self.w_iphid1 += self.learningrate1 * numpy.dot((hid1_errors * hid1_op * (1.0 - hid1_op)), numpy.transpose(ip_value))\n",
    "        \n",
    "        pass\n",
    "\n",
    "    \n",
    "    # query the neural network\n",
    "    def query(self, ip_list):\n",
    "        # convert inputs list to 2d array\n",
    "        ip_value = numpy.array(ip_list, ndmin=2).T\n",
    "        \n",
    "        # calculate signals into hidden layer 1\n",
    "        hid1_ip = numpy.dot(self.w_iphid1, ip_value)\n",
    "        # calculate the signals emerging from hidden layer\n",
    "        hid1_op = self.activation_function(hid1_ip)\n",
    "        \n",
    "        # calculate signals into hidden layer 2\n",
    "        hid2_ip = numpy.dot(self.w_hid1hid2, hid1_op)\n",
    "        # calculate the signals emerging from hidden layer\n",
    "        hid2_op = self.activation_function(hid2_ip)\n",
    "        \n",
    "        # calculate signals into final output layer\n",
    "        final_ip = numpy.dot(self.w_hid2op, hid2_op)\n",
    "        # calculate the signals emerging from final output layer\n",
    "        final_op = self.activation_function(final_ip)\n",
    "        \n",
    "        return final_op"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "5dd2bf2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time \n",
    "\n",
    "def myfunction_task6(learningrate, epoch_task6, instance_name, combi1, combi2, combi3, combi4, combi5, combi6):\n",
    "    \n",
    "    hid_combi = [(combi1), (combi2), (combi3), (combi4), (combi5), (combi6)]  #container of hidden nodes combination as tuple\n",
    "\n",
    "    hidden_layer1_nodes = [x[0] for x in hid_combi]                           #storing first value of every combination in a List\n",
    "    hidden_layer2_nodes = [x[1] for x in hid_combi]                           #storing second value of every combination in a List\n",
    "\n",
    "    t20 = time.time()\n",
    "    # number of input and output nodes\n",
    "    inp_nodes = 784\n",
    "    oup_nodes = 10\n",
    "\n",
    "    # learning rate\n",
    "    lr = learningrate                                                         # value of learning rate\n",
    "\n",
    "    perfo_array_oneD = []                                                     # initialization of array which will store performances\n",
    "\n",
    "    for m in range(len(hid_combi)):   \n",
    "        # create instance of neural network\n",
    "        t22 = time.time()\n",
    "        \n",
    "        # I have used different name of every instance of neural network to prevent data overwriting!\n",
    "        instance_name = neuralNetwork2(inp_nodes,hidden_layer1_nodes[m],hidden_layer2_nodes[m],oup_nodes, lr)\n",
    "\n",
    "        # load the mnist training data CSV file into a list\n",
    "        training_data_file = open(\"mnist_train.csv\", 'r')\n",
    "        training_data_list = training_data_file.readlines()\n",
    "        training_data_file.close()\n",
    "\n",
    "\n",
    "        # train the neural network\n",
    "\n",
    "        # epochs is the number of times the training data set is used for training\n",
    "        epochs = epoch_task6                                                  # value of epochs\n",
    "\n",
    "        for e in range(epochs):\n",
    "            # go through all records in the training data set\n",
    "            for record in training_data_list:\n",
    "                # split the record by the ',' commas\n",
    "                all_values = record.split(',')\n",
    "                # scale and shift the inputs\n",
    "                ip_value = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01\n",
    "                # create the target output values (all 0.01, except the desired label which is 0.99)\n",
    "                target_value = numpy.zeros(oup_nodes) + 0.01\n",
    "                # all_values[0] is the target label for this record\n",
    "                target_value[int(all_values[0])] = 0.99\n",
    "                instance_name.train(ip_value, target_value)\n",
    "                pass\n",
    "            pass\n",
    "\n",
    "        # Loading the test data\n",
    "        # load the mnist test data CSV file into a list\n",
    "        test_data_file = open(\"mnist_test.csv\", 'r')\n",
    "        test_data_list = test_data_file.readlines()\n",
    "        test_data_file.close()\n",
    "\n",
    "        # scorecard for how well the network performs, initially empty\n",
    "        scorecard = []\n",
    "\n",
    "        # go through all the records in the test data set\n",
    "        for record in test_data_list:\n",
    "            # split the record by the ',' commas\n",
    "            all_values = record.split(',')\n",
    "            # correct answer is first value\n",
    "            correct_label = int(all_values[0])\n",
    "            # scale and shift the inputs\n",
    "            ip_value = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01\n",
    "            # query the network\n",
    "            op_value = instance_name.query(ip_value)\n",
    "            # the index of the highest value corresponds to the label\n",
    "            label = numpy.argmax(op_value)\n",
    "            # append correct or incorrect to list\n",
    "            if (label == correct_label):\n",
    "                #print(f\"The number {label} was corrctly detected with a score of {op_value[label]}\")\n",
    "                # network's answer matches correct answer, add 1 to scorecard\n",
    "                scorecard.append(1)\n",
    "            else:\n",
    "                #print(f\"The number {label} was incorrctly detected with a score of {op_value[label]}, was {correct_label}\")\n",
    "                # network's answer doesn't match correct answer, add 0 to scorecard\n",
    "                scorecard.append(0)\n",
    "                pass\n",
    "\n",
    "            pass\n",
    "\n",
    "        # calculate the performance score, the fraction of correct answers\n",
    "        scorecard_array = numpy.asarray(scorecard)\n",
    "        performance = scorecard_array.sum() / scorecard_array.size\n",
    "        #print (\"performance = \", performance)\n",
    "        perfo_array_oneD.append(performance)                                      # appending performance values into array\n",
    "        t23 = time.time()\n",
    "\n",
    "        print('-------------------------------------------------------------------------------')\n",
    "        print('Hidden Nodes in 1st and 2nd layer respectively:', hid_combi[m])\n",
    "        print('Performance is:', performance)\n",
    "        print('Time taken to calculate performance is:', round(t23 - t22,2))\n",
    "        print('-------------------------------------------------------------------------------')\n",
    "\n",
    "    \n",
    "    print('Learning rate is:', lr)\n",
    "    print('Epochs is:', epochs)\n",
    "    print('Hidden layer combination is:', hid_combi)\n",
    "    print('Performance accordingly given combination is:', perfo_array_oneD)\n",
    "    myfunction_task6.per = perfo_array_oneD\n",
    "    myfunction_task6.hid_combi = hid_combi\n",
    "\n",
    "    t21 = time.time()\n",
    "    print('Time to complete whole task is:', round(t21-t20,2), 'seconds.')\n",
    "    \n",
    "    return myfunction_task6.hid_combi, myfunction_task6.per\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "aa1cf92c",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------------------------\n",
      "Hidden Nodes in 1st and 2nd layer respectively: (300, 100)\n",
      "Performance is: 0.9528\n",
      "Time taken to calculate performance is: 426.46\n",
      "-------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------\n",
      "Hidden Nodes in 1st and 2nd layer respectively: (150, 50)\n",
      "Performance is: 0.9387\n",
      "Time taken to calculate performance is: 135.63\n",
      "-------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------\n",
      "Hidden Nodes in 1st and 2nd layer respectively: (200, 100)\n",
      "Performance is: 0.948\n",
      "Time taken to calculate performance is: 309.76\n",
      "-------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------\n",
      "Hidden Nodes in 1st and 2nd layer respectively: (120, 280)\n",
      "Performance is: 0.9423\n",
      "Time taken to calculate performance is: 146.01\n",
      "-------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------\n",
      "Hidden Nodes in 1st and 2nd layer respectively: (20, 180)\n",
      "Performance is: 0.8908\n",
      "Time taken to calculate performance is: 73.36\n",
      "-------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------\n",
      "Hidden Nodes in 1st and 2nd layer respectively: (50, 250)\n",
      "Performance is: 0.9227\n",
      "Time taken to calculate performance is: 104.2\n",
      "-------------------------------------------------------------------------------\n",
      "Learning rate is: 0.07\n",
      "Epochs is: 5\n",
      "Hidden layer combination is: [(300, 100), (150, 50), (200, 100), (120, 280), (20, 180), (50, 250)]\n",
      "Performance accordingly given combination is: [0.9528, 0.9387, 0.948, 0.9423, 0.8908, 0.9227]\n",
      "Time to complete whole task is: 1195.42 seconds.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "([(300, 100), (150, 50), (200, 100), (120, 280), (20, 180), (50, 250)],\n",
       " [0.9528, 0.9387, 0.948, 0.9423, 0.8908, 0.9227])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# applying 0.01 learning rate in 4 Layer Neural Network to check its performance\n",
    "myfunction_task6(0.07, 5, 'n_8', (300,100), (150, 50), (200, 100), (120, 280), (20,180), (50, 250))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96ac8cc7",
   "metadata": {},
   "source": [
    "What are your observations?\n",
    "\n",
    "Was the comparison fair? If not explain what needed to be done to make the comparison fair."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c626d7d8",
   "metadata": {},
   "source": [
    "**Obesrvation, Comparision and explaination:-**\n",
    "\n",
    "(1) I have observed and compare the performances of 4 and 3 layer ANN which I have shown below,\n",
    "    Learning rate 0.07\n",
    "    Epoch 5\n",
    "    \n",
    "    Hidden Nodes combination     Performance in 4 layer ANN  Performance in 3 layer ANN\n",
    "    (300,100)                     0.9528                     0.9759 with 400 nodes  (Got it from task 4)\n",
    "    (120,280)                     0.9423                     0.9759 with 400 nodes  (Got it from task 4)\n",
    "    (200,100)                     0.9480                     0.9736 with 300 nodes  (Got it from task 4)\n",
    "    (50,250)                      0.9227                     0.9736 with 300 nodes  (Got it from task 4)\n",
    "    (150,50)                      0.9287                     0.9768 with 200 nodes  (Got it from task 3)\n",
    "    (20,180)                      0.8908                     0.9768 with 200 nodes  (Got it from task 3)\n",
    "    \n",
    "(2) It can be concluded from above that, 4 layer ANN gives lesser performance than 3 layer ANN for 0.07 learning rate and 5    epoch. Therefore, comparision of 3 and 4 layer ANN is not fair. \n",
    "\n",
    "(3) The reason for less performance for 4 layer ANN is, there is one additional hidden layer added and therefore, activation function becomes more complicated in back-propogation and learning of ANN slows down significantly in earlier layers and model turns in overfitting.\n",
    "\n",
    "(4) Another observation is, for less number of hidden nodes in 1st layer than in 2nd layer takes less time to calculate the performance and also gives less performance as we can see the performance of hidden node combinations (120,280), (50,250), (20,180)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "536f7057",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4705cd00",
   "metadata": {},
   "source": [
    "### Now I have choosed 0.01 learning rate for 3 and 4 layer neural network and have compared their performance below."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75f1ab29",
   "metadata": {},
   "source": [
    "Applying 0.01 learning rate in 4 Layer Neural Network to check its performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "0147a676",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------------------------\n",
      "Hidden Nodes in 1st and 2nd layer respectively: (300, 100)\n",
      "Performance is: 0.9702\n",
      "Time taken to calculate performance is: 420.2\n",
      "-------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------\n",
      "Hidden Nodes in 1st and 2nd layer respectively: (150, 50)\n",
      "Performance is: 0.9689\n",
      "Time taken to calculate performance is: 135.68\n",
      "-------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------\n",
      "Hidden Nodes in 1st and 2nd layer respectively: (200, 100)\n",
      "Performance is: 0.9686\n",
      "Time taken to calculate performance is: 310.06\n",
      "-------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------\n",
      "Hidden Nodes in 1st and 2nd layer respectively: (120, 280)\n",
      "Performance is: 0.9662\n",
      "Time taken to calculate performance is: 145.48\n",
      "-------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------\n",
      "Hidden Nodes in 1st and 2nd layer respectively: (20, 180)\n",
      "Performance is: 0.9336\n",
      "Time taken to calculate performance is: 73.48\n",
      "-------------------------------------------------------------------------------\n",
      "-------------------------------------------------------------------------------\n",
      "Hidden Nodes in 1st and 2nd layer respectively: (50, 250)\n",
      "Performance is: 0.9583\n",
      "Time taken to calculate performance is: 105.21\n",
      "-------------------------------------------------------------------------------\n",
      "Learning rate is: 0.01\n",
      "Epochs is: 5\n",
      "Hidden layer combination is: [(300, 100), (150, 50), (200, 100), (120, 280), (20, 180), (50, 250)]\n",
      "Performance accordingly given combination is: [0.9702, 0.9689, 0.9686, 0.9662, 0.9336, 0.9583]\n",
      "Time to complete whole task is: 1190.12 seconds.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "([(300, 100), (150, 50), (200, 100), (120, 280), (20, 180), (50, 250)],\n",
       " [0.9702, 0.9689, 0.9686, 0.9662, 0.9336, 0.9583])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "\n",
    "myfunction_task6(0.01, 5, 'n_9', (300,100), (150, 50), (200, 100), (120, 280), (20,180), (50, 250))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b29e4d1",
   "metadata": {},
   "source": [
    "Applying 0.01 learning rate in 3 Layer Neural Network to check its performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "546d09b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performance is =  0.9537\n",
      "Time for the completing whole task: 287.34 seconds\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "myfunction_task1(784, 200, 10, 0.01, 5, 'n_10')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "40527b7b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performance is =  0.9522\n",
      "Time for the completing whole task: 400.46 seconds\n"
     ]
    }
   ],
   "source": [
    "myfunction_task1(784, 300, 10, 0.01, 5, 'n_11')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "3bb6c462",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performance is =  0.9508\n",
      "Time for the completing whole task: 503.82 seconds\n"
     ]
    }
   ],
   "source": [
    "myfunction_task1(784, 400, 10, 0.01, 5, 'n_12')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "191a43cd",
   "metadata": {},
   "source": [
    "**Discussion:-**\n",
    "\n",
    "I have changed learning rate from 0.07 to 0.01 and compared the performance of 3 layer and 4 layer ANN which I have shown below,\n",
    "\n",
    "    Hidden Nodes combination    Performance in 4 layer ANN    Performance in 3 layer ANN\n",
    "    (300,100)                     0.9702                   0.9508 with 400 nodes  (Got it from running a function of task 1)\n",
    "    (120,280)                     0.9662                   0.9508 with 400 nodes  (Got it from running a function of task 1)\n",
    "    (200,100)                     0.9686                   0.9522 with 300 nodes  (Got it from running a function of task 1)\n",
    "    (50,250)                      0.9583                   0.9522 with 300 nodes  (Got it from running a function of task 1)\n",
    "    (150,50)                      0.9689                   0.9537 with 200 nodes  (Got it from running a function of task 1)\n",
    "    (20,180)                      0.9336                   0.9537 with 200 nodes  (Got it from running a function of task 1)\n",
    "    \n",
    "so from above results, we can see that, using 0.01 learning rate, performance improves for 4 layer ANN and shows higher than 3 layer ANN performance.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "40d53cde",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function matplotlib.pyplot.show(close=None, block=None)>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#performance array of 4 layer ANN using 0.07 learning rate = [0.9528, 0.9387, 0.948, 0.9423, 0.8908, 0.9227]\n",
    "#performance array of 4 layer ANN using 0.01 learning rate = [0.9702, 0.9689, 0.9686, 0.9662, 0.9336, 0.9583]\n",
    "\n",
    "performanceArr1= [0.9528, 0.9387, 0.948, 0.9423, 0.8908, 0.9227]\n",
    "performanceArr2 = [0.9702, 0.9689, 0.9686, 0.9662, 0.9336, 0.9583]\n",
    "plt.plot(['(300, 100)', '(150, 50)', '(200, 100)', '(120, 280)', '(20, 180)', '(50, 250)'], performanceArr1, 'r', marker = 'o')\n",
    "plt.plot(['(300, 100)', '(150, 50)', '(200, 100)', '(120, 280)', '(20, 180)', '(50, 250)'], performanceArr2, 'g', marker = 'o')\n",
    "plt.xlabel('Hidden nodes combination')\n",
    "plt.ylabel('Performance')\n",
    "plt.legend([\"Learning rate= 0.07\", \"Learning rate= 0.01\"], loc =\"upper right\") \n",
    "plt.title('Performance of 4 layer ANN with respect to Hidden nodes combination and Learning rate')\n",
    "plt.show"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f68083f5",
   "metadata": {},
   "source": [
    "From above figure, it can be seen that, lower learning rate gives better performance when using two Hidden Layer in ANN."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f622294",
   "metadata": {},
   "source": [
    "**Concluded points:-**\n",
    "\n",
    "(1) For this simple classification problem, 4 layer ANN does not give better performance than 3 layer ANN.\n",
    "\n",
    "(2) **To make the comparision fair**, lower learning rate must be chosen while using morethan one hidden layer ANN and hence, it can give the better performance than only one hidden layer ANN. Every possible combination of learning rate and epoch must be tried and should be checked the performance and time taken to findout the best combination according to the performance and time like we did in task 3.\n",
    "\n",
    "(3) 4 Layer ANN gives lower performance when using lower number of hidden nodes in 1st layer than in 2nd. Hence, hidden nodes in 1st layer must be heigher than in 2nd hidden layer to obtain higher performance. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}