Adaptive Planning for Multi-Attribute Controllable Summarization with Monte Carlo Tree Search

The paper introduces PACO, a training-free framework that leverages Monte Carlo Tree Search to adaptively plan the sequential order of attribute adjustments, thereby achieving robust multi-attribute controllable summarization that outperforms fine-tuned baselines and rivals much larger models.

The Gist

Imagine you are a chef trying to cook a perfect dish for a very picky customer. The customer has a long list of specific demands: "It must be exactly 200 calories, spicy but not too hot, include exactly three types of herbs, and the texture must be crunchy."

If you try to cook the entire dish in one go while keeping all these rules in your head, you will likely fail. You might make it crunchy but forget the herbs, or get the spice right but make it 500 calories. This is exactly the problem Large Language Models (LLMs) face when asked to summarize text with multiple specific rules (like length, topic, and style) all at once. They get overwhelmed and produce a result that misses the mark.

This paper introduces a new method called PACO (Adaptive Planning for Multi-Attribute Controllable Summarization) to solve this. Instead of trying to cook the whole meal in one frantic rush, PACO acts like a master chef with a step-by-step game plan.

Here is how PACO works, using simple analogies:

1. The Problem: The "One-Shot" Disaster

Current AI models try to follow all instructions simultaneously. It's like asking a student to write an essay that is exactly 500 words, uses only words starting with the letter 'A', and is written in the style of Shakespeare, all in a single sentence. The result is usually a mess. The AI struggles because the rules often fight against each other (e.g., making it shorter might ruin the specific topic).

2. The Solution: The "Monte Carlo Tree Search" (The Decision Tree)

PACO doesn't guess. It uses a technique called Monte Carlo Tree Search (MCTS). Think of this as a giant decision tree or a "Choose Your Own Adventure" book, but for writing summaries.

• The Root: The AI starts with a rough draft that tries to follow all rules at once (the starting point).
• The Branches: The AI asks itself, "If I fix the length first, what happens? If I fix the topic first, what happens?" It creates different branches for every possible order of fixing the rules.
• The Simulation: It simulates these paths in its mind. It tries a path where it fixes the length, then the topic, then the speaker. It tries another path where it fixes the topic first.
• The Score: After each step, it checks: "Did we get closer to the goal? Did we break a rule we already fixed?" It gives a score to each path.

3. The "Adaptive" Magic: Revisiting Mistakes

The clever part of PACO is that it knows order matters.

• Sometimes, fixing the length ruins the topic.
• Sometimes, fixing the speaker ruins the length.

PACO is smart enough to say, "Okay, we fixed the length, but now the topic is off. Let's go back and fix the topic again." It doesn't just move forward; it can revisit attributes. It keeps exploring different orders of operations until it finds the perfect sequence that satisfies all the rules without breaking any of them.

4. The Result: A Perfect Summary

Once the AI has explored enough paths (simulations), it picks the branch that resulted in the best summary.

• The Magic Trick: The paper shows that even a small, cheap AI model (like a 1-billion parameter model) using PACO can produce summaries just as good as a massive, expensive AI model (like a 70-billion parameter model) that tries to do it all at once.
• Why? Because the small model is following a smart plan, while the big model is just guessing.

Summary of the Analogy

• Old Way: Trying to juggle 5 balls while blindfolded. You drop them all.
• PACO Way: You put the balls on a table. You pick up one, fix it, put it down. Then you pick up the next, fix it, and check if the first one is still okay. If not, you fix the first one again. You keep doing this until all 5 balls are perfectly balanced.

In short: PACO teaches AI to stop trying to do everything at once. Instead, it teaches the AI to plan, test, and refine its work step-by-step, ensuring that every single constraint the user asked for is met perfectly. It's the difference between a chaotic rush and a strategic, thoughtful process.

Technical Summary

1. Problem Definition

Multi-attribute controllable summarization aims to generate summaries that simultaneously satisfy multiple user-specified constraints (e.g., length, extractiveness, topic, speaker, and specificity).

• The Challenge: Large Language Models (LLMs) struggle to enforce multiple, often correlated, constraints in a single decoding pass. Attempting to control all attributes simultaneously often leads to conflicts (e.g., increasing extractiveness might inadvertently violate length constraints) or failure to meet specific targets.
• Limitations of Existing Methods:
  • Fine-tuning approaches: Methods like Mixture-of-Experts (MoE) or prompt tuning require attribute-specific training, limiting flexibility for unseen attributes or diverse user preferences.
  • Self-planning: LLMs attempting to plan their own attribute control order (implicitly or explicitly) often fail to generate effective plans, resulting in repetitive or imbalanced adjustments.
  • Combinatorial Complexity: The space of possible control orders is vast, making it difficult to systematically find the optimal sequence of adjustments.

2. Methodology: PACO

The authors propose PACO (Adaptive Planning for Multi-Attribute Controllable Summarization), a training-free framework that reframes the task as a sequential decision-making problem solved via Monte Carlo Tree Search (MCTS).

