Spaces:
Runtime error
Runtime error
| 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 made by Jaspreet Kaur , Harmanjot Kaur and Jasmine Kaur | |
| ## 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. | |
| ## Developer Contact | |
| For further inquiries or permissions, you can reach out to the developer through the following social media accounts: | |
| - [LinkedIn](http://www.linkedin.com/in/jaspreet-kaur-4884a6292) | |
| - [GitHub](https://github.com/Jassk28) | |
| """ | |
| # 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() | |