| --- |
| language: |
| - en |
| license: apache-2.0 |
| tags: |
| - fp8 |
| - torchao |
| - tile-kernels |
| - moe |
| - byte-level |
| - blackwell |
| - pretraining |
| - fineweb-edu |
| pretty_name: Spider-FLEXITOKENS FP8 Training Data & Code |
| size_categories: |
| - 10B<n<100B |
| --- |
| |
| # 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. |
| |
