Upload 4 files

app.py

@@ -0,0 +1,155 @@
+import streamlit as st
+import torch
+import torchvision
+from torchvision import transforms, models
+from torch.utils.data import DataLoader
+from torch.utils.data.dataset import Dataset
+import numpy as np
+import cv2
+import face_recognition
+from torch.autograd import Variable
+import time
+import sys
+from torch import nn
+import json
+import glob
+import copy
+from PIL import Image as pImage
+import shutil
+import os
+
+im_size = 112
+mean=[0.485, 0.456, 0.406]
+std=[0.229, 0.224, 0.225]
+sm = nn.Softmax()
+inv_normalize = transforms.Normalize(mean=-1*np.divide(mean,std),std=np.divide([1,1,1],std))
+
+train_transforms = transforms.Compose([
+    transforms.ToPILImage(),
+    transforms.Resize((im_size,im_size)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean,std)])
+
+class Model(nn.Module):
+    def __init__(self, num_classes,latent_dim= 2048, lstm_layers=1 , hidden_dim = 2048, bidirectional = False):
+        super(Model, self).__init__()
+        model = models.resnext50_32x4d(pretrained=True)
+        self.model = nn.Sequential(*list(model.children())[:-2])
+        self.lstm = nn.LSTM(latent_dim,hidden_dim, lstm_layers,  bidirectional)
+        self.relu = nn.LeakyReLU()
+        self.dp = nn.Dropout(0.4)
+        self.linear1 = nn.Linear(2048,num_classes)
+        self.avgpool = nn.AdaptiveAvgPool2d(1)
+
+    def forward(self, x):
+        batch_size,seq_length, c, h, w = x.shape
+        x = x.view(batch_size * seq_length, c, h, w)
+        fmap = self.model(x)
+        x = self.avgpool(fmap)
+        x = x.view(batch_size,seq_length,2048)
+        x_lstm,_ = self.lstm(x,None)
+        return fmap,self.dp(self.linear1(x_lstm[:,-1,:]))
+
+class validation_dataset(Dataset):
+    def __init__(self,video_names,sequence_length=60,transform=None):
+        self.video_names = video_names
+        self.transform = transform
+        self.count = sequence_length
+
+    def __len__(self):
+        return len(self.video_names)
+
+    def __getitem__(self,idx):
+        video_path = self.video_names[idx]
+        frames = []
+        a = int(100/self.count)
+        first_frame = np.random.randint(0,a)
+        for i,frame in enumerate(self.frame_extract(video_path)):
+            faces = face_recognition.face_locations(frame)
+            try:
+                top,right,bottom,left = faces[0]
+                frame = frame[top:bottom,left:right,:]
+            except:
+                pass
+            frames.append(self.transform(frame))
+            if(len(frames) == self.count):
+                break
+        frames = torch.stack(frames)
+        frames = frames[:self.count]
+        return frames.unsqueeze(0)
+    
+    def frame_extract(self,path):
+        vidObj = cv2.VideoCapture(path) 
+        success = 1
+        while success:
+            success, image = vidObj.read()
+            if success:
+                yield image
+
+def im_convert(tensor):
+    image = tensor.to("cpu").clone().detach()
+    image = image.squeeze()
+    image = inv_normalize(image)
+    image = image.numpy()
+    image = image.transpose(1,2,0)
+    image = image.clip(0, 1)
+    return image
+
+def predict(model,img):
+    fmap,logits = model(img.to('cuda'))
+    logits = sm(logits)
+    _,prediction = torch.max(logits,1)
+    confidence = logits[:,int(prediction.item())].item()*100
+    return [int(prediction.item()), confidence]
+
+def save_uploaded_file(uploaded_file, save_dir):
+    if not os.path.exists(save_dir):
+        os.makedirs(save_dir)
+    file_path = os.path.join(save_dir, uploaded_file.name)
+    with open(file_path, "wb") as f:
+        f.write(uploaded_file.getbuffer())
+    return file_path
+
+def index():
+    st.title("Fake Video Detection")
+    uploaded_file = st.file_uploader("Upload a video", type=["mp4", "gif", "webm", "avi", "3gp", "wmv", "flv", "mkv"])
+    if uploaded_file is not None:
+        sequence_length = st.number_input("Enter sequence length", min_value=1, value=60)
+        model = Model(2).cuda()
+        st.write("Model loaded successfully.")
+        st.write("Starting prediction...")
+        
+        # Save the uploaded file to disk
+        video_path = save_uploaded_file(uploaded_file, "uploaded_videos")
+        
+        video_dataset = validation_dataset([video_path], sequence_length=sequence_length, transform=train_transforms)
+        #model_name = get_accurate_model(sequence_length)
+        path_to_model = "/content/drive/MyDrive/DeepFake/best_model_accuracy.pt"
+        model.load_state_dict(torch.load(path_to_model))
+        model.eval()
+        prediction = predict(model, video_dataset[0])
+        st.write("Prediction:", "REAL" if prediction[0] == 1 else "FAKE")
+        st.write("Confidence:", round(prediction[1], 2))
+
+if __name__ == "__main__":
+    index()
+
+# def index():
+#     st.title("Fake Video Detection")
+#     uploaded_file = st.file_uploader("Upload a video", type=["mp4", "gif", "webm", "avi", "3gp", "wmv", "flv", "mkv"])
+#     if uploaded_file is not None:
+#         sequence_length = st.number_input("Enter sequence length", min_value=1, value=60)
+#         model = Model(2).cuda()
+#         st.write("Model loaded successfully.")
+#         st.write("Starting prediction...")
+#         video_dataset = validation_dataset([uploaded_file], sequence_length=sequence_length, transform=train_transforms)
+#         # model_name = get_accurate_model(sequence_length)
+#         path_to_model = "/content/drive/MyDrive/DeepFake/best_model_accuracy.pt"   #os.path.join('models', model_name)
+#         model.load_state_dict(torch.load(path_to_model))
+#         model.eval()
+#         prediction = predict(model, video_dataset[0])
+#         st.write("Prediction:", "REAL" if prediction[0] == 1 else "FAKE")
+#         st.write("Confidence:", round(prediction[1], 2))
+
+# if __name__ == "__main__":
+#     index()

