PaperlayerView exact revision on arXiv

Source-linked AI summary

Personalization as Inverse Planning: Learning Latent Design Intents for Agentic Slide Generation via Structural Denoising

Tianci Liu, Zihan Dong, Linjun Zhang, Haoyu Wang, jing Gao, Emre Kiciman, Ranveer Chandra, Wei-Ting Chen

arXiv:2607.00407v1cs.AI

TL;DR

Page-level slide personalization remains difficult because existing agentic systems struggle to infer latent design intents beyond templates or verbose instructions. The paper formulates PSP as inverse planning and introduces SPIRE, which uses structural denoising and two-agent reinforcement learning to make optimization verifiable; experiments report the strongest overall performance for SPIRE.

  • Problem

    Page-level slide personalization lacks scalable intent supervision and remains difficult because rendering quality depends on structured decisions produced by a black-box executor.

  • Method

    SPIRE corrupts gold-slide structures to create self-supervised denoising triplets, then trains a critic and planner to provide feedback and refine executable plans.

  • Results

    SPIRE achieves the strongest overall performance, surpassing GPT-based baselines in judge score while maintaining a visual similarity score of 0.7414.

  • Takeaways & Limitations

    Structural denoising provides a tractable surrogate for PSP and supports inference of latent user intent for page-level visual generation.

  • Takeaways & Limitations

    Visual similarity and judge-based quality scores are not perfectly aligned, limiting standardized metrics as sole measures of PSP.

Abstract

from arXiv · show

Slide design requires personalizing both deck themes and page layouts. Yet, current AI agent-based methods struggle with fine-grained, page-level design. Solely relying on prespecified templates or user verbose instructions, they fail to capture latent design intents, leaving Page-level Slide Personalization (PSP) unresolved. To close this gap, this work formulates PSP as an inverse planning problem. We propose to learn a design intent without assuming any knowledge of the specific executing tools (e.g., PowerPoint, Beamer) being used. However, relinquishing control over these tools makes the problem intractable to optimize end-to-end. To overcome this, we propose SPIRE, a principled framework to solve PSP approximately. By intentionally corrupting the visual structures of clean slides, SPIRE creates a verifiable task to denoise the corruption, whereby two agents learn to collaboratively refine executable designs via reinforcement learning (RL). We present a proof that structural denoising is a consistent surrogate for PSP, and that the multi-agent formulation strictly reduces policy gradient variance in RL. Extensive experiments demonstrate the superiority of SPIRE.

1 Introduction

Practical slide generation is inherently personalized, but agentic systems remain weak at fine-grained page-level design and latent intent inference. SPIRE addresses this by treating personalization as inverse planning and learning structural denoising with coordinated critic and planner agents.

  • Motivation: Slide generation must adapt visual treatments to presenters, audiences, lab identities, and organizational brand guidelines.
  • Motivation: Existing agentic pipelines improve deck-level coherence through modular stages but struggle with page-level hierarchy, alignment, spacing, and styling decisions.
  • Problem Formulation: Because detailed intent annotations are rarely available, PSP requires inferring context-dependent design plans as latent intents from assets and reference slides.
  • Problem Formulation: PSP is difficult to optimize because slide quality depends on structured design decisions and the executor is effectively a black box.
  • SPIRE: SPIRE converts PSP into verifiable structural denoising by corrupting gold-slide layouts, hierarchies, and styles and recording the resulting discrepancies.
  • SPIRE: A critic produces actionable semantic edit suggestions, while a planner creates or revises executable plans using that feedback.

2 Proposed Method

The paper formulates reference-based page-level slide personalization as latent-intent inverse planning and introduces SPIRE as an approximate solution using structural denoising. SPIRE trains complementary planner and critic agents with verifiable perturbation-reconstruction signals, while theory establishes surrogate consistency and lower policy-gradient variance.

  • Problem Formulation: PSP infers a latent, reference-conditioned plan that guides a generally capable executor to reproduce a user’s personalized slide.The plan can specify page-level structure, layout coordinates, visual hierarchy, and element styling, while the executor may be a coding agent, image generator, or human designer.
  • Problem Formulation: The PSP objective maximizes the marginal likelihood of the gold slide under a planner’s latent plan and the executor’s render likelihood.The render likelihood is difficult to optimize because it lacks an explicit form and depends on a black-box executor.
  • Problem Formulation: Pixel-wise similarity provides unreliable guidance because slide quality depends on discrete logical structure, while black-box executors prevent direct differentiation and can cause zeroth-order methods to overfit specific executors.Zeroth-order methods are also described as computationally costly for diverse slide-generation inputs.
  • SPIRE: SPIRE converts PSP into structural denoising by corrupting gold slides with controlled perturbations and training two agents on the resulting verifiable reconstruction signal.The perturbation process yields self-supervised triplets and avoids requiring manual intent annotations.
  • SPIRE: The critic identifies semantic discrepancies in corrupted slides, while the planner generates or revises executable plans using the critic’s feedback.A VLM judge rewards plans whose visual realization matches the gold slide more closely than the perturbed slide.
  • Theoretical Results: SPIRE’s theory states that its objective approximates the original PSP gradient up to an explicit error bound and that two-agent training removes executor-induced noise.The policy-gradient variance satisfies Var(ĝ_2a) ≤ Var(ĝ_e2e), with strict inequality when executor-induced noise is non-zero.

