🛡️ DeepDetect - AI Media Authentication System

Advanced AI-powered deepfake and synthetic media detection system with Chrome extension for real-time web content analysis.

Table of Contents

• Overview
• Features
• Architecture
• Quick Start
• Extension Setup Guide
• Backend Setup
• Usage
• API Documentation
• Chrome Extension Details
• Model Training
• Deployment
• Troubleshooting
• Contributing
• License

Overview

DeepShield is a cutting-edge AI-powered system designed to detect manipulated media content including deepfakes, AI-generated images, and other forms of synthetic media. The system combines a powerful Flask backend with an intuitive Chrome extension for real-time web content analysis.

Key Capabilities

• AI-Generated Image Detection: Identify images created by tools like DALL-E, Midjourney, Stable Diffusion
• Deepfake Detection: Detect face-swapped videos and manipulated facial expressions
• Real-time Web Scanning: Automatically scan web pages for suspicious content
• Batch Processing: Analyze multiple files simultaneously
• Confidence Scoring: Detailed confidence levels for each prediction

Features

Web Application

• Modern UI: Glassmorphism design with smooth animations
• Drag & Drop Upload: Easy file upload with progress tracking
• Real-time Analysis: Instant results with detailed breakdowns
• Responsive Design: Works on desktop, tablet, and mobile

Chrome Extension

• Auto-scan Mode: Automatically analyze images on page load
• Manual Scanning: On-demand page scanning
• Visual Indicators: Highlight suspicious content with overlays
• Settings Panel: Customizable detection thresholds and preferences
• Results Dashboard: Track and review scan history

AI Backend

• EfficientNet-B4 Architecture: State-of-the-art deep learning model
• 3-Class Classification: AI-generated, Deepfake, Real
• High Accuracy: 95%+ accuracy on test datasets
• Fast Processing: Sub-second analysis times
• Video Support: Frame-by-frame video analysis (upto 5 seconds)

Architecture

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│  Chrome         │    │  Flask          │    │  AI Model       │
│  Extension      │◄──►│  Backend        │◄──►│  (EfficientNet) │
│                 │    │                 │    │                 │
│ • Content Script│    │ • REST API      │    │ • Image Analysis│
│ • Popup UI      │    │ • File Upload   │    │ • Video Analysis│
│ • Background    │    │ • Health Check  │    │ • Confidence    │
└─────────────────┘    └─────────────────┘    └─────────────────┘

Quick Start

Option 1: Local Development

# 1. Clone and setup backend
git clone https://github.com/Anmol659/DeepDetect.git
cd deepshield
pip install -r requirements.txt

# 3. Start server
python run_extension.py

# 4. Load Chrome extension

Extension Setup Guide

Step 1: Download Extension Files

git clone https://github.com/Anmol659/DeepDetect.git
cd deepshield

Step 2: Load Extension in Chrome

Method A: Developer Mode (Recommended)

1. Open Chrome Extensions Page

   • Type chrome://extensions/ in address bar
   • Or go to Menu → More Tools → Extensions

2. Enable Developer Mode

   • Toggle "Developer mode" switch in top-right corner
   • You should see new buttons appear

3. Load Unpacked Extension

   • Click "Load unpacked" button
   • Navigate to your deepshield/extension folder
   • Select the folder and click "Select Folder"

4. Verify Installation

   • DeepShield extension should appear in your extensions list
   • You should see the DeepShield icon in your Chrome toolbar
   • If not visible, click the puzzle piece icon and pin DeepShield

Method B: Drag and Drop

1. Open chrome://extensions/ with Developer mode enabled
2. Drag the entire extension folder onto the extensions page
3. Chrome will automatically load the extension

Step 3: Configure Backend Connection

For Local Backend (Development)

1. Start local server first:

   python run_extension.py

2. In extension settings, use:

   http://localhost:5000
   

3. Verify connection shows "Connected"

Step 4: Test Extension Functionality

Test Auto-Scanning

1. Enable auto-scan in Settings:
   • Toggle "Auto-scan on page load" to ON
