Directional Posterior Feedback Fusion for Query Reformulation in Dense Retrieval

In dense retrieval, short queries often under-specify what the user wants. A common fix is to obtain some "feedback" text first, such as the top documents from a first retrieval pass or a hypothetical answer written by an LLM (HyDE), and use it to modify the query vector. Most existing methods average the feedback vectors or interpolate them with the original query. That treats every feedback item as "what the new query should look like" and pulls the query toward it as a whole. This Tsinghua paper proposes DIFF (Directional Posterior Feedback Fusion) and argues that this causes interference: a feedback item usually supports a correction along one direction only, yet it also pulls the query back along every direction it says nothing about. DIFF first computes the direction each feedback item adds relative to the original query and requires the corrected query to agree with the feedback only along that direction, leaving other directions free. It then weights each constraint by feedback quality and adds a "don't move too far from the original query" term as a safeguard. The whole procedure has a closed-form solution and trains no model. On 14 BEIR subsets, 3 retrievers and 4 feedback sources, DIFF has the highest average NDCG@10 in all 12 settings. But with first-pass retrieved documents as feedback it barely improves on the original query without feedback. With LLM-generated feedback, its lead over the strongest baseline, AnchorQE, is about as large as the swing from hyperparameter choice. So the paper's more reliable contribution is "not being dragged down by noisy feedback", not "significantly better retrieval".

1. The problem: treating feedback as target points loses complementary information

Let the original query vector be $q$, and let feedback item $i$ propose a correction $e_i={\ell }_i{u}_i$ relative to $q$, where $u_i$ is a direction (unit vector) and ${\ell }_i$ a magnitude. Pointwise fitting wants the correction $\delta$ to be close to $e_i$, i.e. it minimizes $\Vert \delta -{\ell }_i{u}_i{\Vert }^2$. The authors split this into two terms:
$$\Vert \delta -{\ell }_i{u}_i{\Vert }^2=(u_i^{\top }\delta -{\ell }_i{)}^2+\Vert (I-u_i{u}_i^{\top })\delta {\Vert }^2$$
The first term asks $\delta$'s component along $u_i$ to equal ${\ell }_i$, which is what we want. The second penalizes $\delta$'s components along all other directions, which may be exactly the corrections other feedback items support. For example, take the query "Apple launch event": one feedback document is about a new phone, another about a new computer. Pointwise fitting pulls the query to the middle, going only halfway in each direction.

The authors prove in the appendix that with equal weights, the correction from directional constraints is never smaller than from pointwise fitting, with equality only when all feedback directions are collinear. The difference is largest when the feedback directions are mutually orthogonal. Under directional constraints the correction along direction $j$ is ${\tau }_j{\ell }_j/(\lambda +{\tau }_j)$; under pointwise fitting the denominator also adds the sum of every other item's weight, so the correction is diluted by the other feedback. The proof shows that directional constraints "move further", but moving further is not the same as moving correctly; that has to be tested by experiment.

2. Method: four steps

The first step computes each feedback item's new direction. All vectors are L2-normalized and lie on the unit sphere. For a feedback vector $f_i$, compute its similarity to the query $s_i=q^{\top }{f}_i$, then remove the part parallel to the query to get $r_i=f_i-s_{i}q$. The direction $u_i$ of $r_i$ is where this feedback wants to rotate the query, and its length ${\ell }_i$ equals the sine of the angle between them, measuring how much the feedback brings that the original query lacks. The authors deliberately separate "how much is new" (${\ell }_i$) from "how trustworthy" (decided by $s_i$), so that "very different from the query" is not mistaken for "informative and trustworthy".

The second step scores each feedback item's confidence. Confidence ${\tau }_i=g\cdot a_i$ has two levels. Item quality $a_i$: the $s_i$ of all feedback for the same query are standardized by their median and median absolute deviation, then passed through a sigmoid. Feedback closer to the query gets more weight, and the score does not depend on the absolute similarity scale of a given model. Set confidence $g$: compute the mean $\mu$ of all correction vectors, let $S=\Vert \mu {\Vert }^2$ be the strength of the mean direction and $V$ the average squared distance of each correction vector from $\mu$ (the spread); the geometric confidence is $g_{\text{geo}}=S/(S+V/K)$, with $K$ the number of feedback items, between 0 and 1. $g$ is high when the feedback agrees on a direction and low when it points every which way. It is finally multiplied by the set's average item quality, because a set of uniformly weak feedback can still agree with itself.

The third step solves for the correction jointly. The objective keeps only each feedback item's constraint along its own direction, plus a penalty on the size of the correction:
$${\delta }^{\ast }=\arg \underset{\delta }{\min }\frac{\lambda }{2}\Vert \delta {\Vert }^2+\frac{1}{2}\sum _i{\tau }_i(u_i^{\top }\delta -{\ell }_i{)}^2$$
This has a closed-form solution requiring only a $K\times K$ linear system ($K$ is the number of feedback items, 5 in the main experiments), at a cost of $O(K^{2}D+K^3)$ where $D$ is the embedding dimension.

The fourth step maps the correction back to the sphere: the final rotation angle is the smaller of $\Vert {\delta }^{\ast }\Vert$ and "$g$ × the maximum allowed angle ${\theta }_{up}$", and $q^{\prime }=\cos \varphi q+\sin \varphi {\delta }^{\ast }/\Vert {\delta }^{\ast }\Vert$. When the feedback set is untrustworthy, $g$ is small and the query barely moves.

