""" 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()