A production-ready AI video detection tool with skeleton-based structural matching, VidProM dataset integration, comprehensive preprocessing pipeline, and state-of-the-art deep learning models, featuring a React web app, Chrome extension, and cutting-edge AI detection capabilities.

Note - Previous commited versions were overwritten (cross branches forced + across different divices)

• VidProM Dataset Integration: Automated download and processing from Hugging Face
• Structural Matching: Distance-based classification using class-level embeddings
• Multi-Distance Metrics: Euclidean, Cosine, Mahalanobis, and k-NN distance calculations
• Fusion Architecture: Combines CNN predictions with skeleton matching for improved accuracy

• Novel AI Content Detection: Improved performance on unseen AI generation methods
• Cross-Source Training: Combined DFD (real) + VidProM (AI) datasets
• License-Aware Processing: Commercial-compatible content filtering (CC BY-NC 4.0 acceptable)
• Multi-Task Learning: Optional prompt embedding prediction for semantic understanding

• Deep CNN Backbones: ResNet-50, EfficientNet-B3, ConvNeXt-Tiny for superior accuracy
• Multi-Frame Aggregation: Attention-based temporal fusion for robust video analysis
• Focal Loss: Advanced loss function handling class imbalance and hard examples
• Advanced Augmentation: Realistic transformations for better generalization

• Fast Pre-screening: Metadata analysis, OCR watermark detection, logo recognition
• Early Detection: Skip expensive ML analysis when clear AI indicators are found
• C2PA Support: Placeholder for provenance chain verification
• Invisible Watermarks: Framework for SynthID and similar technologies

• Skeleton-Based Analysis: Advanced structural matching with distance analysis
• Detailed Results: Frame-by-frame analysis with structural similarity scores
• Responsive Design: Works on desktop, tablet, and mobile
• User Authentication: Email/password and Google OAuth via Supabase (optional)
• Analysis History: View and manage past video analyses
• Beautiful UI: Modern gradient design with smooth animations
• Progress Tracking: Real-time analysis progress with detailed status updates

• YouTube Integration: Analyze videos directly on YouTube
• File Upload: Upload videos from popup
• URL Analysis: Paste video URLs for analysis
• Quick Results: Get AI detection results instantly

• Skeleton-Based Detection: Structural matching with configurable fusion weights
• Advanced Video Processing: Multi-frame extraction and analysis
• URL Support: Download videos from YouTube and direct links
• Detailed Analytics: Timestamps, confidence scores, and structural similarity metrics
• Face Analysis: MediaPipe-powered face region detection
• Production Ready: Deployed on Render with comprehensive monitoring

• Skeleton Architecture: Distance-based matching to learned structural representations
• Multi-Frame Processing: Attention-based temporal aggregation
• Comprehensive Training: Focal loss, advanced augmentation, cross-validation
• Robust Evaluation: Detailed metrics, source analysis, confidence assessment

• Frontend: React 18, TypeScript, Tailwind CSS, Vite
• Backend: FastAPI (Python), OpenCV, MediaPipe, FFmpeg
• AI/ML: PyTorch, TIMM, Hugging Face Hub, scikit-learn, TensorBoard
• Skeleton Models: Distance-based matching, multi-task learning
• Datasets: VidProM (Hugging Face), DFD (Kaggle)
• Database: Supabase (PostgreSQL) - Optional
• Authentication: Supabase Auth - Optional
• Chrome Extension: Manifest V3
• Video Processing: FFmpeg, yt-dlp, MediaPipe
• OCR: EasyOCR, Tesseract
• Deployment: Netlify (frontend), Render (backend)
• Monitoring: Sentry (optional), TensorBoard

1. Frontend: Visit the deployed Netlify URL
2. Backend: Automatically connects to deployed Render backend
3. Start Analyzing: Upload videos or paste YouTube URLs immediately

• Node.js 18+
• Python 3.9+
• FFmpeg
• yt-dlp
• Tesseract OCR (optional, for watermark detection)
• CUDA-compatible GPU (optional, for skeleton model training)

# Install dependencies
npm install

# Create environment file
cp .env.example .env

# Add your backend URL to .env
echo "VITE_BACKEND_URL=http://localhost:8000" >> .env

# Start development server
npm run dev

# Navigate to backend directory
cd backend

# Create virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

# Install system dependencies (Ubuntu/Debian)
sudo apt-get install tesseract-ocr ffmpeg

# Enable skeleton-based detection (optional)
export USE_SKELETON_MODEL=true

# Start FastAPI server
python main.py

# Install skeleton detector dependencies
pip install -r ai_detector/requirements_skeleton.txt

# Download VidProM dataset
python ai_detector/scripts/download_vidprom.py --output_dir data --max_videos 1000

# Download DFD dataset (for real videos)
python ai_detector/kaggle_dfd_downloader.py --output_dir data --max_videos 1000

# Train skeleton model
python ai_detector/scripts/train_skeleton.py --dfd_dir data --vidprom_dir data --epochs 100

