diff --git a/math/calculus-for-ml/classification_with_perceptron_sigmoid.ipynb b/math/calculus-for-ml/classification_with_perceptron_sigmoid.ipynb new file mode 100644 index 0000000..0d15d44 --- /dev/null +++ b/math/calculus-for-ml/classification_with_perceptron_sigmoid.ipynb @@ -0,0 +1,1439 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "EAt-K2qgcIou" + }, + "source": [ + "# Classification with Perceptron" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FZYK-0rin5x7" + }, + "source": [ + "In this lab, you will use a single perceptron neural network model to solve a simple classification problem. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Table of Contents\n", + "\n", + "- [ 1 - Simple Classification Problem](#1)\n", + "- [ 2 - Single Perceptron Neural Network with Activation Function](#2)\n", + " - [ 2.1 - Neural Network Structure](#2.1)\n", + " - [ 2.2 - Dataset](#2.2)\n", + " - [ 2.3 - Define Activation Function](#2.3)\n", + "- [ 3 - Implementation of the Neural Network Model](#3)\n", + " - [ 3.1 - Defining the Neural Network Structure](#3.1)\n", + " - [ 3.2 - Initialize the Model's Parameters](#3.2)\n", + " - [ 3.3 - The Loop](#3.3)\n", + " - [ 3.4 - Integrate parts 3.1, 3.2 and 3.3 in nn_model() and make predictions](#3.4)\n", + "- [ 4 - Performance on a Larger Dataset](#4)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XI8PBrk_2Z4V" + }, + "source": [ + "## Packages\n", + "\n", + "Let's first import all the packages that you will need during this lab." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import colors\n", + "# A function to create a dataset.\n", + "from sklearn.datasets import make_blobs \n", + "\n", + "# Output of plotting commands is displayed inline within the Jupyter notebook.\n", + "%matplotlib inline \n", + "\n", + "# Set a seed so that the results are consistent.\n", + "np.random.seed(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 1 - Simple Classification Problem\n", + "\n", + "**Classification** is the problem of identifying which of a set of categories an observation belongs to. In case of only two categories it is called a **binary classification problem**. Let's see a simple example of it.\n", + "\n", + "Imagine that you have a set of sentences which you want to classify as \"happy\" and \"angry\". And you identified that the sentences contain only two words: *aack* and *beep*. For each of the sentences (data point in the given dataset) you count the number of those two words ($x_1$ and $x_2$) and compare them with each other. If there are more \"beep\" ($x_2 > x_1$), the sentence should be classified as \"angry\", if not ($x_2 <= x_1$), it is a \"happy\" sentence. Which means that there will be some straight line separating those two classes.\n", + "\n", + "Let's take a very simple set of $4$ sentenses: \n", + "- \"Beep!\" \n", + "- \"Aack?\" \n", + "- \"Beep aack...\" \n", + "- \"!?\"\n", + "\n", + "Here both $x_1$ and $x_2$ will be either $0$ or $1$. You can plot those points in a plane, and see the points (observations) belong to two classes, \"angry\" (red) and \"happy\" (blue), and a straight line can be used as a decision boundary to separate those two classes. An example of such a line is plotted. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "xmin, xmax = -0.2, 1.4\n", + "x_line = np.arange(xmin, xmax, 0.1)\n", + "# Data points (observations) from two classes.\n", + "ax.scatter(0, 0, color=\"b\")\n", + "ax.scatter(0, 1, color=\"r\")\n", + "ax.scatter(1, 0, color=\"b\")\n", + "ax.scatter(1, 1, color=\"b\")\n", + "ax.set_xlim([xmin, xmax])\n", + "ax.set_ylim([-0.1, 1.1])\n", + "ax.set_xlabel('$x_1$')\n", + "ax.set_ylabel('$x_2$')\n", + "# One of the lines which can be used as a decision boundary to separate two classes.\n", + "ax.plot(x_line, x_line + 0.5, color=\"black\")\n", + "plt.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This particular line is chosen using common sense, just looking at the visual representation of the observations. Such classification problem is called a problem with **two linearly separable classes**.\n", + "\n", + "The line $x_1-x_2+0.5 = 0$ (or $x_2 = x_1 + 0.5$) can be used as a separating line for the problem. All of the points $(x_1, x_2)$ above this line, such that $x_1-x_2+0.5 < 0$ (or $x_2 > x_1 + 0.5$), will be considered belonging to the red class, and below this line $x_1-x_2+0.5 > 0$ ($x_2 < x_1 + 0.5$) - belonging to the blue class. So the problem can be rephrased: in the expression $w_1x_1+w_2x_2+b=0$ find the values for the parameters $w_1$, $w_2$ and the threshold $b$, so that the line can serve as a decision boundary.\n", + "\n", + "In this simple example you could solve the problem of finding the decision boundary just looking at the plot: $w_1 = 1$, $w_2 = -1$, $b = 0.5$. But what if the problem is more complicated? You can use a simple neural network model to do that! Let's implement it for this example and then try it for more complicated problem." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 2 - Single Perceptron Neural Network with Activation Function\n", + "\n", + "You already have constructed and trained a neural network model with one **perceptron**. Here a similar model can be used, but with an activation function. Then a single perceptron basically works as a threshold function." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 2.1 - Neural Network Structure" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The neural network components are shown in the following scheme:\n", + "\n", + "\n", + "\n", + "Similarly to the previous lab, the input layer contains two nodes $x_1$ and $x_2$. Weight vector $W = \\begin{bmatrix} w_1 & w_2\\end{bmatrix}$ and bias ($b$) are the parameters to be updated during the model training. First step in the forward propagation is the same as in the previous lab. For every training example $x^{(i)} = \\begin{bmatrix} x_1^{(i)} & x_2^{(i)}\\end{bmatrix}$:\n", + "\n", + "$$z^{(i)} = w_1x_1^{(i)} + w_2x_2^{(i)} + b = Wx^{(i)} + b.\\tag{1}$$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But now you cannot take a real number $z^{(i)}$ into the output as you need to perform classification. It could be done with a discrete approach: compare the result with zero, and classify as $0$ (blue) if it is below zero and $1$ (red) if it is above zero. Then define cost function as a percentage of incorrectly identified classes and perform backward propagation.\n", + "\n", + "This extra step in the forward propagation is actually an application of an **activation function**. It would be possible to implement the discrete approach described above (with unit step function) for this problem, but it turns out that there is a continuous approach that works better and is commonly used in more complicated neural networks. So you will implement it here: single perceptron with sigmoid activation function." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sigmoid activation function is defined as\n", + "\n", + "$$a = \\sigma\\left(z\\right) = \\frac{1}{1+e^{-z}}.\\tag{2}$$\n", + "\n", + "Then a threshold value of $0.5$ can be used for predictions: $1$ (red) if $a > 0.5$ and $0$ (blue) otherwise. Putting it all together, mathematically the single perceptron neural network with sigmoid activation function can be expressed as:\n", + "\n", + "\\begin{align}\n", + "z^{(i)} &= W x^{(i)} + b,\\\\\n", + "a^{(i)} &= \\sigma\\left(z^{(i)}\\right).\\\\\\tag{3}\n", + "\\end{align}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you have $m$ training examples organised in the columns of ($2 \\times m$) matrix $X$, you can apply the activation function element-wise. So the model can be written as:\n", + "\n", + "\\begin{align}\n", + "Z &= W X + b,\\\\\n", + "A &= \\sigma\\left(Z\\right),\\\\\\tag{4}\n", + "\\end{align}\n", + "\n", + "where $b$ is broadcasted to the vector of a size ($1 \\times m$). \n", + "\n", + "When dealing with classification problems, the most commonly used cost function is the **log loss**, which is described by the following equation:\n", + "\n", + "$$\\mathcal{L}\\left(W, b\\right) = \\frac{1}{m}\\sum_{i=1}^{m} L\\left(W, b\\right) = \\frac{1}{m}\\sum_{i=1}^{m} \\large\\left(\\small -y^{(i)}\\log\\left(a^{(i)}\\right) - (1-y^{(i)})\\log\\left(1- a^{(i)}\\right) \\large \\right) \\small,\\tag{5}$$\n", + "\n", + "where $y^{(i)} \\in \\{0,1\\}$ are the original labels and $a^{(i)}$ are the continuous output values of the forward propagation step (elements of array $A$)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You want to minimize the cost function during the training. To implement gradient descent, calculate partial derivatives using chain rule:\n", + "\n", + "\\begin{align}\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial w_1 } &= \n", + "\\frac{1}{m}\\sum_{i=1}^{m} \\frac{\\partial L }{ \\partial a^{(i)}}\n", + "\\frac{\\partial a^{(i)} }{ \\partial z^{(i)}}\\frac{\\partial z^{(i)} }{ \\partial w_1},\\\\\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial w_2 } &= \n", + "\\frac{1}{m}\\sum_{i=1}^{m} \\frac{\\partial L }{ \\partial a^{(i)}}\n", + "\\frac{\\partial a^{(i)} }{ \\partial z^{(i)}}\\frac{\\partial z^{(i)} }{ \\partial w_2},\\tag{6}\\\\\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial b } &= \n", + "\\frac{1}{m}\\sum_{i=1}^{m} \\frac{\\partial L }{ \\partial a^{(i)}}\n", + "\\frac{\\partial a^{(i)} }{ \\partial z^{(i)}}\\frac{\\partial z^{(i)} }{ \\partial b}.\n", + "\\end{align}\n", + "\n", + "As discussed in the videos, $\\frac{\\partial L }{ \\partial a^{(i)}}\n", + "\\frac{\\partial a^{(i)} }{ \\partial z^{(i)}} = \\left(a^{(i)} - y^{(i)}\\right)$, $\\frac{\\partial z^{(i)}}{ \\partial w_1} = x_1^{(i)}$, $\\frac{\\partial z^{(i)}}{ \\partial w_2} = x_2^{(i)}$ and $\\frac{\\partial z^{(i)}}{ \\partial b} = 1$. Then $(6)$ can be rewritten as:\n", + "\n", + "\\begin{align}\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial w_1 } &= \n", + "\\frac{1}{m}\\sum_{i=1}^{m} \\left(a^{(i)} - y^{(i)}\\right)x_1^{(i)},\\\\\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial w_2 } &= \n", + "\\frac{1}{m}\\sum_{i=1}^{m} \\left(a^{(i)} - y^{(i)}\\right)x_2^{(i)},\\tag{7}\\\\\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial b } &= \n", + "\\frac{1}{m}\\sum_{i=1}^{m} \\left(a^{(i)} - y^{(i)}\\right).\n", + "\\end{align}\n", + "\n", + "Note that the obtained expressions $(7)$ are exactly the same as in the section $3.2$ of the previous lab, when multiple linear regression model was discussed. Thus, they can be rewritten in a matrix form:\n", + "\n", + "\\begin{align}\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial W } &= \n", + "\\begin{bmatrix} \\frac{\\partial \\mathcal{L} }{ \\partial w_1 } & \n", + "\\frac{\\partial \\mathcal{L} }{ \\partial w_2 }\\end{bmatrix} = \\frac{1}{m}\\left(A - Y\\right)X^T,\\\\\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial b } &= \\frac{1}{m}\\left(A - Y\\right)\\mathbf{1}.\n", + "\\tag{8}\n", + "\\end{align}\n", + "\n", + "where $\\left(A - Y\\right)$ is an array of a shape ($1 \\times m$), $X^T$ is an array of a shape ($m \\times 2$) and $\\mathbf{1}$ is just a ($m \\times 1$) vector of ones.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then you can update the parameters:\n", + "\n", + "\\begin{align}\n", + "W &= W - \\alpha \\frac{\\partial \\mathcal{L} }{ \\partial W },\\\\\n", + "b &= b - \\alpha \\frac{\\partial \\mathcal{L} }{ \\partial b },\n", + "\\tag{9}\\end{align}\n", + "\n", + "where $\\alpha$ is the learning rate. Repeat the process in a loop until the cost function stops decreasing." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, the predictions for some example $x$ can be made taking the output $a$ and calculating $\\hat{y}$ as" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$\\hat{y} = \\begin{cases} 1 & \\mbox{if } a > 0.5 \\\\ 0 & \\mbox{otherwise } \\end{cases}\\tag{10}$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 2.2 - Dataset\n", + "\n", + "Let's get the dataset you will work on. The following code will create $m=30$ data points $(x_1, x_2)$, where $x_1, x_2 \\in \\{0,1\\}$ and save them in the `NumPy` array `X` of a shape $(2 \\times m)$ (in the columns of the array). The labels ($0$: blue, $1$: red) will be calculated so that $y = 1$ if $x_1 = 0$ and $x_2 = 1$, in the rest of the cases $y=0$. The labels will be saved in the array `Y` of a shape $(1 \\times m)$." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training dataset X containing (x1, x2) coordinates in the columns:\n", + "[[0 0 1 1 0 0 0 1 1 1 0 1 1 1 0 1 1 0 0 0 0 1 1 0 0 0 1 0 0 0]\n", + " [0 1 0 1 1 0 1 0 0 1 1 0 0 1 0 1 0 1 1 1 1 0 1 0 0 1 1 1 0 0]]\n", + "Training dataset Y containing labels of two classes (0: blue, 1: red)\n", + "[[0 1 0 0 1 0 1 0 0 0 1 0 0 0 0 0 0 1 1 1 1 0 0 0 0 1 0 1 0 0]]\n", + "The shape of X is: (2, 30)\n", + "The shape of Y is: (1, 30)\n", + "I have m = 30 training examples!\n" + ] + } + ], + "source": [ + "m = 30\n", + "\n", + "X = np.random.randint(0, 2, (2, m))\n", + "Y = np.logical_and(X[0] == 0, X[1] == 1).astype(int).reshape((1, m))\n", + "\n", + "print('Training dataset X containing (x1, x2) coordinates in the columns:')\n", + "print(X)\n", + "print('Training dataset Y containing labels of two classes (0: blue, 1: red)')\n", + "print(Y)\n", + "\n", + "print ('The shape of X is: ' + str(X.shape))\n", + "print ('The shape of Y is: ' + str(Y.shape))\n", + "print ('I have m = %d training examples!' % (X.shape[1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 2.3 - Define Activation Function\n", + "\n", + "The sigmoid function $(2)$ for a variable $z$ can be defined with the following code:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sigmoid(-2) = 0.11920292202211755\n", + "sigmoid(0) = 0.5\n", + "sigmoid(3.5) = 0.9706877692486436\n" + ] + } + ], + "source": [ + "def sigmoid(z):\n", + " return 1/(1 + np.exp(-z))\n", + " \n", + "print(\"sigmoid(-2) = \" + str(sigmoid(-2)))\n", + "print(\"sigmoid(0) = \" + str(sigmoid(0)))\n", + "print(\"sigmoid(3.5) = \" + str(sigmoid(3.5)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It can be applied to a `NumPy` array element by element:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.11920292 0.5 0.97068777]\n" + ] + } + ], + "source": [ + "print(sigmoid(np.array([-2, 0, 3.5])))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 3 - Implementation of the Neural Network Model\n", + "\n", + "Implementation of the described neural network will be very similar to the previous lab. The differences will be only in the functions `forward_propagation` and `compute_cost`!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.1 - Defining the Neural Network Structure" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define two variables:\n", + "- `n_x`: the size of the input layer\n", + "- `n_y`: the size of the output layer\n", + "\n", + "using shapes of arrays `X` and `Y`." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The size of the input layer is: n_x = 2\n", + "The size of the output layer is: n_y = 1\n" + ] + } + ], + "source": [ + "def layer_sizes(X, Y):\n", + " \"\"\"\n", + " Arguments:\n", + " X -- input dataset of shape (input size, number of examples)\n", + " Y -- labels of shape (output size, number of examples)\n", + " \n", + " Returns:\n", + " n_x -- the size of the input layer\n", + " n_y -- the size of the output layer\n", + " \"\"\"\n", + " n_x = X.shape[0]\n", + " n_y = Y.shape[0]\n", + " \n", + " return (n_x, n_y)\n", + "\n", + "(n_x, n_y) = layer_sizes(X, Y)\n", + "print(\"The size of the input layer is: n_x = \" + str(n_x))\n", + "print(\"The size of the output layer is: n_y = \" + str(n_y))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.2 - Initialize the Model's Parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Implement the function `initialize_parameters()`, initializing the weights array of shape $(n_y \\times n_x) = (1 \\times 1)$ with random values and the bias vector of shape $(n_y \\times 1) = (1 \\times 1)$ with zeros." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "W = [[-0.00768836 -0.00230031]]\n", + "b = [[0.]]\n" + ] + } + ], + "source": [ + "def initialize_parameters(n_x, n_y):\n", + " \"\"\"\n", + " Returns:\n", + " params -- python dictionary containing your parameters:\n", + " W -- weight matrix of shape (n_y, n_x)\n", + " b -- bias value set as a vector of shape (n_y, 1)\n", + " \"\"\"\n", + " \n", + " W = np.random.randn(n_y, n_x) * 0.01\n", + " b = np.zeros((n_y, 1))\n", + "\n", + " parameters = {\"W\": W,\n", + " \"b\": b}\n", + " \n", + " return parameters\n", + "\n", + "parameters = initialize_parameters(n_x, n_y)\n", + "print(\"W = \" + str(parameters[\"W\"]))\n", + "print(\"b = \" + str(parameters[\"b\"]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.3 - The Loop" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Implement `forward_propagation()` following the equation $(4)$ in the section [2.1](#2.1):\n", + "\\begin{align}\n", + "Z &= W X + b,\\\\\n", + "A &= \\sigma\\left(Z\\right).\n", + "\\end{align}" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Output vector A: [[0.17021412 0.84002926 0.00573233 0.12860739 0.84002926 0.17021412\n", + " 0.84002926 0.00573233 0.00573233 0.12860739 0.84002926 0.00573233\n", + " 0.00573233 0.12860739 0.17021412 0.12860739 0.00573233 0.84002926\n", + " 0.84002926 0.84002926 0.84002926 0.00573233 0.12860739 0.17021412\n", + " 0.17021412 0.84002926 0.12860739 0.84002926 0.17021412 0.17021412]]\n" + ] + } + ], + "source": [ + "def forward_propagation(X, parameters):\n", + " \"\"\"\n", + " Argument:\n", + " X -- input data of size (n_x, m)\n", + " parameters -- python dictionary containing your parameters (output of initialization function)\n", + " \n", + " Returns:\n", + " A -- The output\n", + " \"\"\"\n", + " W = parameters[\"W\"]\n", + " b = parameters[\"b\"]\n", + " \n", + " # Forward Propagation to calculate Z.\n", + " Z = np.matmul(W, X) + b\n", + " A = sigmoid(Z)\n", + "\n", + " return A\n", + "\n", + "A = forward_propagation(X, parameters)\n", + "\n", + "print(\"Output vector A:\", A)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Your weights were just initialized with some random values, so the model has not been trained yet. \n", + "\n", + "Define a cost function $(5)$ which will be used to train the model:\n", + "\n", + "$$\\mathcal{L}\\left(W, b\\right) = \\frac{1}{m}\\sum_{i=1}^{m} \\large\\left(\\small -y^{(i)}\\log\\left(a^{(i)}\\right) - (1-y^{(i)})\\log\\left(1- a^{(i)}\\right) \\large \\right) \\small.$$" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cost = 0.6916391611507907\n" + ] + } + ], + "source": [ + "def compute_cost(A, Y):\n", + " \"\"\"\n", + " Computes the log loss cost function\n", + " \n", + " Arguments:\n", + " A -- The output of the neural network of shape (n_y, number of examples)\n", + " Y -- \"true\" labels vector of shape (n_y, number of examples)\n", + " \n", + " Returns:\n", + " cost -- log loss\n", + " \n", + " \"\"\"\n", + " # Number of examples.\n", + " m = Y.shape[1]\n", + "\n", + " # Compute the cost function.\n", + " logprobs = - np.multiply(np.log(A),Y) - np.multiply(np.log(1 - A),1 - Y)\n", + " cost = 1/m * np.sum(logprobs)\n", + " \n", + " return cost\n", + "\n", + "print(\"cost = \" + str(compute_cost(A, Y)))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [ + "graded" + ] + }, + "source": [ + "Calculate partial derivatives as shown in $(8)$:\n", + "\n", + "\\begin{align}\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial W } &= \\frac{1}{m}\\left(A - Y\\right)X^T,\\\\\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial b } &= \\frac{1}{m}\\left(A - Y\\right)\\mathbf{1}.\n", + "\\end{align}" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dW = [[ 0.21571875 -0.06735779]]\n", + "db = [[0.16552706]]\n" + ] + } + ], + "source": [ + "def backward_propagation(A, X, Y):\n", + " \"\"\"\n", + " Implements the backward propagation, calculating gradients\n", + " \n", + " Arguments:\n", + " A -- the output of the neural network of shape (n_y, number of examples)\n", + " X -- input data of shape (n_x, number of examples)\n", + " Y -- \"true\" labels vector of shape (n_y, number of examples)\n", + " \n", + " Returns:\n", + " grads -- python dictionary containing gradients with respect to different parameters\n", + " \"\"\"\n", + " m = X.shape[1]\n", + " \n", + " # Backward propagation: calculate partial derivatives denoted as dW, db for simplicity. \n", + " dZ = A - Y\n", + " dW = 1/m * np.dot(dZ, X.T)\n", + " db = 1/m * np.sum(dZ, axis = 1, keepdims = True)\n", + " \n", + " grads = {\"dW\": dW,\n", + " \"db\": db}\n", + " \n", + " return grads\n", + "\n", + "grads = backward_propagation(A, X, Y)\n", + "\n", + "print(\"dW = \" + str(grads[\"dW\"]))\n", + "print(\"db = \" + str(grads[\"db\"]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Update parameters as shown in $(9)$:\n", + "\n", + "\\begin{align}\n", + "W &= W - \\alpha \\frac{\\partial \\mathcal{L} }{ \\partial W },\\\\\n", + "b &= b - \\alpha \\frac{\\partial \\mathcal{L} }{ \\partial b }.\\end{align}" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "W updated = [[-0.26655087 0.07852904]]\n", + "b updated = [[-0.19863247]]\n" + ] + } + ], + "source": [ + "def update_parameters(parameters, grads, learning_rate=1.2):\n", + " \"\"\"\n", + " Updates parameters using the gradient descent update rule\n", + " \n", + " Arguments:\n", + " parameters -- python dictionary containing parameters \n", + " grads -- python dictionary containing gradients \n", + " learning_rate -- learning rate parameter for gradient descent\n", + " \n", + " Returns:\n", + " parameters -- python dictionary containing updated parameters \n", + " \"\"\"\n", + " # Retrieve each parameter from the dictionary \"parameters\".\n", + " W = parameters[\"W\"]\n", + " b = parameters[\"b\"]\n", + " \n", + " # Retrieve each gradient from the dictionary \"grads\".\n", + " dW = grads[\"dW\"]\n", + " db = grads[\"db\"]\n", + " \n", + " # Update rule for each parameter.\n", + " W = W - learning_rate * dW\n", + " b = b - learning_rate * db\n", + " \n", + " parameters = {\"W\": W,\n", + " \"b\": b}\n", + " \n", + " return parameters\n", + "\n", + "parameters_updated = update_parameters(parameters, grads)\n", + "\n", + "print(\"W updated = \" + str(parameters_updated[\"W\"]))\n", + "print(\"b updated = \" + str(parameters_updated[\"b\"]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.4 - Integrate parts 3.1, 3.2 and 3.3 in nn_model() and make predictions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Build your neural network model in `nn_model()`." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [], + "source": [ + "def nn_model(X, Y, num_iterations=10, learning_rate=1.2, print_cost=False):\n", + " \"\"\"\n", + " Arguments:\n", + " X -- dataset of shape (n_x, number of examples)\n", + " Y -- labels of shape (n_y, number of examples)\n", + " num_iterations -- number of iterations in the loop\n", + " learning_rate -- learning rate parameter for gradient descent\n", + " print_cost -- if True, print the cost every iteration\n", + " \n", + " Returns:\n", + " parameters -- parameters learnt by the model. They can then be used to make predictions.\n", + " \"\"\"\n", + " \n", + " n_x = layer_sizes(X, Y)[0]\n", + " n_y = layer_sizes(X, Y)[1]\n", + " \n", + " parameters = initialize_parameters(n_x, n_y)\n", + " \n", + " # Loop\n", + " for i in range(0, num_iterations):\n", + " \n", + " # Forward propagation. Inputs: \"X, parameters\". Outputs: \"A\".\n", + " A = forward_propagation(X, parameters)\n", + " \n", + " # Cost function. Inputs: \"A, Y\". Outputs: \"cost\".\n", + " cost = compute_cost(A, Y)\n", + " \n", + " # Backpropagation. Inputs: \"A, X, Y\". Outputs: \"grads\".\n", + " grads = backward_propagation(A, X, Y)\n", + " \n", + " # Gradient descent parameter update. Inputs: \"parameters, grads, learning_rate\". Outputs: \"parameters\".\n", + " parameters = update_parameters(parameters, grads, learning_rate)\n", + " \n", + " # Print the cost every iteration.\n", + " if print_cost:\n", + " print (\"Cost after iteration %i: %f\" %(i, cost))\n", + "\n", + " return parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Z = [[0. 0.01976111 0.00745056 0.02721167 0.01976111 0.\n", + " 0.01976111 0.00745056 0.00745056 0.02721167 0.01976111 0.00745056\n", + " 0.00745056 0.02721167 0. 0.02721167 0.00745056 0.01976111\n", + " 0.01976111 0.01976111 0.01976111 0.00745056 0.02721167 0.\n", + " 0. 0.01976111 0.02721167 0.01976111 0. 0. ]]\n", + "Cost after iteration 0: 0.693480\n", + "Z = [[-0.20413018 -0.10797772 -0.45883376 -0.36268129 -0.10797772 -0.20413018\n", + " -0.10797772 -0.45883376 -0.45883376 -0.36268129 -0.10797772 -0.45883376\n", + " -0.45883376 -0.36268129 -0.20413018 -0.36268129 -0.45883376 -0.10797772\n", + " -0.10797772 -0.10797772 -0.10797772 -0.45883376 -0.36268129 -0.20413018\n", + " -0.20413018 -0.10797772 -0.36268129 -0.10797772 -0.20413018 -0.20413018]]\n", + "Cost after iteration 1: 0.608586\n", + "Z = [[-0.32601125 -0.11754606 -0.78762289 -0.57915769 -0.11754606 -0.32601125\n", + " -0.11754606 -0.78762289 -0.78762289 -0.57915769 -0.11754606 -0.78762289\n", + " -0.78762289 -0.57915769 -0.32601125 -0.57915769 -0.78762289 -0.11754606\n", + " -0.11754606 -0.11754606 -0.11754606 -0.78762289 -0.57915769 -0.32601125\n", + " -0.32601125 -0.11754606 -0.57915769 -0.11754606 -0.32601125 -0.32601125]]\n", + "Cost after iteration 2: 0.554475\n", + "Z = [[-0.40538992 -0.07137398 -1.04074211 -0.70672617 -0.07137398 -0.40538992\n", + " -0.07137398 -1.04074211 -1.04074211 -0.70672617 -0.07137398 -1.04074211\n", + " -1.04074211 -0.70672617 -0.40538992 -0.70672617 -1.04074211 -0.07137398\n", + " -0.07137398 -0.07137398 -0.07137398 -1.04074211 -0.70672617 -0.40538992\n", + " -0.40538992 -0.07137398 -0.70672617 -0.07137398 -0.40538992 -0.40538992]]\n", + "Cost after iteration 3: 0.513124\n", + "Z = [[-4.62619952e-01 -7.47072003e-04 -1.25033149e+00 -7.88458606e-01\n", + " -7.47072003e-04 -4.62619952e-01 -7.47072003e-04 -1.25033149e+00\n", + " -1.25033149e+00 -7.88458606e-01 -7.47072003e-04 -1.25033149e+00\n", + " -1.25033149e+00 -7.88458606e-01 -4.62619952e-01 -7.88458606e-01\n", + " -1.25033149e+00 -7.47072003e-04 -7.47072003e-04 -7.47072003e-04\n", + " -7.47072003e-04 -1.25033149e+00 -7.88458606e-01 -4.62619952e-01\n", + " -4.62619952e-01 -7.47072003e-04 -7.88458606e-01 -7.47072003e-04\n", + " -4.62619952e-01 -4.62619952e-01]]\n", + "Cost after iteration 4: 0.478828\n", + "Z = [[-0.50806721 0.07888044 -1.43311865 -0.846171 0.07888044 -0.50806721\n", + " 0.07888044 -1.43311865 -1.43311865 -0.846171 0.07888044 -1.43311865\n", + " -1.43311865 -0.846171 -0.50806721 -0.846171 -1.43311865 0.07888044\n", + " 0.07888044 0.07888044 0.07888044 -1.43311865 -0.846171 -0.50806721\n", + " -0.50806721 0.07888044 -0.846171 0.07888044 -0.50806721 -0.50806721]]\n", + "Cost after iteration 5: 0.449395\n", + "Z = [[-0.54712076 0.15988613 -1.59816071 -0.89115382 0.15988613 -0.54712076\n", + " 0.15988613 -1.59816071 -1.59816071 -0.89115382 0.15988613 -1.59816071\n", + " -1.59816071 -0.89115382 -0.54712076 -0.89115382 -1.59816071 0.15988613\n", + " 0.15988613 0.15988613 0.15988613 -1.59816071 -0.89115382 -0.54712076\n", + " -0.54712076 0.15988613 -0.89115382 0.15988613 -0.54712076 -0.54712076]]\n", + "Cost after iteration 6: 0.423719\n", + "Z = [[-0.58262065 0.23862238 -1.7505767 -0.92933368 0.23862238 -0.58262065\n", + " 0.23862238 -1.7505767 -1.7505767 -0.92933368 0.23862238 -1.7505767\n", + " -1.7505767 -0.92933368 -0.58262065 -0.92933368 -1.7505767 0.23862238\n", + " 0.23862238 0.23862238 0.23862238 -1.7505767 -0.92933368 -0.58262065\n", + " -0.58262065 0.23862238 -0.92933368 0.23862238 -0.58262065 -0.58262065]]\n", + "Cost after iteration 7: 0.401089\n", + "Z = [[-0.61606988 0.31348912 -1.89339316 -0.96383417 0.31348912 -0.61606988\n", + " 0.31348912 -1.89339316 -1.89339316 -0.96383417 0.31348912 -1.89339316\n", + " -1.89339316 -0.96383417 -0.61606988 -0.96383417 -1.89339316 0.31348912\n", + " 0.31348912 0.31348912 0.31348912 -1.89339316 -0.96383417 -0.61606988\n", + " -0.61606988 0.31348912 -0.96383417 0.31348912 -0.61606988 -0.61606988]]\n", + "Cost after iteration 8: 0.380986\n", + "Z = [[-0.64826072 0.38393691 -2.02849096 -0.99629332 0.38393691 -0.64826072\n", + " 0.38393691 -2.02849096 -2.02849096 -0.99629332 0.38393691 -2.02849096\n", + " -2.02849096 -0.99629332 -0.64826072 -0.99629332 -2.02849096 0.38393691\n", + " 0.38393691 0.38393691 0.38393691 -2.02849096 -0.99629332 -0.64826072\n", + " -0.64826072 0.38393691 -0.99629332 0.38393691 -0.64826072 -0.64826072]]\n", + "Cost after iteration 9: 0.363002\n", + "Z = [[-0.67960576 0.44994196 -2.15710527 -1.02755755 0.44994196 -0.67960576\n", + " 0.44994196 -2.15710527 -2.15710527 -1.02755755 0.44994196 -2.15710527\n", + " -2.15710527 -1.02755755 -0.67960576 -1.02755755 -2.15710527 0.44994196\n", + " 0.44994196 0.44994196 0.44994196 -2.15710527 -1.02755755 -0.67960576\n", + " -0.67960576 0.44994196 -1.02755755 0.44994196 -0.67960576 -0.67960576]]\n", + "Cost after iteration 10: 0.346813\n", + "Z = [[-0.71031499 0.51172866 -2.28009575 -1.0580521 0.51172866 -0.71031499\n", + " 0.51172866 -2.28009575 -2.28009575 -1.0580521 0.51172866 -2.28009575\n", + " -2.28009575 -1.0580521 -0.71031499 -1.0580521 -2.28009575 0.51172866\n", + " 0.51172866 0.51172866 0.51172866 -2.28009575 -1.0580521 -0.71031499\n", + " -0.71031499 0.51172866 -1.0580521 0.51172866 -0.71031499 -0.71031499]]\n", + "Cost after iteration 11: 0.332152\n", + "Z = [[-0.74049125 0.5696241 -2.39809543 -1.08798008 0.5696241 -0.74049125\n", + " 0.5696241 -2.39809543 -2.39809543 -1.08798008 0.5696241 -2.39809543\n", + " -2.39809543 -1.08798008 -0.74049125 -1.08798008 -2.39809543 0.5696241\n", + " 0.5696241 0.5696241 0.5696241 -2.39809543 -1.08798008 -0.74049125\n", + " -0.74049125 0.5696241 -1.08798008 0.5696241 -0.74049125 -0.74049125]]\n", + "Cost after iteration 12: 0.318805\n", + "Z = [[-0.77018168 0.62398338 -2.51159463 -1.11742957 0.62398338 -0.77018168\n", + " 0.62398338 -2.51159463 -2.51159463 -1.11742957 0.62398338 -2.51159463\n", + " -2.51159463 -1.11742957 -0.77018168 -1.11742957 -2.51159463 0.62398338\n", + " 0.62398338 0.62398338 0.62398338 -2.51159463 -1.11742957 -0.77018168\n", + " -0.77018168 0.62398338 -1.11742957 0.62398338 -0.77018168 -0.77018168]]\n", + "Cost after iteration 13: 0.306594\n", + "Z = [[-0.79940544 0.67515282 -2.62098942 -1.14643116 0.67515282 -0.79940544\n", + " 0.67515282 -2.62098942 -2.62098942 -1.14643116 0.67515282 -2.62098942\n", + " -2.62098942 -1.14643116 -0.79940544 -1.14643116 -2.62098942 0.67515282\n", + " 0.67515282 0.67515282 0.67515282 -2.62098942 -1.14643116 -0.79940544\n", + " -0.79940544 0.67515282 -1.14643116 0.67515282 -0.79940544 -0.79940544]]\n", + "Cost after iteration 14: 0.295369\n", + "Z = [[-0.8281685 0.72345339 -2.72661037 -1.17498848 0.72345339 -0.8281685\n", + " 0.72345339 -2.72661037 -2.72661037 -1.17498848 0.72345339 -2.72661037\n", + " -2.72661037 -1.17498848 -0.8281685 -1.17498848 -2.72661037 0.72345339\n", + " 0.72345339 0.72345339 0.72345339 -2.72661037 -1.17498848 -0.8281685\n", + " -0.8281685 0.72345339 -1.17498848 0.72345339 -0.8281685 -0.8281685 ]]\n", + "Cost after iteration 15: 0.285010\n", + "Z = [[-0.85647143 0.76917457 -2.82874034 -1.20309433 0.76917457 -0.85647143\n", + " 0.76917457 -2.82874034 -2.82874034 -1.20309433 0.76917457 -2.82874034\n", + " -2.82874034 -1.20309433 -0.85647143 -1.20309433 -2.82874034 0.76917457\n", + " 0.76917457 0.76917457 0.76917457 -2.82874034 -1.20309433 -0.85647143\n", + " -0.85647143 0.76917457 -1.20309433 0.76917457 -0.85647143 -0.85647143]]\n", + "Cost after iteration 16: 0.275412\n", + "Z = [[-0.88431339 0.81257364 -2.92762575 -1.23073872 0.81257364 -0.88431339\n", + " 0.81257364 -2.92762575 -2.92762575 -1.23073872 0.81257364 -2.92762575\n", + " -2.92762575 -1.23073872 -0.88431339 -1.23073872 -2.92762575 0.81257364\n", + " 0.81257364 0.81257364 0.81257364 -2.92762575 -1.23073872 -0.88431339\n", + " -0.88431339 0.81257364 -1.23073872 0.81257364 -0.88431339 -0.88431339]]\n", + "Cost after iteration 17: 0.266489\n", + "Z = [[-0.91169401 0.85387743 -3.02348421 -1.25791276 0.85387743 -0.91169401\n", + " 0.85387743 -3.02348421 -3.02348421 -1.25791276 0.85387743 -3.02348421\n", + " -3.02348421 -1.25791276 -0.91169401 -1.25791276 -3.02348421 0.85387743\n", + " 0.85387743 0.85387743 0.85387743 -3.02348421 -1.25791276 -0.91169401\n", + " -0.91169401 0.85387743 -1.25791276 0.85387743 -0.91169401 -0.91169401]]\n", + "Cost after iteration 18: 0.258167\n", + "Z = [[-0.93861424 0.89328524 -3.11650977 -1.28461029 0.89328524 -0.93861424\n", + " 0.89328524 -3.11650977 -3.11650977 -1.28461029 0.89328524 -3.11650977\n", + " -3.11650977 -1.28461029 -0.93861424 -1.28461029 -3.11650977 0.89328524\n", + " 0.89328524 0.89328524 0.89328524 -3.11650977 -1.28461029 -0.93861424\n", + " -0.93861424 0.89328524 -1.28461029 0.89328524 -0.93861424 -0.93861424]]\n", + "Cost after iteration 19: 0.250382\n", + "Z = [[-0.96507653 0.93097192 -3.2068768 -1.31082834 0.93097192 -0.96507653\n", + " 0.93097192 -3.2068768 -3.2068768 -1.31082834 0.93097192 -3.2068768\n", + " -3.2068768 -1.31082834 -0.96507653 -1.31082834 -3.2068768 0.93097192\n", + " 0.93097192 0.93097192 0.93097192 -3.2068768 -1.31082834 -0.96507653\n", + " -0.96507653 0.93097192 -1.31082834 0.93097192 -0.96507653 -0.96507653]]\n", + "Cost after iteration 20: 0.243080\n", + "Z = [[-0.99108488 0.96709102 -3.2947429 -1.336567 0.96709102 -0.99108488\n", + " 0.96709102 -3.2947429 -3.2947429 -1.336567 0.96709102 -3.2947429\n", + " -3.2947429 -1.336567 -0.99108488 -1.336567 -3.2947429 0.96709102\n", + " 0.96709102 0.96709102 0.96709102 -3.2947429 -1.336567 -0.99108488\n", + " -0.99108488 0.96709102 -1.336567 0.96709102 -0.99108488 -0.99108488]]\n", + "Cost after iteration 21: 0.236215\n", + "Z = [[-1.01664459 1.00177754 -3.38025121 -1.36182907 1.00177754 -1.01664459\n", + " 1.00177754 -3.38025121 -3.38025121 -1.36182907 1.00177754 -3.38025121\n", + " -3.38025121 -1.36182907 -1.01664459 -1.36182907 -3.38025121 1.00177754\n", + " 1.00177754 1.00177754 1.00177754 -3.38025121 -1.36182907 -1.01664459\n", + " -1.01664459 1.00177754 -1.36182907 1.00177754 -1.01664459 -1.01664459]]\n", + "Cost after iteration 22: 0.229745\n", + "Z = [[-1.0417621 1.0351505 -3.46353224 -1.38661963 1.0351505 -1.0417621\n", + " 1.0351505 -3.46353224 -3.46353224 -1.38661963 1.0351505 -3.46353224\n", + " -3.46353224 -1.38661963 -1.0417621 -1.38661963 -3.46353224 1.0351505\n", + " 1.0351505 1.0351505 1.0351505 -3.46353224 -1.38661963 -1.0417621\n", + " -1.0417621 1.0351505 -1.38661963 1.0351505 -1.0417621 -1.0417621 ]]\n", + "Cost after iteration 23: 0.223634\n", + "Z = [[-1.06644473 1.06731508 -3.54470538 -1.41094557 1.06731508 -1.06644473\n", + " 1.06731508 -3.54470538 -3.54470538 -1.41094557 1.06731508 -3.54470538\n", + " -3.54470538 -1.41094557 -1.06644473 -1.41094557 -3.54470538 1.06731508\n", + " 1.06731508 1.06731508 1.06731508 -3.54470538 -1.41094557 -1.06644473\n", + " -1.06644473 1.06731508 -1.41094557 1.06731508 -1.06644473 -1.06644473]]\n", + "Cost after iteration 24: 0.217853\n", + "Z = [[-1.09070052 1.09836451 -3.62388021 -1.43481518 1.09836451 -1.09070052\n", + " 1.09836451 -3.62388021 -3.62388021 -1.43481518 1.09836451 -3.62388021\n", + " -3.62388021 -1.43481518 -1.09070052 -1.43481518 -3.62388021 1.09836451\n", + " 1.09836451 1.09836451 1.09836451 -3.62388021 -1.43481518 -1.09070052\n", + " -1.09070052 1.09836451 -1.43481518 1.09836451 -1.09070052 -1.09070052]]\n", + "Cost after iteration 25: 0.212372\n", + "Z = [[-1.114538 1.12838172 -3.70115757 -1.45823785 1.12838172 -1.114538\n", + " 1.12838172 -3.70115757 -3.70115757 -1.45823785 1.12838172 -3.70115757\n", + " -3.70115757 -1.45823785 -1.114538 -1.45823785 -3.70115757 1.12838172\n", + " 1.12838172 1.12838172 1.12838172 -3.70115757 -1.45823785 -1.114538\n", + " -1.114538 1.12838172 -1.45823785 1.12838172 -1.114538 -1.114538 ]]\n", + "Cost after iteration 26: 0.207168\n", + "Z = [[-1.1379661 1.15744069 -3.77663049 -1.4812237 1.15744069 -1.1379661\n", + " 1.15744069 -3.77663049 -3.77663049 -1.4812237 1.15744069 -3.77663049\n", + " -3.77663049 -1.4812237 -1.1379661 -1.4812237 -3.77663049 1.15744069\n", + " 1.15744069 1.15744069 1.15744069 -3.77663049 -1.4812237 -1.1379661\n", + " -1.1379661 1.15744069 -1.4812237 1.15744069 -1.1379661 -1.1379661 ]]\n", + "Cost after iteration 27: 0.202219\n", + "Z = [[-1.16099398 1.18560763 -3.85038498 -1.50378337 1.18560763 -1.16099398\n", + " 1.18560763 -3.85038498 -3.85038498 -1.50378337 1.18560763 -3.85038498\n", + " -3.85038498 -1.50378337 -1.16099398 -1.50378337 -3.85038498 1.18560763\n", + " 1.18560763 1.18560763 1.18560763 -3.85038498 -1.50378337 -1.16099398\n", + " -1.16099398 1.18560763 -1.50378337 1.18560763 -1.16099398 -1.16099398]]\n", + "Cost after iteration 28: 0.197505\n", + "Z = [[-1.18363093 1.21294199 -3.92250077 -1.52592785 1.21294199 -1.18363093\n", + " 1.21294199 -3.92250077 -3.92250077 -1.52592785 1.21294199 -3.92250077\n", + " -3.92250077 -1.52592785 -1.18363093 -1.52592785 -3.92250077 1.21294199\n", + " 1.21294199 1.21294199 1.21294199 -3.92250077 -1.52592785 -1.18363093\n", + " -1.18363093 1.21294199 -1.52592785 1.21294199 -1.18363093 -1.18363093]]\n", + "Cost after iteration 29: 0.193009\n", + "Z = [[-1.2058863 1.23949732 -3.9930519 -1.54766828 1.23949732 -1.2058863\n", + " 1.23949732 -3.9930519 -3.9930519 -1.54766828 1.23949732 -3.9930519\n", + " -3.9930519 -1.54766828 -1.2058863 -1.54766828 -3.9930519 1.23949732\n", + " 1.23949732 1.23949732 1.23949732 -3.9930519 -1.54766828 -1.2058863\n", + " -1.2058863 1.23949732 -1.54766828 1.23949732 -1.2058863 -1.2058863 ]]\n", + "Cost after iteration 30: 0.188716\n", + "Z = [[-1.22776944 1.26532199 -4.06210724 -1.56901581 1.26532199 -1.22776944\n", + " 1.26532199 -4.06210724 -4.06210724 -1.56901581 1.26532199 -4.06210724\n", + " -4.06210724 -1.56901581 -1.22776944 -1.56901581 -4.06210724 1.26532199\n", + " 1.26532199 1.26532199 1.26532199 -4.06210724 -1.56901581 -1.22776944\n", + " -1.22776944 1.26532199 -1.56901581 1.26532199 -1.22776944 -1.22776944]]\n", + "Cost after iteration 31: 0.184611\n", + "Z = [[-1.2492896 1.29045985 -4.12973102 -1.58998157 1.29045985 -1.2492896\n", + " 1.29045985 -4.12973102 -4.12973102 -1.58998157 1.29045985 -4.12973102\n", + " -4.12973102 -1.58998157 -1.2492896 -1.58998157 -4.12973102 1.29045985\n", + " 1.29045985 1.29045985 1.29045985 -4.12973102 -1.58998157 -1.2492896\n", + " -1.2492896 1.29045985 -1.58998157 1.29045985 -1.2492896 -1.2492896 ]]\n", + "Cost after iteration 32: 0.180682\n", + "Z = [[-1.27045594 1.31495075 -4.19598322 -1.61057653 1.31495075 -1.27045594\n", + " 1.31495075 -4.19598322 -4.19598322 -1.61057653 1.31495075 -4.19598322\n", + " -4.19598322 -1.61057653 -1.27045594 -1.61057653 -4.19598322 1.31495075\n", + " 1.31495075 1.31495075 1.31495075 -4.19598322 -1.61057653 -1.27045594\n", + " -1.27045594 1.31495075 -1.61057653 1.31495075 -1.27045594 -1.27045594]]\n", + "Cost after iteration 33: 0.176917\n", + "Z = [[-1.29127748 1.33883098 -4.26091995 -1.63081149 1.33883098 -1.29127748\n", + " 1.33883098 -4.26091995 -4.26091995 -1.63081149 1.33883098 -4.26091995\n", + " -4.26091995 -1.63081149 -1.29127748 -1.63081149 -4.26091995 1.33883098\n", + " 1.33883098 1.33883098 1.33883098 -4.26091995 -1.63081149 -1.29127748\n", + " -1.29127748 1.33883098 -1.63081149 1.33883098 -1.29127748 -1.29127748]]\n", + "Cost after iteration 34: 0.173306\n", + "Z = [[-1.31176305 1.36213374 -4.32459379 -1.65069699 1.36213374 -1.31176305\n", + " 1.36213374 -4.32459379 -4.32459379 -1.65069699 1.36213374 -4.32459379\n", + " -4.32459379 -1.65069699 -1.31176305 -1.65069699 -4.32459379 1.36213374\n", + " 1.36213374 1.36213374 1.36213374 -4.32459379 -1.65069699 -1.31176305\n", + " -1.31176305 1.36213374 -1.65069699 1.36213374 -1.31176305 -1.31176305]]\n", + "Cost after iteration 35: 0.169839\n", + "Z = [[-1.33192132 1.38488942 -4.38705407 -1.67024332 1.38488942 -1.33192132\n", + " 1.38488942 -4.38705407 -4.38705407 -1.67024332 1.38488942 -4.38705407\n", + " -4.38705407 -1.67024332 -1.33192132 -1.67024332 -4.38705407 1.38488942\n", + " 1.38488942 1.38488942 1.38488942 -4.38705407 -1.67024332 -1.33192132\n", + " -1.33192132 1.38488942 -1.67024332 1.38488942 -1.33192132 -1.33192132]]\n", + "Cost after iteration 36: 0.166507\n", + "Z = [[-1.35176074 1.40712594 -4.44834717 -1.68946049 1.40712594 -1.35176074\n", + " 1.40712594 -4.44834717 -4.44834717 -1.68946049 1.40712594 -4.44834717\n", + " -4.44834717 -1.68946049 -1.35176074 -1.68946049 -4.44834717 1.40712594\n", + " 1.40712594 1.40712594 1.40712594 -4.44834717 -1.68946049 -1.35176074\n", + " -1.35176074 1.40712594 -1.68946049 1.40712594 -1.35176074 -1.35176074]]\n", + "Cost after iteration 37: 0.163303\n", + "Z = [[-1.37128955 1.42886901 -4.50851674 -1.70835819 1.42886901 -1.37128955\n", + " 1.42886901 -4.50851674 -4.50851674 -1.70835819 1.42886901 -4.50851674\n", + " -4.50851674 -1.70835819 -1.37128955 -1.70835819 -4.50851674 1.42886901\n", + " 1.42886901 1.42886901 1.42886901 -4.50851674 -1.70835819 -1.37128955\n", + " -1.37128955 1.42886901 -1.70835819 1.42886901 -1.37128955 -1.37128955]]\n", + "Cost after iteration 38: 0.160218\n", + "Z = [[-1.39051577 1.45014234 -4.56760393 -1.72694582 1.45014234 -1.39051577\n", + " 1.45014234 -4.56760393 -4.56760393 -1.72694582 1.45014234 -4.56760393\n", + " -4.56760393 -1.72694582 -1.39051577 -1.72694582 -4.56760393 1.45014234\n", + " 1.45014234 1.45014234 1.45014234 -4.56760393 -1.72694582 -1.39051577\n", + " -1.39051577 1.45014234 -1.72694582 1.45014234 -1.39051577 -1.39051577]]\n", + "Cost after iteration 39: 0.157246\n", + "Z = [[-1.40944722 1.47096788 -4.62564757 -1.74523247 1.47096788 -1.40944722\n", + " 1.47096788 -4.62564757 -4.62564757 -1.74523247 1.47096788 -4.62564757\n", + " -4.62564757 -1.74523247 -1.40944722 -1.74523247 -4.62564757 1.47096788\n", + " 1.47096788 1.47096788 1.47096788 -4.62564757 -1.74523247 -1.40944722\n", + " -1.40944722 1.47096788 -1.74523247 1.47096788 -1.40944722 -1.40944722]]\n", + "Cost after iteration 40: 0.154382\n", + "Z = [[-1.42809147 1.49136596 -4.68268434 -1.76322691 1.49136596 -1.42809147\n", + " 1.49136596 -4.68268434 -4.68268434 -1.76322691 1.49136596 -4.68268434\n", + " -4.68268434 -1.76322691 -1.42809147 -1.76322691 -4.68268434 1.49136596\n", + " 1.49136596 1.49136596 1.49136596 -4.68268434 -1.76322691 -1.42809147\n", + " -1.42809147 1.49136596 -1.76322691 1.49136596 -1.42809147 -1.42809147]]\n", + "Cost after iteration 41: 0.151618\n", + "Z = [[-1.44645589 1.51135546 -4.73874896 -1.78093761 1.51135546 -1.44645589\n", + " 1.51135546 -4.73874896 -4.73874896 -1.78093761 1.51135546 -4.73874896\n", + " -4.73874896 -1.78093761 -1.44645589 -1.78093761 -4.73874896 1.51135546\n", + " 1.51135546 1.51135546 1.51135546 -4.73874896 -1.78093761 -1.44645589\n", + " -1.44645589 1.51135546 -1.78093761 1.51135546 -1.44645589 -1.44645589]]\n", + "Cost after iteration 42: 0.148950\n", + "Z = [[-1.46454763 1.53095394 -4.79387431 -1.79837274 1.53095394 -1.46454763\n", + " 1.53095394 -4.79387431 -4.79387431 -1.79837274 1.53095394 -4.79387431\n", + " -4.79387431 -1.79837274 -1.46454763 -1.79837274 -4.79387431 1.53095394\n", + " 1.53095394 1.53095394 1.53095394 -4.79387431 -1.79837274 -1.46454763\n", + " -1.46454763 1.53095394 -1.79837274 1.53095394 -1.46454763 -1.46454763]]\n", + "Cost after iteration 43: 0.146373\n", + "Z = [[-1.48237361 1.5501778 -4.84809156 -1.81554015 1.5501778 -1.48237361\n", + " 1.5501778 -4.84809156 -4.84809156 -1.81554015 1.5501778 -4.84809156\n", + " -4.84809156 -1.81554015 -1.48237361 -1.81554015 -4.84809156 1.5501778\n", + " 1.5501778 1.5501778 1.5501778 -4.84809156 -1.81554015 -1.48237361\n", + " -1.48237361 1.5501778 -1.81554015 1.5501778 -1.48237361 -1.48237361]]\n", + "Cost after iteration 44: 0.143881\n", + "Z = [[-1.49994056 1.56904232 -4.90143032 -1.83244744 1.56904232 -1.49994056\n", + " 1.56904232 -4.90143032 -4.90143032 -1.83244744 1.56904232 -4.90143032\n", + " -4.90143032 -1.83244744 -1.49994056 -1.83244744 -4.90143032 1.56904232\n", + " 1.56904232 1.56904232 1.56904232 -4.90143032 -1.83244744 -1.49994056\n", + " -1.49994056 1.56904232 -1.83244744 1.56904232 -1.49994056 -1.49994056]]\n", + "Cost after iteration 45: 0.141471\n", + "Z = [[-1.51725497 1.58756182 -4.9539187 -1.84910192 1.58756182 -1.51725497\n", + " 1.58756182 -4.9539187 -4.9539187 -1.84910192 1.58756182 -4.9539187\n", + " -4.9539187 -1.84910192 -1.51725497 -1.84910192 -4.9539187 1.58756182\n", + " 1.58756182 1.58756182 1.58756182 -4.9539187 -1.84910192 -1.51725497\n", + " -1.51725497 1.58756182 -1.84910192 1.58756182 -1.51725497 -1.51725497]]\n", + "Cost after iteration 46: 0.139139\n", + "Z = [[-1.53432316 1.6057497 -5.00558346 -1.8655106 1.6057497 -1.53432316\n", + " 1.6057497 -5.00558346 -5.00558346 -1.8655106 1.6057497 -5.00558346\n", + " -5.00558346 -1.8655106 -1.53432316 -1.8655106 -5.00558346 1.6057497\n", + " 1.6057497 1.6057497 1.6057497 -5.00558346 -1.8655106 -1.53432316\n", + " -1.53432316 1.6057497 -1.8655106 1.6057497 -1.53432316 -1.53432316]]\n", + "Cost after iteration 47: 0.136881\n", + "Z = [[-1.55115123 1.62361856 -5.05645006 -1.88168026 1.62361856 -1.55115123\n", + " 1.62361856 -5.05645006 -5.05645006 -1.88168026 1.62361856 -5.05645006\n", + " -5.05645006 -1.88168026 -1.55115123 -1.88168026 -5.05645006 1.62361856\n", + " 1.62361856 1.62361856 1.62361856 -5.05645006 -1.88168026 -1.55115123\n", + " -1.55115123 1.62361856 -1.88168026 1.62361856 -1.55115123 -1.55115123]]\n", + "Cost after iteration 48: 0.134694\n", + "Z = [[-1.56774511 1.64118022 -5.10654276 -1.89761744 1.64118022 -1.56774511\n", + " 1.64118022 -5.10654276 -5.10654276 -1.89761744 1.64118022 -5.10654276\n", + " -5.10654276 -1.89761744 -1.56774511 -1.89761744 -5.10654276 1.64118022\n", + " 1.64118022 1.64118022 1.64118022 -5.10654276 -1.89761744 -1.56774511\n", + " -1.56774511 1.64118022 -1.89761744 1.64118022 -1.56774511 -1.56774511]]\n", + "Cost after iteration 49: 0.132574\n", + "W = [[-3.57177421 3.24255633]]\n", + "b = [[-1.58411051]]\n" + ] + } + ], + "source": [ + "parameters = nn_model(X, Y, num_iterations=50, learning_rate=1.2, print_cost=True)\n", + "print(\"W = \" + str(parameters[\"W\"]))\n", + "print(\"b = \" + str(parameters[\"b\"]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can see that after about $40$ iterations the cost function does keep decreasing, but not as much. It is a sign that it might be reasonable to stop training there. The final model parameters can be used to find the boundary line and for making predictions. Let's visualize the boundary line." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_decision_boundary(X, Y, parameters):\n", + " W = parameters[\"W\"]\n", + " b = parameters[\"b\"]\n", + "\n", + " fig, ax = plt.subplots()\n", + " plt.scatter(X[0, :], X[1, :], c=Y, cmap=colors.ListedColormap(['blue', 'red']));\n", + " \n", + " x_line = np.arange(np.min(X[0,:]),np.max(X[0,:])*1.1, 0.1)\n", + " ax.plot(x_line, - W[0,0] / W[0,1] * x_line + -b[0,0] / W[0,1] , color=\"black\")\n", + " plt.plot()\n", + " plt.show()\n", + " \n", + "plot_decision_boundary(X, Y, parameters)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And make some predictions:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Z = [[-5.15588472 -1.91332839 -1.58411051 1.65844582]]\n", + "Coordinates (in the columns):\n", + "[[1 1 0 0]\n", + " [0 1 0 1]]\n", + "Predictions:\n", + "[[False False False True]]\n" + ] + } + ], + "source": [ + "def predict(X, parameters):\n", + " \"\"\"\n", + " Using the learned parameters, predicts a class for each example in X\n", + " \n", + " Arguments:\n", + " parameters -- python dictionary containing your parameters \n", + " X -- input data of size (n_x, m)\n", + " \n", + " Returns\n", + " predictions -- vector of predictions of our model (blue: False / red: True)\n", + " \"\"\"\n", + " \n", + " # Computes probabilities using forward propagation, and classifies to 0/1 using 0.5 as the threshold.\n", + " A = forward_propagation(X, parameters)\n", + " predictions = A > 0.5\n", + " \n", + " return predictions\n", + "\n", + "X_pred = np.array([[1, 1, 0, 0],\n", + " [0, 1, 0, 1]])\n", + "Y_pred = predict(X_pred, parameters)\n", + "\n", + "print(f\"Coordinates (in the columns):\\n{X_pred}\")\n", + "print(f\"Predictions:\\n{Y_pred}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pretty good for such a simple neural network!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 4 - Performance on a Larger Dataset\n", + "\n", + "Construct a larger and more complex dataset with the function `make_blobs` from the `sklearn.datasets` library:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Dataset\n", + "n_samples = 1000\n", + "samples, labels = make_blobs(n_samples=n_samples, \n", + " centers=([2.5, 3], [6.7, 7.9]), \n", + " cluster_std=1.4,\n", + " random_state=0)\n", + "\n", + "X_larger = np.transpose(samples)\n", + "Y_larger = labels.reshape((1,n_samples))\n", + "\n", + "plt.scatter(X_larger[0, :], X_larger[1, :], c=Y_larger, cmap=colors.ListedColormap(['blue', 'red']));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And train your neural network for $100$ iterations." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "W = [[1.01643208 1.13651775]]\n", + "b = [[-10.65346577]]\n" + ] + } + ], + "source": [ + "parameters_larger = nn_model(X_larger, Y_larger, num_iterations=100, learning_rate=1.2, print_cost=False)\n", + "print(\"W = \" + str(parameters_larger[\"W\"]))\n", + "print(\"b = \" + str(parameters_larger[\"b\"]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the decision boundary:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_decision_boundary(X_larger, Y_larger, parameters_larger)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Try to change values of the parameters `num_iterations` and `learning_rate` and see if the results will be different." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Congrats on finishing the lab!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "name": "C1_W1_Assignment_Solution.ipynb", + "provenance": [] + }, + "coursera": { + "schema_names": [ + "AI4MC1-1" + ] + }, + "grader_version": "1", + "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.8.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/math/calculus-for-ml/nn_two_layers.ipynb b/math/calculus-for-ml/nn_two_layers.ipynb new file mode 100644 index 0000000..b159cbd --- /dev/null +++ b/math/calculus-for-ml/nn_two_layers.ipynb @@ -0,0 +1,4908 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "EAt-K2qgcIou" + }, + "source": [ + "# Neural Network with Two Layers\n", + "\n", + "Welcome to your week three programming assignment. You are ready to build a neural network with two layers and train it to solve a classification problem. \n", + "\n", + "**After this assignment, you will be able to:**\n", + "\n", + "- Implement a neural network with two layers to a classification problem\n", + "- Implement forward propagation using matrix multiplication\n", + "- Perform backward propagation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Table of Contents\n", + "\n", + "- [ 1 - Classification Problem](#1)\n", + "- [ 2 - Neural Network Model with Two Layers](#2)\n", + " - [ 2.1 - Neural Network Model with Two Layers for a Single Training Example](#2.1)\n", + " - [ 2.2 - Neural Network Model with Two Layers for Multiple Training Examples](#2.2)\n", + " - [ 2.3 - Cost Function and Training](#2.3)\n", + " - [ 2.4 - Dataset](#2.4)\n", + " - [ 2.5 - Define Activation Function](#2.5)\n", + " - [ Exercise 1](#ex01)\n", + "- [ 3 - Implementation of the Neural Network Model with Two Layers](#3)\n", + " - [ 3.1 - Defining the Neural Network Structure](#3.1)\n", + " - [ Exercise 2](#ex02)\n", + " - [ 3.2 - Initialize the Model's Parameters](#3.2)\n", + " - [ Exercise 3](#ex03)\n", + " - [ 3.3 - The Loop](#3.3)\n", + " - [ Exercise 4](#ex04)\n", + " - [ Exercise 5](#ex05)\n", + " - [ Exercise 6](#ex06)\n", + " - [ 3.4 - Integrate parts 3.1, 3.2 and 3.3 in nn_model()](#3.4)\n", + " - [ Exercise 7](#ex07)\n", + " - [ Exercise 8](#ex08)\n", + "- [ 4 - Optional: Other Dataset](#4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Packages\n", + "\n", + "First, import all the packages you will need during this assignment." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import colors\n", + "# A function to create a dataset.\n", + "from sklearn.datasets import make_blobs\n", + "\n", + "# Output of plotting commands is displayed inline within the Jupyter notebook.\n", + "%matplotlib inline \n", + "\n", + "# Set a seed so that the results are consistent.\n", + "np.random.seed(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Load the unit tests defined for this notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import w3_unittest" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 1 - Classification Problem" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In one of the labs this week, you trained a neural network with a single perceptron, performing forward and backward propagation. That simple structure was enough to solve a \"linear\" classification problem - finding a straight line in a plane that would serve as a decision boundary to separate two classes.\n", + "\n", + "Imagine that now you have a more complicated problem: you still have two classes, but one line will not be enough to separate them." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "xmin, xmax = -0.2, 1.4\n", + "x_line = np.arange(xmin, xmax, 0.1)\n", + "# Data points (observations) from two classes.\n", + "ax.scatter(0, 0, color=\"r\")\n", + "ax.scatter(0, 1, color=\"b\")\n", + "ax.scatter(1, 0, color=\"b\")\n", + "ax.scatter(1, 1, color=\"r\")\n", + "ax.set_xlim([xmin, xmax])\n", + "ax.set_ylim([-0.1, 1.1])\n", + "ax.set_xlabel('$x_1$')\n", + "ax.set_ylabel('$x_2$')\n", + "# Example of the lines which can be used as a decision boundary to separate two classes.\n", + "ax.plot(x_line, -1 * x_line + 1.5, color=\"black\")\n", + "ax.plot(x_line, -1 * x_line + 0.5, color=\"black\")\n", + "plt.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This logic can appear in many applications. For example, if you train a model to predict whether you should buy a house knowing its size and the year it was built. A big new house will not be affordable, while a small old house will not be worth buying. So, you might be interested in either a big old house, or a small new house.\n", + "\n", + "The one perceptron neural network is not enough to solve such classification problem. Let's look at how you can adjust that model to find the solution.\n", + "\n", + "In the plot above, two lines can serve as a decision boundary. Your intuition might tell you that you should also increase the number of perceptrons. And that is absolutely right! You need to feed your data points (coordinates $x_1$, $x_2$) into two nodes separately and then unify them somehow with another one to make a decision. \n", + "\n", + "Now let's figure out the details, build and train your first multi-layer neural network!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 2 - Neural Network Model with Two Layers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 2.1 - Neural Network Model with Two Layers for a Single Training Example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The input and output layers of the neural network are the same as for one perceptron model, but there is a **hidden layer** now in between them. The training examples $x^{(i)}=\\begin{bmatrix}x_1^{(i)} \\\\ x_2^{(i)}\\end{bmatrix}$ from the input layer of size $n_x = 2$ are first fed into the hidden layer of size $n_h = 2$. They are simultaneously fed into the first perceptron with weights $W_1^{[1]}=\\begin{bmatrix}w_{1,1}^{[1]} & w_{2,1}^{[1]}\\end{bmatrix}$, bias $b_1^{[1]}$; and into the second perceptron with weights $W_2^{[1]}=\\begin{bmatrix}w_{1,2}^{[1]} & w_{2,2}^{[1]}\\end{bmatrix}$, bias $b_2^{[1]}$. The integer in the square brackets $^{[1]}$ denotes the layer number, because there are two layers now with their own parameters and outputs, which need to be distinguished. \n", + "\n", + "\\begin{align}\n", + "z_1^{[1](i)} &= w_{1,1}^{[1]} x_1^{(i)} + w_{2,1}^{[1]} x_2^{(i)} + b_1^{[1]} = W_1^{[1]}x^{(i)} + b_1^{[1]},\\\\\n", + "z_2^{[1](i)} &= w_{1,2}^{[1]} x_1^{(i)} + w_{2,2}^{[1]} x_2^{(i)} + b_2^{[1]} = W_2^{[1]}x^{(i)} + b_2^{[1]}.\\tag{1}\n", + "\\end{align}\n", + "\n", + "These expressions for one training example $x^{(i)}$ can be rewritten in a matrix form :\n", + "\n", + "$$z^{[1](i)} = W^{[1]} x^{(i)} + b^{[1]},\\tag{2}$$\n", + "\n", + "where \n", + "\n", + "    $z^{[1](i)} = \\begin{bmatrix}z_1^{[1](i)} \\\\ z_2^{[1](i)}\\end{bmatrix}$ is vector of size $\\left(n_h \\times 1\\right) = \\left(2 \\times 1\\right)$; \n", + "\n", + "    $W^{[1]} = \\begin{bmatrix}W_1^{[1]} \\\\ W_2^{[1]}\\end{bmatrix} = \n", + "\\begin{bmatrix}w_{1,1}^{[1]} & w_{2,1}^{[1]} \\\\ w_{1,2}^{[1]} & w_{2,2}^{[1]}\\end{bmatrix}$ is matrix of size $\\left(n_h \\times n_x\\right) = \\left(2 \\times 2\\right)$;\n", + "\n", + "    $b^{[1]} = \\begin{bmatrix}b_1^{[1]} \\\\ b_2^{[1]}\\end{bmatrix}$ is vector of size $\\left(n_h \\times 1\\right) = \\left(2 \\times 1\\right)$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, the hidden layer activation function needs to be applied for each of the elements in the vector $z^{[1](i)}$. Various activation functions can be used here and in this model you will take the sigmoid function $\\sigma\\left(x\\right) = \\frac{1}{1 + e^{-x}}$. Remember that its derivative is $\\frac{d\\sigma}{dx} = \\sigma\\left(x\\right)\\left(1-\\sigma\\left(x\\right)\\right)$. The output of the hidden layer is a vector of size $\\left(n_h \\times 1\\right) = \\left(2 \\times 1\\right)$:\n", + "\n", + "$$a^{[1](i)} = \\sigma\\left(z^{[1](i)}\\right) = \n", + "\\begin{bmatrix}\\sigma\\left(z_1^{[1](i)}\\right) \\\\ \\sigma\\left(z_2^{[1](i)}\\right)\\end{bmatrix}.\\tag{3}$$\n", + "\n", + "Then the hidden layer output gets fed into the output layer of size $n_y = 1$. This was covered in the previous lab, the only difference are: $a^{[1](i)}$ is taken instead of $x^{(i)}$ and layer notation $^{[2]}$ appears to identify all parameters and outputs:\n", + "\n", + "$$z^{[2](i)} = w_1^{[2]} a_1^{[1](i)} + w_2^{[2]} a_2^{[1](i)} + b^{[2]}= W^{[2]} a^{[1](i)} + b^{[2]},\\tag{4}$$\n", + "\n", + "    $z^{[2](i)}$ and $b^{[2]}$ are scalars for this model, as $\\left(n_y \\times 1\\right) = \\left(1 \\times 1\\right)$; \n", + "\n", + "    $W^{[2]} = \\begin{bmatrix}w_1^{[2]} & w_2^{[2]}\\end{bmatrix}$ is vector of size $\\left(n_y \\times n_h\\right) = \\left(1 \\times 2\\right)$.\n", + "\n", + "Finally, the same sigmoid function is used as the output layer activation function:\n", + "\n", + "$$a^{[2](i)} = \\sigma\\left(z^{[2](i)}\\right).\\tag{5}$$\n", + "\n", + "Mathematically the two layer neural network model for each training example $x^{(i)}$ can be written with the expressions $(2) - (5)$. Let's rewrite them next to each other for convenience:\n", + "\n", + "\\begin{align}\n", + "z^{[1](i)} &= W^{[1]} x^{(i)} + b^{[1]},\\\\\n", + "a^{[1](i)} &= \\sigma\\left(z^{[1](i)}\\right),\\\\\n", + "z^{[2](i)} &= W^{[2]} a^{[1](i)} + b^{[2]},\\\\\n", + "a^{[2](i)} &= \\sigma\\left(z^{[2](i)}\\right).\\\\\n", + "\\tag{6}\n", + "\\end{align}\n", + "\n", + "Note, that all of the parameters to be trained in the model are without $^{(i)}$ index - they are independent on the input data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, the predictions for some example $x^{(i)}$ can be made taking the output $a^{[2](i)}$ and calculating $\\hat{y}$ as: $\\hat{y} = \\begin{cases} 1 & \\mbox{if } a^{[2](i)} > 0.5, \\\\ 0 & \\mbox{otherwise }. \\end{cases}$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 2.2 - Neural Network Model with Two Layers for Multiple Training Examples" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similarly to the single perceptron model, $m$ training examples can be organised in a matrix $X$ of a shape ($2 \\times m$), putting $x^{(i)}$ into columns. Then the model $(6)$ can be rewritten in terms of matrix multiplications:\n", + "\n", + "\\begin{align}\n", + "Z^{[1]} &= W^{[1]} X + b^{[1]},\\\\\n", + "A^{[1]} &= \\sigma\\left(Z^{[1]}\\right),\\\\\n", + "Z^{[2]} &= W^{[2]} A^{[1]} + b^{[2]},\\\\\n", + "A^{[2]} &= \\sigma\\left(Z^{[2]}\\right),\\\\\n", + "\\tag{7}\n", + "\\end{align}\n", + "\n", + "where $b^{[1]}$ is broadcasted to the matrix of size $\\left(n_h \\times m\\right) = \\left(2 \\times m\\right)$ and $b^{[2]}$ to the vector of size $\\left(n_y \\times m\\right) = \\left(1 \\times m\\right)$. It would be a good exercise for you to have a look at the expressions $(7)$ and check that sizes of the matrices will actually match to perform required multiplications.\n", + "\n", + "You have derived expressions to perform forward propagation. Time to evaluate your model and train it." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 2.3 - Cost Function and Training" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the evaluation of this simple neural network you can use the same cost function as for the single perceptron case - log loss function. Originally initialized weights were just some random values, now you need to perform training of the model: find such set of parameters $W^{[1]}$, $b^{[1]}$, $W^{[2]}$, $b^{[2]}$, that will minimize the cost function.\n", + "\n", + "Like in the previous example of a single perceptron neural network, the cost function can be written as:\n", + "\n", + "$$\\mathcal{L}\\left(W^{[1]}, b^{[1]}, W^{[2]}, b^{[2]}\\right) = \\frac{1}{m}\\sum_{i=1}^{m} L\\left(W^{[1]}, b^{[1]}, W^{[2]}, b^{[2]}\\right) = \\frac{1}{m}\\sum_{i=1}^{m} \\large\\left(\\small - y^{(i)}\\log\\left(a^{[2](i)}\\right) - (1-y^{(i)})\\log\\left(1- a^{[2](i)}\\right) \\large \\right), \\small\\tag{8}$$\n", + "\n", + "where $y^{(i)} \\in \\{0,1\\}$ are the original labels and $a^{[2](i)}$ are the continuous output values of the forward propagation step (elements of array $A^{[2]}$).\n", + "\n", + "To minimize it, you can use gradient descent, updating the parameters with the following expressions:\n", + "\n", + "\\begin{align}\n", + "W^{[1]} &= W^{[1]} - \\alpha \\frac{\\partial \\mathcal{L} }{ \\partial W^{[1]} },\\\\\n", + "b^{[1]} &= b^{[1]} - \\alpha \\frac{\\partial \\mathcal{L} }{ \\partial b^{[1]} },\\\\\n", + "W^{[2]} &= W^{[2]} - \\alpha \\frac{\\partial \\mathcal{L} }{ \\partial W^{[2]} },\\\\\n", + "b^{[2]} &= b^{[2]} - \\alpha \\frac{\\partial \\mathcal{L} }{ \\partial b^{[2]} },\\\\\n", + "\\tag{9}\n", + "\\end{align}\n", + "\n", + "where $\\alpha$ is the learning rate." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "To perform training of the model you need to calculate now $\\frac{\\partial \\mathcal{L} }{ \\partial W^{[1]}}$, $\\frac{\\partial \\mathcal{L} }{ \\partial b^{[1]}}$, $\\frac{\\partial \\mathcal{L} }{ \\partial W^{[2]}}$, $\\frac{\\partial \\mathcal{L} }{ \\partial b^{[2]}}$. \n", + "\n", + "Let's start from the end of the neural network. You can rewrite here the corresponding expressions for $\\frac{\\partial \\mathcal{L} }{ \\partial W }$ and $\\frac{\\partial \\mathcal{L} }{ \\partial b }$ from the single perceptron neural network:\n", + "\n", + "\\begin{align}\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial W } &= \n", + "\\frac{1}{m}\\left(A-Y\\right)X^T,\\\\\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial b } &= \n", + "\\frac{1}{m}\\left(A-Y\\right)\\mathbf{1},\\\\\n", + "\\end{align}\n", + "\n", + "where $\\mathbf{1}$ is just a ($m \\times 1$) vector of ones. Your one perceptron is in the second layer now, so $W$ will be exchanged with $W^{[2]}$, $b$ with $b^{[2]}$, $A$ with $A^{[2]}$, $X$ with $A^{[1]}$:\n", + "\n", + "\\begin{align}\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial W^{[2]} } &= \n", + "\\frac{1}{m}\\left(A^{[2]}-Y\\right)\\left(A^{[1]}\\right)^T,\\\\\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial b^{[2]} } &= \n", + "\\frac{1}{m}\\left(A^{[2]}-Y\\right)\\mathbf{1}.\\\\\n", + "\\tag{10}\n", + "\\end{align}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's now find $\\frac{\\partial \\mathcal{L} }{ \\partial W^{[1]}} = \n", + "\\begin{bmatrix}\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial w_{1,1}^{[1]}} & \\frac{\\partial \\mathcal{L} }{ \\partial w_{2,1}^{[1]}} \\\\\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial w_{1,2}^{[1]}} & \\frac{\\partial \\mathcal{L} }{ \\partial w_{2,2}^{[1]}} \\end{bmatrix}$. It was shown in the videos that $$\\frac{\\partial \\mathcal{L} }{ \\partial w_{1,1}^{[1]}}=\\frac{1}{m}\\sum_{i=1}^{m} \\left( \n", + "\\left(a^{[2](i)} - y^{(i)}\\right) \n", + "w_1^{[2]} \n", + "\\left(a_1^{[1](i)}\\left(1-a_1^{[1](i)}\\right)\\right)\n", + "x_1^{(i)}\\right)\\tag{11}$$\n", + "\n", + "If you do this accurately for each of the elements $\\frac{\\partial \\mathcal{L} }{ \\partial W^{[1]}}$, you will get the following matrix:\n", + "\n", + "$$\\frac{\\partial \\mathcal{L} }{ \\partial W^{[1]}} = \\begin{bmatrix}\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial w_{1,1}^{[1]}} & \\frac{\\partial \\mathcal{L} }{ \\partial w_{2,1}^{[1]}} \\\\\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial w_{1,2}^{[1]}} & \\frac{\\partial \\mathcal{L} }{ \\partial w_{2,2}^{[1]}} \\end{bmatrix}$$\n", + "$$= \\frac{1}{m}\\begin{bmatrix}\n", + "\\sum_{i=1}^{m} \\left( \\left(a^{[2](i)} - y^{(i)}\\right) w_1^{[2]} \\left(a_1^{[1](i)}\\left(1-a_1^{[1](i)}\\right)\\right)\n", + "x_1^{(i)}\\right) & \n", + "\\sum_{i=1}^{m} \\left( \\left(a^{[2](i)} - y^{(i)}\\right) w_1^{[2]} \\left(a_1^{[1](i)}\\left(1-a_1^{[1](i)}\\right)\\right)\n", + "x_2^{(i)}\\right) \\\\\n", + "\\sum_{i=1}^{m} \\left( \\left(a^{[2](i)} - y^{(i)}\\right) w_2^{[2]} \\left(a_2^{[1](i)}\\left(1-a_2^{[1](i)}\\right)\\right)\n", + "x_1^{(i)}\\right) & \n", + "\\sum_{i=1}^{m} \\left( \\left(a^{[2](i)} - y^{(i)}\\right) w_2^{[2]} \\left(a_2^{[1](i)}\\left(1-a_2^{[1](i)}\\right)\\right)\n", + "x_2^{(i)}\\right)\\end{bmatrix}\\tag{12}$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Looking at this, you can notice that all terms and indices somehow are very consistent, so it all can be unified into a matrix form. And that's true! $\\left(W^{[2]}\\right)^T = \\begin{bmatrix}w_1^{[2]} \\\\ w_2^{[2]}\\end{bmatrix}$ of size $\\left(n_h \\times n_y\\right) = \\left(2 \\times 1\\right)$ can be multiplied with the vector $A^{[2]} - Y$ of size $\\left(n_y \\times m\\right) = \\left(1 \\times m\\right)$, resulting in a matrix of size $\\left(n_h \\times m\\right) = \\left(2 \\times m\\right)$:\n", + "\n", + "$$\\left(W^{[2]}\\right)^T \\left(A^{[2]} - Y\\right)=\n", + "\\begin{bmatrix}w_1^{[2]} \\\\ w_2^{[2]}\\end{bmatrix}\n", + "\\begin{bmatrix}\\left(a^{[2](1)} - y^{(1)}\\right) & \\cdots & \\left(a^{[2](m)} - y^{(m)}\\right)\\end{bmatrix}\n", + "=\\begin{bmatrix}\n", + "\\left(a^{[2](1)} - y^{(1)}\\right) w_1^{[2]} & \\cdots & \\left(a^{[2](m)} - y^{(m)}\\right) w_1^{[2]} \\\\\n", + "\\left(a^{[2](1)} - y^{(1)}\\right) w_2^{[2]} & \\cdots & \\left(a^{[2](m)} - y^{(m)}\\right) w_2^{[2]} \\end{bmatrix}$$.\n", + "\n", + "Now taking matrix $A^{[1]}$ of the same size $\\left(n_h \\times m\\right) = \\left(2 \\times m\\right)$,\n", + "\n", + "$$A^{[1]}\n", + "=\\begin{bmatrix}\n", + "a_1^{[1](1)} & \\cdots & a_1^{[1](m)} \\\\\n", + "a_2^{[1](1)} & \\cdots & a_2^{[1](m)} \\end{bmatrix},$$\n", + "\n", + "you can calculate:\n", + "\n", + "$$A^{[1]}\\cdot\\left(1-A^{[1]}\\right)\n", + "=\\begin{bmatrix}\n", + "a_1^{[1](1)}\\left(1 - a_1^{[1](1)}\\right) & \\cdots & a_1^{[1](m)}\\left(1 - a_1^{[1](m)}\\right) \\\\\n", + "a_2^{[1](1)}\\left(1 - a_2^{[1](1)}\\right) & \\cdots & a_2^{[1](m)}\\left(1 - a_2^{[1](m)}\\right) \\end{bmatrix},$$\n", + "\n", + "where \"$\\cdot$\" denotes **element by element** multiplication." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the element by element multiplication,\n", + "\n", + "$$\\left(W^{[2]}\\right)^T \\left(A^{[2]} - Y\\right)\\cdot \\left(A^{[1]}\\cdot\\left(1-A^{[1]}\\right)\\right)=\\begin{bmatrix}\n", + "\\left(a^{[2](1)} - y^{(1)}\\right) w_1^{[2]}\\left(a_1^{[1](1)}\\left(1 - a_1^{[1](1)}\\right)\\right) & \\cdots & \\left(a^{[2](m)} - y^{(m)}\\right) w_1^{[2]}\\left(a_1^{[1](m)}\\left(1 - a_1^{[1](m)}\\right)\\right) \\\\\n", + "\\left(a^{[2](1)} - y^{(1)}\\right) w_2^{[2]}\\left(a_2^{[1](1)}\\left(1 - a_2^{[1](1)}\\right)\\right) & \\cdots & \\left(a^{[2](m)} - y^{(m)}\\right) w_2^{[2]} \\left(a_2^{[1](m)}\\left(1 - a_2^{[1](m)}\\right)\\right) \\end{bmatrix}.$$\n", + "\n", + "If you perform matrix multiplication with $X^T$ of size $\\left(m \\times n_x\\right) = \\left(m \\times 2\\right)$, you will get matrix of size $\\left(n_h \\times n_x\\right) = \\left(2 \\times 2\\right)$:\n", + "\n", + "$$\\left(\\left(W^{[2]}\\right)^T \\left(A^{[2]} - Y\\right)\\cdot \\left(A^{[1]}\\cdot\\left(1-A^{[1]}\\right)\\right)\\right)X^T = \n", + "\\begin{bmatrix}\n", + "\\left(a^{[2](1)} - y^{(1)}\\right) w_1^{[2]}\\left(a_1^{[1](1)}\\left(1 - a_1^{[1](1)}\\right)\\right) & \\cdots & \\left(a^{[2](m)} - y^{(m)}\\right) w_1^{[2]}\\left(a_1^{[1](m)}\\left(1 - a_1^{[1](m)}\\right)\\right) \\\\\n", + "\\left(a^{[2](1)} - y^{(1)}\\right) w_2^{[2]}\\left(a_2^{[1](1)}\\left(1 - a_2^{[1](1)}\\right)\\right) & \\cdots & \\left(a^{[2](m)} - y^{(m)}\\right) w_2^{[2]} \\left(a_2^{[1](m)}\\left(1 - a_2^{[1](m)}\\right)\\right) \\end{bmatrix}\n", + "\\begin{bmatrix}\n", + "x_1^{(1)} & x_2^{(1)} \\\\\n", + "\\cdots & \\cdots \\\\\n", + "x_1^{(m)} & x_2^{(m)}\n", + "\\end{bmatrix}$$\n", + "$$=\\begin{bmatrix}\n", + "\\sum_{i=1}^{m} \\left( \\left(a^{[2](i)} - y^{(i)}\\right) w_1^{[2]} \\left(a_1^{[1](i)}\\left(1 - a_1^{[1](i)}\\right) \\right)\n", + "x_1^{(i)}\\right) & \n", + "\\sum_{i=1}^{m} \\left( \\left(a^{[2](i)} - y^{(i)}\\right) w_1^{[2]} \\left(a_1^{[1](i)}\\left(1-a_1^{[1](i)}\\right)\\right)\n", + "x_2^{(i)}\\right) \\\\\n", + "\\sum_{i=1}^{m} \\left( \\left(a^{[2](i)} - y^{(i)}\\right) w_2^{[2]} \\left(a_2^{[1](i)}\\left(1-a_2^{[1](i)}\\right)\\right)\n", + "x_1^{(i)}\\right) & \n", + "\\sum_{i=1}^{m} \\left( \\left(a^{[2](i)} - y^{(i)}\\right) w_2^{[2]} \\left(a_2^{[1](i)}\\left(1-a_2^{[1](i)}\\right)\\right)\n", + "x_2^{(i)}\\right)\\end{bmatrix}$$\n", + "\n", + "This is exactly like in the expression $(12)$! So, $\\frac{\\partial \\mathcal{L} }{ \\partial W^{[1]}}$ can be written as a mixture of multiplications:\n", + "\n", + "$$\\frac{\\partial \\mathcal{L} }{ \\partial W^{[1]}} = \\frac{1}{m}\\left(\\left(W^{[2]}\\right)^T \\left(A^{[2]} - Y\\right)\\cdot \\left(A^{[1]}\\cdot\\left(1-A^{[1]}\\right)\\right)\\right)X^T\\tag{13},$$\n", + "\n", + "where \"$\\cdot$\" denotes element by element multiplications." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Vector $\\frac{\\partial \\mathcal{L} }{ \\partial b^{[1]}}$ can be found very similarly, but the last terms in the chain rule will be equal to $1$, i.e. $\\frac{\\partial z_1^{[1](i)}}{ \\partial b_1^{[1]}} = 1$. Thus,\n", + "\n", + "$$\\frac{\\partial \\mathcal{L} }{ \\partial b^{[1]}} = \\frac{1}{m}\\left(\\left(W^{[2]}\\right)^T \\left(A^{[2]} - Y\\right)\\cdot \\left(A^{[1]}\\cdot\\left(1-A^{[1]}\\right)\\right)\\right)\\mathbf{1},\\tag{14}$$\n", + "\n", + "where $\\mathbf{1}$ is a ($m \\times 1$) vector of ones.\n", + "\n", + "Expressions $(10)$, $(13)$ and $(14)$ can be used for the parameters update $(9)$ performing backward propagation:\n", + "\n", + "\\begin{align}\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial W^{[2]} } &= \n", + "\\frac{1}{m}\\left(A^{[2]}-Y\\right)\\left(A^{[1]}\\right)^T,\\\\\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial b^{[2]} } &= \n", + "\\frac{1}{m}\\left(A^{[2]}-Y\\right)\\mathbf{1},\\\\\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial W^{[1]}} &= \\frac{1}{m}\\left(\\left(W^{[2]}\\right)^T \\left(A^{[2]} - Y\\right)\\cdot \\left(A^{[1]}\\cdot\\left(1-A^{[1]}\\right)\\right)\\right)X^T,\\\\\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial b^{[1]}} &= \\frac{1}{m}\\left(\\left(W^{[2]}\\right)^T \\left(A^{[2]} - Y\\right)\\cdot \\left(A^{[1]}\\cdot\\left(1-A^{[1]}\\right)\\right)\\right)\\mathbf{1},\\\\\n", + "\\tag{15}\n", + "\\end{align}\n", + "\n", + "where $\\mathbf{1}$ is a ($m \\times 1$) vector of ones." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So, to understand deeply and properly how neural networks perform and get trained, **you do need knowledge of linear algebra and calculus joined together**! But do not worry! All together it is not that scary if you do it step by step accurately with understanding of maths.\n", + "\n", + "Time to implement this all in the code!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 2.2 - Dataset\n", + "\n", + "First, let's get the dataset you will work on. The following code will create $m=2000$ data points $(x_1, x_2)$ and save them in the `NumPy` array `X` of a shape $(2 \\times m)$ (in the columns of the array). The labels ($0$: blue, $1$: red) will be saved in the `NumPy` array `Y` of a shape $(1 \\times m)$." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The shape of X is: (2, 2000)\n", + "The shape of Y is: (1, 2000)\n", + "I have m = 2000 training examples!\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "m = 2000\n", + "samples, labels = make_blobs(n_samples=m, \n", + " centers=([2.5, 3], [6.7, 7.9], [2.1, 7.9], [7.4, 2.8]), \n", + " cluster_std=1.1,\n", + " random_state=0)\n", + "labels[(labels == 0) | (labels == 1)] = 1\n", + "labels[(labels == 2) | (labels == 3)] = 0\n", + "X = np.transpose(samples)\n", + "Y = labels.reshape((1, m))\n", + "\n", + "plt.scatter(X[0, :], X[1, :], c=Y, cmap=colors.ListedColormap(['blue', 'red']));\n", + "\n", + "print ('The shape of X is: ' + str(X.shape))\n", + "print ('The shape of Y is: ' + str(Y.shape))\n", + "print ('I have m = %d training examples!' % (m))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 2.91868287, 10.31812597, 7.79616824, ..., 2.43434264,\n", + " 3.64044705, 6.77517917])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X[1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 2.3 - Define Activation Function" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Exercise 1\n", + "\n", + "Define sigmoid activation function $\\sigma\\left(z\\right) =\\frac{1}{1+e^{-z}} $." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [], + "source": [ + "import math\n", + "def sigmoid(z):\n", + " ### START CODE HERE ### (~ 1 line of code)\n", + " res = 1 / (1 + math.e**-z)\n", + " ### END CODE HERE ###\n", + " \n", + " return res" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sigmoid(-2) = 0.11920292202211757\n", + "sigmoid(0) = 0.5\n", + "sigmoid(3.5) = 0.9706877692486436\n" + ] + } + ], + "source": [ + "print(\"sigmoid(-2) = \" + str(sigmoid(-2)))\n", + "print(\"sigmoid(0) = \" + str(sigmoid(0)))\n", + "print(\"sigmoid(3.5) = \" + str(sigmoid(3.5)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### __Expected Output__\n", + "\n", + "Note: the values may vary in the last decimal places.\n", + "\n", + "```Python\n", + "sigmoid(-2) = 0.11920292202211755\n", + "sigmoid(0) = 0.5\n", + "sigmoid(3.5) = 0.9706877692486436\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[92m All tests passed\n" + ] + } + ], + "source": [ + "w3_unittest.test_sigmoid(sigmoid)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 3 - Implementation of the Neural Network Model with Two Layers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.1 - Defining the Neural Network Structure" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Exercise 2\n", + "\n", + "Define three variables:\n", + "- `n_x`: the size of the input layer\n", + "- `n_h`: the size of the hidden layer (set it equal to 2 for now)\n", + "- `n_y`: the size of the output layer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "\n", + " Hint\n", + "\n", + "

\n", + "

    \n", + " Use shapes of X and Y to find n_x and n_y:\n", + "
  • the size of the input layer n_x equals to the size of the input vectors placed in the columns of the array X,
    • \n", + "
  • the outpus for each of the data point will be saved in the columns of the the array Y.
    • \n", + "
\n", + "

" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: layer_sizes\n", + "\n", + "def layer_sizes(X, Y):\n", + " \"\"\"\n", + " Arguments:\n", + " X -- input dataset of shape (input size, number of examples)\n", + " Y -- labels of shape (output size, number of examples)\n", + " \n", + " Returns:\n", + " n_x -- the size of the input layer\n", + " n_h -- the size of the hidden layer\n", + " n_y -- the size of the output layer\n", + " \"\"\"\n", + " ### START CODE HERE ### (~ 3 lines of code)\n", + " # Size of input layer.\n", + " n_x = X.shape[0]\n", + " # Size of hidden layer.\n", + " n_h = 2\n", + " # Size of output layer.\n", + " n_y = Y.shape[0]\n", + " ### END CODE HERE ###\n", + " return (n_x, n_h, n_y)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The size of the input layer is: n_x = 2\n", + "The size of the hidden layer is: n_h = 2\n", + "The size of the output layer is: n_y = 1\n" + ] + } + ], + "source": [ + "(n_x, n_h, n_y) = layer_sizes(X, Y)\n", + "print(\"The size of the input layer is: n_x = \" + str(n_x))\n", + "print(\"The size of the hidden layer is: n_h = \" + str(n_h))\n", + "print(\"The size of the output layer is: n_y = \" + str(n_y))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### __Expected Output__\n", + "\n", + "```Python\n", + "The size of the input layer is: n_x = 2\n", + "The size of the hidden layer is: n_h = 2\n", + "The size of the output layer is: n_y = 1\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[92m All tests passed\n" + ] + } + ], + "source": [ + "w3_unittest.test_layer_sizes(layer_sizes)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.2 - Initialize the Model's Parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Exercise 3\n", + "\n", + "Implement the function `initialize_parameters()`.\n", + "\n", + "**Instructions**:\n", + "- Make sure your parameters' sizes are right. Refer to the neural network figure above if needed.\n", + "- You will initialize the weights matrix with random values. \n", + " - Use: `np.random.randn(a,b) * 0.01` to randomly initialize a matrix of shape (a,b).\n", + "- You will initialize the bias vector as zeros. \n", + " - Use: `np.zeros((a,b))` to initialize a matrix of shape (a,b) with zeros." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: initialize_parameters\n", + "\n", + "def initialize_parameters(n_x, n_h, n_y):\n", + " \"\"\"\n", + " Argument:\n", + " n_x -- size of the input layer\n", + " n_h -- size of the hidden layer\n", + " n_y -- size of the output layer\n", + " \n", + " Returns:\n", + " params -- python dictionary containing your parameters:\n", + " W1 -- weight matrix of shape (n_h, n_x)\n", + " b1 -- bias vector of shape (n_h, 1)\n", + " W2 -- weight matrix of shape (n_y, n_h)\n", + " b2 -- bias vector of shape (n_y, 1)\n", + " \"\"\"\n", + " \n", + " ### START CODE HERE ### (~ 4 lines of code)\n", + " W1 = np.random.randn(n_h, n_x) * 0.01\n", + " b1 = np.zeros((n_h, 1))\n", + " W2 = np.random.randn(n_y, n_h) * 0.01\n", + " b2 = np.zeros((n_y, 1))\n", + " ### END CODE HERE ###\n", + " \n", + " assert (W1.shape == (n_h, n_x))\n", + " assert (b1.shape == (n_h, 1))\n", + " assert (W2.shape == (n_y, n_h))\n", + " assert (b2.shape == (n_y, 1))\n", + " \n", + " parameters = {\"W1\": W1,\n", + " \"b1\": b1,\n", + " \"W2\": W2,\n", + " \"b2\": b2}\n", + " \n", + " return parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "W1 = [[ 5.96154331e-04 2.44416199e-05]\n", + " [ 4.24635721e-03 -7.25433480e-03]]\n", + "b1 = [[0.]\n", + " [0.]]\n", + "W2 = [[-0.00034943 -0.0014062 ]]\n", + "b2 = [[0.]]\n" + ] + } + ], + "source": [ + "parameters = initialize_parameters(n_x, n_h, n_y)\n", + "\n", + "print(\"W1 = \" + str(parameters[\"W1\"]))\n", + "print(\"b1 = \" + str(parameters[\"b1\"]))\n", + "print(\"W2 = \" + str(parameters[\"W2\"]))\n", + "print(\"b2 = \" + str(parameters[\"b2\"]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### __Expected Output__ \n", + "Note: the elements of the arrays W1 and W2 maybe be different due to random initialization. You can try to restart the kernel to get the same values.\n", + "\n", + "```Python\n", + "W1 = [[ 0.01788628 0.0043651 ]\n", + " [ 0.00096497 -0.01863493]]\n", + "b1 = [[0.]\n", + " [0.]]\n", + "W2 = [[-0.00277388 -0.00354759]]\n", + "b2 = [[0.]]\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[92m All tests passed\n" + ] + } + ], + "source": [ + "# Note: \n", + "# Actual values are not checked here in the unit tests (due to random initialization).\n", + "w3_unittest.test_initialize_parameters(initialize_parameters)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.3 - The Loop" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Exercise 4\n", + "\n", + "Implement `forward_propagation()`.\n", + "\n", + "**Instructions**:\n", + "- Look above at the mathematical representation $(7)$ of your classifier (section [2.2](#2.2)):\n", + "\\begin{align}\n", + "Z^{[1]} &= W^{[1]} X + b^{[1]},\\\\\n", + "A^{[1]} &= \\sigma\\left(Z^{[1]}\\right),\\\\\n", + "Z^{[2]} &= W^{[2]} A^{[1]} + b^{[2]},\\\\\n", + "A^{[2]} &= \\sigma\\left(Z^{[2]}\\right).\\\\\n", + "\\end{align}\n", + "- The steps you have to implement are:\n", + " 1. Retrieve each parameter from the dictionary \"parameters\" (which is the output of `initialize_parameters()`) by using `parameters[\"..\"]`.\n", + " 2. Implement Forward Propagation. Compute `Z1` multiplying matrices `W1`, `X` and adding vector `b1`. Then find `A1` using the `sigmoid` activation function. Perform similar computations for `Z2` and `A2`." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: forward_propagation\n", + "\n", + "def forward_propagation(X, parameters):\n", + " \"\"\"\n", + " Argument:\n", + " X -- input data of size (n_x, m)\n", + " parameters -- python dictionary containing your parameters (output of initialization function)\n", + " \n", + " Returns:\n", + " A2 -- the sigmoid output of the second activation\n", + " cache -- python dictionary containing Z1, A1, Z2, A2 \n", + " (that simplifies the calculations in the back propagation step)\n", + " \"\"\"\n", + "# parameters = {\"W1\": W1,\n", + "# \"b1\": b1,\n", + "# \"W2\": W2,\n", + "# \"b2\": b2}\n", + " # Retrieve each parameter from the dictionary \"parameters\".\n", + " ### START CODE HERE ### (~ 4 lines of code)\n", + " W1 = parameters[\"W1\"]\n", + " b1 = parameters[\"b1\"]\n", + " W2 = parameters[\"W2\"]\n", + " b2 = parameters[\"b2\"]\n", + " ### END CODE HERE ###\n", + " \n", + " # Implement forward propagation to calculate A2.\n", + " ### START CODE HERE ### (~ 4 lines of code)\n", + " Z1 = np.matmul(W1, X) + b1\n", + " A1 = sigmoid(Z1)\n", + " Z2 = np.matmul(W2, A1) + b2\n", + " A2 = sigmoid(Z2)\n", + " ### END CODE HERE ###\n", + " \n", + " assert(A2.shape == (n_y, X.shape[1]))\n", + "\n", + " cache = {\"Z1\": Z1,\n", + " \"A1\": A1,\n", + " \"Z2\": Z2,\n", + " \"A2\": A2}\n", + " \n", + " return A2, cache" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0.49901834 0.49906888 0.49905051 ... 0.49901972 0.49902598 0.49904247]]\n" + ] + } + ], + "source": [ + "A2, cache = forward_propagation(X, parameters)\n", + "\n", + "print(A2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### __Expected Output__ \n", + "Note: the elements of the array A2 maybe be different depending on the initial parameters. If you would like to get exactly the same output, try to restart the Kernel and rerun the notebook.\n", + "\n", + "```Python\n", + "[[0.49920157 0.49922234 0.49921223 ... 0.49921215 0.49921043 0.49920665]]\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[92m All tests passed\n" + ] + } + ], + "source": [ + "# Note: \n", + "# Actual values are not checked here in the unit tests (due to random initialization).\n", + "w3_unittest.test_forward_propagation(forward_propagation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Remember, that your weights were just initialized with some random values, so the model has not been trained yet. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Exercise 5\n", + "\n", + "Define a cost function $(8)$ which will be used to train the model:\n", + "\n", + "$$\\mathcal{L}\\left(W, b\\right) = \\frac{1}{m}\\sum_{i=1}^{m} \\large\\left(\\small - y^{(i)}\\log\\left(a^{(i)}\\right) - (1-y^{(i)})\\log\\left(1- a^{(i)}\\right) \\large \\right) \\small.$$" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [], + "source": [ + "def compute_cost(A2, Y):\n", + " \"\"\"\n", + " Computes the cost function as a log loss\n", + " \n", + " Arguments:\n", + " A2 -- The output of the neural network of shape (1, number of examples)\n", + " Y -- \"true\" labels vector of shape (1, number of examples)\n", + " \n", + " Returns:\n", + " cost -- log loss\n", + " \n", + " \"\"\"\n", + " # Number of examples.\n", + " m = Y.shape[1]\n", + " \n", + " ### START CODE HERE ### (~ 2 lines of code)\n", + " logloss = (-Y*np.log(A2) - (1-Y)*np.log(1-A2))\n", + " cost = np.sum(logloss) / m\n", + " ### END CODE HERE ###\n", + "\n", + " assert(isinstance(cost, float))\n", + " \n", + " return cost" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cost = 0.6931482466617492\n" + ] + } + ], + "source": [ + "print(\"cost = \" + str(compute_cost(A2, Y)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### __Expected Output__ \n", + "Note: the elements of the arrays W1 and W2 maybe be different!\n", + "\n", + "```Python\n", + "cost = 0.6931477703826823\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[92m All tests passed\n" + ] + } + ], + "source": [ + "# Note: \n", + "# Actual values are not checked here in the unit tests (due to random initialization).\n", + "w3_unittest.test_compute_cost(compute_cost, A2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Calculate partial derivatives as shown in $(15)$:\n", + "\n", + "\\begin{align}\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial W^{[2]} } &= \n", + "\\frac{1}{m}\\left(A^{[2]}-Y\\right)\\left(A^{[1]}\\right)^T,\\\\\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial b^{[2]} } &= \n", + "\\frac{1}{m}\\left(A^{[2]}-Y\\right)\\mathbf{1},\\\\\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial W^{[1]}} &= \\frac{1}{m}\\left(\\left(W^{[2]}\\right)^T \\left(A^{[2]} - Y\\right)\\cdot \\left(A^{[1]}\\cdot\\left(1-A^{[1]}\\right)\\right)\\right)X^T,\\\\\n", + "\\frac{\\partial \\mathcal{L} }{ \\partial b^{[1]}} &= \\frac{1}{m}\\left(\\left(W^{[2]}\\right)^T \\left(A^{[2]} - Y\\right)\\cdot \\left(A^{[1]}\\cdot\\left(1-A^{[1]}\\right)\\right)\\right)\\mathbf{1}.\\\\\n", + "\\end{align}" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dW1 = [[-4.30550606e-06 5.21050299e-06]\n", + " [-3.64409261e-05 4.45422832e-05]]\n", + "db1 = [[1.88651352e-07]\n", + " [1.52141995e-06]]\n", + "dW2 = [[-0.00041826 -0.00034353]]\n", + "db2 = [[-0.0009631]]\n" + ] + } + ], + "source": [ + "def backward_propagation(parameters, cache, X, Y):\n", + " \"\"\"\n", + " Implements the backward propagation, calculating gradients\n", + " \n", + " Arguments:\n", + " parameters -- python dictionary containing our parameters \n", + " cache -- python dictionary containing Z1, A1, Z2, A2\n", + " X -- input data of shape (n_x, number of examples)\n", + " Y -- \"true\" labels vector of shape (n_y, number of examples)\n", + " \n", + " Returns:\n", + " grads -- python dictionary containing gradients with respect to different parameters\n", + " \"\"\"\n", + " m = X.shape[1]\n", + " \n", + " # First, retrieve W from the dictionary \"parameters\".\n", + " W1 = parameters[\"W1\"]\n", + " W2 = parameters[\"W2\"]\n", + " \n", + " # Retrieve also A1 and A2 from dictionary \"cache\".\n", + " A1 = cache[\"A1\"]\n", + " A2 = cache[\"A2\"]\n", + " \n", + " # Backward propagation: calculate partial derivatives denoted as dW1, db1, dW2, db2 for simplicity. \n", + " dZ2 = A2 - Y\n", + " dW2 = 1/m * np.dot(dZ2, A1.T)\n", + " db2 = 1/m * np.sum(dZ2, axis = 1, keepdims = True)\n", + " dZ1 = np.dot(W2.T, dZ2) * A1 * (1 - A1)\n", + " dW1 = 1/m * np.dot(dZ1, X.T)\n", + " db1 = 1/m * np.sum(dZ1, axis = 1, keepdims = True)\n", + " \n", + " grads = {\"dW1\": dW1,\n", + " \"db1\": db1,\n", + " \"dW2\": dW2,\n", + " \"db2\": db2}\n", + " \n", + " return grads\n", + "\n", + "grads = backward_propagation(parameters, cache, X, Y)\n", + "\n", + "print(\"dW1 = \" + str(grads[\"dW1\"]))\n", + "print(\"db1 = \" + str(grads[\"db1\"]))\n", + "print(\"dW2 = \" + str(grads[\"dW2\"]))\n", + "print(\"db2 = \" + str(grads[\"db2\"]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Exercise 6\n", + "\n", + "Implement `update_parameters()`.\n", + "\n", + "**Instructions**:\n", + "- Update parameters as shown in $(9)$ (section [2.3](#2.3)):\n", + "\\begin{align}\n", + "W^{[1]} &= W^{[1]} - \\alpha \\frac{\\partial \\mathcal{L} }{ \\partial W^{[1]} },\\\\\n", + "b^{[1]} &= b^{[1]} - \\alpha \\frac{\\partial \\mathcal{L} }{ \\partial b^{[1]} },\\\\\n", + "W^{[2]} &= W^{[2]} - \\alpha \\frac{\\partial \\mathcal{L} }{ \\partial W^{[2]} },\\\\\n", + "b^{[2]} &= b^{[2]} - \\alpha \\frac{\\partial \\mathcal{L} }{ \\partial b^{[2]} }.\\\\\n", + "\\end{align}\n", + "- The steps you have to implement are:\n", + " 1. Retrieve each parameter from the dictionary \"parameters\" (which is the output of `initialize_parameters()`) by using `parameters[\"..\"]`.\n", + " 2. Retrieve each derivative from the dictionary \"grads\" (which is the output of `backward_propagation()`) by using `grads[\"..\"]`.\n", + " 3. Update parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [], + "source": [ + "def update_parameters(parameters, grads, learning_rate=1.2):\n", + " \"\"\"\n", + " Updates parameters using the gradient descent update rule\n", + " \n", + " Arguments:\n", + " parameters -- python dictionary containing parameters \n", + " grads -- python dictionary containing gradients\n", + " learning_rate -- learning rate for gradient descent\n", + " \n", + " Returns:\n", + " parameters -- python dictionary containing updated parameters \n", + " \"\"\"\n", + "# grads = {\"dW1\": dW1,\n", + "# \"db1\": db1,\n", + "# \"dW2\": dW2,\n", + "# \"db2\": db2}\n", + " # Retrieve each parameter from the dictionary \"parameters\".\n", + " ### START CODE HERE ### (~ 4 lines of code)\n", + " W1 = parameters[\"W1\"]\n", + " b1 = parameters[\"b1\"]\n", + " W2 = parameters[\"W2\"]\n", + " b2 = parameters[\"b2\"]\n", + " ### END CODE HERE ###\n", + " \n", + " # Retrieve each gradient from the dictionary \"grads\".\n", + " ### START CODE HERE ### (~ 4 lines of code)\n", + " dW1 = grads[\"dW1\"]\n", + " db1 = grads[\"db1\"]\n", + " dW2 = grads[\"dW2\"]\n", + " db2 = grads[\"db2\"]\n", + " ### END CODE HERE ###\n", + " \n", + " # Update rule for each parameter.\n", + " ### START CODE HERE ### (~ 4 lines of code)\n", + " W1 = W1 - learning_rate*dW1\n", + " b1 = b1 - learning_rate*db1\n", + " W2 = W2 - learning_rate*dW2\n", + " b2 = b2 - learning_rate*db2\n", + " ### END CODE HERE ###\n", + " \n", + " parameters = {\"W1\": W1,\n", + " \"b1\": b1,\n", + " \"W2\": W2,\n", + " \"b2\": b2}\n", + " \n", + " return parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "W1 updated = [[ 0.01789145 0.00435885]\n", + " [ 0.0010087 -0.01868838]]\n", + "b1 updated = [[-0.00277411]\n", + " [-0.00354942]]\n", + "W2 updated = [[-0.00032551 -0.00585777]]\n", + "b2 updated = [[0.00071754]]\n" + ] + } + ], + "source": [ + "parameters_updated = update_parameters(parameters, grads)\n", + "\n", + "print(\"W1 updated = \" + str(parameters_updated[\"W1\"]))\n", + "print(\"b1 updated = \" + str(parameters_updated[\"b1\"]))\n", + "print(\"W2 updated = \" + str(parameters_updated[\"W2\"]))\n", + "print(\"b2 updated = \" + str(parameters_updated[\"b2\"]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### __Expected Output__ \n", + "Note: the actual values can be different!\n", + "\n", + "```Python\n", + "W1 updated = [[ 0.01790427 0.00434496]\n", + " [ 0.00099046 -0.01866419]]\n", + "b1 updated = [[-6.13449205e-07]\n", + " [-8.47483463e-07]]\n", + "W2 updated = [[-0.00238219 -0.00323487]]\n", + "b2 updated = [[0.00094478]]\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[92m All tests passed\n" + ] + } + ], + "source": [ + "w3_unittest.test_update_parameters(update_parameters)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.4 - Integrate parts 3.1, 3.2 and 3.3 in nn_model()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Exercise 7\n", + "\n", + "Build your neural network model in `nn_model()`.\n", + "\n", + "**Instructions**: The neural network model has to use the previous functions in the right order." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: nn_model\n", + "\n", + "def nn_model(X, Y, n_h, num_iterations=10, learning_rate=1.2, print_cost=False):\n", + " \"\"\"\n", + " Arguments:\n", + " X -- dataset of shape (n_x, number of examples)\n", + " Y -- labels of shape (n_y, number of examples)\n", + " num_iterations -- number of iterations in the loop\n", + " learning_rate -- learning rate parameter for gradient descent\n", + " print_cost -- if True, print the cost every iteration\n", + " \n", + " Returns:\n", + " parameters -- parameters learnt by the model. They can then be used to predict.\n", + " \"\"\"\n", + " \n", + " n_x = layer_sizes(X, Y)[0]\n", + " n_y = layer_sizes(X, Y)[2]\n", + " \n", + " # Initialize parameters.\n", + " ### START CODE HERE ### (~ 1 line of code)\n", + " parameters = initialize_parameters(n_x, n_h, n_y)\n", + " ### END CODE HERE ###\n", + " \n", + " # Loop.\n", + " for i in range(0, num_iterations):\n", + " \n", + " ### START CODE HERE ### (~ 4 lines of code)\n", + " # Forward propagation. Inputs: \"X, parameters\". Outputs: \"A2, cache\".\n", + " A2, cache = forward_propagation(X, parameters)\n", + " \n", + " # Cost function. Inputs: \"A2, Y\". Outputs: \"cost\".\n", + " cost = compute_cost(A2, Y)\n", + " \n", + " # Backpropagation. Inputs: \"parameters, cache, X, Y\". Outputs: \"grads\".\n", + " grads = backward_propagation(parameters, cache, X, Y)\n", + " \n", + " # Gradient descent parameter update. Inputs: \"parameters, grads, learning_rate\". Outputs: \"parameters\".\n", + " parameters = update_parameters(parameters, grads, learning_rate)\n", + " ### END CODE HERE ###\n", + " \n", + " # Print the cost every iteration.\n", + " if print_cost:\n", + " print (\"Cost after iteration %i: %f\" %(i, cost))\n", + "\n", + " return parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost after iteration 0: 0.693152\n", + "Cost after iteration 1: 0.693149\n", + "Cost after iteration 2: 0.693148\n", + "Cost after iteration 3: 0.693147\n", + "Cost after iteration 4: 0.693147\n", + "Cost after iteration 5: 0.693147\n", + "Cost after iteration 6: 0.693147\n", + "Cost after iteration 7: 0.693147\n", + "Cost after iteration 8: 0.693147\n", + "Cost after iteration 9: 0.693147\n", + "Cost after iteration 10: 0.693147\n", + "Cost after iteration 11: 0.693147\n", + "Cost after iteration 12: 0.693147\n", + "Cost after iteration 13: 0.693147\n", + "Cost after iteration 14: 0.693147\n", + "Cost after iteration 15: 0.693147\n", + "Cost after iteration 16: 0.693147\n", + "Cost after iteration 17: 0.693146\n", + "Cost after iteration 18: 0.693146\n", + "Cost after iteration 19: 0.693146\n", + "Cost after iteration 20: 0.693146\n", + "Cost after iteration 21: 0.693146\n", + "Cost after iteration 22: 0.693146\n", + "Cost after iteration 23: 0.693146\n", + "Cost after iteration 24: 0.693146\n", + "Cost after iteration 25: 0.693146\n", + "Cost after iteration 26: 0.693146\n", + "Cost after iteration 27: 0.693146\n", + "Cost after iteration 28: 0.693146\n", + "Cost after iteration 29: 0.693146\n", + "Cost after iteration 30: 0.693146\n", + "Cost after iteration 31: 0.693146\n", + "Cost after iteration 32: 0.693146\n", + "Cost after iteration 33: 0.693146\n", + "Cost after iteration 34: 0.693145\n", + "Cost after iteration 35: 0.693145\n", + "Cost after iteration 36: 0.693145\n", + "Cost after iteration 37: 0.693145\n", + "Cost after iteration 38: 0.693145\n", + "Cost after iteration 39: 0.693145\n", + "Cost after iteration 40: 0.693145\n", + "Cost after iteration 41: 0.693145\n", + "Cost after iteration 42: 0.693145\n", + "Cost after iteration 43: 0.693145\n", + "Cost after iteration 44: 0.693145\n", + "Cost after iteration 45: 0.693145\n", + "Cost after iteration 46: 0.693145\n", + "Cost after iteration 47: 0.693145\n", + "Cost after iteration 48: 0.693145\n", + "Cost after iteration 49: 0.693145\n", + "Cost after iteration 50: 0.693144\n", + "Cost after iteration 51: 0.693144\n", + "Cost after iteration 52: 0.693144\n", + "Cost after iteration 53: 0.693144\n", + "Cost after iteration 54: 0.693144\n", + "Cost after iteration 55: 0.693144\n", + "Cost after iteration 56: 0.693144\n", + "Cost after iteration 57: 0.693144\n", + "Cost after iteration 58: 0.693144\n", + "Cost after iteration 59: 0.693144\n", + "Cost after iteration 60: 0.693144\n", + "Cost after iteration 61: 0.693144\n", + "Cost after iteration 62: 0.693144\n", + "Cost after iteration 63: 0.693144\n", + "Cost after iteration 64: 0.693143\n", + "Cost after iteration 65: 0.693143\n", + "Cost after iteration 66: 0.693143\n", + "Cost after iteration 67: 0.693143\n", + "Cost after iteration 68: 0.693143\n", + "Cost after iteration 69: 0.693143\n", + "Cost after iteration 70: 0.693143\n", + "Cost after iteration 71: 0.693143\n", + "Cost after iteration 72: 0.693143\n", + "Cost after iteration 73: 0.693143\n", + "Cost after iteration 74: 0.693143\n", + "Cost after iteration 75: 0.693143\n", + "Cost after iteration 76: 0.693143\n", + "Cost after iteration 77: 0.693142\n", + "Cost after iteration 78: 0.693142\n", + "Cost after iteration 79: 0.693142\n", + "Cost after iteration 80: 0.693142\n", + "Cost after iteration 81: 0.693142\n", + "Cost after iteration 82: 0.693142\n", + "Cost after iteration 83: 0.693142\n", + "Cost after iteration 84: 0.693142\n", + "Cost after iteration 85: 0.693142\n", + "Cost after iteration 86: 0.693142\n", + "Cost after iteration 87: 0.693142\n", + "Cost after iteration 88: 0.693141\n", + "Cost after iteration 89: 0.693141\n", + "Cost after iteration 90: 0.693141\n", + "Cost after iteration 91: 0.693141\n", + "Cost after iteration 92: 0.693141\n", + "Cost after iteration 93: 0.693141\n", + "Cost after iteration 94: 0.693141\n", + "Cost after iteration 95: 0.693141\n", + "Cost after iteration 96: 0.693141\n", + "Cost after iteration 97: 0.693141\n", + "Cost after iteration 98: 0.693140\n", + "Cost after iteration 99: 0.693140\n", + "Cost after iteration 100: 0.693140\n", + "Cost after iteration 101: 0.693140\n", + "Cost after iteration 102: 0.693140\n", + "Cost after iteration 103: 0.693140\n", + "Cost after iteration 104: 0.693140\n", + "Cost after iteration 105: 0.693140\n", + "Cost after iteration 106: 0.693140\n", + "Cost after iteration 107: 0.693139\n", + "Cost after iteration 108: 0.693139\n", + "Cost after iteration 109: 0.693139\n", + "Cost after iteration 110: 0.693139\n", + "Cost after iteration 111: 0.693139\n", + "Cost after iteration 112: 0.693139\n", + "Cost after iteration 113: 0.693139\n", + "Cost after iteration 114: 0.693139\n", + "Cost after iteration 115: 0.693138\n", + "Cost after iteration 116: 0.693138\n", + "Cost after iteration 117: 0.693138\n", + "Cost after iteration 118: 0.693138\n", + "Cost after iteration 119: 0.693138\n", + "Cost after iteration 120: 0.693138\n", + "Cost after iteration 121: 0.693138\n", + "Cost after iteration 122: 0.693137\n", + "Cost after iteration 123: 0.693137\n", + "Cost after iteration 124: 0.693137\n", + "Cost after iteration 125: 0.693137\n", + "Cost after iteration 126: 0.693137\n", + "Cost after iteration 127: 0.693137\n", + "Cost after iteration 128: 0.693137\n", + "Cost after iteration 129: 0.693136\n", + "Cost after iteration 130: 0.693136\n", + "Cost after iteration 131: 0.693136\n", + "Cost after iteration 132: 0.693136\n", + "Cost after iteration 133: 0.693136\n", + "Cost after iteration 134: 0.693136\n", + "Cost after iteration 135: 0.693135\n", + "Cost after iteration 136: 0.693135\n", + "Cost after iteration 137: 0.693135\n", + "Cost after iteration 138: 0.693135\n", + "Cost after iteration 139: 0.693135\n", + "Cost after iteration 140: 0.693135\n", + "Cost after iteration 141: 0.693134\n", + "Cost after iteration 142: 0.693134\n", + "Cost after iteration 143: 0.693134\n", + "Cost after iteration 144: 0.693134\n", + "Cost after iteration 145: 0.693134\n", + "Cost after iteration 146: 0.693133\n", + "Cost after iteration 147: 0.693133\n", + "Cost after iteration 148: 0.693133\n", + "Cost after iteration 149: 0.693133\n", + "Cost after iteration 150: 0.693133\n", + "Cost after iteration 151: 0.693132\n", + "Cost after iteration 152: 0.693132\n", + "Cost after iteration 153: 0.693132\n", + "Cost after iteration 154: 0.693132\n", + "Cost after iteration 155: 0.693132\n", + "Cost after iteration 156: 0.693131\n", + "Cost after iteration 157: 0.693131\n", + "Cost after iteration 158: 0.693131\n", + "Cost after iteration 159: 0.693131\n", + "Cost after iteration 160: 0.693130\n", + "Cost after iteration 161: 0.693130\n", + "Cost after iteration 162: 0.693130\n", + "Cost after iteration 163: 0.693130\n", + "Cost after iteration 164: 0.693129\n", + "Cost after iteration 165: 0.693129\n", + "Cost after iteration 166: 0.693129\n", + "Cost after iteration 167: 0.693129\n", + "Cost after iteration 168: 0.693128\n", + "Cost after iteration 169: 0.693128\n", + "Cost after iteration 170: 0.693128\n", + "Cost after iteration 171: 0.693127\n", + "Cost after iteration 172: 0.693127\n", + "Cost after iteration 173: 0.693127\n", + "Cost after iteration 174: 0.693127\n", + "Cost after iteration 175: 0.693126\n", + "Cost after iteration 176: 0.693126\n", + "Cost after iteration 177: 0.693126\n", + "Cost after iteration 178: 0.693125\n", + "Cost after iteration 179: 0.693125\n", + "Cost after iteration 180: 0.693125\n", + "Cost after iteration 181: 0.693124\n", + "Cost after iteration 182: 0.693124\n", + "Cost after iteration 183: 0.693124\n", + "Cost after iteration 184: 0.693123\n", + "Cost after iteration 185: 0.693123\n", + "Cost after iteration 186: 0.693122\n", + "Cost after iteration 187: 0.693122\n", + "Cost after iteration 188: 0.693122\n", + "Cost after iteration 189: 0.693121\n", + "Cost after iteration 190: 0.693121\n", + "Cost after iteration 191: 0.693120\n", + "Cost after iteration 192: 0.693120\n", + "Cost after iteration 193: 0.693119\n", + "Cost after iteration 194: 0.693119\n", + "Cost after iteration 195: 0.693119\n", + "Cost after iteration 196: 0.693118\n", + "Cost after iteration 197: 0.693118\n", + "Cost after iteration 198: 0.693117\n", + "Cost after iteration 199: 0.693116\n", + "Cost after iteration 200: 0.693116\n", + "Cost after iteration 201: 0.693115\n", + "Cost after iteration 202: 0.693115\n", + "Cost after iteration 203: 0.693114\n", + "Cost after iteration 204: 0.693114\n", + "Cost after iteration 205: 0.693113\n", + "Cost after iteration 206: 0.693112\n", + "Cost after iteration 207: 0.693112\n", + "Cost after iteration 208: 0.693111\n", + "Cost after iteration 209: 0.693110\n", + "Cost after iteration 210: 0.693109\n", + "Cost after iteration 211: 0.693109\n", + "Cost after iteration 212: 0.693108\n", + "Cost after iteration 213: 0.693107\n", + "Cost after iteration 214: 0.693106\n", + "Cost after iteration 215: 0.693105\n", + "Cost after iteration 216: 0.693104\n", + "Cost after iteration 217: 0.693103\n", + "Cost after iteration 218: 0.693102\n", + "Cost after iteration 219: 0.693101\n", + "Cost after iteration 220: 0.693100\n", + "Cost after iteration 221: 0.693099\n", + "Cost after iteration 222: 0.693098\n", + "Cost after iteration 223: 0.693097\n", + "Cost after iteration 224: 0.693096\n", + "Cost after iteration 225: 0.693094\n", + "Cost after iteration 226: 0.693093\n", + "Cost after iteration 227: 0.693092\n", + "Cost after iteration 228: 0.693090\n", + "Cost after iteration 229: 0.693089\n", + "Cost after iteration 230: 0.693087\n", + "Cost after iteration 231: 0.693085\n", + "Cost after iteration 232: 0.693084\n", + "Cost after iteration 233: 0.693082\n", + "Cost after iteration 234: 0.693080\n", + "Cost after iteration 235: 0.693078\n", + "Cost after iteration 236: 0.693076\n", + "Cost after iteration 237: 0.693073\n", + "Cost after iteration 238: 0.693071\n", + "Cost after iteration 239: 0.693069\n", + "Cost after iteration 240: 0.693066\n", + "Cost after iteration 241: 0.693063\n", + "Cost after iteration 242: 0.693060\n", + "Cost after iteration 243: 0.693057\n", + "Cost after iteration 244: 0.693054\n", + "Cost after iteration 245: 0.693051\n", + "Cost after iteration 246: 0.693047\n", + "Cost after iteration 247: 0.693043\n", + "Cost after iteration 248: 0.693039\n", + "Cost after iteration 249: 0.693035\n", + "Cost after iteration 250: 0.693030\n", + "Cost after iteration 251: 0.693025\n", + "Cost after iteration 252: 0.693020\n", + "Cost after iteration 253: 0.693015\n", + "Cost after iteration 254: 0.693009\n", + "Cost after iteration 255: 0.693002\n", + "Cost after iteration 256: 0.692995\n", + "Cost after iteration 257: 0.692988\n", + "Cost after iteration 258: 0.692980\n", + "Cost after iteration 259: 0.692971\n", + "Cost after iteration 260: 0.692962\n", + "Cost after iteration 261: 0.692952\n", + "Cost after iteration 262: 0.692941\n", + "Cost after iteration 263: 0.692929\n", + "Cost after iteration 264: 0.692917\n", + "Cost after iteration 265: 0.692902\n", + "Cost after iteration 266: 0.692887\n", + "Cost after iteration 267: 0.692870\n", + "Cost after iteration 268: 0.692852\n", + "Cost after iteration 269: 0.692831\n", + "Cost after iteration 270: 0.692809\n", + "Cost after iteration 271: 0.692784\n", + "Cost after iteration 272: 0.692756\n", + "Cost after iteration 273: 0.692725\n", + "Cost after iteration 274: 0.692691\n", + "Cost after iteration 275: 0.692653\n", + "Cost after iteration 276: 0.692610\n", + "Cost after iteration 277: 0.692561\n", + "Cost after iteration 278: 0.692507\n", + "Cost after iteration 279: 0.692445\n", + "Cost after iteration 280: 0.692375\n", + "Cost after iteration 281: 0.692295\n", + "Cost after iteration 282: 0.692205\n", + "Cost after iteration 283: 0.692101\n", + "Cost after iteration 284: 0.691983\n", + "Cost after iteration 285: 0.691846\n", + "Cost after iteration 286: 0.691690\n", + "Cost after iteration 287: 0.691510\n", + "Cost after iteration 288: 0.691302\n", + "Cost after iteration 289: 0.691061\n", + "Cost after iteration 290: 0.690784\n", + "Cost after iteration 291: 0.690464\n", + "Cost after iteration 292: 0.690094\n", + "Cost after iteration 293: 0.689668\n", + "Cost after iteration 294: 0.689177\n", + "Cost after iteration 295: 0.688614\n", + "Cost after iteration 296: 0.687970\n", + "Cost after iteration 297: 0.687237\n", + "Cost after iteration 298: 0.686406\n", + "Cost after iteration 299: 0.685469\n", + "Cost after iteration 300: 0.684420\n", + "Cost after iteration 301: 0.683255\n", + "Cost after iteration 302: 0.681968\n", + "Cost after iteration 303: 0.680559\n", + "Cost after iteration 304: 0.679030\n", + "Cost after iteration 305: 0.677381\n", + "Cost after iteration 306: 0.675620\n", + "Cost after iteration 307: 0.673752\n", + "Cost after iteration 308: 0.671786\n", + "Cost after iteration 309: 0.669732\n", + "Cost after iteration 310: 0.667599\n", + "Cost after iteration 311: 0.665399\n", + "Cost after iteration 312: 0.663141\n", + "Cost after iteration 313: 0.660836\n", + "Cost after iteration 314: 0.658492\n", + "Cost after iteration 315: 0.656120\n", + "Cost after iteration 316: 0.653726\n", + "Cost after iteration 317: 0.651318\n", + "Cost after iteration 318: 0.648904\n", + "Cost after iteration 319: 0.646488\n", + "Cost after iteration 320: 0.644076\n", + "Cost after iteration 321: 0.641672\n", + "Cost after iteration 322: 0.639280\n", + "Cost after iteration 323: 0.636904\n", + "Cost after iteration 324: 0.634544\n", + "Cost after iteration 325: 0.632202\n", + "Cost after iteration 326: 0.629878\n", + "Cost after iteration 327: 0.627573\n", + "Cost after iteration 328: 0.625288\n", + "Cost after iteration 329: 0.623024\n", + "Cost after iteration 330: 0.620787\n", + "Cost after iteration 331: 0.618584\n", + "Cost after iteration 332: 0.616423\n", + "Cost after iteration 333: 0.614315\n", + "Cost after iteration 334: 0.612266\n", + "Cost after iteration 335: 0.610284\n", + "Cost after iteration 336: 0.608370\n", + "Cost after iteration 337: 0.606526\n", + "Cost after iteration 338: 0.604750\n", + "Cost after iteration 339: 0.603039\n", + "Cost after iteration 340: 0.601389\n", + "Cost after iteration 341: 0.599798\n", + "Cost after iteration 342: 0.598260\n", + "Cost after iteration 343: 0.596773\n", + "Cost after iteration 344: 0.595332\n", + "Cost after iteration 345: 0.593935\n", + "Cost after iteration 346: 0.592578\n", + "Cost after iteration 347: 0.591258\n", + "Cost after iteration 348: 0.589973\n", + "Cost after iteration 349: 0.588721\n", + "Cost after iteration 350: 0.587499\n", + "Cost after iteration 351: 0.586304\n", + "Cost after iteration 352: 0.585136\n", + "Cost after iteration 353: 0.583992\n", + "Cost after iteration 354: 0.582871\n", + "Cost after iteration 355: 0.581770\n", + "Cost after iteration 356: 0.580690\n", + "Cost after iteration 357: 0.579627\n", + "Cost after iteration 358: 0.578582\n", + "Cost after iteration 359: 0.577553\n", + "Cost after iteration 360: 0.576538\n", + "Cost after iteration 361: 0.575537\n", + "Cost after iteration 362: 0.574548\n", + "Cost after iteration 363: 0.573571\n", + "Cost after iteration 364: 0.572605\n", + "Cost after iteration 365: 0.571649\n", + "Cost after iteration 366: 0.570703\n", + "Cost after iteration 367: 0.569764\n", + "Cost after iteration 368: 0.568834\n", + "Cost after iteration 369: 0.567910\n", + "Cost after iteration 370: 0.566992\n", + "Cost after iteration 371: 0.566080\n", + "Cost after iteration 372: 0.565173\n", + "Cost after iteration 373: 0.564270\n", + "Cost after iteration 374: 0.563371\n", + "Cost after iteration 375: 0.562475\n", + "Cost after iteration 376: 0.561582\n", + "Cost after iteration 377: 0.560690\n", + "Cost after iteration 378: 0.559799\n", + "Cost after iteration 379: 0.558909\n", + "Cost after iteration 380: 0.558019\n", + "Cost after iteration 381: 0.557129\n", + "Cost after iteration 382: 0.556236\n", + "Cost after iteration 383: 0.555341\n", + "Cost after iteration 384: 0.554443\n", + "Cost after iteration 385: 0.553540\n", + "Cost after iteration 386: 0.552630\n", + "Cost after iteration 387: 0.551712\n", + "Cost after iteration 388: 0.550783\n", + "Cost after iteration 389: 0.549837\n", + "Cost after iteration 390: 0.548869\n", + "Cost after iteration 391: 0.547868\n", + "Cost after iteration 392: 0.546814\n", + "Cost after iteration 393: 0.545674\n", + "Cost after iteration 394: 0.544373\n", + "Cost after iteration 395: 0.542747\n", + "Cost after iteration 396: 0.540378\n", + "Cost after iteration 397: 0.536149\n", + "Cost after iteration 398: 0.527639\n", + "Cost after iteration 399: 0.512699\n", + "Cost after iteration 400: 0.493338\n", + "Cost after iteration 401: 0.474928\n", + "Cost after iteration 402: 0.463618\n", + "Cost after iteration 403: 0.480918\n", + "Cost after iteration 404: 0.551833\n", + "Cost after iteration 405: 0.571246\n", + "Cost after iteration 406: 0.435535\n", + "Cost after iteration 407: 0.441931\n", + "Cost after iteration 408: 0.434542\n", + "Cost after iteration 409: 0.436242\n", + "Cost after iteration 410: 0.417449\n", + "Cost after iteration 411: 0.410554\n", + "Cost after iteration 412: 0.397101\n", + "Cost after iteration 413: 0.389498\n", + "Cost after iteration 414: 0.381916\n", + "Cost after iteration 415: 0.376427\n", + "Cost after iteration 416: 0.371607\n", + "Cost after iteration 417: 0.367499\n", + "Cost after iteration 418: 0.363756\n", + "Cost after iteration 419: 0.360298\n", + "Cost after iteration 420: 0.357032\n", + "Cost after iteration 421: 0.353921\n", + "Cost after iteration 422: 0.350935\n", + "Cost after iteration 423: 0.348061\n", + "Cost after iteration 424: 0.345286\n", + "Cost after iteration 425: 0.342604\n", + "Cost after iteration 426: 0.340007\n", + "Cost after iteration 427: 0.337492\n", + "Cost after iteration 428: 0.335055\n", + "Cost after iteration 429: 0.332690\n", + "Cost after iteration 430: 0.330395\n", + "Cost after iteration 431: 0.328167\n", + "Cost after iteration 432: 0.326003\n", + "Cost after iteration 433: 0.323899\n", + "Cost after iteration 434: 0.321853\n", + "Cost after iteration 435: 0.319862\n", + "Cost after iteration 436: 0.317924\n", + "Cost after iteration 437: 0.316037\n", + "Cost after iteration 438: 0.314198\n", + "Cost after iteration 439: 0.312405\n", + "Cost after iteration 440: 0.310657\n", + "Cost after iteration 441: 0.308951\n", + "Cost after iteration 442: 0.307285\n", + "Cost after iteration 443: 0.305659\n", + "Cost after iteration 444: 0.304071\n", + "Cost after iteration 445: 0.302518\n", + "Cost after iteration 446: 0.300999\n", + "Cost after iteration 447: 0.299514\n", + "Cost after iteration 448: 0.298061\n", + "Cost after iteration 449: 0.296638\n", + "Cost after iteration 450: 0.295244\n", + "Cost after iteration 451: 0.293879\n", + "Cost after iteration 452: 0.292540\n", + "Cost after iteration 453: 0.291228\n", + "Cost after iteration 454: 0.289942\n", + "Cost after iteration 455: 0.288679\n", + "Cost after iteration 456: 0.287440\n", + "Cost after iteration 457: 0.286223\n", + "Cost after iteration 458: 0.285028\n", + "Cost after iteration 459: 0.283854\n", + "Cost after iteration 460: 0.282700\n", + "Cost after iteration 461: 0.281566\n", + "Cost after iteration 462: 0.280450\n", + "Cost after iteration 463: 0.279353\n", + "Cost after iteration 464: 0.278274\n", + "Cost after iteration 465: 0.277211\n", + "Cost after iteration 466: 0.276165\n", + "Cost after iteration 467: 0.275135\n", + "Cost after iteration 468: 0.274120\n", + "Cost after iteration 469: 0.273120\n", + "Cost after iteration 470: 0.272135\n", + "Cost after iteration 471: 0.271163\n", + "Cost after iteration 472: 0.270206\n", + "Cost after iteration 473: 0.269261\n", + "Cost after iteration 474: 0.268329\n", + "Cost after iteration 475: 0.267410\n", + "Cost after iteration 476: 0.266503\n", + "Cost after iteration 477: 0.265607\n", + "Cost after iteration 478: 0.264723\n", + "Cost after iteration 479: 0.263850\n", + "Cost after iteration 480: 0.262988\n", + "Cost after iteration 481: 0.262137\n", + "Cost after iteration 482: 0.261296\n", + "Cost after iteration 483: 0.260464\n", + "Cost after iteration 484: 0.259643\n", + "Cost after iteration 485: 0.258831\n", + "Cost after iteration 486: 0.258028\n", + "Cost after iteration 487: 0.257235\n", + "Cost after iteration 488: 0.256450\n", + "Cost after iteration 489: 0.255674\n", + "Cost after iteration 490: 0.254906\n", + "Cost after iteration 491: 0.254147\n", + "Cost after iteration 492: 0.253396\n", + "Cost after iteration 493: 0.252653\n", + "Cost after iteration 494: 0.251918\n", + "Cost after iteration 495: 0.251190\n", + "Cost after iteration 496: 0.250470\n", + "Cost after iteration 497: 0.249758\n", + "Cost after iteration 498: 0.249052\n", + "Cost after iteration 499: 0.248354\n", + "Cost after iteration 500: 0.247663\n", + "Cost after iteration 501: 0.246979\n", + "Cost after iteration 502: 0.246302\n", + "Cost after iteration 503: 0.245631\n", + "Cost after iteration 504: 0.244968\n", + "Cost after iteration 505: 0.244310\n", + "Cost after iteration 506: 0.243659\n", + "Cost after iteration 507: 0.243015\n", + "Cost after iteration 508: 0.242377\n", + "Cost after iteration 509: 0.241745\n", + "Cost after iteration 510: 0.241119\n", + "Cost after iteration 511: 0.240500\n", + "Cost after iteration 512: 0.239886\n", + "Cost after iteration 513: 0.239279\n", + "Cost after iteration 514: 0.238677\n", + "Cost after iteration 515: 0.238081\n", + "Cost after iteration 516: 0.237491\n", + "Cost after iteration 517: 0.236907\n", + "Cost after iteration 518: 0.236329\n", + "Cost after iteration 519: 0.235756\n", + "Cost after iteration 520: 0.235190\n", + "Cost after iteration 521: 0.234629\n", + "Cost after iteration 522: 0.234077\n", + "Cost after iteration 523: 0.233537\n", + "Cost after iteration 524: 0.233019\n", + "Cost after iteration 525: 0.232549\n", + "Cost after iteration 526: 0.232206\n", + "Cost after iteration 527: 0.232197\n", + "Cost after iteration 528: 0.233150\n", + "Cost after iteration 529: 0.236846\n", + "Cost after iteration 530: 0.249298\n", + "Cost after iteration 531: 0.289908\n", + "Cost after iteration 532: 0.415066\n", + "Cost after iteration 533: 0.689740\n", + "Cost after iteration 534: 0.279399\n", + "Cost after iteration 535: 0.273907\n", + "Cost after iteration 536: 0.266330\n", + "Cost after iteration 537: 0.257667\n", + "Cost after iteration 538: 0.251756\n", + "Cost after iteration 539: 0.244553\n", + "Cost after iteration 540: 0.240910\n", + "Cost after iteration 541: 0.236780\n", + "Cost after iteration 542: 0.234707\n", + "Cost after iteration 543: 0.232619\n", + "Cost after iteration 544: 0.231400\n", + "Cost after iteration 545: 0.230243\n", + "Cost after iteration 546: 0.229419\n", + "Cost after iteration 547: 0.228637\n", + "Cost after iteration 548: 0.227989\n", + "Cost after iteration 549: 0.227364\n", + "Cost after iteration 550: 0.226800\n", + "Cost after iteration 551: 0.226248\n", + "Cost after iteration 552: 0.225730\n", + "Cost after iteration 553: 0.225219\n", + "Cost after iteration 554: 0.224731\n", + "Cost after iteration 555: 0.224250\n", + "Cost after iteration 556: 0.223790\n", + "Cost after iteration 557: 0.223339\n", + "Cost after iteration 558: 0.222913\n", + "Cost after iteration 559: 0.222502\n", + "Cost after iteration 560: 0.222131\n", + "Cost after iteration 561: 0.221789\n", + "Cost after iteration 562: 0.221526\n", + "Cost after iteration 563: 0.221334\n", + "Cost after iteration 564: 0.221324\n", + "Cost after iteration 565: 0.221506\n", + "Cost after iteration 566: 0.222186\n", + "Cost after iteration 567: 0.223459\n", + "Cost after iteration 568: 0.226328\n", + "Cost after iteration 569: 0.231373\n", + "Cost after iteration 570: 0.242369\n", + "Cost after iteration 571: 0.263507\n", + "Cost after iteration 572: 0.304958\n", + "Cost after iteration 573: 0.403236\n", + "Cost after iteration 574: 0.446702\n", + "Cost after iteration 575: 0.504966\n", + "Cost after iteration 576: 0.328972\n", + "Cost after iteration 577: 0.292834\n", + "Cost after iteration 578: 0.255294\n", + "Cost after iteration 579: 0.241659\n", + "Cost after iteration 580: 0.233466\n", + "Cost after iteration 581: 0.231332\n", + "Cost after iteration 582: 0.227821\n", + "Cost after iteration 583: 0.226526\n", + "Cost after iteration 584: 0.224618\n", + "Cost after iteration 585: 0.223651\n", + "Cost after iteration 586: 0.222483\n", + "Cost after iteration 587: 0.221735\n", + "Cost after iteration 588: 0.220920\n", + "Cost after iteration 589: 0.220304\n", + "Cost after iteration 590: 0.219664\n", + "Cost after iteration 591: 0.219124\n", + "Cost after iteration 592: 0.218575\n", + "Cost after iteration 593: 0.218081\n", + "Cost after iteration 594: 0.217582\n", + "Cost after iteration 595: 0.217116\n", + "Cost after iteration 596: 0.216648\n", + "Cost after iteration 597: 0.216203\n", + "Cost after iteration 598: 0.215756\n", + "Cost after iteration 599: 0.215326\n", + "Cost after iteration 600: 0.214895\n", + "Cost after iteration 601: 0.214478\n", + "Cost after iteration 602: 0.214060\n", + "Cost after iteration 603: 0.213655\n", + "Cost after iteration 604: 0.213251\n", + "Cost after iteration 605: 0.212859\n", + "Cost after iteration 606: 0.212467\n", + "Cost after iteration 607: 0.212089\n", + "Cost after iteration 608: 0.211712\n", + "Cost after iteration 609: 0.211352\n", + "Cost after iteration 610: 0.210992\n", + "Cost after iteration 611: 0.210655\n", + "Cost after iteration 612: 0.210319\n", + "Cost after iteration 613: 0.210015\n", + "Cost after iteration 614: 0.209715\n", + "Cost after iteration 615: 0.209464\n", + "Cost after iteration 616: 0.209222\n", + "Cost after iteration 617: 0.209069\n", + "Cost after iteration 618: 0.208936\n", + "Cost after iteration 619: 0.208975\n", + "Cost after iteration 620: 0.209068\n", + "Cost after iteration 621: 0.209540\n", + "Cost after iteration 622: 0.210163\n", + "Cost after iteration 623: 0.211719\n", + "Cost after iteration 624: 0.213772\n", + "Cost after iteration 625: 0.218469\n", + "Cost after iteration 626: 0.225177\n", + "Cost after iteration 627: 0.241029\n", + "Cost after iteration 628: 0.267183\n", + "Cost after iteration 629: 0.339497\n", + "Cost after iteration 630: 0.435604\n", + "Cost after iteration 631: 0.686827\n", + "Cost after iteration 632: 0.386111\n", + "Cost after iteration 633: 0.416022\n", + "Cost after iteration 634: 0.294550\n", + "Cost after iteration 635: 0.261221\n", + "Cost after iteration 636: 0.232309\n", + "Cost after iteration 637: 0.222849\n", + "Cost after iteration 638: 0.217465\n", + "Cost after iteration 639: 0.215244\n", + "Cost after iteration 640: 0.213714\n", + "Cost after iteration 641: 0.212813\n", + "Cost after iteration 642: 0.212093\n", + "Cost after iteration 643: 0.211522\n", + "Cost after iteration 644: 0.211010\n", + "Cost after iteration 645: 0.210543\n", + "Cost after iteration 646: 0.210098\n", + "Cost after iteration 647: 0.209672\n", + "Cost after iteration 648: 0.209257\n", + "Cost after iteration 649: 0.208852\n", + "Cost after iteration 650: 0.208455\n", + "Cost after iteration 651: 0.208065\n", + "Cost after iteration 652: 0.207681\n", + "Cost after iteration 653: 0.207304\n", + "Cost after iteration 654: 0.206932\n", + "Cost after iteration 655: 0.206565\n", + "Cost after iteration 656: 0.206204\n", + "Cost after iteration 657: 0.205847\n", + "Cost after iteration 658: 0.205496\n", + "Cost after iteration 659: 0.205150\n", + "Cost after iteration 660: 0.204808\n", + "Cost after iteration 661: 0.204472\n", + "Cost after iteration 662: 0.204140\n", + "Cost after iteration 663: 0.203814\n", + "Cost after iteration 664: 0.203492\n", + "Cost after iteration 665: 0.203175\n", + "Cost after iteration 666: 0.202863\n", + "Cost after iteration 667: 0.202556\n", + "Cost after iteration 668: 0.202254\n", + "Cost after iteration 669: 0.201956\n", + "Cost after iteration 670: 0.201664\n", + "Cost after iteration 671: 0.201376\n", + "Cost after iteration 672: 0.201093\n", + "Cost after iteration 673: 0.200815\n", + "Cost after iteration 674: 0.200542\n", + "Cost after iteration 675: 0.200274\n", + "Cost after iteration 676: 0.200010\n", + "Cost after iteration 677: 0.199752\n", + "Cost after iteration 678: 0.199498\n", + "Cost after iteration 679: 0.199251\n", + "Cost after iteration 680: 0.199009\n", + "Cost after iteration 681: 0.198774\n", + "Cost after iteration 682: 0.198549\n", + "Cost after iteration 683: 0.198338\n", + "Cost after iteration 684: 0.198150\n", + "Cost after iteration 685: 0.198004\n", + "Cost after iteration 686: 0.197939\n", + "Cost after iteration 687: 0.198047\n", + "Cost after iteration 688: 0.198510\n", + "Cost after iteration 689: 0.199814\n", + "Cost after iteration 690: 0.202975\n", + "Cost after iteration 691: 0.211184\n", + "Cost after iteration 692: 0.232227\n", + "Cost after iteration 693: 0.298141\n", + "Cost after iteration 694: 0.439819\n", + "Cost after iteration 695: 0.700675\n", + "Cost after iteration 696: 0.318693\n", + "Cost after iteration 697: 0.354213\n", + "Cost after iteration 698: 0.306831\n", + "Cost after iteration 699: 0.325881\n", + "Cost after iteration 700: 0.263182\n", + "Cost after iteration 701: 0.259535\n", + "Cost after iteration 702: 0.227974\n", + "Cost after iteration 703: 0.223516\n", + "Cost after iteration 704: 0.214248\n", + "Cost after iteration 705: 0.211718\n", + "Cost after iteration 706: 0.208165\n", + "Cost after iteration 707: 0.206693\n", + "Cost after iteration 708: 0.205085\n", + "Cost after iteration 709: 0.204194\n", + "Cost after iteration 710: 0.203327\n", + "Cost after iteration 711: 0.202727\n", + "Cost after iteration 712: 0.202158\n", + "Cost after iteration 713: 0.201699\n", + "Cost after iteration 714: 0.201262\n", + "Cost after iteration 715: 0.200877\n", + "Cost after iteration 716: 0.200506\n", + "Cost after iteration 717: 0.200163\n", + "Cost after iteration 718: 0.199830\n", + "Cost after iteration 719: 0.199514\n", + "Cost after iteration 720: 0.199207\n", + "Cost after iteration 721: 0.198912\n", + "Cost after iteration 722: 0.198624\n", + "Cost after iteration 723: 0.198346\n", + "Cost after iteration 724: 0.198074\n", + "Cost after iteration 725: 0.197811\n", + "Cost after iteration 726: 0.197555\n", + "Cost after iteration 727: 0.197308\n", + "Cost after iteration 728: 0.197067\n", + "Cost after iteration 729: 0.196837\n", + "Cost after iteration 730: 0.196614\n", + "Cost after iteration 731: 0.196405\n", + "Cost after iteration 732: 0.196208\n", + "Cost after iteration 733: 0.196032\n", + "Cost after iteration 734: 0.195877\n", + "Cost after iteration 735: 0.195763\n", + "Cost after iteration 736: 0.195698\n", + "Cost after iteration 737: 0.195731\n", + "Cost after iteration 738: 0.195888\n", + "Cost after iteration 739: 0.196318\n", + "Cost after iteration 740: 0.197120\n", + "Cost after iteration 741: 0.198805\n", + "Cost after iteration 742: 0.201790\n", + "Cost after iteration 743: 0.208228\n", + "Cost after iteration 744: 0.220544\n", + "Cost after iteration 745: 0.251390\n", + "Cost after iteration 746: 0.312040\n", + "Cost after iteration 747: 0.480524\n", + "Cost after iteration 748: 0.492140\n", + "Cost after iteration 749: 0.630011\n", + "Cost after iteration 750: 0.354532\n", + "Cost after iteration 751: 0.370739\n", + "Cost after iteration 752: 0.262515\n", + "Cost after iteration 753: 0.249373\n", + "Cost after iteration 754: 0.218654\n", + "Cost after iteration 755: 0.214057\n", + "Cost after iteration 756: 0.208254\n", + "Cost after iteration 757: 0.206219\n", + "Cost after iteration 758: 0.204375\n", + "Cost after iteration 759: 0.203409\n", + "Cost after iteration 760: 0.202615\n", + "Cost after iteration 761: 0.202049\n", + "Cost after iteration 762: 0.201556\n", + "Cost after iteration 763: 0.201133\n", + "Cost after iteration 764: 0.200741\n", + "Cost after iteration 765: 0.200375\n", + "Cost after iteration 766: 0.200026\n", + "Cost after iteration 767: 0.199690\n", + "Cost after iteration 768: 0.199365\n", + "Cost after iteration 769: 0.199049\n", + "Cost after iteration 770: 0.198741\n", + "Cost after iteration 771: 0.198440\n", + "Cost after iteration 772: 0.198146\n", + "Cost after iteration 773: 0.197859\n", + "Cost after iteration 774: 0.197578\n", + "Cost after iteration 775: 0.197303\n", + "Cost after iteration 776: 0.197033\n", + "Cost after iteration 777: 0.196769\n", + "Cost after iteration 778: 0.196511\n", + "Cost after iteration 779: 0.196258\n", + "Cost after iteration 780: 0.196011\n", + "Cost after iteration 781: 0.195768\n", + "Cost after iteration 782: 0.195531\n", + "Cost after iteration 783: 0.195299\n", + "Cost after iteration 784: 0.195071\n", + "Cost after iteration 785: 0.194849\n", + "Cost after iteration 786: 0.194631\n", + "Cost after iteration 787: 0.194418\n", + "Cost after iteration 788: 0.194210\n", + "Cost after iteration 789: 0.194006\n", + "Cost after iteration 790: 0.193807\n", + "Cost after iteration 791: 0.193612\n", + "Cost after iteration 792: 0.193421\n", + "Cost after iteration 793: 0.193235\n", + "Cost after iteration 794: 0.193053\n", + "Cost after iteration 795: 0.192876\n", + "Cost after iteration 796: 0.192703\n", + "Cost after iteration 797: 0.192533\n", + "Cost after iteration 798: 0.192369\n", + "Cost after iteration 799: 0.192208\n", + "Cost after iteration 800: 0.192053\n", + "Cost after iteration 801: 0.191902\n", + "Cost after iteration 802: 0.191757\n", + "Cost after iteration 803: 0.191619\n", + "Cost after iteration 804: 0.191489\n", + "Cost after iteration 805: 0.191372\n", + "Cost after iteration 806: 0.191272\n", + "Cost after iteration 807: 0.191201\n", + "Cost after iteration 808: 0.191172\n", + "Cost after iteration 809: 0.191229\n", + "Cost after iteration 810: 0.191411\n", + "Cost after iteration 811: 0.191875\n", + "Cost after iteration 812: 0.192759\n", + "Cost after iteration 813: 0.194709\n", + "Cost after iteration 814: 0.198233\n", + "Cost after iteration 815: 0.206542\n", + "Cost after iteration 816: 0.222389\n", + "Cost after iteration 817: 0.268342\n", + "Cost after iteration 818: 0.358855\n", + "Cost after iteration 819: 0.628240\n", + "Cost after iteration 820: 0.503760\n", + "Cost after iteration 821: 0.811366\n", + "Cost after iteration 822: 0.360964\n", + "Cost after iteration 823: 0.330009\n", + "Cost after iteration 824: 0.227297\n", + "Cost after iteration 825: 0.211782\n", + "Cost after iteration 826: 0.205488\n", + "Cost after iteration 827: 0.203191\n", + "Cost after iteration 828: 0.202056\n", + "Cost after iteration 829: 0.201366\n", + "Cost after iteration 830: 0.200823\n", + "Cost after iteration 831: 0.200349\n", + "Cost after iteration 832: 0.199911\n", + "Cost after iteration 833: 0.199497\n", + "Cost after iteration 834: 0.199102\n", + "Cost after iteration 835: 0.198723\n", + "Cost after iteration 836: 0.198359\n", + "Cost after iteration 837: 0.198007\n", + "Cost after iteration 838: 0.197669\n", + "Cost after iteration 839: 0.197342\n", + "Cost after iteration 840: 0.197026\n", + "Cost after iteration 841: 0.196720\n", + "Cost after iteration 842: 0.196424\n", + "Cost after iteration 843: 0.196137\n", + "Cost after iteration 844: 0.195860\n", + "Cost after iteration 845: 0.195590\n", + "Cost after iteration 846: 0.195328\n", + "Cost after iteration 847: 0.195074\n", + "Cost after iteration 848: 0.194827\n", + "Cost after iteration 849: 0.194587\n", + "Cost after iteration 850: 0.194354\n", + "Cost after iteration 851: 0.194127\n", + "Cost after iteration 852: 0.193906\n", + "Cost after iteration 853: 0.193691\n", + "Cost after iteration 854: 0.193482\n", + "Cost after iteration 855: 0.193278\n", + "Cost after iteration 856: 0.193080\n", + "Cost after iteration 857: 0.192886\n", + "Cost after iteration 858: 0.192698\n", + "Cost after iteration 859: 0.192514\n", + "Cost after iteration 860: 0.192336\n", + "Cost after iteration 861: 0.192161\n", + "Cost after iteration 862: 0.191991\n", + "Cost after iteration 863: 0.191826\n", + "Cost after iteration 864: 0.191664\n", + "Cost after iteration 865: 0.191507\n", + "Cost after iteration 866: 0.191353\n", + "Cost after iteration 867: 0.191204\n", + "Cost after iteration 868: 0.191058\n", + "Cost after iteration 869: 0.190915\n", + "Cost after iteration 870: 0.190777\n", + "Cost after iteration 871: 0.190641\n", + "Cost after iteration 872: 0.190510\n", + "Cost after iteration 873: 0.190381\n", + "Cost after iteration 874: 0.190255\n", + "Cost after iteration 875: 0.190133\n", + "Cost after iteration 876: 0.190014\n", + "Cost after iteration 877: 0.189897\n", + "Cost after iteration 878: 0.189783\n", + "Cost after iteration 879: 0.189673\n", + "Cost after iteration 880: 0.189564\n", + "Cost after iteration 881: 0.189459\n", + "Cost after iteration 882: 0.189356\n", + "Cost after iteration 883: 0.189255\n", + "Cost after iteration 884: 0.189157\n", + "Cost after iteration 885: 0.189061\n", + "Cost after iteration 886: 0.188968\n", + "Cost after iteration 887: 0.188877\n", + "Cost after iteration 888: 0.188788\n", + "Cost after iteration 889: 0.188701\n", + "Cost after iteration 890: 0.188616\n", + "Cost after iteration 891: 0.188532\n", + "Cost after iteration 892: 0.188451\n", + "Cost after iteration 893: 0.188372\n", + "Cost after iteration 894: 0.188295\n", + "Cost after iteration 895: 0.188220\n", + "Cost after iteration 896: 0.188146\n", + "Cost after iteration 897: 0.188076\n", + "Cost after iteration 898: 0.188008\n", + "Cost after iteration 899: 0.187946\n", + "Cost after iteration 900: 0.187892\n", + "Cost after iteration 901: 0.187857\n", + "Cost after iteration 902: 0.187857\n", + "Cost after iteration 903: 0.187935\n", + "Cost after iteration 904: 0.188178\n", + "Cost after iteration 905: 0.188814\n", + "Cost after iteration 906: 0.190274\n", + "Cost after iteration 907: 0.193949\n", + "Cost after iteration 908: 0.202259\n", + "Cost after iteration 909: 0.226930\n", + "Cost after iteration 910: 0.290091\n", + "Cost after iteration 911: 0.515634\n", + "Cost after iteration 912: 0.552856\n", + "Cost after iteration 913: 0.844726\n", + "Cost after iteration 914: 0.368204\n", + "Cost after iteration 915: 0.498498\n", + "Cost after iteration 916: 0.236596\n", + "Cost after iteration 917: 0.222691\n", + "Cost after iteration 918: 0.205518\n", + "Cost after iteration 919: 0.201814\n", + "Cost after iteration 920: 0.199648\n", + "Cost after iteration 921: 0.198621\n", + "Cost after iteration 922: 0.197925\n", + "Cost after iteration 923: 0.197397\n", + "Cost after iteration 924: 0.196939\n", + "Cost after iteration 925: 0.196524\n", + "Cost after iteration 926: 0.196136\n", + "Cost after iteration 927: 0.195769\n", + "Cost after iteration 928: 0.195421\n", + "Cost after iteration 929: 0.195089\n", + "Cost after iteration 930: 0.194772\n", + "Cost after iteration 931: 0.194469\n", + "Cost after iteration 932: 0.194179\n", + "Cost after iteration 933: 0.193902\n", + "Cost after iteration 934: 0.193635\n", + "Cost after iteration 935: 0.193380\n", + "Cost after iteration 936: 0.193134\n", + "Cost after iteration 937: 0.192899\n", + "Cost after iteration 938: 0.192672\n", + "Cost after iteration 939: 0.192454\n", + "Cost after iteration 940: 0.192243\n", + "Cost after iteration 941: 0.192041\n", + "Cost after iteration 942: 0.191846\n", + "Cost after iteration 943: 0.191657\n", + "Cost after iteration 944: 0.191475\n", + "Cost after iteration 945: 0.191299\n", + "Cost after iteration 946: 0.191129\n", + "Cost after iteration 947: 0.190965\n", + "Cost after iteration 948: 0.190806\n", + "Cost after iteration 949: 0.190652\n", + "Cost after iteration 950: 0.190503\n", + "Cost after iteration 951: 0.190359\n", + "Cost after iteration 952: 0.190219\n", + "Cost after iteration 953: 0.190083\n", + "Cost after iteration 954: 0.189952\n", + "Cost after iteration 955: 0.189824\n", + "Cost after iteration 956: 0.189700\n", + "Cost after iteration 957: 0.189580\n", + "Cost after iteration 958: 0.189463\n", + "Cost after iteration 959: 0.189350\n", + "Cost after iteration 960: 0.189239\n", + "Cost after iteration 961: 0.189132\n", + "Cost after iteration 962: 0.189028\n", + "Cost after iteration 963: 0.188927\n", + "Cost after iteration 964: 0.188828\n", + "Cost after iteration 965: 0.188733\n", + "Cost after iteration 966: 0.188639\n", + "Cost after iteration 967: 0.188549\n", + "Cost after iteration 968: 0.188460\n", + "Cost after iteration 969: 0.188374\n", + "Cost after iteration 970: 0.188290\n", + "Cost after iteration 971: 0.188209\n", + "Cost after iteration 972: 0.188129\n", + "Cost after iteration 973: 0.188052\n", + "Cost after iteration 974: 0.187976\n", + "Cost after iteration 975: 0.187903\n", + "Cost after iteration 976: 0.187831\n", + "Cost after iteration 977: 0.187761\n", + "Cost after iteration 978: 0.187692\n", + "Cost after iteration 979: 0.187625\n", + "Cost after iteration 980: 0.187560\n", + "Cost after iteration 981: 0.187497\n", + "Cost after iteration 982: 0.187435\n", + "Cost after iteration 983: 0.187375\n", + "Cost after iteration 984: 0.187316\n", + "Cost after iteration 985: 0.187259\n", + "Cost after iteration 986: 0.187204\n", + "Cost after iteration 987: 0.187152\n", + "Cost after iteration 988: 0.187104\n", + "Cost after iteration 989: 0.187062\n", + "Cost after iteration 990: 0.187031\n", + "Cost after iteration 991: 0.187021\n", + "Cost after iteration 992: 0.187049\n", + "Cost after iteration 993: 0.187155\n", + "Cost after iteration 994: 0.187406\n", + "Cost after iteration 995: 0.187981\n", + "Cost after iteration 996: 0.189145\n", + "Cost after iteration 997: 0.191784\n", + "Cost after iteration 998: 0.197019\n", + "Cost after iteration 999: 0.210460\n", + "Cost after iteration 1000: 0.239388\n", + "Cost after iteration 1001: 0.343754\n", + "Cost after iteration 1002: 0.487598\n", + "Cost after iteration 1003: 0.802472\n", + "Cost after iteration 1004: 0.360986\n", + "Cost after iteration 1005: 0.505229\n", + "Cost after iteration 1006: 0.272805\n", + "Cost after iteration 1007: 0.258848\n", + "Cost after iteration 1008: 0.212135\n", + "Cost after iteration 1009: 0.204471\n", + "Cost after iteration 1010: 0.199128\n", + "Cost after iteration 1011: 0.196896\n", + "Cost after iteration 1012: 0.195585\n", + "Cost after iteration 1013: 0.194854\n", + "Cost after iteration 1014: 0.194336\n", + "Cost after iteration 1015: 0.193936\n", + "Cost after iteration 1016: 0.193592\n", + "Cost after iteration 1017: 0.193283\n", + "Cost after iteration 1018: 0.192996\n", + "Cost after iteration 1019: 0.192727\n", + "Cost after iteration 1020: 0.192473\n", + "Cost after iteration 1021: 0.192230\n", + "Cost after iteration 1022: 0.191999\n", + "Cost after iteration 1023: 0.191778\n", + "Cost after iteration 1024: 0.191567\n", + "Cost after iteration 1025: 0.191365\n", + "Cost after iteration 1026: 0.191171\n", + "Cost after iteration 1027: 0.190985\n", + "Cost after iteration 1028: 0.190807\n", + "Cost after iteration 1029: 0.190635\n", + "Cost after iteration 1030: 0.190471\n", + "Cost after iteration 1031: 0.190312\n", + "Cost after iteration 1032: 0.190160\n", + "Cost after iteration 1033: 0.190013\n", + "Cost after iteration 1034: 0.189871\n", + "Cost after iteration 1035: 0.189735\n", + "Cost after iteration 1036: 0.189603\n", + "Cost after iteration 1037: 0.189476\n", + "Cost after iteration 1038: 0.189353\n", + "Cost after iteration 1039: 0.189234\n", + "Cost after iteration 1040: 0.189120\n", + "Cost after iteration 1041: 0.189009\n", + "Cost after iteration 1042: 0.188902\n", + "Cost after iteration 1043: 0.188798\n", + "Cost after iteration 1044: 0.188697\n", + "Cost after iteration 1045: 0.188599\n", + "Cost after iteration 1046: 0.188505\n", + "Cost after iteration 1047: 0.188413\n", + "Cost after iteration 1048: 0.188324\n", + "Cost after iteration 1049: 0.188238\n", + "Cost after iteration 1050: 0.188154\n", + "Cost after iteration 1051: 0.188073\n", + "Cost after iteration 1052: 0.187994\n", + "Cost after iteration 1053: 0.187917\n", + "Cost after iteration 1054: 0.187842\n", + "Cost after iteration 1055: 0.187769\n", + "Cost after iteration 1056: 0.187699\n", + "Cost after iteration 1057: 0.187630\n", + "Cost after iteration 1058: 0.187563\n", + "Cost after iteration 1059: 0.187498\n", + "Cost after iteration 1060: 0.187434\n", + "Cost after iteration 1061: 0.187373\n", + "Cost after iteration 1062: 0.187313\n", + "Cost after iteration 1063: 0.187254\n", + "Cost after iteration 1064: 0.187198\n", + "Cost after iteration 1065: 0.187143\n", + "Cost after iteration 1066: 0.187090\n", + "Cost after iteration 1067: 0.187040\n", + "Cost after iteration 1068: 0.186992\n", + "Cost after iteration 1069: 0.186949\n", + "Cost after iteration 1070: 0.186911\n", + "Cost after iteration 1071: 0.186883\n", + "Cost after iteration 1072: 0.186870\n", + "Cost after iteration 1073: 0.186883\n", + "Cost after iteration 1074: 0.186938\n", + "Cost after iteration 1075: 0.187074\n", + "Cost after iteration 1076: 0.187339\n", + "Cost after iteration 1077: 0.187876\n", + "Cost after iteration 1078: 0.188828\n", + "Cost after iteration 1079: 0.190774\n", + "Cost after iteration 1080: 0.194141\n", + "Cost after iteration 1081: 0.201730\n", + "Cost after iteration 1082: 0.215187\n", + "Cost after iteration 1083: 0.254884\n", + "Cost after iteration 1084: 0.326009\n", + "Cost after iteration 1085: 0.546542\n", + "Cost after iteration 1086: 0.487767\n", + "Cost after iteration 1087: 0.743877\n", + "Cost after iteration 1088: 0.385735\n", + "Cost after iteration 1089: 0.432577\n", + "Cost after iteration 1090: 0.239957\n", + "Cost after iteration 1091: 0.219154\n", + "Cost after iteration 1092: 0.203812\n", + "Cost after iteration 1093: 0.199505\n", + "Cost after iteration 1094: 0.197329\n", + "Cost after iteration 1095: 0.196385\n", + "Cost after iteration 1096: 0.195788\n", + "Cost after iteration 1097: 0.195353\n", + "Cost after iteration 1098: 0.194980\n", + "Cost after iteration 1099: 0.194642\n", + "Cost after iteration 1100: 0.194326\n", + "Cost after iteration 1101: 0.194025\n", + "Cost after iteration 1102: 0.193739\n", + "Cost after iteration 1103: 0.193465\n", + "Cost after iteration 1104: 0.193203\n", + "Cost after iteration 1105: 0.192952\n", + "Cost after iteration 1106: 0.192712\n", + "Cost after iteration 1107: 0.192481\n", + "Cost after iteration 1108: 0.192259\n", + "Cost after iteration 1109: 0.192046\n", + "Cost after iteration 1110: 0.191841\n", + "Cost after iteration 1111: 0.191644\n", + "Cost after iteration 1112: 0.191454\n", + "Cost after iteration 1113: 0.191272\n", + "Cost after iteration 1114: 0.191096\n", + "Cost after iteration 1115: 0.190926\n", + "Cost after iteration 1116: 0.190763\n", + "Cost after iteration 1117: 0.190605\n", + "Cost after iteration 1118: 0.190453\n", + "Cost after iteration 1119: 0.190306\n", + "Cost after iteration 1120: 0.190164\n", + "Cost after iteration 1121: 0.190027\n", + "Cost after iteration 1122: 0.189894\n", + "Cost after iteration 1123: 0.189766\n", + "Cost after iteration 1124: 0.189642\n", + "Cost after iteration 1125: 0.189521\n", + "Cost after iteration 1126: 0.189405\n", + "Cost after iteration 1127: 0.189292\n", + "Cost after iteration 1128: 0.189183\n", + "Cost after iteration 1129: 0.189077\n", + "Cost after iteration 1130: 0.188974\n", + "Cost after iteration 1131: 0.188874\n", + "Cost after iteration 1132: 0.188777\n", + "Cost after iteration 1133: 0.188683\n", + "Cost after iteration 1134: 0.188592\n", + "Cost after iteration 1135: 0.188503\n", + "Cost after iteration 1136: 0.188417\n", + "Cost after iteration 1137: 0.188334\n", + "Cost after iteration 1138: 0.188252\n", + "Cost after iteration 1139: 0.188173\n", + "Cost after iteration 1140: 0.188096\n", + "Cost after iteration 1141: 0.188022\n", + "Cost after iteration 1142: 0.187949\n", + "Cost after iteration 1143: 0.187878\n", + "Cost after iteration 1144: 0.187809\n", + "Cost after iteration 1145: 0.187742\n", + "Cost after iteration 1146: 0.187677\n", + "Cost after iteration 1147: 0.187613\n", + "Cost after iteration 1148: 0.187551\n", + "Cost after iteration 1149: 0.187491\n", + "Cost after iteration 1150: 0.187432\n", + "Cost after iteration 1151: 0.187375\n", + "Cost after iteration 1152: 0.187319\n", + "Cost after iteration 1153: 0.187264\n", + "Cost after iteration 1154: 0.187211\n", + "Cost after iteration 1155: 0.187159\n", + "Cost after iteration 1156: 0.187108\n", + "Cost after iteration 1157: 0.187058\n", + "Cost after iteration 1158: 0.187010\n", + "Cost after iteration 1159: 0.186963\n", + "Cost after iteration 1160: 0.186917\n", + "Cost after iteration 1161: 0.186872\n", + "Cost after iteration 1162: 0.186828\n", + "Cost after iteration 1163: 0.186785\n", + "Cost after iteration 1164: 0.186743\n", + "Cost after iteration 1165: 0.186701\n", + "Cost after iteration 1166: 0.186661\n", + "Cost after iteration 1167: 0.186622\n", + "Cost after iteration 1168: 0.186583\n", + "Cost after iteration 1169: 0.186546\n", + "Cost after iteration 1170: 0.186509\n", + "Cost after iteration 1171: 0.186472\n", + "Cost after iteration 1172: 0.186437\n", + "Cost after iteration 1173: 0.186402\n", + "Cost after iteration 1174: 0.186369\n", + "Cost after iteration 1175: 0.186335\n", + "Cost after iteration 1176: 0.186303\n", + "Cost after iteration 1177: 0.186272\n", + "Cost after iteration 1178: 0.186241\n", + "Cost after iteration 1179: 0.186212\n", + "Cost after iteration 1180: 0.186186\n", + "Cost after iteration 1181: 0.186162\n", + "Cost after iteration 1182: 0.186145\n", + "Cost after iteration 1183: 0.186138\n", + "Cost after iteration 1184: 0.186149\n", + "Cost after iteration 1185: 0.186198\n", + "Cost after iteration 1186: 0.186311\n", + "Cost after iteration 1187: 0.186569\n", + "Cost after iteration 1188: 0.187053\n", + "Cost after iteration 1189: 0.188147\n", + "Cost after iteration 1190: 0.190049\n", + "Cost after iteration 1191: 0.194806\n", + "Cost after iteration 1192: 0.202568\n", + "Cost after iteration 1193: 0.225095\n", + "Cost after iteration 1194: 0.253316\n", + "Cost after iteration 1195: 0.361882\n", + "Cost after iteration 1196: 0.410356\n", + "Cost after iteration 1197: 0.866247\n", + "Cost after iteration 1198: 0.504444\n", + "Cost after iteration 1199: 0.619878\n", + "Cost after iteration 1200: 0.253694\n", + "Cost after iteration 1201: 0.224274\n", + "Cost after iteration 1202: 0.206850\n", + "Cost after iteration 1203: 0.199933\n", + "Cost after iteration 1204: 0.197388\n", + "Cost after iteration 1205: 0.196263\n", + "Cost after iteration 1206: 0.195640\n", + "Cost after iteration 1207: 0.195177\n", + "Cost after iteration 1208: 0.194777\n", + "Cost after iteration 1209: 0.194410\n", + "Cost after iteration 1210: 0.194065\n", + "Cost after iteration 1211: 0.193740\n", + "Cost after iteration 1212: 0.193431\n", + "Cost after iteration 1213: 0.193137\n", + "Cost after iteration 1214: 0.192858\n", + "Cost after iteration 1215: 0.192592\n", + "Cost after iteration 1216: 0.192339\n", + "Cost after iteration 1217: 0.192098\n", + "Cost after iteration 1218: 0.191868\n", + "Cost after iteration 1219: 0.191648\n", + "Cost after iteration 1220: 0.191439\n", + "Cost after iteration 1221: 0.191239\n", + "Cost after iteration 1222: 0.191048\n", + "Cost after iteration 1223: 0.190865\n", + "Cost after iteration 1224: 0.190690\n", + "Cost after iteration 1225: 0.190522\n", + "Cost after iteration 1226: 0.190362\n", + "Cost after iteration 1227: 0.190208\n", + "Cost after iteration 1228: 0.190060\n", + "Cost after iteration 1229: 0.189919\n", + "Cost after iteration 1230: 0.189782\n", + "Cost after iteration 1231: 0.189652\n", + "Cost after iteration 1232: 0.189526\n", + "Cost after iteration 1233: 0.189405\n", + "Cost after iteration 1234: 0.189288\n", + "Cost after iteration 1235: 0.189176\n", + "Cost after iteration 1236: 0.189068\n", + "Cost after iteration 1237: 0.188963\n", + "Cost after iteration 1238: 0.188863\n", + "Cost after iteration 1239: 0.188765\n", + "Cost after iteration 1240: 0.188671\n", + "Cost after iteration 1241: 0.188581\n", + "Cost after iteration 1242: 0.188493\n", + "Cost after iteration 1243: 0.188408\n", + "Cost after iteration 1244: 0.188326\n", + "Cost after iteration 1245: 0.188246\n", + "Cost after iteration 1246: 0.188169\n", + "Cost after iteration 1247: 0.188094\n", + "Cost after iteration 1248: 0.188021\n", + "Cost after iteration 1249: 0.187951\n", + "Cost after iteration 1250: 0.187883\n", + "Cost after iteration 1251: 0.187816\n", + "Cost after iteration 1252: 0.187752\n", + "Cost after iteration 1253: 0.187689\n", + "Cost after iteration 1254: 0.187628\n", + "Cost after iteration 1255: 0.187569\n", + "Cost after iteration 1256: 0.187512\n", + "Cost after iteration 1257: 0.187456\n", + "Cost after iteration 1258: 0.187401\n", + "Cost after iteration 1259: 0.187348\n", + "Cost after iteration 1260: 0.187296\n", + "Cost after iteration 1261: 0.187246\n", + "Cost after iteration 1262: 0.187197\n", + "Cost after iteration 1263: 0.187149\n", + "Cost after iteration 1264: 0.187102\n", + "Cost after iteration 1265: 0.187056\n", + "Cost after iteration 1266: 0.187012\n", + "Cost after iteration 1267: 0.186968\n", + "Cost after iteration 1268: 0.186926\n", + "Cost after iteration 1269: 0.186885\n", + "Cost after iteration 1270: 0.186844\n", + "Cost after iteration 1271: 0.186805\n", + "Cost after iteration 1272: 0.186766\n", + "Cost after iteration 1273: 0.186728\n", + "Cost after iteration 1274: 0.186691\n", + "Cost after iteration 1275: 0.186655\n", + "Cost after iteration 1276: 0.186619\n", + "Cost after iteration 1277: 0.186585\n", + "Cost after iteration 1278: 0.186551\n", + "Cost after iteration 1279: 0.186517\n", + "Cost after iteration 1280: 0.186485\n", + "Cost after iteration 1281: 0.186453\n", + "Cost after iteration 1282: 0.186421\n", + "Cost after iteration 1283: 0.186391\n", + "Cost after iteration 1284: 0.186361\n", + "Cost after iteration 1285: 0.186331\n", + "Cost after iteration 1286: 0.186302\n", + "Cost after iteration 1287: 0.186274\n", + "Cost after iteration 1288: 0.186246\n", + "Cost after iteration 1289: 0.186218\n", + "Cost after iteration 1290: 0.186192\n", + "Cost after iteration 1291: 0.186165\n", + "Cost after iteration 1292: 0.186139\n", + "Cost after iteration 1293: 0.186114\n", + "Cost after iteration 1294: 0.186089\n", + "Cost after iteration 1295: 0.186064\n", + "Cost after iteration 1296: 0.186040\n", + "Cost after iteration 1297: 0.186016\n", + "Cost after iteration 1298: 0.185993\n", + "Cost after iteration 1299: 0.185970\n", + "Cost after iteration 1300: 0.185948\n", + "Cost after iteration 1301: 0.185928\n", + "Cost after iteration 1302: 0.185909\n", + "Cost after iteration 1303: 0.185893\n", + "Cost after iteration 1304: 0.185882\n", + "Cost after iteration 1305: 0.185882\n", + "Cost after iteration 1306: 0.185901\n", + "Cost after iteration 1307: 0.185960\n", + "Cost after iteration 1308: 0.186090\n", + "Cost after iteration 1309: 0.186384\n", + "Cost after iteration 1310: 0.186947\n", + "Cost after iteration 1311: 0.188239\n", + "Cost after iteration 1312: 0.190560\n", + "Cost after iteration 1313: 0.196500\n", + "Cost after iteration 1314: 0.206533\n", + "Cost after iteration 1315: 0.236437\n", + "Cost after iteration 1316: 0.272363\n", + "Cost after iteration 1317: 0.426051\n", + "Cost after iteration 1318: 0.479708\n", + "Cost after iteration 1319: 1.074142\n", + "Cost after iteration 1320: 0.301527\n", + "Cost after iteration 1321: 0.288918\n", + "Cost after iteration 1322: 0.235305\n", + "Cost after iteration 1323: 0.221219\n", + "Cost after iteration 1324: 0.208518\n", + "Cost after iteration 1325: 0.201758\n", + "Cost after iteration 1326: 0.197874\n", + "Cost after iteration 1327: 0.195740\n", + "Cost after iteration 1328: 0.194568\n", + "Cost after iteration 1329: 0.193857\n", + "Cost after iteration 1330: 0.193359\n", + "Cost after iteration 1331: 0.192967\n", + "Cost after iteration 1332: 0.192630\n", + "Cost after iteration 1333: 0.192327\n", + "Cost after iteration 1334: 0.192047\n", + "Cost after iteration 1335: 0.191786\n", + "Cost after iteration 1336: 0.191540\n", + "Cost after iteration 1337: 0.191308\n", + "Cost after iteration 1338: 0.191089\n", + "Cost after iteration 1339: 0.190880\n", + "Cost after iteration 1340: 0.190683\n", + "Cost after iteration 1341: 0.190495\n", + "Cost after iteration 1342: 0.190317\n", + "Cost after iteration 1343: 0.190147\n", + "Cost after iteration 1344: 0.189985\n", + "Cost after iteration 1345: 0.189832\n", + "Cost after iteration 1346: 0.189685\n", + "Cost after iteration 1347: 0.189545\n", + "Cost after iteration 1348: 0.189411\n", + "Cost after iteration 1349: 0.189283\n", + "Cost after iteration 1350: 0.189161\n", + "Cost after iteration 1351: 0.189044\n", + "Cost after iteration 1352: 0.188933\n", + "Cost after iteration 1353: 0.188825\n", + "Cost after iteration 1354: 0.188723\n", + "Cost after iteration 1355: 0.188624\n", + "Cost after iteration 1356: 0.188529\n", + "Cost after iteration 1357: 0.188438\n", + "Cost after iteration 1358: 0.188351\n", + "Cost after iteration 1359: 0.188266\n", + "Cost after iteration 1360: 0.188185\n", + "Cost after iteration 1361: 0.188107\n", + "Cost after iteration 1362: 0.188031\n", + "Cost after iteration 1363: 0.187959\n", + "Cost after iteration 1364: 0.187888\n", + "Cost after iteration 1365: 0.187820\n", + "Cost after iteration 1366: 0.187755\n", + "Cost after iteration 1367: 0.187691\n", + "Cost after iteration 1368: 0.187630\n", + "Cost after iteration 1369: 0.187570\n", + "Cost after iteration 1370: 0.187512\n", + "Cost after iteration 1371: 0.187456\n", + "Cost after iteration 1372: 0.187402\n", + "Cost after iteration 1373: 0.187349\n", + "Cost after iteration 1374: 0.187298\n", + "Cost after iteration 1375: 0.187248\n", + "Cost after iteration 1376: 0.187200\n", + "Cost after iteration 1377: 0.187152\n", + "Cost after iteration 1378: 0.187107\n", + "Cost after iteration 1379: 0.187062\n", + "Cost after iteration 1380: 0.187018\n", + "Cost after iteration 1381: 0.186976\n", + "Cost after iteration 1382: 0.186935\n", + "Cost after iteration 1383: 0.186894\n", + "Cost after iteration 1384: 0.186855\n", + "Cost after iteration 1385: 0.186816\n", + "Cost after iteration 1386: 0.186779\n", + "Cost after iteration 1387: 0.186742\n", + "Cost after iteration 1388: 0.186707\n", + "Cost after iteration 1389: 0.186672\n", + "Cost after iteration 1390: 0.186638\n", + "Cost after iteration 1391: 0.186605\n", + "Cost after iteration 1392: 0.186573\n", + "Cost after iteration 1393: 0.186543\n", + "Cost after iteration 1394: 0.186513\n", + "Cost after iteration 1395: 0.186486\n", + "Cost after iteration 1396: 0.186460\n", + "Cost after iteration 1397: 0.186438\n", + "Cost after iteration 1398: 0.186421\n", + "Cost after iteration 1399: 0.186412\n", + "Cost after iteration 1400: 0.186413\n", + "Cost after iteration 1401: 0.186434\n", + "Cost after iteration 1402: 0.186484\n", + "Cost after iteration 1403: 0.186585\n", + "Cost after iteration 1404: 0.186761\n", + "Cost after iteration 1405: 0.187083\n", + "Cost after iteration 1406: 0.187609\n", + "Cost after iteration 1407: 0.188576\n", + "Cost after iteration 1408: 0.190108\n", + "Cost after iteration 1409: 0.193084\n", + "Cost after iteration 1410: 0.197694\n", + "Cost after iteration 1411: 0.207942\n", + "Cost after iteration 1412: 0.223901\n", + "Cost after iteration 1413: 0.273506\n", + "Cost after iteration 1414: 0.341873\n", + "Cost after iteration 1415: 0.558167\n", + "Cost after iteration 1416: 0.458713\n", + "Cost after iteration 1417: 0.682840\n", + "Cost after iteration 1418: 0.371043\n", + "Cost after iteration 1419: 0.392332\n", + "Cost after iteration 1420: 0.237753\n", + "Cost after iteration 1421: 0.217602\n", + "Cost after iteration 1422: 0.202404\n", + "Cost after iteration 1423: 0.198108\n", + "Cost after iteration 1424: 0.195762\n", + "Cost after iteration 1425: 0.194800\n", + "Cost after iteration 1426: 0.194210\n", + "Cost after iteration 1427: 0.193812\n", + "Cost after iteration 1428: 0.193483\n", + "Cost after iteration 1429: 0.193192\n", + "Cost after iteration 1430: 0.192923\n", + "Cost after iteration 1431: 0.192669\n", + "Cost after iteration 1432: 0.192428\n", + "Cost after iteration 1433: 0.192198\n", + "Cost after iteration 1434: 0.191978\n", + "Cost after iteration 1435: 0.191767\n", + "Cost after iteration 1436: 0.191566\n", + "Cost after iteration 1437: 0.191373\n", + "Cost after iteration 1438: 0.191188\n", + "Cost after iteration 1439: 0.191011\n", + "Cost after iteration 1440: 0.190841\n", + "Cost after iteration 1441: 0.190677\n", + "Cost after iteration 1442: 0.190521\n", + "Cost after iteration 1443: 0.190370\n", + "Cost after iteration 1444: 0.190225\n", + "Cost after iteration 1445: 0.190086\n", + "Cost after iteration 1446: 0.189953\n", + "Cost after iteration 1447: 0.189824\n", + "Cost after iteration 1448: 0.189700\n", + "Cost after iteration 1449: 0.189580\n", + "Cost after iteration 1450: 0.189465\n", + "Cost after iteration 1451: 0.189354\n", + "Cost after iteration 1452: 0.189247\n", + "Cost after iteration 1453: 0.189144\n", + "Cost after iteration 1454: 0.189044\n", + "Cost after iteration 1455: 0.188947\n", + "Cost after iteration 1456: 0.188854\n", + "Cost after iteration 1457: 0.188764\n", + "Cost after iteration 1458: 0.188677\n", + "Cost after iteration 1459: 0.188593\n", + "Cost after iteration 1460: 0.188511\n", + "Cost after iteration 1461: 0.188432\n", + "Cost after iteration 1462: 0.188356\n", + "Cost after iteration 1463: 0.188282\n", + "Cost after iteration 1464: 0.188210\n", + "Cost after iteration 1465: 0.188140\n", + "Cost after iteration 1466: 0.188072\n", + "Cost after iteration 1467: 0.188007\n", + "Cost after iteration 1468: 0.187943\n", + "Cost after iteration 1469: 0.187881\n", + "Cost after iteration 1470: 0.187821\n", + "Cost after iteration 1471: 0.187763\n", + "Cost after iteration 1472: 0.187706\n", + "Cost after iteration 1473: 0.187650\n", + "Cost after iteration 1474: 0.187597\n", + "Cost after iteration 1475: 0.187544\n", + "Cost after iteration 1476: 0.187494\n", + "Cost after iteration 1477: 0.187444\n", + "Cost after iteration 1478: 0.187396\n", + "Cost after iteration 1479: 0.187349\n", + "Cost after iteration 1480: 0.187303\n", + "Cost after iteration 1481: 0.187258\n", + "Cost after iteration 1482: 0.187215\n", + "Cost after iteration 1483: 0.187172\n", + "Cost after iteration 1484: 0.187131\n", + "Cost after iteration 1485: 0.187090\n", + "Cost after iteration 1486: 0.187051\n", + "Cost after iteration 1487: 0.187012\n", + "Cost after iteration 1488: 0.186975\n", + "Cost after iteration 1489: 0.186938\n", + "Cost after iteration 1490: 0.186902\n", + "Cost after iteration 1491: 0.186867\n", + "Cost after iteration 1492: 0.186833\n", + "Cost after iteration 1493: 0.186799\n", + "Cost after iteration 1494: 0.186766\n", + "Cost after iteration 1495: 0.186734\n", + "Cost after iteration 1496: 0.186703\n", + "Cost after iteration 1497: 0.186672\n", + "Cost after iteration 1498: 0.186642\n", + "Cost after iteration 1499: 0.186612\n", + "Cost after iteration 1500: 0.186584\n", + "Cost after iteration 1501: 0.186555\n", + "Cost after iteration 1502: 0.186527\n", + "Cost after iteration 1503: 0.186500\n", + "Cost after iteration 1504: 0.186474\n", + "Cost after iteration 1505: 0.186448\n", + "Cost after iteration 1506: 0.186422\n", + "Cost after iteration 1507: 0.186397\n", + "Cost after iteration 1508: 0.186373\n", + "Cost after iteration 1509: 0.186349\n", + "Cost after iteration 1510: 0.186326\n", + "Cost after iteration 1511: 0.186304\n", + "Cost after iteration 1512: 0.186283\n", + "Cost after iteration 1513: 0.186265\n", + "Cost after iteration 1514: 0.186250\n", + "Cost after iteration 1515: 0.186243\n", + "Cost after iteration 1516: 0.186246\n", + "Cost after iteration 1517: 0.186271\n", + "Cost after iteration 1518: 0.186332\n", + "Cost after iteration 1519: 0.186474\n", + "Cost after iteration 1520: 0.186728\n", + "Cost after iteration 1521: 0.187304\n", + "Cost after iteration 1522: 0.188242\n", + "Cost after iteration 1523: 0.190578\n", + "Cost after iteration 1524: 0.194099\n", + "Cost after iteration 1525: 0.204383\n", + "Cost after iteration 1526: 0.217624\n", + "Cost after iteration 1527: 0.263054\n", + "Cost after iteration 1528: 0.273926\n", + "Cost after iteration 1529: 0.397693\n", + "Cost after iteration 1530: 0.297145\n", + "Cost after iteration 1531: 0.375518\n", + "Cost after iteration 1532: 0.304629\n", + "Cost after iteration 1533: 0.432783\n", + "Cost after iteration 1534: 0.405080\n", + "Cost after iteration 1535: 0.491787\n", + "Cost after iteration 1536: 0.276543\n", + "Cost after iteration 1537: 0.258342\n", + "Cost after iteration 1538: 0.218542\n", + "Cost after iteration 1539: 0.204287\n", + "Cost after iteration 1540: 0.197243\n", + "Cost after iteration 1541: 0.194521\n", + "Cost after iteration 1542: 0.193365\n", + "Cost after iteration 1543: 0.192811\n", + "Cost after iteration 1544: 0.192448\n", + "Cost after iteration 1545: 0.192166\n", + "Cost after iteration 1546: 0.191920\n", + "Cost after iteration 1547: 0.191695\n", + "Cost after iteration 1548: 0.191484\n", + "Cost after iteration 1549: 0.191285\n", + "Cost after iteration 1550: 0.191095\n", + "Cost after iteration 1551: 0.190914\n", + "Cost after iteration 1552: 0.190742\n", + "Cost after iteration 1553: 0.190576\n", + "Cost after iteration 1554: 0.190418\n", + "Cost after iteration 1555: 0.190267\n", + "Cost after iteration 1556: 0.190122\n", + "Cost after iteration 1557: 0.189983\n", + "Cost after iteration 1558: 0.189850\n", + "Cost after iteration 1559: 0.189722\n", + "Cost after iteration 1560: 0.189599\n", + "Cost after iteration 1561: 0.189482\n", + "Cost after iteration 1562: 0.189368\n", + "Cost after iteration 1563: 0.189259\n", + "Cost after iteration 1564: 0.189154\n", + "Cost after iteration 1565: 0.189053\n", + "Cost after iteration 1566: 0.188956\n", + "Cost after iteration 1567: 0.188862\n", + "Cost after iteration 1568: 0.188772\n", + "Cost after iteration 1569: 0.188684\n", + "Cost after iteration 1570: 0.188600\n", + "Cost after iteration 1571: 0.188519\n", + "Cost after iteration 1572: 0.188440\n", + "Cost after iteration 1573: 0.188364\n", + "Cost after iteration 1574: 0.188291\n", + "Cost after iteration 1575: 0.188220\n", + "Cost after iteration 1576: 0.188151\n", + "Cost after iteration 1577: 0.188084\n", + "Cost after iteration 1578: 0.188020\n", + "Cost after iteration 1579: 0.187957\n", + "Cost after iteration 1580: 0.187896\n", + "Cost after iteration 1581: 0.187838\n", + "Cost after iteration 1582: 0.187781\n", + "Cost after iteration 1583: 0.187725\n", + "Cost after iteration 1584: 0.187671\n", + "Cost after iteration 1585: 0.187619\n", + "Cost after iteration 1586: 0.187568\n", + "Cost after iteration 1587: 0.187519\n", + "Cost after iteration 1588: 0.187470\n", + "Cost after iteration 1589: 0.187424\n", + "Cost after iteration 1590: 0.187378\n", + "Cost after iteration 1591: 0.187334\n", + "Cost after iteration 1592: 0.187290\n", + "Cost after iteration 1593: 0.187248\n", + "Cost after iteration 1594: 0.187207\n", + "Cost after iteration 1595: 0.187167\n", + "Cost after iteration 1596: 0.187128\n", + "Cost after iteration 1597: 0.187090\n", + "Cost after iteration 1598: 0.187053\n", + "Cost after iteration 1599: 0.187016\n", + "Cost after iteration 1600: 0.186981\n", + "Cost after iteration 1601: 0.186946\n", + "Cost after iteration 1602: 0.186913\n", + "Cost after iteration 1603: 0.186879\n", + "Cost after iteration 1604: 0.186847\n", + "Cost after iteration 1605: 0.186816\n", + "Cost after iteration 1606: 0.186785\n", + "Cost after iteration 1607: 0.186754\n", + "Cost after iteration 1608: 0.186725\n", + "Cost after iteration 1609: 0.186696\n", + "Cost after iteration 1610: 0.186667\n", + "Cost after iteration 1611: 0.186640\n", + "Cost after iteration 1612: 0.186613\n", + "Cost after iteration 1613: 0.186586\n", + "Cost after iteration 1614: 0.186561\n", + "Cost after iteration 1615: 0.186536\n", + "Cost after iteration 1616: 0.186513\n", + "Cost after iteration 1617: 0.186491\n", + "Cost after iteration 1618: 0.186472\n", + "Cost after iteration 1619: 0.186456\n", + "Cost after iteration 1620: 0.186446\n", + "Cost after iteration 1621: 0.186448\n", + "Cost after iteration 1622: 0.186465\n", + "Cost after iteration 1623: 0.186518\n", + "Cost after iteration 1624: 0.186617\n", + "Cost after iteration 1625: 0.186836\n", + "Cost after iteration 1626: 0.187190\n", + "Cost after iteration 1627: 0.187992\n", + "Cost after iteration 1628: 0.189183\n", + "Cost after iteration 1629: 0.192227\n", + "Cost after iteration 1630: 0.196419\n", + "Cost after iteration 1631: 0.208982\n", + "Cost after iteration 1632: 0.222579\n", + "Cost after iteration 1633: 0.272411\n", + "Cost after iteration 1634: 0.272558\n", + "Cost after iteration 1635: 0.380879\n", + "Cost after iteration 1636: 0.277534\n", + "Cost after iteration 1637: 0.325796\n", + "Cost after iteration 1638: 0.261911\n", + "Cost after iteration 1639: 0.315877\n", + "Cost after iteration 1640: 0.332394\n", + "Cost after iteration 1641: 0.453921\n", + "Cost after iteration 1642: 0.331551\n", + "Cost after iteration 1643: 0.360236\n", + "Cost after iteration 1644: 0.255877\n", + "Cost after iteration 1645: 0.233347\n", + "Cost after iteration 1646: 0.208540\n", + "Cost after iteration 1647: 0.198933\n", + "Cost after iteration 1648: 0.194774\n", + "Cost after iteration 1649: 0.193269\n", + "Cost after iteration 1650: 0.192561\n", + "Cost after iteration 1651: 0.192168\n", + "Cost after iteration 1652: 0.191878\n", + "Cost after iteration 1653: 0.191640\n", + "Cost after iteration 1654: 0.191427\n", + "Cost after iteration 1655: 0.191231\n", + "Cost after iteration 1656: 0.191047\n", + "Cost after iteration 1657: 0.190872\n", + "Cost after iteration 1658: 0.190706\n", + "Cost after iteration 1659: 0.190548\n", + "Cost after iteration 1660: 0.190396\n", + "Cost after iteration 1661: 0.190251\n", + "Cost after iteration 1662: 0.190112\n", + "Cost after iteration 1663: 0.189978\n", + "Cost after iteration 1664: 0.189850\n", + "Cost after iteration 1665: 0.189727\n", + "Cost after iteration 1666: 0.189609\n", + "Cost after iteration 1667: 0.189495\n", + "Cost after iteration 1668: 0.189386\n", + "Cost after iteration 1669: 0.189280\n", + "Cost after iteration 1670: 0.189179\n", + "Cost after iteration 1671: 0.189081\n", + "Cost after iteration 1672: 0.188987\n", + "Cost after iteration 1673: 0.188896\n", + "Cost after iteration 1674: 0.188809\n", + "Cost after iteration 1675: 0.188724\n", + "Cost after iteration 1676: 0.188642\n", + "Cost after iteration 1677: 0.188563\n", + "Cost after iteration 1678: 0.188487\n", + "Cost after iteration 1679: 0.188413\n", + "Cost after iteration 1680: 0.188341\n", + "Cost after iteration 1681: 0.188272\n", + "Cost after iteration 1682: 0.188205\n", + "Cost after iteration 1683: 0.188140\n", + "Cost after iteration 1684: 0.188077\n", + "Cost after iteration 1685: 0.188016\n", + "Cost after iteration 1686: 0.187957\n", + "Cost after iteration 1687: 0.187900\n", + "Cost after iteration 1688: 0.187844\n", + "Cost after iteration 1689: 0.187790\n", + "Cost after iteration 1690: 0.187737\n", + "Cost after iteration 1691: 0.187686\n", + "Cost after iteration 1692: 0.187636\n", + "Cost after iteration 1693: 0.187588\n", + "Cost after iteration 1694: 0.187541\n", + "Cost after iteration 1695: 0.187495\n", + "Cost after iteration 1696: 0.187450\n", + "Cost after iteration 1697: 0.187407\n", + "Cost after iteration 1698: 0.187364\n", + "Cost after iteration 1699: 0.187323\n", + "Cost after iteration 1700: 0.187283\n", + "Cost after iteration 1701: 0.187244\n", + "Cost after iteration 1702: 0.187205\n", + "Cost after iteration 1703: 0.187168\n", + "Cost after iteration 1704: 0.187132\n", + "Cost after iteration 1705: 0.187096\n", + "Cost after iteration 1706: 0.187062\n", + "Cost after iteration 1707: 0.187028\n", + "Cost after iteration 1708: 0.186995\n", + "Cost after iteration 1709: 0.186963\n", + "Cost after iteration 1710: 0.186931\n", + "Cost after iteration 1711: 0.186901\n", + "Cost after iteration 1712: 0.186871\n", + "Cost after iteration 1713: 0.186843\n", + "Cost after iteration 1714: 0.186816\n", + "Cost after iteration 1715: 0.186791\n", + "Cost after iteration 1716: 0.186768\n", + "Cost after iteration 1717: 0.186750\n", + "Cost after iteration 1718: 0.186736\n", + "Cost after iteration 1719: 0.186732\n", + "Cost after iteration 1720: 0.186741\n", + "Cost after iteration 1721: 0.186778\n", + "Cost after iteration 1722: 0.186848\n", + "Cost after iteration 1723: 0.187005\n", + "Cost after iteration 1724: 0.187247\n", + "Cost after iteration 1725: 0.187781\n", + "Cost after iteration 1726: 0.188534\n", + "Cost after iteration 1727: 0.190365\n", + "Cost after iteration 1728: 0.192758\n", + "Cost after iteration 1729: 0.199549\n", + "Cost after iteration 1730: 0.207468\n", + "Cost after iteration 1731: 0.233391\n", + "Cost after iteration 1732: 0.244084\n", + "Cost after iteration 1733: 0.318861\n", + "Cost after iteration 1734: 0.275078\n", + "Cost after iteration 1735: 0.349342\n", + "Cost after iteration 1736: 0.245693\n", + "Cost after iteration 1737: 0.257499\n", + "Cost after iteration 1738: 0.232073\n", + "Cost after iteration 1739: 0.249713\n", + "Cost after iteration 1740: 0.256526\n", + "Cost after iteration 1741: 0.310315\n", + "Cost after iteration 1742: 0.304435\n", + "Cost after iteration 1743: 0.372901\n", + "Cost after iteration 1744: 0.294568\n", + "Cost after iteration 1745: 0.305791\n", + "Cost after iteration 1746: 0.237100\n", + "Cost after iteration 1747: 0.218549\n", + "Cost after iteration 1748: 0.202532\n", + "Cost after iteration 1749: 0.196098\n", + "Cost after iteration 1750: 0.193231\n", + "Cost after iteration 1751: 0.192163\n", + "Cost after iteration 1752: 0.191605\n", + "Cost after iteration 1753: 0.191281\n", + "Cost after iteration 1754: 0.191034\n", + "Cost after iteration 1755: 0.190835\n", + "Cost after iteration 1756: 0.190657\n", + "Cost after iteration 1757: 0.190496\n", + "Cost after iteration 1758: 0.190345\n", + "Cost after iteration 1759: 0.190204\n", + "Cost after iteration 1760: 0.190069\n", + "Cost after iteration 1761: 0.189940\n", + "Cost after iteration 1762: 0.189817\n", + "Cost after iteration 1763: 0.189699\n", + "Cost after iteration 1764: 0.189586\n", + "Cost after iteration 1765: 0.189477\n", + "Cost after iteration 1766: 0.189372\n", + "Cost after iteration 1767: 0.189272\n", + "Cost after iteration 1768: 0.189175\n", + "Cost after iteration 1769: 0.189081\n", + "Cost after iteration 1770: 0.188991\n", + "Cost after iteration 1771: 0.188904\n", + "Cost after iteration 1772: 0.188819\n", + "Cost after iteration 1773: 0.188738\n", + "Cost after iteration 1774: 0.188660\n", + "Cost after iteration 1775: 0.188584\n", + "Cost after iteration 1776: 0.188510\n", + "Cost after iteration 1777: 0.188439\n", + "Cost after iteration 1778: 0.188370\n", + "Cost after iteration 1779: 0.188304\n", + "Cost after iteration 1780: 0.188239\n", + "Cost after iteration 1781: 0.188176\n", + "Cost after iteration 1782: 0.188116\n", + "Cost after iteration 1783: 0.188057\n", + "Cost after iteration 1784: 0.187999\n", + "Cost after iteration 1785: 0.187944\n", + "Cost after iteration 1786: 0.187890\n", + "Cost after iteration 1787: 0.187838\n", + "Cost after iteration 1788: 0.187787\n", + "Cost after iteration 1789: 0.187737\n", + "Cost after iteration 1790: 0.187689\n", + "Cost after iteration 1791: 0.187642\n", + "Cost after iteration 1792: 0.187596\n", + "Cost after iteration 1793: 0.187552\n", + "Cost after iteration 1794: 0.187509\n", + "Cost after iteration 1795: 0.187467\n", + "Cost after iteration 1796: 0.187426\n", + "Cost after iteration 1797: 0.187386\n", + "Cost after iteration 1798: 0.187348\n", + "Cost after iteration 1799: 0.187310\n", + "Cost after iteration 1800: 0.187274\n", + "Cost after iteration 1801: 0.187239\n", + "Cost after iteration 1802: 0.187205\n", + "Cost after iteration 1803: 0.187173\n", + "Cost after iteration 1804: 0.187143\n", + "Cost after iteration 1805: 0.187115\n", + "Cost after iteration 1806: 0.187090\n", + "Cost after iteration 1807: 0.187070\n", + "Cost after iteration 1808: 0.187056\n", + "Cost after iteration 1809: 0.187054\n", + "Cost after iteration 1810: 0.187063\n", + "Cost after iteration 1811: 0.187101\n", + "Cost after iteration 1812: 0.187165\n", + "Cost after iteration 1813: 0.187308\n", + "Cost after iteration 1814: 0.187508\n", + "Cost after iteration 1815: 0.187944\n", + "Cost after iteration 1816: 0.188501\n", + "Cost after iteration 1817: 0.189822\n", + "Cost after iteration 1818: 0.191383\n", + "Cost after iteration 1819: 0.195661\n", + "Cost after iteration 1820: 0.200311\n", + "Cost after iteration 1821: 0.215027\n", + "Cost after iteration 1822: 0.225029\n", + "Cost after iteration 1823: 0.269538\n", + "Cost after iteration 1824: 0.256209\n", + "Cost after iteration 1825: 0.324735\n", + "Cost after iteration 1826: 0.250750\n", + "Cost after iteration 1827: 0.275501\n", + "Cost after iteration 1828: 0.222870\n", + "Cost after iteration 1829: 0.226424\n", + "Cost after iteration 1830: 0.216176\n", + "Cost after iteration 1831: 0.220554\n", + "Cost after iteration 1832: 0.218885\n", + "Cost after iteration 1833: 0.227809\n", + "Cost after iteration 1834: 0.228940\n", + "Cost after iteration 1835: 0.246452\n", + "Cost after iteration 1836: 0.245419\n", + "Cost after iteration 1837: 0.272541\n", + "Cost after iteration 1838: 0.256734\n", + "Cost after iteration 1839: 0.277880\n", + "Cost after iteration 1840: 0.245514\n", + "Cost after iteration 1841: 0.244836\n", + "Cost after iteration 1842: 0.220334\n", + "Cost after iteration 1843: 0.210235\n", + "Cost after iteration 1844: 0.199964\n", + "Cost after iteration 1845: 0.195240\n", + "Cost after iteration 1846: 0.192446\n", + "Cost after iteration 1847: 0.191256\n", + "Cost after iteration 1848: 0.190554\n", + "Cost after iteration 1849: 0.190186\n", + "Cost after iteration 1850: 0.189912\n", + "Cost after iteration 1851: 0.189724\n", + "Cost after iteration 1852: 0.189561\n", + "Cost after iteration 1853: 0.189428\n", + "Cost after iteration 1854: 0.189305\n", + "Cost after iteration 1855: 0.189196\n", + "Cost after iteration 1856: 0.189093\n", + "Cost after iteration 1857: 0.188998\n", + "Cost after iteration 1858: 0.188907\n", + "Cost after iteration 1859: 0.188821\n", + "Cost after iteration 1860: 0.188739\n", + "Cost after iteration 1861: 0.188660\n", + "Cost after iteration 1862: 0.188585\n", + "Cost after iteration 1863: 0.188512\n", + "Cost after iteration 1864: 0.188442\n", + "Cost after iteration 1865: 0.188375\n", + "Cost after iteration 1866: 0.188309\n", + "Cost after iteration 1867: 0.188247\n", + "Cost after iteration 1868: 0.188186\n", + "Cost after iteration 1869: 0.188127\n", + "Cost after iteration 1870: 0.188070\n", + "Cost after iteration 1871: 0.188015\n", + "Cost after iteration 1872: 0.187962\n", + "Cost after iteration 1873: 0.187911\n", + "Cost after iteration 1874: 0.187861\n", + "Cost after iteration 1875: 0.187813\n", + "Cost after iteration 1876: 0.187767\n", + "Cost after iteration 1877: 0.187723\n", + "Cost after iteration 1878: 0.187680\n", + "Cost after iteration 1879: 0.187640\n", + "Cost after iteration 1880: 0.187602\n", + "Cost after iteration 1881: 0.187567\n", + "Cost after iteration 1882: 0.187534\n", + "Cost after iteration 1883: 0.187506\n", + "Cost after iteration 1884: 0.187481\n", + "Cost after iteration 1885: 0.187464\n", + "Cost after iteration 1886: 0.187452\n", + "Cost after iteration 1887: 0.187456\n", + "Cost after iteration 1888: 0.187466\n", + "Cost after iteration 1889: 0.187510\n", + "Cost after iteration 1890: 0.187562\n", + "Cost after iteration 1891: 0.187690\n", + "Cost after iteration 1892: 0.187829\n", + "Cost after iteration 1893: 0.188145\n", + "Cost after iteration 1894: 0.188467\n", + "Cost after iteration 1895: 0.189242\n", + "Cost after iteration 1896: 0.189978\n", + "Cost after iteration 1897: 0.191960\n", + "Cost after iteration 1898: 0.193729\n", + "Cost after iteration 1899: 0.199163\n", + "Cost after iteration 1900: 0.203465\n", + "Cost after iteration 1901: 0.218635\n", + "Cost after iteration 1902: 0.223643\n", + "Cost after iteration 1903: 0.258123\n", + "Cost after iteration 1904: 0.240947\n", + "Cost after iteration 1905: 0.281462\n", + "Cost after iteration 1906: 0.235339\n", + "Cost after iteration 1907: 0.252248\n", + "Cost after iteration 1908: 0.218383\n", + "Cost after iteration 1909: 0.222234\n", + "Cost after iteration 1910: 0.211031\n", + "Cost after iteration 1911: 0.212858\n", + "Cost after iteration 1912: 0.208243\n", + "Cost after iteration 1913: 0.210056\n", + "Cost after iteration 1914: 0.207934\n", + "Cost after iteration 1915: 0.210417\n", + "Cost after iteration 1916: 0.209216\n", + "Cost after iteration 1917: 0.212461\n", + "Cost after iteration 1918: 0.211178\n", + "Cost after iteration 1919: 0.214833\n", + "Cost after iteration 1920: 0.212730\n", + "Cost after iteration 1921: 0.215998\n", + "Cost after iteration 1922: 0.212628\n", + "Cost after iteration 1923: 0.214416\n", + "Cost after iteration 1924: 0.209908\n", + "Cost after iteration 1925: 0.209558\n", + "Cost after iteration 1926: 0.204794\n", + "Cost after iteration 1927: 0.202929\n", + "Cost after iteration 1928: 0.199044\n", + "Cost after iteration 1929: 0.197061\n", + "Cost after iteration 1930: 0.194562\n", + "Cost after iteration 1931: 0.193206\n", + "Cost after iteration 1932: 0.191821\n", + "Cost after iteration 1933: 0.191048\n", + "Cost after iteration 1934: 0.190307\n", + "Cost after iteration 1935: 0.189885\n", + "Cost after iteration 1936: 0.189470\n", + "Cost after iteration 1937: 0.189230\n", + "Cost after iteration 1938: 0.188978\n", + "Cost after iteration 1939: 0.188834\n", + "Cost after iteration 1940: 0.188666\n", + "Cost after iteration 1941: 0.188574\n", + "Cost after iteration 1942: 0.188454\n", + "Cost after iteration 1943: 0.188394\n", + "Cost after iteration 1944: 0.188304\n", + "Cost after iteration 1945: 0.188267\n", + "Cost after iteration 1946: 0.188199\n", + "Cost after iteration 1947: 0.188183\n", + "Cost after iteration 1948: 0.188133\n", + "Cost after iteration 1949: 0.188140\n", + "Cost after iteration 1950: 0.188107\n", + "Cost after iteration 1951: 0.188144\n", + "Cost after iteration 1952: 0.188132\n", + "Cost after iteration 1953: 0.188213\n", + "Cost after iteration 1954: 0.188229\n", + "Cost after iteration 1955: 0.188378\n", + "Cost after iteration 1956: 0.188435\n", + "Cost after iteration 1957: 0.188702\n", + "Cost after iteration 1958: 0.188825\n", + "Cost after iteration 1959: 0.189301\n", + "Cost after iteration 1960: 0.189539\n", + "Cost after iteration 1961: 0.190416\n", + "Cost after iteration 1962: 0.190865\n", + "Cost after iteration 1963: 0.192554\n", + "Cost after iteration 1964: 0.193415\n", + "Cost after iteration 1965: 0.196847\n", + "Cost after iteration 1966: 0.198477\n", + "Cost after iteration 1967: 0.205659\n", + "Cost after iteration 1968: 0.207909\n", + "Cost after iteration 1969: 0.221894\n", + "Cost after iteration 1970: 0.219978\n", + "Cost after iteration 1971: 0.240613\n", + "Cost after iteration 1972: 0.226040\n", + "Cost after iteration 1973: 0.244539\n", + "Cost after iteration 1974: 0.223647\n", + "Cost after iteration 1975: 0.234665\n", + "Cost after iteration 1976: 0.220093\n", + "Cost after iteration 1977: 0.227266\n", + "Cost after iteration 1978: 0.219857\n", + "Cost after iteration 1979: 0.227034\n", + "Cost after iteration 1980: 0.223780\n", + "Cost after iteration 1981: 0.234199\n", + "Cost after iteration 1982: 0.233176\n", + "Cost after iteration 1983: 0.250862\n", + "Cost after iteration 1984: 0.247978\n", + "Cost after iteration 1985: 0.273816\n", + "Cost after iteration 1986: 0.257744\n", + "Cost after iteration 1987: 0.277534\n", + "Cost after iteration 1988: 0.246634\n", + "Cost after iteration 1989: 0.246035\n", + "Cost after iteration 1990: 0.221947\n", + "Cost after iteration 1991: 0.212272\n", + "Cost after iteration 1992: 0.201512\n", + "Cost after iteration 1993: 0.196827\n", + "Cost after iteration 1994: 0.193517\n", + "Cost after iteration 1995: 0.192215\n", + "Cost after iteration 1996: 0.191173\n", + "Cost after iteration 1997: 0.190705\n", + "Cost after iteration 1998: 0.190246\n", + "Cost after iteration 1999: 0.189996\n", + "Cost after iteration 2000: 0.189737\n", + "Cost after iteration 2001: 0.189570\n", + "Cost after iteration 2002: 0.189398\n", + "Cost after iteration 2003: 0.189271\n", + "Cost after iteration 2004: 0.189143\n", + "Cost after iteration 2005: 0.189040\n", + "Cost after iteration 2006: 0.188937\n", + "Cost after iteration 2007: 0.188848\n", + "Cost after iteration 2008: 0.188759\n", + "Cost after iteration 2009: 0.188681\n", + "Cost after iteration 2010: 0.188603\n", + "Cost after iteration 2011: 0.188532\n", + "Cost after iteration 2012: 0.188462\n", + "Cost after iteration 2013: 0.188397\n", + "Cost after iteration 2014: 0.188333\n", + "Cost after iteration 2015: 0.188274\n", + "Cost after iteration 2016: 0.188215\n", + "Cost after iteration 2017: 0.188161\n", + "Cost after iteration 2018: 0.188107\n", + "Cost after iteration 2019: 0.188058\n", + "Cost after iteration 2020: 0.188009\n", + "Cost after iteration 2021: 0.187965\n", + "Cost after iteration 2022: 0.187921\n", + "Cost after iteration 2023: 0.187883\n", + "Cost after iteration 2024: 0.187845\n", + "Cost after iteration 2025: 0.187814\n", + "Cost after iteration 2026: 0.187784\n", + "Cost after iteration 2027: 0.187764\n", + "Cost after iteration 2028: 0.187744\n", + "Cost after iteration 2029: 0.187742\n", + "Cost after iteration 2030: 0.187738\n", + "Cost after iteration 2031: 0.187765\n", + "Cost after iteration 2032: 0.187787\n", + "Cost after iteration 2033: 0.187868\n", + "Cost after iteration 2034: 0.187937\n", + "Cost after iteration 2035: 0.188122\n", + "Cost after iteration 2036: 0.188279\n", + "Cost after iteration 2037: 0.188681\n", + "Cost after iteration 2038: 0.189008\n", + "Cost after iteration 2039: 0.189894\n", + "Cost after iteration 2040: 0.190579\n", + "Cost after iteration 2041: 0.192624\n", + "Cost after iteration 2042: 0.194122\n", + "Cost after iteration 2043: 0.199131\n", + "Cost after iteration 2044: 0.202382\n", + "Cost after iteration 2045: 0.214803\n", + "Cost after iteration 2046: 0.218318\n", + "Cost after iteration 2047: 0.244169\n", + "Cost after iteration 2048: 0.232254\n", + "Cost after iteration 2049: 0.263304\n", + "Cost after iteration 2050: 0.230088\n", + "Cost after iteration 2051: 0.246522\n", + "Cost after iteration 2052: 0.217698\n", + "Cost after iteration 2053: 0.222597\n", + "Cost after iteration 2054: 0.209894\n", + "Cost after iteration 2055: 0.211604\n", + "Cost after iteration 2056: 0.205518\n", + "Cost after iteration 2057: 0.206293\n", + "Cost after iteration 2058: 0.203044\n", + "Cost after iteration 2059: 0.203672\n", + "Cost after iteration 2060: 0.201849\n", + "Cost after iteration 2061: 0.202598\n", + "Cost after iteration 2062: 0.201395\n", + "Cost after iteration 2063: 0.202224\n", + "Cost after iteration 2064: 0.201165\n", + "Cost after iteration 2065: 0.201915\n", + "Cost after iteration 2066: 0.200765\n", + "Cost after iteration 2067: 0.201281\n", + "Cost after iteration 2068: 0.199978\n", + "Cost after iteration 2069: 0.200169\n", + "Cost after iteration 2070: 0.198765\n", + "Cost after iteration 2071: 0.198637\n", + "Cost after iteration 2072: 0.197243\n", + "Cost after iteration 2073: 0.196887\n", + "Cost after iteration 2074: 0.195620\n", + "Cost after iteration 2075: 0.195166\n", + "Cost after iteration 2076: 0.194101\n", + "Cost after iteration 2077: 0.193657\n", + "Cost after iteration 2078: 0.192814\n", + "Cost after iteration 2079: 0.192440\n", + "Cost after iteration 2080: 0.191800\n", + "Cost after iteration 2081: 0.191517\n", + "Cost after iteration 2082: 0.191041\n", + "Cost after iteration 2083: 0.190848\n", + "Cost after iteration 2084: 0.190498\n", + "Cost after iteration 2085: 0.190386\n", + "Cost after iteration 2086: 0.190131\n", + "Cost after iteration 2087: 0.190093\n", + "Cost after iteration 2088: 0.189912\n", + "Cost after iteration 2089: 0.189947\n", + "Cost after iteration 2090: 0.189826\n", + "Cost after iteration 2091: 0.189943\n", + "Cost after iteration 2092: 0.189877\n", + "Cost after iteration 2093: 0.190099\n", + "Cost after iteration 2094: 0.190091\n", + "Cost after iteration 2095: 0.190461\n", + "Cost after iteration 2096: 0.190523\n", + "Cost after iteration 2097: 0.191123\n", + "Cost after iteration 2098: 0.191283\n", + "Cost after iteration 2099: 0.192264\n", + "Cost after iteration 2100: 0.192573\n", + "Cost after iteration 2101: 0.194225\n", + "Cost after iteration 2102: 0.194779\n", + "Cost after iteration 2103: 0.197664\n", + "Cost after iteration 2104: 0.198600\n", + "Cost after iteration 2105: 0.203770\n", + "Cost after iteration 2106: 0.205034\n", + "Cost after iteration 2107: 0.214059\n", + "Cost after iteration 2108: 0.214153\n", + "Cost after iteration 2109: 0.227870\n", + "Cost after iteration 2110: 0.222478\n", + "Cost after iteration 2111: 0.238211\n", + "Cost after iteration 2112: 0.226212\n", + "Cost after iteration 2113: 0.239621\n", + "Cost after iteration 2114: 0.227246\n", + "Cost after iteration 2115: 0.238277\n", + "Cost after iteration 2116: 0.229864\n", + "Cost after iteration 2117: 0.241711\n", + "Cost after iteration 2118: 0.236613\n", + "Cost after iteration 2119: 0.253063\n", + "Cost after iteration 2120: 0.247628\n", + "Cost after iteration 2121: 0.269842\n", + "Cost after iteration 2122: 0.255478\n", + "Cost after iteration 2123: 0.273663\n", + "Cost after iteration 2124: 0.247100\n", + "Cost after iteration 2125: 0.248485\n", + "Cost after iteration 2126: 0.225003\n", + "Cost after iteration 2127: 0.216243\n", + "Cost after iteration 2128: 0.204136\n", + "Cost after iteration 2129: 0.198750\n", + "Cost after iteration 2130: 0.194501\n", + "Cost after iteration 2131: 0.192789\n", + "Cost after iteration 2132: 0.191432\n", + "Cost after iteration 2133: 0.190829\n", + "Cost after iteration 2134: 0.190285\n", + "Cost after iteration 2135: 0.189995\n", + "Cost after iteration 2136: 0.189720\n", + "Cost after iteration 2137: 0.189542\n", + "Cost after iteration 2138: 0.189373\n", + "Cost after iteration 2139: 0.189245\n", + "Cost after iteration 2140: 0.189123\n", + "Cost after iteration 2141: 0.189022\n", + "Cost after iteration 2142: 0.188924\n", + "Cost after iteration 2143: 0.188838\n", + "Cost after iteration 2144: 0.188754\n", + "Cost after iteration 2145: 0.188677\n", + "Cost after iteration 2146: 0.188603\n", + "Cost after iteration 2147: 0.188533\n", + "Cost after iteration 2148: 0.188466\n", + "Cost after iteration 2149: 0.188401\n", + "Cost after iteration 2150: 0.188339\n", + "Cost after iteration 2151: 0.188280\n", + "Cost after iteration 2152: 0.188222\n", + "Cost after iteration 2153: 0.188166\n", + "Cost after iteration 2154: 0.188112\n", + "Cost after iteration 2155: 0.188060\n", + "Cost after iteration 2156: 0.188010\n", + "Cost after iteration 2157: 0.187961\n", + "Cost after iteration 2158: 0.187914\n", + "Cost after iteration 2159: 0.187868\n", + "Cost after iteration 2160: 0.187824\n", + "Cost after iteration 2161: 0.187782\n", + "Cost after iteration 2162: 0.187741\n", + "Cost after iteration 2163: 0.187702\n", + "Cost after iteration 2164: 0.187665\n", + "Cost after iteration 2165: 0.187630\n", + "Cost after iteration 2166: 0.187596\n", + "Cost after iteration 2167: 0.187566\n", + "Cost after iteration 2168: 0.187537\n", + "Cost after iteration 2169: 0.187514\n", + "Cost after iteration 2170: 0.187492\n", + "Cost after iteration 2171: 0.187479\n", + "Cost after iteration 2172: 0.187469\n", + "Cost after iteration 2173: 0.187474\n", + "Cost after iteration 2174: 0.187483\n", + "Cost after iteration 2175: 0.187523\n", + "Cost after iteration 2176: 0.187565\n", + "Cost after iteration 2177: 0.187673\n", + "Cost after iteration 2178: 0.187781\n", + "Cost after iteration 2179: 0.188032\n", + "Cost after iteration 2180: 0.188270\n", + "Cost after iteration 2181: 0.188845\n", + "Cost after iteration 2182: 0.189356\n", + "Cost after iteration 2183: 0.190713\n", + "Cost after iteration 2184: 0.191845\n", + "Cost after iteration 2185: 0.195246\n", + "Cost after iteration 2186: 0.197881\n", + "Cost after iteration 2187: 0.206846\n", + "Cost after iteration 2188: 0.211913\n", + "Cost after iteration 2189: 0.233927\n", + "Cost after iteration 2190: 0.231199\n", + "Cost after iteration 2191: 0.267632\n", + "Cost after iteration 2192: 0.237775\n", + "Cost after iteration 2193: 0.264835\n", + "Cost after iteration 2194: 0.225651\n", + "Cost after iteration 2195: 0.234184\n", + "Cost after iteration 2196: 0.215599\n", + "Cost after iteration 2197: 0.219041\n", + "Cost after iteration 2198: 0.212112\n", + "Cost after iteration 2199: 0.215097\n", + "Cost after iteration 2200: 0.212148\n", + "Cost after iteration 2201: 0.216192\n", + "Cost after iteration 2202: 0.214946\n", + "Cost after iteration 2203: 0.220980\n", + "Cost after iteration 2204: 0.219933\n", + "Cost after iteration 2205: 0.228337\n", + "Cost after iteration 2206: 0.225689\n", + "Cost after iteration 2207: 0.235381\n", + "Cost after iteration 2208: 0.228905\n", + "Cost after iteration 2209: 0.236144\n", + "Cost after iteration 2210: 0.225367\n", + "Cost after iteration 2211: 0.226041\n", + "Cost after iteration 2212: 0.214563\n", + "Cost after iteration 2213: 0.210025\n", + "Cost after iteration 2214: 0.202075\n", + "Cost after iteration 2215: 0.198008\n", + "Cost after iteration 2216: 0.194299\n", + "Cost after iteration 2217: 0.192474\n", + "Cost after iteration 2218: 0.191082\n", + "Cost after iteration 2219: 0.190386\n", + "Cost after iteration 2220: 0.189825\n", + "Cost after iteration 2221: 0.189522\n", + "Cost after iteration 2222: 0.189243\n", + "Cost after iteration 2223: 0.189076\n", + "Cost after iteration 2224: 0.188905\n", + "Cost after iteration 2225: 0.188793\n", + "Cost after iteration 2226: 0.188672\n", + "Cost after iteration 2227: 0.188587\n", + "Cost after iteration 2228: 0.188493\n", + "Cost after iteration 2229: 0.188422\n", + "Cost after iteration 2230: 0.188345\n", + "Cost after iteration 2231: 0.188285\n", + "Cost after iteration 2232: 0.188220\n", + "Cost after iteration 2233: 0.188168\n", + "Cost after iteration 2234: 0.188111\n", + "Cost after iteration 2235: 0.188067\n", + "Cost after iteration 2236: 0.188017\n", + "Cost after iteration 2237: 0.187980\n", + "Cost after iteration 2238: 0.187937\n", + "Cost after iteration 2239: 0.187909\n", + "Cost after iteration 2240: 0.187874\n", + "Cost after iteration 2241: 0.187856\n", + "Cost after iteration 2242: 0.187830\n", + "Cost after iteration 2243: 0.187827\n", + "Cost after iteration 2244: 0.187813\n", + "Cost after iteration 2245: 0.187833\n", + "Cost after iteration 2246: 0.187837\n", + "Cost after iteration 2247: 0.187893\n", + "Cost after iteration 2248: 0.187925\n", + "Cost after iteration 2249: 0.188046\n", + "Cost after iteration 2250: 0.188125\n", + "Cost after iteration 2251: 0.188364\n", + "Cost after iteration 2252: 0.188525\n", + "Cost after iteration 2253: 0.188996\n", + "Cost after iteration 2254: 0.189307\n", + "Cost after iteration 2255: 0.190260\n", + "Cost after iteration 2256: 0.190871\n", + "Cost after iteration 2257: 0.192892\n", + "Cost after iteration 2258: 0.194136\n", + "Cost after iteration 2259: 0.198666\n", + "Cost after iteration 2260: 0.201154\n", + "Cost after iteration 2261: 0.211439\n", + "Cost after iteration 2262: 0.214159\n", + "Cost after iteration 2263: 0.234434\n", + "Cost after iteration 2264: 0.226768\n", + "Cost after iteration 2265: 0.252440\n", + "Cost after iteration 2266: 0.227692\n", + "Cost after iteration 2267: 0.244362\n", + "Cost after iteration 2268: 0.219594\n", + "Cost after iteration 2269: 0.226526\n", + "Cost after iteration 2270: 0.213500\n", + "Cost after iteration 2271: 0.216983\n", + "Cost after iteration 2272: 0.210532\n", + "Cost after iteration 2273: 0.213146\n", + "Cost after iteration 2274: 0.209744\n", + "Cost after iteration 2275: 0.212575\n", + "Cost after iteration 2276: 0.210684\n", + "Cost after iteration 2277: 0.214288\n", + "Cost after iteration 2278: 0.212864\n", + "Cost after iteration 2279: 0.217336\n", + "Cost after iteration 2280: 0.215426\n", + "Cost after iteration 2281: 0.220245\n", + "Cost after iteration 2282: 0.216966\n", + "Cost after iteration 2283: 0.220825\n", + "Cost after iteration 2284: 0.215745\n", + "Cost after iteration 2285: 0.217045\n", + "Cost after iteration 2286: 0.210836\n", + "Cost after iteration 2287: 0.209257\n", + "Cost after iteration 2288: 0.203574\n", + "Cost after iteration 2289: 0.200889\n", + "Cost after iteration 2290: 0.197035\n", + "Cost after iteration 2291: 0.195028\n", + "Cost after iteration 2292: 0.192953\n", + "Cost after iteration 2293: 0.191864\n", + "Cost after iteration 2294: 0.190837\n", + "Cost after iteration 2295: 0.190294\n", + "Cost after iteration 2296: 0.189762\n", + "Cost after iteration 2297: 0.189480\n", + "Cost after iteration 2298: 0.189175\n", + "Cost after iteration 2299: 0.189014\n", + "Cost after iteration 2300: 0.188819\n", + "Cost after iteration 2301: 0.188717\n", + "Cost after iteration 2302: 0.188580\n", + "Cost after iteration 2303: 0.188511\n", + "Cost after iteration 2304: 0.188408\n", + "Cost after iteration 2305: 0.188361\n", + "Cost after iteration 2306: 0.188281\n", + "Cost after iteration 2307: 0.188251\n", + "Cost after iteration 2308: 0.188188\n", + "Cost after iteration 2309: 0.188175\n", + "Cost after iteration 2310: 0.188127\n", + "Cost after iteration 2311: 0.188133\n", + "Cost after iteration 2312: 0.188099\n", + "Cost after iteration 2313: 0.188130\n", + "Cost after iteration 2314: 0.188114\n", + "Cost after iteration 2315: 0.188182\n", + "Cost after iteration 2316: 0.188188\n", + "Cost after iteration 2317: 0.188313\n", + "Cost after iteration 2318: 0.188352\n", + "Cost after iteration 2319: 0.188572\n", + "Cost after iteration 2320: 0.188664\n", + "Cost after iteration 2321: 0.189050\n", + "Cost after iteration 2322: 0.189228\n", + "Cost after iteration 2323: 0.189921\n", + "Cost after iteration 2324: 0.190253\n", + "Cost after iteration 2325: 0.191546\n", + "Cost after iteration 2326: 0.192170\n", + "Cost after iteration 2327: 0.194706\n", + "Cost after iteration 2328: 0.195892\n", + "Cost after iteration 2329: 0.201077\n", + "Cost after iteration 2330: 0.203065\n", + "Cost after iteration 2331: 0.213481\n", + "Cost after iteration 2332: 0.214307\n", + "Cost after iteration 2333: 0.231925\n", + "Cost after iteration 2334: 0.223432\n", + "Cost after iteration 2335: 0.243133\n", + "Cost after iteration 2336: 0.223787\n", + "Cost after iteration 2337: 0.237010\n", + "Cost after iteration 2338: 0.219213\n", + "Cost after iteration 2339: 0.226433\n", + "Cost after iteration 2340: 0.216159\n", + "Cost after iteration 2341: 0.221222\n", + "Cost after iteration 2342: 0.215835\n", + "Cost after iteration 2343: 0.221064\n", + "Cost after iteration 2344: 0.218378\n", + "Cost after iteration 2345: 0.225554\n", + "Cost after iteration 2346: 0.224158\n", + "Cost after iteration 2347: 0.235049\n", + "Cost after iteration 2348: 0.232864\n", + "Cost after iteration 2349: 0.248000\n", + "Cost after iteration 2350: 0.240655\n", + "Cost after iteration 2351: 0.255270\n", + "Cost after iteration 2352: 0.239139\n", + "Cost after iteration 2353: 0.243934\n", + "Cost after iteration 2354: 0.225257\n", + "Cost after iteration 2355: 0.219647\n", + "Cost after iteration 2356: 0.207175\n", + "Cost after iteration 2357: 0.201176\n", + "Cost after iteration 2358: 0.195841\n", + "Cost after iteration 2359: 0.193485\n", + "Cost after iteration 2360: 0.191729\n", + "Cost after iteration 2361: 0.190962\n", + "Cost after iteration 2362: 0.190298\n", + "Cost after iteration 2363: 0.189976\n", + "Cost after iteration 2364: 0.189644\n", + "Cost after iteration 2365: 0.189460\n", + "Cost after iteration 2366: 0.189257\n", + "Cost after iteration 2367: 0.189128\n", + "Cost after iteration 2368: 0.188986\n", + "Cost after iteration 2369: 0.188885\n", + "Cost after iteration 2370: 0.188777\n", + "Cost after iteration 2371: 0.188693\n", + "Cost after iteration 2372: 0.188605\n", + "Cost after iteration 2373: 0.188533\n", + "Cost after iteration 2374: 0.188457\n", + "Cost after iteration 2375: 0.188394\n", + "Cost after iteration 2376: 0.188328\n", + "Cost after iteration 2377: 0.188272\n", + "Cost after iteration 2378: 0.188213\n", + "Cost after iteration 2379: 0.188164\n", + "Cost after iteration 2380: 0.188112\n", + "Cost after iteration 2381: 0.188068\n", + "Cost after iteration 2382: 0.188022\n", + "Cost after iteration 2383: 0.187985\n", + "Cost after iteration 2384: 0.187945\n", + "Cost after iteration 2385: 0.187917\n", + "Cost after iteration 2386: 0.187884\n", + "Cost after iteration 2387: 0.187866\n", + "Cost after iteration 2388: 0.187842\n", + "Cost after iteration 2389: 0.187840\n", + "Cost after iteration 2390: 0.187829\n", + "Cost after iteration 2391: 0.187851\n", + "Cost after iteration 2392: 0.187860\n", + "Cost after iteration 2393: 0.187922\n", + "Cost after iteration 2394: 0.187963\n", + "Cost after iteration 2395: 0.188100\n", + "Cost after iteration 2396: 0.188196\n", + "Cost after iteration 2397: 0.188472\n", + "Cost after iteration 2398: 0.188667\n", + "Cost after iteration 2399: 0.189224\n", + "Cost after iteration 2400: 0.189607\n", + "Cost after iteration 2401: 0.190769\n", + "Cost after iteration 2402: 0.191534\n", + "Cost after iteration 2403: 0.194085\n", + "Cost after iteration 2404: 0.195680\n", + "Cost after iteration 2405: 0.201567\n", + "Cost after iteration 2406: 0.204620\n", + "Cost after iteration 2407: 0.217951\n", + "Cost after iteration 2408: 0.219330\n", + "Cost after iteration 2409: 0.243528\n", + "Cost after iteration 2410: 0.229291\n", + "Cost after iteration 2411: 0.254277\n", + "Cost after iteration 2412: 0.225449\n", + "Cost after iteration 2413: 0.238110\n", + "Cost after iteration 2414: 0.215998\n", + "Cost after iteration 2415: 0.220616\n", + "Cost after iteration 2416: 0.209973\n", + "Cost after iteration 2417: 0.212028\n", + "Cost after iteration 2418: 0.206507\n", + "Cost after iteration 2419: 0.207768\n", + "Cost after iteration 2420: 0.204716\n", + "Cost after iteration 2421: 0.205898\n", + "Cost after iteration 2422: 0.204112\n", + "Cost after iteration 2423: 0.205465\n", + "Cost after iteration 2424: 0.204174\n", + "Cost after iteration 2425: 0.205625\n", + "Cost after iteration 2426: 0.204320\n", + "Cost after iteration 2427: 0.205619\n", + "Cost after iteration 2428: 0.204023\n", + "Cost after iteration 2429: 0.204876\n", + "Cost after iteration 2430: 0.202931\n", + "Cost after iteration 2431: 0.203145\n", + "Cost after iteration 2432: 0.200995\n", + "Cost after iteration 2433: 0.200600\n", + "Cost after iteration 2434: 0.198514\n", + "Cost after iteration 2435: 0.197762\n", + "Cost after iteration 2436: 0.195988\n", + "Cost after iteration 2437: 0.195180\n", + "Cost after iteration 2438: 0.193827\n", + "Cost after iteration 2439: 0.193148\n", + "Cost after iteration 2440: 0.192188\n", + "Cost after iteration 2441: 0.191688\n", + "Cost after iteration 2442: 0.191030\n", + "Cost after iteration 2443: 0.190689\n", + "Cost after iteration 2444: 0.190240\n", + "Cost after iteration 2445: 0.190020\n", + "Cost after iteration 2446: 0.189709\n", + "Cost after iteration 2447: 0.189577\n", + "Cost after iteration 2448: 0.189358\n", + "Cost after iteration 2449: 0.189292\n", + "Cost after iteration 2450: 0.189136\n", + "Cost after iteration 2451: 0.189125\n", + "Cost after iteration 2452: 0.189016\n", + "Cost after iteration 2453: 0.189059\n", + "Cost after iteration 2454: 0.188988\n", + "Cost after iteration 2455: 0.189092\n", + "Cost after iteration 2456: 0.189059\n", + "Cost after iteration 2457: 0.189242\n", + "Cost after iteration 2458: 0.189251\n", + "Cost after iteration 2459: 0.189552\n", + "Cost after iteration 2460: 0.189616\n", + "Cost after iteration 2461: 0.190102\n", + "Cost after iteration 2462: 0.190245\n", + "Cost after iteration 2463: 0.191045\n", + "Cost after iteration 2464: 0.191313\n", + "Cost after iteration 2465: 0.192668\n", + "Cost after iteration 2466: 0.193151\n", + "Cost after iteration 2467: 0.195541\n", + "Cost after iteration 2468: 0.196387\n", + "Cost after iteration 2469: 0.200752\n", + "Cost after iteration 2470: 0.202061\n", + "Cost after iteration 2471: 0.209995\n", + "Cost after iteration 2472: 0.210859\n", + "Cost after iteration 2473: 0.223825\n", + "Cost after iteration 2474: 0.220097\n", + "Cost after iteration 2475: 0.236357\n", + "Cost after iteration 2476: 0.224709\n", + "Cost after iteration 2477: 0.239008\n", + "Cost after iteration 2478: 0.225170\n", + "Cost after iteration 2479: 0.235970\n", + "Cost after iteration 2480: 0.226279\n", + "Cost after iteration 2481: 0.236580\n", + "Cost after iteration 2482: 0.231378\n", + "Cost after iteration 2483: 0.245479\n", + "Cost after iteration 2484: 0.242558\n", + "Cost after iteration 2485: 0.265133\n", + "Cost after iteration 2486: 0.257391\n", + "Cost after iteration 2487: 0.285130\n", + "Cost after iteration 2488: 0.259832\n", + "Cost after iteration 2489: 0.273223\n", + "Cost after iteration 2490: 0.240095\n", + "Cost after iteration 2491: 0.233452\n", + "Cost after iteration 2492: 0.213734\n", + "Cost after iteration 2493: 0.205056\n", + "Cost after iteration 2494: 0.197571\n", + "Cost after iteration 2495: 0.194553\n", + "Cost after iteration 2496: 0.192373\n", + "Cost after iteration 2497: 0.191485\n", + "Cost after iteration 2498: 0.190731\n", + "Cost after iteration 2499: 0.190360\n", + "Cost after iteration 2500: 0.190013\n", + "Cost after iteration 2501: 0.189803\n", + "Cost after iteration 2502: 0.189604\n", + "Cost after iteration 2503: 0.189460\n", + "Cost after iteration 2504: 0.189323\n", + "Cost after iteration 2505: 0.189211\n", + "Cost after iteration 2506: 0.189105\n", + "Cost after iteration 2507: 0.189011\n", + "Cost after iteration 2508: 0.188922\n", + "Cost after iteration 2509: 0.188840\n", + "Cost after iteration 2510: 0.188761\n", + "Cost after iteration 2511: 0.188687\n", + "Cost after iteration 2512: 0.188615\n", + "Cost after iteration 2513: 0.188547\n", + "Cost after iteration 2514: 0.188482\n", + "Cost after iteration 2515: 0.188419\n", + "Cost after iteration 2516: 0.188358\n", + "Cost after iteration 2517: 0.188300\n", + "Cost after iteration 2518: 0.188243\n", + "Cost after iteration 2519: 0.188188\n", + "Cost after iteration 2520: 0.188135\n", + "Cost after iteration 2521: 0.188084\n", + "Cost after iteration 2522: 0.188034\n", + "Cost after iteration 2523: 0.187986\n", + "Cost after iteration 2524: 0.187940\n", + "Cost after iteration 2525: 0.187895\n", + "Cost after iteration 2526: 0.187852\n", + "Cost after iteration 2527: 0.187810\n", + "Cost after iteration 2528: 0.187769\n", + "Cost after iteration 2529: 0.187731\n", + "Cost after iteration 2530: 0.187694\n", + "Cost after iteration 2531: 0.187659\n", + "Cost after iteration 2532: 0.187625\n", + "Cost after iteration 2533: 0.187595\n", + "Cost after iteration 2534: 0.187566\n", + "Cost after iteration 2535: 0.187543\n", + "Cost after iteration 2536: 0.187521\n", + "Cost after iteration 2537: 0.187507\n", + "Cost after iteration 2538: 0.187496\n", + "Cost after iteration 2539: 0.187500\n", + "Cost after iteration 2540: 0.187507\n", + "Cost after iteration 2541: 0.187543\n", + "Cost after iteration 2542: 0.187583\n", + "Cost after iteration 2543: 0.187684\n", + "Cost after iteration 2544: 0.187786\n", + "Cost after iteration 2545: 0.188024\n", + "Cost after iteration 2546: 0.188252\n", + "Cost after iteration 2547: 0.188798\n", + "Cost after iteration 2548: 0.189288\n", + "Cost after iteration 2549: 0.190579\n", + "Cost after iteration 2550: 0.191661\n", + "Cost after iteration 2551: 0.194892\n", + "Cost after iteration 2552: 0.197415\n", + "Cost after iteration 2553: 0.205940\n", + "Cost after iteration 2554: 0.210963\n", + "Cost after iteration 2555: 0.232164\n", + "Cost after iteration 2556: 0.230462\n", + "Cost after iteration 2557: 0.266815\n", + "Cost after iteration 2558: 0.237939\n", + "Cost after iteration 2559: 0.266042\n", + "Cost after iteration 2560: 0.225800\n", + "Cost after iteration 2561: 0.234468\n", + "Cost after iteration 2562: 0.214650\n", + "Cost after iteration 2563: 0.217535\n", + "Cost after iteration 2564: 0.210049\n", + "Cost after iteration 2565: 0.212009\n", + "Cost after iteration 2566: 0.208580\n", + "Cost after iteration 2567: 0.210879\n", + "Cost after iteration 2568: 0.209187\n", + "Cost after iteration 2569: 0.212300\n", + "Cost after iteration 2570: 0.211074\n", + "Cost after iteration 2571: 0.214939\n", + "Cost after iteration 2572: 0.213222\n", + "Cost after iteration 2573: 0.217246\n", + "Cost after iteration 2574: 0.214307\n", + "Cost after iteration 2575: 0.217350\n", + "Cost after iteration 2576: 0.212921\n", + "Cost after iteration 2577: 0.213764\n", + "Cost after iteration 2578: 0.208455\n", + "Cost after iteration 2579: 0.206986\n", + "Cost after iteration 2580: 0.202131\n", + "Cost after iteration 2581: 0.199793\n", + "Cost after iteration 2582: 0.196427\n", + "Cost after iteration 2583: 0.194613\n", + "Cost after iteration 2584: 0.192724\n", + "Cost after iteration 2585: 0.191675\n", + "Cost after iteration 2586: 0.190704\n", + "Cost after iteration 2587: 0.190149\n", + "Cost after iteration 2588: 0.189640\n", + "Cost after iteration 2589: 0.189339\n", + "Cost after iteration 2590: 0.189050\n", + "Cost after iteration 2591: 0.188874\n", + "Cost after iteration 2592: 0.188692\n", + "Cost after iteration 2593: 0.188579\n", + "Cost after iteration 2594: 0.188453\n", + "Cost after iteration 2595: 0.188375\n", + "Cost after iteration 2596: 0.188282\n", + "Cost after iteration 2597: 0.188225\n", + "Cost after iteration 2598: 0.188152\n", + "Cost after iteration 2599: 0.188111\n", + "Cost after iteration 2600: 0.188053\n", + "Cost after iteration 2601: 0.188025\n", + "Cost after iteration 2602: 0.187979\n", + "Cost after iteration 2603: 0.187964\n", + "Cost after iteration 2604: 0.187930\n", + "Cost after iteration 2605: 0.187932\n", + "Cost after iteration 2606: 0.187910\n", + "Cost after iteration 2607: 0.187935\n", + "Cost after iteration 2608: 0.187929\n", + "Cost after iteration 2609: 0.187987\n", + "Cost after iteration 2610: 0.188004\n", + "Cost after iteration 2611: 0.188117\n", + "Cost after iteration 2612: 0.188168\n", + "Cost after iteration 2613: 0.188372\n", + "Cost after iteration 2614: 0.188480\n", + "Cost after iteration 2615: 0.188849\n", + "Cost after iteration 2616: 0.189052\n", + "Cost after iteration 2617: 0.189734\n", + "Cost after iteration 2618: 0.190110\n", + "Cost after iteration 2619: 0.191420\n", + "Cost after iteration 2620: 0.192131\n", + "Cost after iteration 2621: 0.194783\n", + "Cost after iteration 2622: 0.196162\n", + "Cost after iteration 2623: 0.201770\n", + "Cost after iteration 2624: 0.204144\n", + "Cost after iteration 2625: 0.215753\n", + "Cost after iteration 2626: 0.216650\n", + "Cost after iteration 2627: 0.236466\n", + "Cost after iteration 2628: 0.226149\n", + "Cost after iteration 2629: 0.247551\n", + "Cost after iteration 2630: 0.225948\n", + "Cost after iteration 2631: 0.239642\n", + "Cost after iteration 2632: 0.221536\n", + "Cost after iteration 2633: 0.229467\n", + "Cost after iteration 2634: 0.220118\n", + "Cost after iteration 2635: 0.227146\n", + "Cost after iteration 2636: 0.223009\n", + "Cost after iteration 2637: 0.232707\n", + "Cost after iteration 2638: 0.231429\n", + "Cost after iteration 2639: 0.248077\n", + "Cost after iteration 2640: 0.246137\n", + "Cost after iteration 2641: 0.272353\n", + "Cost after iteration 2642: 0.258572\n", + "Cost after iteration 2643: 0.282103\n", + "Cost after iteration 2644: 0.250527\n", + "Cost after iteration 2645: 0.253215\n", + "Cost after iteration 2646: 0.225877\n", + "Cost after iteration 2647: 0.215975\n", + "Cost after iteration 2648: 0.203344\n", + "Cost after iteration 2649: 0.197715\n", + "Cost after iteration 2650: 0.193827\n", + "Cost after iteration 2651: 0.192283\n", + "Cost after iteration 2652: 0.191165\n", + "Cost after iteration 2653: 0.190663\n", + "Cost after iteration 2654: 0.190211\n", + "Cost after iteration 2655: 0.189961\n", + "Cost after iteration 2656: 0.189718\n", + "Cost after iteration 2657: 0.189555\n", + "Cost after iteration 2658: 0.189396\n", + "Cost after iteration 2659: 0.189274\n", + "Cost after iteration 2660: 0.189154\n", + "Cost after iteration 2661: 0.189055\n", + "Cost after iteration 2662: 0.188957\n", + "Cost after iteration 2663: 0.188872\n", + "Cost after iteration 2664: 0.188788\n", + "Cost after iteration 2665: 0.188711\n", + "Cost after iteration 2666: 0.188637\n", + "Cost after iteration 2667: 0.188567\n", + "Cost after iteration 2668: 0.188500\n", + "Cost after iteration 2669: 0.188436\n", + "Cost after iteration 2670: 0.188374\n", + "Cost after iteration 2671: 0.188315\n", + "Cost after iteration 2672: 0.188258\n", + "Cost after iteration 2673: 0.188203\n", + "Cost after iteration 2674: 0.188150\n", + "Cost after iteration 2675: 0.188100\n", + "Cost after iteration 2676: 0.188050\n", + "Cost after iteration 2677: 0.188004\n", + "Cost after iteration 2678: 0.187958\n", + "Cost after iteration 2679: 0.187916\n", + "Cost after iteration 2680: 0.187874\n", + "Cost after iteration 2681: 0.187836\n", + "Cost after iteration 2682: 0.187798\n", + "Cost after iteration 2683: 0.187765\n", + "Cost after iteration 2684: 0.187733\n", + "Cost after iteration 2685: 0.187707\n", + "Cost after iteration 2686: 0.187682\n", + "Cost after iteration 2687: 0.187666\n", + "Cost after iteration 2688: 0.187651\n", + "Cost after iteration 2689: 0.187653\n", + "Cost after iteration 2690: 0.187654\n", + "Cost after iteration 2691: 0.187686\n", + "Cost after iteration 2692: 0.187716\n", + "Cost after iteration 2693: 0.187804\n", + "Cost after iteration 2694: 0.187887\n", + "Cost after iteration 2695: 0.188089\n", + "Cost after iteration 2696: 0.188271\n", + "Cost after iteration 2697: 0.188719\n", + "Cost after iteration 2698: 0.189098\n", + "Cost after iteration 2699: 0.190108\n", + "Cost after iteration 2700: 0.190911\n", + "Cost after iteration 2701: 0.193303\n", + "Cost after iteration 2702: 0.195093\n", + "Cost after iteration 2703: 0.201100\n", + "Cost after iteration 2704: 0.204936\n", + "Cost after iteration 2705: 0.219907\n", + "Cost after iteration 2706: 0.222499\n", + "Cost after iteration 2707: 0.252143\n", + "Cost after iteration 2708: 0.234712\n", + "Cost after iteration 2709: 0.265587\n", + "Cost after iteration 2710: 0.228704\n", + "Cost after iteration 2711: 0.242015\n", + "Cost after iteration 2712: 0.215878\n", + "Cost after iteration 2713: 0.219534\n", + "Cost after iteration 2714: 0.208912\n", + "Cost after iteration 2715: 0.210226\n", + "Cost after iteration 2716: 0.205087\n", + "Cost after iteration 2717: 0.205801\n", + "Cost after iteration 2718: 0.203081\n", + "Cost after iteration 2719: 0.203814\n", + "Cost after iteration 2720: 0.202244\n", + "Cost after iteration 2721: 0.203123\n", + "Cost after iteration 2722: 0.201954\n", + "Cost after iteration 2723: 0.202840\n", + "Cost after iteration 2724: 0.201659\n", + "Cost after iteration 2725: 0.202346\n", + "Cost after iteration 2726: 0.200990\n", + "Cost after iteration 2727: 0.201322\n", + "Cost after iteration 2728: 0.199803\n", + "Cost after iteration 2729: 0.199735\n", + "Cost after iteration 2730: 0.198173\n", + "Cost after iteration 2731: 0.197787\n", + "Cost after iteration 2732: 0.196334\n", + "Cost after iteration 2733: 0.195790\n", + "Cost after iteration 2734: 0.194559\n", + "Cost after iteration 2735: 0.194004\n", + "Cost after iteration 2736: 0.193036\n", + "Cost after iteration 2737: 0.192559\n", + "Cost after iteration 2738: 0.191835\n", + "Cost after iteration 2739: 0.191464\n", + "Cost after iteration 2740: 0.190936\n", + "Cost after iteration 2741: 0.190667\n", + "Cost after iteration 2742: 0.190285\n", + "Cost after iteration 2743: 0.190102\n", + "Cost after iteration 2744: 0.189826\n", + "Cost after iteration 2745: 0.189712\n", + "Cost after iteration 2746: 0.189513\n", + "Cost after iteration 2747: 0.189457\n", + "Cost after iteration 2748: 0.189315\n", + "Cost after iteration 2749: 0.189313\n", + "Cost after iteration 2750: 0.189217\n", + "Cost after iteration 2751: 0.189271\n", + "Cost after iteration 2752: 0.189217\n", + "Cost after iteration 2753: 0.189338\n", + "Cost after iteration 2754: 0.189326\n", + "Cost after iteration 2755: 0.189540\n", + "Cost after iteration 2756: 0.189577\n", + "Cost after iteration 2757: 0.189929\n", + "Cost after iteration 2758: 0.190034\n", + "Cost after iteration 2759: 0.190607\n", + "Cost after iteration 2760: 0.190811\n", + "Cost after iteration 2761: 0.191761\n", + "Cost after iteration 2762: 0.192126\n", + "Cost after iteration 2763: 0.193757\n", + "Cost after iteration 2764: 0.194395\n", + "Cost after iteration 2765: 0.197311\n", + "Cost after iteration 2766: 0.198402\n", + "Cost after iteration 2767: 0.203775\n", + "Cost after iteration 2768: 0.205324\n", + "Cost after iteration 2769: 0.214983\n", + "Cost after iteration 2770: 0.215309\n", + "Cost after iteration 2771: 0.230294\n", + "Cost after iteration 2772: 0.224250\n", + "Cost after iteration 2773: 0.241342\n", + "Cost after iteration 2774: 0.227986\n", + "Cost after iteration 2775: 0.242248\n", + "Cost after iteration 2776: 0.229227\n", + "Cost after iteration 2777: 0.241288\n", + "Cost after iteration 2778: 0.233184\n", + "Cost after iteration 2779: 0.247521\n", + "Cost after iteration 2780: 0.242916\n", + "Cost after iteration 2781: 0.264683\n", + "Cost after iteration 2782: 0.257125\n", + "Cost after iteration 2783: 0.285003\n", + "Cost after iteration 2784: 0.261460\n", + "Cost after iteration 2785: 0.277350\n", + "Cost after iteration 2786: 0.243575\n", + "Cost after iteration 2787: 0.238567\n", + "Cost after iteration 2788: 0.216878\n", + "Cost after iteration 2789: 0.207608\n", + "Cost after iteration 2790: 0.198904\n", + "Cost after iteration 2791: 0.195339\n", + "Cost after iteration 2792: 0.192752\n", + "Cost after iteration 2793: 0.191707\n", + "Cost after iteration 2794: 0.190852\n", + "Cost after iteration 2795: 0.190438\n", + "Cost after iteration 2796: 0.190067\n", + "Cost after iteration 2797: 0.189844\n", + "Cost after iteration 2798: 0.189639\n", + "Cost after iteration 2799: 0.189492\n", + "Cost after iteration 2800: 0.189355\n", + "Cost after iteration 2801: 0.189243\n", + "Cost after iteration 2802: 0.189137\n", + "Cost after iteration 2803: 0.189043\n", + "Cost after iteration 2804: 0.188954\n", + "Cost after iteration 2805: 0.188872\n", + "Cost after iteration 2806: 0.188794\n", + "Cost after iteration 2807: 0.188720\n", + "Cost after iteration 2808: 0.188648\n", + "Cost after iteration 2809: 0.188580\n", + "Cost after iteration 2810: 0.188515\n", + "Cost after iteration 2811: 0.188452\n", + "Cost after iteration 2812: 0.188391\n", + "Cost after iteration 2813: 0.188332\n", + "Cost after iteration 2814: 0.188275\n", + "Cost after iteration 2815: 0.188220\n", + "Cost after iteration 2816: 0.188167\n", + "Cost after iteration 2817: 0.188115\n", + "Cost after iteration 2818: 0.188065\n", + "Cost after iteration 2819: 0.188017\n", + "Cost after iteration 2820: 0.187970\n", + "Cost after iteration 2821: 0.187924\n", + "Cost after iteration 2822: 0.187880\n", + "Cost after iteration 2823: 0.187837\n", + "Cost after iteration 2824: 0.187795\n", + "Cost after iteration 2825: 0.187755\n", + "Cost after iteration 2826: 0.187716\n", + "Cost after iteration 2827: 0.187679\n", + "Cost after iteration 2828: 0.187643\n", + "Cost after iteration 2829: 0.187608\n", + "Cost after iteration 2830: 0.187575\n", + "Cost after iteration 2831: 0.187545\n", + "Cost after iteration 2832: 0.187516\n", + "Cost after iteration 2833: 0.187490\n", + "Cost after iteration 2834: 0.187466\n", + "Cost after iteration 2835: 0.187449\n", + "Cost after iteration 2836: 0.187434\n", + "Cost after iteration 2837: 0.187429\n", + "Cost after iteration 2838: 0.187428\n", + "Cost after iteration 2839: 0.187448\n", + "Cost after iteration 2840: 0.187474\n", + "Cost after iteration 2841: 0.187542\n", + "Cost after iteration 2842: 0.187618\n", + "Cost after iteration 2843: 0.187790\n", + "Cost after iteration 2844: 0.187967\n", + "Cost after iteration 2845: 0.188373\n", + "Cost after iteration 2846: 0.188763\n", + "Cost after iteration 2847: 0.189732\n", + "Cost after iteration 2848: 0.190598\n", + "Cost after iteration 2849: 0.193035\n", + "Cost after iteration 2850: 0.195070\n", + "Cost after iteration 2851: 0.201591\n", + "Cost after iteration 2852: 0.206233\n", + "Cost after iteration 2853: 0.223543\n", + "Cost after iteration 2854: 0.226535\n", + "Cost after iteration 2855: 0.262052\n", + "Cost after iteration 2856: 0.240111\n", + "Cost after iteration 2857: 0.275595\n", + "Cost after iteration 2858: 0.231426\n", + "Cost after iteration 2859: 0.244352\n", + "Cost after iteration 2860: 0.217259\n", + "Cost after iteration 2861: 0.220866\n", + "Cost after iteration 2862: 0.211725\n", + "Cost after iteration 2863: 0.214070\n", + "Cost after iteration 2864: 0.210223\n", + "Cost after iteration 2865: 0.213044\n", + "Cost after iteration 2866: 0.211323\n", + "Cost after iteration 2867: 0.215362\n", + "Cost after iteration 2868: 0.214223\n", + "Cost after iteration 2869: 0.219629\n", + "Cost after iteration 2870: 0.217800\n", + "Cost after iteration 2871: 0.223950\n", + "Cost after iteration 2872: 0.220209\n", + "Cost after iteration 2873: 0.225327\n", + "Cost after iteration 2874: 0.219047\n", + "Cost after iteration 2875: 0.220767\n", + "Cost after iteration 2876: 0.213014\n", + "Cost after iteration 2877: 0.210850\n", + "Cost after iteration 2878: 0.204058\n", + "Cost after iteration 2879: 0.200677\n", + "Cost after iteration 2880: 0.196474\n", + "Cost after iteration 2881: 0.194243\n", + "Cost after iteration 2882: 0.192246\n", + "Cost after iteration 2883: 0.191176\n", + "Cost after iteration 2884: 0.190299\n", + "Cost after iteration 2885: 0.189809\n", + "Cost after iteration 2886: 0.189393\n", + "Cost after iteration 2887: 0.189145\n", + "Cost after iteration 2888: 0.188917\n", + "Cost after iteration 2889: 0.188772\n", + "Cost after iteration 2890: 0.188626\n", + "Cost after iteration 2891: 0.188528\n", + "Cost after iteration 2892: 0.188424\n", + "Cost after iteration 2893: 0.188350\n", + "Cost after iteration 2894: 0.188269\n", + "Cost after iteration 2895: 0.188210\n", + "Cost after iteration 2896: 0.188144\n", + "Cost after iteration 2897: 0.188095\n", + "Cost after iteration 2898: 0.188039\n", + "Cost after iteration 2899: 0.187998\n", + "Cost after iteration 2900: 0.187950\n", + "Cost after iteration 2901: 0.187918\n", + "Cost after iteration 2902: 0.187877\n", + "Cost after iteration 2903: 0.187853\n", + "Cost after iteration 2904: 0.187821\n", + "Cost after iteration 2905: 0.187808\n", + "Cost after iteration 2906: 0.187785\n", + "Cost after iteration 2907: 0.187787\n", + "Cost after iteration 2908: 0.187776\n", + "Cost after iteration 2909: 0.187801\n", + "Cost after iteration 2910: 0.187807\n", + "Cost after iteration 2911: 0.187869\n", + "Cost after iteration 2912: 0.187902\n", + "Cost after iteration 2913: 0.188027\n", + "Cost after iteration 2914: 0.188104\n", + "Cost after iteration 2915: 0.188344\n", + "Cost after iteration 2916: 0.188498\n", + "Cost after iteration 2917: 0.188957\n", + "Cost after iteration 2918: 0.189251\n", + "Cost after iteration 2919: 0.190157\n", + "Cost after iteration 2920: 0.190721\n", + "Cost after iteration 2921: 0.192597\n", + "Cost after iteration 2922: 0.193722\n", + "Cost after iteration 2923: 0.197827\n", + "Cost after iteration 2924: 0.200064\n", + "Cost after iteration 2925: 0.209245\n", + "Cost after iteration 2926: 0.212083\n", + "Cost after iteration 2927: 0.230443\n", + "Cost after iteration 2928: 0.225238\n", + "Cost after iteration 2929: 0.250207\n", + "Cost after iteration 2930: 0.228370\n", + "Cost after iteration 2931: 0.246551\n", + "Cost after iteration 2932: 0.222073\n", + "Cost after iteration 2933: 0.230648\n", + "Cost after iteration 2934: 0.217023\n", + "Cost after iteration 2935: 0.222124\n", + "Cost after iteration 2936: 0.215683\n", + "Cost after iteration 2937: 0.220594\n", + "Cost after iteration 2938: 0.217587\n", + "Cost after iteration 2939: 0.224278\n", + "Cost after iteration 2940: 0.222911\n", + "Cost after iteration 2941: 0.233255\n", + "Cost after iteration 2942: 0.231489\n", + "Cost after iteration 2943: 0.246422\n", + "Cost after iteration 2944: 0.240024\n", + "Cost after iteration 2945: 0.255579\n", + "Cost after iteration 2946: 0.240119\n", + "Cost after iteration 2947: 0.246644\n", + "Cost after iteration 2948: 0.227315\n", + "Cost after iteration 2949: 0.222435\n", + "Cost after iteration 2950: 0.208894\n", + "Cost after iteration 2951: 0.202405\n", + "Cost after iteration 2952: 0.196436\n", + "Cost after iteration 2953: 0.193741\n", + "Cost after iteration 2954: 0.191814\n", + "Cost after iteration 2955: 0.190960\n", + "Cost after iteration 2956: 0.190277\n", + "Cost after iteration 2957: 0.189939\n", + "Cost after iteration 2958: 0.189616\n", + "Cost after iteration 2959: 0.189429\n", + "Cost after iteration 2960: 0.189236\n", + "Cost after iteration 2961: 0.189108\n", + "Cost after iteration 2962: 0.188973\n", + "Cost after iteration 2963: 0.188874\n", + "Cost after iteration 2964: 0.188770\n", + "Cost after iteration 2965: 0.188687\n", + "Cost after iteration 2966: 0.188602\n", + "Cost after iteration 2967: 0.188531\n", + "Cost after iteration 2968: 0.188457\n", + "Cost after iteration 2969: 0.188394\n", + "Cost after iteration 2970: 0.188330\n", + "Cost after iteration 2971: 0.188273\n", + "Cost after iteration 2972: 0.188216\n", + "Cost after iteration 2973: 0.188165\n", + "Cost after iteration 2974: 0.188113\n", + "Cost after iteration 2975: 0.188068\n", + "Cost after iteration 2976: 0.188022\n", + "Cost after iteration 2977: 0.187982\n", + "Cost after iteration 2978: 0.187941\n", + "Cost after iteration 2979: 0.187908\n", + "Cost after iteration 2980: 0.187873\n", + "Cost after iteration 2981: 0.187849\n", + "Cost after iteration 2982: 0.187821\n", + "Cost after iteration 2983: 0.187808\n", + "Cost after iteration 2984: 0.187790\n", + "Cost after iteration 2985: 0.187795\n", + "Cost after iteration 2986: 0.187792\n", + "Cost after iteration 2987: 0.187826\n", + "Cost after iteration 2988: 0.187847\n", + "Cost after iteration 2989: 0.187931\n", + "Cost after iteration 2990: 0.187992\n", + "Cost after iteration 2991: 0.188170\n", + "Cost after iteration 2992: 0.188303\n", + "Cost after iteration 2993: 0.188667\n", + "Cost after iteration 2994: 0.188933\n", + "Cost after iteration 2995: 0.189687\n", + "Cost after iteration 2996: 0.190215\n", + "Cost after iteration 2997: 0.191844\n", + "Cost after iteration 2998: 0.192934\n", + "Cost after iteration 2999: 0.196657\n", + "W1 = [[-2.04656776 1.66958888]\n", + " [-2.23184234 1.98940688]]\n", + "b1 = [[ 4.81245665]\n", + " [-6.35603685]]\n", + "W2 = [[ 7.24522298 -7.11808143]]\n", + "b2 = [[-3.57778411]]\n" + ] + } + ], + "source": [ + "parameters = nn_model(X, Y, n_h=2, num_iterations=3000, learning_rate=1.2, print_cost=True)\n", + "print(\"W1 = \" + str(parameters[\"W1\"]))\n", + "print(\"b1 = \" + str(parameters[\"b1\"]))\n", + "print(\"W2 = \" + str(parameters[\"W2\"]))\n", + "print(\"b2 = \" + str(parameters[\"b2\"]))\n", + "\n", + "W1 = parameters[\"W1\"]\n", + "b1 = parameters[\"b1\"]\n", + "W2 = parameters[\"W2\"]\n", + "b2 = parameters[\"b2\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### __Expected Output__ \n", + "Note: the actual values can be different!\n", + "\n", + "```Python\n", + "Cost after iteration 0: 0.693148\n", + "Cost after iteration 1: 0.693147\n", + "Cost after iteration 2: 0.693147\n", + "Cost after iteration 3: 0.693147\n", + "Cost after iteration 4: 0.693147\n", + "Cost after iteration 5: 0.693147\n", + "...\n", + "Cost after iteration 2995: 0.209524\n", + "Cost after iteration 2996: 0.208025\n", + "Cost after iteration 2997: 0.210427\n", + "Cost after iteration 2998: 0.208929\n", + "Cost after iteration 2999: 0.211306\n", + "W1 = [[ 2.14274251 -1.93155541]\n", + " [ 2.20268789 -2.1131799 ]]\n", + "b1 = [[-4.83079243]\n", + " [ 6.2845223 ]]\n", + "W2 = [[-7.21370685 7.0898022 ]]\n", + "b2 = [[-3.48755239]]\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[92m All tests passed\n" + ] + } + ], + "source": [ + "# Note: \n", + "# Actual values are not checked here in the unit tests (due to random initialization).\n", + "w3_unittest.test_nn_model(nn_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The final model parameters can be used to find the boundary line and for making predictions. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Exercise 8\n", + "\n", + "Computes probabilities using forward propagation, and make classification to 0/1 using 0.5 as the threshold." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: predict\n", + "\n", + "def predict(X, parameters):\n", + " \"\"\"\n", + " Using the learned parameters, predicts a class for each example in X\n", + " \n", + " Arguments:\n", + " parameters -- python dictionary containing your parameters \n", + " X -- input data of size (n_x, m)\n", + " \n", + " Returns\n", + " predictions -- vector of predictions of our model (blue: 0 / red: 1)\n", + " \"\"\"\n", + " \n", + " ### START CODE HERE ### (≈ 2 lines of code)\n", + " A2, cache = forward_propagation(X, parameters)\n", + " predictions = A2 > 0.5\n", + " ### END CODE HERE ###\n", + " \n", + " return predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Coordinates (in the columns):\n", + "[[2 8 2 8]\n", + " [2 8 8 2]]\n", + "Predictions:\n", + "[[ True True False False]]\n" + ] + } + ], + "source": [ + "X_pred = np.array([[2, 8, 2, 8], [2, 8, 8, 2]])\n", + "Y_pred = predict(X_pred, parameters)\n", + "\n", + "print(f\"Coordinates (in the columns):\\n{X_pred}\")\n", + "print(f\"Predictions:\\n{Y_pred}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### __Expected Output__ \n", + "\n", + "```Python\n", + "Coordinates (in the columns):\n", + "[[2 8 2 8]\n", + " [2 8 8 2]]\n", + "Predictions:\n", + "[[ True True False False]]\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[92m All tests passed\n" + ] + } + ], + "source": [ + "w3_unittest.test_predict(predict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's visualize the boundary line. Do not worry if you don't understand the function `plot_decision_boundary` line by line - it simply makes prediction for some points on the plane and plots them as a contour plot (just two colors - blue and red)." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Decision Boundary for hidden layer size 2')" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_decision_boundary(predict, parameters, X, Y):\n", + " # Define bounds of the domain.\n", + " min1, max1 = X[0, :].min()-1, X[0, :].max()+1\n", + " min2, max2 = X[1, :].min()-1, X[1, :].max()+1\n", + " # Define the x and y scale.\n", + " x1grid = np.arange(min1, max1, 0.1)\n", + " x2grid = np.arange(min2, max2, 0.1)\n", + " # Create all of the lines and rows of the grid.\n", + " xx, yy = np.meshgrid(x1grid, x2grid)\n", + " # Flatten each grid to a vector.\n", + " r1, r2 = xx.flatten(), yy.flatten()\n", + " r1, r2 = r1.reshape((1, len(r1))), r2.reshape((1, len(r2)))\n", + " # Vertical stack vectors to create x1,x2 input for the model.\n", + " grid = np.vstack((r1,r2))\n", + " # Make predictions for the grid.\n", + " predictions = predict(grid, parameters)\n", + " # Reshape the predictions back into a grid.\n", + " zz = predictions.reshape(xx.shape)\n", + " # Plot the grid of x, y and z values as a surface.\n", + " plt.contourf(xx, yy, zz, cmap=plt.cm.Spectral.reversed())\n", + " plt.scatter(X[0, :], X[1, :], c=Y, cmap=colors.ListedColormap(['blue', 'red']));\n", + "\n", + "# Plot the decision boundary.\n", + "plot_decision_boundary(predict, parameters, X, Y)\n", + "plt.title(\"Decision Boundary for hidden layer size \" + str(n_h))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 4 - Optional: Other Dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Build a slightly different dataset:" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n_samples = 2000\n", + "samples, labels = make_blobs(n_samples=n_samples, \n", + " centers=([2.5, 3], [6.7, 7.9], [2.1, 7.9], [7.4, 2.8]), \n", + " cluster_std=1.1,\n", + " random_state=0)\n", + "labels[(labels == 0)] = 0\n", + "labels[(labels == 1)] = 1\n", + "labels[(labels == 2) | (labels == 3)] = 1\n", + "X_2 = np.transpose(samples)\n", + "Y_2 = labels.reshape((1,n_samples))\n", + "\n", + "plt.scatter(X_2[0, :], X_2[1, :], c=Y_2, cmap=colors.ListedColormap(['blue', 'red']));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice that when building your neural network, a number of the nodes in the hidden layer could be taken as a parameter. Try to change this parameter and investigate the results:" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Decision Boundary')" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# parameters_2 = nn_model(X_2, Y_2, n_h=1, num_iterations=3000, learning_rate=1.2, print_cost=False)\n", + "# parameters_2 = nn_model(X_2, Y_2, n_h=2, num_iterations=3000, learning_rate=1.2, print_cost=False)\n", + "parameters_2 = nn_model(X_2, Y_2, n_h=15, num_iterations=3000, learning_rate=1.2, print_cost=False)\n", + "\n", + "# This function will call predict function \n", + "plot_decision_boundary(predict, parameters_2, X_2, Y_2)\n", + "plt.title(\"Decision Boundary\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can see that there are some misclassified points - real-world datasets are usually linearly inseparable, and there will be a small percentage of errors. More than that, you do not want to build a model that fits too closely, almost exactly to a particular set of data - it may fail to predict future observations. This problem is known as **overfitting**." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Congrats on finishing this programming assignment!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "graded" + ] + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "name": "C1_W1_Assignment_Solution.ipynb", + "provenance": [] + }, + "coursera": { + "schema_names": [ + "AI4MC1-1" + ] + }, + "grader_version": "2", + "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.8.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/math/calculus-for-ml/regression_with_perceptron.ipynb b/math/calculus-for-ml/regression_with_perceptron_no_sigmoid.ipynb similarity index 100% rename from math/calculus-for-ml/regression_with_perceptron.ipynb rename to math/calculus-for-ml/regression_with_perceptron_no_sigmoid.ipynb