Detecção de Fraudes em Cartões de Crédito com Algoritmos de Machine Learning

Apenas no Brasil, de acordo com a pesquisa da CNDL/SPC Brasil mostra que 59% dos internautas sofreram algum tipo de fraude financeira nos últimos 12 meses, contra 46% em 2019. Isso corresponde a um contingente 16,7 milhões de brasileiros. O estudo estima que o prejuízo decorrente de fraudes financeiras sofridas no universo dos internautas brasileiros chegou a R$ 2,7 bilhões nos últimos 12 meses, incluídos os gastos na busca de reparação do problema.

Dentre essas fraudes, aquelas envolvendo cartões de crédito são de grande relevância uma vez que não sendo detectado acarretará em prejuízos consideráveis, tanto para o consumidor quanto para a instituição financeira.

Um outro fator a ser considerado é a quantidade de falsos positivos, ou seja, aquelas vezes em que você tentou fazer uma compra e teve seu cartão bloqueado preventivamente - o que provavelmente gerou estresse e constrangimento.

Por todos esses motivos, o investimento na área de detecção de fraudes por meio de Inteligência Artificial vem crescendo a cada ano, representando uma grande oportunidade em Data Science.

Devido ao enorme volume de dados de cada cliente e cada atividade financeira, um algoritmo de Machine Learning pode ser utilizado para identificar com eficácia padrões suspeitos nas transações. Para aumentar a precisão das análises, muitas instituições estão investindo no aprimoramento de algoritmos de Inteligência Artifical. E esse é o desafio, aprimorar cada vez mais o uso de algoritmos visando inibir ou evitar transações fraudulentas.

Sobre os Dados

O dataset utilizado neste projeto foi retirado do Kaggle e contém operações financeiras realizadas em Setembro de 2013 que ocorreram no perído de dois dias.

Podemos observar que o dataset é bastante desbalanceado, uma vez que possui 492 fraudes das 284.807 transações, correspondendo há cerca de 0,17% do total.

Todas as features do dataset são numéricas. Devido ao sigilo do cliente, as colunas foram renomeadas para V1, V2, …, V28, e suas variáveis passaram por uma transformação PCA, que consiste em reduzir a dimensionalidade do dataset, ou seja, diminuir a quantidade de variáveis do mesmo. Para saber mais sobre PCA veja neste link.

# importar os pacotes necessários
import pandas  as pd
import numpy   as np
import seaborn as sns
import scikitplot as skplt
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split
from sklearn.preprocessing   import StandardScaler
from sklearn.linear_model    import LogisticRegression
from sklearn.tree    import DecisionTreeClassifier
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix, classification_report, roc_auc_score, roc_curve, accuracy_score

from imblearn.under_sampling import RandomUnderSampler

import warnings
warnings.filterwarnings("ignore")

# configurar o estilo dos gráficos com o Seaborn
sns.set_style('dark')

#importar os dados para um dataframe
df = pd.read_csv("https://www.dropbox.com/s/b44o3t3ehmnx2b7/creditcard.csv?dl=1")

Os dados fornecidos pelo Kaggle estão prontos para uso e não precisam de qualquer alteração. Podemos passar para a análise exploratória a fim de preparar um modelo de Machine Learning.

Análise Exploratória

Olhando as cinco primeiras entradas do dataframe é possível tirar algumas conclusões:

• A transformação PCA alterou as variáveis V1-v28 para numéricas, garantindo o anonimato dos dados.

• As duas únicas exceções foram as variáveis Time e Amount, contendo os segundos decorridos entre cada transação e a primeira transação no dataset, e o valor da transação, respectivamente.

• A feature Class é a variável alvo e assume os valores:

  0 - para transações regulares

  1 - para transações fraudulentas

df.head()

Verificando abaixo o resumo estatístico por meio do método describe() podemos confirmar que as variáveis relativas aos componentes principais (transformação PCA) não têm nenhuma discrepância aparente, bem como a variável Time.

