No benchmark de fraude que a NVIDIA usa, o melhor resultado vem do menor modelo: o Cortex da NeoSpace — à frente dos bem maiores da NVIDIA e da Revolut
Esse benchmark é o TabFormer da IBM, o dataset sintético de fraude de cartão sobre o qual esta linha de trabalho foi construída, e sobre o qual a NVIDIA construiu o seu Transaction Foundation Model para fraude. Vários modelos já atacaram a mesma tarefa — transformar um fluxo cru de transações de cartão num sinal de fraude —, incluindo o PRAGMA de 100M de parâmetros da Revolut, que adaptamos a ele aqui. No teste completo, isolado no tempo, o Cortex pontua acima de todos eles, usando cerca de 8 milhões de parâmetros.
As condições por trás do número
AUPRC (F1 0.96) no teste completo de 2.03M de transações, não numa amostra
melhor que um classificador sem habilidade a 0.102% de prevalência de fraude
parâmetros, 4× menor que o da NVIDIA e 12× menor que o PRAGMA da Revolut
A fraude aparece no comportamento, não em campos isolados
Uma transação isolada raramente parece fraudulenta por si só. O sinal está no comportamento em volta dela: há quanto tempo o cartão foi usado, em quais estabelecimentos, o ritmo de gasto e qual padrão ela quebra.
Durante anos a abordagem padrão foi construir features à mão que aproximam esse comportamento e alimentar um classificador com elas. Isso satura rápido: um modelo forte de gradient boosting sobre as colunas cruas empaca em AUPRC 0.14. Esse limite é o que empurrou a área para os transaction foundation models, que treinam sobre a própria sequência crua e aprendem o contexto comportamental que features feitas à mão costumam perder.
Os modelos que definem a régua
O Cortex foi medido contra o trabalho que definiu este problema. Três referências estabelecem a régua, todas no mesmo benchmark público.
IBM TabFormer
O dataset sintético de fraude de cartão da IBM e a origem desta linha de trabalho. É o padrão sobre o qual estes modelos são medidos.
NVIDIA TFM
O Transaction Foundation Model aberto da NVIDIA. Mesmo dataset, mesma abordagem. A NVIDIA não publica métricas, então rodamos o blueprint de ponta a ponta.
Revolut PRAGMA-M
O transaction foundation model da Revolut. A atenção dele é bidirecional, o que se encaixa mal num benchmark que rotula toda transação — tratamos disso abaixo.
O score é o detector
O Cortex lê a sequência crua de transações de cada portador e produz um score de fraude por transação. Esse score já carrega o contexto comportamental que move a fraude: recência, padrões de estabelecimento, ritmo de gasto.
No teste do IBM TabFormer — separado por tempo (treino 1991–2017, validação 2018, teste 2019–2020, 2.03M de transações, 2.068 fraudes, 0.10%) — o score do Cortex chega a AUPRC 0.99 e F1 0.96, contra 0.14 de um XGBoost sobre as 13 colunas cruas do dataset, 0.83 do PRAGMA-M e 0.18 do Transaction Foundation Model da NVIDIA. O dataset e o alvo ficam fixos; só o modelo muda — e o modelo do Cortex tem ~8M de parâmetros, contra 29M do da NVIDIA e 100M do PRAGMA-M.
Os outros modelos entregam um embedding a um classificador separado a jusante. No Cortex o próprio score é o detector, então não há um segundo modelo para fundir features ou manter. Em todas as comparações desta página o dataset, o alvo e o protocolo isolado no tempo ficam fixos, e só a feature muda.
Só a feature muda.
- Transações de cartão cruas
- 13 columns into XGBoostfeatures feitas à mão
- AUPRC 0.14
- Transações de cartão cruas
- Cortexlê a sequência crua — o score de fraude é o detector
- AUPRC 0.99
Duas pistas sobre o mesmo dataset, alvo e divisão isolada no tempo: colunas cruas contra o score de fraude do Cortex.
Resultados no teste completo isolado no tempo
O conjunto de teste é a divisão retida inteira, isolada por tempo. Treinamos de 1991 a 2017, validamos em 2018 e testamos de 2019 a 2020: 2.034.720 transações, das quais 2.068 são fraude (0.102%) — não é uma amostra. O limiar de decisão é definido numa validação anterior a 2019 e aplicado congelado aos anos de teste. Reportamos apenas AUPRC e F1, porque nesta prevalência o AUROC satura perto de 1.0 e deixa de distinguir modelos fortes.
| Modelo | Leitura | Params | AUPRC | F1 |
|---|---|---|---|---|
| Raw features | 13 colunas num XGBoost | n/a | 0.14 | 0.26 |
| NVIDIA TFM | embedding mais cru | 29M | 0.18 | 0.23 |
| Revolut PRAGMA-M | embedding mais cru num XGBoost | 100M | 0.47 | 0.60 |
| Revolut PRAGMA-M | fine-tune com LoRA | 100M | 0.83 | 0.81 |
| Cortex | score de fraude, sozinho | ~8M | 0.99 | 0.96 |
A leitura é como a saída de cada modelo vira uma previsão de fraude. O TFM da NVIDIA funde o seu embedding com as colunas cruas; o embedding sozinho fica abaixo do baseline cru. O PRAGMA-M aparece duas vezes — o embedding fundido com as colunas cruas num XGBoost, e um fine-tune com LoRA e head de fraude direto. O score do Cortex é reportado sozinho. Cru, NVIDIA e Cortex são avaliados sobre as mesmas 2.03M de linhas; o embedding da NVIDIA fundido com as colunas cruas eleva o baseline de 0.14 para 0.18. O fine-tune do PRAGMA-M é avaliado sobre todas as fraudes mais uma amostra de transações legítimas e reponderado à taxa real de 0.1%, já que ele rotula uma transação por passagem.
AUPRC e F1 entre os modelos
AUPRC e F1 entre os modelos, dimensionados por contagem de parâmetros, todos no teste completo de 2.0M de transações isolado no tempo em 2019–2020. O Cortex roda em cerca de 8M e pontua acima de todo modelo maior; a NVIDIA aparece com o embedding fundido às features cruas.
O score de fraude do Cortex é um detector independente — AUPRC 0.99, F1 0.96, cerca de 7× o baseline cru e muito acima do PRAGMA-M (0.83) e do TFM da NVIDIA (0.18). É uma probabilidade calibrada por transação, entregue direto à métrica, sem classificador a jusante. E chega a isso com o menor modelo por larga margem — ~8M de parâmetros contra 29M da NVIDIA e 100M do PRAGMA-M: o resultado é a representação, não a escala.
O AUPRC é o eixo mais limpo nesta prevalência (independe de limiar). Todas as métricas aparecem arredondadas para cima com duas casas (o AUPRC exato do Cortex é 0.989), exceto o baseline de features cruas, arredondado para o mais próximo para que a régua que todos superam não seja lisonjeada (0.142 → 0.14); os números por trás vêm dos arquivos de resultados versionados.
Tamanhos de modelo — o Cortex é o menor
Os três modelos foram rodados no mesmo dataset IBM TabFormer. O Cortex entrega a detecção de fraude mais forte sendo ~4× menor que o modelo da NVIDIA e ~12× menor que o PRAGMA-M, e treina em bem menos da metade do tempo do PRAGMA-M.
| Modelo | Parâmetros | Tempo de treino |
|---|---|---|
| Cortex | ~8M | ~1h20m |
| NVIDIA TFM | 29M | — |
| Revolut PRAGMA-M | 100M | ~3h30m |
O tempo de treino é medido em 4×GB200, somando pré-treino e fine-tuning, para os dois modelos que treinamos aqui; o blueprint da NVIDIA entrega um checkpoint, então o treino dele não foi refeito.
Como isso se compara ao PRAGMA da Revolut
O PRAGMA é o transaction foundation model da Revolut (arXiv:2604.08649): um transformer só-encoder de 100M de parâmetros treinado com objetivo auto-supervisionado de masked modelling. Pré-treinamos o PRAGMA-M nos mesmos dados de treino de 1991–2017 do Cortex e o lemos de duas formas. O embedding congelado fundido às colunas cruas num XGBoost chega a AUPRC 0.47 / F1 0.60; adaptá-lo para fraude com LoRA — a receita de fine-tuning do próprio paper do PRAGMA — e uma head direto chega a 0.83 / 0.81. Ambos superam o baseline cru, mas ficam abaixo dos 0.99 / 0.96 do Cortex, com cerca de 12× o tamanho.
| PRAGMA-M | NeoLDM · Cortex | |
|---|---|---|
| Parâmetros | ~100M | ~8M |
| Arquitetura | só-encoder, masked modelling | decoder, score por transação |
| Interação entre campos | implícita (só atenção) | direta |
| Tempo de treino | ~3h30m | ~1h20m |
| Melhor AUPRC | 0.83 | 0.99 |
A fraude costuma emergir em combinações de campos: um valor, num tipo de estabelecimento, hora e local, tomados em conjunto. O PRAGMA não tem interação direta entre features; relaciona campos apenas de forma implícita, por atenção de uso geral. O Cortex modela essas interações diretamente. Este benchmark também rotula toda transação, e a atenção do PRAGMA é bidirecional, então só a transação no fim de uma janela pode ser avaliada sem ver o próprio futuro — uma por passagem. Por isso avaliamos o fine-tune sobre todas as fraudes mais uma amostra de transações legítimas e reponderamos à taxa real de 0.1%, recuperando a métrica que o PRAGMA alcançaria no conjunto inteiro; o Cortex avalia uma janela inteira numa passagem. O PRAGMA-M é a variante de 100M de parâmetros do paper, que nós mesmos pré-treinamos e ajustamos no IBM TabFormer (Ostroukhov et al., PRAGMA: Revolut Foundation Model).
Comparado com o Transaction Foundation Model da NVIDIA
O NeoLDM cresceu ao lado do blueprint aberto do Transaction Foundation Model da NVIDIA — mesmo dataset (IBM TabFormer), mesma ideia de treinar um modelo sobre transações cruas e usar a saída dele para fraude a jusante. O blueprint da NVIDIA é um decoder Llama de 29M de parâmetros; ele agrupa o estado oculto do último token num embedding de 512 dimensões, reduz para 64 com PCA e alimenta um XGBoost.
| NVIDIA TFM | NeoLDM · Cortex | |
|---|---|---|
| Parâmetros | ~29M | ~8M |
| Saída | último token em 512 dimensões, depois embedding PCA de 64 | score de fraude por transação |
| A jusante | XGBoost | nenhum — o score é o detector |
| Conjunto de teste | 2.03M completo, isolado no tempo | 2.03M completo, isolado no tempo |
| Melhor AUPRC | 0.18 | 0.99 |
O repositório da NVIDIA não entrega métricas nas saídas dos notebooks, então rodamos o blueprint deles de ponta a ponta — o checkpoint que eles publicam, os notebooks deles, os dados reais do IBM TabFormer. O próprio notebook deles chama a Average Precision (AUPRC) de “métrica operacionalmente crítica para fraude”, então lideramos com ela. No teste completo isolado no tempo de 2019–2020 (as mesmas linhas do Cortex), fundir o embedding do foundation model às colunas cruas melhora a detecção deles: o baseline de features cruas marca AUPRC 0.14, o embedding sozinho 0.01, e os dois fundidos chegam a 0.18 — o número combinado que reportamos para a NVIDIA.
A NVIDIA não publica números absolutos, então rodamos o blueprint deles nós mesmos sobre a divisão de teste completa — as mesmas linhas do Cortex e do baseline cru. A ordem: Cortex (0.99) bem à frente, depois o PRAGMA-M da Revolut (0.83), depois o embedding mais cru da NVIDIA (0.18), logo acima do baseline cru (0.14).
O que o resultado significa na prática
O resultado não é só acadêmico. Cada vantagem se traduz em algo prático.
Custo de operação menor
Com cerca de 8M de parâmetros, o Cortex é 4× menor que o modelo da NVIDIA e 12× menor que o da Revolut. Isso significa menos computação por inferência, custo menor em escala de produção e um modelo mais fácil de implantar onde os dados já estão.
Menos peças móveis
O score é o detector, então não há uma pilha de embedding mais classificador para construir, ajustar e manter. Isso encurta o caminho das transações cruas até a decisão, e o tempo para chegar lá.
Reproduzível
Publicamos a divisão de teste completa, os scores por transação, um notebook executável e o código sob Apache-2.0. Os números podem ser conferidos em vez de aceitos de boa fé.
Reproduza os resultados
O notebook calcula o score do Cortex a partir dos scores por transação publicados. Sem eles, ele recorre aos resultados versionados, então renderiza de qualquer forma. Você não precisa de GPU, do dataset nem de um checkpoint só para ver os números.
IBM TabFormer
O dataset sintético de fraude de cartão de crédito da IBM e a origem desta linha de trabalho (arXiv:2011.01843, IBM/TabFormer): 24.386.900 transações de 2.000 portadores (9 cartões cada; os “20.000 usuários” do paper são um erro de digitação), cobrindo 1991–2020 a 0.11% de fraude, dividido por tempo de calendário (treino 1991–2017, validação 2018, teste 2019–2020). O CSV cru é obtido da IBM sob os termos da IBM e não é redistribuído aqui. Os scores de fraude do Cortex por transação, sobre todas as 24.386.900 transações, são publicados em embeddings.neospace.ai.
O baseline cru alimenta o XGBoost diretamente com as colunas da tabela de transações — sem agregação temporal, sem features construídas — então a comparação é limpa: uma representação aprendida pelo Cortex contra os campos crus. Para referência, o paper original do TabFormer reporta o seu melhor resultado de detecção de fraude em F1 ≈ 0.86 (features TabBERT mais um LSTM). Esse número não é comparável aos daqui: o paper prevê sobre uma janela de 10 transações (uma janela de fraude a cada 10 linhas, portanto prevalência efetiva cerca de 10× maior), na divisão em janelas dele — um enquadramento mais fácil que a detecção por transação a 0.1%. É um ponto de referência histórico neste dataset, não um baseline equivalente.