Exercise2/exercise2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programming Exercise 2: Logistic Regression\n",
    "\n",
    "## Introduction\n",
    "\n",
    "In this exercise, you will implement logistic regression and apply it to two different datasets. Before starting on the programming exercise, we strongly recommend watching the video lectures and completing the review questions for the associated topics.\n",
    "\n",
    "All the information you need for solving this assignment is in this notebook, and all the code you will be implementing will take place within this notebook. The assignment can be promptly submitted to the coursera grader directly from this notebook (code and instructions are included below).\n",
    "\n",
    "Before we begin with the exercises, we need to import all libraries required for this programming exercise. Throughout the course, we will be using [`numpy`](http://www.numpy.org/) for all arrays and matrix operations, and [`matplotlib`](https://matplotlib.org/) for plotting. In this assignment, we will also use [`scipy`](https://docs.scipy.org/doc/scipy/reference/), which contains scientific and numerical computation functions and tools. \n",
    "\n",
    "You can find instructions on how to install required libraries in the README file in the [github repository](https://github.com/dibgerge/ml-coursera-python-assignments)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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",
    "# 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": "markdown",
   "metadata": {},
   "source": [
    "## Submission and Grading\n",
    "\n",
    "\n",
    "After completing each part of the assignment, be sure to submit your solutions to the grader. The following is a breakdown of how each part of this exercise is scored.\n",
    "\n",
    "\n",
    "| Section | Part                                 | Submission function   | Points \n",
    "| :-      |:-                                    | :-                    | :-:\n",
    "| 1       | [Sigmoid Function](#section1)                   | [`sigmoid`](#sigmoid) | 5      \n",
    "| 2       | [Compute cost for logistic regression](#section2) | [`costFunction`](#costFunction) | 30     \n",
    "| 3       | [Gradient for logistic regression](#section2)     | [`costFunction`](#costFunction) | 30     \n",
    "| 4       | [Predict Function](#section4)                     | [`predict`](#predict) | 5      \n",
    "| 5       | [Compute cost for regularized LR](#section5)      | [`costFunctionReg`](#costFunctionReg) | 15     \n",
    "| 6       | [Gradient for regularized LR](#section5)          | [`costFunctionReg`](#costFunctionReg) | 15     \n",
    "|         | Total Points                         | | 100    \n",
    "\n",
    "\n",
    "\n",
    "You are allowed to submit your solutions multiple times, and we will take only the highest score into consideration.\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "At the end of each section in this notebook, we have a cell which contains code for submitting the solutions thus far to the grader. Execute the cell to see your score up to the current section. For all your work to be submitted properly, you must execute those cells at least once. They must also be re-executed everytime the submitted function is updated.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 Logistic Regression\n",
    "\n",
    "In this part of the exercise, you will build a logistic regression model to predict whether a student gets admitted into a university. Suppose that you are the administrator of a university department and\n",
    "you want to determine each applicant’s chance of admission based on their results on two exams. You have historical data from previous applicants that you can use as a training set for logistic regression. For each training example, you have the applicant’s scores on two exams and the admissions\n",
    "decision. Your task is to build a classification model that estimates an applicant’s probability of admission based the scores from those two exams. \n",
    "\n",
    "The following cell will load the data and corresponding labels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Visualizing the data\n",
    "\n",
    "Before starting to implement any learning algorithm, it is always good to visualize the data if possible. We  display the data on a 2-dimensional plot by calling the function `plotData`. You will now complete the code in `plotData` so that it displays a figure where the axes are the two exam scores, and the positive and negative examples are shown with different markers.\n",
    "\n",
    "To help you get more familiar with plotting, we have left `plotData` empty so you can try to implement it yourself. However, this is an optional (ungraded) exercise. We also provide our implementation below so you can\n",
    "copy it or refer to it. If you choose to copy our example, make sure you learn\n",
    "what each of its commands is doing by consulting the `matplotlib` and `numpy` documentation.\n",
    "\n",
    "```python\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",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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": "markdown",
   "metadata": {},
   "source": [
    "Now, we call the implemented function to display the loaded data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section1\"></a>\n",
    "### 1.2 Implementation\n",
    "\n",
    "#### 1.2.1 Warmup exercise: sigmoid function\n",
    "\n",
    "Before you start with the actual cost function, recall that the logistic regression hypothesis is defined as:\n",
    "\n",
    "$$ h_\\theta(x) = g(\\theta^T x)$$\n",
    "\n",
    "where function $g$ is the sigmoid function. The sigmoid function is defined as: \n",
    "\n",
    "$$g(z) = \\frac{1}{1+e^{-z}}$$.\n",
    "\n",
    "Your first step is to implement this function `sigmoid` so it can be\n",
    "called by the rest of your program. When you are finished, try testing a few\n",
    "values by calling `sigmoid(x)` in a new cell. For large positive values of `x`, the sigmoid should be close to 1, while for large negative values, the sigmoid should be close to 0. Evaluating `sigmoid(0)` should give you exactly 0.5. Your code should also work with vectors and matrices. **For a matrix, your function should perform the sigmoid function on every element.**\n",
    "<a id=\"sigmoid\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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",
    "    return g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following cell evaluates the sigmoid function at `z=0`. You should get a value of 0.5. You can also try different values for `z` to experiment with the sigmoid function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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": "markdown",
   "metadata": {},
   "source": [
    "After completing a part of the exercise, you can submit your solutions for grading by first adding the function you modified to the submission object, and then sending your function to Coursera for grading. \n",
    "\n",
    "The submission script will prompt you for your login e-mail and submission token. You can obtain a submission token from the web page for the assignment. You are allowed to submit your solutions multiple times, and we will take only the highest score into consideration.\n",
    "\n",
    "Execute the following cell to grade your solution to the first part of this exercise.\n",
    "\n",
    "*You should now submit your solutions.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Submitting Solutions | Programming Exercise logistic-regression\n",
      "\n",
      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
      "                                  Part Name |     Score | Feedback\n",
      "                                  --------- |     ----- | --------\n",
      "                           Sigmoid Function |   5 /   5 | Nice work!\n",
      "                   Logistic Regression Cost |   0 /  30 | \n",
      "               Logistic Regression Gradient |   0 /  30 | \n",
      "                                    Predict |   0 /   5 | \n",
      "       Regularized Logistic Regression Cost |   0 /  15 | \n",
      "   Regularized Logistic Regression Gradient |   0 /  15 | \n",
      "                                  --------------------------------\n",
      "                                            |   5 / 100 |  \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# appends the implemented function in part 1 to the grader object\n",
    "grader[1] = sigmoid\n",
    "\n",
    "# send the added functions to coursera grader for getting a grade on this part\n",
    "grader.grade()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section2\"></a>\n",
    "#### 1.2.2 Cost function and gradient\n",
    "\n",
    "Now you will implement the cost function and gradient for logistic regression. Before proceeding we add the intercept term to X. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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": "markdown",
   "metadata": {},
   "source": [
    "Now, complete the code for the function `costFunction` to return the cost and gradient. Recall that the cost function in logistic regression is\n",
    "\n",
    "$$ J(\\theta) = \\frac{1}{m} \\sum_{i=1}^{m} \\left[ -y^{(i)} \\log\\left(h_\\theta\\left( x^{(i)} \\right) \\right) - \\left( 1 - y^{(i)}\\right) \\log \\left( 1 - h_\\theta\\left( x^{(i)} \\right) \\right) \\right]$$\n",
    "\n",
    "and the gradient of the cost is a vector of the same length as $\\theta$ where the $j^{th}$\n",
    "element (for $j = 0, 1, \\cdots , n$) is defined as follows:\n",
    "\n",
    "$$ \\frac{\\partial J(\\theta)}{\\partial \\theta_j} = \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta \\left( x^{(i)} \\right) - y^{(i)} \\right) x_j^{(i)} $$\n",
    "\n",
    "Note that while this gradient looks identical to the linear regression gradient, the formula is actually different because linear and logistic regression have different definitions of $h_\\theta(x)$.\n",
    "<a id=\"costFunction\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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",
    "    J = (-1/m) * ((np.sum(y*(np.log(1/(np.exp(-np.dot(theta,X.transpose())) + 1))))) + \n",
    "                     (np.sum((1-y)*(np.log(1-(1/(np.exp(-np.dot(theta,X.transpose())) + 1)))))))\n",
    "    \n",
    "    for i in range(n+1):\n",
    "        grad[i] = (1/m) * np.sum(((1/(1 + np.exp(-np.dot(theta,X.transpose())))) - y) * X[:,i])\n",
    "    \n",
    "    # =============================================================\n",
    "    return J, grad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you are done call your `costFunction` using two test cases for  $\\theta$ by executing the next cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "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": "markdown",
   "metadata": {},
   "source": [
    "*You should now submit your solutions.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Submitting Solutions | Programming Exercise logistic-regression\n",
      "\n",
      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
      "                                  Part Name |     Score | Feedback\n",
      "                                  --------- |     ----- | --------\n",
      "                           Sigmoid Function |   5 /   5 | Nice work!\n",
      "                   Logistic Regression Cost |  30 /  30 | Nice work!\n",
      "               Logistic Regression Gradient |  30 /  30 | Nice work!\n",
      "                                    Predict |   0 /   5 | \n",
      "       Regularized Logistic Regression Cost |   0 /  15 | \n",
      "   Regularized Logistic Regression Gradient |   0 /  15 | \n",
      "                                  --------------------------------\n",
      "                                            |  65 / 100 |  \n",
      "\n"
     ]
    }
   ],
   "source": [
    "grader[2] = costFunction\n",
    "grader[3] = costFunction\n",
    "grader.grade()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.2.3 Learning parameters using `scipy.optimize`\n",
    "\n",
    "In the previous assignment, you found the optimal parameters of a linear regression model by implementing gradient descent. You wrote a cost function and calculated its gradient, then took a gradient descent step accordingly. This time, instead of taking gradient descent steps, you will use the [`scipy.optimize` module](https://docs.scipy.org/doc/scipy/reference/optimize.html). SciPy is a numerical computing library for `python`. It provides an optimization module for root finding and minimization. As of `scipy 1.0`, the function `scipy.optimize.minimize` is the method to use for optimization problems(both constrained and unconstrained).\n",
    "\n",
    "For logistic regression, you want to optimize the cost function $J(\\theta)$ with parameters $\\theta$.\n",
    "Concretely, you are going to use `optimize.minimize` to find the best parameters $\\theta$ for the logistic regression cost function, given a fixed dataset (of X and y values). You will pass to `optimize.minimize` the following inputs:\n",
    "- `costFunction`: A cost function that, when given the training set and a particular $\\theta$, computes the logistic regression cost and gradient with respect to $\\theta$ for the dataset (X, y). It is important to note that we only pass the name of the function without the parenthesis. This indicates that we are only providing a reference to this function, and not evaluating the result from this function.\n",
    "- `initial_theta`: The initial values of the parameters we are trying to optimize.\n",
    "- `(X, y)`: These are additional arguments to the cost function.\n",
    "- `jac`: Indication if the cost function returns the Jacobian (gradient) along with cost value. (True)\n",
    "- `method`: Optimization method/algorithm to use\n",
    "- `options`: Additional options which might be specific to the specific optimization method. In the following, we only tell the algorithm the maximum number of iterations before it terminates.\n",
    "\n",
    "If you have completed the `costFunction` correctly, `optimize.minimize` will converge on the right optimization parameters and return the final values of the cost and $\\theta$ in a class object. Notice that by using `optimize.minimize`, you did not have to write any loops yourself, or set a learning rate like you did for gradient descent. This is all done by `optimize.minimize`: you only needed to provide a function calculating the cost and the gradient.\n",
    "\n",
    "In the following, we already have code written to call `optimize.minimize` with the correct arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "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,\n",
    "                        initial_theta,\n",
    "                        (X, y),\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\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": "markdown",
   "metadata": {},
   "source": [
    "Once `optimize.minimize` completes, we want to use the final value for $\\theta$ to visualize the decision boundary on the training data as shown in the figure below. \n",
    "\n",
    "![](Figures/decision_boundary1.png)\n",
    "\n",
    "To do so, we have written a function `plotDecisionBoundary` for plotting the decision boundary on top of training data. You do not need to write any code for plotting the decision boundary, but we also encourage you to look at the code in `plotDecisionBoundary` to see how to plot such a boundary using the $\\theta$ values. You can find this function in the `utils.py` file which comes with this assignment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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",
    "utils.plotDecisionBoundary(plotData, theta, X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section4\"></a>\n",
    "#### 1.2.4 Evaluating logistic regression\n",
    "\n",
    "After learning the parameters, you can use the model to predict whether a particular student will be admitted. For a student with an Exam 1 score of 45 and an Exam 2 score of 85, you should expect to see an admission\n",
    "probability of 0.776. Another way to evaluate the quality of the parameters we have found is to see how well the learned model predicts on our training set. In this part, your task is to complete the code in function `predict`. The predict function will produce “1” or “0” predictions given a dataset and a learned parameter vector $\\theta$. \n",
    "<a id=\"predict\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "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 vector 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",
    "    temp = sigmoid(np.dot(theta,X.transpose()))\n",
    "    #p = [1 for i in range(m) if temp[i]>=0.5]\n",
    "    for i in range(m):\n",
    "        if temp[i] >= 0.5:\n",
    "            p[i] = 1\n",
    "        else:\n",
    "            p[i] = 0\n",
    "    # ============================================================\n",
    "    return p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After you have completed the code in `predict`, we proceed to report the training accuracy of your classifier by computing the percentage of examples it got correct."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "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": "markdown",
   "metadata": {},
   "source": [
    "*You should now submit your solutions.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Submitting Solutions | Programming Exercise logistic-regression\n",
      "\n",
      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
      "                                  Part Name |     Score | Feedback\n",
      "                                  --------- |     ----- | --------\n",
      "                           Sigmoid Function |   5 /   5 | Nice work!\n",
      "                   Logistic Regression Cost |  30 /  30 | Nice work!\n",
      "               Logistic Regression Gradient |  30 /  30 | Nice work!\n",
      "                                    Predict |   5 /   5 | Nice work!\n",
      "       Regularized Logistic Regression Cost |   0 /  15 | \n",
      "   Regularized Logistic Regression Gradient |   0 /  15 | \n",
      "                                  --------------------------------\n",
      "                                            |  70 / 100 |  \n",
      "\n"
     ]
    }
   ],
   "source": [
    "grader[4] = predict\n",
    "grader.grade()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Regularized logistic regression\n",
    "\n",
    "In this part of the exercise, you will implement regularized logistic regression to predict whether microchips from a fabrication plant passes quality assurance (QA). During QA, each microchip goes through various tests to ensure it is functioning correctly.\n",
    "Suppose you are the product manager of the factory and you have the test results for some microchips on two different tests. From these two tests, you would like to determine whether the microchips should be accepted or rejected. To help you make the decision, you have a dataset of test results on past microchips, from which you can build a logistic regression model.\n",
    "\n",
    "First, we load the data from a CSV file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "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": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Visualize the data\n",
    "\n",
    "Similar to the previous parts of this exercise, `plotData` is used to generate a figure, where the axes are the two test scores, and the positive (y = 1, accepted) and negative (y = 0, rejected) examples are shown with\n",
    "different markers."
   ]
  },
  {
   "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"
    }
   ],
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above figure shows that our dataset cannot be separated into positive and negative examples by a straight-line through the plot. Therefore, a straight-forward application of logistic regression will not perform well on this dataset since logistic regression will only be able to find a linear decision boundary.\n",
    "\n",
    "### 2.2 Feature mapping\n",
    "\n",
    "One way to fit the data better is to create more features from each data point. In the function `mapFeature` defined in the file `utils.py`, we will map the features into all polynomial terms of $x_1$ and $x_2$ up to the sixth power.\n",
    "\n",
    "$$ \\text{mapFeature}(x) = \\begin{bmatrix} 1 & x_1 & x_2 & x_1^2 & x_1 x_2 & x_2^2 & x_1^3 & \\dots & x_1 x_2^5 & x_2^6 \\end{bmatrix}^T $$\n",
    "\n",
    "As a result of this mapping, our vector of two features (the scores on two QA tests) has been transformed into a 28-dimensional vector. A logistic regression classifier trained on this higher-dimension feature vector will have a more complex decision boundary and will appear nonlinear when drawn in our 2-dimensional plot.\n",
    "While the feature mapping allows us to build a more expressive classifier, it also more susceptible to overfitting. In the next parts of the exercise, you will implement regularized logistic regression to fit the data and also see for yourself how regularization can help combat the overfitting problem.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note that mapFeature also adds a column of ones for us, so the intercept\n",
    "# term is handled\n",
    "X = utils.mapFeature(X[:, 0], X[:, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"section5\"></a>\n",
    "### 2.3 Cost function and gradient\n",
    "\n",
    "Now you will implement code to compute the cost function and gradient for regularized logistic regression. Complete the code for the function `costFunctionReg` below to return the cost and gradient.\n",
    "\n",
    "Recall that the regularized cost function in logistic regression is\n",
    "\n",
    "$$ J(\\theta) = \\frac{1}{m} \\sum_{i=1}^m \\left[ -y^{(i)}\\log \\left( h_\\theta \\left(x^{(i)} \\right) \\right) - \\left( 1 - y^{(i)} \\right) \\log \\left( 1 - h_\\theta \\left( x^{(i)} \\right) \\right) \\right] + \\frac{\\lambda}{2m} \\sum_{j=1}^n \\theta_j^2 $$\n",
    "\n",
    "Note that you should not regularize the parameters $\\theta_0$. The gradient of the cost function is a vector where the $j^{th}$ element is defined as follows:\n",
    "\n",
    "$$ \\frac{\\partial J(\\theta)}{\\partial \\theta_0} = \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta \\left(x^{(i)}\\right) - y^{(i)} \\right) x_j^{(i)} \\qquad \\text{for } j =0 $$\n",
    "\n",
    "$$ \\frac{\\partial J(\\theta)}{\\partial \\theta_j} = \\left( \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta \\left(x^{(i)}\\right) - y^{(i)} \\right) x_j^{(i)} \\right) + \\frac{\\lambda}{m}\\theta_j \\qquad \\text{for } j \\ge 1 $$\n",
    "<a id=\"costFunctionReg\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "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 = theta.size\n",
    "    # You need to return the following variables correctly \n",
    "    J = 0\n",
    "    grad = np.zeros(theta.shape)\n",
    "\n",
    "    # ===================== YOUR CODE HERE ======================\n",
    "    J = (-1/m) * ((np.sum(y*(np.log(1/(np.exp(-np.dot(theta,X.transpose())) + 1))))) + (np.sum((1-y)*(np.log(1-(1/(np.exp(-np.dot(theta,X.transpose())) + 1))))))) + ((lambda_/(2*m))*(np.sum(np.square(theta))-(theta[0]*theta[0])))\n",
    "    \n",
    "    grad[0] = (1/m) * np.sum(((1/(1 + np.exp(-np.dot(theta,X.transpose())))) - y) * X[:,0])\n",
    "    \n",
    "    for i in range(n-1):\n",
    "        grad[i+1] = (1/m) * (np.sum(((1/(1 + np.exp(-np.dot(theta,X.transpose())))) - y) * X[:,i+1])+\n",
    "                             (lambda_*theta[i+1]))                                \n",
    "    \n",
    "    # =============================================================\n",
    "    return J, grad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you are done with the `costFunctionReg`, we call it below using the initial value of $\\theta$ (initialized to all zeros), and also another test case where $\\theta$ is all ones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "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": "markdown",
   "metadata": {},
   "source": [
    "*You should now submit your solutions.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Submitting Solutions | Programming Exercise logistic-regression\n",
      "\n",
      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
      "                                  Part Name |     Score | Feedback\n",
      "                                  --------- |     ----- | --------\n",
      "                           Sigmoid Function |   5 /   5 | Nice work!\n",
      "                   Logistic Regression Cost |  30 /  30 | Nice work!\n",
      "               Logistic Regression Gradient |  30 /  30 | Nice work!\n",
      "                                    Predict |   5 /   5 | Nice work!\n",
      "       Regularized Logistic Regression Cost |  15 /  15 | Nice work!\n",
      "   Regularized Logistic Regression Gradient |  15 /  15 | Nice work!\n",
      "                                  --------------------------------\n",
      "                                            | 100 / 100 |  \n",
      "\n"
     ]
    }
   ],
   "source": [
    "grader[5] = costFunctionReg\n",
    "grader[6] = costFunctionReg\n",
    "grader.grade()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3.1 Learning parameters using `scipy.optimize.minimize`\n",
    "\n",
    "Similar to the previous parts, you will use `optimize.minimize` to learn the optimal parameters $\\theta$. If you have completed the cost and gradient for regularized logistic regression (`costFunctionReg`) correctly, you should be able to step through the next part of to learn the parameters $\\theta$ using `optimize.minimize`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 Plotting the decision boundary\n",
    "\n",
    "To help you visualize the model learned by this classifier, we have provided the function `plotDecisionBoundary` which plots the (non-linear) decision boundary that separates the positive and negative examples. In `plotDecisionBoundary`, we plot the non-linear decision boundary by computing the classifier’s predictions on an evenly spaced grid and then and draw a contour plot where the predictions change from y = 0 to y = 1. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5 Optional (ungraded) exercises\n",
    "\n",
    "In this part of the exercise, you will get to try out different regularization parameters for the dataset to understand how regularization prevents overfitting.\n",
    "\n",
    "Notice the changes in the decision boundary as you vary $\\lambda$. With a small\n",
    "$\\lambda$, you should find that the classifier gets almost every training example correct, but draws a very complicated boundary, thus overfitting the data. See the following figures for the decision boundaries you should get for different values of $\\lambda$. \n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td style=\"text-align:center\">\n",
    "            No regularization (overfitting)<img src=\"Figures/decision_boundary3.png\">\n",
    "        </td>        \n",
    "        <td style=\"text-align:center\">\n",
    "            Decision boundary with regularization\n",
    "            <img src=\"Figures/decision_boundary2.png\">\n",
    "        </td>\n",
    "        <td style=\"text-align:center\">\n",
    "            Decision boundary with too much regularization\n",
    "            <img src=\"Figures/decision_boundary4.png\">\n",
    "        </td>        \n",
    "    <tr>\n",
    "</table>\n",
    "\n",
    "This is not a good decision boundary: for example, it predicts that a point at $x = (−0.25, 1.5)$ is accepted $(y = 1)$, which seems to be an incorrect decision given the training set.\n",
    "With a larger $\\lambda$, you should see a plot that shows an simpler decision boundary which still separates the positives and negatives fairly well. However, if $\\lambda$ is set to too high a value, you will not get a good fit and the decision boundary will not follow the data so well, thus underfitting the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "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",
    "utils.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')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*You do not need to submit any solutions for these optional (ungraded) exercises.*"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}