The Expansion Compression Dynamics of Neural Representations

26 concepts18 papers1 proposal

When we look at the hidden layers of a deep neural network, we are looking at data written in a high-dimensional language. A model like Llama or CLIP might project a single word or image into a vector space of 4,096 dimensions. However, the data rarely utilizes the full freedom of that massive space. Instead, it sits on a much lower-dimensional, highly curved surface curled inside the ambient space—a representation manifold.

To understand how a model processes information, we can measure its Intrinsic Dimensionality (ID): the minimum number of coordinates needed to describe the data without losing vital information.

For years, a common assumption was that deep networks steadily and monotonically simplify data layer by layer, stripping away noise until only the final answer remains. But recent geometric analyses paint a far more dynamic picture. As data flows through a network, and as a network evolves over training time, it undergoes a non-monotonic expansion-compression cycle. Networks do not just compress information; they actively blow it up into high-dimensional abstractions before distilling it into low-dimensional certainties.


The Layer-by-Layer Trajectory: Disentangling to Decide

If you plot the intrinsic dimensionality of a model's activations layer by layer, you do not see a downward slope. Instead, you see a distinct "hunchback" or bell-shaped curve.

Intrinsic 
Dimension
   ^
   |         * * *  (High-Dimensional Abstraction)
   |       *       *
   |     *           *
   |   *               * * (Task Commitment / Output)
   | *
   +-----------------------------> Depth (Layers)
  Input

This geometric signature reveals a two-phase processing strategy common to language, vision, and biological sequence models:

1. The Expansion Phase (Unfolding)

In the early layers, the intrinsic dimensionality rises sharply. Why would a network intentionally make its representations more complex? The answer lies in the need to disentangle features. Raw inputs—like individual tokens or visual pixels—are highly coupled with surface-level statistics.

To separate syntax from semantics, or a typographic pattern from an underlying concept, the model projects the data into a higher-dimensional space. As noted by Hanzhang Wang et al. in Textural or Textual: How Vision-Language Models Read Text in Images, vision-language models use these early phases to capture low-level visual features before they can map them to high-level conceptual categories. By expanding the effective degrees of freedom, the network "unfolds" the data manifold, making complex relationships easier to manipulate.

This unfolding also straightens the paths that sentences take through activation space. Eghbal A. Hosseini et al. discovered in Large language models implicitly learn to straighten neural sentence trajectories to construct a predictive representation of natural language. that language models flatten the curvature of sentence trajectories as they approach the middle layers, making the next linguistic step predictable via simple linear extrapolation.

2. The Mid-Network Peak (Abstraction)

In the intermediate layers, the intrinsic dimensionality reaches its apex. As Emily Cheng et al. demonstrate in Emergence of a High-Dimensional Abstraction Phase in Language Transformers, this peak marks a functional pivot point: a high-dimensional abstraction phase. Here, the model discards surface-level text features (like sentence length or exact word choice) and represents abstract linguistic structures like syntax and deep semantics. The complexity of internal representations is highest here because the model is evaluating a vast web of context and potential meanings.

3. The Compression Phase (Commitment)

Once the abstract features are extracted, the trajectory reverses. In the later layers, the intrinsic dimensionality sharply contracts. Abhinav Joshi et al. describe this in Geometry of Decision Making in Language Models as the moment the model "commits" to a specific decision.

To output a single word or classification, the model must collapse the high-dimensional cloud of abstract possibilities down to a low-dimensional state focused entirely on output selection. Diego Doimo et al. confirm this phase transition in The Representation Landscape of Few-Shot Learning and Fine-Tuning in Large Language Models, showing that the later layers witness a significant reduction in distinct probability modes as the network narrows its focus to task-oriented logic.

This universal geometry isn't exclusive to text. Kosio Beshkov et al. found the exact same expansion-contraction pattern in Towards Understanding the Shape of Representations in Protein Language Models, proving that whether a model is processing human paragraphs or biological amino acid sequences, the geometric mechanics of abstraction remain the same.


The Training Axis: How the Hunchback is Born

This elegant layer-by-layer geometry does not exist at initialization; it is carved into the weights over the course of training. Just as data undergoes an expansion-compression cycle as it flows through a trained network, the network's global representation space undergoes a non-monotonic geometric evolution across training time.

