model/mamba2.py

"""
Mamba-2 (SSD-style) language model -- "semi-official", mirroring model.mamba.

Like `model.mamba.Mamba`, this keeps a hand-written block (in_proj / depthwise
conv1d / gated RMSNorm / out_proj) but delegates the heavy state-space scan to
the OFFICIAL fused Triton kernel `mamba_chunk_scan_combined` from the
`mamba_ssm` package WHEN it is available and `config.use_cuda=True`. If the
package (mamba_ssm >= 2.2 with a `Mamba2`) is not installed, it transparently
falls back to the self-contained pure-PyTorch chunked SSD scan below, so the
exact same code runs in either environment.

It mirrors the public interface of `model.mamba.Mamba` (forward(idx, targets)
-> (logits, loss), .generate(), .configure_optimizers(), .get_num_params(), and
a `.layers` ModuleList) so it plugs directly into train_maze.py / test_maze.py
/ maze_kstep_detour_test.py.

Key differences from Mamba-1 (model.mamba):
  * Multi-head structure: d_inner is split into `nheads` heads of `headdim`.
  * The state-transition A is a single scalar PER HEAD (A = -exp(A_log),
    A_log shape (nheads,)) instead of a full (d_inner, d_state) matrix. This is
    the Mamba-2 "scalar-times-identity" SSD simplification.
  * dt (the discretization step) is per-head, shape (B, L, nheads).
  * A single depthwise conv is applied jointly to (x, B, C).
  * Output is gated-RMSNorm'd with the z branch before the final projection.

The linear recurrence H[t] = a[t] * H[t-1] + X[t] is computed with the
chunked SSD ("state-space duality") algorithm from the Mamba-2 paper. Instead
of materializing the full (B, L, d_inner, d_state) per-timestep state for the
whole sequence (as a naive parallel scan would), the sequence is split into
chunks of `chunk_size`: outputs within a chunk are computed with an
attention-like matmul, and only small chunk-level states (B, nheads, headdim,
d_state) are carried across chunks. This is dramatically faster and lighter on
memory than a full scan, which is the whole point of Mamba-2.
"""

import math
import inspect
from dataclasses import dataclass
from typing import Union

import torch
import torch.nn as nn
import torch.nn.functional as F

# Official fused Triton SSD kernel (mamba_ssm >= 2.2). Optional: if it is not
# installed we fall back to the pure-PyTorch chunked scan in `_ssd` below.
try:
    from mamba_ssm.ops.triton.ssd_combined import mamba_chunk_scan_combined
    _HAS_MAMBA2_KERNEL = True
except Exception:  # pragma: no cover - import guard
    mamba_chunk_scan_combined = None
    _HAS_MAMBA2_KERNEL = False


class RMSNorm(nn.Module):
    def __init__(self, n_embd: int, eps: float = 1e-5):
        super().__init__()

        self.eps = eps
        self.weight = nn.Parameter(torch.ones(n_embd))

    def forward(self, x):
        output = (
            x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps) * self.weight
        )

        return output


@dataclass
class Mamba2Config:
    n_embd: int                       # D (model dimension)
    n_layer: int

    d_state: int = 64                 # N: SSM state size per head
    expand_factor: int = 2            # E: d_inner = E * D
    headdim: int = 64                 # P: dimension per head (d_inner must be divisible by it)
    ngroups: int = 1                  # number of (B, C) groups (1 == shared across all heads)
    d_conv: int = 4
    chunk_size: int = 64              # SSD chunk length for the chunked scan

    vocab_size: int = 64

    dt_min: float = 0.001
    dt_max: float = 0.1
    dt_init_floor: float = 1e-4
    A_init_min: float = 1.0           # A_log initialized from U(log(A_init_min), log(A_init_max))
    A_init_max: float = 16.0

    rms_norm_eps: float = 1e-5

    bias: bool = False
    conv_bias: bool = True

    pscan: bool = True                # kept for config compatibility (always parallel scan here)
    use_cuda: bool = False            # use the official fused Triton kernel when mamba_ssm>=2.2 is installed (auto-fallback to pure PyTorch otherwise)

    model_type: str = "mamba2"
    pad_id: int = -1

    def __post_init__(self):
        self.d_inner = self.expand_factor * self.n_embd
        assert self.d_inner % self.headdim == 0, (
            f"d_inner ({self.d_inner}) must be divisible by headdim ({self.headdim})")
        self.nheads = self.d_inner // self.headdim


