Upload app (1).py

app (1).py

@@ -0,0 +1,206 @@
+import gradio as gr
+from PIL import Image
+import numpy as np
+import os
+from face_cropper import detect_and_label_faces
+# Define a custom function to convert an image to grayscale
+def to_grayscale(input_image):
+    grayscale_image = Image.fromarray(np.array(input_image).mean(axis=-1).astype(np.uint8))
+    return grayscale_image
+
+
+description_markdown = """
+# Fake Face Detection tool from TrustWorthy BiometraVision Lab IISER Bhopal
+
+## Usage
+This tool expects a face image as input. Upon submission, it will process the image and provide an output with bounding boxes drawn on the face. Alongside the visual markers, the tool will give a detection result indicating whether the face is fake or real.
+
+## Disclaimer
+Please note that this tool is for research purposes only and may not always be 100% accurate. Users are advised to exercise discretion and supervise the tool's usage accordingly.
+
+## Licensing and Permissions
+This tool has been developed solely for research and demonstrative purposes. Any commercial utilization of this tool is strictly prohibited unless explicit permission has been obtained from the developers.
+
+## Developer Contact
+For further inquiries or permissions, you can reach out to the developer through the following social media accounts:
+- [LAB Webpage](https://sites.google.com/iiitd.ac.in/agarwalakshay/labiiserb?authuser=0)
+- [LinkedIn](https://www.linkedin.com/in/shivam-shukla-0a50ab1a2/)
+- [GitHub](https://github.com/SaShukla090)
+"""
+
+
+
+
+# Create the Gradio app
+app = gr.Interface(
+    fn=detect_and_label_faces,
+    inputs=gr.Image(type="pil"),
+    outputs="image",
+    # examples=[
+    #     "path_to_example_image_1.jpg",
+    #     "path_to_example_image_2.jpg"
+    # ]
+    examples=[
+        os.path.join("Examples", image_name) for image_name in os.listdir("Examples")
+    ],
+    title="Fake Face Detection",
+    description=description_markdown,
+)
+
+# Run the app
+app.launch()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# import torch.nn.functional as F
+# import torch
+# import torch.nn as nn
+# import torch.optim as optim
+# from torch.utils.data import DataLoader
+# from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+# from torch.optim.lr_scheduler import CosineAnnealingLR
+# from tqdm import tqdm
+# import warnings
+# warnings.filterwarnings("ignore")
+
+# from utils.config import cfg
+# from dataset.real_n_fake_dataloader import Extracted_Frames_Dataset
+# from utils.data_transforms import get_transforms_train, get_transforms_val
+# from net.Multimodalmodel import Image_n_DCT
+# import gradio as gr
+
+
+
+
+# import os
+# import json
+# import torch
+# from torchvision import transforms
+# from torch.utils.data import DataLoader, Dataset
+# from PIL import Image
+# import numpy as np
+# import pandas as pd
+# import cv2
+# import argparse
+
+
+
+
+
+
+# from sklearn.metrics import classification_report, confusion_matrix
+# import matplotlib.pyplot as plt
+# import seaborn as sns
+
+
+
+    
+
+# class Test_Dataset(Dataset):
+#     def __init__(self, test_data_path = None, transform = None, image = None):
+#         """
+#         Args:   
+#         returns:
+#             """
+        
+#         if test_data_path is None and image is not None:
+#             self.dataset = [(image, 2)]
+#             self.transform = transform
+
+#     def __len__(self):
+#         return len(self.dataset)
+
+#     def __getitem__(self, idx):
+#         sample_input = self.get_sample_input(idx)
+#         return sample_input
+    
+
+#     def get_sample_input(self, idx):
+#         rgb_image = self.get_rgb_image(self.dataset[idx][0])
+#         dct_image = self.compute_dct_color(self.dataset[idx][0])
+#         # label = self.get_label(idx)
+#         sample_input = {"rgb_image": rgb_image, "dct_image": dct_image}
+
+#         return sample_input
+    
+
+#     def get_rgb_image(self, rgb_image):
+#         # rgb_image_path = self.dataset[idx][0]
+#         # rgb_image = Image.open(rgb_image_path)
+#         if self.transform:
+#             rgb_image = self.transform(rgb_image)
+#         return rgb_image
+    
+#     def get_dct_image(self, idx):
+#         rgb_image_path = self.dataset[idx][0]
+#         rgb_image = cv2.imread(rgb_image_path)
+#         dct_image = self.compute_dct_color(rgb_image)
+#         if self.transform:
+#             dct_image = self.transform(dct_image)
+        
+#         return dct_image
+    
+#     def get_label(self, idx):
+#         return self.dataset[idx][1]
+    
+
+#     def compute_dct_color(self, image):
+#         image_float = np.float32(image)
+#         dct_image = np.zeros_like(image_float)
+#         for i in range(3):  
+#             dct_image[:, :, i] = cv2.dct(image_float[:, :, i])
+#         if self.transform:
+#             dct_image = self.transform(dct_image)
+#         return dct_image
+    
+
+# device = torch.device("cpu")
+# # print(device)
+# model = Image_n_DCT()
+# model.load_state_dict(torch.load('weights/best_model.pth', map_location = device))
+# model.to(device)
+# model.eval()
+
+
+# def classify(image):
+#     test_dataset = Test_Dataset(transform = get_transforms_val(), image = image)
+#     inputs = test_dataset[0]
+#     rgb_image, dct_image = inputs['rgb_image'].to(device), inputs['dct_image'].to(device)
+#     output = model(rgb_image.unsqueeze(0), dct_image.unsqueeze(0))
+#     # _, predicted = torch.max(output.data, 1)
+#     # print(f"the face is {'real' if predicted==1 else 'fake'}")
+#     return {'Fake': output[0][0], 'Real': output[0][1]}
+
+# iface = gr.Interface(fn=classify, inputs="image", outputs="label")
+# if __name__ == "__main__":
+#     iface.launch()