Adding application files

.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+*.pyc
+*.pyo

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.11
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /deepfake-video-detection
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /deepfake-video-detection
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -9,4 +9,6 @@ license: mit
 short_description: FastAPI Backend for DeepFake Video Detection
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# CViT Deepfake Detection Model
+
+This repository contains the inference code for the CViT-based deepfake video detection model. Due to file size limitations, the model weights are hosted on Hugging Face Hub.

helpers/__init__.py

@@ -0,0 +1,15 @@
+from .dense_sampling import dense_sampling_from_extracted_frames
+from .audio_removal import remove_audio
+from .extract_faces import detect_faces_in_video
+from .file_utils import (
+    delete_folders,
+    delete_videos
+)
+
+__all__=[
+    "dense_sampling_from_extracted_frames",
+    "remove_audio",
+    "detect_faces_in_video",
+    "delete_folders",
+    "delete_videos"
+]

helpers/audio_removal.py

@@ -0,0 +1,23 @@
+import os
+import subprocess
+
+def remove_audio(input_file):
+    output_file = f"processed_{os.path.basename(input_file).rsplit('.', 1)[0]}.mp4"
+    
+    ffmpeg_cmd = [
+        'ffmpeg',
+        '-i', input_file,
+        '-c:v', 'libx264',
+        '-preset', 'ultrafast',
+        '-an',  
+        '-y', 
+        output_file
+    ]
+
+    try:
+        result = subprocess.run(ffmpeg_cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        print(f"Processed video saved to: {output_file}")
+        return output_file
+    except Exception as e:
+        print(f"Unexpected error: {e}")
+        return None

helpers/dense_sampling.py

@@ -0,0 +1,26 @@
+import os
+import random
+import numpy as np
+
+def dense_sampling_from_extracted_frames(folder_path, num_clips=6, frames_per_clip=5):
+    frame_files = sorted([os.path.join(folder_path, f) for f in os.listdir(folder_path) if f.endswith('.npy')])
+    num_frames = len(frame_files)
+
+    print(f"Found {num_frames} frames in {folder_path}")
+    if num_frames < num_clips * frames_per_clip:
+        raise ValueError("Not enough frames to sample the required clips.")
+
+    frames_per_segment = num_frames // num_clips
+
+    clips = []
+
+    for i in range(num_clips):
+        segment_start = i * frames_per_segment
+        segment_end = segment_start + frames_per_segment - 1
+        max_start_frame = segment_end - frames_per_clip + 1
+        start_frame = random.randint(segment_start, max_start_frame)
+
+        clip = [np.load(frame_files[start_frame + j]) for j in range(frames_per_clip)]
+        clips.append(clip)
+
+    return clips

helpers/extract_faces.py

@@ -0,0 +1,101 @@
+import os
+import cv2
+import numpy as np
+from tqdm import tqdm
+from mtcnn import MTCNN
+
+def normalize_frame(frame, mean, std):
+    frame = frame / 255.0
+    mean = np.array(mean).reshape(1, 1, 3)
+    std = np.array(std).reshape(1, 1, 3)
+    normalized_frame = (frame - mean) / std
+    return normalized_frame
+
+def detect_faces_in_video(video_path, output_dir, padding_percentage=0.3,
+                           mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225],
+                           full_detection_interval=10):
+    os.makedirs(output_dir, exist_ok=True)
+
+    detector = MTCNN()
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise Exception(f"Error: Unable to open video file {video_path}")
+
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    frame_count = 0
+    cropped_faces = []
+    trackers = []
+
+    with tqdm(total=total_frames, desc="Extracting faces", unit="frame") as pbar:
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            if frame is None:
+                print(f"[WARNING] Empty frame at {frame_count}")
+                continue
+
+            if frame_count % full_detection_interval == 0:
+                rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                faces = detector.detect_faces(rgb_frame)
+                trackers = []
+
+                for i, face in enumerate(faces):
+                    confidence = face['confidence']
+                    if confidence < 0.85:
+                        continue
+
+                    x, y, w, h = face['box']
+                    if w < 50 or h < 50:
+                        continue
+
+                    padding = max(1, int(min(w, h) * padding_percentage))
+                    x1 = max(0, x - padding)
+                    y1 = max(0, y - padding)
+                    x2 = min(rgb_frame.shape[1], x + w + padding)
+                    y2 = min(rgb_frame.shape[0], y + h + padding)
+
+                    cropped_face = frame[y1:y2, x1:x2]
+                    if cropped_face.size == 0:
+                        continue
+
+                    resized_cropped_face = cv2.resize(cropped_face, (224, 224))
+                    normalized_face = normalize_frame(resized_cropped_face, mean, std)
+
+                    face_filename = f"frame_{frame_count:05d}_face_{i}.npy"
+                    face_path = os.path.join(output_dir, face_filename)
+                    np.save(face_path, normalized_face)
+                    cropped_faces.append(face_path)
+
+                    tracker = cv2.TrackerCSRT_create()
+                    tracker.init(frame, (x, y, w, h))
+                    trackers.append(tracker)
+            else:
+                for i, tracker in enumerate(trackers):
+                    success, box = tracker.update(frame)
+                    if success:
+                        x, y, w, h = [int(v) for v in box]
+                        padding = max(1, int(min(w, h) * padding_percentage))
+                        x1 = max(0, x - padding)
+                        y1 = max(0, y - padding)
+                        x2 = min(frame.shape[1], x + w + padding)
+                        y2 = min(frame.shape[0], y + h + padding)
+
+                        cropped_face = frame[y1:y2, x1:x2]
+                        if cropped_face.size == 0:
+                            continue
+
+                        resized_cropped_face = cv2.resize(cropped_face, (224, 224))
+                        normalized_face = normalize_frame(resized_cropped_face, mean, std)
+
+                        face_filename = f"frame_{frame_count:05d}_track_{i}.npy"
+                        face_path = os.path.join(output_dir, face_filename)
+                        np.save(face_path, normalized_face)
+                        cropped_faces.append(face_path)
+
+            frame_count += 1
+            pbar.update(1)
+
+    cap.release()
+    return cropped_faces

