Grad_Cam_CNN.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyOf0VaAJRQ1F0zJqyPabrSH",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Ris-code/BasicML/blob/main/Grad_Cam_CNN.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Dataset**"
      ],
      "metadata": {
        "id": "yo7yXSlgr_JT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "import numpy as np\n",
        "\n",
        "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data()\n",
        "\n",
        "# train set / data\n",
        "x_train = x_train.astype('float32') / 255\n",
        "# train set / target\n",
        "y_train = tf.keras.utils.to_categorical(y_train , num_classes=10)\n",
        "\n",
        "# validation set / data\n",
        "x_test = x_test.astype('float32') / 255\n",
        "# validation set / target\n",
        "y_test = tf.keras.utils.to_categorical(y_test, num_classes=10)\n",
        "\n",
        "print(x_train.shape, y_train.shape)\n",
        "print(x_test.shape, y_test.shape)"
      ],
      "metadata": {
        "id": "IafeTENwrkhx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3fed9912-17f1-4bc6-80ca-353837409116"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n",
            "170498071/170498071 [==============================] - 2s 0us/step\n",
            "(50000, 32, 32, 3) (50000, 10)\n",
            "(10000, 32, 32, 3) (10000, 10)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Model**"
      ],
      "metadata": {
        "id": "6MxxJWrQttdf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "input = tf.keras.Input(shape=(32,32,3))\n",
        "efnet = tf.keras.applications.EfficientNetB0(weights='imagenet',\n",
        "                                             include_top = False,\n",
        "                                             input_tensor = input)\n",
        "# Now that we apply global max pooling.\n",
        "gap = tf.keras.layers.GlobalMaxPooling2D()(efnet.output)\n",
        "\n",
        "# Finally, we add a classification layer.\n",
        "output = tf.keras.layers.Dense(10, activation='softmax')(gap)\n",
        "\n",
        "# bind all\n",
        "func_model = tf.keras.Model(efnet.input, output)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mTw89e2XtyMJ",
        "outputId": "3337efd3-1bb1-4b93-a812-f367906ecbfc"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/keras-applications/efficientnetb0_notop.h5\n",
            "16705208/16705208 [==============================] - 0s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Compile and Run**"
      ],
      "metadata": {
        "id": "9BLWQjG2t1o3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "func_model.compile(\n",
        "          loss      = tf.keras.losses.CategoricalCrossentropy(),\n",
        "          metrics   = tf.keras.metrics.CategoricalAccuracy(),\n",
        "          optimizer = tf.keras.optimizers.Adam())\n",
        "# fit\n",
        "func_model.fit(x_train, y_train, batch_size=128, epochs=10, verbose = 2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wiCeJzVkt1Ar",
        "outputId": "9bed5e3d-7f18-4a28-885a-7321b6894507"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "391/391 - 59s - loss: 1.3088 - categorical_accuracy: 0.5491 - 59s/epoch - 151ms/step\n",
            "Epoch 2/10\n",
            "391/391 - 18s - loss: 0.8007 - categorical_accuracy: 0.7242 - 18s/epoch - 47ms/step\n",
            "Epoch 3/10\n",
            "391/391 - 18s - loss: 0.6408 - categorical_accuracy: 0.7778 - 18s/epoch - 46ms/step\n",
            "Epoch 4/10\n",
            "391/391 - 18s - loss: 0.5299 - categorical_accuracy: 0.8158 - 18s/epoch - 47ms/step\n",
            "Epoch 5/10\n",
            "391/391 - 18s - loss: 0.4535 - categorical_accuracy: 0.8430 - 18s/epoch - 46ms/step\n",
            "Epoch 6/10\n",
            "391/391 - 18s - loss: 0.3878 - categorical_accuracy: 0.8646 - 18s/epoch - 47ms/step\n",
            "Epoch 7/10\n",
            "391/391 - 18s - loss: 0.3319 - categorical_accuracy: 0.8840 - 18s/epoch - 46ms/step\n",
            "Epoch 8/10\n",
            "391/391 - 18s - loss: 0.2928 - categorical_accuracy: 0.8981 - 18s/epoch - 47ms/step\n",
            "Epoch 9/10\n",
            "391/391 - 19s - loss: 0.2598 - categorical_accuracy: 0.9092 - 19s/epoch - 49ms/step\n",
            "Epoch 10/10\n",
            "391/391 - 18s - loss: 0.2294 - categorical_accuracy: 0.9208 - 18s/epoch - 46ms/step\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.src.callbacks.History at 0x7e35b81cbc10>"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Grad-Cam**"
      ],
      "metadata": {
        "id": "nOjohuhXuBc-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "import numpy as np\n",
        "import cv2\n",
        "from tensorflow.keras.models import Model\n",
        "\n",
        "class GradCAM:\n",
        "    def __init__(self, model, class_idx, layer_name=None):\n",
        "        self.model = model\n",
        "        self.class_idx = class_idx\n",
        "        self.layer_name = layer_name or self.find_target_layer()\n",
        "\n",
        "    def find_target_layer(self):\n",
        "        for layer in reversed(self.model.layers):\n",
        "            if len(layer.output_shape) == 4:\n",
        "                return layer.name\n",
        "        raise ValueError(\"Could not find 4D layer. Cannot apply GradCAM.\")\n",
        "\n",
        "    def compute_heatmap(self, image, eps=1e-8):\n",
        "        grad_model = Model(inputs=[self.model.inputs], outputs=[self.model.get_layer(self.layer_name).output, self.model.output])\n",
        "        with tf.GradientTape() as tape:\n",
        "            inputs = tf.cast(image, tf.float32)\n",
        "            conv_outputs, predictions = grad_model(inputs)\n",
        "            loss = predictions[:, tf.argmax(predictions[0])]\n",
        "        grads = tape.gradient(loss, conv_outputs)\n",
        "        cast_conv_outputs = tf.cast(conv_outputs > 0, \"float32\")\n",
        "        cast_grads = tf.cast(grads > 0, \"float32\")\n",
        "        guided_grads = cast_conv_outputs * cast_grads * grads\n",
        "        conv_outputs = conv_outputs[0]\n",
        "        guided_grads = guided_grads[0]\n",
        "        weights = tf.reduce_mean(guided_grads, axis=(0, 1))\n",
        "        cam = tf.reduce_sum(tf.multiply(weights, conv_outputs), axis=-1)\n",
        "        (w, h) = (image.shape[2], image.shape[1])\n",
        "        heatmap = cv2.resize(cam.numpy(), (w, h))\n",
        "        heatmap = ((heatmap - np.min(heatmap)) / ((heatmap.max() - heatmap.min()) + eps) * 255).astype(\"uint8\")\n",
        "        return heatmap\n",
        "\n",
        "    def overlay_heatmap(self, heatmap, image, alpha=0.5,\n",
        "                          colormap=cv2.COLORMAP_VIRIDIS):\n",
        "          heatmap = cv2.applyColorMap(heatmap, colormap)\n",
        "          output = cv2.addWeighted(image, alpha, heatmap, 1 - alpha, 0)\n",
        "          return heatmap, output\n"
      ],
      "metadata": {
        "id": "pry2F0AouLQH"
      },
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Prediction**"
      ],
      "metadata": {
        "id": "KgfPENRluQb4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "image = cv2.imread('/content/Elephant_image_1.jpg')\n",
        "image = cv2.resize(image, (32, 32))\n",
        "image = image.astype('float32') / 255\n",
        "image = np.expand_dims(image, axis=0)\n",
        "\n",
        "preds = func_model.predict(image)\n",
        "i = np.argmax(preds[0])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5XZoMf2RuQKP",
        "outputId": "88593ead-7590-4c8c-d434-9d8e42f72692"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 25ms/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for idx in range(len(func_model.layers)):\n",
        "  print(func_model.get_layer(index = idx).name)\n",
        "\n",
        "# we picked `block5c_project_con` layer"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7bnFr9vuuaue",
        "outputId": "64ca7a75-cf10-420a-e0ff-f9e085e608a8"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "input_1\n",
            "rescaling\n",
            "normalization\n",
            "rescaling_1\n",
            "stem_conv_pad\n",
            "stem_conv\n",
            "stem_bn\n",
            "stem_activation\n",
            "block1a_dwconv\n",
            "block1a_bn\n",
            "block1a_activation\n",
            "block1a_se_squeeze\n",
            "block1a_se_reshape\n",
            "block1a_se_reduce\n",
            "block1a_se_expand\n",
            "block1a_se_excite\n",
            "block1a_project_conv\n",
            "block1a_project_bn\n",
            "block2a_expand_conv\n",
            "block2a_expand_bn\n",
            "block2a_expand_activation\n",
            "block2a_dwconv_pad\n",
            "block2a_dwconv\n",
            "block2a_bn\n",
            "block2a_activation\n",
            "block2a_se_squeeze\n",
            "block2a_se_reshape\n",
            "block2a_se_reduce\n",
            "block2a_se_expand\n",
            "block2a_se_excite\n",
            "block2a_project_conv\n",
            "block2a_project_bn\n",
            "block2b_expand_conv\n",
            "block2b_expand_bn\n",
            "block2b_expand_activation\n",
            "block2b_dwconv\n",
            "block2b_bn\n",
            "block2b_activation\n",
            "block2b_se_squeeze\n",
            "block2b_se_reshape\n",
            "block2b_se_reduce\n",
            "block2b_se_expand\n",
            "block2b_se_excite\n",
            "block2b_project_conv\n",
            "block2b_project_bn\n",
            "block2b_drop\n",
            "block2b_add\n",
            "block3a_expand_conv\n",
            "block3a_expand_bn\n",
            "block3a_expand_activation\n",
            "block3a_dwconv_pad\n",
            "block3a_dwconv\n",
            "block3a_bn\n",
            "block3a_activation\n",
            "block3a_se_squeeze\n",
            "block3a_se_reshape\n",
            "block3a_se_reduce\n",
            "block3a_se_expand\n",
            "block3a_se_excite\n",
            "block3a_project_conv\n",
            "block3a_project_bn\n",
            "block3b_expand_conv\n",
            "block3b_expand_bn\n",
            "block3b_expand_activation\n",
            "block3b_dwconv\n",
            "block3b_bn\n",
            "block3b_activation\n",
            "block3b_se_squeeze\n",
            "block3b_se_reshape\n",
            "block3b_se_reduce\n",
            "block3b_se_expand\n",
            "block3b_se_excite\n",
            "block3b_project_conv\n",
            "block3b_project_bn\n",
            "block3b_drop\n",
            "block3b_add\n",
            "block4a_expand_conv\n",
            "block4a_expand_bn\n",
            "block4a_expand_activation\n",
            "block4a_dwconv_pad\n",
            "block4a_dwconv\n",
            "block4a_bn\n",
            "block4a_activation\n",
            "block4a_se_squeeze\n",
            "block4a_se_reshape\n",
            "block4a_se_reduce\n",
            "block4a_se_expand\n",
            "block4a_se_excite\n",
            "block4a_project_conv\n",
            "block4a_project_bn\n",
            "block4b_expand_conv\n",
            "block4b_expand_bn\n",
            "block4b_expand_activation\n",
            "block4b_dwconv\n",
            "block4b_bn\n",
            "block4b_activation\n",
            "block4b_se_squeeze\n",
            "block4b_se_reshape\n",
            "block4b_se_reduce\n",
            "block4b_se_expand\n",
            "block4b_se_excite\n",
            "block4b_project_conv\n",
            "block4b_project_bn\n",
            "block4b_drop\n",
            "block4b_add\n",
            "block4c_expand_conv\n",
            "block4c_expand_bn\n",
            "block4c_expand_activation\n",
            "block4c_dwconv\n",
            "block4c_bn\n",
            "block4c_activation\n",
            "block4c_se_squeeze\n",
            "block4c_se_reshape\n",
            "block4c_se_reduce\n",
            "block4c_se_expand\n",
            "block4c_se_excite\n",
            "block4c_project_conv\n",
            "block4c_project_bn\n",
            "block4c_drop\n",
            "block4c_add\n",
            "block5a_expand_conv\n",
            "block5a_expand_bn\n",
            "block5a_expand_activation\n",
            "block5a_dwconv\n",
            "block5a_bn\n",
            "block5a_activation\n",
            "block5a_se_squeeze\n",
            "block5a_se_reshape\n",
            "block5a_se_reduce\n",
            "block5a_se_expand\n",
            "block5a_se_excite\n",
            "block5a_project_conv\n",
            "block5a_project_bn\n",
            "block5b_expand_conv\n",
            "block5b_expand_bn\n",
            "block5b_expand_activation\n",
            "block5b_dwconv\n",
            "block5b_bn\n",
            "block5b_activation\n",
            "block5b_se_squeeze\n",
            "block5b_se_reshape\n",
            "block5b_se_reduce\n",
            "block5b_se_expand\n",
            "block5b_se_excite\n",
            "block5b_project_conv\n",
            "block5b_project_bn\n",
            "block5b_drop\n",
            "block5b_add\n",
            "block5c_expand_conv\n",
            "block5c_expand_bn\n",
            "block5c_expand_activation\n",
            "block5c_dwconv\n",
            "block5c_bn\n",
            "block5c_activation\n",
            "block5c_se_squeeze\n",
            "block5c_se_reshape\n",
            "block5c_se_reduce\n",
            "block5c_se_expand\n",
            "block5c_se_excite\n",
            "block5c_project_conv\n",
            "block5c_project_bn\n",
            "block5c_drop\n",
            "block5c_add\n",
            "block6a_expand_conv\n",
            "block6a_expand_bn\n",
            "block6a_expand_activation\n",
            "block6a_dwconv_pad\n",
            "block6a_dwconv\n",
            "block6a_bn\n",
            "block6a_activation\n",
            "block6a_se_squeeze\n",
            "block6a_se_reshape\n",
            "block6a_se_reduce\n",
            "block6a_se_expand\n",
            "block6a_se_excite\n",
            "block6a_project_conv\n",
            "block6a_project_bn\n",
            "block6b_expand_conv\n",
            "block6b_expand_bn\n",
            "block6b_expand_activation\n",
            "block6b_dwconv\n",
            "block6b_bn\n",
            "block6b_activation\n",
            "block6b_se_squeeze\n",
            "block6b_se_reshape\n",
            "block6b_se_reduce\n",
            "block6b_se_expand\n",
            "block6b_se_excite\n",
            "block6b_project_conv\n",
            "block6b_project_bn\n",
            "block6b_drop\n",
            "block6b_add\n",
            "block6c_expand_conv\n",
            "block6c_expand_bn\n",
            "block6c_expand_activation\n",
            "block6c_dwconv\n",
            "block6c_bn\n",
            "block6c_activation\n",
            "block6c_se_squeeze\n",
            "block6c_se_reshape\n",
            "block6c_se_reduce\n",
            "block6c_se_expand\n",
            "block6c_se_excite\n",
            "block6c_project_conv\n",
            "block6c_project_bn\n",
            "block6c_drop\n",
            "block6c_add\n",
            "block6d_expand_conv\n",
            "block6d_expand_bn\n",
            "block6d_expand_activation\n",
            "block6d_dwconv\n",
            "block6d_bn\n",
            "block6d_activation\n",
            "block6d_se_squeeze\n",
            "block6d_se_reshape\n",
            "block6d_se_reduce\n",
            "block6d_se_expand\n",
            "block6d_se_excite\n",
            "block6d_project_conv\n",
            "block6d_project_bn\n",
            "block6d_drop\n",
            "block6d_add\n",
            "block7a_expand_conv\n",
            "block7a_expand_bn\n",
            "block7a_expand_activation\n",
            "block7a_dwconv\n",
            "block7a_bn\n",
            "block7a_activation\n",
            "block7a_se_squeeze\n",
            "block7a_se_reshape\n",
            "block7a_se_reduce\n",
            "block7a_se_expand\n",
            "block7a_se_excite\n",
            "block7a_project_conv\n",
            "block7a_project_bn\n",
            "top_conv\n",
            "top_bn\n",
            "top_activation\n",
            "global_max_pooling2d\n",
            "dense\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "icam = GradCAM(func_model, i, 'block5c_project_conv')\n",
        "heatmap = icam.compute_heatmap(image)\n",
        "heatmap = cv2.resize(heatmap, (32, 32))\n",
        "\n",
        "image = cv2.imread('/content/Elephant_image_1.jpg')\n",
        "image = cv2.resize(image, (32, 32))\n",
        "print(heatmap.shape, image.shape)\n",
        "\n",
        "(heatmap, output) = icam.overlay_heatmap(heatmap, image, alpha=0.5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fh4b-t1iudem",
        "outputId": "6e9a974c-9656-4fbc-bc67-cdc44305b272"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(32, 32) (32, 32, 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Visualisation**"
      ],
      "metadata": {
        "id": "DGFkmxj5ufzw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Assuming heatmap, image, and superimposed_img are defined\n",
        "fig, ax = plt.subplots(1, 3, figsize=(15, 5))  # Increase the figure size here\n",
        "\n",
        "ax[0].imshow(heatmap)\n",
        "ax[0].set_title('Heatmap')\n",
        "\n",
        "ax[1].imshow(image)\n",
        "ax[1].set_title('Original Image')\n",
        "\n",
        "ax[2].imshow(output)\n",
        "ax[2].set_title('Superimposed Image')\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 323
        },
        "id": "o8VihiPxujDe",
        "outputId": "abf8d81f-eb18-40e0-dc32-6b885440ef24"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x500 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}