Tree-Gate Proximal Policy Optimization

• TGPPO is a reinforcement learning framework that leverages tree-gate transformer architecture to select optimal branching variables in MILPs.
• It formulates branch-and-bound as a Markov Decision Process, using on-policy PPO and generalized advantage estimation to effectively reduce node counts and primal-dual integrals.
• Empirical evaluations show TGPPO significantly outperforms traditional and learned baselines, especially for out-of-distribution MILP instances.

Tree-Gate Proximal Policy Optimization (TGPPO) is a reinforcement learning (RL) framework for learning branching policies in Mixed Integer Linear Programs (MILPs) solved by the branch-and-bound (B&B) paradigm. TGPPO addresses the challenge of generalization across structurally diverse MILP instances by employing on-policy policy optimization, leveraging a transformer-based architecture to encode the combinatorial context of the evolving B&B search tree. Empirical evidence demonstrates that TGPPO surpasses both hand-crafted and existing learned branching strategies in terms of node count reduction and primal-dual integral, particularly for out-of-distribution instances (Mhamed et al., 17 Nov 2025).

1. Branch-and-Bound Policy Learning as Markov Decision Process

TGPPO formulates the B&B procedure as a Markov Decision Process (MDP), where the agent interacts with a MILP solver (SCIP). At decision step $t$, the state $s_t$ consists of:

• $C_t$: The set of candidate fractional variables for branching, each with a feature vector $c_{t,i}\in\mathbb{R}^{d_c}$, $d_c=25$.
• $Tree_t$: Global and local tree statistics partitioned into $n_t\in\mathbb{R}^{d_n}$ ($d_n=8$) and $m_t\in\mathbb{R}^{d_m}$ ($d_m=53$).

The set of available actions $s_t$0 corresponds to selecting a candidate variable to branch. The solver updates the state by expanding the B&B tree according to SCIP’s default node-selection. The scalar reward $s_t$1 penalizes expansion of large trees and lack of progress, normalized relative to a baseline policy. The transition and reward mechanisms induce variable-length episodes, terminating with optimality or time/resource limits.

2. State Space and Tree-Gate Representation

TGPPO employs a parameterized tree-gate encoding inspired by tree-aware transformer architectures to flexibly represent B&B states. The feature pipeline is:

• Project candidate features: $s_t$2, $s_t$3.
• Project global tree context: $s_t$4, $s_t$5.
• Concatenate and linearly transform: $s_t$6, $s_t$7.

The set $s_t$8 is permutation-equivariant, allowing the representation of variable-arity candidate sets. A padding mask $s_t$9 enables batching.

3. Network Architecture and Policy Parameterization

TGPPO utilizes an actor-critic model with a shared network core:

• Transformer Encoder: An $C_t$0-layer transformer, respecting $C_t$1, processes $C_t$2; output $C_t$3.
• Bi-directional Matching Block: Implements mutual attention between transformed candidate ($C_t$4) and tree context ($C_t$5) features, using:
  • $C_t$6
  • $C_t$7
  • Aggregation and fusion: $C_t$8

Actor Head (Tree-Gated MLP):

• Applies $C_t$9 successive tree-gated layers: $c_{t,i}\in\mathbb{R}^{d_c}$0, with $c_{t,i}\in\mathbb{R}^{d_c}$1 and $c_{t,i}\in\mathbb{R}^{d_c}$2.
• Computes logits $c_{t,i}\in\mathbb{R}^{d_c}$3; policy: $c_{t,i}\in\mathbb{R}^{d_c}$4.

Critic Head (Value Function):

• Computes mean-pooled summary $c_{t,i}\in\mathbb{R}^{d_c}$5, concatenates with tree context, and passes through a two-layer MLP and tree-gated reduction to obtain $c_{t,i}\in\mathbb{R}^{d_c}$6.

4. Reinforcement Learning Objective and PPO Algorithm

The RL objective for TGPPO employs Proximal Policy Optimization (PPO), utilizing:

• Cumulative discounted return: $c_{t,i}\in\mathbb{R}^{d_c}$7 (typically with $c_{t,i}\in\mathbb{R}^{d_c}$8).
• Generalized Advantage Estimation (GAE): $c_{t,i}\in\mathbb{R}^{d_c}$9 computed from advantage residuals $d_c=25$0.
• PPO clipped surrogate objective:

$d_c=25$1

with $d_c=25$2.

The full objective combines policy, value, and entropy terms:

$d_c=25$3

where $d_c=25$4 denotes the entropy bonus.

5. Training Methodology and Hyperparameter Regime

TGPPO is trained via episodic on-policy RL as outlined in Algorithm 1. Each episode proceeds as follows:

1. Initialize parameters $d_c=25$5; reset buffer.
2. Sample MILP instance and seed; reset SCIP state (for data augmentation).
3. For each timestep $d_c=25$6:
   • Extract candidate and tree features; form $d_c=25$7.
   • Sample action $d_c=25$8; execute in SCIP, observe $d_c=25$9 and $Tree_t$0.
   • Store $Tree_t$1 in buffer.
4. On episode end or buffer full, compute returns and GAE advantages.
5. For $Tree_t$2 epochs, sample mini‐batches, update $Tree_t$3 via AdamW on combined loss.
6. Repeat for subsequent episodes.

Key hyperparameters: $Tree_t$4, $Tree_t$5 transformer layers, 8 heads, $Tree_t$6, $Tree_t$7 (GAE), batch size 256, $Tree_t$8, reward variant H3; all obtained via nested cross-validation/Optuna.

6. Experimental Evaluation and Results

TGPPO's empirical evaluation utilizes a training set of 25 MIPLIB 3/2010/2017 + CORAL instances (each with 5 SCIP seeds, yielding 125 episodes) and a test set of 66 held-out problems (33 “easy,” 33 “hard”). Experimental protocols employ a one-hour solve cap per test instance. Metrics:

• Node count ($Tree_t$9): Employed on “easy” instances.
• Primal-dual integral (PDI): Used for “hard” cases.

Reporting uses the shifted geometric mean (SGM) and head-to-head comparisons.

Key findings:

• Against the state-of-the-art tbrant learner, TGPPO achieves superior performance in 78.8% of instances by node count and 90.6% by PDI.
• TGPPO outperforms classical and learned baselines (pscost, relpscost, brant, ltbrant, tree) on 70%–90% of test instances.
• Friedman–Nemenyi tests confirm statistically significant improvements (p < 0.001).
• Comparative scatter plots demonstrate that the majority of test instances favor TGPPO (points fall below the diagonal).

7. Conclusions, Implications, and Future Directions

TGPPO establishes that on-policy PPO training mitigates overfitting to expert demonstrations, a notable limitation in previous imitation-learning-based policies. The tree-gate transformer architecture accommodates variable-length candidate sets and captures hierarchical tree context, enabling generalization across diverse MILP structures. TGPPO substantially lowers computational effort (nodes expanded) on easy instances and reduces PDI on challenging ones, enhancing anytime solution quality under compute constraints.

Residual performance gaps relative to expert heuristics such as relpscost indicate the potential benefit of integrating TGPPO with end-to-end solvers, enriched graph-based representations, and advanced reward schemes (e.g., risk-sensitive objectives). A plausible implication is that this approach provides a robust foundation for automated solver design, especially in scenarios with highly heterogeneous or previously unseen MILP distributions (Mhamed et al., 17 Nov 2025).