Papers
Topics
Authors
Recent
Search
2000 character limit reached

DREAM: Dense Retrieval Embeddings via Autoregressive Modeling

Published 23 Jun 2026 in cs.CL | (2606.24667v1)

Abstract: Dense retrieval embedding models are a fundamental component of modern retrieval-based AI systems. Most dense retrievers are trained with contrastive objectives, which require labeled positive and negative document pairs that are often costly and difficult to obtain. In this work, we investigate whether the autoregressive next-token prediction objective of a LLM can provide supervision for dense retrieval. The intuition is simple: if a document contains information relevant to a query, conditioning on that document should make the target output easier for the LLM to predict. A key challenge is that the next-token prediction loss is computed inside the LLM, while the retriever is a separate embedding model. To address this challenge, we propose DREAM (Dense Retrieval Embeddings via Autoregressive Modeling), which injects retriever-generated query-document similarity scores into selected attention heads of a frozen LLM. During training, these scores determine how much attention each candidate document receives while the LLM predicts the target output. The resulting prediction loss provides gradients for retriever training through the attention mechanism. We evaluate DREAM on retrieval benchmarks BEIR and RTEB using embedding backbones ranging from 0.5B to 3B parameters. DREAM consistently outperforms existing baselines across different model scales. These results demonstrate that DREAM provides a promising approach for training dense retrievers through autoregressive modeling.

Authors (2)

Summary

  • The paper introduces a novel dense retriever training method that leverages next-token prediction losses from a frozen LLM to eliminate the need for contrastive pairs.
  • It incorporates candidate score injection into selected query-focused attention heads, thereby enhancing retrieval efficacy across benchmarks like BEIR and RTEB.
  • Empirical evaluations demonstrate improved NDCG@10 and superior embedding uniformity, affirming the scalability and robustness of the autoregressive approach.

DREAM: Dense Retrieval Embeddings via Autoregressive Modeling

Motivation and Background

Dense retrieval models are a crucial driver of retrieval-augmented generation and agentic search in modern LLM architectures. Traditionally, dense retrievers are trained with supervised contrastive objectives over query-positive-negative document pairs, relying on curated relevance annotations and hard-negative mining. This paradigm faces significant practical bottlenecks: relevance labels are labor-intensive, negative sampling may pollute supervision with false negatives, and the transferability of positive/negative designations is dataset-dependent.

Autoregressive next-token prediction (NTP) objectives, integral to LLM pretraining, offer an alternative avenue for supervision. The intuition underlying DREAM is that models conditioned on relevant documents should exhibit improved target passage generation, reflected in reduced NTP loss. Unlike contrastive objectives, NTP supervision requires no explicit relevance labels or negative sampling.

Methodological Formulation

DREAM introduces an architecture wherein a dense retriever is trained via gradients propagated from NTP loss in a frozen LLM. Candidate document scores computed by the retriever modulate selected attention heads in the LLM during prediction, directly coupling retriever decisions to LLM performance. Figure 1

Figure 1: Overview of DREAM, coupling retriever scores to attention heads within a frozen LLM to supervise training via next-token prediction loss.

Key methodological aspects include:

  • Retriever Score Injection: Retriever similarities sϕ(q,dj)s_\phi(q, d_j) are normalized to weights pϕ(djq)p_\phi(d_j|q) and injected into designated attention heads at query-token positions. These heads are selected pre-training using a ranking based on their query-to-candidate alignment, following query-focused retrieval head identification [zhang2025queryfocused]. Only heads with evidential relevance for retrieval are chosen, maximizing informative supervision.
  • Attention Modulation: For each selected head hh, retriever weights assign attention distribution across documents, while intra-document token selection adheres to frozen LLM preferences. A learnable gate determines the impact of retriever modulation.
  • Training Objective: Cross-entropy NTP loss on target passage tokens is backpropagated, providing gradients solely to the retriever via the modified attention αh\alpha'_h. This induces competition among candidates, obviating the need for explicit negatives; increasing weight on non-informative candidates is directly penalized.

Empirical Evaluation

DREAM is benchmarked across BEIR and RTEB using embedding backbones from 0.5B to 8B parameters, with candidate and target passages constructed from Wikipedia chunks and queries synthesized by Qwen3-14B.

