Deploy DeepFake video classifier to Hugging Face Spaces

- FastAPI backend for video deepfake detection
- EfficientNet model for classification
- Face detection preprocessing with OpenCV
- Git LFS for model file (50MB)
- Configured for HF Spaces on port 7860

.dockerignore

@@ -0,0 +1,11 @@
+__pycache__
+*.pyc
+.git
+.gitignore
+*.pth
+models/
+temp/
+*.log
+.DS_Store
+.env
+*.backup

Dockerfile

@@ -0,0 +1,31 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    wget \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app ./app
+
+RUN mkdir -p /tmp/uploads
+
+ENV PYTHONPATH=/app
+ENV ENVIRONMENT=production
+ENV DEVICE=cpu
+ENV HF_HOME=/tmp/huggingface-cache
+ENV SPACE_AUTHOR=oo01
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app/config.py

@@ -0,0 +1,48 @@
+import os
+from pathlib import Path
+import torch
+from dotenv import load_dotenv
+import tempfile
+
+load_dotenv()
+
+# Model configuration - Use temp directory for HF Spaces
+if os.environ.get("SPACE_AUTHOR"):
+    MODEL_PATH = os.environ.get(
+        "MODEL_PATH",
+        str(Path(tempfile.gettempdir()) / "models" / "ffpp_efficientnet_best.pth")
+    )
+else:
+    MODEL_PATH = os.environ.get(
+        "MODEL_PATH",
+        str(Path("models") / "ffpp_efficientnet_best.pth")
+    )
+
+if os.environ.get("FORCE_CPU", "false").lower() == "true":
+    DEVICE = "cpu"
+elif torch.cuda.is_available():
+    DEVICE = "cuda"
+elif torch.backends.mps.is_available():
+    DEVICE = "mps"
+else:
+    DEVICE = "cpu"
+
+PREDICTION_THRESHOLD = float(os.environ.get("PREDICTION_THRESHOLD", 0.5))
+
+FRAMES_PER_CLIP = int(os.environ.get("FRAMES_PER_CLIP", 16))
+IMG_SIZE = int(os.environ.get("IMG_SIZE", 224))
+MAX_FILE_SIZE = int(os.environ.get("MAX_FILE_SIZE", 50 * 1024 * 1024))
+ALLOWED_EXTENSIONS = {".mp4", ".avi", ".mov", ".mkv"}
+
+ALLOWED_ORIGINS = os.environ.get(
+    "ALLOWED_ORIGINS",
+    "http://localhost:5173,http://localhost:3000,https://your-frontend.onrender.com"
+).split(",")
+
+IMAGENET_MEAN = [0.485, 0.456, 0.406]
+IMAGENET_STD = [0.229, 0.224, 0.225]
+
+LOG_LEVEL = os.environ.get("LOG_LEVEL", "INFO")
+IS_PRODUCTION = os.environ.get("ENVIRONMENT", "development") == "production"
+
+RATE_LIMIT_PER_MINUTE = int(os.environ.get("RATE_LIMIT_PER_MINUTE", 10))

app/config.py.backup

@@ -0,0 +1,78 @@
+import os
+from pathlib import Path
+import torch
+from dotenv import load_dotenv
+import os
+
+# Load environment variables
+load_dotenv()
+
+# Model configuration - Use environment variable for model path
+MODEL_PATH = os.environ.get(
+    "MODEL_PATH",
+    str( Path("models") / "ffpp_efficientnet_best.pth")
+)
+
+# Device configuration with fallback
+if os.environ.get("FORCE_CPU", "false").lower() == "true":
+    DEVICE = "cpu"
+elif torch.cuda.is_available():
+    DEVICE = "cuda"
+elif torch.backends.mps.is_available():
+    DEVICE = "mps"
+else:
+    DEVICE = "cpu"
+
+# Prediction threshold (can be overridden by env)
+PREDICTION_THRESHOLD = float(os.environ.get("PREDICTION_THRESHOLD", 0.5))
+
+# Video processing
+FRAMES_PER_CLIP = int(os.environ.get("FRAMES_PER_CLIP", 16))
+IMG_SIZE = int(os.environ.get("IMG_SIZE", 224))
+MAX_FILE_SIZE = int(os.environ.get("MAX_FILE_SIZE", 50 * 1024 * 1024))  # 50MB
+ALLOWED_EXTENSIONS = {".mp4", ".avi", ".mov", ".mkv"}
+
+# CORS - Get from environment
+ALLOWED_ORIGINS = os.environ.get(
+    "ALLOWED_ORIGINS",
+    "http://localhost:5173,http://localhost:3000,https://your-frontend.onrender.com"
+).split(",")
+
+# ImageNet normalization
+IMAGENET_MEAN = [0.485, 0.456, 0.406]
+IMAGENET_STD = [0.229, 0.224, 0.225]
+
+# Logging configuration
+LOG_LEVEL = os.environ.get("LOG_LEVEL", "INFO")
+IS_PRODUCTION = os.environ.get("ENVIRONMENT", "development") == "production"
+
+# Rate limiting (optional)
+RATE_LIMIT_PER_MINUTE = int(os.environ.get("RATE_LIMIT_PER_MINUTE", 10))
+
+
+# import os
+# from pathlib import Path
+# import torch
+
+# # Model configuration
+# MODEL_PATH = Path(__file__).parent.parent / "models" / "ffpp_efficientnet_best.pth"
+
+# if torch.cuda.is_available():
+#     DEVICE = "cuda"
+# elif torch.backends.mps.is_available():
+#     DEVICE = "mps"
+# else:
+#     DEVICE = "cpu"
+
+# # Prediction threshold (based on notebook testing - 0.5 works well)
+# PREDICTION_THRESHOLD = 0.5
+
+# # Video processing
+# FRAMES_PER_CLIP = 16
+# IMG_SIZE = 224
+# MAX_FILE_SIZE = 50 * 1024 * 1024  # 50MB
+# ALLOWED_EXTENSIONS = {".mp4", ".avi", ".mov", ".mkv"}
+
+# # ImageNet normalization
+# IMAGENET_MEAN = [0.485, 0.456, 0.406]
+# IMAGENET_STD = [0.229, 0.224, 0.225]

