Análise Comparativa de Modelos para Detecção de Fraude

Este repositório contém uma "arena" de competição entre diversos modelos de Machine Learning para o clássico problema de detecção de fraude em transações de cartão de crédito. O objetivo é realizar uma análise completa, desde o pré-processamento dos dados até o treinamento, otimização e comparação final de performance dos algoritmos.

1. Sobre o Projeto
2. Dataset
3. Metodologia
4. Estrutura do Repositório
5. Como Executar
6. Resultados Finais
7. Principais Aprendizados

O principal desafio na detecção de fraudes é o severo desbalanceamento dos dados: transações fraudulentas são eventos raros. Este projeto aborda esse desafio de frente, implementando uma metodologia robusta que inclui:

• Balanceamento do conjunto de treino com SMOTE.
• Normalização de features com StandardScaler.
• Treinamento de múltiplos modelos, incluindo Regressão Logística, SVM, Redes Neurais, RandomForest e XGBoost.
• Otimização do limiar de decisão para cada modelo, visando maximizar o F1-Score e obter uma avaliação justa de seu melhor desempenho potencial.

A análise conclui que modelos de ensemble baseados em árvores (RandomForest e XGBoost) são superiores, com o XGBoost emergindo como o campeão técnico geral.

O estudo foi realizado utilizando o dataset "Credit Card Fraud Detection", disponibilizado pela ULB (Université Libre de Bruxelles).

• Link para o Dataset: Credit Card Fraud Detection no Kaggle
• Características: O dataset contém transações europeias ao longo de dois dias, com 492 fraudes em 284.807 transações (apenas 0,172%). As features são majoritariamente componentes principais (V1-V28) resultantes de uma transformação PCA, além das colunas Time e Amount.

A abordagem foi dividida em três etapas principais:

1. Pré-processamento (src/train-test-generator.py):

   • Divisão dos dados em treino (70%) e teste (30%) de forma estratificada.
   • Normalização das colunas Time e Amount do conjunto de treino e de teste.
   • Aplicação do SMOTE apenas no conjunto de treino para criar um dataset balanceado, que será usado para treinar os modelos.

2. Treinamento e Avaliação Otimizada:

   • Para cada algoritmo, um script dedicado (src/train_evaluate_..._optimized.py) foi criado.
   • Os modelos são treinados no dataset de treino balanceado.
   • As predições e a avaliação são feitas no conjunto de teste original e desbalanceado, simulando um cenário real.

3. Otimização do Limiar:

   • Após prever as probabilidades, o limiar de decisão (padrão 0.5) é ajustado.
   • Utilizando a curva Precision-Recall, o limiar que maximiza o F1-Score é encontrado.
   • As métricas finais (Matriz de Confusão, Precisão, Recall) são calculadas com base neste limiar ótimo.

fraud-detection-arena/
├── datasets/
│   ├── creditcard.csv          # Dataset original (necessário baixar)
│   ├── train_balanced.csv      # Gerado pelo script de pré-processamento
│   └── test_original.csv       # Gerado pelo script de pré-processamento
├── resultados/
│   ├── randomForest/
│   ├── logisticRegression/
│   ├── neuralNetwork/
│   ├── xgboost/
│   └── svm/                     # Pastas com as métricas e plots de cada modelo
├── src/
│   ├── train-test-generator.py # Script inicial para pré-processamento
│   ├── train_evaluate_rf_optimized.py
│   ├── train_evaluate_lr_optimized.py
│   ├── train_evaluate_nn_optimized.py
│   ├── train_evaluate_xgb_optimized.py
│   └── train_evaluate_svm_subsample.py # Script de treino/avaliação para cada modelo
├── requirements.txt             # Dependências do projeto
└── README.md                    # Este arquivo

1. Clone o repositório:

   git clone https://github.com/s4bino/fraud-detection-arena.git
   cd fraud-detection-arena

2. Crie e ative 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

4. Baixe o Dataset:

   • Faça o download do arquivo creditcard.csv a partir do link do Kaggle.
   • Coloque o arquivo creditcard.csv dentro da pasta datasets/.

5. Execute o Pré-processamento:

   python src/train-test-generator.py

6. Execute a avaliação de um modelo (ex: XGBoost):

   python src/train_evaluate_xgb_optimized.py

A tabela abaixo compara o desempenho dos três melhores modelos, já com seus limiares de decisão otimizados.

Veredito: O XGBoost se consagra como o campeão geral, oferecendo o melhor equilíbrio e a maior capacidade de detecção de fraudes. O RandomForest se destaca como o modelo mais preciso, ideal para cenários que priorizam a minimização de falsos alarmes.

• A utilização de SMOTE foi crucial para permitir que os modelos aprendessem os padrões da classe minoritária.
• A otimização do limiar de decisão é uma etapa não-negociável, transformando modelos com bom potencial (como a Regressão Logística) em soluções de negócio viáveis.
• Modelos de ensemble baseados em árvores (RandomForest, XGBoost) demonstraram maior estabilidade e performance para este tipo de dado tabular em comparação com Redes Neurais ou SVM.
• A escolha final entre os melhores modelos pode depender da estratégia de negócio: minimizar o prejuízo direto (Falsos Negativos) ou o custo operacional e o atrito com o cliente (Falsos Positivos).