nvidia/Kumo Tabular
Model Overview
Description
Kumo-Tabular 1.0 is NVIDIA's tabular foundation model. It predicts classification labels and regression targets for tabular data by in-context learning: given a table of labeled context rows and unlabeled query rows with the same columns, the network returns class probabilities or numeric predictions for the query rows in a single forward pass. No task-specific training, gradient updates, or hyperparameter tuning is needed.
Kumo-Tabular 1.0 is part of the Kumo family of structured-data models, alongside Kumo Relational. It was pretrained only on synthetic tables generated from structural causal models; no real-world data was used for training. Three sizes are released: Kumo-Tabular-Small (about 28M parameters), Kumo-Tabular-Medium (about 62M parameters), and Kumo-Tabular-Large (about 215M parameters). The model accepts structured-data arrays or Arrow IPC payloads through the NVIDIA structured-data-models library for synchronous inference.
This model is ready for commercial or non-commercial use.
License and Terms of Use:
GOVERNING TERMS: The NIM container is governed by the NVIDIA Software License Agreement and the Product-Specific Terms for NVIDIA AI Products. Use of the model is governed solely by the OpenMDW License Agreement, version 1.1 (OpenMDW-1.1).
Deployment Geography:
Global
Use Case:
Use Case: Kumo-Tabular is for data scientists, machine learning engineers, and application developers who need accurate predictions on structured tabular data without training and tuning a task-specific model. Typical uses are classification tasks such as churn, default, fraud, and conversion prediction, and regression tasks such as demand, price, and duration forecasting from tabular features, across domains such as finance, retail, marketing, healthcare analytics, and operations. It suits both small tables, where training a dedicated model is impractical, and iterative workflows, where a new prediction task can be set up in minutes. The weights can also be used for research on tabular foundation models and in-context learning.
Release Date:
Hugging Face: 09/23/2026 via https://huggingface.co/nvidia/Kumo-Tabular
Model Architecture:
Architecture Type: Transformer Network Architecture:
- Kumo-Tabular is a three-stage tabular transformer:
- Cell embedding: each table cell becomes a token built from Fourier features of its value; missing cells are imputed with the column mean of the context rows and marked by a learned missingness term. Context rows also receive an embedding of their label.
- Table encoder: alternating column stages and row stages. A column stage attends over the rows of one column through a fixed set of inducing points, so its cost grows linearly with the number of rows. A row stage attends across the columns of one row, with rotary position encoding for column order. Each row is summarized into four learned summary (CLS) tokens.
- In-context-learning transformer: every row attends to the labeled context rows only. A prediction head then maps each query row to class logits (classification) or to quantiles of the target (regression).
- The three sizes share this design and differ in width and depth:
| Size | Parameters | Cell embedding | Table encoder | In-context-learning transformer |
|---|---|---|---|---|
| Kumo-Tabular-Small | about 28 million | 128 channels per cell | 4 layers, 128 inducing points; the four CLS tokens form a 512-channel row embedding | 12 blocks, width 512, 8 attention heads |
| Kumo-Tabular-Medium | about 62 million | 256 channels per cell | 6 layers, 256 inducing points; the four CLS tokens (1,024 channels) are projected to a 512-channel row embedding | 24 blocks, width 512, 8 attention heads |
| Kumo-Tabular-Large | about 215 million | 256 channels per cell | 6 layers, 256 inducing points; the four CLS tokens form a 1,024-channel row embedding | 24 blocks, width 1,024, 16 attention heads |
Total Parameters: Kumo-Tabular-Small about 28M (2.8 x 10^7); Kumo-Tabular-Medium about 62M (6.2 x 10^7); Kumo-Tabular-Large about 215M (2.2 x 10^8).
Input:
Input Types: Tabular Input Formats: JSON arrays-format or Arrow IPC tabular data Input Parameters: One Dimensional (1D) Other Properties Related to Input: Requests contain one instance table with numerical and categorical features, including missing values, plus labeled context rows and prediction rows. Related tables and relationships are not supported.
Output:
Output Types: Tabular predictions Output Format: JSON prediction results Output Parameters: One Dimensional (1D) Other Properties Related to Output: Classification outputs include predictions and class probabilities. Regression outputs include predictions and quantiles, including the model's native 999-quantile distribution.
Our AI models are designed and/or optimized to run on NVIDIA GPU-accelerated systems. By leveraging NVIDIA's hardware (e.g. GPU cores) and software frameworks (e.g., CUDA libraries), the model achieves faster training and inference times compared to CPU-only solutions.
Software Integration:
Runtime Engines: NVIDIA structured-data-models and PyTorch
Supported Hardware Microarchitecture Compatibility:
- NVIDIA Ampere
- NVIDIA Blackwell
- NVIDIA Hopper
Supported Operating System: Linux
The integration of foundation and fine-tuned models into AI systems requires additional testing using use-case-specific data to ensure safe and effective deployment. Following the V-model methodology, iterative testing and validation at both unit and system levels are essential to mitigate risks, meet technical and functional requirements, and ensure compliance with safety and ethical standards before deployment.
Model Version(s)
Kumo-Tabular v1.0, released in three sizes: Kumo-Tabular-Small, Kumo-Tabular-Medium, and Kumo-Tabular-Large.
Training, Testing, and Evaluation Datasets:
Training Dataset
Data Modality: Tabular Other Training Data Size: About 35 million synthetic tables for Kumo-Tabular-Small, 71 million for Kumo-Tabular-Medium, and 137 million for Kumo-Tabular-Large, covering tables of up to 60,000 rows and 100 feature columns with numerical and categorical features, missing values, and 2 to 10 classes.
Data Collection Method by dataset: Synthetic Labeling Method by dataset: Synthetic Properties: Kumo Tabular was pretrained on diverse synthetic tables generated from structural causal models. The tables include numerical and categorical features with missing values; no private enterprise data or personal data was used for training.
Testing Dataset
Data Collection Method by dataset: Not Applicable
Labeling Method by dataset: Not Applicable
Properties: Not Applicable. No synthetic test split was held out.
Evaluation Dataset
Evaluation Benchmark Score: Undisclosed
Data Collection Method by dataset: Public benchmark datasets Labeling Method by dataset: Benchmark-provided labels Properties: Public benchmark suites of real-world tabular datasets, used only for evaluation and never for training:
- TabArena-v0.1: 51 datasets (38 classification, 13 regression); https://tabarena.ai
- TALENT: 300 datasets (200 classification, 100 regression); https://github.com/LAMDA-Tabular/TALENT
- BeyondArena: classification and regression datasets with random, temporal, and grouped splits; https://huggingface.co/datasets/TabArena/BeyondArena
The datasets are publicly available tables from repositories such as OpenML, UCI, and Kaggle, covering finance, healthcare, retail, science, and other domains. Several of them (for example the UCI Adult census, COMPAS, German credit, and Diabetes 130-US hospitals tables) contain demographic attributes such as age, sex, or race of real individuals, as distributed by the public benchmarks.
Inference
Acceleration Engine: PyTorch with NVIDIA CUDA
Supported Tasks: Classification and regression
API Endpoints: POST /v1/predictions, POST /v1/sessions, POST /v1/sessions/{session_id}/predictions, and DELETE /v1/sessions/{session_id}
Test Hardware:
- NVIDIA Hopper - H100
Ethical Considerations
NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. Developers should work with their internal developer team to ensure these software components meet requirements for the relevant industry and use case and address unforeseen product misuse.
Users are responsible for model inputs and outputs. Users are responsible for ensuring safe integration of this model, including implementing guardrails as well as other safety mechanisms, prior to deployment.
Please report model quality, risk, security vulnerabilities or NVIDIA AI Concerns here.