app/download_model.py

@@ -0,0 +1,46 @@
+import os
+import shutil
+from pathlib import Path
+
+def download_model():
+    """Copy model file from various possible locations"""
+    
+    # Destination path in temp directory
+    dest_path = Path("/tmp/models/ffpp_efficientnet_best.pth")
+    dest_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    # Check if model already exists
+    if dest_path.exists():
+        print(f"✓ Model already exists at {dest_path}")
+        return str(dest_path)
+    
+    # Check different possible source locations
+    possible_sources = []
+    
+    # If running on HF Space, check if we have a models folder
+    if os.environ.get("SPACE_AUTHOR"):
+        possible_sources.append(Path("/app/models/ffpp_efficientnet_best.pth"))
+    
+    # Check local models folder
+    possible_sources.append(Path("models/ffpp_efficientnet_best.pth"))
+    
+    # Check parent backend folder (for local dev)
+    possible_sources.append(Path("../backend/models/ffpp_efficientnet_best.pth"))
+    
+    # Try each source
+    for src_path in possible_sources:
+        if src_path.exists():
+            print(f"✓ Found model at {src_path}")
+            shutil.copy2(src_path, dest_path)
+            print(f"✓ Model copied to {dest_path}")
+            return str(dest_path)
+    
+    # Model not found - will cause error but let the app handle it
+    print("⚠️ WARNING: Model file not found! DeepFake detection will not work.")
+    return None
+
+# Run when imported
+if __name__ == "__main__":
+    download_model()
+else:
+    download_model()

app/main.py

