L-layer-model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy\n",
    "from PIL import Image\n",
    "from scipy import ndimage\n",
    "from dnn_app_utils_v3 import *\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (5.0, 4.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "np.random.seed(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_x_orig, train_y, test_x_orig, test_y, classes = load_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 0. It's a non-cat picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example of a picture\n",
    "index = 10\n",
    "plt.imshow(train_x_orig[index])\n",
    "print (\"y = \" + str(train_y[0,index]) + \". It's a \" + classes[train_y[0,index]].decode(\"utf-8\") +  \" picture.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of training examples: 209\n",
      "Number of testing examples: 50\n",
      "Each image is of size: (64, 64, 3)\n",
      "train_x_orig shape: (209, 64, 64, 3)\n",
      "train_y shape: (1, 209)\n",
      "test_x_orig shape: (50, 64, 64, 3)\n",
      "test_y shape: (1, 50)\n"
     ]
    }
   ],
   "source": [
    "# Explore dataset \n",
    "m_train = train_x_orig.shape[0]\n",
    "num_px = train_x_orig.shape[1]\n",
    "m_test = test_x_orig.shape[0]\n",
    "\n",
    "print (\"Number of training examples: \" + str(m_train))\n",
    "print (\"Number of testing examples: \" + str(m_test))\n",
    "print (\"Each image is of size: (\" + str(num_px) + \", \" + str(num_px) + \", 3)\")\n",
    "print (\"train_x_orig shape: \" + str(train_x_orig.shape))\n",
    "print (\"train_y shape: \" + str(train_y.shape))\n",
    "print (\"test_x_orig shape: \" + str(test_x_orig.shape))\n",
    "print (\"test_y shape: \" + str(test_y.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_x's shape: (12288, 209)\n",
      "test_x's shape: (12288, 50)\n"
     ]
    }
   ],
   "source": [
    "# Reshape the training and test examples \n",
    "train_x_flatten = train_x_orig.reshape(train_x_orig.shape[0], -1).T\n",
    "test_x_flatten = test_x_orig.reshape(test_x_orig.shape[0], -1).T\n",
    "\n",
    "# Standardize data to have feature values between 0 and 1.\n",
    "train_x = train_x_flatten/255.\n",
    "test_x = test_x_flatten/255.\n",
    "\n",
    "print (\"train_x's shape: \" + str(train_x.shape))\n",
    "print (\"test_x's shape: \" + str(test_x.shape))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## L-layer neural network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CONSTANTS\n",
    "layers_dims = [12288, 20, 7, 5, 1] #4-layer model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_parameters_deep(layers_dims):\n",
    "    parameters = {}\n",
    "    L = len(layers_dims)\n",
    "\n",
    "    for l in range(1, L):\n",
    "        parameters[\"W\" + str(l)] = np.random.randn(layers_dims[l],layers_dims[l-1]) / np.sqrt(layers_dims[l-1])\n",
    "        parameters[\"b\" + str(l)] = np.zeros((layers_dims[l],1))\n",
    "\n",
    "        #Checking dimension\n",
    "        assert(parameters['W' + str(l)].shape == (layers_dims[l], layers_dims[l-1]))\n",
    "        assert(parameters['b' + str(l)].shape == (layers_dims[l], 1))\n",
    "    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "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",
    "    for l in range(1, L):\n",
    "        A_prev = A\n",
    "        A, cache = linear_activation_forward(A_prev, parameters[\"W\"+str(l)], parameters[\"b\" + str(l)], \n",
    "                                                activation = \"relu\" )\n",
    "        caches.append(cache)\n",
    "        \n",
    "    # Implement LINEAR -> SIGMOID\n",
    "    AL, cache = linear_activation_forward(A, parameters[\"W\" + str(L)] , parameters[\"b\" + str(L)] , \"sigmoid\")\n",
    "    caches.append(cache) # Add \"cache\" to the \"caches\" list\n",
    "\n",
    "    #Checking dimension\n",
    "    assert(AL.shape == (1,X.shape[1]))\n",
    "    \n",
    "    return AL, caches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost(AL, Y):\n",
    "    m = Y.shape[1]\n",
    "    cost = - np.sum(Y*np.log(AL) + (1-Y)*np.log(1-AL)) / m\n",
    "\n",
    "    cost = np.squeeze(cost)\n",
    "    \n",
    "    assert(cost.shape == ())\n",
    "    \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "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",
    "    # last layer calculation\n",
    "    dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))\n",
    "    current_cache = caches[L-1]\n",
    "\n",
    "    # putting data of last layer\n",
    "    grads[\"dA\" + str(L-1)], grads[\"dW\" + str(L)], grads[\"db\" + str(L)] = linear_activation_backward(dAL, \n",
    "                                                                                                    current_cache, \n",
    "                                                                                                    \"sigmoid\")\n",
    "    \n",
    "    for l in reversed(range(L-1)):\n",
    "        current_cache = caches[l]\n",
    "        dA_prev_temp, dW_temp, db_temp = linear_activation_backward(grads[\"dA\"+ str(l+1)], current_cache, \"relu\")\n",
    "        grads[\"dW\" + str(l+1)] = dW_temp\n",
    "        grads[\"db\" + str(l+1)] = db_temp\n",
    "        grads[\"dA\" + str(l)] = dA_prev_temp\n",
    "    \n",
    "    return grads"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_parameters(parameters, grads, learning_rate):\n",
    "    L = len(parameters) // 2 # number of layers in the neural network\n",
    "\n",
    "    # Update rule for each parameter\n",
    "    for l in range(L):\n",
    "        parameters[\"W\" + str(l+1)] = parameters[\"W\"+ str(l+1)] - learning_rate * grads[\"dW\"+ str(l+1)]\n",
    "        parameters[\"b\" + str(l+1)] = parameters[\"b\"+ str(l+1)] - learning_rate * grads[\"db\"+ str(l+1)]\n",
    "    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: L_layer_model\n",
    "\n",
    "def L_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):#lr was 0.009\n",
    "    np.random.seed(1)\n",
    "    costs = []                         # keep track of cost\n",
    "    \n",
    "    # Parameters initialization\n",
    "    parameters = initialize_parameters_deep(layers_dims)\n",
    "    \n",
    "    # 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)\n",
    "    \n",
    "        # Backward propagation\n",
    "        grads = L_model_backward(AL, Y, caches)\n",
    " \n",
    "        # Update parameters\n",
    "        parameters = update_parameters(parameters, grads, learning_rate)\n",
    "                \n",
    "        # Print the cost every 100 training example\n",
    "        if print_cost and i % 100 == 0:\n",
    "            print (\"Cost after iteration %i: %f\" %(i, cost))\n",
    "        if print_cost and i % 100 == 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": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 0.771749\n",
      "Cost after iteration 100: 0.672053\n",
      "Cost after iteration 200: 0.648263\n",
      "Cost after iteration 300: 0.611507\n",
      "Cost after iteration 400: 0.567047\n",
      "Cost after iteration 500: 0.540138\n",
      "Cost after iteration 600: 0.527930\n",
      "Cost after iteration 700: 0.465477\n",
      "Cost after iteration 800: 0.369126\n",
      "Cost after iteration 900: 0.391747\n",
      "Cost after iteration 1000: 0.315187\n",
      "Cost after iteration 1100: 0.272700\n",
      "Cost after iteration 1200: 0.237419\n",
      "Cost after iteration 1300: 0.199601\n",
      "Cost after iteration 1400: 0.189263\n",
      "Cost after iteration 1500: 0.161189\n",
      "Cost after iteration 1600: 0.148214\n",
      "Cost after iteration 1700: 0.137775\n",
      "Cost after iteration 1800: 0.129740\n",
      "Cost after iteration 1900: 0.121225\n",
      "Cost after iteration 2000: 0.113821\n",
      "Cost after iteration 2100: 0.107839\n",
      "Cost after iteration 2200: 0.102855\n",
      "Cost after iteration 2300: 0.100897\n",
      "Cost after iteration 2400: 0.092878\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "parameters = L_layer_model(train_x, train_y, layers_dims, num_iterations = 2500, print_cost = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.9856459330143539\n"
     ]
    }
   ],
   "source": [
    "pred_train = predict(train_x, train_y, parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.8\n"
     ]
    }
   ],
   "source": [
    "pred_test = predict(test_x, test_y, parameters)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}