modelfire_train.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/harsh-hks-580/FireProof/blob/main/modelfire_train.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BIqFsvI6FEhq",
        "outputId": "65fae616-cf56-4a5d-ecba-0731eb08897a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5fL0kAPxFM6u",
        "outputId": "03e00288-f71b-42ce-ce7e-1cf461d1eb18"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "/content/drive/MyDrive\n"
          ]
        }
      ],
      "source": [
        "%cd /content/drive/MyDrive"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BbiWxOOJNvGk"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import os\n",
        "import random\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "import keras.backend as K\n",
        "\n",
        "from tensorflow.keras.layers import *\n",
        "from tensorflow.keras.callbacks import *\n",
        "from tensorflow.keras.optimizers import *\n",
        "from tensorflow.keras.applications import Xception, InceptionV3, MobileNetV2, NASNetMobile, EfficientNetB0    #Xception 299, inceptionV2 299, Nasnet 224\n",
        "from tensorflow.keras.activations import *\n",
        "from tensorflow.keras.losses import *\n",
        "from keras.callbacks import LearningRateScheduler\n",
        "\n",
        "import cv2\n",
        "from google.colab.patches import cv2_imshow\n",
        "import matplotlib.pyplot as plt\n",
        "import joblib\n",
        "from keras.preprocessing.image import load_img\n",
        "from keras.preprocessing import image\n",
        "\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-0NoROKaJ51d",
        "outputId": "10d07ea3-c9a4-4450-f461-943bdb6387d6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Num GPUs Available:  1\n"
          ]
        }
      ],
      "source": [
        "print(\"Num GPUs Available: \", len(tf.config.experimental.list_physical_devices('GPU')))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BZ-vpe5a5oH9",
        "outputId": "276d2211-8667-493f-838c-df601b34266e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Found 8795 images belonging to 2 classes.\n",
            "Found 976 images belonging to 2 classes.\n",
            "Found 1472 images belonging to 2 classes.\n"
          ]
        }
      ],
      "source": [
        "train_dir = '/content/drive/MyDrive/Fire-Safety-Dataset/Train/'\n",
        "train_datagen = ImageDataGenerator(rescale=1./255,\n",
        "    shear_range=0.1,\n",
        "    zoom_range=0.1,\n",
        "    width_shift_range=0.1,\n",
        "    height_shift_range=0.1,\n",
        "    horizontal_flip=True,\n",
        "    vertical_flip=True,\n",
        "    validation_split=0.1\n",
        "                                  )\n",
        "train_generator = train_datagen.flow_from_directory(train_dir,\n",
        "                                                    batch_size=16,\n",
        "                                                    class_mode='categorical',\n",
        "                                                    target_size=(224,224),\n",
        "                                                    subset = 'training',\n",
        "                                                    shuffle = True)\n",
        "\n",
        "validation_dir = train_dir\n",
        "validation_datagen = ImageDataGenerator(rescale=1.0/255,\n",
        "                                        validation_split = 0.1\n",
        "                                        )\n",
        "validation_generator = validation_datagen.flow_from_directory(validation_dir,\n",
        "                                                              batch_size=16,\n",
        "                                                              subset = 'validation',\n",
        "                                                              class_mode ='categorical',\n",
        "                                                              target_size=(224,224),\n",
        "                                                              shuffle = True)\n",
        "\n",
        "test_dir = '/content/drive/MyDrive/Fire-Safety-Dataset/Test/'\n",
        "test_datagen = ImageDataGenerator(rescale = 1./255,\n",
        "                                  )\n",
        "test_generator =test_datagen.flow_from_directory(test_dir,\n",
        "                                                              batch_size=16,\n",
        "                                                              class_mode ='categorical',\n",
        "                                                              target_size=(224,224),\n",
        "                                                              shuffle = True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DJntC_vCISuI",
        "outputId": "84d63eb6-fed6-4e01-a847-9e196cbadf66"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/mobilenet_v2/mobilenet_v2_weights_tf_dim_ordering_tf_kernels_1.0_224_no_top.h5\n",
            "9412608/9406464 [==============================] - 0s 0us/step\n"
          ]
        }
      ],
      "source": [
        "base_model = MobileNetV2(\n",
        "    include_top=False, weights='imagenet', input_tensor=None,\n",
        "    input_shape=(224,224,3), classes = 2\n",
        ")\n",
        "\n",
        "fine_tune_at = int (len(base_model.layers)*0.7)\n",
        "for layer in base_model.layers[:fine_tune_at]:\n",
        "  layer.trainable =  False"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0l0nnoqDISyG",
        "outputId": "9772080f-b8b2-4d9f-b58a-fcd1b4e2bcf8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "mobilenetv2_1.00_224 (Functi (None, 7, 7, 1280)        2257984   \n",
            "_________________________________________________________________\n",
            "flatten_1 (Flatten)          (None, 62720)             0         \n",
            "_________________________________________________________________\n",
            "dense_3 (Dense)              (None, 128)               8028288   \n",
            "_________________________________________________________________\n",
            "dropout_1 (Dropout)          (None, 128)               0         \n",
            "_________________________________________________________________\n",
            "dense_4 (Dense)              (None, 64)                8256      \n",
            "_________________________________________________________________\n",
            "dense_5 (Dense)              (None, 2)                 130       \n",
            "=================================================================\n",
            "Total params: 10,294,658\n",
            "Trainable params: 9,836,290\n",
            "Non-trainable params: 458,368\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "model = tf.keras.models.Sequential()\n",
        "model.add(base_model)\n",
        "model.add(Flatten())\n",
        "model.add(Dense(128,activation='relu'))\n",
        "model.add(Dropout(0.3))\n",
        "model.add(Dense(64,activation='relu'))\n",
        "model.add(Dense(2,activation='softmax'))\n",
        "#tf.keras.models.load_model('suryafire.h5')\n",
        "model.compile(optimizer = Adam(lr=2e-5), loss='binary_crossentropy', metrics=['acc'])\n",
        "model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tSyjbJugfT8z",
        "outputId": "0e3b5794-813b-4fb3-cb0a-777cfed043a6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(1472, 2)\n",
            "0.8002717391304348\n"
          ]
        }
      ],
      "source": [
        "labels = test_generator.classes\n",
        "preds = model.predict(test_generator)\n",
        "correct = 0\n",
        "print(preds.shape)\n",
        "for i in range(labels.size):\n",
        "  ilabel = 1\n",
        "  if preds[i][0] > preds[i][1]:\n",
        "    ilabel = 0\n",
        "  if labels[i] == ilabel :\n",
        "    correct = correct + 1\n",
        "\n",
        "print(correct/ (labels.size))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f2Xyuf9C4feR",
        "outputId": "716a795a-608e-463f-815e-f610435de09e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0.8002717391304348\n"
          ]
        }
      ],
      "source": [
        "correct = 0\n",
        "for i in range(92) :\n",
        "  test_x, test_y = test_generator.__getitem__(i)\n",
        "  preds = model.predict(test_x)\n",
        "  for i in range(preds.shape[0]):\n",
        "    if np.argmax(preds[i]) == np.argmax(test_y[i]):\n",
        "      correct += 1\n",
        "print( correct/ test_generator.n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HramrWLaIS0I"
      },
      "outputs": [],
      "source": [
        "filepath= 'suryafire.h5'  \n",
        "my_callbacks = [\n",
        "  ReduceLROnPlateau(\n",
        "    monitor='val_acc', factor=0.5, patience=3, verbose=True,\n",
        "    mode='auto', min_delta=0.000001, cooldown=0, min_lr=0 \n",
        "  ), \n",
        "  ModelCheckpoint(\n",
        "    filepath, monitor='val_loss', verbose=0, save_best_only=True, mode= 'min')]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ne4rRMihIS1v",
        "outputId": "bd615c7f-ca15-4c6b-996f-94681484b82b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/10\n",
            "550/550 [==============================] - 110s 192ms/step - loss: 0.4714 - acc: 0.7739 - val_loss: 0.0983 - val_acc: 0.9672\n",
            "Epoch 2/10\n",
            "550/550 [==============================] - 107s 192ms/step - loss: 0.1546 - acc: 0.9437 - val_loss: 0.0725 - val_acc: 0.9723\n",
            "Epoch 3/10\n",
            "550/550 [==============================] - 106s 191ms/step - loss: 0.1119 - acc: 0.9601 - val_loss: 0.0605 - val_acc: 0.9775\n",
            "Epoch 4/10\n",
            "550/550 [==============================] - 107s 192ms/step - loss: 0.0884 - acc: 0.9674 - val_loss: 0.0591 - val_acc: 0.9764\n",
            "Epoch 5/10\n",
            "550/550 [==============================] - 106s 191ms/step - loss: 0.0774 - acc: 0.9734 - val_loss: 0.0834 - val_acc: 0.9775\n",
            "Epoch 6/10\n",
            "550/550 [==============================] - 106s 190ms/step - loss: 0.0702 - acc: 0.9759 - val_loss: 0.0766 - val_acc: 0.9764\n",
            "\n",
            "Epoch 00006: ReduceLROnPlateau reducing learning rate to 9.999999747378752e-06.\n",
            "Epoch 7/10\n",
            "550/550 [==============================] - 106s 190ms/step - loss: 0.0606 - acc: 0.9781 - val_loss: 0.0775 - val_acc: 0.9775\n",
            "Epoch 8/10\n",
            "550/550 [==============================] - 106s 191ms/step - loss: 0.0472 - acc: 0.9851 - val_loss: 0.0766 - val_acc: 0.9775\n",
            "Epoch 9/10\n",
            "550/550 [==============================] - 106s 191ms/step - loss: 0.0459 - acc: 0.9835 - val_loss: 0.0659 - val_acc: 0.9846\n",
            "Epoch 10/10\n",
            "550/550 [==============================] - 106s 191ms/step - loss: 0.0373 - acc: 0.9894 - val_loss: 0.0628 - val_acc: 0.9836\n"
          ]
        }
      ],
      "source": [
        "history = model.fit(train_generator,\n",
        "                    shuffle = True,\n",
        "                    epochs=10,\n",
        "                    workers = 8,\n",
        "                    verbose=True,\n",
        "                    validation_data=validation_generator,\n",
        "                    callbacks=my_callbacks)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B8uSX3_s-8sL",
        "outputId": "264d3cb7-1c57-412d-ad10-55999bf81f81"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(1472, 2)\n",
            "0.670516304347826\n"
          ]
        }
      ],
      "source": [
        "labels = test_generator.classes\n",
        "preds = model.predict(test_generator)\n",
        "correct = 0\n",
        "print(preds.shape)\n",
        "for i in range(labels.size):\n",
        "  ilabel = 1\n",
        "  if preds[i][0] > preds[i][1]:\n",
        "    ilabel = 0\n",
        "  if labels[i] == ilabel :\n",
        "    correct = correct + 1\n",
        "\n",
        "print(correct/ (labels.size))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 553
        },
        "id": "Ewrjsc_dIS4I",
        "outputId": "2fe280ab-4dbd-4ccf-df88-8ae8d631a6ff"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.8673110008239746, 0.9479249715805054, 0.9606594443321228, 0.9696418642997742, 0.973393976688385, 0.9764639139175415, 0.9803297519683838, 0.9854462742805481, 0.9849914908409119, 0.9856736660003662]\n",
            "[0.9672130942344666, 0.9723360538482666, 0.9774590134620667, 0.9764344096183777, 0.9774590134620667, 0.9764344096183777, 0.9774590134620667, 0.9774590134620667, 0.9846311211585999, 0.9836065769195557]\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 576x576 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light",
            "tags": []
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "acc = history.history['acc']\n",
        "val_acc = history.history['val_acc']\n",
        "\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "print(acc)\n",
        "print(val_acc)\n",
        "\n",
        "plt.figure(figsize=(8, 8))\n",
        "plt.subplot(2, 1, 1)\n",
        "plt.plot(acc, label='Training Accuracy')\n",
        "plt.plot(val_acc, label='Validation Accuracy')\n",
        "plt.legend(loc='lower right')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.ylim([min(plt.ylim()),1])\n",
        "plt.title('Training and Validation Accuracy')\n",
        "\n",
        "plt.subplot(2, 1, 2)\n",
        "plt.plot(loss, label='Training Loss')\n",
        "plt.plot(val_loss, label='Validation Loss')\n",
        "plt.legend(loc='upper right')\n",
        "plt.ylabel('Cross Entropy')\n",
        "plt.ylim([0,max(plt.ylim())])\n",
        "plt.title('Training and Validation Loss')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "J6he4C384VA5"
      },
      "outputs": [],
      "source": [
        "def Branch1(x):\n",
        "  y= Conv2D(filters= 28 , kernel_size= (1,1),input_shape=(54,54,32),\n",
        "                    padding= \"valid\" ,activation='linear', use_bias= True) (x)\n",
        "  y= Conv2D(filters= 28 , kernel_size= (3,3),\n",
        "                    padding= \"valid\" ,activation='linear', use_bias= True) (y)\n",
        "  y= (MaxPooling2D(pool_size=(2, 2), padding='valid'))(y)\n",
        "  y= Conv2D(filters= 56 , kernel_size= (3,3),\n",
        "                    padding= \"valid\" ,activation='linear', use_bias= True) (y)\n",
        "  return y\n",
        "\n",
        "def Branch2(x):\n",
        "  y= Conv2D(filters= 28 , kernel_size= (1,1), input_shape=(54,54,32),\n",
        "                    padding= \"valid\" ,activation='relu', use_bias= True)(x)\n",
        "  y= Conv2D(filters= 28 , kernel_size= (4,1),\n",
        "                    padding= \"valid\" ,activation='relu', use_bias= True) (y)\n",
        "  y= Conv2D(filters= 28 , kernel_size= (1,4),\n",
        "                    padding= \"valid\" ,activation='relu', use_bias= True) (y)\n",
        "  y= (MaxPooling2D(pool_size=(2, 2), padding='valid'))(y)\n",
        "  y= Conv2D(filters= 56 , kernel_size= (2,2),\n",
        "                    padding= \"valid\" ,activation='relu', use_bias= True) (y)\n",
        "  \n",
        "  return y"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QAwy9ynT7-ix"
      },
      "outputs": [],
      "source": [
        "input= tf.keras.Input((224, 224, 3))\n",
        "deepFire=Conv2D(filters= 16 , kernel_size= (3,3), \n",
        "                    padding= \"valid\" ,activation='relu')(input)\n",
        "deepFire=(AveragePooling2D(pool_size=(3, 3), padding='valid'))(deepFire)\n",
        "deepFire=(Dropout(0.2))(deepFire)\n",
        "\n",
        "deepFire=Conv2D(filters= 32 , kernel_size= (3,3), \n",
        "                    padding= \"valid\" ,activation='relu')(input)\n",
        "deepFire=(AveragePooling2D(pool_size=(3, 3), padding='valid'))(deepFire)\n",
        "deepFire=(Dropout(0.2))(deepFire)\n",
        "\n",
        "deepFire=Conv2D(filters= 64 , kernel_size= (3,3), \n",
        "                    padding= \"valid\" ,activation='relu')(input)\n",
        "deepFire=(AveragePooling2D(pool_size=(3, 3), padding='valid'))(deepFire)\n",
        "deepFire=(Dropout(0.2))(deepFire)\n",
        "\n",
        "\n",
        "deepFire=(Flatten())(deepFire)\n",
        "deepFire=(Dense(256, activation= 'relu'))(deepFire)\n",
        "deepFire=(Dropout(0.2))(deepFire)\n",
        "deepFire=(Dense(128, activation='relu'))(deepFire)\n",
        "deepFire_out=(Dense(2, activation= 'softmax'))(deepFire)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rz3BmoSf9ifv",
        "outputId": "00aba406-2404-4d27-fd10-d66c7cfcd75a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"model\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "input_3 (InputLayer)         [(None, 224, 224, 3)]     0         \n",
            "_________________________________________________________________\n",
            "conv2d_2 (Conv2D)            (None, 222, 222, 64)      1792      \n",
            "_________________________________________________________________\n",
            "average_pooling2d_2 (Average (None, 74, 74, 64)        0         \n",
            "_________________________________________________________________\n",
            "dropout_4 (Dropout)          (None, 74, 74, 64)        0         \n",
            "_________________________________________________________________\n",
            "flatten_2 (Flatten)          (None, 350464)            0         \n",
            "_________________________________________________________________\n",
            "dense_6 (Dense)              (None, 256)               89719040  \n",
            "_________________________________________________________________\n",
            "dropout_5 (Dropout)          (None, 256)               0         \n",
            "_________________________________________________________________\n",
            "dense_7 (Dense)              (None, 128)               32896     \n",
            "_________________________________________________________________\n",
            "dense_8 (Dense)              (None, 2)                 258       \n",
            "=================================================================\n",
            "Total params: 89,753,986\n",
            "Trainable params: 89,753,986\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "deepFire = tf.keras.models.Model(input,deepFire_out)\n",
        "deepFire.compile(optimizer=RMSprop(lr=0.001), loss='binary_crossentropy', metrics=['acc'])\n",
        "deepFire.summary()\n",
        "#plot_model(deepFire, show_shapes=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8A0cUVJ99rhW",
        "outputId": "760b974e-f56c-492f-a466-e104e4f4f25e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0.4008152173913043\n"
          ]
        }
      ],
      "source": [
        "labels = test_generator.classes\n",
        "preds = deepFire.predict(test_generator)\n",
        "correct = 0\n",
        "for i in range(labels.size):\n",
        "  ilabel = 1\n",
        "  if preds[i][0] > preds[i][1]:\n",
        "    ilabel = 0\n",
        "  if labels[i] == ilabel :\n",
        "    correct = correct + 1\n",
        "\n",
        "print(correct/ (labels.size))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zOG6trHe92zC",
        "outputId": "2288717b-bf5b-4298-8122-c5832701f689"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0.3383152173913043\n"
          ]
        }
      ],
      "source": [
        "correct = 0\n",
        "for i in range(92) :\n",
        "  test_x, test_y = test_generator.__getitem__(i)\n",
        "  preds = deepFire.predict(test_x)\n",
        "  for i in range(preds.shape[0]):\n",
        "    if np.argmax(preds[i]) == np.argmax(test_y[i]):\n",
        "      correct += 1\n",
        "print( correct/ test_generator.n)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sXKjRWTH-JdK"
      },
      "outputs": [],
      "source": [
        "filepath= 'suryafirecustom.h5'  \n",
        "my_callbacks = [\n",
        "  ReduceLROnPlateau(\n",
        "    monitor='val_acc', factor=0.5, patience=3, verbose=True,\n",
        "    mode='auto', min_delta=0.000001, cooldown=0, min_lr=0 \n",
        "  ), \n",
        "  ModelCheckpoint(\n",
        "    filepath, monitor='val_loss', verbose=0, save_best_only=True, mode= 'min')]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sMAUetU499Ik",
        "outputId": "5c119005-f067-43b8-97a0-4da1f14816b1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/5\n",
            "550/550 [==============================] - 106s 189ms/step - loss: 1.4464 - acc: 0.6762 - val_loss: 0.5160 - val_acc: 0.7910\n",
            "Epoch 2/5\n",
            "550/550 [==============================] - 106s 189ms/step - loss: 0.5325 - acc: 0.7655 - val_loss: 0.3782 - val_acc: 0.8156\n",
            "Epoch 3/5\n",
            "550/550 [==============================] - 106s 190ms/step - loss: 0.4774 - acc: 0.7961 - val_loss: 0.4093 - val_acc: 0.8709\n",
            "Epoch 4/5\n",
            "550/550 [==============================] - 103s 186ms/step - loss: 0.4697 - acc: 0.8063 - val_loss: 0.3329 - val_acc: 0.8863\n",
            "Epoch 5/5\n",
            "550/550 [==============================] - 105s 189ms/step - loss: 0.4465 - acc: 0.8179 - val_loss: 0.3155 - val_acc: 0.8883\n"
          ]
        }
      ],
      "source": [
        "history = deepFire.fit(train_generator,\n",
        "                    shuffle = True,\n",
        "                    epochs=5,\n",
        "                    workers = 8,\n",
        "                    verbose=True,\n",
        "                    validation_data=validation_generator,\n",
        "                    callbacks=my_callbacks)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LId0nXQ6-Rde",
        "outputId": "08f5a881-621b-4907-9216-94c011eb23d8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.7137009501457214, 0.773393988609314, 0.7960204482078552, 0.8125070929527283, 0.8193291425704956]\n",
            "[0.7909836173057556, 0.8155737519264221, 0.8709016442298889, 0.8862704634666443, 0.8883196711540222]\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 576x576 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light",
            "tags": []
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "acc = history.history['acc']\n",
        "val_acc = history.history['val_acc']\n",
        "\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "print(acc)\n",
        "print(val_acc)\n",
        "\n",
        "plt.figure(figsize=(8, 8))\n",
        "plt.subplot(2, 1, 1)\n",
        "plt.plot(acc, label='Training Accuracy')\n",
        "plt.plot(val_acc, label='Validation Accuracy')\n",
        "plt.legend(loc='lower right')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.ylim([min(plt.ylim()),1])\n",
        "plt.title('Training and Validation Accuracy')\n",
        "\n",
        "plt.subplot(2, 1, 2)\n",
        "plt.plot(loss, label='Training Loss')\n",
        "plt.plot(val_loss, label='Validation Loss')\n",
        "plt.legend(loc='upper right')\n",
        "plt.ylabel('Cross Entropy')\n",
        "plt.ylim([0,max(plt.ylim())])\n",
        "plt.title('Training and Validation Loss')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1IS7yxEp-VBa"
      },
      "outputs": [],
      "source": [
        "##hks"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kY6x-B2WfXTO",
        "outputId": "32ffaa77-9c60-4d11-9ef2-3a374a2f2a9c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n",
            "/content/drive/MyDrive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "%cd /content/drive/MyDrive"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eY2qf-CkfZnv",
        "outputId": "272182c2-4377-42ec-8d85-7f0aeec41176"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/externals/joblib/__init__.py:15: FutureWarning: sklearn.externals.joblib is deprecated in 0.21 and will be removed in 0.23. Please import this functionality directly from joblib, which can be installed with: pip install joblib. If this warning is raised when loading pickled models, you may need to re-serialize those models with scikit-learn 0.21+.\n",
            "  warnings.warn(msg, category=FutureWarning)\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import os\n",
        "import random\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras.optimizers import RMSprop, Adam\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "import keras as K\n",
        "from tensorflow.keras import layers\n",
        "\n",
        "from tensorflow.keras.layers import Dense, Dropout, Flatten, BatchNormalization, GlobalAveragePooling2D\n",
        "from tensorflow.keras import activations\n",
        "from keras.callbacks import LearningRateScheduler as lrschduler\n",
        "\n",
        "import cv2\n",
        "from google.colab.patches import cv2_imshow\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.externals import joblib\n",
        "from keras.preprocessing.image import load_img\n",
        "from keras.preprocessing import image\n",
        "\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "agix9pIofe6f",
        "outputId": "6f0cd2eb-49a5-44b4-ba0d-30b14fda5c4b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Found 8795 images belonging to 2 classes.\n",
            "Found 976 images belonging to 2 classes.\n",
            "Found 1472 images belonging to 2 classes.\n"
          ]
        }
      ],
      "source": [
        "train_dir = '/content/drive/MyDrive/Fire-Safety-Dataset/Train/'\n",
        "train_datagen = ImageDataGenerator(rescale=1./255,\n",
        "    shear_range=0.1,\n",
        "    zoom_range=0.1,\n",
        "    width_shift_range=0.1,\n",
        "    height_shift_range=0.1,\n",
        "    horizontal_flip=True,\n",
        "    vertical_flip=True,\n",
        "    validation_split=0.1\n",
        "                                  )\n",
        "train_generator = train_datagen.flow_from_directory(train_dir,\n",
        "                                                    batch_size=32,\n",
        "                                                    class_mode='categorical',\n",
        "                                                    target_size=(64,64),\n",
        "                                                    subset = 'training',\n",
        "                                                    shuffle = True)\n",
        "\n",
        "validation_dir = train_dir\n",
        "validation_datagen = ImageDataGenerator(rescale=1.0/255,\n",
        "                                        validation_split = 0.1\n",
        "                                        )\n",
        "validation_generator = validation_datagen.flow_from_directory(validation_dir,\n",
        "                                                              batch_size=32,\n",
        "                                                              subset = 'validation',\n",
        "                                                              class_mode ='categorical',\n",
        "                                                              target_size=(64,64),\n",
        "                                                              shuffle = True)\n",
        "\n",
        "test_dir = '/content/drive/MyDrive/Fire-Safety-Dataset/Test/'\n",
        "test_datagen = ImageDataGenerator(rescale = 1./255,\n",
        "                                  )\n",
        "test_generator =test_datagen.flow_from_directory(test_dir,\n",
        "                                                              batch_size=32,\n",
        "                                                              class_mode ='categorical',\n",
        "                                                              target_size=(64,64),\n",
        "                                                              shuffle = True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ejj9bF7Wfh2X"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "from tensorflow.keras.datasets import cifar10\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Dense, Dropout, Activation, Flatten\n",
        "from tensorflow.keras.layers import Conv2D, AveragePooling2D\n",
        "\n",
        "model = Sequential()\n",
        "\n",
        "model.add(Conv2D(filters=16, kernel_size=(3, 3), activation='relu', input_shape=(64,64,3)))\n",
        "model.add(AveragePooling2D())\n",
        "model.add(Dropout(0.5))\n",
        "\n",
        "model.add(Conv2D(filters=32, kernel_size=(3, 3), activation='relu'))\n",
        "model.add(AveragePooling2D())\n",
        "model.add(Dropout(0.5))\n",
        "\n",
        "model.add(Conv2D(filters=64, kernel_size=(3, 3), activation='relu'))\n",
        "model.add(AveragePooling2D())\n",
        "model.add(Dropout(0.5))\n",
        "\n",
        "model.add(Flatten())\n",
        "\n",
        "model.add(Dense(units=256, activation='relu'))\n",
        "model.add(Dropout(0.2))\n",
        "\n",
        "model.add(Dense(units=128, activation='relu'))\n",
        "\n",
        "model.add(Dense(units=2, activation = 'softmax'))\n",
        "\n",
        "model.compile(loss='categorical_crossentropy',\n",
        "              optimizer='adam',\n",
        "              metrics=['accuracy'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_X3uBtEDfkIC",
        "outputId": "377f3c01-c4bd-4711-c30e-bcca9ae55984"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/10\n",
            "275/275 [==============================] - 459s 2s/step - loss: 0.6513 - accuracy: 0.6014 - val_loss: 0.5807 - val_accuracy: 0.5943\n",
            "Epoch 2/10\n",
            "275/275 [==============================] - 61s 220ms/step - loss: 0.4988 - accuracy: 0.7647 - val_loss: 0.5702 - val_accuracy: 0.6855\n",
            "Epoch 3/10\n",
            "275/275 [==============================] - 63s 221ms/step - loss: 0.4421 - accuracy: 0.8045 - val_loss: 0.3109 - val_accuracy: 0.8760\n",
            "Epoch 4/10\n",
            "275/275 [==============================] - 63s 220ms/step - loss: 0.3813 - accuracy: 0.8423 - val_loss: 0.2412 - val_accuracy: 0.8986\n",
            "Epoch 5/10\n",
            "275/275 [==============================] - 62s 221ms/step - loss: 0.3518 - accuracy: 0.8526 - val_loss: 0.2794 - val_accuracy: 0.8832\n",
            "Epoch 6/10\n",
            "275/275 [==============================] - 61s 219ms/step - loss: 0.3442 - accuracy: 0.8570 - val_loss: 0.2996 - val_accuracy: 0.8719\n",
            "Epoch 7/10\n",
            "275/275 [==============================] - 61s 217ms/step - loss: 0.3311 - accuracy: 0.8593 - val_loss: 0.2155 - val_accuracy: 0.9057\n",
            "Epoch 8/10\n",
            "275/275 [==============================] - 61s 219ms/step - loss: 0.3179 - accuracy: 0.8750 - val_loss: 0.1785 - val_accuracy: 0.9211\n",
            "Epoch 9/10\n",
            "275/275 [==============================] - 61s 219ms/step - loss: 0.3149 - accuracy: 0.8701 - val_loss: 0.1957 - val_accuracy: 0.9221\n",
            "Epoch 10/10\n",
            "275/275 [==============================] - 62s 217ms/step - loss: 0.3087 - accuracy: 0.8769 - val_loss: 0.1797 - val_accuracy: 0.9201\n"
          ]
        }
      ],
      "source": [
        "history = model.fit(train_generator,\n",
        "                    shuffle = True,\n",
        "                    epochs=10,\n",
        "                    workers = 8,\n",
        "                    verbose=True,\n",
        "                    validation_data=validation_generator\n",
        "                    )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "TFD1Rk_Ufl9E",
        "outputId": "881a8868-ad5b-40d2-a625-6f7863840930"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light",
            "tags": []
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.plot(history.history['accuracy'])\n",
        "plt.plot(history.history['val_accuracy'])\n",
        "plt.title('model accuracy')\n",
        "plt.ylabel('accuracy')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['train', 'validation'], loc='upper left')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Wl2SST02ipjm",
        "outputId": "9a189fd3-4935-4294-9418-3b85bcc8fb9d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "46/46 [==============================] - 6s 134ms/step - loss: 0.2724 - accuracy: 0.8655\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "[0.2724178433418274, 0.86548912525177]"
            ]
          },
          "execution_count": 15,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model.evaluate(test_generator, batch_size=32,verbose = True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9lTaFOU_n1V6"
      },
      "outputs": [],
      "source": [
        "def check_area(image):\n",
        "  frame = image\n",
        "  frame = cv2.resize(frame, (500, 500))\n",
        "  hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)\n",
        "  hl = 0\n",
        "  sl = 0\n",
        "  vl = 246\n",
        "  hh = 255\n",
        "  sh = 255\n",
        "  vh = 255\n",
        "\n",
        "  low = np.array([hl, sl, vl])\n",
        "  high = np.array([hh, sh, vh])\n",
        "\n",
        "  mask = cv2.inRange(hsv, low, high)\n",
        "\n",
        "  _, thresh = cv2.threshold(mask, 125, 255, cv2.THRESH_BINARY)\n",
        "  contours, _ = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n",
        "  totalArea = 0\n",
        "  for i in range(0, len(contours)):\n",
        "      approx = cv2.approxPolyDP(contours[i], 0.01 * cv2.arcLength(contours[i], True), True)\n",
        "      area = cv2.contourArea(contours[i])\n",
        "      totalArea = totalArea + area\n",
        "      cv2.drawContours(frame, contours, i, (0, 255, 0), 2)\n",
        "\n",
        "  #cv2_imshow( mask)\n",
        "  #cv2_imshow(frame)\n",
        "  t = 1\n",
        "  return (totalArea/2500)\n",
        "\n",
        "def cost_calc(arr, image):\n",
        "  cost=0\n",
        "  if arr == 1 :\n",
        "    cost = check_area(image)\n",
        "  return cost\n",
        "\n",
        "def fire(filename):\n",
        "  imag = cv2.imread(filename)\n",
        "  #cv2_imshow(imag)\n",
        "\n",
        "  image_path = filename\n",
        "  img = load_img(image_path, target_size = (64,64))\n",
        "  x = image.img_to_array(img)\n",
        "  x = np.expand_dims(x, axis=0)\n",
        "  x = x/255\n",
        "  p = model.predict(x)\n",
        "  #print(p)\n",
        "  #print(labels[i])\n",
        "  i = np.argmax(p,1).squeeze()\n",
        "  return cost_calc(i, imag)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "05wjotKJqjml"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [],
      "include_colab_link": true,
      "name": "modelfire-train.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}