Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.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
-*.xz 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
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.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
+*.xz 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

README.md

@@ -1,3 +1,71 @@
 ---
+language: en
 license: mit
+tags:
+  - deepfake
+  - video-classification
+  - pytorch
+  - computer-vision
+datasets:
+  - custom
+pipeline_tag: video-classification
+widget:
+  - example_title: Deepfake Detection
+    example_input: "Upload a video to detect if it's real or fake"
 ---
+
+# DeepFake Detection Model
+
+This model detects deepfake videos using a combination of ResNext50 and LSTM architecture. It analyzes video frames to determine if a video is authentic or manipulated.
+
+## Model Details
+
+- **Model Type:** Video Classification
+- **Task:** Deepfake Detection
+- **Framework:** PyTorch
+- **Training Data:** Deepfake video datasets
+- **Accuracy:** 87% on test datasets
+- **Output:** Binary classification (real/fake) with confidence score
+
+## Usage
+
+```python
+from transformers import pipeline
+
+# Load the model
+detector = pipeline("video-classification", model="tayyabimam/Deepfake")
+
+# Analyze a video
+result = detector("path/to/video.mp4")
+print(result)
+```
+
+## API Usage
+
+You can also use this model through the Hugging Face Inference API:
+
+```python
+import requests
+
+API_URL = "https://api-inference.huggingface.co/models/tayyabimam/Deepfake"
+headers = {"Authorization": "Bearer YOUR_API_TOKEN"}
+
+def query(video_path):
+    with open(video_path, "rb") as f:
+        data = f.read()
+    response = requests.post(API_URL, headers=headers, data=data)
+    return response.json()
+
+result = query("path/to/video.mp4")
+print(result)
+```
+
+## Model Architecture
+
+The model uses a ResNext50 backbone to extract features from video frames, followed by an LSTM to capture temporal relationships between frames. This architecture is particularly effective for detecting manipulation artifacts that appear across multiple frames in deepfake videos.
+
+## Limitations
+
+- The model works best with videos that include human faces
+- Performance may vary with different video qualities and resolutions
+- The model is designed for 20-frame sequences for optimal performance

config.json

@@ -0,0 +1,21 @@
+{
+  "architectures": [
+    "DeepFakeDetector"
+  ],
+  "model_type": "deepfake_detector",
+  "hidden_size": 512,
+  "num_hidden_layers": 2,
+  "num_attention_heads": 8,
+  "intermediate_size": 2048,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "attention_probs_dropout_prob": 0.1,
+  "max_position_embeddings": 20,
+  "initializer_range": 0.02,
+  "layer_norm_eps": 1e-12,
+  "pad_token_id": 0,
+  "backbone": "resnext50",
+  "sequence_length": 20,
+  "num_classes": 2,
+  "pipeline_tag": "video-classification"
+}

inference.py

@@ -0,0 +1,69 @@
+
+from transformers import AutoProcessor, AutoModelForVideoClassification
+import torch
+import torch.nn.functional as F
+from PIL import Image
+import cv2
+import numpy as np
+import io
+import base64
+
+# Import the model definition
+from modeling import DeepFakeDetector, load_model
+
+# Constants
+im_size = 112
+mean = [0.485, 0.456, 0.406]
+std = [0.229, 0.224, 0.225]
+
+def preprocess_frame(frame):
+    # Convert to PIL Image if it's a numpy array
+    if isinstance(frame, np.ndarray):
+        frame = Image.fromarray(frame)
+    
+    # Resize
+    frame = frame.resize((im_size, im_size))
+    
+    # Convert to tensor
+    frame = np.array(frame).astype(np.float32) / 255.0
+    frame = (frame - np.array(mean)) / np.array(std)
+    frame = frame.transpose(2, 0, 1)  # HWC -> CHW
+    frame = torch.tensor(frame, dtype=torch.float32)
+    
+    return frame
+
+def inference(model_inputs):
+    # Load the model
+    model = load_model()
+    
+    # Process inputs
+    if "frames" in model_inputs:
+        # Process frames from base64
+        frames = []
+        for frame_b64 in model_inputs["frames"]:
+            img_data = base64.b64decode(frame_b64)
+            frame = Image.open(io.BytesIO(img_data))
+            frame = np.array(frame)
+            frames.append(preprocess_frame(frame))
+        
+        # Stack frames
+        frames = torch.stack(frames)
+        frames = frames.unsqueeze(0)  # Add batch dimension
+        
+        # Run inference
+        with torch.no_grad():
+            _, outputs = model(frames)
+            probs = F.softmax(outputs, dim=1).cpu().numpy()[0]
+            
+            # Get prediction (0: fake, 1: real)
+            prediction = int(np.argmax(probs))
+            confidence = float(probs[prediction]) * 100
+            
+            return {
+                "prediction": "REAL" if prediction == 1 else "FAKE",
+                "confidence": round(confidence, 1),
+                "prediction_code": prediction
+            }
+    
+    # Default response if no valid input
+    return {"error": "Invalid input format"}

