En el benchmark de fraude que usa NVIDIA, el mejor resultado viene del modelo más pequeño: el Cortex de NeoSpace — por delante de los mucho más grandes de NVIDIA y Revolut
Ese benchmark es el TabFormer de IBM, el dataset sintético de fraude con tarjeta sobre el que se construyó esta línea de trabajo, y sobre el que NVIDIA construyó su Transaction Foundation Model para fraude. Varios modelos han abordado la misma tarea — convertir un flujo bruto de transacciones de tarjeta en una señal de fraude —, incluido el PRAGMA de 100M de parámetros de Revolut, que adaptamos aquí. En la prueba completa, aislada en el tiempo, Cortex puntúa por encima de todos ellos, usando unos 8 millones de parámetros.
Las condiciones detrás del número
AUPRC (F1 0.96) en la prueba completa de 2.03M de transacciones, no en una muestra
mejor que un clasificador sin habilidad al 0.102% de prevalencia de fraude
parámetros, 4× menor que el de NVIDIA y 12× menor que el PRAGMA de Revolut
El fraude aparece en el comportamiento, no en campos aislados
Una transacción aislada rara vez parece fraudulenta por sí sola. La señal está en el comportamiento a su alrededor: hace cuánto se usó la tarjeta, en qué comercios, el ritmo de gasto y qué patrón rompe.
Durante años el enfoque estándar fue construir features a mano que aproximan ese comportamiento y alimentar con ellas a un clasificador. Se satura rápido: un modelo fuerte de gradient boosting sobre las columnas brutas se estanca en AUPRC 0.14. Ese límite es lo que empujó al campo hacia los transaction foundation models, que entrenan sobre la propia secuencia bruta y aprenden el contexto conductual que las features construidas a mano suelen perder.
Los modelos que fijan el listón
Cortex se midió contra el trabajo que definió este problema. Tres referencias fijan el listón, todas en el mismo benchmark público.
IBM TabFormer
El dataset sintético de fraude con tarjeta de IBM y el origen de esta línea de trabajo. Es el estándar sobre el que se miden estos modelos.
NVIDIA TFM
El Transaction Foundation Model abierto de NVIDIA. Mismo dataset, mismo enfoque. NVIDIA no publica métricas, así que ejecutamos el blueprint de principio a fin.
Revolut PRAGMA-M
El transaction foundation model de Revolut. Su atención es bidireccional, lo que encaja mal en un benchmark que etiqueta cada transacción — lo tratamos más abajo.
El score es el detector
Cortex lee la secuencia bruta de transacciones de cada titular y produce un score de fraude por transacción. Ese score ya lleva el contexto conductual que impulsa el fraude: recencia, patrones de comercio, ritmo de gasto.
En la prueba del IBM TabFormer — separada por tiempo (entrenamiento 1991–2017, validación 2018, prueba 2019–2020, 2.03M de transacciones, 2.068 fraudes, 0.10%) — el score de Cortex alcanza AUPRC 0.99 y F1 0.96, frente a 0.14 de un XGBoost sobre las 13 columnas brutas del dataset, 0.83 de PRAGMA-M y 0.18 del Transaction Foundation Model de NVIDIA. El dataset y el objetivo se mantienen fijos; solo cambia el modelo — y el modelo de Cortex tiene ~8M de parámetros, frente a 29M del de NVIDIA y 100M del PRAGMA-M.
Los otros modelos entregan un embedding a un clasificador separado. En Cortex el propio score es el detector, así que no hay un segundo modelo que fusione features ni que mantener. En todas las comparaciones de esta página el dataset, el objetivo y el protocolo aislado en el tiempo se mantienen fijos, y solo cambia la feature.
Solo cambia la feature.
- Transacciones de tarjeta brutas
- 13 columns into XGBoostfeatures construidas a mano
- AUPRC 0.14
- Transacciones de tarjeta brutas
- Cortexlee la secuencia bruta — el score de fraude es el detector
- AUPRC 0.99
Dos carriles sobre el mismo dataset, objetivo y división aislada en el tiempo: columnas brutas frente al score de fraude de Cortex.
Resultados en la prueba completa aislada en el tiempo
El conjunto de prueba es la división retenida completa, aislada por tiempo. Entrenamos de 1991 a 2017, validamos en 2018 y probamos de 2019 a 2020: 2.034.720 transacciones, de las cuales 2.068 son fraude (0.102%) — no es una muestra. El umbral de decisión se fija en una validación anterior a 2019 y se aplica congelado a los años de prueba. Reportamos solo AUPRC y F1, porque a esta prevalencia el AUROC se satura cerca de 1.0 y deja de distinguir modelos fuertes.
| Modelo | Lectura | Params | AUPRC | F1 |
|---|---|---|---|---|
| Raw features | 13 columnas en un XGBoost | n/a | 0.14 | 0.26 |
| NVIDIA TFM | embedding más bruto | 29M | 0.18 | 0.23 |
| Revolut PRAGMA-M | embedding más bruto en un XGBoost | 100M | 0.47 | 0.60 |
| Revolut PRAGMA-M | fine-tune con LoRA | 100M | 0.83 | 0.81 |
| Cortex | score de fraude, por sí solo | ~8M | 0.99 | 0.96 |
La lectura es cómo la salida de cada modelo se convierte en una predicción de fraude. El TFM de NVIDIA fusiona su embedding con las columnas brutas; el embedding solo queda por debajo del baseline bruto. PRAGMA-M aparece dos veces — su embedding fusionado con las columnas brutas en un XGBoost, y un fine-tune con LoRA y head de fraude directo. El score de Cortex se reporta por sí solo. Bruto, NVIDIA y Cortex se evalúan sobre las mismas 2.03M de filas; el embedding de NVIDIA fusionado con las columnas brutas eleva el baseline de 0.14 a 0.18. El fine-tune de PRAGMA-M se evalúa sobre todos los fraudes más una muestra de transacciones legítimas y se repondera a la tasa real del 0.1%, ya que etiqueta una transacción por pasada.
AUPRC y F1 entre los modelos
AUPRC y F1 entre los modelos, dimensionados por número de parámetros, todos en la prueba completa de 2.0M de transacciones aislada en el tiempo en 2019–2020. Cortex funciona con unos 8M y puntúa por encima de todo modelo mayor; NVIDIA aparece con su embedding fusionado a las features brutas.
El score de fraude de Cortex es un detector independiente — AUPRC 0.99, F1 0.96, unas 7× el baseline bruto y muy por encima de PRAGMA-M (0.83) y del TFM de NVIDIA (0.18). Es una probabilidad calibrada por transacción, entregada directamente a la métrica, sin clasificador posterior. Y llega a esto con el modelo más pequeño por amplio margen — ~8M de parámetros frente a 29M de NVIDIA y 100M de PRAGMA-M: el resultado es la representación, no la escala.
El AUPRC es el eje más limpio a esta prevalencia (no depende del umbral). Todas las métricas se muestran redondeadas hacia arriba con dos decimales (el AUPRC exacto de Cortex es 0.989), excepto el baseline de features brutas, redondeado al más cercano para que el listón que todos superan no quede favorecido (0.142 → 0.14); las cifras subyacentes provienen de los archivos de resultados versionados.
Tamaños de modelo — Cortex es el más pequeño
Los tres modelos se ejecutaron sobre el mismo dataset IBM TabFormer. Cortex entrega la detección de fraude más fuerte siendo ~4× menor que el modelo de NVIDIA y ~12× menor que PRAGMA-M, y entrena en bastante menos de la mitad del tiempo de PRAGMA-M.
| Modelo | Parámetros | Tiempo de entrenamiento |
|---|---|---|
| Cortex | ~8M | ~1h20m |
| NVIDIA TFM | 29M | — |
| Revolut PRAGMA-M | 100M | ~3h30m |
El tiempo de entrenamiento se mide en 4×GB200, sumando preentrenamiento y fine-tuning, para los dos modelos que entrenamos aquí; el blueprint de NVIDIA entrega un checkpoint, así que su entrenamiento no se repitió.
Cómo se compara con el PRAGMA de Revolut
PRAGMA es el transaction foundation model de Revolut (arXiv:2604.08649): un transformer solo-encoder de 100M de parámetros entrenado con un objetivo auto-supervisado de masked modelling. Preentrenamos PRAGMA-M con los mismos datos de entrenamiento de 1991–2017 que Cortex y lo leímos de dos formas. Su embedding congelado fusionado con las columnas brutas en un XGBoost alcanza AUPRC 0.47 / F1 0.60; adaptarlo para fraude con LoRA — la receta de fine-tuning del propio paper de PRAGMA — y una head directo alcanza 0.83 / 0.81. Ambos superan el baseline bruto, pero se quedan por debajo del 0.99 / 0.96 de Cortex, con unas 12× el tamaño.
| PRAGMA-M | NeoLDM · Cortex | |
|---|---|---|
| Parámetros | ~100M | ~8M |
| Arquitectura | solo-encoder, masked modelling | decoder, score por transacción |
| Interacción entre campos | implícita (solo atención) | directa |
| Tiempo de entrenamiento | ~3h30m | ~1h20m |
| Mejor AUPRC | 0.83 | 0.99 |
El fraude suele emerger en combinaciones de campos: un importe, en un tipo de comercio, hora y ubicación, tomados en conjunto. PRAGMA no tiene interacción directa entre features; relaciona campos solo de forma implícita, mediante atención de propósito general. Cortex modela esas interacciones directamente. Este benchmark además etiqueta cada transacción, y la atención de PRAGMA es bidireccional, así que solo la transacción al final de una ventana puede evaluarse sin ver su propio futuro — una por pasada. Por eso evaluamos el fine-tune sobre todos los fraudes más una muestra de transacciones legítimas y reponderamos a la tasa real del 0.1%, recuperando la métrica que PRAGMA alcanzaría en todo el conjunto; Cortex evalúa una ventana entera en una pasada. PRAGMA-M es la variante de 100M de parámetros del paper, que nosotros mismos preentrenamos y ajustamos en IBM TabFormer (Ostroukhov et al., PRAGMA: Revolut Foundation Model).
Comparado con el Transaction Foundation Model de NVIDIA
NeoLDM creció junto al blueprint abierto del Transaction Foundation Model de NVIDIA — mismo dataset (IBM TabFormer), misma idea de entrenar un modelo sobre transacciones brutas y usar su salida para fraude posterior. El blueprint de NVIDIA es un decoder Llama de 29M de parámetros; agrupa el estado oculto del último token en un embedding de 512 dimensiones, lo reduce a 64 con PCA y alimenta un XGBoost.
| NVIDIA TFM | NeoLDM · Cortex | |
|---|---|---|
| Parámetros | ~29M | ~8M |
| Salida | último token en 512 dimensiones, luego embedding PCA de 64 | score de fraude por transacción |
| Posterior | XGBoost | ninguno — el score es el detector |
| Conjunto de prueba | 2.03M completo, aislado en el tiempo | 2.03M completo, aislado en el tiempo |
| Mejor AUPRC | 0.18 | 0.99 |
El repositorio de NVIDIA no entrega métricas en las salidas de sus notebooks, así que ejecutamos su blueprint de principio a fin — su checkpoint publicado, sus notebooks, los datos reales de IBM TabFormer. Su propio notebook llama a la Average Precision (AUPRC) “la métrica operacionalmente crítica para el fraude”, así que lideramos con ella. En la prueba completa aislada en el tiempo de 2019–2020 (las mismas filas que Cortex), fusionar el embedding del foundation model con las columnas brutas mejora su detección: el baseline de features brutas marca AUPRC 0.14, el embedding solo 0.01, y los dos fusionados llegan a 0.18 — el número combinado que reportamos para NVIDIA.
NVIDIA no publica números absolutos, así que ejecutamos su blueprint nosotros mismos sobre la división de prueba completa — las mismas filas que Cortex y el baseline bruto. El orden: Cortex (0.99) muy por delante, luego PRAGMA-M de Revolut (0.83), luego el embedding más bruto de NVIDIA (0.18), justo por encima del baseline bruto (0.14).
Qué significa el resultado en la práctica
El resultado no es solo académico. Cada ventaja se traduce en algo práctico.
Menor coste de operación
Con unos 8M de parámetros, Cortex es 4× menor que el modelo de NVIDIA y 12× menor que el de Revolut. Eso significa menos cómputo por inferencia, menor coste a escala de producción y un modelo más fácil de desplegar donde los datos ya están.
Menos piezas móviles
El score es el detector, así que no hay una pila de embedding más clasificador que construir, ajustar y mantener. Eso acorta el camino de las transacciones brutas a la decisión, y el tiempo que toma llegar.
Reproducible
Publicamos la división de prueba completa, los scores por transacción, un notebook ejecutable y el código bajo Apache-2.0. Los números pueden comprobarse en lugar de aceptarse de buena fe.
Reproduce los resultados
El notebook calcula el score de Cortex a partir de los scores por transacción publicados. Sin ellos, recurre a los resultados versionados, así que renderiza igualmente. No necesitas GPU, el dataset ni un checkpoint solo para ver los números.
IBM TabFormer
El dataset sintético de fraude con tarjeta de crédito de IBM y el origen de esta línea de trabajo (arXiv:2011.01843, IBM/TabFormer): 24.386.900 transacciones de 2.000 titulares (9 tarjetas cada uno; los “20.000 usuarios” del paper son una errata), que abarcan 1991–2020 con un 0.11% de fraude, divididas por tiempo de calendario (entrenamiento 1991–2017, validación 2018, prueba 2019–2020). El CSV bruto se obtiene de IBM bajo los términos de IBM y no se redistribuye aquí. Los scores de fraude de Cortex por transacción, sobre las 24.386.900 transacciones, se publican en embeddings.neospace.ai.
El baseline bruto alimenta el XGBoost directamente con las columnas de la tabla de transacciones — sin agregación temporal, sin features construidas — así que la comparación es limpia: una representación aprendida por Cortex frente a los campos brutos. Como referencia, el paper original de TabFormer reporta su mejor resultado de detección de fraude en F1 ≈ 0.86 (features TabBERT más un LSTM). Ese número no es comparable con los de aquí: el paper predice sobre una ventana de 10 transacciones (una ventana de fraude cada 10 filas, por lo que la prevalencia efectiva es unas 10× mayor), en su propia división por ventanas — un planteamiento más fácil que la detección por transacción al 0.1%. Es un punto de referencia histórico en este dataset, no un baseline equivalente.