LFM2.5-VL-450M ARCHITECTURE

• Gated Short Convolution as Primary Token Mixer 62.5% of layers use depthwise convolution with input-dependent multiplicative gating instead of attention. The gating formula o = Linear(C * Conv_k(B * h~)) where B, C, h~ are all linear projections of the input provides data-dependent routing at O(n) cost. Hardware-in-the-loop search confirmed this beats SSMs, linear attention, and extra convolution variants on this model size.
• Minimal Hybrid Design (37.5% Attention) Only 6 of 16 layers use attention, placed to provide long-range retrieval where convolutions fail. This is architecturally distinct from Mamba (100% SSM), Jamba (interleaved SSM+attention), or standard transformers (100% attention). The ratio was determined empirically -- more attention layers did not improve quality on this model scale.
• PixelUnshuffle Vision-Language Projection Instead of flattening vision features or using cross-attention, LFM2.5-VL applies a PixelUnshuffle operation that reshapes (B, W, H, C) to (B, H/2, W/2, C*4), expanding channel dimension while preserving spatial locality. This feeds into a 2-layer MLP projector (3072 → 2560 → 1024). The approach reduces visual tokens by 4x while keeping local spatial relationships intact.
• NaFlex Variable-Resolution Vision SigLIP2 NaFlex supports native aspect ratios without distortion: images are smart-resized to maintain dimensions divisible by encoder_patch_size * downsample_factor = 32. Large images are tiled into non-overlapping 512x512 patches (2-10 tiles) with an optional low-resolution thumbnail for global context. Token budget is tunable at inference: min_image_tokens=32, max_image_tokens=256.
• Tempered Decoupled Knowledge Distillation The 350M backbone was trained with knowledge distillation from a 7B teacher (LFM1-7B) using Top-K=32 tempered decoupled distillation. This is a major contributor to the model punching above its weight class -- the small model learns soft targets from a 20x larger teacher.
• 3-Stage Post-Training Pipeline Stage 1: SFT on 5.39M samples across 67 sources. Stage 2: Length-normalized preference alignment on ~700K conversations. Stage 3: Model merging using parameter-space techniques (soup, task arithmetic, TIES, DARE, DELLA). This is one of the most aggressive post-training pipelines for a sub-500M model.

# Pseudocode: Gated Short Convolution Block (from LFM2 report)
def gated_conv_block(h, W_B, W_C, W_h, W_out, conv_weight, norm):
    h = norm(h)                          # Pre-norm RMSNorm
    B = h @ W_B                          # Input gate:  (batch, seq, d)
    C = h @ W_C                          # Output gate: (batch, seq, d)
    h_tilde = h @ W_h                    # Value proj:  (batch, seq, d)
    y = B * h_tilde                      # Gated input: element-wise
    z = depthwise_conv1d(y, conv_weight) # Local mixing: kernel_size=3
    out = (C * z) @ W_out                # Gated output
    return h + out                       # Residual connection
    # Followed by: h = h + swiglu_ffn(norm(h))

# Pseudocode: Multimodal Projector (from modeling_lfm2_vl.py)
def pixel_unshuffle(features, factor=2):
    # features: (batch, width, height, channels)
    # Rearrange to fold spatial dims into channel dim
    B, W, H, C = features.shape
    features = features.reshape(B, W, H // factor, factor, C)
    features = features.reshape(B, W, H // factor, C * factor)
    features = features.transpose(1, 2)  # (B, H//factor, W, C*factor)
    features = features.reshape(B, H // factor, W // factor, factor, C * factor)
    features = features.reshape(B, H // factor, W // factor, C * factor * factor)
    return features  # (B, H/2, W/2, C*4)

class Lfm2VlMultiModalProjector:
    def forward(self, image_features):
        # image_features from SigLIP2: (B, H, W, 768)
        x = pixel_unshuffle(image_features, factor=2)  # -> (B, H/2, W/2, 3072)
        x = self.layer_norm(x)                          # LayerNorm
        x = gelu(self.linear_1(x))                      # 3072 -> 2560 + GELU
        x = self.linear_2(x)                            # 2560 -> 1024
        return x

Rendered live from the MADL source below. The MADL string declares the architecture; the JavaScript parser interprets it as a vertical block stack with attention/conv substructure expanded inline. LFM2.5-VL uses a hybrid layer declaration to express the interleaved conv+attention stack.