Consciousness Prior Framework

• The Consciousness Prior is a representation learning framework that isolates sparse, high-level abstract factors using an attention bottleneck.
• It employs a structured sparse factor graph to enhance interpretability and supports reasoning, planning, and natural language mapping.
• The framework integrates recurrent encoders, attention-based controllers, and language decoders to simulate human-like System 2 cognition.

The Consciousness Prior is a representation learning framework designed to promote the disentanglement of high-level abstract factors through a structural prior inspired by cognitive neuroscience theories of consciousness. It integrates architectural and information-processing constraints, positing that only a sparse subset of high-level variables is selected by attention at any moment to form a low-dimensional "conscious state." This conscious state serves as a bottleneck analogous to the information humans manipulate linguistically in so-called "System 2" cognition. The Consciousness Prior offers a mechanism for organizing and uncovering abstract factors by modeling their joint distribution as a sparse factor graph, providing enhanced interpretability and tractability for reasoning, planning, and natural language mapping (Bengio, 2017).

1. Motivation and Theoretical Foundations

The Consciousness Prior addresses the limitation of current deep learning systems, which predominantly implement "System 1" cognition—fast, intuitive, and highly entangled representations. In contrast, humans routinely engage in "System 2" processes, where concise conscious states involving few abstract concepts are manipulated, reasoned about, and verbalized. The hypothesis underlying this prior is that to learn such disentangled, high-level concepts, the learning system must be biased toward forming low-dimensional conscious states through an attention bottleneck. This corresponds to assuming that the true joint distribution over all abstract factors is well approximated by a sparse factor graph, each factor linking only a handful of variables, resulting in strong, localized "dips" in the overall energy function. Conscious attention is analogized to tractable inference or exploration on this graph (Bengio, 2017).

2. Formal Architecture and Notation

The framework introduces several core modules, each associated with a specific role in the representation learning process:

• $x_t \in X$: Raw observation at time $t$.
• $h_t = F(x_t, h_{t-1})$: The high-dimensional "unconscious" representation, typically generated by a recurrent state encoder.
• $c_t = C(h_t, c_{t-1}, m_{t-1}, z_t)$: The low-dimensional conscious state at time $t$, computed by a consciousness (attention) RNN $C$, with $z_t$ as injected noise for stochasticity and $m_{t-1}$ as memory.
• $m_t = M(m_{t-1}, c_t)$: Updated longer-term memory from conscious state $c_t$.
• $V(h_t, c_{t-k})$: A verifier network that scores the match between a previous conscious state and current unconscious representation (e.g., computing $\log P(\text{statement} \mid \text{current world})$).
• $U(c_t, u_{t-1})$: An RNN decoder mapping conscious states to natural-language utterances.

These modules collectively instantiate a system in which perception, memory, verification, and language are all mediated through attention-driven conscious state selection (Bengio, 2017).

3. Construction of the Conscious State via Attention Mechanisms

The conscious state $c_t$ is derived from the high-dimensional state $h_t$ using an attention mechanism. The general form is

$c_t = C(h_t, c_{t-1}, m_{t-1}, z_t).$

In practical terms, if $h_t$ is interpreted as a set of vectors $\{h_t^{(i)}\}$, attention weights $\alpha^{(i)}$ are computed:

$$\alpha^{(i)} = \mathrm{softmax}_i\left(s(h_t^{(i)}, c_{t-1}, m_{t-1})\right)$$

and the conscious state is assembled as

$$c_t = \sum_i \alpha^{(i)} h_t^{(i)} + \text{(optionally keys or type embeddings)}.$$

Injected noise $z_t$ is used to induce stochasticity, enabling either hard attention (sampling a subset) or regularized exploration through perturbation. This approach ensures that the conscious state remains low-dimensional and focuses on subsets of the latent representation most salient for ongoing processing (Bengio, 2017).

4. Sparse Factor Graphs and Energy-Based Modeling

