Create ReadMe.md

ReadMe.md

@@ -0,0 +1,91 @@
+## Deepfake Detection Model
+
+This repository contains a deepfake detection model built using a combination of a pre-trained Xception network and an LSTM layer. The model is designed to classify videos as either "Real" or "Fake" by analyzing sequences of facial frames extracted from the video.
+
+### Model Architecture
+
+The model architecture consists of the following components:
+
+1.  **Input Layer**: Takes a sequence of `TIME_STEPS` frames, each resized to `299x299` pixels with 3 color channels. The input shape is `(batch_size, TIME_STEPS, HEIGHT, WIDTH, 3)`.
+
+2.  **TimeDistributed Xception**: A pre-trained Xception network (trained on ImageNet) is applied to each frame independently using a `TimeDistributed` wrapper. The `include_top` is set to `False`, and `pooling` is set to `'avg'`, effectively using the Xception network as a feature extractor for each frame. This produces a sequence of feature vectors, one for each frame.
+
+3.  **LSTM Layer**: The sequence of feature vectors from the `TimeDistributed Xception` layer is fed into an LSTM (Long Short-Term Memory) layer with `256` hidden units. The LSTM layer is capable of learning temporal dependencies between frames, which is crucial for deepfake detection.
+
+4.  **Dropout Layer**: A `Dropout` layer with a rate of `0.5` is applied after the LSTM layer to prevent overfitting.
+
+5.  **Output Layer**: A `Dense` layer with `2` units and a `softmax` activation function outputs the probabilities for the two classes: "Real" and "Fake".
+
+### How to Use
+
+#### 1\. Setup
+
+Clone the repository and install the required libraries:
+
+```bash
+pip install tensorflow opencv-python numpy mtcnn Pillow
+```
+
+#### 2\. Model Loading
+
+The model weights are loaded from `COMBINED_best_Phase1.keras`. Ensure this file is accessible at the specified `model_path`.
+
+```python
+model_path = '/content/drive/MyDrive/Dataset DDM/FINAL models/COMBINED_best_Phase1.keras'
+model = build_model() # Architecture defined in the `build_model` function
+model.load_weights(model_path)
+```
+
+#### 3\. Face Extraction and Preprocessing
+
+The `extract_faces_from_video` function processes a given video file:
+
+  * It uses the MTCNN (Multi-task Cascaded Convolutional Networks) for robust face detection in each frame.
+  * It samples `TIME_STEPS` frames from the video.
+  * For each sampled frame, it detects the primary face, extracts it, and resizes it to `299x299` pixels.
+  * The extracted face images are then preprocessed using `preprocess_input` from `tensorflow.keras.applications.xception`, which scales pixel values to the range expected by the Xception model.
+  * If no face is detected in a frame, a black image of the same dimensions is used as a placeholder.
+  * The function ensures that exactly `TIME_STEPS` frames are returned, padding with the last available frame or black images if necessary.
+
+<!-- end list -->
+
+```python
+from mtcnn import MTCNN
+import cv2
+import numpy as np
+from PIL import Image
+from tensorflow.keras.applications.xception import preprocess_input
+
+def extract_faces_from_video(video_path, num_frames=30):
+    # ... (function implementation as provided in prediction.ipynb)
+    pass
+
+video_path = '/content/drive/MyDrive/Dataset DDM/FF++/manipulated_sequences/FaceShifter/raw/videos/724_725.mp4'
+video_array = extract_faces_from_video(video_path, num_frames=TIME_STEPS)
+```
+
+#### 4\. Prediction
+
+Once the `video_array` (preprocessed frames) is ready, you can make a prediction using the loaded model:
+
+```python
+predictions = model.predict(video_array)
+predicted_class = np.argmax(predictions, axis=1)[0]
+probabilities = predictions[0]
+
+class_names = ['Real', 'Fake']
+print(f"Predicted Class: {class_names[predicted_class]}")
+print(f"Class Probabilities: Real: {probabilities[0]:.4f}, Fake: {probabilities[1]:.4f}")
+```
+
+### Parameters
+
+  * `TIME_STEPS`: Number of frames to extract from each video (default: `30`).
+  * `HEIGHT`, `WIDTH`: Dimensions to which each extracted face image is resized (default: `299, 299`).
+  * `lstm_hidden_size`: Number of hidden units in the LSTM layer (default: `256`).
+  * `dropout_rate`: Dropout rate applied after the LSTM layer (default: `0.5`).
+  * `num_classes`: Number of output classes (default: `2` for "Real" and "Fake").
+
+### Development Environment
+
+The provided code snippet is written in Python and utilizes `tensorflow` (Keras API), `opencv-python`, `numpy`, `mtcnn`, and `Pillow`. It is designed to be run in an environment with these libraries installed. The paths suggest it was developed using Google Drive, potentially within a Colab environment.