When a model first begins to pretrain, its internal geometry progresses through highly predictable, non-monotonic phases. Work by Melody Zixuan Li et al. in Tracing the Representation Geometry of Language Models from Pretraining to Post-training maps this out as a triphasic trajectory:

  1. Initial Collapse (Warmup): The model first suppresses random initialization noise, causing a sudden drop in representation dimensionality. As Xuyang Ge et al. note in Evolution of Concepts in Language Model Pre-Training, this is a "statistical" phase where the model aligns its basic data orientations and learns simple word frequencies.
  2. Entropy-Seeking (Expansion): Next, the model enters an expansion phase. It begins to pack more complex concepts, long-range dependencies, and data statistics into its activation space, causing the global intrinsic dimension to climb.
  3. Compression-Seeking (Generalization): Finally, the model enters a compression phase. It selectively prunes its representation space, distilling memorized statistics into structured, generalized features.

This macro-level training cycle directly mirrors the micro-level layer behavior. Anton Razzhigaev et al. show in The Shape of Learning: Anisotropy and Intrinsic Dimensions in Transformer-Based Models that this training dynamic is what allows decoders to unfold information into high-dimensional spaces before refining them into efficient, compact representations.

Crucially, this geometric evolution is tied to the emergence of actual reasoning. Jin Hwa Lee et al. demonstrate in Geometric Signatures of Compositionality Across a Language Model's Lifetime that when a model transitions from learning superficial word patterns to understanding hierarchical, compositional language, its nonlinear intrinsic dimension undergoes a sharp, sudden phase transition.

Remarkably, these behavioral and geometric phases are highly consistent. As James A. Michaelov et al. show in Language Model Behavioral Phases are Consistent Across Architecture, Training Data, and Scale, and Xin Du et al. reinforce in Correlation Dimension of Autoregressive Large Language Models, this progression from local token patterns to long-range context compression occurs reliably across different model families (Transformers, Mamba, RWKV) and parameter scales.


Why It Works: The Utility of the Geometric Tell

Understanding the expansion-compression cycle gives us a powerful diagnostic tool. Because the shape of the representation manifold reflects how confident or "confused" a model is, we can read its geometry to predict its behavior without ever looking at its final output tokens.

Detecting Hallucinations

When a model is prompted with something it understands well, its internal token representations contract smoothly into a low-dimensional space toward the output layers. But what happens when it hallucinates?

Karthik Viswanathan et al. discovered in The Geometry of Tokens in Internal Representations of Large Language Models that when a model is confused or experiencing high loss, its internal tokens fail to compress efficiently, remaining scattered across a higher-dimensional space.

By measuring this Local Intrinsic Dimension (LID) layer by layer, Fan Yin et al. demonstrated in Characterizing Truthfulness in Large Language Model Generations with Local Intrinsic Dimension that we can catch hallucinations in real-time. A failure to compress in the later layers serves as a geometric "tell" that the model is generating untruthful or ungrounded text, outperforming traditional entropy-based uncertainty metrics.

As models scale in width, depth, and training duration, their final layers tend toward an ideal state known as "Neural Collapse"—a extreme geometric simplification where intra-class representations collapse into perfectly symmetrical, clean structures. Robert Wu et al. show in Linguistic Collapse: Neural Collapse in (Large) Language Models that this collapse emerges naturally in massive language models despite their imbalanced vocabularies, and its presence is tightly correlated with a model's ability to generalize.

Because an effective architecture must be capable of executing this expansion-compression signature, we can use ID as a shortcut for model design. Instead of running expensive gradient-based training to evaluate a new model structure, Jiangchao Yao et al. developed NAS-LID: Efficient Neural Architecture Search with Local Intrinsic Dimension. By tracking the progression of intrinsic dimensionality using only fast, forward-pass representations, they cut GPU memory usage by up to 86% while accurately identifying top-performing neural architectures.

Ultimately, the expansion-compression cycle shows us that learning is a balancing act. To reason, a model must first open its mind—expanding its representation space to capture the rich, high-dimensional nuances of the world. But to act, it must close it—compressing those abstractions into a sharp, low-dimensional point of decision.

Key Foundational Work

The Shape of Learning: Anisotropy and Intrinsic Dimensions in Transformer-Based Models (2024) — contributed 2 concept elements to this direction.
The Representation Landscape of Few-Shot Learning and Fine-Tuning in Large Language Models (2024) — contributed 2 concept elements to this direction.
Characterizing Truthfulness in Large Language Model Generations with Local Intrinsic Dimension (2024) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_intrinsic_dimensionality_peak_35b21df6,
  title = {intrinsic dimensionality peak},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/intrinsic-dimensionality-peak/rdr_35b21df6d00c49f0a0330badda298f5a},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_intrinsic_dimensionality_peak_35b21df6_v1,
  title = {intrinsic dimensionality peak},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/intrinsic-dimensionality-peak/rdr_35b21df6d00c49f0a0330badda298f5a/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake