Files

.gitattributes

@@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+fake-1.mp4 filter=lfs diff=lfs merge=lfs -text
+p1/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+real-1.mp4 filter=lfs diff=lfs merge=lfs -text
+Video1-fake-1-ff.mp4 filter=lfs diff=lfs merge=lfs -text
+Video6-real-1-ff.mp4 filter=lfs diff=lfs merge=lfs -text
+Video8-real-3-ff.mp4 filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,37 @@
+---
+title: Deepfakes_Video_Detector
+emoji: 🔥
+colorFrom: blue
+colorTo: gray
+sdk: gradio
+app_file: app.py
+pinned: false
+---
+
+# Configuration
+
+`title`: _string_
+Display title for the Space
+
+`emoji`: _string_
+Space emoji (emoji-only character allowed)
+
+`colorFrom`: _string_
+Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
+
+`colorTo`: _string_
+Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
+
+`sdk`: _string_
+Can be either `gradio`, `streamlit`, or `static`
+
+`sdk_version` : _string_
+Only applicable for `streamlit` SDK.  
+See [doc](https://hf.co/docs/hub/spaces) for more info on supported versions.
+
+`app_file`: _string_
+Path to your main application file (which contains either `gradio` or `streamlit` Python code, or `static` html code).
+Path is relative to the root of the repository.
+
+`pinned`: _boolean_
+Whether the Space stays on top of your list.

Video1-fake-1-ff.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:58262ed5e804069587e393ed06b48e655ca35d7ad58b68c161f5356a14482c48
+size 1746578

Video6-real-1-ff.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad4e54db5f1b0c2f556e039d61ec38e7195edbba6257e266244be64af0bda5e3
+size 1771036

Video8-real-3-ff.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:719f49698458abfa2ff25eb617ff03c5e56ddea51d912d65fbfa44c3db94768a
+size 8949516

api.py

@@ -0,0 +1,149 @@
+from flask import Flask, render_template, request, redirect, url_for
+import gradio as gr
+import cv2
+import numpy as np
+import tensorflow as tf
+from facenet_pytorch import MTCNN
+import moviepy.editor as mp
+from PIL import Image
+import os
+import zipfile
+import json
+import base64
+from tensorflow_addons.optimizers import RectifiedAdam  # Import the RectifiedAdam optimizer
+from keras.utils import get_custom_objects  # Use tensorflow.keras.utils instead
+get_custom_objects().update({"RectifiedAdam": RectifiedAdam})
+
+app = Flask(__name__)
+
+# Load face detector
+mtcnn = MTCNN(margin=14, keep_all=True, factor=0.7, device='cpu')
+
+# DetectionPipeline class
+class DetectionPipeline:
+    def __init__(self, detector, n_frames=None, batch_size=60, resize=None):
+        self.detector = detector
+        self.n_frames = n_frames
+        self.batch_size = batch_size
+        self.resize = resize
+
+    def __call__(self, filename):
+        v_cap = cv2.VideoCapture(filename)
+        v_len = int(v_cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+        if self.n_frames is None:
+            sample = np.arange(0, v_len)
+        else:
+            sample = np.linspace(0, v_len - 1, self.n_frames).astype(int)
+
+        faces = []
+        frames = []
+
+        for j in range(v_len):
+            success = v_cap.grab()
+            if j in sample:
+                success, frame = v_cap.retrieve()
+                if not success:
+                    continue
+                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+
+                if self.resize is not None:
+                    frame = frame.resize([int(d * self.resize) for d in frame.size])
+
+                frames.append(frame)
+
+                if len(frames) % self.batch_size == 0 or j == sample[-1]:
+                    boxes, probs = self.detector.detect(frames)
+
+                    for i in range(len(frames)):
+                        if boxes[i] is None:
+                            faces.append(face2)
+                            continue
+
+                        box = boxes[i][0].astype(int) 
+                        frame = frames[i]
+                        face = frame[box[1]:box[3], box[0]:box[2]]
+
+                        if not face.any():
+                            faces.append(face2)
+                            continue
+
+                        face2 = cv2.resize(face, (224, 224))
+                        faces.append(face2)
+
+                    frames = []
+
+        v_cap.release()
+
+        return faces
+
+detection_pipeline = DetectionPipeline(detector=mtcnn, n_frames=20, batch_size=60)
+
+model = tf.keras.models.load_model("./Detecto-DeepFake_Video_Detector/p1")
+
+def deepfakespredict(input_video):
+    faces = detection_pipeline(input_video)
+    total = 0
+    real = 0
+    fake = 0
+
+    for face in faces:
+        face2 = face / 255
+        pred = model.predict(np.expand_dims(face2, axis=0))[0]
+        total += 1
+        pred2 = pred[1]
+
+        if pred2 > 0.5:
+            fake += 1
+        else:
+            real += 1
+
+    fake_ratio = fake / total
+    text = ""
+    text2 = f"Deepfakes Confidence: {fake_ratio * 100:.2f}%"
+
+    if fake_ratio >= 0.5:
+        text = "The video is FAKE."
+    else:
+        text = "The video is REAL."
+
+    face_frames = []
+    
+    for face in faces:
+        face_frame = Image.fromarray(face.astype('uint8'), 'RGB')
+        face_frames.append(face_frame)
+        
+    face_frames[0].save('results.gif', save_all=True, append_images=face_frames[1:], duration=250, loop=100)
+    clip = mp.VideoFileClip("results.gif")
+    clip.write_videofile("video.mp4")
+
+    return text, text2, "video.mp4"
+
+iface = gr.Interface(
+    fn=deepfakespredict,
+    inputs=gr.inputs.Video(type="mp4"),
+    outputs=[
+        gr.outputs.Text(label="Detection Result"),
+        gr.outputs.Text(label="Confidence"),
+        gr.outputs.File(label="Result Video")
+    ],
+    live=True,
+    title="EfficientNetV2 Deepfakes Video Detector",
+    description="This is a demo implementation of EfficientNetV2 Deepfakes Image Detector ",
+    examples=[
+        [open('./Detecto-DeepFake_Video_Detector/Video1-fake-1-ff.mp4', 'rb')],
+        [open('./Detecto-DeepFake_Video_Detector/Video6-real-1-ff.mp4', 'rb')],
+        [open('./Detecto-DeepFake_Video_Detector/Video3-fake-3-ff.mp4', 'rb')],
+        [open('./Detecto-DeepFake_Video_Detector/Video8-real-3-ff.mp4', 'rb')],
+        [open('./Detecto-DeepFake_Video_Detector/real-1.mp4', 'rb')],
+        [open('./Detecto-DeepFake_Video_Detector/fake-1.mp4', 'rb')]
+    ]
+)
+
+@app.route('/')
+def index():
+    iface.launch(share=True)
+    return iface.ui()
+
+if __name__ == '__main__':
+    app.run(debug=True)

app.py

@@ -0,0 +1,213 @@
+import gradio as gr
+import cv2
+import numpy as np
+import tensorflow as tf
+import tensorflow_addons
+
+from facenet_pytorch import MTCNN
+from PIL import Image
+import moviepy.editor as mp
+import os
+import zipfile
+
+# local_zip = "FINAL-EFFICIENTNETV2-B0.zip"
+# zip_ref = zipfile.ZipFile(local_zip, 'r')
+# zip_ref.extractall('FINAL-EFFICIENTNETV2-B0')
+# zip_ref.close()
+
+# Load face detector
+mtcnn = MTCNN(margin=14, keep_all=True, factor=0.7, device='cpu')
+
+#Face Detection function, Reference: (Timesler, 2020); Source link: https://www.kaggle.com/timesler/facial-recognition-model-in-pytorch
+class DetectionPipeline:
+    """Pipeline class for detecting faces in the frames of a video file."""
+
+    def __init__(self, detector, n_frames=None, batch_size=60, resize=None):
+        """Constructor for DetectionPipeline class.
+
+        Keyword Arguments:
+            n_frames {int} -- Total number of frames to load. These will be evenly spaced
+                throughout the video. If not specified (i.e., None), all frames will be loaded.
+                (default: {None})
+            batch_size {int} -- Batch size to use with MTCNN face detector. (default: {32})
+            resize {float} -- Fraction by which to resize frames from original prior to face
+                detection. A value less than 1 results in downsampling and a value greater than
+                1 result in upsampling. (default: {None})
+        """
+        self.detector = detector
+        self.n_frames = n_frames
+        self.batch_size = batch_size
+        self.resize = resize
+
+    def __call__(self, filename):
+        """Load frames from an MP4 video and detect faces.
+
+        Arguments:
+            filename {str} -- Path to video.
+        """
+        # Create video reader and find length
+        v_cap = cv2.VideoCapture(filename)
+        v_len = int(v_cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+        # Pick 'n_frames' evenly spaced frames to sample
+        if self.n_frames is None:
+            sample = np.arange(0, v_len)
+        else:
+            sample = np.linspace(0, v_len - 1, self.n_frames).astype(int)
+
+        # Loop through frames
+        faces = []
+        frames = []
+        for j in range(v_len):
+            success = v_cap.grab()
+            if j in sample:
+                # Load frame
+                success, frame = v_cap.retrieve()
+                if not success:
+                    continue
+                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                # frame = Image.fromarray(frame)
+
+                # Resize frame to desired size
+                if self.resize is not None:
+                    frame = frame.resize([int(d * self.resize) for d in frame.size])
+                frames.append(frame)
+
+                # When batch is full, detect faces and reset frame list
+                if len(frames) % self.batch_size == 0 or j == sample[-1]:
+
+                    boxes, probs = self.detector.detect(frames)
+
+                    for i in range(len(frames)):
+
+                        if boxes[i] is None:
+                            faces.append(face2)     #append previous face frame if no face is detected
+                            continue
+
+                        box = boxes[i][0].astype(int)
+                        frame = frames[i]
+                        face = frame[box[1]:box[3], box[0]:box[2]]
+
+                        if not face.any():
+                            faces.append(face2)     #append previous face frame if no face is detected
+                            continue
+
+                        face2 = cv2.resize(face, (224, 224))
+
+                        faces.append(face2)
+
+                    frames = []
+
+        v_cap.release()
+
+        return faces
+
+
+detection_pipeline = DetectionPipeline(detector=mtcnn,n_frames=20, batch_size=60)
+
+model = tf.keras.models.load_model("./Detecto-DeepFake_Video_Detector/p1")
+
+
+def deepfakespredict(input_video):
+
+    faces = detection_pipeline(input_video)
+
+    total = 0
+    real = 0
+    fake = 0
+
+    for face in faces:
+
+        face2 = face/255
+        pred = model.predict(np.expand_dims(face2, axis=0))[0]
+        total+=1
+
+        pred2 = pred[1]
+
+        if pred2 > 0.5:
+          fake+=1
+        else:
+          real+=1
+
+    fake_ratio = fake/total
+
+    text =""
+    text2 = "Deepfakes Confidence: " + str(fake_ratio*100) + "%"
+
+    if fake_ratio >= 0.5:
+        text = "The video is FAKE."
+    else:
+        text = "The video is REAL."
+
+    face_frames = []
+    
+    for face in faces:
+        face_frame = Image.fromarray(face.astype('uint8'), 'RGB')
+        face_frames.append(face_frame)
+        
+    face_frames[0].save('results.gif', save_all=True, append_images=face_frames[1:], duration = 250, loop = 100 )
+    clip = mp.VideoFileClip("results.gif")
+    clip.write_videofile("video.mp4")
+
+    return text, text2, "video.mp4"
+
+
+
+title="EfficientNetV2 Deepfakes Video Detector"
+description="This is a demo implementation of EfficientNetV2 Deepfakes Image Detector by using frame-by-frame detection. \
+            To use it, simply upload your video, or click one of the examples to load them.\
+            This demo and model represent the Final Year Project titled \"Achieving Face Swapped Deepfakes Detection Using EfficientNetV2\" by a CS undergraduate Lee Sheng Yeh. \
+            The examples were extracted from Celeb-DF(V2)(Li et al, 2020) and FaceForensics++(Rossler et al., 2019). Full reference details is available in \"references.txt.\" \
+            The examples are used under fair use to demo the working of the model only. If any copyright is infringed, please contact the researcher via this email: [email protected].\
+            "
+            
+examples = [              
+                ['./Detecto-DeepFake_Video_Detector/Video1-fake-1-ff.mp4'],
+                ['./Detecto-DeepFake_Video_Detector/Video6-real-1-ff.mp4'],
+                ['./Detecto-DeepFake_Video_Detector/Video3-fake-3-ff.mp4'],
+                ['./Detecto-DeepFake_Video_Detector/Video8-real-3-ff.mp4'],
+                ['./Detecto-DeepFake_Video_Detector/real-1.mp4'],
+                ['./Detecto-DeepFake_Video_Detector/fake-1.mp4'],
+           ]
+           
+gr.Interface(deepfakespredict,
+                     inputs = ["video"],
+                     outputs=["text","text", gr.outputs.Video(label="Detected face sequence")],
+                     title=title,
+                     description=description,
+                     examples=examples
+                     ).launch()
+
+# # Import the necessary module to interact with the Hugging Face Hub.
+# from huggingface_hub import notebook_login
+
+# # Perform a login to the Hugging Face Hub.
+# notebook_login()
+
+# # Import the HfApi class from the huggingface_hub library.
+# from huggingface_hub import HfApi
+
+# # Create an instance of the HfApi class.
+# api = HfApi()
+
+# # Define the repository ID by combining the username "dima806" with the model name.
+# repo_id = f"DarkVision/Deepfake_detection_video"
+
+# try:
+#     # Attempt to create a new repository on the Hugging Face Model Hub using the specified repo_id.
+#     api.create_repo(repo_id)
+    
+#     # If the repository creation is successful, print a message indicating that the repository was created.
+#     print(f"Repo {repo_id} created")
+# except:
+#     # If an exception is raised, print a message indicating that the repository already exists.
+#     print(f"Repo {repo_id} already exists")
+    
+# # Uploading a folder to the Hugging Face Model Hub
+# api.upload_folder(
+#     folder_path= "Detecto-DeepFake_Video_Detector/",  # The path to the folder to be uploaded
+#     path_in_repo=".",  # The path where the folder will be stored in the repository
+#     repo_id=repo_id,  # The ID of the repository where the folder will be uploaded
+#     repo_type="model",  # The type of the repository (in this case, a model repository)
+#     revision="main" # Revision name
+# )

fake-1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:14d58b019d1d2a2be3c8293654b00a5fe7c3912267885eb8a9d42cfde411f91f
+size 1142692

p1/keras_metadata.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8411f85bd22de246fee31adc6bbf0a60d403ac22d8f572154fd77eb866b8daf3
+size 202114

p1/saved_model.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca17aff86eeedbeab2ace0fc42296a1fe11352c6adb418f04f96c5a3607bd28a
+size 10505251

p1/variables/variables.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6418ccca9c8b62339ccfae9e5e3aae785fbdeed31fa08af7207ad4f0fc94fbbf
+size 23824720

packages.txt

@@ -0,0 +1,3 @@
+ffmpeg 
+libsm6 
+libxext6

real-1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c80effbdbdf7ea5b6b2fab02fa8d4b5dde64aef46c91d6c6911a01e6d03673a4
+size 1152146