Deepfake Detection and Image Authenticity Verification

Module: Computer Vision | Difficulty: Premium

Binary Manipulation Detection

where are forensic features, is manipulation probability.

Noiseprint Analysis

where is the super-resolution reconstruction.

Provenance Chain

| Model | FaceForensics++ | Celeb-DF | DFDC | Approach | |-------|----------------|----------|------|----------| | Xception | 99.7% | 73.5% | 70.2% | CNN | | RECCE | 99.8% | 85.1% | 76.0% | Reconstruction | | SLADD | 99.9% | 90.2% | 80.1% | Latent analysis | | UnivFD | 99.5% | 92.3% | 78.5% | CLIP features |

import torch
import torch.nn as nn
import torch.nn.functional as F

class DeepfakeDetector(nn.Module):
    def __init__(self, backbone='xception', num_classes=2):
        super().__init__()
        import torchvision.models as models
        if backbone == 'xception':
            self.backbone = models.convnext_tiny(pretrained=True)
            feat_dim = 768
        self.head = nn.Sequential(
            nn.AdaptiveAvgPool2d(1),
            nn.Flatten(),
            nn.Dropout(0.5),
            nn.Linear(feat_dim, 512),
            nn.ReLU(inplace=True),
            nn.Dropout(0.3),
            nn.Linear(512, num_classes),
        )

    def forward(self, x):
        features = self.backbone.features(x)
        return self.head(features)

class FrequencyAnalyzer:
    def __init__(self):
        pass

    def compute_dct(self, image_block):
        import numpy as np
        from scipy.fft import dctn
        return dctn(image_block, type=2, norm='ortho')

    def spectral_analysis(self, image, block_size=8):
        import numpy as np
        if isinstance(image, torch.Tensor):
            image = image.cpu().numpy()
        h, w = image.shape[-2:]
        spectrum = np.zeros((h, w))
        for i in range(0, h, block_size):
            for j in range(0, w, block_size):
                block = image[..., i:i+block_size, j:j+block_size]
                dct = self.compute_dct(block)
                spectrum[i:i+block_size, j:j+block_size] = np.abs(dct)
        return spectrum

Research Insight: Deepfake detection faces a fundamental arms race: as generation quality improves, detection becomes harder. Frequency-based methods exploit artifacts in the DCT spectrum that are invisible to the human eye but detectable by neural networks. The key challenge is generalization: detectors trained on one type of deepfake often fail on others. Foundation model-based approaches (UnivFD using CLIP features) show better generalization because they leverage broad visual knowledge rather than task-specific features. The field is moving toward proactive approaches (watermarking, provenance) rather than reactive detection.