Retrieval Performance:

  • DREAM consistently outperforms BM25, InfoNCE, RePlug, and Revela retrievers at each backbone scale in NDCG@10 across both BEIR and RTEB.
  • Gains over contrastive InfoNCE baseline (trained on same data/candidate pools) isolate advantages arising specifically from the autoregressive training signal, not from candidate selection artifacts.

Attention Head Analysis:

  • Injecting scores into query-focused retrieval heads yields markedly higher retrieval performance versus random or middle-layer heads, confirming that the interface between retriever and LLM is critical to signal efficacy. Figure 2

    Figure 2: Retrieval heads selected via query-focused ranking enable significantly stronger supervision compared to non-specialized heads.

  • Increasing the number of selected heads improves retrieval up to a threshold (Top 16 heads), with performance deteriorating when diluted by weaker heads. Figure 3

    Figure 3: Average NDCG@10 as a function of the count of selected heads; optimal performance at Top 16 retrieval heads.

Embedding Geometry:

  • DREAM's retrievers yield embeddings with superior uniformity and competitive alignment versus RePlug and Revela, achieving a less collapsed, more discriminative embedding space without contrastive objectives. Figure 4

    Figure 4: Embedding-space analysis of query-positive pairs: DREAM achieves better uniformity with strong alignment.

Ablation Studies:

  • Keeping the judge LLM frozen provides more stable supervision than jointly updating LoRA adapters, confirming that supervision should be anchored to fixed model computation. Figure 5

    Figure 5: Frozen judge LLM yields stronger retriever training signal than LoRA-updated judge.

  • Training with larger candidate document sets (e.g., 16 per sample) benefits retrieval performance, consistent with stronger inter-document competition. Figure 6

    Figure 6: Retrieval improves as candidate set size grows, saturating at model scales and candidate counts used in DREAM.

  • DREAM scaling experiments at 8B backbone show competitive or superior retrieval performance to strong off-the-shelf embedding models, validating the scalability of the method.

Theoretical and Practical Implications

The DREAM framework demonstrates that direct supervision for dense retrieval can be achieved through autoregressive losses, circumventing the established reliance on contrastive pair construction. By leveraging attention head specializations within frozen LLMs, DREAM effectively aligns retriever optimization with end-task utility, as measured by NTP performance.

This suggests future directions for:

  • Self-supervised Retrieval Training: Exploiting rich NTP signals for retrieval in domains lacking relevance annotations or with weakly curated corpora.
  • LLM-augmented Retriever Design: Harnessing head-level analyses and modular attention injections to integrate retrievers tightly with LLM inference architectures.
  • Model Scaling and Adaptivity: Extending to larger embedding backbones and dynamic head selection for adaptive retrieval in evolving corpus domains.

The method challenges the notion that contrastive pairwise objectives are necessary for dense retriever training, proposing that autoregressive modeling, when correctly interfaced, is an effective, scalable alternative.

Conclusion

DREAM operationalizes dense retriever training directly via autoregressive NTP losses in a frozen LLM, using strategic attention head modulation to propagate supervision. The approach is empirically validated across standard benchmarks and scales, outperforming both classical lexical baselines and contemporary LLM-supervised methods. Theoretical implications support a shift in training paradigms for embedding-based retrieval, emphasizing autoregressive objectives and informed attention interfacing as core mechanisms.

Paper to Video (Beta)

No one has generated a video about this paper yet.

Whiteboard

No one has generated a whiteboard explanation for this paper yet.

Explain it Like I'm 14

A simple guide to “DREAM: Dense Retrieval Embeddings via Autoregressive Modeling”

1) What is this paper about?

This paper is about teaching computers to find the most helpful information for answering a question. The authors introduce a method called DREAM that trains a “retriever” (a tool that picks useful documents) by using a “writer” (a LLM, or LLM) that predicts the next word in a text. Instead of needing lots of human-made labels that say “this document is good” and “that one is bad,” DREAM learns from how much a document actually helps the LLM write the correct answer.

2) What questions are the authors trying to answer?

  • Can we train a document retriever without expensive, hand-made labels?
  • Can we use a LLM’s basic skill—predicting the next word—to judge whether a document actually helps answer a question?
  • If we connect the retriever to the LLM in a smart way, will the retriever get better at finding helpful documents?

3) How does DREAM work? (With everyday analogies)

Think of an LLM as a student who writes answers, and the retriever as a librarian who brings the student a stack of books. The key idea is: good books should make it easier for the student to write the right answer. DREAM teaches the librarian by watching whether the student writes better when given certain books.

