NVIDIA Kumo 关系超常操作监督机器学习关系数据，不需要培训

中文版正在随流水线自动整理，稍后刷新即可；可先阅读下方英文原文。

本文由 AI宝盒自动抓取并翻译，版权归原作者所有；如需查看原文请点下方链接。

NVIDIA Kumo Relational Outperforms Supervised Machine Learning on Relational Data, No Training Required

TL;DR

NVIDIA Kumo Relational is a pre-trained relational foundation model that makes predictions directly on enterprise databases. Given a predictive query, it gathers up to 10,000 historical examples as context and predicts outcomes such as churn, demand, or fraud in a single forward pass. It needs no task-specific training, no feature engineering, and no flattening of tables. Kumo Relational is the first few-shot foundation model to outperform supervised machine learning on common relational benchmarks. Across 41 tasks on 15 databases, it beats supervised relational deep learning models and expert-engineered gradient-boosted tree pipelines, and on the SAP SALT enterprise benchmark it surpasses AutoGluon ensembles by 8% in mean reciprocal rank (MRR). It scales to databases with 500B+ rows and works for humans and agents alike, through NVIDIA's open-source, GPU-native structured-data-models library or as an NVIDIA NIM.

- Paper: https://arxiv.org/abs/2604.12596

- Documentation: https://docs.nvidia.com/sdgm/rfm/overview

The Shift to Structured Data Foundation Models

Foundation models have already rewritten the playbook for language and vision. Not long ago, production NLP meant a dedicated model per task, each fed by its own pipeline of tokenization, lemmatization, and n-grams. LLMs made that stack largely obsolete for three reasons: they were more accurate than the best task-specific models, far simpler to put into production, and flexible enough to open a new era of agentic applications.

The same shift is now underway for structured data. Relational databases power the world's most critical business decisions, yet predictive modeling on them still requires weeks of feature engineering, task-specific training, and tuned pipelines. Structured data foundation models change that for the same three reasons:

Better accuracy today: As drop-in replacements, these models already beat many production pipelines, especially XGBoost. On RelBench V1 classification tasks, Kumo Relational outperforms gradient-boosted trees on expert-engineered features by nearly 4 AUROC points on average. On SAP SALT, it beats XGBoost on engineered features by 7 MRR points out of the box and by 13 MRR points after fine-tuning. These results make a compelling case for replacing production XGBoost pipelines with Kumo Relational.

Simplicity and agility: One pre-trained model replaces separate pipelines for individual tasks. A new prediction becomes a query instead of a project, so ML teams can finally take on use cases that traditional ML made too laborious to build at every level of the organization.

Agents that can predict: LLMs let agents read, write, and reason. Structured data foundation models let them anticipate what happens next, such as which customer will churn, and act on it. Kumo Relational is already built to be called by agents, and its Predictive Query Language (PQL) gives them a simple interface for asking predictive questions.

Today, we are introducing Kumo Relational (paper, documentation), a pre-trained foundation model that brings this paradigm to relational data. Connect a database, describe what to predict, and get predictions in a single forward pass. No training required.

How Kumo Relational Works

Most foundation models for structured data operate on a single flat table. Real-world data lives in relational databases instead: users connected to orders connected to products, all evolving over time. Flattening these relationships into one row through manual aggregation (e.g., "average order value in the last 30 days") loses fine-grained structural signals and takes significant human effort.

Kumo Relational is a Relational Foundation Model that operates directly on the database, respecting its tables, foreign keys, and timestamps. It is pre-trained once on synthetic relational data that reflects real-world datasets and adapts to each new task through in-context learning, reading up to 10,000 context examples at inference time. Each example pairs a local subgraph around an entity at a point in time with its ground-truth target (e.g., "this user churned" or "this item sold 142 units").

![Overview of the NVIDIA Kumo Relational system: (a) database integration, (b) a prompting interface that turns natural language into a predictive query, and (c) automatic context generation feeding the NVIDIA Kumo Relational model, which scales horizontally across tenants.]

Figure 1. Overview of the Kumo Relational system. Connect a database, specify a predictive query, and Kumo Relational handles the rest, from context generation to model inference.

To make a prediction, Kumo Relational has to do three things: (1) understand the values within each table, (2) relate records across tables, and (3) relate context examples with known targets to the entity being predicted. Here is how it works:

![Kumo Relational architecture: (a) context input with task, users, orders and items tables; (b) column and row attention within tables with injected context targets; (c) graph attention and cross-sample attention across tables.]

Figure 2. Kumo Relational architecture: (a) context input, (b) reasoning within tables, (c) reasoning across tables.

Automatic Context Generation: Tasks are written in the Predictive Query Language (PQL), a declarative interface where you state what to predict rather than how. For temporal tasks, Kumo Relational replays historical database states: it samples entity-centric subgraphs up to an anchor timestamp and computes each target from events after that timestamp, while serving the model only the data from before it. This prevents data leakage.

Reasoning Within Tables: A lightweight network processes each table independently, alternating column attention (relating values within a column) and row attention (relating features within a row). The model learns which columns and rows matter for the current prediction and filters out noise before it propagates.

