Detectar fraude con TensorFlow y Python

En este artículo exploraremos las posibilidades que ofrece Python junto con TensorFlow para resolver un caso de uso de banca. Python se ha convertido en uno de los lenguajes de programación más populares para data science y machine learning, ya que ofrece una gran colección de librerías y herramientas para que los desarrolladores implementen modelos complejos de forma sencilla. Una de esas librerías es TensorFlow, cuya popularidad ha aumentado en los últimos años.

En este artículo introduciremos TensorFlow y comentaremos un caso de uso en el ámbito de banca que se puede resolver usando modelos de machine learning, entre ellos modelos de TensorFlow, para detectar fraudes en movimientos con tarjetas de crédito. Para apoyar al artículo se incluye un notebook con el código que se ha usado para resolver el problema del caso de uso.

Tensorflow

TensorFlow es una librería de machine learning desarrollada por Google que permite a los desarrolladores construir y desplegar modelos complejos, entre los que se encuentran redes neuronales. Su popularidad ha aumentado mucho en los últimos años, y se usa en muchas industrias, como en finanzas o e-commerce. Tensorflow tiene implementación en Python, por lo que se ha vuelto mucho más accesible para un gran número de desarrolladores. La arquitectura de Tensorflow está basada en gráficos de flujo de datos que representan computaciones como una serie de nodos conectados por aristas. Esta estructura permite que TensorFlow pueda escalar los procesos a múltiples CPUs y GPUs.

TensorFlow ofrece integración con Keras, que es una API para redes neuronales que ofrece una forma simplificada de construir y entrenar modelos de deep learning. En este artículo vamos a construir una red neuronal usando Keras para resolver un caso de uso de detección de fraude en transferencias con tarjetas.

Detección de fraude con tarjetas de crédito

El fraude con tarjetas de crédito causa pérdidas de miles de millones de dólares a bancos y otros negocios cada año, y las pérdidas aumentan cada año. Según el Nilson Report de 2020, los emisores de tarjetas de crédito, negocios y cajeros automáticos sufrieron pérdidas de 28 mil millones de dólares.

A pesar de que no hay casos seguros de fraude de transacciones, dado que hay un gran número de posibles escenarios en los que puede ocurrir, se han detectado algunos patrones que ocurren más a menudo que otros en casos de fraude. Aún así, es un gran desafío diseñar un sistema de detección de fraude fiable.

Dada la estricta confidencialidad del tema de este caso de uso, las compañías que lo trabajan regularmente no hacen públicos sus datasets. El dataset de este caso de uso se llama Credit Card Fraud Detection y es de Kaggle. Este dataset contiene transacciones de tarjetas de crédito realizadas en septiembre de 2013. Las transacciones se realizaron en dos días consecutivos, siendo 492 de las 284807 fraudulentas. El dataset está muy desbalanceado, por tanto, ya que las transacciones fraudulentas solo conforman el 0.172% del total.

Dado que vamos a trabajar con un dataset muy desbalanceado, es muy importante escoger un modelo o hacer uso de técnicas que nos permitan trabajar con ese desbalanceo de los datos de forma efectiva. Algunas de las opciones que se pueden emplear son:

1. Usar una función de pérdida (loss function) con pesos para las clases. Esta es una forma de tratar con el desbalanceo de las clases cuando se trabaja con redes neuronales, como en este caso con TensorFlow. Se puede asignar un peso mayor a la clase minoritaria y un peso menor a la clase mayoritaria. En el caso de TensorFlow, podemos usar la función tf.keras.losses.BinaryCrossentropy.
2. Usar técnicas de oversampling o undersampling. En lugar de ajustar el modelo, otra forma de tratar el problema es ajustar los datos de entrenamiento. Las técnicas de oversampling replican muestras de la clase minoritaria para balancear el dataset, mientras que las técnicas de undersampling eliminan muestras de la clase mayoritaria. TensorFlow ofrece varias funciones para implementar estas técnicas, entre las que se encuentran tf.data.experimental.rejection_resample para undersampling y tf.data.experimental.sample_from_datasets para oversampling. Otra de las opciones más populares es la librería imblearn, que ofrece pipelines para aplicar estas técnicas al conjunto de datos de entrenamiento.

Workflow

El objetivo será construir un modelo de machine learning usando TensorFlow en Python para predecir si las transacciones serán fraudulentas o no. La estructura de la resolución del caso de uso es la siguiente:

• Ingesta y procesamiento de datos
• Modelado
• Evaluación

Ingesta y procesamiento de los datos

