{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.11.11","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceId":9146200,"sourceType":"datasetVersion","datasetId":5524489},{"sourceId":11177874,"sourceType":"datasetVersion","datasetId":6886913}],"dockerImageVersionId":31041,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import os\nimport glob\nimport random\nimport numpy as np\nfrom PIL import Image\nimport tensorflow as tf\nfrom sklearn.model_selection import train_test_split\nfrom tensorflow.keras.applications import ResNet50, EfficientNetB0\nfrom tensorflow.keras.models import Model\nfrom tensorflow.keras.layers import GlobalAveragePooling2D, Dense, Dropout, Reshape, multiply, Input, Concatenate\nfrom tensorflow.keras.utils import Sequence\nfrom tensorflow.keras.callbacks import EarlyStopping\nfrom tensorflow.keras.applications.resnet50 import preprocess_input as preprocess_resnet\nfrom tensorflow.keras.applications.efficientnet import preprocess_input as preprocess_effnet\nfrom tabulate import tabulate\nfrom sklearn.metrics import confusion_matrix, classification_report\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nfrom tensorflow.keras.regularizers import l2\n\nbase_path = \"/kaggle/input/faceforensics-c23-processed/ff/ff++/frames\"\nreal_dir = os.path.join(base_path, \"original\")\nfake_dir = os.path.join(base_path, \"Deepfakes\")\n\ndef collect_image_paths(directory):\n image_paths = []\n for subdir, _, _ in os.walk(directory):\n images = glob.glob(os.path.join(subdir, \"*.png\"))\n image_paths.extend(images)\n return image_paths\n\nreal_images = collect_image_paths(real_dir)\nfake_images = collect_image_paths(fake_dir)\nreal_labels = [0] * len(real_images)\nfake_labels = [1] * len(fake_images)\n\nall_images = real_images + fake_images\nall_labels = real_labels + fake_labels\n\ncombined = list(zip(all_images, all_labels))\nrandom.shuffle(combined)\nimages_shuffled, labels_shuffled = zip(*combined)\n\nX_temp, X_test, y_temp, y_test = train_test_split(images_shuffled, labels_shuffled, test_size=0.15, random_state=42)\nX_train, X_val, y_train, y_val = train_test_split(X_temp, y_temp, test_size=0.1765, random_state=42)\n\nprint(f\"Train size: {len(X_train)}, Validation size: {len(X_val)}, Test size: {len(X_test)}\")\n\nclass DualInputDataGenerator(Sequence):\n def __init__(self, image_paths, labels, batch_size=32, img_size=(224, 224), shuffle=True):\n self.image_paths = image_paths\n self.labels = labels\n self.batch_size = batch_size\n self.img_size = img_size\n self.shuffle = shuffle\n self.on_epoch_end()\n\n def __len__(self):\n return int(np.ceil(len(self.image_paths) / self.batch_size))\n\n def __getitem__(self, idx):\n batch_paths = self.image_paths[idx * self.batch_size:(idx + 1) * self.batch_size]\n batch_labels = self.labels[idx * self.batch_size:(idx + 1) * self.batch_size]\n resnet_imgs = []\n effnet_imgs = []\n\n for path in batch_paths:\n img = np.array(Image.open(path).resize(self.img_size).convert(\"RGB\"))\n resnet_imgs.append(preprocess_resnet(img))\n effnet_imgs.append(preprocess_effnet(img))\n\n return {\n 'resnet_input': np.array(resnet_imgs),\n 'effnet_input': np.array(effnet_imgs)\n }, np.array(batch_labels)\n\n def on_epoch_end(self):\n if self.shuffle:\n combined = list(zip(self.image_paths, self.labels))\n random.shuffle(combined)\n self.image_paths, self.labels = zip(*combined)\n\ntrain_gen = DualInputDataGenerator(X_train, y_train)\nval_gen = DualInputDataGenerator(X_val, y_val, shuffle=False)\ntest_gen = DualInputDataGenerator(X_test, y_test, shuffle=False)\n\ndef se_block(input_tensor, ratio=16, l2_reg=1e-4):\n channels = input_tensor.shape[-1]\n se = GlobalAveragePooling2D()(input_tensor)\n se = Dense(channels // ratio, activation='relu', kernel_regularizer=l2(l2_reg))(se)\n se = Dense(channels, activation='sigmoid', kernel_regularizer=l2(l2_reg))(se)\n se = Reshape((1, 1, channels))(se)\n return multiply([input_tensor, se])\n\ndef build_combined_model(input_shape=(224, 224, 3), l2_reg=1e-4, fine_tune_at_resnet=140, fine_tune_at_effnet=200):\n # Inputs\n resnet_input = Input(shape=input_shape, name='resnet_input')\n effnet_input = Input(shape=input_shape, name='effnet_input')\n\n # Base models\n resnet_base = ResNet50(include_top=False, weights='imagenet', input_tensor=resnet_input)\n effnet_base = EfficientNetB0(include_top=False, weights='imagenet', input_tensor=effnet_input)\n\n # Freeze all layers initially\n resnet_base.trainable = False\n effnet_base.trainable = False\n\n # Later unfreeze selected layers for fine-tuning\n for layer in resnet_base.layers[fine_tune_at_resnet:]:\n layer.trainable = True\n for layer in effnet_base.layers[fine_tune_at_effnet:]:\n layer.trainable = True\n\n # SE + Global Pooling\n resnet_out = se_block(resnet_base.output, l2_reg=l2_reg)\n effnet_out = se_block(effnet_base.output, l2_reg=l2_reg)\n\n resnet_pool = GlobalAveragePooling2D()(resnet_out)\n effnet_pool = GlobalAveragePooling2D()(effnet_out)\n\n # Merge and Classify\n merged = Concatenate()([resnet_pool, effnet_pool])\n merged = Dropout(0.5)(merged)\n output = Dense(1, activation='sigmoid', kernel_regularizer=l2(l2_reg))(merged)\n\n model = Model(inputs=[resnet_input, effnet_input], outputs=output)\n return model\n \n\nmodel = build_combined_model()\n\nmodel.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4),\n loss='binary_crossentropy', metrics=['accuracy'])\n\nmodel.fit(train_gen, validation_data=val_gen, epochs=10,\n callbacks=[EarlyStopping(monitor='val_loss', patience=3, restore_best_weights=True)])\n# Evaluation\nval_loss, val_acc = model.evaluate(val_gen)\ntest_loss, test_acc = model.evaluate(test_gen)\nprint(f\"Validation Accuracy: {val_acc:.4f}, Test Accuracy: {test_acc:.4f}\")\n\n# Confusion Matrix\ny_true = np.array(y_test)\ny_pred_probs = model.predict(test_gen).flatten()\ny_pred = (y_pred_probs > 0.5).astype(int)\n\ncm = confusion_matrix(y_true, y_pred)\nsns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=['Real', 'Fake'], yticklabels=['Real', 'Fake'])\nplt.xlabel('Predicted')\nplt.ylabel('Actual')\nplt.title('Confusion Matrix')\nplt.show()\n\nprint(classification_report(y_true, y_pred, target_names=['Real', 'Fake']))\n\nprint(f\"Real samples: {np.sum(y_true == 0)}\")\nprint(f\"Fake samples: {np.sum(y_true == 1)}\")\n\nmodel.save(\"/kaggle/working/res50_effB0_final_v5.keras\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-07-08T01:07:27.860441Z","iopub.execute_input":"2025-07-08T01:07:27.860753Z","iopub.status.idle":"2025-07-08T04:56:01.461913Z","shell.execute_reply.started":"2025-07-08T01:07:27.860732Z","shell.execute_reply":"2025-07-08T04:56:01.459732Z"}},"outputs":[{"name":"stderr","text":"2025-07-08 01:07:29.332134: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:477] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\nWARNING: All log messages before absl::InitializeLog() is called are written to STDERR\nE0000 00:00:1751936849.533067 35 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\nE0000 00:00:1751936849.592710 35 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n","output_type":"stream"},{"name":"stdout","text":"Train size: 33598, Validation size: 7202, Test size: 7200\n","output_type":"stream"},{"name":"stderr","text":"I0000 00:00:1751936941.355927 35 gpu_device.cc:2022] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 15513 MB memory: -> device: 0, name: Tesla P100-PCIE-16GB, pci bus id: 0000:00:04.0, compute capability: 6.0\n","output_type":"stream"},{"name":"stdout","text":"Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/resnet/resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5\n\u001b[1m94765736/94765736\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 0us/step\nDownloading data from https://storage.googleapis.com/keras-applications/efficientnetb0_notop.h5\n\u001b[1m16705208/16705208\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 0us/step\n","output_type":"stream"},{"name":"stderr","text":"/usr/local/lib/python3.11/dist-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n self._warn_if_super_not_called()\n","output_type":"stream"},{"name":"stdout","text":"Epoch 1/10\n","output_type":"stream"},{"name":"stderr","text":"WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\nI0000 00:00:1751936997.208556 94 service.cc:148] XLA service 0x7bf190002960 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\nI0000 00:00:1751936997.209532 94 service.cc:156] StreamExecutor device (0): Tesla P100-PCIE-16GB, Compute Capability 6.0\nI0000 00:00:1751937002.376303 94 cuda_dnn.cc:529] Loaded cuDNN version 90300\nE0000 00:00:1751937010.713438 94 gpu_timer.cc:82] Delay kernel timed out: measured time has sub-optimal accuracy. There may be a missing warmup execution, please investigate in Nsight Systems.\nE0000 00:00:1751937010.919985 94 gpu_timer.cc:82] Delay kernel timed out: measured time has sub-optimal accuracy. There may be a missing warmup execution, please investigate in Nsight Systems.\nE0000 00:00:1751937011.666412 94 gpu_timer.cc:82] Delay kernel timed out: measured time has sub-optimal accuracy. There may be a missing warmup execution, please investigate in Nsight Systems.\nE0000 00:00:1751937011.873183 94 gpu_timer.cc:82] Delay kernel timed out: measured time has sub-optimal accuracy. There may be a missing warmup execution, please investigate in Nsight Systems.\n","output_type":"stream"},{"name":"stdout","text":"\u001b[1m 1/1050\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m22:36:05\u001b[0m 78s/step - accuracy: 0.7188 - loss: 0.7233","output_type":"stream"},{"name":"stderr","text":"I0000 00:00:1751937027.057702 94 device_compiler.h:188] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process.\n","output_type":"stream"},{"name":"stdout","text":"\u001b[1m 16/1050\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m21:12\u001b[0m 1s/step - accuracy: 0.5917 - loss: 0.7745","output_type":"stream"},{"name":"stderr","text":"E0000 00:00:1751937057.757900 95 gpu_timer.cc:82] Delay kernel timed out: measured time has sub-optimal accuracy. There may be a missing warmup execution, please investigate in Nsight Systems.\nE0000 00:00:1751937057.965743 95 gpu_timer.cc:82] Delay kernel timed out: measured time has sub-optimal accuracy. There may be a missing warmup execution, please investigate in Nsight Systems.\nE0000 00:00:1751937058.592292 95 gpu_timer.cc:82] Delay kernel timed out: measured time has sub-optimal accuracy. There may be a missing warmup execution, please investigate in Nsight Systems.\nE0000 00:00:1751937058.800185 95 gpu_timer.cc:82] Delay kernel timed out: measured time has sub-optimal accuracy. There may be a missing warmup execution, please investigate in Nsight Systems.\n","output_type":"stream"},{"name":"stdout","text":"\u001b[1m1050/1050\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1727s\u001b[0m 2s/step - accuracy: 0.6555 - loss: 0.6570 - val_accuracy: 0.8428 - val_loss: 0.3836\nEpoch 2/10\n\u001b[1m1050/1050\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1382s\u001b[0m 1s/step - accuracy: 0.8717 - loss: 0.3061 - val_accuracy: 0.9054 - val_loss: 0.2294\nEpoch 3/10\n\u001b[1m1050/1050\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1260s\u001b[0m 1s/step - accuracy: 0.9223 - loss: 0.1904 - val_accuracy: 0.9171 - val_loss: 0.1849\nEpoch 4/10\n\u001b[1m1050/1050\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1293s\u001b[0m 1s/step - accuracy: 0.9434 - loss: 0.1349 - val_accuracy: 0.9332 - val_loss: 0.1592\nEpoch 5/10\n\u001b[1m1050/1050\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1204s\u001b[0m 1s/step - accuracy: 0.9591 - loss: 0.1010 - val_accuracy: 0.9397 - val_loss: 0.1395\nEpoch 6/10\n\u001b[1m1050/1050\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1196s\u001b[0m 1s/step - accuracy: 0.9682 - loss: 0.0804 - val_accuracy: 0.9475 - val_loss: 0.1384\nEpoch 7/10\n\u001b[1m1050/1050\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1248s\u001b[0m 1s/step - accuracy: 0.9686 - loss: 0.0783 - val_accuracy: 0.9515 - val_loss: 0.1225\nEpoch 8/10\n\u001b[1m1050/1050\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1179s\u001b[0m 1s/step - accuracy: 0.9772 - loss: 0.0599 - val_accuracy: 0.9439 - val_loss: 0.1472\nEpoch 9/10\n\u001b[1m1050/1050\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1163s\u001b[0m 1s/step - accuracy: 0.9778 - loss: 0.0548 - val_accuracy: 0.9606 - val_loss: 0.1045\nEpoch 10/10\n\u001b[1m1050/1050\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1241s\u001b[0m 1s/step - accuracy: 0.9791 - loss: 0.0511 - val_accuracy: 0.9614 - val_loss: 0.0950\n\u001b[1m226/226\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m183s\u001b[0m 810ms/step - accuracy: 0.9607 - loss: 0.0964\n\u001b[1m225/225\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m270s\u001b[0m 1s/step - accuracy: 0.9641 - loss: 0.0988\nValidation Accuracy: 0.9614, Test Accuracy: 0.9632\n\u001b[1m225/225\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m256s\u001b[0m 1s/step\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"
","image/png":"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\n"},"metadata":{}},{"name":"stdout","text":" precision recall f1-score support\n\n Real 0.96 0.96 0.96 3577\n Fake 0.97 0.96 0.96 3623\n\n accuracy 0.96 7200\n macro avg 0.96 0.96 0.96 7200\nweighted avg 0.96 0.96 0.96 7200\n\nReal samples: 3577\nFake samples: 3623\n","output_type":"stream"}],"execution_count":1},{"cell_type":"code","source":"from tensorflow.keras.models import load_model\n\n# Redefine se_block (needed for loading if it uses custom layers)\ndef se_block(input_tensor, ratio=16, l2_reg=1e-4):\n channels = input_tensor.shape[-1]\n se = GlobalAveragePooling2D()(input_tensor)\n se = Dense(channels // ratio, activation='relu', kernel_regularizer=l2(l2_reg))(se)\n se = Dense(channels, activation='sigmoid', kernel_regularizer=l2(l2_reg))(se)\n se = Reshape((1, 1, channels))(se)\n return multiply([input_tensor, se])\n\n# Load model from 10th epoch\nmodel = load_model(\"/kaggle/working/res50_effB0_final_v5.keras\",\n custom_objects={'se_block': se_block})\n\n# Recreate data generators (if not already in memory)\ntrain_gen = DualInputDataGenerator(X_train, y_train)\nval_gen = DualInputDataGenerator(X_val, y_val, shuffle=False)\n\n# Recompile the model (needed after loading)\nmodel.compile(\n optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4),\n loss='binary_crossentropy',\n metrics=['accuracy']\n)\n\n# Resume training for 5 more epochs\nhistory = model.fit(\n train_gen,\n validation_data=val_gen,\n initial_epoch=10, # ← Start from epoch 10\n epochs=15, # ← Go up to epoch 15\n callbacks=[EarlyStopping(monitor='val_loss', patience=2, restore_best_weights=True)]\n)\n\n# Save updated model\nmodel.save(\"/kaggle/working/res50_effB0_final_v6.keras\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-07-08T04:57:29.704941Z","iopub.execute_input":"2025-07-08T04:57:29.705258Z","iopub.status.idle":"2025-07-08T06:41:11.788514Z","shell.execute_reply.started":"2025-07-08T04:57:29.705233Z","shell.execute_reply":"2025-07-08T06:41:11.785883Z"}},"outputs":[{"name":"stderr","text":"/usr/local/lib/python3.11/dist-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n self._warn_if_super_not_called()\n","output_type":"stream"},{"name":"stdout","text":"Epoch 11/15\n\u001b[1m1050/1050\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1453s\u001b[0m 1s/step - accuracy: 0.9836 - loss: 0.0424 - val_accuracy: 0.9625 - val_loss: 0.1065\nEpoch 12/15\n\u001b[1m1050/1050\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1282s\u001b[0m 1s/step - accuracy: 0.9848 - loss: 0.0443 - val_accuracy: 0.9645 - val_loss: 0.1044\nEpoch 13/15\n\u001b[1m1050/1050\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1153s\u001b[0m 1s/step - accuracy: 0.9868 - loss: 0.0377 - val_accuracy: 0.9670 - val_loss: 0.0926\nEpoch 14/15\n\u001b[1m1050/1050\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1141s\u001b[0m 1s/step - accuracy: 0.9895 - loss: 0.0303 - val_accuracy: 0.9720 - val_loss: 0.0802\nEpoch 15/15\n\u001b[1m1050/1050\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1185s\u001b[0m 1s/step - accuracy: 0.9902 - loss: 0.0313 - val_accuracy: 0.9732 - val_loss: 0.0808\n","output_type":"stream"}],"execution_count":2},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n\nplt.plot(history.history['accuracy'], label='Train Accuracy')\nplt.plot(history.history['val_accuracy'], label='Val Accuracy')\nplt.xlabel(\"Epoch\")\nplt.ylabel(\"Accuracy\")\nplt.title(\"Continued Training (Epochs 10-15)\")\nplt.legend()\nplt.show()\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-07-08T06:41:11.793246Z","iopub.execute_input":"2025-07-08T06:41:11.793486Z","iopub.status.idle":"2025-07-08T06:41:12.054321Z","shell.execute_reply.started":"2025-07-08T06:41:11.793468Z","shell.execute_reply":"2025-07-08T06:41:12.053607Z"}},"outputs":[{"output_type":"display_data","data":{"text/plain":"
","image/png":"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\n"},"metadata":{}}],"execution_count":3},{"cell_type":"code","source":"y_true = np.array(y_test)\ny_pred_probs = model.predict(test_gen).flatten()\ny_pred = (y_pred_probs > 0.5).astype(int)\n\ncm = confusion_matrix(y_true, y_pred)\nsns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=['Real', 'Fake'], yticklabels=['Real', 'Fake'])\nplt.xlabel('Predicted')\nplt.ylabel('Actual')\nplt.title('Confusion Matrix')\nplt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-07-08T06:53:22.327585Z","iopub.execute_input":"2025-07-08T06:53:22.327903Z","iopub.status.idle":"2025-07-08T06:57:46.161833Z","shell.execute_reply.started":"2025-07-08T06:53:22.327879Z","shell.execute_reply":"2025-07-08T06:57:46.16103Z"}},"outputs":[{"name":"stdout","text":"\u001b[1m225/225\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m261s\u001b[0m 1s/step\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"
","image/png":"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\n"},"metadata":{}}],"execution_count":5},{"cell_type":"code","source":"import os\nimport cv2\nimport numpy as np\nimport pandas as pd\nfrom tensorflow.keras.models import load_model\nfrom tensorflow.keras.applications.resnet50 import preprocess_input as preprocess_resnet\nfrom tensorflow.keras.applications.efficientnet import preprocess_input as preprocess_effnet\nfrom tqdm import tqdm\n\n# === Load the trained model ===\nmodel = load_model(\"/kaggle/working/res50_effB0_final_v6.keras\")\n\n# === Dual input preprocessing ===\ndef preprocess_frame_dual(frame, img_size=(224, 224)):\n resized = cv2.resize(frame, img_size)\n rgb = cv2.cvtColor(resized, cv2.COLOR_BGR2RGB)\n return preprocess_resnet(rgb.astype(np.float32)), preprocess_effnet(rgb.astype(np.float32))\n\n# === Extract dual inputs from video ===\ndef extract_dual_inputs(video_path, num_frames=20):\n cap = cv2.VideoCapture(video_path)\n total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))\n frame_ids = np.linspace(0, total - 1, num_frames, dtype=int)\n\n resnet_list, effnet_list = [], []\n for fid in frame_ids:\n cap.set(cv2.CAP_PROP_POS_FRAMES, fid)\n ret, frame = cap.read()\n if not ret:\n continue\n r_img, e_img = preprocess_frame_dual(frame)\n resnet_list.append(r_img)\n effnet_list.append(e_img)\n cap.release()\n\n return np.array(resnet_list), np.array(effnet_list)\n\n# === Predict single video ===\ndef predict_video_file(video_path):\n resnet_input, effnet_input = extract_dual_inputs(video_path)\n if len(resnet_input) == 0 or len(effnet_input) == 0:\n return None\n preds = model.predict({\n \"resnet_input\": resnet_input,\n \"effnet_input\": effnet_input\n }, verbose=0).flatten()\n return np.mean(preds)\n\n# === Run prediction and write CSV ===\ndef run_inference_on_folder(video_folder, output_csv):\n video_files = [f for f in os.listdir(video_folder) if f.endswith(\".mp4\")]\n results = []\n\n for filename in tqdm(video_files, desc=f\"Processing {os.path.basename(video_folder)}\", unit=\"video\"):\n video_path = os.path.join(video_folder, filename)\n avg_pred = predict_video_file(video_path)\n if avg_pred is None:\n label = \"error\"\n else:\n label = \"real\" if avg_pred < 0.5 else \"fake\"\n results.append({\n \"filename\": filename,\n \"label\": label\n })\n\n df = pd.DataFrame(results)\n df.to_csv(output_csv, index=False)\n print(f\"✅ Saved results to {output_csv}\")\n\n# === Paths ===\nfake_video_folder = \"/kaggle/input/deep-fake-detection-dfd-entire-original-dataset/DFD_manipulated_sequences/DFD_manipulated_sequences\"\nreal_video_folder = \"/kaggle/input/deep-fake-detection-dfd-entire-original-dataset/DFD_original_sequences\"\n\n# === Run inference on both folders ===\nrun_inference_on_folder(fake_video_folder, \"/kaggle/working/fake_predictions.csv\")\nrun_inference_on_folder(real_video_folder, \"/kaggle/working/real_predictions.csv\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-07-10T04:56:21.420937Z","iopub.execute_input":"2025-07-10T04:56:21.421647Z","iopub.status.idle":"2025-07-10T04:59:23.795368Z","shell.execute_reply.started":"2025-07-10T04:56:21.421622Z","shell.execute_reply":"2025-07-10T04:59:23.794369Z"}},"outputs":[{"name":"stderr","text":"Processing DFD_manipulated_sequences: 0%| | 0/3068 [00:00\u001b[0;34m()\u001b[0m\n\u001b[1;32m 73\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[0;31m# === Run inference on both folders ===\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 75\u001b[0;31m \u001b[0mrun_inference_on_folder\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfake_video_folder\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"/kaggle/working/fake_predictions.csv\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 76\u001b[0m \u001b[0mrun_inference_on_folder\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreal_video_folder\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"/kaggle/working/real_predictions.csv\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/tmp/ipykernel_35/895879068.py\u001b[0m in \u001b[0;36mrun_inference_on_folder\u001b[0;34m(video_folder, output_csv)\u001b[0m\n\u001b[1;32m 54\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mfilename\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtqdm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvideo_files\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdesc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34mf\"Processing {os.path.basename(video_folder)}\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0munit\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"video\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 55\u001b[0m \u001b[0mvideo_path\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvideo_folder\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfilename\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 56\u001b[0;31m \u001b[0mavg_pred\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpredict_video_file\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvideo_path\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 57\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mavg_pred\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 58\u001b[0m \u001b[0mlabel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"error\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/tmp/ipykernel_35/895879068.py\u001b[0m in \u001b[0;36mpredict_video_file\u001b[0;34m(video_path)\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[0;31m# === Predict single video ===\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mpredict_video_file\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvideo_path\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 40\u001b[0;31m \u001b[0mresnet_input\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meffnet_input\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mextract_dual_inputs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvideo_path\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 41\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresnet_input\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0meffnet_input\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 42\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/tmp/ipykernel_35/895879068.py\u001b[0m in \u001b[0;36mextract_dual_inputs\u001b[0;34m(video_path, num_frames)\u001b[0m\n\u001b[1;32m 25\u001b[0m \u001b[0mresnet_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meffnet_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 26\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mfid\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mframe_ids\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 27\u001b[0;31m \u001b[0mcap\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcv2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCAP_PROP_POS_FRAMES\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfid\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 28\u001b[0m \u001b[0mret\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mframe\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcap\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mret\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mKeyboardInterrupt\u001b[0m: "],"ename":"KeyboardInterrupt","evalue":"","output_type":"error"}],"execution_count":2},{"cell_type":"code","source":"%pip install av tqdm","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-07-10T04:59:36.03973Z","iopub.execute_input":"2025-07-10T04:59:36.040019Z","iopub.status.idle":"2025-07-10T04:59:41.400995Z","shell.execute_reply.started":"2025-07-10T04:59:36.039997Z","shell.execute_reply":"2025-07-10T04:59:41.400193Z"}},"outputs":[{"name":"stdout","text":"Collecting av\n Downloading av-15.0.0-cp311-cp311-manylinux_2_28_x86_64.whl.metadata (4.6 kB)\nRequirement already satisfied: tqdm in /usr/local/lib/python3.11/dist-packages (4.67.1)\nDownloading av-15.0.0-cp311-cp311-manylinux_2_28_x86_64.whl (39.7 MB)\n\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m39.7/39.7 MB\u001b[0m \u001b[31m43.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m:00:01\u001b[0m00:01\u001b[0m\n\u001b[?25hInstalling collected packages: av\nSuccessfully installed av-15.0.0\nNote: you may need to restart the kernel to use updated packages.\n","output_type":"stream"}],"execution_count":3},{"cell_type":"code","source":"import os\nimport av\nimport numpy as np\nimport pandas as pd\nfrom tqdm import tqdm\nimport tensorflow as tf\nfrom tensorflow.keras.models import load_model\nfrom tensorflow.keras.applications.resnet50 import preprocess_input as preprocess_resnet\nfrom tensorflow.keras.applications.efficientnet import preprocess_input as preprocess_effnet\n\n# === Load the trained model ===\nmodel = load_model(\"/kaggle/working/res50_effB0_final_v6.keras\")\n\n# === GPU-accelerated frame preprocessing using tf.image ===\ndef preprocess_frame_dual_tf(frame, img_size=(224, 224)):\n frame = tf.convert_to_tensor(frame, dtype=tf.uint8)\n frame = tf.image.resize(frame, img_size)\n frame = tf.cast(frame, tf.float32)\n\n resnet_input = preprocess_resnet(frame)\n effnet_input = preprocess_effnet(frame)\n\n return resnet_input, effnet_input\n\n# === Faster video decoding using PyAV and batch dual processing ===\ndef extract_dual_inputs_av(video_path, num_frames=20, img_size=(224, 224)):\n try:\n container = av.open(video_path)\n total_frames = container.streams.video[0].frames\n frame_ids = np.linspace(0, total_frames - 1, num_frames, dtype=int)\n\n resnet_list, effnet_list = [], []\n for i, frame in enumerate(container.decode(video=0)):\n if i in frame_ids:\n img = frame.to_ndarray(format=\"rgb24\")\n res, eff = preprocess_frame_dual_tf(img, img_size)\n resnet_list.append(res.numpy()) # Convert back to NumPy for model.predict\n effnet_list.append(eff.numpy())\n if i > frame_ids[-1]:\n break\n\n if len(resnet_list) == 0:\n return None, None\n\n return np.stack(resnet_list), np.stack(effnet_list)\n except Exception as e:\n print(f\"⚠️ Failed to read {video_path}: {e}\")\n return None, None\n\n# === Predict a single video ===\ndef predict_video_file(video_path):\n resnet_input, effnet_input = extract_dual_inputs_av(video_path)\n if resnet_input is None or effnet_input is None:\n return None\n preds = model.predict({\n \"resnet_input\": resnet_input,\n \"effnet_input\": effnet_input\n }, verbose=0).flatten()\n return np.mean(preds)\n\n# === Run inference with tqdm progress bar ===\ndef run_inference_on_folder(video_folder, output_csv):\n video_files = [f for f in os.listdir(video_folder) if f.endswith(\".mp4\")]\n results = []\n\n for filename in tqdm(video_files, desc=f\"Processing {os.path.basename(video_folder)}\", unit=\"video\"):\n video_path = os.path.join(video_folder, filename)\n avg_pred = predict_video_file(video_path)\n if avg_pred is None:\n label = \"error\"\n else:\n label = \"real\" if avg_pred < 0.5 else \"fake\"\n results.append({\n \"filename\": filename,\n \"label\": label\n })\n\n df = pd.DataFrame(results)\n df.to_csv(output_csv, index=False)\n print(f\"✅ Saved results to {output_csv}\")\n\n# === Input paths ===\nfake_video_folder = \"/kaggle/input/deep-fake-detection-dfd-entire-original-dataset/DFD_manipulated_sequences/DFD_manipulated_sequences\"\nreal_video_folder = \"/kaggle/input/deep-fake-detection-dfd-entire-original-dataset/DFD_original sequences\"\n\n# === Run inference ===\n# run_inference_on_folder(fake_video_folder, \"/kaggle/working/fake_predictions.csv\")\nrun_inference_on_folder(real_video_folder, \"/kaggle/working/real_predictions.csv\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-07-10T09:14:21.572889Z","iopub.execute_input":"2025-07-10T09:14:21.573512Z","iopub.status.idle":"2025-07-10T09:46:15.479667Z","shell.execute_reply.started":"2025-07-10T09:14:21.573487Z","shell.execute_reply":"2025-07-10T09:46:15.478747Z"}},"outputs":[{"name":"stderr","text":"Processing DFD_original sequences: 100%|██████████| 363/363 [31:50<00:00, 5.26s/video]","output_type":"stream"},{"name":"stdout","text":"✅ Saved results to /kaggle/working/real_predictions.csv\n","output_type":"stream"},{"name":"stderr","text":"\n","output_type":"stream"}],"execution_count":3},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null}]}