Multi-Head RAG: Solving Multi-Aspect Problems with LLMs

## Abstract

Abstract Retrieval Augmented Generation (RAG) enhances the abilities of Large Language Models (LLMs) by enabling the retrieval of documents into the LLM context to provide more accurate and relevant responses. Existing RAG solutions do not focus on queries that may require fetching multiple documents with substantially different contents. Such queries occur frequently, but are challenging because the embeddings of these documents may be distant in the embedding space, making it hard to retrieve them all.
This paper introduces Multi-Head RAG (MRAG), a novel scheme designed to address this gap with a simple yet powerful idea: leveraging activations of Transformer’s multi-head attention layer, instead of the decoder layer, as keys for fetching multi-aspect documents. The driving motivation is that different attention heads can learn to capture different data aspects. Harnessing the corresponding activations results in embeddings that represent various facets of data items and queries, improving the retrieval accuracy for complex queries. We provide an evaluation methodology and metrics, synthetic datasets, and real-world use cases to demonstrate MRAG’s effectiveness, showing improvements of up to 20% in relevance over standard RAG baselines. MRAG can be seamlessly integrated with existing RAG frameworks and benchmarking tools like RAGAS as well as different classes of data stores.

## 1 Introduction

Large Language Models (LLMs) transformed many machine learning tasks using in-context learning abilities. They achieved such accuracy by leveraging an increasing number of parameters, which in recent models have grown to hundreds of billions, making LLM training expensive in terms of both time and resources. It also comes with the danger of leaking confidential data into model weights [, , ]. Additionally, continuous training through fine-tuning is necessary to keep LLMs up-to-date. Even using the newest data, LLMs display an ongoing problem of hallucinations [, , ] by providing factually incorrect information. Retrieval Augmented Generation (RAG) was proposed [, ] in order to address these issues as well as others and make LLMs more trustworthy.

The key idea behind RAG is to enhance the generative model’s capabilities by integrating a retrieval system that can fetch relevant documents or passages from a large corpus of data. In this setting, when a query is received, the retrieval system first identifies and retrieves pertinent information, which is fed into the generative model’s context for a more accurate and relevant response.
Instead of the model storing information within its weights, RAG effectively leverages external knowledge, reducing hallucinations (by grounding the LLM reply in reliable sources), and ensuring that responses contain up-to-date knowledge (e.g., by accessing the Internet), all without requiring expensive training.

More specifically, there are two main stages in a RAG pipeline: data preparation and query execution. During data preparation, one constructs a vector database (DB) populated with embeddings and their corresponding data items such as documents. During query execution, one constructs an embedding of that query and retrieves data items in the store with similar embeddings.

Intense recent research efforts have been put into RAG [, , , , , , ].
On one hand, different RAG designs have been proposed, for example RAPTOR [], Self-RAG [], Chain-of-Note [], and many others [, , , , , , ].
In general, these schemes focus on making the retrieved data more accurate and relevant to the query.
On the other hand, there have also been efforts into benchmarking and datasets for RAG evaluation [, , , ].

Despite all these advances, we observe that no existing RAG scheme or evaluation methodology explicitly targets an important class of problems that come with a high degree of multi-aspectuality. These are problems that require combining several (potentially many) significantly different aspects in a single query.
As a simple illustrative example of such a query, consider the question “What car did Alexander the Great drive?”, and assume that the queried model has not been trained on history. When using RAG, to answer this question accurately, one would retrieve two documents, one describing Alexander the Great and one outlining the history of car manufacturing. However, the embeddings of these two documents could be far away from each other in the embedding space.
At the same time, such queries are common in different industry settings, as indicated by extensive discussions with our industry collaborators. Imagine a chemical processing plant experiencing an equipment accident. One could use an LLM to find the accident cause, which might require the retrieval of multiple, potentially confidential documents to provide the necessary context. These documents could be related to different aspects, for example psychological profiles of workers (“Was the accident due to mismanaging a worker?”), equipment purchase records (“Was some equipment part too old?”), maintenance (“Was some equipment part rusty?”), weather (“Was there a particularly strong thunderstorm at the accident time that could have caused dangerous power spikes in the grid?”), or even microclimate (“Was it too humid for an extended period of time in the production hall?”).
As we illustrate in Section 4, such problems pose challenges for existing RAG schemes and have been unaddressed by modern RAG benchmarking pipelines.

Figure: Figure 1: An overview of the decoder architecture, and a comparison of how standard RAG and Multi-Head RAG embeddings are generated.
Refer to caption: x1.png

In this work, we propose Multi-Head RAG (MRAG): a scheme that addresses the above problem.
Common practice in modern RAG designs is the use of embeddings based on last-layer decoder block activations.
Our key idea is to use instead the activations of the multi-head attention part of the decoder block as embeddings.
The Transformer architecture can be seen as a pipeline with many (e.g., 96 for GPT-3 []) blocks, where a single block consists of an attention module and a feed-forward module. Each individual attention module is multi-headed: it consists of multiple parts called heads that learn different sets of weight matrices; see Figure 1 for an overview. It is conjectured that these different heads could capture different aspects of the processed data.
We use this as a driving design feature that facilitates capturing the potential multi-aspectuality of the data without increasing space requirements compared to standard RAG (contribution 1).

