HF Ready

.gitattributes

@@ -25,7 +25,6 @@
 *.safetensors filter=lfs diff=lfs merge=lfs -text
 saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
 *.tflite filter=lfs diff=lfs merge=lfs -text
 *.tgz filter=lfs diff=lfs merge=lfs -text
 *.wasm filter=lfs diff=lfs merge=lfs -text
@@ -33,3 +32,11 @@ 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
+Weights/Weights.tar filter=lfs diff=lfs merge=lfs -text
+Weights/FFc23.tar filter=lfs diff=lfs merge=lfs -text
+Examples/Fake1.mp4 filter=lfs diff=lfs merge=lfs -text
+Examples/Real1.mp4 filter=lfs diff=lfs merge=lfs -text
+*.dat filter=lfs diff=lfs merge=lfs -text
+Weights/weights.tar filter=lfs diff=lfs merge=lfs -text
+Examples/Real/Real1.PNG filter=lfs diff=lfs merge=lfs -text
+Examples/Real/Real2.PNG filter=lfs diff=lfs merge=lfs -text

Examples/Fake1.mp4

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

Examples/Real1.mp4

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

README.md

@@ -1,12 +1,11 @@
 ---
 title: DFDetection
-emoji: 📊
+emoji: 📚
 colorFrom: blue
 colorTo: green
 sdk: gradio
-sdk_version: 4.31.5
+sdk_version: 4.29.0
 app_file: app.py
 pinned: false
+license: mit
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

Scripts/DeepFakeMask.py

