🤖 AI

LatentLens: Revealing Highly Interpretable Visual Tokens in LLMs

This paper introduces LatentLens, a novel interpretability method that maps visual token representations in Vision-Language Models to natural language descriptions via nearest-neighbor retrieval from a text corpus, demonstrating that visual tokens are far more interpretable across all model layers than previously revealed by methods like LogitLens.

Original authors: Benno Krojer, Shravan Nayak, Oscar Mañas, Vaibhav Adlakha, Desmond Elliott, Siva Reddy, Marius Mosbach

Published 2026-06-12✓ Author reviewed ⓘ

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Benno Krojer, Shravan Nayak, Oscar Mañas, Vaibhav Adlakha, Desmond Elliott, Siva Reddy, Marius Mosbach

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 by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a super-smart robot that only speaks "Text." You want to show it a picture of a red building, but the robot doesn't understand images. To fix this, scientists built a small translator (a "connector") that turns the picture into a list of secret codes (tokens) that the robot can read.

The big mystery was: What do these secret codes actually mean?

For a long time, researchers tried to decode these codes using two old, slightly broken flashlights:

The "Dictionary" Flashlight (EmbeddingLens): This tried to match the code to the closest word in the robot's dictionary.
The "Next Word" Flashlight (LogitLens): This tried to guess what word the robot would say next based on the code.

The Problem: These old flashlights were dim. They often showed that the codes were gibberish or just random fragments of words. It looked like the robot was confused about what it was seeing.

Enter LATENTLENS: The "Contextual Search Engine"

The authors of this paper introduced a new tool called LATENTLENS. Instead of just looking at a dictionary or guessing the next word, LATENTLENS works like a massive, intelligent search engine.

Here is how it works, using a simple analogy:

Imagine you have a secret code for a "clock tower."

The Old Way: You ask, "What single word is closest to this code?" The answer might be "clock" or "tower," but it feels incomplete.
The LATENTLENS Way: You ask, "What full sentence in our entire library of books sounds most like this code?"
- The search engine scans millions of sentences and finds: "A large stone tower with gold clocks."
- It returns that whole sentence as the description.

The Result: Suddenly, the secret codes aren't gibberish anymore. They turn out to be highly descriptive. The robot isn't confused; it just needed the right tool to translate its internal thoughts into human language.

Key Discoveries (The "Aha!" Moments)

1. The Codes Were Always Clear (We Just Had Bad Glasses)
The paper tested 15 different robot models. With the old flashlights, they thought only about 24–32% of the image codes were understandable. With LATENTLENS, they found that 68% of the codes were actually very clear and meaningful right from the start. The robot was "seeing" the world clearly all along; we just couldn't read its notes.

2. The "Mid-Layer Leap" (The Magic Jump)
This is the most surprising finding.

Imagine the robot has a long hallway of rooms (layers) where it processes information.
When you show it a picture, the code enters at the very first room.
You might expect the code to match the "meaning" of the first room.
But it doesn't. The code from the first room actually matches the meaning of the middle rooms (like rooms 8 to 16) best.
The Metaphor: It's like dropping a letter into a mailbox (the input). You expect the letter to be read immediately, but instead, it magically "jumps" to the middle of the sorting facility where the meaning is fully formed, before it even travels through the rest of the building. The visual information instantly aligns with the robot's "semantic" (meaning-based) understanding, skipping the "word-by-word" processing.

3. Whole Sentences vs. Sub-words
The old methods often returned weird fragments like "couch" or "potato" or even punctuation marks like ",". LATENTLENS returns full, coherent phrases like "a brown and white tower-clock." It's the difference between reading a single letter of a word versus reading the whole sentence.

Why This Matters

This paper proves that when we connect a camera to a text-brain, the brain understands the picture almost immediately. It doesn't need to be "taught" to understand the image in a complex way; the image just naturally fits into the brain's existing understanding of the world.

The authors built a tool (LATENTLENS) that lets us peek inside these models and see exactly what they are "thinking" about an image, revealing that their internal vision is much more human-like and interpretable than we previously believed.

Technical Summary: LATENTLENS

Problem Statement

Transforming a Large Language Model (LLM) into a Vision-Language Model (VLM) often requires only a shallow projection (e.g., a linear layer or MLP) to map visual tokens from a vision encoder into the LLM's embedding space. While this empirical success suggests LLMs act as "universal computation engines" capable of processing arbitrary modalities, the internal mechanism remains opaque. Specifically, it is unclear how visual token representations are integrated within the LLM's latent space and, crucially, whether these representations are interpretable as semantically meaningful language at every layer of processing.

