> This page is for Structured Data Models. > For clean Markdown of any page, append .md to the page URL. > For a complete documentation index, see https://docs.nvidia.com/sdgm/llms.txt. > For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/sdgm/_mcp/server. # Kumo Tabular > Classification and regression on a single table, in context. Kumo Tabular predicts a target column for new rows from labeled rows of the same table, in one forward pass, with no training or tuning. It handles classification and regression on numerical and categorical features. ## At a Glance | Property | Value | | ------------ | ------------------------------------------------------------------------------------------------------------------------------------- | | Class | `sdm.models.KumoTabular` | | Tasks | Classification (any number of classes) and regression (999 quantiles) | | Features | Numerical and categorical columns | | Sizes | `small`, `medium`, `large` (default) | | Weights | [nvidia/Kumo-Tabular](https://huggingface.co/nvidia/Kumo-Tabular), OpenMDW-1.1, public | | Available in | SDM 0.2.1 and later | | Reference | [NVIDIA Kumo Tabular Sets a New Accuracy-Efficiency Frontier for Tabular Prediction](https://huggingface.co/blog/nvidia/kumo-tabular) | ## When to Use It * Your examples are rows of one table, and the target is a label or a number. * You want a strong baseline without hyperparameter tuning or feature engineering. * Choose [Kumo Relational](/sdgm/structured-data-models/models/kumo-relational) instead when the signal lives in other tables linked by keys. ## How It Works ![Kumo Tabular overview: a table of labeled context rows and unlabeled query rows passes through three stages in one forward pass. Cell embedding turns every cell into a token, the table encoder attends across columns and rows to turn each row into one vector, and in-context learning lets query rows attend to the labeled rows to output class probabilities or quantiles.](/sdgm/_fern-files/nvidia-sdgm.docs.buildwithfern.com/6ca395a3b8feaf3dca70211cf0b1560d3a5be260f2860a3b4398dfb0760471e9/_dot_dot_/images/structured-data-models/kumo_tabular_light.svg) ![Kumo Tabular overview: a table of labeled context rows and unlabeled query rows passes through three stages in one forward pass. Cell embedding turns every cell into a token, the table encoder attends across columns and rows to turn each row into one vector, and in-context learning lets query rows attend to the labeled rows to output class probabilities or quantiles.](/sdgm/_fern-files/nvidia-sdgm.docs.buildwithfern.com/6cfa091798546ceb20294e3cdaf334da7bb5260e986b558d1b65666a5f6e8c77/_dot_dot_/images/structured-data-models/kumo_tabular_dark.svg) 1. **Cell embedding.** Numerical and categorical cells use separate learned Fourier features and projections, plus a missingness projection. 2. **Table encoder.** Column-wise induced set attention and row-wise attention alternate. Learnable readout tokens compress each row into a fixed-size representation. 3. **In-context learning.** A transformer over rows lets each query row attend to the labeled context rows and predicts class logits or quantiles. Kumo Tabular was pretrained only on synthetic tables generated from structural causal models, with context sizes up to 60,000 rows and up to 100 columns. ## Example The [Quickstart](/sdgm/structured-data-models/quickstart) runs Kumo Tabular end to end on CPU. The core call is: ```python model = sdm.models.KumoTabular(task="classification", device=device) probs = model(x_context=x_context, y_context=y_context, x_query=x_query, num_estimators=8) ``` ## Choose a Size | Size | Classifier parameters | Regressor parameters | ICL transformer | | --------------- | --------------------- | -------------------- | ------------------------ | | small | 27.46M | 28.47M | 12 layers, 512 channels | | medium | 61.49M | 62.49M | 24 layers, 512 channels | | large (default) | 213.67M | 215.68M | 24 layers, 1024 channels | ## Inputs and Limits * One target column per call. Related tables are not accepted. * One forward pass covers up to 10 classes; SDM extends this to any number of classes with error-correcting output codes. * The default recipe keeps at most 500 feature columns per estimator, after shuffling columns. * Accuracy may degrade on tables far beyond the pretraining ranges, or when query rows come from a different distribution than context rows. * Text, datetime, and other column types need recipe processors that turn them into numerical features. ## Key Parameters | Parameter | Where | Meaning | | ---------------------- | ------------ | ------------------------------------------------------------------------------------- | | `task` | Constructor | `"classification"`, `"regression"`, or both (default). Loads only the heads you need. | | `size` | Constructor | `"small"`, `"medium"`, or `"large"` | | `num_estimators` | Forward, fit | Number of ensemble members over randomized views | | `estimator_batch_size` | Forward, fit | Members per model call. Lower it to reduce device memory. | | `recipe` | Forward, fit | Replace the default preprocessing and postprocessing | | `generator` | Forward, fit | Seeded `torch.Generator` for reproducible results | ## Fine-Tuning Kumo Tabular supports full fine-tuning through a differentiable forward pass. See the [fine-tuning guide](https://nvidia.github.io/structured-data-models/finetuning.html) and [examples/tabular/finetune.py](https://github.com/NVIDIA/structured-data-models/blob/main/examples/tabular/finetune.py). ## Learn More * [KumoTabular API reference](https://nvidia.github.io/structured-data-models/api/generated/sdm.models.KumoTabular.html) * [Hugging Face model card](https://huggingface.co/nvidia/Kumo-Tabular) * [Kumo Tabular blog post](https://huggingface.co/blog/nvidia/kumo-tabular)