Here’s the approach in simple steps:

  • The system gets:
    • A question (the “query”),
    • A bunch of candidate documents (possible “books”),
    • And a target passage (the “answer” or text we want the model to produce).
  • The retriever scores each document: how likely is it to help with this question? (This is like the librarian ranking books by usefulness.)
  • These scores are fed into specific “attention heads” inside a frozen LLM. Attention heads are like spotlights that tell the LLM where to “look” in the text. DREAM carefully picks the heads that already focus on connecting the question to useful information (like the spotlights that already point toward relevant pages).
  • While the LLM tries to predict the next word of the target answer (like finishing a sentence), the document scores influence how much the LLM “reads” from each candidate document. If the LLM writes more accurately when it “looks” at a certain document, that document’s score should go up.
  • The LLM itself is “frozen” (not changed during training), so the only thing that learns is the retriever. This is like keeping the student’s writing style fixed and training the librarian to pick better books.

Two important details:

  • Normalized scores: The retriever’s scores are turned into a probability-like distribution across documents. That means giving more weight to one document automatically gives less to others—so documents “compete” for attention.
  • Selected attention heads: Instead of changing every spotlight, DREAM chooses only the ones that already connect questions to helpful context. This keeps the training signal strong and focused.

4) What did they find, and why is it important?

The researchers tested DREAM on two big benchmarks (BEIR and RTEB) that evaluate how well models retrieve helpful information across many topics (like science, medicine, code, and more).

Main findings:

  • DREAM consistently beat several strong baselines, including:
    • Traditional methods that rely on hand-crafted labels,
    • RePlug (which uses LLM likelihoods but doesn’t directly link scores to LLM attention), and
    • Revela (which also uses language modeling but without an explicit question-and-target setup).
  • The improvements held across different model sizes (from about 0.5B to 3B parameters).
  • Picking the right attention heads matters a lot. Injecting scores into random heads performed poorly. Using heads that naturally focus on “query-to-document” relevance made the learning signal much stronger.
  • Freezing the LLM works better than training it together with the retriever. Keeping the LLM fixed makes it a consistent “judge,” so improvements in writing accuracy clearly point back to better document choices.
  • The retriever’s learned “embedding space” (how it places texts as points in a high-dimensional space) became both:
    • Well aligned (relevant documents closer to their questions), and
    • Nicely spread out (less collapse, so different texts remain distinguishable).
    • This is impressive because DREAM does this without the usual “contrastive” pairs of positives and negatives.

Why this matters:

  • It reduces the need for expensive labeled data (no need to hand-pick “good” and “bad” documents).
  • It directly measures usefulness: a document is considered “good” if it actually helps the LLM produce the right answer.
  • It produces a retriever that can be used on its own in real systems.

5) What are the broader implications?

DREAM shows a practical, scalable way to train document retrievers by tapping into the natural training signal of LLMs—predicting the next word. This could:

  • Make building search and question-answering systems cheaper and faster (less manual labeling),
  • Improve tools that help LLMs look up information (like AI assistants that search before answering),
  • Encourage new designs where retrieval and generation work together more tightly.

In short, DREAM is like teaching the librarian by watching how well the student writes with each book, rather than telling the librarian in advance which books are “right.” It’s a simple idea that leads to better, more flexible retrieval systems.

Knowledge Gaps

Knowledge gaps, limitations, and open questions