Existing interpretability methods for VLMs, such as EmbeddingLens (comparing latent vectors to the input embedding matrix) and LogitLens (projecting latent vectors through the unembedding matrix to predict vocabulary tokens), have yielded inconclusive results. Prior studies suggest visual tokens are rarely interpretable at the input level via these methods, and LogitLens often fails to provide coherent descriptions in early layers, returning subwords or unrelated tokens. This raises the question: Are visual tokens truly uninterpretable, or do current methods fail to capture the nature of their alignment with language?

Methodology: LATENTLENS

The authors propose LATENTLENS, a training-free interpretability method designed to map latent visual token representations to natural language descriptions. The core insight is that the most natural comparison for a visual token is not a static vocabulary token (as in LogitLens) or an input embedding, but rather a contextualized token representation derived from a large corpus of sentences.

Technical Workflow

Corpus Encoding: A large text corpus (e.g., Visual Genome captions) is encoded using the target LLM. For every token in every sentence, the model stores the contextualized representation vectors at specific intermediate layers ( $\ell \in \{1, 2, 4, \dots, L\}$ ).
Visual Token Extraction: Visual tokens are extracted from the VLM at various layers ( $\ell'$ ) during the forward pass.
Nearest Neighbor Search: The visual token representation $h^{(\ell')}_i$ is compared via cosine similarity against the pool of pre-computed contextualized text representations $r^{(\ell)}_{j,t}$ .
Description Retrieval: The top- $k$ nearest neighbors are retrieved. Unlike LogitLens, which returns single tokens, LATENTLENS returns the full sentence context associated with the nearest neighbor token, providing rich, sentence-level descriptions.
Evaluation: An LLM-based judge (GPT-5) evaluates whether the retrieved descriptions are semantically interpretable relative to the image patch, classifying them as concrete, abstract, or global.

Key Contributions

Novel Interpretability Framework: LATENTLENS introduces a method that utilizes contextualized embeddings rather than static vocabulary embeddings. This allows for fine-grained, sentence-level descriptions of latent visual representations.
Re-evaluation of Visual Token Interpretability: The paper challenges the prevailing assumption that visual tokens are largely uninterpretable in early layers. By using the correct "lens" (contextualized representations), the authors demonstrate that visual tokens are highly interpretable across all layers of diverse VLMs.
Discovery of the "Mid-Layer Leap": The authors identify a phenomenon where visual tokens at the input and early layers align most strongly with mid-layer textual representations (e.g., layers 8–16) rather than input or output embeddings. This suggests the projection targets semantic representations rather than purely lexical ones.
Comprehensive Benchmarking: The method is evaluated across 15 different VLM configurations (including controlled setups with OLMo, Qwen2, and LLaMA3 backbones paired with CLIP, DINOv2, and SigLIP encoders) and six off-the-shelf VLMs.

Experimental Results

Interpretability Rates: Across 15 VLMs and all layers, LATENTLENS renders 68% of visual tokens interpretable (judged by an LLM). In contrast, EmbeddingLens and LogitLens achieve only 32% and 24% interpretability, respectively.
Layer Consistency: While LogitLens shows low interpretability in early layers with a sharp increase only in later layers, LATENTLENS maintains high interpretability (60–85%) consistently from the input layer through the final layer.
Generalization: The findings hold for off-the-shelf models (e.g., Molmo, LLaVA, Qwen2-VL), where LATENTLENS consistently outperforms baselines.
Corpus Sensitivity: Ablation studies show that interpretability remains robust even with a significantly reduced corpus (1% of the full dataset yields ~67% interpretability vs. 72% for the full corpus), indicating the method does not require massive storage to be effective.
Qualitative Superiority: Visual examples demonstrate that LATENTLENS provides coherent, full-sentence descriptions (e.g., "large tower with clocks"), whereas LogitLens often returns subwords, punctuation, or unrelated next-token predictions (e.g., "es", "potato").

Significance and Claims

The paper claims that previous methods substantially underestimate the interpretability of visual tokens in VLMs. The inability of LogitLens and EmbeddingLens to reveal this interpretability is attributed to their reliance on static input/output embeddings, which do not match the semantic nature of the projected visual tokens.

The authors argue that their findings provide new evidence for the alignment between vision and language representations, supporting the "Platonic Representation Hypothesis" which posits that different modalities converge to a shared structure. The discovery of the Mid-Layer Leap offers a mechanistic explanation for why simple projections suffice to connect vision and language: the projection aligns visual inputs with the LLM's intermediate semantic representations rather than its raw lexical embeddings.

The work concludes that visual tokens are not "black boxes" but are consistently interpretable as language-like concepts when analyzed with the appropriate contextualized reference space. This opens new directions for analyzing latent representations in LLMs and understanding how multimodal models integrate non-linguistic data.