Nota-se que a variável Amount tem um valor médio de 88.34 e uma mediana de 22. O desvio padrão é de 250.12 e temos um valor máximo em uma transação de 25.961,16.

df.describe()

Quanto à qualidade do dataset, este não apresentou nenhum valor ausente ou que demandasse uma etapa de limpeza, então estamos prontos para seguir em frente.

# verificar se há valores nulos
df.isnull().sum().max()

0

Como foi informado na descrição dos dados, as entradas relativas à transações fraudulentas correspondam a 0,17% do total. Vamos verificar essa discrepância no gráfico abaixo.

# plotar gráfico de barras para as Classes
fig, ax = plt.subplots()
sns.countplot(x='Class', data=df)
ax.set_title('Distribuição das Classes')
plt.show()

Agora vamos verificar a distribuição das duas classes ao longo do tempo. No entanto, não foi identificada nenhum informação a partir das distribuições de frequência abaixo.

fig, ax = plt.subplots(nrows=2, ncols=1, figsize=(12,6))

ax[0].hist(df.Time[df.Class == 0], bins=40)
ax[0].set_title('Transações regulares')
ax[0].set_xlabel('Tempo (segundos)')
ax[0].set_ylabel('Quantidade')
plt.tight_layout()

ax[1].hist(df.Time[df.Class == 1], bins=40)
ax[1].set_title('Transações fraudulentas')
ax[1].set_xlabel('Tempo (segundos)')
ax[1].set_ylabel('Quantidade')
plt.tight_layout()

Embora o número de transações fraudulentas seja significativamente menor do que o número de transações regulares, podemos ver um comportamento distinto, especialmente em torno da marca de tempo 100.000.

Observe que o número de transações regulares cai drasticamente em torno da marca de 90.000 segundos, para aumentar novamente em torno da marca de 110.000 segundos. Não seria absurdo supor que esse período seja durante a noite, quando as pessoas naturalmente realizam menos compras do que durante o dia. Por outro lado, um grande número de transações fraudulentas ocorreram em torno da marca de 100.000, o que poderia confirmar a premissa anterior, considerando que os fraudadores devem preferir cometer fraudes tarde da noite, supondo que haveria menos vigilância.

Isso é apenas uma hipótese. Vamos esperar para ver como nosso modelo de Machine Learning interpretará esses números.

Podemos fazer a mesma análise utilizando a variável Amount de cada transação.

fig, ax = plt.subplots(nrows=2, ncols=1, figsize=(12,6))

ax[0].hist(df.Amount[df.Class == 0], bins=20)
ax[0].set_title('Transações regulares')
ax[0].set_xlabel('Valor')
ax[0].set_ylabel('Quantidade')
plt.tight_layout()

ax[1].hist(df.Amount[df.Class == 1], bins=20)
ax[1].set_title('Transações fraudulentas')
ax[1].set_xlabel('Valor')
ax[1].set_ylabel('Quantidade')
plt.tight_layout()

Quanto ao valor das transações, aparentemente não há um insight significativo que possamos obter delas. A maioria das transações, regulares e fraudulentas, eram de valores “pequenos”. Como vimos anteriormente, a maioria das transações são de menos de 100.00.

No entanto, podemos realizar uma inspeção mais profunda com um gráfico de boxplot.

Usamos o boxplot para ver se há alguma diferença no padrão transações em relação à dimensão Amount. De uma maneira geral, percebe-se uma distribuição diferente para as duas classes, o que provavelmente irá contribuir para o treinamento do modelo de Machine Learning.

fig, ax = plt.subplots(figsize=(6,10), sharex=True)
sns.boxplot(df.Class, df.Amount, showmeans=True, ax=ax)
plt.ylim((-20, 400))
plt.xticks([0, 1], ['Normal', 'Fraude'])
plt.tight_layout()

Vamos plotar um gráfico de matriz de correlação para determinar a correlação entre as variáveis.