# Enable skeleton detection
export USE_SKELETON_MODEL=true

The backend runs on http://localhost:8000 The frontend runs on http://localhost:5173

The skeleton-based detector uses distance-based matching to structural representations:

1. Training Phase:

   • Train CNN backbone on combined DFD + VidProM data
   • Extract video-level embeddings for all training samples
   • Compute class-level statistics (skeletons) for AI and Real videos
   • Store mean, variance, and covariance information

2. Inference Phase:

   • Extract video embedding using trained backbone
   • Calculate distances to AI and Real skeletons using multiple metrics
   • Fuse base CNN prediction with skeleton distances
   • Generate structural similarity score

# Available distance calculation methods
distance_methods = [
    'euclidean',     # L2 distance to skeleton mean
    'cosine',        # Cosine similarity to skeleton mean  
    'mahalanobis',   # Mahalanobis distance using covariance
    'knn'           # Distance to k nearest neighbors
]

• Sora (OpenAI): High-quality video generation
• Runway Gen-2: Creative video synthesis
• Pika Labs: AI video creation platform
• Stable Video Diffusion: Open-source video generation
• AnimateDiff: Animation-focused generation

# Commercial-compatible licenses (CC BY-NC 4.0 acceptable for MVP)
allowed_licenses = [
    'cc-by-4.0',      # Creative Commons Attribution
    'cc-by-sa-4.0',   # Creative Commons ShareAlike
    'cc-by-nc-4.0',   # Creative Commons Non-Commercial
    'mit',            # MIT License
    'apache-2.0',     # Apache License
    'bsd-3-clause',   # BSD License
    'public-domain'   # Public Domain
]

# Download and process VidProM dataset
python ai_detector/scripts/download_vidprom.py \
    --output_dir data \
    --max_videos 1000 \
    --frames_per_video 5

# Expected output structure:
# data/ai/     ← VidProM AI-generated frames
# data/real/   ← DFD authentic frames

# Basic skeleton training
python ai_detector/scripts/train_skeleton.py \
    --dfd_dir data \
    --vidprom_dir data \
    --epochs 100 \
    --batch_size 16

# Advanced training with multi-task learning
python ai_detector/scripts/train_skeleton.py \
    --enable_multitask \
    --backbone convnext_tiny \
    --epochs 150 \
    --batch_size 8 \
    --lr 5e-4

# Custom configuration
python ai_detector/scripts/train_skeleton.py \
    --max_videos 1000 \
    --epochs 200 \
    --fusion_weight 0.6

# Fast training (ResNet-50, 3 frames)
python ai_detector/scripts/train_advanced.py \
    --model_config fast \
    --data_dir data \
    --epochs 50 \
    --batch_size 32

# Balanced training (EfficientNet-B3, 5 frames)
python ai_detector/scripts/train_advanced.py \
    --model_config balanced \
    --data_dir data \
    --epochs 100 \
    --batch_size 16

# Accurate training (ConvNeXt-Tiny, 7 frames)
python ai_detector/scripts/train_advanced.py \
    --model_config accurate \
    --data_dir data \
    --epochs 150 \
    --batch_size 8

POST /analyze-video

Multi-stage video analysis with skeleton-based detection, preprocessing pipeline, and ML classification.

Parameters:

• video (file, optional): Video file upload (max 100MB)
• video_url (string, optional): Video URL (YouTube, Vimeo, etc.)
• user_id (string, required): User identifier

Response:

{
  "overall_likelihood": 85.3,
  "analysis_results": {
    "method": "skeleton_enhanced",
    "preprocessing_details": {
      "metadata_flag": false,
      "ocr_flag": true,
      "logo_flag": false,
      "final_decision": "AI-generated (watermark)",
      "confidence_score": 0.90,
      "processing_time": 2.1
    },
    "ml_analysis": {
      "timestamps": [...],
      "total_frames": 180,
      "overall_likelihood": 85.3,
      "video_duration": 60.0,
      "analysis_fps": 3.0
    },
    "structural_similarity": {
      "ai_distance": 2.34,
      "real_distance": 5.67,
      "skeleton_probability": 0.87,
      "base_probability": 0.82,
      "distance_method": "mahalanobis"
    },
    "structural_match_score": 86.2,
    "fusion_weight": 0.5,
    "skeleton_enabled": true,
    "early_detection": false,
    "processing_time": 32.1
  },
  "processing_time": 32.1,
  "total_frames": 180
}

# Enable skeleton-based detection
export USE_SKELETON_MODEL=true

# Configure fusion weight (optional)
export SKELETON_FUSION_WEIGHT=0.6

# Set distance method (optional)  
export SKELETON_DISTANCE_METHOD=mahalanobis

# Skeleton detector configuration
detector = SkeletonBasedDetectorInference(
    model_path='weights/best_skeleton_model.pt',
    fusion_weight=0.5,  # 0=base only, 1=skeleton only
    distance_method='mahalanobis',
    threshold=0.5
)

from ai_detector.inference.skeleton_inference import SkeletonBasedDetectorInference

