Violence_Detection_Our_Dataset.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "Violence Detection - Our Dataset.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "j9vyKhocvWzX"
      },
      "source": [
        "# importing libraries\n",
        "from tensorflow.keras.applications.vgg16 import VGG16\n",
        "from tensorflow.keras.applications.densenet import DenseNet201\n",
        "from tensorflow.keras.applications import ResNet101\n",
        "from tensorflow.keras.applications import Xception\n",
        "from tensorflow.keras.models import Model\n",
        "from tensorflow.keras.layers import Dense, Input\n",
        "from tensorflow.keras.layers import GlobalAveragePooling2D, GlobalMaxPooling2D\n",
        "from tensorflow.keras.layers import LSTM\n",
        "from tensorflow.keras.layers import GRU\n",
        "from tensorflow.keras.layers import Bidirectional\n",
        "from tensorflow.keras.layers import TimeDistributed\n",
        "from tensorflow.keras.optimizers import Nadam"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rB7iJkHTvfoV"
      },
      "source": [
        "#defining input shape\n",
        "video = Input(shape=(70,\n",
        "                     70,\n",
        "                     150,\n",
        "                     3))\n",
        "#using resnet model\n",
        "cnn_base = VGG16(input_shape=(70,\n",
        "                              150,\n",
        "                              3),\n",
        "                 weights=\"imagenet\",\n",
        "                 include_top=False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ud2A2IWJft5N",
        "outputId": "0ff34751-8cc6-43a2-9da6-edbf8feddb22"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LR17rIgTLovb"
      },
      "source": [
        "#doing global averaging\n",
        "cnn_out = GlobalMaxPooling2D()(cnn_base.output)\n",
        "\n",
        "#made model\n",
        "cnn = Model(inputs=cnn_base.input, outputs=cnn_out)\n",
        "\n",
        "# will not train this part\n",
        "cnn.trainable = False\n",
        "\n",
        "# time distributed layer ecodes 70 frames input from video\n",
        "encoded_frames = TimeDistributed(cnn)(video)\n",
        "\n",
        "# passed into LSTM which returns the sequence\n",
        "encoded_sequence = LSTM(256)(encoded_frames)\n",
        "\n",
        "#output is then sent to fully connected layer\n",
        "hidden_layer = Dense(units=1024, activation=\"relu\")(encoded_sequence)\n",
        "\n",
        "#it is then reduced to 2 output\n",
        "outputs = Dense(2, activation=\"softmax\")(hidden_layer)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3hMVgklDvqKo",
        "outputId": "07f78cf5-f807-4513-bc36-67d5699c3115"
      },
      "source": [
        "# initialized the model\n",
        "model = Model([video], outputs)\n",
        "\n",
        "#defined optimizer\n",
        "optimizer = Nadam(lr=0.002,\n",
        "                  beta_1=0.9,\n",
        "                  beta_2=0.999,\n",
        "                  epsilon=1e-08,\n",
        "                  schedule_decay=0.004)\n",
        "\n",
        "#compilation of model\n",
        "model.compile(loss=\"categorical_crossentropy\",\n",
        "              optimizer=optimizer,\n",
        "              metrics=[\"categorical_accuracy\"]) \n",
        "\n",
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model_4\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_5 (InputLayer)        [(None, 70, 70, 150, 3)]  0         \n",
            "                                                                 \n",
            " time_distributed_3 (TimeDis  (None, 70, 512)          14714688  \n",
            " tributed)                                                       \n",
            "                                                                 \n",
            " lstm_3 (LSTM)               (None, 256)               787456    \n",
            "                                                                 \n",
            " dense_2 (Dense)             (None, 1024)              263168    \n",
            "                                                                 \n",
            " dense_3 (Dense)             (None, 2)                 2050      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 15,767,362\n",
            "Trainable params: 1,052,674\n",
            "Non-trainable params: 14,714,688\n",
            "_________________________________________________________________\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/keras/optimizer_v2/nadam.py:73: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
            "  super(Nadam, self).__init__(name, **kwargs)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XhBBiFeGvtGI"
      },
      "source": [
        "import os\n",
        "import cv2\n",
        "import numpy as np\n",
        "from sklearn.model_selection import train_test_split\n",
        "import tensorflow.keras.metrics as k"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "obFZBv8hvv4L"
      },
      "source": [
        "from tensorflow.keras.callbacks import ModelCheckpoint, LearningRateScheduler, TensorBoard, EarlyStopping"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C7-oGp_3v28z"
      },
      "source": [
        "data_dir = \"/content/drive/MyDrive/clips/\"\n",
        "img_height , img_width = 150,70\n",
        "seq_len = 70\n",
        " \n",
        "classes = [\"Violence\",\"Non-Violence\"]\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u4rUM2SawAZK"
      },
      "source": [
        "def frames_extraction(video_path):\n",
        "    frames_list = []\n",
        "     \n",
        "    vidObj = cv2.VideoCapture(video_path)\n",
        "    # Used as counter variable \n",
        "    count = 1\n",
        " \n",
        "    while count <= seq_len: \n",
        "         \n",
        "        success, image = vidObj.read() \n",
        "        if success:\n",
        "            image = cv2.resize(image, (img_height, img_width))\n",
        "            # image  = image/255.0\n",
        "            frames_list.append(image)\n",
        "            count += 1  # as their will be success it will append in framelist and increment the count\n",
        "        else:\n",
        "            print(\"Defected frame\")\n",
        "            break\n",
        " \n",
        "            #hence it returns frame list\n",
        "    return frames_list"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FWzfdbFJwDDw"
      },
      "source": [
        "def create_data(input_dir):\n",
        "    X = []\n",
        "    Y = []\n",
        "     \n",
        "    classes_list = os.listdir(input_dir)\n",
        "     \n",
        "    for c in classes_list:\n",
        "        print(c)\n",
        "        files_list = os.listdir(os.path.join(input_dir, c))\n",
        "        for f in files_list:\n",
        "            # passing video for frame extraction which will extract and returns those frames\n",
        "           frames = frames_extraction(os.path.join(os.path.join(input_dir, c), f))\n",
        "           if len(frames) == seq_len:\n",
        "                X.append(frames)\n",
        "                # appending frames into X which is list of list\n",
        "                y = [0]*len(classes) # corresponding y in list form is sent\n",
        "                y[classes.index(c)] = 1\n",
        "                Y.append(y) # y is appended into Y\n",
        "     \n",
        "    X = np.asarray(X)\n",
        "    Y = np.asarray(Y)\n",
        "    return X, Y"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ATvKXQkYPaaV"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NqtqYOS3wESi"
      },
      "source": [
        "%%time\n",
        "# create data will make X and Y so basically does preprocessing\n",
        "X, Y = create_data(data_dir)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1sItkUgTPblr"
      },
      "source": [
        "print(X.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZUXAcIhCwG0J"
      },
      "source": [
        "#data is divided into train and test\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.20, shuffle=True,  random_state=0,stratify=Y )\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kyj3QLVwwNSa"
      },
      "source": [
        "X.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L_WnR5A7wP6_"
      },
      "source": [
        "Y.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L3Z6d8NRPg0H"
      },
      "source": [
        "in_shape = (SequenceLength, IMSIZE[0], IMSIZE[1], 3)\n",
        "    model = Sequential()\n",
        "    model.add(ConvLSTM2D(32, kernel_size=(7, 7), padding='valid', return_sequences=True, input_shape=in_shape))\n",
        "    model.add(Activation('relu'))\n",
        "    model.add(MaxPooling3D(pool_size=(1, 2, 2)))\n",
        "    model.add(ConvLSTM2D(64, kernel_size=(5, 5), padding='valid', return_sequences=True))\n",
        "    model.add(MaxPooling3D(pool_size=(1, 2, 2)))\n",
        "    model.add(ConvLSTM2D(96, kernel_size=(3, 3), padding='valid', return_sequences=True))\n",
        "    model.add(Activation('relu'))\n",
        "    model.add(ConvLSTM2D(96, kernel_size=(3, 3), padding='valid', return_sequences=True))\n",
        "    model.add(Activation('relu'))\n",
        "    model.add(ConvLSTM2D(96, kernel_size=(3, 3), padding='valid', return_sequences=True))\n",
        "    model.add(MaxPooling3D(pool_size=(1, 2, 2)))\n",
        "    model.add(Dense(320))\n",
        "    model.add(Activation('relu'))\n",
        "    model.add(Dropout(0.5))\n",
        "\n",
        "    out_shape = model.output_shape\n",
        "    # print('====Model shape: ', out_shape)\n",
        "    model.add(Reshape((SequenceLength, out_shape[2] * out_shape[3] * out_shape[4])))\n",
        "    model.add(LSTM(64, return_sequences=False))\n",
        "    model.add(Dropout(0.5))\n",
        "    model.add(Dense(N_CLASSES, activation='softmax'))\n",
        "    model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy'])\n",
        "\n",
        "    # model structure summary\n",
        "    print(model.summary())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lIm1dkT0wSUB"
      },
      "source": [
        "#defined earlystopping with pathience of 7 and put that object into callback\n",
        "earlystop = EarlyStopping(patience=7)\n",
        "callbacks = [earlystop]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x-hFLJbmwVN5"
      },
      "source": [
        "#model.fit starts the training, which also calls callback after every epoch\n",
        "#history = model.fit(X,Y, epochs=22, batch_size = 1 , shuffle=True)\n",
        "\n",
        "#model.fit starts the training, which also calls callback after every epoch\n",
        "history = model.fit(x = X_train, y = y_train, epochs=10, batch_size = 1 , shuffle=True, validation_split=0.2, callbacks=callbacks)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SX9R0TV2YoBd"
      },
      "source": [
        "#model is saved into h5 file which will takes input X, and Y\n",
        "model.save('/content/drive/MyDrive/clips/model_v1.h5')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bAp1uzbO22C6"
      },
      "source": [
        "cp '/content/drive/MyDrive/clips/model_v1.h5' '/content/drive/My Drive/clips'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y0O8cTExYoJf"
      },
      "source": [
        "from keras.utils.vis_utils import plot_model\n",
        "plot_model(model, to_file='model_plot.png', show_shapes=True, show_layer_names=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OIO1dQtpwaV6"
      },
      "source": [
        "from sklearn.metrics import classification_report"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pYH49RzewcCJ"
      },
      "source": [
        "y_pred = model.predict(X_test,batch_size=1)\n",
        "y_pred = np.argmax(y_pred, axis = 1)\n",
        "y_test = np.argmax(y_test, axis = 1)\n",
        " \n",
        "print(classification_report(y_test, y_pred))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VJv72MNSrxGz"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}