Upload folder using huggingface_hub

model.py

@@ -0,0 +1,355 @@
+"""
+SID-GPT v2 - LLaMA-style transformer for SID register prediction.
+
+258-token vocabulary (0-255 byte values, 256=SEP, 257=FRAME).
+Predicts next SID register token given sequence of previous tokens.
+"""
+
+import math
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+@dataclass
+class ModelConfig:
+    n_embd: int = 512
+    n_layer: int = 8
+    n_head: int = 8
+    n_kv_head: int = 2
+    intermediate_size: int = 1408
+    block_size: int = 4096
+    vocab_size: int = 258
+    rope_theta: float = 10000.0
+    bias: bool = False
+    dropout: float = 0.0
+
+    @staticmethod
+    def small() -> "ModelConfig":
+        return ModelConfig(
+            n_embd=512,
+            n_layer=8,
+            n_head=8,
+            n_kv_head=2,
+            intermediate_size=1408,
+        )
+
+    @staticmethod
+    def large() -> "ModelConfig":
+        return ModelConfig(
+            n_embd=1024,
+            n_layer=24,
+            n_head=16,
+            n_kv_head=4,
+            intermediate_size=2816,
+        )
+
+
+class RMSNorm(nn.Module):
+    def __init__(self, dim: int, eps: float = 1e-6):
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(dim))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        # Norm in float32 for stability
+        norm_x = x.float()
+        norm_x = norm_x * torch.rsqrt(
+            norm_x.pow(2).mean(-1, keepdim=True) + self.eps
+        )
+        return (norm_x * self.weight).to(x.dtype)
+
+
+def precompute_rope_freqs(
+    dim: int,
+    max_seq_len: int,
+    theta: float = 10000.0,
+    device: Optional[torch.device] = None,
+) -> torch.Tensor:
+    """
+    Precompute complex-valued RoPE frequency table.
+
+    For each position p and frequency index i:
+      freq_i = 1 / (theta^(2i/dim))
+      rope[p, i] = exp(j * p * freq_i)
+
+    Returns complex tensor of shape (max_seq_len, dim//2).
+    """
+    freqs = 1.0 / (
+        theta
+        ** (torch.arange(0, dim, 2, device=device).float() / dim)
+    )
+    t = torch.arange(max_seq_len, device=device).float()
+    freqs = torch.outer(t, freqs)
+    return torch.polar(torch.ones_like(freqs), freqs)
+
+
+def apply_rope(
+    xq: torch.Tensor,
+    xk: torch.Tensor,
+    freqs: torch.Tensor,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Apply rotary embeddings to Q and K via complex multiplication.
+
+    Reshapes last dim of Q/K into pairs -> complex,
+    multiplies by precomputed freqs, converts back to real.
+    """
+    xq_c = torch.view_as_complex(
+        xq.float().reshape(*xq.shape[:-1], -1, 2)
+    )
+    xk_c = torch.view_as_complex(
+        xk.float().reshape(*xk.shape[:-1], -1, 2)
+    )
+    # xq_c/xk_c: (B, heads, T, head_dim//2)
+    # freqs: (T, head_dim//2) -> (1, 1, T, head_dim//2)
+    freqs = freqs.unsqueeze(0).unsqueeze(1)
+    xq_out = torch.view_as_real(xq_c * freqs).flatten(-2)
+    xk_out = torch.view_as_real(xk_c * freqs).flatten(-2)
+    return xq_out.to(xq.dtype), xk_out.to(xk.dtype)
+
+
+class GQAAttention(nn.Module):
+    """
+    Grouped-Query Attention: fewer KV heads than Q heads.
+    Group size = n_head / n_kv_head. KV heads are expanded
+    via repeat_interleave to match Q head count.
+    """
+
+    def __init__(self, config: ModelConfig):
+        super().__init__()
+        self.n_head = config.n_head
+        self.n_kv_head = config.n_kv_head
+        self.head_dim = config.n_embd // config.n_head
+        self.n_rep = config.n_head // config.n_kv_head
+        self.block_size = config.block_size
+
+        self.q_proj = nn.Linear(
+            config.n_embd,
+            config.n_head * self.head_dim,
+            bias=config.bias,
+        )
+        self.k_proj = nn.Linear(
+            config.n_embd,
+            config.n_kv_head * self.head_dim,
+            bias=config.bias,
+        )
+        self.v_proj = nn.Linear(
+            config.n_embd,
+            config.n_kv_head * self.head_dim,
+            bias=config.bias,
+        )
+        self.o_proj = nn.Linear(
+            config.n_embd,
+            config.n_embd,
+            bias=config.bias,
+        )
+        self.attn_dropout = nn.Dropout(config.dropout)
+        self.resid_dropout = nn.Dropout(config.dropout)
+
+        # KV cache buffers (populated during inference)
+        self.cache_k: Optional[torch.Tensor] = None
+        self.cache_v: Optional[torch.Tensor] = None
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        freqs: torch.Tensor,
+        start_pos: Optional[int] = None,
+    ) -> torch.Tensor:
+        B, T, _ = x.shape
+
+        q = self.q_proj(x)
+        k = self.k_proj(x)
+        v = self.v_proj(x)
+
+        q = q.view(B, T, self.n_head, self.head_dim)
+        k = k.view(B, T, self.n_kv_head, self.head_dim)
+        v = v.view(B, T, self.n_kv_head, self.head_dim)
+
+        # Transpose to (B, heads, T, head_dim)
+        q = q.transpose(1, 2)
+        k = k.transpose(1, 2)
+        v = v.transpose(1, 2)
+
+        # Apply RoPE to Q and K
+        q, k = apply_rope(q, k, freqs)
+
+        if start_pos is not None:
+            # Inference with KV-cache
+            if self.cache_k is None or start_pos == 0:
+                self.cache_k = torch.zeros(
+                    B, self.n_kv_head, self.block_size,
+                    self.head_dim,
+                    device=x.device, dtype=x.dtype,
+                )
+                self.cache_v = torch.zeros_like(self.cache_k)
+
+            end_pos = start_pos + T
+            self.cache_k[:, :, start_pos:end_pos, :] = k
+            self.cache_v[:, :, start_pos:end_pos, :] = v
+
+            k = self.cache_k[:, :, :end_pos, :]
+            v = self.cache_v[:, :, :end_pos, :]
+
+        # Expand KV heads to match Q heads
+        if self.n_rep > 1:
+            k = k.repeat_interleave(self.n_rep, dim=1)
+            v = v.repeat_interleave(self.n_rep, dim=1)
+
+        is_causal = start_pos is None or start_pos == 0
+        if start_pos is not None and start_pos > 0:
+            # Single-token decode: no causal mask needed
+            # (attending to all cached positions)
+            is_causal = False
+
+        y = F.scaled_dot_product_attention(
+            q, k, v,
+            dropout_p=(
+                self.attn_dropout.p if self.training else 0.0
+            ),
+            is_causal=is_causal,
+        )
+
+        y = y.transpose(1, 2).contiguous().view(B, T, -1)
+        return self.resid_dropout(self.o_proj(y))
+
+
+class SwiGLUFFN(nn.Module):
+    """
+    SwiGLU feed-forward: down(silu(gate(x)) * up(x))
+    Three projections, no bias.
+    """
+
+    def __init__(self, config: ModelConfig):
+        super().__init__()
+        self.gate_proj = nn.Linear(
+            config.n_embd,
+            config.intermediate_size,
+            bias=config.bias,
+        )
+        self.up_proj = nn.Linear(
+            config.n_embd,
+            config.intermediate_size,
+            bias=config.bias,
+        )
+        self.down_proj = nn.Linear(
+            config.intermediate_size,
+            config.n_embd,
+            bias=config.bias,
+        )
+        self.dropout = nn.Dropout(config.dropout)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.dropout(
+            self.down_proj(
+                F.silu(self.gate_proj(x)) * self.up_proj(x)
+            )
+        )
+
+
+class TransformerBlock(nn.Module):
+    """Pre-norm residual: x + attn(norm(x)), h + ffn(norm(h))"""
+
+    def __init__(self, config: ModelConfig):
+        super().__init__()
+        self.attn_norm = RMSNorm(config.n_embd)
+        self.attn = GQAAttention(config)
+        self.ffn_norm = RMSNorm(config.n_embd)
+        self.ffn = SwiGLUFFN(config)
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        freqs: torch.Tensor,
+        start_pos: Optional[int] = None,
+    ) -> torch.Tensor:
+        h = x + self.attn(self.attn_norm(x), freqs, start_pos)
+        return h + self.ffn(self.ffn_norm(h))
+
+
+class Transformer(nn.Module):
+    def __init__(self, config: ModelConfig):
+        super().__init__()
+        self.config = config
+
+        self.tok_emb = nn.Embedding(config.vocab_size, config.n_embd)
+        self.drop = nn.Dropout(config.dropout)
+        self.blocks = nn.ModuleList(
+            [TransformerBlock(config) for _ in range(config.n_layer)]
+        )
+        self.norm = RMSNorm(config.n_embd)
+        self.lm_head = nn.Linear(
+            config.n_embd, config.vocab_size, bias=False
+        )
+
+        # Weight tying
+        self.lm_head.weight = self.tok_emb.weight
+
+        # Precompute RoPE frequencies
+        head_dim = config.n_embd // config.n_head
+        self.register_buffer(
+            "rope_freqs",
+            precompute_rope_freqs(
+                head_dim, config.block_size, config.rope_theta
+            ),
+            persistent=False,
+        )
+
+        self.apply(self._init_weights)
+        # Scale residual projections
+        res_scale = 1.0 / math.sqrt(2 * config.n_layer)
+        for block in self.blocks:
+            block.attn.o_proj.weight.data *= res_scale
+            block.ffn.down_proj.weight.data *= res_scale
+
+    def _init_weights(self, module: nn.Module):
+        if isinstance(module, nn.Linear):
+            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
+            if module.bias is not None:
+                torch.nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Embedding):
+            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
+
+    def forward(
+        self,
+        idx: torch.Tensor,
+        targets: Optional[torch.Tensor] = None,
+        start_pos: Optional[int] = None,
+    ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:
+        B, T = idx.shape
+        assert T <= self.config.block_size, (
+            f"Sequence length {T} exceeds block_size "
+            f"{self.config.block_size}"
+        )
+
+        x = self.drop(self.tok_emb(idx))
+
+        if start_pos is not None:
+            freqs = self.rope_freqs[start_pos : start_pos + T]
+        else:
+            freqs = self.rope_freqs[:T]
+
+        for block in self.blocks:
+            x = block(x, freqs, start_pos)
+
+        x = self.norm(x)
+        logits = self.lm_head(x)
+
+        loss = None
+        if targets is not None:
+            loss = F.cross_entropy(
+                logits.view(-1, logits.size(-1)),
+                targets.view(-1),
+            )
+
+        return logits, loss
+
+    def count_params(self) -> int:
+        # Subtract lm_head since it's tied
+        n = sum(p.numel() for p in self.parameters())
+        n -= self.lm_head.weight.numel()
+        return n

sample.py

@@ -0,0 +1,258 @@
+"""
+SID-GPT v2 generation with KV-cache.
+
+Generates SID register sequences token-by-token,
+outputs uint16 LE binary playable by sidgpt-play.
+"""
+
+import argparse
+import os
+import struct
+import sys
+
+os.environ["TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL"] = "1"
+
+import numpy as np
+import torch
+
+from model import ModelConfig, Transformer
+
+TOKEN_SEP = 256
+TOKEN_FRAME = 257
+TOKENS_PER_FRAME = 26
+
+
+def load_checkpoint(path, device):
+    ckpt = torch.load(
+        path, map_location=device, weights_only=False
+    )
+    config = ckpt["config"]
+    model = Transformer(config).to(device)
+    model.load_state_dict(ckpt["model"])
+    model.eval()
+    return model, config
+
+
+def build_prompt(seed_file, num_seed_frames, device):
+    """
+    Build prompt tensor. Unconditional = one SEP frame.
+    Style-seeded = SEP frame + N frames from a .bin file.
+    """
+    prompt = [TOKEN_SEP] * TOKENS_PER_FRAME
+
+    if seed_file is not None:
+        raw = np.fromfile(seed_file, dtype=np.uint16)
+        tokens = raw.tolist()
+
+        # Find first data frame after initial SEP frames
+        pos = 0
+        while pos < len(tokens):
+            if tokens[pos] != TOKEN_SEP:
+                break
+            pos += 1
+
+        frames_added = 0
+        while pos < len(tokens) and frames_added < num_seed_frames:
+            if tokens[pos] == TOKEN_SEP:
+                pos += TOKENS_PER_FRAME
+                continue
+            if tokens[pos] == TOKEN_FRAME:
+                end = pos + TOKENS_PER_FRAME
+                if end <= len(tokens):
+                    prompt.extend(tokens[pos:end])
+                    frames_added += 1
+                pos = end
+            else:
+                pos += 1
+
+        print(f"[SEED] {frames_added} frames from {seed_file}")
+
+    return torch.tensor([prompt], dtype=torch.long, device=device)
+
+
+def _reset_kv_cache(model):
+    for block in model.blocks:
+        block.attn.cache_k = None
+        block.attn.cache_v = None
+
+
+def _sample_token(next_logits, temperature, top_k):
+    """Sample one token from logits with temp + top-k."""
+    if temperature <= 0:
+        return torch.argmax(next_logits, dim=-1, keepdim=True)
+
+    scaled = next_logits / temperature
+    if top_k > 0 and top_k < scaled.shape[-1]:
+        v, _ = torch.topk(scaled, top_k)
+        threshold = v[:, -1].unsqueeze(-1)
+        scaled = scaled.masked_fill(
+            scaled < threshold, float("-inf")
+        )
+    probs = torch.softmax(scaled, dim=-1)
+    return torch.multinomial(probs, num_samples=1)
+
+
+@torch.no_grad()
+def generate(
+    model,
+    prompt,
+    num_tokens,
+    temperature=1.0,
+    top_k=50,
+    device="cpu",
+):
+    """
+    Autoregressive generation with KV-cache and sliding
+    window. When the cache fills up (cur_pos == block_size),
+    keeps the last 75% of tokens (frame-aligned), resets
+    the cache, re-prefills, and continues. RoPE encodes
+    relative positions so resetting absolute pos is safe.
+    """
+    block_size = model.config.block_size
+    keep_ratio = 0.75
+    keep_len = int(block_size * keep_ratio)
+    keep_len = (keep_len // TOKENS_PER_FRAME) * TOKENS_PER_FRAME
+
+    prompt_list = prompt[0].tolist()
+    all_tokens = list(prompt_list)
+
+    if len(prompt_list) > block_size:
+        print(
+            f"[WARN] Prompt ({len(prompt_list)}) exceeds "
+            f"block_size ({block_size}), truncating"
+        )
+        prompt_list = prompt_list[-block_size:]
+        all_tokens = list(prompt_list)
+
+    # Prefill
+    inp = torch.tensor(
+        [prompt_list], dtype=torch.long, device=device
+    )
+    logits, _ = model(inp, start_pos=0)
+    next_logits = logits[:, -1, :]
+    cur_pos = len(prompt_list)
+    slide_count = 0
+
+    generated = []
+    for i in range(num_tokens):
+        # Sliding window: reset cache when full
+        if cur_pos >= block_size:
+            slide_count += 1
+            window = all_tokens[-keep_len:]
+            _reset_kv_cache(model)
+            inp = torch.tensor(
+                [window], dtype=torch.long, device=device
+            )
+            logits, _ = model(inp, start_pos=0)
+            next_logits = logits[:, -1, :]
+            cur_pos = keep_len
+            print(
+                f"[SLIDE] #{slide_count} at token {i}, "
+                f"kept {keep_len} tokens, "
+                f"generated {len(generated)} so far"
+            )
+
+        idx = _sample_token(next_logits, temperature, top_k)
+        tok = idx.item()
+        generated.append(tok)
+        all_tokens.append(tok)
+
+        # Decode step with KV-cache
+        logits, _ = model(idx, start_pos=cur_pos)
+        next_logits = logits[:, -1, :]
+        cur_pos += 1
+
+    return generated
+
+
+def write_output(tokens, output_path):
+    """Write uint16 LE binary, directly playable by sidgpt-play."""
+    data = struct.pack(f"<{len(tokens)}H", *tokens)
+    if output_path == "-":
+        sys.stdout.buffer.write(data)
+    else:
+        with open(output_path, "wb") as f:
+            f.write(data)
+        print(f"[OUT] Wrote {len(tokens)} tokens to {output_path}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="SID-GPT v2 generation"
+    )
+    parser.add_argument(
+        "--checkpoint", type=str, required=True,
+    )
+    parser.add_argument("--num-frames", type=int, default=500)
+    parser.add_argument("--temperature", type=float, default=0.9)
+    parser.add_argument("--top-k", type=int, default=50)
+    parser.add_argument("--seed", type=int, default=None)
+    parser.add_argument(
+        "--output", type=str, default="generated.bin"
+    )
+    parser.add_argument("--device", type=str, default="auto")
+    parser.add_argument("--seed-file", type=str, default=None)
+    parser.add_argument(
+        "--seed-frames", type=int, default=10,
+        help="Number of frames to use from seed file",
+    )
+    args = parser.parse_args()
+
+    if args.device == "auto":
+        if torch.cuda.is_available():
+            device = "cuda"
+        elif (
+            hasattr(torch.backends, "mps")
+            and torch.backends.mps.is_available()
+        ):
+            device = "mps"
+        else:
+            device = "cpu"
+    else:
+        device = args.device
+
+    if args.seed is not None:
+        torch.manual_seed(args.seed)
+
+    print(f"[INIT] Device: {device}")
+
+    model, config = load_checkpoint(args.checkpoint, device)
+    print(
+        f"[MODEL] {config.n_layer}L/{config.n_head}H/"
+        f"{config.n_embd}D, "
+        f"{model.count_params():,} params"
+    )
+
+    prompt = build_prompt(args.seed_file, args.seed_frames, device)
+    prompt_tokens = prompt.shape[1]
+    num_tokens = args.num_frames * TOKENS_PER_FRAME
+    print(
+        f"[GEN] Prompt: {prompt_tokens} tokens, "
+        f"generating {num_tokens} tokens "
+        f"({args.num_frames} frames)"
+    )
+
+    generated = generate(
+        model,
+        prompt,
+        num_tokens,
+        temperature=args.temperature,
+        top_k=args.top_k,
+        device=device,
+    )
+
+    all_tokens = prompt[0].tolist() + generated
+    write_output(all_tokens, args.output)
+
+    # Stats
+    n_sep = sum(1 for t in all_tokens if t == TOKEN_SEP)
+    n_frame = sum(1 for t in all_tokens if t == TOKEN_FRAME)
+    n_data = sum(1 for t in all_tokens if t < 256)
+    print(
+        f"[STATS] Total: {len(all_tokens)} tokens "
+        f"(SEP={n_sep}, FRAME={n_frame}, data={n_data})"
+    )
+
+
+if __name__ == "__main__":
+    main()

train.py

@@ -0,0 +1,481 @@
+"""
+SID-GPT v2 training script.
+
+nanoGPT-style training loop with frame-aligned batch sampling,
+cosine LR schedule, gradient accumulation, and AMP support.
+Supports single-GPU and multi-GPU (DDP via torchrun).
+"""
+
+import argparse
+import math
+import os
+import struct
+import time
+from contextlib import nullcontext
+
+import numpy as np
+import torch
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel as DDP
+
+from model import ModelConfig, Transformer
+
+TOKEN_SEP = 256
+TOKEN_FRAME = 257
+TOKENS_PER_FRAME = 26
+BYTES_PER_FRAME = 25
+
+
+def setup_ddp():
+    """
+    Auto-detect DDP: torchrun sets RANK/LOCAL_RANK env vars.
+    Returns (rank, local_rank, world_size, is_ddp).
+    Without torchrun, returns (0, 0, 1, False).
+    """
+    if "RANK" not in os.environ:
+        return 0, 0, 1, False
+    rank = int(os.environ["RANK"])
+    local_rank = int(os.environ["LOCAL_RANK"])
+    world_size = int(os.environ["WORLD_SIZE"])
+    torch.cuda.set_device(local_rank)
+    dist.init_process_group(backend="nccl")
+    return rank, local_rank, world_size, True
+
+
+def get_device(requested: str) -> str:
+    if requested != "auto":
+        return requested
+    if torch.cuda.is_available():
+        return "cuda"
+    if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+        return "mps"
+    return "cpu"
+
+
+def get_dtype(requested: str, device: str) -> torch.dtype:
+    if requested == "bfloat16":
+        if device == "cuda" and torch.cuda.is_bf16_supported():
+            return torch.bfloat16
+        print("[WARN] bfloat16 not supported, falling back to float16")
+        return torch.float16
+    if requested == "float16":
+        return torch.float16
+    return torch.float32
+
+
+def load_data(path: str, device: str) -> torch.Tensor:
+    raw = np.fromfile(path, dtype=np.uint16)
+    print(f"[DATA] Loaded {len(raw)} tokens from {path}")
+    return torch.from_numpy(raw.astype(np.int64)).to(device)
+
+
+def generate_synth_data(device: str) -> torch.Tensor:
+    """
+    Generate synthetic training data: ~20 short songs with
+    deterministic patterns (ascending frequencies, simple ADSR)
+    for end-to-end pipeline testing without HVSC data.
+    """
+    tokens = []
+    rng = np.random.RandomState(42)
+
+    for song_idx in range(20):
+        # SEP frame
+        tokens.extend([TOKEN_SEP] * TOKENS_PER_FRAME)
+
+        num_frames = 80 + song_idx * 5
+        base_freq = 1000 + song_idx * 200
+
+        for f in range(num_frames):
+            tokens.append(TOKEN_FRAME)
+            regs = [0] * BYTES_PER_FRAME
+
+            # Voice 1: ascending frequency
+            freq = (base_freq + f * 50) & 0xFFFF
+            regs[0] = freq & 0xFF
+            regs[1] = (freq >> 8) & 0xFF
+            # Pulse width
+            regs[2] = 0x00
+            regs[3] = 0x08
+            # Control: gate on, triangle
+            regs[4] = 0x11 if f < num_frames - 5 else 0x10
+            # ADSR
+            regs[5] = 0x09
+            regs[6] = 0x00
+
+            # Voice 2: harmony (offset frequency)
+            freq2 = (base_freq + f * 37 + 500) & 0xFFFF
+            regs[7] = freq2 & 0xFF
+            regs[8] = (freq2 >> 8) & 0xFF
+            regs[9] = 0x00
+            regs[10] = 0x08
+            regs[11] = 0x21 if f % 16 < 12 else 0x20
+            regs[12] = 0x0A
+            regs[13] = 0x00
+
+            # Voice 3: bass (slow frequency)
+            freq3 = (base_freq // 2 + f * 10) & 0xFFFF
+            regs[14] = freq3 & 0xFF
+            regs[15] = (freq3 >> 8) & 0xFF
+            regs[16] = 0x00
+            regs[17] = 0x04
+            regs[18] = 0x41 if f % 32 < 24 else 0x40
+            regs[19] = 0x0C
+            regs[20] = 0x00
+
+            # Filter + volume
+            regs[21] = 0x00
+            regs[22] = rng.randint(0, 8)
+            regs[23] = 0x00
+            regs[24] = 0x0F
+
+            tokens.extend(regs)
+
+    data = np.array(tokens, dtype=np.uint16)
+    print(f"[SYNTH] Generated {len(data)} tokens ({20} songs)")
+    return torch.from_numpy(data.astype(np.int64)).to(device)
+
+
+def split_data(data, block_size):
+    """Split at frame-aligned boundary (multiple of 26)."""
+    n = len(data)
+    split_tok = int(n * 0.95)
+    # Align to frame boundary
+    split_tok = (split_tok // TOKENS_PER_FRAME) * TOKENS_PER_FRAME
+    return data[:split_tok], data[split_tok:]
+
+
+def get_batch(data, block_size, batch_size, device):
+    """
+    Frame-aligned batch sampling. Offsets are multiples of 26
+    so sequences always start on frame boundaries.
+    """
+    max_start = (len(data) - block_size - 1) // TOKENS_PER_FRAME
+    if max_start < 1:
+        max_start = 1
+    offsets = torch.randint(max_start, (batch_size,)) * TOKENS_PER_FRAME
+    x = torch.stack([data[o : o + block_size] for o in offsets])
+    y = torch.stack(
+        [data[o + 1 : o + 1 + block_size] for o in offsets]
+    )
+    return x.to(device), y.to(device)
+
+
+@torch.no_grad()
+def estimate_loss(
+    model, train_data, val_data, config, args, device,
+):
+    model.eval()
+    out = {}
+    for name, data in [("train", train_data), ("val", val_data)]:
+        losses = []
+        for _ in range(args.eval_iters):
+            x, y = get_batch(
+                data, config.block_size,
+                args.batch_size, device,
+            )
+            with torch.amp.autocast(
+                device_type=device.split(":")[0],
+                dtype=args.amp_dtype,
+            ):
+                _, loss = model(x, y)
+            losses.append(loss.item())
+        out[name] = sum(losses) / len(losses)
+    model.train()
+    return out
+
+
+def get_lr(step, args):
+    """
+    Cosine LR schedule with linear warmup.
+    Decays from lr to min_lr over max_steps.
+    """
+    if step < args.warmup:
+        return args.lr * (step + 1) / args.warmup
+    if step >= args.max_steps:
+        return args.min_lr
+    progress = (step - args.warmup) / (args.max_steps - args.warmup)
+    coeff = 0.5 * (1.0 + math.cos(math.pi * progress))
+    return args.min_lr + coeff * (args.lr - args.min_lr)
+
+
+def configure_optimizer(model, args, device):
+    # Separate params: decay 2D+ params, no decay for 1D (norms, biases)
+    decay_params = []
+    no_decay_params = []
+    for name, p in model.named_parameters():
+        if not p.requires_grad:
+            continue
+        if p.dim() >= 2:
+            decay_params.append(p)
+        else:
+            no_decay_params.append(p)
+
+    groups = [
+        {"params": decay_params, "weight_decay": args.weight_decay},
+        {"params": no_decay_params, "weight_decay": 0.0},
+    ]
+
+    use_fused = device.startswith("cuda")
+    optimizer = torch.optim.AdamW(
+        groups,
+        lr=args.lr,
+        betas=(args.beta1, args.beta2),
+        fused=use_fused,
+    )
+    return optimizer
+
+
+def save_checkpoint(model, optimizer, config, step, path):
+    torch.save(
+        {
+            "model": model.state_dict(),
+            "optimizer": optimizer.state_dict(),
+            "config": config,
+            "step": step,
+        },
+        path,
+    )
+    print(f"[CKPT] Saved {path}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="SID-GPT v2 training"
+    )
+    parser.add_argument("--data", type=str, default=None)
+    parser.add_argument(
+        "--config", type=str, default="small",
+        choices=["small", "large"],
+    )
+    parser.add_argument("--batch-size", type=int, default=8)
+    parser.add_argument("--grad-accum", type=int, default=4)
+    parser.add_argument("--max-steps", type=int, default=5000)
+    parser.add_argument("--lr", type=float, default=3e-4)
+    parser.add_argument("--min-lr", type=float, default=3e-5)
+    parser.add_argument("--warmup", type=int, default=200)
+    parser.add_argument("--weight-decay", type=float, default=0.1)
+    parser.add_argument("--beta1", type=float, default=0.9)
+    parser.add_argument("--beta2", type=float, default=0.95)
+    parser.add_argument("--eval-interval", type=int, default=250)
+    parser.add_argument("--eval-iters", type=int, default=50)
+    parser.add_argument("--log-interval", type=int, default=10)
+    parser.add_argument(
+        "--out-dir", type=str, default="training/checkpoints"
+    )
+    parser.add_argument("--device", type=str, default="auto")
+    parser.add_argument(
+        "--dtype", type=str, default="bfloat16",
+        choices=["bfloat16", "float16", "float32"],
+    )
+    parser.add_argument("--compile", action="store_true")
+    parser.add_argument("--seed", type=int, default=1337)
+    parser.add_argument("--synth", action="store_true")
+    parser.add_argument("--resume", type=str, default=None)
+    args = parser.parse_args()
+
+    if not args.synth and args.data is None and args.resume is None:
+        parser.error("--data or --synth or --resume required")
+
+    # Enable experimental Flash Attention on ROCm
+    os.environ["TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL"] = "1"
+
+    # DDP setup (auto-detect torchrun)
+    rank, local_rank, world_size, is_ddp = setup_ddp()
+    is_master = rank == 0
+
+    if is_ddp:
+        device = f"cuda:{local_rank}"
+        device_type = "cuda"
+    else:
+        device = get_device(args.device)
+        device_type = device.split(":")[0]
+
+    torch.manual_seed(args.seed + rank)
+    args.amp_dtype = get_dtype(args.dtype, device)
+
+    if is_master:
+        if is_ddp:
+            print(
+                f"[INIT] DDP: {world_size} GPUs, "
+                f"dtype: {args.amp_dtype}"
+            )
+        else:
+            print(
+                f"[INIT] Device: {device}, "
+                f"dtype: {args.amp_dtype}"
+            )
+
+    # Model config
+    if args.config == "large":
+        config = ModelConfig.large()
+    else:
+        config = ModelConfig.small()
+
+    start_step = 0
+
+    if args.resume:
+        if is_master:
+            print(f"[RESUME] Loading checkpoint {args.resume}")
+        ckpt = torch.load(
+            args.resume, map_location=device,
+            weights_only=False,
+        )
+        config = ckpt["config"]
+        model = Transformer(config).to(device)
+        model.load_state_dict(ckpt["model"])
+        start_step = ckpt["step"]
+        if is_master:
+            print(f"[RESUME] Resuming from step {start_step}")
+    else:
+        model = Transformer(config).to(device)
+
+    if is_master:
+        print(
+            f"[MODEL] {args.config}: "
+            f"{model.count_params():,} params, "
+            f"{config.n_layer}L/{config.n_head}H/"
+            f"{config.n_embd}D"
+        )
+
+    if args.compile and device_type == "cuda":
+        if is_master:
+            print("[COMPILE] torch.compile enabled")
+        model = torch.compile(model)
+
+    # Wrap in DDP after compile
+    if is_ddp:
+        model = DDP(model, device_ids=[local_rank])
+    raw_model = model.module if is_ddp else model
+
+    # Data
+    if args.synth:
+        data = generate_synth_data(device)
+    else:
+        data = load_data(args.data, device)
+
+    train_data, val_data = split_data(data, config.block_size)
+    if is_master:
+        print(
+            f"[DATA] Train: {len(train_data):,} tokens, "
+            f"Val: {len(val_data):,} tokens"
+        )
+
+    # Optimizer (on raw model params)
+    optimizer = configure_optimizer(raw_model, args, device)
+
+    if args.resume and "optimizer" in ckpt:
+        optimizer.load_state_dict(ckpt["optimizer"])
+
+    # GradScaler only for float16
+    use_scaler = args.amp_dtype == torch.float16
+    scaler = torch.amp.GradScaler(enabled=use_scaler)
+
+    if is_master:
+        os.makedirs(args.out_dir, exist_ok=True)
+
+    # Training loop
+    model.train()
+    t0 = time.time()
+
+    for step in range(start_step, args.max_steps):
+        lr = get_lr(step, args)
+        for pg in optimizer.param_groups:
+            pg["lr"] = lr
+
+        # Eval (rank 0 only)
+        if (
+            step % args.eval_interval == 0
+            and step > 0
+            and is_master
+        ):
+            losses = estimate_loss(
+                model, train_data, val_data,
+                config, args, device,
+            )
+            print(
+                f"[EVAL] step {step}: "
+                f"train={losses['train']:.4f}, "
+                f"val={losses['val']:.4f}"
+            )
+            save_checkpoint(
+                raw_model, optimizer, config, step,
+                os.path.join(
+                    args.out_dir, f"ckpt_{step}.pt"
+                ),
+            )
+
+        # Gradient accumulation
+        optimizer.zero_grad(set_to_none=True)
+        accum_loss = 0.0
+
+        for micro in range(args.grad_accum):
+            x, y = get_batch(
+                train_data, config.block_size,
+                args.batch_size, device,
+            )
+            with torch.amp.autocast(
+                device_type=device_type, dtype=args.amp_dtype
+            ):
+                _, loss = model(x, y)
+                loss = loss / args.grad_accum
+
+            accum_loss += loss.item()
+            scaler.scale(loss).backward()
+
+        scaler.unscale_(optimizer)
+        torch.nn.utils.clip_grad_norm_(
+            model.parameters(), 1.0
+        )
+        scaler.step(optimizer)
+        scaler.update()
+
+        # Logging (rank 0 only)
+        if step % args.log_interval == 0 and is_master:
+            dt = time.time() - t0
+            t0 = time.time()
+            if dt > 0 and step > start_step:
+                ms_per_step = (
+                    dt / args.log_interval * 1000
+                )
+                tps = (
+                    args.batch_size * args.grad_accum
+                    * config.block_size
+                    * args.log_interval
+                    * world_size / dt
+                )
+            else:
+                ms_per_step = 0
+                tps = 0
+            print(
+                f"[TRAIN] step {step:5d} | "
+                f"loss {accum_loss:.4f} | "
+                f"lr {lr:.2e} | "
+                f"{ms_per_step:.0f}ms/step | "
+                f"{dt:.2f}s/{args.log_interval}steps | "
+                f"{tps/1e6:.2f}M tok/s"
+            )
+
+    # Final save (rank 0 only)
+    if is_master:
+        save_checkpoint(
+            raw_model, optimizer, config, args.max_steps,
+            os.path.join(
+                args.out_dir, f"ckpt_{args.max_steps}.pt"
+            ),
+        )
+
+        losses = estimate_loss(
+            model, train_data, val_data,
+            config, args, device,
+        )
+        print(
+            f"[DONE] Final: train={losses['train']:.4f}, "
+            f"val={losses['val']:.4f}"
+        )
+
+    if is_ddp:
+        dist.destroy_process_group()
+
+
+if __name__ == "__main__":
+    main()