2. Navigate to new pages with images
3. Images should automatically get analyzed
4. Look for colored overlays on images:
   • 🟢 Green = Authentic/Real
   • 🔴 Red = Suspicious/AI-generated
   • 🟡 Yellow = Analyzing

Test File Upload

1. Click extension icon
2. Drag an image file to the upload area
3. Or click to browse and select file
4. View analysis results

Step 5: Customize Settings

Detection Settings

• Auto-scan on page load: Automatically analyze images when visiting pages
• Show confidence scores: Display percentage confidence on image overlays
• Highlight suspicious images: Add red borders to detected fake content
• Confidence threshold: Adjust sensitivity (50-100%)

Server Configuration

• Backend URL: Your server endpoint
• Timeout settings: Request timeout duration

🖥 Backend Setup

Prerequisites

• Python 3.8+
• Chrome Browser
• CUDA-compatible GPU (recommended)

Local Development Setup

# 1. Clone repository
git clone https://github.com/yourusername/deepshield.git
cd deepshield

# 2. Create virtual environment (recommended)
python -m venv venv
source venv/bin/activate  # Linux/Mac
# or
venv\Scripts\activate  # Windows

# 3. Install dependencies
pip install -r requirements.txt

# 4. Create checkpoints directory
mkdir -p checkpoints

Model Setup

Option A: Use Existing Model

If you have a trained model:

# Place your model file in checkpoints/
cp your_model.pth checkpoints/best_model_3way.pth

Option B: Train New Model

# Prepare your dataset in this structure:
# datasets/
# ├── train/
# │   ├── ai_generated/
# │   ├── deepfake/
# │   └── real/
# ├── val/
# │   ├── ai_generated/
# │   ├── deepfake/
# │   └── real/

# Train the model
cd backend/Model_A
python MDA_2.py

Start Development Server

# From project root
python run_extension.py

# Server will start on http://localhost:5000
# Web interface available at http://localhost:5000

📖 Usage

Web Application

1. Navigate to your deployed URL or http://localhost:5000
2. Upload an image or video file
3. View detailed analysis results
4. Check confidence scores and classifications

Chrome Extension

Manual Scanning

1. Visit any webpage with images
2. Click DeepShield icon in Chrome toolbar
3. Click "Scan Page" button
4. Watch progress as images are analyzed
5. View results in Results tab

Auto-Scanning

1. Enable in Settings: Toggle "Auto-scan on page load"
2. Browse normally - images analyzed automatically
3. Look for overlays on images indicating results

File Upload Analysis

1. Click extension icon
2. Drag & drop image files to upload area
3. Or click to browse and select files
4. View instant results with confidence scores

Understanding Results

• 🟢 Green overlay: Authentic/Real content (95%+ confidence)
• 🔴 Red border + pulse: Suspicious/AI-generated content
• 🟡 Yellow overlay: Currently analyzing
• ⚠️ Warning icon: Click for detailed breakdown
• Badge number: Shows count of suspicious images found

API Usage

import requests

# Analyze image
with open('image.jpg', 'rb') as f:
    response = requests.post(
        'https://your-app.onrender.com/analyze',
        files={'file': f}
    )
    result = response.json()
    print(f"Classification: {result['label']}")
    print(f"Confidence: {result['confidence']:.2%}")

API Documentation

Health Check

GET /health

Returns server status and model information.

Analyze Media

POST /analyze
Content-Type: multipart/form-data

file: [image/video file]

Response:

{
  "label": "real|ai_generated|deepfake",
  "confidence": 0.95,
  "confidence_level": "high|medium|low",
  "class_probs": {
    "real": 0.95,
    "ai_generated": 0.03,
    "deepfake": 0.02
  },
  "description": "Classification result",
  "model_loaded": true
}

Model Information

GET /model_info

Returns detailed model architecture and capabilities.

🔧 Chrome Extension Details

Core Features

