| """GPT-OSS decoder layer: attention + MoE with RMSNorm residual connections. |
| |
| Uses the shared ``LlamaAttention`` with ``use_sinks=True`` and |
| ``sliding_window`` to implement GPT-OSS attention sinks and per-layer |
| sliding window. Rotary embedding is passed through forward (created |
| once at the model level and shared across layers). |
| """ |
|
|
| from __future__ import annotations |
|
|
| import torch |
| import torch.nn as nn |
|
|
| from fastkernels.infra.cuda_ext import lazy_op |
|
|
| from ..L1.rms_norm import RMSNorm |
| from ..L2.attention import LlamaAttention |
| from ..L2.gpt_oss_moe import GptOssMoE, _router_small_batch_kernel |
|
|
|
|
| _C = lazy_op("candidate_gpt_oss_decoder_v3", "gpt_oss_decoder.cu") |
|
|
|
|
| class GptOssDecoderLayer(nn.Module): |
| def __init__(self, config, layer_idx: int): |
| super().__init__() |
| self.self_attn = LlamaAttention( |
| config.hidden_size, |
| config.num_attention_heads, |
| config.num_key_value_heads, |
| config.head_dim, |
| bias=True, |
| o_proj_bias=True, |
| use_sinks=True, |
| sliding_window=config.sliding_window, |
| layer_idx=layer_idx, |
| ) |
| self.mlp = GptOssMoE(config) |
| self.input_layernorm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps) |
| self.post_attention_layernorm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps) |
|
|
| @staticmethod |
| def _rms_norm(hidden_states, residual, layernorm): |
| if ( |
| hidden_states.is_cuda |
| and hidden_states.dtype == torch.bfloat16 |
| and hidden_states.is_contiguous() |
| and hidden_states.shape[-1] == 2880 |
| and ( |
| 1 < hidden_states.shape[0] <= 32 |
| or 128 < hidden_states.shape[0] <= 512 |
| ) |
| ): |
| if residual is None: |
| out = torch.empty_like(hidden_states) |
| _C.rms_norm_2880( |
| out, hidden_states, layernorm.weight, layernorm.eps |
| ) |
| return out, hidden_states |
| if residual.is_contiguous(): |
| _C.add_rms_norm_2880( |
| hidden_states, residual, layernorm.weight, layernorm.eps |
| ) |
| return hidden_states, residual |
| if residual is None: |
| return layernorm(hidden_states), hidden_states |
| return layernorm(hidden_states, residual) |
|
|
| def _mlp(self, hidden_states): |
| mlp = self.mlp |
| if not ( |
| hidden_states.shape[0] == 1 |
| and hidden_states.is_cuda |
| and mlp.use_trtllm |
| and mlp._H_pad != mlp.hidden_size |
| and not mlp._use_custom_op |
| ): |
| return mlp(hidden_states) |
|
|
| if not mlp._processed: |
| mlp.process_weights_after_loading() |
| padded_shape = (1, mlp._H_pad) |
| if ( |
| mlp._padded_hidden is None |
| or mlp._padded_hidden.shape != padded_shape |
| or mlp._padded_hidden.device != hidden_states.device |
| ): |
| mlp._padded_hidden = hidden_states.new_empty(padded_shape) |
| router_logits = torch.empty( |
| (1, mlp.num_experts), |
| dtype=hidden_states.dtype, |
| device=hidden_states.device, |
| ) |
| _router_small_batch_kernel[(mlp.num_experts, 1)]( |
| hidden_states, |
| mlp.router.weight, |
| mlp.router.bias, |
| router_logits, |
| mlp._padded_hidden, |
| K=mlp.hidden_size, |
| E=mlp.num_experts, |
| PAD_K=mlp._H_pad, |
| BLOCK_K=4096, |
| STORE_PAD=True, |
| num_warps=4, |
| ) |
| output = mlp.trtllm_moe( |
| mlp._padded_hidden, |
| router_logits, |
| mlp._w13_shuffled, |
| mlp._w13_scale, |
| mlp._w13_bias_f32, |
| mlp._w2_shuffled, |
| mlp._w2_scale, |
| mlp._w2_bias_f32, |
| ) |
| if mlp.tp_size > 1: |
| output = mlp.allreduce(output) |
| return output |
|
|
| def forward(self, positions, hidden_states, residual, rotary_emb): |
| hidden_states, residual = self._rms_norm( |
| hidden_states, residual, self.input_layernorm |
| ) |
| hidden_states = self.self_attn(positions, hidden_states, rotary_emb=rotary_emb) |
| hidden_states, residual = self._rms_norm( |
| hidden_states, residual, self.post_attention_layernorm |
| ) |
| hidden_states = self._mlp(hidden_states) |
| return hidden_states, residual |
|
|
