Download scripts/train_medium.py from scs09/zenex-ai-project: direct link, hf CLI and curl.
- Browser
- Download file 6.27 kB
-
https://huggingface.co/datasets/scs09/zenex-ai-project/resolve/main/scripts/train_medium.py
- Command line
-
hf download hf://datasets/scs09/zenex-ai-project/scripts/train_medium.py
-
curl -L -o train_medium.py https://huggingface.co/datasets/scs09/zenex-ai-project/resolve/main/scripts/train_medium.py
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() | |