06-Dog Breed_v1.3.ipynb

{
 "cells": [
  {
   "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 = [\"Golden\", \"German\"]\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": [
      "302\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 = (302, 64, 64, 3)\n",
      "Shape of y = (302,)\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.2)"
   ]
  },
  {
   "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= [1]\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": [
    "plt.imshow(x_train[5])\n",
    "print(\"y= \"+ str(y_train[:,5]))"
   ]
  },
  {
   "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 = 241\n",
      "Number of testing examples: m_test = 61\n",
      "Height/Width of each image: num_px = 64\n",
      "Each image is of size: (64, 64, 3)\n",
      "train_set_x shape: (241, 64, 64, 3)\n",
      "train_set_y shape: (1, 241)\n",
      "test_set_x shape: (61, 64, 64, 3)\n",
      "test_set_y shape: (1, 61)\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, 241)\n",
      "train_set_y shape: (1, 241)\n",
      "test_set_x_flatten shape: (12288, 61)\n",
      "test_set_y shape: (1, 61)\n",
      "sanity check after reshaping: [194 198 189  30  35]\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])*0.01\n",
    "        parameters[\"b\" + str(l)] = np.zeros((layer_dims[l],1))*0.01\n",
    "        \n",
    "        assert(parameters['W' + str(l)].shape == (layer_dims[l],\n",
    "                                                  layer_dims[l-1]))\n",
    "        assert(parameters['b' + str(l)].shape == (layer_dims[l], 1))\n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Forward Prop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "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": 22,
   "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": 23,
   "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": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost(AL, Y):\n",
    "    m = Y.shape[1]\n",
    "\n",
    "    cost = -(1/m) * np.sum(np.multiply(np.log(AL),Y) + \n",
    "                           np.multiply(np.log(1-AL),1-Y))\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": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_backward(dZ, cache):\n",
    "    A_prev, W, b = cache\n",
    "    m = A_prev.shape[1]\n",
    "\n",
    "    dW = (1/m) * np.dot(dZ,A_prev.T)\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": 26,
   "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)\n",
    "        \n",
    "    elif activation == \"sigmoid\":\n",
    "        dZ = sigmoid_backward(dA,activation_cache)\n",
    "        dA_prev, dW, db = linear_backward(dZ,linear_cache)\n",
    "    \n",
    "    return dA_prev, dW, db"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Update Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_parameters(parameters, grads, learning_rate):\n",
    "    L = len(parameters) // 2 # number of layers in the neural network\n",
    "\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",
    "    return parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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": 29,
   "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": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "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",
    "    # 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)\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",
    "        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": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 0.693591\n",
      "Cost after iteration 100: 0.691029\n",
      "Cost after iteration 200: 0.671957\n",
      "Cost after iteration 300: 0.617207\n",
      "Cost after iteration 400: 0.523275\n",
      "Cost after iteration 500: 0.385129\n",
      "Cost after iteration 600: 0.297149\n",
      "Cost after iteration 700: 0.230393\n",
      "Cost after iteration 800: 0.229465\n",
      "Cost after iteration 900: 0.142278\n",
      "Cost after iteration 1000: 0.111343\n",
      "Cost after iteration 1100: 0.087870\n",
      "Cost after iteration 1200: 0.070207\n",
      "Cost after iteration 1300: 0.056925\n",
      "Cost after iteration 1400: 0.046909\n",
      "Cost after iteration 1500: 0.039469\n",
      "Cost after iteration 1600: 0.033781\n",
      "Cost after iteration 1700: 0.029316\n",
      "Cost after iteration 1800: 0.025772\n",
      "Cost after iteration 1900: 0.022891\n",
      "Cost after iteration 2000: 0.020511\n",
      "Cost after iteration 2100: 0.018510\n"
     ]
    }
   ],
   "source": [
    "layer_dims = [12288,4,1] # 4-layer\n",
    "parameters = L_layer_model(train_x,y_train,layer_dims,num_iterations=2500,print_cost=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 1.0\n"
     ]
    }
   ],
   "source": [
    "pred_train = predict(train_x, y_train, parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.737704918032787\n"
     ]
    }
   ],
   "source": [
    "pred_test = predict(test_x, y_test, parameters)"
   ]
  },
  {
   "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
}