# Initialize skeleton detector
detector = SkeletonBasedDetectorInference('weights/best_skeleton_model.pt')

# Analyze video with structural matching
result = detector.predict_video('path/to/video.mp4')
print(f"Prediction: {result['label']} ({result['probability']:.3f})")
print(f"Structural match score: {result['structural_match_score']:.1f}%")

# Detailed structural analysis
frames = extract_frames_from_video('path/to/video.mp4')
structural_analysis = detector.analyze_structural_similarity(frames)
print(f"Distance methods: {list(structural_analysis['distance_analysis'].keys())}")

# Replace existing detection function
from ai_detector.inference.skeleton_inference import integrate_skeleton_with_existing_pipeline

def detect_frame_ai_likelihood_enhanced(frame, frame_time=0.0):
    return integrate_skeleton_with_existing_pipeline(frame, frame_time)

1. Open Chrome → Extensions → Developer mode
2. Load unpacked → Select extension folder
3. Extension appears in toolbar

1. Navigate to any YouTube video
2. Click "Truthful" button next to like/dislike
3. View results with structural similarity scores

• id: UUID primary key
• user_id: UUID reference to auth.users
• video_url: Optional video URL
• video_filename: Optional uploaded filename
• overall_likelihood: Float (0-100) AI detection percentage
• analysis_results: JSONB detailed analysis including skeleton results
• created_at: Timestamp
• updated_at: Timestamp

# Monitor skeleton training progress
tensorboard --logdir ai_detector/logs/

curl https://your-backend-url/health

Returns comprehensive system status including skeleton detector availability.

• Input Validation: Comprehensive file and URL validation
• CORS Protection: Properly configured for production domains
• Rate Limiting: Built-in protection against abuse
• Error Handling: Secure error messages without data leakage
• File Cleanup: Automatic removal of temporary files
• License Compliance: Automated filtering for commercial compatibility

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests if applicable
5. Submit a pull request

• Skeleton Improvements: New distance metrics and fusion strategies
• Dataset Expansion: Additional AI generation methods and sources
• VidProM Integration: Enhanced dataset processing and filtering
• Performance Optimization: Faster structural matching and inference
• Evaluation: Cross-dataset validation and robustness testing

MIT License - see LICENSE file for details

For issues and questions:

• Create an issue on GitHub
• Check the deployment guide in backend/deployment-guide.md
• Review the API documentation at /docs (FastAPI auto-generated)
• Check skeleton detector documentation in ai_detector/README_skeleton.md
• Monitor training with TensorBoard

• Skeleton-Based Detection: Distance-based structural matching with VidProM dataset
• Enhanced Generalization: Improved performance on novel AI generation methods
• Multi-Task Learning: Optional prompt embedding prediction for semantic understanding
• VidProM Integration: Automated dataset download and processing from Hugging Face
• License-Aware Processing: Commercial-compatible content filtering
• Fusion Architecture: Configurable combination of CNN and skeleton predictions

• Advanced AI Models: Deep CNN backbones with multi-frame aggregation
• Robust Training Pipeline: Focal loss, advanced augmentation, cross-validation
• Comprehensive Evaluation: Detailed metrics, source analysis, confidence assessment
• Enhanced Integration: Seamless preprocessing + advanced ML classification
• Production Inference: Multi-frame video analysis with temporal consistency

• Enhanced AI detection with MediaPipe face analysis
• Increased frame sampling to 3 FPS
• Added real-time progress tracking
• Production deployment on Render + Netlify
• Sentry monitoring integration

• Initial release with basic AI detection
• Supabase integration
• Chrome extension
• Basic video analysis capabilities

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   Frontend      │    │    Backend       │    │  AI Detector    │
│   (React)       │◄──►│   (FastAPI)      │◄──►│   Pipeline      │
│                 │    │                  │    │                 │
│ • Video Upload  │    │ • Preprocessing  │    │ • Skeleton      │
│ • URL Input     │    │ • ML Analysis    │    │ • Metadata      │
│ • Results UI    │    │ • Progress Track │    │ • OCR           │
│ • History       │    │ • Error Handling │    │ • Advanced ML   │
└─────────────────┘    └──────────────────┘    └─────────────────┘
         │                       │                      |
         │              ┌────────▼────────┐             │
         │              │   Supabase      │             │
         │              │   (Optional)    │             │
         │              │                 │             │
         │              │ • User Auth     │             │
         │              │ • Data Storage  │             │
         │              │ • History       │             │
         │              └─────────────────┘             │
         │                                              │
┌────────▼──────────────────────────────────────────────▼─────┐
│                Chrome Extension                             │
│                                                             │
│ • YouTube Integration                                       │
│ • Popup Interface                                           │
│ • Direct Analysis                                           │
└─────────────────────────────────────────────────────────────┘

This comprehensive AI video detection tool provides a complete solution for identifying AI-generated content with skeleton-based structural matching, fast preprocessing, and robust training pipelines, ready for production deployment and continuous improvement.