#cria uma variável que recebe a função corr(), que calcula a correlação entre as colunas.
corr = df.corr()

#plota um gráfico de correlação utilizando a variável criada com a função corr()
fig, ax = plt.subplots(figsize=(9, 7))
sns.heatmap(corr, xticklabels=corr.columns, yticklabels=corr.columns,
            linewidths=.1, cmap="coolwarm", ax=ax)
plt.tight_layout()

Não foi observado nenhuma correlação forte entre as variáveis.

Preparando os dados

Padronizar as variáveis Time e Amount

Este é um passo essencial para que os dados sejam interpretados de forma correta pelo algoritmo de Machine Learning. Uma vez que a coluna Amount possui outliers, será usada a padronização por meio da classe StandardScaler.

#criar uma cópia do dataframe
df_clean = df.copy()

#padronizar as colunas Time e Amount
std_scaler = StandardScaler()
df_clean['std_amount'] = std_scaler.fit_transform(df_clean['Amount'].values.reshape(-1,1))
df_clean['std_time'] = std_scaler.fit_transform(df_clean['Time'].values.reshape(-1,1))

df_clean.drop(['Time', 'Amount'], axis=1, inplace=True)

Após a padronização vamos verificar como ficou o dataframe:

df_clean.head()

Dividir entre conjuntos de treino e teste

Depois de padronizar as features Time e Amount, vamos dividir o dataset em treino e teste. Caso contrário, não teremos parâmetros para conferir se no momento do balanceamento dos dados foi adequado. Usaremos a divisão padrão para o conjunto de teste de 25%. Para garantir que os conjuntos de treino e teste tenham a mesma quantidade de classes proporcionalmente, passamos o parâmetro stratify=True.

#separar target vector da feature matrix
X = df_clean.drop('Class', axis=1)
y = df_clean['Class']

#dividir entre treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, shuffle=True)

Balanceamento dos dados

Como mencionado antes, o dataset está bastante desbalanceado. Como existe uma grande diferença na distribuição das classes(284.315 classe 0 e 492 classe 1) o conjunto de treino pode ser tendencioso e influenciar o algoritmo de Machine Learning a exibir resultados desbalanceados, por exemplo, ignorando a classe com menos entradas.

Para resolver esse problema, vamos usar a biblioteca imblearn e aplicar técnicas de balanceamento de dados. Existem duas abordagens principais para isso, sendo:

• Random Oversampling: Duplica aleatoriamente observações da classe de menor ocorrência utilizando RandomOverSampler()
• Random Undersampling: Exclui aleatoriamente observações da classe de maior ocorrência utilizando RandomUnderSampler()

Utilizaremos o Random Undersamping.

#usar técnica de undersampling
rus = RandomUnderSampler()
X_rus, y_rus = rus.fit_sample(X_train, y_train)

Vamos verificar como ficou os dados após o balanceamento:

print(pd.Series(y_rus).value_counts())
sns.countplot(y_rus);

1    369
0    369
dtype: int64

Nós balanceamos os dados, com 369 entradas para cada classe. Vamos verificar a matriz de correlação novamente para ver se podemos determinar alguma correlação.

#plotar matriz de correção
corr = X_train.corr()
corr_rus = pd.DataFrame(X_rus).corr()

fig, ax = plt.subplots(figsize = (9,7))
fig.suptitle('Matriz de Correlação')

sns.heatmap(corr_rus, xticklabels=corr.columns, yticklabels=corr.columns,
            linewidths=.1, cmap="coolwarm", ax=ax[1])
ax[1].set_title('Balanceado')

plt.show()

Observe como anteriormente, sem o balanceamento de dados, a matriz de correlação não trazia nenhuma informação relevante. Entretanto, ela traz muito mais informações após um correto balanceamento.

Modelo de Machine Learning

Com todos os dados preparados e após uma análise exploratória completa ,vamos utilizar dois dos principais métodos de classificação de Machine Learning:

• Regressão Logística
• Decision Tree