class RMSNormGated(nn.Module):
    """RMSNorm with a SiLU gate (Mamba-2 output normalization): normalize x * silu(z)."""

    def __init__(self, n_embd: int, eps: float = 1e-5):
        super().__init__()
        self.eps = eps
        self.weight = nn.Parameter(torch.ones(n_embd))

    def forward(self, x, z):
        x = x * F.silu(z)
        return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps) * self.weight


def _segsum(x):
    """Stable segment-sum: x (..., T) -> (..., T, T) lower-triangular cumulative sums."""
    T = x.size(-1)
    x = x.unsqueeze(-1).expand(*x.shape, T)
    mask = torch.tril(torch.ones(T, T, device=x.device, dtype=torch.bool), diagonal=-1)
    x = x.masked_fill(~mask, 0)
    x_segsum = torch.cumsum(x, dim=-2)
    mask = torch.tril(torch.ones(T, T, device=x.device, dtype=torch.bool), diagonal=0)
    x_segsum = x_segsum.masked_fill(~mask, float('-inf'))
    return x_segsum


def _ssd(X, A, B, C, chunk_size):
    """Chunked state-space-duality scan (Mamba-2).

    Args:
        X : (b, l, h, p)  input (already scaled by dt)
        A : (b, l, h)     per-step log-decay (= dt * A_scalar)
        B : (b, l, h, n)
        C : (b, l, h, n)
        chunk_size : int, must divide l
    Returns:
        Y : (b, l, h, p)
    """
    b, l, h, p = X.shape
    c = l // chunk_size
    X = X.reshape(b, c, chunk_size, h, p)
    A = A.reshape(b, c, chunk_size, h).permute(0, 3, 1, 2)   # (b, h, c, k)
    B = B.reshape(b, c, chunk_size, h, B.size(-1))
    C = C.reshape(b, c, chunk_size, h, C.size(-1))

    A_cumsum = torch.cumsum(A, dim=-1)                        # (b, h, c, k)

    # 1. intra-chunk (diagonal) outputs
    Lmat = torch.exp(_segsum(A))                             # (b, h, c, k, k)
    Y_diag = torch.einsum("bclhn,bcshn,bhcls,bcshp->bclhp", C, B, Lmat, X)

    # 2. each chunk's end state
    decay_states = torch.exp(A_cumsum[..., -1:] - A_cumsum)  # (b, h, c, k)
    states = torch.einsum("bclhn,bhcl,bclhp->bchpn", B, decay_states, X)

    # 3. inter-chunk recurrence (scan over chunks only)
    init = torch.zeros_like(states[:, :1])
    states = torch.cat([init, states], dim=1)               # (b, c+1, h, p, n)
    decay_chunk = torch.exp(_segsum(F.pad(A_cumsum[..., -1], (1, 0))))  # (b, h, c+1, c+1)
    new_states = torch.einsum("bhzc,bchpn->bzhpn", decay_chunk, states)
    states = new_states[:, :-1]                             # (b, c, h, p, n)

    # 4. add the contribution of each chunk's initial state to its outputs
    state_decay_out = torch.exp(A_cumsum)                   # (b, h, c, k)
    Y_off = torch.einsum("bclhn,bchpn,bhcl->bclhp", C, states, state_decay_out)

    return (Y_diag + Y_off).reshape(b, l, h, p)