model_87_acc_20_frames_final_data.pt

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

modeling.py

@@ -0,0 +1,30 @@
+
+import torch
+import torch.nn as nn
+import torchvision.models as models
+
+class DeepFakeDetector(nn.Module):
+    def __init__(self, num_classes=2, latent_dim=2048, lstm_layers=1, hidden_dim=2048, bidirectional=False):
+        super(DeepFakeDetector, 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, :]))
+
+def load_model():
+    model = DeepFakeDetector(2)
+    model.load_state_dict(torch.load("model_87_acc_20_frames_final_data.pt", map_location=torch.device('cpu')))
+    model.eval()
+    return model

modeling_deepfake.py

@@ -0,0 +1,139 @@
+import torch
+import torch.nn as nn
+import torchvision.models as models
+from transformers import PreTrainedModel
+from transformers.modeling_outputs import SequenceClassifierOutput
+
+class DeepFakeDetectorConfig:
+    """Configuration class for DeepFakeDetector."""
+    
+    def __init__(self, num_classes=2, latent_dim=2048, lstm_layers=1, hidden_dim=2048, 
+                 bidirectional=False, sequence_length=20, im_size=112, **kwargs):
+        self.num_classes = num_classes
+        self.latent_dim = latent_dim
+        self.lstm_layers = lstm_layers
+        self.hidden_dim = hidden_dim
+        self.bidirectional = bidirectional
+        self.sequence_length = sequence_length
+        self.im_size = im_size
+        
+    @classmethod
+    def from_dict(cls, config_dict):
+        """Create a configuration from a dictionary."""
+        return cls(**config_dict)
+    
+    def to_dict(self):
+        """Convert configuration to a dictionary."""
+        return {
+            "num_classes": self.num_classes,
+            "latent_dim": self.latent_dim,
+            "lstm_layers": self.lstm_layers,
+            "hidden_dim": self.hidden_dim,
+            "bidirectional": self.bidirectional,
+            "sequence_length": self.sequence_length,
+            "im_size": self.im_size
+        }
+
+
+class DeepFakeDetectorModel(PreTrainedModel):
+    """DeepFake detection model using ResNext50 and LSTM."""
+    
+    config_class = DeepFakeDetectorConfig
+    
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_classes = config.num_classes
+        self.latent_dim = config.latent_dim
+        self.lstm_layers = config.lstm_layers
+        self.hidden_dim = config.hidden_dim
+        self.bidirectional = config.bidirectional
+        
+        # Initialize ResNext50 backbone
+        resnext = models.resnext50_32x4d(pretrained=True)
+        self.backbone = nn.Sequential(*list(resnext.children())[:-2])
+        
+        # Initialize LSTM
+        self.lstm = nn.LSTM(
+            self.latent_dim, 
+            self.hidden_dim,
+            self.lstm_layers, 
+            bidirectional=self.bidirectional
+        )
+        
+        # Additional layers
+        self.relu = nn.LeakyReLU()
+        self.dropout = nn.Dropout(0.4)
+        self.classifier = nn.Linear(self.hidden_dim, self.num_classes)
+        self.avgpool = nn.AdaptiveAvgPool2d(1)
+    
+    def forward(self, x, labels=None):
+        """
+        Forward pass of the model.
+        
+        Args:
+            x: Input tensor of shape (batch_size, sequence_length, channels, height, width)
+            labels: Optional labels for computing loss
+            
+        Returns:
+            SequenceClassifierOutput: Model outputs including loss and logits
+        """
+        batch_size, seq_length, c, h, w = x.shape
+        
+        # Reshape for ResNext processing
+        x = x.view(batch_size * seq_length, c, h, w)
+        
+        # Extract features using ResNext
+        features = self.backbone(x)
+        
+        # Apply average pooling
+        pooled = self.avgpool(features)
+        
+        # Reshape for LSTM processing
+        pooled = pooled.view(batch_size, seq_length, self.latent_dim)
+        
+        # Process with LSTM
+        lstm_out, _ = self.lstm(pooled, None)
+        
+        # Get the final time step output
+        final = lstm_out[:, -1, :]
+        
+        # Apply dropout and classification
+        logits = self.classifier(self.dropout(final))
+        
+        # Compute loss if labels are provided
+        loss = None
+        if labels is not None:
+            loss_fct = nn.CrossEntropyLoss()
+            loss = loss_fct(logits, labels)
+        
+        return SequenceClassifierOutput(
+            loss=loss,
+            logits=logits
+        )
+    
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path, *model_args, **kwargs):
+        """Load a pretrained model."""
+        # Load config
+        config_dict = kwargs.pop("config", None)
+        if config_dict is None:
+            config_dict = {
+                "num_classes": 2,
+                "latent_dim": 2048,
+                "lstm_layers": 1,
+                "hidden_dim": 2048,
+                "bidirectional": False,
+                "sequence_length": 20,
+                "im_size": 112
+            }
+        
+        config = DeepFakeDetectorConfig.from_dict(config_dict)
+        
+        # Create model
+        model = cls(config, *model_args, **kwargs)
+        
+        # Load weights
+        state_dict = torch.load(pretrained_model_name_or_path, map_location="cpu")
+        model.load_state_dict(state_dict)
+        
+        return model

