Upload README.md with huggingface_hub

README.md

@@ -0,0 +1,235 @@
+# Spider-FLEXITOKENS FP8 Training
+
+FP8 training pipeline for [Spider-FLEXITOKENS](https://huggingface.co/CLIWorks/Spider-FLEXITOKENS) on NVIDIA Blackwell GPUs (sm_120) using **torchao Float8Linear** and optional **TileKernels** fused MoE routing.
+
+## Architecture
+
+Spider is a Recurrent-Depth Transformer (RDT) with:
+- **1B parameters** (996M), hidden_size=2048
+- **Byte-level vocab**: 272 tokens (256 UTF-8 bytes + 16 specials: BOS=257, EOS=258, PAD=256)
+- **6 recurrent layers** with MoE (32 experts, top-2 routing) + MLA attention
+- **2 prelude + 2 coda** dense layers
+- **Engram conditional memory** at recurrent layers 1 and 4
+- **FlexiTokens** via BoundaryPredictor + downsample/upsample
+- **ACT halting** with LTI injection + LoRA adapter per loop iteration
+- Gradient checkpointing on recurrent layers
+
+## Training Scripts
+
+| File | Description |
+|------|-------------|
+| `fp8_train.py` | Pure torchao FP8 training (Python MoE loop) |
+| `tk-train.py` | torchao FP8 + TileKernels fused MoE routing |
+| `fp8-ready-spider.py` | Model definition (Python MoE loop) — used by `fp8_train.py` |
+| `tk-spider.py` | Model definition (TileKernels MoE) — used by `tk-train.py` |
+
+### fp8_train.py
+
+Standard torchao FP8 training. Uses Python loops for MoE expert routing (top-2 gating, expert dispatch, weighted reduction). All linear layers (except embeddings, norms, routers, predictors) are converted to `Float8Linear` with the **tensorwise** recipe.
+
+### tk-train.py
+
+Same as `fp8_train.py` but replaces the Python MoE loop with **TileKernels** fused CUDA kernels:
+- `topk_gate` — fused top-k gating
+- `normalize_weight` — gate weight normalization
+- `get_fused_mapping` — expert-token mapping computation
+- `expand_to_fused` — token-to-expert expansion
+- `reduce_fused` — expert output reduction
+- `aux_fi` — auxiliary load-balancing loss
+
+Falls back to Python MoE loop if TileKernels is unavailable.
+
+## Requirements
+
+- **GPU**: NVIDIA Blackwell (sm_120) or Hopper (sm_90)
+- **CUDA**: 13.2+
+- **PyTorch**: 2.11.0+ (with CUDA 13.x support)
+- **torchao**: `pip install torchao` (for Float8Linear FP8 training)
+- **TileKernels** (optional, for tk-train.py): included in `tile_kernels/` directory
+- **bitsandbytes** (optional): for 8-bit AdamW optimizer
+- **loguru** (optional): logging; falls back to stdlib logging
+- **numpy**: for memory-mapped dataset loading
+
+## Data
+
+### FineWeb-Edu Byte-Level Dataset
+
+Pre-tokenized FineWeb-Edu at byte level (~17B tokens, 14 shards):
+- Format: uint16 `.bin` files, no header
+- Vocab: BOS=257, EOS=258, PAD=256, raw bytes 0-255
+- Each shard: ~2.5GB, ~1.2B tokens
+- `metadata.json` with shard info
+
+```python
+from torch.utils.data import IterableDataset, DataLoader, get_worker_info
+import numpy as np, os, torch
+
+class LocalByteLevelDataset(IterableDataset):
+    def __init__(self, data_dir, seq_len=2048, rank=0, world_size=1):
+        self.seq_len = seq_len
+        self.data_dir = data_dir
+        self.rank = rank
+        self.world_size = world_size
+        self._files = self._discover_files()
+
+    def _discover_files(self):
+        import glob as _glob
+        files = sorted(_glob.glob(os.path.join(self.data_dir, "**/*.bin"), recursive=True))
+        return [f for i, f in enumerate(files) if i % self.world_size == self.rank]
+
+    def __iter__(self):
+        worker = get_worker_info()
+        num_workers = worker.num_workers if worker else 1
+        worker_id = worker.id if worker else 0
+        files = [f for i, f in enumerate(self._files) if i % num_workers == worker_id]
+        for filepath in files:
+            arr = np.memmap(filepath, dtype=np.uint16, mode='r')
+            pos = 0
+            while pos + self.seq_len + 1 <= len(arr):
+                chunk = arr[pos:pos + self.seq_len + 1]
+                pos += self.seq_len + 1
+                x = torch.tensor(chunk[:-1], dtype=torch.long)
+                y = torch.tensor(chunk[1:], dtype=torch.long)
+                y[y == 256] = -100  # PAD_ID = -100 for loss
+                yield x, y
+```
+
+## Usage
+
+### FP8 Training (torchao only)
+
+```bash
+python3 fp8_train.py \
+    --seq_len 256 --micro_batch 112 --grad_accum 4 \
+    --precision fp8 --n_loops 6
+```
+
+### FP8 + TileKernels Training
+
+```bash
+# Make TileKernels importable
+export PYTHONPATH="$HOME/TileKernels:$PYTHONPATH"
+
+python3 tk-train.py \
+    --seq_len 256 --micro_batch 112 --grad_accum 4 \
+    --precision fp8 --n_loops 6
+```
+
+### Resume from Checkpoint
+
+```bash
+python3 fp8_train.py --resume checkpoints-fp8/spider-step2650.pt
+```
+
+### Fresh Start (Load Weights, Reset Optimizer)
+
+```bash
+python3 fp8_train.py --resume checkpoints-fp8/spider-step2650.pt --reset_steps
+```
+
+### With torch.compile
+
+```bash
+python3 fp8_train.py --compile --precision fp8
+```
+
+### Mock Data (Quick Test)
+
+```bash
+python3 fp8_train.py --mock_data --max_steps 20 --seq_len 128 --micro_batch 2
+```
+
+## CLI Flags
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--seq_len` | 2048 | Sequence length |
+| `--micro_batch` | 64 | Micro batch size per GPU |
+| `--grad_accum` | 1 (env: `GRAD_ACCUM`) | Gradient accumulation steps |
+| `--n_loops` | 6 (env: `N_LOOPS`) | RDT loop iterations |
+| `--lr` | 3e-4 (env: `LR`) | Peak learning rate |
+| `--precision` | auto | `auto`, `fp8`, or `bf16` |
+| `--compile` | off | Enable `torch.compile(mode="default")` |
+| `--resume` | auto-detect | Path to checkpoint |
+| `--reset_steps` | off | Load weights, zero optimizer, reset step=0 |
+| `--ckpt_dir` | `checkpoints-fp8` / `checkpoints-tk` | Checkpoint directory |
+| `--data_dir` | `/home/lamcodealong/fineweb_bytelevel` | Local .bin data directory |
+| `--mock_data` | off | Use synthetic data for testing |
+| `--max_steps` | 0 (unlimited) | Max training steps |
+| `--no_gradient_checkpointing` | off | Disable grad checkpointing |
+
+## Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `SEQ_LEN` | 2048 | Override `--seq_len` |
+| `MICRO_BATCH` | 64 | Override `--micro_batch` |
+| `GRAD_ACCUM` | 1 | Override `--grad_accum` |
+| `N_LOOPS` | 6 | Override `--n_loops` |
+| `LR` | 3e-4 | Override `--lr` |
+| `TARGET_TOKENS` | 10B | Total training tokens |
+| `CKPT_EVERY` | 50 | Steps between checkpoints |
+
+## FP8 Configuration
+
+- **Recipe**: `tensorwise` (axiswise incompatible with grad checkpointing + reshape on sm_120)
+- **Module filter**: Skips `boundary_predictor`, `loop_embedding`, `engram`, `layernorm`, `norm`, `embed_tokens`, `lm_head`, `halt_predictor`, `router`
+- **pad_inner_dim=True**: Pads linear layer inner dims for FP8 alignment
+- **Warmup**: 2 fwd+bwd passes with dummy data before training starts (kernel compilation)
+
+## Performance
+
+Benchmarked on RTX PRO 6000 (Blackwell sm_120, 96GB VRAM):
+
+| Config | Throughput | Peak VRAM |
+|--------|-----------|-----------|
+| FP8, mb=112, seq=256, ga=4 | ~11.8k tok/s | 25.3 GB |
+| FP8, mb=64, seq=2048, ga=1 | ~2.2k tok/s | ~42 GB |
+
+## Checkpoints
+
+Latest checkpoint: `spider-step2650.pt` (3.8GB)
+- Contains: `model_state_dict`, `optimizer_state_dict`, `step`, `epoch`, `cfg`, `best_loss`
+- Step 2650, loss ~1.9
+
+## TileKernels
+
+TileKernels provides fused CUDA/Triton kernels for MoE operations. Only the MoE routing kernels are used here (no weight dtype changes):
+
+- `tile_kernels.moe.topk_gate` — fused top-k gating
+- `tile_kernels.moe.normalize_weight` — gate weight L2 normalization
+- `tile_kernels.moe.get_fused_mapping` — compute expert-token dispatch mapping
+- `tile_kernels.moe.expand_to_fused` — expand tokens to expert slots
+- `tile_kernels.moe.reduce_fused` — reduce expert outputs back to tokens
+- `tile_kernels.moe.aux_fi` — auxiliary load-balancing loss
+
+Install from the included `tile_kernels/` directory:
+```bash
+cd tile_kernels && pip install -e .
+```
+
+## Tokenizer
+
+Byte-level encoding (no learned tokenizer needed):
+
+```python
+def encode(text: str) -> list[int]:
+    return [257] + list(text.encode('utf-8')) + [258]  # BOS + bytes + EOS
+
+def decode(ids: list[int]) -> str:
+    return bytes(i for i in ids if 0 <= i <= 255).decode('utf-8', errors='replace')
+```
+
+Special tokens: `PAD=256`, `BOS=257`, `EOS=258`, `IMG_START=0`, `IMG_END=1`, `IMG_PATCH=2`, `IMG_NEWLINE=3`, plus boundary and loop sentinels.
+
+## Known Limitations
+
+- **DeepGEMM**: Blocked on sm_120 (`Unknown recipe arch_major: 12`)
+- **FlashMLA**: sm_100f kernels produce CUTLASS errors on sm_120
+- **TransformerEngine**: `cublasLtGroupedMatrixLayoutInit_internal` symbol error
+- **torchao axiswise recipe**: Incompatible with gradient checkpointing + reshape on sm_120
+- **torch.compile reduce-overhead mode**: Has issues; use `mode="default"` only
+
+## License
+
+Same as Spider-FLEXITOKENS.