Cat_vs_Non_cat.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "hDaqylAnfgGo"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import h5py\n",
        "from matplotlib import pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_data = h5py.File('train_catvnoncat.h5', 'r')"
      ],
      "metadata": {
        "id": "gLSXFkNIf_AS"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_x = np.array(train_data[\"train_set_x\"][:])\n",
        "train_y = np.array(train_data[\"train_set_y\"][:])"
      ],
      "metadata": {
        "id": "BkY72LHJgC-n"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "m_train = train_x.shape[0]\n",
        "\n",
        "train_x_flattened = train_x.reshape(-1, m_train)\n",
        "print(train_x_flattened.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XELR30xFgHyL",
        "outputId": "21959e8f-1d1b-4139-fadd-f29469e56960"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(12288, 209)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_x = train_x_flattened / 255."
      ],
      "metadata": {
        "id": "Ewp1pZY2gQy4"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_y = train_y.reshape(1, train_y.shape[0])"
      ],
      "metadata": {
        "id": "6iT83TOngUd4"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print (\"train_x's shape: \" + str(train_x.shape))\n",
        "print(\"train_y's shape: \" + str(train_y.shape))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R5zrSuBigXFg",
        "outputId": "c7f22716-847b-4ec1-8a0a-68277850cd6a"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "train_x's shape: (12288, 209)\n",
            "train_y's shape: (1, 209)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Parameter Initialization"
      ],
      "metadata": {
        "id": "GPRSAmiMMek3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def initialize_parameters(layer_dims):\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], layer_dims[l-1]) * 0.01\n",
        "        parameters['b' + str(l)] = np.zeros((layer_dims[l], 1))\n",
        "        \n",
        "    \n",
        "    return parameters    "
      ],
      "metadata": {
        "id": "IFmdXN03gcj7"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Forward Propagation"
      ],
      "metadata": {
        "id": "KEZv_2WyMqpE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def sigmoid(Z):\n",
        "    return (1 / (1 + np.exp(-Z)), Z)"
      ],
      "metadata": {
        "id": "J8JOYQZBgdLW"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def relu(Z):\n",
        "    return (np.maximum(0, Z), Z)"
      ],
      "metadata": {
        "id": "H7BBX3Nwgfq-"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def linear_forward(A, W, b):\n",
        "    Z = np.dot(W, A) + b\n",
        "    \n",
        "    cache = (A, W, b)\n",
        "    \n",
        "    return Z, cache"
      ],
      "metadata": {
        "id": "W_1e1Tu9gg6F"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def linear_activation_forward(A_prev, W, b, activation):\n",
        "    if activation == 'relu':\n",
        "        Z, linear_cache = linear_forward(A_prev, W, b)\n",
        "        A, activation_cache = relu(Z)\n",
        "    \n",
        "    elif activation == 'sigmoid':\n",
        "        Z, linear_cache = linear_forward(A_prev, W, b)\n",
        "        A, activation_cache = sigmoid(Z)\n",
        "        \n",
        "    cache = (linear_cache, activation_cache)\n",
        "    \n",
        "    return A, cache"
      ],
      "metadata": {
        "id": "DE8KIzuggh_B"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def deep_forward(X, parameters):\n",
        "    caches = []\n",
        "    A = X\n",
        "    L = len(parameters) // 2\n",
        "    \n",
        "    for l in range(1, L):\n",
        "        A_prev = A\n",
        "        \n",
        "        A, cache = linear_activation_forward(A_prev, parameters['W' + str(l)], parameters['b' + str(l)], 'relu')\n",
        "        caches.append(cache)\n",
        "    \n",
        "    AL, cache = linear_activation_forward(A, parameters['W' + str(L)], parameters['b' + str(L)], 'sigmoid')\n",
        "    caches.append(cache)\n",
        "    \n",
        "    return AL, caches"
      ],
      "metadata": {
        "id": "d7Ob2HdngjaW"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Cost computation"
      ],
      "metadata": {
        "id": "pMhXcOyKMu6h"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def compute_cost(AL, Y):\n",
        "    m = Y.shape\n",
        "    \n",
        "    cost = -(1/m) * (np.dot(Y, np.log(AL).T) + np.dot((1-Y), np.log(1-AL).T))\n",
        "    cost = np.squeeze(cost)\n",
        "    \n",
        "    return cost"
      ],
      "metadata": {
        "id": "KAb36aWsgkn8"
      },
      "execution_count": 85,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Backpropagation"
      ],
      "metadata": {
        "id": "Xq-A_4aaMx95"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def sigmoid_deriv(Z):\n",
        "    return sigmoid(Z)[0] * (1 - sigmoid(Z)[0])\n",
        "\n",
        "def sigmoid_backward(dA, activation_cache):\n",
        "    return dA * sigmoid_deriv(activation_cache)"
      ],
      "metadata": {
        "id": "HMbNYBnhgm2T"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def relu_deriv(Z):\n",
        "    return Z > 0\n",
        "\n",
        "def relu_backward(dA, activation_cache):\n",
        "    return dA * relu_deriv(activation_cache)"
      ],
      "metadata": {
        "id": "2vHXcCCSgoXu"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "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",
        "    return dA_prev, dW, db"
      ],
      "metadata": {
        "id": "kji7Ts5wgpcw"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "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"
      ],
      "metadata": {
        "id": "UFDBJ695gqsQ"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def deep_backward(AL, Y, caches):\n",
        "    grads = {}\n",
        "    L = len(caches)\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",
        "    \n",
        "    current_cache = caches[L-1]\n",
        "    dA_prev_temp, dW_temp, db_temp = linear_activation_backward(dAL, current_cache, \"sigmoid\")\n",
        "    grads[\"dA\" + str(L-1)] = dA_prev_temp\n",
        "    grads[\"dW\" + str(L)] = dW_temp\n",
        "    grads[\"db\" + str(L)] = db_temp\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[\"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"
      ],
      "metadata": {
        "id": "xD7kmzWLgrvz"
      },
      "execution_count": 59,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Update Parameters"
      ],
      "metadata": {
        "id": "PHdlVd5jM15i"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def update_parameters(params, grads, learning_rate):\n",
        "    parameters = params.copy()\n",
        "    L = len(parameters) // 2\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",
        "        \n",
        "    return parameters"
      ],
      "metadata": {
        "id": "7t9dTdVggtbE"
      },
      "execution_count": 60,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Buliding the L-layer neural network"
      ],
      "metadata": {
        "id": "1JXeLwfRM8h1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "layers_dims = [12288, 20, 7, 5, 1]"
      ],
      "metadata": {
        "id": "ie0h_x-xhwyP"
      },
      "execution_count": 61,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def L_layer_model(X, Y, layer_dims, learning_rate = 0.0075, num_iterations = 3000):\n",
        "    costs = []\n",
        "    \n",
        "    parameters = initialize_parameters(layers_dims)\n",
        "    \n",
        "    for i in range(0, num_iterations):\n",
        "        AL, caches = deep_forward(X, parameters)\n",
        "        \n",
        "        cost = compute_cost(AL, Y)\n",
        "        \n",
        "        grads = deep_backward(AL, Y, caches)\n",
        "        \n",
        "        parameters = update_parameters(parameters, grads, learning_rate)\n",
        "        \n",
        "        if i%100 == 0 or i == num_iterations-1:\n",
        "            print(f\"Cost after iteration {i}: {np.squeeze(cost)}\")\n",
        "            costs.append(cost)\n",
        "    \n",
        "    \n",
        "    return parameters, costs"
      ],
      "metadata": {
        "id": "-dLfn-AUguyg"
      },
      "execution_count": 81,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Train the model"
      ],
      "metadata": {
        "id": "zIFVc-LJM-GC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Parameters, Costs = L_layer_model(train_x, train_y, layers_dims, learning_rate = 0.01)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qKyCMb3AgwT8",
        "outputId": "e8d7c76a-b63f-48fb-9641-b85d60b76913"
      },
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cost after iteration 0: 0.6931475988874048\n",
            "Cost after iteration 100: 0.6740958771233654\n",
            "Cost after iteration 200: 0.662520116598468\n",
            "Cost after iteration 300: 0.6554523290635692\n",
            "Cost after iteration 400: 0.6511119270756448\n",
            "Cost after iteration 500: 0.6484312180824577\n",
            "Cost after iteration 600: 0.6467670066863824\n",
            "Cost after iteration 700: 0.6457292251661968\n",
            "Cost after iteration 800: 0.6450796367243201\n",
            "Cost after iteration 900: 0.6446717622080372\n",
            "Cost after iteration 1000: 0.64441500217289\n",
            "Cost after iteration 1100: 0.6442530311919518\n",
            "Cost after iteration 1200: 0.6441506838385265\n",
            "Cost after iteration 1300: 0.6440859113386007\n",
            "Cost after iteration 1400: 0.6440448282100932\n",
            "Cost after iteration 1500: 0.6440188041558915\n",
            "Cost after iteration 1600: 0.6440022983844276\n",
            "Cost after iteration 1700: 0.6439918198630776\n",
            "Cost after iteration 1800: 0.6439851645037237\n",
            "Cost after iteration 1900: 0.6439809357098407\n",
            "Cost after iteration 2000: 0.6439782478208872\n",
            "Cost after iteration 2100: 0.6439765388123198\n",
            "Cost after iteration 2200: 0.6439754518420155\n",
            "Cost after iteration 2300: 0.6439747602383816\n",
            "Cost after iteration 2400: 0.6439743199893063\n",
            "Cost after iteration 2500: 0.6439740395687514\n",
            "Cost after iteration 2600: 0.6439738607678664\n",
            "Cost after iteration 2700: 0.6439737465872699\n",
            "Cost after iteration 2800: 0.6439736734860361\n",
            "Cost after iteration 2900: 0.6439736265017173\n",
            "Cost after iteration 2999: 0.6439735963945143\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = [i for i in range(31)]\n",
        "plt.xlabel(\"Number of iterations (in thousands)\")\n",
        "plt.ylabel(\"Cost\")\n",
        "plt.plot(x, Costs)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 466
        },
        "id": "vsYKgV0Ggxva",
        "outputId": "907a73b6-f4f7-40af-c0f4-bf609e914a09"
      },
      "execution_count": 104,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7fe4b20dcb20>]"
            ]
          },
          "metadata": {},
          "execution_count": 104
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Pfg579tDNjwW"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}