3. Experiments

Setup: 14 BEIR subsets (including argument retrieval ArguAna, fact checking FEVER, multi-hop QA HotpotQA, MSMARCO, Google search questions NQ (Natural Questions), scientific claim verification SciFact, pandemic literature search TREC-COVID and others), and three retrievers: bge-base-en-v1.5, e5-base-v2 and Qwen3-Embedding-0.6B. There are two kinds of feedback: the top $K$ documents from first-pass retrieval (PRF), and three kinds of text generated by Qwen3.8-27B (HyDE hypothetical documents, Q2D query expansion, CoT reasoning). All methods share the same encoder, feedback and index; only the fusion method differs. Baselines include vector averaging (VPRF), concatenate-then-re-encode (Concat-P/L), OR-PRF which keeps only orthogonal components, DIME (per-dimension importance selection) and its refinement Eclipse, and AnchorQE, which needs extra retrieval to estimate weights.

3.1 Main results

The table gives average NDCG@10 over the 14 subsets; the original query's score without feedback is in parentheses:

Two things stand out. First, with retrieved documents as feedback, plain averaging drags the score below the original query, from 0.5492 to 0.5045 on BGE; in this column DIFF merely avoids losing points. The paper's own significance marks agree: on E5 and Qwen, DIFF's change relative to the original query is not significant, and only BGE's +0.003 is marked significant. Second, with LLM-generated feedback every method improves, and DIFF is very close to AnchorQE. On E5 + HyDE the gap is 0.0002 and with CoT feedback on BGE it is 0.0004, and the paper marks no significant difference in either cell. AnchorQE needs extra retrieval to estimate weights and DIFF does not; that is DIFF's practical advantage when the scores tie.

3.2 Per-query changes beneath the average

This figure explains why the PRF average barely moves. VPRF makes many queries clearly worse, with a batch losing 0.4 to 0.6. DIFF leaves the vast majority of queries essentially unchanged, with roughly as many getting better as worse. The reason is that retrieved documents point in scattered directions, so set confidence $g$ is low and step four squeezes the rotation angle to almost nothing. In other words, DIFF's behavior under noisy feedback is close to "don't move". That is robust, but it also means DIFF fails to pick out the useful few among the retrieved documents. The authors report that under HyDE feedback DIFF improves clearly more queries than it hurts, while still leaving many queries unchanged.

3.3 By subset: the gains concentrate in a few datasets

The appendix gives per-subset results on BGE. The table picks the subsets with the most visible changes:

Under PRF, DIFF rises slightly on 10 subsets and drops slightly on 4. The largest gain is 0.021 on TREC-COVID and the largest drop 0.010 on Touche2020, so the average barely changes. Under HyDE the gains come mainly from QA and entity-retrieval tasks such as NQ, TREC-COVID and DBPedia, because the LLM's hypothetical answers resemble the target documents in style. Quora is duplicate-question retrieval, where a hypothetical answer does not match the target's genre, and DIFF ends up slightly below the original query. Subset by subset, under HyDE DIFF beats AnchorQE on 10 subsets and loses on 4.

3.4 Ablations

On BGE, one component is removed or replaced at a time:

Reverting to pointwise fitting is among the largest drops, which supports the paper's central claim. Under PRF, though, every variant in the table falls below the original query's 0.5492, and only full DIFF is above it, by 0.003. So the components mainly bring the loss down to zero rather than producing a gain. Under HyDE, removing item quality drops the score from 0.5717 to 0.5481, showing that generated hypothetical documents vary in quality and must be treated differently.

3.5 Hyperparameters and efficiency

DIFF has two hyperparameters: the pull back toward the original query $\lambda$ and the maximum rotation angle ${\theta }_{up}$, searched on a 3×3 grid. Under PRF the 9 results range from 0.5452 to 0.5522, only 5 of them above the original query. The best setting uses the small angle π/12, which again says the best strategy with retrieved feedback is to barely move. Under HyDE the 9 results range from 0.5631 to 0.5717, and only 2 beat AnchorQE's 0.5700. The paper does not say which data the grid search used. If settings were picked directly on the test set, DIFF's lead over AnchorQE lies within this range of variation.

On efficiency, timed on 10 queries, DIFF takes 0.258 seconds, on par with vector averaging at 0.247 seconds, while AnchorQE takes 3.67 times as long as DIFF because of its extra retrieval. But 10 queries is a tiny sample, good only for the order of magnitude.

4. Limitations

The main one is in the main table and the distribution plot: with first-pass retrieved documents as feedback, DIFF gains almost nothing over the original query; its value is "not being dragged down by noise". Next, the lead over AnchorQE with generated feedback is small and may depend on hyperparameter choice, and the paper reports no variance across runs. Also, experiments are only on BEIR, the largest retriever is 0.6B, and there is no validation on production-scale corpora or larger embedding models. Generated feedback also comes from a single LLM.

5. Practical implications

If your system already uses HyDE or query expansion and averages the encoded generated text with the original query, consider switching to DIFF. It relies only on the vectors, needs no training and no extra retrieval, and adds one 5×5 linear solve per query, matching AnchorQE without extra retrieval calls. Before rollout, evaluate separately by query type: for tasks like Quora's "find similar questions", a hypothetical answer is the wrong kind of text to begin with. If your feedback comes from first-pass retrieval results, this paper suggests the gain is limited. Treat DIFF as insurance against averaging dragging your metrics down, not as a source of improvement.