BCPO: Bottlenecked Contextual Policy Optimization

• Bottlenecked Contextual Policy Optimization (BCPO) is a reinforcement learning framework that uses a variational information bottleneck to summarize latent contexts for robust policy generalization.
• It decomposes the learning process into an inference step with an encoder and a control step using off-policy methods, ensuring efficient dual-loop optimization.
• Empirical results demonstrate BCPO's faster convergence and superior out-of-distribution performance on benchmarks like CartPole, Hopper, and Humanoid.

Bottlenecked Contextual Policy Optimization (BCPO) is a reinforcement learning (RL) framework for robust policy generalization in environments with latent contextual variation. BCPO addresses the problem of learning policies that generalize to previously unseen or out-of-distribution contexts by explicitly modeling context information through a variational information bottleneck deployed in front of any off-policy RL agent (Gu et al., 25 Jul 2025).

1. Contextual MDPs and Dual Inference–Control Decomposition

BCPO operates within the Contextual Markov Decision Process (MDP) formalism, where each episode is governed by a latent, unobserved context $c \sim p(c)$. The contextual MDP $\mathcal{M}(c)$ is characterized by state space $\mathcal{S}$, action space $\mathcal{A}$, context-specific dynamics $\mathcal{T}_c(s'|s,a)$, and rewards $r_c(s,a)$. Episodes have fixed length $T$; trajectories $\tau$ are unrolled under policy $\pi$ as:

$$\tau = (s_1, a_1, \ldots, s_T, a_T),\quad p(\tau|c) = p(s_1)\prod_{t=1}^T \mathcal{T}_c(s_{t+1}|s_t, a_t)\pi(a_t|s_t).$$

The principal objective is to maximize the expected return:

$\mathcal{M}(c)$0

BCPO decomposes the problem into:

• Inference: Compress a window of the initial $\mathcal{M}(c)$1 steps $\mathcal{M}(c)$2 using a variational encoder $\mathcal{M}(c)$3 so that $\mathcal{M}(c)$4 serves as a proxy summary for the unobserved context $\mathcal{M}(c)$5.
• Control: Condition the policy $\mathcal{M}(c)$6 on this summary to optimize decisions in an augmented $\mathcal{M}(c)$7 state space.

2. Information-Theoretic Foundations: Sufficiency and Contextual ELBO

BCPO formalizes two tiers of sufficiency:

• Observation sufficiency: The encoder $\mathcal{M}(c)$8 is observation sufficient if $\mathcal{M}(c)$9, meaning $\mathcal{S}$0 captures all information about $\mathcal{S}$1 present in the observations.
• Control sufficiency:
  • Weak: Existence of a policy $\mathcal{S}$2 achieving the optimal contextual return $\mathcal{S}$3.
  • Strong: For almost every $\mathcal{S}$4 with $\mathcal{S}$5, the state-action value functions satisfy $\mathcal{S}$6.

There exists a hierarchy: strong control sufficiency implies observation sufficiency, but not conversely (except in a lossless observation window).

BCPO is rooted in a variational evidence lower bound (contextual ELBO) for RL:

$\mathcal{S}$7

The rightmost term is the information residual; closing this gap is necessary for optimality.

3. BCPO Algorithmic Procedure

BCPO employs a two-level, nested optimization:

• Policy Update (outer loop): Fix the encoder $\mathcal{S}$8 and optimize the surrogate RL objective $\mathcal{S}$9 (the MaxEnt RL objective on $\mathcal{A}$0) using any off-policy algorithm (e.g., Soft Actor-Critic, SAC).
• Encoder Update (inner loop): Fix the policy $\mathcal{A}$1 and minimize the information residual via an Information Bottleneck loss:

$\mathcal{A}$2

with variational estimates for $\mathcal{A}$3 (via KL divergence to a Gaussian prior) and $\mathcal{A}$4 (via variational or InfoNCE contrastive losses).

Summary Table: Core BCPO Optimization

Step	Fixed	Optimized
Policy optimization	Encoder	$\mathcal{A}$5
Bottleneck minimization	Policy	$\mathcal{A}$6

The full BCPO objective is:

$\mathcal{A}$7

The standard training iteration includes:

1. Warm-up with random episodes to populate replay buffer $\mathcal{A}$8.
2. Pretrain the encoder $\mathcal{A}$9.
3. For each iteration:
   • Sample context $\mathcal{T}_c(s'|s,a)$0, run episode: encode $\mathcal{T}_c(s'|s,a)$1, select action $\mathcal{T}_c(s'|s,a)$2, and collect transitions in $\mathcal{T}_c(s'|s,a)$3.
   • Inner loop: Update encoder $\mathcal{T}_c(s'|s,a)$4 for $\mathcal{T}_c(s'|s,a)$5 steps on recent batches, minimizing $\mathcal{T}_c(s'|s,a)$6.
   • Outer loop: Update policy/critic via SAC for $\mathcal{T}_c(s'|s,a)$7 steps, always re-encoding $\mathcal{T}_c(s'|s,a)$8 with latest $\mathcal{T}_c(s'|s,a)$9.
   • Anneal $r_c(s,a)$0.

4. Architecture and Hyperparameterization

Standard architectures utilized in BCPO are:

• Encoder ($r_c(s,a)$1): MLP with layers [512, 512, 128] followed by layer normalization and GeLU activations, outputting $r_c(s,a)$2, $r_c(s,a)$3 for a reparameterized Gaussian.
• Policy ($r_c(s,a)$4): MLP [256, 256], produces mean and log-standard deviation, passed through Tanh for action bounds.
• Critics ($r_c(s,a)$5): Twin MLPs, each [256, 256].

Typical hyperparameter settings across tasks:

• Observation window $r_c(s,a)$6.
• Latent $r_c(s,a)$7 dimension: from 2 (CartPole) up to 30 (Humanoid).
• Information bottleneck weight $r_c(s,a)$8: linearly annealed from $r_c(s,a)$9 to $T$0.
• Learning rates: $T$1 (encoder, actor, critic).
• Batch size: 128; replay buffer: $T$2.
• Update ratio: $T$3 (encoder), $T$4 (policy).
• SAC defaults: $T$5.

5. Diagnostics, Metrics, and Analysis

• Observation sufficiency is tracked via empirical mutual information $T$6. If it fails to reach the Fano lower bound $T$7, the window size $T$8 is increased.
• Encoder gap: Monitored through $T$9; convergence to $\tau$0 indicates sufficiency.
• Replay gap: Controlled by clipping importance weights $\tau$1, training $\tau$2 on recent samples, and reducing effective context count through curriculum bins.
• Control sufficiency and generalization: Measured by the return $\tau$3 versus $\tau$4, and performance on out-of-distribution (OOD) held-out contexts.
• Empirical ablations: The effect of $\tau$5-annealing is evaluated, and 2D embedding visualizations of $\tau$6 display shrinkage of intra-cluster variance as $\tau$7 approaches 1.

6. Empirical Results and Benchmark Comparisons

BCPO is evaluated on standard MuJoCo-based continuous control benchmarks with global mass-scale context variation $\tau$8, including:

• CartPole (3D context: pole mass, length, cart mass)
• Hopper, Walker2d, HalfCheetah, Ant, Humanoid (1D continuous $\tau$9)

Training takes place over $\pi$0; OOD generalization is evaluated for $\pi$1.

Baseline comparisons include:

• Implicit-context: Domain Randomization, Round-Robin, SPaCE, SPDRL
• Explicit-context: RMA/MSE, ObsAug, PEARL

Summary of empirical findings:

• BCPO attains 80% of its final score in $\pi$2 steps, which is $\pi$3–$\pi$4 faster than Domain Randomization.
• OOD performance average: matches or outperforms all baselines. For example—
  • HalfCheetah: BCPO ($\pi$5) vs DR ($\pi$6)
  • Ant: BCPO ($\pi$7) vs DR ($\pi$8)
  • Humanoid: BCPO ($\pi$9) vs DR ($$\tau = (s_1, a_1, \ldots, s_T, a_T),\quad p(\tau|c) = p(s_1)\prod_{t=1}^T \mathcal{T}_c(s_{t+1}|s_t, a_t)\pi(a_t|s_t).$$0)
• Under extreme variation ($$\tau = (s_1, a_1, \ldots, s_T, a_T),\quad p(\tau|c) = p(s_1)\prod_{t=1}^T \mathcal{T}_c(s_{t+1}|s_t, a_t)\pi(a_t|s_t).$$1), BCPO degrades smoothly, as predicted by the residual analysis—further improvement hinges on the control capacity, not the representation.

7. Recommendations for Reproducibility

• Warm-up and pretraining are necessary: collect $$\tau = (s_1, a_1, \ldots, s_T, a_T),\quad p(\tau|c) = p(s_1)\prod_{t=1}^T \mathcal{T}_c(s_{t+1}|s_t, a_t)\pi(a_t|s_t).$$2 random episodes, pretrain encoder to stabilize early learning.
• On-the-fly encoding: Always recompute $$\tau = (s_1, a_1, \ldots, s_T, a_T),\quad p(\tau|c) = p(s_1)\prod_{t=1}^T \mathcal{T}_c(s_{t+1}|s_t, a_t)\pi(a_t|s_t).$$3 with the current encoder; never store $$\tau = (s_1, a_1, \ldots, s_T, a_T),\quad p(\tau|c) = p(s_1)\prod_{t=1}^T \mathcal{T}_c(s_{t+1}|s_t, a_t)\pi(a_t|s_t).$$4 in the replay buffer.
• Context curriculum: Discretize continuous $$\tau = (s_1, a_1, \ldots, s_T, a_T),\quad p(\tau|c) = p(s_1)\prod_{t=1}^T \mathcal{T}_c(s_{t+1}|s_t, a_t)\pi(a_t|s_t).$$5 into $$\tau = (s_1, a_1, \ldots, s_T, a_T),\quad p(\tau|c) = p(s_1)\prod_{t=1}^T \mathcal{T}_c(s_{t+1}|s_t, a_t)\pi(a_t|s_t).$$6 bins, gradually increase task difficulty by sampling bins in order of average return.
• Update schedule: Maintain $$\tau = (s_1, a_1, \ldots, s_T, a_T),\quad p(\tau|c) = p(s_1)\prod_{t=1}^T \mathcal{T}_c(s_{t+1}|s_t, a_t)\pi(a_t|s_t).$$7 to enforce near-complete minimization of encoder loss before outer policy updates.
• $$\tau = (s_1, a_1, \ldots, s_T, a_T),\quad p(\tau|c) = p(s_1)\prod_{t=1}^T \mathcal{T}_c(s_{t+1}|s_t, a_t)\pi(a_t|s_t).$$8-annealing: Begin with small $$\tau = (s_1, a_1, \ldots, s_T, a_T),\quad p(\tau|c) = p(s_1)\prod_{t=1}^T \mathcal{T}_c(s_{t+1}|s_t, a_t)\pi(a_t|s_t).$$9 to drive exploration, increase toward 1 for more minimal, robust codes.
• Clipping: Limit trajectory importance weights to $\mathcal{M}(c)$00 to bound replay-induced bias.

Collectively, these guidelines and the nested dual optimization structure enable faithful reproduction and robust deployment of BCPO across a spectrum of context-varying RL environments (Gu et al., 25 Jul 2025).