Such multi-aspect embeddings are then directly used for both data items and query representation.
Considering multi-aspectuality explicitly comes with challenges. For example, how to assess the effectiveness of a RAG solution in retrieving data that indeed does cover multiple aspects of a given domain. For this, we establish an evaluation methodology as well as a full data construction and query processing pipeline that implements the multi-aspect embedding idea (contribution 2). Our datasets facilitate broad evaluation by considering both fully-automatically generated, synthetic data and analyzing specific industry use cases that show the benefits of MRAG (contribution 3).
Our evaluation illustrates the benefits in the relevance of retrieved documents, for example 20% over a modern RAG baseline for fetching multi-aspect Wikipedia articles (contribution 4).
We also show how MRAG and its benchmarking principles can be seamlessly integrated with both existing RAG solutions and benchmarking frameworks such as RAGAS (contribution 5).
MRAG’s code is publicly available(^1^11[https://github.com/spcl/MRAG](https://github.com/spcl/MRAG)).

## 2 The MRAG Formulation & Pipeline

We now present in detail the mathematical underpinning of MRAG and its corresponding pipeline.

Decoder Formulation
We first introduce formally the decoder architecture.
We omit, for clarity, unnecessary details such as layer normalizations.
The input is a text chunk that consists of $n$ tokens.
The output of an attention head $h$ for the $i$th token $x_{i}$ is defined as [] $\text{head}^{h}(\mathbf{x}_{i})=\sum_{j}w_{ij}\mathbf{v}_{j}^{h}$, where
$w_{ij}=\text{softmax}\left(\left(\mathbf{q}_{i}^{h}\right)^{T}\mathbf{k}_{j}^{
h}\right)$, $\mathbf{q}_{i}^{h}=\mathbf{W}_{q}^{h}\mathbf{x}_{i}$, $\mathbf{k}_{j}^{h}=\mathbf{W}_{k}^{h}\mathbf{x}_{j}$, $\mathbf{v}_{j}^{h}=\mathbf{W}_{v}^{h}\mathbf{x}_{j}$.
Here, $\mathbf{W}_{q}^{h},\mathbf{W}_{k}^{h},\mathbf{W}_{v}^{h}$ are, respectively, learnable query, key, and value projections associated with head $h$, and $\mathbf{x}_{j}$ is the vector embedding of the $j$th token $x_{j}$. These outputs get combined to form the output of the $i$th multi-head attention block as
$\text{multi-head}(\mathbf{x}_{i})=\mathbf{W}_{o}\ \text{concat}(head^{1}(
\mathbf{x}_{i}),\dots,head^{h}(\mathbf{x}_{i}))^{T}$,
where matrix $\mathbf{W}_{o}$ is the linear layer that combines the outcomes of all the attention heads.
This step is then followed by the Transformer feed-forward layer.

Standard RAG Formulation
Assume a sequence of $n$ tokens as the input text chunk. The embedding for that chunk is obtained as the activation vector after the feed-forward decoder layer for the last $n$th token of this chunk, i.e., $\text{feed-forward}(\text{multi-head}(\mathbf{x}_{n}))$, generated in the last decoder block.

Multi-Head RAG Formulation
The key idea behind MRAG is simple: instead of the single activation vector generated by the last feed-forward decoder layer for the last token, we harness the $H$ separate activation vectors generated by the last attention layer for the last token, before processing it via $\mathbf{W_{o}}$.
This can be formulated as a set of embeddings $\mathcal{S}=\{\mathbf{e}_{k}\forall_{k}\}$ where $\mathbf{e}_{k}=\text{head}^{k}(\mathbf{x}_{n})$,
which is simply the set of all outputs from the attention heads on the last token $\mathbf{x}_{n}$ of the input. As processing with multiple heads does not change the size of the output vector, $\mathcal{S}$ has the same space requirements as standard RAG. However, because we capture the separate embeddings before their mixing with $\mathbf{W}_{o}$, we conjecture that it gives more information about what the different parts of the input attend to, facilitating capturing multi-aspectuality.

Naming
We use the terms “single-aspect embedding” and “multi-aspect embedding” to refer to, respectively, a small embedding extracted from a single attention head and a collection of all single-aspect embeddings extracted from an attention layer.

### 2.1 Overview of the Multi-Head RAG Pipeline

We now describe how the above embedding model fits the RAG pipeline. Figure 2 shows a summary of the design. The MRAG pipeline consists of two main parts, dedicated to data preparation  and query execution . Both parts heavily use the data store  (vector DB).

#### 2.1.1 Data Preparation

During data preparation , we populate a data store  with multi-aspect MRAG text embeddings  and their corresponding documents  or text chunks  (MRAG is orthogonal to the type of data being embedded, and while we primarily use chunking of documents in order to reflect modern RAG pipelines, one can also embed whole documents or even other types of data). We create the multi-aspect embedding  of each text chunk  using a selected decoder-based embedding model  (this part is detailed in Section 2.2). The user of the pipeline can plug in their model  of choice as well as use their input data. We also offer a dedicated synthetic data generator  that can be used to construct multi-aspect input documents  (we detail this part in Section 3) for evaluation purposes.

MRAG stores data differently than standard RAG, where a single embedding  points to a single text chunk . For MRAG, each multi-aspect embedding consists of $h$ single-aspect embeddings , each pointing to the original text chunk . So the data store  contains $h$ embedding spaces, each capturing a different aspect of the text. This crucial feature allows MRAG to compare query  and text chunks  in multiple embedding spaces that capture multiple aspects of the data.

#### 2.1.2 Query Execution

During query execution , we first generate a multi-aspect embedding  of the input query , using the selected embedding model  (details in Section 2.2). Then, we find the nearest multi-aspect embeddings  and their corresponding text chunks  in the data store  using a special multi-aspect retrieval strategy  (detailed in Section 2.3).
Finally, the retrieved data can optionally be assessed  with novel metrics regarding how well it corresponds to the multi-aspect requirements (detailed in Section 3).
As with the data preparation  stage, the query execution  stage is flexible, and the user can plug in their models  /  of choice and use their own queries . We also offer a dedicated synthetic query generator  that can be used to construct multi-aspect input queries  (detailed in Section 3) for evaluation purposes.

Figure: Figure 2: Overview of the MRAG pipeline, consisting of two parts: data preparation and query execution . The embedding model and the data store are used by both parts. The data store contains text embeddings linking to text chunks reflecting three different aspects (cyan, magenta, yellow). Blocks marked by a star are a novelty of this work.
Refer to caption: x36.png

### 2.2 Constructing Multi-Aspect Embeddings

MRAG can leverage any embedding model with multi-head attention support to construct the multi-aspect embeddings for a given input text. In this work, we consider two embedding models from the MTEB leaderboard [] as potential candidates. Specifically, the SFR-Embedding-Model [] and the e5-mistral-7b-instruct [], both based on the Mistral 7B architecture with 32 decoder blocks and 32 attention heads per multi-head attention.

While our approach allows for extracting and using the multi-aspect embeddings from any decoder block, and from different layers within a block, we found that multi-aspect embeddings extracted from the last multi-head attention worked best in our experimental setting. We provide further discussion on the carried out experiments in Section 4.

### 2.3 Retrieval Strategies for Multi-Aspect Data

A retrieval strategy determines how we select the closest text chunks from the DB given a multi-aspect embedding of the user query.
In general, the MRAG retrieval strategy consists of three steps.
First, during data preparation, we assign importance scores to all $h$ embedding spaces. Intuitively, these scores capture the fact that different spaces (and the corresponding heads) may be more or less relevant for the used data.
Then, during query execution, MRAG starts by applying the traditional RAG retrieval separately for each embedding space. This returns a list of $c$ closest text chunks for each embedding space (a total of $h$ lists).
Here, we use a special voting strategy to pick overall top $k$ out of all $hc$ chunks, using the pre-computed importance scores.

Figure: Algorithm 1 Importance scores for heads.

Algorithm 1 details the construction of importance scores. It is a heuristic based on extensive empirical evaluation; it gives high-quality results across the tested datasets and tasks. Intuitively, the score $s_{i}$ of a given head $h_{i}$ consists of two parts, $a_{i}$ and $b_{i}$. $a_{i}$ is the average of L2 norms of all embeddings in the vector space $i$; it represents how important a given head is: the larger the norms, the more attention was given to this attention head. $b_{i}$ is the average of cosine distances between all (or a randomly sampled subset, if the user wants to reduce pre-compute time) embeddings in vector space $i$. Intuitively, $b_{i}$ is a proxy for measuring the “spread” of vector space $i$: the larger $b_{i}$, the larger the average angle between different embeddings in this space is.
Deriving $s_{i}$ as a product $a_{i}\cdot b_{i}$ ensures that we reward heads with high average attention and high average spread, but simultaneously penalize heads with lower average attention or with low average spread (both $a_{i}$ and $b_{i}$ are appropriately scaled).

The used voting strategy combines the constructed lists of text chunks from individual embedding spaces into a single list of top $k$ chunks. The strategy is very simple (the corresponding Algorithm 2 is in the Appendix).
Each text chunk from a list $i$ of the vector space $i$ has a certain position on this list, we denote this position with $p$. We obtain a weight for this chunk as $s_{i}\cdot 2^{-p}$; $s_{i}$ is the previously defined importance score of the space $i$. Multiplying $s_{i}$ with $2^{-p}$ exponentially lowers the significance of less relevant text chunks. Finally, all chunks from all lists are sorted using their weights and the top $k$ chunks form the final list.

#### 2.3.1 Integration with Data Stores

MRAG can be seamlessly used with different classes of data stores  and nearest neighbor (NN) search approaches.
It can be combined with both the exact and the approximate NN to find the matching (embedding, chunk)-pairs.
These two parts of the broader RAG processing pipeline are orthogonal to MRAG.

## 3 Multi-Aspect Datasets, Queries, and Metrics

To assess how well MRAG performs on multi-aspect queries, and to compare it to modern RAG schemes, we need (1) datasets of documents that capture multi-aspectuality, (2) queries to the LLM that touch upon multi-aspectuality and require retrieving documents from the multi-aspect dataset, and (3) metrics that assess how well a RAG scheme retrieves such multi-aspect data.
We now describe these three elements.
In Section 4, we also briefly discuss real-world data and queries used.

Multi-Aspect Dataset Generation
We first select conceptually different categories of documents. We primarily focus on publicly available Wikipedia articles and select 25 categories (e.g., countries, board games, historical swords, shipwrecks, etc.). For each category, we sample 50 documents. The first part of the document (overview) is used as a text chunk to be embedded. We enforce that each overview must have at least 800 characters, matching commonly used chunk sizes in RAG schemes.

Multi-Aspect Query Generation
We also require queries that touch upon a given number of $n$ aspects. For example, a query with 10 aspects must contain a question about 10 different documents from 10 different categories. We create such queries by selecting $n$ categories, sampling a document from each selected category (ensuring there are no duplicates overall), and then generating a story that combines these documents, using an LLM (GPT-3.5 Turbo).
We construct 25 queries with 1, 5, 10, 15 and 20 aspects (125 queries in total).
An example multi-aspect query sent to the LLM that requires retrieving 10 documents from 10 different categories, is pictured in the top part of Figure 3.

Metrics
We also design novel metrics to assess how well a given RAG scheme supports multi-aspectuality.
For a query $Q$, a used retrieval strategy $S$ (detailed in Section 2.3), and $n$ documents from $n$ categories to retrieve, $Q_{rel}$ denotes the ideal set of documents that should be retrieved for $Q$. Then, $S(Q,n)$ is the set of the actually retrieved documents. We define the Retrieval Success Ratio as $\Xi(Q,n)=\frac{|S(Q,n)\cap Q_{rel}|}{|Q_{rel}|}$, i.e., the ratio of successfully retrieved relevant documents.
Moreover, there is a case when a RAG scheme does not retrieve the exact desired document, but it still retrieves successfully some other document from the same category. To consider such cases, we use another measure, the Category Retrieval Success Ratio or $\Xi_{c}$. It has the same form as $\Xi(Q,n)$ above, with one difference: $S(Q,n)$ is now the set of all the retrieved documents that belong to categories of the ideal desired documents.
Finally, to combine these two metrics, we use the Weighted Retrieval Success Ratio $\Xi_{w}$ as $\Xi_{w}=\frac{w\cdot\Xi+\Xi_{c}}{w+1}$.
By varying $w$, the user can adjust the importance of exact document matches and category matches.
An example of using these metrics to assess how well MRAG and Standard RAG capture multi-aspectuality is pictured in the bottom part of Figure 3.

## 4 Evaluation

We now illustrate the advantages of MRAG over the state of the art.

Comparison Baselines
We compare MRAG to two main baselines: Standard RAG and Split RAG. The first represents a modern RAG pipeline in which each document uses the activations of the last decoder layer as its embedding. The second is a blend between Standard RAG and MRAG. Specifically, it splits the activation of the last decoder layer in the same way as MRAG and applies a voting strategy. The purpose of Split RAG is to show that MRAG’s benefits come from using the multi-head output as embedding and not merely using multiple embedding spaces.
Additionally, we consider Fusion RAG [], an optional mechanism that we harness to further enhance the benefits of MRAG at the cost of additional tokens (detailed in Section 4.2).

We use queries and metrics introduced in Section 3. We use the weighted retrieval success ratio with 2:1 weighting, which considers category matches as relevant but prioritizes the exact document matches.
Figure 3 shows an example query and metrics usage. Each query requires retrieving a specific number of documents and the corresponding non-overlapping categories which define the ground truth. We fetch the top $k$ documents from a database, where $k$ is the “total number of documents fetched for a tested RAG scheme” (including potentially mismatches). Among these $k$ documents, we search for matches with the ground truth.

Figure: Figure 3: An example query used to evaluate different RAG strategies. We mention the documents to be fetched in the text and then assess the success ratio of different RAG strategies in finding these documents and their categories. We mark exact document matches , category matches , documents that match a category multiple times , and text segments with no matching document . Finally, we show the weighted success ratio for each strategy, taking a 2:1 weighting (prioritizing the exact article matches).
Refer to caption: x54.png

Samples & Summaries
Each data point in our plots corresponds to 25 queries. We present the data using standard boxplots to showcase the distribution. Our primary focus is on the average retrieval performance among those 25 queries.

### 4.1 Analysis of Results

We start from the query example in Figure 3 and show first the absolute retrieval performance of MRAG over Standard RAG in Figure 4. We fix the number of aspects present in the queries to 10, and vary the total number of retrieved documents from 10 to 30. MRAG consistently outperforms Standard RAG ($>10\%$ increase in the retrieval success ratio on average for exact document matches). Moreover, the retrieval performance increase is even more significant on category matches ($>25\%$ increase in the retrieval success ratio on average). The performance increase is further detailed in the histograms on the right side. Here, for a specific number of documents fetched, MRAG’s histogram indicates a better distribution of retrieval success ratios (across all 25 queries).

Next, Figure 5 shows the relative weighted performance improvement of MRAG with respect to Standard RAG as we vary the number of aspects present in the queries. We show data for two different embedding models (SFR and e5). MRAG consistently outperforms the Standard RAG by 10-20% on average, not only across the number of documents fetched, but also across the number of aspects present in the replies, for both models.

Figure: Figure 4: Retrieval success ratio over 25 queries between MRAG and Standard RAG, where each query includes 10 different aspects. The upper part presents exact document matches while the lower part presents category only matches (we explain the metrics used in Section 3). A histogram is presented for a specific sample to showcase the detailed distribution among the 25 queries (the number of documents fetched for each query is 30).
Refer to caption: x63.png

Figure: Figure 5: Relative retrieval improvement of MRAG over Standard RAG across queries with different numbers of aspects and different embedding models (SFR in the left side, e5 in the right side).
Refer to caption: x64.png

**Table 1: Retrieval success ratio (the exact document match) for 25 queries with a single aspect.**
| Documents Fetched | Multi-Aspect Dataset |  | Legal Dataset |  | Accidents Dataset |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| SFR |  | e5 |  | SFR |  | SFR |  |  |  |  |  |
| MRAG | Standard RAG | | | MRAG | Standard RAG | | | MRAG | Standard RAG | | | MRAG | Standard RAG |  |
| 1 | 24/25 | 25/25 |  | 24/25 | 25/25 |  | 24/25 | 24/25 |  | 25/25 | 25/25 |
| 2 | 25/25 | 25/25 |  | 25/25 | 25/25 |  | 25/25 | 25/25 |  | 25/25 | 25/25 |
| 3 | 25/25 | 25/25 |  | 25/25 | 25/25 |  | 25/25 | 25/25 |  | 25/25 | 25/25 |

We additionally show in Table 1 that MRAG performs on-par with Standard RAG on queries from our multi-aspect dataset where only a single aspect is expected. Hence, our approach does not suffer from significant decrease in performance for single-aspect tasks.

### 4.2 Further Improvements with Additional Tokens

We now show that MRAG can be seamlessly integrated with other RAG approaches: We combine MRAG with Fusion RAG, representing RAG schemes that use an LLM (additional token cost) for more accurate retrieval.
Fusion RAG uses an LLM to create a fixed number of questions about the RAG query. Each question is separately applied through an embedding model using Standard RAG.
We apply MRAG’s approach to each of these questions and denote the combined scheme as Fusion MRAG.
Red plots of Figure 6 show that both Fusion RAG and Fusion MRAG perform better than Standard RAG, on average gaining 10 to 30% in accuracy. Fusion MRAG performs consistently better than pure Fusion RAG, indicating that these optimizations can be combined together. However, both Fusion strategies introduce a greater variance than MRAG and additional costs in terms of compute, latency, and tokens.

### 4.3 Benefits from Multi-Head Attention Solely

We also compare MRAG to the Split RAG baseline in Figure 6.
The blue plots show the relative weighted performance of MRAG and Split RAG over Standard RAG. MRAG performs better than Split RAG, illustrating that its high accuracy is due to the actual multi-head part, and not merely just partitioning the vector and using multiple embedding spaces.

Figure: Figure 6: Relative retrieval improvements of MRAG over Standard RAG for the SFR embedding model compared with Split RAG (the blue plots), and the relative retrieval improvements of Fusion MRAG over both Fusion RAG and MRAG (the red plots).
Refer to caption: x65.png

### 4.4 Real-World Workloads

Figure: Figure 7: Average improvement of the retrieval success ratio of MRAG and Split RAG over Standard RAG for two real-world workloads constructing legal documents (left) and discovering causes of industry accidents (right).
Refer to caption: x66.png

To further illustrate advantages of MRAG, we also consider two real-word use cases from in-house industry data analytics projects, namely, the synthesis of legal documents and the analysis of causes of chemical plant accidents. The results are in Figure 7.
In the former (the left side), the task is to create a document based on user requirements that may be related to different aspects, for example to the law being considered (e.g., the British or the US one), the subject (e.g., energetic or civil), the style of the document (e.g., aggressive or mild), etc.. This task is executed with RAG that can fetch documents from a database.
In the latter (the right side), the task is to discover a cause of an accident. Here, one also wants to retrieve documents from a database that should be used in the LLM context to facilitate discovering the cause of the accident. The causes are grouped in categories such as utility impact due to severe weather, lack of preparedness and planning, incorrect installation of equipment, lack of maintenance, etc..
Similarly to the previous analyses, we measure the retrieval success ratio over corresponding databases. MRAG offers advantages over other schemes.

### 4.5 Additional Analyses

Figure: Figure 8: Evaluation of different voting strategies for MRAG and Split RAG
Refer to caption: x67.png

We also analyze the impact of using embeddings from different decoder blocks for MRAG (instead of the last one) and the impact of using different voting strategies for MRAG as well as for Split RAG.

We consider taking multi-aspect embeddings from three different layers of the embedding model: after the first multi-head attention block, after multi-head attention block 16 (in the middle of the decoder architecture), and the final multi-head attention. We discover that the last multi-head attention performs the best when compared with the Standard RAG.

We also illustrate selected representative data from a long investigation two additional voting strategies for MRAG. We compare MRAG (1) where only the exponential lowering of significance of selected chunks is applied ($w_{i,p}=2^{-p}$), and MRAG (2) which assigns the weight for each text chunk based on the distance between the particular text chunk ($d_{i,p}$) and the query ($q$) ($w_{i}=\frac{1}{distance(d_{i,p},q)})$. Figure 8 shows that these voting strategies perform worse on average than our selected strategy for MRAG, justifying its design and selection (described in Section 2.3).

We also consider two voting strategies for Split RAG, to further deepen the empirical evaluation. Split (1) only uses the exponential lowering of significance ($w_{i,p}=2^{-p}$) and Split (2) which uses the same strategy as MRAG ($w_{i,p}=s_{i}\cdot 2^{-p}$). Figure 8 (on the right) shows that these voting strategies are on-par with each other while being worse than MRAG, further showcasing the advantages of MRAG.

## 5 Related Work

Our work touches on many areas which we now briefly discuss.

Many RAG schemes appeared recently [], using the output of the last decoder layer for embedding generation. In contrast, MRAG leverages different embedding spaces of attention heads to focus on different aspects of documents and queries. As such, it can be combined with other schemes to further improve RAG pipelines.

Retrieval is sometimes enhanced by a cross-encoder reranking phase [, , , , , ]. In such solutions, typically after retrieving a set of relevant chunks, they are re-ranked using specialized models.
In this work, we focus solely on the first retrieval phase, so MRAG can be seamlessly used in conjunction with such cross-encoders.

Structure-enhanced RAG schemes employ different strategies for structuring text to improve retrieval quality. A common idea is to construct a Knowledge Graph from text, which enables retrieval amongst entities and relationships [, , , , ]. RAPTOR [] generates multi-level summaries for clusters of related chunks, building a tree of summaries with increasing levels of abstraction to better capture the meaning of the text.
Graph RAG [] creates a Knowledge Graph, and summarizes communities in the graph, which provide data at the different levels of abstraction.
All these systems try to improve RAG quality by utilizing additional structures that describe entity relationships or the inner organization of text. Usually, they need a sophisticated preprocessing phase to prepare such structures. MRAG achieves the improvement solely based on the embedding model and has no additional storage requirements, and
can be combined with any of these schemes.

## 6 Conclusion

Retrieval Augmented Generation (RAG) is pivotal for democratizing access to accurate and relevant outputs from large language models (LLMs). Enhancing the precision and relevance of these outputs is a critical goal, especially given the challenges posed by queries requiring the retrieval of multiple documents with significantly different contents. These complex queries are common across various domains, but existing RAG solutions struggle because the embeddings of the necessary documents can be far apart in the embedding space, complicating their retrieval.

To address this gap, we introduced Multi-Head RAG (MRAG), a novel scheme that leverages the activations from the multi-head attention layer of decoder models instead of the traditional feed-forward layer. This approach is grounded in the insight that different attention heads can capture distinct aspects of the data. By using these diverse activations, MRAG creates embeddings that better represent the multifaceted nature of data items and queries, thus enhancing the retrieval accuracy for complex, multi-aspect queries. The simplicity and versatility of this idea allow it to be seamlessly integrated into any modern RAG pipeline or data analytics framework.

Our comprehensive evaluation methodology, including specific metrics, synthetic datasets, and real-world use cases, demonstrates MRAG’s effectiveness. The results indicate a significant improvement in the relevance of retrieved documents, with up to 20% better performance compared to modern RAG baselines. This validates MRAG’s potential to handle the intricacies of multi-aspect queries effectively.

Moreover, MRAG proves to be both cost-effective and energy-efficient. It does not require additional LLM queries, multiple model instances, increased storage, or multiple inference passes over the embedding model. This efficiency, combined with the enhanced retrieval accuracy, positions MRAG as a valuable advancement in the field of LLMs and RAG systems. By addressing the challenges of multi-aspectuality in queries, MRAG paves the way for more reliable and accurate LLM applications across diverse industries.

## Acknowledgments and Disclosure of Funding

We thank Hussein Harake, Colin McMurtrie, Mark Klein, Angelo Mangili, and the whole CSCS team granting access to the Ault and Daint machines, and for their excellent technical support.
We thank Timo Schneider for help with infrastructure at SPCL.
This project received funding from the European Research Council (Project PSAP, No. 101002047), and the European High-Performance Computing Joint Undertaking (JU) under grant agreement No. 955513 (MAELSTROM). This project was supported by the ETH Future Computing Laboratory (EFCL), financed by a donation from Huawei Technologies. This project received funding from the European Union’s HE research and innovation programme under the grant agreement No. 101070141 (Project GLACIATION).
We gratefully acknowledge Polish high-performance computing infrastructure PLGrid (HPC Center: ACK Cyfronet AGH) for providing computer facilities and support within computational grant no. PLG/2024/017103.

## Appendix

## Appendix A Model Design: Additional Details

### A.1 Retrieval Strategies for Multi-Aspect Data

Figure: Algorithm 2 Voting strategy.

## Appendix B Evaluation Methodology: Additional Details

### B.1 Compute Resources

Our experiments were executed with compute nodes containing 4x NVIDIA GH200 and a total memory of 800 GB. In general one GPU with at least 40GB of memory should suffice. We used at most 50GB of storage and the OpenAI API as an external resource. The full experiments took at most three hours of GPU time and the cost for the OpenAI API were at most $15. We carried out additional experiments, which amounted to around 20 hours of GPU time and cost of $25 for the OpenAI API. Additional evaluation was executed with a mix of compute resources including NVIDIA A100 and V100 GPUs.

### B.2 Dataset Details

**Table 2: Prompt template for query generation.**
| Please create a story about the attached <number of articles> articles on the topics <list of titles>. |
| --- |
| It is very important that each of the attached articles is relevant to the story, in a way that references the content of the article, not just its title. But please also mention each title at least once. Please make sure that all of the attached articles are relevant to your story, and that each article is referenced in at least two sentences! They do not necessarily have to be referenced in the same order, but make sure no article is forgotten. |
| Important: Output only the story, no additional text. And do not use bullet points, or paragraphs. |
| Articles: |
| ——— |
| Article <title>: |
| <body> |
| <…> |
| ——— |
| Again, make sure that you reference all the following topics in your story: <list of titles> |

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: As mentioned in the Weaknesses, should multi-aspect embeddings be trained, or can they be directly extracted from existing models?
soundness: 3
strengths: - The research problem is practically significant.
- The idea is simple yet intuitive.
- The author constructed a test dataset specifically for this task and also tested it on real-world use cases.
summary: The authors address an interesting problem: how to handle queries that may require fetching multiple documents with substantially different contents. The authors propose using activations from different heads in the transformer layer as multi-aspect text representations, rather than the final hidden states. Additionally, the authors design a voting strategy to integrate the results from different aspect embeddings.
weaknesses: - The author’s description of the technical details is unclear. It appears that the activations from different heads in the last layer are directly used as multi-aspect embeddings, but these activations are not trained for retrieval tasks. It hard to believe that they can achieve better results than a trained embedding model.
- The author did not compare their method with other multi-vector representations, such as poly-encoder[1] or ColBERT[2], which can generate multiple embeddings for a text to represent different aspects.
- The evaluation dataset is very small, with only 25 queries per setting, which can lead to significant fluctuations. Minor adjustments could lead to substantial changes in results, making them less convincing.

[1] Poly-encoders: Transformer Architectures and Pre-training Strategies for Fast and Accurate Multi-sentence Scoring
[2] ColBERT: Efficient and Effective Passage Search via Contextualized Late Interaction over BERT

---

confidence: 3
contribution: 2
initial_rating: 3
presentation: 2
questions: 1. Does the retriever in this method need training? If not, how can the different heads in retriever attend to different aspects in your dataset created?
2. The data in Table 1 is confusing. Why almost all datasets and baselines show 100% success retrieval rate. That is contrary to Figure 3.
soundness: 2
strengths: 1. This paper establishes an evaluation methodology as well as a full data construction and query processing pipeline that implements the multi-aspect embedding idea.
2.  Evaluation illustrates the benefits in the relevance of retrieved documents, for example 20% over a modern RAG baseline for fetching multi-aspect Wikipedia articles, and comparable performance for single aspect queries.
summary: Existing RAG solutions struggle because the embeddings of the necessary documents can be far apart in the embedding space, complicating their retrieval. To address this gap, MRAG leverages the activation from the multi-head attention layer of decoder models instead of the traditional feed-forward layer. This approach is grounded in the insight that different attention heads can capture distinct aspects of the data.
weaknesses: 1. The motivation of directly using different heads in retriever to retrieve different aspects of the query is not reasonable. The multi-head embedding space is not corresponding to the different aspects in query.
2. The evaluation are conducted on the created dataset and the generalization of dataset is not proved.
3. The compared baselines are limited, other RAG methods should be compared.

---

confidence: 5
contribution: 1
initial_rating: 3
presentation: 1
questions: Please refer to the weaknesses.
soundness: 2
strengths: 1. The proposed method aims to leverage activations of the Transformer’s multi-head attention layer, instead of the decoder layer, as keys for fetching multi-aspect documents, which is an interesting topic.
2. The authors' harnessing the corresponding activations results in embeddings that represent various facets of data items and queries by multi-head, which seems reasonable.
summary: This paper addresses the limitation of existing Retrieval Augmented Generation (RAG) solutions in handling queries that require multiple documents with diverse content. It proposes a novel approach called Multi-Head RAG (MRAG), which leverages activations from the multi-head attention layer of Transformers to improve the retrieval of multi-aspect documents. The results indicate that MRAG enhances retrieval accuracy by up to 20% compared to standard RAG baselines while remaining compatible with existing RAG frameworks and datasets.
weaknesses: 1. The paper is not organized clearly, which is not friendly for understanding. For example, there is a lack of details on more detailed comparisons between standard RAG and MRAG. 
2. The novelty of the method in the paper seems limited since the multihead idea has been widely studied by previous work [1][2]. 
[1] Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks
[2] End-to-End Training of Multi-Document Reader and Retriever for Open-Domain Question Answering

3. The paper lacks the analysis of time complexity as well as space complexity, which is necessary to study the efficiency of the model. 
4. The experiments are simple and do not compare with recent methods, such as [1][2], and the experiments utilize GPT-3.5 Turbo, which has been updated and cannot be obtained.
[1] RAGraph: A General Retrieval-Augmented Graph Learning Framework
[2] RQ-RAG: Learning to Refine Queries for Retrieval Augmented Generation

---

confidence: 2
contribution: 2
initial_rating: 3
presentation: 3
questions: How does your approach differ from existing methods that utilize multi-head embeddings other than it is for RAG?  

One suggestion is to expand the number of queries in your experiments to provide a more comprehensive evaluation.
soundness: 2
strengths: The paper identifies a critical problem in RAG and proposes a reasonable solution. It makes a significant contribution by generating a new dataset, query set, and a set of evaluation metrics tailored to assess RAG performance on complex queries with multiple aspects. The paper is well-structured, providing a clear and logical flow of information, although there is still some room for improvement.
summary: The paper addresses the challenge of retrieving multiple documents with different intents for a complex query in RAG systems. The paper introduces MRAG, which leverages the activations of the multi-head attention layer in Transformer models instead of the decoder layer. MRAG shows up to 20% improvement in relevance over standard RAG baselines for multi-aspect queries.
weaknesses: The method proposed in the paper lacks innovation, as the use of multi-head embeddings has been previously explored. The approach of combining results from different embeddings is relatively straightforward and could benefit from the implementation of a more sophisticated heuristic reranker. Additionally, the experiments conducted are insufficient; the use of only 125 queries is inadequate to comprehensively evaluate the performance of the solution for such a complex problem. Furthermore, the advantages over fusion RAG are not clearly articulated.

---

confidence: 2
contribution: 3
initial_rating: 8
presentation: 3
questions: None
soundness: 3
strengths: 1. The experiments in this paper are thorough and well-executed, covering both synthetic and real-world use cases.  This high level of experimental completeness adds credibility and reliability to the proposed method's performance claims.
2. MRAG introduces a novel approach by leveraging embeddings from each attention head in the multi-head attention layer, a significant departure from standard RAG methods that rely on a single embedding. This innovation enables MRAG to capture diverse dimensions of data within a single query, allowing it to retrieve documents that cover a broader range of relevant topics.
summary: The authors introduce MRAG, which  is an improved RAG method that enhances LLMs for handling complex, multi-aspect queries. Instead of using a single embedding from the last layer of the decoder, MRAG leverages embeddings from each attention head in the multi-head attention layer.
weaknesses: While the MRAG method improves retrieval accuracy without increasing storage requirements, its multi-head attention multi-aspect embeddings introduce additional computational complexity. In particular, when involving multiple heads, this could result in increased computational costs and potential latency.

Meta-review: The authors tackle an intriguing challenge: handling queries that necessitate retrieving multiple documents with significantly diverse content. They propose leveraging activations from various transformer heads as multi-aspect text representations, rather than relying solely on the final hidden states. To combine results from these aspect-specific embeddings, they introduce a voting strategy for integration.

There reviewers have raised several key concerns regarding both the clarity of the presentation and the completeness of the evaluation. Given there is no rebuttal from the authors, I believe this paper is not ready to be published at its current form.

Decision: Reject