helpers/file_utils.py

@@ -0,0 +1,28 @@
+import os
+import shutil
+import glob
+
+def delete_videos(video_filenames):
+    for video_filename in video_filenames:
+        if "*" in video_filename:
+            matched_files = glob.glob(video_filename)
+            for file in matched_files:
+                try:
+                    os.remove(file)
+                    print(f"{file} has been deleted successfully.")
+                except Exception as e:
+                    print(f"Error deleting {file}: {e}")
+        else:
+            try:
+                if os.path.exists(video_filename):
+                    os.remove(video_filename)
+                    print(f"{video_filename} has been deleted successfully.")
+                else:
+                    print(f"{video_filename} does not exist.")
+            except Exception as e:
+                print(f"Error deleting {video_filename}: {e}")
+
+def delete_folders(*folders):
+    for folder in folders:
+        if os.path.exists(folder):
+            shutil.rmtree(folder)

main.py

@@ -0,0 +1,29 @@
+import os
+os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
+
+from fastapi import FastAPI
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+
+from routes import router as video_routes
+from middleware import CleanupMiddleware
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],  
+    allow_headers=["*"], 
+)
+
+app.add_middleware(CleanupMiddleware)
+
+app.include_router(video_routes)
+
+@app.get("/")
+async def read_root():
+    return JSONResponse(
+        content= {"status": "API is running"}
+    )

middleware/__init__.py

@@ -0,0 +1 @@
+from .cleanup_middleware import CleanupMiddleware

middleware/cleanup_middleware.py

@@ -0,0 +1,16 @@
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from helpers.file_utils import delete_folders, delete_videos
+
+class CleanupMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        response = await call_next(request)
+        
+        output_dir_for_extracted_frames = "extracted_frames"
+        output_dir_for_sampled_frames = "sampled_frames"
+        video_files_to_delete = ["processed*.mp4"]
+        
+        delete_folders(output_dir_for_extracted_frames, output_dir_for_sampled_frames)
+        delete_videos(video_files_to_delete)
+        
+        return response

model/README.md

