| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| """ |
| Smilyai-G1 : Fast Sparse General-Assistant Transformer — FSDP2 EDITION (8xH200) |
| ~20B total params | ~2B active per token |
| |
| v7 — DATA-MIX + OBSERVABILITY (on top of v6 host-RAM fixes): |
| |
| 23. TOKEN-WEIGHTED SOURCE SCHEDULER. v6 picked a source per *document*; a |
| stack-v3 document is a whole repository (~60K tokens) vs ~1K for a web |
| page, so 20% of docs became ~70% of tokens. Session 3's train-loss drop |
| (3.1 -> 1.7) was this, not model progress. Now a deficit scheduler picks |
| the source furthest behind its TOKEN quota -> exact mix regardless of |
| document length. Zero throughput cost. |
| 24. Repo cap 262K -> 64K chars so one repo can't monopolise ~15 consecutive |
| micro-batches. |
| 25. stack-v3 arrow batch_size 64 -> 4 rows (each row is a whole repo; this |
| was several hundred GB of host RAM across 32 readers). |
| 26. EOS: session 3 ran with eos_id=0 (no known EOS name found). Now scans the |
| tokenizer's added tokens for anything that looks like end-of-text, logs |
| what it picked, and honours G1_EOS_TOKEN=<token string> as an override. |
| 27. PER-SOURCE LOSS. The `folder` tag was the *last appended* document's |
| source, not the batch's. Batches are now tagged by MAJORITY source of |
| their tokens, and the log prints loss + batch share per source every |
| log_every steps (rank-0 local window). |
| 28. Session-3 note: train loss is NOT comparable across sessions when the |
| mix changes. Use [val] (fineweb-edu only) as the progress signal. |
| |
| Invariant: *** EVERY collective must be executed by EVERY rank, in the same order. *** |
| |
| RUN: |
| export HF_TOKEN=... |
| export G1_SESSION_ID=4 |
| export MAX_TRAINING_HOURS=138 |
| export G1_WORK_DIR=/some/real/local/disk # NOT tmpfs (check: df -hT /tmp) |
| export MALLOC_ARENA_MAX=2 |
| # optional: export G1_EOS_TOKEN='<|endoftext|>' |
| torchrun --nproc_per_node=8 train_g1_fsdp.py |
| """ |
|
|
| import os |
|
|
| os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True") |
| os.environ.setdefault("TORCHINDUCTOR_COMPILE_THREADS", "1") |
| os.environ.setdefault("HF_HUB_DISABLE_PROGRESS_BARS", "1") |
| os.environ.setdefault("HF_DATASETS_DISABLE_PROGRESS_BARS", "1") |
| os.environ.setdefault("ARROW_DEFAULT_MEMORY_POOL", "system") |
| os.environ.setdefault("OMP_NUM_THREADS", "4") |
| try: |
| import ctypes |
| _libc = ctypes.CDLL("libc.so.6") |
| _libc.mallopt(-8, 2) |
| _libc.mallopt(-1, 128 * 1024) |
| except Exception: |
| pass |
|
|
| import gc, json, time, math, random, logging, threading, queue, shutil, collections, datetime as _dt |
| from dataclasses import dataclass, asdict |
| from typing import Optional, Tuple, List, Iterator |
|
|
| import numpy as np |
| import torch |
| import torch.nn as nn |
| import torch.nn.functional as F |
| import torch.distributed as dist |
| import torch.multiprocessing as mp |
| from torch.utils.data import Dataset, DataLoader |
|
|
| try: |
| from torch.distributed.fsdp import fully_shard, MixedPrecisionPolicy |
| except ImportError: |
| from torch.distributed._composable.fsdp import fully_shard, MixedPrecisionPolicy |
|
|
| from torch.distributed.tensor import DTensor, distribute_tensor |
| from torch.distributed.checkpoint.state_dict import ( |
| get_model_state_dict, set_model_state_dict, |
| get_optimizer_state_dict, set_optimizer_state_dict, |
| StateDictOptions, |
| ) |
|
|
| import triton |
| import triton.language as tl |
|
|
| from huggingface_hub import HfApi, hf_hub_download, upload_file, login as hf_login |
|
|
| try: |
| import bitsandbytes as bnb |
| HAS_BNB = True |
| except ImportError: |
| HAS_BNB = False |
|
|
| try: |
| from safetensors.torch import save_file as st_save |
| HAS_ST = True |
| except ImportError: |
| HAS_ST = False |
|
|
| try: |
| from flash_attn import flash_attn_func |
| HAS_FLASH = True |
| except ImportError: |
| HAS_FLASH = False |
|
|
| try: |
| from torchao.float8 import convert_to_float8_training, Float8LinearConfig |
| HAS_FP8 = True |
| except ImportError: |
| HAS_FP8 = False |
| convert_to_float8_training = None |
| Float8LinearConfig = None |
|
|
| os.environ["TOKENIZERS_PARALLELISM"] = "false" |
| torch.set_float32_matmul_precision('high') |
| torch.backends.cuda.matmul.allow_tf32 = True |
| torch.backends.cudnn.allow_tf32 = True |
| torch.backends.cuda.enable_flash_sdp(True) |
| torch.backends.cuda.enable_mem_efficient_sdp(True) |
|
|
| try: |
| import torch._dynamo |
| torch._dynamo.config.cache_size_limit = 64 |
| torch._dynamo.config.suppress_errors = True |
| torch._dynamo.config.capture_scalar_outputs = True |
| except Exception: |
| pass |
|
|
| logging.basicConfig(level=logging.INFO, format='%(asctime)s | %(message)s', datefmt='%H:%M:%S') |
| for _noisy in ("httpx", "httpcore", "urllib3", "filelock", |
| "huggingface_hub", "huggingface_hub.hf_api", |
| "huggingface_hub.file_download", "datasets", "fsspec"): |
| logging.getLogger(_noisy).setLevel(logging.WARNING) |
|
|
| log = logging.getLogger("smilyai-g1-fsdp") |
| _MODULE_IS_MASTER = os.environ.get("RANK", "0") == "0" |
| if _MODULE_IS_MASTER: |
| log.info(f"[env] flash_attn={HAS_FLASH} | bnb={HAS_BNB}") |
|
|
| |
| |
| |
| HF_TOKEN = os.environ.get("HF_TOKEN", "") |
| SESSION_ID = int(os.environ.get("G1_SESSION_ID", "4")) |
| REPO_PREFIX = "hugging-science/Smilyai-G1-20B-v2-session-" |
| HF_MODEL_REPO = f"{REPO_PREFIX}{SESSION_ID:03d}" |
|
|
| if not HF_TOKEN: |
| if _MODULE_IS_MASTER: |
| log.warning("[hf] HF_TOKEN not set — uploads/downloads will fail. export HF_TOKEN=...") |
| else: |
| try: |
| hf_login(token=HF_TOKEN) |
| if _MODULE_IS_MASTER: |
| log.info("[hf] logged in") |
| except Exception as e: |
| if _MODULE_IS_MASTER: |
| log.warning(f"[hf] login failed: {e}") |
|
|
| hf_api = HfApi() |
|
|
| def _is_ram_backed(path: str) -> bool: |
| try: |
| best = ("", "") |
| with open("/proc/mounts") as f: |
| for line in f: |
| parts = line.split() |
| if len(parts) >= 3 and path.startswith(parts[1]) and len(parts[1]) > len(best[0]): |
| best = (parts[1], parts[2]) |
| return best[1] in ("tmpfs", "ramfs") |
| except Exception: |
| return False |
|
|
| _WORK = os.environ.get("G1_WORK_DIR", "/tmp") |
| if _is_ram_backed(_WORK): |
| _fb = os.path.join(os.getcwd(), "g1_work") |
| if _MODULE_IS_MASTER: |
| log.warning(f"[disk] {_WORK} is RAM-backed — a 127GB checkpoint there IS host RAM. " |
| f"Falling back to {_fb}. Set G1_WORK_DIR to a real local disk.") |
| _WORK = _fb |
| LOCAL_CACHE = os.path.join(_WORK, "g1_cache") |
| TEMP_CKPT_DIR = os.path.join(_WORK, "g1_ckpts") |
| os.makedirs(LOCAL_CACHE, exist_ok=True) |
| os.makedirs(TEMP_CKPT_DIR, exist_ok=True) |
|
|
| def host_mem_str() -> str: |
| out = [] |
| try: |
| with open("/proc/self/status") as f: |
| for line in f: |
| if line.startswith("VmRSS:"): |
| out.append(f"rss={int(line.split()[1])/1024**2:.1f}GB"); break |
| with open("/proc/meminfo") as f: |
| for line in f: |
| if line.startswith("MemAvailable:"): |
| out.append(f"avail={int(line.split()[1])/1024**2:.0f}GB"); break |
| for cur, mx in (("/sys/fs/cgroup/memory.current", "/sys/fs/cgroup/memory.max"), |
| ("/sys/fs/cgroup/memory/memory.usage_in_bytes", |
| "/sys/fs/cgroup/memory/memory.limit_in_bytes")): |
| try: |
| c = int(open(cur).read()); m = open(mx).read().strip() |
| if m != "max" and int(m) < (1 << 60): |
| out.append(f"cgroup={c/1024**3:.0f}/{int(m)/1024**3:.0f}GB"); break |
| except Exception: |
| continue |
| except Exception: |
| pass |
| return "host " + " ".join(out) if out else "host=?" |
|
|
| def start_mem_watchdog(rank: int): |
| def _loop(): |
| last = 0.0 |
| while True: |
| time.sleep(15) |
| try: |
| avail, total = None, 0.0 |
| with open("/proc/meminfo") as f: |
| for line in f: |
| if line.startswith("MemTotal:"): total = int(line.split()[1]) / 1024**2 |
| if line.startswith("MemAvailable:"): avail = int(line.split()[1]) / 1024**2 |
| if avail is not None and avail < max(0.05 * total, 8.0) and time.time() - last > 60: |
| log.error(f"[mem-watchdog] rank={rank} HOST RAM CRITICAL — {host_mem_str()}") |
| last = time.time() |
| except Exception: |
| pass |
| threading.Thread(target=_loop, daemon=True).start() |
|
|
| MAX_HOURS = float(os.environ.get("MAX_TRAINING_HOURS", "138.0")) |
| START_TIME = time.time() |
| def elapsed_h(): return (time.time() - START_TIME) / 3600 |
| def remaining_h(): return MAX_HOURS - elapsed_h() |
| def should_stop_local(): |
| if elapsed_h() >= MAX_HOURS: |
| log.info("[time] budget done"); return True |
| return False |
| def vram_gb(): return torch.cuda.memory_allocated() / 1024**3 |
| def vram_total_gb(): return torch.cuda.get_device_properties(torch.cuda.current_device()).total_memory / 1024**3 |
| def vram_str(): return f"{vram_gb():.1f}/{vram_total_gb():.0f}GB" |
|
|
| def ensure_repo(): |
| try: |
| hf_api.repo_info(repo_id=HF_MODEL_REPO, repo_type="model", token=HF_TOKEN) |
| except Exception: |
| hf_api.create_repo(repo_id=HF_MODEL_REPO, repo_type="model", private=False, token=HF_TOKEN) |
| log.info(f"[hf] created {HF_MODEL_REPO}") |
| log.info(f"[hf] USING REPO: {HF_MODEL_REPO}") |
|
|
| def upload_to_hf(local: str, remote: str) -> bool: |
| try: |
| upload_file(path_or_fileobj=local, path_in_repo=remote, |
| repo_id=HF_MODEL_REPO, repo_type="model", token=HF_TOKEN) |
| log.info(f"[hf] up {remote}") |
| return True |
| except Exception as e: |
| log.error(f"[hf] upload failed: {e}") |
| return False |
|
|
| METRICS_FILE = os.path.join(TEMP_CKPT_DIR, f"metrics_session_{SESSION_ID:03d}.jsonl") |
| def log_metrics(**kw): |
| m = {'timestamp': time.time(), 'elapsed_hours': elapsed_h(), 'session_id': SESSION_ID, **kw} |
| with open(METRICS_FILE, 'a') as f: |
| f.write(json.dumps(m) + '\n') |
| return m |
| def upload_metrics(): |
| if os.path.exists(METRICS_FILE): |
| upload_to_hf(METRICS_FILE, f"metrics_session_{SESSION_ID:03d}.jsonl") |
|
|
| |
| |
| |
| import datetime |
| try: |
| import matplotlib; matplotlib.use("Agg"); import matplotlib.pyplot as plt |
| HAS_MPL = True |
| except ImportError: |
| HAS_MPL = False |
|
|
| SAMPLES_FILE = os.path.join(TEMP_CKPT_DIR, "samples.md") |
| SUMMARY_FILE = os.path.join(TEMP_CKPT_DIR, "summary.jsonl") |
| PROGRESS_MD = os.path.join(TEMP_CKPT_DIR, "PROGRESS.md") |
| _step_clock = [] |
| _tok = None |
|
|
| def _real_steps_per_hour(): |
| if len(_step_clock) < 2: return None |
| (s0, t0), (s1, t1) = _step_clock[0], _step_clock[-1] |
| if t1 - t0 < 30 or s1 <= s0: return None |
| return (s1 - s0) / (t1 - t0) * 3600 |
|
|
| def sessions_left(step, total): |
| sph = _real_steps_per_hour() |
| if sph is None: return None |
| usable_h = max(MAX_HOURS - 0.75, 8.0) |
| return max(math.ceil((total - step) / max(sph * usable_h, 1)), 0) |
|
|
| def session_banner(): |
| try: |
| files = hf_api.list_repo_files(repo_id=HF_MODEL_REPO, repo_type="model", token=HF_TOKEN) |
| pts = [f for f in files if f.endswith(".pt")] |
| latest = max([int(f.split("step")[-1].split(".")[0]) for f in pts]) if pts else 0 |
| except Exception: |
| pts, latest = [], 0 |
| log.info("🌱" * 25) |
| log.info(f"WELCOME BACK — feed #{len(pts)+1}. Smilyai survived {len(pts)} sessions.") |
| log.info(f"Latest checkpoint on the Hub: step {latest:,}") |
| log.info("🌱" * 25) |
|
|
| def _bootstrap_from_hub(local, remote): |
| try: |
| src = hf_hub_download(HF_MODEL_REPO, remote, cache_dir=TEMP_CKPT_DIR, token=HF_TOKEN) |
| shutil.copy(src, local) |
| log.info(f"[motiv] restored {remote}") |
| except Exception: |
| pass |
|
|
| def _get_tokenizer(): |
| global _tok |
| if _tok is None: |
| try: |
| _tok = get_tokenizer(Config()) |
| except Exception as e: |
| log.warning(f"[tokenizer] failed: {e}") |
| _tok = None |
| return _tok |
|
|
| DOMAIN_TOKEN = "" |
|
|
| @torch.no_grad() |
| def make_sample(model, prompt="def fibonacci(n):", max_new=48, temp=0.8, top_p=0.95): |
| try: |
| tok = _get_tokenizer() |
| if tok is None: return None |
| token_ids = tok.encode(DOMAIN_TOKEN + prompt, add_special_tokens=False).ids[-128:] |
| if not token_ids: return None |
| device = next(model.parameters()).device |
| ids = torch.tensor([token_ids], device=device) |
| except Exception as e: |
| log.warning(f"[sample] tokenizer error: {e}"); return None |
|
|
| gen = torch.Generator(device=device); gen.manual_seed(1234) |
| was_training = model.training |
| model.eval() |
| try: |
| for _ in range(max_new): |
| with torch.amp.autocast('cuda', dtype=model.cfg.dtype): |
| logits, _ = model(ids[:, -model.cfg.max_len:], None) |
| p = F.softmax(logits[:, -1].float() / temp, dim=-1) |
| sp, si = torch.sort(p, descending=True) |
| keep = (torch.cumsum(sp, -1) - sp) < top_p |
| sp = sp * keep |
| sp = sp / sp.sum(-1, keepdim=True).clamp_min(1e-9) |
| nxt = si.gather(-1, torch.multinomial(sp, 1, generator=gen)) |
| ids = torch.cat([ids, nxt], dim=1) |
| finally: |
| if was_training: model.train() |
| try: |
| return tok.decode(ids[0].tolist()) |
| except Exception as e: |
| log.warning(f"[sample] decode error: {e}") |
| return None |
|
|
| def record_sample(model, step, is_master: bool): |
| txt = make_sample(model) |
| if not is_master: |
| return |
| with open(SAMPLES_FILE, "a") as f: |
| f.write(f"\n## step {step:,} — {datetime.datetime.now():%d %b %H:%M}\n> {txt or '(skipped)'}\n") |
| upload_to_hf(SAMPLES_FILE, "samples.md") |
| if txt: log.info(f"[motiv] sample » {txt[:120]!r}") |
|
|
| def make_loss_chart(): |
| if not (HAS_MPL and os.path.exists(METRICS_FILE)): return |
| tr, va = [], [] |
| for line in open(METRICS_FILE): |
| try: m = json.loads(line) |
| except Exception: continue |
| if "loss" in m and "step" in m: tr.append((m["step"], m["loss"])) |
| elif "val_loss" in m and "step" in m: va.append((m["step"], m["val_loss"])) |
| if not tr: return |
| fig, ax = plt.subplots(figsize=(10, 5)) |
| ax.plot(*zip(*tr), lw=1, label="train") |
| if va: ax.plot(*zip(*va), "o-", color="tab:red", label="val") |
| ax.set_xlabel("step"); ax.set_ylabel("loss"); ax.grid(alpha=.3); ax.legend() |
| ax.set_title("Smilyai-G1 20B learning curve 🌱") |
| p = os.path.join(TEMP_CKPT_DIR, "loss_curve.png") |
| fig.savefig(p, dpi=110, bbox_inches="tight"); plt.close(fig) |
| upload_to_hf(p, "loss_curve.png"); os.remove(p) |
|
|
| def update_progress_md(cfg, step, epoch, tr_loss, val_loss): |
| rec = {"t": f"{datetime.datetime.now():%d %b %H:%M}", "step": step, "epoch": epoch, |
| "loss": round(tr_loss, 4) if tr_loss is not None else None, |
| "val": round(val_loss, 4) if (val_loss is not None and val_loss == val_loss) else None} |
| with open(SUMMARY_FILE, "a") as f: f.write(json.dumps(rec) + "\n") |
| sl = sessions_left(step, cfg.total_steps); sl = f"~{sl}" if sl is not None else "?" |
| lines = ["# Smilyai-G1 20B · live progress 🌱", "", |
| f"**{100*step/cfg.total_steps:.1f}% trained** · estimated clicks left: **{sl}** 🖱️", "", |
| "> Note: train loss is only comparable within a session — the data mix changed between " |
| "sessions 2, 3 and 4. Use **val loss** (fineweb-edu only) as the progress signal.", "", |
| "| when | step | train loss | val loss |", "|---|---|---|---|"] |
| for line in open(SUMMARY_FILE): |
| try: r = json.loads(line) |
| except Exception: continue |
| lines.append(f"| {r['t']} | {r['step']:,} | {r['loss'] if r['loss'] is not None else '—'} " |
| f"| {r['val'] if r['val'] is not None else '—'} |") |
| with open(PROGRESS_MD, "w") as f: f.write("\n".join(lines) + "\n") |
| upload_to_hf(PROGRESS_MD, "PROGRESS.md") |
|
|
| |
| |
| |
| @dataclass |
| class Config: |
| vocab_size: int = 131_072 |
|
|
| d_model: int = 2048 |
| n_layers: int = 32 |
| n_heads: int = 16 |
| n_kv_heads: int = 4 |
| max_len: int = 2048 |
| rope_theta: float = 500_000.0 |
|
|
| n_experts: int = 56 |
| top_k: int = 2 |
| expert_hidden_mult: float = 0.875 |
| shared_hidden_mult: float = 2.0 |
| n_shared_experts: int = 1 |
| aux_loss_coef: float = 0.01 |
| bias_update_rate: float = 0.001 |
| bias_update_every: int = 10 |
| bias_cap: float = 2.0 |
| bias_decay: float = 0.0005 |
| usage_ema_decay: float = 0.99 |
| moe_block_m: int = 64 |
|
|
| tie_embeddings: bool = True |
|
|
| muon_lr: float = 0.02 |
| muon_min_lr: float = 0.002 |
| muon_mom: float = 0.95 |
| adamw_lr: float = 1.5e-4 |
| adamw_min_lr:float = 1.5e-5 |
| beta1: float = 0.9 |
| beta2: float = 0.95 |
| wd: float = 0.1 |
| grad_clip: float = 1.0 |
| warmup: int = 3000 |
| total_steps: int = 300_000 |
|
|
| micro_batch: int = 2 |
| grad_accum: int = 16 |
|
|
| log_every: int = 10 |
| eval_every: int = 500 |
| ckpt_every: int = 1000 |
|
|
| enable_dpo_bursts: bool = False |
| dpo_start_step: int = 250_000 |
| dpo_every: int = 500 |
| dpo_beta: float= 0.1 |
|
|
| |
| |
| dataset_sources: tuple = ( |
| ("HuggingFaceFW/fineweb-edu", "train", "text", 200_000_000_000, None), |
| ("HuggingFaceCode/stack-v3-train", "train", "content", 100_000_000_000, None), |
| ("opencsg/chinese-fineweb-edu", "train", "text", 60_000_000_000, None), |
| ("hotchpotch/fineweb-2-edu-japanese", "train", "text", 40_000_000_000, None), |
| ("KORMo-Team/korean-web-collection", "train", "text", 30_000_000_000, None), |
| ("HuggingFaceFW/fineweb", "train", "text", 70_000_000_000, "sample-350BT"), |
| ) |
| tokenizer_repo: str = "Smilyai-labs/Smilyai-U1-B-Tokenizer" |
|
|
| tokenizer_workers: int = 4 |
| prefetch_shards: int = 20 |
| shuffle_buffer: int = 500 |
|
|
| use_compile: bool = False |
| use_fp8: bool = False |
|
|
| @property |
| def dtype(self): return torch.bfloat16 |
| @property |
| def head_dim(self): return self.d_model // self.n_heads |
| def tokens_per_step(self, bs, world_size=1): return bs * self.grad_accum * self.max_len * world_size |
|
|
| def arch_fingerprint(self) -> dict: |
| return { |
| "vocab_size": self.vocab_size, "d_model": self.d_model, |
| "n_layers": self.n_layers, "n_heads": self.n_heads, |
| "n_kv_heads": self.n_kv_heads, "n_experts": self.n_experts, |
| "top_k": self.top_k, "expert_hidden_mult": self.expert_hidden_mult, |
| "shared_hidden_mult": self.shared_hidden_mult, |
| "tie_embeddings": self.tie_embeddings, |
| } |
|
|
| |
| |
| |
| def dist_ready() -> bool: |
| return dist.is_available() and dist.is_initialized() |
|
|
| def distributed_mean(value: float, device: torch.device) -> float: |
| t = torch.tensor(float(value), dtype=torch.float64, device=device) |
| if dist_ready(): |
| dist.all_reduce(t, op=dist.ReduceOp.SUM) |
| t /= dist.get_world_size() |
| return t.item() |
|
|
| def broadcast_flag(value: bool, device: torch.device) -> bool: |
| flag = torch.tensor(int(bool(value)), dtype=torch.int32, device=device) |
| if dist_ready(): |
| dist.broadcast(flag, src=0) |
| return bool(flag.item()) |
|
|
| def all_ok(ok: bool, device: torch.device) -> bool: |
| t = torch.tensor(int(bool(ok)), dtype=torch.int32, device=device) |
| if dist_ready(): |
| dist.all_reduce(t, op=dist.ReduceOp.MIN) |
| return bool(t.item()) |
|
|
| def distributed_should_stop(device: torch.device, is_master: bool, step: int, total_steps: int) -> bool: |
| stop = (should_stop_local() or step >= total_steps) if is_master else False |
| return broadcast_flag(stop, device) |
|
|
| |
| |
| |
| @triton.jit |
| def smilyai_rmsnorm_fwd(X, W, Y, RSTD, stride_row, N, eps, BLOCK_N: tl.constexpr): |
| row = tl.program_id(0) |
| X += row * stride_row; Y += row * stride_row |
| cols = tl.arange(0, BLOCK_N); mask = cols < N |
| x = tl.load(X + cols, mask=mask, other=0.0).to(tl.float32) |
| var = tl.sum(x * x, axis=0) / N |
| rstd = 1.0 / tl.sqrt(var + eps) |
| tl.store(RSTD + row, rstd) |
| w = tl.load(W + cols, mask=mask, other=0.0).to(tl.float32) |
| tl.store(Y + cols, (x * rstd * w).to(Y.dtype.element_ty), mask=mask) |
|
|
| @triton.jit |
| def smilyai_rmsnorm_bwd(X, W, DY, DX, DW_PARTIAL, RSTD, stride_row, N, BLOCK_N: tl.constexpr): |
| row = tl.program_id(0) |
| X += row * stride_row; DY += row * stride_row; DX += row * stride_row |
| cols = tl.arange(0, BLOCK_N); mask = cols < N |
| x = tl.load(X + cols, mask=mask, other=0.0).to(tl.float32) |
| dy = tl.load(DY + cols, mask=mask, other=0.0).to(tl.float32) |
| w = tl.load(W + cols, mask=mask, other=0.0).to(tl.float32) |
| rstd = tl.load(RSTD + row) |
| wdy = w * dy |
| s = tl.sum(x * wdy, axis=0) |
| dx = rstd * wdy - (rstd * rstd * rstd / N) * x * s |
| tl.store(DX + cols, dx.to(DX.dtype.element_ty), mask=mask) |
| tl.store(DW_PARTIAL + row * N + cols, dy * x * rstd, mask=mask) |
|
|
| @triton.jit |
| def smilyai_swiglu_fwd(GATE, UP, OUT, N, BLOCK: tl.constexpr): |
| pid = tl.program_id(0) |
| offs = pid * BLOCK + tl.arange(0, BLOCK); mask = offs < N |
| g = tl.load(GATE + offs, mask=mask, other=0.0).to(tl.float32) |
| u = tl.load(UP + offs, mask=mask, other=0.0).to(tl.float32) |
| tl.store(OUT + offs, (g * tl.sigmoid(g) * u).to(OUT.dtype.element_ty), mask=mask) |
|
|
| @triton.jit |
| def smilyai_swiglu_bwd(GATE, UP, DOUT, DGATE, DUP, N, BLOCK: tl.constexpr): |
| pid = tl.program_id(0) |
| offs = pid * BLOCK + tl.arange(0, BLOCK); mask = offs < N |
| g = tl.load(GATE + offs, mask=mask, other=0.0).to(tl.float32) |
| u = tl.load(UP + offs, mask=mask, other=0.0).to(tl.float32) |
| dout = tl.load(DOUT + offs, mask=mask, other=0.0).to(tl.float32) |
| s = tl.sigmoid(g); silu = g * s; dsilu = s * (1.0 + g * (1.0 - s)) |
| tl.store(DGATE + offs, (dout * u * dsilu).to(DGATE.dtype.element_ty), mask=mask) |
| tl.store(DUP + offs, (dout * silu ).to(DUP.dtype.element_ty), mask=mask) |
|
|
| class _TritonRMSNormFn(torch.autograd.Function): |
| @staticmethod |
| @torch.compiler.disable |
| def forward(ctx, x, w, eps): |
| orig = x.shape; x2 = x.reshape(-1, orig[-1]).contiguous() |
| M, N = x2.shape; y = torch.empty_like(x2) |
| rstd = torch.empty(M, device=x.device, dtype=torch.float32) |
| BN = triton.next_power_of_2(N) |
| w = w.contiguous() |
| smilyai_rmsnorm_fwd[(M,)](x2, w, y, rstd, x2.stride(0), N, eps, BLOCK_N=BN) |
| ctx.save_for_backward(x2, w, rstd); ctx.BN = BN; ctx.orig = orig |
| return y.view(orig) |
|
|
| @staticmethod |
| @torch.compiler.disable |
| def backward(ctx, dy): |
| x2, w, rstd = ctx.saved_tensors; M, N = x2.shape |
| dy2 = dy.reshape(M, N).contiguous() |
| dx = torch.empty_like(x2) |
| dwp = torch.empty(M, N, device=x2.device, dtype=torch.float32) |
| smilyai_rmsnorm_bwd[(M,)](x2, w, dy2, dx, dwp, rstd, x2.stride(0), N, BLOCK_N=ctx.BN) |
| return dx.view(ctx.orig), dwp.sum(0).to(w.dtype), None |
|
|
| class RMSNorm(nn.Module): |
| def __init__(self, dim: int, eps: float = 1e-6): |
| super().__init__(); self.eps = eps; self.w = nn.Parameter(torch.ones(dim)) |
| def forward(self, x): |
| if x.is_cuda: return _TritonRMSNormFn.apply(x, self.w, self.eps) |
| x32 = x.float() |
| return (x32 * torch.rsqrt(x32.pow(2).mean(-1, keepdim=True) + self.eps) * self.w).to(x.dtype) |
|
|
| class _FusedSwiGLUFn(torch.autograd.Function): |
| @staticmethod |
| @torch.compiler.disable |
| def forward(ctx, gate, up): |
| shape = gate.shape; g = gate.reshape(-1).contiguous(); u = up.reshape(-1).contiguous() |
| N = g.numel(); out = torch.empty_like(g); BLOCK = 1024 |
| smilyai_swiglu_fwd[(triton.cdiv(N, BLOCK),)](g, u, out, N, BLOCK=BLOCK) |
| ctx.save_for_backward(g, u); ctx.shape = shape; ctx.BLOCK = BLOCK |
| return out.view(shape) |
|
|
| @staticmethod |
| @torch.compiler.disable |
| def backward(ctx, dout): |
| g, u = ctx.saved_tensors; N = g.numel() |
| dout_flat = dout.reshape(-1).contiguous() |
| dgate = torch.empty_like(g); dup = torch.empty_like(u) |
| smilyai_swiglu_bwd[(triton.cdiv(N, ctx.BLOCK),)](g, u, dout_flat, dgate, dup, N, BLOCK=ctx.BLOCK) |
| return dgate.view(ctx.shape), dup.view(ctx.shape) |
|
|
| def fused_swiglu(gate, up): |
| return _FusedSwiGLUFn.apply(gate, up) if gate.is_cuda else F.silu(gate) * up |
|
|
| def precompute_rope(head_dim, max_len, theta, device): |
| inv_freq = 1.0 / (theta ** (torch.arange(0, head_dim, 2, device=device, dtype=torch.float32) / head_dim)) |
| pos = torch.arange(max_len, device=device, dtype=torch.float32) |
| freqs = torch.outer(pos, inv_freq) |
| return freqs.cos(), freqs.sin() |
|
|
| def apply_rope(x, cos, sin): |
| dt = x.dtype |
| L = x.shape[1]; h = x.shape[-1] // 2 |
| c = cos[:L].unsqueeze(0).unsqueeze(2); s = sin[:L].unsqueeze(0).unsqueeze(2) |
| x32 = x.float() |
| x1, x2 = x32[..., :h], x32[..., h:] |
| return torch.cat([x1 * c - x2 * s, x2 * c + x1 * s], dim=-1).to(dt) |
|
|
| class GQAAttention(nn.Module): |
| def __init__(self, cfg: Config, layer_idx: int): |
| super().__init__() |
| self.n_heads = cfg.n_heads |
| self.n_kv_heads = cfg.n_kv_heads |
| self.hd = cfg.head_dim |
| d = cfg.d_model |
| self.wq = nn.Linear(d, self.n_heads * self.hd, bias=False) |
| self.wk = nn.Linear(d, self.n_kv_heads * self.hd, bias=False) |
| self.wv = nn.Linear(d, self.n_kv_heads * self.hd, bias=False) |
| self.wo = nn.Linear(self.n_heads * self.hd, d, bias=False) |
| self.q_norm = RMSNorm(self.hd) |
| self.k_norm = RMSNorm(self.hd) |
| std = 0.02 |
| for m in [self.wq, self.wk, self.wv]: nn.init.normal_(m.weight, std=std) |
| nn.init.normal_(self.wo.weight, std=std / math.sqrt(2 * cfg.n_layers)) |
|
|
| def _attend(self, q, k, v): |
| if HAS_FLASH and q.is_cuda and q.dtype in (torch.bfloat16, torch.float16): |
| return flash_attn_func(q, k, v, causal=True) |
| B, L, Hq, D = q.shape; Hkv = k.shape[2] |
| qt = q.transpose(1,2); kt = k.transpose(1,2); vt = v.transpose(1,2) |
| if Hq != Hkv: |
| rep = Hq // Hkv |
| kt = kt.repeat_interleave(rep, 1); vt = vt.repeat_interleave(rep, 1) |
| out = F.scaled_dot_product_attention(qt, kt, vt, is_causal=True) |
| return out.transpose(1, 2) |
|
|
| def forward(self, x, cos, sin): |
| B, L, _ = x.shape |
| q = self.wq(x).view(B, L, self.n_heads, self.hd) |
| k = self.wk(x).view(B, L, self.n_kv_heads, self.hd) |
| v = self.wv(x).view(B, L, self.n_kv_heads, self.hd) |
| q, k = self.q_norm(q), self.k_norm(k) |
| q, k = apply_rope(q, cos, sin), apply_rope(k, cos, sin) |
| out = self._attend(q, k, v) |
| return self.wo(out.reshape(B, L, -1)) |
|
|
| |
| |
| |
| _moe_autotune_configs = [ |
| triton.Config({"BLOCK_N": 64, "BLOCK_K": 32}, num_warps=4, num_stages=3), |
| triton.Config({"BLOCK_N": 128, "BLOCK_K": 32}, num_warps=8, num_stages=3), |
| triton.Config({"BLOCK_N": 128, "BLOCK_K": 64}, num_warps=8, num_stages=4), |
| triton.Config({"BLOCK_N": 64, "BLOCK_K": 64}, num_warps=4, num_stages=4), |
| ] |
|
|
| @triton.autotune(configs=_moe_autotune_configs, key=["K", "N"]) |
| @triton.jit |
| def _moe_gemm_kernel( |
| A_ptr, B_ptr, C_ptr, block_expert_ptr, |
| M_padded, K, N, |
| stride_am, stride_ak, |
| stride_be, stride_bk, stride_bn, |
| stride_cm, stride_cn, |
| BLOCK_M: tl.constexpr, BLOCK_N: tl.constexpr, BLOCK_K: tl.constexpr, |
| ): |
| pid_m = tl.program_id(0) |
| pid_n = tl.program_id(1) |
| e = tl.load(block_expert_ptr + pid_m).to(tl.int64) |
| offs_m = pid_m * BLOCK_M + tl.arange(0, BLOCK_M) |
| offs_n = pid_n * BLOCK_N + tl.arange(0, BLOCK_N) |
| offs_k = tl.arange(0, BLOCK_K) |
| m_mask = offs_m < M_padded |
| n_mask = offs_n < N |
| a_ptrs = A_ptr + offs_m[:, None] * stride_am + offs_k[None, :] * stride_ak |
| b_ptrs = B_ptr + e * stride_be + offs_k[:, None] * stride_bk + offs_n[None, :] * stride_bn |
| acc = tl.zeros((BLOCK_M, BLOCK_N), dtype=tl.float32) |
| for k0 in range(0, K, BLOCK_K): |
| k_mask = (k0 + offs_k) < K |
| a = tl.load(a_ptrs, mask=m_mask[:, None] & k_mask[None, :], other=0.0) |
| b = tl.load(b_ptrs, mask=k_mask[:, None] & n_mask[None, :], other=0.0) |
| acc = tl.dot(a, b, acc) |
| a_ptrs += BLOCK_K * stride_ak |
| b_ptrs += BLOCK_K * stride_bk |
| tl.store( |
| C_ptr + offs_m[:, None] * stride_cm + offs_n[None, :] * stride_cn, |
| acc.to(tl.bfloat16), mask=m_mask[:, None] & n_mask[None, :], |
| ) |
|
|
| def _grouped_linear_raw(A, W, block_expert, M_padded, transpose, BM): |
| E, OUT, IN = W.shape |
| if not transpose: |
| K, N = IN, OUT; stride_bk = W.stride(2); stride_bn = W.stride(1) |
| else: |
| K, N = OUT, IN; stride_bk = W.stride(1); stride_bn = W.stride(2) |
| C = torch.empty((M_padded, N), device=A.device, dtype=torch.bfloat16) |
| grid = lambda META: (triton.cdiv(M_padded, BM), triton.cdiv(N, META["BLOCK_N"])) |
| _moe_gemm_kernel[grid]( |
| A, W, C, block_expert, M_padded, K, N, |
| A.stride(0), A.stride(1), |
| W.stride(0), stride_bk, stride_bn, |
| C.stride(0), C.stride(1), |
| BLOCK_M=BM, |
| ) |
| return C |
|
|
| @triton.autotune(configs=_moe_autotune_configs, key=["K", "N"], reset_to_zero=["DW_ptr"]) |
| @triton.jit |
| def _moe_dw_kernel( |
| A_ptr, DC_ptr, DW_ptr, block_expert_ptr, |
| M_padded, K, N, |
| stride_am, stride_ak, |
| stride_dcm, stride_dcn, |
| stride_dwe, stride_dwn, stride_dwk, |
| BLOCK_M: tl.constexpr, BLOCK_N: tl.constexpr, BLOCK_K: tl.constexpr, |
| ): |
| pid_m = tl.program_id(0) |
| pid_n = tl.program_id(1) |
| pid_k = tl.program_id(2) |
| e = tl.load(block_expert_ptr + pid_m).to(tl.int64) |
| offs_m = pid_m * BLOCK_M + tl.arange(0, BLOCK_M) |
| offs_n = pid_n * BLOCK_N + tl.arange(0, BLOCK_N) |
| offs_k = pid_k * BLOCK_K + tl.arange(0, BLOCK_K) |
| m_mask = offs_m < M_padded |
| n_mask = offs_n < N |
| k_mask = offs_k < K |
| a = tl.load(A_ptr + offs_m[:, None] * stride_am + offs_k[None, :] * stride_ak, |
| mask=m_mask[:, None] & k_mask[None, :], other=0.0) |
| dc = tl.load(DC_ptr + offs_m[:, None] * stride_dcm + offs_n[None, :] * stride_dcn, |
| mask=m_mask[:, None] & n_mask[None, :], other=0.0) |
| tl.atomic_add( |
| DW_ptr + e * stride_dwe + offs_n[:, None] * stride_dwn + offs_k[None, :] * stride_dwk, |
| tl.dot(tl.trans(dc), a), |
| mask=n_mask[:, None] & k_mask[None, :], |
| ) |
|
|
| def _grouped_dw_raw(A, dC, block_expert, E, OUT, IN, M_padded, BM): |
| DW = torch.zeros((E, OUT, IN), device=A.device, dtype=torch.float32) |
| grid = lambda META: ( |
| triton.cdiv(M_padded, BM), |
| triton.cdiv(OUT, META["BLOCK_N"]), |
| triton.cdiv(IN, META["BLOCK_K"]), |
| ) |
| _moe_dw_kernel[grid]( |
| A, dC, DW, block_expert, M_padded, IN, OUT, |
| A.stride(0), A.stride(1), |
| dC.stride(0), dC.stride(1), |
| DW.stride(0), DW.stride(1), DW.stride(2), |
| BLOCK_M=BM, |
| ) |
| return DW |
|
|
| class GroupedLinearFn(torch.autograd.Function): |
| @staticmethod |
| def forward(ctx, A, W, block_expert, padded_offsets, M_padded, BM): |
| A = A.contiguous().to(torch.bfloat16) |
| W = W.contiguous() |
| C = _grouped_linear_raw(A, W, block_expert, M_padded, False, BM) |
| ctx.save_for_backward(A, W, block_expert, padded_offsets) |
| ctx.M_padded = M_padded |
| ctx.BM = BM |
| return C |
|
|
| @staticmethod |
| def backward(ctx, dC): |
| A, W, block_expert, _ = ctx.saved_tensors |
| dC = dC.contiguous().to(torch.bfloat16) |
| dA = _grouped_linear_raw(dC, W, block_expert, ctx.M_padded, True, ctx.BM) \ |
| if ctx.needs_input_grad[0] else None |
| dW = _grouped_dw_raw(A, dC, block_expert, W.shape[0], W.shape[1], W.shape[2], |
| ctx.M_padded, ctx.BM).to(W.dtype) \ |
| if ctx.needs_input_grad[1] else None |
| return dA, dW, None, None, None, None |
|
|
| def moe_align_block_size(expert_ids, num_experts, block_size, device): |
| counts = torch.bincount(expert_ids, minlength=num_experts) |
| padded_counts = ((counts + block_size - 1) // block_size) * block_size |
| padded_offsets = torch.zeros(num_experts + 1, dtype=torch.long, device=device) |
| padded_offsets[1:] = torch.cumsum(padded_counts, dim=0) |
| orig_offsets = torch.zeros(num_experts + 1, dtype=torch.long, device=device) |
| orig_offsets[1:] = torch.cumsum(counts, dim=0) |
| total_padded = int(padded_offsets[-1].item()) |
| sort_idx = torch.argsort(expert_ids, stable=True) |
| num_blocks_per_expert = padded_counts // block_size |
| block_expert = torch.repeat_interleave( |
| torch.arange(num_experts, device=device), num_blocks_per_expert |
| ) |
| n_rows = expert_ids.numel() |
| arange_total = torch.arange(n_rows, device=device) |
| sorted_expert_of_row = expert_ids[sort_idx] |
| row_within_expert = arange_total - orig_offsets[sorted_expert_of_row] |
| dest = padded_offsets[sorted_expert_of_row] + row_within_expert |
| perm = torch.full((total_padded,), -1, dtype=torch.long, device=device) |
| perm[dest] = sort_idx |
| return perm, block_expert, total_padded, padded_offsets |
|
|
| class MoEFFN(nn.Module): |
| def __init__(self, cfg: Config, layer_idx: int): |
| super().__init__() |
| d = cfg.d_model |
| h = int(d * cfg.expert_hidden_mult) |
| E = cfg.n_experts |
| self.E = E; self.d = d; self.h = h |
| self.top_k = cfg.top_k |
| self.aux_loss_coef = cfg.aux_loss_coef |
| self.block_m = cfg.moe_block_m |
|
|
| self.gate_w = nn.Parameter(torch.empty(E, h, d)) |
| self.up_w = nn.Parameter(torch.empty(E, h, d)) |
| self.down_w = nn.Parameter(torch.empty(E, d, h)) |
| nn.init.normal_(self.gate_w, std=0.02) |
| nn.init.normal_(self.up_w, std=0.02) |
| nn.init.normal_(self.down_w, std=0.02 / math.sqrt(2 * cfg.n_layers)) |
|
|
| self.router = nn.Linear(d, E, bias=False) |
| nn.init.normal_(self.router.weight, std=0.02) |
|
|
| sh = int(d * cfg.shared_hidden_mult) |
| self.shared_gate = nn.Linear(d, sh, bias=False) |
| self.shared_up = nn.Linear(d, sh, bias=False) |
| self.shared_down = nn.Linear(sh, d, bias=False) |
| nn.init.normal_(self.shared_gate.weight, std=0.02) |
| nn.init.normal_(self.shared_up.weight, std=0.02) |
| nn.init.normal_(self.shared_down.weight, std=0.02 / math.sqrt(2 * cfg.n_layers)) |
|
|
| self.bias_update_rate = cfg.bias_update_rate |
| self.bias_cap = cfg.bias_cap |
| self.bias_decay = cfg.bias_decay |
| self.usage_ema_decay = cfg.usage_ema_decay |
| self.register_buffer('expert_bias', torch.zeros(E, dtype=torch.float32)) |
| self.register_buffer('expert_usage_ema', torch.zeros(E, dtype=torch.float32)) |
| self._bias_capped_warned = False |
| self.last_aux_loss = torch.tensor(0.0, dtype=torch.float32) |
|
|
| @torch.no_grad() |
| def accumulate_usage(self, topk_i): |
| counts = F.one_hot(topk_i, self.E).float().sum(dim=(0, 1)) |
| self.expert_usage_ema.mul_(self.usage_ema_decay).add_(counts, alpha=1 - self.usage_ema_decay) |
|
|
| @torch.no_grad() |
| def update_bias(self): |
| if dist_ready(): |
| dist.all_reduce(self.expert_usage_ema, op=dist.ReduceOp.AVG) |
| usage = self.expert_usage_ema |
| avg = usage.mean().clamp_min(1e-6) |
| error = ((avg - usage) / avg).clamp(-1.0, 1.0) |
| self.expert_bias.add_(self.bias_update_rate * error) |
| self.expert_bias.mul_(1.0 - self.bias_decay) |
| self.expert_bias.clamp_(-self.bias_cap, self.bias_cap) |
| if not self._bias_capped_warned and bool((self.expert_bias.abs() >= self.bias_cap * 0.99).any()): |
| log.warning(f"[moe] expert_bias hit cap ({self.bias_cap}) on some expert") |
| self._bias_capped_warned = True |
|
|
| def dead_expert_count(self, threshold: float = 1e-6) -> int: |
| return int((self.expert_usage_ema < threshold).sum().item()) |
|
|
| def capped_expert_count(self) -> int: |
| return int((self.expert_bias.abs() >= self.bias_cap * 0.99).sum().item()) |
|
|
| def forward(self, x): |
| B, L, D = x.shape; T = B * L |
| x_flat = x.reshape(T, D) |
| E, top_k, BM = self.E, self.top_k, self.block_m |
| device = x.device |
|
|
| shared_out = self.shared_down( |
| fused_swiglu(self.shared_gate(x_flat), self.shared_up(x_flat))) |
|
|
| logits = self.router(x_flat).float() |
| probs = F.softmax(logits, dim=-1) |
|
|
| biased = logits + self.expert_bias.detach().float() |
| _, topk_i = torch.topk(biased, top_k, dim=-1) |
| topk_p = probs.gather(-1, topk_i) |
| topk_p = topk_p / topk_p.sum(-1, keepdim=True).clamp_min(1e-9) |
|
|
| with torch.no_grad(): |
| f_i = F.one_hot(topk_i, E).float().sum(1).mean(0) |
| p_i = probs.mean(0) |
| self.last_aux_loss = (E * (f_i * p_i).sum()) * self.aux_loss_coef |
|
|
| if self.training: |
| self.accumulate_usage(topk_i) |
|
|
| expert_ids_flat = topk_i.reshape(-1) |
| gate_flat = topk_p.reshape(-1).to(x.dtype) |
| token_idx_flat = torch.arange(T, device=device).unsqueeze(1).expand(T, top_k).reshape(-1) |
|
|
| perm, block_expert, total_padded, padded_offsets = moe_align_block_size( |
| expert_ids_flat, E, BM, device) |
|
|
| valid = perm >= 0 |
| gather_idx = perm.clamp_min(0) |
| src_token = token_idx_flat[gather_idx] |
| A_padded = x_flat[src_token] * valid.unsqueeze(1).to(x_flat.dtype) |
|
|
| gate = GroupedLinearFn.apply(A_padded, self.gate_w, block_expert, padded_offsets, total_padded, BM) |
| up = GroupedLinearFn.apply(A_padded, self.up_w, block_expert, padded_offsets, total_padded, BM) |
| down = GroupedLinearFn.apply(fused_swiglu(gate, up), self.down_w, block_expert, padded_offsets, total_padded, BM) |
|
|
| gate_vals = (gate_flat[gather_idx] * valid.to(gate_flat.dtype)).unsqueeze(1) |
| routed_out = torch.zeros(T, D, dtype=down.dtype, device=device) |
| routed_out.index_add_(0, src_token, (down * gate_vals.to(down.dtype))) |
|
|
| return (routed_out.to(x.dtype) + shared_out).view(B, L, D) |
|
|
| class Block(nn.Module): |
| def __init__(self, cfg: Config, layer_idx: int): |
| super().__init__() |
| self.norm1 = RMSNorm(cfg.d_model) |
| self.norm2 = RMSNorm(cfg.d_model) |
| self.attn = GQAAttention(cfg, layer_idx) |
| self.ffn = MoEFFN(cfg, layer_idx) |
|
|
| def forward(self, x, cos, sin): |
| x = x + self.attn(self.norm1(x), cos, sin) |
| x = x + self.ffn (self.norm2(x)) |
| return x |
|
|
| class SmilyaiG1(nn.Module): |
| def __init__(self, cfg: Config): |
| super().__init__() |
| self.cfg = cfg |
| self.embed = nn.Embedding(cfg.vocab_size, cfg.d_model) |
| nn.init.normal_(self.embed.weight, std=0.02) |
| self.blocks = nn.ModuleList([Block(cfg, i) for i in range(cfg.n_layers)]) |
| self.final_norm = RMSNorm(cfg.d_model) |
| if not cfg.tie_embeddings: |
| self.lm_head = nn.Linear(cfg.d_model, cfg.vocab_size, bias=False) |
| nn.init.normal_(self.lm_head.weight, std=0.02 / math.sqrt(cfg.n_layers)) |
| else: |
| self.lm_head = None |
| self.register_buffer("rope_cos", torch.zeros(cfg.max_len, cfg.head_dim // 2, dtype=torch.float32), persistent=False) |
| self.register_buffer("rope_sin", torch.zeros(cfg.max_len, cfg.head_dim // 2, dtype=torch.float32), persistent=False) |
| self._rope_ready = False |
| self._step = 0 |
| self._last_lm_loss = None |
| self._last_aux_loss = None |
| self._log_summary() |
|
|
| def _raw_blocks(self): |
| return [getattr(b, "_orig_mod", b) for b in self.blocks] |
|
|
| def init_rope(self, device): |
| c, s = precompute_rope(self.cfg.head_dim, self.cfg.max_len, self.cfg.rope_theta, device) |
| self.rope_cos = c.float() |
| self.rope_sin = s.float() |
| self._rope_ready = True |
|
|
| def force_fp32_balancing_buffers(self): |
| for b in self._raw_blocks(): |
| b.ffn.expert_bias = b.ffn.expert_bias.float() |
| b.ffn.expert_usage_ema = b.ffn.expert_usage_ema.float() |
|
|
| def _log_summary(self): |
| cfg = self.cfg |
| total = sum(p.numel() for p in self.parameters()) |
| attn_p = sum(p.numel() for n, p in self.named_parameters() if 'attn' in n) |
| shared_p= sum(p.numel() for n, p in self.named_parameters() if 'shared' in n) |
| h_e = int(cfg.d_model * cfg.expert_hidden_mult) |
| routed_total = cfg.n_layers * cfg.n_experts * (2*cfg.d_model*h_e + h_e*cfg.d_model) |
| routed_active = routed_total * (cfg.top_k / cfg.n_experts) |
| active_est = attn_p + shared_p + routed_active + cfg.d_model * cfg.vocab_size |
| log.info("=" * 70) |
| log.info("Smilyai-G1 20B — plain GQA + Sparse MoE (FSDP2)") |
| log.info(f" d={cfg.d_model} L={cfg.n_layers} heads={cfg.n_heads} kv={cfg.n_kv_heads}") |
| log.info(f" MoE: {cfg.n_experts} experts, top_k={cfg.top_k}, shared_mult={cfg.shared_hidden_mult}") |
| log.info(f" Total params: {total/1e9:.2f}B") |
| log.info(f" Active/token (estimate): {active_est/1e9:.2f}B (target ~2B)") |
| log.info(f" vocab={cfg.vocab_size} | Flash: {HAS_FLASH}") |
| log.info(f" Muon LR: {cfg.muon_lr} (aspect-ratio scaling)") |
| log.info(f" Compile: {cfg.use_compile}") |
| log.info("=" * 70) |
|
|
| def count_params(self): return sum(p.numel() for p in self.parameters()) |
| def collect_aux_loss(self): return sum(b.ffn.last_aux_loss for b in self._raw_blocks()) |
| def set_step(self, s: int): self._step = s |
|
|
| def update_expert_bias(self): |
| for b in self._raw_blocks(): |
| b.ffn.update_bias() |
|
|
| def dead_expert_report(self): |
| raw = self._raw_blocks() |
| dead = [b.ffn.dead_expert_count() for b in raw] |
| capped = [b.ffn.capped_expert_count() for b in raw] |
| return dead, sum(dead), capped, sum(capped) |
|
|
| def forward(self, tokens, targets=None): |
| B, L = tokens.shape; device = tokens.device |
| if not self._rope_ready: |
| self.init_rope(device) |
| cos, sin = self.rope_cos[:L], self.rope_sin[:L] |
|
|
| x = self.embed(tokens) |
| for block in self.blocks: |
| x = block(x, cos, sin) |
|
|
| x = self.final_norm(x) |
| logits= F.linear(x, self.embed.weight) if self.lm_head is None else self.lm_head(x) |
|
|
| if targets is None: |
| return logits, None |
|
|
| lm_loss = F.cross_entropy( |
| logits[:, :-1].reshape(-1, self.cfg.vocab_size).float(), |
| targets[:, 1:].reshape(-1), ignore_index=-1) |
| aux_loss = self.collect_aux_loss() |
| total_loss = lm_loss + aux_loss |
| self._last_lm_loss = lm_loss.detach() |
| self._last_aux_loss = aux_loss.detach() if torch.is_tensor(aux_loss) \ |
| else torch.tensor(float(aux_loss), device=device) |
| return logits, total_loss |
|
|
| |
| |
| |
| _FP8_SKIP = ("router", "lm_head", "embed") |
|
|
| def fp8_capable_gpu() -> bool: |
| return torch.cuda.is_available() and \ |
| torch.cuda.get_device_capability(torch.cuda.current_device())[0] >= 9 |
|
|
| def apply_fp8(model: SmilyaiG1, cfg: Config, is_master: bool) -> SmilyaiG1: |
| if not cfg.use_fp8: |
| if is_master: log.info("[fp8] disabled") |
| return model |
| if not HAS_FP8: |
| if is_master: log.warning("[fp8] torchao not installed — staying bf16") |
| return model |
| if not fp8_capable_gpu(): |
| if is_master: log.warning("[fp8] pre-Hopper GPU — staying bf16") |
| return model |
| convert_to_float8_training( |
| model, |
| config=Float8LinearConfig.from_recipe_name("rowwise"), |
| module_filter_fn=lambda m, fqn: ( |
| isinstance(m, nn.Linear) and not any(s in fqn for s in _FP8_SKIP) |
| ), |
| ) |
| if is_master: |
| log.info("[fp8] converted dense nn.Linear layers to float8 (rowwise); MoE stays bf16") |
| return model |
|
|
| def apply_fsdp(model: SmilyaiG1, cfg: Config) -> SmilyaiG1: |
| if not dist_ready(): |
| log.warning("[fsdp] no process group — running unsharded (single GPU)") |
| return model |
| mp_policy = MixedPrecisionPolicy(param_dtype=torch.bfloat16, reduce_dtype=torch.float32) |
| for block in model.blocks: |
| fully_shard(block, mp_policy=mp_policy) |
| fully_shard(model, mp_policy=mp_policy) |
| if torch.cuda.is_available(): |
| torch.cuda.empty_cache() |
| return model |
|
|
| def apply_compile(model: SmilyaiG1, cfg: Config, is_master: bool) -> SmilyaiG1: |
| if not cfg.use_compile: |
| if is_master: log.info("[compile] disabled") |
| return model |
| compiled = 0 |
| for i, block in enumerate(model.blocks): |
| try: |
| model.blocks[i] = torch.compile(block, dynamic=True, mode="default", fullgraph=False) |
| compiled += 1 |
| except Exception as e: |
| if is_master: |
| log.warning(f"[compile] block {i} failed, staying eager: {e}") |
| if torch.cuda.is_available(): |
| torch.cuda.empty_cache() |
| if is_master: |
| if compiled > 0: |
| log.info(f"[compile] compiled {compiled}/{len(model.blocks)} blocks") |
| else: |
| log.warning("[compile] ALL blocks fell back to eager") |
| return model |
|
|
| |
| |
| |
| def newton_schulz_5(G: torch.Tensor, steps: int = 5) -> torch.Tensor: |
| a, b, c = 3.4445, -4.7750, 2.0315 |
| squeeze = (G.ndim == 2) |
| X = (G.unsqueeze(0) if squeeze else G).bfloat16() |
| transposed = X.size(-2) < X.size(-1) |
| if transposed: X = X.transpose(-2,-1) |
| X = X / (X.norm(dim=(-2,-1), keepdim=True) + 1e-7) |
| for _ in range(steps): |
| A = X @ X.transpose(-2,-1) |
| X = a*X + (b*A + c*A@A) @ X |
| if transposed: X = X.transpose(-2,-1) |
| return X.squeeze(0) if squeeze else X |
|
|
| @torch.no_grad() |
| def stochastic_round_to(dtype: torch.dtype, x_fp32: torch.Tensor) -> torch.Tensor: |
| if dtype != torch.bfloat16: |
| return x_fp32.to(dtype) |
| bits = x_fp32.contiguous().view(torch.int32) |
| noise = torch.randint(0, 1 << 16, bits.shape, device=bits.device, dtype=torch.int32) |
| rounded = (bits + noise) & -65536 |
| return rounded.view(torch.float32).to(torch.bfloat16) |
|
|
| class Muon(torch.optim.Optimizer): |
| def __init__(self, params, lr=0.02, momentum=0.95, wd=0.0): |
| super().__init__(list(params), dict(lr=lr, momentum=momentum, wd=wd)) |
|
|
| @torch.no_grad() |
| def step(self, closure=None): |
| for g in self.param_groups: |
| lr, mom, wd = g['lr'], g['momentum'], g['wd'] |
| for p in g['params']: |
| if p.grad is None: |
| continue |
| grad = p.grad |
| is_dtensor = isinstance(p, DTensor) |
| st = self.state[p] |
| if 'buf' not in st: |
| st['buf'] = torch.zeros_like(grad, dtype=torch.float32) |
| buf = st['buf'] |
| buf.mul_(mom).add_(grad.to(torch.float32)) |
| gnest = grad.to(torch.float32).add(buf, alpha=mom) |
| full = gnest.full_tensor() if is_dtensor else gnest |
| if full.ndim in (2, 3): |
| u = newton_schulz_5(full) |
| rows, cols = full.shape[-2], full.shape[-1] |
| scale = max(1.0, rows / cols) ** 0.5 |
| update = u.to(torch.float32) * (lr * 0.2 * scale) |
| else: |
| update = full * lr |
| del full |
| if is_dtensor: |
| upd_local = distribute_tensor(update, p.device_mesh, p.placements).to_local() |
| p_local = p.to_local() |
| else: |
| upd_local = update |
| p_local = p.data |
| if wd > 0: |
| p_local.mul_(1.0 - lr * wd) |
| p_local.sub_(stochastic_round_to(p_local.dtype, upd_local.contiguous())) |
|
|
| def build_optimizers(model: SmilyaiG1, cfg: Config, is_master: bool): |
| muon_p, adamw_p = [], [] |
| for name, p in model.named_parameters(): |
| if not p.requires_grad: continue |
| if p.ndim in (2, 3) and 'embed' not in name and 'lm_head' not in name: |
| muon_p.append(p) |
| else: |
| adamw_p.append(p) |
| muon_opt = Muon(muon_p, lr=cfg.muon_lr, momentum=cfg.muon_mom, wd=cfg.wd) |
| groups = [{'params': adamw_p, 'lr': cfg.adamw_lr}] |
| if dist_ready(): |
| adamw_opt = torch.optim.AdamW(groups, betas=(cfg.beta1, cfg.beta2), weight_decay=cfg.wd, foreach=True) |
| if is_master: log.info("[optim] Muon (FIXED scale) + foreach AdamW (DTensor-safe)") |
| elif HAS_BNB: |
| adamw_opt = bnb.optim.AdamW8bit(groups, betas=(cfg.beta1, cfg.beta2), weight_decay=cfg.wd) |
| if is_master: log.info("[optim] Muon (FIXED) + 8-bit AdamW (single GPU)") |
| else: |
| adamw_opt = torch.optim.AdamW(groups, betas=(cfg.beta1, cfg.beta2), weight_decay=cfg.wd, fused=True) |
| if is_master: log.info("[optim] Muon (FIXED) + fused AdamW (single GPU)") |
| if is_master: |
| log.info(f"[optim] Muon={sum(p.numel() for p in muon_p)/1e6:.1f}M | " |
| f"AdamW={sum(p.numel() for p in adamw_p)/1e6:.1f}M") |
| return muon_opt, adamw_opt |
|
|
| def cosine_lr(step, warmup, total, peak, minimum): |
| if step < warmup: return peak * (step + 1) / warmup |
| if step >= total: return minimum |
| t = (step - warmup) / (total - warmup) |
| return minimum + 0.5 * (peak - minimum) * (1 + math.cos(math.pi * t)) |
|
|
| |
| |
| |
| try: |
| from datasets import load_dataset |
| import datasets as _hfds |
| HAS_DATASETS = True |
| try: _hfds.disable_progress_bars() |
| except Exception: pass |
| try: |
| import pyarrow as _pa |
| _pa.set_cpu_count(2); _pa.set_io_thread_count(4) |
| except Exception: |
| pass |
| except ImportError: |
| HAS_DATASETS = False |
|
|
| _g1_tokenizer = None |
|
|
| def get_tokenizer(cfg: Config): |
| global _g1_tokenizer |
| if _g1_tokenizer is not None: |
| return _g1_tokenizer |
| from tokenizers import Tokenizer |
| tok_path = hf_hub_download(repo_id=cfg.tokenizer_repo, filename="tokenizer.json", |
| cache_dir=LOCAL_CACHE, token=HF_TOKEN) |
| _g1_tokenizer = Tokenizer.from_file(tok_path) |
| got_vocab = _g1_tokenizer.get_vocab_size() |
| if got_vocab != cfg.vocab_size: |
| log.warning(f"[tokenizer] loaded vocab_size={got_vocab} != cfg.vocab_size=" |
| f"{cfg.vocab_size} — fix Config.vocab_size to match the real tokenizer.") |
| return _g1_tokenizer |
|
|
| _EOS_CACHE: Optional[int] = None |
|
|
| def _resolve_eos(tok) -> int: |
| """v7: env override > known names > scan added tokens for anything EOS-like > id 0 (logged loudly).""" |
| global _EOS_CACHE |
| if _EOS_CACHE is not None: |
| return _EOS_CACHE |
| override = os.environ.get("G1_EOS_TOKEN", "").strip() |
| if override: |
| tid = tok.token_to_id(override) |
| if tid is not None: |
| log.info(f"[tokenizer] EOS from G1_EOS_TOKEN: {override!r} -> id {tid}") |
| _EOS_CACHE = tid; return tid |
| log.warning(f"[tokenizer] G1_EOS_TOKEN={override!r} not in vocab — falling back to auto-detect") |
| for cand in ("<|endoftext|>", "<|end_of_text|>", "</s>", "<eos>", "<|eos|>", "<|eot_id|>", |
| "<|im_end|>", "[EOS]", "<end_of_text>", "<|end|>"): |
| tid = tok.token_to_id(cand) |
| if tid is not None: |
| log.info(f"[tokenizer] EOS auto-detected: {cand!r} -> id {tid}") |
| _EOS_CACHE = tid; return tid |
| try: |
| added = tok.get_added_tokens_decoder() |
| names = {tid: t.content for tid, t in added.items()} |
| for tid, name in names.items(): |
| low = name.lower() |
| if ("eos" in low or "end" in low) and "pad" not in low and "unk" not in low: |
| log.info(f"[tokenizer] EOS heuristically picked from added tokens: {name!r} -> id {tid}") |
| _EOS_CACHE = tid; return tid |
| log.error(f"[tokenizer] NO EOS TOKEN FOUND. Added tokens are: {names}. " |
| f"Set G1_EOS_TOKEN to the right one. Using id 0 as a document separator for now.") |
| except Exception as e: |
| log.error(f"[tokenizer] could not inspect added tokens ({e}); using id 0 as separator") |
| _EOS_CACHE = 0 |
| return 0 |
|
|
| _STACK_KEEP_LANGS = { |
| "Python", "JavaScript", "TypeScript", "Java", "C", "C++", "C#", |
| "Go", "Rust", "Ruby", "PHP", "Swift", "Kotlin", "Scala", "Shell", |
| "SQL", "HTML", "CSS", "Markdown", "R", "Julia", "Lua", "Haskell", |
| "Elixir", "Erlang", "Dart", "Zig", "CUDA", "Fortran", |
| } |
| _MIN_CODE_CHARS = 64 |
| _MAX_CODE_CHARS = 65536 |
| _MAX_DOC_CHARS = 1_000_000 |
| _MAX_REPO_CHARS = 65_536 |
|
|
| def _extract_stack_v3_text(row: dict) -> Optional[str]: |
| files = row.get("files") |
| if not files: |
| return None |
| parts, total = [], 0 |
| for f in files: |
| content = f.get("content", "") |
| if not content: |
| continue |
| lang = f.get("language", "") |
| if lang and lang not in _STACK_KEEP_LANGS: |
| continue |
| if len(content) < _MIN_CODE_CHARS or len(content) > _MAX_CODE_CHARS: |
| continue |
| parts.append(f"# {f.get('file_path', '')}\n{content}") |
| total += len(content) |
| if total >= _MAX_REPO_CHARS: |
| break |
| return "\n\n".join(parts) if parts else None |
|
|
| def _extract_text(row: dict, text_field: str, repo_id: str) -> Optional[str]: |
| if "stack-v3" in repo_id: |
| text = row.get("text") if ("text" in row and "files" not in row) else _extract_stack_v3_text(row) |
| else: |
| text = row.get(text_field) |
| if not text or not isinstance(text, str): |
| return None |
| return text[:_MAX_DOC_CHARS] if len(text) > _MAX_DOC_CHARS else text |
|
|
| def _open_source_stream(repo_id: str, split: str, shard_index: int, num_shards: int, |
| shuffle_buffer: int = 0, shuffle_seed: int = 0, |
| config_name: Optional[str] = None, text_field: str = "text"): |
| is_stack = "stack-v3" in repo_id |
| need_col = "files" if is_stack else text_field |
| args = (repo_id, config_name) if config_name else (repo_id,) |
| kw = dict(split=split, streaming=True) |
| try: |
| |
| ds = load_dataset(*args, columns=[need_col], batch_size=(4 if is_stack else 64), **kw) |
| except Exception: |
| ds = load_dataset(*args, **kw) |
|
|
| if num_shards > 1: |
| ds = ds.shard(num_shards=num_shards, index=shard_index) |
|
|
| if is_stack: |
| cols = ds.column_names |
| ds = ds.map(lambda r: {"text": _extract_stack_v3_text(r) or ""}, remove_columns=cols) |
| ds = ds.filter(lambda r: len(r["text"]) > 0) |
|
|
| if shuffle_buffer > 0: |
| ds = ds.shuffle(buffer_size=shuffle_buffer, seed=shuffle_seed) |
| return ds |
|
|
| def _short_src(repo_id: str) -> str: |
| return repo_id.split("/")[-1][:18] |
|
|
| class LiveStreamingDataset: |
| def __init__(self, cfg: Config, batch_size: int, rank: int, world_size: int): |
| if not HAS_DATASETS: |
| raise RuntimeError("the `datasets` package is required for live streaming") |
| self.cfg = cfg |
| self.batch_size = batch_size |
| self.rank = rank |
| self.world_size = world_size |
| self.max_len = cfg.max_len |
| self.n_workers = max(1, cfg.tokenizer_workers) |
| self.total_shards = world_size * self.n_workers |
| self.tok = get_tokenizer(cfg) |
| self.eos_id = _resolve_eos(self.tok) |
|
|
| qsize = max(cfg.prefetch_shards, self.n_workers * 2) |
| self._q: queue.Queue = queue.Queue(maxsize=qsize) |
| self._stop = threading.Event() |
| self._workers = [threading.Thread(target=self._fetch_loop, args=(w,), daemon=True) |
| for w in range(self.n_workers)] |
| for t in self._workers: |
| t.start() |
| log.info(f"[stream] rank={rank}/{world_size}: {self.n_workers} tokenizer threads " |
| f"({self.total_shards} global shards) | {len(cfg.dataset_sources)} sources | " |
| f"shuffle_buffer={cfg.shuffle_buffer} eos_id={self.eos_id} session={SESSION_ID}") |
|
|
| def _fetch_loop(self, worker_id: int): |
| shard_index = self.rank * self.n_workers + worker_id |
| shuffle_seed = 1234 + shard_index + SESSION_ID * 97 |
| try: |
| streams, failed = [], [] |
| for repo_id, split, text_field, w, config_name in self.cfg.dataset_sources: |
| try: |
| streams.append([ |
| _open_source_stream(repo_id, split, shard_index, self.total_shards, |
| shuffle_buffer=self.cfg.shuffle_buffer, |
| shuffle_seed=shuffle_seed, |
| config_name=config_name, text_field=text_field), |
| text_field, repo_id, split, float(w), config_name]) |
| except Exception as e: |
| log.error(f"[stream] rank={self.rank}.w{worker_id} FAILED TO OPEN {repo_id}: {str(e)[:300]}") |
| failed.append(repo_id) |
| if failed: |
| log.error(f"[stream] rank={self.rank}.w{worker_id} MISSING SOURCES (0% contribution): {failed}") |
| if not streams: |
| log.error(f"[stream] rank={self.rank}.w{worker_id} NO SOURCES OPENED — worker is dead") |
| return |
|
|
| rng = np.random.default_rng(shuffle_seed) |
| iters = [iter(s[0]) for s in streams] |
| probs = np.array([s[4] for s in streams], dtype=np.float64); probs /= probs.sum() |
| consumed = np.zeros(len(iters), dtype=np.float64) |
| if worker_id == 0 and self.rank == 0: |
| log.info("[stream] target TOKEN mix (deficit-scheduled):") |
| for s, p in zip(streams, probs): |
| log.info(f" {s[2]:55s} {p*100:5.1f}%") |
|
|
| buf: List[int] = [] |
| segs: List[List[int]] = [] |
| pos = 0 |
| need = self.max_len * self.batch_size |
|
|
| while not self._stop.is_set(): |
| |
| deficit = (consumed + 1.0) / probs |
| idx = int(np.argmin(deficit * rng.uniform(0.9, 1.1, size=len(iters)))) |
| _, text_field, repo_id, split, _w, config_name = streams[idx] |
| try: |
| row = next(iters[idx]) |
| except StopIteration: |
| streams[idx][0] = _open_source_stream( |
| repo_id, split, shard_index, self.total_shards, |
| shuffle_buffer=self.cfg.shuffle_buffer, shuffle_seed=shuffle_seed + 1, |
| config_name=config_name, text_field=text_field) |
| iters[idx] = iter(streams[idx][0]); continue |
| except Exception as e: |
| log.warning(f"[stream] rank={self.rank}.w{worker_id} read error on {repo_id}: {str(e)[:300]}") |
| consumed[idx] += need |
| time.sleep(1.0); continue |
|
|
| text = _extract_text(row, text_field, repo_id) |
| del row |
| if not text: |
| continue |
| try: |
| ids = self.tok.encode(text, add_special_tokens=False).ids |
| except Exception: |
| continue |
| del text |
| ids.append(self.eos_id) |
| n = len(ids) |
| buf.extend(ids) |
| del ids |
| segs.append([idx, n]) |
| consumed[idx] += n |
|
|
| while len(buf) - pos >= need: |
| if self._stop.is_set(): |
| return |
| |
| counts: dict = {} |
| remaining = need |
| while remaining > 0 and segs: |
| s = segs[0] |
| take = min(s[1], remaining) |
| counts[s[0]] = counts.get(s[0], 0) + take |
| s[1] -= take; remaining -= take |
| if s[1] == 0: |
| segs.pop(0) |
| maj = max(counts, key=counts.get) if counts else idx |
| arr = np.array(buf[pos:pos + need], dtype=np.int64).reshape(self.batch_size, self.max_len) |
| pos += need |
| self._q.put((torch.from_numpy(arr), streams[maj][2])) |
| if pos: |
| del buf[:pos]; pos = 0 |
| except Exception as e: |
| log.error(f"[stream] rank={self.rank}.w{worker_id} fetch loop crashed: {str(e)[:300]}") |
|
|
| def __iter__(self) -> Iterator[Tuple[torch.Tensor, str]]: |
| return self |
|
|
| def __next__(self) -> Tuple[torch.Tensor, str]: |
| while not self._stop.is_set(): |
| try: |
| return self._q.get(timeout=60) |
| except queue.Empty: |
| log.warning(f"[stream] rank={self.rank} queue empty — waiting for data … ({host_mem_str()})") |
| raise StopIteration |
|
|
| def close(self): |
| self._stop.set() |
| try: |
| while True: self._q.get_nowait() |
| except queue.Empty: |
| pass |
| for t in self._workers: |
| t.join(timeout=5) |
|
|
| def build_val_loader(cfg: Config) -> Optional[DataLoader]: |
| if not HAS_DATASETS: |
| return None |
| tok = get_tokenizer(cfg) |
| repo_id, split, text_field, _, config_name = max(cfg.dataset_sources, key=lambda s: s[3]) |
| try: |
| ds = _open_source_stream(repo_id, split, 0, 1, shuffle_buffer=0, |
| config_name=config_name, text_field=text_field) |
| except Exception as e: |
| log.warning(f"[val] could not open {repo_id}: {str(e)[:300]}") |
| return None |
|
|
| eos_id = _resolve_eos(tok) |
| buf: List[int] = [] |
| rows = [] |
| n_val_seqs = 128 |
| try: |
| for row in ds: |
| text = _extract_text(row, text_field, repo_id) |
| if not text: |
| continue |
| ids = tok.encode(text, add_special_tokens=False).ids |
| ids.append(eos_id) |
| buf.extend(ids) |
| while len(buf) >= cfg.max_len: |
| rows.append(np.array(buf[:cfg.max_len], dtype=np.int64)) |
| buf = buf[cfg.max_len:] |
| if len(rows) >= n_val_seqs: |
| break |
| if len(rows) >= n_val_seqs: |
| break |
| except Exception as e: |
| log.warning(f"[val] stream error: {str(e)[:300]}") |
| del ds |
|
|
| if not rows: |
| log.warning(f"[val] got no validation rows from {repo_id}") |
| return None |
| data = np.stack(rows, axis=0) |
|
|
| class _ValDS(Dataset): |
| def __len__(self): return len(data) |
| def __getitem__(self, i): return torch.from_numpy(data[i]) |
|
|
| return DataLoader(_ValDS(), batch_size=min(cfg.micro_batch, 4), |
| shuffle=False, num_workers=0, pin_memory=True, drop_last=True) |
|
|
| |
| |
| |
| _ckpt_thread: Optional[threading.Thread] = None |
|
|
| def _async_save_and_upload(payload: list, step, epoch, cfg_dict, loss): |
| name = f"g1_s{SESSION_ID:03d}_step{step:07d}" |
| local = os.path.join(TEMP_CKPT_DIR, f"{name}.pt") |
| try: |
| t0 = time.time() |
| model_sd, muon_sd, adamw_sd = payload.pop() |
| torch.save({'model': model_sd, 'muon': muon_sd, 'adamw': adamw_sd, |
| 'step': step, 'epoch': epoch, 'loss': loss, 'config': cfg_dict}, local) |
| del model_sd, muon_sd, adamw_sd |
| gc.collect() |
| log.info(f"[ckpt-async] saved in {time.time()-t0:.1f}s, heap freed ({host_mem_str()}), uploading…") |
| upload_to_hf(local, f"{name}.pt") |
| log.info(f"[ckpt-async] step={step} uploaded ({time.time()-t0:.1f}s total)") |
| except Exception as e: |
| log.error(f"[ckpt-async] failed: {e}") |
| finally: |
| try: os.remove(local) |
| except OSError: pass |
|
|
| def save_ckpt(model, muon, adamw, step, epoch, cfg, loss, is_master: bool): |
| global _ckpt_thread |
| if is_master and _ckpt_thread is not None and _ckpt_thread.is_alive(): |
| log.warning("[ckpt] previous checkpoint still in flight — waiting before gathering another") |
| _ckpt_thread.join() |
| opts = StateDictOptions(full_state_dict=True, cpu_offload=True) |
| model_sd = get_model_state_dict(model, options=opts) |
| try: muon_sd = get_optimizer_state_dict(model, muon, options=opts) |
| except Exception as e: |
| log.warning(f"[ckpt] could not gather muon state: {e}"); muon_sd = {} |
| try: adamw_sd = get_optimizer_state_dict(model, adamw, options=opts) |
| except Exception as e: |
| log.warning(f"[ckpt] could not gather adamw state: {e}"); adamw_sd = {} |
| if not is_master: |
| del model_sd, muon_sd, adamw_sd |
| return |
| payload = [(model_sd, muon_sd, adamw_sd)] |
| del model_sd, muon_sd, adamw_sd |
| _ckpt_thread = threading.Thread(target=_async_save_and_upload, |
| args=(payload, step, epoch, asdict(cfg), loss), daemon=True) |
| _ckpt_thread.start() |
| log.info(f"[ckpt] step={step} gathered ({host_mem_str()}), saving+uploading in background") |
|
|
| def _find_latest_ckpt(): |
| for sid in range(SESSION_ID, 0, -1): |
| repo = f"{REPO_PREFIX}{sid:03d}" |
| try: |
| files = hf_api.list_repo_files(repo_id=repo, repo_type="model", token=HF_TOKEN) |
| except Exception: |
| continue |
| ckpts = sorted([f for f in files if f.endswith(".pt") and "step" in f], |
| key=lambda x: int(x.split("step")[-1].split(".")[0])) |
| if ckpts: |
| return repo, ckpts[-1] |
| return None, None |
|
|
| def load_ckpt(model, muon, adamw, cfg, device, is_master: bool): |
| ckpt = None |
| dl_dir = os.path.join(TEMP_CKPT_DIR, "resume_dl") |
| meta = torch.zeros(3, dtype=torch.float64, device=device) |
| loss_t = torch.zeros(1, dtype=torch.float64, device=device) |
| mismatch_flag = torch.zeros(1, dtype=torch.int32, device=device) |
|
|
| if is_master: |
| repo, ckpt_name = _find_latest_ckpt() |
| if repo is None: |
| log.warning("[ckpt] no checkpoint in this or any earlier session repo — fresh start") |
| else: |
| try: |
| shutil.rmtree(dl_dir, ignore_errors=True) |
| path = hf_hub_download(repo, ckpt_name, local_dir=dl_dir, token=HF_TOKEN) |
| ckpt = torch.load(path, map_location="cpu", weights_only=False, mmap=True) |
| log.info(f"[ckpt] mapped {ckpt_name} ({host_mem_str()})") |
| saved_cfg = ckpt.get('config', {}) |
| mismatches = [f"{k}: ckpt={saved_cfg[k]} vs live={v}" |
| for k, v in cfg.arch_fingerprint().items() |
| if k in saved_cfg and saved_cfg[k] != v] |
| if mismatches: |
| log.error("[ckpt] ARCHITECTURE MISMATCH — refusing to resume: " + "; ".join(mismatches)) |
| mismatch_flag[0] = 1; ckpt = None |
| else: |
| meta[0] = 1.0; meta[1] = float(ckpt['step']); meta[2] = float(ckpt['epoch']) |
| loss_t[0] = float(ckpt['loss']) |
| if repo != HF_MODEL_REPO: |
| log.info(f"[ckpt] resuming from an EARLIER session's repo: {repo}/{ckpt_name}") |
| except Exception as e: |
| log.error(f"[ckpt] FOUND {repo}/{ckpt_name} BUT COULD NOT LOAD IT: {e} — fresh start") |
| ckpt = None |
|
|
| if dist_ready(): |
| dist.broadcast(meta, src=0); dist.broadcast(loss_t, src=0); dist.broadcast(mismatch_flag, src=0) |
| if mismatch_flag.item() > 0: |
| raise RuntimeError("Checkpoint architecture mismatch — see rank 0 log.") |
| if meta[0].item() < 0.5: |
| return 0, 0, float('inf') |
|
|
| opts = StateDictOptions(full_state_dict=True, broadcast_from_rank0=True) |
| set_model_state_dict(model, model_state_dict=(ckpt['model'] if is_master else {}), options=opts) |
| try: |
| set_optimizer_state_dict(model, muon, optim_state_dict=(ckpt['muon'] if is_master else {}), options=opts) |
| except Exception as e: |
| log.warning(f"[ckpt] muon state not restored: {e}") |
| try: |
| set_optimizer_state_dict(model, adamw, optim_state_dict=(ckpt['adamw'] if is_master else {}), options=opts) |
| except Exception as e: |
| log.warning(f"[ckpt] adamw state not restored: {e}") |
|
|
| step, epoch, loss = int(meta[1].item()), int(meta[2].item()), float(loss_t[0].item()) |
| del ckpt |
| gc.collect() |
| if is_master: |
| shutil.rmtree(dl_dir, ignore_errors=True) |
| log.info(f"[ckpt] resumed step={step} loss={loss:.4f} ✅ | {host_mem_str()}") |
| return step, epoch, loss |
|
|
| def save_final(model, cfg, step, epoch, loss, is_master: bool): |
| opts = StateDictOptions(full_state_dict=True, cpu_offload=True) |
| model_sd = get_model_state_dict(model, options=opts) |
| if not is_master: |
| return |
| name = f"g1_final_s{SESSION_ID:03d}_step{step:07d}" |
| mname = f"{name}.safetensors" if HAS_ST else f"{name}.pt" |
| mpath = os.path.join(TEMP_CKPT_DIR, mname) |
| cpath = os.path.join(TEMP_CKPT_DIR, f"{name}_config.json") |
| if HAS_ST: |
| st_save({k: v.contiguous() for k, v in model_sd.items()}, mpath) |
| else: |
| torch.save(model_sd, mpath) |
| del model_sd; gc.collect() |
| with open(cpath, 'w') as f: |
| json.dump({**asdict(cfg), 'step': step, 'epoch': epoch, |
| 'loss': loss, 'arch': 'Smilyai-G1-20B'}, f, indent=2) |
| upload_to_hf(mpath, mname); upload_to_hf(cpath, os.path.basename(cpath)) |
| for p in (mpath, cpath): |
| try: os.remove(p) |
| except OSError: pass |
|
|
| @torch.no_grad() |
| def validate(model, val_loader, device, cfg, n=100): |
| if val_loader is None: |
| return float('nan') |
| was_training = model.training |
| model.eval(); losses = [] |
| for i, batch in enumerate(val_loader): |
| if i >= n: break |
| batch = batch.to(device, non_blocking=True) |
| with torch.amp.autocast('cuda', dtype=cfg.dtype): |
| _, loss = model(batch, batch) |
| lm = getattr(model, '_last_lm_loss', None) |
| lm = lm if lm is not None else loss |
| if lm is not None and torch.isfinite(lm): |
| losses.append(lm.item()) |
| if was_training: model.train() |
| local = float(np.mean(losses)) if losses else float('nan') |
| if math.isnan(local): |
| return local |
| return distributed_mean(local, device) |
|
|
| |
| |
| |
| def train(): |
| if not torch.cuda.is_available(): |
| raise RuntimeError("this script requires CUDA GPUs") |
|
|
| local_rank = int(os.environ.get("LOCAL_RANK", "0")) |
| rank = int(os.environ.get("RANK", "0")) |
| world_size = int(os.environ.get("WORLD_SIZE", "1")) |
| torch.cuda.set_device(local_rank) |
| device = torch.device("cuda", local_rank) |
| if world_size > 1 and not dist_ready(): |
| dist.init_process_group(backend="nccl", init_method="env://", device_id=device, |
| timeout=_dt.timedelta(minutes=20)) |
| is_master = (rank == 0) |
| if not is_master: |
| log.setLevel(logging.WARNING) |
|
|
| torch.manual_seed(42 + rank); np.random.seed(42 + rank); random.seed(42 + rank) |
|
|
| log.info(f"[env] rank={rank}/{world_size} device={device} | " |
| f"GPU={torch.cuda.get_device_name(local_rank)} | VRAM={vram_total_gb():.0f}GB") |
| log.info(f"[env] {host_mem_str()} | work_dir={_WORK}") |
| start_mem_watchdog(rank) |
|
|
| if is_master: |
| ensure_repo() |
| session_banner() |
| _bootstrap_from_hub(METRICS_FILE, os.path.basename(METRICS_FILE)) |
| _bootstrap_from_hub(SAMPLES_FILE, "samples.md") |
| _bootstrap_from_hub(SUMMARY_FILE, "summary.jsonl") |
| if dist_ready(): |
| dist.barrier() |
|
|
| cfg = Config() |
|
|
| if local_rank == 0: |
| try: get_tokenizer(cfg) |
| except Exception as e: log.warning(f"[tokenizer] pre-load failed, will retry lazily: {e}") |
| if dist_ready(): |
| dist.barrier() |
| if local_rank != 0: |
| try: get_tokenizer(cfg) |
| except Exception as e: log.warning(f"[tokenizer] pre-load failed, will retry lazily: {e}") |
|
|
| _prev_dtype = torch.get_default_dtype() |
| torch.set_default_dtype(cfg.dtype) |
| try: |
| model = SmilyaiG1(cfg) |
| finally: |
| torch.set_default_dtype(_prev_dtype) |
| model = model.to(cfg.dtype).to(device) |
| gc.collect() |
| model.init_rope(device) |
| model.force_fp32_balancing_buffers() |
| log.info(f"[env] model on GPU | {vram_str()} | {host_mem_str()}") |
|
|
| model = apply_fp8(model, cfg, is_master) |
| model = apply_fsdp(model, cfg) |
| model = apply_compile(model, cfg, is_master) |
|
|
| muon, adamw = build_optimizers(model, cfg, is_master) |
|
|
| start_step, start_epoch, best_loss = load_ckpt(model, muon, adamw, cfg, device, is_master) |
| if dist_ready(): |
| dist.barrier() |
|
|
| last_val = float('nan') |
| bs = cfg.micro_batch |
|
|
| stream = LiveStreamingDataset(cfg, batch_size=bs, rank=rank, world_size=world_size) |
| val_loader = build_val_loader(cfg) |
|
|
| if is_master: |
| log.info("=" * 70) |
| log.info(f"Smilyai-G1 | {model.count_params()/1e9:.2f}B total params | " |
| f"Session {SESSION_ID} | FSDP2 world={world_size}") |
| log.info(f" micro_batch={bs}/GPU grad_accum={cfg.grad_accum} " |
| f"eff_batch={bs*cfg.grad_accum*world_size} max_len={cfg.max_len}") |
| log.info(f" {cfg.tokens_per_step(bs, world_size)/1e6:.1f}M tok/step | " |
| f"{MAX_HOURS}h budget | streaming=True | compile={cfg.use_compile}") |
| log.info(f" Muon LR={cfg.muon_lr} | resumed at step={start_step} | {host_mem_str()}") |
| log.info(" NOTE: train loss is only comparable within a session — the mix changed. Watch [val].") |
| log.info("=" * 70) |
|
|
| step, epoch = start_step, start_epoch |
| losses, aux_losses = [], [] |
| src_window: collections.deque = collections.deque(maxlen=200) |
| model.train(); model.zero_grad(set_to_none=True) |
| t0 = time.time(); last_ckpt = time.time() |
|
|
| try: |
| record_sample(model, step, is_master) |
| except Exception as e: |
| log.warning(f"[sample] {e}") |
|
|
| accum_n = 0 |
| while not distributed_should_stop(device, is_master, step, cfg.total_steps): |
| try: |
| batch, folder = next(stream) |
| except StopIteration: |
| log.warning(f"[stream] rank={rank} exhausted — sleeping 60s") |
| time.sleep(60); continue |
| except Exception as e: |
| log.error(f"[data] rank={rank} {e}"); time.sleep(5); continue |
|
|
| batch = batch.to(device, non_blocking=True) |
|
|
| try: |
| with torch.amp.autocast('cuda', dtype=cfg.dtype): |
| _, loss = model(batch, batch) |
| loss_s = loss / cfg.grad_accum |
| loss_s.backward() |
| micro_ok = bool(torch.isfinite(loss)) |
| if micro_ok: |
| lm_only = getattr(model, '_last_lm_loss', loss) |
| aux_only = getattr(model, '_last_aux_loss', None) |
| lm_f = float(lm_only) |
| losses.append(lm_f) |
| aux_losses.append(float(aux_only) if aux_only is not None else 0.0) |
| src_window.append((folder, lm_f)) |
| del loss, loss_s |
| except torch.OutOfMemoryError: |
| log.error(f"[oom] rank={rank} step={step} CUDA OOM | {vram_str()} | {host_mem_str()}") |
| log.error(torch.cuda.memory_summary(abbreviated=True)) |
| raise |
|
|
| if not all_ok(micro_ok, device): |
| if is_master: log.error(f"[skip] step={step} non-finite loss on >=1 rank") |
| model.zero_grad(set_to_none=True); accum_n = 0 |
| continue |
|
|
| accum_n += 1 |
| if accum_n < cfg.grad_accum: |
| continue |
|
|
| mlr = cosine_lr(step, cfg.warmup, cfg.total_steps, cfg.muon_lr, cfg.muon_min_lr) |
| alr = cosine_lr(step, cfg.warmup, cfg.total_steps, cfg.adamw_lr, cfg.adamw_min_lr) |
| for g in muon.param_groups: g['lr'] = mlr |
| for g in adamw.param_groups: g['lr'] = alr |
|
|
| norm = torch.nn.utils.clip_grad_norm_(model.parameters(), cfg.grad_clip) |
| if isinstance(norm, DTensor): |
| norm = norm.full_tensor() |
| if not torch.isfinite(norm): |
| if is_master: log.error("[nan] grad-norm non-finite — skipping step") |
| model.zero_grad(set_to_none=True); accum_n = 0; continue |
|
|
| muon.step(); adamw.step(); model.zero_grad(set_to_none=True) |
|
|
| step += 1 |
| model.set_step(step) |
| accum_n = 0 |
| if len(losses) > 500: losses = losses[-500:] |
| if len(aux_losses) > 500: aux_losses = aux_losses[-500:] |
|
|
| if step % cfg.bias_update_every == 0: |
| model.update_expert_bias() |
|
|
| if step % cfg.log_every == 0 and losses: |
| avg = distributed_mean(float(np.mean(losses[-50:])), device) |
| avg_aux = distributed_mean(float(np.mean(aux_losses[-50:])), device) if aux_losses else 0.0 |
| _step_clock.append((step, time.time())) |
| if len(_step_clock) > 300: _step_clock.pop(0) |
| sph = _real_steps_per_hour() |
| tps = (sph * cfg.tokens_per_step(bs, world_size) / 3600) if sph else \ |
| (max(step - start_step, 1) * cfg.tokens_per_step(bs, world_size) / max(time.time() - t0, 1)) |
| if is_master: |
| |
| by_src: dict = collections.defaultdict(list) |
| for s, l in src_window: by_src[s].append(l) |
| n_tot = max(len(src_window), 1) |
| per_src = " ".join(f"{_short_src(s)}:{np.mean(v):.2f}({100*len(v)/n_tot:.0f}%)" |
| for s, v in sorted(by_src.items(), key=lambda kv: -len(kv[1]))) |
| log_metrics(step=step, loss=avg, aux=avg_aux, tok_s=tps, folder=folder, |
| per_source={s: [float(np.mean(v)), len(v) / n_tot] for s, v in by_src.items()}) |
| sl = sessions_left(step, cfg.total_steps) |
| suffix = f" | ~{sl} more sessions" if sl is not None else "" |
| log.info(f"step {step:06d} | ep {epoch+1} | lm {avg:.4f} | aux {avg_aux:.4f} | " |
| f"ppl {math.exp(min(avg,20)):.1f} | {tps/1e3:.1f}K tok/s | " |
| f"{vram_str()} | {remaining_h():.1f}h left{suffix}") |
| log.info(f" [mix] {per_src}") |
| if step % (cfg.log_every * 10) == 0: |
| log.info(f" [{host_mem_str()}]") |
|
|
| if step % cfg.eval_every == 0: |
| vl = validate(model, val_loader, device, cfg) |
| if is_master and vl == vl: |
| marker = " *NEW BEST*" if vl < best_loss else "" |
| if vl < best_loss: best_loss = vl |
| last_val = vl |
| log_metrics(step=step, val_loss=vl) |
| log.info(f" [val] loss={vl:.4f} ppl={math.exp(min(vl,20)):.1f}{marker}") |
| dead, total_dead, capped, total_capped = model.dead_expert_report() |
| total_experts = cfg.n_experts * cfg.n_layers |
| if total_dead > 0: |
| log.info(f" [experts] dead={total_dead}/{total_experts}") |
| else: |
| log.info(f" [experts] all {total_experts} experts alive ✅") |
| if total_capped > 0: |
| log.info(f" [experts] bias-capped={total_capped}/{total_experts}") |
| try: |
| record_sample(model, step, is_master) |
| except Exception as e: |
| log.warning(f"[sample] {e}") |
| if dist_ready(): |
| dist.barrier() |
|
|
| local_due = (step % cfg.ckpt_every == 0) or ((time.time() - last_ckpt) > 1800) |
| if broadcast_flag(local_due if is_master else False, device): |
| save_ckpt(model, muon, adamw, step, epoch, cfg, losses[-1] if losses else 0.0, is_master) |
| if is_master: |
| update_progress_md(cfg, step, epoch, |
| float(np.mean(losses[-50:])) if losses else None, last_val) |
| make_loss_chart(); upload_metrics() |
| last_ckpt = time.time() |
|
|
| log.info(f"[rank {rank}] DONE training loop") |
| stream.close() |
|
|
| if is_master and _ckpt_thread is not None and _ckpt_thread.is_alive(): |
| log.info("[ckpt] waiting for final in-flight checkpoint upload to finish…") |
| _ckpt_thread.join() |
|
|
| vm = validate(model, val_loader, device, cfg, n=300) |
| if vm != vm: |
| vm = losses[-1] if losses else 0.0 |
| save_final(model, cfg, step, epoch, vm, is_master) |
| if is_master: |
| try: |
| update_progress_md(cfg, step, epoch, float(np.mean(losses[-50:])) if losses else None, vm) |
| make_loss_chart(); upload_metrics() |
| except Exception as e: |
| log.warning(f"[motiv] final refresh failed: {e}") |
| log.info(f"Steps={step:,} | Epochs={epoch+1} | Time={elapsed_h():.2f}h | Final val={vm:.4f}") |
|
|
| if dist_ready(): |
| dist.barrier() |
| dist.destroy_process_group() |
|
|
|
|
| def _spawn_worker(local_rank: int, world_size: int): |
| os.environ["LOCAL_RANK"] = str(local_rank) |
| os.environ["RANK"] = str(local_rank) |
| os.environ["WORLD_SIZE"] = str(world_size) |
| train() |
|
|
|
|
| def launch(): |
| if "RANK" in os.environ and "WORLD_SIZE" in os.environ: |
| train() |
| return |
| world_size = torch.cuda.device_count() |
| if world_size < 1: |
| raise RuntimeError("No CUDA GPUs are visible") |
| expected_world = int(os.environ.get("EXPECTED_WORLD_SIZE", str(world_size))) |
| if world_size != expected_world: |
| raise RuntimeError(f"Expected {expected_world} visible GPUs, found {world_size}; " |
| "refusing to run with the wrong allocation") |
| os.environ.setdefault("MASTER_ADDR", "127.0.0.1") |
| os.environ.setdefault("MASTER_PORT", "29500") |
| os.environ.setdefault("TORCH_NCCL_ASYNC_ERROR_HANDLING", "1") |
| mp.spawn(_spawn_worker, args=(world_size,), nprocs=world_size, join=True) |
|
|
|
|
| if __name__ == "__main__": |
| launch() |
