LFM3-Audio-2B / modeling_lfm3.py
paulpak58
orech
Paul Pak
LFM3-Audio-2B
9d49701 about 3 hours ago
Raw History Blame Contribute Delete
42.4 kB
# Copyright 2026 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import copy
from collections.abc import Callable

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

from transformers import initialization as init
from transformers.activations import ACT2FN
from transformers.cache_utils import Cache, DynamicCache
from transformers.configuration_utils import PreTrainedConfig
from transformers.generation import GenerationMixin
from transformers.integrations import (
    use_kernel_forward_from_hub,
    use_kernel_func_from_hub_with_fallback,
    use_kernelized_func,
)
from transformers.integrations.accelerate import force_accelerate_hooks
from transformers.masking_utils import (
    create_causal_mask,
    create_recurrent_attention_mask,
    create_sliding_window_causal_mask,
)
from transformers.modeling_layers import GradientCheckpointingLayer
from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast
from transformers.modeling_rope_utils import ROPE_INIT_FUNCTIONS, dynamic_rope_update
from transformers.modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
from transformers.processing_utils import Unpack
from transformers.utils import TransformersKwargs, auto_docstring, can_return_tuple, torch_compilable_check
from transformers.utils.generic import merge_with_config_defaults
from transformers.utils.import_utils import is_tracing
from transformers.utils.output_capturing import capture_outputs

from .configuration_lfm3 import Lfm3Config
from .lfm3_conv import can_use_lfm3_conv, lfm3_causal_conv1d, lfm3_causal_conv1d_update


@use_kernel_forward_from_hub("RMSNorm")
class Lfm3RMSNorm(nn.Module):
    def __init__(self, hidden_size, eps: float = 1e-6) -> None:
        """
        Lfm3RMSNorm is equivalent to T5LayerNorm
        """
        super().__init__()
        self.weight = nn.Parameter(torch.ones(hidden_size))
        self.variance_epsilon = eps

    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
        input_dtype = hidden_states.dtype
        hidden_states = hidden_states.to(torch.float32)
        variance = hidden_states.pow(2).mean(-1, keepdim=True)
        hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
        return self.weight * hidden_states.to(input_dtype)

    def extra_repr(self):
        return f"{tuple(self.weight.shape)}, eps={self.variance_epsilon}"


