Sistema de Detecção de DeepFake

Sistema de detecção de vídeos deepfake utilizando aprendizado profundo com redes neurais convolucionais (CNN). O projeto implementa um modelo baseado na arquitetura MesoNet-4 para classificar vídeos como autênticos ou manipulados.

📋 Sobre o Projeto

Este projeto foi desenvolvido como parte de um trabalho acadêmico em Visão Computacional. O sistema utiliza técnicas de processamento de imagem e deep learning para identificar manipulações faciais em vídeos, analisando características sutis que distinguem vídeos reais de deepfakes.

Objetivos

• Desenvolver um modelo de classificação binária para detectar deepfakes
• Extrair e analisar características faciais de vídeos
• Implementar uma interface web interativa para análise de vídeos
• Avaliar a performance do modelo com métricas detalhadas

🎯 Resultados Obtidos

Métricas de Performance

O modelo treinado alcançou os seguintes resultados no conjunto de teste:

Métrica	Valor
Acurácia	81.25%
Precisão Média	86.36%
Recall Médio	81.25%
F1-Score Médio	80.57%

Métricas por Classe

Classe Real

• Precisão: 100.00%
• Recall: 62.50%
• F1-Score: 76.92%

Classe Falso

• Precisão: 72.73%
• Recall: 100.00%
• F1-Score: 84.21%

Visualizações Detalhadas

Matriz de Confusão

A matriz de confusão mostra a distribuição das predições corretas e incorretas:

Análise:

• Verdadeiros Positivos (Real): 8 vídeos reais classificados corretamente
• Verdadeiros Negativos (Falso): 5 vídeos falsos classificados corretamente
• Falsos Positivos: 3 vídeos falsos classificados como reais
• Falsos Negativos: 0 vídeos reais classificados como falsos

Comparação de Métricas

Comparação detalhada entre as classes Real e Falso:

Observações:

• A classe Real apresenta precisão perfeita (100%), mas recall menor (62.5%)
• A classe Falso apresenta recall perfeito (100%), mas precisão menor (72.73%)
• O modelo é mais conservador ao classificar vídeos como reais, preferindo errar no sentido de marcar falsos como reais

🛠️ Tecnologias Utilizadas

• Python 3.9
• TensorFlow/Keras 2.15.0: Framework de deep learning
• OpenCV: Processamento de vídeo e detecção facial
• Streamlit: Interface web interativa
• scikit-learn: Métricas de avaliação
• NumPy: Processamento numérico
• Matplotlib/Seaborn: Visualização de dados
• Jupyter Notebooks: Análise e experimentação

📁 Estrutura do Projeto

deep-fake-detection/
├── app/
│   └── app.py                 # Interface Streamlit
├── data/
│   ├── fake/                  # Vídeos falsos (49 vídeos)
│   └── real/                  # Vídeos reais (49 vídeos)
├── data_split/
│   ├── train/                 # Conjunto de treino (70%)
│   ├── val/                   # Conjunto de validação (15%)
│   └── test/                  # Conjunto de teste (15%)
├── data_faces/
│   ├── train/                 # Faces extraídas para treino
│   └── val/                   # Faces extraídas para validação
├── docs/
│   ├── confusion_matrix.png   # Matriz de confusão
│   ├── general_metrics.png    # Métricas gerais
│   ├── metrics_by_class.png   # Métricas por classe
│   └── comparison_metrics.png # Comparação de métricas
├── models/
│   ├── deepfake_detector.h5   # Modelo treinado
│   ├── deepfake_detector_best.h5  # Melhor modelo (checkpoint)
│   └── metrics.json           # Métricas de avaliação
├── notebooks/
│   ├── 01_preprocessing_deterministic.ipynb  # Pré-processamento
│   ├── 02_model_training.ipynb               # Treinamento
│   └── 03_evaluation.ipynb                   # Avaliação
├── src/
│   └── data_split.py          # Script de divisão do dataset
└── requirements.txt           # Dependências do projeto

🚀 Instalação

Pré-requisitos

• Python 3.9 ou superior
• pip ou conda

Passos de Instalação

1. Clone o repositório:

git clone <url-do-repositorio>
cd deep-fake-detection

