Projeto de Detecção de Fraude de Cartão de Crédito – Projeto de Aprendizado de Máquina

Bem-vindo ao nosso projeto de detecção de fraude de cartão de crédito. Hoje, usaremos Python e aprendizado de máquina para detectar fraudes em um conjunto de dados de transações com cartão de crédito. Embora tenhamos compartilhado o código para cada etapa, seria melhor entender como cada etapa funciona e implementá-la.

Vamos começar!

Projeto de detecção de fraude de cartão de crédito com etapas

Em nosso projeto de detecção de fraude de cartão de crédito, usaremos Python, uma das linguagens de programação mais populares disponíveis. Nossa solução detectaria se alguém contorna as paredes de segurança do nosso sistema e faz uma transação ilegítima.

O conjunto de dados possui transações de cartão de crédito e suas características são resultado da análise do PCA. Possui recursos 'Amount', 'Time' e 'Class' onde 'Amount' mostra o valor monetário de cada transação, 'Time' mostra os segundos decorridos entre a primeira e a respectiva transação e 'Class' mostra se uma transação é legal ou não.

Em 'Class', o valor 1 representa uma transação de fraude e o valor 0 representa uma transação válida.

Você pode obter o conjunto de dados e todo o código-fonte aqui .

Etapa 1: importar pacotes

Iniciaremos nosso projeto de detecção de fraude de cartão de crédito instalando os pacotes necessários. Crie um arquivo 'main.py' e importe estes pacotes:

importar numpy como np

importar pandas como pd

importar sklearn

da norma de importação scipy.stats

de scipy.stats import multivariate_normal

de sklearn.preprocessing importe MinMaxScaler

importar matplotlib.pyplot como plt

importar seaborn como sns

Etapa 2: procurar erros

Antes de usarmos o conjunto de dados, devemos procurar quaisquer erros e valores ausentes nele. A presença de valores ausentes pode fazer com que seu modelo forneça resultados incorretos, tornando-o ineficiente e ineficaz. Portanto, leremos o conjunto de dados e procuraremos os valores ausentes:

df = pd.read_csv('creditcardfraud/creditcard.csv')

# valores ausentes

print(“valores ausentes:”, df.isnull().values.any())

Não encontramos valores ausentes neste conjunto de dados, portanto, podemos prosseguir para a próxima etapa.

Participe do Curso de Inteligência Artificial online das melhores universidades do mundo - Mestrados, Programas de Pós-Graduação Executiva e Programa de Certificado Avançado em ML e IA para acelerar sua carreira.

Etapa 3: visualização

Nesta etapa do nosso projeto de detecção de fraude de cartão de crédito, visualizaremos nossos dados. A visualização ajuda a entender o que nossos dados mostram e revela quaisquer padrões que possamos ter perdido. Vamos criar um gráfico do nosso conjunto de dados:

# trama normal e fraude

count_classes = pd.value_counts(df['Class'], sort=True)

count_classes.plot(kind='bar', rot=0)

plt.title(“Transações Distribuídas”)

plt.xticks(range(2), ['Normal', 'Fraude'])

plt.xlabel(“Classe”)

plt.ylabel(“Frequência”)

plt.show()

Em nosso gráfico, descobrimos que os dados são altamente desequilibrados. Isso significa que não podemos usar algoritmos de aprendizado supervisionado, pois isso resultará em overfitting. Além disso, não descobrimos qual seria o melhor método para resolver nosso problema, então vamos realizar mais visualizações. Use o seguinte para traçar o mapa de calor:

# mapa de calor

sns.heatmap(df.corr(), vmin=-1)

plt.show()

Agora, criaremos gráficos de distribuição de dados para nos ajudar a entender de onde vieram nossos dados:

fig, axs = plt.subplots(6, 5, squeeze=False)

para i, ax em enumerate(axs.flatten()):

ax.set_facecolor('xkcd:charcoal')

ax.set_title(df.columns[i])