The paper leaves several aspects insufficiently explored. The following concrete gaps can guide future work:

  • Training candidate pool realism
    • Training uses candidate chunks drawn from a single document (16-way intra-document competition). Assess whether DREAM still learns effective global discrimination when candidates span the entire corpus and include hard negatives from other documents/domains.
    • Study curriculum or sampling strategies that gradually expand from intra-document to cross-document candidate sets, and quantify effects on embedding geometry and retrieval metrics.
  • Dependence on the frozen judge LLM
    • Generalization across judges: DREAM is evaluated with a single frozen LLM (Llama-3.1-8B-Instruct). Test sensitivity to judge architecture, scale, pretraining data, and instruction-tuning (e.g., different Llama/Qwen/Mistral variants).
    • Judge prior leakage: Quantify how much of the next-token loss signal derives from the judge’s internal knowledge vs retrieved context (e.g., include “no-context” baselines, masked/held-out topics, or judges trained without target domains).
    • Black-box constraints: The method requires white-box access to attention weights and the ability to modify head-level attention. Investigate black-box-compatible alternatives (e.g., gradient-free distillation, token routing via controllable prompting, or proxy cross-attention modules).
    • Stability across head-selection procedures: Evaluate whether retrieval-head selection transfers across judge LLMs, across datasets, and under smaller probe sets; analyze sensitivity to the “content-free” query choice and ranking threshold.
  • Attention-injection design choices
    • Injection locus: Compare post-softmax reweighting to pre-softmax logit perturbation, key/value-vector modulation, or mixed strategies; measure gradient strength and training stability trade-offs.
    • Gating granularity: The paper uses a single learnable gate g; test per-head, per-layer, or per-query gates, and dynamic gating conditioned on query/document features.
    • Token-row selection: Injection is applied only to query-token rows. Explore injecting into target-token rows (to control evidence aggregation during generation), or jointly into query and target rows.
    • Prompt order and positional effects: Only “document-first” order is used. Examine alternative orderings (e.g., interleaved passages, query-first) and their impact on attention biases and training signal.
    • Number and identity of heads: Head count is tuned but fixed (Top-16). Explore adaptive head selection during training, head-swap schedules across layers, or data-dependent head subsets.
  • Scalability and efficiency
    • Computational cost: Training concatenates K passages + query + target into the judge LLM; report memory/latency and compare total training FLOPs to contrastive objectives. Investigate efficiency techniques (e.g., chunk pruning, sparse attention, or smaller judges).
    • Large candidate sets: Training K ≤ 16; test K ≫ 16 and sampling/mini-batch strategies that approximate corpus-scale competition without prohibitive sequence lengths.
    • Indexing/inference efficiency: Although the retriever is standalone at inference, there is no analysis of approximate nearest neighbor indexing, latency, or throughput under large-scale deployments.
  • Data and supervision quality
    • Synthetic query bias: Queries are generated by an LLM (Qwen3-14B). Quantify sensitivity to query quality and style, and compare with human-annotated positives or mined real queries.
    • Multi-positive and multi-hop supervision: Training assumes a single target passage. Extend to settings with multiple relevant passages and multi-hop questions where support must be aggregated.
    • Domain and language coverage: Training on Wikipedia may limit diversity; evaluate training/evaluation on non-English corpora and highly specialized or dynamic domains.
  • Evaluation scope and realism
    • Downstream RAG impact: The paper reports retrieval metrics (NDCG@10) but not end-to-end QA or task performance in RAG/agent pipelines. Measure answer accuracy, factuality, and latency in full systems.
    • Robustness tests: Assess sensitivity to adversarial/off-topic distractors, noisy/contradictory documents, and long-tail queries.
    • Error analysis: Provide qualitative analyses of failure modes (e.g., positional biases, topical confusions, or over-reliance on a small set of heads).
  • Theoretical and diagnostic understanding
    • Objective alignment: Formalize when reductions in next-token loss correspond to improvements in relevance metrics like NDCG/Recall; analyze cases where language-modeling loss and retrieval quality diverge.
    • Gradient signal quality: Analyze variance and saturation of gradients flowing through attention reweighting (e.g., effects of temperature τ and gate g on signal-to-noise).
    • Embedding geometry causality: The paper observes improved uniformity; investigate causal links between competition over p(d|q) and uniformity, and whether explicit regularizers can enhance or stabilize these properties.
  • Method interactions and extensions
    • Combining losses: Evaluate hybrid objectives that blend DREAM with contrastive losses or distillation (e.g., InfoNCE + NTP-supervision) and ablate which components drive gains.
    • Compatibility with encoder–decoder LMs: DREAM targets decoder-only judges; test encoder–decoder judges and cross-attention-based interfaces.
    • Cross-model deployment: Train with judge A but deploy retriever with generator B; measure cross-LLM transfer and identify mismatch failure modes.
  • Practical and ethical considerations
    • Data leakage and overlaps: BEIR/RTEB may overlap with Wikipedia content used for training; quantify overlap and its impact on reported zero-shot gains.
    • Bias and fairness: Examine whether head selection or judge priors introduce demographic/topic biases in retrieval rankings; develop mitigation strategies.

Practical Applications

Immediate Applications