Reasoning Across Tables: A larger network distributes the row embeddings across the relational structure via graph attention over primary-key/foreign-key relationships, interleaved with cross-sample attention across context examples. This is where relational reasoning happens, such as linking a user's profile to their transaction history. Because this stage works on row embeddings rather than on every cell in every table, the design avoids quadratic cost and scales to large contexts and deeper subgraphs.

How Kumo Relational Was Built

Kumo Relational is pre-trained on entirely synthetic relational data simulated to reflect real-world relational databases with diverse predictive queries. Pre-training proceeds in stages, from single tables to increasingly complex relational structures.

The diverse relational databases needed for pre-training are rarely public, so synthetic data fills the gap. Kumo Relational's generator builds on the approach of PluRel (Kothapalli et al., ICML 2026), which extends single-table data generators to full relational databases. Members of the Kumo team helped develop PluRel and co-authored the original paper. PluRel generates each database in three stages: a schema, foreign-key links between rows that cluster as they do in real data, and column values from Structural Causal Models with temporal trends and cross-table dependencies. Generation is lightweight, so pre-training data is effectively unlimited, and the PluRel paper shows that pre-training loss follows a power law as synthetic databases are added, with gains that carry over to real databases.

Through this pre-training, the model learns to filter, correlate, and aggregate information across tables instead of relying on fixed aggregations. When maximum accuracy matters, Kumo Relational can also be fine-tuned on a specific dataset and task.

Performance

In this paper, we evaluated Kumo Relational on 41 benchmarks across 15 relational databases from RelBench V1 and V2, SAP SALT, and 4DBInfer, spanning e-commerce, medical, enterprise, social, and academic domains. None of these datasets were seen in pre-training. Kumo Relational outperforms the strongest supervised models in both classification and regression, including relational deep learning models and expert-engineered tabular ensembles. On the RelArena-α leaderboard, which compares relational models and systems on RelBench V1, it also sits on the accuracy-efficiency Pareto front out of the box:

![Scatter plot of the RelArena-α leaderboard: relative accuracy as Elo across tasks (y-axis) versus median inference time per 1,000 samples (x-axis, log scale). Kumo Relational sits on the Pareto front at about 17 seconds and Elo 1,842. The highest-scoring entry, rt-plurel, reaches Elo 1,878 at about 7,300 seconds, roughly 430 times slower. Every other foundation model, feature-engineering system, and supervised model scores lower and runs slower than Kumo Relational.]

Figure 3. RelArena-α leaderboard: Elo across tasks versus median inference time per 1,000 samples (log scale). Kumo Relational is about 430× faster than the highest-scoring entry at similar accuracy.

The paper also reports that on the SAP SALT enterprise benchmark, Kumo Relational surpasses large AutoGluon ensembles by 8% in mean reciprocal rank (MRR) and recent tabular foundation models by about 25%, and fine-tuning extends its lead over AutoGluon to 16%. It also holds up under hard conditions: it performs well with as little as 0.2% of the training data as context, stays stable when up to 75% of foreign-key links are removed, and barely degrades when many noisy columns are added.

Limitations

Kumo Relational performs best on data with meaningful relationships and temporal dynamics, such as user behavior over time. On tasks with very large training sets, task-specific supervised models may still edge out in-context predictions, which used at most 10,000 context examples in our benchmarks. Fine-tuning of the foundation model is designed for exactly this case. Predictive signals must also be reachable within a limited number of hops, so start with a focused query over a few relevant tables and expand the graph as needed.

Demo

Kumo Relational runs in-context learning natively over databases: in memory, through database and warehouse connectors, or through a custom graph engine that handles 500B+ rows via memory-mapped I/O at up to 5 GB/s. It is available in NVIDIA's newly released, GPU-native structured-data-models library, the same open-source library that powers our sister model, Kumo Tabular. The library downloads the weights from the Hugging Face Hub on first use, so you can load the model in a GPU-backed notebook and predict directly from it. The code below passes context examples, prediction entities, and their related tables to the model:

# pip install structured-data-models

import sdm

model = sdm.models.KumoRelational(device="cuda")

pred = model(

# In-context training table (fkeys/timestamps/targets):

x_context=...,

y_context=...,

# Prediction examples (fkeys/timestamps):

x_query=...,

# Multi-table information for context/prediction entities:

related_context_tables=...,

related_query_tables=...,

)

See the library's relational examples for complete RelBench and SAP SALT pipelines, including how to sample each entity's related tables.

To run the model as a separate service instead, deploy it as an NVIDIA NIM and point the open-source structured-data-models-client at it from your notebook. You write the prediction in PQL, and the client gathers the context examples and related tables, then sends the request:

# pip install 'structured-data-models-client[relational]'

import sdm_client

client = sdm_client.SDMClient(url="http://localhost:8001") # NIM URL

query = sdm_client.PredictiveQuery(

# Prediction task in Predictive Query Language (PQL):

"PREDICT COUNT(orders.*, 0, 30, days) FOR EACH users.user_id",

# Multi-table data as pandas DataFrames (keys/links

Auto-fetched and translated by AI Gem Box. All rights belong to the original author.