L10: Deepfake Detection & Media Forensics

sudo apt update && sudo apt install -y python3-pip ffmpeg exiftool libgl1
pip3 install opencv-python-headless numpy matplotlib scipy \
    Pillow imageio scikit-learn torch torchvision

mkdir ~/deepfake-lab && cd ~/deepfake-lab
mkdir samples/real samples/fake analysis reports

# Install py-feat for facial action unit analysis (optional)
pip3 install py-feat

# Verify
python3 -c "import cv2, torch, PIL; print(f'OpenCV {cv2.__version__}, PyTorch {torch.__version__}')"

cd ~/deepfake-lab

# Download FaceForensics++ sample (requires academic registration at github.com/ondyari/FaceForensics)
# Alternative: use this public deepfake detection dataset subset
wget -P samples/ \
  "https://github.com/yuezunli/celeb-deepfakeforensics/raw/master/README.md"

# Generate synthetic "deepfake" test images using StyleGAN-generated faces
# thispersondoesnotexist.com API (public faces, no real person)
python3 << 'EOF'
import requests, os, time

print("Downloading GAN-generated faces (this-person-does-not-exist.com)...")
for i in range(10):
    resp = requests.get("https://thispersondoesnotexist.com/",
                        headers={"User-Agent": "Mozilla/5.0"})
    if resp.status_code == 200:
        with open(f"samples/fake/gan_face_{i:03d}.jpg", 'wb') as f:
            f.write(resp.content)
        print(f"  Downloaded fake face {i+1}/10")
    time.sleep(2)  # Rate limit

# Real photos: download from Flickr Creative Commons (public domain faces)
print("\nNote: Add real photos to samples/real/ for comparison")
print("Source: commons.wikimedia.org/wiki/Category:Photographs_of_people")
EOF

cat > ~/deepfake-lab/frequency_analysis.py << 'EOF'
import cv2, numpy as np, matplotlib.pyplot as plt
import os, glob

def analyze_frequency(image_path, label):
    img = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
    if img is None: return None

    # Resize to standard size
    img = cv2.resize(img, (256, 256))

    # 2D Discrete Fourier Transform
    f = np.fft.fft2(img)
    fshift = np.fft.fftshift(f)
    magnitude = 20 * np.log(np.abs(fshift) + 1)

    # GAN artifact: periodic grid pattern at specific frequencies
    # Compute radial power spectrum
    h, w = magnitude.shape
    cy, cx = h//2, w//2
    radial_power = []
    for r in range(1, min(h,w)//2):
        mask = np.zeros((h,w), bool)
        for y in range(h):
            for x in range(w):
                if abs(np.sqrt((y-cy)**2 + (x-cx)**2) - r) < 1:
                    mask[y,x] = True
        radial_power.append(magnitude[mask].mean())

    return {
        'path': image_path,
        'label': label,
        'magnitude': magnitude,
        'radial_power': np.array(radial_power),
        'mean_high_freq': np.array(radial_power[50:]).mean(),
        'std_magnitude': magnitude.std(),
    }

# Analyze samples
results = []
for f in glob.glob('samples/fake/*.jpg')[:5]:
    r = analyze_frequency(f, 'DEEPFAKE')
    if r: results.append(r)

# Plot DFT spectrums side by side
fig, axes = plt.subplots(2, len(results), figsize=(15, 6))
for i, r in enumerate(results):
    axes[0,i].imshow(cv2.imread(r['path'])[:,:,::-1])
    axes[0,i].set_title(f"{r['label']}", fontsize=8)
    axes[0,i].axis('off')
    axes[1,i].imshow(r['magnitude'], cmap='hot')
    axes[1,i].set_title(f"DFT (σ={r['std_magnitude']:.1f})", fontsize=8)
    axes[1,i].axis('off')
plt.suptitle('Frequency Domain Analysis — GAN Artifact Detection')
plt.tight_layout()
plt.savefig('analysis/frequency_analysis.png', dpi=150)
print("Saved frequency_analysis.png")

for r in results:
    print(f"\n{os.path.basename(r['path'])}")
    print(f"  Mean high-freq power: {r['mean_high_freq']:.2f}")
    print(f"  DFT std deviation:    {r['std_magnitude']:.2f}")
    print(f"  GAN artifacts: {'LIKELY' if r['std_magnitude'] > 80 else 'UNCLEAR'}")
EOF
python3 frequency_analysis.py

cat > ~/deepfake-lab/face_analysis.py << 'EOF'
import cv2, numpy as np, matplotlib.pyplot as plt, glob, os

face_cascade = cv2.CascadeClassifier(
    cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier(
    cv2.data.haarcascades + 'haarcascade_eye.xml')

def analyze_face(image_path):
    img = cv2.imread(image_path)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    faces = face_cascade.detectMultiScale(gray, 1.1, 5, minSize=(100,100))
    if len(faces) == 0:
        return {'face_detected': False}

    x, y, w, h = faces[0]
    face_roi = gray[y:y+h, x:x+w]
    face_color = img[y:y+h, x:x+w]

    # Detect eyes in face region
    eyes = eye_cascade.detectMultiScale(face_roi, 1.1, 5)

    # Laplacian for blur detection (deepfakes often have uneven sharpness)
    laplacian = cv2.Laplacian(face_roi, cv2.CV_64F)
    sharpness = laplacian.var()

    # Symmetry analysis (deepfakes can have L-R asymmetry artifacts)
    left_half = face_roi[:, :w//2]
    right_half = cv2.flip(face_roi[:, w//2:], 1)
    if left_half.shape == right_half.shape:
        symmetry_score = cv2.matchTemplate(
            left_half.astype(float), right_half.astype(float),
            cv2.TM_CCOEFF_NORMED)[0][0]
    else:
        symmetry_score = 0

    return {
        'face_detected': True,
        'face_size': (w, h),
        'eyes_detected': len(eyes),
        'sharpness': sharpness,
        'symmetry_score': float(symmetry_score),
        'face_img': face_color,
    }

results = []
for path in glob.glob('samples/fake/*.jpg')[:5]:
    r = analyze_face(path)
    r['path'] = path
    results.append(r)
    if r['face_detected']:
        print(f"\n{os.path.basename(path)}")
        print(f"  Eyes detected:  {r['eyes_detected']} (expect 2)")
        print(f"  Sharpness:      {r['sharpness']:.1f}")
        print(f"  L-R Symmetry:   {r['symmetry_score']:.3f}")
        if r['eyes_detected'] != 2:
            print(f"  [!] Unusual eye count — possible GAN artifact")
        if r['symmetry_score'] < 0.7:
            print(f"  [!] Low facial symmetry — possible manipulation")
EOF
python3 face_analysis.py