Below are deployable use cases that can be implemented with today’s open-source models and infrastructure, leveraging DREAM’s ability to train dense retrievers via next-token prediction with a frozen LLM.

  • Sector: Software/Enterprise Search — Cold-start retriever for RAG without labels
    • What: Train organization-specific retrievers for internal wikis, runbooks, design docs, and ticket systems using DREAM instead of contrastive labeling and hard-negative mining.
    • Tools/Workflow:
    • Document chunking and indexing in a vector DB (e.g., FAISS, Milvus, pgvector).
    • Frozen open-source judge LLM (e.g., Llama 3.1 8B) with attention-head access.
    • DREAM training pipeline with head selection; LoRA adapters on the embedding backbone (0.5B–3B feasible; 8B if resources allow).
    • Why now: Demonstrated gains over RePlug/Revela and contrastive baselines on BEIR/RTEB.
    • Assumptions/Dependencies:
    • Access to a frozen LLM with modifiable attention (closed APIs typically won’t work).
    • GPU time for training; quality chunking and synthetic query generation (if logs not available).
  • Sector: Customer Support/Contact Centers — Knowledge-base assistants
    • What: Improve ticket deflection and agent-assist by training DREAM retrievers on support articles and historical chat logs (queries) with accepted replies (targets).
    • Tools/Workflow:
    • Mine resolved tickets as query–target pairs; generate synthetic queries for underrepresented topics.
    • Integrate DREAM retriever into RAG pipelines for chatbots/assist widgets.
    • Why now: Eliminates manual relevance labeling and hard-negative mining in evolving KBs.
    • Assumptions/Dependencies:
    • Sufficient historical logs or reliable synthetic query generation.
    • Secure, on-prem deployment of the judge LLM for PII compliance.
  • Sector: Legal — E-discovery and case-law search
    • What: Tune a domain retriever over statutes, case opinions, contracts to improve recall and precision for legal research.
    • Tools/Workflow:
    • Use prior memos/briefs as targets; generate or mine queries from attorney prompts.
    • DREAM-trained retriever plugged into legal search UX with semantic filters.
    • Why now: Strong BEIR/RTEB performance suggests cross-domain transfer; label-light training is cost-effective.
    • Assumptions/Dependencies:
    • Robust access controls and on-prem compute for sensitive documents.
    • Human-in-the-loop validation for high-stakes use.
  • Sector: Finance — Research and compliance search
    • What: Retrieval over filings, earnings calls, policy manuals, and risk/compliance guidelines to support analysts and auditors.
    • Tools/Workflow:
    • Train on internal research notes (targets) paired with analyst prompts (queries) or synthetically generated questions.
    • Integrate retriever with RAG for Q&A and summarization of disclosures.
    • Why now: Reduces reliance on costly relevance labeling; supports broad document types.
    • Assumptions/Dependencies:
    • Data governance for MNPI; stable frozen judge LLM for repeatable training.
  • Sector: Developer Tools — Code, docs, and structured data retrieval
    • What: POWER IDE assistants and code search by DREAM-tuned retrievers for repos, READMEs, and API docs; retrieve related tables/specs (e.g., WikiSQL-style artifacts).
    • Tools/Workflow:
    • Train with historical PRs/issues/commit messages as targets; synthesize queries from code snippets.
    • Integrate with embeddings in code browsers and LLM-based autocompletion.
    • Why now: RTEB gains on code/structured-data tasks; standalone embedding retriever works in existing dev tooling.
    • Assumptions/Dependencies:
    • Multilingual repos may require multilingual backbones; repository chunking strategy matters.
  • Sector: Healthcare/Biomedical — Literature and clinical knowledge retrieval (non-diagnostic assistant)
    • What: Evidence retrieval for literature reviews and guideline lookup (not clinical decision-making).
    • Tools/Workflow:
    • Train on internal literature review Q&A or synthesize queries from abstracts; integrate with RAG for summarization.
    • Why now: Label-light training reduces cost for fast-moving biomedical corpora.
    • Assumptions/Dependencies:
    • Strict safety and compliance; professional oversight; avoid direct diagnostic use.
  • Sector: Academia/Education — Course assistants and literature search
    • What: Course-specific assistants retrieving from lecture notes, slides, and readings; lab/lit search assistants for research groups.
    • Tools/Workflow:
    • Use past exams or instructor-written Q&A as targets; synthesize additional queries.
    • Deploy in LMS with a DREAM-based retriever.
    • Why now: Minimal labeling overhead; strong results across diverse BEIR tasks.
    • Assumptions/Dependencies:
    • Sufficient course materials; content chunking and evaluation by instructors.
  • Sector: Government/Public Sector — Records and policy retrieval
    • What: FOIA, procurement, and policy-document search augmented by DREAM retrievers trained on internal corpora with minimal labels.
    • Tools/Workflow:
    • Train with prior information requests and official responses; synthesize queries for coverage.
    • On-prem DREAM pipeline using a frozen judge LLM to maintain sovereignty.
    • Why now: Cuts annotation requirements; enhances recall across heterogeneous records.
    • Assumptions/Dependencies:
    • Classification and access-control integration; auditable training procedure.
  • Sector: Personal Knowledge Management — Private note and email search
    • What: Local retriever trained over personal notes, emails, and bookmarks for better semantic search without cloud labels.
    • Tools/Workflow:
    • Use a local 3B–8B judge LLM; generate queries from notes; plug retriever into local search apps.
    • Why now: Works with modest hardware; improves recall over standard keyword search.
    • Assumptions/Dependencies:
    • Local GPU/CPU constraints; privacy-preserving storage; careful chunking.