@@ -0,0 +1,428 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from fastapi.middleware.trustedhost import TrustedHostMiddleware
+import tempfile
+import shutil
+from pathlib import Path
+import logging
+import time
+import os
+from contextlib import asynccontextmanager
+
+from .download_model import download_model
+
+# Download model at startup
+download_model()
+
+from .config import (
+    MODEL_PATH, DEVICE, FRAMES_PER_CLIP, IMG_SIZE, 
+    MAX_FILE_SIZE, ALLOWED_EXTENSIONS, PREDICTION_THRESHOLD,
+    ALLOWED_ORIGINS, LOG_LEVEL, IS_PRODUCTION
+)
+from .model import DeepFakeModel
+from .utils import video_to_tensor, save_uploaded_video
+
+# Setup logging
+logging.basicConfig(
+    level=getattr(logging, LOG_LEVEL),
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Global model variable
+model = None
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Lifespan context manager for startup/shutdown events"""
+    global model
+    # Startup
+    logger.info("Starting up...")
+    try:
+        if not Path(MODEL_PATH).exists():
+            logger.error(f"Model file not found at {MODEL_PATH}")
+            raise FileNotFoundError(f"Model not found at {MODEL_PATH}")
+        
+        model = DeepFakeModel(MODEL_PATH, DEVICE)
+        logger.info(f"Model loaded successfully on {DEVICE}")
+    except Exception as e:
+        logger.error(f"Failed to load model: {e}")
+        model = None
+    
+    yield
+    
+    # Shutdown
+    logger.info("Shutting down...")
+
+# Initialize FastAPI with lifespan
+app = FastAPI(
+    title="DeepFake Detection API",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# Add security middleware in production
+if IS_PRODUCTION:
+    app.add_middleware(
+        TrustedHostMiddleware,
+        allowed_hosts=os.environ.get("ALLOWED_HOSTS", "*").split(",")
+    )
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=ALLOWED_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "OPTIONS"],
+    allow_headers=["*"],
+    max_age=3600,
+)
+
+# Rate limiting middleware (simple version)
+request_counts = {}
+
+@app.middleware("http")
+async def rate_limit_middleware(request: Request, call_next):
+    if IS_PRODUCTION:
+        client_ip = request.client.host
+        current_minute = int(time.time() / 60)
+        key = f"{client_ip}:{current_minute}"
+        
+        from .config import RATE_LIMIT_PER_MINUTE
+        request_counts[key] = request_counts.get(key, 0) + 1
+        
+        if request_counts[key] > RATE_LIMIT_PER_MINUTE:
+            return JSONResponse(
+                status_code=429,
+                content={"detail": "Rate limit exceeded. Please try again later."}
+            )
+        
+        # Clean old entries
+        if len(request_counts) > 1000:
+            old_keys = [k for k in request_counts.keys() 
+                       if int(k.split(':')[1]) < current_minute - 1]
+            for k in old_keys:
+                del request_counts[k]
+    
+    response = await call_next(request)
+    return response
+
+@app.get("/")
+async def root():
+    """Root endpoint with API info."""
+    return {
+        "name": "DeepFake Detection API",
+        "version": "1.0.0",
+        "status": "running",
+        "endpoints": [
+            "/health - Health check",
+            "/predict - Upload video for detection",
+            "/predict-batch - Batch prediction"
+        ]
+    }
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint for Render."""
+    return {
+        "status": "healthy" if model else "degraded",
+        "device": DEVICE,
+        "model_loaded": model is not None,
+        "threshold": PREDICTION_THRESHOLD,
+        "environment": "production" if IS_PRODUCTION else "development"
+    }
+
+@app.post("/predict")
+async def predict(file: UploadFile = File(...)):
+    """Predict if uploaded video is REAL or FAKE."""
+    if model is None:
+        raise HTTPException(status_code=503, detail="Model not loaded")
+    
+    # Validate file extension
+    file_ext = Path(file.filename).suffix.lower()
+    if file_ext not in ALLOWED_EXTENSIONS:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unsupported file type. Allowed: {', '.join(ALLOWED_EXTENSIONS)}"
+        )
+    
+    # Validate file size
+    file.file.seek(0, 2)
+    file_size = file.file.tell()
+    file.file.seek(0)
+    
+    if file_size > MAX_FILE_SIZE:
+        raise HTTPException(
+            status_code=400,
+            detail=f"File too large. Max size: {MAX_FILE_SIZE // (1024*1024)}MB"
+        )
+    
+    temp_dir = tempfile.mkdtemp()
+    
+    try:
+        # Save uploaded file
+        video_path = save_uploaded_video(file, temp_dir)
+        logger.info(f"Processing video: {file.filename} (size: {file_size} bytes)")
+        
+        # Convert video to tensor
+        video_tensor = video_to_tensor(
+            video_path,
+            num_frames=FRAMES_PER_CLIP,
+            img_size=IMG_SIZE
+        )
+        
+        # Make prediction with configured threshold
+        result = model.predict(video_tensor, threshold=PREDICTION_THRESHOLD)
+        result["filename"] = file.filename
+        
+        logger.info(f"Prediction for {file.filename}: {result['prediction']} (conf={result['confidence']})")
+        
+        return JSONResponse(content=result)
+    
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error processing video: {e}")
+        raise HTTPException(status_code=500, detail=f"Error processing video: {str(e)}")
+    
+    finally:
+        # Cleanup
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+
+# from fastapi import FastAPI, UploadFile, File, HTTPException
+# from fastapi.middleware.cors import CORSMiddleware
+# from fastapi.responses import JSONResponse
+# import tempfile
+# import shutil
+# from pathlib import Path
+# import logging
+# # /opt/anaconda3/envs/deepfake/bin/python -m uvicorn app.main:app --reload
+# from .config import MODEL_PATH, DEVICE, FRAMES_PER_CLIP, IMG_SIZE, MAX_FILE_SIZE, ALLOWED_EXTENSIONS, PREDICTION_THRESHOLD
+# from .model import DeepFakeModel
+# from .utils import video_to_tensor, save_uploaded_video
+
+# # Setup logging
+# logging.basicConfig(level=logging.INFO)
+# logger = logging.getLogger(__name__)
+
+# # Initialize FastAPI
+# app = FastAPI(title="DeepFake Detection API", version="1.0.0")
+
+# # CORS middleware
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=["http://localhost:5173", "http://localhost:3000"],  # React dev servers
+#     allow_credentials=True,
+#     allow_methods=["*"],
+#     allow_headers=["*"],
+# )
+
+# # Load model (with error handling)
+# model = None
+
+# @app.on_event("startup")
+# async def load_model():
+#     global model
+#     try:
+#         if not MODEL_PATH.exists():
+#             logger.error(f"Model file not found at {MODEL_PATH}")
+#             raise FileNotFoundError(f"Model not found at {MODEL_PATH}")
+        
+#         model = DeepFakeModel(str(MODEL_PATH), DEVICE)
+#         logger.info("Model loaded successfully")
+#     except Exception as e:
+#         logger.error(f"Failed to load model: {e}")
+#         model = None
+
+
+# @app.get("/health")
+# async def health_check():
+#     """Health check endpoint."""
+#     return {
+#         "status": "healthy" if model else "model_not_loaded",
+#         "device": DEVICE,
+#         "model_loaded": model is not None,
+#         "threshold": PREDICTION_THRESHOLD
+#     }
+
+
+# @app.post("/predict")
+# async def predict(file: UploadFile = File(...)):
+#     """
+#     Predict if uploaded video is REAL or FAKE.
+    
+#     Args:
+#         file: Video file (mp4, avi, mov, mkv)
+    
+#     Returns:
+#         Prediction result with confidence scores
+#     """
+#     if model is None:
+#         raise HTTPException(status_code=503, detail="Model not loaded")
+    
+#     # Validate file extension
+#     file_ext = Path(file.filename).suffix.lower()
+#     if file_ext not in ALLOWED_EXTENSIONS:
+#         raise HTTPException(
+#             status_code=400,
+#             detail=f"Unsupported file type. Allowed: {', '.join(ALLOWED_EXTENSIONS)}"
+#         )
+    
+#     # Validate file size
+#     file.file.seek(0, 2)
+#     file_size = file.file.tell()
+#     file.file.seek(0)
+    
+#     if file_size > MAX_FILE_SIZE:
+#         raise HTTPException(
+#             status_code=400,
+#             detail=f"File too large. Max size: {MAX_FILE_SIZE // (1024*1024)}MB"
+#         )
+    
+#     temp_dir = tempfile.mkdtemp()
+    
+#     try:
+#         # Save uploaded file
+#         video_path = save_uploaded_video(file, temp_dir)
+#         logger.info(f"Processing video: {file.filename}")
+        
+#         # Convert video to tensor
+#         video_tensor = video_to_tensor(
+#             video_path,
+#             num_frames=FRAMES_PER_CLIP,
+#             img_size=IMG_SIZE
+#         )
+        
+#         # Make prediction with configured threshold
+#         result = model.predict(video_tensor, threshold=PREDICTION_THRESHOLD)
+#         result["filename"] = file.filename
+        
+#         logger.info(f"Prediction for {file.filename}: {result['prediction']} (conf={result['confidence']})")
+        
+#         return JSONResponse(content=result)
+    
+#     except ValueError as e:
+#         raise HTTPException(status_code=400, detail=str(e))
+#     except Exception as e:
+#         logger.error(f"Error processing video: {e}")
+#         raise HTTPException(status_code=500, detail=f"Error processing video: {str(e)}")
+    
+#     finally:
+#         # Cleanup
+#         shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+# @app.post("/predict-batch")
+# async def predict_batch(files: list[UploadFile] = File(...)):
+#     """
+#     Predict for multiple videos.
+#     """
+#     if model is None:
+#         raise HTTPException(status_code=503, detail="Model not loaded")
+    
+#     results = []
+    
+#     for file in files:
+#         file_ext = Path(file.filename).suffix.lower()
+#         if file_ext not in ALLOWED_EXTENSIONS:
+#             results.append({
+#                 "filename": file.filename,
+#                 "error": f"Unsupported file type: {file_ext}"
+#             })
+#             continue
+        
+#         temp_dir = tempfile.mkdtemp()
+        
+#         try:
+#             video_path = save_uploaded_video(file, temp_dir)
+#             video_tensor = video_to_tensor(video_path, FRAMES_PER_CLIP, IMG_SIZE)
+#             result = model.predict(video_tensor, threshold=PREDICTION_THRESHOLD)
+#             result["filename"] = file.filename
+#             results.append(result)
+#         except Exception as e:
+#             results.append({
+#                 "filename": file.filename,
+#                 "error": str(e)
+#             })
+#         finally:
+#             shutil.rmtree(temp_dir, ignore_errors=True)
+    
+#     return JSONResponse(content={"results": results})
+
+
+# # Optional: Endpoint to test with custom threshold
+# @app.post("/predict-custom")
+# async def predict_custom(
+#     file: UploadFile = File(...),
+#     threshold: float = PREDICTION_THRESHOLD
+# ):
+#     """
+#     Predict with custom threshold.
+    
+#     Args:
+#         file: Video file (mp4, avi, mov, mkv)
+#         threshold: Custom threshold between 0 and 1 (default: 0.4)
+#     """
+#     if model is None:
+#         raise HTTPException(status_code=503, detail="Model not loaded")
+    
+#     # Validate threshold
+#     if threshold < 0 or threshold > 1:
+#         raise HTTPException(
+#             status_code=400,
+#             detail="Threshold must be between 0 and 1"
+#         )
+    
+#     # Validate file extension
+#     file_ext = Path(file.filename).suffix.lower()
+#     if file_ext not in ALLOWED_EXTENSIONS:
+#         raise HTTPException(
+#             status_code=400,
+#             detail=f"Unsupported file type. Allowed: {', '.join(ALLOWED_EXTENSIONS)}"
+#         )
+    
+#     # Validate file size
+#     file.file.seek(0, 2)
+#     file_size = file.file.tell()
+#     file.file.seek(0)
+    
+#     if file_size > MAX_FILE_SIZE:
+#         raise HTTPException(
+#             status_code=400,
+#             detail=f"File too large. Max size: {MAX_FILE_SIZE // (1024*1024)}MB"
+#         )
+    
+#     temp_dir = tempfile.mkdtemp()
+    
+#     try:
+#         # Save uploaded file
+#         video_path = save_uploaded_video(file, temp_dir)
+#         logger.info(f"Processing video: {file.filename}")
+        
+#         # Convert video to tensor
+#         video_tensor = video_to_tensor(
+#             video_path,
+#             num_frames=FRAMES_PER_CLIP,
+#             img_size=IMG_SIZE
+#         )
+        
+#         # Make prediction with custom threshold
+#         result = model.predict(video_tensor, threshold=threshold)
+#         result["filename"] = file.filename
+        
+#         logger.info(f"Prediction for {file.filename}: {result['prediction']} (conf={result['confidence']}, threshold={threshold})")
+        
+#         return JSONResponse(content=result)
+    
+#     except ValueError as e:
+#         raise HTTPException(status_code=400, detail=str(e))
+#     except Exception as e:
+#         logger.error(f"Error processing video: {e}")
+#         raise HTTPException(status_code=500, detail=f"Error processing video: {str(e)}")
+    
+#     finally:
+#         # Cleanup
+#         shutil.rmtree(temp_dir, ignore_errors=True)

