Detecção de Fraudes com Autoencoder em Python

É importante que as empresas de cartões de crédito consigam reconhecer transações fraudulentas para que os clientes não sejam cobrados por itens que não compraram.

Os dados nesta atividade contêm transações efetuadas por cartões de crédito em setembro de 2013 por portadores de cartões europeus. Este conjunto de dados apresenta transações que ocorreram em dois dias, onde temos 492 fraudes de 284.807 transações.

A primeira coisa que devemos fazer é entender o básico de nossos dados. Lembre-se, exceto pela transação e quantia que não sabemos quais são as outras colunas (devido a questões de privacidade). A única coisa que sabemos é que essas colunas que são desconhecidas já foram tradadas com PCA.

Todas as variáveis no conjunto de dados são numéricas. Os dois recursos que não foram alterados são Time and Amount. O tempo contém os segundos decorridos entre cada transação e a primeira transação no conjunto de dados.

É sempre interessante visualizarmos se temos dados faltantes NAs¶ Nossa base de dados esta completa!

Observe como o nosso conjunto de dados original é desequilibrado!

A maioria das transações não são fraudulentas. Se usarmos esse dataframe como base para nossos modelos preditivos e análise, poderemos obter muitos erros, e nossos algoritmos provavelmente se encaixarão, já que “assumiremos” que a maioria das transações não é uma fraude. Mas não queremos que nosso modelo assuma, queremos que nosso modelo detecte padrões que dão sinais de fraude!

Ao ver as distribuições, podemos ter uma ideia de como esses recursos são distorcidos, também podemos ver outras distribuições dos outros recursos. Existem técnicas que podem ajudar as distribuições a serem menos distorcidas que serão implementadas neste notebook posteriormente!

Visualmente não parece que o horário da transação realmente importa em nossa análise.

Alterando a escala dos dados e distribuindo as classes para minimizar os erros do nosso modelo.

Nesta fase de pré-processamento, iremos selecionar as colunas Time e Amount. O tempo e a quantidade devem ser escalonados como as outras colunas. Por outro lado, também precisamos criar uma sub-amostra do dataframe para ter uma quantidade igual de casos de Fraude e Não-Fraude, ajudando nossos algoritmos a entender melhor os padrões que determinam se uma transação é uma fraude ou não.

Nossa sub-amostra será um dataframe com uma proporção de 50/50 de transações fraudulentas e sem fraude. Isso significa que nossa sub-amostra terá a mesma quantidade de transações fraudulentas e não fraudulentas.

Overfitting: Nossos modelos de classificação assumirão que na maioria dos casos não há fraudes! O que queremos para o nosso modelo é ter certeza quando ocorre uma fraude, assim teremos um modelo mais generalista.

Correlações erradas: embora não saibamos o que as características “V” significam no dataset, será útil entender como cada uma dessas características influencia o resultado (Fraude ou Sem Fraude) ao ter um dataframe de desequilíbrio, não podemos ver verdadeiras correlações entre a classe e os recursos.

Agora, nosso principal objetivo é encaixar o modelo com os quadros de dados que não tinham amostras e sobrescrever (para que nossos modelos detectem os padrões) e testá-lo no conjunto de testes original.

Uma vez que determinamos quantas instâncias são consideradas transações fraudulentas (Fraude = “1”), devemos trazer as transações sem fraude para o mesmo valor das transações fraudulentas (assumindo que queremos uma relação 50/50), isto será equivalente a 492 casos de fraude e 492 casos de transações sem fraude.

Depois de implementar essa técnica, temos uma sub-amostra do nosso dataframe com uma proporção de 50/50 em relação às nossas classes. Então o próximo passo que vamos implementar é embaralhar os dados para ver se nossos modelos podem manter uma certa precisão toda vez que rodarmos este script.

O algoritmo t-SNE pode agrupar com precisão os casos que foram fraudulentos e não fraudulentos em nosso conjunto de dados.

Embora a sub-amostra seja bastante pequena, o algoritmo t-SNE é capaz de detectar clusters com bastante precisão em todos os cenários (embaralhei o conjunto de dados antes de executar o t-SNE)

Autoencoders

Os autoencoders podem parecer bastante estranhos no início. O trabalho desses modelos é prever a entrada, dada a mesma entrada. O autoencoder tenta aprender a aproximar a seguinte função de identidade:

𝑓𝑊,𝑏(𝑥)≈𝑥fW,b(x)≈x

Autoendcoders são redes neurais especiais que podem ser usadas como uma etapa de pré-processamento em sistemas de aprendizado de máquina para reduzir a dimensionalidade de um dado conjunto de dados. Essa propriedade dos autoencoders os torna ideais para o aprendizado não supervisionado de recursos, ao invés de escolher manualmente os recursos com base na intuição ou tentativa e erro. Essencialmente, eles trabalham copiando os dados de entrada para a saída, mas essa cópia não é uma réplica exata. A cópia é uma versão compactada dos dados, essa restrição força os autoencodificadores a manter apenas os recursos mais interessantes.

Aqui está uma representação visual do que um Autoencoder pode aprender:

Erro de Reconstrução

Otimizamos os parâmetros do nosso modelo de Autoencoder de forma a que um tipo especial de erro — erro de reconstrução seja minimizado. Na prática, o erro quadrático tradicional é frequentemente usado:

𝐿(𝑥,𝑥′)=||𝑥−𝑥′||2L(x,x′)=||x−x′||2

Em uma curva Receiver Operating Characteristic (ROC), a taxa positiva verdadeira (Sensibilidade) é plotada em função da taxa de falsos positivos (especificidade de 100) para diferentes pontos de corte. Cada ponto da curva ROC representa um par de sensibilidade / especificidade correspondente a um determinado limiar de decisão. Um teste com discriminação perfeita (sem sobreposição nas duas distribuições) tem uma curva ROC que passa pelo canto superior esquerdo (100% de sensibilidade, 100% de especificidade). Portanto, quanto mais próxima a curva ROC estiver do canto superior esquerdo, maior a precisão geral do teste (Zweig & Campbell, 1993).

Para prever se uma transação nova ou não é normal ou fraudulenta, calcularemos o erro de reconstrução dos próprios dados da transação. Se o erro for maior que um limite predefinido, o marcaremos como uma fraude (já que nosso modelo deve ter um erro baixo nas transações normais). Vamos escolher esse valor: