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

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

TL；数据

NVIDIA Kumo关系(英語：NVIDIA Kumo Relational)是一种经过预先训练的关系基础模型，直接在企业数据库中进行预测。 鉴于一个预测性的查询，它收集了多达10 000个历史实例作为上下文，并预测结果，如在单一的前进通道中，需要或欺诈。 它不需要具体任务的培训，不需要特色工程，也不需要平整桌子。 Kumo Relational是第一个在共同关系基准测试上超越监督机器学习的几弹基础模型。 在15个数据库的41项任务中，它以平均对等等级(MRR)比监督关系深层学习模型和专家设计的梯度助推树管，在SAP SALT企业中，基准测试它比超越 AutoGluon 综艺节目高8%。 它通过NVIDIA的开源，GPU-nature结构-数据模型库或作为NVIDIA NIM，缩放到有500B+行的数据库，并为人类和agents同样工作。

- 文件：https://arxiv.org/abs/2604.12596

- 文件：https://docs.nvidia.com/sdgm/rfm/overview

转向结构化数据基础模型

基金会模型已经为语言和视觉改写了游戏本。 不久以前，生产NLP意味着每个任务都有一个专用模型，每个模型都由它自己的标致化，lemmatization，和n克的管道提供。 LLMs使该堆栈基本过时，原因有三：它们比最佳的任务特定型号更准确，投入生产要简单得多，足够灵活，可以开启新的代理应用时代。

结构化数据也正在发生变化。 关系数据库为世界最关键的商业决策提供动力，然而对其进行预测模型，仍然需要几周的特色工程、特定任务培训和调制管道。 结构化数据基础模型改变的原因有三：

今天的精度更好：作为滴入式替换，这些模型已经击败了许多生产管道，特别是XGBoost. 在Rel Bench V1分类任务上，Kumo关系在专家设计的特征上比梯度-促进树平均高出近4个AUROC点。 在SAP SALT上，它通过7个MRR从盒子中点出，在微调后以13个MRR点击败XGBoost在工程特性上。 这些结果为用Kumo关系取代XGBoost生产管道提供了令人信服的理由。

简便和敏捷性：一个经过预先训练的模型取代单独的管道，用于个别任务。 新的预测变成了一个查询而不是一个项目，因此ML团队最终可以承担传统ML制造的过于费力，无法在组织的各个级别建设的使用案例。

可以预测的Agents:LLMs让agents读，写，和理性。 结构化的数据基础模型让它们预测接下来会发生什么，例如哪个客户会摇摆不定，并据此采取行动。 Kumo Relational已经建成由agents调用，其预测性查询语言(PQL)给了他们一个简单的界面来询问预测性问题。

今天，我们正在引入Kumo关系(纸，文档)，这是一个经过预先训练的基础模型，带来这个模式用于关系数据。 连接一个数据库，描述什么是预测，并在一个单一的前进通道中获得预测。 无需培训。

库莫关系如何运作

大多数结构化数据的基础模型运行在单一的平面表上。 而现实世界的数据则生活在关系数据库中：用户连接到与产品相连的订单，这些订单都随时间演变。 通过手动聚合将这些关系平整成一行(如"过去30天的平均顺序值")，失去精细的纹理结构信号，需要大量人力努力。

Kumo Relational是一个在数据库上直接运行的Relational Foundation Model，尊重其表格，外国密钥和时间戳。 它曾经接受过一次关于合成关系数据的预训，通过内文本学习，在推论时间读取多达10,000个上下文实例，反映现实世界数据集，并适应每个新任务。 每个示例在某一时间点上将一个地方子图与一个实体的地面真实目标(如"这个用户churned"或"这个物品售出142个单位")相配。

NVIDIA Kumo关系系统概述：(a) 数据库集成，(b) 将自然语言转化为预测性查询的提示界面，(c) 自动上下文生成供养NVIDIA Kumo关系模型，该模型横跨租户。 ]

图1. 库莫关系体系概况。 连接一个数据库，指定一个预测性查询，库莫关系处理其余的，从上下文生成到模型推论。

为了作出预测，Kumo Relational必须做三件事：(1)了解每个表格中的数值，(2)将记录与表格联系起来，(3)将上下文实例与已知目标与预测的实体联系起来。 事情是这样的：

![库莫关系架构：(a) 与任务、用户、订单和项目表格的上下文输入；(b) 表格中的栏目和行目注意，并附有注入的上下文目标；(c) 图表注意和跨表格的交叉抽样注意。 ]

图2. Kumo关系结构：(a) 上下文输入，(b) 表格内的推理，(c) 表格间的推理。

自动上下文生成：任务以预测查询语言(PQL)写成，这是一个声明式的界面，在此您会说明要预测什么而不是如何预测。 对于时间性任务，Kumo Relational重放历史数据库中声明：它将实体中心子图取样到一个锚定时间戳，并从该时间戳后的事件中计算出每个目标，同时只服务于模型之前的数据。 这可以防止数据泄漏。

在表格中说明理由：一个轻量级网络独立处理每个表格，交替处理列注意(关于一栏内的数值)和行注意(关于一列内的特性). 该模型了解哪些列和行对当前预测很重要，并在传播之前过滤出噪音。