Long-Term Applications

These opportunities are promising but require further research, engineering, or ecosystem changes (e.g., better APIs, larger/multilingual models, safety evaluations).

  • Sector: Platform/Infrastructure — Retriever auto-tuning from live RAG logs
    • What: Continuous learning loop that transforms production RAG interactions (user queries + accepted LLM outputs) into DREAM training examples, periodically refreshing the retriever.
    • Tools/Workflow:
    • “AutoTune Retriever” service: log ingestion → query–target curation → head selection → DREAM fine-tuning → A/B rollouts.
    • Dependencies/Assumptions:
    • Robust feedback signal (clicks, dwell, edits); privacy-safe logging; safeguards against feedback loops and drift.
  • Sector: Model/Tooling Ecosystem — Attention-head selection and injection as a service
    • What: General-purpose library that identifies query-focused retrieval heads and safely injects document weights across diverse open models.
    • Tools/Workflow:
    • Head-ranking module; adapters for major open LLMs; diagnostics dashboards (e.g., attention distributions, loss attribution).
    • Dependencies/Assumptions:
    • Standardized attention APIs; reproducibility across model families; efficient instrumentation.
  • Sector: Cloud AI/ISVs — Vector DBs and RAG frameworks with built-in DREAM trainers
    • What: One-click DREAM training integrated into vector databases and RAG orchestration (e.g., LlamaIndex, LangChain), enabling enterprises to train label-light retrievers inside their stack.
    • Tools/Workflow:
    • “Train via NTP” option alongside contrastive training; orchestration for frozen-judge selection, dataset synthesis, and evaluation.
    • Dependencies/Assumptions:
    • Support for hosting/forking frozen LLM checkpoints; resource scheduling; governance controls.
  • Sector: Multilingual/Global — Cross-lingual and multilingual DREAM retrievers
    • What: Train retrievers that work across languages by using multilingual backbones and multilingual frozen judges.
    • Tools/Workflow:
    • Multilingual corpora; language-aware head selection; evaluation on multilingual BEIR/MTEB.
    • Dependencies/Assumptions:
    • Suitable multilingual LLMs with accessible attention; domain-specific evaluation; handling script diversity.
  • Sector: Robotics/Autonomy — Memory retrieval for agentic planning
    • What: Train retrievers over embodied agent logs, sensor summaries, and task histories by supervising with next-action or plan-token prediction (“judge” is the policy/model).
    • Tools/Workflow:
    • DREAM-style attention injection into planning models’ retrieval heads; memory selection tuned by future-token loss.
    • Dependencies/Assumptions:
    • Reliable identification of retrieval heads in policy models; safe online learning; sim2real transfer.
  • Sector: Healthcare (regulated) — Clinically validated evidence retrievers
    • What: DREAM-tuned retrievers that feed clinician-facing RAG assistants with traceable evidence and better recall, evaluated under medical benchmarks and human review.
    • Tools/Workflow:
    • Prospective studies; bias/safety audits; integration with EHRs and knowledge graphs.
    • Dependencies/Assumptions:
    • Rigorous clinical validation; regulatory approvals; robust safeguards for hallucination and outdated evidence.
  • Sector: Privacy/Security — Federated and on-device DREAM training
    • What: Train retrievers from local corpora using a local frozen judge LLM, coordinated via federated learning to avoid centralizing sensitive data.
    • Tools/Workflow:
    • Client-side attention-injection trainers; secure aggregation; differential privacy.
    • Dependencies/Assumptions:
    • Efficient on-device training; communication-efficient aggregation; privacy guarantees.
  • Sector: Safety/Policy — Fairness- and safety-aware retrieval objectives
    • What: Extend the NTP-supervised objective with fairness/safety constraints so retrievers avoid systematically under-retrieving protected or sensitive content.
    • Tools/Workflow:
    • Constraint-aware training; counterfactual or coverage regularizers; red-team evaluation.
    • Dependencies/Assumptions:
    • Measurable fairness criteria per domain; representative datasets; governance policies.
  • Sector: Closed-Model Ecosystems — Black-box-compatible variants
    • What: Approximate DREAM training for API-only LLMs via surrogate open judges or distilling gradients from likelihood preferences without internal attention access.
    • Tools/Workflow:
    • Hybrid pipeline: open judge for training, production RAG with closed model; or preference-distillation adapters.
    • Dependencies/Assumptions:
    • Transferability gap between open-judge supervision and closed-model inference; monitoring for regressions.
  • Sector: Research — Unified theory and diagnostics of retrieval heads
    • What: Systematic methods to discover, score, and control retrieval heads across architectures; explainability tools linking head behavior to retrieval quality.
    • Tools/Workflow:
    • Benchmarks for head-centric supervision; visualization and probing suites; ablation harnesses at scale.
    • Dependencies/Assumptions:
    • Community standardization; reproducible probes; open checkpoints.