@@ -0,0 +1,149 @@
+import logging
+import cv2
+import numpy as np
+
+logger = logging.getLogger(__name__)  # pylint: disable=invalid-name
+
+class Mask():
+    """ Parent class for masks
+        the output mask will be <mask_type>.mask
+        channels: 1, 3 or 4:
+                    1 - Returns a single channel mask
+                    3 - Returns a 3 channel mask
+                    4 - Returns the original image with the mask in the alpha channel """
+
+    def __init__(self, landmarks, face, channels=4):
+        logger.info("Initializing %s: (face_shape: %s, channels: %s, landmarks: %s)",
+                     self.__class__.__name__, face.shape, channels, landmarks)
+        self.landmarks = landmarks
+        self.face = face
+        self.channels = channels
+
+        mask = self.build_mask()
+        self.mask = self.merge_mask(mask)
+        logger.info("Initialized %s", self.__class__.__name__)
+
+    def build_mask(self):
+        """ Override to build the mask """
+        raise NotImplementedError
+
+    def merge_mask(self, mask):
+        """ Return the mask in requested shape """
+        logger.info("mask_shape: %s", mask.shape)
+        assert self.channels in (1, 3, 4), "Channels should be 1, 3 or 4"
+        assert mask.shape[2] == 1 and mask.ndim == 3, "Input mask be 3 dimensions with 1 channel"
+
+        if self.channels == 3:
+            retval = np.tile(mask, 3)
+        elif self.channels == 4:
+            retval = np.concatenate((self.face, mask), -1)
+        else:
+            retval = mask
+
+        logger.info("Final mask shape: %s", retval.shape)
+        return retval
+
+
+class dfl_full(Mask):  # pylint: disable=invalid-name
+    """ DFL facial mask """
+    def build_mask(self):
+        mask = np.zeros(self.face.shape[0:2] + (1, ), dtype=np.float32)
+
+        nose_ridge = (self.landmarks[27:31], self.landmarks[33:34])
+        jaw = (self.landmarks[0:17],
+               self.landmarks[48:68],
+               self.landmarks[0:1],
+               self.landmarks[8:9],
+               self.landmarks[16:17])
+        eyes = (self.landmarks[17:27],
+                self.landmarks[0:1],
+                self.landmarks[27:28],
+                self.landmarks[16:17],
+                self.landmarks[33:34])
+        parts = [jaw, nose_ridge, eyes]
+
+        for item in parts:
+            merged = np.concatenate(item)
+            cv2.fillConvexPoly(mask, cv2.convexHull(merged), 255.)  # pylint: disable=no-member
+        return mask
+
+
+class components(Mask):  # pylint: disable=invalid-name
+    """ Component model mask """
+    def build_mask(self):
+        mask = np.zeros(self.face.shape[0:2] + (1, ), dtype=np.float32)
+
+        r_jaw = (self.landmarks[0:9], self.landmarks[17:18])
+        l_jaw = (self.landmarks[8:17], self.landmarks[26:27])
+        r_cheek = (self.landmarks[17:20], self.landmarks[8:9])
+        l_cheek = (self.landmarks[24:27], self.landmarks[8:9])
+        nose_ridge = (self.landmarks[19:25], self.landmarks[8:9],)
+        r_eye = (self.landmarks[17:22],
+                 self.landmarks[27:28],
+                 self.landmarks[31:36],
+                 self.landmarks[8:9])
+        l_eye = (self.landmarks[22:27],
+                 self.landmarks[27:28],
+                 self.landmarks[31:36],
+                 self.landmarks[8:9])
+        nose = (self.landmarks[27:31], self.landmarks[31:36])
+        parts = [r_jaw, l_jaw, r_cheek, l_cheek, nose_ridge, r_eye, l_eye, nose]
+
+        for item in parts:
+            merged = np.concatenate(item)
+            cv2.fillConvexPoly(mask, cv2.convexHull(merged), 255.)  # pylint: disable=no-member
+        return mask
+
+
+class extended(Mask):  # pylint: disable=invalid-name
+    """ Extended mask
+        Based on components mask. Attempts to extend the eyebrow points up the forehead
+    """
+    def build_mask(self):
+        mask = np.zeros(self.face.shape[0:2] + (1, ), dtype=np.float32)
+
+        landmarks = self.landmarks.copy()
+        # mid points between the side of face and eye point
+        ml_pnt = (landmarks[36] + landmarks[0]) // 2
+        mr_pnt = (landmarks[16] + landmarks[45]) // 2
+
+        # mid points between the mid points and eye
+        ql_pnt = (landmarks[36] + ml_pnt) // 2
+        qr_pnt = (landmarks[45] + mr_pnt) // 2
+
+        # Top of the eye arrays
+        bot_l = np.array((ql_pnt, landmarks[36], landmarks[37], landmarks[38], landmarks[39]))
+        bot_r = np.array((landmarks[42], landmarks[43], landmarks[44], landmarks[45], qr_pnt))
+
+        # Eyebrow arrays
+        top_l = landmarks[17:22]
+        top_r = landmarks[22:27]
+
+        # Adjust eyebrow arrays
+        landmarks[17:22] = top_l + ((top_l - bot_l) // 2)
+        landmarks[22:27] = top_r + ((top_r - bot_r) // 2)
+
+        r_jaw = (landmarks[0:9], landmarks[17:18])
+        l_jaw = (landmarks[8:17], landmarks[26:27])
+        r_cheek = (landmarks[17:20], landmarks[8:9])
+        l_cheek = (landmarks[24:27], landmarks[8:9])
+        nose_ridge = (landmarks[19:25], landmarks[8:9],)
+        r_eye = (landmarks[17:22], landmarks[27:28], landmarks[31:36], landmarks[8:9])
+        l_eye = (landmarks[22:27], landmarks[27:28], landmarks[31:36], landmarks[8:9])
+        nose = (landmarks[27:31], landmarks[31:36])
+        parts = [r_jaw, l_jaw, r_cheek, l_cheek, nose_ridge, r_eye, l_eye, nose]
+
+        for item in parts:
+            merged = np.concatenate(item)
+            cv2.fillConvexPoly(mask, cv2.convexHull(merged), 255.)  # pylint: disable=no-member
+        return mask
+
+
+class facehull(Mask):  # pylint: disable=invalid-name
+    """ Basic face hull mask """
+    def build_mask(self):
+        mask = np.zeros(self.face.shape[0:2] + (1, ), dtype=np.float32)
+        hull = cv2.convexHull(  # pylint: disable=no-member
+            np.array(self.landmarks).reshape((-1, 2)))
+        cv2.fillConvexPoly(mask, hull, 255.0, lineType=cv2.LINE_AA)  # pylint: disable=no-member
+        return mask

Scripts/ca_generator.py

@@ -0,0 +1,32 @@
+import albumentations as alb
+from albumentations.pytorch import ToTensorV2
+import cv2
+
+def get_augs(name):
+    IMG_SIZE = 380  
+    if name == "REAlbu":
+        return alb.Compose([
+            alb.HorizontalFlip(),
+            alb.CoarseDropout(max_holes = 1, min_height=int(IMG_SIZE*0.02), max_height=int(IMG_SIZE*0.2), min_width=int(IMG_SIZE*0.02), max_width=int(IMG_SIZE*0.2), p=1),
+        ])
+    elif name == "RandCropAlbu":
+        return alb.Compose([
+            alb.HorizontalFlip(),
+            alb.RandomResizedCrop(height = IMG_SIZE, width = IMG_SIZE, scale=(1/1.3, 1.0), ratio=(0.9,1.1)),
+        ])
+    elif name == "DFDCAlbu":
+        return alb.Compose([
+            alb.ImageCompression(quality_lower=60, quality_upper=100, p=0.5),
+            alb.GaussNoise(p=0.1),
+            alb.GaussianBlur(blur_limit=3, p=0.05),
+            alb.HorizontalFlip(),
+            alb.OneOf([
+                alb.LongestMaxSize(max_size=IMG_SIZE, interpolation=cv2.INTER_CUBIC),
+                alb.LongestMaxSize(max_size=IMG_SIZE, interpolation=cv2.INTER_AREA),
+                alb.LongestMaxSize(max_size=IMG_SIZE, interpolation=cv2.INTER_LINEAR)
+            ], p=1.0),
+            alb.PadIfNeeded(min_height=IMG_SIZE, min_width=IMG_SIZE, border_mode=cv2.BORDER_CONSTANT),
+            alb.OneOf([alb.RandomBrightnessContrast(), alb.FancyPCA(), alb.HueSaturationValue()], p=0.7),
+            alb.ToGray(p=0.2),
+            alb.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.2, rotate_limit=10, border_mode=cv2.BORDER_CONSTANT, p=0.5),
+        ])

Scripts/model.py

@@ -0,0 +1,34 @@
+import torch
+from torch import nn
+from efficientnet_pytorch import EfficientNet
+from pytorch_grad_cam import GradCAMElementWise
+from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
+
+
+class Detector(nn.Module):
+    def __init__(self):
+        super(Detector, self).__init__()
+        self.net=EfficientNet.from_pretrained("efficientnet-b4",advprop=True,num_classes=2)
+
+    def forward(self,x):
+        x=self.net(x)
+        return x
+    
+
+def create_model(path="Weights/94_0.9485_val.tar", device=torch.device('cpu')):
+    model=Detector()
+    model=model.to(device)
+    if device == torch.device('cpu'):
+        cnn_sd=torch.load(path, map_location=torch.device('cpu') )["model"]
+    else:
+        cnn_sd=torch.load(path)["model"]
+    model.load_state_dict(cnn_sd)
+    model.eval()
+    return model
+
+def create_cam(model):
+    target_layers = [model.net._blocks[-1]]
+    targets = [ClassifierOutputTarget(1)]
+    cam_algorithm = GradCAMElementWise
+    cam = cam_algorithm(model=model,target_layers=target_layers,use_cuda=False)
+    return cam

Scripts/preprocess.py

@@ -0,0 +1,149 @@
+import numpy as np
+import cv2
+from tqdm import tqdm
+
+def extract_frames(filename,num_frames,model,image_size=(380,380)):
+	cap_org = cv2.VideoCapture(filename)
+	
+	if not cap_org.isOpened():
+		print(f'Cannot open: {filename}')
+		# sys.exit()
+		return []
+	
+	croppedfaces=[]
+	idx_list=[]
+	frame_count_org = int(cap_org.get(cv2.CAP_PROP_FRAME_COUNT))
+	
+	frame_idxs = np.linspace(0, frame_count_org - 1, num_frames, endpoint=True, dtype=int)
+	for cnt_frame in range(frame_count_org): 
+		ret_org, frame_org = cap_org.read()
+		height,width=frame_org.shape[:-1]
+		if not ret_org:
+			tqdm.write('Frame read {} Error! : {}'.format(cnt_frame,os.path.basename(filename)))
+			break
+		
+		if cnt_frame not in frame_idxs:
+			continue
+
+		frame = cv2.cvtColor(frame_org, cv2.COLOR_BGR2RGB)
+		
+		faces = model.predict_jsons(frame)
+		try:
+			if len(faces)==0:
+				tqdm.write('No faces in {}:{}'.format(cnt_frame,os.path.basename(filename)))
+				continue
+
+			size_list=[]
+			croppedfaces_temp=[]
+			idx_list_temp=[]
+			
+			for face_idx in range(len(faces)):
+				x0,y0,x1,y1=faces[face_idx]['bbox']
+				bbox=np.array([[x0,y0],[x1,y1]])
+				croppedfaces_temp.append(cv2.resize(crop_face(frame,None,bbox,False,crop_by_bbox=True,only_img=True,phase='test'),dsize=image_size).transpose((2,0,1)))
+				idx_list_temp.append(cnt_frame)
+				size_list.append((x1-x0)*(y1-y0))
+			
+			max_size=max(size_list)
+			croppedfaces_temp=[f for face_idx,f in enumerate(croppedfaces_temp) if size_list[face_idx]>=max_size/2]
+			idx_list_temp=[f for face_idx,f in enumerate(idx_list_temp) if size_list[face_idx]>=max_size/2]
+			croppedfaces+=croppedfaces_temp
+			idx_list+=idx_list_temp	
+		except Exception as e:
+			print(f'error in {cnt_frame}:{filename}')
+			print(e)
+			continue
+	cap_org.release()
+
+	
+
+	return croppedfaces,idx_list
+
+def extract_face(frame,model,image_size=(380,380)):
+	
+	
+	faces = model.predict_jsons(frame)
+
+	if len(faces[0]['bbox'])==0:
+		return []
+	croppedfaces=[]
+	for face_idx in range(len(faces)):
+		x0,y0,x1,y1=faces[face_idx]['bbox']
+		bbox=np.array([[x0,y0],[x1,y1]])
+		croppedfaces.append(cv2.resize(crop_face(frame,None,bbox,False,crop_by_bbox=True,only_img=True,phase='test'),dsize=image_size).transpose((2,0,1)))
+	
+	return croppedfaces
+
+
+def crop_face(img,landmark=None,bbox=None,margin=False,crop_by_bbox=True,abs_coord=False,only_img=False,phase='train'):
+	assert phase in ['train','val','test']
+
+	#crop face------------------------------------------
+	H,W=len(img),len(img[0])
+
+	assert landmark is not None or bbox is not None
+
+	H,W=len(img),len(img[0])
+	
+	if crop_by_bbox:
+		x0,y0=bbox[0]
+		x1,y1=bbox[1]
+		w=x1-x0
+		h=y1-y0
+		w0_margin=w/4#0#np.random.rand()*(w/8)
+		w1_margin=w/4
+		h0_margin=h/4#0#np.random.rand()*(h/5)
+		h1_margin=h/4
+	else:
+		x0,y0=landmark[:68,0].min(),landmark[:68,1].min()
+		x1,y1=landmark[:68,0].max(),landmark[:68,1].max()
+		w=x1-x0
+		h=y1-y0
+		w0_margin=w/8#0#np.random.rand()*(w/8)
+		w1_margin=w/8
+		h0_margin=h/2#0#np.random.rand()*(h/5)
+		h1_margin=h/5
+
+	
+
+	if margin:
+		w0_margin*=4
+		w1_margin*=4
+		h0_margin*=2
+		h1_margin*=2
+	elif phase=='train':
+		w0_margin*=(np.random.rand()*0.6+0.2)#np.random.rand()
+		w1_margin*=(np.random.rand()*0.6+0.2)#np.random.rand()
+		h0_margin*=(np.random.rand()*0.6+0.2)#np.random.rand()
+		h1_margin*=(np.random.rand()*0.6+0.2)#np.random.rand()	
+	else:
+		w0_margin*=0.5
+		w1_margin*=0.5
+		h0_margin*=0.5
+		h1_margin*=0.5
+			
+	y0_new=max(0,int(y0-h0_margin))
+	y1_new=min(H,int(y1+h1_margin)+1)
+	x0_new=max(0,int(x0-w0_margin))
+	x1_new=min(W,int(x1+w1_margin)+1)
+	
+	img_cropped=img[y0_new:y1_new,x0_new:x1_new]
+	if landmark is not None:
+		landmark_cropped=np.zeros_like(landmark)
+		for i,(p,q) in enumerate(landmark):
+			landmark_cropped[i]=[p-x0_new,q-y0_new]
+	else:
+		landmark_cropped=None
+	if bbox is not None:
+		bbox_cropped=np.zeros_like(bbox)
+		for i,(p,q) in enumerate(bbox):
+			bbox_cropped[i]=[p-x0_new,q-y0_new]
+	else:
+		bbox_cropped=None
+
+	if only_img:
+		return img_cropped
+	if abs_coord:
+		return img_cropped,landmark_cropped,bbox_cropped,(y0-y0_new,x0-x0_new,y1_new-y1,x1_new-x1),y0_new,y1_new,x0_new,x1_new
+	else:
+		return img_cropped,landmark_cropped,bbox_cropped,(y0-y0_new,x0-x0_new,y1_new-y1,x1_new-x1)

Weights/FFc23.tar

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

Weights/shape_predictor_81_face_landmarks.dat

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

Weights/weights.tar

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

app.py

@@ -0,0 +1,189 @@
+import gradio as gr
+import warnings
+import cv2
+import dlib
+from pytorch_grad_cam.utils.image import show_cam_on_image
+from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
+import numpy as np
+import torch
+from retinaface.pre_trained_models import get_model
+
+from Scripts.model import create_cam, create_model
+from Scripts.preprocess import crop_face, extract_face, extract_frames
+from Scripts.ca_generator import get_augs
+
+warnings.filterwarnings('ignore')
+
+
+
+device = torch.device('cpu')
+
+sbcl = create_model("Weights/weights.tar")
+
+
+face_detector = get_model("resnet50_2020-07-20", max_size=1024, device=device)
+face_detector.eval()
+
+cam_sbcl = create_cam(sbcl)
+targets = [ClassifierOutputTarget(1)]
+
+# Examples
+examples = ["Examples/Fake/Fake1.PNG", "Examples/Real/Real1.PNG", "Examples/Real/Real2.PNG", "Examples/Fake/Fake3.PNG",
+            "Examples/Fake/Fake2.PNG", ]
+examples_videos = ['Examples/Fake1.mp4', 'Examples/Real1.mp4']
+
+# dlib Models
+dlib_face_detector = dlib.get_frontal_face_detector()
+dlib_face_predictor = dlib.shape_predictor(
+    'Weights/shape_predictor_81_face_landmarks.dat')
+
+
+def predict_image(inp):
+    
+    face_list = extract_face(inp, face_detector)
+
+    if len(face_list) == 0:
+        return {'No face detected!': 1}, None
+
+    with torch.no_grad():
+        img = torch.tensor(face_list).to(device).float()/255
+        pred = sbcl(img).softmax(1)[:, 1].cpu().data.numpy().tolist()[0]
+        confidences = {'Real': 1-pred, 'Fake': pred}
+
+    grayscale_cam = cam_sbcl(input_tensor=img, targets=targets, aug_smooth=True)
+    grayscale_cam = grayscale_cam[0, :]
+    cam_image = show_cam_on_image(face_list[0].transpose(1, 2, 0)/255, grayscale_cam, use_rgb=True)
+
+    return confidences, cam_image
+
+
+def predict_video(inp):
+    
+    face_list, idx_list = extract_frames(inp, 10, face_detector)
+
+    with torch.no_grad():
+        img = torch.tensor(face_list).to(device).float()/255
+        pred = sbcl(img).softmax(1)[:, 1]
+
+    pred_list = []
+    idx_img = -1
+    for i in range(len(pred)):
+        if idx_list[i] != idx_img:
+            pred_list.append([])
+            idx_img = idx_list[i]
+        pred_list[-1].append(pred[i].item())
+    pred_res = np.zeros(len(pred_list))
+    for i in range(len(pred_res)):
+        pred_res[i] = max(pred_list[i])
+    pred = pred_res.mean()
+
+    most_fake = np.argmax(pred_res)
+    grayscale_cam = cam_sbcl(input_tensor=img[most_fake].unsqueeze(0), targets=targets, aug_smooth=True)
+    grayscale_cam = grayscale_cam[0, :]
+    cam_image = show_cam_on_image(face_list[most_fake].transpose(1, 2, 0)/255, grayscale_cam, use_rgb=True)
+
+    return {'Real': 1-pred, 'Fake': pred}, cam_image
+
+
+
+with gr.Blocks(title="Deepfake Detection CL", theme='upsatwal/mlsc_tiet', css="""
+    @import url('https://fonts.googleapis.com/css?family=Source+Code+Pro:200');
+    #custom_header {
+        min-height: 3rem;
+        background-image: url('https://static.pexels.com/photos/414171/pexels-photo-414171.jpeg');
+        background-size: cover;
+        background-position: top;
+        color: white;
+        text-align: center;
+        padding: 0.5rem;
+        font-family: 'Source Code Pro', monospace;
+        text-transform: uppercase;
+    }
+    #custom_header:hover {
+        -webkit-animation: slidein 10s;
+        animation: slidein 10s;
+        -webkit-animation-fill-mode: forwards;
+        animation-fill-mode: forwards;
+        -webkit-animation-iteration-count: infinite;
+        animation-iteration-count: infinite;
+        -webkit-animation-direction: alternate;
+        animation-direction: alternate;
+    }
+    @-webkit-keyframes slidein {
+        from {
+            background-position: top;
+            background-size: 3000px;
+        }
+        to {
+            background-position: -100px 0px;
+            background-size: 2750px;
+        }
+    }
+    @keyframes slidein {
+        from {
+            background-position: top;
+            background-size: 3000px;
+        }
+        to {
+            background-position: -100px 0px;
+            background-size: 2750px;
+        }
+    }
+    #custom_title {
+        min-height: 3rem;
+        text-align: center;
+    }
+    .full-width {
+        width: 100%;
+    }
+    .full-width:hover {
+        background: rgba(75, 75, 250, 0.3);
+        color: white;
+    }
+""") as demo:
+
+    with gr.Tab("Image"):
+        with gr.Row():
+            with gr.Column():
+                with gr.Group():
+                    gr.Markdown("## Deepfake Detection", elem_id="custom_header")
+                    input_image = gr.Image(label="Input Image", height=240)
+                    btn = gr.Button(value="Submit", variant="primary", elem_classes="full-width")
+            with gr.Column():
+                with gr.Group():
+                    gr.Markdown("## Result", elem_id="custom_header")
+                    output_image = gr.Image(label="GradCAM Image", height=240)
+                    label_probs = gr.Label()
+        gr.Examples(
+            examples=examples,
+            inputs=input_image,
+            outputs=output_image,
+            fn=predict_image,
+            cache_examples=False,
+        )
+        btn.click(predict_image, inputs=input_image, outputs=[label_probs, output_image], api_name="/predict_image")
+
+    with gr.Tab("Video"):
+        with gr.Row():
+            with gr.Column():
+                with gr.Group():
+                    gr.Markdown("## Deepfake Detection", elem_id="custom_header")
+                    input_video = gr.Video(label="Input Video", height=240)
+                    btn_video = gr.Button(value="Submit", variant="primary", elem_classes="full-width")
+
+            with gr.Column():
+                with gr.Group():
+                    gr.Markdown("## Result", elem_id="custom_header")
+                    output_image_video = gr.Image(label="GradCAM", height=240)
+                    label_probs_video = gr.Label()
+        gr.Examples(
+            examples=examples_videos,
+            inputs=input_video,
+            outputs=output_image_video,
+            fn=predict_video,
+            cache_examples=False,
+        )
+        btn_video.click(predict_video, inputs=input_video, outputs=[label_probs_video, output_image_video], api_name="/predict_video")
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,10 @@
+dlib
+retinaface_pytorch
+imutils
+numpy
+grad-cam==1.4.8
+gradio 
+opencv-python
+efficientnet_pytorch
+httpx 
+ffmpeg