Cat Recognition model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image\n",
    "from dnn_app_utils_v3 import *\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from testCases import *\n",
    "from dnn_utils import sigmoid, sigmoid_backward, relu, relu_backward\n",
    "\n",
    "\n",
    "train_x_orig, train_y, test_x_orig, test_y, classes = load_data()\n",
    "\n",
    "train_x_flatten = train_x_orig.reshape(train_x_orig.shape[0], -1).T   # The \"-1\" makes reshape flatten the remaining dimensions\n",
    "test_x_flatten = test_x_orig.reshape(test_x_orig.shape[0], -1).T\n",
    "\n",
    "train_x = train_x_flatten/255\n",
    "test_x = test_x_flatten/255\n",
    "\n",
    "import copy\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",
    "np.random.seed(1)\n",
    "\n",
    "\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",
    "\n",
    "def initialize_parameters(n_x, n_h, n_y):\n",
    "\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",
    "\n",
    "    parameters = {\"W1\": W1 , \"b1\": b1, \"W2\": W2, \"b2\": b2}\n",
    "    \n",
    "    return parameters  \n",
    "\n",
    "\n",
    "def initialize_parameters_deep(layer_dims):\n",
    "\n",
    "    np.random.seed(3)\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",
    "    return parameters\n",
    "\n",
    "\n",
    "def linear_forward(A, W, b):\n",
    "\n",
    "    Z = np.dot(W,A) + b\n",
    "    cache = (A, W, b)\n",
    "    \n",
    "    return Z, cache\n",
    "\n",
    "\n",
    "def linear_activation_forward(A_prev, W, b, activation):\n",
    "\n",
    "    if activation == \"sigmoid\":\n",
    "        Z, linear_cache = linear_forward(A_prev, W, b)\n",
    "        A, activation_cache = sigmoid(Z)\n",
    "    \n",
    "    elif activation == \"relu\":\n",
    "        Z, linear_cache = linear_forward(A_prev, W, b)\n",
    "        A, activation_cache = relu(Z)\n",
    "    \n",
    "    cache = (linear_cache, activation_cache)\n",
    "\n",
    "    return A, cache\n",
    "\n",
    "\n",
    "def L_model_forward(X, parameters):\n",
    "\n",
    "    caches = []\n",
    "    A = X\n",
    "    L = len(parameters) // 2  \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)], \"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\n",
    "\n",
    "\n",
    "def compute_cost(AL, Y):\n",
    "\n",
    "    m = Y.shape[1]\n",
    "    cost = (-1/m)*np.sum((np.dot(Y,np.log(AL).T) + np.dot((1-Y),np.log(1-AL).T)),axis = 0, keepdims = True)\n",
    "    cost = np.squeeze(cost) \n",
    "\n",
    "    return cost\n",
    "\n",
    "\n",
    "def linear_backward(dZ, cache):\n",
    "\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(cache[1].T,dZ)\n",
    "\n",
    "    return dA_prev, dW, db\n",
    "\n",
    "\n",
    "def linear_activation_backward(dA, cache, activation):\n",
    "\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",
    "        \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\n",
    "\n",
    "\n",
    "def L_model_backward(AL, Y, caches):\n",
    "\n",
    "    grads = {}\n",
    "    L = len(caches) # the number of layers\n",
    "    m = AL.shape[1]\n",
    "    Y = Y.reshape(AL.shape)\n",
    "\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\n",
    "\n",
    "\n",
    "def update_parameters(params, grads, learning_rate):\n",
    "\n",
    "    parameters = copy.deepcopy(params)\n",
    "    L = len(parameters) // 2 \n",
    "\n",
    "    for l in range(L):\n",
    "        parameters[\"W\" + str(l+1)] = params[\"W\" + str(l+1)] - learning_rate*grads[\"dW\" + str(l+1)]\n",
    "        parameters[\"b\" + str(l+1)] = params[\"b\" + str(l+1)] - learning_rate*grads[\"db\" + str(l+1)]\n",
    "    \n",
    "    return parameters\n",
    "\n",
    "\n",
    "n_x = 12288     # num_px * num_px * 3\n",
    "n_h = 7\n",
    "n_y = 1\n",
    "layers_dims = (n_x, n_h, n_y)\n",
    "learning_rate = 0.0075\n",
    "\n",
    "\n",
    "def plot_costs(costs, learning_rate=0.0075):\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",
    "\n",
    "def L_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):\n",
    "\n",
    "    np.random.seed(1)\n",
    "    costs = []   \n",
    "\n",
    "    parameters =  initialize_parameters_deep(layers_dims)\n",
    "\n",
    "    for i in range(0, num_iterations):\n",
    "        AL , caches = L_model_forward(X, parameters)\n",
    "        cost = compute_cost(AL, Y)\n",
    "        grads = L_model_backward(AL, Y, caches)\n",
    "        parameters = update_parameters(parameters, grads, learning_rate)\n",
    "\n",
    "        if print_cost and i % 100 == 0 or i == num_iterations - 1:\n",
    "            print(\"Cost after iteration {}: {}\".format(i, np.squeeze(cost)))\n",
    "        if i % 100 == 0 or i == num_iterations:\n",
    "            costs.append(cost)\n",
    "    \n",
    "    return parameters, costs\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 0.6923799160908503\n",
      "Cost after iteration 100: 0.6461586699206975\n",
      "Cost after iteration 200: 0.6317752454522949\n",
      "Cost after iteration 300: 0.6000906114062464\n",
      "Cost after iteration 400: 0.5594266141002633\n",
      "Cost after iteration 500: 0.5129882975097562\n",
      "Cost after iteration 600: 0.4548146042072384\n",
      "Cost after iteration 700: 0.39938804920553517\n",
      "Cost after iteration 800: 0.4205154699577257\n",
      "Cost after iteration 900: 0.3691844132011299\n",
      "Cost after iteration 1000: 0.3623927556792381\n",
      "Cost after iteration 1100: 0.3413659079571165\n",
      "Cost after iteration 1200: 0.3333440319337271\n",
      "Cost after iteration 1300: 0.26379708597074125\n",
      "Cost after iteration 1400: 0.16480532038932788\n",
      "Cost after iteration 1500: 0.14360822941781876\n",
      "Cost after iteration 1600: 0.12446701193149183\n",
      "Cost after iteration 1700: 0.7067523839110107\n",
      "Cost after iteration 1800: 0.09239377122581145\n",
      "Cost after iteration 1900: 0.0785723824020304\n",
      "Cost after iteration 2000: 0.06809230848758144\n",
      "Cost after iteration 2100: 0.059649048570878764\n",
      "Cost after iteration 2200: 0.05261877564906631\n",
      "Cost after iteration 2300: 0.04681675171988825\n",
      "Cost after iteration 2400: 0.041927817460429125\n",
      "Cost after iteration 2499: 0.03779698017313768\n"
     ]
    }
   ],
   "source": [
    "parameters, costs = L_layer_model(train_x, train_y, layers_dims, num_iterations = 2500 , print_cost = True)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 1.0\n",
      "y = 1.0, your L-layer model predicts a \"cat\" picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_image = \"my_image.jpeg\" # change this to the name of image file \n",
    "my_label_y = [1] # the true class of your image (1 -> cat, 0 -> non-cat)\n",
    "\n",
    "\n",
    "fname = \"images/\" + my_image\n",
    "image = np.array(Image.open(fname).resize((num_px, num_px)))\n",
    "plt.imshow(image)\n",
    "image = image / 255.\n",
    "image = image.reshape((1, num_px * num_px * 3)).T\n",
    "\n",
    "my_predicted_image = predict(image, my_label_y, parameters)\n",
    "\n",
    "\n",
    "print (\"y = \" + str(np.squeeze(my_predicted_image)) + \", your L-layer model predicts a \\\"\" + classes[int(np.squeeze(my_predicted_image)),].decode(\"utf-8\") +  \"\\\" picture.\")"
   ]
  }
 ],
 "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.11.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}