10-Dog Breed_v1.4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DNN with He/Xavier initialization and Adam optimizer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "np.random.seed(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATADIR = \"C:/Users/Omkar/ML and DS/Dog/dataset\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "CATEGORIES = [\"Golden1\", \"German1\"]\n",
    "img_size = 64"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating training data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_data=[]\n",
    "\n",
    "def create_training_data():\n",
    "    for category in CATEGORIES:\n",
    "        path = os.path.join(DATADIR, category)\n",
    "        class_num = CATEGORIES.index(category)\n",
    "        for img in os.listdir(path):\n",
    "            img_array = cv2.imread(os.path.join(path, img))\n",
    "            new_array = cv2.resize(img_array,(img_size,img_size))\n",
    "            training_data.append([new_array, class_num])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "604\n"
     ]
    }
   ],
   "source": [
    "create_training_data()\n",
    "print(len(training_data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "random.shuffle(training_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seperation of X,y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = []\n",
    "y = []\n",
    "for features, label in training_data:\n",
    "    X.append(features)\n",
    "    y.append(label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.array(X)\n",
    "y = np.array(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of X = (604, 64, 64, 3)\n",
      "Shape of y = (604,)\n"
     ]
    }
   ],
   "source": [
    "print(\"Shape of X = \"+ str(X.shape))\n",
    "print(\"Shape of y = \" + str(y.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train,x_test,y_train,y_test=train_test_split(X,y,test_size=0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Reshaping y**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train = y_train.reshape((1, y_train.shape[0]))\n",
    "y_test = y_test.reshape((1, y_test.shape[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example of picture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y= [0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "index = 99\n",
    "plt.imshow(x_train[index])\n",
    "print(\"y= \"+ str(y_train[:,index]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explore Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of training examples: m_train = 422\n",
      "Number of testing examples: m_test = 182\n",
      "Height/Width of each image: num_px = 64\n",
      "Each image is of size: (64, 64, 3)\n",
      "train_set_x shape: (422, 64, 64, 3)\n",
      "train_set_y shape: (1, 422)\n",
      "test_set_x shape: (182, 64, 64, 3)\n",
      "test_set_y shape: (1, 182)\n"
     ]
    }
   ],
   "source": [
    "m_train = x_train.shape[0]\n",
    "m_test = x_test.shape[0]\n",
    "num_px = x_train.shape[1]\n",
    "\n",
    "print (\"Number of training examples: m_train = \" + str(m_train))\n",
    "print (\"Number of testing examples: m_test = \" + str(m_test))\n",
    "print (\"Height/Width of each image: num_px = \" + str(num_px))\n",
    "print (\"Each image is of size: (\" + str(num_px) + \", \" + str(num_px) + \", 3)\")\n",
    "print (\"train_set_x shape: \" + str(x_train.shape))\n",
    "print (\"train_set_y shape: \" + str(y_train.shape))\n",
    "print (\"test_set_x shape: \" + str(x_test.shape))\n",
    "print (\"test_set_y shape: \" + str(y_test.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reshaping Training and Test examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_set_x_flatten shape: (12288, 422)\n",
      "train_set_y shape: (1, 422)\n",
      "test_set_x_flatten shape: (12288, 182)\n",
      "test_set_y shape: (1, 182)\n",
      "sanity check after reshaping: [ 81  92 121  72 107]\n"
     ]
    }
   ],
   "source": [
    "train_set_x_flatten = x_train.reshape(x_train.shape[0], -1).T\n",
    "test_set_x_flatten = x_test.reshape(x_test.shape[0], -1).T\n",
    "\n",
    "print (\"train_set_x_flatten shape: \" + str(train_set_x_flatten.shape))\n",
    "print (\"train_set_y shape: \" + str(y_train.shape))\n",
    "print (\"test_set_x_flatten shape: \" + str(test_set_x_flatten.shape))\n",
    "print (\"test_set_y shape: \" + str(y_test.shape))\n",
    "print (\"sanity check after reshaping: \" + str(train_set_x_flatten[0:5,0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Standardizing Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_x = train_set_x_flatten/255.\n",
    "test_x = test_set_x_flatten/255."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Helper Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(Z):\n",
    "    A = 1/(1+np.exp(-Z))\n",
    "    cache = Z\n",
    "    \n",
    "    return A,cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def relu(Z):\n",
    "    A = np.maximum(0,Z)\n",
    "    \n",
    "    assert(A.shape == Z.shape)\n",
    "    cache = Z\n",
    "    return A,cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid_backward(dA, cache):\n",
    "    Z = cache\n",
    "    s = 1/(1+np.exp(-Z))\n",
    "    dZ = dA * s * (1-s)\n",
    "    \n",
    "    assert(dZ.shape == Z.shape)\n",
    "    return dZ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def relu_backward(dA, cache):\n",
    "    Z = cache\n",
    "    dZ = np.array(dA, copy=True)\n",
    "    \n",
    "    dZ[Z <= 0] = 0\n",
    "    \n",
    "    assert(dZ.shape == Z.shape)\n",
    "    return dZ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_parameters_deep(layer_dims):\n",
    "    np.random.seed(1)\n",
    "    parameters = {}\n",
    "    L = len(layer_dims)\n",
    "    \n",
    "    for l in range(1,L):\n",
    "        parameters[\"W\" + str(l)] = np.random.randn(layer_dims[l],\n",
    "                                                   layer_dims[l-1])*(np.sqrt(2. / layer_dims[l-1]))\n",
    "        \n",
    "        parameters[\"b\" + str(l)] = np.zeros((layer_dims[l],1))\n",
    "        \n",
    "        assert(parameters['W' + str(l)].shape == (layer_dims[l],\n",
    "                                                  layer_dims[l-1]))\n",
    "        \n",
    "        assert(parameters['b' + str(l)].shape == (layer_dims[l], 1))\n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_adam(parameters) :\n",
    "    \n",
    "    L = len(parameters) // 2 # number of layers in the neural networks\n",
    "    v = {}\n",
    "    s = {}\n",
    "    \n",
    "    # Initialize v, s. Input: \"parameters\". Outputs: \"v, s\".\n",
    "    for l in range(L):\n",
    "        v[\"dW\" + str(l+1)] = np.zeros_like(parameters[\"W\" + str(l+1)])\n",
    "        v[\"db\" + str(l+1)] = np.zeros_like(parameters[\"b\" + str(l+1)])\n",
    "        s[\"dW\" + str(l+1)] = np.zeros_like(parameters[\"W\" + str(l+1)])\n",
    "        s[\"db\" + str(l+1)] = np.zeros_like(parameters[\"b\" + str(l+1)])\n",
    "    \n",
    "    return v, s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Forward Prop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_forward(A, W, b):\n",
    "    Z = np.dot(W,A)+b\n",
    "    assert(Z.shape == (W.shape[0], A.shape[1]))\n",
    "    cache = (A, W, b)\n",
    "    \n",
    "    return Z, cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_activation_forward(A_prev, W, b, activation):\n",
    "    if activation == \"sigmoid\":\n",
    "        # Inputs: \"A_prev, W, b\". Outputs: \"A, activation_cache\"\n",
    "        Z, linear_cache = linear_forward(A_prev, W, b)\n",
    "        A, activation_cache = sigmoid(Z)\n",
    "    \n",
    "    elif activation == \"relu\":\n",
    "        # Inputs: \"A_prev, W, b\". Outputs: \"A, activation_cache\"\n",
    "        Z, linear_cache = linear_forward(A_prev, W, b)\n",
    "        A, activation_cache = relu(Z)\n",
    "    \n",
    "    assert (A.shape == (W.shape[0], A_prev.shape[1]))\n",
    "    cache = (linear_cache, activation_cache)\n",
    "\n",
    "    return A, cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def L_model_forward(X, parameters):\n",
    "    caches = []\n",
    "    A = X\n",
    "    L = len(parameters) // 2    # number of layers in the neural network\n",
    "    \n",
    "    # Implement [LINEAR -> RELU]*(L-1). Add \"cache\" to the \"caches\" list.\n",
    "    for l in range(1, L):\n",
    "        A_prev = A \n",
    "        A, cache = linear_activation_forward(A_prev, parameters['W'+ str(l)],\n",
    "                                             parameters['b'+ str(l)],\n",
    "                                             activation = \"relu\")\n",
    "        caches.append(cache)\n",
    "    \n",
    "    # Implement LINEAR -> SIGMOID. Add \"cache\" to the \"caches\" list.\n",
    "    AL, cache = linear_activation_forward(A, parameters['W' + str(L)],\n",
    "                                          parameters['b' + str(L)],\n",
    "                                          activation= \"sigmoid\")\n",
    "    caches.append(cache)\n",
    "    \n",
    "    assert(AL.shape == (1,X.shape[1]))\n",
    "            \n",
    "    return AL, caches"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cost Function\n",
    "\n",
    "$$-\\frac{1}{m} \\sum\\limits_{i = 1}^{m} (y^{(i)}\\log\\left(a^{[L] (i)}\\right) + (1-y^{(i)})\\log\\left(1- a^{[L](i)}\\right)) \\tag{7}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost(AL, Y, parameters, lambd):\n",
    "    m = Y.shape[1]\n",
    "    L = len(parameters) // 2\n",
    "    W_r = np.zeros((1,1))\n",
    "    \n",
    "    for l in range(L):\n",
    "        \n",
    "        W = parameters[\"W\"+str(l+1)]\n",
    "        W = np.sum(np.square(W))\n",
    "        W_r += W\n",
    "        \n",
    "        \n",
    "    cost = (-(1/m) * np.sum(np.multiply(np.log(AL),Y) + np.multiply(np.log(1-AL),1-Y))) + (lambd/(2*m))*W_r\n",
    "    \n",
    "    cost = np.squeeze(cost)\n",
    "    assert(cost.shape == ())\n",
    "    \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Backward Prop\n",
    "\n",
    "#### Linear back prop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_backward(dZ, cache, lambd):\n",
    "    A_prev, W, b = cache\n",
    "    m = A_prev.shape[1]\n",
    "\n",
    "    dW = (1/m) * np.dot(dZ,A_prev.T)+ (lambd/m)\n",
    "    db = (1/m) * np.sum(dZ, axis=1, keepdims=True)\n",
    "    dA_prev = np.dot(W.T, dZ)\n",
    "    \n",
    "    assert (dA_prev.shape == A_prev.shape)\n",
    "    assert (dW.shape == W.shape)\n",
    "    assert (db.shape == b.shape)\n",
    "    \n",
    "    return dA_prev, dW, db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_activation_backward(dA, cache, activation):\n",
    "    linear_cache, activation_cache = cache\n",
    "    \n",
    "    if activation == \"relu\":\n",
    "        dZ = relu_backward(dA,activation_cache)\n",
    "        dA_prev, dW, db = linear_backward(dZ,linear_cache,lambd= 0.7)\n",
    "        \n",
    "    elif activation == \"sigmoid\":\n",
    "        dZ = sigmoid_backward(dA,activation_cache)\n",
    "        dA_prev, dW, db = linear_backward(dZ,linear_cache, lambd = 0.7)\n",
    "    \n",
    "    return dA_prev, dW, db"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Update Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_parameters(parameters, grads, v, s, t, learning_rate, beta1 = 0.9, beta2 = 0.999,  epsilon = 1e-8):\n",
    "    L = len(parameters) // 2 # number of layers in the neural network\n",
    "    \n",
    "    v_corrected = {}    # Initializing first moment estimate\n",
    "    s_corrected = {}\n",
    "\n",
    "    for l in range(L):\n",
    "        \n",
    "        v[\"dW\" + str(l+1)] = beta1*v[\"dW\" + str(l+1)] + (1-beta1)*grads['dW' + str(l+1)]\n",
    "        v[\"db\" + str(l+1)] = beta1*v[\"db\" + str(l+1)] + (1-beta1)*grads['db' + str(l+1)]\n",
    "        \n",
    "        v_corrected[\"dW\" + str(l+1)] = v[\"dW\" + str(l+1)]/(1-np.power(beta1,t))\n",
    "        v_corrected[\"db\" + str(l+1)] = v[\"db\" + str(l+1)]/(1-np.power(beta1,t))\n",
    "        \n",
    "        s[\"dW\" + str(l+1)] = beta2*s[\"dW\" + str(l+1)]+(1-beta2)*np.square(grads['dW' + str(l+1)])\n",
    "        s[\"db\" + str(l+1)] = beta2*s[\"db\" + str(l+1)]+(1-beta2)*np.square(grads['db' + str(l+1)])\n",
    "        \n",
    "        s_corrected[\"dW\" + str(l+1)] = s[\"dW\" + str(l+1)]/(1-np.power(beta2,t))\n",
    "        s_corrected[\"db\" + str(l+1)] = s[\"db\" + str(l+1)]/(1-np.power(beta2,t))\n",
    "        \n",
    "        parameters[\"W\" + str(l+1)] = parameters[\"W\"+ str(l+1)] - learning_rate*v_corrected[\"dW\" + str(l+1)]/np.sqrt(s_corrected[\"dW\" + str(l+1)] +epsilon)\n",
    "        parameters[\"b\" + str(l+1)] = parameters[\"b\" + str(l+1)] - learning_rate*v_corrected[\"db\" + str(l+1)]/np.sqrt(s_corrected[\"db\" + str(l+1)]+epsilon)\n",
    "    \n",
    "    return parameters, v, s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(X, y, parameters):\n",
    "    m = X.shape[1]\n",
    "    n = len(parameters) // 2 # number of layers in the neural network\n",
    "    p = np.zeros((1,m))\n",
    "    \n",
    "    # Forward propagation\n",
    "    probas, caches = L_model_forward(X, parameters)\n",
    "    \n",
    "    # convert probas to 0/1 predictions\n",
    "    for i in range(0, probas.shape[1]):\n",
    "        if probas[0,i] > 0.5:\n",
    "            p[0,i] = 1\n",
    "        else:\n",
    "            p[0,i] = 0\n",
    "    \n",
    "    #print results\n",
    "    #print (\"predictions: \" + str(p))\n",
    "    #print (\"true labels: \" + str(y))\n",
    "    print(\"Accuracy: \"  + str(np.sum((p == y)/m)))\n",
    "        \n",
    "    return p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deep NN\n",
    "\n",
    "### L-Model Backward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def L_model_backward(AL, Y, caches):\n",
    "    grads = {}\n",
    "    L = len(caches) # the number of layers\n",
    "    m = AL.shape[1]\n",
    "    Y = Y.reshape(AL.shape) # after this line, Y is the same shape as AL\n",
    "    \n",
    "    # Initializing the backpropagation\n",
    "    dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))\n",
    "    # Lth layer (SIGMOID -> LINEAR) gradients.\n",
    "    current_cache = caches[L-1]\n",
    "    grads[\"dA\" + str(L-1)], grads[\"dW\" + str(L)], grads[\"db\" + str(L)] = linear_activation_backward(dAL, current_cache, activation = \"sigmoid\")\n",
    "\n",
    "    \n",
    "    # Loop from l=L-2 to l=0\n",
    "    for l in reversed(range(L-1)):\n",
    "        # lth layer: (RELU -> LINEAR) gradients.\n",
    "        current_cache = caches[l]\n",
    "        dA_prev_temp, dW_temp, db_temp = linear_activation_backward(grads[\"dA\" + str(l + 1)],\n",
    "                                   current_cache, activation = \"relu\")\n",
    "        grads[\"dA\" + str(l)] = dA_prev_temp\n",
    "        grads[\"dW\" + str(l + 1)] = dW_temp \n",
    "        grads[\"db\" + str(l + 1)] = db_temp\n",
    "\n",
    "    return grads"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### L-Layer NN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "def L_layer_model(X, Y, layers_dims, learning_rate = 0.000002,num_iterations=5000, \n",
    "                  beta = 0.8, beta1 = 0.8, beta2 = 0.899,  epsilon = 1e-8, print_cost = True):#lr was 0.009\n",
    "    \n",
    "    costs = []   # keep track of cost\n",
    "    t = 0\n",
    "    \n",
    "    # Parameters initialization\n",
    "    parameters = initialize_parameters_deep(layers_dims)\n",
    "    v, s = initialize_adam(parameters)\n",
    "    \n",
    "    # Loop (gradient descent)\n",
    "    for i in range(0, num_iterations):\n",
    "\n",
    "        # Forward propagation: [LINEAR -> RELU]*(L-1) -> LINEAR -> SIGMOID\n",
    "        AL, caches = L_model_forward(X, parameters)\n",
    "        \n",
    "        # Compute cost\n",
    "        cost = compute_cost(AL, Y, parameters, lambd = 0.7)\n",
    "    \n",
    "        # Backward propagation\n",
    "        grads = L_model_backward(AL, Y, caches)\n",
    " \n",
    "        # Update parameters\n",
    "        t = t + 1\n",
    "        parameters, v, s = update_parameters(parameters, grads, v, s, t, learning_rate, beta1, beta2,  epsilon)\n",
    "                \n",
    "        if print_cost and i % 1000 == 0:\n",
    "            print (\"Cost after iteration %i: %f\" %(i, cost))\n",
    "        if print_cost and i % 1000 == 0:\n",
    "            costs.append(cost)\n",
    "            \n",
    "    # plot the cost\n",
    "    plt.plot(np.squeeze(costs))\n",
    "    plt.ylabel('cost')\n",
    "    plt.xlabel('iterations (per hundreds)')\n",
    "    plt.title(\"Learning rate =\" + str(learning_rate))\n",
    "    plt.show()\n",
    "    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 0.764635\n",
      "Cost after iteration 1000: 0.473535\n",
      "Cost after iteration 2000: 0.348153\n",
      "Cost after iteration 3000: 0.269270\n",
      "Cost after iteration 4000: 0.215707\n",
      "Cost after iteration 5000: 0.180278\n",
      "Cost after iteration 6000: 0.152495\n",
      "Cost after iteration 7000: 0.130945\n",
      "Cost after iteration 8000: 0.114728\n",
      "Cost after iteration 9000: 0.101975\n",
      "Cost after iteration 10000: 0.091941\n",
      "Cost after iteration 11000: 0.084453\n",
      "Cost after iteration 12000: 0.088775\n",
      "Cost after iteration 13000: 0.084777\n",
      "Cost after iteration 14000: 0.081010\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "layer_dims = [12288,4,1] # 4-layer\n",
    "parameters = L_layer_model(train_x,y_train,layer_dims,num_iterations=15000,print_cost=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.9905213270142181\n"
     ]
    }
   ],
   "source": [
    "pred_train = predict(train_x, y_train, parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.7912087912087913\n"
     ]
    }
   ],
   "source": [
    "pred_test = predict(test_x, y_test, parameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\begin{cases}\n",
    "v_{W^{[l]}} = \\beta_1 v_{W^{[l]}} + (1 - \\beta_1) \\frac{\\partial J }{ \\partial W^{[l]} } \\\\\n",
    "v^{corrected}_{W^{[l]}} = \\frac{v_{W^{[l]}}}{1 - (\\beta_1)^t} \\\\\n",
    "s_{W^{[l]}} = \\beta_2 s_{W^{[l]}} + (1 - \\beta_2) (\\frac{\\partial J }{\\partial W^{[l]} })^2 \\\\\n",
    "s^{corrected}_{W^{[l]}} = \\frac{s_{W^{[l]}}}{1 - (\\beta_2)^t} \\\\\n",
    "W^{[l]} = W^{[l]} - \\alpha \\frac{v^{corrected}_{W^{[l]}}}{\\sqrt{s^{corrected}_{W^{[l]}}}+\\varepsilon}\n",
    "\\end{cases}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}