跨表格理性：一个更大的网络通过图示关注在主键/外键关系上分配嵌入在关系结构中的行，与跨上下文实例的交叉抽样关注互换。 这就是关系推理发生的地方，例如将用户的配置与其交易历史联系起来。 由于这个阶段在行嵌入而不是在每个表格的每个单元格上工作，设计避免了四极成本和尺度到大上下文和更深的子图。

库莫关系是如何构建的

Kumo Relational在模拟完全合成的关系数据上进行预训，以反映真实世界的关系数据库，并带有不同的预测查询。 培训前工作分阶段进行，从单一表格到日益复杂的关系结构。

培训前所需的多种关系数据库很少公开，因此合成数据填补了空白。 Kumo Relational的生成器基于PluRel(Kothapalli等人，ICML 2026)的处理方法，将单表数据生成器扩展至全关系数据库。 库莫团队的成员帮助开发了PluRel，并共同撰写了原论文。 PluRel将每个数据库分三个阶段生成：一个计划，真实数据中集群的各行之间的外键链接，以及结构causal Models中具有时间趋势和跨表依赖性的列值。 生成是轻量级的，所以训练前数据实际上是无限的，而PluRel纸显示，训练前丢失遵循了动力定律，因为添加了合成数据库，收益会结转到真正的数据库。

通过这种预训，该模型学会在表格之间过滤、关联和汇总信息，而不是依赖固定汇总。 当最大精确度重要时，库莫关系还可以对特定数据集和任务进行微调。

业绩

在本文中，我们评价了来自Rel Bench V1和V2、SAP SALT和4DBInfer的15个关系数据库中的41 基准测试关系，涉及电子商务、医疗、企业、社会和学术领域。 在培训前没有看到这些数据集。 Kumo关系在分类和回归两个方面都超越了最强的受监督模型，包括关系深层学习模型和专家设计的表格组合。 在比较Rel Bench V1上的关系模型和系统的RelArena-α领导板上，它也坐在盒外的精度效率Pareto前面：

! [Relarena-α导板的散射图：相对于每千个样本(x轴，日志尺度)的中位推算时间而言，与任务跨度(y轴)的Elo相对精确度。 库莫关系坐落在帕雷托前方约17秒，埃洛1,842. 得分最高的条目rt-plurel以约7300秒的速度达到Elo 1,878，大约430倍慢。 所有其他基础模型，特征工程系统，以及监督模型的得分都比Kumo Relational低，运行速度慢。 ]

图3. RelArena-α 领导板：每1 000个样本的Elo跨任务比中位推论时间(逻辑尺度)。 Kumo Relational以类似的精度比得分最高的条目快约430×.

文件还报告说，在SAP SALT企业基准测试上，Kumo relational 超越大型AutoGluon组合以平均对等等级(MRR)的8%和最近的表格式基础模型大约25%，微调将其领先度从AutoGluon扩大到16%. 在困难的条件下，它也坚挺起来：它以不到0.2%的训练数据作为上下文，在去除多达75%的外国钥匙链接时保持稳定，在添加许多吵闹的列时几乎不会降解。

限制

Kumo关系在具有有意义的关系和时间动态的数据上表现最好，如用户随时间演变的行为。 在具有非常大的培训组的任务上，具体的任务监督模型可能仍然会偏向于内在的预测，这些预测最多在我们的基准测试中使用了10,000个上下文实例。 基础模型的微调正是为这个案例设计的。 预测信号也必须在数量有限的hop中达到，因此从几个相关表格的焦点查询开始，并根据需要扩展图表。

演示

Kumo Relational在数据库上进行本土化的context学习：在内存中，通过数据库和仓库连接器，或通过自定义的图式引擎，通过内存映射的I/O处理500B+列，最高可达5GB/s. 它可以在NVIDIA的新发布，GPU-native结构-数据模型库中找到，同样的开源库可以赋予我们的姊妹模型Kumo Tabular权力。 库在首次使用时从Hugging Face Hub下载权重，这样就可以将模型装入GPU背面的笔记本，直接从中预测。 以下代码将上下文实例、预测实体及其相关表格传递到模型中：

# pip 安装结构化的数据模型

导入 sdm

model = sdm.models. Kumo关系(device="cuda").

pred=型号(

# 内容内培训表(钥匙/时间戳/目标):

x 文本=...

y 缩写=...

# 预测实例(fkeys/timestamps):

x 凯里=.

# 上下文/预测实体的多表信息：

相关背景 tables=.

相关 query tables=.

)

完整的Rel Bench和SAP SALT管道，包括如何对每个实体的相关表格进行抽样，请参见库中的关系实例。

为了将模型作为单独的服务运行，将它作为NVIDIA NIM进行部署，并将开源结构化的数据模型客户端从你的笔记本中指向它。 用 PQL 编写预测，客户端收集上下文示例和相关表格，然后发送请求：

# pip 安装“ 结构化- 数据模型- 客户端[ 关系] ”

导入 sdm 客户端

客户端 = sdm 客户端。 SDMClient(url="http://localhost:8001)# NIM URL

查询=sdm 客户端。 预测性查询( E)

# 预测查询语言中的预测任务(PQL):

"PREDICT COUNT(订单。 *, 0, 30, days)，供 EACH 用户.user id 使用。

# 多表数据作为熊猫 DataFrames (键/链接)

本文由 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 Atlas. All rights belong to the original author.