class Mamba2Block(nn.Module):
    def __init__(self, config: Mamba2Config):
        super().__init__()
        self.config = config
        d_inner = config.d_inner
        nheads = config.nheads
        ngroups = config.ngroups
        d_state = config.d_state

        # in_proj produces [z, x, B, C, dt]
        conv_dim = d_inner + 2 * ngroups * d_state
        d_in_proj = 2 * d_inner + 2 * ngroups * d_state + nheads
        self.in_proj = nn.Linear(config.n_embd, d_in_proj, bias=config.bias)

        # depthwise conv over the (x, B, C) channels
        self.conv_dim = conv_dim
        self.conv1d = nn.Conv1d(
            in_channels=conv_dim,
            out_channels=conv_dim,
            kernel_size=config.d_conv,
            groups=conv_dim,
            bias=config.conv_bias,
            padding=config.d_conv - 1,
        )

        # dt bias (per head); softplus(dt + dt_bias) at runtime
        dt = torch.exp(
            torch.rand(nheads) * (math.log(config.dt_max) - math.log(config.dt_min))
            + math.log(config.dt_min)
        ).clamp(min=config.dt_init_floor)
        inv_dt = dt + torch.log(-torch.expm1(-dt))  # inverse softplus
        self.dt_bias = nn.Parameter(inv_dt)

        # per-head scalar A (stored in log space to keep A < 0 via A = -exp(A_log))
        A = torch.empty(nheads).uniform_(config.A_init_min, config.A_init_max)
        self.A_log = nn.Parameter(torch.log(A))
        self.A_log._no_weight_decay = True

        # per-head skip connection D
        self.D = nn.Parameter(torch.ones(nheads))
        self.D._no_weight_decay = True

        self.norm = RMSNormGated(d_inner, eps=config.rms_norm_eps)
        self.out_proj = nn.Linear(d_inner, config.n_embd, bias=config.bias)

        # Use the official fused Triton kernel only if requested AND available.
        self.use_kernel = bool(config.use_cuda) and _HAS_MAMBA2_KERNEL

    def forward(self, u):
        # u : (B, L, D)
        B_, L, _ = u.shape
        cfg = self.config
        d_inner, nheads, headdim = cfg.d_inner, cfg.nheads, cfg.headdim
        ngroups, d_state = cfg.ngroups, cfg.d_state

        zxbcdt = self.in_proj(u)  # (B, L, d_in_proj)
        z, xBC, dt = torch.split(
            zxbcdt, [d_inner, self.conv_dim, nheads], dim=-1)

        # depthwise conv (causal) over (x, B, C)
        xBC = xBC.transpose(1, 2)               # (B, conv_dim, L)
        xBC = self.conv1d(xBC)[:, :, :L]        # causal: drop the right padding
        xBC = xBC.transpose(1, 2)               # (B, L, conv_dim)
        xBC = F.silu(xBC)

        x, Bmat, Cmat = torch.split(
            xBC, [d_inner, ngroups * d_state, ngroups * d_state], dim=-1)

        A = -torch.exp(self.A_log.float())                       # (nheads,)
        x = x.view(B_, L, nheads, headdim)                       # (B, L, H, P)
        Bmat = Bmat.view(B_, L, ngroups, d_state)
        Cmat = Cmat.view(B_, L, ngroups, d_state)

        if self.use_kernel:
            # --- official fused Triton SSD kernel ---
            # It applies softplus(dt + dt_bias), the chunked scan, and the
            # per-head D skip connection internally. B/C keep the ngroups dim.
            y = mamba_chunk_scan_combined(
                x, dt, A, Bmat, Cmat,
                chunk_size=cfg.chunk_size,
                D=self.D,
                z=None,
                dt_bias=self.dt_bias,
                dt_softplus=True,
            )                                                    # (B, L, H, P)
            y = y.reshape(B_, L, d_inner).to(z.dtype)
        else:
            # --- pure-PyTorch chunked SSD scan (float32 for stability) ---
            dt = F.softplus(dt + self.dt_bias)                   # (B, L, nheads)
            # heads per group (ngroups==1 -> shared across all heads)
            rep = nheads // ngroups
            Bh = Bmat.repeat_interleave(rep, dim=2)              # (B, L, H, N)
            Ch = Cmat.repeat_interleave(rep, dim=2)             # (B, L, H, N)

            dt_f = dt.float()
            X_in = x.float() * dt_f.unsqueeze(-1)                # (B, L, H, P)
            A_in = A * dt_f                                      # (B, L, H)
            Bf = Bh.float()
            Cf = Ch.float()

            chunk = min(self.config.chunk_size, L)
            pad_len = (chunk - L % chunk) % chunk                # pad L up to a multiple of chunk
            if pad_len:
                X_in = F.pad(X_in, (0, 0, 0, 0, 0, pad_len))
                A_in = F.pad(A_in, (0, 0, 0, pad_len))
                Bf = F.pad(Bf, (0, 0, 0, 0, 0, pad_len))
                Cf = F.pad(Cf, (0, 0, 0, 0, 0, pad_len))

            y = _ssd(X_in, A_in, Bf, Cf, chunk)                 # (B, L_pad, H, P)
            y = y[:, :L]                                        # drop the padded steps
            y = y + self.D.float().view(1, 1, nheads, 1) * x.float()  # per-head skip
            y = y.reshape(B_, L, d_inner).to(z.dtype)           # back to input dtype

        y = self.norm(y, z)                                    # gated RMSNorm
        return self.out_proj(y)                                # (B, L, D)