Notes on Feasibility and Key Assumptions (Applies Across Use Cases)

  • Frozen Judge LLM Access: DREAM’s training requires a frozen, modifiable LLM with attention access; proprietary black-box APIs typically cannot be used directly.
  • Data Preparation: High-quality chunking and either historical query–target pairs or reliable synthetic queries are central to performance.
  • Compute: Training with 16+ candidates per query and 1B–8B models requires moderate GPUs; LoRA helps but does not eliminate cost.
  • Stability: Freezing the judge improves signal quality; updating the judge weakens supervision (observed empirically).
  • Generalization: Results reported mainly in English; multilingual and specialized domains may require additional adaptation and evaluation.
  • Safety/Compliance: High-stakes domains (healthcare, legal, finance, government) require guardrails, audit trails, and human review.

Glossary

  • Alignment: An embedding-space metric that measures how close queries are to their relevant documents. "Alignment measures the average squared distance between a query embedding and its positive-document embedding."
  • Autoregressive next-token prediction (NTP): A training objective where a LLM predicts the next token, providing supervision from raw text. "At the same time, autoregressive modeling via next-token prediction (NTP) has become the foundation of modern language-model training"
  • BEIR: A heterogeneous benchmark for evaluating information retrieval models across multiple domains. "We evaluate with NDCG@10 on BEIR \citep{thakur2021beir} and RTEB \citep{muennighoff2023mteb}."
  • BM25: A classical lexical retrieval algorithm based on term frequency and inverse document frequency. "BM25 is a lexical retrieval baseline and does not use a learned embedding backbone."
  • Contrastive objectives: Training losses that increase similarity for positive pairs and decrease similarity for negative pairs. "Most dense retrievers are trained with contrastive objectives."
  • Decoder-only LLM: A LLM architecture composed solely of decoder layers used for autoregressive generation. "DREAM trains a dense retriever by feeding the retriever's query-document scores into selected attention heads of a frozen decoder-only LLM as it predicts the target passage."
  • Dense dual-encoders: Retrieval models that encode queries and documents separately and rank them by vector similarity. "Dense dual-encoders embed a query and a passage separately and rank them by similarity \citep{karpukhin2020dense},"
  • Document-first causal order: An input ordering where candidate documents precede the query and target so they can be attended to causally. "We use document-first causal order:"
  • Document-level weights: Normalized scores over candidate documents used to allocate attention across documents. "we normalize the candidate scores into document-level weights:"
  • Embedding backbone: The underlying model architecture used to compute embeddings for queries and documents. "using embedding backbones ranging from 0.5B to 3B parameters."
  • False negatives: Negative samples that are incorrectly labeled and actually relevant, which can mislead training. "hard negatives are difficult to mine reliably and may include false negatives"
  • Frozen LLM: A LLM whose parameters are kept fixed during training to provide a stable supervision signal. "these scores are injected into selected attention heads of the frozen LLM."
  • Gate: A learnable scalar (via a sigmoid) that controls the mixture of original and retriever-guided attention. "where g=σ(γ)[0,1]g=\sigma(\gamma)\in[0,1] is a learnable gate."
  • Hard-negative mining: The practice of selecting challenging negative examples to improve contrastive training. "and hard-negative mining \citep{xiong2021approximate,qu2020rocketqa}."
  • In-batch attention: An attention mechanism that operates over examples within a batch to incorporate retrieval signals. "through in-batch attention"
  • In-context learning: The capability of models to learn patterns from prompts without parameter updates. "Interpretability work shows that induction heads implement structured copying that underlies in-context learning"
  • Induction heads: Specialized attention heads that perform structured copying behaviors linked to in-context learning. "Interpretability work shows that induction heads implement structured copying that underlies in-context learning"
  • InfoNCE: A contrastive loss used for representation learning by distinguishing positives from many negatives. "InfoNCE~\citep{oord2018representation} is a contrastive baseline trained on the same data and candidate pool as DREAM"
  • L2-normalized: A normalization that scales vectors to unit length under the L2 norm. "produces L2-normalized last-token representations:"
  • Likelihood distillation: Training a retriever from preferences or likelihoods computed by a (possibly frozen) LLM. "This objective differs from likelihood distillation in how the supervision reaches the retriever."
  • LoRA adapters: Low-rank adaptation modules that efficiently fine-tune large models via rank-constrained updates. "We train LoRA adapters on the embedding model's q/k/v/oq/k/v/o projection modules with rank 32 and alpha 64."
  • Masked LLM: A language modeling objective where tokens are masked and the model predicts them from context. "REALM jointly trains a retriever with a masked LLM so that the language-model objective shapes retrieval"
  • Multi-head attention: An architecture that uses multiple attention heads to capture diverse token-to-token relationships. "Multi-head attention lets different heads specialize in distinct token-to-token computations"
  • NDCG@10: A ranking metric (Normalized Discounted Cumulative Gain) computed at cutoff 10 for retrieval quality. "with gains ranging from 0.015 to 0.081 NDCG@10 on BEIR"
  • Next-token cross entropy: The cross-entropy loss computed over the next-token predictions in autoregressive training. "The loss is standard next-token cross entropy on the target-passage tokens."
  • Query-focused retrieval heads: Attention heads identified to naturally route query tokens to relevant context. "We therefore inject retriever scores only into query-focused retrieval heads identified by \citet{zhang2025queryfocused}."
  • REALM: A method that jointly trains retrieval with a LLM so the LM objective guides what to retrieve. "REALM jointly trains a retriever with a masked LLM so that the language-model objective shapes retrieval"
  • Retrieval-augmented generation: A paradigm where external documents are retrieved and added to the prompt to improve generation. "Retrieval-augmented generation adds external documents to the prompt"
  • Revela: A retriever learning approach that integrates language modeling signals and updates both retriever and LM. "Revela trains dense retrievers with a language-modeling objective over chunk sequences, jointly updating the retriever and the LLM"
  • RePlug: A method that uses frozen-LLM likelihoods to distill document preferences into a retriever. "RePlug distills document preferences from frozen-LLM likelihoods"
  • RTEB: A retrieval evaluation benchmark spanning many domains (legal, financial, code, etc.). "We evaluate with NDCG@10 on BEIR \citep{thakur2021beir} and RTEB \citep{muennighoff2023mteb}."
  • Temperature: A scaling parameter in softmax that controls the sharpness of the distribution over documents. "where τ\tau is a learnable temperature."
  • Uniformity: An embedding-space metric that measures how spread out representations are, indicating non-collapse. "Uniformity measures how spread out the query and positive-document embeddings are in the representation space~\citep{gao2021simcse}."

Open Problems

We haven't generated a list of open problems mentioned in this paper yet.

Collections

Sign up for free to add this paper to one or more collections.

Tweets

Sign up for free to view the 1 tweet with 61 likes about this paper.