update app.py for dowload from HF

README.md

@@ -0,0 +1,12 @@
+---
+title: DeepFake Videos Detection
+emoji: 😻
+colorFrom: red
+colorTo: green
+sdk: gradio
+sdk_version: 5.9.1
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -8,6 +8,7 @@ from tqdm import tqdm
 from training.detectors import DETECTOR
 import yaml
 import gradio as gr
+from huggingface_hub import hf_hub_download
 
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
@@ -17,7 +18,7 @@ AVAILABLE_MODELS = [
     "ucf",
 ]
 
-# load the model
+# load the model from HF Model Registry
 def load_model(model_name, config_path, weights_path):
     with open(config_path, 'r') as f:
         config = yaml.safe_load(f)
@@ -55,9 +56,8 @@ def preprocess_video(video_path, output_dir, frame_num=32):
     cap.release()
     return frames
 
-#  inference on a single video
+# inference on a single video
 def infer_video(video_path, model, device):
-    # Preprocess the video
     output_dir = "temp_video_frames"
     frames = preprocess_video(video_path, output_dir)
     
@@ -90,18 +90,21 @@ def infer_video(video_path, model, device):
     prediction = "Fake" if avg_prob > 0.5 else "Real"
     return prediction, avg_prob
 
-# gradio inference function
+# Gradio inference function
 def gradio_inference(video, model_name):
-    config_path = f"/teamspace/studios/this_studio/DeepfakeBench/training/config/detector/{model_name}.yaml"
-    weights_path = f"/teamspace/studios/this_studio/DeepfakeBench/training/weights/{model_name}_best.pth"
+    # Download config and weights from Hugging Face Model Registry
+    repo_id = "ArissBandoss/deepfake-video-classifier"
+    config_filename = f"{model_name}.yaml"
+    weights_filename = f"{model_name}_best.pth"
     
-    if not os.path.exists(config_path):
-        return f"Error: Config file for model '{model_name}' not found at {config_path}."
-    if not os.path.exists(weights_path):
-        return f"Error: Weights file for model '{model_name}' not found at {weights_path}."
+    # Download files
+    config_path = hf_hub_download(repo_id=repo_id, filename=config_filename)
+    weights_path = hf_hub_download(repo_id=repo_id, filename=weights_filename)
     
+    # Load the model
     model = load_model(model_name, config_path, weights_path)
     
+    # Run inference
     prediction, confidence = infer_video(video, model, device)
     return f"Model: {model_name}\nPrediction: {prediction} (Confidence: {confidence:.4f})"
 

app_local.py

