Cómo detectar fraudes en transacciones con Azure ML: paso a paso

Este tutorial muestra cómo detectar fraudes en transacciones con Azure Machine Learning, útil para reducir pérdidas y automatizar anomalías en pagos. Aprenderá por qué usar features, entrenamiento y deployment para obtener predicciones en tiempo real.

Requisitos previos

• Cuenta Azure con suscripción activa y permisos para crear recursos.
• Azure Machine Learning workspace creado.
• Python 3.8+ instalado localmente y pip; paquetes: azure-ai-ml, azure-ml, scikit-learn, pandas.
• Dataset de transacciones en CSV (columnas: transaction_id, amount, timestamp, merchant, customer_id, label).
• Familiaridad básica con ML (features, entrenamiento, evaluación).

Paso 1: Preparar el entorno y cargar el dataset

Creé un entorno Python e instale las bibliotecas. A continuación conéctese al workspace y cargue el CSV en un DataFrame. Es importante validar tipos y valores en campos como amount y timestamp.

pip install azure-ai-ml azure-identity scikit-learn pandas joblib

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential
import pandas as pd

ws = MLClient(DefaultAzureCredential(), subscription_id="", resource_group_name="", workspace_name="")
df = pd.read_csv('transactions.csv')
df['timestamp'] = pd.to_datetime(df['timestamp'])
print(df.head())

Paso 2: Preprocesamiento e ingeniería de features

Explique por qué: features bien construidas mejoran la detección de fraude (por ejemplo, frecuencia del cliente, valor medio, hora del día). Cree columnas como hour, txn_per_customer, avg_amount_customer. Procese valores faltantes y normalice amount.

# Exemplo simples de features
import numpy as np

df['hour'] = df['timestamp'].dt.hour
cust_stats = df.groupby('customer_id')['amount'].agg(['count','mean']).rename(columns={'count':'txn_count','mean':'avg_amount'})
df = df.merge(cust_stats, on='customer_id')

df['amount_norm'] = (df['amount'] - df['avg_amount']) / (df['amount'].std() + 1e-9)

features = ['amount_norm','hour','txn_count']
X = df[features].fillna(0)
y = df['label']  # 1 = fraud, 0 = legit

Paso 3: Entrenar un modelo de clasificación

Por qué: los modelos basados en árboles funcionan bien con features tabulares. Aquí usamos RandomForest para un ejemplo rápido. Guarde el modelo con joblib para el deployment.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
import joblib

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=42)
model = RandomForestClassifier(n_estimators=100, class_weight='balanced', random_state=42)
model.fit(X_train, y_train)

preds = model.predict(X_test)
print(classification_report(y_test, preds))
joblib.dump(model, 'fraud_rf.joblib')

Paso 4: Registrar y empaquetar el modelo en Azure Machine Learning

Registre el fichero del modelo en el workspace para gestión de versiones. Cree un entorno de ejecución (conda) y un scoring script simple que cargue el modelo y prediga la label.

from azure.ai.ml.entities import Model

model_aml = Model(path='fraud_rf.joblib', name='fraud-rf-model', description='RandomForest para detección de fraude')
registered = ws.models.create_or_update(model_aml)
print('Model registered:', registered.name)

Paso 5: Crear una imagen de contenedor / endpoint de inferencia

Por qué: un endpoint permite predicciones en tiempo real. Defina el scoring script que procese JSON con las mismas features y devuelva probabilidad. Después cree un deployment como Managed Online Endpoint o compute que soporte el contenedor.

# scoring.py (simplificado)
import json
import joblib
import numpy as np

def init():
    global model
    model = joblib.load('fraud_rf.joblib')

def run(raw_data):
    data = json.loads(raw_data)
    X = np.array([data['amount_norm'], data['hour'], data['txn_count']]).reshape(1,-1)
    pred = model.predict_proba(X)[0,1]
    return {'fraud_probability': float(pred)}

Paso 6: Probar localmente e implementar en Azure

Pruebe el scoring script localmente con un ejemplo JSON. Después cree el endpoint Managed Online Endpoint en Azure ML y haga el deploy del contenedor con la imagen que incluye scoring.py y el modelo registrado.

# Teste local (ejemplo)
import requests, json
payload = {'amount_norm':0.5,'hour':2,'txn_count':10}
print(run(json.dumps(payload)))

# En Azure: crear endpoint y deployment via Azure ML CLI/SDK (resumen):
# az ml online-endpoint create -n fraud-endpoint -f endpoint.yml
# az ml online-deployment create -n deployment1 --endpoint fraud-endpoint -f deployment.yml

Verificar el resultado

Confirme que el endpoint responde y que la precisión/recall son aceptables. Envíe ejemplos reales y verifique probabilidades para fraudes conocidos. Monitorice métricas (TP, FP) y latencia en el panel de Azure Machine Learning.

Conclusión

Ha creado un flujo completo para detección de fraude en transacciones con Azure Machine Learning: preparación, entrenamiento, registro y deployment de un endpoint de inferencia. Próximos pasos: ajustar features, probar XGBoost o LightGBM, e integrar alertas. Consejo: valide con datos recientes e implemente thresholds dinámicos para reducir falsos positivos.