Datasets:

---

pszemraj

/

LocalLLaMA-posts

like 0

ERROR: type should be string, got "https://preview.redd.it/jc9264uwqf6g1.jpg?width=1038&format=pjpg&auto=webp&s=4772b11fbdbee9d6f6b55be43ceab9bf8352ea1c\n\nSo I've been working with [nanochat](https://github.com/karpathy/nanochat) for the past few weeks. Andrej Karpathy released this thing claiming it's \"The best ChatGPT that $100 can buy\" and I was skeptical at first ? A full ChatGPT clone for $100?\n\nTurns out, it's actually pretty legit. The codebase is surprisingly small (like 8K lines), and it does everything: tokenization, training, fine-tuning, even a web UI. I've been trying to get it running on a single GPU (because I don't have 8 H100s lying around), and let me tell you, it's been... educational.\n\nI've hit a bunch of roadblocks, learned a ton about how these models actually work, and figured out some stuff that might be useful to share. So here's my take on what makes nanochat click, what I learned from trying to run it, and why it's actually pretty cool even if the model quality isn't GPT-5 level.\n\n# What is NanoChat?\n\nOkay, so what is this thing? Basically, nanochat is a complete ChatGPT clone implementation that's way smaller than you'd expect. We're talking like 8K lines of code across 45 files, that's it. No massive framework, no thousands of config options, just the essentials.\n\nIt does the whole pipeline:\n\n* Tokenization \n* Pretraining on raw text\n* Fine-tuning for chat\n* Evaluation\n* Even a web UI so you can actually talk to it\n\n\n\nThe whole point is that you can understand the entire codebase. You can read it, modify it, break it, fix it. It's designed to train on 8 H100s for around $100-1000, which is way cheaper than training GPT-5.\n\n# Architecture\n\nSo the architecture is basically a Transformer, but with a bunch of modern tweaks that make it more efficient. Instead of the learned positional embeddings, it uses Rotary Positional Embeddings (RoPE), which encodes position through rotations rather than learning embeddings(which is now common with all modern LLM's). This is more efficient and actually works better for longer sequences.\n\nThen there's QK normalization, which normalizes the queries and keys before the attention computation which apparently helps with training stability. The model also uses untied weights, meaning the input embeddings and output logits use separate embedding matrices instead of sharing one. This seems to help performance for smaller models.\n\nThis is a kind of surprising for me, for the activation function, it uses ReLU² (that's relu(x)²) instead of the more common GELU. It's simpler and apparently works just as well, if not better. \n\n x = F.relu(x).square()\n\nThe attention mechanism uses Group-Query Attention (GQA), which shares key/value heads across multiple query heads. This makes inference more efficient without really hurting quality.\n\nOh, and one thing I noticed, all the linear layers are bias-free. No bias terms anywhere. This reduces the parameter count slightly and apparently improves efficiency. It's these little details that add up.\n\nAgain, these are standard components found in most modern LLMs, so nothing unusual here, except the choice of activation function.\n\n# Model Scaling\n\nThe cool thing about nanochat is that model size is controlled by just one parameter: depth, which is the number of layers. Everything else scales automatically. The model dimension is depth × 64 (they call this the aspect ratio), the number of heads is derived from that to keep the head dimension at 128, and the vocab size is fixed at 65,536.\n\nhttps://preview.redd.it/wus9ftn7rf6g1.png?width=633&format=png&auto=webp&s=4c59f2c7aaa4a06076473204f7931147d80c9d48\n\n[https://github.com/karpathy/nanochat/blob/d5759400f96789d7649e040e5f444790101baa21/scripts/base\\_train.py#L90](https://github.com/karpathy/nanochat/blob/d5759400f96789d7649e040e5f444790101baa21/scripts/base_train.py#L90)\n\nSo if you set depth=20, you get about 561 million parameters (they call this the d20 model). If you go up to depth=32, you're looking at around 1.9 billion parameters. It's a nice, simple way to scale the model up or down depending on what you can afford.\n\n# The Training Pipeline: 3 Stages\n\nTraining happens in three stages, each doing something different. It's not just \"train on data and you're done\"first it learns language, then it learns how to chat, then it gets better at chatting. Let me explain what each stage does.\n\n# 1: Base Training (Pretraining)\n\nThis is where you train the model on raw text to learn language. Andrej use FineWeb-Edu 100BT, which is educational web text from HuggingFace. It's huge 455 billion characters total, split into about 1,822 files with roughly 250 million characters each.\n\n**Dataset**: [karpathy/fineweb-edu-100b-shuffle](https://huggingface.co/datasets/karpathy/fineweb-edu-100b-shuffle)\n\nThe goal is simple: predict the next word, just like any other language model. But there are some cool details. They use Chinchilla scaling, which means they train on 20 times the number of parameters in tokens. So for the d20 model with 561 million parameters, that's 11.2 billion tokens.\n\nThey also use two different optimizers. Muon for the transformer layers (it's a momentum optimizer with some math tricks), and AdamW for the embeddings and output layer. I'll explain why later, but it's a smart split.\n\nThe code is made for training across 8 GPUs, but it automatically works on a single GPU too. When I tried running this on a single A100, it took forever (like 3-4 days instead of 4 hours), but the code just automatically increased the gradient accumulation to keep the same batch size. \n\n# 2: Midtraining\n\nAt this stage base model can generate text, but it doesn't know how to have a conversation. Midtraining teaches it how to actually chat.\n\nThe training data is a mix of about 850K examples:\n\n\n\n* **SmolTalk** (460K conversations): [HuggingFaceTB/smol-smoltalk](https://huggingface.co/datasets/HuggingFaceTB/smol-smoltalk) \\- General conversational data\n* **MMLU** (100K examples): [cais/mmlu](https://huggingface.co/datasets/cais/mmlu) \\- Multiple choice questions\n* **GSM8K** (8K examples): [openai/gsm8k](https://huggingface.co/datasets/openai/gsm8k) \\- Math word problems (uses Python calculator)\n* **Identity** (2K examples): [Download link](https://karpathy-public.s3.us-west-2.amazonaws.com/identity_conversations.jsonl) \\- Synthetic personality conversations\n* **Spelling tasks** (280K examples): SimpleSpelling (200K) and SpellingBee (80K) - Synthetic tasks for spelling and letter counting\n\n\n\nThis stage teaches the model how to format conversations with user/assistant turns, how to use tools (like that Python calculator for math), how to handle multiple choice questions, and all those special tokens like <|user\\_start|> and <|assistant\\_start|>.\n\nWhen the model needs to do math, it wraps Python code in special tokens. The engine detects these, runs the code, and puts the results back. It's a simple pattern but it works.\n\n# 3: Supervised Fine-Tuning (SFT)\n\nThis is the final step. By now the model knows how to chat, so SFT is about making conversations better. The dataset is much smaller, only about 23K examples, but they're more curated. It's a mix of:\n\n\n\n* **ARC** (3.4K examples): [allenai/ai2\\_arc](https://huggingface.co/datasets/allenai/ai2_arc) \\- Science questions (ARC-Easy: 2.3K, ARC-Challenge: 1.1K)\n* **GSM8K** (8K examples): [openai/gsm8k](https://huggingface.co/datasets/openai/gsm8k) \\- Math problems\n* **SmolTalk** (10K examples): [HuggingFaceTB/smol-smoltalk](https://huggingface.co/datasets/HuggingFaceTB/smol-smoltalk) \\- General conversations (subset)\n* **Identity** (1K examples): [Download link](https://karpathy-public.s3.us-west-2.amazonaws.com/identity_conversations.jsonl) \\- Personality maintenance\n* **Spelling tasks** (600 examples): SimpleSpelling (300) and SpellingBee (300) - Synthetic spelling tasks\n\n\n\nThe key difference is they use masked loss. Only the assistant's words count for training , user words are ignored. This makes sense because you want the model to learn how to respond, not how to predict what the user will say.\n\nThe smaller dataset is intentional. By this point, the model already knows how to chat - SFT is just about making it better. Quality over quantity.\n\n# The Optimizers: Muon + AdamW\n\nNanochat uses TWO different optimizers, which I thought was weird at first but makes sense once you understand why:\n\n# 1. Muon Optimizer (for Transformer Layers)\n\nMuon is a momentum optimizer with some math tricks. It does a standard update, but then does some processing to make it more stable. I know a few companies that use it, but I mostly use AdamW, so I'm not going to pretend I fully understand the math, but the idea is that it helps the model train better.\n\nAFAIK It's more efficient for large operations and runs in bfloat16, which saves memory. The transformer layers (attention and MLP) use this optimizer. Those who want to dig more [https://github.com/karpathy/nanochat/blob/master/nanochat/muon.py](https://github.com/karpathy/nanochat/blob/master/nanochat/muon.py)\n\n# 2. AdamW Optimizer (for Embeddings + LM Head)\n\nThe embeddings and output layer use standard AdamW instead. This makes sense because embedding layers update differently (most words don't appear in every batch), and the output layer needs different handling. AdamW works better for these.\n\nSo the split is: transformer layers get Muon, embeddings and the output layer get AdamW. It's a smart approach, using the right optimizer for the right parts. I wouldn't have thought of this, but it works.\n\n# Tokenizer: Custom Rust BPE\n\nThe tokenizer is interesting, they use a custom Rust implementation for training, then switch to tiktoken for inference. Why Rust? Because it's way faster for training, which matters when you're processing huge datasets. Same algorithm, just faster.\n\nIt's GPT-4 style, which means byte-level tokenization, BPE merging, and special tokens for conversation format and tool use. Here's the special tokens definition from \n\nhttps://preview.redd.it/dbcmsikarf6g1.png?width=633&format=png&auto=webp&s=13c250754cce5ea80eae10f91602a97afda35eaf\n\n[https://github.com/karpathy/nanochat/blob/d5759400f96789d7649e040e5f444790101baa21/nanochat/tokenizer.py#L13](https://github.com/karpathy/nanochat/blob/d5759400f96789d7649e040e5f444790101baa21/nanochat/tokenizer.py#L13)\n\n# Inference Engine\n\nThe inference engine has some nice optimizations. It uses a KV cache, which stores some values so you don't have to recompute them for previous words. The cache grows as needed, which is efficient.\n\nFor batch generation, it does a single pass, then clones the cache for multiple samples. This lets you generate multiple responses at the same time.\n\nThe tool use is straightforward, it detects those <|python\\_start|> tokens, runs the Python code, and puts the results back. And it has streaming support, giving you tokens one at a time so you can build real-time chat interfaces.\n\n# My Experience: Running on Single GPU\n\nThe original speedrun.sh(https://github.com/karpathy/nanochat/blob/master/speedrun.sh) is designed for 8xH100 GPUs (640GB total VRAM). That's a massive setup, each H100 has 80GB of memory, and with 8 of them working together, you can train a 561M parameter model (d20) with a batch size of 32 and sequence length of 2048 in just 4 hours.\n\nI wanted to run it on a single A100 GPU (40GB). That's a huge difference, instead of 640GB total VRAM, I'd have just 40GB. Instead of 8 GPUs working in parallel, I'd have one GPU doing everything sequentially. The math is simple: 8 GPUs can process 8 batches at once, so a single GPU needs to do 8x the work, which means 8x the time (or more, since there's overhead).\n\nBut here's the thing, I don't have access to 8 H100s. Most people don't. So I wanted to see if I could actually make this work on a single GPU, even if it meant waiting days instead of hours. The question was: would the code even work, or would it crash immediately?\n\n# My Learning\n\nThe first thing I found is that the code already supports single GPU! The scripts automatically detect if you're using multiple GPUs. If you use torchrun, it runs in multi-GPU mode. If you just run the Python script directly without torchrun, it automatically switches to single GPU mode and increases gradient accumulation to keep the same batch size. So you can just remove torchrun and run \n\n python -m scripts.base_train --depth=20 \n\nand it works.\n\nBut there are memory constraints. For a single 40GB A100, the d20 model with 561M parameters is too large, you need to drop down to d12-d14. You also need to reduce the batch size from 32 to maybe 4-8, and shorten sequences from 2048 to 1024-1536. It still works, just smaller.\n\nThe time reality check is, well as expected it's not great. On 8 H100s it takes 4 hours and costs about $96. On a single H100, you're looking at 1.5 days and $81-148.\n\nHere's the catch: An 80GB A100 can train the full d20 model (561M params), which takes 3.5-4.5 days ($128). A 40GB A100 can only fit a smaller d12-d14 model, which takes 1-2 days ($82). So the 80GB is actually more powerful, but it's doing more work (bigger model), so it takes longer. The 40GB is faster because it's training a smaller model.\n\nSingle GPU is 20-25x slower than 8 GPUs, but hey, it works!\n\n# PyTorch CUDA Issue\n\nOne frustrating issue I encountered: The pyproject.toml specifies CUDA 12.8, which requires libnvshmem\\_host.so.3 that's not available on all systems in google Colab's GPU.\n\nModify pyproject.toml to use CUDA 11.8 instead:\n\n sed -i 's/pytorch-cu128/pytorch-cu118/g' pyproject.toml\n sed -i 's/cu128/cu118/g' pyproject.toml \n\nThis ensures uv sync installs a compatible PyTorch version from the start.\n\n# What NanoChat can (and can't) do\n\nSo what can this thing actually do? It's pretty good at general conversation, natural dialogue, following instructions, keeping context. For reasoning tasks, it gets 28-39% on ARC science questions, 31% on MMLU multiple choice, and 2.5-7.6% on GSM8K math (which is basic, but it can use the Python calculator). It can run simple Python expressions through that calculator.\n\nhttps://preview.redd.it/u4fgxw5erf6g1.png?width=631&format=png&auto=webp&s=74737dd1a6a030b939f5d4823c902cb38b4f4b52\n\nBut it's not good at coding. The HumanEval score is only 6.7-8.5%, which is very low. It's not trained on coding datasets, so while it can generate some Python, the quality is poor. It also struggles with complex reasoning, long content, and facts, it makes stuff up a lot.\n\n# Key Insights and Learnings\n\nThe biggest thing I learned is that simplicity is a feature. NanoChat proves you don't need a huge framework to build a modern LLM. The entire codebase is only about 8K lines, yet it includes a custom tokenizer, distributed training, multiple optimizers, tool use, a web UI, and evaluation. \n\nThe three-stage pipeline (base → mid → SFT) is elegant. Base learns language, mid teaches conversation format and tools, and SFT makes it better. Each stage builds on the previous one, and keeping them separate makes the code easier to understand and change.\n\nThe modern optimizations actually matter. RoPE instead of learned positional embeddings, QK normalization, the Muon optimizer, GQA for inference, these aren't just academic. They make the model more efficient and easier to train.\n\nTool use is simpler than I thought. The Python calculator integration is straightforward , special tokens mark code blocks, the engine detects and runs them, and results get put back into the conversation. This pattern could easily be extended to other tools like web search or database queries.\n\nAnd single GPU is possible, just slow. You don't need 8 GPUs to train nanochat. A single A100 works fine if you make the model smaller, cut the batch size, increase gradient accumulation, and have patience (3-4 days instead of 4 hours).\n\n# Codebase Structure\n\nWhat I love about nanochat is how everything is organized. Each file has a clear purpose, and the code is well-commented. You can actually read and understand the entire codebase in a reasonable amount of time.\n\n nanochat/\n ├── gpt.py # The Transformer model (clean, readable)\n ├── tokenizer.py # BPE tokenizer wrapper\n ├── engine.py # Efficient inference engine\n ├── dataloader.py # Distributed data loading\n ├── muon.py # Muon optimizer\n ├── adamw.py # Distributed AdamW\n └── ...\n \n scripts/\n ├── base_train.py # Pretraining\n ├── mid_train.py # Midtraining\n ├── chat_sft.py # Supervised fine-tuning\n ├── chat_eval.py # Evaluation\n └── chat_web.py # Web UI\n \n tasks/\n ├── arc.py # Science questions\n ├── gsm8k.py # Math problems\n ├── humaneval.py # Coding benchmark\n └── ...\n\n# What makes NanoChat special\n\nMost LLM repos I have worked with do one thing, pretraining OR fine-tuning OR evaluation. NanoChat does all of it. Tokenizer training, pretraining, fine-tuning, evaluation, even a web UI. You can go from raw text to a working ChatGPT clone in one script. \n\nThe dependencies are pretty minimal: PyTorch, HuggingFace datasets, FastAPI for the web UI, tiktoken, and wandb (optional). No huge frameworks, no weird abstractions. Just what you need.\n\nThis is honestly the best codebase I've seen for learning. It has all the modern techniques (RoPE, QK norm, Muon optimizer), but the code is clean and readable. You can actually understand what's happening.\n\nAnd it's super hackable. Want to add a new task? Just drop a file in tasks/. Want to mess with the optimizer? Edit muon.py or adamw.py. Everything is right there, no hidden magic.\n\n# What I would do differently\n\nIf I could find pre-trained base models, I'd skip straight to midtraining/SFT. Base training takes forever and honestly, I don't need to train from scratch just to learn how it works.\n\nEven 2-4 GPUs would make a huge difference. Single GPU works,it's super slow. If you have access to multiple GPUs, use them.\n\nI tried to run everything at once and got overwhelmed. Should've gotten base training working first, then moved on. Baby steps.\n\nI should've been watching nvidia-smi more. If you're not using most of your GPU memory, you can probably increase batch size. If you're hitting OOM errors, decrease it. Simple, but easy to forget.\n\n**Summary**\n\nFinally, I'm not saying nanochat is going to change AI or anything. But it does show that you don't need millions of dollars to train an LLM. With a single GPU (or cloud access), a few hundred bucks, and a lot of patience, you can actually do this.\n\nBut honestly, the real value is learning. By actually reading the code, running it, breaking it, and fixing it, you learn how these models actually work (not just theory), what the training pipeline looks like in practice, why different optimizers matter, how tool use is actually implemented, and how evaluation works. That stuff is way more valuable than just reading papers. At least for me, anyway.\n\nAnyway, that's my experience with nanochat so far. If you've tried it, let me know what you think. Or if you're thinking about trying it and have questions, feel free to ask. I'm definitely not an expert, but I've made enough mistakes that I might be able to help you avoid some of them.\n\n# Resources\n\n* **Repository**: [https://github.com/karpathy/nanochat](https://github.com/karpathy/nanochat)\n* **Live Demo**: [nanochat.karpathy.ai](http://nanochat.karpathy.ai/)\n\n"

ERROR: type should be string, got " https://github.com/VikingFlow/continuous-index\n \n Warehouse worker here – I only come up with ideas and architecture, no coding. \n The code is a minimal AI-generated PoC. \n Fork / build / DM if you want to help – I handle design, community handles code."