🍔 FatTummy

The zero-boilerplate ML framework that trains, chats, and predicts — in one line.

Native models · HuggingFace · OpenAI · Anthropic · Gemini · Ollama · CSV Forecasting

What is FatTummy?

FatTummy is an all-in-one Python ML toolkit built for people who want to build and use language models without spending weeks on boilerplate.

It wires together every stage of the ML workflow — dataset loading, training, inference, and prediction — behind a single, clean builder API. Switch from a local native model to GPT-4o to a HuggingFace checkpoint by changing one word.

"Using FatTummy just beats fiddling with PyTorch for centuries." — Origin-Labs

✨ Features at a Glance

🚀 Installation

pip install fattummy

On first import, FatTummy automatically detects and installs any missing optional dependencies:

import FatTummy as ft
# FatTummy: installing missing dependencies: torch, datasets ...
# FatTummy: dependencies ready.

Recommended: Python 3.11 or 3.12. Python 3.14 works for API chat, but PyTorch native training is best on 3.11/3.12.

⚡ Quick Start

1 — Interactive Wizard (Easiest)

import FatTummy as ft
ft.build()

The terminal launches a wizard — pick an action, fill in the blanks, and you're training or chatting in minutes.

2 — Native Model (MOOE)

Train FatTummy's built-in Mixture-of-Optimized-Experts model on any dataset:

import FatTummy as ft

ft.engine("mooe") \
  .modelbuild("small") \
  .data("roneneldan/TinyStories") \
  .epochs(3) \
  .finetune()

print(ft.generate("Once upon a time"))

3 — Fine-Tune a HuggingFace Model

import FatTummy as ft

ft.engine("hf") \
  .type("mistralai/Mistral-7B-v0.1") \
  .data("tatsu-lab/alpaca") \
  .epochs(1) \
  .finetune()

ft.chat()

4 — Cloud Chat (OpenAI / Anthropic / Gemini)

import FatTummy as ft

ft.engine("openai").key("sk-...").chat()

# Or Anthropic Claude:
ft.engine("anthropic").key("sk-ant-...").chat()

# Or Google Gemini:
ft.engine("gemini").key("AIza...").chat()

5 — CSV Time-Series Forecasting

import FatTummy as ft

results = ft.predict_csv(
    "sales_data.csv",
    target_column="revenue",
    steps=7,            # predict 7 days ahead
    date_column="date"
)
print(results)

Or pass a raw list:

ft.predict([100, 105, 98, 112, 130, 145], steps=3)
# → [158.2, 172.0, 186.4]

🏗️ Supported Engines

🎛️ Full Builder API

Every method is chainable and returns the engine for fluent composition:

import FatTummy as ft

ft.engine("mooe")           # pick engine
  .modelbuild("small")      # model scale: tiny / small / medium / large
  .data("user/dataset")     # HF repo, local .txt/.csv/.json, or raw text
  .epochs(5)                # training epochs
  .token_limit(512)         # max tokens to generate
  .optimizer("lion")        # adamw | lion | sgd | adagrad
  .lr_scheduler("cosine")   # none | cosine | linear
  .weight_decay(0.01)       # L2 regularization
  .warmup(100)              # warmup steps
  .clip_grad(1.0)           # gradient clipping norm
  .quantize("int8")         # quantization hint for HF models
  .temp(0.8)                # generation temperature
  .finetune()               # train

result = ft.generate("The future of AI is")

📦 Dataset Handling

FatTummy auto-detects your data source:

Non-standard schemas are handled automatically — instruction/output, text, conversations, code, and more field layouts all work out of the box.

🧠 MOOE Architecture

FatTummy's built-in Mixture-of-Optimized-Experts (MOOE) model is a lightweight, from-scratch transformer designed for fast experimentation:

Input → Embedding → [MOOE Layer × N] → LM Head → Output
                         ↓
               Router (softmax gate)
               → Top-K expert selection
               → Expert FFN (GELU)
               → Weighted sum

*256 when SpaceByte byte-level encoding is enabled.

🌊 SpaceByte — Byte-Level Training

No vocabulary, no tokenizer. Train directly on raw bytes:

import FatTummy as ft

ft.engine("spacebyte") \
  .modelbuild("small") \
  .data("my_raw_logs.txt") \
  .finetune()

print(ft.generate("ERROR: connection"))

SpaceByte uses vocab_size=256 (all possible bytes) — perfect for code, logs, and multilingual data.

🧪 Run in Google Colab

!pip install fattummy

import FatTummy as ft

# API chat (no GPU needed)
ft.engine("openai").key("sk-...").chat()

# Or train a native model (free Colab GPU)
ft.engine("mooe").modelbuild("small").data("roneneldan/TinyStories").epochs(2).finetune()

Colab is preferred over Kaggle for interactive wizard mode.

🔒 HuggingFace Token

For gated models and private datasets:

import FatTummy as ft

ft.hf_login("hf_your_token_here") \
  .engine("hf") \
  .type("meta-llama/Llama-2-7b-chat-hf") \
  .chat()

Or set it as an environment variable: HF_TOKEN=hf_...

🗂️ Package Structure

FatTummy/
├── __init__.py          # Global API + auto-installer hook
├── engine.py            # Builder engine (the core orchestrator)
├── installer.py         # Silent dependency auto-installer
├── interactive.py       # Terminal wizard (ft.build())
├── predictor.py         # CSV / numeric forecasting
├── exceptions.py        # Typed error classes
├── models/
│   └── mooe.py          # Native MOOE architecture
├── data/
│   └── loader.py        # HF + local dataset resolution
├── tuning/
│   └── trainer.py       # Training loop (epochs, checkpointing)
└── inference/
    ├── cloud_adapters.py # OpenAI / Anthropic / Gemini
    └── local_adapters.py # HuggingFace / Ollama

📊 Real-World Scenarios Tested

FatTummy is verified against real production-style workloads:

• ✅ E-commerce sales forecasting — CSV-based multi-step prediction
• ✅ Log anomaly analysis — byte-level SpaceByte training on server logs
• ✅ Support knowledge base — Alpaca-style instruction fine-tuning
• ✅ Streaming large HF datasets — TinyStories, WikiText-2, Alpaca (live HF Hub)
• ✅ End-to-end: train → generate — Full pipeline in < 10 lines of code

🛣️ Roadmap

• LoRA / QLoRA adapters for efficient fine-tuning
• GGUF / llama.cpp inference backend
• Model merging and SLERP interpolation
• FatTummy Hub — community model sharing
• Web UI dashboard (already in app.py)
• Stable v1.0 release

🤝 Contributing

FatTummy is 100% open-source and free. Contributions, issues, and feature requests are welcome.

git clone https://github.com/shukladwij5-maker/fattummy
cd fattummy
pip install -e ".[all]"
pytest tests/

📄 License

GNU General Public License v3.0 — see LICENSE for details.

💬 Philosophy

FatTummy is built for everyone — researchers, engineers, students, and people with zero ML experience who just want AI to work.

No configuration files. No YAML hell. No 300-line training scripts. Just Python.

Made with ❤️ by Origin-Labs