Kumo Tabular

Kumo Tabular

Predicts classes or values for new table rows from labeled example rows given as context. NVIDIA's pretrained tabular foundation model for classification and regression, for developers and data teams.

Made by nvidia on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Kumo Tabular is a pretrained foundation model from NVIDIA for data in tables. It handles classification and regression, so it can predict a category or a number for each row.

You hand it labeled example rows as context plus new rows to score. It returns class probabilities for the new rows, using the Python package structured-data-models.

Who it suits: Developers and data teams who work with spreadsheet-style data and want predictions from labeled examples without building a model from scratch.

Industry | Who uses it | How they use it | Example
Analytics | Data analysts | Predict a label for new rows from known ones | Score new records with class probabilities
Software | Developers adding predictions to apps | Call the model from Python with a DataFrame | Classify rows exported from a database
Research | Machine learning researchers | Test a tabular foundation model on datasets | Try it on a public scikit-learn dataset

Skip it if your data is text, images or audio, since this model is built for tables.

Where to use it:

• Python programs that use pandas, PyTorch and the structured-data-models package
• Machines with a CUDA GPU or just a CPU, since the example picks whichever is available
• Windows, macOS or Linux with Python, to download the files

Use case | Who | What they get back
Classification | Data teams | Class probabilities for new rows
Regression | Analysts | Predicted numbers, as the model supports regression
Quick baselines | Researchers | Predictions from labeled context rows with no separate training step in the example

How to set it up:

• Python and pip
• PyTorch, scikit-learn and pandas, which the example imports
• The structured-data-models package from NVIDIA

1. Install the package.
2. Load your table into a pandas DataFrame.
3. Run the example script and swap in your own data.

pip install structured-data-models

How to use it: Convert your DataFrame into a table tensor, create the model with a task, then call it with context rows, their labels and the query rows to score.

import torch
from sklearn.datasets import load_breast_cancer

import sdm

df = load_breast_cancer(as_frame=True).frame
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

table = sdm.TableTensor.from_pandas(
    df=df,
    stypes=sdm.infer_stypes(df, overrides={"target": "categorical"}),
    device=device,
)
model = sdm.models.KumoTabular(task="classification", device=device)

with torch.amp.autocast(
    device.type,
    dtype=torch.float16,
    enabled=device.type == "cuda",
):
    probs = model(
        x_context=table[:300].drop_columns("target"),
        y_context=table[:300, "target"],
        x_query=table[300:].drop_columns("target"),
        num_estimators=8,
    )

print(probs)

Tool | What it does
sdm.TableTensor.from_pandas | Turns a pandas DataFrame into a table the model reads
sdm.infer_stypes | Works out each column type, with overrides such as marking the target as categorical
sdm.models.KumoTabular | Creates the model for a task such as classification
model call | Takes context rows, their labels and query rows and returns probabilities

Example: You load a table with a target column, use the first 300 rows as labeled context and treat the remaining rows as queries. Printing the result shows class probabilities for each query row.

For newcomers and experts: If you are new to this, run the example as it is on the built-in breast cancer sample and read the printed probabilities. Then replace the DataFrame with your own table and name your target column.

If you know the field, the model predicts in context, so the labeled rows are passed at call time rather than used to train weights. The example runs mixed precision on a CUDA GPU and sets the number of estimators to 8.

Load a table into pandas
Convert it to a table tensor
Pass context rows, labels and query rows
Receive class probabilities

Good to know:

• The example context uses 300 rows and treats the remaining rows as queries
• Hugging Face lists 3 quantized and 7 fine-tuned versions made by other people
• License: OpenMDW 1.1 for the weights
• Cost to run: none named
• Data it reaches: the tables you load into it, plus the files you download
• Not for: data that is not tabular

On Hugging Face, 13 November 2026

• Downloads in the last 30 days: 158,434
• Likes: 214
• License: openmdw-1.1
• Quantized versions: 3
• Fine-tunes: 8
• Tags: kumo_tabular, tabular-foundation-model, structured-data-models

Links

• Model: https://huggingface.co/nvidia/Kumo-Tabular
• Files: https://huggingface.co/nvidia/Kumo-Tabular/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download nvidia/Kumo-Tabular

Then follow the usage in its model card. Nothing in this kit runs by itself.