Como Bancos e Fintechs Detectam Fraudes: Da Ilusão da Acurácia ao Ensemble de Isolation Forest e Autoencoders

1. O Paradoxo do Desbalanceamento Extremo em Dados Financeiros

No universo de cartões de crédito, Pix e pagamentos online, a proporção entre transações genuínas e fraudulentas é esmagadora. Em uma base típica de 488.000 transações de uma fintech de médio porte, é comum encontrar cerca de 2.400 fraudes confirmadas — uma taxa de apenas 0,49%, equivalente a uma proporção de 1 fraude para cada 204 transações legítimas.

Esse cenário impõe um desafio metodológico crítico. Se um cientista de dados treinar um classificador qualquer e avaliar seu desempenho puramente por acurácia global, um modelo nulo — que simplesmente carimba toda e qualquer transação como legítima — exibirá 99,51% de acurácia. No entanto, o sistema terá detectado zero fraudes e causado 100% de prejuízo em chargebacks.

Portanto, métricas de avaliação que dependem da contagem de Verdadeiros Negativos (TN) são estruturalmente inadequadas para ambientes com desbalanceamento severo, exigindo métricas orientadas à precisão cirúrgica e à capacidade de captura da minoria.

2. Por que o ROC-AUC Engana: A Supremacia da Curva Precision-Recall

Uma das armadilhas mais frequentes em ciência de dados financeira é a utilização acrítica da curva ROC (Receiver Operating Characteristic) e sua respectiva área sob a curva (ROC-AUC). A taxa de falsos positivos na curva ROC é dada por FPR = FP / (FP + TN).

Como o número de verdadeiros negativos (TN) é gigantesco (mais de 485.000 transações legítimas), o denominador (FP + TN) permanece enorme, mesmo quando o modelo bloqueia erroneamente 5.000 clientes legítimos. O resultado matemático é que o FPR parece ínfimo (em torno de 1%), gerando curvas ROC com AUC aparentemente estelar (> 0,98) que camuflam um sistema inaceitável para a operação comercial.

Em contrapartida, a Curva Precision-Recall (PR-AUC) ignora completamente os verdadeiros negativos no denominador: Precision = TP / (TP + FP) e Recall = TP / (TP + FN). Se o modelo cometer 5.000 falsos positivos para capturar 2.000 fraudes, a precisão desaba imediatamente para 28,5%. A PR-AUC reflete com precisão matemática a experiência do cliente e o impacto financeiro real da operação anti-fraude.

3. Engenharia de Variáveis Comportamentais & Janelas Móveis

Nenhum modelo de Machine Learning supera a qualidade de sua engenharia de atributos (feature engineering). Em fraudes transacionais, variáveis estáticas (como gênero ou idade do titular) possuem poder preditivo residual. O verdadeiro sinal reside no comportamento dinâmico e na quebra de padrões temporais e espaciais.

As variáveis mais determinantes desenvolvidas na arquitetura anti-fraude moderna incluem:

• Z-Score do Valor da Transação: Mede o número de desvios padrão que o valor da transação atual se afasta da média histórica do titular nos últimos 90 dias: Z = (Valor - μ) / σ. Transações com |Z| > 3.5 ativam alertas imediatos.

• Velocidade Transacional em Janela Móvel: Contagem agregada do número de transações nas últimas 1h, 6h e 24h para o mesmo cartão. Padrões de testagem rápida de cartão (card testing) exibem surtos de mais de 6 transações em 5 minutos.

• Distância Geográfica e 'Viagem Impossível': Distância euclidiana ou geodésica entre as coordenadas da transação atual e da anterior, dividida pelo intervalo de tempo decorrido. Se a velocidade inferida ultrapassar 700 km/h sem registro prévio de aeroporto, a transação possui probabilidade quase nula de legitimidade humana.

• Desvio de Perfil Horário (KDE): Estimativa de densidade por kernel (KDE) da distribuição histórica de horários do portador. Transações efetuadas na madrugada (03h às 05h) por clientes com histórico estritamente diurno representam uma anomalia comportamental de alta relevância.

4. A Mecânica do Isolation Forest: Isolamento Rápido no Espaço Amostral

Enquanto métodos tradicionais de aprendizado supervisionado buscam traçar fronteiras que separam classes conhecidas, o Isolation Forest adota uma perspectiva radicalmente diferente: isolar anomalias diretamente em vez de modelar a normalidade.

A premissa matemática do algoritmo (proposto por Liu, Ting e Zhou) é elegante: anomalias são 'poucas e diferentes'. Em uma árvore de isolamento (iTree), partições aleatórias são criadas escolhendo aleatoriamente um atributo e um valor de corte entre o mínimo e o máximo desse atributo.

Pontos normais, que pertencem a aglomerados densos, exigem muitas divisões sucessivas para serem individualizados (caminhos profundos na árvore). Já transações fraudulentas, situadas em regiões esparsas do espaço de features, são rapidamente isoladas em nós próximos à raiz (caminhos curtos). A pontuação de anomalia s(x, n) é inversamente exponencial ao comprimento médio do caminho percorrido através de um conjunto de 300 árvores florestais.

5. Deep Learning Não-Supervisionado: Autoencoders em PyTorch

Para complementar a detecção não linear baseada em árvores, o sistema incorpora um Autoencoder Neural undercomplete implementado em PyTorch. A filosofia do Autoencoder é fascinante: ele é treinado exclusivamente com transações legítimas para aprender uma representação comprimida (manifold de baixa dimensão) do tráfego comum.