3 Experiment

SPIRE is evaluated on in-distribution and out-of-distribution pages against slide-native and generic visual-generation baselines, using visual-similarity and VLM-judge measures. Results show strong overall PSP performance, generalization, and benefits from preference-aligned training, iterative revision, and a trained critic.

  • Quantitative Results: Spire achieves the strongest overall performance, surpassing GPT-based AutoPresent and PSP (o4-mini) in judge score while maintaining a visual similarity score of 0.7414.The reported judge scores for AutoPresent and PSP (o4-mini) are 0.5069 and 0.4784, respectively.
  • Quantitative Results: On OOD pages, Spire obtains the highest judge average, the best scores across judging dimensions, and the second-best visual similarity.The result is reported against AutoPresent, PSP (o4-mini), PPTAgent, SD 3.5, and PSP (Base).
  • Evaluation Caveat: Visual similarity and judge scores are not perfectly aligned, limiting the reliability of standardized metrics alone for evaluating PSP.PSP (o4-mini) has the highest visual averages across settings but substantially lower judge-based quality than Spire.
  • Ablation Study: Replacing the larger untrained GPT critic with a Spire-trained 7B critic produces consistent improvements across all metrics.The result indicates that targeted critic training can guide PSP despite the smaller model scale.
  • Ablation Study: Preference-aligned fine-tuning raises visual average from 0.3344 to 0.7414 and judge average from 0.3230 to 0.5415 relative to directly prompted base Qwen models.The ablation attributes the gap to targeted structural denoising optimization for latent page-level design intents.
  • Ablation Study: Multi-round revision steadily improves visual similarity and judge scores by enabling the planner to apply structural corrections from critic feedback.This supports progressive refinement rather than single-pass generation.

4 Related Work

Early slide-generation systems emphasized content extraction and deck-level organization, while newer agentic pipelines add modular design stages and coordination. However, page-level personalization remains limited because existing approaches rely on generic templates, system objectives, or lengthy user instructions rather than user-specific design intents.

  • Early methods treated slide generation primarily as text summarization, overlooking coherent layout design and slides’ multimodal nature.
  • Recent agentic systems decompose slide creation into outlining, asset extraction, layout arrangement, and iterative refinement.
  • These systems mainly address deck- or document-level planning rather than fine-grained page-level layout design.
  • Page-level approaches depend on generic templates and system-defined objectives or explicit lengthy user instructions, limiting personalization to user-specific design intents.
  • Existing personalization work largely adapts content and narrative structure to audiences or presentation contexts rather than page-level visual design.

5 Conclusion

The paper frames Page-level Slide Personalization as latent-intent inference and introduces Spire, which uses structural denoising and two-agent refinement to make the problem tractable. It provides theoretical guarantees for surrogate consistency and reduced policy-gradient variance, alongside experiments showing effectiveness against representative baselines.

  • The paper formulates PSP as an inverse-planning problem that infers latent user design intents for diverse visual executors.
  • Spire corrupts gold-slide structures to create a self-supervised denoising task for two agents that iteratively refine design plans.
  • Theoretical analysis shows structural denoising is a consistent surrogate for PSP and that the multi-agent formulation strictly reduces policy-gradient variance.
  • Extensive experiments demonstrate Spire’s effectiveness against representative PSP baselines.

Supplementary Material of Personalization as Inverse Planning: Learning

The supplementary material formalizes the training setup and objectives underlying the critic–planner framework. It defines the original PSP objective, its Jensen lower bound, and the structural-planning objective implemented by the learned critic and planner.

  • Training instances contain user assets, a gold slide, and reference slides, while the planner samples a latent plan conditioned on the assets and references.
  • The original PSP objective maximizes the log marginal likelihood of the gold slide under plans sampled from the planner.
  • The Jensen lower bound replaces the log marginal likelihood with an expectation of log p(s*|z) over planner-sampled latent plans.
  • The structural-planning objective averages a learned critic-induced reward over corrupted slides and planner-sampled plans.
  • The empirical estimator is the loss implemented by the critic and planner objectives in the main text.