@@ -0,0 +1,132 @@
+import os
+import cv2
+import torch
+import numpy as np
+from torchvision import transforms
+from PIL import Image
+from tqdm import tqdm
+from training.detectors import DETECTOR
+import yaml
+import gradio as gr
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# available models in the repository
+AVAILABLE_MODELS = [
+    "xception",
+    "ucf",
+]
+
+# load the model
+def load_model(model_name, config_path, weights_path):
+    with open(config_path, 'r') as f:
+        config = yaml.safe_load(f)
+    
+    config['model_name'] = model_name
+    
+    model_class = DETECTOR[model_name]
+    model = model_class(config).to(device)
+    
+    checkpoint = torch.load(weights_path, map_location=device)
+    model.load_state_dict(checkpoint, strict=True)
+    model.eval()
+    return model
+
+# preprocess a single video
+def preprocess_video(video_path, output_dir, frame_num=32):
+    os.makedirs(output_dir, exist_ok=True)
+    frames_dir = os.path.join(output_dir, "frames")
+    os.makedirs(frames_dir, exist_ok=True)
+    
+    cap = cv2.VideoCapture(video_path)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    frame_indices = np.linspace(0, total_frames - 1, frame_num, dtype=int)
+    
+    # extract frames
+    frames = []
+    for idx in frame_indices:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
+        ret, frame = cap.read()
+        if ret:
+            frame_path = os.path.join(frames_dir, f"frame_{idx:04d}.png")
+            cv2.imwrite(frame_path, frame)
+            frames.append(frame_path)
+    
+    cap.release()
+    return frames
+
+#  inference on a single video
+def infer_video(video_path, model, device):
+    # Preprocess the video
+    output_dir = "temp_video_frames"
+    frames = preprocess_video(video_path, output_dir)
+    
+    transform = transforms.Compose([
+        transforms.Resize((256, 256)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+    ])
+    
+    probs = []
+    for frame_path in frames:
+        frame = Image.open(frame_path).convert("RGB")
+        frame = transform(frame).unsqueeze(0).to(device)
+        
+        data_dict = {
+            "image": frame,
+            "label": torch.tensor([0]).to(device),  # Dummy label
+            "label_spe": torch.tensor([0]).to(device),  # Dummy specific label
+        }
+        
+        with torch.no_grad():
+            pred_dict = model(data_dict, inference=True)
+            
+            logits = pred_dict["cls"]  # Shape: [batch_size, num_classes]
+            prob = torch.softmax(logits, dim=1)[:, 1].item()  # Probability of being "fake"
+            probs.append(prob)
+    
+    # aggregate predictions (e.g., average probability)
+    avg_prob = np.mean(probs)
+    prediction = "Fake" if avg_prob > 0.5 else "Real"
+    return prediction, avg_prob
+
+# gradio inference function
+def gradio_inference(video, model_name):
+    config_path = f"/teamspace/studios/this_studio/DeepfakeBench/training/config/detector/{model_name}.yaml"
+    weights_path = f"/teamspace/studios/this_studio/DeepfakeBench/training/weights/{model_name}_best.pth"
+    
+    if not os.path.exists(config_path):
+        return f"Error: Config file for model '{model_name}' not found at {config_path}."
+    if not os.path.exists(weights_path):
+        return f"Error: Weights file for model '{model_name}' not found at {weights_path}."
+    
+    model = load_model(model_name, config_path, weights_path)
+    
+    prediction, confidence = infer_video(video, model, device)
+    return f"Model: {model_name}\nPrediction: {prediction} (Confidence: {confidence:.4f})"
+
+# Gradio App
+def create_gradio_app():
+    with gr.Blocks() as demo:
+        gr.Markdown("# Deepfake Detection Demo")
+        gr.Markdown("Upload a video and select a model to detect if it's real or fake.")
+        
+        with gr.Row():
+            video_input = gr.Video(label="Upload Video")
+            model_dropdown = gr.Dropdown(choices=AVAILABLE_MODELS, label="Select Model", value="xception")
+        
+        output_text = gr.Textbox(label="Prediction Result")
+        
+        submit_button = gr.Button("Run Inference")
+        submit_button.click(
+            fn=gradio_inference,
+            inputs=[video_input, model_dropdown],
+            outputs=output_text,
+        )
+    
+    return demo
+
+
+if __name__ == "__main__":
+    demo = create_gradio_app()
+    demo.launch(share=True)

requirements.txt

@@ -1,33 +1,16 @@
+huggingface_hub
 numpy==1.21.5
-pandas==1.4.2
 Pillow==9.0.1
-dlib==19.24.0
-imageio==2.9.0
-imgaug==0.4.0
+opencv-python==4.6.0.66
 tqdm==4.61.0
-scipy==1.7.3
-seaborn==0.11.2
 pyyaml==6.0
-imutils==0.5.4
-opencv-python==4.6.0.66
+scipy==1.7.3
 scikit-image==0.19.2
 scikit-learn==1.0.2
 albumentations==1.1.0
 torch==1.12.0
 torchvision==0.13.0
-torchaudio==0.12.0
 efficientnet-pytorch==0.7.1
 timm==0.6.12
-segmentation-models-pytorch==0.3.2
-torchtoolbox==0.1.8.2
-tensorboard==2.10.1
-setuptools==59.5.0
-loralib
-einops
 transformers
-filterpy
-simplejson
-kornia
-fvcore
-imgaug==0.4.0
-git+https://github.com/openai/CLIP.git
+gradio