Momentum-Aided Prompt Optimization (MAPO)

• MAPO is a framework for automated prompt engineering that iteratively refines prompts using positive natural language gradients and momentum-based updates.
• It employs beam search candidate expansion and UCB bandit selection to efficiently explore and select high-performing prompt trajectories.
• MAPO significantly reduces convergence time and API calls while enhancing F1 scores, as demonstrated on fake-news and hate-speech detection tasks.

Momentum-Aided Prompt Optimization (MAPO) is a framework for automated prompt engineering that enhances the efficiency and efficacy of prompt optimization for LLMs. By employing positive textual gradients and a momentum mechanism, MAPO refines prompts iteratively, leveraging beam search and Upper Confidence Bound (UCB) bandit selection to balance candidate expansion and selection. This results in faster convergence, reduced API call requirements, and improved downstream task performance relative to prior art such as ProTeGi (Cui et al., 2024).

1. Positive Natural Language Gradients

MAPO conceptualizes prompt optimization as an iterative process where the prompt $p$ (a natural language string) is continuously refined using feedback from an LLM. At each iteration $t$, given a minibatch $D_t = \{(x_i, y_i)\}_{i=1}^m$ of input–label pairs, the current prompt $p_t$ is applied to generate predictions $\hat{y}_i = \mathrm{LLM}(p_t, x_i)$. The subset $S_t = \{s_j\}$ of predictions matching true labels (correct outputs) is extracted.

MAPO then invokes the LLM with a fixed gradient-eliciting template $\tau$ to "praise and improve" $p_t$ utilizing each $s_j \in S_t$, producing textual guidance $\nabla p_t^{(j)}$. These gradients are interpreted as semantically directed improvements, not numeric derivatives. The set $t$0 is passed back into the LLM via a static template $t$1, which aggregates and applies these gradients to yield a new candidate prompt. Formally, one imagines a mapping $t$2 from text to semantic space, and the average semantic direction is

$t$3

though $t$4 is not computed explicitly; aggregation occurs entirely in language space using the LLM.

2. Momentum-Based Optimization

MAPO introduces a textual momentum buffer $t$5, analogous to the velocity vector in momentum SGD, to stabilize optimization and mitigate oscillation/local minima. At each round,

$t$6

where $t$7 is the learning rate controlling semantic step size and $t$8 ($t$9, typically $D_t = \{(x_i, y_i)\}_{i=1}^m$0) is the momentum coefficient. The operation “$D_t = \{(x_i, y_i)\}_{i=1}^m$1” denotes the semantic-update step implemented by feeding $D_t = \{(x_i, y_i)\}_{i=1}^m$2 and $D_t = \{(x_i, y_i)\}_{i=1}^m$3 into the LLM via prompt $D_t = \{(x_i, y_i)\}_{i=1}^m$4. To ensure diversity in updates, $D_t = \{(x_i, y_i)\}_{i=1}^m$5 is typically sampled randomly from the pool of positive gradients in the top-$D_t = \{(x_i, y_i)\}_{i=1}^m$6 beam.

Ablation analysis reveals that disabling momentum slows convergence by approximately 54%, though final F1 scores remain nearly unchanged. This suggests momentum primarily accelerates optimization stability rather than increasing absolute peak performance.

3. Beam Search Candidate Expansion

MAPO maintains a beam of size $D_t = \{(x_i, y_i)\}_{i=1}^m$7 (default $D_t = \{(x_i, y_i)\}_{i=1}^m$8) containing the top-performing prompt candidates at each round. For each beam member $D_t = \{(x_i, y_i)\}_{i=1}^m$9, a momentum-augmented gradient step generates $p_t$0 new continuations (default $p_t$1), resulting in up to $p_t$2 new candidates. Each candidate $p_t$3 is evaluated on a separate validation minibatch using a task-specific metric (typically F1 score), and the top $p_t$4 scoring candidates form the beam for the subsequent iteration.

This beam-based expansion ensures exploration of multiple prompt trajectories, increasing the likelihood of discovering high-performing semantic configurations.

4. Upper Confidence Bound (UCB) Bandit Selection

To balance exploration and exploitation in selecting beam prompts, MAPO employs a UCB score for candidate selection. For candidate $p_t$5, the score is