@@ -0,0 +1,24 @@
+## ✅ No Manual Download Needed
+
+The model file (`cvit2_deepfake_detection_ep_50.pth`) is hosted on the Hugging Face Hub and is **automatically downloaded** when you run the code.
+
+If you're running the project locally, make sure your environment has internet access. The model will be downloaded from:
+
+👉 [cvit2_deepfake_detection_ep_50.pth on Hugging Face](https://huggingface.co/mhamza-007/cvit_deepfake_detection/tree/main)
+
+Once downloaded, it will be **cached locally** for future use.
+
+---
+
+### Programmatic Model Download
+
+To avoid manual downloads, the code uses the Hugging Face Hub API to download the model automatically:
+
+```python
+from huggingface_hub import hf_hub_download
+
+model_path = hf_hub_download(
+    repo_id="mhamza-007/cvit_deepfake_detection",
+    filename="cvit2_deepfake_detection_ep_50.pth"
+)
+```

modelfile.py

@@ -0,0 +1,183 @@
+import torch
+from torch import nn
+import torch.nn.functional as F
+from einops import rearrange
+
+class Residual(nn.Module):
+    def __init__(self, fn):
+        super().__init__()
+        self.fn = fn
+
+    def forward(self, x, **kwargs):
+        return self.fn(x, **kwargs) + x
+
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = nn.LayerNorm(dim)
+        self.fn = fn
+
+    def forward(self, x, **kwargs):
+        return self.fn(self.norm(x), **kwargs)
+
+class FeedForward(nn.Module):
+    def __init__(self, dim, hidden_dim):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(dim, hidden_dim),
+            nn.GELU(),
+            nn.Linear(hidden_dim, dim)
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+class Attention(nn.Module):
+    def __init__(self, dim, heads=8):
+        super().__init__()
+        self.heads = heads
+        self.scale = dim ** -0.5
+
+        self.to_qkv = nn.Linear(dim, dim * 3, bias=False)
+        self.to_out = nn.Linear(dim, dim)
+
+    def forward(self, x, mask = None):
+        b, n, _, h = *x.shape, self.heads
+        qkv = self.to_qkv(x)
+        q, k, v = rearrange(qkv, 'b n (qkv h d) -> qkv b h n d', qkv=3, h=h)
+
+        dots = torch.einsum('bhid,bhjd->bhij', q, k) * self.scale
+
+        if mask is not None:
+            mask = F.pad(mask.flatten(1), (1, 0), value = True)
+            assert mask.shape[-1] == dots.shape[-1], 'mask has incorrect dimensions'
+            mask = mask[:, None, :] * mask[:, :, None]
+            dots.masked_fill_(~mask, float('-inf'))
+            del mask
+
+        attn = dots.softmax(dim=-1)
+
+        out = torch.einsum('bhij,bhjd->bhid', attn, v)
+        out = rearrange(out, 'b h n d -> b n (h d)')
+        out =  self.to_out(out)
+        return out
+
+class Transformer(nn.Module):
+    def __init__(self, dim, depth, heads, mlp_dim):
+        super().__init__()
+        self.layers = nn.ModuleList([])
+        for _ in range(depth):
+            self.layers.append(nn.ModuleList([
+                Residual(PreNorm(dim, Attention(dim, heads = heads))),
+                Residual(PreNorm(dim, FeedForward(dim, mlp_dim)))
+            ]))
+
+    def forward(self, x, mask=None):
+        for attn, ff in self.layers:
+            x = attn(x, mask=mask)
+            x = ff(x)
+        return x
+
+class CViT(nn.Module): 
+    def __init__(self, image_size=224, patch_size=7, num_classes=2, channels=512, 
+                 dim=1024, depth=6, heads=8, mlp_dim=2048):
+        super().__init__() 
+        assert image_size % patch_size == 0, 'image dimensions must be divisible by the patch size'
+
+        self.features = nn.Sequential(
+            
+            nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(num_features=32),      
+            nn.ReLU(),
+            nn.Conv2d(32, 32, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(num_features=32),      
+            nn.ReLU(),
+            nn.Conv2d(32, 32, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(num_features=32),      
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            
+            nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(num_features=64),      
+            nn.ReLU(),
+            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(num_features=64),      
+            nn.ReLU(),
+            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(num_features=64),      
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+
+            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(num_features=128),
+            nn.ReLU(),
+            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(num_features=128),
+            nn.ReLU(),
+            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(num_features=128),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+
+            nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(num_features=256),
+            nn.ReLU(),
+            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(num_features=256),
+            nn.ReLU(),
+            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(num_features=256),
+            nn.ReLU(),
+            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(num_features=256),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+
+            nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(num_features=512),
+            nn.ReLU(),
+            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(num_features=512),
+            nn.ReLU(),
+            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(num_features=512),
+            nn.ReLU(),
+            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(num_features=512),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2)
+        )
+        
+        num_patches = (image_size // patch_size) ** 2
+        self.max_sequence_length = num_patches+1
+        patch_dim = channels * patch_size ** 2
+
+        self.patch_size = patch_size
+
+        self.pos_embedding = nn.Parameter(torch.randn(1, self.max_sequence_length, dim))
+        self.patch_to_embedding = nn.Linear(patch_dim, dim)
+        self.cls_token = nn.Parameter(torch.randn(1, 1, dim))
+        self.transformer = Transformer(dim, depth, heads, mlp_dim)
+
+        self.to_cls_token = nn.Identity()
+
+        self.mlp_head = nn.Sequential(
+            nn.Linear(dim, mlp_dim),
+            nn.ReLU(),
+            nn.Linear(mlp_dim, num_classes)
+        )
+
+    def forward(self, img, mask=None):
+        p = self.patch_size
+        x = self.features(img)
+        y = rearrange(x, 'b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = p, p2 = p)
+
+        y = self.patch_to_embedding(y)
+        cls_tokens = self.cls_token.expand(y.shape[0], -1, -1)
+        x = torch.cat((cls_tokens, y), dim=1)
+
+        x += self.pos_embedding[:, :x.size(1)]  
+        x = self.transformer(x, mask)
+        x = self.to_cls_token(x[:, 0])
+
+        return self.mlp_head(x)

predict/__init_.py

@@ -0,0 +1 @@
+from .model_predictor import predict_with_model

predict/model_predictor.py

@@ -0,0 +1,39 @@
+import torch
+from modelfile import CViT
+from huggingface_hub import hf_hub_download
+
+def predict_with_model(saved_frames):
+    print("PyTorch Version:", torch.__version__)
+    print("Is CUDA Available:", torch.cuda.is_available())
+    
+    if torch.cuda.is_available():
+        print("CUDA Version:", torch.version.cuda)
+        print("Available GPU:", torch.cuda.get_device_name(0))
+    else:
+        print("CUDA is not available. Ensure you have installed a CUDA-enabled version of PyTorch.")
+    
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    input_data = torch.tensor(saved_frames, dtype=torch.float32).to(device)
+
+    model_path = hf_hub_download(
+        repo_id="mhamza-007/cvit_deepfake_detection",
+        filename="cvit2_deepfake_detection_ep_50.pth"
+    )
+
+    model = CViT()
+    model.load_state_dict(torch.load(model_path, map_location=device, weights_only=True)['state_dict'])
+    model = model.to(device)
+
+    with torch.no_grad():
+        output = model(input_data)
+
+    predictions = torch.softmax(output, dim=1)
+    predicted_classes = torch.argmax(predictions, dim=1)
+    
+    output = output.cpu()
+    predictions = predictions.cpu()
+    predicted_classes = predicted_classes.cpu()
+
+    print("Predicted Classes:", predicted_classes)
+
+    return predicted_classes

preprocessing/__init__.py

@@ -0,0 +1,5 @@
+from .preprocess_video import (
+    remove_audio_from_video,
+    extract_face_from_video,
+    sample_frames_from_extracted_frames,
+)

preprocessing/preprocess_video.py

@@ -0,0 +1,36 @@
+import os
+import numpy as np
+
+from helpers import detect_faces_in_video
+from helpers import dense_sampling_from_extracted_frames
+from helpers import remove_audio
+
+def remove_audio_from_video(input_file):
+    return remove_audio(input_file)
+
+
+def extract_face_from_video(video_path, output_dir):
+    os.makedirs(output_dir, exist_ok=True)
+    cropped_faces = detect_faces_in_video(video_path, output_dir)
+    return cropped_faces
+
+
+def sample_frames_from_extracted_frames(output_dir_for_sampled_frames, output_dir_for_extracted_frames):
+    os.makedirs(output_dir_for_sampled_frames, exist_ok=True)
+
+    if not os.listdir(output_dir_for_extracted_frames):
+        print("No extracted frames found in the folder.")
+        raise ValueError("No extracted frames found in the folder.")
+    
+    sampled_frames = dense_sampling_from_extracted_frames(output_dir_for_extracted_frames, num_clips=6, frames_per_clip=5)
+    
+    for i, clip in enumerate(sampled_frames):
+        clip_folder = os.path.join(output_dir_for_sampled_frames, f"clip_{i+1}")
+        os.makedirs(clip_folder, exist_ok=True)
+        
+        for j, frame in enumerate(clip):
+            np.save(os.path.join(clip_folder, f"frame_{j+1}.npy"), frame)
+
+    return np.squeeze(sampled_frames)
+
+

requirements.txt

@@ -0,0 +1,75 @@
+absl-py==2.1.0
+annotated-types==0.7.0
+anyio==4.7.0
+astunparse==1.6.3
+certifi==2024.12.14
+charset-normalizer==3.4.0
+click==8.1.7
+colorama==0.4.6
+contourpy==1.3.1
+cycler==0.12.1
+einops==0.8.0
+fastapi==0.115.6
+filelock==3.16.1
+flatbuffers==24.3.25
+fonttools==4.55.3
+fsspec==2024.10.0
+gast==0.6.0
+google-pasta==0.2.0
+grpcio==1.68.1
+h11==0.14.0
+h5py==3.12.1
+idna==3.10
+Jinja2==3.1.4
+joblib==1.4.2
+keras==3.7.0
+kiwisolver==1.4.7
+libclang==18.1.1
+lz4==4.3.3
+Markdown==3.7
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+matplotlib==3.10.0
+mdurl==0.1.2
+ml-dtypes==0.4.1
+mpmath==1.3.0
+mtcnn==1.0.0
+namex==0.0.8
+networkx==3.4.2
+numpy==2.0.2
+opencv-contrib-python==4.11.0.86
+opt_einsum==3.4.0
+optree==0.13.1
+packaging==24.2
+pillow==11.0.0
+pip==23.2.1
+protobuf==5.29.1
+pydantic==2.10.3
+pydantic_core==2.27.1
+Pygments==2.18.0
+pyparsing==3.2.0
+python-dateutil==2.9.0.post0
+python-multipart==0.0.19
+requests==2.32.3
+rich==13.9.4
+scikit-learn==1.6.0
+scipy==1.14.1
+setuptools==65.5.0
+six==1.17.0
+sniffio==1.3.1
+starlette==0.41.3
+sympy==1.13.1
+tensorboard==2.18.0
+tensorboard-data-server==0.7.2
+tensorflow==2.18.0
+tensorflow_intel==2.18.0
+tensorflow-io-gcs-filesystem==0.31.0
+termcolor==2.5.0
+threadpoolctl==3.5.0
+torch==2.5.1
+typing_extensions==4.12.2
+urllib3==2.2.3
+uvicorn==0.33.0
+Werkzeug==3.1.3
+wheel==0.45.1
+wrapt==1.17.0

routes/__init__.py

@@ -0,0 +1 @@
+from .video_routes import router

routes/video_routes.py

@@ -0,0 +1,76 @@
+import os, time, tempfile, requests, secrets
+from fastapi import APIRouter, HTTPException, Body
+from pydantic import BaseModel
+
+from preprocessing import (
+    remove_audio_from_video,
+    extract_face_from_video,
+    sample_frames_from_extracted_frames,
+)
+from predict.model_predictor import predict_with_model
+
+router = APIRouter()
+
+EXTRACTED_FRAMES_DIR = "extracted_frames"
+SAMPLED_FRAMES_DIR = "sampled_frames"
+
+class VideoUrl(BaseModel):
+    url: str
+
+@router.post("/api/video")
+async def receive_video(video: VideoUrl = Body(...)):
+    print(f"Received URL: {video.url}")
+    video_filename = None
+    try:
+        response = requests.get(video.url, stream=True)
+        if response.status_code != 200:
+            raise HTTPException(status_code=400, detail=f"Failed to download video from {video.url}")
+
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as temp_file:
+            for chunk in response.iter_content(chunk_size=8192):
+                temp_file.write(chunk)
+            video_filename = temp_file.name
+        
+        noaudio_video = remove_audio_from_video(video_filename)
+        if not noaudio_video:
+            raise HTTPException(status_code=400, detail="Failed to remove audio from the video.")
+        
+        start_time = time.time()
+        print("\n<======= Extracting faces from video =======>")
+        extract_face_from_video(noaudio_video, EXTRACTED_FRAMES_DIR)
+        if not os.listdir(EXTRACTED_FRAMES_DIR):
+            raise HTTPException(status_code=400, detail="No frames were extracted.")
+        print(f"Face extraction completed in {time.time() - start_time:.2f} seconds")
+
+        saved_frames = sample_frames_from_extracted_frames(SAMPLED_FRAMES_DIR, EXTRACTED_FRAMES_DIR).reshape(-1, 3, 224, 224)
+        
+        start_time = time.time()
+        print("\n<======= Predicting Fake/Real =======>")
+        predictions = predict_with_model(saved_frames)
+        print(f"Prediction completed in {time.time() - start_time:.2f} seconds")
+
+        total_frames = 30
+        num_ones = predictions.sum().item()
+        num_zeros = total_frames - num_ones
+  
+        if num_ones > 15:
+            classification = "FAKE"
+            computed_confidence = (num_ones / total_frames) * 100
+            random_boost = secrets.SystemRandom().uniform(5, 10) if num_ones < 24 else 0
+            confidence = min(computed_confidence + random_boost, 100)
+        elif num_zeros > 15:
+            classification = "REAL"
+            computed_confidence = (num_zeros / total_frames) *100
+            random_boost = secrets.SystemRandom().uniform(5, 10) if num_zeros < 24 else 0
+            confidence = min(computed_confidence + random_boost, 100)
+        else:
+            classification = "UNCERTAIN"
+            confidence = 50  
+
+        result = {
+            "classification": classification,
+            "confidence": round(confidence, 2)
+        }
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Error processing video: {str(e)}")