A.2 Details of Informal Theorem 1 (Surrogate Consistency)

The supplementary analysis bounds the gradient discrepancy between Spire’s empirical structural-planning objective and the original PSP objective under regularity, critic-calibration, and gradient-gap assumptions. The resulting error decomposes into empirical, calibration, structural-surrogate, and variational-gap terms.

  • Under A1–A3, Theorem 4 bounds the distance between the empirical structural-planning gradient and β/4 times the original PSP gradient.
  • The bound contains empirical optimization, critic-calibration, structural-surrogate, and variational-gap contributions.
  • The formal result states that the squared total error is bounded by ε_tot.
  • The proof proceeds through intermediate objectives, first relating the structural-planning objective to the Jensen lower bound and then relating that bound to the original PSP objective.

A.3 Details of Informal Theorem 2 (Variance Reduction)

The analysis shows that conditioning on the critique signal replaces stochastic execution rewards with a conditional target, yielding lower policy-gradient variance than end-to-end optimization. The reduction is strict whenever execution reward remains conditionally random.

  • The end-to-end estimator uses the policy score multiplied by the execution reward minus a baseline.The reward is obtained through black-box execution.
  • The two-agent estimator replaces the stochastic reward with its conditional mean given the latent plan, critique, and context.This estimator retains the same policy-score structure while using the conditional expected reward.
  • Var(ĝ_e2e) = Var(ĝ_2a) + Δ_exec|c, decomposing end-to-end variance into two-agent variance plus executor-induced variance.The decomposition follows from conditioning on the plan and critique.
  • Var(ĝ_2a) ≤ Var(ĝ_e2e), with strict inequality whenever Var(r | z, c, x) > 0 on a set of non-zero measure.Thus critique-conditioned training formally reduces variance under the stated assumptions.
  • The two-agent decomposition removes executor-induced randomness from the policy-gradient target by conditioning on critique.This is the stated interpretation of the variance decomposition.

B.1 Details about reference-based PSP Data

The reference-based PSP data pipeline converts raw slide decks into instruction–target–reference triplets and controlled critique-supervision examples. It uses deck-aware splits and a single same-deck reference to expose latent visual intent while preventing test leakage.

  • Each training example contains a high-level instruction, a gold slide page, and a reference set.The triplets are constructed from raw slide decks.
  • The instruction summarizes factual slide content while omitting visual style, leaving latent design intent to be inferred from references.Omitted attributes include color, font size, and layout organization.
  • Each target is paired with a few pages from the same deck, with experiments using one reference slide.Same-deck pairing leverages inherent visual coherence and creates a challenging personalization setting.
  • The last 20% of slides are held out chronologically for testing, while earlier slides support training or retrieval baselines.Target–reference pairs are formed within each split to avoid test-slide leakage.
  • OOD evaluation pairs each slide from page two onward with its immediately preceding page and applies no complexity filtering.A raw OOD deck with K pages yields K − 1 evaluation examples.
  • The critic is trained to produce structured feedback over eight perturbed visual aspects, with numeric targets for positional or size corrections.The aspects include graphic, image, and text color, position, and size attributes.
  • The critic’s accuracy reward measures coverage of issue–correction keyword pairs, and feedback receives the dominant format-reward weight of 0.85.The accuracy check compares extracted critiques with perturbation annotations.

B.3 Training Details of the Planner

Planner training teaches agents to generate executable slide plans and revise imperfect plans using structured critique. Its rewards jointly enforce output format and fidelity to the gold slide over a perturbed alternative.

  • The planner performs initial plan generation and critique-guided revision conditioned on instructions and reference slides.Separate prompt templates are used for the two subtasks.
  • Planner analysis extracts transferable design principles, while strategy converts them into layout, element, color, position, size, and typography decisions.The plan stage then specifies the complete slide composition sequentially.
  • Executable plans require concrete normalized spatial specifications and prohibit ambiguous instructions.The plan covers backgrounds, containers, text, visual elements, and spacing or balance.
  • During revision, the planner normalizes the previous plan, applies requested edits, and preserves already satisfactory aspects where possible.The revised output remains a complete executable plan.
  • The planner format reward weights the final plan at 0.80, making it the dominant component of format evaluation.Structure and analysis each receive 0.05, while strategy receives 0.10.
  • Planner accuracy compares whether the extracted plan matches the gold slide more faithfully than a randomly perturbed slide under both presentation orders.The final reward combines this plan–visual matching score with the format reward.
  • Revision data consists of a perturbed slide, an aligned suboptimal plan, and an oracle critique specifying corrections toward the gold slide.Rejection filtering retains critiques and plans that satisfy their respective verification rewards.