Após instanciar o modelo, o mesmo será treinado em cima dos dados em X_rus e y_rus. Na sequência, serão realizadas as previsões sobre os dados de teste.

Regressão Logística

O modelo de Regressão Logística é usado para determinar as chances de uma determinada classe ou evento existir. No nosso caso, vai estabelecer a probabilidade de uma transação pertencer a classe 0 ou 1, ou seja, regular ou fraudulenta.

#instanciar e treinar o modelo de Regressão Logística
model_lr = LogisticRegression(random_state=0)
model_lr.fit(X_rus, y_rus)

y_pred_lr = model_lr.predict(X_test)

Vamos avaliar a acurácia do modelo usando o classification_report, roc_auc_score e confusion_matrix.

# exibir o relatório de classificação
print(classification_report(y_test, y_pred_lr))

# imprimir o score AUC
print("ROC AUC score: {:.2f}\n".format(roc_auc_score(y_test, y_pred_lr)))


# plotar a matriz de confusão
skplt.metrics.plot_confusion_matrix(y_test, y_pred_lr, normalize=True);

              precision    recall  f1-score   support

           0       1.00      0.97      0.98     71079
           1       0.05      0.89      0.09       123

    accuracy                           0.97     71202
   macro avg       0.52      0.93      0.54     71202
weighted avg       1.00      0.97      0.98     71202

ROC AUC score: 0.93

O modelo teve uma acurácia de 97% e uma AUC de 93%, o que significa que o nosso modelo de Regressão Logística teve um desempenho muito bom.

A partir da matriz de confusão podemos concluir que 97% das transações regulares foram corretamente classificadas como regulares(Verdadeiro Negativo), e 89% das transações fraudulentas foram corretamente classificadas como fraudes(Verdadeiro Positivo).

Decision Tree

Nós vimos que o modelo de Regressão Logística teve um bom desempenho. Agora vamos ver como o modelo de Decision Tree se sai.

#instanciar e treinar o modelo de Decision Tree
model_tree = DecisionTreeClassifier(max_depth=4, criterion="entropy", random_state=0)
model_tree.fit(X_rus, y_rus)

y_pred_tree = model_tree.predict(X_test)

# classification report
print(classification_report(y_test, y_pred_tree))

# ROC AUC score
print("ROC AUC Score: {:.2f}\n".format(roc_auc_score(y_test, y_pred_tree)))

# plotar a matriz de confusão
skplt.metrics.plot_confusion_matrix(y_test, y_pred_tree, normalize=True);

              precision    recall  f1-score   support

           0       1.00      0.96      0.98     71079
           1       0.03      0.87      0.06       123

    accuracy                           0.96     71202
   macro avg       0.52      0.91      0.52     71202
weighted avg       1.00      0.96      0.98     71202

ROC AUC Score: 0.91

O modelo de Decision Tree obteve um desempenho com uma acurácia de 96% e AUC score de 91%. Os verdadeiros positivos e verdadeiros negativos foram bem previstos, com 96% e 87% respectivamente.

Conclusão

Ambos os modelos, de Regressão Logística e Decision Tree desempenharam muito bem na classificação das atividades de cartão de crédito, com uma acurácia, AUC e precisão acima de 90%.

Embora tenham produzido resultados semelhantes, o modelo de Regressão Logística exibiu um resultado melhor, com uma acurácia de 97%.

É importante também ressaltar o pré-processamento e o balanceamento dos dados. Lembre-se de como a matriz de correlação teve um desempenho melhor após o balanceamento dos mesmos.

Obviamente, apesar do bom resultado final, há espaço para testar o desempenho com outros algoritmos de classificação, além de otimizar seus parâmetros.

Os algoritmos de Machine Learning para detectar fraudes de cartão de crédito são altamente eficientes, mas ainda existem falhas a serem corrigidas. Um dos maiores problemas é a ocorrência de Falsos Positivos, ou seja, quando o algoritmo detecta incorretamente uma fraude.