jetImage_CNN.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNkYhPsEN7XW9J7dOlKNl4v",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/swagata87/IITKanpurPhy654/blob/main/jetImage_CNN.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t3ufp2a0a9ov",
        "outputId": "1ed73b7f-3905-4372-8851-27e5ebac0be5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2024-07-13 05:04:15--  https://zenodo.org/record/3901869/files/jet_images.h5?download=1\n",
            "Resolving zenodo.org (zenodo.org)... 188.185.79.172, 188.184.98.238, 188.184.103.159, ...\n",
            "Connecting to zenodo.org (zenodo.org)|188.185.79.172|:443... connected.\n",
            "HTTP request sent, awaiting response... 301 MOVED PERMANENTLY\n",
            "Location: /records/3901869/files/jet_images.h5 [following]\n",
            "--2024-07-13 05:04:15--  https://zenodo.org/records/3901869/files/jet_images.h5\n",
            "Reusing existing connection to zenodo.org:443.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 85520350 (82M) [application/octet-stream]\n",
            "Saving to: ‘data/jet_images.h5’\n",
            "\n",
            "data/jet_images.h5  100%[===================>]  81.56M  19.1MB/s    in 4.3s    \n",
            "\n",
            "2024-07-13 05:04:20 (19.1 MB/s) - ‘data/jet_images.h5’ saved [85520350/85520350]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "!mkdir -p data\n",
        "!wget -O data/jet_images.h5 \"https://zenodo.org/record/3901869/files/jet_images.h5?download=1\""
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import h5py\n",
        "\n",
        "h5f = h5py.File(\"data/jet_images.h5\", \"r\")\n",
        "\n",
        "for key in h5f.keys():\n",
        "    print(key) #Names of the root level object names in HDF5 file.\n",
        "    print(type(h5f[key])) # get the object type: usually group or dataset\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FcNmY29Deiwe",
        "outputId": "af29d5e5-da70-40bb-b777-0b280d17b199"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "QCD\n",
            "<class 'h5py._hl.dataset.Dataset'>\n",
            "QCD_particles\n",
            "<class 'h5py._hl.dataset.Dataset'>\n",
            "TT\n",
            "<class 'h5py._hl.dataset.Dataset'>\n",
            "TT_particles\n",
            "<class 'h5py._hl.dataset.Dataset'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "jet_images_dict = {}\n",
        "jet_images_dict[\"QCD\"] = h5f[\"QCD\"][()]\n",
        "jet_images_dict[\"TT\"] = h5f[\"TT\"][()]\n",
        "\n",
        "h5f.close()"
      ],
      "metadata": {
        "id": "dZk45ztklc2h"
      },
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 4D tensor (tensorflow backend)\n",
        "# 1st dim is jet index\n",
        "# 2nd dim is eta bin\n",
        "# 3rd dim is phi bin\n",
        "# 4th dim is pt value (or rgb values, etc.)\n",
        "print(jet_images_dict[\"QCD\"].shape)\n",
        "print(jet_images_dict[\"TT\"].shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4p5EcT66ev9I",
        "outputId": "7905ced7-88b8-42ba-f670-9534cb03cbab"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(3305, 30, 30, 1)\n",
            "(1722, 30, 30, 1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import matplotlib as mpl\n",
        "import numpy as np\n",
        "\n",
        "%matplotlib inline\n",
        "\n",
        "# plot ttbar jet\n",
        "i = 10\n",
        "plt.figure()\n",
        "plt.imshow(\n",
        "    jet_images_dict[\"TT\"][i, :, :, 0].T,\n",
        "    norm=mpl.colors.LogNorm(),\n",
        "    origin=\"lower\",\n",
        "    interpolation=\"none\",\n",
        ")\n",
        "cbar = plt.colorbar()\n",
        "cbar.set_label(\"pT\")\n",
        "plt.xlabel(\"ieta\")\n",
        "plt.ylabel(\"iphi\")\n",
        "plt.title('top quark')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "nvE9QqLFghtL",
        "outputId": "96ff47a9-442c-458d-8de4-7afc0a7a0e8a"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# plot QCD jet\n",
        "i = 15\n",
        "plt.figure()\n",
        "plt.imshow(\n",
        "    jet_images_dict[\"QCD\"][i, :, :, 0].T,\n",
        "    norm=mpl.colors.LogNorm(),\n",
        "    origin=\"lower\",\n",
        "    interpolation=\"none\",\n",
        ")\n",
        "cbar = plt.colorbar()\n",
        "cbar.set_label(\"pT\")\n",
        "plt.xlabel(\"ieta\")\n",
        "plt.ylabel(\"iphi\")\n",
        "plt.title('QCD jet')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "QWbJSBxegyaL",
        "outputId": "0611b51b-3a82-4612-fc25-e0237dc9e435"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "4PHnF1RXkaSW"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow.keras.backend as K\n",
        "from tensorflow.keras.models import Model\n",
        "from tensorflow.keras.layers import (\n",
        "    Input,\n",
        "    Conv2D,\n",
        "    MaxPool2D,\n",
        "    Flatten,\n",
        "    Dropout,\n",
        "    Dense,\n",
        "    BatchNormalization,\n",
        "    Concatenate,\n",
        ")\n",
        "from tensorflow.keras.regularizers import l1, l2\n",
        "\n",
        "nx = 30\n",
        "ny = 30\n",
        "inputs = Input(shape=(nx, ny, 1), name=\"input\")\n",
        "x = Conv2D(\n",
        "    filters=8,\n",
        "    kernel_size=(3, 3),\n",
        "    strides=(1, 1),\n",
        "    padding=\"same\",\n",
        "    activation=\"relu\",\n",
        "    name=\"conv2d_1\",\n",
        "    kernel_regularizer=l2(0.01),\n",
        ")(inputs)\n",
        "x = BatchNormalization(momentum=0.6, name=\"batchnorm_1\")(x)\n",
        "x = MaxPool2D(pool_size=(2, 2), name=\"maxpool2d_1\")(x)\n",
        "x = Flatten(name=\"flatten\")(x)\n",
        "x = Dense(64, activation=\"relu\", name=\"dense\")(x)\n",
        "outputs = Dense(1, activation=\"sigmoid\", name=\"output\")(x)\n",
        "model = Model(inputs=inputs, outputs=outputs)\n",
        "model.compile(optimizer=\"adam\", loss=\"binary_crossentropy\", metrics=[\"accuracy\"])\n",
        "model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "352gqCGIg4rZ",
        "outputId": "7ca145ff-4df3-4bbf-9535-63296957191a"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input (InputLayer)          [(None, 30, 30, 1)]       0         \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 30, 30, 8)         80        \n",
            "                                                                 \n",
            " batchnorm_1 (BatchNormaliz  (None, 30, 30, 8)         32        \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " maxpool2d_1 (MaxPooling2D)  (None, 15, 15, 8)         0         \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 1800)              0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 64)                115264    \n",
            "                                                                 \n",
            " output (Dense)              (None, 1)                 65        \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 115441 (450.94 KB)\n",
            "Trainable params: 115425 (450.88 KB)\n",
            "Non-trainable params: 16 (64.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "jet_images = np.concatenate([jet_images_dict[\"TT\"], jet_images_dict[\"QCD\"]])\n",
        "jet_labels = np.concatenate(\n",
        "    [np.ones(len(jet_images_dict[\"TT\"])), np.zeros(len(jet_images_dict[\"QCD\"]))]\n",
        ")\n",
        "\n",
        "X = jet_images\n",
        "Y = jet_labels\n",
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "X_train_val, X_test, Y_train_val, Y_test = train_test_split(X, Y, test_size=0.2, random_state=7)\n",
        "\n",
        "print(\"number of ttbar jets for training/validation: %i\" % np.sum(Y_train_val == 1))\n",
        "print(\"number of QCD jets for training/validation: %i\" % np.sum(Y_train_val == 0))\n",
        "\n",
        "print(\"number of ttbar jets for testing: %i\" % np.sum(Y_test == 1))\n",
        "print(\"number of QCD jets for testing: %i\" % np.sum(Y_test == 0))\n",
        "\n",
        "# early stopping callback\n",
        "from tensorflow.keras.callbacks import EarlyStopping\n",
        "\n",
        "early_stopping = EarlyStopping(monitor=\"val_loss\", patience=10)\n",
        "\n",
        "# model checkpoint callback\n",
        "# this saves our model architecture + parameters into conv2d_model.h5\n",
        "from tensorflow.keras.callbacks import ModelCheckpoint\n",
        "\n",
        "model_checkpoint = ModelCheckpoint(\n",
        "    \"conv2d_model.h5\",\n",
        "    monitor=\"val_loss\",\n",
        "    verbose=0,\n",
        "    save_best_only=True,\n",
        "    save_weights_only=False,\n",
        "    mode=\"auto\",\n",
        "    save_freq=\"epoch\",\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DdjV5jNohHPL",
        "outputId": "df837e6a-c4a8-4343-d4e0-64010880083b"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "number of ttbar jets for training/validation: 1384\n",
            "number of QCD jets for training/validation: 2637\n",
            "number of ttbar jets for testing: 338\n",
            "number of QCD jets for testing: 668\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Train classifier\n",
        "history = model.fit(\n",
        "    X_train_val,\n",
        "    Y_train_val,\n",
        "    epochs=100,\n",
        "    batch_size=1024,\n",
        "    verbose=1,\n",
        "    callbacks=[early_stopping, model_checkpoint],\n",
        "    validation_split=0.25,\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "12wHtoKVhn16",
        "outputId": "60a1fbcb-2f97-4195-973c-5b4aaaf4f284"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/100\n",
            "3/3 [==============================] - 3s 609ms/step - loss: 1.1514 - accuracy: 0.5022 - val_loss: 0.5665 - val_accuracy: 0.7247\n",
            "Epoch 2/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/keras/src/engine/training.py:3103: UserWarning: You are saving your model as an HDF5 file via `model.save()`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')`.\n",
            "  saving_api.save_model(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3/3 [==============================] - 1s 432ms/step - loss: 0.5047 - accuracy: 0.7552 - val_loss: 0.4341 - val_accuracy: 0.8191\n",
            "Epoch 3/100\n",
            "3/3 [==============================] - 1s 454ms/step - loss: 0.3760 - accuracy: 0.8554 - val_loss: 0.4196 - val_accuracy: 0.8748\n",
            "Epoch 4/100\n",
            "3/3 [==============================] - 1s 414ms/step - loss: 0.3781 - accuracy: 0.8819 - val_loss: 0.4217 - val_accuracy: 0.8827\n",
            "Epoch 5/100\n",
            "3/3 [==============================] - 1s 465ms/step - loss: 0.3465 - accuracy: 0.8925 - val_loss: 0.3869 - val_accuracy: 0.8797\n",
            "Epoch 6/100\n",
            "3/3 [==============================] - 1s 425ms/step - loss: 0.3252 - accuracy: 0.8886 - val_loss: 0.3906 - val_accuracy: 0.8728\n",
            "Epoch 7/100\n",
            "3/3 [==============================] - 1s 440ms/step - loss: 0.3269 - accuracy: 0.8833 - val_loss: 0.3786 - val_accuracy: 0.8777\n",
            "Epoch 8/100\n",
            "3/3 [==============================] - 2s 818ms/step - loss: 0.3122 - accuracy: 0.8959 - val_loss: 0.3669 - val_accuracy: 0.8877\n",
            "Epoch 9/100\n",
            "3/3 [==============================] - 2s 776ms/step - loss: 0.3037 - accuracy: 0.9048 - val_loss: 0.3648 - val_accuracy: 0.8926\n",
            "Epoch 10/100\n",
            "3/3 [==============================] - 1s 421ms/step - loss: 0.3012 - accuracy: 0.9078 - val_loss: 0.3530 - val_accuracy: 0.8887\n",
            "Epoch 11/100\n",
            "3/3 [==============================] - 1s 415ms/step - loss: 0.2927 - accuracy: 0.9032 - val_loss: 0.3458 - val_accuracy: 0.8887\n",
            "Epoch 12/100\n",
            "3/3 [==============================] - 1s 453ms/step - loss: 0.2864 - accuracy: 0.9015 - val_loss: 0.3386 - val_accuracy: 0.8867\n",
            "Epoch 13/100\n",
            "3/3 [==============================] - 1s 447ms/step - loss: 0.2800 - accuracy: 0.9085 - val_loss: 0.3346 - val_accuracy: 0.8867\n",
            "Epoch 14/100\n",
            "3/3 [==============================] - 1s 437ms/step - loss: 0.2759 - accuracy: 0.9095 - val_loss: 0.3294 - val_accuracy: 0.8857\n",
            "Epoch 15/100\n",
            "3/3 [==============================] - 1s 436ms/step - loss: 0.2711 - accuracy: 0.9098 - val_loss: 0.3235 - val_accuracy: 0.8877\n",
            "Epoch 16/100\n",
            "3/3 [==============================] - 1s 401ms/step - loss: 0.2657 - accuracy: 0.9091 - val_loss: 0.3184 - val_accuracy: 0.8877\n",
            "Epoch 17/100\n",
            "3/3 [==============================] - 1s 432ms/step - loss: 0.2610 - accuracy: 0.9104 - val_loss: 0.3155 - val_accuracy: 0.8867\n",
            "Epoch 18/100\n",
            "3/3 [==============================] - 2s 774ms/step - loss: 0.2570 - accuracy: 0.9144 - val_loss: 0.3135 - val_accuracy: 0.8877\n",
            "Epoch 19/100\n",
            "3/3 [==============================] - 2s 786ms/step - loss: 0.2534 - accuracy: 0.9128 - val_loss: 0.3119 - val_accuracy: 0.8847\n",
            "Epoch 20/100\n",
            "3/3 [==============================] - 1s 439ms/step - loss: 0.2496 - accuracy: 0.9138 - val_loss: 0.3091 - val_accuracy: 0.8907\n",
            "Epoch 21/100\n",
            "3/3 [==============================] - 1s 437ms/step - loss: 0.2465 - accuracy: 0.9161 - val_loss: 0.3067 - val_accuracy: 0.8926\n",
            "Epoch 22/100\n",
            "3/3 [==============================] - 1s 411ms/step - loss: 0.2430 - accuracy: 0.9181 - val_loss: 0.3047 - val_accuracy: 0.8897\n",
            "Epoch 23/100\n",
            "3/3 [==============================] - 1s 416ms/step - loss: 0.2403 - accuracy: 0.9164 - val_loss: 0.3034 - val_accuracy: 0.8897\n",
            "Epoch 24/100\n",
            "3/3 [==============================] - 1s 414ms/step - loss: 0.2372 - accuracy: 0.9177 - val_loss: 0.3021 - val_accuracy: 0.8936\n",
            "Epoch 25/100\n",
            "3/3 [==============================] - 1s 436ms/step - loss: 0.2355 - accuracy: 0.9194 - val_loss: 0.3012 - val_accuracy: 0.8926\n",
            "Epoch 26/100\n",
            "3/3 [==============================] - 1s 448ms/step - loss: 0.2322 - accuracy: 0.9187 - val_loss: 0.3003 - val_accuracy: 0.8877\n",
            "Epoch 27/100\n",
            "3/3 [==============================] - 1s 427ms/step - loss: 0.2306 - accuracy: 0.9171 - val_loss: 0.2986 - val_accuracy: 0.8917\n",
            "Epoch 28/100\n",
            "3/3 [==============================] - 2s 791ms/step - loss: 0.2286 - accuracy: 0.9214 - val_loss: 0.2976 - val_accuracy: 0.8996\n",
            "Epoch 29/100\n",
            "3/3 [==============================] - 2s 788ms/step - loss: 0.2263 - accuracy: 0.9234 - val_loss: 0.2969 - val_accuracy: 0.8907\n",
            "Epoch 30/100\n",
            "3/3 [==============================] - 1s 438ms/step - loss: 0.2243 - accuracy: 0.9217 - val_loss: 0.2967 - val_accuracy: 0.8926\n",
            "Epoch 31/100\n",
            "3/3 [==============================] - 1s 431ms/step - loss: 0.2219 - accuracy: 0.9240 - val_loss: 0.2956 - val_accuracy: 0.9016\n",
            "Epoch 32/100\n",
            "3/3 [==============================] - 1s 414ms/step - loss: 0.2200 - accuracy: 0.9257 - val_loss: 0.2949 - val_accuracy: 0.9006\n",
            "Epoch 33/100\n",
            "3/3 [==============================] - 1s 427ms/step - loss: 0.2185 - accuracy: 0.9247 - val_loss: 0.2946 - val_accuracy: 0.8926\n",
            "Epoch 34/100\n",
            "3/3 [==============================] - 1s 427ms/step - loss: 0.2159 - accuracy: 0.9250 - val_loss: 0.2939 - val_accuracy: 0.8986\n",
            "Epoch 35/100\n",
            "3/3 [==============================] - 1s 431ms/step - loss: 0.2144 - accuracy: 0.9250 - val_loss: 0.2936 - val_accuracy: 0.8946\n",
            "Epoch 36/100\n",
            "3/3 [==============================] - 1s 422ms/step - loss: 0.2123 - accuracy: 0.9277 - val_loss: 0.2929 - val_accuracy: 0.8946\n",
            "Epoch 37/100\n",
            "3/3 [==============================] - 1s 439ms/step - loss: 0.2105 - accuracy: 0.9284 - val_loss: 0.2916 - val_accuracy: 0.8926\n",
            "Epoch 38/100\n",
            "3/3 [==============================] - 2s 728ms/step - loss: 0.2089 - accuracy: 0.9264 - val_loss: 0.2918 - val_accuracy: 0.8926\n",
            "Epoch 39/100\n",
            "3/3 [==============================] - 2s 733ms/step - loss: 0.2076 - accuracy: 0.9270 - val_loss: 0.2932 - val_accuracy: 0.8926\n",
            "Epoch 40/100\n",
            "3/3 [==============================] - 1s 432ms/step - loss: 0.2051 - accuracy: 0.9280 - val_loss: 0.2914 - val_accuracy: 0.8956\n",
            "Epoch 41/100\n",
            "3/3 [==============================] - 1s 426ms/step - loss: 0.2037 - accuracy: 0.9287 - val_loss: 0.2902 - val_accuracy: 0.8946\n",
            "Epoch 42/100\n",
            "3/3 [==============================] - 1s 443ms/step - loss: 0.2014 - accuracy: 0.9320 - val_loss: 0.2902 - val_accuracy: 0.8917\n",
            "Epoch 43/100\n",
            "3/3 [==============================] - 2s 613ms/step - loss: 0.2000 - accuracy: 0.9333 - val_loss: 0.2895 - val_accuracy: 0.8926\n",
            "Epoch 44/100\n",
            "3/3 [==============================] - 1s 416ms/step - loss: 0.1986 - accuracy: 0.9317 - val_loss: 0.2903 - val_accuracy: 0.8946\n",
            "Epoch 45/100\n",
            "3/3 [==============================] - 1s 404ms/step - loss: 0.1972 - accuracy: 0.9320 - val_loss: 0.2898 - val_accuracy: 0.8926\n",
            "Epoch 46/100\n",
            "3/3 [==============================] - 1s 439ms/step - loss: 0.1960 - accuracy: 0.9320 - val_loss: 0.2875 - val_accuracy: 0.8936\n",
            "Epoch 47/100\n",
            "3/3 [==============================] - 2s 670ms/step - loss: 0.1930 - accuracy: 0.9340 - val_loss: 0.2883 - val_accuracy: 0.8917\n",
            "Epoch 48/100\n",
            "3/3 [==============================] - 2s 700ms/step - loss: 0.1918 - accuracy: 0.9360 - val_loss: 0.2872 - val_accuracy: 0.8946\n",
            "Epoch 49/100\n",
            "3/3 [==============================] - 2s 618ms/step - loss: 0.1902 - accuracy: 0.9357 - val_loss: 0.2866 - val_accuracy: 0.8926\n",
            "Epoch 50/100\n",
            "3/3 [==============================] - 1s 412ms/step - loss: 0.1884 - accuracy: 0.9360 - val_loss: 0.2870 - val_accuracy: 0.8936\n",
            "Epoch 51/100\n",
            "3/3 [==============================] - 1s 417ms/step - loss: 0.1865 - accuracy: 0.9380 - val_loss: 0.2851 - val_accuracy: 0.8936\n",
            "Epoch 52/100\n",
            "3/3 [==============================] - 1s 449ms/step - loss: 0.1855 - accuracy: 0.9370 - val_loss: 0.2843 - val_accuracy: 0.8946\n",
            "Epoch 53/100\n",
            "3/3 [==============================] - 1s 412ms/step - loss: 0.1841 - accuracy: 0.9390 - val_loss: 0.2858 - val_accuracy: 0.8946\n",
            "Epoch 54/100\n",
            "3/3 [==============================] - 1s 408ms/step - loss: 0.1815 - accuracy: 0.9376 - val_loss: 0.2854 - val_accuracy: 0.8926\n",
            "Epoch 55/100\n",
            "3/3 [==============================] - 1s 432ms/step - loss: 0.1810 - accuracy: 0.9390 - val_loss: 0.2863 - val_accuracy: 0.8946\n",
            "Epoch 56/100\n",
            "3/3 [==============================] - 1s 431ms/step - loss: 0.1791 - accuracy: 0.9413 - val_loss: 0.2847 - val_accuracy: 0.8946\n",
            "Epoch 57/100\n",
            "3/3 [==============================] - 1s 515ms/step - loss: 0.1778 - accuracy: 0.9400 - val_loss: 0.2842 - val_accuracy: 0.8917\n",
            "Epoch 58/100\n",
            "3/3 [==============================] - 2s 774ms/step - loss: 0.1762 - accuracy: 0.9426 - val_loss: 0.2841 - val_accuracy: 0.8926\n",
            "Epoch 59/100\n",
            "3/3 [==============================] - 2s 607ms/step - loss: 0.1785 - accuracy: 0.9413 - val_loss: 0.2852 - val_accuracy: 0.8917\n",
            "Epoch 60/100\n",
            "3/3 [==============================] - 1s 413ms/step - loss: 0.1765 - accuracy: 0.9406 - val_loss: 0.2862 - val_accuracy: 0.8936\n",
            "Epoch 61/100\n",
            "3/3 [==============================] - 1s 411ms/step - loss: 0.1728 - accuracy: 0.9430 - val_loss: 0.2856 - val_accuracy: 0.8956\n",
            "Epoch 62/100\n",
            "3/3 [==============================] - 1s 401ms/step - loss: 0.1714 - accuracy: 0.9420 - val_loss: 0.2848 - val_accuracy: 0.8936\n",
            "Epoch 63/100\n",
            "3/3 [==============================] - 1s 417ms/step - loss: 0.1697 - accuracy: 0.9446 - val_loss: 0.2843 - val_accuracy: 0.8897\n",
            "Epoch 64/100\n",
            "3/3 [==============================] - 1s 409ms/step - loss: 0.1687 - accuracy: 0.9420 - val_loss: 0.2864 - val_accuracy: 0.8926\n",
            "Epoch 65/100\n",
            "3/3 [==============================] - 1s 397ms/step - loss: 0.1667 - accuracy: 0.9456 - val_loss: 0.2849 - val_accuracy: 0.8917\n",
            "Epoch 66/100\n",
            "3/3 [==============================] - 1s 432ms/step - loss: 0.1656 - accuracy: 0.9446 - val_loss: 0.2837 - val_accuracy: 0.8917\n",
            "Epoch 67/100\n",
            "3/3 [==============================] - 1s 415ms/step - loss: 0.1633 - accuracy: 0.9489 - val_loss: 0.2856 - val_accuracy: 0.8926\n",
            "Epoch 68/100\n",
            "3/3 [==============================] - 2s 785ms/step - loss: 0.1628 - accuracy: 0.9483 - val_loss: 0.2861 - val_accuracy: 0.8907\n",
            "Epoch 69/100\n",
            "3/3 [==============================] - 2s 617ms/step - loss: 0.1614 - accuracy: 0.9466 - val_loss: 0.2862 - val_accuracy: 0.8926\n",
            "Epoch 70/100\n",
            "3/3 [==============================] - 1s 440ms/step - loss: 0.1615 - accuracy: 0.9469 - val_loss: 0.2863 - val_accuracy: 0.8897\n",
            "Epoch 71/100\n",
            "3/3 [==============================] - 1s 404ms/step - loss: 0.1622 - accuracy: 0.9489 - val_loss: 0.2870 - val_accuracy: 0.8936\n",
            "Epoch 72/100\n",
            "3/3 [==============================] - 1s 412ms/step - loss: 0.1576 - accuracy: 0.9466 - val_loss: 0.2888 - val_accuracy: 0.8966\n",
            "Epoch 73/100\n",
            "3/3 [==============================] - 2s 599ms/step - loss: 0.1554 - accuracy: 0.9483 - val_loss: 0.2894 - val_accuracy: 0.8917\n",
            "Epoch 74/100\n",
            "3/3 [==============================] - 2s 417ms/step - loss: 0.1559 - accuracy: 0.9519 - val_loss: 0.2875 - val_accuracy: 0.8887\n",
            "Epoch 75/100\n",
            "3/3 [==============================] - 1s 430ms/step - loss: 0.1547 - accuracy: 0.9493 - val_loss: 0.2872 - val_accuracy: 0.8926\n",
            "Epoch 76/100\n",
            "3/3 [==============================] - 1s 407ms/step - loss: 0.1529 - accuracy: 0.9526 - val_loss: 0.2877 - val_accuracy: 0.8907\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "%matplotlib inline\n",
        "# plot loss vs epoch\n",
        "plt.figure(figsize=(15, 10))\n",
        "ax = plt.subplot(2, 2, 1)\n",
        "ax.plot(history.history[\"loss\"], label=\"loss\")\n",
        "ax.plot(history.history[\"val_loss\"], label=\"val_loss\")\n",
        "ax.legend(loc=\"upper right\")\n",
        "ax.set_xlabel(\"epoch\")\n",
        "ax.set_ylabel(\"loss\")\n",
        "\n",
        "# plot accuracy vs epoch\n",
        "ax = plt.subplot(2, 2, 2)\n",
        "ax.plot(history.history[\"accuracy\"], label=\"acc\")\n",
        "ax.plot(history.history[\"val_accuracy\"], label=\"val_acc\")\n",
        "ax.legend(loc=\"lower right\")\n",
        "ax.set_xlabel(\"epoch\")\n",
        "ax.set_ylabel(\"acc\")\n",
        "\n",
        "# Plot ROC\n",
        "Y_predict = model.predict(X_test)\n",
        "from sklearn.metrics import roc_curve, auc\n",
        "\n",
        "fpr, tpr, thresholds = roc_curve(Y_test, Y_predict)\n",
        "roc_auc = auc(fpr, tpr)\n",
        "ax = plt.subplot(2, 2, 3)\n",
        "ax.plot(fpr, tpr, lw=2, color=\"cyan\", label=\"auc = %.3f\" % (roc_auc))\n",
        "ax.plot([0, 1], [0, 1], linestyle=\"--\", lw=2, color=\"k\", label=\"random chance\")\n",
        "ax.set_xlim([0, 1.0])\n",
        "ax.set_ylim([0, 1.0])\n",
        "ax.set_xlabel(\"false positive rate\")\n",
        "ax.set_ylabel(\"true positive rate\")\n",
        "ax.set_title(\"receiver operating curve\")\n",
        "ax.legend(loc=\"lower right\")\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 872
        },
        "id": "yMazwwi_iJBm",
        "outputId": "3f904901-e872-4d85-fcd7-e2c518b1ca6e"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "32/32 [==============================] - 0s 7ms/step\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x1000 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}