Core Concept

Instead of generating a summary in one pass, PACO treats the generation process as a tree search where:

• Nodes: Represent complete summaries (not tokens or sentences), reducing the search space complexity.
• Actions: Correspond to adjusting a single attribute (e.g., "Control Length," "Control Topic").
• State: The current summary and the history of adjustments made.
• Goal: Adaptively discover the optimal order of attribute adjustments to satisfy all constraints.

MCTS Algorithm Design

PACO utilizes a customized MCTS algorithm with four key phases:

1. Selection: Starts from a root node (an initial summary attempting to control all attributes). It selects child nodes using a variant of the Predictor Upper Confidence Tree (PUCT) algorithm to balance exploration (trying new attribute orders) and exploitation (following high-reward paths).
2. Expansion: When a leaf node is reached, the algorithm expands it by generating child nodes for all possible legal actions (adjusting any of the 5 attributes: Extractiveness, Length, Specificity, Topic, Speaker). Crucially, attributes can be revisited, as a previous adjustment might be disrupted by a subsequent one.
3. Evaluation: Nodes are scored using a Local Reward function based on the deviation from target values:
   • Deterministic Attributes (Length, Extractiveness, Specificity): Measured by Mean Absolute Deviation (MAD) from the target.
   • Non-Deterministic Attributes (Topic, Speaker): Measured by alignment scores (e.g., embedding similarity).
   • The total reward is a weighted combination of these metrics.
4. Backpropagation: The reward value and visit counts are propagated up the tree to update the value estimates of parent nodes.
5. Decision: Unlike standard MCTS which picks the most visited leaf, PACO selects the node across the entire tree that maximizes the overall control degree (satisfying the most constraints effectively).

Key Technical Distinctions

• Granularity: Nodes are defined at the summary level, avoiding the intractable search space of token-level trees common in reasoning tasks.
• Adaptive Revisiting: The framework allows the model to adjust the same attribute multiple times if subsequent actions degrade its control, a flexibility missing in fixed-sequence baselines.
• Training-Free: PACO requires no fine-tuning; it operates entirely at inference time using pre-trained LLMs as the policy.

3. Key Contributions

1. Novel Framework: Introduction of PACO, the first framework to cast multi-attribute summarization as a sequential planning problem using MCTS.
2. Summary-Level Search: A tailored MCTS design that operates on full summaries rather than tokens, enabling efficient exploration of control orders.
3. Attribute Categorization: A reward mechanism that distinguishes between deterministic (target-matching) and non-deterministic (alignment-based) attributes, allowing flexible weighting.
4. Training-Free Efficiency: Demonstrates that high-level controllability can be achieved without attribute-specific fine-tuning, relying instead on structured inference-time planning.

4. Experimental Results

The authors evaluated PACO on three datasets (MACSumDial, MACSumDoc, DialogSum) using various LLMs (Llama-3.2-1B, Llama-3.3-70B, Qwen2.5-7B).

• Superior Controllability: PACO significantly outperforms all baselines (including fine-tuned BART, implicit/explicit self-planning, and random/joint iterative methods) in meeting attribute constraints.
  • Example: On MACSumDial, PACO with a 1B model reduced the Length MAD from 55.68 (base) to 17.96, achieving performance comparable to the 70B baseline.
  • Example: PACO with a 70B model achieved an average MAD of ~5 on deterministic attributes, outperforming all competitors.
• Robustness: PACO maintains strong performance across different domains (meetings, news, dialogues) and model sizes.
• Quality Preservation: Despite aggressive constraint enforcement, PACO preserves summary quality (ROUGE and BERTScore) comparable to baselines, avoiding the degradation often seen when forcing multiple constraints simultaneously.
• Ablation Studies:
  • Removing the MCTS structure (using simple self-planning) drastically reduces performance.
  • The Local Reward alone is sufficient; adding a heuristic value function provided negligible gains, suggesting that predicting future feasibility is difficult and local feedback is more effective.

5. Significance and Impact

• Paradigm Shift: PACO demonstrates that planning is a more effective strategy than fine-tuning for complex, multi-constraint generation tasks. It proves that LLMs can be guided to solve complex constraint satisfaction problems through structured search rather than parameter updates.
• Scalability: The ability of a small 1B model to rival a 70B model in controllability suggests that inference-time compute (via MCTS) can compensate for model size limitations in specific tasks.
• Practical Applicability: As a training-free method, PACO is immediately deployable with any pre-trained LLM, offering a flexible solution for real-world applications where user preferences (attributes) change dynamically and cannot be pre-trained for.
• Trade-off: The primary limitation is computational cost (PACO is slower than single-pass generation), but the paper argues this is a necessary trade-off for achieving high-fidelity control in complex scenarios.

In conclusion, PACO establishes a new state-of-the-art for multi-attribute summarization by leveraging Monte Carlo Tree Search to dynamically plan the order of attribute adjustments, achieving robust control without the need for expensive retraining.