zenex-ai-project / scripts /train_medium.py
shashankmacherla's picture
Upload full llm_project
6d5c79f verified
Raw History Blame Contribute Delete
6.27 kB
"""Medium-sized Zenex MoE training using a real BPE tokenizer.
Loads SentencePiece tokenizer, encodes corpus once (cached as .npy),
trains a larger MoE config for many more steps. Still CPU-friendly.
"""
from __future__ import annotations
import argparse
import logging
import math
import time
from pathlib import Path
import numpy as np
import sentencepiece as spm
import torch
from architecture.config import ModelConfig
from architecture.model import ZenexMoEDecoder
LOGGER = logging.getLogger(__name__)
def build_medium_config(vocab_size: int) -> ModelConfig:
"""Bigger MoE that still trains on a laptop CPU in a few hours."""
return ModelConfig(
num_layers=6,
hidden_size=384,
num_attention_heads_q=8,
num_attention_heads_kv=8,
head_dim=48,
vocab_size=vocab_size,
ffn_intermediate_size=1024,
num_routed_experts=8,
num_shared_experts=1,
top_k_experts=2,
mla_kv_latent_dim=192,
mla_q_latent_dim=192,
mtp_predict_steps=1,
)
def encode_corpus(sp: spm.SentencePieceProcessor, corpus: Path, cache: Path) -> np.ndarray:
"""Tokenize corpus once and cache as .npy on disk."""
if cache.exists():
LOGGER.info("Loading cached token array: %s", cache)
return np.load(cache)
LOGGER.info("Encoding corpus with BPE: %s", corpus)
tokens: list[int] = []
eos = sp.eos_id() if sp.eos_id() >= 0 else 3
chunk_size = 0
with corpus.open("r", encoding="utf-8") as f:
for line in f:
line = line.strip()
if not line:
continue
ids = sp.encode(line, out_type=int)
tokens.extend(ids)
tokens.append(eos)
chunk_size += 1
if chunk_size % 50_000 == 0:
LOGGER.info("Encoded %d lines, %d tokens", chunk_size, len(tokens))
arr = np.asarray(tokens, dtype=np.int32)
cache.parent.mkdir(parents=True, exist_ok=True)
np.save(cache, arr)
LOGGER.info("Saved %d tokens to %s", len(arr), cache)
return arr
def get_batch(data: np.ndarray, seq_len: int, batch_size: int, device: torch.device):
"""Sample random contiguous chunks."""
ix = np.random.randint(0, len(data) - seq_len - 1, size=batch_size)
x = np.stack([data[i : i + seq_len].astype(np.int64) for i in ix])
y = np.stack([data[i + 1 : i + seq_len + 1].astype(np.int64) for i in ix])
return torch.from_numpy(x).to(device), torch.from_numpy(y).to(device)
def cosine_lr(step: int, total: int, warmup: int, peak: float, min_lr: float) -> float:
if step < warmup:
return peak * (step + 1) / max(1, warmup)
progress = (step - warmup) / max(1, total - warmup)
return min_lr + 0.5 * (peak - min_lr) * (1 + math.cos(math.pi * progress))
def pick_device() -> torch.device:
"""Pick best available device: CUDA > Apple MPS > CPU."""
if torch.cuda.is_available():
return torch.device("cuda")
if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
return torch.device("mps")
return torch.device("cpu")
def train(args: argparse.Namespace) -> None:
"""Main training loop."""
device = pick_device()
LOGGER.info("Training on device: %s", device)
sp = spm.SentencePieceProcessor(model_file=str(args.tokenizer))
LOGGER.info("Tokenizer loaded: vocab=%d", sp.vocab_size())
data = encode_corpus(sp, args.corpus, args.cache)
LOGGER.info("Corpus tokens: %d", len(data))
cfg = build_medium_config(vocab_size=sp.vocab_size())
model = ZenexMoEDecoder(cfg).to(device)
n_params = sum(p.numel() for p in model.parameters())
LOGGER.info("Model size: %.2fM params", n_params / 1e6)
optimizer = torch.optim.AdamW(
model.parameters(), lr=args.peak_lr, betas=(0.9, 0.95),
eps=1e-8, weight_decay=0.1,
)
model.train()
args.output.parent.mkdir(parents=True, exist_ok=True)
start = time.time()
for step in range(1, args.steps + 1):
lr = cosine_lr(step, args.steps, warmup=max(50, args.steps // 50),
peak=args.peak_lr, min_lr=args.peak_lr * 0.1)
for g in optimizer.param_groups:
g["lr"] = lr
x, y = get_batch(data, args.seq_len, args.batch_size, device)
optimizer.zero_grad(set_to_none=True)
out = model(x)
logits = out.logits
loss = torch.nn.functional.cross_entropy(
logits.reshape(-1, logits.size(-1)), y.reshape(-1)
)
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
optimizer.step()
if step % args.log_every == 0 or step == 1:
elapsed = time.time() - start
tps = step * args.batch_size * args.seq_len / max(1e-6, elapsed)
LOGGER.info(
"step=%d loss=%.4f lr=%.2e tok/s=%.0f elapsed=%.1fs",
step, float(loss.item()), lr, tps, elapsed,
)
if step % args.save_every == 0 or step == args.steps:
torch.save(model.state_dict(), args.output)
LOGGER.info("Checkpoint saved -> %s", args.output)
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description="Medium MoE training with BPE tokenizer")
parser.add_argument("--corpus", type=Path, default=Path("/mnt/nas/data/corpus.txt"))
parser.add_argument("--cache", type=Path, default=Path("/mnt/nas/data/corpus.tokens.npy"))
parser.add_argument("--tokenizer", type=Path, default=Path("/mnt/nas/tokenizer/tokenizer.model"))
parser.add_argument("--output", type=Path, default=Path("/mnt/nas/checkpoints/medium.pt"))
parser.add_argument("--steps", type=int, default=3000)
parser.add_argument("--seq-len", type=int, default=256)
parser.add_argument("--batch-size", type=int, default=8)
parser.add_argument("--peak-lr", type=float, default=3e-4)
parser.add_argument("--log-every", type=int, default=20)
parser.add_argument("--save-every", type=int, default=500)
return parser.parse_args()
def main() -> None:
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s")
args = parse_args()
train(args)
if __name__ == "__main__":
main()