class ResidualBlock2(nn.Module):
    def __init__(self, config: Mamba2Config):
        super().__init__()
        self.mixer = Mamba2Block(config)
        self.norm = RMSNorm(config.n_embd, config.rms_norm_eps)

    def forward(self, x):
        return self.mixer(self.norm(x)) + x


class Mamba2(nn.Module):
    def __init__(self, config: Mamba2Config):
        super().__init__()
        self.config = config

        self.embedding = nn.Embedding(config.vocab_size, config.n_embd, padding_idx=0)
        self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
        self.lm_head.weight = self.embedding.weight  # weight tying

        self.layers = nn.ModuleList([ResidualBlock2(config) for _ in range(config.n_layer)])
        self.out_norm = RMSNorm(config.n_embd, config.rms_norm_eps)

        self.apply(self._init_weights)
        for pn, p in self.named_parameters():
            if pn.endswith("out_proj.weight"):
                torch.nn.init.normal_(p, mean=0.0, std=0.02 / math.sqrt(2 * config.n_layer))

        print(f"number of parameters: {self.get_num_params() / 1e6:.2f}M")

        if config.use_cuda and _HAS_MAMBA2_KERNEL:
            print("[mamba2] using official fused Triton kernel (mamba_chunk_scan_combined)")
        elif config.use_cuda and not _HAS_MAMBA2_KERNEL:
            print("[mamba2] use_cuda=True but mamba_ssm kernel not found -> "
                  "falling back to pure-PyTorch chunked SSD")
        else:
            print("[mamba2] using pure-PyTorch chunked SSD scan")

    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):
        x = self.embedding(idx)
        for layer in self.layers:
            x = layer(x)
        x = self.out_norm(x)

        if targets is not None:
            logits = self.lm_head(x)
            loss = F.cross_entropy(
                logits.view(-1, logits.size(-1)),
                targets.view(-1),
                ignore_index=self.config.pad_id,
            )
        else:
            logits = self.lm_head(x[:, [-1], :])
            loss = None
        return logits, loss

    @torch.no_grad()
    def generate(self, idx, max_new_tokens, temperature=1.0, top_k=None, return_confidence=False):
        """Autoregressive generation matching model.mamba.Mamba.generate's contract."""
        confidences = [] if return_confidence else None
        top3_tokens = [] if return_confidence else None
        top3_probs = [] if return_confidence else None
        B = idx.size(0)

        for _ in range(max_new_tokens):
            logits, _ = self(idx)
            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:
            if B == 1:
                return (idx,
                        [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 idx, conf_bs, tok_bs, prob_bs
        return idx

    def configure_optimizers(self, weight_decay, learning_rate, betas, device_type):
        param_dict = {pn: p for pn, p in self.named_parameters() if p.requires_grad}
        decay_params = [p for n, p in param_dict.items() if p.dim() >= 2]
        nodecay_params = [p for n, p in param_dict.items() if p.dim() < 2]
        optim_groups = [
            {"params": decay_params, "weight_decay": weight_decay},
            {"params": nodecay_params, "weight_decay": 0.0},
        ]
        num_decay = sum(p.numel() for p in decay_params)
        num_nodecay = sum(p.numel() for p in nodecay_params)
        print(f"num decayed parameter tensors: {len(decay_params)}, with {num_decay:,} parameters")
        print(f"num non-decayed parameter tensors: {len(nodecay_params)}, with {num_nodecay:,} parameters")
        fused_available = "fused" in inspect.signature(torch.optim.AdamW).parameters
        use_fused = fused_available and device_type == "cuda"
        extra_args = dict(fused=True) if use_fused else {}
        optimizer = torch.optim.AdamW(optim_groups, lr=learning_rate, betas=betas, **extra_args)
        print(f"using fused AdamW: {use_fused}")
        return optimizer

    def estimate_mfu(self, fwdbwd_per_iter, dt):
        return -1

    def get_num_params(self, non_embedding=True):
        n_params = sum(p.numel() for p in self.parameters())
        if non_embedding:
            n_params -= self.embedding.weight.numel()
        return n_params