The Consciousness Prior asserts that the true joint distribution $P(S)$ over all high-level variables $S = \{V_1, ..., V_n\}$ is captured by a sparse factor graph:

$P(S) = \frac{1}{Z} \prod_j f_j(S_j),$

with each factor $f_j$ depending only on a small subset $S_j \subset S$, and equivalently in energy-form:

$$E(S) = \sum_j E_j(S_j), \quad P(S) \propto \exp\left(-E(S)\right).$$

The sparseness of this factorization induces the structural prior: meaningful high-level predictions and manipulations can be realized by attending to small, tractable slices of the graph. Attention, therefore, operationalizes inference about the corresponding sub-graphs, focusing computational resources on relevant variables and their dependencies (Bengio, 2017).

5. Integration with Learning Objectives

The Consciousness Prior augments standard learning frameworks by integrating with multiple objectives:

• Reconstruction losses: Auto-encoding approaches reconstruct $x_t$ from $h_t$.
• Prediction and verification: Given $c_t$ (selecting $B$) and some target $A$, maximize $\log P(A \mid B)$ using a decoder or conditional VAE/GAN; the verifier network is trained to approximate

$$V(h_t, c_{t-k}) \approx \log P(\text{“thought }c_{t-k}\text{” is true} \mid h_t).$$

• Reinforcement learning rewards: If $c_t$ is used for action selection, back-propagate the RL reward through both $F$ and $C$.
• Diversity regularization: To prevent trivial or degenerate attention (e.g., focusing solely on easily predicted elements), maximize mutual information or entropy proxies such as

$$\max I(B;A) \quad \text{or} \quad \text{maximize } H[B,A],$$

compelling the attention mechanism to explore various $(A,B)$ slices of the factor graph and so cover a diverse set of abstract variables (Bengio, 2017).

6. Mapping Conscious States to Language

The architecture enables a bidirectional mapping between the conscious state $c_t$ and a natural language utterance $u_t$ through an RNN $U$:

$u_t = U(c_t, u_{t-1}).$

The model can be trained via teacher forcing using supervised language data aligned to internal conscious contents, or the process can be inverted to set $c_t$ by conditioning on a provided utterance. This procedural symmetry encourages conscious states to align with language-like, discrete, interpretable abstractions (words or short phrases), promoting further disentanglement of representations within the conscious bottleneck (Bengio, 2017).

7. Example Architectures and Training Regimes

Typical realization of the Consciousness Prior uses:

• Representation RNN $F$: LSTM, GRU, or Transformer encoder for modeling $x_{1..t}$.
• Consciousness RNN $C$: Small attention network, sampling a subset $K \ll \dim(h_t)$ per step.
• Memory $M$: RNN (e.g., LSTM) updating from $c_t$ to $m_t$.
• Verifier $V$: Feed-forward or attention-based scorer evaluating $(h_t, c_{t-k})$.
• Language decoder $U$: Seq2seq decoder attending to $c_t$.
• General training loop:

1. Observe $x_t$, update $h_t = F(x_t, h_{t-1})$.
2. Compute or sample $c_t = C(h_t, c_{t-1}, m_{t-1}, z_t)$.
3. Optionally update memory as $m_t = M(m_{t-1}, c_t)$.
4. Define prediction target $A$; select $B$ in $c_t$.
5. Compute prediction loss $-\log P(A|B)$ and/or verifier loss $-V(h_{t+k}, c_t)$.
6. If language data is available, minimize $-\log P(u_t|c_t)$.
7. Back-propagate through $U$, $V$, $C$, $F$ (and via RL if applicable).
8. Apply regularizers on attention weights to encourage entropy or mutual information.

The paper does not supply explicit pseudocode or large-scale experiments, instead proposing validation on controlled environments (e.g., blocks falling from a table), where high-entropy raw input is complemented by low-entropy, abstract latent variables that the agent is incentivized to discover and manipulate (Bengio, 2017).