app/main.py.backup

@@ -0,0 +1,423 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from fastapi.middleware.trustedhost import TrustedHostMiddleware
+import tempfile
+import shutil
+from pathlib import Path
+import logging
+import time
+import os
+from contextlib import asynccontextmanager
+
+from .config import (
+    MODEL_PATH, DEVICE, FRAMES_PER_CLIP, IMG_SIZE, 
+    MAX_FILE_SIZE, ALLOWED_EXTENSIONS, PREDICTION_THRESHOLD,
+    ALLOWED_ORIGINS, LOG_LEVEL, IS_PRODUCTION
+)
+from .model import DeepFakeModel
+from .utils import video_to_tensor, save_uploaded_video
+
+# Setup logging
+logging.basicConfig(
+    level=getattr(logging, LOG_LEVEL),
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Global model variable
+model = None
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Lifespan context manager for startup/shutdown events"""
+    global model
+    # Startup
+    logger.info("Starting up...")
+    try:
+        if not Path(MODEL_PATH).exists():
+            logger.error(f"Model file not found at {MODEL_PATH}")
+            raise FileNotFoundError(f"Model not found at {MODEL_PATH}")
+        
+        model = DeepFakeModel(MODEL_PATH, DEVICE)
+        logger.info(f"Model loaded successfully on {DEVICE}")
+    except Exception as e:
+        logger.error(f"Failed to load model: {e}")
+        model = None
+    
+    yield
+    
+    # Shutdown
+    logger.info("Shutting down...")
+
+# Initialize FastAPI with lifespan
+app = FastAPI(
+    title="DeepFake Detection API",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# Add security middleware in production
+if IS_PRODUCTION:
+    app.add_middleware(
+        TrustedHostMiddleware,
+        allowed_hosts=os.environ.get("ALLOWED_HOSTS", "*").split(",")
+    )
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=ALLOWED_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "OPTIONS"],
+    allow_headers=["*"],
+    max_age=3600,
+)
+
+# Rate limiting middleware (simple version)
+request_counts = {}
+
+@app.middleware("http")
+async def rate_limit_middleware(request: Request, call_next):
+    if IS_PRODUCTION:
+        client_ip = request.client.host
+        current_minute = int(time.time() / 60)
+        key = f"{client_ip}:{current_minute}"
+        
+        from .config import RATE_LIMIT_PER_MINUTE
+        request_counts[key] = request_counts.get(key, 0) + 1
+        
+        if request_counts[key] > RATE_LIMIT_PER_MINUTE:
+            return JSONResponse(
+                status_code=429,
+                content={"detail": "Rate limit exceeded. Please try again later."}
+            )
+        
+        # Clean old entries
+        if len(request_counts) > 1000:
+            old_keys = [k for k in request_counts.keys() 
+                       if int(k.split(':')[1]) < current_minute - 1]
+            for k in old_keys:
+                del request_counts[k]
+    
+    response = await call_next(request)
+    return response
+
+@app.get("/")
+async def root():
+    """Root endpoint with API info."""
+    return {
+        "name": "DeepFake Detection API",
+        "version": "1.0.0",
+        "status": "running",
+        "endpoints": [
+            "/health - Health check",
+            "/predict - Upload video for detection",
+            "/predict-batch - Batch prediction"
+        ]
+    }
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint for Render."""
+    return {
+        "status": "healthy" if model else "degraded",
+        "device": DEVICE,
+        "model_loaded": model is not None,
+        "threshold": PREDICTION_THRESHOLD,
+        "environment": "production" if IS_PRODUCTION else "development"
+    }
+
+@app.post("/predict")
+async def predict(file: UploadFile = File(...)):
+    """Predict if uploaded video is REAL or FAKE."""
+    if model is None:
+        raise HTTPException(status_code=503, detail="Model not loaded")
+    
+    # Validate file extension
+    file_ext = Path(file.filename).suffix.lower()
+    if file_ext not in ALLOWED_EXTENSIONS:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unsupported file type. Allowed: {', '.join(ALLOWED_EXTENSIONS)}"
+        )
+    
+    # Validate file size
+    file.file.seek(0, 2)
+    file_size = file.file.tell()
+    file.file.seek(0)
+    
+    if file_size > MAX_FILE_SIZE:
+        raise HTTPException(
+            status_code=400,
+            detail=f"File too large. Max size: {MAX_FILE_SIZE // (1024*1024)}MB"
+        )
+    
+    temp_dir = tempfile.mkdtemp()
+    
+    try:
+        # Save uploaded file
+        video_path = save_uploaded_video(file, temp_dir)
+        logger.info(f"Processing video: {file.filename} (size: {file_size} bytes)")
+        
+        # Convert video to tensor
+        video_tensor = video_to_tensor(
+            video_path,
+            num_frames=FRAMES_PER_CLIP,
+            img_size=IMG_SIZE
+        )
+        
+        # Make prediction with configured threshold
+        result = model.predict(video_tensor, threshold=PREDICTION_THRESHOLD)
+        result["filename"] = file.filename
+        
+        logger.info(f"Prediction for {file.filename}: {result['prediction']} (conf={result['confidence']})")
+        
+        return JSONResponse(content=result)
+    
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error processing video: {e}")
+        raise HTTPException(status_code=500, detail=f"Error processing video: {str(e)}")
+    
+    finally:
+        # Cleanup
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+
+# from fastapi import FastAPI, UploadFile, File, HTTPException
+# from fastapi.middleware.cors import CORSMiddleware
+# from fastapi.responses import JSONResponse
+# import tempfile
+# import shutil
+# from pathlib import Path
+# import logging
+# # /opt/anaconda3/envs/deepfake/bin/python -m uvicorn app.main:app --reload
+# from .config import MODEL_PATH, DEVICE, FRAMES_PER_CLIP, IMG_SIZE, MAX_FILE_SIZE, ALLOWED_EXTENSIONS, PREDICTION_THRESHOLD
+# from .model import DeepFakeModel
+# from .utils import video_to_tensor, save_uploaded_video
+
+# # Setup logging
+# logging.basicConfig(level=logging.INFO)
+# logger = logging.getLogger(__name__)
+
+# # Initialize FastAPI
+# app = FastAPI(title="DeepFake Detection API", version="1.0.0")
+
+# # CORS middleware
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=["http://localhost:5173", "http://localhost:3000"],  # React dev servers
+#     allow_credentials=True,
+#     allow_methods=["*"],
+#     allow_headers=["*"],
+# )
+
+# # Load model (with error handling)
+# model = None
+
+# @app.on_event("startup")
+# async def load_model():
+#     global model
+#     try:
+#         if not MODEL_PATH.exists():
+#             logger.error(f"Model file not found at {MODEL_PATH}")
+#             raise FileNotFoundError(f"Model not found at {MODEL_PATH}")
+        
+#         model = DeepFakeModel(str(MODEL_PATH), DEVICE)
+#         logger.info("Model loaded successfully")
+#     except Exception as e:
+#         logger.error(f"Failed to load model: {e}")
+#         model = None
+
+
+# @app.get("/health")
+# async def health_check():
+#     """Health check endpoint."""
+#     return {
+#         "status": "healthy" if model else "model_not_loaded",
+#         "device": DEVICE,
+#         "model_loaded": model is not None,
+#         "threshold": PREDICTION_THRESHOLD
+#     }
+
+
+# @app.post("/predict")
+# async def predict(file: UploadFile = File(...)):
+#     """
+#     Predict if uploaded video is REAL or FAKE.
+    
+#     Args:
+#         file: Video file (mp4, avi, mov, mkv)
+    
+#     Returns:
+#         Prediction result with confidence scores
+#     """
+#     if model is None:
+#         raise HTTPException(status_code=503, detail="Model not loaded")
+    
+#     # Validate file extension
+#     file_ext = Path(file.filename).suffix.lower()
+#     if file_ext not in ALLOWED_EXTENSIONS:
+#         raise HTTPException(
+#             status_code=400,
+#             detail=f"Unsupported file type. Allowed: {', '.join(ALLOWED_EXTENSIONS)}"
+#         )
+    
+#     # Validate file size
+#     file.file.seek(0, 2)
+#     file_size = file.file.tell()
+#     file.file.seek(0)
+    
+#     if file_size > MAX_FILE_SIZE:
+#         raise HTTPException(
+#             status_code=400,
+#             detail=f"File too large. Max size: {MAX_FILE_SIZE // (1024*1024)}MB"
+#         )
+    
+#     temp_dir = tempfile.mkdtemp()
+    
+#     try:
+#         # Save uploaded file
+#         video_path = save_uploaded_video(file, temp_dir)
+#         logger.info(f"Processing video: {file.filename}")
+        
+#         # Convert video to tensor
+#         video_tensor = video_to_tensor(
+#             video_path,
+#             num_frames=FRAMES_PER_CLIP,
+#             img_size=IMG_SIZE
+#         )
+        
+#         # Make prediction with configured threshold
+#         result = model.predict(video_tensor, threshold=PREDICTION_THRESHOLD)
+#         result["filename"] = file.filename
+        
+#         logger.info(f"Prediction for {file.filename}: {result['prediction']} (conf={result['confidence']})")
+        
+#         return JSONResponse(content=result)
+    
+#     except ValueError as e:
+#         raise HTTPException(status_code=400, detail=str(e))
+#     except Exception as e:
+#         logger.error(f"Error processing video: {e}")
+#         raise HTTPException(status_code=500, detail=f"Error processing video: {str(e)}")
+    
+#     finally:
+#         # Cleanup
+#         shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+# @app.post("/predict-batch")
+# async def predict_batch(files: list[UploadFile] = File(...)):
+#     """
+#     Predict for multiple videos.
+#     """
+#     if model is None:
+#         raise HTTPException(status_code=503, detail="Model not loaded")
+    
+#     results = []
+    
+#     for file in files:
+#         file_ext = Path(file.filename).suffix.lower()
+#         if file_ext not in ALLOWED_EXTENSIONS:
+#             results.append({
+#                 "filename": file.filename,
+#                 "error": f"Unsupported file type: {file_ext}"
+#             })
+#             continue
+        
+#         temp_dir = tempfile.mkdtemp()
+        
+#         try:
+#             video_path = save_uploaded_video(file, temp_dir)
+#             video_tensor = video_to_tensor(video_path, FRAMES_PER_CLIP, IMG_SIZE)
+#             result = model.predict(video_tensor, threshold=PREDICTION_THRESHOLD)
+#             result["filename"] = file.filename
+#             results.append(result)
+#         except Exception as e:
+#             results.append({
+#                 "filename": file.filename,
+#                 "error": str(e)
+#             })
+#         finally:
+#             shutil.rmtree(temp_dir, ignore_errors=True)
+    
+#     return JSONResponse(content={"results": results})
+
+
+# # Optional: Endpoint to test with custom threshold
+# @app.post("/predict-custom")
+# async def predict_custom(
+#     file: UploadFile = File(...),
+#     threshold: float = PREDICTION_THRESHOLD
+# ):
+#     """
+#     Predict with custom threshold.
+    
+#     Args:
+#         file: Video file (mp4, avi, mov, mkv)
+#         threshold: Custom threshold between 0 and 1 (default: 0.4)
+#     """
+#     if model is None:
+#         raise HTTPException(status_code=503, detail="Model not loaded")
+    
+#     # Validate threshold
+#     if threshold < 0 or threshold > 1:
+#         raise HTTPException(
+#             status_code=400,
+#             detail="Threshold must be between 0 and 1"
+#         )
+    
+#     # Validate file extension
+#     file_ext = Path(file.filename).suffix.lower()
+#     if file_ext not in ALLOWED_EXTENSIONS:
+#         raise HTTPException(
+#             status_code=400,
+#             detail=f"Unsupported file type. Allowed: {', '.join(ALLOWED_EXTENSIONS)}"
+#         )
+    
+#     # Validate file size
+#     file.file.seek(0, 2)
+#     file_size = file.file.tell()
+#     file.file.seek(0)
+    
+#     if file_size > MAX_FILE_SIZE:
+#         raise HTTPException(
+#             status_code=400,
+#             detail=f"File too large. Max size: {MAX_FILE_SIZE // (1024*1024)}MB"
+#         )
+    
+#     temp_dir = tempfile.mkdtemp()
+    
+#     try:
+#         # Save uploaded file
+#         video_path = save_uploaded_video(file, temp_dir)
+#         logger.info(f"Processing video: {file.filename}")
+        
+#         # Convert video to tensor
+#         video_tensor = video_to_tensor(
+#             video_path,
+#             num_frames=FRAMES_PER_CLIP,
+#             img_size=IMG_SIZE
+#         )
+        
+#         # Make prediction with custom threshold
+#         result = model.predict(video_tensor, threshold=threshold)
+#         result["filename"] = file.filename
+        
+#         logger.info(f"Prediction for {file.filename}: {result['prediction']} (conf={result['confidence']}, threshold={threshold})")
+        
+#         return JSONResponse(content=result)
+    
+#     except ValueError as e:
+#         raise HTTPException(status_code=400, detail=str(e))
+#     except Exception as e:
+#         logger.error(f"Error processing video: {e}")
+#         raise HTTPException(status_code=500, detail=f"Error processing video: {str(e)}")
+    
+#     finally:
+#         # Cleanup
+#         shutil.rmtree(temp_dir, ignore_errors=True)