class Lfm3RotaryEmbedding(nn.Module):
    """
    Rotary embedding per attention layer type, like Gemma 3; `conv` layers register no buffers. Partial RoPE keeps the
    frequency progression of the full head dimension and zeroes the tail instead of shrinking the rotated dimension.
    """

    def __init__(self, config: Lfm3Config, device=None):
        super().__init__()
        self.max_seq_len_cached = config.max_position_embeddings
        self.original_max_seq_len = config.max_position_embeddings
        self.config = config
        self.layer_types = sorted(set(config.layer_types) & set(config.rope_parameters))
        self.rope_type = {}
        for layer_type in self.layer_types:
            rope_params = self.config.rope_parameters[layer_type]
            self.rope_type[layer_type] = rope_params["rope_type"]
            curr_inv_freq, curr_attention_scaling = self.compute_rope_parameters(config, device, layer_type=layer_type)
            setattr(self, f"{layer_type}_inv_freq", nn.Buffer(curr_inv_freq, persistent=False))
            setattr(self, f"{layer_type}_original_inv_freq", nn.Buffer(curr_inv_freq.clone(), persistent=False))
            setattr(self, f"{layer_type}_attention_scaling", curr_attention_scaling)

    @staticmethod
    def compute_default_rope_parameters(
        config: Lfm3Config, device=None, layer_type: str | None = None, **kwargs
    ) -> tuple[torch.Tensor, float]:
        """
        Inverse frequencies of the default RoPE with LFM3's zero-tail partial rotation: the first
        `partial_rotary_factor * head_dim // 2` frequencies follow the progression of the full head dimension and the
        rest are zero, leaving those dimensions unrotated.
        Returns:
            Tuple of (`torch.Tensor`, `float`): the inverse frequencies and the attention scaling factor (always 1).
        """
        base = config.rope_parameters[layer_type]["rope_theta"]
        partial_rotary_factor = config.rope_parameters[layer_type].get("partial_rotary_factor", 1.0)
        dim = getattr(config, "head_dim", None) or config.hidden_size // config.num_attention_heads
        rope_angles = int(partial_rotary_factor * dim) // 2
        inv_freq = 1.0 / (base ** (torch.arange(0, 2 * rope_angles, 2, dtype=torch.float) / dim))
        inv_freq = torch.cat((inv_freq, torch.zeros(dim // 2 - rope_angles, dtype=torch.float)))
        return inv_freq.to(device), 1.0

    @torch.no_grad()
    @dynamic_rope_update  # power user: used with advanced RoPE types (e.g. dynamic rope)
    def forward(self, x, position_ids, layer_type):
        inv_freq = getattr(self, f"{layer_type}_inv_freq")
        attention_scaling = getattr(self, f"{layer_type}_attention_scaling")

        freqs = position_ids[..., None].float() * inv_freq.to(device=x.device, dtype=torch.float)
        emb = torch.cat((freqs, freqs), dim=-1)
        cos = emb.cos() * attention_scaling
        sin = emb.sin() * attention_scaling

        return cos.to(dtype=x.dtype), sin.to(dtype=x.dtype)

    @classmethod
    def compute_rope_parameters(
        cls, config: Lfm3Config, device=None, layer_type: str | None = None
    ) -> tuple[torch.Tensor, float]:
        """Inverse frequencies of any RoPE type in the zero-tail layout: scaled types are evaluated over the full head
        dimension and truncated to the rotated prefix."""
        rope_params = config.rope_parameters[layer_type]
        if rope_params["rope_type"] == "default":
            return cls.compute_default_rope_parameters(config, device, layer_type=layer_type)
        full_config = copy.copy(config)
        full_config.rope_parameters = {
            **config.rope_parameters,
            layer_type: {**rope_params, "partial_rotary_factor": 1.0},
        }
        inv_freq, attention_factor = ROPE_INIT_FUNCTIONS[rope_params["rope_type"]](
            full_config, device, layer_type=layer_type
        )
        dim = getattr(config, "head_dim", None) or config.hidden_size // config.num_attention_heads
        rope_angles = int(rope_params.get("partial_rotary_factor", 1.0) * dim) // 2
        inv_freq = torch.cat((inv_freq[:rope_angles], inv_freq.new_zeros(dim // 2 - rope_angles)))
        return inv_freq, attention_factor


class Lfm3MLP(nn.Module):
    def __init__(self, config: Lfm3Config):
        super().__init__()
        self.w1 = nn.Linear(config.hidden_size, config.intermediate_size, bias=False)
        self.w3 = nn.Linear(config.hidden_size, config.intermediate_size, bias=False)
        self.w2 = nn.Linear(config.intermediate_size, config.hidden_size, bias=False)

    def forward(self, x):
        return self.w2(F.silu(self.w1(x)) * self.w3(x))


def rotate_half(x):
    """Rotates half the hidden dims of the input."""
    x1 = x[..., : x.shape[-1] // 2]
    x2 = x[..., x.shape[-1] // 2 :]
    return torch.cat((-x2, x1), dim=-1)


def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
    """
    This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,
    num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)
    """
    batch, num_key_value_heads, slen, head_dim = hidden_states.shape
    if n_rep == 1:
        return hidden_states
    hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim)
    return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)


def eager_attention_forward(
    module: nn.Module,
    query: torch.Tensor,
    key: torch.Tensor,
    value: torch.Tensor,
    attention_mask: torch.Tensor | None,
    scaling: float,
    dropout: float = 0.0,
    **kwargs: Unpack[TransformersKwargs],
):
    key_states = repeat_kv(key, module.num_key_value_groups)
    value_states = repeat_kv(value, module.num_key_value_groups)

    attn_weights = torch.matmul(query, key_states.transpose(2, 3)) * scaling
    if attention_mask is not None:
        attn_weights = attn_weights + attention_mask

    attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query.dtype)
    attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
    attn_output = torch.matmul(attn_weights, value_states)
    attn_output = attn_output.transpose(1, 2).contiguous()

    return attn_output, attn_weights


def apply_rotary_pos_emb(q, k, cos, sin, unsqueeze_dim=1):
    """Applies RoPE to the query and key tensors in float32, like the reference implementation."""
    cos = cos.unsqueeze(unsqueeze_dim).float()
    sin = sin.unsqueeze(unsqueeze_dim).float()
    q_embed = (q.float() * cos) + (rotate_half(q.float()) * sin)
    k_embed = (k.float() * cos) + (rotate_half(k.float()) * sin)
    return q_embed.to(q.dtype), k_embed.to(k.dtype)


class Lfm3Attention(nn.Module):
    """Llama attention with QK RMSNorm, a sigmoid output gate per head, a sliding window on `sliding_attention`
    layers and RoPE in float32."""

    def __init__(self, config: Lfm3Config, layer_idx: int):
        super().__init__()
        self.config = config
        self.layer_idx = layer_idx
        self.head_dim = getattr(config, "head_dim", config.hidden_size // config.num_attention_heads)
        self.num_key_value_groups = config.num_attention_heads // config.num_key_value_heads
        self.scaling = self.head_dim**-0.5
        self.is_causal = True
        self.q_proj = nn.Linear(config.hidden_size, config.num_attention_heads * self.head_dim, bias=False)
        self.k_proj = nn.Linear(config.hidden_size, config.num_key_value_heads * self.head_dim, bias=False)
        self.v_proj = nn.Linear(config.hidden_size, config.num_key_value_heads * self.head_dim, bias=False)
        self.o_proj = nn.Linear(config.num_attention_heads * self.head_dim, config.hidden_size, bias=False)
        self.q_norm = Lfm3RMSNorm(self.head_dim, eps=config.norm_eps)
        self.k_norm = Lfm3RMSNorm(self.head_dim, eps=config.norm_eps)
        self.gate_proj = nn.Linear(config.hidden_size, config.num_attention_heads, bias=False)
        self.sliding_window = config.sliding_window if config.layer_types[layer_idx] == "sliding_attention" else None

    def forward(
        self,
        hidden_states: torch.Tensor,
        position_embeddings: tuple[torch.Tensor, torch.Tensor],
        attention_mask: torch.Tensor | None,
        past_key_values: Cache | None = None,
        **kwargs: Unpack[TransformersKwargs],
    ) -> tuple[torch.Tensor, torch.Tensor | None]:
        input_shape = hidden_states.shape[:-1]
        hidden_shape = (*input_shape, -1, self.head_dim)

        query_states = self.q_norm(self.q_proj(hidden_states).view(*hidden_shape)).transpose(1, 2)
        key_states = self.k_norm(self.k_proj(hidden_states).view(*hidden_shape)).transpose(1, 2)
        value_states = self.v_proj(hidden_states).view(*hidden_shape).transpose(1, 2)

        cos, sin = position_embeddings
        query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)

        if past_key_values is not None:
            key_states, value_states = past_key_values.update(key_states, value_states, self.layer_idx)

        attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
            self.config._attn_implementation, eager_attention_forward
        )

        attn_output, attn_weights = attention_interface(
            self,
            query_states,
            key_states,
            value_states,
            attention_mask,
            dropout=0.0,
            scaling=self.scaling,
            sliding_window=self.sliding_window,
            **kwargs,
        )
        gate = torch.sigmoid(self.gate_proj(hidden_states)).unsqueeze(-1)
        attn_output = (attn_output * gate).reshape(*input_shape, -1).contiguous()
        attn_output = self.o_proj(attn_output)
        return attn_output, attn_weights


def apply_mask_to_padding_states(hidden_states, attention_mask):
    """
    Tunes out the hidden states for padding tokens, see https://github.com/state-spaces/mamba/issues/66
    """
    # NOTE: attention mask is a 2D boolean tensor
    if attention_mask is not None:
        dtype = hidden_states.dtype
        hidden_states = (hidden_states * attention_mask[:, :, None]).to(dtype)

    return hidden_states


@use_kernel_func_from_hub_with_fallback("causal_conv1d_update", "causal_conv1d")
def causal_conv1d_update(
    hidden_states: torch.Tensor,
    conv_state: torch.Tensor,
    weight: nn.Parameter,
    bias: nn.Parameter | None = None,
    activation: str | None = None,
):
    _, hidden_size, seq_len = hidden_states.shape
    state_len = conv_state.shape[-1]

    hidden_states_new = torch.cat([conv_state, hidden_states], dim=-1).to(weight.dtype)
    conv_state.copy_(hidden_states_new[:, :, -state_len:])
    out = F.conv1d(hidden_states_new, weight.unsqueeze(1), bias, padding=0, groups=hidden_size)
    out = out[:, :, -seq_len:]
    if activation is not None:
        out = ACT2FN[activation](out)
    return out.to(hidden_states.dtype)


@use_kernel_func_from_hub_with_fallback("causal_conv1d_fn", "causal_conv1d")
def causal_conv1d_fn(
    hidden_states: torch.Tensor,
    weight: nn.Parameter,
    bias: nn.Parameter | None = None,
    activation: str | None = None,
    **kwargs,
):
    _, hidden_size, seq_len = hidden_states.shape
    padding = weight.shape[-1] - 1

    out = F.conv1d(
        hidden_states.to(weight.dtype),
        weight=weight.unsqueeze(1),
        bias=bias,
        padding=padding,
        groups=hidden_size,
    )[:, :, :seq_len]
    if activation is not None:
        out = ACT2FN[activation](out)
    return out.to(hidden_states.dtype)


@use_kernelized_func([causal_conv1d_update, causal_conv1d_fn])
class Lfm3ShortConv(nn.Module):
    """LFM2 gated short convolution with packed-document boundaries (`seq_idx`), the padding mask re-applied after a
    biased `in_proj`, and width-7 Triton inference kernels with a PyTorch fallback."""

    def __init__(
        self,
        config: Lfm3Config,
        layer_idx: int,
    ):
        super().__init__()
        self.config = config
        self.layer_idx = layer_idx
        self.conv_kernel_size = config.conv_L_cache
        self.bias = config.conv_bias

        self.conv = nn.Conv1d(
            in_channels=config.hidden_size,
            out_channels=config.hidden_size,
            kernel_size=self.conv_kernel_size,
            groups=config.hidden_size,
            bias=self.bias,
            padding=self.conv_kernel_size - 1,
        )
        self.in_proj = nn.Linear(config.hidden_size, 3 * config.hidden_size, bias=self.bias)
        self.out_proj = nn.Linear(config.hidden_size, config.hidden_size, bias=self.bias)

        self.layer_type = config.layer_types[layer_idx]

    @force_accelerate_hooks("conv")
    def forward(
        self,
        hidden_states: torch.Tensor,
        past_key_values: Cache | None = None,
        attention_mask: torch.Tensor | None = None,
        seq_idx: torch.IntTensor | None = None,
    ):
        seq_len = hidden_states.shape[1]

        hidden_states = apply_mask_to_padding_states(hidden_states, attention_mask)
        BCx = self.in_proj(hidden_states).transpose(-1, -2)
        B, C, x = BCx.chunk(3, dim=-2)
        hidden_states = B * x
        if attention_mask is not None:
            # with `conv_bias` the projection makes the padded positions non-zero again
            hidden_states = hidden_states * attention_mask[:, None, :].to(hidden_states.dtype)

        use_precomputed_states = past_key_values is not None and past_key_values.has_previous_state(self.layer_idx)
        use_kernels = 2 <= self.conv_kernel_size <= 4
        use_wide_kernel = can_use_lfm3_conv(hidden_states, self.conv.weight)

        if use_precomputed_states and seq_len == 1 and not past_key_values.layers[self.layer_idx].record_past:
            conv_state = past_key_values.layers[self.layer_idx].conv_states[0]
            if use_wide_kernel and conv_state.shape[-1] in (6, 7):
                hidden_states = lfm3_causal_conv1d_update(
                    hidden_states, conv_state, self.conv.weight.squeeze(1), self.conv.bias
                )
            elif use_kernels:
                hidden_states = causal_conv1d_update(
                    hidden_states, conv_state, self.conv.weight.squeeze(1), self.conv.bias
                )
            else:
                hidden_states = torch.cat([conv_state, hidden_states], dim=-1)
                conv_state.copy_(hidden_states[:, :, -conv_state.shape[-1] :])
                hidden_states = self._conv(hidden_states)[:, :, -seq_len:]
        else:
            if past_key_values is not None and seq_idx is not None:
                # `seq_idx` is only set on an empty cache, and the decode steps read the cached window without it:
                # only the last document (after any positional left padding) may enter the window
                last_document = (seq_idx == seq_idx[:, -1:])[:, None].to(hidden_states.dtype)
                past_key_values.update_conv_state(
                    hidden_states * last_document, self.layer_idx, conv_kernel_size=self.conv_kernel_size
                )
            elif past_key_values is not None:
                hidden_states = past_key_values.update_conv_state(
                    hidden_states, self.layer_idx, conv_kernel_size=self.conv_kernel_size
                )

            if use_wide_kernel:
                hidden_states = lfm3_causal_conv1d(hidden_states, self.conv.weight.squeeze(1), self.conv.bias, seq_idx)
            elif seq_idx is not None:
                hidden_states = self._segmented_conv(hidden_states, seq_idx)
            elif use_kernels:
                hidden_states = causal_conv1d_fn(hidden_states, self.conv.weight.squeeze(1), self.conv.bias)
            else:
                hidden_states = self._conv(hidden_states)

            # Drop the additional previous states
            if past_key_values is not None:
                hidden_states = hidden_states[:, :, -seq_len:]

        y = C * hidden_states
        y = y.transpose(-1, -2).contiguous()
        y = self.out_proj(y)
        return y

    def _conv(self, hidden_states: torch.Tensor) -> torch.Tensor:
        """Causal depthwise conv in torch: the `causal_conv1d` kernels only accept widths 2 to 4."""
        conv_out = self.conv(hidden_states.to(self.conv.weight.dtype))[..., : hidden_states.shape[-1]]
        return conv_out.to(hidden_states.dtype)

    def _segmented_conv(self, hidden_states: torch.Tensor, seq_idx: torch.Tensor) -> torch.Tensor:
        """Causal depthwise conv that only reads positions sharing the current token's document index."""
        kernel_size = self.conv_kernel_size
        seq_idx = F.pad(seq_idx, (hidden_states.shape[-1] - seq_idx.shape[-1] + kernel_size - 1, 0), value=-1)
        windows = F.pad(hidden_states, (kernel_size - 1, 0)).unfold(-1, kernel_size, 1)
        seq_idx_windows = seq_idx.unfold(-1, kernel_size, 1)
        same_document = (seq_idx_windows == seq_idx_windows[..., -1:]).unsqueeze(1)
        conv_out = torch.einsum("bdtk,dk->bdt", windows * same_document.to(windows.dtype), self.conv.weight.squeeze(1))
        if self.bias:
            conv_out = conv_out + self.conv.bias[None, :, None]
        return conv_out.to(hidden_states.dtype)


class Lfm3DecoderLayer(GradientCheckpointingLayer):
    def __init__(self, config: Lfm3Config, layer_idx: int):
        super().__init__()
        self.is_attention_layer = config.layer_types[layer_idx] in config._attention_layer_types
        self.use_sandwich_norm = config.use_sandwich_norm

        if self.is_attention_layer:
            self.self_attn = Lfm3Attention(config, layer_idx)
        else:
            self.conv = Lfm3ShortConv(config, layer_idx)
        self.feed_forward = Lfm3MLP(config)
        self.operator_norm = Lfm3RMSNorm(config.hidden_size, eps=config.norm_eps)
        self.ffn_norm = Lfm3RMSNorm(config.hidden_size, eps=config.norm_eps)
        if self.use_sandwich_norm:
            self.post_operator_norm = Lfm3RMSNorm(config.hidden_size, eps=config.norm_eps)
            self.post_ffn_norm = Lfm3RMSNorm(config.hidden_size, eps=config.norm_eps)

    def forward(
        self,
        hidden_states: torch.Tensor,
        position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
        attention_mask: torch.Tensor | None = None,
        position_ids: torch.LongTensor | None = None,
        past_key_values: Cache | None = None,
        seq_idx: torch.IntTensor | None = None,
        **kwargs,
    ) -> torch.Tensor:
        residual = hidden_states
        if self.is_attention_layer:
            hidden_states, _ = self.self_attn(
                hidden_states=self.operator_norm(hidden_states),
                position_embeddings=position_embeddings,
                attention_mask=attention_mask,
                position_ids=position_ids,
                past_key_values=past_key_values,
                **kwargs,
            )
        else:
            hidden_states = self.conv(
                hidden_states=self.operator_norm(hidden_states),
                past_key_values=past_key_values,
                attention_mask=attention_mask,
                seq_idx=seq_idx,
            )
        if self.use_sandwich_norm:
            hidden_states = self.post_operator_norm(hidden_states)
        hidden_states = hidden_states + residual

        ffn_out = self.feed_forward(self.ffn_norm(hidden_states))
        if self.use_sandwich_norm:
            ffn_out = self.post_ffn_norm(ffn_out)
        hidden_states = hidden_states + ffn_out

        return hidden_states


def create_masks_by_layer_type(
    config: PreTrainedConfig,
    inputs_embeds: torch.Tensor,
    attention_mask: torch.Tensor | None,
    past_key_values: Cache | None,
    position_ids: torch.Tensor | None = None,
) -> dict:
    """The cache sizes each mask from the layer it is asked about, and the generic mask utilities ask about the first
    non-sliding layer, which for a leading `conv` layer redirects to the first attention layer of any type: name the
    first layer of each mask's own type instead."""
    config = config.get_text_config()
    mask_kwargs = {
        "config": config,
        "inputs_embeds": inputs_embeds,
        "attention_mask": attention_mask,
        "past_key_values": past_key_values,
        "position_ids": position_ids,
    }
    layer_types, causal_mask_mapping = config.layer_types, {}
    if "full_attention" in layer_types:
        layer_idx = layer_types.index("full_attention")
        causal_mask_mapping["full_attention"] = create_causal_mask(**mask_kwargs, layer_idx=layer_idx)
    if "sliding_attention" in layer_types:
        layer_idx = layer_types.index("sliding_attention")
        causal_mask_mapping["sliding_attention"] = create_sliding_window_causal_mask(
            **mask_kwargs, layer_idx=layer_idx
        )
    if "conv" in layer_types:
        causal_mask_mapping["conv"] = create_recurrent_attention_mask(**mask_kwargs)
    return causal_mask_mapping


@auto_docstring
class Lfm3PreTrainedModel(PreTrainedModel):
    config: Lfm3Config
    base_model_prefix = "model"
    supports_gradient_checkpointing = True
    _no_split_modules = ["Lfm3DecoderLayer"]
    _skip_keys_device_placement = ["past_key_values"]
    _supports_flash_attn = True
    _supports_sdpa = True
    _supports_flex_attn = True

    _can_compile_fullgraph = True
    _supports_attention_backend = True
    _can_record_outputs = {
        "hidden_states": Lfm3DecoderLayer,
        "attentions": Lfm3Attention,
    }

    @torch.no_grad()
    def _init_weights(self, module):
        super()._init_weights(module)
        if isinstance(module, Lfm3RotaryEmbedding):
            for layer_type in module.layer_types:
                curr_inv_freq, _ = module.compute_rope_parameters(module.config, layer_type=layer_type)
                init.copy_(getattr(module, f"{layer_type}_inv_freq"), curr_inv_freq)
                init.copy_(getattr(module, f"{layer_type}_original_inv_freq"), curr_inv_freq)

    @staticmethod
    def create_masks_for_generate(
        config: PreTrainedConfig,
        inputs_embeds: torch.Tensor,
        attention_mask: torch.Tensor | None,
        past_key_values: Cache | None,
        position_ids: torch.Tensor | None = None,
        **kwargs,
    ) -> dict:
        return create_masks_by_layer_type(config, inputs_embeds, attention_mask, past_key_values, position_ids)


def packed_under_padding(position_ids: torch.Tensor, padding_mask: torch.Tensor, filled) -> torch.Tensor:
    """Padding repeats position 0, so packing is a restart between two kept tokens, or a kept position 0 on a filled
    cache whose row holds a kept token; attention under a padding mask cannot isolate it."""
    restarts = torch.diff(position_ids, prepend=position_ids[:, :1] - 1, dim=-1) != 1
    valid = padding_mask[:, -restarts.shape[-1] :].bool()
    packed = restarts[:, 1:] & valid[:, 1:] & valid[:, :-1]
    if filled:
        # a row whose cached tokens are all padding (chunked prefill of a left-padded batch) has no document to pack
        # against; a mask covering only the chunk keeps the strict rule
        cached = padding_mask[:, : padding_mask.shape[-1] - restarts.shape[-1]]
        cached_valid = cached.bool().any(-1, keepdim=True) if cached.shape[-1] else torch.ones_like(valid[:, :1])
        packed = packed | (valid[:, :1] & (position_ids[:, :1] == 0) & cached_valid)
    return packed


@auto_docstring
class Lfm3Model(Lfm3PreTrainedModel):
    """LFM2 model with sliding-attention layers as a third layer type: the mask and the rotary embedding are built per
    layer type, and packed documents (`position_ids` restarting) reset the short-conv window through `seq_idx`."""

    def __init__(self, config: Lfm3Config):
        super().__init__(config)
        self.padding_idx = config.pad_token_id
        self.vocab_size = config.vocab_size

        self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx)
        self.layers = nn.ModuleList(
            [Lfm3DecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
        )
        self.rotary_emb = Lfm3RotaryEmbedding(config=config)
        self.gradient_checkpointing = False
        self.embedding_norm = Lfm3RMSNorm(config.hidden_size, eps=config.norm_eps)

        # Initialize weights and apply final processing
        self.post_init()

    @merge_with_config_defaults
    @capture_outputs
    @auto_docstring
    def forward(
        self,
        input_ids: torch.LongTensor | None = None,
        attention_mask: torch.Tensor | None = None,
        position_ids: torch.LongTensor | None = None,
        past_key_values: Cache | None = None,
        inputs_embeds: torch.FloatTensor | None = None,
        use_cache: bool | None = None,
        **kwargs: Unpack[TransformersKwargs],
    ) -> BaseModelOutputWithPast:
        r"""
        attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)` or `dict`, *optional*):
            Mask to avoid performing attention on padding token indices (1 keeps a token, 0 masks it), or the mask
            dict of `create_masks_for_generate`. A mask dict is used as given: `generate` refuses packed
            `position_ids` before its prefill.
        """
        if (input_ids is None) ^ (inputs_embeds is not None):
            raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
        # `seq_idx` is a shared kwarg (`DataCollatorWithFlattening(return_seq_idx=True)`, read by Lfm2); LFM3 derives
        # the documents from the restarting `position_ids` that come with it
        if kwargs.pop("seq_idx", None) is not None and position_ids is None:
            raise ValueError("Pass packed documents as `position_ids` restarting at 0; LFM3 does not read `seq_idx`")

        if inputs_embeds is None:
            inputs_embeds = self.embed_tokens(input_ids)

        if use_cache and past_key_values is None:
            past_key_values = DynamicCache(config=self.config)
        filled = past_key_values is not None and (
            past_key_values.get_seq_length() > 0
            if any(t != "conv" for t in self.config.layer_types)
            else past_key_values.has_previous_state()
        )
        packed_cache = getattr(past_key_values, "lfm3_packed", None)
        if isinstance(packed_cache, torch.Tensor) or packed_cache:
            # Reset layers have no history to mix. Ordinary caches carry a Python `False` and skip this, so the decode
            # steps do no tensor work here; only a compiled packed prefill leaves a tensor flag, and `filled` stays
            # tensor-valued for static caches.
            packed_message = (
                "A cache filled by a packed-document forward cannot be continued: its attention spans the documents"
            )
            packed_cache = packed_cache & filled if isinstance(packed_cache, torch.Tensor) else filled
            if isinstance(packed_cache, torch.Tensor):
                torch_compilable_check(~packed_cache, packed_message)
                if not is_tracing(packed_cache):
                    past_key_values.lfm3_packed = bool(packed_cache)
            elif packed_cache:
                raise ValueError(packed_message)
            else:
                past_key_values.lfm3_packed = False

        # The mask utilities detect packing only with `attention_mask=None`, so a multi-token forward with explicit
        # positions drops the all-ones mask tokenizers emit (a data-dependent check, hence not when traced).
        explicit_positions = position_ids is not None and inputs_embeds.shape[1] > 1
        if (
            explicit_positions
            and isinstance(attention_mask, torch.Tensor)
            and attention_mask.ndim == 2
            and not is_tracing(position_ids)
            and bool(attention_mask.all())
        ):
            attention_mask = None
        seq_idx = None
        if position_ids is None:
            past_seen_tokens = past_key_values.get_seq_length() if past_key_values is not None else 0
            position_ids = torch.arange(inputs_embeds.shape[1], device=inputs_embeds.device) + past_seen_tokens
            position_ids = position_ids.unsqueeze(0)
        elif explicit_positions and not isinstance(attention_mask, dict):
            # a mask dict comes from `generate`, which refused packing before its prefill
            if isinstance(attention_mask, torch.Tensor) and attention_mask.ndim == 2:
                # data-dependent: a traced forward skips it (`generate` refuses packing eagerly before its prefill)
                if not is_tracing(position_ids):
                    torch_compilable_check(
                        ~packed_under_padding(position_ids, attention_mask, filled),
                        "Packed documents (`position_ids` restarting) cannot be combined with an attention mask: "
                        "attention would not isolate the documents. Pass `attention_mask=None` without a static cache.",
                    )
            else:
                restarts = torch.diff(position_ids, prepend=position_ids[:, :1] - 1, dim=-1) != 1
                document_ids = restarts.cumsum(-1)
                if is_tracing(position_ids) or bool((document_ids[..., -1] > 0).any()):
                    seq_idx = document_ids.to(torch.int32)
                # Packed documents are prefilled in one forward on an empty cache (cached tokens would join the first
                # document), and their cache is never continued
                if filled:
                    torch_compilable_check(
                        (~restarts[:, 1:]).all() & (position_ids[:, 0] != 0).all(),
                        "Packed documents must be prefilled in one forward; the cache already holds tokens",
                    )
                    # Ordinary continuation must retain the convolution window from the cached document.
                    seq_idx = None
                if attention_mask is None:
                    # without a mask only the cacheless packed-sequence mask isolates repeated zero positions (left
                    # padding): a cache-sized mask and every later decode step would attend them, so they count too
                    packed = (document_ids[..., -1] > 0).any()
                else:
                    # a prepared 4D mask is the caller's and carries the padding (repeated zero positions), but may
                    # or may not isolate documents, so the cache records the packing and is never continued
                    steps = torch.diff(position_ids, dim=-1)
                    packed = ((steps != 1) & ~((steps == 0) & (position_ids[:, :-1] == 0))).any()
                if past_key_values is not None:
                    # resolved here, where the prefill already syncs, so the decode steps carry a Python flag: no
                    # per-step host sync, data-dependent op or CUDA-graph output on the cache
                    past_key_values.lfm3_packed = packed if is_tracing(position_ids) else bool(packed)

        if not isinstance(causal_mask_mapping := attention_mask, dict):
            mask_kwargs = {
                "config": self.config,
                "inputs_embeds": inputs_embeds,
                "attention_mask": attention_mask,
                "past_key_values": past_key_values,
                "position_ids": position_ids,
            }
            # The mask utilities only isolate packed documents without a cache, and an empty cache adds nothing.
            layer_types = self.config.layer_types
            if seq_idx is not None and past_key_values is not None:
                attention_layer = next((i for i, t in enumerate(layer_types) if t != "conv"), None)
                if attention_layer is not None and past_key_values.get_seq_length(attention_layer) == 0:
                    if past_key_values.is_compileable:
                        # static layers always return their full length, so the masks are sized by the cache, which
                        # isolates neither documents nor positional-only left padding
                        torch_compilable_check(
                            ~packed,
                            "Packed documents, or left padding without an attention mask, cannot be prefilled into a "
                            "static cache: its masks are sized by the cache. Pass the padding as `attention_mask`, or "
                            "use a `DynamicCache` for packed documents",
                        )
                    else:
                        mask_kwargs["past_key_values"] = None
            causal_mask_mapping = create_masks_by_layer_type(**mask_kwargs)

        hidden_states = inputs_embeds
        position_embeddings = {
            layer_type: self.rotary_emb(hidden_states, position_ids=position_ids, layer_type=layer_type)
            for layer_type in self.rotary_emb.layer_types
        }

        for i, decoder_layer in enumerate(self.layers[: self.config.num_hidden_layers]):
            layer_type = self.config.layer_types[i]
            hidden_states = decoder_layer(
                hidden_states,
                attention_mask=causal_mask_mapping[layer_type],
                position_embeddings=position_embeddings.get(layer_type),
                position_ids=position_ids,
                past_key_values=past_key_values,
                seq_idx=seq_idx,
                **kwargs,
            )

        hidden_states = self.embedding_norm(hidden_states)

        return BaseModelOutputWithPast(
            last_hidden_state=hidden_states,
            past_key_values=past_key_values,
        )


def reject_packed_generation(config: PreTrainedConfig, input_ids, generation_config, model_kwargs, is_first_iteration):
    """`generate` decodes from the cache its prefill fills, and no mask it builds isolates packed documents
    (`position_ids` restarting): the prompt is refused before the prefill, one forward or every chunk, writes to it."""
    position_ids, attention_mask = model_kwargs.get("position_ids"), model_kwargs.get("attention_mask")
    cache = model_kwargs.get("past_key_values")
    if cache is None or position_ids is None or position_ids.ndim != 2:
        return
    if attention_mask is not None and attention_mask.ndim != 2:
        return
    has_attention = any(t != "conv" for t in config.get_text_config().layer_types)
    filled = bool(cache.get_seq_length() > 0 if has_attention else cache.has_previous_state())
    inputs_embeds = model_kwargs.get("inputs_embeds") if is_first_iteration else None
    length = input_ids.shape[1] if inputs_embeds is None else inputs_embeds.shape[1]
    if generation_config.prefill_chunk_size is not None:
        # the chunks run from the start of the prompt
        position_ids = position_ids[:, :length]
    else:
        if filled and has_attention:
            # the slice `_prefill` feeds: a prompt that spans the cache is cut to its uncached part
            mask_length = getattr(generation_config, "_mask_length", -1)
            if attention_mask is not None:
                mask_length = attention_mask.shape[1]
            if inputs_embeds is not None or mask_length == length:
                length -= int(cache.get_seq_length())
        position_ids = position_ids[:, position_ids.shape[1] - length :]
    if attention_mask is None:
        attention_mask = torch.ones_like(position_ids)
    if bool(packed_under_padding(position_ids, attention_mask, filled).any()):
        raise ValueError(
            "`generate` cannot decode packed documents (`position_ids` restarting, or starting at 0 on a cache that "
            "holds tokens): attention would span them. Generate each document in its own row of a left-padded batch."
        )


@auto_docstring
class Lfm3ForCausalLM(Lfm3PreTrainedModel, GenerationMixin):
    _tied_weights_keys = {"lm_head.weight": "model.embed_tokens.weight"}
    _tp_plan = {"lm_head": "colwise_gather_output"}
    _pp_plan = {"lm_head": (["hidden_states"], ["logits"])}
    _fsdp_plan = {"lm_head": "keep_full_weight"}

    def __init__(self, config):
        super().__init__(config)
        self.model = Lfm3Model(config)
        self.vocab_size = config.vocab_size
        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)

        # Initialize weights and apply final processing
        self.post_init()

    @can_return_tuple
    @auto_docstring
    def forward(
        self,
        input_ids: torch.LongTensor | None = None,
        attention_mask: torch.Tensor | None = None,
        position_ids: torch.LongTensor | None = None,
        past_key_values: Cache | None = None,
        inputs_embeds: torch.FloatTensor | None = None,
        labels: torch.LongTensor | None = None,
        use_cache: bool | None = None,
        logits_to_keep: int | torch.Tensor = 0,
        **kwargs: Unpack[TransformersKwargs],
    ) -> CausalLMOutputWithPast:
        r"""
        Example:
        ```python
        >>> from transformers import AutoTokenizer, Lfm3ForCausalLM
        >>> model = Lfm3ForCausalLM.from_pretrained("LiquidAI/LFM3-1.7B-Preview")
        >>> tokenizer = AutoTokenizer.from_pretrained("LiquidAI/LFM3-1.7B-Preview")
        >>> inputs = tokenizer.apply_chat_template(
        ...     [{"role": "user", "content": "What is C. elegans?"}], add_generation_prompt=True, return_tensors="pt"
        ... )
        >>> generate_ids = model.generate(**inputs, max_new_tokens=64)
        >>> tokenizer.decode(generate_ids[0, inputs["input_ids"].shape[1] :], skip_special_tokens=True)
        ```"""
        outputs: BaseModelOutputWithPast = self.model(
            input_ids=input_ids,
            attention_mask=attention_mask,
            position_ids=position_ids,
            past_key_values=past_key_values,
            inputs_embeds=inputs_embeds,
            use_cache=use_cache,
            **kwargs,
        )

        hidden_states = outputs.last_hidden_state
        # Only compute necessary logits, and do not upcast them to float if we are not computing the loss
        slice_indices = slice(-logits_to_keep, None) if isinstance(logits_to_keep, int) else logits_to_keep
        logits = self.lm_head(hidden_states[:, slice_indices, :])

        loss = None
        if labels is not None:
            loss = self.loss_function(logits=logits, labels=labels, vocab_size=self.config.vocab_size, **kwargs)

        return CausalLMOutputWithPast(
            loss=loss,
            logits=logits,
            past_key_values=outputs.past_key_values,
            hidden_states=outputs.hidden_states,
            attentions=outputs.attentions,
        )

    def _prefill(self, input_ids, generation_config, model_kwargs, is_first_iteration=True):
        # every prefill passes here once before its first forward: a check per chunk would leave the earlier chunks
        # in the cache, and a dynamic cache would only refuse packing at the first decode step
        reject_packed_generation(self.config, input_ids, generation_config, model_kwargs, is_first_iteration)
        return super()._prefill(input_ids, generation_config, model_kwargs, is_first_iteration=is_first_iteration)


__all__ = ["Lfm3ForCausalLM", "Lfm3Model", "Lfm3PreTrainedModel"]