best_model_accuracy.pt

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

model.py

@@ -0,0 +1,83 @@
+
+import warnings
+warnings.filterwarnings('ignore')
+import torch
+from torch import nn
+from torch.autograd import Variable
+import torchvision
+from torchvision import models
+from torchvision import transforms
+from torch.utils.data import DataLoader
+from torch.utils.data.dataset import Dataset
+import os
+import sys
+import time
+import pandas as pd
+import numpy as np
+import cv2
+import matplotlib.pyplot as plt
+import face_recognition
+
+
+#Model with feature visualization
+class Model(nn.Module):
+    def __init__(self, num_classes=2,latent_dim= 2048, lstm_layers=1 , hidden_dim = 2048, bidirectional = False):
+        super(Model, self).__init__()
+        model = models.resnext50_32x4d(pretrained = True) #Residual Network CNN
+        self.model = nn.Sequential(*list(model.children())[:-2])
+        self.lstm = nn.LSTM(latent_dim,hidden_dim, lstm_layers,  bidirectional)
+        self.relu = nn.LeakyReLU()
+        self.dp = nn.Dropout(0.4)
+        self.linear1 = nn.Linear(2048,num_classes)
+        self.avgpool = nn.AdaptiveAvgPool2d(1)
+    def forward(self, x):
+        batch_size,seq_length, c, h, w = x.shape
+        x = x.view(batch_size * seq_length, c, h, w)
+        fmap = self.model(x)
+        x = self.avgpool(fmap)
+        x = x.view(batch_size,seq_length,2048)
+        x_lstm,_ = self.lstm(x,None)
+        return fmap,self.dp(self.linear1(torch.mean(x_lstm,dim = 1)))
+
+im_size = 112
+mean=[0.485, 0.456, 0.406]
+std=[0.229, 0.224, 0.225]
+sm = nn.Softmax()
+inv_normalize =  transforms.Normalize(mean=-1*np.divide(mean,std),std=np.divide([1,1,1],std))
+def im_convert(tensor):
+    """ Display a tensor as an image. """
+    image = tensor.to("cpu").clone().detach()
+    image = image.squeeze()
+    image = inv_normalize(image)
+    image = image.numpy()
+    image = image.transpose(1,2,0)
+    image = image.clip(0, 1)
+    cv2.imwrite('./2.png',image*255)
+    return image
+
+def predict(model,img,path = './'):
+  fmap,logits = model(img.to('cuda'))
+  params = list(model.parameters())
+  weight_softmax = model.linear1.weight.detach().cpu().numpy()
+  logits = sm(logits)
+  _,prediction = torch.max(logits,1)
+  confidence = logits[:,int(prediction.item())].item()*100
+  print('confidence of prediction:',logits[:,int(prediction.item())].item()*100)
+  idx = np.argmax(logits.detach().cpu().numpy())
+  bz, nc, h, w = fmap.shape
+  out = np.dot(fmap[-1].detach().cpu().numpy().reshape((nc, h*w)).T,weight_softmax[idx,:].T)
+  predict = out.reshape(h,w)
+  predict = predict - np.min(predict)
+  predict_img = predict / np.max(predict)
+  predict_img = np.uint8(255*predict_img)
+  out = cv2.resize(predict_img, (im_size,im_size))
+  heatmap = cv2.applyColorMap(out, cv2.COLORMAP_JET)
+  img = im_convert(img[:,-1,:,:,:])
+  result = heatmap * 0.5 + img*0.8*255
+  cv2.imwrite('/content/drive/MyDrive/DeepFake/FF++/HeatMaps/3.png',result)
+  result1 = heatmap * 0.5/255 + img*0.8
+  r,g,b = cv2.split(result1)
+  result1 = cv2.merge((r,g,b))
+  plt.imshow(result1)
+  plt.show()
+  return [int(prediction.item()),confidence]

requirements.txt

@@ -0,0 +1,13 @@
+glob
+pandas
+numpy
+os
+torch
+torchvision
+face-recognition
+cv2
+matplotlib
+random
+sklearn
+scikit-learn
+seaborn