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