sns.distplot(df.iloc[:, i], ax=ax, fit=norm,

color=”#DC143C”, fit_kws={“color”: “#4e8ef5”})

ax.set_xlabel()

fig.tight_layout(h_pad=-1.5, w_pad=-1.5)

plt.show()

Com gráficos de distribuição de dados, descobrimos que quase todos os recursos vêm da distribuição gaussiana, exceto 'Tempo'.

Então, usaremos a distribuição gaussiana multivariada para detectar fraudes. Como apenas o recurso 'Tempo' vem da distribuição bimodal (e observe a distribuição gaussiana), vamos descartá-lo. Além disso, nossa visualização revelou que o recurso 'Tempo' não possui valores extremos como os outros, o que é outro motivo pelo qual o descartaremos.

Adicione o código a seguir para descartar os recursos que discutimos e dimensionar outros:

classes = df['Classe']

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

cols = df.columns.difference(['Class'])

MMscaller = MinMaxScaler()

df = MMscaller.fit_transform(df)

df = pd.DataFrame(dados=df, colunas=colunas)

df = pd.concat([df, classes], eixo=1)

Etapa 4: dividir o conjunto de dados

Crie um arquivo 'functions.py'. Aqui, adicionaremos funções para implementar os diferentes estágios do nosso algoritmo. No entanto, antes de adicionarmos essas funções, vamos dividir nosso conjunto de dados em dois conjuntos, o conjunto de validação e o conjunto de teste.

importar pandas como pd

importar numpy como np

def train_validation_splits(df):

# Transações de fraude

fraude = df[df['Class'] == 1]

# Transações normais

normal = df[df['Classe'] == 0]

print('normal:', normal.shape[0])

print('fraud:', fraud.shape[0])

normal_test_start = int(normal.shape[0] * .2)

fraud_test_start = int(fraud.shape[0] * .5)

normal_train_start = normal_test_start * 2

val_normal = normal[:normal_test_start]

val_fraud = fraude[:fraud_test_start]

validação_set = pd.concat([val_normal, val_fraud], axis=0)

test_normal = normal[normal_test_start:normal_train_start]

test_fraud = fraude[fraud_test_start:fraud.shape[0]]

test_set = pd.concat([test_normal, test_fraud], axis=0)

Xval = validation_set.iloc[:, :-1]

Yval = validation_set.iloc[:, -1]

Xtest = test_set.iloc[:, :-1]

Ytest = test_set.iloc[:, -1]

train_set = normal[normal_train_start:normal.shape[0]]

Xtrain = train_set.iloc[:, :-1]

return Xtrain.to_numpy(), Xtest.to_numpy(), Xval.to_numpy(), Ytest.to_numpy(), Yval.to_numpy()

Etapa 5: Calcular a Matriz de Média e Covariância

A função a seguir nos ajudará a calcular a média e a matriz de covariância:

def estimativa_gaussian_params(X):

“””

Calcula a média e a covariância para cada característica.

Argumentos:

X: conjunto de dados

“””

mu = np.mean(X, eixo=0)

sigma = np.cov(XT)

retornar mu, sigma

Etapa 6: adicione os toques finais

Em nosso arquivo 'main.py', vamos importar e chamar as funções que implementamos na etapa anterior para cada conjunto:

(Xtrain, Xtest, Xval, Ytest, Yval) = train_validation_splits(df)

(mu, sigma) = estimativa_gaussian_params(Xtrain)

# calcular gaussian pdf

p = multivariada_normal.pdf(Xtrain, mu, sigma)

pval = multivariada_normal.pdf(Xval, mu, sigma)

ptest = multivariate_normal.pdf(Xtest, mu, sigma)

Agora temos que nos referir ao epsilon (ou o limiar). Normalmente, é melhor inicializar o limite com o valor mínimo do pdf e aumentar a cada passo até atingir o pdf máximo, salvando cada valor epsilon em um vetor.

Depois de criarmos nosso vetor necessário, fazemos um loop 'for' e iteramos sobre o mesmo. Comparamos o limite com os valores do pdf que geram nossas previsões em cada iteração.

Também calculamos a pontuação da F1 de acordo com nossos valores de verdade e as previsões. Se a pontuação F1 encontrada for maior que a anterior, substituímos uma variável de 'melhor limite'.

Lembre-se de que não podemos usar 'precisão' como uma métrica em nosso projeto de detecção de fraude de cartão de crédito. Isso porque refletiria todas as transações normalmente com 99% de precisão, tornando nosso algoritmo inútil.

Implementaremos todos os processos que discutimos acima em nosso arquivo 'functions.py':

def métricas(y, previsões):

fp = np.sum(np.all([previsões == 1, y == 0], eixo=0))

tp = np.sum(np.all([previsões == 1, y == 1], eixo=0))

fn = np.sum(np.all([previsões == 0, y == 1], eixo=0))

precisão = (tp / (tp + fp)) se (tp + fp) > 0 senão 0

recall = (tp / (tp + fn)) if (tp + fn) > 0 else 0

F1 = (2 * precisão * recall) / (precisão +

recall) if (precisão + recall) > 0 else 0

retornar precisão, recall, F1

def selectThreshold(yval, pval):

e_values ​​= pval

melhorF1 = 0

melhorEpsilon = 0

para epsilon em e_values:

previsões = pval < epsilon

(precisão, recall, F1) = métricas(yval, previsões)

se F1 > melhorF1:

melhorF1 = F1

melhorEpsilon = epsilon

return bestEpsilon, bestF1

No final, importaremos as funções no arquivo 'main.py' e as chamaremos para retornar a pontuação F1 e o limite. Isso nos permitirá avaliar nosso modelo no conjunto de teste:

(épsilon, F1) = selectThreshold(Yval, pval)

print(“Melhor epsilon encontrado:”, epsilon)

print(“Melhor F1 no conjunto de validação cruzada:”, F1)

(test_precision, test_recall, test_F1) = métricas(Ytest, ptest < epsilon)

print("Outliers encontrados:", np.sum(ptest < epsilon))

print(“Precisão do conjunto de teste:”, test_precision)

print(“Recall do conjunto de teste:”, test_recall)

print(“Pontuação do conjunto de teste F1:”, test_F1)

Aqui estão os resultados de todo esse esforço:

Melhor epsilon encontrado: 5e-324

Melhor F1 no conjunto de validação cruzada: 0,7852998065764023

Valores atípicos encontrados: 210

Precisão do conjunto de teste: 0,9095238095238095

Recall do conjunto de teste: 0,7764227642276422

Pontuação F1 do conjunto de teste: 0,837719298245614

Conclusão

Aí está - um projeto de detecção de fraude de cartão de crédito totalmente funcional!

Se você tiver alguma dúvida ou sugestão sobre este projeto, deixe-nos saber deixando um comentário abaixo. Adoraríamos ouvir de você.

Com todas as habilidades aprendidas, você também pode se tornar ativo em outras plataformas competitivas para testar suas habilidades e obter ainda mais experiência prática. Se você estiver interessado em saber mais sobre o curso, confira a página do Programa PG Executivo em Machine Learning & AI e fale com nosso conselheiro de carreira para mais informações.