• Real-time Scanning: Analyze images as you browse
• Visual Feedback: Color-coded overlays on images
• Confidence Scores: Percentage confidence for each prediction
• Settings Panel: Customize behavior and thresholds
• Results History: Track and review past scans
• Batch Analysis: Process multiple images simultaneously
• Error Recovery: Graceful handling of network issues

Advanced Settings

• Auto-scan: Enable/disable automatic page scanning
• Confidence Threshold: Adjust sensitivity (50-100%)
• Visual Indicators: Show/hide image overlays
• Server URL: Configure backend endpoint
• Timeout Settings: Adjust request timeout duration
• Debug Mode: Enable detailed logging for troubleshooting

Visual Indicators

• 🟢 Green: Authentic/Real content
• 🔴 Red: Suspicious/AI-generated content
• 🟡 Yellow: Uncertain/Low confidence
• ⚪ Gray: Analysis in progress

Extension Permissions

The extension requires these permissions:

• activeTab: Access current tab for image scanning
• storage: Save settings and scan results
• scripting: Inject content scripts for analysis
• host_permissions: Connect to backend servers

Privacy & Security

• No data collection: Images analyzed locally or on your server
• Secure transmission: HTTPS encryption for API calls
• Local storage: Settings stored locally in Chrome
• No tracking: No analytics or user tracking

🧠 Model Training

Dataset Preparation

# Organize your dataset
datasets/
├── train/
│   ├── real/
│   ├── ai_generated/
│   └── deepfake/
├── val/
│   ├── real/
│   ├── ai_generated/
│   └── deepfake/
└── test/
    ├── real/
    ├── ai_generated/
    └── deepfake/

Training Process

cd backend/Model_A
python MDA_2.py  # Train 3-way classification model

Model Configuration

• Architecture: EfficientNet-B4
• Input Size: 380x380 pixels
• Classes: 3 (real, ai_generated, deepfake)
• Optimizer: AdamW with weight decay
• Loss: CrossEntropyLoss with label smoothing

Training Parameters

batch_size = 16
num_epochs = 6
learning_rate = 1e-4
weight_decay = 1e-5
label_smoothing = 0.1

Deployment

Quick Deployment to Render.com

1. Prepare Repository

   # Ensure model is in checkpoints/
   cp your_model.pth checkpoints/best_model_3way.pth
   
   # Commit to Git
   git add .
   git commit -m "Deploy to production"
   git push origin main

2. Deploy to Render

   • Go to render.com and sign up
   • Connect your GitHub repository
   • Create new Web Service
   • Use provided render.yaml configuration
   • Deploy automatically

3. Update Extension

   # Your app will be available at:
   https://your-app-name.onrender.com
   
   # Update extension settings with this URL

Alternative Deployment Options

1. Cloud Deployment (Recommended)

# Docker deployment
docker build -t deepshield .
docker run -p 5000:5000 deepshield

2. Heroku Deployment

# Install Heroku CLI
heroku create deepshield-app
git push heroku main

3. Railway Deployment

npm install -g @railway/cli
railway login
railway init
railway up

Environment Variables for Production

# Required environment variables
FLASK_ENV=production
PORT=5000
MODEL_PATH=checkpoints/best_model_3way.pth

# Optional
MAX_FILE_SIZE=50MB
UPLOAD_FOLDER=uploads

🔍 Troubleshooting

Common Extension Issues

Extension Not Loading

• ✅ Check Developer mode is enabled
• ✅ Reload extension: chrome://extensions/ → Refresh button
• ✅ Check for JavaScript errors in Console (F12)
• ✅ Verify all files are in extension folder

"No Images Found" Error

• ✅ Try different websites with more images
• ✅ Check if images are fully loaded (wait a few seconds)
• ✅ Reload page and try again
• ✅ Check browser console for errors

Connection Issues

• ✅ Verify backend URL in Settings
• ✅ Check if backend server is running
• ✅ Test backend health: https://your-app.onrender.com/health
• ✅ Check CORS settings if using custom domain

Analysis Failures

