What I Built

SlothML is a zero-training tabular machine learning web application built with FastAPI and TabPFN (Tabular Prior-data Fitted Networks). It automates data ingestion, preprocessing, target detection, benchmarking, and real-time inference without requiring traditional model training loops or hyperparameter tuning.

Code

joey441 / SlothML

SlothML brings the foundation model revolution to tabular data: drop in any messy spreadsheet, sit back like a sloth, and get state-of-the-art predictions in seconds with zero training loops.

🦥 SlothML

🚀 Live Application

Access the production deployment here: https://slothml.onrender.com

📋 Core Features

In-Context Tabular Foundation AI (tabpfn): Leverages pre-trained transformer models for fast tabular classification and regression without iterative gradient descent training.
Automated Data Pipeline & Sanitization: Robust ingestion engine that handles missing values, strip whitespace, cleans column headers containing special characters/spaces, and auto-detects data types.
Auto-Target & Task Detection: Automatically infers target/label columns and classifies problem types (binary/multiclass classification vs. regression).
Head-to-Head Benchmarking: Compares TabPFN inference speed and accuracy directly against traditional Random Forest baselines.
Interactive "What-If" Simulator: Real-time inference endpoint allowing users to modify feature inputs and calculate dynamic probability updates.
Pre-Loaded Demo Datasets: Instant evaluation…

View on GitHub

How I Built It

SlothML is built around TabPFN (Tabular Prior-data Fitted Networks), an open-source, transformer-based tabular foundation model developed by Prior Labs. Unlike traditional machine learning models that require slow, iterative training loops and extensive hyperparameter tuning (like XGBoost or Random Forest), TabPFN performs in-context learning using a pre-trained transformer trained on millions of synthetic datasets.

Here is how the project is architected around it:

The In-Context Inference Engine (ml_engine.py):

When a dataset is ingested, the engine bypasses training entirely. It passes the raw tabular tensors directly into the pre-trained TabPFN model, achieving high-accuracy classification and regression in milliseconds.
It includes a comparative benchmarking layer that pits TabPFN head-to-head against a Scikit-Learn Random Forest baseline to dynamically calculate speedup ratios and accuracy margins.

Backend Orchestration & API (app.py):

Built with FastAPI to handle multipart file uploads, asynchronous session storage, and low-latency REST endpoints.
Features an automated data preprocessing pipeline powered by Pandas that cleans column headers, strips special characters, handles missing value imputation, and automatically infers target columns and task types (classification vs. regression).

Real-Time "What-If" Simulation:

The app exposes a live inference endpoint that takes feature perturbations from the frontend, feeds them into the loaded session state, and recalculates probability distributions on the fly in under 50ms.

Frontend & Deployment:

Paired with a responsive single-page frontend (Tailwind CSS, Chart.js) for live visualization of feature importances, prediction probabilities, and automated business insights ("Sloth Notes").
Containerized and deployed live on Render.

Why Does Open Innovation Matter?

Open innovation—specifically leveraging open-source foundation models like TabPFN rather than relying on closed, proprietary APIs—was critical to making SlothML possible for several core reasons:

Absolute Data Privacy & Security:
Tabular data often contains highly sensitive enterprise metrics, customer financial histories, or patient health records. A closed API approach would require streaming raw, unencrypted tabular rows to a third-party proprietary server, introducing massive compliance and privacy risks. Because TabPFN is open-source and runs locally in-process, user data never leaves the deployment container, ensuring strict data governance.

Sub-Second In-Process Latency:
The core "showstopper" feature of SlothML is the real-time "What-If" scenario simulator, where users drag feature sliders and watch probability distributions update instantly (in under 50ms). A closed external API call would introduce network latency, rate limits, and round-trip overhead that would break this fluid interactivity. Running an open-source model directly inside the Python backend keeps inference lightning-fast.

Specialized Tabular Architecture vs. Text LLMs:
Closed APIs (like commercial LLM endpoints) are fundamentally optimized for natural language text, token prediction, and general reasoning. They notoriously struggle with raw numerical tabular math, missing value imputation, and tabular feature interactions without massive prompt engineering. TabPFN is an open-source transformer designed specifically for tabular priors, delivering native statistical accuracy that text-based APIs simply cannot match out of the box.

Zero-Cost Scalability & Reproducibility:
Open-source models eliminate recurring per-token or per-prediction API costs. Anyone can clone the repository, run pip install -r requirements.txt, and deploy or audit the entire machine learning pipeline locally without being locked into a proprietary vendor's ecosystem or pricing tier.

The Lazy Payoff

Traditionally, building a production-ready tabular machine learning pipeline is an exhausting multi-hour grind: writing data cleaning scripts, encoding categoricals, handling missing values, splitting training/test sets, setting up cross-validation, tuning XGBoost or Random Forest hyperparameters, and writing deployment wrapper code. It easily eats up 2 to 4 hours of tedious boilerplate.

SlothML cuts that down to 0.3 seconds.

By leveraging TabPFN’s pre-trained tabular priors, we completely eliminated training loops and hyperparameter tuning. During our live testing on Render, we uploaded messy, uncleaned CSVs containing special characters and missing values—and within a single click, the app automatically sanitized the data, ran a comparative speed benchmark against Random Forest, and booted up a live what-if simulation engine.

It turns hours of data science grunt work into instant, zero-effort gratification. Drop the spreadsheet, sit back like a sloth, and let the foundation model do the heavy lifting.

DEV Community

SlothML TabPFN Powered Zero-Training In-Context Tabular Foundation AI