Detección de Fraude Financiero con Modelos de Aprendizaje No Supervisado en Python

🚀 Introducción a la Detección de Fraude Financiero con Machine Learning

La detección de fraude financiero es uno de los desafíos más críticos para la industria bancaria y de pagos. Con millones de transacciones procesadas diariamente, los sistemas tradicionales basados en reglas fijas ya no son suficientes para detener a los estafadores modernos, quienes adaptan constantemente sus tácticas.

Aquí es donde entra en juego el Machine Learning no supervisado. A diferencia de los enfoques supervisados que requieren etiquetas históricas de qué transacción fue fraudulenta (algo muy escaso y desbalanceado), los modelos no supervisados buscan patrones inusuales o anomalías en los datos sin requerir entrenamiento previo con ejemplos de fraude.

En este tutorial completo, aprenderás a construir un pipeline de detección de anomalías en Python utilizando librerías estándar de la industria como Scikit-Learn y Pandas.

🛠️ Requisitos Previos y Configuración del Entorno

Antes de escribir código, asegúrate de tener instalado Python 3.8 o superior. Utilizaremos las siguientes librerías:

• pandas para la manipulación de datos.
• numpy para operaciones numéricas.
• scikit-learn para los algoritmos de Machine Learning y preprocesamiento.
• matplotlib y seaborn para la visualización de resultados.

Ejecuta el siguiente comando en tu terminal para instalar las dependencias necesarias:

pip install pandas numpy scikit-learn matplotlib seaborn

Una vez instaladas las librerías, crearemos nuestro entorno de trabajo importando los módulos necesarios en nuestro script de Python:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.ensemble import IsolationForest
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.metrics import classification_report, confusion_matrix

# Configuración de estilo para gráficos
sns.set_theme(style="whitegrid")
print("Librerías importadas correctamente.")

📊 Preparación y Exploración del Dataset

Para este tutorial, simularemos un conjunto de datos realista de transacciones con tarjeta de crédito. En un escenario real, los datos suelen estar altamente desbalanceados, donde menos del 0.1% de las transacciones son fraudulentas.

Vamos a cargar y examinar la estructura inicial de nuestros datos:

# Generación de datos simulados para el ejercicio
np.random.seed(42)
n_samples = 10000

transaction_amount = np.exponential(scale=50, size=n_samples)
transaction_hour = np.random.randint(0, 24, size=n_samples)
distance_from_home = np.random.exponential(scale=5, size=n_samples)

# Crear un DataFrame
df = pd.DataFrame({
    'amount': transaction_amount,
    'hour': transaction_hour,
    'distance_from_home': distance_from_home
})

# Introducir algunas anomalías artificiales (fraudes)
n_anomalies = 100
anomaly_indices = np.random.choice(n_samples, n_anomalies, replace=False)

df.loc[anomaly_indices, 'amount'] = np.random.uniform(500, 2000, size=n_anomalies)
df.loc[anomaly_indices, 'distance_from_home'] = np.random.uniform(50, 150, size=n_anomalies)

print(df.head())

Limpieza y Normalización de Características

Los algoritmos de aprendizaje no supervisado son muy sensibles a la escala de las variables. Una característica con valores grandes (como el monto en dólares) dominará sobre variables con valores pequeños (como la hora del día).

Aplicaremos un StandardScaler para normalizar todas las columnas a media cero y varianza uno:

scaler = StandardScaler()
scaled_features = scaler.fit_transform(df)

# Convertir de nuevo a DataFrame para facilitar su manejo
df_scaled = pd.DataFrame(scaled_features, columns=df.columns)
print(df_scaled.describe())

🤖 Implementación del Modelo Isolation Forest

Intermedio El algoritmo Isolation Forest es uno de los métodos más eficientes para la detección de anomalías en datos tabulares de alta dimensión. Funciona aislando observaciones mediante la selección aleatoria de una característica y un valor de división. Las anomalías requieren menos divisiones para ser aisladas en comparación con los puntos normales.

Vamos a configurar y entrenar nuestro modelo con los datos normalizados:

# Instanciar Isolation Forest
# contamination representa el porcentaje esperado de anomalías en el dataset
iso_forest = IsolationForest(contamination=0.01, random_state=42)

# Entrenar el modelo y predecir
# Devuelve 1 para datos normales y -1 para anomalías (fraude)
predictions = iso_forest.fit_predict(df_scaled)

# Añadir las predicciones al DataFrame original
df['anomaly_prediction'] = predictions

# Mapear -1 a 1 (fraude) y 1 a 0 (normal) para análisis
df['is_fraud'] = df['anomaly_prediction'].apply(lambda x: 1 if x == -1 else 0)

print(f"Total de anomalías detectadas: {sum(df['is_fraud'] == 1)}")

Análisis de los Resultados Obtenidos

Una vez que el modelo ha clasificado las transacciones, es fundamental analizar las características de las transacciones marcadas como fraudulentas para validar si el modelo tiene sentido comercial.

# Agrupar por predicción para comparar medias
summary = df.groupby('is_fraud').mean()
print(summary)

📈 Visualización de las Anomalías Detectadas

La visualización es clave para validar el comportamiento del modelo. Utilizaremos Reducción de Dimensionalidad con PCA (Análisis de Componentes Principales) para proyectar nuestros datos en un espacio de 2 dimensiones y graficar los resultados.

# Reducir dimensionalidad a 2 componentes
pca = PCA(n_components=2)
principal_components = pca.fit_transform(df_scaled)

df_pca = pd.DataFrame(principal_components, columns=['PC1', 'PC2'])
df_pca['is_fraud'] = df['is_fraud']

# Graficar
plt.figure(figsize=(10, 6))
sns.scatterplot(
    x='PC1',
    y='PC2',
    hue='is_fraud',
    palette={0: 'blue', 1: 'red'},
    data=df_pca,
    alpha=0.7
)
plt.title('Detección de Fraude con Isolation Forest (Proyección PCA)')
plt.xlabel('Componente Principal 1')
plt.ylabel('Componente Principal 2')
plt.legend(title='¿Es Fraude?', labels=['Normal', 'Fraude'])
plt.show()

🔍 Preguntas Frecuentes (FAQ)

🎯 Conclusión y Próximos Pasos

Has aprendido a implementar un sistema completo de detección de fraude financiero utilizando técnicas de aprendizaje no supervisado en Python. Con Isolation Forest, fuimos capaces de identificar transacciones atípicas sin necesidad de contar con un historial etiquetado de fraudes.

Como siguientes pasos recomendados, te sugerimos:

1. Experimentar con la afinación de hiperparámetros como n_estimators y contamination.
2. Probar otros algoritmos de detección de anomalías como Local Outlier Factor (LOF).
3. Integrar el modelo entrenado en una API web para procesamiento en tiempo real.