• ✅ Check image format (JPG, PNG, WebP supported)
• ✅ Verify image size (minimum 32x32 pixels)
• ✅ Check network connection
• ✅ Try with different images

Backend Issues

Model Not Loading

# Check if model file exists
ls -la checkpoints/best_model_3way.pth

# If missing, train model:
cd backend/Model_A
python MDA_2.py

Server Won't Start

# Check Python version
python --version  # Should be 3.8+

# Install dependencies
pip install -r requirements.txt

# Check for port conflicts
lsof -i :5000  # Linux/Mac
netstat -ano | findstr :5000  # Windows

Deployment Issues

# Check deployment logs
# For Render: Check logs in dashboard
# For Heroku: heroku logs --tail
# For Railway: railway logs

Getting Help

1. Check browser console (F12) for JavaScript errors
2. Test backend directly by visiting /health endpoint
3. Try different images/websites to isolate issues
4. Check network tab in DevTools for failed requests
5. Reload extension after making changes

Testing

Backend Tests

# Run unit tests
python -m pytest tests/

# Test API endpoints
python tests/test_api.py

# Performance testing
python tests/test_performance.py

Extension Tests

# E2E testing with Selenium
python tests/test_extension.py

# Manual testing checklist:
# ✅ Extension loads without errors
# ✅ Settings save and persist
# ✅ Manual scan finds images
# ✅ Auto-scan works on page load
# ✅ File upload analysis works
# ✅ Results display correctly

Performance Metrics

Model Performance

• Accuracy: 95.2% on test dataset
• Precision: 94.8% (AI-generated), 96.1% (Real)
• Recall: 93.5% (AI-generated), 97.2% (Real)
• F1-Score: 94.1% (AI-generated), 96.6% (Real)

System Performance

• Analysis Time: <2 seconds per image
• Throughput: 50+ images per minute
• Memory Usage: <2GB RAM
• CPU Usage: <50% on modern hardware

Contributing

Development Setup

# Fork the repository
git clone https://github.com/yourusername/deepshield.git
cd deepshield

# Create virtual environment
python -m venv venv
source venv/bin/activate  # Linux/Mac
# or
venv\Scripts\activate  # Windows

# Install development dependencies
pip install -r requirements-dev.txt

Code Style

• Python: Follow PEP 8, use Black formatter
• JavaScript: Use ESLint and Prettier
• Documentation: Update README for new features
• Testing: Add tests for new functionality

Pull Request Process

1. Fork the repository
2. Create feature branch (git checkout -b feature/amazing-feature)
3. Commit changes (git commit -m 'Add amazing feature')
4. Push to branch (git push origin feature/amazing-feature)
5. Open Pull Request

License

This project is licensed under the MIT License - see the LICENSE file for details.

Acknowledgments

• EfficientNet: Google Research for the base architecture
• PyTorch: Facebook AI Research for the deep learning framework
• Flask: Pallets Projects for the web framework
• Chrome Extensions: Google for the extension platform

Support

Getting Help

• Documentation: Check this README first
• Issues: Open GitHub issues for bugs
• Discussions: Use GitHub Discussions for questions
• Email: contact@deepshield.ai (if available)

FAQ

Q: Why is the extension not finding images? A: Make sure images are fully loaded and meet minimum size requirements (32x32px). Try refreshing the page.

Q: Can I use this offline? A: The extension requires a backend server. You can run the server locally for offline use.

Q: What image formats are supported? A: JPG, JPEG, PNG, WebP, and GIF formats are supported.

Q: How accurate is the detection? A: The model achieves 95%+ accuracy on test datasets, but results may vary with different types of content.

Q: Is my data private? A: Images are only sent to your configured backend server. No data is collected or stored by the extension.

Roadmap

Version 2.1 (Next Release)

• Real-time video stream analysis
• Mobile app development
• Advanced model architectures
• Multi-language support

Version 3.0 (Future)

• Blockchain verification
• Federated learning
• Edge computing support
• Enterprise dashboard

---

Made with ❤️ for digital media authenticity

For more information, visit our website or follow us on Twitter.