From c70bbff1c1a4e4ed608d457574d07cf162766ff4 Mon Sep 17 00:00:00 2001
From: redox2024 <58564953+redox2024@users.noreply.github.com>
Date: Sat, 11 Apr 2020 19:28:34 +0500
Subject: [PATCH 1/7] Add files via upload

---
 Priyansh_Mali_190107052 | 909 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 909 insertions(+)
 create mode 100644 Priyansh_Mali_190107052

diff --git a/Priyansh_Mali_190107052 b/Priyansh_Mali_190107052
new file mode 100644
index 000000000..65996b4bd
--- /dev/null
+++ b/Priyansh_Mali_190107052
@@ -0,0 +1,909 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# used for manipulating directory paths\n",
+    "import os\n",
+    "\n",
+    "# Scientific and vector computation for python\n",
+    "import numpy as np\n",
+    "\n",
+    "# Plotting library\n",
+    "from matplotlib import pyplot\n",
+    "from mpl_toolkits.mplot3d import Axes3D  # needed to plot 3-D surfaces\n",
+    "# tells matplotlib to embed plots within the notebook\n",
+    "%matplotlib inline\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "def warmUpExercise():\n",
+    "    \"\"\"\n",
+    "    Example function in Python which computes the identity matrix.\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    A : array_like\n",
+    "        The 5x5 identity matrix.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Return the 5x5 identity matrix.\n",
+    "    \"\"\"    \n",
+    "    # ======== YOUR CODE HERE ======\n",
+    "    A = np.eye(5)\n",
+    "    \n",
+    "    # ==============================\n",
+    "    return A"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1., 0., 0., 0., 0.],\n",
+       "       [0., 1., 0., 0., 0.],\n",
+       "       [0., 0., 1., 0., 0.],\n",
+       "       [0., 0., 0., 1., 0.],\n",
+       "       [0., 0., 0., 0., 1.]])"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "warmUpExercise()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import os\n",
+    "from matplotlib import pyplot\n",
+    "\n",
+    "data=np.loadtxt(os.path.join('Data','ex1data1.txt'),delimiter =',')\n",
+    "X,y =data[:,0],data[:,1]\n",
+    "m=y.size"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plotData(x, y):\n",
+    "    \"\"\"\n",
+    "    Plots the data points x and y into a new figure. Plots the data \n",
+    "    points and gives the figure axes labels of population and profit.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    x : array_like\n",
+    "        Data point values for x-axis.\n",
+    "\n",
+    "    y : array_like\n",
+    "        Data point values for y-axis. Note x and y should have the same size.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Plot the training data into a figure using the \"figure\" and \"plot\"\n",
+    "    functions. Set the axes labels using the \"xlabel\" and \"ylabel\" functions.\n",
+    "    Assume the population and revenue data have been passed in as the x\n",
+    "    and y arguments of this function.    \n",
+    "    \n",
+    "    Hint\n",
+    "    ----\n",
+    "    You can use the 'ro' option with plot to have the markers\n",
+    "    appear as red circles. Furthermore, you can make the markers larger by\n",
+    "    using plot(..., 'ro', ms=10), where `ms` refers to marker size. You \n",
+    "    can also set the marker edge color using the `mec` property.\n",
+    "    \"\"\"\n",
+    "    fig = pyplot.figure()  # open a new figure\n",
+    "    \n",
+    "    # ====================== YOUR CODE HERE ======================= \n",
+    "    pyplot.plot(x, y, 'ro', ms=10, mec='k')\n",
+    "    pyplot.ylabel('Profit in $10,000')\n",
+    "    pyplot.xlabel('Population of City in 10,000s')\n",
+    "    pyplot.show()\n",
+    "\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEHCAYAAACncpHfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3de5wcVZ338c9vZhqYcdIhMElkUcCdR10VI2jUILoPrvsooxhWjBcChEtCIBd2MwZNgrvP4uNrQdTA7hq8QMYLCRHciBrZzLoYb+yG4AaUAQRl2kVEuSTqhonhFTrh9/xR1UlPp7ureqaru6f7+3696tU91VVdpzud+tU5dc7vmLsjIiKtp63eBRARkfpQABARaVEKACIiLUoBQESkRSkAiIi0KAUAEZEW1ZHUG5vZi4GbgBcCzwM3uPs/mdmVwMXAjnDTK9x9c7n36unp8RNOOCGpooqINKV77rlnp7tPLfV6YgEA2Acsd/d7zWwScI+Z3RG+dp27fzruG51wwgls3749kUKKiDQrM/tVudcTCwDu/gTwRPh8xMweAo5N6ngiIlKZmtwDMLMTgJOBu8NVS81syMy+aGZTalEGEREZLfEAYGbdwNeBZe7+DPA5oBc4iaCGsLrEfgvNbLuZbd+xY0exTUREZBwSDQBmliI4+d/s7rcBuPtT7r7f3Z8HbgTeUGxfd7/B3We6+8ypU0vewxARaTqZTIb+xYuZnk7T3tbG9HSa/sWLyWQyVT1OYgHAzAwYAB5y92vz1h+Tt9l7gAeSKoOIyEQzODjIrBkz6Fy7lq0jI+x1Z+vICJ1r1zJrxgwGBwerdixLKhuomb0ZuBO4n6AbKMAVwNkEzT8OPApcEt4wLmnmzJmuXkAi0uwymQyzZsxg0549nFLk9buA2V1dbBsaore3N/L9zOwed59Z6vUkewH9B2BFXirb519EpFWtWb2ai7PZoid/gFOABdks1193HdeuWTPu42kksIhIg9iwfj3zs9my2yzIZtmwbl1VjqcAICLSIHbu3s3xEdscF25XDQoAIiINoqe7m7JDd4HHwu2qQQFARKRBzD33XAZSqbLbrE2lmHveeVU5ngKAiEiDWLp8OTemUtxV4vW7CALAkv7+qhxPAUBEpEH09vZy08aNzO7qYlUqRQbIAhlgVSrF7K4ubtq4MVYX0DgUAEREGkhfXx/bhobYu3Ahp6bTdLa1cWo6zd6FC9k2NERfX1/VjpXYQLBq0kAwEYFgoNSa1avZsH49O3fvpqe7m7nnnsvS5curdlXcTKIGgqkGICITQi1TJLQK1QBEpOFVO0VCq1ANQEQmvEpSJEh8CgAi0vBqnSKhVSgAiEjDq3WKhFahACAiDa/WKRJahQKAiDS8WqRIqNUsXI1EAUBEGl7SKRJatYupAoCINLwkUyRkMhnmzZnDpj17uCqbpZdgpqxe4Kpslk179jBvzpymrAkoAIjIhJBUioRW7mKqgWAi0tKmp9NsHRmhXN0hA5yaTvPkrl21KlZVaCCYiEgZhV1MM0A/MB1oDx//GdgxMlKH0iVLAUBEWlp+F9NBYBbQCWwF9oaPXcAR7k13M1gBQERaWq6LaQaYB2wCroJRN4OvBr4LTXczWAFARFparovp3wIXQ0vdDFYAEJGWluti+i1gfsS2zZZvSAFARFpeX18fe81aLt+QAoCICK2Zb0gBQESE2uQbajQKACIiJJ9vqBElFgDM7MVm9n0ze8jMHjSzvwnXH2Vmd5jZI+HjlKTKICISV5L5hhpVkjWAfcByd38FwdiKJWb2SmAlsMXdXwpsCf8WEam7pPINNaqa5QIys28Ba8LlNHd/wsyOAX7g7i8vt69yAYmIVK4hcgGZ2QnAycDdwHR3fwIgfJxWizKIiMhoiQcAM+sGvg4sc/dnKthvoZltN7PtO3bsSK6AIiItKtEAYGYpgpP/ze5+W7j6qbDph/Dx6WL7uvsN7j7T3WdOnTo1yWKKiLSkJHsBGTAAPOTu1+a9tAk4P3x+PvCtpMogIiKldST43qcC5wH3m9lPw3VXAJ8AvmZm8wkG1r0vwTKIiEgJiQUAd/8PwEq8/LakjisiIvFoJLCISItSABARaVEKACIiLUoBQESkRSkAiIi0KAUAEZEqymQy9C9ezPR0mva2Nqan0/QvXtyQk8krAIiIVMng4CCzZsygc+1ato6MsNedrSMjdK5dy6wZMxgcHKx3EUepWTbQ8VA2UBFpdJlMhlkzZrBpzx5OKfL6XcDsri62DQ3VbE6BhsgGOpFNpOqciNTPmtWruTibLXryBzgFWJDNcv1119WyWGUpAJQx0apzIlI/G9avZ342W3abBdksG9atq1GJoqkJqIRGrM6JSONqb2tjr3vZ/DpZoLOtjX3799ekTGoCGqOJWJ0Tkfrp6e7mVxHbPBZu1ygUAEqYiNU5kWbXyPfk5p57LgOpVNlt1qZSzD3vvBqVKJoCQAk7d+/m+Ihtjgu3E5HkNfo9uaXLl3NjKsVdJV6/iyAALOnvr2WxylIAKGEiVudEmlUmk2HenDls2rOHq7JZegly2fcCV2WzbNqzh3lz5tS1JtDb28tNGzcyu6uLVakUGYI2/wywKpVidlcXN23c2FD3DBUASpiI1TmRZjVR7sn19fWxbWiIvQsXcmo6TWdbG6em0+xduJBtQ0P09fXVtXyF1AuoBPUCEmkc09Npto6MUO5/WgY4NZ3myV27alWshqdeQGM0EatzIs1K9+SSoQBQxkSrzok0K92TS4YCQITe3l6uXbOGJ3ftYt/+/Ty5axfXrlmjK3+RGtI9uWQoAIhIw5uIXSwnAgUAEWl4uieXDAUAEZkQdE+u+iK7gZqZAW8AjgUc+C3wY69h/1HNByATUSaTYc3q1WxYv56du3fT093N3HPPZeny5bpSlZoYVzdQM3s78AhwJfBO4F3Ax4BHwtdEpIhGT1sgAhE1ADN7COhz90cL1r8E2Ozur0i2eAHVAGQi0SBCaRTjHQjWATxeZP1vgPJ9skRa1ERJWyASVQNYBbwfuAX4dbj6xcAHga+5+9WJlxDVAGRiUdoCaRTjqgGEJ/hzACO4cHlT+PycqJO/mX3RzJ42swfy1l1pZr8xs5+Gyzsr+TAiE4HSFshEEdkN1N1/5u6fAP4e+Dt3/4S7/yzGe38ZOL3I+uvc/aRw2VxZcUVqYzwTjyhtgUwUUb2AjjOzW8zsaeBu4MfhVf0tZnZCuX3d/UfA76tWUpEaGW8PHqUtkIkiqgZwK/AN4Bh3f6m7vxQ4BvgmwX2BsVhqZkNhE9GUMb6HSCKqMfGI0hbIRBEVAHrc/VZ3PzCFvbvvd/dbgKPHcLzPEfxfOgl4AlhdakMzW2hm281s+44dO8ZwKJHKVaMHj9IWyEQR1QvoFoJmnK8wuhfQ+QTB4f1l3zxoJrrd3U+s5LVC6gUktVLNHjyZTIbrr7uODevWHRwJfN55LOnv18lfaiKqF1BUADgMmA+cSZAKwgjGBWwCBtx9b8TBTyDvJG9mx7j7E+HzfuCN7v7BqA+hACC10t7Wxl53OspskwU629rYt39/ma1E6i8qAJT7nePuzxE023xuDAf+KnAa0GNmjxP0IjrNzE4iyCn0KHBJpe8rkqSe7m5+FVEDUA8eaRZRvYA6zOwSMxsMb9zeFz6/1MzKdnNw97Pd/Rh3T7n7i9x9wN3Pc/dXu/sMd5+dqw1IdYyn66IE1INHWknUTeB1BDdsP8boZHCvAdYnWzSphJKPVYd68EgriQoAr3X3Re6+zd0fD5dt7r4IOLkWBZRo1ei62IqK1ZjWrF7NNZ/5jHrwSEuICgB/MLP3mdmB7cyszcw+APwh2aJJXEo+VrlyNaYVl13GNZ/5jCYekaYX1QvoBOAa4C84eMI/Evg+sNLd/zvh8gHqBRRFyccqo3TN0irGmwzuUXf/gLtPJUwG5+7TwnU1OflLNCUfq4xqTCKB2HMCu/vv3H0ngJnNNLNjkyuWVELJxyqzYf165mezZbdZkM2yYd26GpVIpD7GOin8ZcDtZnZrNQsjY6Oui5VRjUkkMKYA4O7nu/vJwIIql0fGQF0XK6Mak0ggMgCY2WQz+4CZfcjM+sPnRwK4+0jyRZQoSj5WGdWYRAJRI4HnAfcSpHToAl4AvBW4J3xNGkRfXx/bhobUdTEG1ZhEAlHdQH9OkLDtfwrWTwHudveXJVw+QN1ApfoGBweZN2cOC7JZFmSzHEfQ7LM2lWJtKsVNGzcqaMqEN65uoATZP4tFiOfD12SCa9X8QY1aY2rVfw+pE3cvuRDk/c8QZAO9Ilw+H667oNy+1Vxe97rXucQzPDzsyxYt8mmTJnmbmU+bNMmXLVrkw8PDh2y7efNm7+nq8lWplA+DZ8GHwVelUt7T1eWbN2+uwydoXfr3kGoDtnu5c3y5F4P9mQJ8EFgOXB4+nxK1XzWXiRwAKjkhj/cYkzs7vQv88vDEUe4EMjw87D1dXb4Vgp9BwbIVvKerq6rllNL07yFJGHcAaIRlogaAWlzR5Y5xaUeHHx2eKOKcQJYtWuSrUqmi2+aWlamU9y9ZMu4ySjT9e0gSEgsAwP1j3bfSZSIGgFpc0eUfYxn4qjInj8ITyLRJk3w4Yvth8OnpdLW+EilD/x6ShKgAENUN9KwSy3uBF1b9hkQTqUW+mfxjbCCYu7Oc/PQGGg3bWPTvIfUQ1Q00C9xM8Z5Ac9x9UlIFyzcRu4HWIkNn/jHagb2Un+Mzfy5bZRBtLPr3kCSMtxvoEPBpd7+wcAH+J2LfllaLK7r8Y/RARekNNBq2sejfQ+ohKgAsA54p8dp7qlyWplKLfDP5x5gLDERsn38C0WjYxqJ/D6mHqPkA7nT3x0q8NrHaZGqsFld0+cdYCtwIsU8gyh/UWPTvIXVR7g5xeH9gGvCC8Hkn8FHgE8AxUftWa1EvoHjH2AzeA74y7DHyXPi4oqOjZLfT4eFh71+yxKen097e1ubT02nvX7JE/c3rRP8eUk1UYSDY94DjwuefBL4ErAC+H7VvtZaJGADcD/bRXxmOA8idkFcmMA4gd4yHwC8CnwzeBn50V5dOICItKioARHUDPR/oBU4Ln38A2A48CRxvZvPMbEa1ayXNohb5ZgqPcWJbG/+aTnPRkiX8YniYnX/8I9euWaOmAxE5RFQ30OOB7wDnAZOBq4A5BIngNgLvBXa5e6L90iZiN1ARkXqL6gZarts47v4rM/sn4HYgBcxz98fM7Dhgp5e4QSwiIo0vckYwd/8cQTPQi9z99nD174CzkyyYSC0o/bK0slhzArv7bnffk/f3H71gkhiRiWZwcJBZM2bQuXYtW0dG2OvO1pEROteuZdaMGQwODta7iCKJGtOk8HGY2RfN7GkzeyBv3VFmdoeZPRI+Tknq+CLlZDIZ5s2Zw6Y9e7gqm6WXoD20F7gqm2XTnj3MmzNHNQFpaokFAODLwOkF61YCW9z9pcCW8G+RmqtFsj6RRle2F9C439zsBOB2dz8x/PvnwGnu/oSZHQP8wN1fHvU+6gUk1abka9IKxpsMLvcmZ4XNNrvM7BkzGzGzUjmCypnu7k8AhI/TyhxzoZltN7PtO3bsGMOhREpT+mWR+E1AnwRmu/tkd0+7+yR3TydZMHe/wd1nuvvMqVOnJnkoaUG1SNYn0ujiBoCn3P2hKhzvqbDph/Dx6Sq855io+19rqyRZn34r0qziBoDtZnarmZ2dPzPYGI63CTg/fH4+8K0xvMe4qfufxE2/fOJrX6vfijSvcomCcgtBArjC5YsR+3wVeIIgq+3jBDMWHk3Q++eR8PGoOMevZjK4WmTplIkhKlnfwMCAfisyoTGeZHB5QeKQGcHc/aKIfc5292PcPeXuL3L3AXf/nbu/zd1fGj7+fgwxa1zU/U9yopL13b99u34r0tSiksF9xN0/aWafoci8wO7+10kWLqea3UDV/U/i0m9FJrpxJYMDcjd+m6YTvrr/SVz6rUizi8oG+u3w8Su1KU7yerq7+VXEVZ26/wnotyLNL8lUEA2pFnP1SnPQb0WaXcsFgLjd/3KTp0vjqHV/fP1WpNnFTQVxapx1E0Fvby83bdzI7K4uVqVSZAj6qWaAVakUs7u6uGnjRk2h2GDqMXZDvxVpeuX6iOYW4N4465JakpgUfnh42PuXLPHp6bS3t7X59HRak6eP0fDwsC9btMinTZrkbWY+bdIkX7ZoUdW+y3qP3dBvRSYqIsYBRHUDPQV4E7AMyO/snAbe4+6vSSwy5VE20MY1ODjIvDlzuDibZX42y/HAr4CBVIobUylu2riRvr6+cR2jf/FiOteu5apstuQ2q1Ip9i5cyLVr1ozrWCLNZLzZQA8Dugl6C03KW54hmBxeWkCptvfvfe97NZlUZcP69cwvc/KHYEDWhnXrxnUckVYTaz4AMzve3aOSJyZGNYD6KXeFf707p7tz6/79JfevxpV5e1sbe93L9lnOAp1tbewrUxaRVjOuGoCZ/WP4dI2ZbSpcqlrSBjERMz8mVeaoaRP/bd8+tuzfT7mjVOPKXKmbRZIR1QR0U/j4aWB1kaWpTMQsoUmWOVbeJOD6Mu9RaqRsJUFL/fFFElLuDjHB/L0A15TbLukliV5Aherd02Qski7ztEmTfLjEe+eWYfDpUa+n06PeN5eFc1WYhTMbbrcqzMK5efPmmn5OkWZFRC+gqADwM+B/E+QEOhl4bf5Sbt9qLrUIAMsWLfJVqVTZk93KVMr7lyxJ5Phj6Uo53jJHHbPNzLMRAeA58PbwBL4MfBp4W/i4DPySjo5Rxx/ryTwqdXNh0BCR8QeAOcAgMAJ8v2D5Xrl9q7nUIgDEvtotuJqthlJXxCs7Ojzd0eGTOzuLnqDHU+Y4V+Fx378bvAt8efh37r1WhOsHBgYOHHc8QUv98UUqM64AcGAj+Ls42yW11CIAxL7aNTuwTzUGQMW5Ij4a/OGCE/TAwIAfXuSKu/CE/Rx4e1tbxcfs6eryC+bOjTxZfwj8BeE+ca7o6xloRVpNVACIOyHMx81stpl9OlzOqMb9h0bS3dERq6dJd3gzslo3X+PcaL0Y+AKj+9dfNn8+5wFbgb3hYycwi6DKll/mwt4xcSfFaTOLzIVzI3BeuE+598pNmqIUyyINpFx0yC3A1QRTOF4ULncAV8fZtxpLLWoAk1MpXxlxZboCfHIqVdWbkmO90foR8P5Sx86rCRRrTqnkKrxU2/vlZj4ZfHKRWke5K3rVAERqhyo1AQ0BbXl/twNDcfatxlKLAGDhibPsSR28zayqN4wrudEaFRQOHDsMDqUCUexjhk1HxdreJ6dSvoWg+amS96r3zXaRVlLNAHBU3t9HNVsAmDZpkg+EJ/mV4Qn2QE+TcP1AeGVaeBVbrAfMheBHd3fHOu5YagDFgkL+9pPDk3+x3jHVuArPBZFpVFYDUJdOkdqJCgBx5wO4GviJmX3ZzL4C3ANcVY0mqEYx99xzGU6l2EbQpn4qQZv6qeHf24BHwsFG+e3YgwTt7p2Mbo+fDjy7e3fkvYBYg5yAuQXrHgN6Smx/HEG3rW1DQ0UTsVVjYFVudO5cYKDsO41+L6VYFmkg5aJDEEAw4MXAMcBs4EzghVH7VXOptAYwlt45lVyZ5q6gh4nRbBRxNRvruEWusleGtYxife+3RFy9V+MqPNeUM9bvQF06RZJHlZqA7omzXVJLJQGg0lGmxfaNGmyUO/ktA18V0fwRpz271HE/Ep5cNxc5qaYJuoeuYnTf+1Vh889fnXHGmI4Zd2BVfhDZTPGms+XgR3d2apCWSJ1UKwBcD7w+zrZJLHEDQDWubONcmW7ZssXT7e3eSfk++Ln276nd3ZE1ksLjHt3V5en2dr+ko2PUSXVFR4cfEZ7ky44d6OyMvJou9lkvOuccv2Du3Fi1p/wgsgX8b8Cnht9JF/hZZ5xR9Sv6pCefEWkm1QoAPwP2EzTVDgH304A3gWvRw2Tz5s1+dGenX27mwwQDtC4MT8gGflRBMHguPCGOpUZSKhi947TT/PIq1DyKfbZKa0+1bMoZT+1OpBVVKwAcX2yJs281lrgBIOk+5sPDw37kYYcduPLONX0UNsPkeg1t5uB9gmr2eKnkc8a9Ym703jmNXj6RRjSuAAAcQTAd5BrgEqCj3PZJLXEDwFjSOVTiHaed5svzTrBxxg0soPiArWJX6nFP1pV8zrhXzI3eP7/RyyfSiMYbAG4F1ocn/28C/1Ru+6SWatcAuqDiK8Xh4WHv5GDTTpwbwB8Bn8ToewOFYwZ6CEYXDwwMxD5ZV/I5myVHT6OXT6QRjTcA3J/3vAO4t9z2cRfg0fA+wk+jCugVBIBlixb5h83KniRWgs8yq/hKcdmiRaNGvcYdAHV03t+lmoyWhyfr1TFP1nGuhi8381lR30XeFXOlo4NrrdHLJ9KIxhsA7i3391iXMAD0xN2+kl5AkVe9jO4nH7fZZdqkSaP648dOgZAXDOI0GZUKKoVNRVHt4V3h54x7xdzoV9iNXj6RRhQVAKJGAr/GzJ4JlxFgRu65mT0TPcystnp7e3mWYLTaKhg9yjRcfxPwFoJsk5Vk9Ny5e/eoUa89ECt76KTw+RqCrJ5jnV5xQTbLF66/nva2Nt508smcetppvLuzs+Ro2meBP48oX37WzUafdrHRyycyIZWLDkktwH8D9xKklFhYYpuFwHZg+3HHHRc74k2bNMm3ENx4nR5egU8P/x7Ou1I8uru7ol4luffNXcXHuQewoqPD0+3tvpUKcuZE1Cby7w1MOeIIP+uMM4p2waz0irnRe9k0evlEGhHV6AZa7QX4k/BxGnAf8Ofltq9kJHCc9vEVHR1+7JQpFfWlX7Zoka/s6DjQjn8JQft+1Akpd3M3TpPRQ1BykpdiwaHwpDeqOYtgbEKpAWqFn8+98addbPTyiTSahgwAowoAVwKXl9umkgAQt308HfeKvMgV8jBBjeJIRk+FWOqENDw8HMwjUOZYm8OAcjmHpnboAX8fB2sx+b2IJoO//sQTS/YiWkHpdBITMUdPo5dPpJE0XAAAXgBMynu+FTi93D6VJoMrdaW4oqPjQG+bSvPY57/virz0DFvA3wDeSdDvPndC2rJly6iby5NTqVE9lPJP5EZ0l80u8Ksp3otoQYz9jyaoYZQKUEqvINJ8GjEA/GnY7HMf8CDw0ah9xjIfwJYtW3zmq17lXXkn2GOnTPFL2tvdqTyPfU6cK9BiKQu2cDB/T2F30L8Or9TLleXDBLWWYif5ZTH2X07QvFRYXqVXEGleDRcAxrKMtQZQeFLLn75wvJk8S101b9mypWQT1OawDIUn8qNiBqMjS7w2nmCmG6sizavlAkC5k1p+s894cvmXu2pOt7f7irCWUWy5EEbdfB4mqKGMZVrIYp8rbnOWu9IriDS7lgsApU5qm2FUKgcnmOIxzaE3cT9E6ekUo66aj464Gi+8Wl9GBROrx3zPuDUADa4SaW5RASDulJATxob165mfzY5alwHmEUxllhvINQisIJjS8A8cnALydcDngZNe/3pe9rKXHfL+a1av5uJstuSArj/Agekii9kB/DPBlJHtwA3AWURPq/hZ4F0lXqt0Wsac/KktS8kfLCYiTaZcdGiUpZIaQLGcMbn2/lyzz9eIbv7pAu9ua/OBgQF3P9jm30X5SWDKXY1vDt83N3NWNnyvh2OWZ0GZq/SxNGepBiDS3Gi1GkBusvJ8G4D5QC9BKogFwIWUT8uwBHjV889z2fz59Pf3H0gZMcTBid87CSaEz5/2fS7BJO6FcrWQ7wJXh2XpIEgp0RGWq1QKi3cDHUccwTe7uriryHv3htv9JbCyoyP2ROtKryDS4spFh0ZZxnIPoLCfff4Ve1Q7fe7Kd2pYW4iTYG5Umoki25fqdZS/PjfArDCFxSUdHd6/ZEnkSNiBgYGKBkmpF5BIc6PVbgIPDw97+vDD/SiKT5jeQ/xeN23hCfrDEduuZPSkL+9rb/d0R8eoE3WpTJ+VNt9UeySs0iuINK+WDABTDj+8KqmSu6g8iVvuhL1ly5ZRJ+pyQSc3MGwF5VNKJEXpFUSaU8sFgDh92z8EPqvISbwwx05nQW2hcJtcs9JDBE025U7YUTdch8EvCoOOTsIiUg1RAaDpbgIX6wZaaDEwBAduqA4S3MztJLi5u5cgT/XicN1NJbbJ3Qh+M8GN3L0LF7JtaIi+vr5Djhl1w7UXmJZKccmSJezbv58nd+3i2jVrDrlxKyJSLRYEicY2c+ZM3759e6xt29va2OtOR5ltsgSz3R8FvBfYCHyb4r2C7gLeDhwesc3pHR3c+/DDJU/YmUyGWTNmsGnPnpLvMburi21DQzrpi0hVmNk97j6z1OtNVwMo1g200GMEAeCzBLPSRHUJfQVwUcQ2i4Drr7uu5DF7e3u5aeNGZnd1lZzFq1hXTRGRpDRdACjV1JIB+glG4L4MsLY2FrS38xBwacR7/jdwScQ2F+/bx4Z168pu09fXx7ahIfYuXMip6TSdbW2cmk6XbToSEUlK0zUBZTIZ3vjqV/PtZ589cMU+SDAI62KCAWHHE8zn+3kzPuvOPwI/A9YDvyeoHewnmKxgHkHqhr0Q2azU2dbGvv37K/14IiKJaLkmoN7eXt781rfSRzA69nsEJ/FNwFUcHIHbC3zKne8Cy4A9wDaCE/0QQW3BgN8StP/HaVbq6e6u+ucREUlK0wUAgLvuvJPbCE7mZwHnU779finB1X5+cLia4Kbv94C/AD4XcUylTBCRiaYpA8DO3bv5c+Bagqv3RRHbLyTIF1ToFIK8QdMJ8vsUy8NDuP7Gjg6W9PePrcAiInXQlAEgvyfQTsqnZ4Yw5XGJ1xYAtwAjwNuANxDUCnI9eFYCfUD2+ef5xS9+Mc6Si4jUTlMGgPyeQD3EbL8v8dpxBE1Je4H7gdMIsnMeQTCHwHMEg8b+be9e5s2ZQyaTKfo+mUyG/sWLmZ5O097WxvR0mv7Fi0tuLyKStKYMAEuXL+fGVIq7iDlZSrhdMY8BhwHHAmsIuoN+l2AQ2X8SNDP1EjYXZbNFxwIMDg4eSCe9dWSEve5sHRmhc+1aZs2YweDg4CH7iIgkrSkDQP6gq90Es26Va79fS5D/v5gbCe4R5BuIi2gAAA+RSURBVOf//x+CpqHrC7ZdkM0eMhYgk8kwb84cNu3Zw1XZ7KgbzVdls2zas6dszUFEJClNGQDg4KCr5885h90Ek6VczujJVlaG61cRnJAL3UVQe7gsfP0qgu6k5wGPAF8gmNZxOkG30SyHTp8YNYVkuZqDiEiSmjYA5KTTaY7o7OR54E7gJGASMAP4FEEvoY8RjAYunIlrNkEiuPzgcApwAfAbOGR2sDcDkw4/fNTx4ySnK1ZzEBFJWtMGgPx293uefZafAvuA5wmu1nMn7/8iyPr5VYKgcDjBSX4vwcCwYskZFhGkhxjVnEMwbuD5bHZUc44mXheRRtWUAaBYu/tvgIc5dE7e3KCvfwNyGYR+y8Gbu8WU6jZ6CkFOoA+eeeaBIBA3OZ1GEYtIrTVlAMhvd88lgTuT4Mq9XFv8xUA34+s2uggYfvDBA717kpx4XV1LRWQ8mjIA5Nrd8ydxOYLoEcGXEjQTXRGxXbluo8cRDBrL9e5595w5B7qkFnMXQQCodBSxupaKyLiVmy4sqQU4Hfg5MAysjNq+kikh3d3bzPzhgsnW28rMyZs/EXx7OC3j18pN0l5mnuD8+YFXplLev2RJ1SdeHx4e9p6urtgTyYtIa6LRpoQ0s3aCLvR9wCuBs83sldU8Rk93N9cQNOnkmnwqGRG8lKCf/ypG9wz6sBl9HNozKF9+7SDXu6fa8wCoa6mIVEW56JDEQnB++k7e36uAVeX2qbQGsGzRIp9ccJW+DHxVRA1gJXh/uN/U8Pn0vFrBReec41OOOKL8lXfecZ8LJ3ivtqgJ5g/URNLpqh9bRCYOGq0GQJBV4dd5fz8erquapcuX8wyjk8AtJRjVG2dE8HEEE8NcCzwJfDicrH1g/Xpuvu02Znd1HTKorNi4gaR696hrqYhUQz0CgBVZd8i0ZGa20My2m9n2HTt2VHSA3t5epnR2jmry6SU4Of8lwQjgcifv/F4+hTdpc805P3zVq5hJcIP5VIqPG0hqjgB1LRWRaqhHAHgceHHe3y8i6Ho/irvf4O4z3X3m1KlTKz7IvAsuYG3H6Ekc+4D3Az8kOGmXOnnfCLyL0pO19/b2csu3vkVHVxd3EtQSCscNjLV3TxxJdi0VkRZSrn0oiYVg/NUvgZcQJNq8D3hVuX0qvQfgHvSUmXL44Ye01w8X9A4q1o7fBX50d7f3L1lStidNtXv3VPLZ1AtIRKLQaPcA3H0fQZP8d4CHgK+5+4NJHGs/cAaje/MAvJWgKWg5BU1B4RX/xs2b2TkywrVr1oy68i9U7d49ceVnO12VShX9DIW1FhGRQhYEicY2c+ZM3759e0X79C9eTOfatczPZrmeYMrHnQRt+3MJAsMVZjycSrF73z56uruZe955LOnvnzAnzkwmw/XXXceGdevYuXv3hPwMIpIcM7vH3WeWfL1ZA8D0dJqtIyMl++tDcMX8xq4udv7xj+Mqn4hII4oKAE2ZCgLid5X8w549FefOUQ4eEWkGTRsA4naVnAQVjZhVDh4RaRZNGwDmnnsun4/YZi3wXog9GYumdxSRZtK0AWDp8uV8luiRvx8m/ohZ5eARkWbStAGgt7eXVGcn7+bQpG75I39TxB8xq+kdRaSZNG0AALjwggt4X0cHeyk98reSEbPKwSMizaSpA8DS5cvZeNhhvI8gXcM+RqdtqDRdg3LwiEgzaeoAUO0Rs8rBIyLNpKkDAFQ3XcPS5csTmd5RRKQemjIAFA7UetPJJ+PPP89/3nsv+/bv58lduyLz/BSjHDwi0kyaLgAkPVCrXgngRESqralyAWUyGWbNmMGmPXuK9tW/C5jd1cW2oSFdpYtI02upXEAaqCUiEl9TBQAN1BIRia+pAoAGaomIxNdUAUADtURE4muqAKCBWiIi8TVVANBALRGR+JoqAGiglohIfE0VAEADtURE4mqqgWAiInJQSw0EExGR+BQARERalAKAiEiLmhD3AMxsB0SO8SqlB9hZxeIkTeVN3kQrs8qbrIlWXohf5uPdfWqpFydEABgPM9te7iZIo1F5kzfRyqzyJmuilReqV2Y1AYmItCgFABGRFtUKAeCGehegQipv8iZamVXeZE208kKVytz09wBERKS4VqgBiIhIEU0TAMzsUTO738x+amaH5I2wwD+b2bCZDZnZa+tRzrAsLw/LmVueMbNlBducZma78rb5vzUu4xfN7GkzeyBv3VFmdoeZPRI+Timx7/nhNo+Y2fl1LvOnzOzh8N/8G2Z2ZIl9y/5+aljeK83sN3n/7u8sse/pZvbz8Pe8so7lvTWvrI+a2U9L7FuP7/fFZvZ9M3vIzB40s78J1zfk77hMeZP7Dbt7UyzAo0BPmdffCQwCBswC7q53mcNytQNPEvTXzV9/GnB7Hcv158BrgQfy1n0SWBk+XwlcU2S/o4Bfho9TwudT6ljmtwMd4fNripU5zu+nhuW9Erg8xm8mA/wpcBhwH/DKepS34PXVwP9toO/3GOC14fNJwC+AVzbq77hMeRP7DTdNDSCGM4GbPLANONLMjql3oYC3ARl3H+tAt0S4+4+A3xesPhP4Svj8K8BfFdn1HcAd7v57d/8DcAdwemIFzVOszO7+7+6+L/xzG/CiWpQljhLfcRxvAIbd/Zfu/hxwC8G/TaLKldfMDHg/8NWkyxGXuz/h7veGz0eAh4BjadDfcanyJvkbbqYA4MC/m9k9ZrawyOvHAr/O+/vxcF29fZDS/2lOMbP7zGzQzF5Vy0KVMN3dn4DgxwpMK7JNo37PABcR1AKLifr91NLSsLr/xRLNE434Hb8FeMrdHynxel2/XzM7ATgZuJsJ8DsuKG++qv6GO8ZawAZ0qrv/1symAXeY2cPhFUuOFdmnrl2gzOwwYDawqsjL9xI0C+0O24G/Cby0luUbo4b7ngHM7KPAPuDmEptE/X5q5XPAxwm+s48TNKtcVLBNI37HZ1P+6r9u36+ZdQNfB5a5+zNBZSV6tyLravIdF5Y3b33Vf8NNUwNw99+Gj08D3yCoJud7HHhx3t8vAn5bm9KV1Afc6+5PFb7g7s+4++7w+WYgZWY9tS5ggadyzWbh49NFtmm47zm8gXcGcI6HjaWFYvx+asLdn3L3/e7+PHBjiXI01HdsZh3AWcCtpbap1/drZimCk+nN7n5buLphf8clypvYb7gpAoCZvcDMJuWeE9w0eaBgs03APAvMAnblqoF1VPKqycxeGLarYmZvIPi3+l0Ny1bMJiDXG+J84FtFtvkO8HYzmxI2X7w9XFcXZnY6sAKY7e57SmwT5/dTEwX3pd5Tohz/BbzUzF4S1iI/SPBvUy9/CTzs7o8Xe7Fe32/4/2cAeMjdr817qSF/x6XKm+hvOMm72rVaCHpD3BcuDwIfDddfClwaPjfgeoLeE/cDM+tc5i6CE/rkvHX55V0afpb7CG78vKnG5fsq8ATBtMqPA/OBo4EtwCPh41HhtjOBtXn7XgQMh8uFdS7zMEFb7k/D5fPhtn8CbC73+6lTedeFv88hghPVMYXlDf9+J0EvkUw9yxuu/3Lud5u3bSN8v28maLYZyvv3f2ej/o7LlDex37BGAouItKimaAISEZHKKQCIiLQoBQARkRalACAi0qIUAEREWpQCgMRiZvvDLIMPmNm/mFlXld//AjNbE7HNaWb2pry/LzWzedUsR5FjfirMzPipIq/1mdn2MHvjw2b26cJyhZ/rTyo85loze2UF2/+Zmd1lZnvN7PKC1yKzhlqJ7JjhmJmiGXStThlfpcpq0R9Xy8RfgN15z28GPlTl978AWBOxzZVEZMpM4HM/AxxeZP2JBH3w/yz8uwNYXGS7H5DwmBOCXDavB/4h//shZtZQSmTHpEQGXeqY8VVLdRfVAGQs7gT+F4CZfSisFTxg4ZwGZnZCeEX8lfDKcWOuxmBBzvKe8PlMM/tB4Zub2bvN7G4z+4mZfdfMpluQHOtSoD+sibzFgtz5l4f7nGRm2+xgzvTcVewPzOwaM/uxmf3CzN5S5HgWXuk/YEE+9Q+E6zcBLwDuzq3L8xHgH9z9YQB33+funw33u9LMLjezOQSDi24Oy/wuM/tG3nH/j5ndVvC+uTLPDJ/vNrN/sCAp4DYzm164vbs/7e7/RTBAK1/crKGlsmOWyqBbNFOmmbWb2Zfzvsf+IseSBqIAIBWxIO9LH3C/mb0OuBB4I8EV4sVmdnK46cuBG9x9BsFV9OIKDvMfwCx3P5ngpPURd38U+Dxwnbuf5O53FuxzE7AiPN79wN/nvdbh7m8AlhWszzkLOAl4DUFag0+Z2THuPht4NjxeYZ6bE4F7yn0Id98IbCfI33ISsBl4hZlNDTe5EPhSufcgCEDb3P01wI+AiyO2zxc3o2Wp7Jil9i+1/iSC9MUnuvurif5sUmcKABJXpwWzPW0HHiPIWfJm4Bvu/kcPEtfdRpAWGODX7v6f4fP14bZxvQj4jpndD3wYKJsK28wmA0e6+w/DVV8hmLwkJ3eVfQ9wQpG3eDPwVQ+SsD0F/JCgSaWq3N0JUj2ca8GsTqdQOrVvznPA7eHzUuUvZbwZLUvtX2r9L4E/NbPPWJC/5pki20kDUQCQuHJXwie5+2Vhk0K5vLqFJ5rc3/s4+Ls7osS+nyG4H/Bq4JIy28W1N3zcT/EU6LHyAxd4EHjdGPb7EnAuQSLAf/GDE32Ukg0DB5QufylxM1qWyo5Zav+i68PmoNcQ3PdYAqytoKxSBwoAMh4/Av7KzLosyED4HoL7AwDHmdkp4fOzCZp1IJi2LnfifG+J950M/CZ8nt/DZIRgqrxR3H0X8Ie89v3zCK7iK/kcHwjbsKcS1B5+HLHPp4ArzOxlAGbWZmYfKrLdqDJ7kLL3t8DfEiRRS1LJrKFmdrWZvSfcrlR2zFIZdItmygzv7bS5+9eBvyOYPlIaWDNNCCM15u73mtmXOXiyXOvuPwlv2D4EnG9mXyDIuvi5cJuPAQNmdgWHznaUcyXwL2b2G4JMqC8J138b2GhmZwKXFexzPvD58GbzLwna1+P6BkFzzH0ENZWPuPuT5XZw96HwpvdXw2M68K9FNv1yWK5ngVPc/VmCXlRT3f1nFZSxJDN7IUHTXBp4PizXKz2Y/GQpwQm7Hfiiuz8Y7vZqDqaQ/gTwNTObT9C8975w/WYOZqPcQ/iduvvvzezjBAEG4P+F614DfMnMcheWxSY6kgaibKBSdWEAuN3dT6xzURqSBeMdfuLuA3Usw3fc/R31Or40BtUARGrIzO4B/ggsr2c5dPIXUA1ARKRl6SawiEiLUgAQEWlRCgAiIi1KAUBEpEUpAIiItCgFABGRFvX/AYH/yuNsMedbAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plotData(X,y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Add a column of ones to X. The numpy function stack joins arrays along a given axis. \n",
+    "# The first axis (axis=0) refers to rows (training examples) \n",
+    "# and second axis (axis=1) refers to columns (features).\n",
+    "X = np.stack([np.ones(m), X], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def computeCost(X, y, theta):\n",
+    "    \"\"\"\n",
+    "    Compute cost for linear regression. Computes the cost of using theta as the\n",
+    "    parameter for linear regression to fit the data points in X and y.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The input dataset of shape (m x n+1), where m is the number of examples,\n",
+    "        and n is the number of features. We assume a vector of one's already \n",
+    "        appended to the features so we have n+1 columns.\n",
+    "    \n",
+    "    y : array_like\n",
+    "        The values of the function at each data point. This is a vector of\n",
+    "        shape (m, ).\n",
+    "    \n",
+    "    theta : array_like\n",
+    "        The parameters for the regression function. This is a vector of \n",
+    "        shape (n+1, ).\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    J : float\n",
+    "        The value of the regression cost function.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the cost of a particular choice of theta. \n",
+    "    You should set J to the cost.\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # initialize some useful values\n",
+    "    m = y.size  # number of training examples\n",
+    "    \n",
+    "    # You need to return the following variables correctly\n",
+    "    J = 0\n",
+    "    \n",
+    "    # ====================== YOUR CODE HERE =====================\n",
+    "    A=np.zeros((2,1))\n",
+    "    A[0,0]=theta[0]\n",
+    "    A[1,0]=theta[1]\n",
+    "    product=np.dot(X,theta)\n",
+    "    \n",
+    "    sum=0\n",
+    "    for i in range(0,m):\n",
+    "        pred=product[i]\n",
+    "        sum += (pred - y[i])**2\n",
+    "        \n",
+    "    J = sum/(2*m)          \n",
+    "    # ===========================================================\n",
+    "    return J"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "With theta = [0, 0] \n",
+      "Cost computed = 32.07\n",
+      "Expected cost value (approximately) 32.07\n",
+      "\n",
+      "With theta = [-1, 2]\n",
+      "Cost computed = 54.24\n",
+      "Expected cost value (approximately) 54.24\n"
+     ]
+    }
+   ],
+   "source": [
+    "J = computeCost(X, y, theta=np.array([0.0, 0.0]))\n",
+    "print('With theta = [0, 0] \\nCost computed = %.2f' % J)\n",
+    "print('Expected cost value (approximately) 32.07\\n')\n",
+    "\n",
+    "# further testing of the cost function\n",
+    "J = computeCost(X, y, theta=np.array([-1, 2]))\n",
+    "print('With theta = [-1, 2]\\nCost computed = %.2f' % J)\n",
+    "print('Expected cost value (approximately) 54.24')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def gradientDescent(X, y, theta, alpha, num_iters):\n",
+    "    \"\"\"\n",
+    "    Performs gradient descent to learn `theta`. Updates theta by taking `num_iters`\n",
+    "    gradient steps with learning rate `alpha`.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The input dataset of shape (m x n+1).\n",
+    "    \n",
+    "    y : arra_like\n",
+    "        Value at given features. A vector of shape (m, ).\n",
+    "    \n",
+    "    theta : array_like\n",
+    "        Initial values for the linear regression parameters. \n",
+    "        A vector of shape (n+1, ).\n",
+    "    \n",
+    "    alpha : float\n",
+    "        The learning rate.\n",
+    "    \n",
+    "    num_iters : int\n",
+    "        The number of iterations for gradient descent. \n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    theta : array_like\n",
+    "        The learned linear regression parameters. A vector of shape (n+1, ).\n",
+    "    \n",
+    "    J_history : list\n",
+    "        A python list for the values of the cost function after each iteration.\n",
+    "     Instructions\n",
+    "    ------------\n",
+    "    Peform a single gradient step on the parameter vector theta.\n",
+    "\n",
+    "    While debugging, it can be useful to print out the values of \n",
+    "    the cost function (computeCost) and gradient here.\n",
+    "    \"\"\"\n",
+    "    # Initialize some useful values\n",
+    "    m = y.shape[0]  # number of training examples\n",
+    "    \n",
+    "    # make a copy of theta, to avoid changing the original array, since numpy arrays\n",
+    "    # are passed by reference to functions\n",
+    "    theta = theta.copy()\n",
+    "    J_history =[]\n",
+    "    xtrans =X.transpose()\n",
+    "    for i in range(num_iters):\n",
+    "        h=np.dot(X,theta)\n",
+    "        loss = h-y\n",
+    "        gradient = np.dot(xtrans,loss)/m\n",
+    "        theta = theta - alpha*gradient\n",
+    "        J_history.append(computeCost(X, y, theta))\n",
+    "    return theta, J_history"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Theta found by gradient descent: -3.6303, 1.1664\n",
+      "Expected theta values (approximately): [-3.6303, 1.1664]\n"
+     ]
+    }
+   ],
+   "source": [
+    "theta = np.zeros(2)\n",
+    "\n",
+    "# some gradient descent settings\n",
+    "iterations = 1500\n",
+    "alpha = 0.01\n",
+    "\n",
+    "theta, J_history = gradientDescent(X ,y, theta, alpha, iterations)\n",
+    "print('Theta found by gradient descent: {:.4f}, {:.4f}'.format(*theta))\n",
+    "print('Expected theta values (approximately): [-3.6303, 1.1664]')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "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"
+    }
+   ],
+   "source": [
+    "plotData(X[:, 1], y)\n",
+    "pyplot.plot(X[:, 1], np.dot(X, theta), '-')\n",
+    "pyplot.legend(['Training data', 'Linear regression']);\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "For population = 35,000, we predict a profit of 4519.77\n",
+      "\n",
+      "For population = 70,000, we predict a profit of 45342.45\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Predict values for population sizes of 35,000 and 70,000\n",
+    "predict1 = np.dot([1, 3.5], theta)\n",
+    "print('For population = 35,000, we predict a profit of {:.2f}\\n'.format(predict1*10000))\n",
+    "\n",
+    "predict2 = np.dot([1, 7], theta)\n",
+    "print('For population = 70,000, we predict a profit of {:.2f}\\n'.format(predict2*10000))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "theta0_vals = np.linspace(-10, 10, 100)\n",
+    "theta1_vals = np.linspace(-1, 4, 100)\n",
+    "\n",
+    "# initialize J_vals to a matrix of 0's\n",
+    "J_vals = np.zeros((theta0_vals.shape[0], theta1_vals.shape[0]))\n",
+    "\n",
+    "# Fill out J_vals\n",
+    "for i, theta0 in enumerate(theta0_vals):\n",
+    "    for j, theta1 in enumerate(theta1_vals):\n",
+    "        J_vals[i, j] = computeCost(X, y, [theta0, theta1])\n",
+    "        \n",
+    "# Because of the way meshgrids work in the surf command, we need to\n",
+    "# transpose J_vals before calling surf, or else the axes will be flipped\n",
+    "J_vals = J_vals.T\n",
+    "\n",
+    "# surface plot\n",
+    "fig = pyplot.figure(figsize=(12, 5))\n",
+    "ax = fig.add_subplot(121, projection='3d')\n",
+    "ax.plot_surface(theta0_vals, theta1_vals, J_vals, cmap='viridis')\n",
+    "pyplot.xlabel('theta0')\n",
+    "pyplot.ylabel('theta1')\n",
+    "pyplot.title('Surface')\n",
+    "\n",
+    "# contour plot\n",
+    "# Plot J_vals as 15 contours spaced logarithmically between 0.01 and 100\n",
+    "ax = pyplot.subplot(122)\n",
+    "pyplot.contour(theta0_vals, theta1_vals, J_vals, linewidths=2, cmap='viridis', levels=np.logspace(-2, 3, 20))\n",
+    "pyplot.xlabel('theta0')\n",
+    "pyplot.ylabel('theta1')\n",
+    "pyplot.plot(theta[0], theta[1], 'ro', ms=10, lw=2)\n",
+    "pyplot.title('Contour, showing minimum')\n",
+    "pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  X[:,0] X[:, 1]         y\n",
+      "--------------------------\n",
+      "    2104       3    399900\n",
+      "    1600       3    329900\n",
+      "    2400       3    369000\n",
+      "    1416       2    232000\n",
+      "    3000       4    539900\n",
+      "    1985       4    299900\n",
+      "    1534       3    314900\n",
+      "    1427       3    198999\n",
+      "    1380       3    212000\n",
+      "    1494       3    242500\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Load data\n",
+    "data = np.loadtxt(os.path.join('Data', 'ex1data2.txt'), delimiter=',')\n",
+    "X = data[:, :2]\n",
+    "y = data[:, 2]\n",
+    "m = y.size\n",
+    "\n",
+    "# print out some data points\n",
+    "print('{:>8s}{:>8s}{:>10s}'.format('X[:,0]', 'X[:, 1]', 'y'))\n",
+    "print('-'*26)\n",
+    "for i in range(10):\n",
+    "    print('{:8.0f}{:8.0f}{:10.0f}'.format(X[i, 0], X[i, 1], y[i]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def  featureNormalize(X):\n",
+    "    \"\"\"\n",
+    "    Normalizes the features in X. returns a normalized version of X where\n",
+    "    the mean value of each feature is 0 and the standard deviation\n",
+    "    is 1. This is often a good preprocessing step to do when working with\n",
+    "    learning algorithms.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The dataset of shape (m x n).\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    X_norm : array_like\n",
+    "        The normalized dataset of shape (m x n).\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    First, for each feature dimension, compute the mean of the feature\n",
+    "    and subtract it from the dataset, storing the mean value in mu. \n",
+    "    Next, compute the  standard deviation of each feature and divide\n",
+    "    each feature by it's standard deviation, storing the standard deviation \n",
+    "    in sigma. \n",
+    "    \n",
+    "    Note that X is a matrix where each column is a feature and each row is\n",
+    "    an example. You needto perform the normalization separately for each feature. \n",
+    "    \n",
+    "    Hint\n",
+    "    ----\n",
+    "    You might find the 'np.mean' and 'np.std' functions useful.\n",
+    "    \"\"\"\n",
+    "    # You need to set these values correctly\n",
+    "    X_norm = X.copy()\n",
+    "    mu = np.zeros(X.shape[1])\n",
+    "    sigma = np.zeros(X.shape[1])\n",
+    "\n",
+    "    # =========================== YOUR CODE HERE =====================\n",
+    "    mu=np.mean(X,axis=0)\n",
+    "    sigma=np.std(X-mu,axis=0)\n",
+    "    X_norm=(X-mu)/sigma\n",
+    "    \n",
+    "    # ================================================================\n",
+    "    return X_norm, mu, sigma"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Computed mean: [2000.68085106    3.17021277]\n",
+      "Computed standard deviation: [7.86202619e+02 7.52842809e-01]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# call featureNormalize on the loaded data\n",
+    "X_norm, mu, sigma = featureNormalize(X)\n",
+    "\n",
+    "print('Computed mean:', mu)\n",
+    "print('Computed standard deviation:', sigma)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Add intercept term to X\n",
+    "X = np.concatenate([np.ones((m, 1)), X_norm], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def computeCostMulti(X, y, theta):\n",
+    "    \"\"\"\n",
+    "    Compute cost for linear regression with multiple variables.\n",
+    "    Computes the cost of using theta as the parameter for linear regression to fit the data points in X and y.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The dataset of shape (m x n+1).\n",
+    "    \n",
+    "    y : array_like\n",
+    "        A vector of shape (m, ) for the values at a given data point.\n",
+    "    \n",
+    "    theta : array_like\n",
+    "        The linear regression parameters. A vector of shape (n+1, )\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    J : float\n",
+    "        The value of the cost function. \n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the cost of a particular choice of theta. You should set J to the cost.\n",
+    "    \"\"\"\n",
+    "    # Initialize some useful values\n",
+    "    m = y.shape[0] # number of training examples\n",
+    "    \n",
+    "    # You need to return the following variable correctly\n",
+    "    J = 0\n",
+    "    # ======================= YOUR CODE HERE ===========================\n",
+    "    sum = 0\n",
+    "    h=np.dot(X,theta)\n",
+    "    \n",
+    "    for i in range (0,m):\n",
+    "        c=h[i]-y[i]\n",
+    "        d=np.transpose(c)\n",
+    "        sum += np.dot(d,c)\n",
+    "    J = (1/(2*m))*sum    \n",
+    "    # ==================================================================\n",
+    "    return J\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sum0(X,y,theta):\n",
+    "    sum=0\n",
+    "    for i in range (0,y.size):\n",
+    "        sum += (theta[0]*X[i,0]+theta[1]*X[i,1]+theta[2]*X[i,2]-y[i])*X[i,0]\n",
+    "    return sum\n",
+    "\n",
+    "def sum1(X,y,theta):\n",
+    "    sum=0\n",
+    "    for i in range (0,y.size):\n",
+    "        sum += (theta[0]*X[i,0]+theta[1]*X[i,1]+theta[2]*X[i,2]-y[i])*X[i,1]\n",
+    "    return sum\n",
+    "\n",
+    "def sum2(X,y,theta):\n",
+    "    sum=0\n",
+    "    for i in range (0,y.size):\n",
+    "        sum += (theta[0]*X[i,0]+theta[1]*X[i,1]+theta[2]*X[i,2]-y[i])*X[i,2]\n",
+    "    return sum"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def gradientDescentMulti(X, y, theta, alpha, num_iters):\n",
+    "    \"\"\"\n",
+    "    Performs gradient descent to learn theta.\n",
+    "    Updates theta by taking num_iters gradient steps with learning rate alpha.\n",
+    "        \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The dataset of shape (m x n+1).\n",
+    "    \n",
+    "    y : array_like\n",
+    "        A vector of shape (m, ) for the values at a given data point.\n",
+    "    \n",
+    "    theta : array_like\n",
+    "        The linear regression parameters. A vector of shape (n+1, )\n",
+    "    \n",
+    "    alpha : float\n",
+    "        The learning rate for gradient descent. \n",
+    "    \n",
+    "    num_iters : int\n",
+    "        The number of iterations to run gradient descent. \n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    theta : array_like\n",
+    "        The learned linear regression parameters. A vector of shape (n+1, ).\n",
+    "    \n",
+    "    J_history : list\n",
+    "        A python list for the values of the cost function after each iteration.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Peform a single gradient step on the parameter vector theta.\n",
+    "\n",
+    "    While debugging, it can be useful to print out the values of \n",
+    "    the cost function (computeCost) and gradient here.\n",
+    "    \"\"\"\n",
+    "    # Initialize some useful values\n",
+    "    m = y.shape[0] # number of training examples\n",
+    "    \n",
+    "    # make a copy of theta, which will be updated by gradient descent\n",
+    "    theta = theta.copy()\n",
+    "    \n",
+    "    J_history = []\n",
+    "    \n",
+    "    for i in range(num_iters):\n",
+    "        # ======================= YOUR CODE HERE ==========================\n",
+    "        \n",
+    "        T0=theta[0]-alpha*((1/m)*sum0(X,y,theta))\n",
+    "        T1=theta[1]-alpha*((1/m)*sum1(X,y,theta))\n",
+    "        T2=theta[2]-alpha*((1/m)*sum2(X,y,theta))\n",
+    "        theta[0]=T0\n",
+    "        theta[1]=T1\n",
+    "        theta[2]=T2\n",
+    "        \n",
+    "        # =================================================================\n",
+    "        \n",
+    "        # save the cost J in every iteration\n",
+    "        J_history.append(computeCostMulti(X, y, theta))\n",
+    "    \n",
+    "    return theta, J_history"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "theta computed from gradient descent: [340412.65957447 109447.75525931  -6578.31364383]\n",
+      "[340412.65957447 109447.75525931  -6578.31364383]\n",
+      "Predicted price of a 1650 sq-ft, 3 br house (using gradient descent): $293081\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"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "Instructions\n",
+    "------------\n",
+    "We have provided you with the following starter code that runs\n",
+    "gradient descent with a particular learning rate (alpha). \n",
+    "\n",
+    "Your task is to first make sure that your functions - `computeCost`\n",
+    "and `gradientDescent` already work with  this starter code and\n",
+    "support multiple variables.\n",
+    "\n",
+    "After that, try running gradient descent with different values of\n",
+    "alpha and see which one gives you the best result.\n",
+    "\n",
+    "Finally, you should complete the code at the end to predict the price\n",
+    "of a 1650 sq-ft, 3 br house.\n",
+    "\n",
+    "Hint\n",
+    "----\n",
+    "At prediction, make sure you do the same feature normalization.\n",
+    "\"\"\"\n",
+    "# Choose some alpha value - change this\n",
+    "alpha = 0.3\n",
+    "num_iters = 100\n",
+    "\n",
+    "# init theta and run gradient descent\n",
+    "theta = np.zeros(3)\n",
+    "theta, J_history = gradientDescentMulti(X, y, theta, alpha, num_iters)\n",
+    "\n",
+    "# Plot the convergence graph\n",
+    "pyplot.plot(np.arange(len(J_history)), J_history, lw=2)\n",
+    "pyplot.xlabel('Number of iterations')\n",
+    "pyplot.ylabel('Cost J')\n",
+    "\n",
+    "# Display the gradient descent's result\n",
+    "print('theta computed from gradient descent: {:s}'.format(str(theta)))\n",
+    "\n",
+    "# Estimate the price of a 1650 sq-ft, 3 br house\n",
+    "# ======================= YOUR CODE HERE ===========================\n",
+    "# Recall that the first column of X is all-ones. \n",
+    "# Thus, it does not need to be normalized.\n",
+    "\n",
+    "price = theta[0]*1+theta[1]*(1650-2000.68085106)/786.202619+theta[2]*(3-3.17021277)/0.752842809\n",
+    "print(theta)\n",
+    "# ===================================================================\n",
+    "\n",
+    "print('Predicted price of a 1650 sq-ft, 3 br house (using gradient descent): ${:.0f}'.format(price))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 330,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load data\n",
+    "data = np.loadtxt(os.path.join('Data', 'ex1data2.txt'), delimiter=',')\n",
+    "X = data[:, :2]\n",
+    "y = data[:, 2]\n",
+    "m = y.size\n",
+    "X = np.concatenate([np.ones((m, 1)), X], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 331,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def normalEqn(X, y):\n",
+    "    \"\"\"\n",
+    "    Computes the closed-form solution to linear regression using the normal equations.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The dataset of shape (m x n+1).\n",
+    "    \n",
+    "    y : array_like\n",
+    "        The value at each data point. A vector of shape (m, ).\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    theta : array_like\n",
+    "        Estimated linear regression parameters. A vector of shape (n+1, ).\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Complete the code to compute the closed form solution to linear\n",
+    "    regression and put the result in theta.\n",
+    "    \n",
+    "    Hint\n",
+    "    ----\n",
+    "    Look up the function `np.linalg.pinv` for computing matrix inverse.\n",
+    "    \"\"\"\n",
+    "    theta = np.zeros(X.shape[1])\n",
+    "    \n",
+    "    # ===================== YOUR CODE HERE ============================\n",
+    "    \n",
+    "    Part1=(np.linalg.inv(np.transpose(X).dot(X)))\n",
+    "    Part2=(np.transpose(X).dot(y))\n",
+    "    theta=Part1.dot(Part2)\n",
+    "    \n",
+    "    # =================================================================\n",
+    "    return theta"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 332,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Theta computed from the normal equations: [89597.9095428    139.21067402 -8738.01911233]\n",
+      "Predicted price of a 1650 sq-ft, 3 br house (using normal equations): $293081\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Calculate the parameters from the normal equation\n",
+    "theta = normalEqn(X, y);\n",
+    "\n",
+    "# Display normal equation's result\n",
+    "print('Theta computed from the normal equations: {:s}'.format(str(theta)));\n",
+    "\n",
+    "# Estimate the price of a 1650 sq-ft, 3 br house\n",
+    "# ====================== YOUR CODE HERE ======================\n",
+    "\n",
+    "price = theta[0]+theta[1]*1650+theta[2]*3\n",
+    "\n",
+    "# ============================================================\n",
+    "\n",
+    "print('Predicted price of a 1650 sq-ft, 3 br house (using normal equations): ${:.0f}'.format(price))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

From 460b031602dbcc0ac5ce5b07d49feea5a4e4b640 Mon Sep 17 00:00:00 2001
From: redox2024 <58564953+redox2024@users.noreply.github.com>
Date: Wed, 15 Apr 2020 19:20:56 +0500
Subject: [PATCH 2/7] Add files via upload

---
 Priyansh_Mali190107052.ipynb | 827 +++++++++++++++++++++++++++++++++++
 1 file changed, 827 insertions(+)
 create mode 100644 Priyansh_Mali190107052.ipynb

diff --git a/Priyansh_Mali190107052.ipynb b/Priyansh_Mali190107052.ipynb
new file mode 100644
index 000000000..35f3619bf
--- /dev/null
+++ b/Priyansh_Mali190107052.ipynb
@@ -0,0 +1,827 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "import numpy as np\n",
+    "from matplotlib import pyplot\n",
+    "\n",
+    "sys.path.append('..')\n",
+    "# from submission import SubmissionBase\n",
+    "\n",
+    "\n",
+    "def mapFeature(X1, X2, degree=6):\n",
+    "    \"\"\"\n",
+    "    Maps the two input features to quadratic features used in the regularization exercise.\n",
+    "    Returns a new feature array with more features, comprising of\n",
+    "    X1, X2, X1.^2, X2.^2, X1*X2, X1*X2.^2, etc..\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X1 : array_like\n",
+    "        A vector of shape (m, 1), containing one feature for all examples.\n",
+    "    X2 : array_like\n",
+    "        A vector of shape (m, 1), containing a second feature for all examples.\n",
+    "        Inputs X1, X2 must be the same size.\n",
+    "    degree: int, optional\n",
+    "        The polynomial degree.\n",
+    "    Returns\n",
+    "    -------\n",
+    "    : array_like\n",
+    "        A matrix of of m rows, and columns depend on the degree of polynomial.\n",
+    "    \"\"\"\n",
+    "    if X1.ndim > 0:\n",
+    "        out = [np.ones(X1.shape[0])]\n",
+    "    else:\n",
+    "        out = [np.ones(1)]\n",
+    "\n",
+    "    for i in range(1, degree + 1):\n",
+    "        for j in range(i + 1):\n",
+    "            out.append((X1 ** (i - j)) * (X2 ** j))\n",
+    "\n",
+    "    if X1.ndim > 0:\n",
+    "        return np.stack(out, axis=1)\n",
+    "    else:\n",
+    "        return np.array(out)\n",
+    "\n",
+    "\n",
+    "def plotDecisionBoundary(plotData, theta, X, y):\n",
+    "    \"\"\"\n",
+    "    Plots the data points X and y into a new figure with the decision boundary defined by theta.\n",
+    "    Plots the data points with * for the positive examples and o for  the negative examples.\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    plotData : func\n",
+    "        A function reference for plotting the X, y data.\n",
+    "    theta : array_like\n",
+    "        Parameters for logistic regression. A vector of shape (n+1, ).\n",
+    "    X : array_like\n",
+    "        The input dataset. X is assumed to be  a either:\n",
+    "            1) Mx3 matrix, where the first column is an all ones column for the intercept.\n",
+    "            2) MxN, N>3 matrix, where the first column is all ones.\n",
+    "    y : array_like\n",
+    "        Vector of data labels of shape (m, ).\n",
+    "    \"\"\"\n",
+    "    # make sure theta is a numpy array\n",
+    "    theta = np.array(theta)\n",
+    "\n",
+    "    # Plot Data (remember first column in X is the intercept)\n",
+    "    plotData(X[:, 1:3], y)\n",
+    "\n",
+    "    if X.shape[1] <= 3:\n",
+    "        # Only need 2 points to define a line, so choose two endpoints\n",
+    "        plot_x = np.array([np.min(X[:, 1]) - 2, np.max(X[:, 1]) + 2])\n",
+    "\n",
+    "        # Calculate the decision boundary line\n",
+    "        plot_y = (-1. / theta[2]) * (theta[1] * plot_x + theta[0])\n",
+    "\n",
+    "        # Plot, and adjust axes for better viewing\n",
+    "        pyplot.plot(plot_x, plot_y)\n",
+    "\n",
+    "        # Legend, specific for the exercise\n",
+    "        pyplot.legend(['Admitted', 'Not admitted', 'Decision Boundary'])\n",
+    "        pyplot.xlim([30, 100])\n",
+    "        pyplot.ylim([30, 100])\n",
+    "    else:\n",
+    "        # Here is the grid range\n",
+    "        u = np.linspace(-1, 1.5, 50)\n",
+    "        v = np.linspace(-1, 1.5, 50)\n",
+    "\n",
+    "        z = np.zeros((u.size, v.size))\n",
+    "        # Evaluate z = theta*x over the grid\n",
+    "        for i, ui in enumerate(u):\n",
+    "            for j, vj in enumerate(v):\n",
+    "                z[i, j] = np.dot(mapFeature(ui, vj), theta)\n",
+    "\n",
+    "        z = z.T  # important to transpose z before calling contour\n",
+    "        # print(z)\n",
+    "\n",
+    "        # Plot z = 0\n",
+    "        pyplot.contour(u, v, z, levels=[0], linewidths=2, colors='g')\n",
+    "        pyplot.contourf(u, v, z, levels=[np.min(z), 0, np.max(z)], cmap='Greens', alpha=0.4)\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# used for manipulating directory paths\n",
+    "import os\n",
+    "\n",
+    "# Scientific and vector computation for python\n",
+    "import numpy as np\n",
+    "\n",
+    "# Plotting library\n",
+    "from matplotlib import pyplot\n",
+    "import matplotlib\n",
+    "\n",
+    "import utils\n",
+    "\n",
+    "\n",
+    "# Optimization module in scipy\n",
+    "from scipy import optimize\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load data\n",
+    "# The first two columns contains the exam scores and the third column\n",
+    "# contains the label.\n",
+    "data = np.loadtxt(os.path.join('Data', 'ex2data1.txt'), delimiter=',')\n",
+    "X, y = data[:, 0:2], data[:, 2]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plotData(X, y):\n",
+    "    \"\"\"\n",
+    "    Plots the data points X and y into a new figure. Plots the data \n",
+    "    points with * for the positive examples and o for the negative examples.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        An Mx2 matrix representing the dataset. \n",
+    "    \n",
+    "    y : array_like\n",
+    "        Label values for the dataset. A vector of size (M, ).\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Plot the positive and negative examples on a 2D plot, using the\n",
+    "    option 'k*' for the positive examples and 'ko' for the negative examples.    \n",
+    "    \"\"\"\n",
+    "    # Create New Figure\n",
+    "    fig = pyplot.figure()\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    # Find Indices of Positive and Negative Examples\n",
+    "    pos = y == 1\n",
+    "    neg = y == 0\n",
+    "\n",
+    "    # Plot Examples\n",
+    "    pyplot.plot(X[pos, 0], X[pos, 1], 'k*', lw=2, ms=10)\n",
+    "    pyplot.plot(X[neg, 0], X[neg, 1], 'ko', mfc='y', ms=8, mec='k', mew=1)\n",
+    "    \n",
+    "    # ============================================================"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "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"
+    }
+   ],
+   "source": [
+    "plotData(X, y)\n",
+    "# add axes labels\n",
+    "pyplot.xlabel('Exam 1 score')\n",
+    "pyplot.ylabel('Exam 2 score')\n",
+    "pyplot.legend(['Admitted', 'Not admitted'])\n",
+    "pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sigmoid(z):\n",
+    "    \"\"\"\n",
+    "    Compute sigmoid function given the input z.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    z : array_like\n",
+    "        The input to the sigmoid function. This can be a 1-D vector \n",
+    "        or a 2-D matrix. \n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    g : array_like\n",
+    "        The computed sigmoid function. g has the same shape as z, since\n",
+    "        the sigmoid is computed element-wise on z.\n",
+    "        \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the sigmoid of each value of z (z can be a matrix, vector or scalar).\n",
+    "    \"\"\"\n",
+    "    # convert input to a numpy array\n",
+    "    z = np.array(z)\n",
+    "    \n",
+    "    # You need to return the following variables correctly \n",
+    "    g = np.zeros(z.shape)\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    g = 1/(1+np.exp(-z))\n",
+    "    \n",
+    "\n",
+    "    # =============================================================\n",
+    "    return g"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "g( 0 ) =  0.5\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Test the implementation of sigmoid function here\n",
+    "z = 0\n",
+    "g = sigmoid(z)\n",
+    "\n",
+    "print('g(', z, ') = ', g)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Setup the data matrix appropriately, and add ones for the intercept term\n",
+    "m, n = X.shape\n",
+    "\n",
+    "# Add intercept term to X\n",
+    "X = np.concatenate([np.ones((m, 1)), X], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def costFunction(theta, X, y):\n",
+    "    \"\"\"\n",
+    "    Compute cost and gradient for logistic regression. \n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    theta : array_like\n",
+    "        The parameters for logistic regression. This a vector\n",
+    "        of shape (n+1, ).\n",
+    "    \n",
+    "    X : array_like\n",
+    "        The input dataset of shape (m x n+1) where m is the total number\n",
+    "        of data points and n is the number of features. We assume the \n",
+    "        intercept has already been added to the input.\n",
+    "    \n",
+    "    y : arra_like\n",
+    "        Labels for the input. This is a vector of shape (m, ).\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    J : float\n",
+    "        The computed value for the cost function. \n",
+    "    \n",
+    "    grad : array_like\n",
+    "        A vector of shape (n+1, ) which is the gradient of the cost\n",
+    "        function with respect to theta, at the current values of theta.\n",
+    "        \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the cost of a particular choice of theta. You should set J to \n",
+    "    the cost. Compute the partial derivatives and set grad to the partial\n",
+    "    derivatives of the cost w.r.t. each parameter in theta.\n",
+    "    \"\"\"\n",
+    "    # Initialize some useful values\n",
+    "    m = y.size  # number of training examples\n",
+    "\n",
+    "    # You need to return the following variables correctly \n",
+    "    J = 0\n",
+    "    grad = np.zeros(theta.shape)\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    m, n = X.shape\n",
+    "    z = X.dot(theta)\n",
+    "\n",
+    "    J = 1.0 / m * (-y.T.dot(np.log(sigmoid(z))) - (1 - y).T.dot(np.log(1 - sigmoid(z))))\n",
+    "\n",
+    "    grad = 1.0 / m * (sigmoid(z) - y).T.dot(X)\n",
+    "   \n",
+    "    \n",
+    "    # =============================================================\n",
+    "    return J, grad"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cost at initial theta (zeros): 0.693\n",
+      "Expected cost (approx): 0.693\n",
+      "\n",
+      "Gradient at initial theta (zeros):\n",
+      "\t[-0.1000, -12.0092, -11.2628]\n",
+      "Expected gradients (approx):\n",
+      "\t[-0.1000, -12.0092, -11.2628]\n",
+      "\n",
+      "Cost at test theta: 0.218\n",
+      "Expected cost (approx): 0.218\n",
+      "\n",
+      "Gradient at test theta:\n",
+      "\t[0.043, 2.566, 2.647]\n",
+      "Expected gradients (approx):\n",
+      "\t[0.043, 2.566, 2.647]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Initialize fitting parameters\n",
+    "initial_theta = np.zeros(n+1)\n",
+    "\n",
+    "cost, grad = costFunction(initial_theta, X, y)\n",
+    "\n",
+    "print('Cost at initial theta (zeros): {:.3f}'.format(cost))\n",
+    "print('Expected cost (approx): 0.693\\n')\n",
+    "\n",
+    "print('Gradient at initial theta (zeros):')\n",
+    "print('\\t[{:.4f}, {:.4f}, {:.4f}]'.format(*grad))\n",
+    "print('Expected gradients (approx):\\n\\t[-0.1000, -12.0092, -11.2628]\\n')\n",
+    "\n",
+    "# Compute and display cost and gradient with non-zero theta\n",
+    "test_theta = np.array([-24, 0.2, 0.2])\n",
+    "cost, grad = costFunction(test_theta, X, y)\n",
+    "\n",
+    "print('Cost at test theta: {:.3f}'.format(cost))\n",
+    "print('Expected cost (approx): 0.218\\n')\n",
+    "\n",
+    "print('Gradient at test theta:')\n",
+    "print('\\t[{:.3f}, {:.3f}, {:.3f}]'.format(*grad))\n",
+    "print('Expected gradients (approx):\\n\\t[0.043, 2.566, 2.647]')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cost at theta found by optimize.minimize: 0.203\n",
+      "Expected cost (approx): 0.203\n",
+      "\n",
+      "theta:\n",
+      "\t[-25.161, 0.206, 0.201]\n",
+      "Expected theta (approx):\n",
+      "\t[-25.161, 0.206, 0.201]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set options for optimize.minimize\n",
+    "options= {'maxiter': 400}\n",
+    "\n",
+    "# see documention for scipy's optimize.minimize  for description about\n",
+    "# the different parameters\n",
+    "# The function returns an object `OptimizeResult`\n",
+    "# We use truncated Newton algorithm for optimization which is \n",
+    "# equivalent to MATLAB's fminunc\n",
+    "# See https://stackoverflow.com/questions/18801002/fminunc-alternate-in-numpy\n",
+    "res = optimize.minimize(costFunction,initial_theta,(X, y),jac=True,method='TNC',options=options)\n",
+    "\n",
+    "# the fun property of `OptimizeResult` object returns\n",
+    "# the value of costFunction at optimized theta\n",
+    "cost = res.fun\n",
+    "\n",
+    "# the optimized theta is in the x property\n",
+    "theta = res.x\n",
+    "\n",
+    "# Print theta to screen\n",
+    "print('Cost at theta found by optimize.minimize: {:.3f}'.format(cost))\n",
+    "print('Expected cost (approx): 0.203\\n');\n",
+    "\n",
+    "print('theta:')\n",
+    "print('\\t[{:.3f}, {:.3f}, {:.3f}]'.format(*theta))\n",
+    "print('Expected theta (approx):\\n\\t[-25.161, 0.206, 0.201]')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "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"
+    }
+   ],
+   "source": [
+    "# Plot Boundary\n",
+    "plotDecisionBoundary(plotData, theta, X, y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def predict(theta, X):\n",
+    "    \"\"\"\n",
+    "    Predict whether the label is 0 or 1 using learned logistic regression.\n",
+    "    Computes the predictions for X using a threshold at 0.5 \n",
+    "    (i.e., if sigmoid(theta.T*x) >= 0.5, predict 1)\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    theta : array_like\n",
+    "        Parameters for logistic regression. A vecotor of shape (n+1, ).\n",
+    "    \n",
+    "    X : array_like\n",
+    "        The data to use for computing predictions. The rows is the number \n",
+    "        of points to compute predictions, and columns is the number of\n",
+    "        features.\n",
+    "\n",
+    "    Returns\n",
+    "    -------\n",
+    "    p : array_like\n",
+    "        Predictions and 0 or 1 for each row in X. \n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Complete the following code to make predictions using your learned \n",
+    "    logistic regression parameters.You should set p to a vector of 0's and 1's    \n",
+    "    \"\"\"\n",
+    "    m = X.shape[0] # Number of training examples\n",
+    "\n",
+    "    # You need to return the following variables correctly\n",
+    "    p = np.zeros(m)\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    z=np.dot(X,theta.T)\n",
+    "    pred = sigmoid(z)\n",
+    "    p = np.where(pred >= .5, 1, 0) \n",
+    "    p=np.squeeze(p) \n",
+    "    \n",
+    "    \n",
+    "    # ============================================================\n",
+    "    return p"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "For a student with scores 45 and 85,we predict an admission probability of 0.776\n",
+      "Expected value: 0.775 +/- 0.002\n",
+      "\n",
+      "Train Accuracy: 89.00 %\n",
+      "Expected accuracy (approx): 89.00 %\n"
+     ]
+    }
+   ],
+   "source": [
+    "#  Predict probability for a student with score 45 on exam 1 \n",
+    "#  and score 85 on exam 2 \n",
+    "prob = sigmoid(np.dot([1, 45, 85], theta))\n",
+    "print('For a student with scores 45 and 85,'\n",
+    "      'we predict an admission probability of {:.3f}'.format(prob))\n",
+    "print('Expected value: 0.775 +/- 0.002\\n')\n",
+    "\n",
+    "# Compute accuracy on our training set\n",
+    "p = predict(theta, X)\n",
+    "print('Train Accuracy: {:.2f} %'.format(np.mean(p == y) * 100))\n",
+    "print('Expected accuracy (approx): 89.00 %')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load Data\n",
+    "# The first two columns contains the X values and the third column\n",
+    "# contains the label (y).\n",
+    "data = np.loadtxt(os.path.join('Data', 'ex2data2.txt'), delimiter=',')\n",
+    "X = data[:, :2]\n",
+    "y = data[:, 2]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "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"
+    }
+   ],
+   "source": [
+    "plotData(X, y)\n",
+    "# Labels and Legend\n",
+    "pyplot.xlabel('Microchip Test 1')\n",
+    "pyplot.ylabel('Microchip Test 2')\n",
+    "\n",
+    "# Specified in plot order\n",
+    "pyplot.legend(['y = 1', 'y = 0'], loc='upper right')\n",
+    "pass\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Note that mapFeature also adds a column of ones for us, so the intercept\n",
+    "# term is handled\n",
+    "X = map_feature(X[:, 0], X[:, 1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def costFunctionReg(theta, X, y, lambda_):\n",
+    "    \"\"\"\n",
+    "    Compute cost and gradient for logistic regression with regularization.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    theta : array_like\n",
+    "        Logistic regression parameters. A vector with shape (n, ). n is \n",
+    "        the number of features including any intercept. If we have mapped\n",
+    "        our initial features into polynomial features, then n is the total \n",
+    "        number of polynomial features. \n",
+    "    \n",
+    "    X : array_like\n",
+    "        The data set with shape (m x n). m is the number of examples, and\n",
+    "        n is the number of features (after feature mapping).\n",
+    "    \n",
+    "    y : array_like\n",
+    "        The data labels. A vector with shape (m, ).\n",
+    "    \n",
+    "    lambda_ : float\n",
+    "        The regularization parameter. \n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    J : float\n",
+    "        The computed value for the regularized cost function. \n",
+    "    \n",
+    "    grad : array_like\n",
+    "        A vector of shape (n, ) which is the gradient of the cost\n",
+    "        function with respect to theta, at the current values of theta.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the cost `J` of a particular choice of theta.\n",
+    "    Compute the partial derivatives and set `grad` to the partial\n",
+    "    derivatives of the cost w.r.t. each parameter in theta.\n",
+    "    \"\"\"\n",
+    "    # Initialize some useful values\n",
+    "    m = y.size  # number of training examples\n",
+    "\n",
+    "    # You need to return the following variables correctly \n",
+    "    J = 0\n",
+    "    grad = np.zeros(theta.shape)\n",
+    "   \n",
+    "\n",
+    "    # ===================== YOUR CODE HERE ======================\n",
+    "    m, n = X.shape\n",
+    "    z = X.dot(theta)\n",
+    "    i = np.eye(len(theta))\n",
+    "    # Skip the theta[0, 0] parameter when performing regularization\n",
+    "    i[0,0] = 0\n",
+    "    \n",
+    "    J = 1.0 / m * (np.dot(-y.T, np.log(sigmoid(z))) - np.dot((1 - y).T, np.log(1 - sigmoid(z)))) \n",
+    "    J += 1.0 * (lambda_) / (2 * m) * np.sum(np.power((i.dot(theta)), 2))\n",
+    "\n",
+    "    grad = 1.0 / m * np.dot((sigmoid(z) - y).T, X).T + 1.0 * (lambda_) / m * (i.dot(theta))\n",
+    "\n",
+    "   \n",
+    "    # =============================================================\n",
+    "    return J, grad"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cost at initial theta (zeros): 0.693\n",
+      "Expected cost (approx)       : 0.693\n",
+      "\n",
+      "Gradient at initial theta (zeros) - first five values only:\n",
+      "\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\n",
+      "Expected gradients (approx) - first five values only:\n",
+      "\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\n",
+      "\n",
+      "------------------------------\n",
+      "\n",
+      "Cost at test theta    : 3.16\n",
+      "Expected cost (approx): 3.16\n",
+      "\n",
+      "Gradient at initial theta (zeros) - first five values only:\n",
+      "\t[0.3460, 0.1614, 0.1948, 0.2269, 0.0922]\n",
+      "Expected gradients (approx) - first five values only:\n",
+      "\t[0.3460, 0.1614, 0.1948, 0.2269, 0.0922]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Initialize fitting parameters\n",
+    "initial_theta = np.zeros(X.shape[1])\n",
+    "\n",
+    "# Set regularization parameter lambda to 1\n",
+    "# DO NOT use `lambda` as a variable name in python\n",
+    "# because it is a python keyword\n",
+    "lambda_ = 1\n",
+    "\n",
+    "# Compute and display initial cost and gradient for regularized logistic\n",
+    "# regression\n",
+    "cost, grad = costFunctionReg(initial_theta, X, y, lambda_)\n",
+    "\n",
+    "print('Cost at initial theta (zeros): {:.3f}'.format(cost))\n",
+    "print('Expected cost (approx)       : 0.693\\n')\n",
+    "\n",
+    "print('Gradient at initial theta (zeros) - first five values only:')\n",
+    "print('\\t[{:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f}]'.format(*grad[:5]))\n",
+    "print('Expected gradients (approx) - first five values only:')\n",
+    "print('\\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\\n')\n",
+    "\n",
+    "\n",
+    "# Compute and display cost and gradient\n",
+    "# with all-ones theta and lambda = 10\n",
+    "test_theta = np.ones(X.shape[1])\n",
+    "cost, grad = costFunctionReg(test_theta, X, y, 10)\n",
+    "\n",
+    "print('------------------------------\\n')\n",
+    "print('Cost at test theta    : {:.2f}'.format(cost))\n",
+    "print('Expected cost (approx): 3.16\\n')\n",
+    "\n",
+    "print('Gradient at initial theta (zeros) - first five values only:')\n",
+    "print('\\t[{:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f}]'.format(*grad[:5]))\n",
+    "print('Expected gradients (approx) - first five values only:')\n",
+    "print('\\t[0.3460, 0.1614, 0.1948, 0.2269, 0.0922]')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train Accuracy: 83.1 %\n",
+      "Expected accuracy (with lambda = 1): 83.1 % (approx)\n",
+      "\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"
+    }
+   ],
+   "source": [
+    "# Initialize fitting parameters\n",
+    "initial_theta = np.zeros(X.shape[1])\n",
+    "\n",
+    "# Set regularization parameter lambda to 1 (you should vary this)\n",
+    "lambda_ = 1\n",
+    "\n",
+    "# set options for optimize.minimize\n",
+    "options= {'maxiter': 100}\n",
+    "\n",
+    "res = optimize.minimize(costFunctionReg,\n",
+    "                        initial_theta,\n",
+    "                        (X, y, lambda_),\n",
+    "                        jac=True,\n",
+    "                        method='TNC',\n",
+    "                        options=options)\n",
+    "\n",
+    "# the fun property of OptimizeResult object returns\n",
+    "# the value of costFunction at optimized theta\n",
+    "cost = res.fun\n",
+    "\n",
+    "# the optimized theta is in the x property of the result\n",
+    "theta = res.x\n",
+    "\n",
+    "plotDecisionBoundary(plotData, theta, X, y)\n",
+    "pyplot.xlabel('Microchip Test 1')\n",
+    "pyplot.ylabel('Microchip Test 2')\n",
+    "pyplot.legend(['y = 1', 'y = 0'])\n",
+    "pyplot.grid(False)\n",
+    "pyplot.title('lambda = %0.2f' % lambda_)\n",
+    "\n",
+    "# Compute accuracy on our training set\n",
+    "p = predict(theta, X)\n",
+    "\n",
+    "print('Train Accuracy: %.1f %%' % (np.mean(p == y) * 100))\n",
+    "print('Expected accuracy (with lambda = 1): 83.1 % (approx)\\n')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

From 200b7639538d38e17ccff809e10f617b60da273d Mon Sep 17 00:00:00 2001
From: redox2024 <58564953+redox2024@users.noreply.github.com>
Date: Wed, 15 Apr 2020 19:47:11 +0500
Subject: [PATCH 3/7] Priyansh Mali 190107052 week 3 solution


From e27f04d72d6d6cb79a2837efd567f51e9d629250 Mon Sep 17 00:00:00 2001
From: redox2024 <58564953+redox2024@users.noreply.github.com>
Date: Wed, 15 Apr 2020 21:31:47 +0500
Subject: [PATCH 4/7] Priyansh.M 190107052


From 4f5a1cdad1c228c4924f62c33886858f2b994cb2 Mon Sep 17 00:00:00 2001
From: redox2024 <58564953+redox2024@users.noreply.github.com>
Date: Wed, 15 Apr 2020 22:25:40 +0530
Subject: [PATCH 5/7] Add files via upload

---
 .../Priyansh_Mali190107052.ipynb              | 827 ++++++++++++++++++
 1 file changed, 827 insertions(+)
 create mode 100644 Phase 3 - 2020 (Summer)/Week 3(Apr 13 - Apr 18)/Priyansh_Mali190107052.ipynb

diff --git a/Phase 3 - 2020 (Summer)/Week 3(Apr 13 - Apr 18)/Priyansh_Mali190107052.ipynb b/Phase 3 - 2020 (Summer)/Week 3(Apr 13 - Apr 18)/Priyansh_Mali190107052.ipynb
new file mode 100644
index 000000000..35f3619bf
--- /dev/null
+++ b/Phase 3 - 2020 (Summer)/Week 3(Apr 13 - Apr 18)/Priyansh_Mali190107052.ipynb	
@@ -0,0 +1,827 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "import numpy as np\n",
+    "from matplotlib import pyplot\n",
+    "\n",
+    "sys.path.append('..')\n",
+    "# from submission import SubmissionBase\n",
+    "\n",
+    "\n",
+    "def mapFeature(X1, X2, degree=6):\n",
+    "    \"\"\"\n",
+    "    Maps the two input features to quadratic features used in the regularization exercise.\n",
+    "    Returns a new feature array with more features, comprising of\n",
+    "    X1, X2, X1.^2, X2.^2, X1*X2, X1*X2.^2, etc..\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X1 : array_like\n",
+    "        A vector of shape (m, 1), containing one feature for all examples.\n",
+    "    X2 : array_like\n",
+    "        A vector of shape (m, 1), containing a second feature for all examples.\n",
+    "        Inputs X1, X2 must be the same size.\n",
+    "    degree: int, optional\n",
+    "        The polynomial degree.\n",
+    "    Returns\n",
+    "    -------\n",
+    "    : array_like\n",
+    "        A matrix of of m rows, and columns depend on the degree of polynomial.\n",
+    "    \"\"\"\n",
+    "    if X1.ndim > 0:\n",
+    "        out = [np.ones(X1.shape[0])]\n",
+    "    else:\n",
+    "        out = [np.ones(1)]\n",
+    "\n",
+    "    for i in range(1, degree + 1):\n",
+    "        for j in range(i + 1):\n",
+    "            out.append((X1 ** (i - j)) * (X2 ** j))\n",
+    "\n",
+    "    if X1.ndim > 0:\n",
+    "        return np.stack(out, axis=1)\n",
+    "    else:\n",
+    "        return np.array(out)\n",
+    "\n",
+    "\n",
+    "def plotDecisionBoundary(plotData, theta, X, y):\n",
+    "    \"\"\"\n",
+    "    Plots the data points X and y into a new figure with the decision boundary defined by theta.\n",
+    "    Plots the data points with * for the positive examples and o for  the negative examples.\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    plotData : func\n",
+    "        A function reference for plotting the X, y data.\n",
+    "    theta : array_like\n",
+    "        Parameters for logistic regression. A vector of shape (n+1, ).\n",
+    "    X : array_like\n",
+    "        The input dataset. X is assumed to be  a either:\n",
+    "            1) Mx3 matrix, where the first column is an all ones column for the intercept.\n",
+    "            2) MxN, N>3 matrix, where the first column is all ones.\n",
+    "    y : array_like\n",
+    "        Vector of data labels of shape (m, ).\n",
+    "    \"\"\"\n",
+    "    # make sure theta is a numpy array\n",
+    "    theta = np.array(theta)\n",
+    "\n",
+    "    # Plot Data (remember first column in X is the intercept)\n",
+    "    plotData(X[:, 1:3], y)\n",
+    "\n",
+    "    if X.shape[1] <= 3:\n",
+    "        # Only need 2 points to define a line, so choose two endpoints\n",
+    "        plot_x = np.array([np.min(X[:, 1]) - 2, np.max(X[:, 1]) + 2])\n",
+    "\n",
+    "        # Calculate the decision boundary line\n",
+    "        plot_y = (-1. / theta[2]) * (theta[1] * plot_x + theta[0])\n",
+    "\n",
+    "        # Plot, and adjust axes for better viewing\n",
+    "        pyplot.plot(plot_x, plot_y)\n",
+    "\n",
+    "        # Legend, specific for the exercise\n",
+    "        pyplot.legend(['Admitted', 'Not admitted', 'Decision Boundary'])\n",
+    "        pyplot.xlim([30, 100])\n",
+    "        pyplot.ylim([30, 100])\n",
+    "    else:\n",
+    "        # Here is the grid range\n",
+    "        u = np.linspace(-1, 1.5, 50)\n",
+    "        v = np.linspace(-1, 1.5, 50)\n",
+    "\n",
+    "        z = np.zeros((u.size, v.size))\n",
+    "        # Evaluate z = theta*x over the grid\n",
+    "        for i, ui in enumerate(u):\n",
+    "            for j, vj in enumerate(v):\n",
+    "                z[i, j] = np.dot(mapFeature(ui, vj), theta)\n",
+    "\n",
+    "        z = z.T  # important to transpose z before calling contour\n",
+    "        # print(z)\n",
+    "\n",
+    "        # Plot z = 0\n",
+    "        pyplot.contour(u, v, z, levels=[0], linewidths=2, colors='g')\n",
+    "        pyplot.contourf(u, v, z, levels=[np.min(z), 0, np.max(z)], cmap='Greens', alpha=0.4)\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# used for manipulating directory paths\n",
+    "import os\n",
+    "\n",
+    "# Scientific and vector computation for python\n",
+    "import numpy as np\n",
+    "\n",
+    "# Plotting library\n",
+    "from matplotlib import pyplot\n",
+    "import matplotlib\n",
+    "\n",
+    "import utils\n",
+    "\n",
+    "\n",
+    "# Optimization module in scipy\n",
+    "from scipy import optimize\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load data\n",
+    "# The first two columns contains the exam scores and the third column\n",
+    "# contains the label.\n",
+    "data = np.loadtxt(os.path.join('Data', 'ex2data1.txt'), delimiter=',')\n",
+    "X, y = data[:, 0:2], data[:, 2]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plotData(X, y):\n",
+    "    \"\"\"\n",
+    "    Plots the data points X and y into a new figure. Plots the data \n",
+    "    points with * for the positive examples and o for the negative examples.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        An Mx2 matrix representing the dataset. \n",
+    "    \n",
+    "    y : array_like\n",
+    "        Label values for the dataset. A vector of size (M, ).\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Plot the positive and negative examples on a 2D plot, using the\n",
+    "    option 'k*' for the positive examples and 'ko' for the negative examples.    \n",
+    "    \"\"\"\n",
+    "    # Create New Figure\n",
+    "    fig = pyplot.figure()\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    # Find Indices of Positive and Negative Examples\n",
+    "    pos = y == 1\n",
+    "    neg = y == 0\n",
+    "\n",
+    "    # Plot Examples\n",
+    "    pyplot.plot(X[pos, 0], X[pos, 1], 'k*', lw=2, ms=10)\n",
+    "    pyplot.plot(X[neg, 0], X[neg, 1], 'ko', mfc='y', ms=8, mec='k', mew=1)\n",
+    "    \n",
+    "    # ============================================================"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "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"
+    }
+   ],
+   "source": [
+    "plotData(X, y)\n",
+    "# add axes labels\n",
+    "pyplot.xlabel('Exam 1 score')\n",
+    "pyplot.ylabel('Exam 2 score')\n",
+    "pyplot.legend(['Admitted', 'Not admitted'])\n",
+    "pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sigmoid(z):\n",
+    "    \"\"\"\n",
+    "    Compute sigmoid function given the input z.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    z : array_like\n",
+    "        The input to the sigmoid function. This can be a 1-D vector \n",
+    "        or a 2-D matrix. \n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    g : array_like\n",
+    "        The computed sigmoid function. g has the same shape as z, since\n",
+    "        the sigmoid is computed element-wise on z.\n",
+    "        \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the sigmoid of each value of z (z can be a matrix, vector or scalar).\n",
+    "    \"\"\"\n",
+    "    # convert input to a numpy array\n",
+    "    z = np.array(z)\n",
+    "    \n",
+    "    # You need to return the following variables correctly \n",
+    "    g = np.zeros(z.shape)\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    g = 1/(1+np.exp(-z))\n",
+    "    \n",
+    "\n",
+    "    # =============================================================\n",
+    "    return g"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "g( 0 ) =  0.5\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Test the implementation of sigmoid function here\n",
+    "z = 0\n",
+    "g = sigmoid(z)\n",
+    "\n",
+    "print('g(', z, ') = ', g)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Setup the data matrix appropriately, and add ones for the intercept term\n",
+    "m, n = X.shape\n",
+    "\n",
+    "# Add intercept term to X\n",
+    "X = np.concatenate([np.ones((m, 1)), X], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def costFunction(theta, X, y):\n",
+    "    \"\"\"\n",
+    "    Compute cost and gradient for logistic regression. \n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    theta : array_like\n",
+    "        The parameters for logistic regression. This a vector\n",
+    "        of shape (n+1, ).\n",
+    "    \n",
+    "    X : array_like\n",
+    "        The input dataset of shape (m x n+1) where m is the total number\n",
+    "        of data points and n is the number of features. We assume the \n",
+    "        intercept has already been added to the input.\n",
+    "    \n",
+    "    y : arra_like\n",
+    "        Labels for the input. This is a vector of shape (m, ).\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    J : float\n",
+    "        The computed value for the cost function. \n",
+    "    \n",
+    "    grad : array_like\n",
+    "        A vector of shape (n+1, ) which is the gradient of the cost\n",
+    "        function with respect to theta, at the current values of theta.\n",
+    "        \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the cost of a particular choice of theta. You should set J to \n",
+    "    the cost. Compute the partial derivatives and set grad to the partial\n",
+    "    derivatives of the cost w.r.t. each parameter in theta.\n",
+    "    \"\"\"\n",
+    "    # Initialize some useful values\n",
+    "    m = y.size  # number of training examples\n",
+    "\n",
+    "    # You need to return the following variables correctly \n",
+    "    J = 0\n",
+    "    grad = np.zeros(theta.shape)\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    m, n = X.shape\n",
+    "    z = X.dot(theta)\n",
+    "\n",
+    "    J = 1.0 / m * (-y.T.dot(np.log(sigmoid(z))) - (1 - y).T.dot(np.log(1 - sigmoid(z))))\n",
+    "\n",
+    "    grad = 1.0 / m * (sigmoid(z) - y).T.dot(X)\n",
+    "   \n",
+    "    \n",
+    "    # =============================================================\n",
+    "    return J, grad"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cost at initial theta (zeros): 0.693\n",
+      "Expected cost (approx): 0.693\n",
+      "\n",
+      "Gradient at initial theta (zeros):\n",
+      "\t[-0.1000, -12.0092, -11.2628]\n",
+      "Expected gradients (approx):\n",
+      "\t[-0.1000, -12.0092, -11.2628]\n",
+      "\n",
+      "Cost at test theta: 0.218\n",
+      "Expected cost (approx): 0.218\n",
+      "\n",
+      "Gradient at test theta:\n",
+      "\t[0.043, 2.566, 2.647]\n",
+      "Expected gradients (approx):\n",
+      "\t[0.043, 2.566, 2.647]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Initialize fitting parameters\n",
+    "initial_theta = np.zeros(n+1)\n",
+    "\n",
+    "cost, grad = costFunction(initial_theta, X, y)\n",
+    "\n",
+    "print('Cost at initial theta (zeros): {:.3f}'.format(cost))\n",
+    "print('Expected cost (approx): 0.693\\n')\n",
+    "\n",
+    "print('Gradient at initial theta (zeros):')\n",
+    "print('\\t[{:.4f}, {:.4f}, {:.4f}]'.format(*grad))\n",
+    "print('Expected gradients (approx):\\n\\t[-0.1000, -12.0092, -11.2628]\\n')\n",
+    "\n",
+    "# Compute and display cost and gradient with non-zero theta\n",
+    "test_theta = np.array([-24, 0.2, 0.2])\n",
+    "cost, grad = costFunction(test_theta, X, y)\n",
+    "\n",
+    "print('Cost at test theta: {:.3f}'.format(cost))\n",
+    "print('Expected cost (approx): 0.218\\n')\n",
+    "\n",
+    "print('Gradient at test theta:')\n",
+    "print('\\t[{:.3f}, {:.3f}, {:.3f}]'.format(*grad))\n",
+    "print('Expected gradients (approx):\\n\\t[0.043, 2.566, 2.647]')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cost at theta found by optimize.minimize: 0.203\n",
+      "Expected cost (approx): 0.203\n",
+      "\n",
+      "theta:\n",
+      "\t[-25.161, 0.206, 0.201]\n",
+      "Expected theta (approx):\n",
+      "\t[-25.161, 0.206, 0.201]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set options for optimize.minimize\n",
+    "options= {'maxiter': 400}\n",
+    "\n",
+    "# see documention for scipy's optimize.minimize  for description about\n",
+    "# the different parameters\n",
+    "# The function returns an object `OptimizeResult`\n",
+    "# We use truncated Newton algorithm for optimization which is \n",
+    "# equivalent to MATLAB's fminunc\n",
+    "# See https://stackoverflow.com/questions/18801002/fminunc-alternate-in-numpy\n",
+    "res = optimize.minimize(costFunction,initial_theta,(X, y),jac=True,method='TNC',options=options)\n",
+    "\n",
+    "# the fun property of `OptimizeResult` object returns\n",
+    "# the value of costFunction at optimized theta\n",
+    "cost = res.fun\n",
+    "\n",
+    "# the optimized theta is in the x property\n",
+    "theta = res.x\n",
+    "\n",
+    "# Print theta to screen\n",
+    "print('Cost at theta found by optimize.minimize: {:.3f}'.format(cost))\n",
+    "print('Expected cost (approx): 0.203\\n');\n",
+    "\n",
+    "print('theta:')\n",
+    "print('\\t[{:.3f}, {:.3f}, {:.3f}]'.format(*theta))\n",
+    "print('Expected theta (approx):\\n\\t[-25.161, 0.206, 0.201]')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "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"
+    }
+   ],
+   "source": [
+    "# Plot Boundary\n",
+    "plotDecisionBoundary(plotData, theta, X, y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def predict(theta, X):\n",
+    "    \"\"\"\n",
+    "    Predict whether the label is 0 or 1 using learned logistic regression.\n",
+    "    Computes the predictions for X using a threshold at 0.5 \n",
+    "    (i.e., if sigmoid(theta.T*x) >= 0.5, predict 1)\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    theta : array_like\n",
+    "        Parameters for logistic regression. A vecotor of shape (n+1, ).\n",
+    "    \n",
+    "    X : array_like\n",
+    "        The data to use for computing predictions. The rows is the number \n",
+    "        of points to compute predictions, and columns is the number of\n",
+    "        features.\n",
+    "\n",
+    "    Returns\n",
+    "    -------\n",
+    "    p : array_like\n",
+    "        Predictions and 0 or 1 for each row in X. \n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Complete the following code to make predictions using your learned \n",
+    "    logistic regression parameters.You should set p to a vector of 0's and 1's    \n",
+    "    \"\"\"\n",
+    "    m = X.shape[0] # Number of training examples\n",
+    "\n",
+    "    # You need to return the following variables correctly\n",
+    "    p = np.zeros(m)\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    z=np.dot(X,theta.T)\n",
+    "    pred = sigmoid(z)\n",
+    "    p = np.where(pred >= .5, 1, 0) \n",
+    "    p=np.squeeze(p) \n",
+    "    \n",
+    "    \n",
+    "    # ============================================================\n",
+    "    return p"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "For a student with scores 45 and 85,we predict an admission probability of 0.776\n",
+      "Expected value: 0.775 +/- 0.002\n",
+      "\n",
+      "Train Accuracy: 89.00 %\n",
+      "Expected accuracy (approx): 89.00 %\n"
+     ]
+    }
+   ],
+   "source": [
+    "#  Predict probability for a student with score 45 on exam 1 \n",
+    "#  and score 85 on exam 2 \n",
+    "prob = sigmoid(np.dot([1, 45, 85], theta))\n",
+    "print('For a student with scores 45 and 85,'\n",
+    "      'we predict an admission probability of {:.3f}'.format(prob))\n",
+    "print('Expected value: 0.775 +/- 0.002\\n')\n",
+    "\n",
+    "# Compute accuracy on our training set\n",
+    "p = predict(theta, X)\n",
+    "print('Train Accuracy: {:.2f} %'.format(np.mean(p == y) * 100))\n",
+    "print('Expected accuracy (approx): 89.00 %')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load Data\n",
+    "# The first two columns contains the X values and the third column\n",
+    "# contains the label (y).\n",
+    "data = np.loadtxt(os.path.join('Data', 'ex2data2.txt'), delimiter=',')\n",
+    "X = data[:, :2]\n",
+    "y = data[:, 2]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "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"
+    }
+   ],
+   "source": [
+    "plotData(X, y)\n",
+    "# Labels and Legend\n",
+    "pyplot.xlabel('Microchip Test 1')\n",
+    "pyplot.ylabel('Microchip Test 2')\n",
+    "\n",
+    "# Specified in plot order\n",
+    "pyplot.legend(['y = 1', 'y = 0'], loc='upper right')\n",
+    "pass\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Note that mapFeature also adds a column of ones for us, so the intercept\n",
+    "# term is handled\n",
+    "X = map_feature(X[:, 0], X[:, 1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def costFunctionReg(theta, X, y, lambda_):\n",
+    "    \"\"\"\n",
+    "    Compute cost and gradient for logistic regression with regularization.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    theta : array_like\n",
+    "        Logistic regression parameters. A vector with shape (n, ). n is \n",
+    "        the number of features including any intercept. If we have mapped\n",
+    "        our initial features into polynomial features, then n is the total \n",
+    "        number of polynomial features. \n",
+    "    \n",
+    "    X : array_like\n",
+    "        The data set with shape (m x n). m is the number of examples, and\n",
+    "        n is the number of features (after feature mapping).\n",
+    "    \n",
+    "    y : array_like\n",
+    "        The data labels. A vector with shape (m, ).\n",
+    "    \n",
+    "    lambda_ : float\n",
+    "        The regularization parameter. \n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    J : float\n",
+    "        The computed value for the regularized cost function. \n",
+    "    \n",
+    "    grad : array_like\n",
+    "        A vector of shape (n, ) which is the gradient of the cost\n",
+    "        function with respect to theta, at the current values of theta.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the cost `J` of a particular choice of theta.\n",
+    "    Compute the partial derivatives and set `grad` to the partial\n",
+    "    derivatives of the cost w.r.t. each parameter in theta.\n",
+    "    \"\"\"\n",
+    "    # Initialize some useful values\n",
+    "    m = y.size  # number of training examples\n",
+    "\n",
+    "    # You need to return the following variables correctly \n",
+    "    J = 0\n",
+    "    grad = np.zeros(theta.shape)\n",
+    "   \n",
+    "\n",
+    "    # ===================== YOUR CODE HERE ======================\n",
+    "    m, n = X.shape\n",
+    "    z = X.dot(theta)\n",
+    "    i = np.eye(len(theta))\n",
+    "    # Skip the theta[0, 0] parameter when performing regularization\n",
+    "    i[0,0] = 0\n",
+    "    \n",
+    "    J = 1.0 / m * (np.dot(-y.T, np.log(sigmoid(z))) - np.dot((1 - y).T, np.log(1 - sigmoid(z)))) \n",
+    "    J += 1.0 * (lambda_) / (2 * m) * np.sum(np.power((i.dot(theta)), 2))\n",
+    "\n",
+    "    grad = 1.0 / m * np.dot((sigmoid(z) - y).T, X).T + 1.0 * (lambda_) / m * (i.dot(theta))\n",
+    "\n",
+    "   \n",
+    "    # =============================================================\n",
+    "    return J, grad"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cost at initial theta (zeros): 0.693\n",
+      "Expected cost (approx)       : 0.693\n",
+      "\n",
+      "Gradient at initial theta (zeros) - first five values only:\n",
+      "\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\n",
+      "Expected gradients (approx) - first five values only:\n",
+      "\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\n",
+      "\n",
+      "------------------------------\n",
+      "\n",
+      "Cost at test theta    : 3.16\n",
+      "Expected cost (approx): 3.16\n",
+      "\n",
+      "Gradient at initial theta (zeros) - first five values only:\n",
+      "\t[0.3460, 0.1614, 0.1948, 0.2269, 0.0922]\n",
+      "Expected gradients (approx) - first five values only:\n",
+      "\t[0.3460, 0.1614, 0.1948, 0.2269, 0.0922]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Initialize fitting parameters\n",
+    "initial_theta = np.zeros(X.shape[1])\n",
+    "\n",
+    "# Set regularization parameter lambda to 1\n",
+    "# DO NOT use `lambda` as a variable name in python\n",
+    "# because it is a python keyword\n",
+    "lambda_ = 1\n",
+    "\n",
+    "# Compute and display initial cost and gradient for regularized logistic\n",
+    "# regression\n",
+    "cost, grad = costFunctionReg(initial_theta, X, y, lambda_)\n",
+    "\n",
+    "print('Cost at initial theta (zeros): {:.3f}'.format(cost))\n",
+    "print('Expected cost (approx)       : 0.693\\n')\n",
+    "\n",
+    "print('Gradient at initial theta (zeros) - first five values only:')\n",
+    "print('\\t[{:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f}]'.format(*grad[:5]))\n",
+    "print('Expected gradients (approx) - first five values only:')\n",
+    "print('\\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\\n')\n",
+    "\n",
+    "\n",
+    "# Compute and display cost and gradient\n",
+    "# with all-ones theta and lambda = 10\n",
+    "test_theta = np.ones(X.shape[1])\n",
+    "cost, grad = costFunctionReg(test_theta, X, y, 10)\n",
+    "\n",
+    "print('------------------------------\\n')\n",
+    "print('Cost at test theta    : {:.2f}'.format(cost))\n",
+    "print('Expected cost (approx): 3.16\\n')\n",
+    "\n",
+    "print('Gradient at initial theta (zeros) - first five values only:')\n",
+    "print('\\t[{:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f}]'.format(*grad[:5]))\n",
+    "print('Expected gradients (approx) - first five values only:')\n",
+    "print('\\t[0.3460, 0.1614, 0.1948, 0.2269, 0.0922]')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train Accuracy: 83.1 %\n",
+      "Expected accuracy (with lambda = 1): 83.1 % (approx)\n",
+      "\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"
+    }
+   ],
+   "source": [
+    "# Initialize fitting parameters\n",
+    "initial_theta = np.zeros(X.shape[1])\n",
+    "\n",
+    "# Set regularization parameter lambda to 1 (you should vary this)\n",
+    "lambda_ = 1\n",
+    "\n",
+    "# set options for optimize.minimize\n",
+    "options= {'maxiter': 100}\n",
+    "\n",
+    "res = optimize.minimize(costFunctionReg,\n",
+    "                        initial_theta,\n",
+    "                        (X, y, lambda_),\n",
+    "                        jac=True,\n",
+    "                        method='TNC',\n",
+    "                        options=options)\n",
+    "\n",
+    "# the fun property of OptimizeResult object returns\n",
+    "# the value of costFunction at optimized theta\n",
+    "cost = res.fun\n",
+    "\n",
+    "# the optimized theta is in the x property of the result\n",
+    "theta = res.x\n",
+    "\n",
+    "plotDecisionBoundary(plotData, theta, X, y)\n",
+    "pyplot.xlabel('Microchip Test 1')\n",
+    "pyplot.ylabel('Microchip Test 2')\n",
+    "pyplot.legend(['y = 1', 'y = 0'])\n",
+    "pyplot.grid(False)\n",
+    "pyplot.title('lambda = %0.2f' % lambda_)\n",
+    "\n",
+    "# Compute accuracy on our training set\n",
+    "p = predict(theta, X)\n",
+    "\n",
+    "print('Train Accuracy: %.1f %%' % (np.mean(p == y) * 100))\n",
+    "print('Expected accuracy (with lambda = 1): 83.1 % (approx)\\n')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

From 89098d62ca7f41268eef043d40fbc29c2192eb63 Mon Sep 17 00:00:00 2001
From: redox2024 <58564953+redox2024@users.noreply.github.com>
Date: Sat, 18 Apr 2020 22:18:29 +0530
Subject: [PATCH 6/7] Priyansh Mali 190107052 week 3 solutions


From 3ce09e3bfaadc971f3adae91b31ff2b11e61f859 Mon Sep 17 00:00:00 2001
From: redox2024 <58564953+redox2024@users.noreply.github.com>
Date: Sat, 9 May 2020 18:44:04 +0530
Subject: [PATCH 7/7] Week 5 solutions Priyansh Mali 190107052

---
 Phase 3 - 2020 (Summer)/Exercise_4.ipynb | 788 +++++++++++++++++++++
 Phase 3 - 2020 (Summer)/Exercise_5.ipynb | 847 +++++++++++++++++++++++
 2 files changed, 1635 insertions(+)
 create mode 100644 Phase 3 - 2020 (Summer)/Exercise_4.ipynb
 create mode 100644 Phase 3 - 2020 (Summer)/Exercise_5.ipynb

diff --git a/Phase 3 - 2020 (Summer)/Exercise_4.ipynb b/Phase 3 - 2020 (Summer)/Exercise_4.ipynb
new file mode 100644
index 000000000..3fdc179db
--- /dev/null
+++ b/Phase 3 - 2020 (Summer)/Exercise_4.ipynb	
@@ -0,0 +1,788 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "import numpy as np\n",
+    "from matplotlib import pyplot\n",
+    "\n",
+    "sys.path.append('..')\n",
+    "# from submission import SubmissionBase\n",
+    "\n",
+    "\n",
+    "def displayData(X, example_width=None, figsize=(10, 10)):\n",
+    "    \"\"\"\n",
+    "    Displays 2D data stored in X in a nice grid.\n",
+    "    \"\"\"\n",
+    "    # Compute rows, cols\n",
+    "    if X.ndim == 2:\n",
+    "        m, n = X.shape\n",
+    "    elif X.ndim == 1:\n",
+    "        n = X.size\n",
+    "        m = 1\n",
+    "        X = X[None]  # Promote to a 2 dimensional array\n",
+    "    else:\n",
+    "        raise IndexError('Input X should be 1 or 2 dimensional.')\n",
+    "\n",
+    "    example_width = example_width or int(np.round(np.sqrt(n)))\n",
+    "    example_height = n / example_width\n",
+    "\n",
+    "    # Compute number of items to display\n",
+    "    display_rows = int(np.floor(np.sqrt(m)))\n",
+    "    display_cols = int(np.ceil(m / display_rows))\n",
+    "\n",
+    "    fig, ax_array = pyplot.subplots(display_rows, display_cols, figsize=figsize)\n",
+    "    fig.subplots_adjust(wspace=0.025, hspace=0.025)\n",
+    "\n",
+    "    ax_array = [ax_array] if m == 1 else ax_array.ravel()\n",
+    "\n",
+    "    for i, ax in enumerate(ax_array):\n",
+    "        # Display Image\n",
+    "        h = ax.imshow(X[i].reshape(example_width, example_width, order='F'),\n",
+    "                      cmap='Greys', extent=[0, 1, 0, 1])\n",
+    "        ax.axis('off')\n",
+    "\n",
+    "\n",
+    "def predict(Theta1, Theta2, X):\n",
+    "    \"\"\"\n",
+    "    Predict the label of an input given a trained neural network\n",
+    "    Outputs the predicted label of X given the trained weights of a neural\n",
+    "    network(Theta1, Theta2)\n",
+    "    \"\"\"\n",
+    "    # Useful values\n",
+    "    m = X.shape[0]\n",
+    "    num_labels = Theta2.shape[0]\n",
+    "\n",
+    "    # You need to return the following variables correctly\n",
+    "    p = np.zeros(m)\n",
+    "    h1 = sigmoid(np.dot(np.concatenate([np.ones((m, 1)), X], axis=1), Theta1.T))\n",
+    "    h2 = sigmoid(np.dot(np.concatenate([np.ones((m, 1)), h1], axis=1), Theta2.T))\n",
+    "    p = np.argmax(h2, axis=1)\n",
+    "    return p\n",
+    "\n",
+    "\n",
+    "def debugInitializeWeights(fan_out, fan_in):\n",
+    "    \"\"\"\n",
+    "    Initialize the weights of a layer with fan_in incoming connections and fan_out outgoings\n",
+    "    connections using a fixed strategy. This will help you later in debugging.\n",
+    "    Note that W should be set a matrix of size (1+fan_in, fan_out) as the first row of W handles\n",
+    "    the \"bias\" terms.\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    fan_out : int\n",
+    "        The number of outgoing connections.\n",
+    "    fan_in : int\n",
+    "        The number of incoming connections.\n",
+    "    Returns\n",
+    "    -------\n",
+    "    W : array_like (1+fan_in, fan_out)\n",
+    "        The initialized weights array given the dimensions.\n",
+    "    \"\"\"\n",
+    "    # Initialize W using \"sin\". This ensures that W is always of the same values and will be\n",
+    "    # useful for debugging\n",
+    "    W = np.sin(np.arange(1, 1 + (1+fan_in)*fan_out))/10.0\n",
+    "    W = W.reshape(fan_out, 1+fan_in, order='F')\n",
+    "    return W\n",
+    "\n",
+    "\n",
+    "def computeNumericalGradient(J, theta, e=1e-4):\n",
+    "    \"\"\"\n",
+    "    Computes the gradient using \"finite differences\" and gives us a numerical estimate of the\n",
+    "    gradient.\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    J : func\n",
+    "        The cost function which will be used to estimate its numerical gradient.\n",
+    "    theta : array_like\n",
+    "        The one dimensional unrolled network parameters. The numerical gradient is computed at\n",
+    "         those given parameters.\n",
+    "    e : float (optional)\n",
+    "        The value to use for epsilon for computing the finite difference.\n",
+    "    Notes\n",
+    "    -----\n",
+    "    The following code implements numerical gradient checking, and\n",
+    "    returns the numerical gradient. It sets `numgrad[i]` to (a numerical\n",
+    "    approximation of) the partial derivative of J with respect to the\n",
+    "    i-th input argument, evaluated at theta. (i.e., `numgrad[i]` should\n",
+    "    be the (approximately) the partial derivative of J with respect\n",
+    "    to theta[i].)\n",
+    "    \"\"\"\n",
+    "    numgrad = np.zeros(theta.shape)\n",
+    "    perturb = np.diag(e * np.ones(theta.shape))\n",
+    "    for i in range(theta.size):\n",
+    "        loss1, _ = J(theta - perturb[:, i])\n",
+    "        loss2, _ = J(theta + perturb[:, i])\n",
+    "        numgrad[i] = (loss2 - loss1)/(2*e)\n",
+    "    return numgrad\n",
+    "\n",
+    "\n",
+    "def checkNNGradients(nnCostFunction, lambda_=0):\n",
+    "    \"\"\"\n",
+    "    Creates a small neural network to check the backpropagation gradients. It will output the\n",
+    "    analytical gradients produced by your backprop code and the numerical gradients\n",
+    "    (computed using computeNumericalGradient). These two gradient computations should result in\n",
+    "    very similar values.\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    nnCostFunction : func\n",
+    "        A reference to the cost function implemented by the student.\n",
+    "    lambda_ : float (optional)\n",
+    "        The regularization parameter value.\n",
+    "    \"\"\"\n",
+    "    input_layer_size = 3\n",
+    "    hidden_layer_size = 5\n",
+    "    num_labels = 3\n",
+    "    m = 5\n",
+    "\n",
+    "    # We generate some 'random' test data\n",
+    "    Theta1 = debugInitializeWeights(hidden_layer_size, input_layer_size)\n",
+    "    Theta2 = debugInitializeWeights(num_labels, hidden_layer_size)\n",
+    "\n",
+    "    # Reusing debugInitializeWeights to generate X\n",
+    "    X = debugInitializeWeights(m, input_layer_size - 1)\n",
+    "    y = np.arange(1, 1+m) % num_labels\n",
+    "    # print(y)\n",
+    "    # Unroll parameters\n",
+    "    nn_params = np.concatenate([Theta1.ravel(), Theta2.ravel()])\n",
+    "\n",
+    "    # short hand for cost function\n",
+    "    costFunc = lambda p: nnCostFunction(p, input_layer_size, hidden_layer_size,\n",
+    "                                        num_labels, X, y, lambda_)\n",
+    "    cost, grad = costFunc(nn_params)\n",
+    "    numgrad = computeNumericalGradient(costFunc, nn_params)\n",
+    "\n",
+    "    # Visually examine the two gradient computations.The two columns you get should be very similar.\n",
+    "    print(np.stack([numgrad, grad], axis=1))\n",
+    "    print('The above two columns you get should be very similar.')\n",
+    "    print('(Left-Your Numerical Gradient, Right-Analytical Gradient)\\n')\n",
+    "\n",
+    "    # Evaluate the norm of the difference between two the solutions. If you have a correct\n",
+    "    # implementation, and assuming you used e = 0.0001 in computeNumericalGradient, then diff\n",
+    "    # should be less than 1e-9.\n",
+    "    diff = np.linalg.norm(numgrad - grad)/np.linalg.norm(numgrad + grad)\n",
+    "\n",
+    "    print('If your backpropagation implementation is correct, then \\n'\n",
+    "          'the relative difference will be small (less than 1e-9). \\n'\n",
+    "          'Relative Difference: %g' % diff)\n",
+    "\n",
+    "\n",
+    "def sigmoid(z):\n",
+    "    \"\"\"\n",
+    "    Computes the sigmoid of z.\n",
+    "    \"\"\"\n",
+    "    return 1.0 / (1.0 + np.exp(-z))\n",
+    "def sigmoid_gradient(z):\n",
+    "    \"\"\"\n",
+    "    Computes the gradient of the sigmoid function evaluated at z\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    z : array_like\n",
+    "        Variable for sigmoid function.\n",
+    "    Returns\n",
+    "    -------\n",
+    "    ndarray\n",
+    "        The gradient of the sigmoid of each value of z.\n",
+    "    \"\"\"\n",
+    "    g = sigmoid(z) * (1 - sigmoid(z))\n",
+    "    return g\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# used for manipulating directory paths\n",
+    "import os\n",
+    "\n",
+    "# Scientific and vector computation for python\n",
+    "import numpy as np\n",
+    "\n",
+    "# Plotting library\n",
+    "from matplotlib import pyplot\n",
+    "\n",
+    "# Optimization module in scipy\n",
+    "from scipy import optimize\n",
+    "\n",
+    "# will be used to load MATLAB mat datafile format\n",
+    "from scipy.io import loadmat\n",
+    "\n",
+    "# library written for this exercise providing additional functions for assignment submission, and others\n",
+    "import utils\n",
+    "\n",
+    "# # define the submission/grader object for this exercise\n",
+    "# grader = utils.Grader()\n",
+    "\n",
+    "# tells matplotlib to embed plots within the notebook\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#  training data stored in arrays X, y\n",
+    "data = loadmat(os.path.join('Data', 'ex4data1.mat'))\n",
+    "X, y = data['X'], data['y'].ravel()\n",
+    "\n",
+    "# set the zero digit to 0, rather than its mapped 10 in this dataset\n",
+    "# This is an artifact due to the fact that this dataset was used in \n",
+    "# MATLAB where there is no index 0\n",
+    "y[y == 10] = 0\n",
+    "\n",
+    "# Number of training examples\n",
+    "m = y.size"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 100 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Randomly select 100 data points to display\n",
+    "rand_indices = np.random.choice(m, 100, replace=False)\n",
+    "sel = X[rand_indices, :]\n",
+    "\n",
+    "displayData(sel)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Setup the parameters you will use for this exercise\n",
+    "input_layer_size  = 400  # 20x20 Input Images of Digits\n",
+    "hidden_layer_size = 25   # 25 hidden units\n",
+    "num_labels = 10          # 10 labels, from 0 to 9\n",
+    "\n",
+    "# Load the weights into variables Theta1 and Theta2\n",
+    "weights = loadmat(os.path.join('Data', 'ex4weights.mat'))\n",
+    "\n",
+    "# Theta1 has size 25 x 401\n",
+    "# Theta2 has size 10 x 26\n",
+    "Theta1, Theta2 = weights['Theta1'], weights['Theta2']\n",
+    "\n",
+    "# swap first and last columns of Theta2, due to legacy from MATLAB indexing, \n",
+    "# since the weight file ex3weights.mat was saved based on MATLAB indexing\n",
+    "Theta2 = np.roll(Theta2, 1, axis=0)\n",
+    "\n",
+    "# Unroll parameters \n",
+    "nn_params = np.concatenate([Theta1.ravel(), Theta2.ravel()])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def nnCostFunction(nn_params, input_layer_size, hidden_layer_size, num_labels, X, y, l):\n",
+    "    \"\"\"\n",
+    "    Implements the neural network cost function for a two layer neural network which performs classification.\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    nn_params : ndarray, shape (n_params,)\n",
+    "        Parameters for the neural network, \"unrolled\" into a vector.\n",
+    "    input_layer_size : int\n",
+    "        The size of the input layer.\n",
+    "    hidden_layer_size : int\n",
+    "        The size of the hidden layer.\n",
+    "    num_labels : int\n",
+    "        The number of labels.\n",
+    "    X : ndarray, shape (n_samples, n_features)\n",
+    "        Samples, where n_samples is the number of samples and n_features is the number of features.\n",
+    "    y : ndarray, shape (n_samples,)\n",
+    "        Labels.\n",
+    "    l : float\n",
+    "        Regularization parameter.\n",
+    "\n",
+    "    Returns\n",
+    "    -------\n",
+    "    j : numpy.float64\n",
+    "        The cost of the neural network w.r.t. the parameters.\n",
+    "    grad: ndarray, shape (n_params,)\n",
+    "        The gradient of the neural network w.r.t. the parameters.\n",
+    "    \"\"\"\n",
+    "    Theta1 = np.reshape(nn_params[0:(hidden_layer_size * (input_layer_size + 1)), ],\n",
+    "                         (hidden_layer_size, input_layer_size + 1))\n",
+    "    Theta2 = np.reshape(nn_params[(hidden_layer_size * (input_layer_size + 1)):, ],\n",
+    "                         (num_labels, hidden_layer_size + 1))\n",
+    "    m,n = X.shape\n",
+    "    \n",
+    "    X = np.concatenate( ( np.ones((m,1)), X), axis=1)\n",
+    "    Theta1_T = np.transpose(Theta1)\n",
+    "    Theta2_T = np.transpose(Theta2)\n",
+    "    Z_2 = X.dot(Theta1.T)\n",
+    "    A_2 = sigmoid(Z_2)\n",
+    "    A_2 = np.hstack((np.ones((m, 1)), A_2))\n",
+    "\n",
+    "    Z_3 = A_2.dot(Theta2.T)\n",
+    "    A_3 = sigmoid(Z_3)\n",
+    "\n",
+    "    Y = np.zeros((num_labels,m))\n",
+    "    \n",
+    "    Y_T = np.transpose(Y)\n",
+    "    for j in range(m):\n",
+    "        t=y[j]\n",
+    "        Y[t,j] = 1\n",
+    "    J= (np.trace(- np.dot( np.log(A_3),Y ) - np.dot( np.log(1-A_3),(1-Y))) +lambda_*(np.sum(Theta1**2) + np.sum(Theta2**2)-np.sum(Theta1_T[0]**2) -np.sum(Theta2_T[0]**2))/2)/m      \n",
+    "    \n",
+    "    \n",
+    "    d_3 = A_3 - Y_T\n",
+    "    D_2 = d_3.T.dot(A_2)\n",
+    "\n",
+    "    Z_2 = np.hstack((np.ones((m, 1)), Z_2))\n",
+    "    d_2 = d_3.dot(Theta2) * sigmoid_gradient(Z_2)\n",
+    "    d_2 = d_2[:, 1:]\n",
+    "    D_1 = d_2.T.dot(X)\n",
+    "\n",
+    "    Theta_1_grad = 1.0 * D_1 / m\n",
+    "    Theta_1_grad[:, 1:] = Theta_1_grad[:, 1:] + 1.0 * l / m * Theta1[:, 1:]\n",
+    "\n",
+    "    Theta_2_grad = 1.0 * D_2 / m\n",
+    "    Theta_2_grad[:, 1:] = Theta_2_grad[:, 1:] + 1.0 * l / m * Theta2[:, 1:]\n",
+    "\n",
+    "    grad = np.hstack((Theta_1_grad.ravel(), Theta_2_grad.ravel()))\n",
+    "\n",
+    "    return J, grad"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cost at parameters (loaded from ex4weights): 0.287629 \n",
+      "The cost should be about                   : 0.287629.\n"
+     ]
+    }
+   ],
+   "source": [
+    "lambda_ = 0\n",
+    "J, _ = nnCostFunction(nn_params, input_layer_size, hidden_layer_size,\n",
+    "                   num_labels, X, y, lambda_)\n",
+    "\n",
+    "print('Cost at parameters (loaded from ex4weights): %.6f ' % J)\n",
+    "print('The cost should be about                   : 0.287629.')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cost at parameters (loaded from ex4weights): 0.383770\n",
+      "This value should be about                 : 0.383770.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Weight regularization parameter (we set this to 1 here).\n",
+    "lambda_ = 1\n",
+    "J, _ = nnCostFunction(nn_params, input_layer_size, hidden_layer_size,\n",
+    "                      num_labels, X, y, lambda_)\n",
+    "\n",
+    "print('Cost at parameters (loaded from ex4weights): %.6f' % J)\n",
+    "print('This value should be about                 : 0.383770.')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sigmoidGradient(z):\n",
+    "    \"\"\"\n",
+    "    Computes the gradient of the sigmoid function evaluated at z. \n",
+    "    This should work regardless if z is a matrix or a vector. \n",
+    "    In particular, if z is a vector or matrix, you should return\n",
+    "    the gradient for each element.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    z : array_like\n",
+    "        A vector or matrix as input to the sigmoid function. \n",
+    "    \n",
+    "    Returns\n",
+    "    --------\n",
+    "    g : array_like\n",
+    "        Gradient of the sigmoid function. Has the same shape as z. \n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the gradient of the sigmoid function evaluated at\n",
+    "    each value of z (z can be a matrix, vector or scalar).\n",
+    "    \n",
+    "    Note\n",
+    "    ----\n",
+    "    We have provided an implementation of the sigmoid function \n",
+    "    in `utils.py` file accompanying this assignment.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    g = np.zeros(z.shape)\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    g = sigmoid(z) * (1 - sigmoid(z))\n",
+    "\n",
+    "\n",
+    "    # =============================================================\n",
+    "    return g"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Sigmoid gradient evaluated at [-1 -0.5 0 0.5 1]:\n",
+      "  \n",
+      "[0.19661193 0.23500371 0.25       0.23500371 0.19661193]\n"
+     ]
+    }
+   ],
+   "source": [
+    "z = np.array([-1, -0.5, 0, 0.5, 1])\n",
+    "g = sigmoidGradient(z)\n",
+    "print('Sigmoid gradient evaluated at [-1 -0.5 0 0.5 1]:\\n  ')\n",
+    "print(g)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def randInitializeWeights(L_in, L_out, epsilon_init=0.12):\n",
+    "    \"\"\"\n",
+    "    Randomly initialize the weights of a layer in a neural network.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    L_in : int\n",
+    "        Number of incomming connections.\n",
+    "    \n",
+    "    L_out : int\n",
+    "        Number of outgoing connections. \n",
+    "    \n",
+    "    epsilon_init : float, optional\n",
+    "        Range of values which the weight can take from a uniform \n",
+    "        distribution.\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    W : array_like\n",
+    "        The weight initialiatized to random values.  Note that W should\n",
+    "        be set to a matrix of size(L_out, 1 + L_in) as\n",
+    "        the first column of W handles the \"bias\" terms.\n",
+    "        \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Initialize W randomly so that we break the symmetry while training\n",
+    "    the neural network. Note that the first column of W corresponds \n",
+    "    to the parameters for the bias unit.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # You need to return the following variables correctly \n",
+    "    W = np.zeros((L_out, 1 + L_in))\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    epsilon_init = 0.12\n",
+    "\n",
+    "    # Note that w should be set to a matrix of size(l_out, 1 + l_in) as the first column of W handles the \"bias\" terms\n",
+    "    W = np.random.rand(L_out, 1 + L_in) * 2 * epsilon_init - epsilon_init\n",
+    "\n",
+    "\n",
+    "    # ============================================================\n",
+    "    return W"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "initial_theta_1 = randInitializeWeights(input_layer_size, hidden_layer_size)\n",
+    "initial_theta_2 = randInitializeWeights(hidden_layer_size, num_labels)\n",
+    "initial_nn_params = np.hstack((initial_theta_1.ravel(), initial_theta_2.ravel()))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Initializing Neural Network Parameters ...\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('Initializing Neural Network Parameters ...')\n",
+    "\n",
+    "initial_Theta1 = randInitializeWeights(input_layer_size, hidden_layer_size)\n",
+    "initial_Theta2 = randInitializeWeights(hidden_layer_size, num_labels)\n",
+    "\n",
+    "# Unroll parameters\n",
+    "initial_nn_params = np.concatenate([initial_Theta1.ravel(), initial_Theta2.ravel()], axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[-9.27825235e-03 -9.27825236e-03]\n",
+      " [-5.59135975e-03 -3.04978914e-06]\n",
+      " [-2.01748642e-02 -1.75060082e-04]\n",
+      " [-5.85433239e-03 -9.62660620e-05]\n",
+      " [ 8.89911959e-03  8.89911960e-03]\n",
+      " [ 1.31540189e-02  1.42869443e-05]\n",
+      " [-1.04983120e-02  2.33146357e-04]\n",
+      " [-1.91099672e-02  1.17982666e-04]\n",
+      " [-8.36010761e-03 -8.36010762e-03]\n",
+      " [ 1.97612266e-02 -2.59383100e-05]\n",
+      " [ 8.11587201e-03 -2.87468729e-04]\n",
+      " [-1.51568946e-02 -1.37149706e-04]\n",
+      " [ 7.62813551e-03  7.62813551e-03]\n",
+      " [ 8.27935803e-03  3.69883234e-05]\n",
+      " [ 2.01474675e-02  3.35320347e-04]\n",
+      " [ 3.15079127e-03  1.53247082e-04]\n",
+      " [-6.74798370e-03 -6.74798370e-03]\n",
+      " [-1.09272982e-02 -4.68759769e-05]\n",
+      " [ 1.26295412e-02 -3.76215587e-04]\n",
+      " [ 1.80923447e-02 -1.66560294e-04]\n",
+      " [ 3.14544970e-01  3.14544970e-01]\n",
+      " [ 1.48954769e-01  1.64090819e-01]\n",
+      " [ 1.77707664e-01  1.64567932e-01]\n",
+      " [ 1.47458912e-01  1.58339334e-01]\n",
+      " [ 1.59530868e-01  1.51127527e-01]\n",
+      " [ 1.43810268e-01  1.49568335e-01]\n",
+      " [ 1.11056588e-01  1.11056588e-01]\n",
+      " [ 3.83951639e-02  5.75736493e-02]\n",
+      " [ 7.75739028e-02  5.77867378e-02]\n",
+      " [ 3.59237255e-02  5.59235296e-02]\n",
+      " [ 7.35088480e-02  5.36967009e-02]\n",
+      " [ 3.39262554e-02  5.31542052e-02]\n",
+      " [ 9.74006970e-02  9.74006970e-02]\n",
+      " [ 4.48692755e-02  5.04575855e-02]\n",
+      " [ 5.89953870e-02  5.07530173e-02]\n",
+      " [ 3.84306258e-02  4.91620841e-02]\n",
+      " [ 6.01513817e-02  4.71456249e-02]\n",
+      " [ 3.15399737e-02  4.65597186e-02]]\n",
+      "The above two columns you get should be very similar.\n",
+      "(Left-Your Numerical Gradient, Right-Analytical Gradient)\n",
+      "\n",
+      "If your backpropagation implementation is correct, then \n",
+      "the relative difference will be small (less than 1e-9). \n",
+      "Relative Difference: 0.0747121\n"
+     ]
+    }
+   ],
+   "source": [
+    "checkNNGradients(nnCostFunction)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[-9.27825235e-03 -9.27825236e-03]\n",
+      " [-1.67679797e-02 -1.67679797e-02]\n",
+      " [-6.01744725e-02 -6.01744725e-02]\n",
+      " [-1.73704651e-02 -1.73704651e-02]\n",
+      " [ 8.89911959e-03  8.89911960e-03]\n",
+      " [ 3.94334829e-02  3.94334829e-02]\n",
+      " [-3.19612287e-02 -3.19612287e-02]\n",
+      " [-5.75658668e-02 -5.75658668e-02]\n",
+      " [-8.36010761e-03 -8.36010762e-03]\n",
+      " [ 5.93355565e-02  5.93355565e-02]\n",
+      " [ 2.49225535e-02  2.49225535e-02]\n",
+      " [-4.51963845e-02 -4.51963845e-02]\n",
+      " [ 7.62813551e-03  7.62813551e-03]\n",
+      " [ 2.47640974e-02  2.47640974e-02]\n",
+      " [ 5.97717617e-02  5.97717617e-02]\n",
+      " [ 9.14587966e-03  9.14587966e-03]\n",
+      " [-6.74798369e-03 -6.74798370e-03]\n",
+      " [-3.26881426e-02 -3.26881426e-02]\n",
+      " [ 3.86410548e-02  3.86410548e-02]\n",
+      " [ 5.46101547e-02  5.46101547e-02]\n",
+      " [ 3.14544970e-01  3.14544970e-01]\n",
+      " [ 1.18682669e-01  1.18682669e-01]\n",
+      " [ 2.03987128e-01  2.03987128e-01]\n",
+      " [ 1.25698067e-01  1.25698067e-01]\n",
+      " [ 1.76337550e-01  1.76337550e-01]\n",
+      " [ 1.32294136e-01  1.32294136e-01]\n",
+      " [ 1.11056588e-01  1.11056588e-01]\n",
+      " [ 3.81928666e-05  3.81928696e-05]\n",
+      " [ 1.17148233e-01  1.17148233e-01]\n",
+      " [-4.07588279e-03 -4.07588279e-03]\n",
+      " [ 1.13133142e-01  1.13133142e-01]\n",
+      " [-4.52964427e-03 -4.52964427e-03]\n",
+      " [ 9.74006970e-02  9.74006970e-02]\n",
+      " [ 3.36926556e-02  3.36926556e-02]\n",
+      " [ 7.54801264e-02  7.54801264e-02]\n",
+      " [ 1.69677090e-02  1.69677090e-02]\n",
+      " [ 8.61628953e-02  8.61628953e-02]\n",
+      " [ 1.50048382e-03  1.50048382e-03]]\n",
+      "The above two columns you get should be very similar.\n",
+      "(Left-Your Numerical Gradient, Right-Analytical Gradient)\n",
+      "\n",
+      "If your backpropagation implementation is correct, then \n",
+      "the relative difference will be small (less than 1e-9). \n",
+      "Relative Difference: 2.15393e-11\n",
+      "\n",
+      "\n",
+      "Cost at (fixed) debugging parameters (w/ lambda = 3.000000): 0.576051 \n",
+      "(for lambda = 3, this value should be about 0.576051)\n"
+     ]
+    }
+   ],
+   "source": [
+    "#  Check gradients by running checkNNGradients\n",
+    "lambda_ = 3\n",
+    "checkNNGradients(nnCostFunction, lambda_)\n",
+    "\n",
+    "# Also output the costFunction debugging values\n",
+    "debug_J, _  = nnCostFunction(nn_params, input_layer_size,\n",
+    "                          hidden_layer_size, num_labels, X, y, lambda_)\n",
+    "\n",
+    "print('\\n\\nCost at (fixed) debugging parameters (w/ lambda = %f): %f ' % (lambda_, debug_J))\n",
+    "print('(for lambda = 3, this value should be about 0.576051)')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#  After you have completed the assignment, change the maxiter to a larger\n",
+    "#  value to see how more training helps.\n",
+    "options= {'maxiter': 100}\n",
+    "\n",
+    "#  You should also try different values of lambda\n",
+    "lambda_ = 1\n",
+    "\n",
+    "# Create \"short hand\" for the cost function to be minimized\n",
+    "costFunction = lambda p: nnCostFunction(p, input_layer_size,\n",
+    "                                        hidden_layer_size,\n",
+    "                                        num_labels, X, y, lambda_)\n",
+    "\n",
+    "# Now, costFunction is a function that takes in only one argument\n",
+    "# (the neural network parameters)\n",
+    "res = optimize.minimize(costFunction,\n",
+    "                        initial_nn_params,\n",
+    "                        jac=True,\n",
+    "                        method='TNC',\n",
+    "                        options=options)\n",
+    "\n",
+    "# get the solution of the optimization\n",
+    "nn_params = res.x\n",
+    "        \n",
+    "# Obtain Theta1 and Theta2 back from nn_params\n",
+    "Theta1 = np.reshape(nn_params[:hidden_layer_size * (input_layer_size + 1)],\n",
+    "                    (hidden_layer_size, (input_layer_size + 1)))\n",
+    "\n",
+    "Theta2 = np.reshape(nn_params[(hidden_layer_size * (input_layer_size + 1)):],\n",
+    "                    (num_labels, (hidden_layer_size + 1)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training Set Accuracy: 95.500000\n"
+     ]
+    }
+   ],
+   "source": [
+    "pred = predict(Theta1, Theta2, X)\n",
+    "print('Training Set Accuracy: %f' % (np.mean(pred == y) * 100))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Phase 3 - 2020 (Summer)/Exercise_5.ipynb b/Phase 3 - 2020 (Summer)/Exercise_5.ipynb
new file mode 100644
index 000000000..e32fcf31f
--- /dev/null
+++ b/Phase 3 - 2020 (Summer)/Exercise_5.ipynb	
@@ -0,0 +1,847 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 88,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "import numpy as np\n",
+    "from scipy import optimize\n",
+    "from matplotlib import pyplot\n",
+    "\n",
+    "sys.path.append('..')\n",
+    "# from submission import SubmissionBase\n",
+    "\n",
+    "\n",
+    "def trainLinearReg(linearRegCostFunction, X, y, lambda_=0.0, maxiter=200):\n",
+    "    \"\"\"\n",
+    "    Trains linear regression using scipy's optimize.minimize.\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The dataset with shape (m x n+1). The bias term is assumed to be concatenated.\n",
+    "    y : array_like\n",
+    "        Function values at each datapoint. A vector of shape (m,).\n",
+    "    lambda_ : float, optional\n",
+    "        The regularization parameter.\n",
+    "    maxiter : int, optional\n",
+    "        Maximum number of iteration for the optimization algorithm.\n",
+    "    Returns\n",
+    "    -------\n",
+    "    theta : array_like\n",
+    "        The parameters for linear regression. This is a vector of shape (n+1,).\n",
+    "    \"\"\"\n",
+    "    # Initialize Theta\n",
+    "    initial_theta = np.zeros(X.shape[1])\n",
+    "\n",
+    "    # Create \"short hand\" for the cost function to be minimized\n",
+    "    costFunction = lambda t: linearRegCostFunction(X, y, t, lambda_)\n",
+    "\n",
+    "    # Now, costFunction is a function that takes in only one argument\n",
+    "    options = {'maxiter': maxiter}\n",
+    "\n",
+    "    # Minimize using scipy\n",
+    "    res = optimize.minimize(costFunction, initial_theta, jac=True, method='TNC', options=options)\n",
+    "    return res.x\n",
+    "\n",
+    "\n",
+    "def featureNormalize(X):\n",
+    "    \"\"\"\n",
+    "    Normalizes the features in X returns a normalized version of X where the mean value of each\n",
+    "    feature is 0 and the standard deviation is 1. This is often a good preprocessing step to do when\n",
+    "    working with learning algorithms.\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        An dataset which is a (m x n) matrix, where m is the number of examples,\n",
+    "        and n is the number of dimensions for each example.\n",
+    "    Returns\n",
+    "    -------\n",
+    "    X_norm : array_like\n",
+    "        The normalized input dataset.\n",
+    "    mu : array_like\n",
+    "        A vector of size n corresponding to the mean for each dimension across all examples.\n",
+    "    sigma : array_like\n",
+    "        A vector of size n corresponding to the standard deviations for each dimension across\n",
+    "        all examples.\n",
+    "    \"\"\"\n",
+    "    mu = np.mean(X, axis=0)\n",
+    "    X_norm = X - mu\n",
+    "\n",
+    "    sigma = np.std(X_norm, axis=0, ddof=1)\n",
+    "    X_norm /= sigma\n",
+    "    return X_norm, mu, sigma\n",
+    "\n",
+    "\n",
+    "def plotFit(polyFeatures, min_x, max_x, mu, sigma, theta, p):\n",
+    "    \"\"\"\n",
+    "    Plots a learned polynomial regression fit over an existing figure.\n",
+    "    Also works with linear regression.\n",
+    "    Plots the learned polynomial fit with power p and feature normalization (mu, sigma).\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    polyFeatures : func\n",
+    "        A function which generators polynomial features from a single feature.\n",
+    "    min_x : float\n",
+    "        The minimum value for the feature.\n",
+    "    max_x : float\n",
+    "        The maximum value for the feature.\n",
+    "    mu : float\n",
+    "        The mean feature value over the training dataset.\n",
+    "    sigma : float\n",
+    "        The feature standard deviation of the training dataset.\n",
+    "    theta : array_like\n",
+    "        The parameters for the trained polynomial linear regression.\n",
+    "    p : int\n",
+    "        The polynomial order.\n",
+    "    \"\"\"\n",
+    "    # We plot a range slightly bigger than the min and max values to get\n",
+    "    # an idea of how the fit will vary outside the range of the data points\n",
+    "    x = np.arange(min_x - 15, max_x + 25, 0.05).reshape(-1, 1)\n",
+    "\n",
+    "    # Map the X values\n",
+    "    X_poly = polyFeatures(x, p)\n",
+    "    X_poly -= mu\n",
+    "    X_poly /= sigma\n",
+    "\n",
+    "    # Add ones\n",
+    "    X_poly = np.concatenate([np.ones((x.shape[0], 1)), X_poly], axis=1)\n",
+    "\n",
+    "    # Plot\n",
+    "    pyplot.plot(x, np.dot(X_poly, theta), '--', lw=2)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 89,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# used for manipulating directory paths\n",
+    "import os\n",
+    "\n",
+    "# Scientific and vector computation for python\n",
+    "import numpy as np\n",
+    "\n",
+    "# Plotting library\n",
+    "from matplotlib import pyplot\n",
+    "\n",
+    "# Optimization module in scipy\n",
+    "from scipy import optimize\n",
+    "\n",
+    "# will be used to load MATLAB mat datafile format\n",
+    "from scipy.io import loadmat\n",
+    "\n",
+    "# library written for this exercise providing additional functions for assignment submission, and others\n",
+    "import utils\n",
+    "\n",
+    "# # define the submission/grader object for this exercise\n",
+    "# grader = utils5.Grader()\n",
+    "\n",
+    "# tells matplotlib to embed plots within the notebook\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 90,
+   "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"
+    }
+   ],
+   "source": [
+    "# Load from ex5data1.mat, where all variables will be store in a dictionary\n",
+    "data = loadmat(os.path.join('Data', 'ex5data1.mat'))\n",
+    "\n",
+    "# Extract train, test, validation data from dictionary\n",
+    "# and also convert y's form 2-D matrix (MATLAB format) to a numpy vector\n",
+    "X, y = data['X'], data['y'][:, 0]\n",
+    "Xtest, ytest = data['Xtest'], data['ytest'][:, 0]\n",
+    "Xval, yval = data['Xval'], data['yval'][:, 0]\n",
+    "\n",
+    "# m = Number of examples\n",
+    "m = y.size\n",
+    "\n",
+    "# Plot training data\n",
+    "pyplot.plot(X, y, 'ro', ms=10, mec='k', mew=1)\n",
+    "pyplot.xlabel('Change in water level (x)')\n",
+    "pyplot.ylabel('Water flowing out of the dam (y)');"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 91,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "def linearRegCostFunction(X, y, theta, lambda_=0.0):\n",
+    "    \"\"\"\n",
+    "    Compute cost and gradient for regularized linear regression \n",
+    "    with multiple variables. Computes the cost of using theta as\n",
+    "    the parameter for linear regression to fit the data points in X and y. \n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The dataset. Matrix with shape (m x n + 1) where m is the \n",
+    "        total number of examples, and n is the number of features \n",
+    "        before adding the bias term.\n",
+    "    \n",
+    "    y : array_like\n",
+    "        The functions values at each datapoint. A vector of\n",
+    "        shape (m, ).\n",
+    "    \n",
+    "    theta : array_like\n",
+    "        The parameters for linear regression. A vector of shape (n+1,).\n",
+    "    \n",
+    "    lambda_ : float, optional\n",
+    "        The regularization parameter.\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    J : float\n",
+    "        The computed cost function. \n",
+    "    \n",
+    "    grad : array_like\n",
+    "        The value of the cost function gradient w.r.t theta. \n",
+    "        A vector of shape (n+1, ).\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the cost and gradient of regularized linear regression for\n",
+    "    a particular choice of theta.\n",
+    "    You should set J to the cost and grad to the gradient.\n",
+    "    \"\"\"\n",
+    "    # Initialize some useful values\n",
+    "    m = y.size # number of training examples\n",
+    "    # You need to return the following variables correctly \n",
+    "    J = 0\n",
+    "    grad = np.zeros(theta.shape)\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "   \n",
+    "    J = 1.0 / (2 * m) * np.sum(np.square(X.dot(theta) - y)) + 1.0 * (lambda_) / (2 * m) * np.sum(np.square(theta[1:]))\n",
+    "\n",
+    "    mask = np.eye(len(theta))\n",
+    "    mask[0, 0] = 0\n",
+    "    grad = 1.0 / m * X.T.dot(X.dot(theta) - y) + 1.0 * (lambda_) / m * (mask.dot(theta))\n",
+    "\n",
+    "\n",
+    "    # ============================================================\n",
+    "    return J, grad\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 92,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cost at theta = [1, 1]:\t   303.993192 \n",
+      "This value should be about 303.993192)\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "theta = np.array([1, 1])\n",
+    "J, _ = linearRegCostFunction(np.concatenate([np.ones((m, 1)), X], axis=1), y, theta, 1)\n",
+    "\n",
+    "print('Cost at theta = [1, 1]:\\t   %f ' % J)\n",
+    "print('This value should be about 303.993192)\\n' % J)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 93,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Gradient at theta = [1, 1]:  [-15.303016, 598.250744] \n",
+      " (this value should be about [-15.303016, 598.250744])\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "theta = np.array([1, 1])\n",
+    "J, grad = linearRegCostFunction(np.concatenate([np.ones((m, 1)), X], axis=1), y, theta, 1)\n",
+    "\n",
+    "print('Gradient at theta = [1, 1]:  [{:.6f}, {:.6f}] '.format(*grad))\n",
+    "print(' (this value should be about [-15.303016, 598.250744])\\n')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 94,
+   "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"
+    }
+   ],
+   "source": [
+    "# add a columns of ones for the y-intercept\n",
+    "X_aug = np.concatenate([np.ones((m, 1)), X], axis=1)\n",
+    "theta = trainLinearReg(linearRegCostFunction, X_aug, y, lambda_=0)\n",
+    "\n",
+    "#  Plot fit over the data\n",
+    "pyplot.plot(X, y, 'ro', ms=10, mec='k', mew=1.5)\n",
+    "pyplot.xlabel('Change in water level (x)')\n",
+    "pyplot.ylabel('Water flowing out of the dam (y)')\n",
+    "pyplot.plot(X, np.dot(X_aug, theta), '--', lw=2);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 104,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def learningCurve(X, y, Xval, yval, lambda_=0):\n",
+    "    \"\"\"\n",
+    "    Generates the train and cross validation set errors needed to plot a learning curve\n",
+    "    returns the train and cross validation set errors for a learning curve. \n",
+    "    \n",
+    "    In this function, you will compute the train and test errors for\n",
+    "    dataset sizes from 1 up to m. In practice, when working with larger\n",
+    "    datasets, you might want to do this in larger intervals.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The training dataset. Matrix with shape (m x n + 1) where m is the \n",
+    "        total number of examples, and n is the number of features \n",
+    "        before adding the bias term.\n",
+    "    \n",
+    "    y : array_like\n",
+    "        The functions values at each training datapoint. A vector of\n",
+    "        shape (m, ).\n",
+    "    \n",
+    "    Xval : array_like\n",
+    "        The validation dataset. Matrix with shape (m_val x n + 1) where m is the \n",
+    "        total number of examples, and n is the number of features \n",
+    "        before adding the bias term.\n",
+    "    \n",
+    "    yval : array_like\n",
+    "        The functions values at each validation datapoint. A vector of\n",
+    "        shape (m_val, ).\n",
+    "    \n",
+    "    lambda_ : float, optional\n",
+    "        The regularization parameter.\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    error_train : array_like\n",
+    "        A vector of shape m. error_train[i] contains the training error for\n",
+    "        i examples.\n",
+    "    error_val : array_like\n",
+    "        A vecotr of shape m. error_val[i] contains the validation error for\n",
+    "        i training examples.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Fill in this function to return training errors in error_train and the\n",
+    "    cross validation errors in error_val. i.e., error_train[i] and \n",
+    "    error_val[i] should give you the errors obtained after training on i examples.\n",
+    "    \n",
+    "    Notes\n",
+    "    -----\n",
+    "    - You should evaluate the training error on the first i training\n",
+    "      examples (i.e., X[:i, :] and y[:i]).\n",
+    "    \n",
+    "      For the cross-validation error, you should instead evaluate on\n",
+    "      the _entire_ cross validation set (Xval and yval).\n",
+    "    \n",
+    "    - If you are using your cost function (linearRegCostFunction) to compute\n",
+    "      the training and cross validation error, you should call the function with\n",
+    "      the lambda argument set to 0. Do note that you will still need to use\n",
+    "      lambda when running the training to obtain the theta parameters.\n",
+    "    \n",
+    "    Hint\n",
+    "    ----\n",
+    "    You can loop over the examples with the following:\n",
+    "     \n",
+    "           for i in range(1, m+1):\n",
+    "               # Compute train/cross validation errors using training examples \n",
+    "               # X[:i, :] and y[:i], storing the result in \n",
+    "               # error_train[i-1] and error_val[i-1]\n",
+    "               ....  \n",
+    "    \"\"\"\n",
+    "    # Number of training examples\n",
+    "    m = y.size\n",
+    "\n",
+    "    # You need to return these values correctly\n",
+    "    error_train = np.zeros(m)\n",
+    "    error_val   = np.zeros(m)\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "   \n",
+    "    m_val = Xval.shape[0]\n",
+    "    error_train = np.zeros(m)\n",
+    "    error_val = np.zeros(m)\n",
+    "    \n",
+    "    for i in range(1, m+1):\n",
+    "        res = trainLinearReg(linearRegCostFunction,X[:i,:] ,y[:i] ,lambda_)\n",
+    "        \n",
+    "        error_train[i-1], grad1 = linearRegCostFunction(X[:i, :], y[:i],res)\n",
+    "        error_val[i-1], grad2 = linearRegCostFunction(Xval[:i, :], yval[:i], res)\n",
+    "\n",
+    "   \n",
+    "       \n",
+    "    # =============================================================\n",
+    "    return error_train, error_val"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "# Training Examples\tTrain Error\tCross Validation Error\n",
+      "  \t1\t\t0.000000\t1.858338\n",
+      "  \t2\t\t0.000000\t1.938215\n",
+      "  \t3\t\t3.286595\t1.112333\n",
+      "  \t4\t\t2.842678\t63.664347\n",
+      "  \t5\t\t13.154049\t29.036790\n",
+      "  \t6\t\t19.443963\t31.797566\n",
+      "  \t7\t\t20.098522\t32.115594\n",
+      "  \t8\t\t18.172859\t26.933567\n",
+      "  \t9\t\t22.609405\t26.031529\n",
+      "  \t10\t\t23.261462\t19.980170\n",
+      "  \t11\t\t24.317250\t18.948920\n",
+      "  \t12\t\t22.373906\t17.921571\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"
+    }
+   ],
+   "source": [
+    "X_aug = np.concatenate([np.ones((m, 1)), X], axis=1)\n",
+    "Xval_aug = np.concatenate([np.ones((yval.size, 1)), Xval], axis=1)\n",
+    "error_train, error_val = learningCurve(X_aug, y, Xval_aug, yval, lambda_=0)\n",
+    "\n",
+    "pyplot.plot(np.arange(1, m+1), error_train, np.arange(1, m+1), error_val, lw=2)\n",
+    "pyplot.title('Learning curve for linear regression')\n",
+    "pyplot.legend(['Train', 'Cross Validation'])\n",
+    "pyplot.xlabel('Number of training examples')\n",
+    "pyplot.ylabel('Error')\n",
+    "pyplot.axis([0, 13, 0, 150])\n",
+    "\n",
+    "print('# Training Examples\\tTrain Error\\tCross Validation Error')\n",
+    "for i in range(m):\n",
+    "    print('  \\t%d\\t\\t%f\\t%f' % (i+1, error_train[i], error_val[i]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 106,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# used for manipulating directory paths\n",
+    "import os\n",
+    "\n",
+    "# Scientific and vector computation for python\n",
+    "import numpy as np\n",
+    "\n",
+    "# Plotting library\n",
+    "from matplotlib import pyplot\n",
+    "\n",
+    "# Optimization module in scipy\n",
+    "from scipy import optimize\n",
+    "\n",
+    "# will be used to load MATLAB mat datafile format\n",
+    "from scipy.io import loadmat\n",
+    "\n",
+    "# library written for this exercise providing additional functions for assignment submission, and others\n",
+    "import utils\n",
+    "\n",
+    "# # define the submission/grader object for this exercise\n",
+    "# grader = utils.Grader()\n",
+    "\n",
+    "# tells matplotlib to embed plots within the notebook\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 107,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def polyFeatures(X, p):\n",
+    "    \"\"\"\n",
+    "    Maps X (1D vector) into the p-th power.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        A data vector of size m, where m is the number of examples.\n",
+    "    \n",
+    "    p : int\n",
+    "        The polynomial power to map the features. \n",
+    "    \n",
+    "    Returns \n",
+    "    -------\n",
+    "    X_poly : array_like\n",
+    "        A matrix of shape (m x p) where p is the polynomial \n",
+    "        power and m is the number of examples. That is:\n",
+    "    \n",
+    "        X_poly[i, :] = [X[i], X[i]**2, X[i]**3 ...  X[i]**p]\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Given a vector X, return a matrix X_poly where the p-th column of\n",
+    "    X contains the values of X to the p-th power.\n",
+    "    \"\"\"\n",
+    "    # You need to return the following variables correctly.\n",
+    "    X_poly = np.zeros((X.shape[0], p))\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    \n",
+    "\n",
+    "    for i in range(p):\n",
+    "        X_poly[:, i] = np.power(X, i + 1).ravel()\n",
+    "\n",
+    "    # ============================================================\n",
+    "    return X_poly"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 108,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Normalized Training Example 1:\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "array([ 1.        , -0.36214078, -0.75508669,  0.18222588, -0.70618991,\n",
+       "        0.30661792, -0.59087767,  0.3445158 , -0.50848117])"
+      ]
+     },
+     "execution_count": 108,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "p = 8\n",
+    "\n",
+    "# Map X onto Polynomial Features and Normalize\n",
+    "X_poly = polyFeatures(X, p)\n",
+    "X_poly, mu, sigma = featureNormalize(X_poly)\n",
+    "X_poly = np.concatenate([np.ones((m, 1)), X_poly], axis=1)\n",
+    "\n",
+    "# Map X_poly_test and normalize (using mu and sigma)\n",
+    "X_poly_test = polyFeatures(Xtest, p)\n",
+    "X_poly_test -= mu\n",
+    "X_poly_test /= sigma\n",
+    "X_poly_test = np.concatenate([np.ones((ytest.size, 1)), X_poly_test], axis=1)\n",
+    "\n",
+    "# Map X_poly_val and normalize (using mu and sigma)\n",
+    "X_poly_val = polyFeatures(Xval, p)\n",
+    "X_poly_val -= mu\n",
+    "X_poly_val /= sigma\n",
+    "X_poly_val = np.concatenate([np.ones((yval.size, 1)), X_poly_val], axis=1)\n",
+    "\n",
+    "print('Normalized Training Example 1:')\n",
+    "X_poly[0, :]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 109,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Polynomial Regression (lambda = 100.000000)\n",
+      "\n",
+      "# Training Examples\tTrain Error\tCross Validation Error\n",
+      "  \t1\t\t0.000000\t2.072427\n",
+      "  \t2\t\t0.114107\t3.032247\n",
+      "  \t3\t\t106.956580\t77.159474\n",
+      "  \t4\t\t121.740879\t67.479681\n",
+      "  \t5\t\t102.949459\t63.591811\n",
+      "  \t6\t\t97.169857\t58.744052\n",
+      "  \t7\t\t83.326539\t55.642282\n",
+      "  \t8\t\t76.491825\t53.200540\n",
+      "  \t9\t\t71.297176\t53.480251\n",
+      "  \t10\t\t64.350636\t51.767860\n",
+      "  \t11\t\t58.997943\t49.340313\n",
+      "  \t12\t\t57.977080\t44.478534\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"
+    },
+    {
+     "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": [
+    "lambda_ = 100\n",
+    "theta = trainLinearReg(linearRegCostFunction, X_poly, y,\n",
+    "                             lambda_=0, maxiter=55)\n",
+    "\n",
+    "# Plot training data and fit\n",
+    "pyplot.plot(X, y, 'ro', ms=10, mew=1.5, mec='k')\n",
+    "\n",
+    "plotFit(polyFeatures, np.min(X), np.max(X), mu, sigma, theta, p)\n",
+    "\n",
+    "pyplot.xlabel('Change in water level (x)')\n",
+    "pyplot.ylabel('Water flowing out of the dam (y)')\n",
+    "pyplot.title('Polynomial Regression Fit (lambda = %f)' % lambda_)\n",
+    "pyplot.ylim([-20, 50])\n",
+    "\n",
+    "pyplot.figure()\n",
+    "error_train, error_val = learningCurve(X_poly, y, X_poly_val, yval, lambda_)\n",
+    "pyplot.plot(np.arange(1, 1+m), error_train, np.arange(1, 1+m), error_val)\n",
+    "\n",
+    "pyplot.title('Polynomial Regression Learning Curve (lambda = %f)' % lambda_)\n",
+    "pyplot.xlabel('Number of training examples')\n",
+    "pyplot.ylabel('Error')\n",
+    "pyplot.axis([0, 13, 0, 100])\n",
+    "pyplot.legend(['Train', 'Cross Validation'])\n",
+    "\n",
+    "print('Polynomial Regression (lambda = %f)\\n' % lambda_)\n",
+    "print('# Training Examples\\tTrain Error\\tCross Validation Error')\n",
+    "for i in range(m):\n",
+    "    print('  \\t%d\\t\\t%f\\t%f' % (i+1, error_train[i], error_val[i]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 110,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def validationCurve(X, y, Xval, yval):\n",
+    "    \"\"\"\n",
+    "    Generate the train and validation errors needed to plot a validation\n",
+    "    curve that we can use to select lambda_.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The training dataset. Matrix with shape (m x n) where m is the \n",
+    "        total number of training examples, and n is the number of features \n",
+    "        including any polynomial features.\n",
+    "    \n",
+    "    y : array_like\n",
+    "        The functions values at each training datapoint. A vector of\n",
+    "        shape (m, ).\n",
+    "    \n",
+    "    Xval : array_like\n",
+    "        The validation dataset. Matrix with shape (m_val x n) where m is the \n",
+    "        total number of validation examples, and n is the number of features \n",
+    "        including any polynomial features.\n",
+    "    \n",
+    "    yval : array_like\n",
+    "        The functions values at each validation datapoint. A vector of\n",
+    "        shape (m_val, ).\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    lambda_vec : list\n",
+    "        The values of the regularization parameters which were used in \n",
+    "        cross validation.\n",
+    "    \n",
+    "    error_train : list\n",
+    "        The training error computed at each value for the regularization\n",
+    "        parameter.\n",
+    "    \n",
+    "    error_val : list\n",
+    "        The validation error computed at each value for the regularization\n",
+    "        parameter.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Fill in this function to return training er\n",
+    "    Fill in this function to return training errors in `error_train` and\n",
+    "    the validation errors in `error_val`. The vector `lambda_vec` contains\n",
+    "    the different lambda parameters to use for each calculation of the\n",
+    "    errors, i.e, `error_train[i]`, and `error_val[i]` should give you the\n",
+    "    errors obtained after training with `lambda_ = lambda_vec[i]`.\n",
+    "\n",
+    "    Note\n",
+    "    ----\n",
+    "    You can loop over lambda_vec with the following:\n",
+    "    \n",
+    "          for i in range(len(lambda_vec))\n",
+    "              lambda = lambda_vec[i]\n",
+    "              # Compute train / val errors when training linear \n",
+    "              # regression with regularization parameter lambda_\n",
+    "              # You should store the result in error_train[i]\n",
+    "              # and error_val[i]\n",
+    "              ....\n",
+    "    \"\"\"\n",
+    "    # Selected values of lambda (you should not change this)\n",
+    "    lambda_vec = [0, 0.001, 0.003, 0.01, 0.03, 0.1, 0.3, 1, 3, 10]\n",
+    "\n",
+    "    # You need to return these variables correctly.\n",
+    "    error_train = np.zeros(len(lambda_vec))\n",
+    "    error_val = np.zeros(len(lambda_vec))\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    m = X.shape[0]\n",
+    "    m_val = Xval.shape[0]\n",
+    "    for i in range(1,len(lambda_vec)):\n",
+    "        l = lambda_vec[i]\n",
+    "        theta = trainLinearReg(X, y, l)\n",
+    "        error_train[i] = 1.0 / (2 * m) * np.sum(np.square(X.dot(theta) - y))\n",
+    "        error_val[i] = 1.0 / (2 * m_val) * np.sum(np.square(Xval.dot(theta) - yval))\n",
+    "\n",
+    "    # ============================================================\n",
+    "    return lambda_vec, error_train, error_val"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 111,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "IndexError",
+     "evalue": "tuple index out of range",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-111-894fa62a6de4>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mlambda_vec\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0merror_train\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0merror_val\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mvalidationCurve\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX_poly\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX_poly_val\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0myval\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mpyplot\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlambda_vec\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0merror_train\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'-o'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlambda_vec\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0merror_val\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'-o'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlw\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mpyplot\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlegend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'Train'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'Cross Validation'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mpyplot\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mxlabel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'lambda'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;32m<ipython-input-110-0a9e7370d39f>\u001b[0m in \u001b[0;36mvalidationCurve\u001b[1;34m(X, y, Xval, yval)\u001b[0m\n\u001b[0;32m     71\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlambda_vec\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     72\u001b[0m         \u001b[0ml\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlambda_vec\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 73\u001b[1;33m         \u001b[0mtheta\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtrainLinearReg\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ml\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     74\u001b[0m         \u001b[0merror_train\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1.0\u001b[0m \u001b[1;33m/\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mm\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msquare\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtheta\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m-\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     75\u001b[0m         \u001b[0merror_val\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1.0\u001b[0m \u001b[1;33m/\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mm_val\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msquare\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mXval\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtheta\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m-\u001b[0m \u001b[0myval\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;32m<ipython-input-88-2efd32502b4a>\u001b[0m in \u001b[0;36mtrainLinearReg\u001b[1;34m(linearRegCostFunction, X, y, lambda_, maxiter)\u001b[0m\n\u001b[0;32m     27\u001b[0m     \"\"\"\n\u001b[0;32m     28\u001b[0m     \u001b[1;31m# Initialize Theta\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 29\u001b[1;33m     \u001b[0minitial_theta\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     30\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     31\u001b[0m     \u001b[1;31m# Create \"short hand\" for the cost function to be minimized\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;31mIndexError\u001b[0m: tuple index out of range"
+     ]
+    }
+   ],
+   "source": [
+    "lambda_vec, error_train, error_val = validationCurve(X_poly, y, X_poly_val, yval)\n",
+    "\n",
+    "pyplot.plot(lambda_vec, error_train, '-o', lambda_vec, error_val, '-o', lw=2)\n",
+    "pyplot.legend(['Train', 'Cross Validation'])\n",
+    "pyplot.xlabel('lambda')\n",
+    "pyplot.ylabel('Error')\n",
+    "\n",
+    "print('lambda\\t\\tTrain Error\\tValidation Error')\n",
+    "for i in range(len(lambda_vec)):\n",
+    "    print(' %f\\t%f\\t%f' % (lambda_vec[i], error_train[i], error_val[i]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}