2. Crie um ambiente virtual (recomendado):

python -m venv .venv
source .venv/bin/activate  # No Windows: .venv\Scripts\activate

3. Instale as dependências:

pip install -r requirements.txt

📖 Como Usar

1. Preparação dos Dados

Primeiro, divida o dataset em treino, validação e teste:

python src/data_split.py

Isso criará a estrutura data_split/ com as divisões apropriadas.

2. Treinamento do Modelo

Execute o notebook 02_model_training.ipynb na seguinte ordem:

1. Preparação dos Dados: Extração de faces dos vídeos
2. Configuração dos Geradores: Data augmentation e normalização
3. Arquitetura do Modelo: Definição da CNN baseada em MesoNet-4
4. Treinamento: Execução com callbacks e otimizações

O modelo será salvo em models/deepfake_detector.h5 e o melhor modelo em models/deepfake_detector_best.h5.

3. Avaliação

Execute o notebook 03_evaluation.ipynb para:

• Avaliar o modelo no conjunto de teste
• Gerar métricas detalhadas
• Visualizar matriz de confusão
• Salvar resultados em models/metrics.json

4. Interface Web (Streamlit)

Execute a aplicação web interativa:

streamlit run app/app.py

A interface permite:

• Upload de vídeos para análise
• Preview do vídeo com controles de play/pause
• Visualização de resultados detalhados
• Análise frame a frame
• Gráficos e métricas interativas

🏗️ Arquitetura do Modelo

O modelo utiliza uma arquitetura CNN inspirada na MesoNet-4:

Input: (128, 128, 3)
├── Conv2D(8, 3x3) + BatchNorm + MaxPooling
├── Conv2D(8, 5x5) + BatchNorm + MaxPooling
├── Conv2D(16, 5x5) + BatchNorm + MaxPooling
├── Conv2D(16, 5x5) + BatchNorm + MaxPooling
├── Flatten
├── Dropout(0.4) + Dense(16)
├── Dropout(0.4)
└── Dense(1, sigmoid) → Output: [0, 1]

Parâmetros Totais: 15,785 (61.66 KB)

Hiperparâmetros

• Learning Rate: 0.001 (com scheduler)
• Batch Size: 16
• Épocas: 50 (com early stopping)
• Dropout: 0.4
• Otimizador: Adam (legacy para Mac M1/M2)
• Loss Function: Binary Crossentropy

📊 Dataset

O dataset utilizado contém:

• 98 vídeos no total

  • 49 vídeos reais
  • 49 vídeos falsos

• Divisão:

  • Treino: 68 vídeos (34 real + 34 fake)
  • Validação: 14 vídeos (7 real + 7 fake)
  • Teste: 16 vídeos (8 real + 8 fake)

• Processamento:

  • Extração de até 15 faces por vídeo
  • Redimensionamento para 128x128 pixels
  • Data augmentation no treino

🔍 Pipeline de Processamento

1. Extração de Faces: Detecção facial usando Haar Cascades
2. Pré-processamento: Redimensionamento e normalização
3. Treinamento: Modelo CNN com data augmentation
4. Avaliação: Predição em múltiplos frames e agregação robusta
5. Visualização: Interface web para análise interativa

📈 Métricas de Treinamento

O modelo foi treinado com as seguintes configurações:

• Early Stopping: Patience de 5 épocas
• ReduceLROnPlateau: Redução de LR quando val_loss para de melhorar
• ModelCheckpoint: Salvamento automático do melhor modelo

O treinamento parou na época 14 devido ao early stopping, alcançando:

• Val Accuracy: 86.19% (melhor modelo)
• Val Loss: 0.3741 (melhor modelo)

🔬 Métodos Determinísticos

O projeto também implementa métodos determinísticos de análise (notebook 01):

• Análise de Bordas: Variância Laplaciana para detectar desfoque
• Análise Espectral: FFT para identificar artefatos no domínio da frequência

📝 Notas Técnicas

• O modelo utiliza detecção facial com Haar Cascades do OpenCV
• Frames são processados a cada 5 frames para eficiência
• A agregação de predições usa mediana com trimming de outliers (percentis 25-75)