$p_t$6

where $p_t$7 is the cumulative mean minibatch score (F1), $p_t$8 the count of times candidate $p_t$9 has been selected/evaluated, $\hat{y}_i = \mathrm{LLM}(p_t, x_i)$0 the total evaluations, and $\hat{y}_i = \mathrm{LLM}(p_t, x_i)$1 ($\hat{y}_i = \mathrm{LLM}(p_t, x_i)$2, default $\hat{y}_i = \mathrm{LLM}(p_t, x_i)$3) the exploration constant.

At each round, UCB scores are computed for all candidates, and the $\hat{y}_i = \mathrm{LLM}(p_t, x_i)$4 highest scoring prompts are retained. This mechanism prevents premature pruning of promising under-explored candidates and supports efficient search over the prompt landscape.

5. Formal Framework and Algorithm

MAPO’s overall workflow is summarized by the following pseudocode:

$\tau$7

Recommended defaults include minibatch size $\hat{y}_i = \mathrm{LLM}(p_t, x_i)$5, beam width $\hat{y}_i = \mathrm{LLM}(p_t, x_i)$6, expansions per beam $\hat{y}_i = \mathrm{LLM}(p_t, x_i)$7, gradient learning rate $\hat{y}_i = \mathrm{LLM}(p_t, x_i)$8–$\hat{y}_i = \mathrm{LLM}(p_t, x_i)$9, momentum $S_t = \{s_j\}$0, exploration constant $S_t = \{s_j\}$1, and LLM temperature set to 0 for deterministic outputs.

6. Experimental Protocol and Benchmarking

MAPO has been evaluated in fake-news detection (“Liar” dataset) and hate-speech detection (“Ethos” dataset) tasks, using 200 held-out test samples per dataset. Each iteration generates two positive gradients, contrasting with ProTeGi’s four negative gradients. Metrics are reported as the best F1 over beam candidates (averaged over three runs); total API calls per run and wall-clock time are monitored and used as convergence criteria (defined by no F1 improvement or reaching the maximum round count).

Empirical results are presented in the table below:

Dataset	Method	Wall-Clock (s)	API Calls	Peak F1
Liar	ProTeGi	735	417	0.581
Liar	MAPO	285 (–61%)	77 (–81%)	0.612 (+5.3%)
Ethos	ProTeGi	686	402	0.905
Ethos	MAPO	136 (–80%)	62 (–85%)	0.951 (+5.2%)

MAPO achieves reductions in convergence time by $S_t = \{s_j\}$2, API calls by $S_t = \{s_j\}$3, and peak F1 improvement by $S_t = \{s_j\}$4. Convergence curves are characterized by fewer oscillations and plateau at higher F1 values.

7. Implementation Guidelines and Practical Considerations

MAPO is designed for black-box LLM APIs and can be implemented with the following recommendations:

• Hyperparameters: $S_t = \{s_j\}$5–$S_t = \{s_j\}$6, $S_t = \{s_j\}$7, $S_t = \{s_j\}$8, $S_t = \{s_j\}$9, $\tau$0, $\tau$1 (tunable $\tau$2–$\tau$3), minibatch size $\tau$4.
• LLM outputs: Use temperature $\tau$5 for deterministic generations.
• Variance: Results should be averaged over $\tau$6 runs to account for LLM variability.
• Reproducibility: Fix model version (e.g., October 2024 GPT-3.5-turbo) and random seeds for batching/sampling.
• Efficiency: Cache repeat evaluations of identical prompts to minimize redundant API calls.
• Early Stopping: Monitor per-round F1 gains; stopping often occurs by round 4.
• Resource Constraints: Reduce beam width or gradients per round to trade off efficacy for computational savings.

This suggests MAPO’s modularity allows adaptation for various budget and deployment scenarios, provided the recommended practices are followed.

By integrating positive natural language gradients, momentum-based semantic steps, beam search candidate generation, and UCB-based bandit selection, MAPO constructs a robust and scalable framework for automated prompt engineering, surpassing previous methods in stability, efficiency, and effectiveness for optimizing prompts in LLM-driven applications (Cui et al., 2024).