app/model.py

@@ -0,0 +1,99 @@
+import torch
+import torch.nn as nn
+import timm
+from pathlib import Path
+import logging
+import os
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class EfficientNetDeepFakeDetector(nn.Module):
+    """Frame-level EfficientNet-B0 with temporal mean-pooling."""
+
+    FEAT_DIM = 1280
+
+    def __init__(self, dropout: float = 0.4):
+        super().__init__()
+
+        # Backbone
+        backbone = timm.create_model(
+            'efficientnet_b0',
+            pretrained=False,
+            num_classes=0,
+            global_pool='avg'
+        )
+
+        # Freeze BatchNorm layers
+        for m in backbone.modules():
+            if isinstance(m, (nn.BatchNorm2d, nn.SyncBatchNorm)):
+                m.eval()
+                for p in m.parameters():
+                    p.requires_grad = False
+
+        self.backbone = backbone
+
+        # Classifier head
+        self.head = nn.Sequential(
+            nn.LayerNorm(self.FEAT_DIM),
+            nn.Dropout(dropout),
+            nn.Linear(self.FEAT_DIM, 256),
+            nn.GELU(),
+            nn.Dropout(dropout * 0.5),
+            nn.Linear(256, 1)
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        B, T, C, H, W = x.shape
+        x = x.view(B * T, C, H, W)
+        feat = self.backbone(x)
+        feat = feat.view(B, T, self.FEAT_DIM)
+        feat = feat.mean(dim=1)
+        logit = self.head(feat).squeeze(-1)
+        return logit
+
+
+class DeepFakeModel:
+    def __init__(self, model_path: str, device: str = "cpu"):
+        self.device = torch.device(device)
+        self.model = EfficientNetDeepFakeDetector(dropout=0.4).to(self.device)
+        self._load_model(model_path)
+        self.model.eval()
+        logger.info(f"Model loaded on {self.device}")
+
+    def _load_model(self, model_path: str):
+        checkpoint = torch.load(model_path, map_location=self.device, weights_only=False)
+        self.model.load_state_dict(checkpoint['model_state_dict'])
+        logger.info(f"Loaded checkpoint from epoch {checkpoint.get('epoch', 'unknown')}")
+
+    @torch.no_grad()
+    def predict(self, video_tensor: torch.Tensor, threshold: float = 0.4) -> dict:
+        """
+        Predict if video is real or fake.
+        
+        Args:
+            video_tensor: Tensor of shape (T, 3, H, W) or (1, T, 3, H, W)
+            threshold: Decision threshold (default: 0.4 from notebook testing)
+        
+        Returns:
+            dict with prediction, confidence, and probabilities
+        """
+        if video_tensor.dim() == 4:
+            video_tensor = video_tensor.unsqueeze(0)
+
+        video_tensor = video_tensor.to(self.device)
+        logit = self.model(video_tensor)
+        prob = torch.sigmoid(logit).item()
+        
+        # prob = P(REAL), because training used label 1=REAL, 0=FAKE
+        prediction = "REAL" if prob >= threshold else "FAKE"
+        confidence = prob if prediction == "REAL" else 1 - prob
+
+        return {
+            "prediction": prediction,
+            "confidence": round(confidence, 4),
+            "probability_real": round(prob, 4),
+            "probability_fake": round(1 - prob, 4),
+            "threshold": threshold
+        }

app/utils.py

@@ -0,0 +1,154 @@
+import cv2
+import numpy as np
+import torch
+from PIL import Image
+import tempfile
+import os
+from pathlib import Path
+import logging
+
+# logger = logging.getLogger(__name__)
+
+# # ImageNet normalization constants
+# MEAN = torch.tensor([0.485, 0.456, 0.406]).view(3, 1, 1)
+# STD = torch.tensor([0.229, 0.224, 0.225]).view(3, 1, 1)
+
+
+def save_uploaded_video(upload_file, temp_dir: str) -> str:
+    """Save uploaded video to temporary file and return path."""
+    file_path = os.path.join(temp_dir, upload_file.filename)
+    with open(file_path, "wb") as buffer:
+        buffer.write(upload_file.file.read())
+    return file_path
+
+
+# def extract_frames(video_path: str, num_frames: int = 16) -> list:
+#     """Extract evenly spaced frames from video."""
+#     cap = cv2.VideoCapture(video_path)
+#     total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    
+#     if total_frames <= 0:
+#         cap.release()
+#         return []
+    
+#     indices = np.linspace(0, total_frames - 1, num=min(num_frames, total_frames), dtype=int)
+#     frames = []
+    
+#     for idx in indices:
+#         cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
+#         ret, frame = cap.read()
+#         if ret:
+#             frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+#             frames.append(frame_rgb)
+    
+#     cap.release()
+#     return frames
+# utils.py — replace extract_frames + preprocess_frame with these
+
+import cv2
+import numpy as np
+import torch
+from PIL import Image
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+MEAN = torch.tensor([0.485, 0.456, 0.406]).view(3, 1, 1)
+STD  = torch.tensor([0.229, 0.224, 0.225]).view(3, 1, 1)
+
+# Load OpenCV's face detector (ships with opencv-python, no extra install)
+_face_cascade = cv2.CascadeClassifier(
+    cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
+)
+
+def _crop_face(frame_bgr: np.ndarray, margin: float = 0.3) -> np.ndarray:
+    """
+    Detect and crop the largest face in a BGR frame.
+    Returns the face crop, or the full frame if no face found.
+    """
+    gray = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2GRAY)
+    faces = _face_cascade.detectMultiScale(
+        gray, scaleFactor=1.1, minNeighbors=5, minSize=(60, 60)
+    )
+
+    if len(faces) == 0:
+        # Fall back to centre crop (better than full frame)
+        h, w = frame_bgr.shape[:2]
+        size = min(h, w)
+        y0 = (h - size) // 2
+        x0 = (w - size) // 2
+        return frame_bgr[y0:y0+size, x0:x0+size]
+
+    # Pick the largest detected face
+    x, y, fw, fh = max(faces, key=lambda f: f[2] * f[3])
+
+    # Add margin
+    mx = int(fw * margin)
+    my = int(fh * margin)
+    H, W = frame_bgr.shape[:2]
+    x1 = max(0, x - mx)
+    y1 = max(0, y - my)
+    x2 = min(W, x + fw + mx)
+    y2 = min(H, y + fh + my)
+
+    return frame_bgr[y1:y2, x1:x2]
+
+
+def extract_frames(video_path: str, num_frames: int = 16) -> list:
+    """Extract evenly spaced frames from video, with face crop."""
+    cap = cv2.VideoCapture(video_path)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+    if total_frames <= 0:
+        cap.release()
+        return []
+
+    indices = np.linspace(0, total_frames - 1, num=min(num_frames, total_frames), dtype=int)
+    frames = []
+
+    for idx in indices:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
+        ret, frame = cap.read()
+        if ret:
+            face = _crop_face(frame)                          # <-- crop face
+            frame_rgb = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
+            frames.append(frame_rgb)
+
+    cap.release()
+    return frames
+
+def preprocess_frame(frame: np.ndarray, target_size: int = 224) -> torch.Tensor:
+    """Preprocess a single frame for model input."""
+    # Convert to PIL and resize
+    pil_img = Image.fromarray(frame).resize((target_size, target_size), Image.BILINEAR)
+    
+    # Convert to tensor and normalize to [0, 1]
+    tensor = torch.from_numpy(np.array(pil_img)).float().permute(2, 0, 1) / 255.0
+    
+    # Normalize with ImageNet stats
+    tensor = (tensor - MEAN) / STD
+    tensor = torch.nan_to_num(tensor, nan=0.0, posinf=5.0, neginf=-5.0)
+    
+    return tensor
+
+
+def video_to_tensor(video_path: str, num_frames: int = 16, img_size: int = 224) -> torch.Tensor:
+    """Convert video to tensor of shape (num_frames, 3, img_size, img_size)."""
+    frames = extract_frames(video_path, num_frames)
+    
+    if not frames:
+        raise ValueError("Could not extract frames from video")
+    
+    tensors = []
+    for frame in frames:
+        tensor = preprocess_frame(frame, img_size)
+        tensors.append(tensor)
+    
+    # Pad if needed
+    if len(tensors) < num_frames:
+        last_tensor = tensors[-1]
+        while len(tensors) < num_frames:
+            tensors.append(last_tensor.clone())
+    
+    return torch.stack(tensors)

models/ffpp_efficientnet_best.pth

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

requirements.txt

@@ -0,0 +1,12 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+torch==2.1.0
+torchvision==0.16.0
+timm==0.9.12
+opencv-python-headless==4.8.1.78
+numpy==1.24.3
+python-multipart==0.0.6
+Pillow==10.1.0
+python-dotenv==1.0.0
+python-decouple==3.8
+gunicorn==21.2.0