processor_deepfake.py

@@ -0,0 +1,136 @@
+import numpy as np
+import torch
+from PIL import Image
+import cv2
+import face_recognition
+from transformers import ProcessorMixin
+
+class DeepFakeProcessor(ProcessorMixin):
+    """Processor for DeepFake detection model."""
+    
+    def __init__(self, im_size=112, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]):
+        self.im_size = im_size
+        self.mean = mean
+        self.std = std
+    
+    def preprocess_frame(self, frame):
+        """
+        Preprocess a single frame.
+        
+        Args:
+            frame: PIL Image or numpy array
+            
+        Returns:
+            torch.Tensor: Processed frame tensor
+        """
+        # Convert to PIL Image if it's a numpy array
+        if isinstance(frame, np.ndarray):
+            frame = Image.fromarray(frame)
+        
+        # Resize
+        frame = frame.resize((self.im_size, self.im_size))
+        
+        # Convert to tensor
+        frame = np.array(frame).astype(np.float32) / 255.0
+        frame = (frame - np.array(self.mean)) / np.array(self.std)
+        frame = frame.transpose(2, 0, 1)  # HWC -> CHW
+        frame = torch.tensor(frame, dtype=torch.float32)
+        
+        return frame
+    
+    def extract_frames(self, video_path, sequence_length=20, extract_faces=True):
+        """
+        Extract frames from a video file.
+        
+        Args:
+            video_path: Path to the video file
+            sequence_length: Number of frames to extract
+            extract_faces: Whether to extract faces from frames
+            
+        Returns:
+            torch.Tensor: Tensor of shape (1, sequence_length, 3, im_size, im_size)
+        """
+        frames = []
+        
+        # Open video file
+        vidObj = cv2.VideoCapture(video_path)
+        
+        # Calculate frame interval
+        total_frames = int(vidObj.get(cv2.CAP_PROP_FRAME_COUNT))
+        interval = max(1, total_frames // sequence_length)
+        
+        # Extract frames
+        count = 0
+        success = True
+        
+        while success and len(frames) < sequence_length:
+            success, image = vidObj.read()
+            
+            if success and count % interval == 0:
+                # Convert BGR to RGB
+                image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+                
+                # Extract face if requested
+                if extract_faces:
+                    face_locations = face_recognition.face_locations(image)
+                    if face_locations:
+                        top, right, bottom, left = face_locations[0]
+                        # Add padding
+                        padding = 40
+                        h, w = image.shape[:2]
+                        top = max(0, top - padding)
+                        bottom = min(h, bottom + padding)
+                        left = max(0, left - padding)
+                        right = min(w, right + padding)
+                        image = image[top:bottom, left:right]
+                
+                # Preprocess frame
+                processed_frame = self.preprocess_frame(image)
+                frames.append(processed_frame)
+            
+            count += 1
+        
+        # If we couldn't extract enough frames, duplicate the last one
+        while len(frames) < sequence_length:
+            frames.append(frames[-1] if frames else torch.zeros((3, self.im_size, self.im_size)))
+        
+        # Stack frames
+        frames = torch.stack(frames)
+        
+        # Add batch dimension
+        frames = frames.unsqueeze(0)
+        
+        return frames
+    
+    def __call__(self, video_path=None, frames=None, return_tensors="pt", **kwargs):
+        """
+        Process video for the model.
+        
+        Args:
+            video_path: Path to the video file
+            frames: List of frames (PIL Images or numpy arrays)
+            return_tensors: Return format (only "pt" supported)
+            
+        Returns:
+            dict: Processed inputs for the model
+        """
+        if return_tensors != "pt":
+            raise ValueError("Only 'pt' return tensors are supported")
+        
+        if video_path is not None:
+            # Extract frames from video
+            sequence_length = kwargs.get("sequence_length", 20)
+            extract_faces = kwargs.get("extract_faces", True)
+            processed_frames = self.extract_frames(
+                video_path, 
+                sequence_length=sequence_length,
+                extract_faces=extract_faces
+            )
+        elif frames is not None:
+            # Process provided frames
+            processed_frames = torch.stack([self.preprocess_frame(frame) for frame in frames])
+            processed_frames = processed_frames.unsqueeze(0)  # Add batch dimension
+        else:
+            raise ValueError("Either video_path or frames must be provided")
+        
+        return {"pixel_values": processed_frames}

requirements.txt

@@ -0,0 +1,8 @@
+torch>=2.0.0
+torchvision>=0.15.0
+transformers>=4.30.0
+numpy>=1.24.0
+Pillow>=9.0.0
+opencv-python>=4.7.0
+face-recognition>=1.3.0
+safetensors>=0.3.1