Formalizing the Binding Problem

Formalizing the Binding Problem: An Information-Theoretic Approach to Visual Representations

When looking at a scene, our brains easily know which color belongs to which shape. This paper creates a mathematical way to measure if AI models can do the same. It finds that while summary tokens miss much of this info, spatial tokens capture it almost perfectly.

In computer vision, we often assume that if a model recognizes "red" and "square," it has understood the scene. But there is a massive difference between knowing a scene contains red and knowing there is a red square. This distinction is the "binding problem"—the ability to correctly associate specific features with specific objects.

Current Vision Transformers (ViTs) are excellent at recognizing features. However, they frequently stumble when objects share those features. As shown in, vision-language models often suffer from feature misattribution.

They might incorrectly describe a grid pattern by combining elements from adjacent blocks. Despite this visible failure, we have lacked a formal way to quantify exactly how much "binding information" is present in a model's internal representations.

The Problem

The status quo in visual representation learning treats objects and features as somewhat interchangeable high-level signals. We rely on models to implicitly learn the conjunction (the joining) of attributes. Yet, we lack a metric to diagnose when they fail. Most current evaluations are "symptomatic." We look at downstream task accuracy and infer that the model failed at binding.

This is problematic. A model might fail a reasoning task for many reasons. It could have poor feature recognition or logical errors. It might not be a failure to bind. Furthermore, existing mechanistic approaches often use simple linear probes (simple layers that map features to labels) to inspect representations. The authors argue that linear probes are insufficient. Binding is a combinatorial problem. Separating complex attribute associations often requires non-linear interactions. Without a formal framework, we cannot distinguish between a model that doesn't "know" the features and a model that knows the features but cannot "bind" them together.

How It Works

The authors address this by introducing an information-theoretic framework. They define binding as the mutual information (a measure of how much two variables tell you about each other) between an "object code" and the model's representation $Z$.

The methodology follows a structured pipeline to move from abstract theory to measurable bits:

1. Defining the Codes: They define a feature code $F$ (which features exist) and an object code $O$ (which specific conjunctions of features exist). They treat binding as the information the representation provides about the object code.
2. The Probing Mechanism: Predicting an exponential space of object combinations is impossible. To solve this, they use an autoregressive decomposition. Instead of predicting the whole object vector at once, they train conditional probes $q_\theta(o_k | o_{<k}, z)$. These predict the presence of the $k$-th object given the status of the previous $k-1$ objects.
3. Estimating Uncertainty: They leverage the relationship between cross-entropy loss (a common loss function for classification) and conditional entropy. By training these probes to minimize loss, they estimate the uncertainty $H(O|Z)$. This allows them to calculate the binding information $B_O(Z)$ in bits.
4. Measuring Conditional Binding: To ensure they aren't just measuring feature recognition, they introduce conditional binding information $B^_{O,F}(Z)$. This measures the binding information that exists beyond* what can be explained by the feature code alone.

The framework is visualized in .

It outlines the transition from feature/object sets to the entropy-based calculation of binding information.

Numbers

The most striking result is the massive discrepancy between different parts of the ViT architecture. Using a DINOv2-Large backbone on a synthetic ColorShape dataset, the authors find that the $[CLS]$ summary token is surprisingly inadequate. This token is the standard output used for most downstream tasks. The paper reports that the $[CLS]$ token encodes less than half (48.5%) of the total binding information in a scene. Even when conditioning on features, the $[CLS]$ token only captures 42.4% of the binding information.

In contrast, the spatial tokens (the individual patch representations) hold the vast majority of the signal. When the authors apply a simplified attention probe to the full set of spatial tokens, they report that the model can decode 92.2% of the binding information.

The authors also observe a structural pattern in the $[CLS]$ token. While a Deep Neural Network (DNN) probe performs best, a quadratic probe performs nearly as well. This suggests that the binding information stored in the summary token is largely structured as second-order interactions (dot products) between feature projections.

The sensitivity of binding to environmental factors is also quantified. In the CLEVR dataset, binding information decays monotonically as occlusion increases .

Additionally, as the complexity of the feature space grows, the fraction of binding information the model captures decreases .

What's Missing

While the framework is mathematically rigorous, there are several gaps that a practitioner should note:

• Discrete vs. Continuous: The framework relies on predefined, discrete feature vocabularies (e.g., "red," "square"). Real-world vision involves continuous color gradients and textures. The paper acknowledges this limitation. Extending the theory to continuous features would require different probes.
• Decodability vs. Causality: The authors are honest about a major caveat. They are measuring decodable information. Just because a probe can extract binding information doesn't mean the model actually uses it during inference. A model could have perfect binding in its hidden states but ignore it during caption generation.
• The Feature-Object Assumption: The conditional binding metric $B^*_{O,F}(Z)$ assumes the feature code can be reliably inferred from the object code. In noisy environments, this assumption might break down. This could potentially skew the measurement of "pure" binding.

Should You Prototype This

Depends.

If you are building high-precision visual inspection systems or robotics controllers, you should prototype this. The takeaway is clear. If your application requires precise object-attribute association, do not rely solely on the $[CLS]$ token or global average pooling. You need to architect your downstream heads to attend to the spatial tokens.

Furthermore, the finding that increasing input resolution (from 224px to 336px) improves binding in CLIP-like models is a concrete lever. Use it to improve compositional performance.

The code is reportedly available; see the paper for the canonical link at https://github.com/KordingLab/formalizing-the-binding-problem. It is a solid tool for diagnosing whether your model's failures are due to "not seeing" or "not connecting."

Figures from the paper