CLIWorks/Spider-FLEXITOKENS-FP8

Spider-FLEXITOKENS FP8 Training

FP8 training pipeline for 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

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)

python3 fp8_train.py \
    --seq_len 256 --micro_batch 112 --grad_accum 4 \
    --precision fp8 --n_loops 6

FP8 + TileKernels Training

# 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

python3 fp8_train.py --resume checkpoints-fp8/spider-step2650.pt

Fresh Start (Load Weights, Reset Optimizer)

python3 fp8_train.py --resume checkpoints-fp8/spider-step2650.pt --reset_steps

With torch.compile

python3 fp8_train.py --compile --precision fp8

Mock Data (Quick Test)

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:

cd tile_kernels && pip install -e .

Tokenizer

Byte-level encoding (no learned tokenizer needed):

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.