A rede é estruturada em uma arquitetura simétrica 'funil': o Encoder reduz a dimensionalidade do vetor de features de 8 para 32, depois 16 e finalmente um gargalo (bottleneck) de apenas 4 neurônios com ativação LeakyReLU e regularização Dropout. Em seguida, o Decoder reconstrói o vetor original.

Quando o modelo opera em inferência e recebe uma transação legítima, ele a comprime e a reconstrói com altíssima fidelidade (erro de reconstrução MSE baixo). Porém, ao se deparar com uma transação fraudulenta, cujos padrões nunca foram observados durante o aprendizado do gargalo, a rede falha em reconstruir o sinal original, fazendo o erro quadrático médio (MSE) disparar em ordens de magnitude.

import torch
import torch.nn as nn
import torch.optim as optim
import polars as pl
from sklearn.preprocessing import RobustScaler

# 1. Arquitetura Neural do Autoencoder Undercomplete
class FraudAutoencoder(nn.Module):
    def __init__(self, input_dim: int = 8, latent_dim: int = 4):
        super().__init__()
        # Encoder: compressão para representação latente
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, 32),
            nn.BatchNorm1d(32),
            nn.LeakyReLU(0.1),
            nn.Dropout(0.15),
            nn.Linear(32, 16),
            nn.BatchNorm1d(16),
            nn.LeakyReLU(0.1),
            nn.Linear(16, latent_dim),
        )
        # Decoder: reconstrução do vetor original
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, 16),
            nn.BatchNorm1d(16),
            nn.LeakyReLU(0.1),
            nn.Dropout(0.15),
            nn.Linear(16, 32),
            nn.BatchNorm1d(32),
            nn.LeakyReLU(0.1),
            nn.Linear(32, input_dim),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        latent = self.encoder(x)
        return self.decoder(latent)

# 2. Treinamento Semi-Supervisionado: Apenas Transações Legítimas
def train_autoencoder(X_normal_tensor: torch.Tensor, epochs: int = 50, batch_size: int = 512):
    model = FraudAutoencoder(input_dim=8, latent_dim=4)
    criterion = nn.MSELoss(reduction='none')
    optimizer = optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-5)
    
    dataset = torch.utils.data.TensorDataset(X_normal_tensor)
    loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)
    
    model.train()
    for epoch in range(epochs):
        for (batch_x,) in loader:
            optimizer.zero_grad()
            reconstructed = model(batch_x)
            loss = criterion(reconstructed, batch_x).mean()
            loss.backward()
            optimizer.step()
            
    return model

# 3. Score de Anomalia via Reconstruction Error (MSE por amostra)
def compute_anomaly_scores(model: FraudAutoencoder, X_test_tensor: torch.Tensor) -> torch.Tensor:
    model.eval()
    criterion = nn.MSELoss(reduction='none')
    with torch.no_grad():
        reconstructed = model(X_test_tensor)
        # Erro quadrático médio por linha (sample-wise MSE)
        sample_mse = criterion(reconstructed, X_test_tensor).mean(dim=1)
    return sample_mse

6. Decisão Baseada em Custo: A Matriz de Perda Financeira Assimétrica

O maior pecado de um sistema preditivo em produção é desacoplar o algoritmo da realidade econômica do negócio. Em problemas de fraude, os custos de classificação errônea são brutalmente assimétricos:

• Falso Positivo (FP): Uma transação legítima é bloqueada ou enviada para step-up/biometria. O custo decorre de fricção, ligação para a central de atendimento e eventual desistência de compra (churn). Estima-se em R$ 15,00 por ocorrência.

• Falso Negativo (FN): Uma fraude passa despercebida. O banco arca com o chargeback integral, multa da bandeira e perda de capital. O custo médio verificado em carteiras corporativas é de R$ 3.500,00 por evento não capturado.

Isso significa que um Falso Negativo é 233 vezes mais custoso do que um Falso Positivo. Se adotássemos o threshold padrão de 0.50, otimizado para acurácia ou F1-score simétrico, estaríamos gerando um sangramento financeiro desnecessário.

A decisão correta exige calcular a Função de Perda Total Esperada: L(θ) = C_FP × FP(θ) + C_FN × FN(θ). O threshold ótimo θ* é encontrado minimizando L(θ) ao longo de todo o espectro de probabilidade. No caso estudado, o limiar ótimo situou-se em 0.65, permitindo capturar 91,8% das fraudes com uma taxa de falsos positivos de apenas 0,30%, garantindo um ROI de R$ 299 em fraudes poupadas para cada R$ 1 de custo operacional.

7. Conclusão: Arquitetura de Produção e o Trade-off entre Fricção e Perda

Sistemas modernos de detecção de fraudes não dependem de um 'oráculo' isolado, mas de uma orquestração de camadas especializadas. A união entre a velocidade de inferência do Isolation Forest e a capacidade de representação do Autoencoder neural em PyTorch cria uma barreira resiliente contra ataques de engenharia social, clonagem de cartões e lavagem de capitais.

Além disso, a introdução de políticas sensíveis ao custo transforma o departamento de prevenção a fraudes de um centro de custos reativo em uma unidade geradora de eficiência patrimonial mensurável.

O futuro do setor reside na personalização dinâmica de thresholds por perfil de titular (contextual scoring) e na inferência em tempo real com pipelines vetorizados em C++/Rust com tempo de resposta inferior a 25 milissegundos por autorização.