Deepfake_face_detection.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Deepfake_face_detection.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u9DHiAtDx1eo",
        "outputId": "7a5e3acc-48a8-4833-f8a7-2aa9117af6f6"
      },
      "source": [
        "!pip install mtcnn"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: mtcnn in /usr/local/lib/python3.7/dist-packages (0.1.1)\n",
            "Requirement already satisfied: keras>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from mtcnn) (2.6.0)\n",
            "Requirement already satisfied: opencv-python>=4.1.0 in /usr/local/lib/python3.7/dist-packages (from mtcnn) (4.1.2.30)\n",
            "Requirement already satisfied: numpy>=1.14.5 in /usr/local/lib/python3.7/dist-packages (from opencv-python>=4.1.0->mtcnn) (1.19.5)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y82aMrAhztpB"
      },
      "source": [
        "import dlib\n",
        "from mtcnn import MTCNN\n",
        "import cv2\n",
        "import os\n",
        "import re\n",
        "import json\n",
        "from pylab import *\n",
        "from PIL import Image, ImageChops, ImageEnhance\n",
        "import scipy\n",
        "import scipy.misc\n",
        "from scipy import ndimage\n",
        "import skimage.io\n",
        "import skimage.filters\n",
        "import sys"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ELqVHl1svOED",
        "outputId": "ccd20ca4-bac8-4269-efa7-f5889982a2b8"
      },
      "source": [
        "!mkdir /content/dataset\n",
        "!mkdir /content/dataset/real\n",
        "!mkdir /content/dataset/fake"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "mkdir: cannot create directory ‘/content/dataset’: File exists\n",
            "mkdir: cannot create directory ‘/content/dataset/real’: File exists\n",
            "mkdir: cannot create directory ‘/content/dataset/fake’: File exists\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LCW8JTJcWSdg",
        "outputId": "9a66b225-789a-42ab-9855-5c32dd4e08b3"
      },
      "source": [
        "train_frame_folder = '/content/drive/MyDrive/train_sample_videos'\n",
        "ct=0\n",
        "with open(os.path.join(train_frame_folder, 'metadata.json'), 'r') as file:\n",
        "    data = json.load(file)\n",
        "list_of_train_data = [f for f in os.listdir(train_frame_folder) if f.endswith('.mp4')]\n",
        "detector = MTCNN()\n",
        "for vid in list_of_train_data:\n",
        "    count = 0\n",
        "    cap = cv2.VideoCapture(os.path.join(train_frame_folder, vid))\n",
        "    frameRate = cap.get(5)\n",
        "    while cap.isOpened():\n",
        "        frameId = cap.get(1)\n",
        "        ret, frame = cap.read()\n",
        "        if ret != True:\n",
        "            break\n",
        "        if frameId % ((int(frameRate)+1)*1) == 0:\n",
        "            face_rects=detector.detect_faces(frame)\n",
        "            for i, d in enumerate(face_rects):\n",
        "                x, y, width, height = face_rects[0]['box']\n",
        "                x1,y1,x2,y2 = x-10,y+10,x-10 +width + 20,y+10+height\n",
        "                crop_img = frame[y1:y2, x1:x2]\n",
        "                if data[vid]['label'] == 'REAL':\n",
        "                    cv2.imwrite('dataset/real/'+vid.split('.')[0]+'_'+str(count)+'.png', cv2.resize(crop_img, (128, 128)))\n",
        "                elif data[vid]['label'] == 'FAKE':\n",
        "                    cv2.imwrite('dataset/fake/'+vid.split('.')[0]+'_'+str(count)+'.png',cv2.resize(crop_img, (128, 128)))\n",
        "                count+=1\n",
        "\n",
        "    ct+=1\n",
        "    print(ct)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n",
            "11\n",
            "12\n",
            "13\n",
            "14\n",
            "15\n",
            "16\n",
            "17\n",
            "18\n",
            "19\n",
            "20\n",
            "21\n",
            "22\n",
            "23\n",
            "24\n",
            "25\n",
            "26\n",
            "27\n",
            "28\n",
            "29\n",
            "30\n",
            "31\n",
            "32\n",
            "33\n",
            "34\n",
            "35\n",
            "36\n",
            "37\n",
            "38\n",
            "39\n",
            "40\n",
            "41\n",
            "42\n",
            "43\n",
            "44\n",
            "45\n",
            "46\n",
            "47\n",
            "48\n",
            "49\n",
            "50\n",
            "51\n",
            "52\n",
            "53\n",
            "54\n",
            "55\n",
            "56\n",
            "57\n",
            "58\n",
            "59\n",
            "60\n",
            "61\n",
            "62\n",
            "63\n",
            "64\n",
            "65\n",
            "66\n",
            "67\n",
            "68\n",
            "69\n",
            "70\n",
            "71\n",
            "72\n",
            "73\n",
            "74\n",
            "75\n",
            "76\n",
            "77\n",
            "78\n",
            "79\n",
            "80\n",
            "81\n",
            "82\n",
            "83\n",
            "84\n",
            "85\n",
            "86\n",
            "87\n",
            "88\n",
            "89\n",
            "90\n",
            "91\n",
            "92\n",
            "93\n",
            "94\n",
            "95\n",
            "96\n",
            "97\n",
            "98\n",
            "99\n",
            "100\n",
            "101\n",
            "102\n",
            "103\n",
            "104\n",
            "105\n",
            "106\n",
            "107\n",
            "108\n",
            "109\n",
            "110\n",
            "111\n",
            "112\n",
            "113\n",
            "114\n",
            "115\n",
            "116\n",
            "117\n",
            "118\n",
            "119\n",
            "120\n",
            "121\n",
            "122\n",
            "123\n",
            "124\n",
            "125\n",
            "126\n",
            "127\n",
            "128\n",
            "129\n",
            "130\n",
            "131\n",
            "132\n",
            "133\n",
            "134\n",
            "135\n",
            "136\n",
            "137\n",
            "138\n",
            "139\n",
            "140\n",
            "141\n",
            "142\n",
            "143\n",
            "144\n",
            "145\n",
            "146\n",
            "147\n",
            "148\n",
            "149\n",
            "150\n",
            "151\n",
            "152\n",
            "153\n",
            "154\n",
            "155\n",
            "156\n",
            "157\n",
            "158\n",
            "159\n",
            "160\n",
            "161\n",
            "162\n",
            "163\n",
            "164\n",
            "165\n",
            "166\n",
            "167\n",
            "168\n",
            "169\n",
            "170\n",
            "171\n",
            "172\n",
            "173\n",
            "174\n",
            "175\n",
            "176\n",
            "177\n",
            "178\n",
            "179\n",
            "180\n",
            "181\n",
            "182\n",
            "183\n",
            "184\n",
            "185\n",
            "186\n",
            "187\n",
            "188\n",
            "189\n",
            "190\n",
            "191\n",
            "192\n",
            "193\n",
            "194\n",
            "195\n",
            "196\n",
            "197\n",
            "198\n",
            "199\n",
            "200\n",
            "201\n",
            "202\n",
            "203\n",
            "204\n",
            "205\n",
            "206\n",
            "207\n",
            "208\n",
            "209\n",
            "210\n",
            "211\n",
            "212\n",
            "213\n",
            "214\n",
            "215\n",
            "216\n",
            "217\n",
            "218\n",
            "219\n",
            "220\n",
            "221\n",
            "222\n",
            "223\n",
            "224\n",
            "225\n",
            "226\n",
            "227\n",
            "228\n",
            "229\n",
            "230\n",
            "231\n",
            "232\n",
            "233\n",
            "234\n",
            "235\n",
            "236\n",
            "237\n",
            "238\n",
            "239\n",
            "240\n",
            "241\n",
            "242\n",
            "243\n",
            "244\n",
            "245\n",
            "246\n",
            "247\n",
            "248\n",
            "249\n",
            "250\n",
            "251\n",
            "252\n",
            "253\n",
            "254\n",
            "255\n",
            "256\n",
            "257\n",
            "258\n",
            "259\n",
            "260\n",
            "261\n",
            "262\n",
            "263\n",
            "264\n",
            "265\n",
            "266\n",
            "267\n",
            "268\n",
            "269\n",
            "270\n",
            "271\n",
            "272\n",
            "273\n",
            "274\n",
            "275\n",
            "276\n",
            "277\n",
            "278\n",
            "279\n",
            "280\n",
            "281\n",
            "282\n",
            "283\n",
            "284\n",
            "285\n",
            "286\n",
            "287\n",
            "288\n",
            "289\n",
            "290\n",
            "291\n",
            "292\n",
            "293\n",
            "294\n",
            "295\n",
            "296\n",
            "297\n",
            "298\n",
            "299\n",
            "300\n",
            "301\n",
            "302\n",
            "303\n",
            "304\n",
            "305\n",
            "306\n",
            "307\n",
            "308\n",
            "309\n",
            "310\n",
            "311\n",
            "312\n",
            "313\n",
            "314\n",
            "315\n",
            "316\n",
            "317\n",
            "318\n",
            "319\n",
            "320\n",
            "321\n",
            "322\n",
            "323\n",
            "324\n",
            "325\n",
            "326\n",
            "327\n",
            "328\n",
            "329\n",
            "330\n",
            "331\n",
            "332\n",
            "333\n",
            "334\n",
            "335\n",
            "336\n",
            "337\n",
            "338\n",
            "339\n",
            "340\n",
            "341\n",
            "342\n",
            "343\n",
            "344\n",
            "345\n",
            "346\n",
            "347\n",
            "348\n",
            "349\n",
            "350\n",
            "351\n",
            "352\n",
            "353\n",
            "354\n",
            "355\n",
            "356\n",
            "357\n",
            "358\n",
            "359\n",
            "360\n",
            "361\n",
            "362\n",
            "363\n",
            "364\n",
            "365\n",
            "366\n",
            "367\n",
            "368\n",
            "369\n",
            "370\n",
            "371\n",
            "372\n",
            "373\n",
            "374\n",
            "375\n",
            "376\n",
            "377\n",
            "378\n",
            "379\n",
            "380\n",
            "381\n",
            "382\n",
            "383\n",
            "384\n",
            "385\n",
            "386\n",
            "387\n",
            "388\n",
            "389\n",
            "390\n",
            "391\n",
            "392\n",
            "393\n",
            "394\n",
            "395\n",
            "396\n",
            "397\n",
            "398\n",
            "399\n",
            "400\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pfNVozNusxRd"
      },
      "source": [
        "import os\n",
        "import cv2\n",
        "import json\n",
        "import tensorflow as tf\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sn\n",
        "import pandas as pd\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator, img_to_array, load_img\n",
        "from tensorflow.keras.utils import to_categorical\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import confusion_matrix"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mxzaVe4ZWicD"
      },
      "source": [
        "input_shape = (128, 128, 3)\n",
        "data_dir = '/content/dataset'\n",
        "\n",
        "real_data = [f for f in os.listdir(data_dir+'/real') if f.endswith('.png')]\n",
        "fake_data = [f for f in os.listdir(data_dir+'/fake') if f.endswith('.png')]\n",
        "\n",
        "X = []\n",
        "Y = []\n",
        "\n",
        "for img in real_data:\n",
        "    X.append(img_to_array(load_img(data_dir+'/real/'+img)).flatten() / 255.0)\n",
        "    Y.append(1)\n",
        "for img in fake_data:\n",
        "    X.append(img_to_array(load_img(data_dir+'/fake/'+img)).flatten() / 255.0)\n",
        "    Y.append(0)\n",
        "\n",
        "Y_val_org = Y\n",
        "\n",
        "#Normalization\n",
        "X = np.array(X)\n",
        "Y = to_categorical(Y, 2)\n",
        "\n",
        "#Reshape\n",
        "X = X.reshape(-1, 128, 128, 3)\n",
        "\n",
        "#Train-Test split\n",
        "X_train, X_val, Y_train, Y_val = train_test_split(X, Y, test_size = 0.2, random_state=5)"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v30hq0q_sr_K",
        "outputId": "dbe3cb73-a344-4d1e-df34-e252a3d0be0a"
      },
      "source": [
        "from tensorflow.keras.applications import InceptionResNetV2\n",
        "from tensorflow.keras.layers import Conv2D\n",
        "from tensorflow.keras.layers import MaxPooling2D\n",
        "from tensorflow.keras.layers import Flatten\n",
        "from tensorflow.keras.layers import Dense\n",
        "from tensorflow.keras.layers import Dropout\n",
        "from tensorflow.keras.layers import InputLayer\n",
        "from tensorflow.keras.layers import GlobalAveragePooling2D\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.models import Model\n",
        "from tensorflow.keras import optimizers\n",
        "from tensorflow.keras.callbacks import ReduceLROnPlateau, EarlyStopping\n",
        "\n",
        "googleNet_model = InceptionResNetV2(include_top=False, weights='imagenet', input_shape=input_shape)\n",
        "googleNet_model.trainable = True\n",
        "model = Sequential()\n",
        "model.add(googleNet_model)\n",
        "model.add(GlobalAveragePooling2D())\n",
        "model.add(Dense(units=2, activation='softmax'))\n",
        "model.compile(loss='binary_crossentropy',\n",
        "              optimizer=optimizers.Adam(lr=1e-5, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False),\n",
        "              metrics=['accuracy'])\n",
        "model.summary()"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/inception_resnet_v2/inception_resnet_v2_weights_tf_dim_ordering_tf_kernels_notop.h5\n",
            "219062272/219055592 [==============================] - 1s 0us/step\n",
            "219070464/219055592 [==============================] - 1s 0us/step\n",
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "inception_resnet_v2 (Functio (None, 2, 2, 1536)        54336736  \n",
            "_________________________________________________________________\n",
            "global_average_pooling2d (Gl (None, 1536)              0         \n",
            "_________________________________________________________________\n",
            "dense_7 (Dense)              (None, 2)                 3074      \n",
            "=================================================================\n",
            "Total params: 54,339,810\n",
            "Trainable params: 54,279,266\n",
            "Non-trainable params: 60,544\n",
            "_________________________________________________________________\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/keras/optimizer_v2/optimizer_v2.py:356: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
            "  \"The `lr` argument is deprecated, use `learning_rate` instead.\")\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ewEKV_W1s3Sj",
        "outputId": "45a04cb4-8cfd-47a7-b96e-37da154c65c7"
      },
      "source": [
        "early_stopping = EarlyStopping(monitor='val_loss',\n",
        "                               min_delta=0,\n",
        "                               patience=2,\n",
        "                               verbose=0, mode='auto')\n",
        "EPOCHS = 20\n",
        "BATCH_SIZE = 100\n",
        "history = model.fit(X_train, Y_train, batch_size = BATCH_SIZE, epochs = EPOCHS, validation_data = (X_val, Y_val), verbose = 1)"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n",
            "33/33 [==============================] - 36s 465ms/step - loss: 0.6837 - accuracy: 0.5927 - val_loss: 0.8415 - val_accuracy: 0.5642\n",
            "Epoch 2/20\n",
            "33/33 [==============================] - 11s 342ms/step - loss: 0.5610 - accuracy: 0.7921 - val_loss: 0.7966 - val_accuracy: 0.5206\n",
            "Epoch 3/20\n",
            "33/33 [==============================] - 11s 343ms/step - loss: 0.4621 - accuracy: 0.8700 - val_loss: 0.7350 - val_accuracy: 0.5521\n",
            "Epoch 4/20\n",
            "33/33 [==============================] - 11s 342ms/step - loss: 0.3814 - accuracy: 0.9058 - val_loss: 0.6841 - val_accuracy: 0.6223\n",
            "Epoch 5/20\n",
            "33/33 [==============================] - 11s 342ms/step - loss: 0.3061 - accuracy: 0.9276 - val_loss: 0.6021 - val_accuracy: 0.7155\n",
            "Epoch 6/20\n",
            "33/33 [==============================] - 11s 342ms/step - loss: 0.2435 - accuracy: 0.9467 - val_loss: 0.5516 - val_accuracy: 0.7627\n",
            "Epoch 7/20\n",
            "33/33 [==============================] - 11s 343ms/step - loss: 0.1921 - accuracy: 0.9527 - val_loss: 0.4816 - val_accuracy: 0.8136\n",
            "Epoch 8/20\n",
            "33/33 [==============================] - 11s 342ms/step - loss: 0.1546 - accuracy: 0.9627 - val_loss: 0.3993 - val_accuracy: 0.8620\n",
            "Epoch 9/20\n",
            "33/33 [==============================] - 11s 341ms/step - loss: 0.1191 - accuracy: 0.9745 - val_loss: 0.3374 - val_accuracy: 0.8995\n",
            "Epoch 10/20\n",
            "33/33 [==============================] - 11s 342ms/step - loss: 0.0966 - accuracy: 0.9776 - val_loss: 0.3065 - val_accuracy: 0.9068\n",
            "Epoch 11/20\n",
            "33/33 [==============================] - 11s 342ms/step - loss: 0.0801 - accuracy: 0.9821 - val_loss: 0.2822 - val_accuracy: 0.9201\n",
            "Epoch 12/20\n",
            "33/33 [==============================] - 11s 342ms/step - loss: 0.0640 - accuracy: 0.9885 - val_loss: 0.2647 - val_accuracy: 0.9249\n",
            "Epoch 13/20\n",
            "33/33 [==============================] - 11s 343ms/step - loss: 0.0546 - accuracy: 0.9900 - val_loss: 0.2849 - val_accuracy: 0.9310\n",
            "Epoch 14/20\n",
            "33/33 [==============================] - 11s 342ms/step - loss: 0.0458 - accuracy: 0.9909 - val_loss: 0.2611 - val_accuracy: 0.9358\n",
            "Epoch 15/20\n",
            "33/33 [==============================] - 11s 343ms/step - loss: 0.0470 - accuracy: 0.9906 - val_loss: 0.2558 - val_accuracy: 0.9322\n",
            "Epoch 16/20\n",
            "33/33 [==============================] - 11s 342ms/step - loss: 0.0313 - accuracy: 0.9948 - val_loss: 0.2556 - val_accuracy: 0.9346\n",
            "Epoch 17/20\n",
            "33/33 [==============================] - 11s 343ms/step - loss: 0.0282 - accuracy: 0.9952 - val_loss: 0.2543 - val_accuracy: 0.9346\n",
            "Epoch 18/20\n",
            "33/33 [==============================] - 11s 342ms/step - loss: 0.0270 - accuracy: 0.9952 - val_loss: 0.2489 - val_accuracy: 0.9346\n",
            "Epoch 19/20\n",
            "33/33 [==============================] - 11s 342ms/step - loss: 0.0252 - accuracy: 0.9958 - val_loss: 0.2599 - val_accuracy: 0.9322\n",
            "Epoch 20/20\n",
            "33/33 [==============================] - 11s 342ms/step - loss: 0.0173 - accuracy: 0.9973 - val_loss: 0.2576 - val_accuracy: 0.9358\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 306
        },
        "id": "T89oVUeZs8Rw",
        "outputId": "40f78b7c-4219-4756-c5b3-d5800f0b13a0"
      },
      "source": [
        "\n",
        "f, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 4))\n",
        "t = f.suptitle('Pre-trained InceptionResNetV2 Transfer Learn with Fine-Tuning & Image Augmentation Performance ', fontsize=12)\n",
        "f.subplots_adjust(top=0.85, wspace=0.3)\n",
        "\n",
        "epoch_list = list(range(1,EPOCHS+1))\n",
        "ax1.plot(epoch_list, history.history['accuracy'], label='Train Accuracy')\n",
        "ax1.plot(epoch_list, history.history['val_accuracy'], label='Validation Accuracy')\n",
        "ax1.set_xticks(np.arange(0, EPOCHS+1, 1))\n",
        "ax1.set_ylabel('Accuracy Value')\n",
        "ax1.set_xlabel('Epoch #')\n",
        "ax1.set_title('Accuracy')\n",
        "l1 = ax1.legend(loc=\"best\")\n",
        "\n",
        "ax2.plot(epoch_list, history.history['loss'], label='Train Loss')\n",
        "ax2.plot(epoch_list, history.history['val_loss'], label='Validation Loss')\n",
        "ax2.set_xticks(np.arange(0, EPOCHS+1, 1))\n",
        "ax2.set_ylabel('Loss Value')\n",
        "ax2.set_xlabel('Epoch #')\n",
        "ax2.set_title('Loss')\n",
        "l2 = ax2.legend(loc=\"best\")"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_wvAAq4uFNbd"
      },
      "source": [
        "model.save('deepfake-detection-model.hdf5')"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1ujQAUg5GwSn"
      },
      "source": [
        "##TESTING"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qKMRyegnF0eY"
      },
      "source": [
        "import tensorflow as tf\n",
        "import mtcnn\n",
        "import cv2\n",
        "import os\n",
        "import numpy as np\n",
        "from mtcnn import MTCNN\n",
        "from PIL import Image, ImageChops, ImageEnhance\n",
        "from tensorflow.keras.models import load_model\n",
        "from tensorflow.keras.preprocessing.image import img_to_array, load_img"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0JjSBi-nGz9x"
      },
      "source": [
        "model = load_model('/content/drive/MyDrive/deepfake-detection-model.hdf5')"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nFK2NwexG5jo",
        "outputId": "e01e20f9-6b88-4978-ec2c-df8bd281b17d"
      },
      "source": [
        "input_shape = (128, 128, 3)\n",
        "pr_data = []\n",
        "detector = MTCNN()\n",
        "#cap = cv2.VideoCapture('/content/drive/MyDrive/test_videos/aassnaulhq.mp4')\n",
        "cap=cv2.VideoCapture('/content/drive/MyDrive/train_sample_videos/aagfhgtpmv.mp4')\n",
        "frameRate = cap.get(5)\n",
        "while cap.isOpened():\n",
        "  frameId = cap.get(1)\n",
        "  ret, frame = cap.read()\n",
        "  if ret != True:\n",
        "    break\n",
        "  if frameId % ((int(frameRate)+1)*1) == 0:\n",
        "    face_rects=detector.detect_faces(frame)\n",
        "    for i, d in enumerate(face_rects):\n",
        "      x, y, width, height = face_rects[0]['box']\n",
        "      x1,y1,x2,y2 = x-10,y+10,x-10 +width + 20,y+10+height\n",
        "      crop_img = frame[y1:y2, x1:x2]\n",
        "      data = img_to_array(cv2.resize(crop_img, (128, 128))).flatten() / 255.0\n",
        "      data = data.reshape(-1, 128, 128, 3)\n",
        "      print(model.predict(data))"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0.6297813  0.37021872]]\n",
            "[[0.6769913  0.32300872]]\n",
            "[[0.27756765 0.7224323 ]]\n",
            "[[0.71699625 0.28300372]]\n",
            "[[0.6691242 0.3308758]]\n",
            "[[0.5326348 0.4673652]]\n",
            "[[0.0876537 0.9123463]]\n",
            "[[0.67959785 0.32040215]]\n",
            "[[0.55352384 0.4464762 ]]\n",
            "[[0.38096157 0.6190384 ]]\n",
            "[[0.38096157 0.6190384 ]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "61zAei1fRPQ6"
      },
      "source": [
        "##This is 2d vector output for each frame which indicates how real or fake that particular frame is. The 1st value indicates the closeness of the frame to being real and the 2nd one to a fake."
      ]
    }
  ]
}