B.4 Implementation and Evaluation Details of Experiments

The experiments train SPIRE with verl and evaluate rendered slides using full-reference image similarity and reference-free VLM judgments. The protocols measure structural fidelity, global visual similarity, and four aspects of generation quality.

  • SPIRE is trained with verl, with detailed training hyper-parameters reported in Table 1.
  • Visual similarity treats each slide as a rendered full-page image and reports SSIM and CLIP Image Similarity normalized to [0, 1].SSIM measures low-level structural fidelity, while CLIP compares global visual representations using AltCLIP.
  • The VLM-as-a-judge protocol scores generated slides from 0–10 on four aspects and normalizes the scores to [0, 1].The supplied aspects include faithfulness, color, and layout; the protocol evaluates generation quality from the instruction and slide.
  • Faithfulness assesses whether requested text is preserved and readable without missing content, truncation, or severe overlap.
  • Color evaluates palette harmony and foreground–background contrast, while layout evaluates composition, alignment, and spacing.
  • The full VLM-as-a-judge prompt is provided in the supplementary material.

C Additional Experiment Results

Additional experiments evaluate SPIRE with reference-based pairwise VLM judgments and component ablations. SPIRE consistently outperforms baselines on test and out-of-distribution pages, with especially strong results in layout and faithfulness.

  • Spire Training and Iterative Revision: Ablation results show that preference-aligned fine-tuning and iterative revision contribute to SPIRE’s personalization performance.The supplied passage introduces an ablation of both components, while the reported comparison specifically shows a large gap between base Qwen models and fine-tuned SPIRE.
  • Reference-based Pairwise VLM-Judge Evaluation: SPIRE is evaluated using reference-based pairwise VLM comparisons that measure relative quality against the intended target slide.The judge receives the user instruction, gold slide, and two generated slides; each pair is evaluated twice with swapped presentation order.
  • Reference-based Pairwise VLM-Judge Evaluation: SPIRE consistently outperforms all baselines on both test and OOD pages, especially in Layout and Faithfulness.Table 2 reports win/tie rates, defined as the fraction of cases where SPIRE is judged at least as good as the baseline.
  • Reference-based Pairwise VLM-Judge Evaluation: SPIRE achieves win/tie rates exceeding 90% against most baselines and averages 0.847/0.851 against the GPT-based o4-mini baseline.These results are reported as evidence that SPIRE is consistently preferred in head-to-head comparisons.

C.1 More Qualitative Results

Additional qualitative results describe SPIRE’s structural perturbation pipeline and its reference-guided planning and critique prompts. The examples emphasize instruction faithfulness, reference consistency, and executable plans with concrete spatial specifications.

  • More Qualitative Results: SPIRE’s qualitative comparisons cover both in-distribution and OOD slides, showing stronger instruction faithfulness and reference-slide design consistency.The comparison is presented as additional visual evidence against baseline methods.
  • Perturbation Categories: Structural perturbations are organized by three element roles—text, graphic, and image—and eight role-conditioned attribute categories.Categories include position, size, and color perturbations specialized to the element type.
  • Perturbation Categories: Numerical perturbations sample a signed relative ratio from a severity-dependent interval, apply it to the original attribute, and clip invalid results when necessary.Categorical attributes instead use uniformly sampled valid alternatives excluding the original value.
  • Sampling Strategy: Each perturbation category is independently activated with p = 0.5, while each physical shape receives at most one primary perturbation to avoid conflicting edits.The pipeline may add one lower-severity extra perturbation from remaining candidates.
  • Sampling Strategy: The perturbation process is role-aware, attribute-specific, and severity-controlled, producing structured slide variations while preventing incompatible edits.Figure 2 compares original slides with their perturbed counterparts in paired columns.
  • Planning and Critique Prompts: The critique prompt assesses eight aspects—graphic and image position or size, graphic and text color, text position and size—using concise numeric revision targets.It treats the reference as a style guide rather than a content template and requires all eight aspects in a fixed order.
  • Planning and Critique Prompts: SPIRE’s planning prompt extracts transferable visual principles, adapts them to the requested content, and outputs a complete executable design plan.The plan covers layout, visual roles, color, position, size, typography, spacing, and normalized spatial specifications.
Loading 2607.00407v1…