El trabajo comienza con la ingesta de los datos. El dataset se encuentra en Kaggle y se puede descargar en el siguiente link. Los datos ya están pre-procesados en cierta medida (aunque no conocemos el contexto del que provienen estas features) según la documentación, ya que las 28 features numéricas son resultado de una transformación PCA. Estas features además ya se han escalado; las únicas features que no se han escalado son Amount y Time. Por tanto, en este caso, el único pre-procesado que tenemos que hacer es dividir el dataset en conjuntos de entrenamiento, test y validación.

# Load the dataset
df = pd.read_csv('creditcard.csv')

# Split the dataset into train, validation, and test sets
X_train, X_test, y_train, y_test = train_test_split(
    df.drop(['Class', 'Time'], axis=1), df['Class'], test_size=0.2, random_state=42)
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.25, random_state=42)

Modelado

Entrenar modelos de machine learning con datasets muy desbalanceados normalmente conlleva unos resultados pobres. En la sección del caso de uso se han mencionado dos métodos para resolver este problema. Dos métodos muy populares de sampling son Random Under Sampling y Synthetic Minority Over-Sampling (SMOTE). Estas técnicas solo se hacen efectivas cuando se use fit en los modelos.

En cuanto a los modelos, además de una red neuronal creada con Keras y TensorFlow, en el notebook se incluye un Random Forest Classifier y un XGBoost Classifier.

Evaluación

El último paso del workflow será evaluar los modelos con el conjunto de datos de test. Vamos a evaluar las siguientes métricas:

• Precisión: la precisión indica la proporción de identificaciones positivas correctas. En este caso de uso, una precisión alta significa que la mayoría de casos identificados como fraudulentos eran realmente transacciones fraudulentas.
• Recall: el recall indica la proporción de casos positivos reales identificados. En este caso de uso, un recall alto significa que el modelo ha identificado la mayoría de transacciones fraudulentas.
• Métricas ROC-AUC: la curva ROC (receiver operating characteristic) es una gráfica que muestra el rendimiento de un modelo al representar las razones de verdaderos positivos y falsos negativos. La métrica AUC (Area under the ROC curve) mide el área bajo la curva ROC. En este caso de uso, una AUC alta significa que la mayoría de las predicciones del modelo han sido correctas.

Desarrollo

La red neuronal, construida con Keras, contiene diferentes capas de nodos conectadas:

# Define the neural network architecture
model = tf.keras.Sequential([
    tf.keras.layers.Dense(256, activation='relu', input_shape=(X_train.shape[1],)),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dropout(0.3),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(32, activation='relu'),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

1. La primera capa tiene 256 neuronas y usa la función de activación ReLU (Rectified Linear Unit) a los inputs. El parámetro input_shape especifica la forma de los datos que entran en la red neuronal.
2. La segunda capa aplica regularización dropout, que deja fuera del entrenamiento una fracción del input para evitar overfitting.
3. La tercera capa tiene 128 neuronas y usa la función de activación ReLU.
4. La cuarta capa aplica regularización dropout también.
5. La quinta capa tiene 64 neuronas y usa la función de activación ReLU.
6. La sexta capa aplica regularización dropout también.
7. La séptima capa tiene 32 neuronas y usa la función de activación ReLU.
8. La octava capa aplica regularización dropout también.
9. La última capa tiene una sola neurona y una función de activación sigmoide, que devuelve una probabilidad entre 0 y 1, que representa la probabilidad de que el registro pertenezca a una de las dos clases.

A la hora de compilar la red neuronal se ha especificado binary cross entropy como función de pérdida, ya que funciona bien para casos con datasets desbalanceados.

# Compile the model with binary crossentropy loss and class weights
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy', precision, recall, auc])

callback = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=10)

# Train the model
history = model.fit(X_train,
                    y_train,
                    epochs=20,
                    batch_size=512,
                    validation_data=(X_val, y_val),
                    callbacks=[callback]
                   )

Resultados

Los resultados de la evaluación de la red neuronal en el conjunto de datos de test han dado los siguientes resultados:

# Evaluate the model
test_prec, test_rec, test_auc = model.evaluate(X_test, y_test)
print('Test Precision:', test_prec)
print('Test Recall:', test_rec)
print('Test AUC:', test_auc)

A pesar de que las métricas son buenas, se podrían mejorar optimizando la red neuronal. Encontrar la red neuronal ideal implica modificar la complejidad de la red, probar distintas técnicas de regularización y tunear los hiperparámetros. Por ejemplo, se podrían modificar el número de capas de la red o el número de neuronas de cada capa. Aún así, aunque los resultados han sido buenos, es importante explorar otras estrategias y posibilidades para mejorar el modelo.

Conclusiones

En este artículo hemos presentado TensorFlow y Python y cómo se pueden usar los dos en un caso de uso del ámbito de banca, construyendo una red neuronal que predice si una transacción con una tarjeta de crédito es fraudulenta o no. Esperamos que haya sido útil para empezar a usar TensorFlow y Python para resolver otros casos de uso.