Proyecto de detección de fraude con tarjetas de crédito – Proyecto de aprendizaje automático
Publicado: 2021-05-24Bienvenido a nuestro proyecto de detección de fraudes con tarjetas de crédito. Hoy, usaremos Python y el aprendizaje automático para detectar fraudes en un conjunto de datos de transacciones con tarjetas de crédito. Aunque hemos compartido el código para cada paso, sería mejor entender cómo funciona cada paso y luego implementarlo.
¡Vamos a empezar!
Tabla de contenido
Proyecto de detección de fraude de tarjetas de crédito con pasos
En nuestro proyecto de detección de fraudes con tarjetas de crédito, utilizaremos Python, uno de los lenguajes de programación disponibles más populares. Nuestra solución detectaría si alguien elude los muros de seguridad de nuestro sistema y realiza una transacción ilegítima.
El conjunto de datos tiene transacciones con tarjeta de crédito y sus características son el resultado del análisis PCA. Tiene características de 'Cantidad', 'Tiempo' y 'Clase' donde 'Cantidad' muestra el valor monetario de cada transacción, 'Tiempo' muestra los segundos transcurridos entre la primera y la respectiva transacción, y 'Clase' muestra si una transacción es legítimo o no.
En 'Clase', el valor 1 representa una transacción fraudulenta y el valor 0 representa una transacción válida.
Puede obtener el conjunto de datos y el código fuente completo aquí .
Paso 1: importar paquetes
Comenzaremos nuestro proyecto de detección de fraude con tarjetas de crédito instalando los paquetes necesarios. Cree un archivo 'main.py' e importe estos paquetes:
importar numpy como np
importar pandas como pd
importar sklearn
de la norma de importación de scipy.stats
de scipy.stats importar multivariante_normal
desde sklearn.preprocessing importar MinMaxScaler
importar matplotlib.pyplot como plt
importar seaborn como sns
Paso 2: busque errores
Antes de usar el conjunto de datos, debemos buscar errores y valores faltantes en él. La presencia de valores faltantes puede hacer que su modelo proporcione resultados defectuosos, haciéndolo ineficiente e ineficaz. Por lo tanto, leeremos el conjunto de datos y buscaremos los valores faltantes:
df = pd.read_csv('fraude con tarjeta de crédito/tarjeta de crédito.csv')
# valores faltantes
imprimir(“valores faltantes:”, df.isnull().valores.cualquiera())
No encontramos valores faltantes en este conjunto de datos, por lo que podemos continuar con el siguiente paso.
Únase al curso de inteligencia artificial en línea de las mejores universidades del mundo: maestrías, programas ejecutivos de posgrado y programa de certificado avanzado en ML e IA para acelerar su carrera.
Paso 3: Visualización
En este paso de nuestro proyecto de detección de fraudes con tarjetas de crédito, visualizaremos nuestros datos. La visualización ayuda a comprender lo que muestran nuestros datos y revela cualquier patrón que podamos haber pasado por alto. Vamos a crear un gráfico de nuestro conjunto de datos:
# trama normal y fraude
count_classes = pd.value_counts(df['Class'], sort=True)
count_classes.plot(tipo='barra', rot=0)
plt.title ("Transacciones distribuidas")
plt.xticks(rango(2), ['Normal', 'Fraude'])
plt.xlabel(“Clase”)
plt.ylabel(“Frecuencia”)
plt.mostrar()
En nuestro gráfico, encontramos que los datos están muy desequilibrados. Esto significa que no podemos usar algoritmos de aprendizaje supervisado, ya que resultará en un sobreajuste. Además, no hemos descubierto cuál sería el mejor método para resolver nuestro problema, por lo que realizaremos más visualizaciones. Use lo siguiente para trazar el mapa de calor:
# mapa de calor
sns.heatmap(df.corr(), vmin=-1)
plt.mostrar()
Ahora, crearemos gráficos de distribución de datos para ayudarnos a comprender de dónde provienen nuestros datos:
fig, axs = plt.subplots(6, 5, squeeze=False)
para i, hacha en enumerar (axs.flatten()):
ax.set_facecolor('xkcd:carbón')
ax.set_title(df.columnas[i])
sns.distplot(df.iloc[:, i], ax=ax, fit=norma,
color=”#DC143C”, fit_kws={“color”: “#4e8ef5”})
hacha.set_xlabel(")
figura.tight_layout(h_pad=-1.5, w_pad=-1.5)
plt.mostrar()
Con los gráficos de distribución de datos, descubrimos que casi todas las características provienen de la distribución gaussiana, excepto 'Tiempo'.
Así que usaremos la distribución gaussiana multivariante para detectar el fraude. Como solo la función 'Tiempo' proviene de la distribución bimodal (y tenga en cuenta la distribución gaussiana), la descartaremos. Además, nuestra visualización reveló que la característica 'Tiempo' no tiene valores extremos como los demás, que es otra razón por la que la descartaremos.
Agregue el siguiente código para descartar las características que discutimos y escalar otras:
clases = df['Clase']
df.drop(['Tiempo', 'Clase', 'Cantidad'], eje=1, en el lugar=Verdadero)
columnas = df.columnas.diferencia(['Clase'])
MMscaller = MinMaxScaler()
df = MMcaller.fit_transform(df)
df = pd.DataFrame(datos=df, columnas=columnas)
df = pd.concat([df, clases], eje=1)
Paso 4: dividir el conjunto de datos
Cree un archivo 'funciones.py'. Aquí, agregaremos funciones para implementar las diferentes etapas de nuestro algoritmo. Sin embargo, antes de agregar esas funciones, dividamos nuestro conjunto de datos en dos conjuntos, el conjunto de validación y el conjunto de prueba.
importar pandas como pd
importar numpy como np
def train_validation_splits(df):
# Transacciones Fraudulentas
fraude = df[df['Clase'] == 1]
# Transacciones normales
normal = df[df['Clase'] == 0]
imprimir('normal:', normal.forma[0])
imprimir('fraude:', fraude.forma[0])
normal_test_start = int(normal.shape[0] * .2)
fraude_prueba_inicio = int(fraude.forma[0] * .5)
inicio_tren_normal = inicio_prueba_normal * 2
val_normal = normal[:normal_test_start]
val_fraud = fraude[:fraud_test_start]
conjunto_validación = pd.concat([val_normal, val_fraude], eje=0)
test_normal = normal[normal_test_start:normal_train_start]
prueba_fraude = fraude[fraude_prueba_inicio:fraude.forma[0]]
test_set = pd.concat([test_normal, test_fraud], eje=0)
Xval = conjunto_validación.iloc[:, :-1]
Yval = conjunto_validación.iloc[:, -1]
Xtest = test_set.iloc[:, :-1]
Ytest = test_set.iloc[:, -1]
train_set = normal[normal_train_start:normal.shape[0]]
Xtren = conjunto_tren.iloc[:, :-1]
devuelve Xtrain.to_numpy(), Xtest.to_numpy(), Xval.to_numpy(), Ytest.to_numpy(), Yval.to_numpy()
Paso 5: Calcular la Media y la Matriz de Covarianza
La siguiente función nos ayudará a calcular la media y la matriz de covarianza:
def estimación_parámetros_gaussianos(X):
“””
Calcula la media y la covarianza de cada función.
Argumentos:
X: conjunto de datos
“””
mu = np.media(X, eje=0)
sigma = np.cov(XT)
volver mu, sigma
Paso 6: Agrega los toques finales
En nuestro archivo 'main.py', importaremos y llamaremos a las funciones que implementamos en el paso anterior para cada conjunto:
(Xtrain, Xtest, Xval, Ytest, Yval) = train_validation_splits(df)
(mu, sigma) = estimación_parámetros_gaussianos(Xtren)
# calcular pdf gaussiano
p = multivariado_normal.pdf(Xtren, mu, sigma)
pval = multivariado_normal.pdf(Xval, mu, sigma)
ptest = multivariante_normal.pdf(Xtest, mu, sigma)
Ahora tenemos que referirnos al épsilon (o al umbral). Por lo general, es mejor inicializar el umbral con el valor mínimo de pdf y aumentar con cada paso hasta alcanzar el pdf máximo mientras guarda cada valor de épsilon en un vector.
Después de crear nuestro vector requerido, hacemos un bucle 'for' e iteramos sobre el mismo. Comparamos el umbral con los valores del pdf que generan nuestras predicciones en cada iteración.
También calculamos la puntuación de F1 de acuerdo con nuestros valores reales y las predicciones. Si la puntuación F1 encontrada es más alta que la anterior, anulamos una variable de 'mejor umbral'.
Tenga en cuenta que no podemos usar la "precisión" como métrica en nuestro proyecto de detección de fraudes con tarjetas de crédito. Esto se debe a que reflejaría todas las transacciones con normalidad con un 99 % de precisión, lo que inutilizaría nuestro algoritmo.
Implementaremos todos los procesos que discutimos anteriormente en nuestro archivo 'functions.py':
métricas def (y, predicciones):
fp = np.sum(np.all([predicciones == 1, y == 0], eje=0))
tp = np.sum(np.all([predicciones == 1, y == 1], eje=0))
fn = np.sum(np.all([predicciones == 0, y == 1], eje=0))
precision = (tp / (tp + fp)) if (tp + fp) > 0 else 0
recordar = (tp / (tp + fn)) if (tp + fn) > 0 else 0
F1 = (2 * precisión * recuperación) / (precisión +
recordar) si (precisión + recordar) > 0 else 0
precisión de retorno, recuperación, F1
def seleccionar Umbral(yval, pval):
valores_e = pval
mejorF1 = 0
mejorEpsilon = 0
para epsilon en e_values:
predicciones = pval < épsilon
(precisión, recuperación, F1) = métricas (yval, predicciones)
si F1 > mejorF1:
mejorF1 = F1
mejorEpsilon = épsilon
volver mejorEpsilon, mejorF1
Al final, importaremos las funciones en el archivo 'main.py' y las llamaremos para devolver la puntuación F1 y el umbral. Nos permitirá evaluar nuestro modelo en el conjunto de prueba:
(épsilon, F1) = seleccionar Umbral (Yval, pval)
print(“Mejor épsilon encontrado:”, épsilon)
print("Mejor F1 en el conjunto de validación cruzada:", F1)
(test_precision, test_recall, test_F1) = métricas (Ytest, ptest < epsilon)
print(“Valores atípicos encontrados:”, np.sum(ptest < epsilon))
print(“Precisión del conjunto de prueba:”, test_precision)
print(“Recuperación del conjunto de prueba:”, test_recall)
print(“Prueba conjunto puntuación F1:”, test_F1)
Estos son los resultados de todo este esfuerzo:
Mejor épsilon encontrado: 5e-324
Mejor F1 en conjunto de validación cruzada: 0.7852998065764023
Valores atípicos encontrados: 210
Conjunto de prueba Precisión: 0.9095238095238095
Retiro del conjunto de prueba: 0.7764227642276422
Puntuación del conjunto de prueba F1: 0.837719298245614
Conclusión
Ahí lo tiene: ¡un proyecto de detección de fraude con tarjetas de crédito completamente funcional!
Si tiene alguna pregunta o sugerencia con respecto a este proyecto, háganoslo saber dejando un comentario a continuación. Nos encantaría saber de usted.
Con todas las habilidades aprendidas, también puede activarse en otras plataformas competitivas para probar sus habilidades y obtener aún más experiencia práctica. Si está interesado en obtener más información sobre el curso, consulte la página del Programa Execitive PG en Machine Learning & AI y hable con nuestro consejero de carrera para obtener más información.
¿Cuál es el objetivo del proyecto de detección de fraudes con tarjetas de crédito?
El objetivo de este proyecto es predecir si una transacción con tarjeta de crédito es fraudulenta o no, según el monto de la transacción, la ubicación y otros datos relacionados con la transacción. Su objetivo es rastrear los datos de transacciones de tarjetas de crédito, lo que se hace mediante la detección de anomalías en los datos de transacciones. La detección de fraude con tarjetas de crédito generalmente se implementa mediante un algoritmo que detecta cualquier anomalía en los datos de la transacción y notifica al titular de la tarjeta (como medida de precaución) y al banco sobre cualquier transacción sospechosa.
¿Cómo ayuda la detección de fraudes con tarjetas de crédito a detectar y detener los fraudes con tarjetas de crédito?
Para detectar y detener el fraude con tarjetas de crédito, una compañía de tarjetas de crédito analiza los datos que recibe de los comerciantes sobre los consumidores que han realizado compras con su tarjeta. La compañía de la tarjeta de crédito compara automáticamente los datos de la compra con los datos previamente almacenados sobre el consumidor para determinar si la compra y el consumidor son consistentes. Una computadora analiza los datos del consumidor y los compara con los datos de la compra. La computadora también intenta detectar cualquier diferencia entre el historial de compras del consumidor y la compra actual. Luego, la computadora realiza un análisis de riesgo para la compra y determina si la empresa debe permitir que la compra se lleve a cabo.
¿Qué algoritmo de aprendizaje automático se utiliza en la detección de fraudes con tarjetas de crédito?
Existen varios algoritmos de aprendizaje automático que se utilizan en la detección de fraudes con tarjetas de crédito. Uno de los algoritmos más comunes es SVM o máquinas de vectores de soporte. SVM es un algoritmo de clasificación y regresión adaptativo con muchas aplicaciones en informática. Se utiliza en la detección de fraudes con tarjetas de crédito para predecir y clasificar un nuevo conjunto de datos en un conjunto de categorías predefinidas (también denominadas clases). SVM se puede utilizar en la detección de fraudes con tarjetas de crédito para predecir si los nuevos datos pertenecen a alguna categoría que ya hemos definido.