← Latest papers
💬 NLP

From Layers to Submodules: Rethinking Granularity in Replacement-Based LLM Compression

The paper introduces SubFit, a post-training LLM compression method that overcomes the limitations of existing layer-based approaches by enabling non-contiguous, submodule-level selection of Attention and FeedForward components with individual fitted residual bypasses, thereby achieving superior accuracy-perplexity trade-offs and inference efficiency across various models and sparsity levels.

Original authors: Elia Cunegatti, Marcus Vukojevic, Erik Nielsen, Giovanni Iacca

Published 2026-06-02
📖 4 min read☕ Coffee break read

Original authors: Elia Cunegatti, Marcus Vukojevic, Erik Nielsen, Giovanni Iacca

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a Large Language Model (LLM) as a massive, high-end factory assembly line. This factory has hundreds of identical workstations (layers), and each workstation has two main workers: one who specializes in Attention (looking at the context and connecting ideas) and one who specializes in FeedForward (processing and transforming those ideas).

To make this factory run faster and use less electricity (memory), you want to remove some of these workstations. But here's the problem: if you just rip a workstation out of the middle of the line, the product (the AI's answer) falls apart because the flow of information is broken.

The Old Way: "The Neighborhood Demolition"

Previous methods tried to solve this by picking a whole contiguous block of workstations (say, layers 10 through 15) and removing them all at once. They then tried to build a single, small "shortcut tunnel" to replace that whole block.

The authors of this paper argue this is like trying to fix a broken neighborhood by knocking down a whole row of houses and building one tiny shed to replace them. It's too blunt. They realized that:

  1. Redundancy isn't neat: The "extra" work that can be removed isn't always in a neat, consecutive row. Some workstations in the middle of the line are doing very little, while others nearby are doing a lot.
  2. Different workers need different fixes: The "Attention" worker and the "FeedForward" worker are different. They need different types of shortcuts to replace them effectively.

The New Way: "SUBFIT" (The Custom Patch Job)

The paper introduces a method called SUBFIT. Instead of knocking down whole neighborhoods, SUBFIT acts like a master tailor or a surgeon.

  1. Snip and Patch, Not Demolish: It looks at every single workstation individually, regardless of where it is in the line. It picks the specific ones that are doing the least amount of unique work (the "redundant" ones) and removes them. These don't have to be next to each other; they can be scattered all over the factory.
  2. Custom-Made Bypasses: For every single workstation it removes, it sews on a tiny, custom-made "bypass" (a shortcut).
    • For the Attention workers: It uses a very simple, low-rank shortcut (like a narrow footpath).
    • For the FeedForward workers: It uses a slightly more complex path, but here's the clever trick: it shares the "blueprint" of this path across all the removed FeedForward workers. This saves a huge amount of space, like using one master key to open many different doors.

The Results: Faster, Smaller, and Still Smart

The authors tested this on ten different AI models (both basic ones and ones trained to follow instructions). They compared SUBFIT against the old "neighborhood demolition" methods.

  • The Trade-off: Usually, when you compress an AI, it gets faster but starts making more mistakes (higher "perplexity" and lower "accuracy").
  • The Winner: SUBFIT kept the AI much smarter than the old methods. At a 25% compression level (removing a quarter of the workstations), the old methods dropped to about 81% of their original intelligence. SUBFIT stayed at 84.6%.
  • The "Aggressive" Test: When they tried to compress the models even more (37.5%), the old methods fell apart completely. SUBFIT held its ground much better.
  • Speed: Because they actually removed the heavy machinery (the submodules), the factory runs faster. The AI generates its first word quicker and uses less memory (KV-cache) to remember the conversation.

The Bottom Line

The paper claims that by changing the "granularity" (the size of the pieces you cut out) from whole layers to individual sub-components, and by treating those components differently based on what they do, you can shrink AI models significantly without losing as much of their brainpower.

It's like realizing you don't need to replace an entire engine block to save weight; you just need to carefully remove the specific heavy bolts that aren't doing much work and replace them with lightweight, custom-fit spacers. The result is a lighter engine that still runs just as smoothly.

Drowning in papers in your field?

Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.

Try Digest →