""" Transformer + NextLat (Next-Latent Prediction) as a standalone, selectable model. This packages a standard GPT together with the NextLat latent-dynamics auxiliary objective (arXiv:2511.05963) into a single nn.Module, so it can be selected with `--model transformer-nextlat` just like `transformer` / `mamba` / `mamba2`. Unlike the legacy `--NextLat` flag (which keeps a *separate* latent model and a *separate* optimizer alongside a plain GPT), here the latent dynamics model is **encapsulated** inside this module. Consequences: * a single optimizer (configure_optimizers) covers both the GPT and the latent model, and a single checkpoint (`model` state_dict) stores both; * `.forward(idx, targets)` behaves EXACTLY like a plain GPT (returns (logits, loss)), so inference / probing / evaluation are unchanged; * the NextLat auxiliary losses are produced by `.forward_nextlat(idx, targets)`, which is only used during training. The `.transformer` property plus the generate()/crop_block_size() delegations keep it drop-in compatible with the rest of the pipeline (e.g. get_block_list, which reads `model.transformer.h`). """ import math import inspect from dataclasses import dataclass, fields from typing import Optional import torch import torch.nn as nn from torch.nn import functional as F # ============================================================================ # GPT backbone, copied from model/transformer.py so this model is fully # self-contained and does NOT import anything from transformer.py. Only the # standard Transformer path that NextLat actually exercises is included (no # PostGRU / NLS / Dyadic variants). The module/attribute layout (self.gpt -> # transformer.{wte,wpe,drop,h,ln_f} + lm_head, Block.{ln_1,attn,ln_2,mlp}) is # identical to the plain GPT, so existing transformer-nextlat checkpoints load # unchanged. # ============================================================================ def new_gelu(x): """GELU activation (identical to OpenAI GPT / Google BERT).""" return 0.5 * x * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi) * (x + 0.044715 * torch.pow(x, 3.0)))) class LayerNorm(nn.Module): """ LayerNorm but with an optional bias. PyTorch doesn't support simply bias=False """ def __init__(self, ndim, bias): super().__init__() self.weight = nn.Parameter(torch.ones(ndim)) self.bias = nn.Parameter(torch.zeros(ndim)) if bias else None def forward(self, input): return F.layer_norm(input, self.weight.shape, self.weight, self.bias, 1e-5) class CausalSelfAttention(nn.Module): def __init__(self, config): super().__init__() assert config.n_embd % config.n_head == 0 # key, query, value projections for all heads, but in a batch self.c_attn = nn.Linear(config.n_embd, 3 * config.n_embd, bias=config.bias) # output projection self.c_proj = nn.Linear(config.n_embd, config.n_embd, bias=config.bias) # regularization self.attn_dropout = nn.Dropout(config.dropout) self.resid_dropout = nn.Dropout(config.dropout) self.n_head = config.n_head self.n_embd = config.n_embd self.dropout = config.dropout # flash attention make GPU go brrrrr but support is only in PyTorch >= 2.0 self.flash = config.use_flash and hasattr(torch.nn.functional, 'scaled_dot_product_attention') if not self.flash: if not config.use_flash: print("INFO: Flash attention disabled via --local flag (for local GPU compatibility)") else: print("WARNING: using slow attention. Flash Attention requires PyTorch >= 2.0") # causal mask to ensure that attention is only applied to the left in the input sequence self.register_buffer("bias", torch.tril(torch.ones(config.block_size, config.block_size)) .view(1, 1, config.block_size, config.block_size)) def forward(self, x, kv_cache=None): B, T, C = x.size() # batch size, sequence length, embedding dimensionality (n_embd) # calculate query, key, values for all heads in batch and move head forward to be the batch dim q, k, v = self.c_attn(x).split(self.n_embd, dim=2) nh = self.n_head; hs = C // nh k = k.view(B, T, nh, hs).transpose(1, 2) # (B, nh, T, hs) q = q.view(B, T, nh, hs).transpose(1, 2) # (B, nh, T, hs) v = v.view(B, T, nh, hs).transpose(1, 2) # (B, nh, T, hs) if kv_cache is None: # ---- standard path: full causal self-attention ---- if self.flash: y = torch.nn.functional.scaled_dot_product_attention( q, k, v, attn_mask=None, dropout_p=self.dropout if self.training else 0, is_causal=True) else: att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1))) att = att.masked_fill(self.bias[:, :, :T, :T] == 0, float('-inf')) att = F.softmax(att, dim=-1) att = self.attn_dropout(att) y = att @ v else: # ---- incremental path: append k,v to preallocated buffer, attend over full prefix ---- cur_len = kv_cache.get('len', 0) max_L = kv_cache['max_L'] if 'k_buf' not in kv_cache: kv_cache['k_buf'] = torch.empty(B, nh, max_L, hs, dtype=k.dtype, device=k.device) kv_cache['v_buf'] = torch.empty(B, nh, max_L, hs, dtype=v.dtype, device=v.device) new_end = cur_len + T assert new_end <= max_L, f"KV cache overflow: {new_end} > {max_L}" kv_cache['k_buf'][:, :, cur_len:new_end].copy_(k) kv_cache['v_buf'][:, :, cur_len:new_end].copy_(v) kv_cache['len'] = new_end k_full = kv_cache['k_buf'][:, :, :new_end] # (B, nh, new_end, hs) v_full = kv_cache['v_buf'][:, :, :new_end] if T == 1: # Single new query attends to all prior keys; no causal mask needed. if self.flash: y = torch.nn.functional.scaled_dot_product_attention( q, k_full, v_full, attn_mask=None, dropout_p=0, is_causal=False) else: att = (q @ k_full.transpose(-2, -1)) * (1.0 / math.sqrt(hs)) att = F.softmax(att, dim=-1) y = att @ v_full else: # Multiple new queries (e.g. initial prompt). Build rectangular causal mask. device = q.device q_abs = torch.arange(cur_len, new_end, device=device).unsqueeze(1) # (T, 1) k_abs = torch.arange(0, new_end, device=device).unsqueeze(0) # (1, new_end) mask = (k_abs <= q_abs).view(1, 1, T, new_end) if self.flash: y = torch.nn.functional.scaled_dot_product_attention( q, k_full, v_full, attn_mask=mask, dropout_p=0, is_causal=False) else: att = (q @ k_full.transpose(-2, -1)) * (1.0 / math.sqrt(hs)) att = att.masked_fill(~mask, float('-inf')) att = F.softmax(att, dim=-1) y = att @ v_full y = y.transpose(1, 2).contiguous().view(B, T, C) # re-assemble all head outputs side by side # output projection y = self.resid_dropout(self.c_proj(y)) return y class MLP(nn.Module): def __init__(self, config): super().__init__() self.c_fc = nn.Linear(config.n_embd, 4 * config.n_embd, bias=config.bias) self.c_proj = nn.Linear(4 * config.n_embd, config.n_embd, bias=config.bias) self.dropout = nn.Dropout(config.dropout) def forward(self, x): x = self.c_fc(x) x = new_gelu(x) x = self.c_proj(x) x = self.dropout(x) return x class Block(nn.Module): def __init__(self, config, layer_idx=0): super().__init__() self.layer_idx = layer_idx self.ln_1 = LayerNorm(config.n_embd, bias=config.bias) self.attn = CausalSelfAttention(config) self.ln_2 = LayerNorm(config.n_embd, bias=config.bias) self.mlp = MLP(config) def forward(self, x, nls_cache=None, kv_cache=None): x = x + self.attn(self.ln_1(x), kv_cache=kv_cache) x = x + self.mlp(self.ln_2(x)) return x @dataclass class GPTConfig: block_size: int = 1024 vocab_size: int = 50304 # GPT-2 vocab_size of 50257, padded up to nearest multiple of 64 for efficiency n_layer: int = 12 n_head: int = 12 n_embd: int = 768 dropout: float = 0.0 bias: bool = True # True: bias in Linears and LayerNorms, like GPT-2. False: a bit better and faster use_flash: bool = True # Enable flash attention (disable for local GPUs that don't support it) class LatentDynamicsModel(nn.Module): """ NextLat latent dynamics model p_ψ (arXiv:2511.05963). A 3-layer MLP that predicts the next hidden state from the current hidden state and the next token embedding, using a residual connection: h_hat_{t+1} = f_ψ(h_t, emb(x_{t+1})) + h_t """ def __init__(self, n_embd, mlp_hidden_dim=None): super().__init__() if mlp_hidden_dim is None: mlp_hidden_dim = 2 * n_embd self.ln = LayerNorm(2 * n_embd, bias=True) self.fc1 = nn.Linear(2 * n_embd, mlp_hidden_dim) self.fc2 = nn.Linear(mlp_hidden_dim, mlp_hidden_dim) self.fc3 = nn.Linear(mlp_hidden_dim, n_embd) def forward(self, h_t, tok_emb_next): """ Args: h_t: (B, D) current hidden state tok_emb_next: (B, D) token embedding of the next token Returns: h_hat_next: (B, D) predicted next hidden state """ x = torch.cat([h_t, tok_emb_next], dim=-1) # (B, 2D) x = self.ln(x) x = F.gelu(self.fc1(x)) x = F.gelu(self.fc2(x)) x = self.fc3(x) return x + h_t # residual connection class GPT(nn.Module): def __init__(self, config): super().__init__() assert config.vocab_size is not None assert config.block_size is not None self.config = config block_list = nn.ModuleList([Block(config, layer_idx=i) for i in range(config.n_layer)]) self.transformer = nn.ModuleDict(dict( wte = nn.Embedding(config.vocab_size, config.n_embd), wpe = nn.Embedding(config.block_size, config.n_embd), drop = nn.Dropout(config.dropout), h = block_list, ln_f = LayerNorm(config.n_embd, bias=config.bias), )) self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False) # weight tying self.transformer.wte.weight = self.lm_head.weight # https://paperswithcode.com/method/weight-tying # init all weights self.apply(self._init_weights) # apply special scaled init to the residual projections, per GPT-2 paper for pn, p in self.named_parameters(): if pn.endswith('c_proj.weight'): torch.nn.init.normal_(p, mean=0.0, std=0.02 / math.sqrt(2 * len(self.transformer.h))) # report number of parameters print("number of parameters: %.2fM" % (self.get_num_params() / 1e6,)) def get_num_params(self, non_embedding=True): """Return the number of parameters in the model (excluding position embeddings by default; token embeddings are tied to lm_head and kept).""" n_params = sum(p.numel() for p in self.parameters()) if non_embedding: n_params -= self.transformer.wpe.weight.numel() return n_params def _init_weights(self, 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, targets=None, nls_caches=None, kv_caches=None): device = idx.device b, t = idx.size() # Determine position offset for incremental decoding. if kv_caches is not None and len(kv_caches) > 0 and kv_caches[0].get('len', 0) > 0: pos_offset = kv_caches[0]['len'] else: pos_offset = 0 assert pos_offset + t <= self.config.block_size, ( f"Cannot forward sequence of length {pos_offset + t}, block size is only {self.config.block_size}") pos = torch.arange(pos_offset, pos_offset + t, dtype=torch.long, device=device).unsqueeze(0) # forward the GPT model itself tok_emb = self.transformer.wte(idx) # token embeddings of shape (b, t, n_embd) pos_emb = self.transformer.wpe(pos) # position embeddings of shape (1, t, n_embd) x = self.transformer.drop(tok_emb + pos_emb) for i, block in enumerate(self.transformer.h): blk_nls_cache = nls_caches[i] if nls_caches is not None else None blk_kv_cache = kv_caches[i] if kv_caches is not None else None x = block(x, nls_cache=blk_nls_cache, kv_cache=blk_kv_cache) x = self.transformer.ln_f(x) if targets is not None: # if we are given some desired targets also calculate the loss logits = self.lm_head(x) loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1), ignore_index=0) else: # inference-time mini-optimization: only forward the lm_head on the very last position logits = self.lm_head(x[:, [-1], :]) # note: using list [-1] to preserve the time dim loss = None return logits, loss def forward_nextlat(self, idx, targets, latent_model, horizon=1, lambda_h=1.0, lambda_kl=1.0): """ NextLat forward pass (arXiv:2511.05963). Computes standard next-token loss plus auxiliary latent dynamics losses. Returns: total_loss, loss_next_token, loss_next_h, loss_kl """ device = idx.device b, t = idx.size() assert t <= self.config.block_size pos = torch.arange(0, t, dtype=torch.long, device=device).unsqueeze(0) # Forward the transformer to get hidden states tok_emb = self.transformer.wte(idx) # (B, T, D) pos_emb = self.transformer.wpe(pos) x = self.transformer.drop(tok_emb + pos_emb) for block in self.transformer.h: x = block(x) hidden_states = self.transformer.ln_f(x) # (B, T, D) # Standard next-token prediction loss logits = self.lm_head(hidden_states) loss_next_token = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1), ignore_index=0) # NextLat auxiliary losses: token embeddings for the teacher-forced next tokens target_tok_emb = self.transformer.wte(targets) # (B, T, D) # For each starting position t, unroll latent dynamics for `horizon` steps max_start = t - horizon if max_start <= 0: # Sequence too short for the given horizon; fall back to horizon=1 horizon = max(1, t - 1) max_start = t - horizon loss_next_h = torch.tensor(0.0, device=device) loss_kl = torch.tensor(0.0, device=device) count = 0 # Detach hidden state targets (stop-gradient) hidden_targets = hidden_states.detach() # (B, T, D) for d in range(1, horizon + 1): if d == 1: # First step: predict from actual hidden states h_current = hidden_states[:, :max_start, :] # (B, max_start, D) tok_emb_next = target_tok_emb[:, :max_start, :] # (B, max_start, D) B_T = b * max_start h_pred = latent_model( h_current.reshape(B_T, -1), tok_emb_next.reshape(B_T, -1) ).reshape(b, max_start, -1) # (B, max_start, D) else: # Multi-step: unroll from previous predicted states tok_emb_next = target_tok_emb[:, d-1:max_start+d-1, :] # (B, max_start, D) B_T = b * max_start h_pred = latent_model( h_pred.reshape(B_T, -1), tok_emb_next.reshape(B_T, -1) ).reshape(b, max_start, -1) # SmoothL1 loss: compare predicted h with actual h (stop-gradient on target) h_target = hidden_targets[:, d:max_start+d, :] # (B, max_start, D) # Create valid mask to ignore padding tokens (index 0) valid_mask = (targets[:, d:max_start+d] != 0) # (B, max_start) valid_tokens_count = valid_mask.sum() if valid_tokens_count > 0: # Masked SmoothL1 Loss h_loss_unreduced = F.smooth_l1_loss(h_pred, h_target, reduction='none') # (B, max_start, D) h_loss_unreduced = h_loss_unreduced.mean(dim=-1) # (B, max_start) loss_next_h = loss_next_h + (h_loss_unreduced * valid_mask).sum() / valid_tokens_count # Masked KL Loss with torch.no_grad(): logits_target = self.lm_head(h_target) # (B, max_start, V) log_probs_target = F.log_softmax(logits_target, dim=-1) # Use detached lm_head weights logits_pred = F.linear(h_pred, self.lm_head.weight.detach()) # (B, max_start, V) log_probs_pred = F.log_softmax(logits_pred, dim=-1) # KL(p_target || p_pred); log_target=True for numerical stability kl_unreduced = F.kl_div(log_probs_pred, log_probs_target, reduction='none', log_target=True) kl_unreduced = kl_unreduced.sum(dim=-1) # sum over vocabulary -> (B, max_start) loss_kl = loss_kl + (kl_unreduced * valid_mask).sum() / valid_tokens_count count += 1 if count > 0: loss_next_h = loss_next_h / count loss_kl = loss_kl / count total_loss = loss_next_token + lambda_h * loss_next_h + lambda_kl * loss_kl return total_loss, loss_next_token, loss_next_h, loss_kl def crop_block_size(self, block_size): # model surgery to decrease the block size if necessary assert block_size <= self.config.block_size self.config.block_size = block_size self.transformer.wpe.weight = nn.Parameter(self.transformer.wpe.weight[:block_size]) for block in self.transformer.h: if hasattr(block.attn, 'bias'): block.attn.bias = block.attn.bias[:, :, :block_size, :block_size] def estimate_mfu(self, fwdbwd_per_iter, dt): """ estimate model flops utilization (MFU) in units of A100 bfloat16 peak FLOPS """ N = self.get_num_params() cfg = self.config L, H, Q, T = cfg.n_layer, cfg.n_head, cfg.n_embd // cfg.n_head, cfg.block_size flops_per_token = 6 * N + 12 * L * H * Q * T flops_per_fwdbwd = flops_per_token * T flops_per_iter = flops_per_fwdbwd * fwdbwd_per_iter flops_achieved = flops_per_iter * (1.0 / dt) # per second flops_promised = 312e12 # A100 GPU bfloat16 peak flops is 312 TFLOPS return flops_achieved / flops_promised @torch.no_grad() def generate(self, idx, max_new_tokens, temperature=1.0, top_k=None, return_confidence=False): """ Take a conditioning sequence of indices idx (LongTensor of shape (b,t)) and complete the sequence max_new_tokens times, feeding the predictions back into the model each time. """ confidences = [] if return_confidence else None top3_tokens = [] if return_confidence else None top3_probs = [] if return_confidence else None B = idx.size(0) block_size = self.config.block_size any_nls = any(getattr(b, 'per_block_nls', None) is not None for b in self.transformer.h) any_postgru = any(getattr(b, 'per_block_gru', None) is not None for b in self.transformer.h) # Fast path: KV-cached incremental decoding (disabled for PostGRU / training). use_incremental = (not self.training) and (not any_postgru) def _format_conf_outputs(): """Reshape collected per-step (B, ...) lists into the documented format.""" if B == 1: return ([c[0] for c in confidences], [t[0] for t in top3_tokens], [p[0] for p in top3_probs]) T = len(confidences) conf_bs = [[confidences[t][b] for t in range(T)] for b in range(B)] tok_bs = [[top3_tokens[t][b] for t in range(T)] for b in range(B)] prob_bs = [[top3_probs[t][b] for t in range(T)] for b in range(B)] return conf_bs, tok_bs, prob_bs if use_incremental: kv_caches = [{'max_L': block_size} for _ in self.transformer.h] nls_caches = ([{'max_L': block_size, 'incremental': True} for _ in self.transformer.h] if any_nls else None) def _reset_caches(): for c in kv_caches: c.pop('k_buf', None) c.pop('v_buf', None) c['len'] = 0 if nls_caches is not None: for c in nls_caches: c['bufs'] = [] c['lens'] = [] def _sample_from(logits_last): if temperature <= 0: probs = F.softmax(logits_last, dim=-1) idx_next = probs.argmax(dim=-1, keepdim=True) # (B, 1) else: logits_last = logits_last / temperature if top_k is not None: v, _ = torch.topk(logits_last, min(top_k, logits_last.size(-1))) logits_last = torch.where(logits_last < v[:, [-1]], torch.full_like(logits_last, -float('Inf')), logits_last) probs = F.softmax(logits_last, dim=-1) idx_next = torch.multinomial(probs, num_samples=1) # (B, 1) if return_confidence: sampled_probs = probs.gather(1, idx_next).squeeze(-1) # (B,) confidences.append(sampled_probs.cpu().tolist()) top3_prob_vals, top3_token_ids = torch.topk(probs, 3, dim=-1) # (B, 3) top3_tokens.append(top3_token_ids.cpu().tolist()) top3_probs.append(top3_prob_vals.cpu().tolist()) return idx_next # Initial forward over the full prompt (cropped if needed). idx_cond = idx if idx.size(1) <= block_size else idx[:, -block_size:] logits, _ = self(idx_cond, nls_caches=nls_caches, kv_caches=kv_caches) idx_next = _sample_from(logits[:, -1, :]) idx = torch.cat((idx, idx_next), dim=1) for _ in range(max_new_tokens - 1): cur_len = kv_caches[0]['len'] if cur_len + 1 > block_size: # Caches full; slide the window: reset and re-encode the recent prefix. _reset_caches() idx_cond = idx[:, -(block_size - 1):] logits, _ = self(idx_cond, nls_caches=nls_caches, kv_caches=kv_caches) else: # Incremental: feed only the most recently sampled token. logits, _ = self(idx_next, nls_caches=nls_caches, kv_caches=kv_caches) idx_next = _sample_from(logits[:, -1, :]) idx = torch.cat((idx, idx_next), dim=1) if return_confidence: conf, t3t, t3p = _format_conf_outputs() return idx, conf, t3t, t3p return idx # ---- Legacy path: full re-forward each step ---- nls_caches = ([{'max_L': block_size} for _ in self.transformer.h] if any_nls else None) prev_cond_len = 0 for _ in range(max_new_tokens): idx_cond = idx if idx.size(1) <= block_size else idx[:, -block_size:] if nls_caches is not None and ( idx_cond.size(1) < prev_cond_len or (idx_cond.size(1) == block_size and prev_cond_len == block_size) ): for c in nls_caches: if isinstance(c, dict): c['bufs'] = [] c['lens'] = [] else: c.clear() prev_cond_len = idx_cond.size(1) logits, _ = self(idx_cond, nls_caches=nls_caches) if temperature <= 0: probs = F.softmax(logits[:, -1, :], dim=-1) idx_next = probs.argmax(dim=-1, keepdim=True) else: logits = logits[:, -1, :] / temperature if top_k is not None: v, _ = torch.topk(logits, min(top_k, logits.size(-1))) logits[logits < v[:, [-1]]] = -float('Inf') probs = F.softmax(logits, dim=-1) idx_next = torch.multinomial(probs, num_samples=1) if return_confidence: sampled_probs = probs.gather(1, idx_next).squeeze(-1) confidences.append(sampled_probs.cpu().tolist()) top3_prob_vals, top3_token_ids = torch.topk(probs, 3, dim=-1) top3_tokens.append(top3_token_ids.cpu().tolist()) top3_probs.append(top3_prob_vals.cpu().tolist()) idx = torch.cat((idx, idx_next), dim=1) if return_confidence: conf, t3t, t3p = _format_conf_outputs() return idx, conf, t3t, t3p return idx @dataclass class TransformerNextLatConfig: # --- GPT backbone fields (mirror GPTConfig) --- block_size: int = 1024 vocab_size: int = 50304 n_layer: int = 12 n_head: int = 12 n_embd: int = 768 dropout: float = 0.0 bias: bool = True use_flash: bool = True # --- NextLat fields --- mlp_hidden_dim: Optional[int] = None # latent MLP hidden dim (default: 2 * n_embd) nextlat_horizon: int = 1 # latent-dynamics rollout horizon d lambda_h: float = 1.0 # weight of next-hidden-state regression loss lambda_kl: float = 1.0 # weight of KL divergence loss model_type: str = 'transformer-nextlat' def gpt_config(self) -> GPTConfig: """Build the backbone GPTConfig from the shared fields.""" gpt_keys = {f.name for f in fields(GPTConfig)} return GPTConfig(**{k: getattr(self, k) for k in gpt_keys}) class TransformerNextLat(nn.Module): def __init__(self, config: TransformerNextLatConfig): super().__init__() self.config = config self.gpt = GPT(config.gpt_config()) self.latent_model = LatentDynamicsModel(config.n_embd, config.mlp_hidden_dim) self.nextlat_horizon = config.nextlat_horizon self.lambda_h = config.lambda_h self.lambda_kl = config.lambda_kl n_latent = sum(p.numel() for p in self.latent_model.parameters()) print(f"NextLat latent dynamics model parameters: {n_latent / 1e6:.2f}M") # Expose the backbone's transformer module so helpers that read # `model.transformer.h` (e.g. get_block_list) work unchanged. Using a # property (not a registered submodule) avoids double-counting parameters. @property def transformer(self): return self.gpt.transformer def forward(self, idx, targets=None, nls_caches=None, kv_caches=None): """Standard GPT forward (used by eval / test / probes / generation).""" return self.gpt(idx, targets, nls_caches=nls_caches, kv_caches=kv_caches) def forward_nextlat(self, idx, targets, horizon=None, lambda_h=None, lambda_kl=None): """NextLat training forward: next-token loss + latent-dynamics aux losses. Returns (total_loss, loss_next_token, loss_next_h, loss_kl).""" return self.gpt.forward_nextlat( idx, targets, self.latent_model, horizon=self.nextlat_horizon if horizon is None else horizon, lambda_h=self.lambda_h if lambda_h is None else lambda_h, lambda_kl=self.lambda_kl if lambda_kl is None else lambda_kl, ) @torch.no_grad() def generate(self, *args, **kwargs): return self.gpt.generate(*args, **kwargs) def crop_block_size(self, block_size): self.gpt.crop_block_size(block_size) self.config.block_size = block_size def estimate_mfu(self, fwdbwd_per_iter, dt): return self.gpt.estimate_mfu(fwdbwd_per_iter, dt) def get_num_params(self, non_embedding=True): return (self.gpt.get_num_params(non_embedding) + sum(p.numel() for p in self.latent_model.parameters())) def configure_optimizers(self, weight_decay, learning_rate, betas, device_type): """Single optimizer over the GPT backbone AND the latent model. Uses a dim-based decay split (>=2D decayed, <2D not), which correctly handles the tied embedding/lm_head weight (returned once by named_parameters) and the latent MLP's LayerNorm/biases.""" param_dict = {pn: p for pn, p in self.named_parameters() if p.requires_grad} decay_params = [p for p in param_dict.values() if p.dim() >= 2] nodecay_params = [p for p in param_dict.values() if p.dim() < 2] optim_groups = [ {"params": decay_params, "weight_decay": weight_decay}, {"params": nodecay_params, "weight_decay": 0.0}, ] use_fused = (device_type == 'cuda') and ('fused' in inspect.signature(torch.optim.AdamW).parameters) print(f"using fused AdamW: {use_fused}") extra_args = dict(fused=True) if use_fused else dict() return torch.optim.AdamW(optim_groups, lr=learning_rate, betas=betas, **extra_args)