Can LLMs Evaluate Complex Attribution in QA? Automatic Benchmarking Using Knowledge Graphs

## Abstract

Abstract The attribution of question answering is to provide citations for supporting generated statements, and has attracted wide research attention.
The current methods for automatically evaluating the attribution, which are often based on Large Language Models (LLMs), are still inadequate, particularly in recognizing subtle differences between attributions, and complex relationships between citations and statements.
To compare these attribution evaluation methods and develop new ones, we introduce a set of fine-grained categories (i.e., supportive, insufficient, contradictory and irrelevant) for measuring the attribution, and develop a Complex Attributed Question Answering (CAQA) benchmark by leveraging knowledge graphs (KGs) for automatically generating attributions of different categories to question-answer pairs.
Our analysis reveals that existing evaluators perform poorly under fine-grained attribution settings and exhibit weaknesses in complex citation-statement reasoning. Our CAQA benchmark, validated with human annotations, emerges as a promising tool for selecting and developing LLM attribution evaluators.

## 1 Introduction

Figure: Figure 1: Attributed QA is to generate answers with citations for a question. In this study, we have four fine-grained attribution categories: supportive, insufficient, contradictory, and irrelevant.
Refer to caption: x1.png

Generative large language models (LLMs) Brown et al. (); OpenAI (); Touvron et al. () are increasingly adept together with search engines to produce textual statements as answers to natural language questions. However, their tendency to generate confident yet inaccurate or “hallucinated” content Ji et al. () can be particularly problematic in high-stakes domains such as medicine Lee et al. () and law Volokh (). In response to this challenge, question answering with attribution has be proposed, where not only answers but also citations (or evidence snippets) for supporting the answers are output Menick et al. (); Rashkin et al. (); Bohnet et al. (); Li et al. (). Such models are essential for enhancing user trust and reliability in real systems.

Despite their potential, current state-of-the-art implementations of attributed question answering, exemplified in generative LLMs and search engines like Bing Chat, perplexity.ai and YouChat(^1^11bing.com/new, perplexity.ai, https://you.com/), still has much space for further improvement.
Liu et al. () manually examine these systems and observe that less than 52% of generated sentences are fully supported by their citations.
This gap highlights the urgent need for more effective approaches to ensure the attribution, and in fact, this is being studied more and more widely Li et al. ().

One critical research question is how to evaluate the attributions.
Currently, there is a lack of robust evaluation methods capable of continually assessing the performance of attribution models.
The predominant evaluation method still relies on manual labour Liu et al. (); Bohnet et al. (); Gao et al. (); Kamalloo et al. (), which is reliable but costly and unsustainable.
Automatic evaluation methods like AutoAIS Gao et al. (, ); Bohnet et al. () and AttrScore Yue et al. () have been proposed, but they fall short in detecting subtle differences in attributions. AutoAIS can only distinguish whether citations support or not support the generated answer, while AttrScore further divides the situation of not support into extrapolatory and contradictory.
We argue that these categories do not fully cover the situations of attribution and may fail to accurately and comprehensively measure the attribution performance Gao et al. (); Liu et al. (). To bridge this gap, we introduce a more fine-grained attribution categorization with categories of supportive, insufficient, contradictory, and irrelevant (see Fig. 1), which can enable more precise identification of different errors of attributions.

Furthermore, we construct a Complex Attributed Question Answering (CAQA) benchmark utilising knowledge graphs (KGs), which are composed of relational facts in form of triples such as (London, capitalOf, The UK) for representing graph structured data Hogan et al. (), to compare the evaluation methods and develop better ones. Different from the existing benchmarks (see Table 1), CAQA has a larger scale, more fine-grained attribution categories, and different levels of reasoning complexity in attributing the answers.
Specifically, we develop an automatic method to generate the benchmark given a KG and a KG question answering dataset which includes question-answer pairs and corresponding KG queries that return the answers. The method utilises the query to get KG sub-graphs as the seeds for constructing the citations to support the answer.
These sub-graphs are extended by different rules with more logical operators for higher reasoning complexity, edited by different strategies for more attribution categories, and transformed into natural language citations by prompting ChatGPT.
This approach is configurable for generating attributed QA benchmarks with different features, and adaptable to different KGs and KGQA datasets.

**Table 1: Comparison of CAQA to other benchmarks. The upper five benchmarks are manually constructed, while the lower two benchmarks are automatically constructed. For ALCE, we consider its manually annotated attribution labels. The reasoning types are to indicate the level of attribution complexity (see Table 2 for their definitions).**
| Benchmarks | Scale | Reasoning Type | Attribution Categories |
| --- | --- | --- | --- |
| Bohnet et al. Bohnet et al. () | 23,000 | I | S/N |
| Liu et al. Liu et al. () | 11,037 | I | S/P/N |
| ALCE^* Gao et al. () | 800 | I, II | S/P/N |
| HAGRID Kamalloo et al. () | 2,638 | I, II | S/N |
| ExpertQA Malaviya et al. () | 2,177 | I, II | S/N |
| AttrEval Yue et al. () | 67.8K | I, III, IV | S/C/E |
| CAQA (Ours) | 161.1K | I, II, III, IV | S/In/C/Ir |

To summarize, our main contributions are as follows.

- •
We define more fine-grained attribution categories including supportive, insufficient, contradictory and irrelevant considering different errors in attribution, and four types of attribution to measure the reasoning complexity of attribution according to different forms of citations.
- •
We develop an automatic manner for generating benchmarks of attributed QA using KGs, and accordingly produce one such benchmark with a larger scale, more fine-grained attribution categories and more complex attribution cases.
- •
We compare and analyze various automatic QA attribution evaluators together with manual evaluation using the generated benchmark, and find that some LLMs such as Vicuna (13B) can act as good evaluators when they are fine-tuned.

## 2 Related Work

### 2.1 Attributed Question Answering with LLMs

Generative LLMs now lead the performance in QA, but often produce hallucinations Ji et al. (); Xiao and Wang (); Wang and Sennrich (); Shuster et al. (). To alleviate this issue, some explorations Menick et al. (); Nakano et al. (); Gao et al. () train LLMs to answer questions while providing citations.
Some other studies propose to augment LLMs with external tools Mialon et al. (); Shen et al. (); Schick et al. () such as retrievers Han et al. (); Shi et al. (); Asai et al. (); Izacard et al. () and search engines Nakano et al. (); Komeili et al. (), where external references are incorporated for generating references and citations for supporting the answer statements.
However, the validity of such attributions remains questionable, and their automatic evaluation is still an open research question.

### 2.2 Evaluating Question Answering Attributions

To detect attribution errors, current evaluation methods predominantly depend on human annotation, which is costly and very inefficient Nakano et al. (); Bohnet et al. (); Liu et al. (); Rashkin et al. (); Muller et al. (). For example, annotating a single (question, answer, citation) example can cost around $1 Liu et al. ().
This often burdens users with the responsibility of manual verification in practical applications.

Recent studies Gao et al. (, ); Bohnet et al. (); Li et al. () have utilized large language models (LLMs) specifically designed for natural language inference (NLI) tasks to automatically assess attributions.
These models determine whether a given citation adequately supports an answer statement, modeling as a binary classification task.
While Yue et al. Yue et al. () categorized attributions as 1) attributable, 2) extrapolatory, or 3) contradictory, our method identifies four detailed attribution labels, addressing limitations in their framework such as partial support or irrelevant citations. We also introduce a novel aspect: controlling for attribution complexity, making this the first study to examine how reasoning complexity influences attribution accuracy.

## 3 Definitions in Question Answering Attribution

### 3.1 Task Formulation

This paper studies the evaluation of question answering evaluation, which is to verify whether one or multiple citations that state facts can sufficiently support a generated answer statement to a user’s natural language question.
Formally, given a question $q$, an answer statement $a$ and a citation $c$, the objective of the attributable evaluation method is to map them to an attribution category $t$ (a.k.a. class label).
Note that $q$, $a$ and $c$ are all in natural language.
This mapping can be represented by the function $\mathcal{F}:\mathcal{Q}\times\mathcal{A}\times\mathcal{C}\mapsto\mathcal{T}$, where $\mathcal{Q}$, $\mathcal{A}$ and $\mathcal{C}$ denote all the questions, answers and citations, respectively,
and $\mathcal{T}$ denotes a set of candidate categories, such as $\{$supportive, insufficient, contradictory, irrelevant$\}$ which indicates whether “the citation $c$ is supportive, insufficient, contradictory or irrelevant to the answer $a$ of the query $q$.”

### 3.2 Fine-grained Attribution Categorization

In this paper, we analyse the performance of practical attributed LLMs on attributed QA benchmarks Gao et al. (); Liu et al. (), and then propose advancing this task by introducing a more fine-grained categorization. Specifically, we classify attributions into four distinct categories:

- •
Supportive (Sup.): The cited citation fully supports the answer statement.
- •
Insufficient (Ins.): The cited citation lacks all the evidence needed to reason out the answer statement.
- •
Contradictory (Con.): The cited citation supports the reasoning process of the answer statement but comes to a different conclusion than the answer statement.
- •
Irrelevant (Irr.): The cited citation is not relevant to the answer statement and it is not helpful in answering the question.

Fig. 1 provides examples of the four attribution categories.
The key facts in the generated answer to the question “Who wrote the song Don’t Give Up on Me?” are “Dan Penn and Carson Whitsett with Hoy Lindsey” and “Andy Grammer”. The figure lists all potential citations that may be used in different scenarios during the generation process. In the supportive scenario, the answer is supported by citations [1] and [2]: citation [1] provides information that the song was written by “Dan Penn, Carson Whitsett, and Hoy Lindsey,” while citation [2] identifies “Andy Grammer” as the songwriter for the song. The insufficient scenario occurs when only citation [1] is cited, omitting the essential information needed to fully support the final answer. In the contradictory scenario, citation [3] is used, which states that “Gerry Rafferty & Hugh Murphy” wrote the song, contradicting the information in the generated answer. The irrelevant scenario involves citing source [4], which discusses the album of the same name but provides no information about the songwriters, contributing nothing to the answer. Note that while attributed LLMs may sometimes give an incorrect answer, this study assumes the answer is correct and focuses primarily on the attribution.

### 3.3 Attribution Complexity

**Table 2: Examples of the four complexity types. Reasoning Graphs show the reasoning relationships between citations-answers. Green represents content associated with the answer, gray indicates excluded content, and orange indicates the common term connecting the citations.**
| Complexity | Examples | Reasoning Graphs |
| --- | --- | --- |
| Single (I) | Question: NPR all things considered appears in what radio program episode?<br>Answer: The radio program episode in which NPR All Things Considered appears is Remorse: The 14 Stories of Eric Morse [1].<br>Citations: [1] Remorse: The 14 Stories of Eric Morse is an episode of the radio program All Things Considered…. |  |
| Union (II) | Question: What is the profession of richard scott?<br>Answer: Richard Scott is a name shared by individuals in various professions, including those who are artist and doctor [1][2].<br>Citations: [1] Richard Scott was a Scottish medical doctor who was the … [2] Richard Scott is a South African artist, … |  |
| Intersection (III) | Question: The computer designer for Macintosh 128k and NeXT computer was whom?<br>Answer: The computer designer for Macintosh 128k and NeXT computer was Steve Jobs [1][2].<br>Citations: [1] The computer designer for Macintosh 128k was Jerry Manock, an industrial designer who worked with Steve Jobs to develop the vertical body … [2] …Several former Apple employees followed Jobs to NeXT, including Joanna Hoffman, Bud Tribble, George Crow, Rich Page… |  |
| Concatenation (IV) | Question: What are the official languages in the politician Mohammad Najibullah’s country?<br>Answer: Pashto and Dari are the official languages in the politician Mohammad Najibullah’s country. [1][2].<br>Citations: [1] Mohammad Najibullah was the president of Afghanistan from 1986 to 1992 … [2] Afghanistan s a multilingual country, where Pashto and Dari (a dialect of Persian) are the official languages with … |  |

Prior work has not fully explored varying levels of the difficulty encountered in inferring the answer with the given citations. We attempt to measure the reasoning complexity of attribution by dividing the attribution complexity into four types according to the form of supporting facts in the citations (See Table 2 for examples):

- •
Single (S., Type I): The answer statement is supported by a fact from a single citation.
- •
Union (U., Type II): The answer statement is supported by independent facts from multiple citations.
- •
Intersection (I., Type III): The answer statement is supported by facts of some common entities from multiple citations.
- •
Concatenation (C., Type IV): The answer statement is supported by chains of facts consisting of multiple citations.

In our study, the two basic types (Intersection and Concatenation) may be combined into more complex types, due to our extended operations on examples of these two basic types, as introduced in Section 4.2.

## 4 Benchmark Construction Methodology using Knowledge Graph

In this section, we present our automated approach that leverages KGs to construct attributed question answering benchmarks. Section 4.1 details the data preparation steps essential for our methodology. Subsequently, Section 4.2 delves into the core processes employed in constructing these benchmarks.

### 4.1 KGQA and Logical Queries

We construct the attributed QA benchmark built on top of an existing knowledge graph question answering (KGQA) dataset and its associated KG. This is primarily motivated by two observations: Firstly, KGQA is a popular task with substantial open resources, as evidenced by 25 KGQA datasets for 5 different KGs reported in Jiang and Usbeck ()). Secondly, existing KGQA datasets contain high-quality question-answer pairs and corresponding KG logical queries (which are often in SPARQL) for inferring the answers, although they lack attribution statements in natural language.
By utilising the existing datasets, we streamline the base question-answer pair collection process, allowing us to focus on the attributions.

Each KGQA dataset is composed of samples in the form of $S=(q_{0},a_{0},l)$, with $q_{0}$ denoting a natural language question, $a_{0}$ denotes the answer entity, and $l$ denotes a KG logical query. Our data collection focuses on samples where the KG logical query falls into one of three types: single-triple, path-like, or tree-like queries.
As shown in the first three columns in Table 3, a single triple query denoted as $(e_{0},r_{0},?a)$ indicates that the answer entity $?a$ can be queried through the subject entity $e_{0}$ and the KG relation $r_{0}$.
A path-like query denoted as $[e_{0},r_{0},?v_{1},\ldots,?v_{n-1},r_{n-1},?a]$ represents that the answer entity $?a$ can be queried through the subject entity $e_{1}$ starting through $n$-hopping relations and $n-1$ intermediate variable entities $?v$. In particular, the path-like query is equivalent to the single-triad query when $n=1$.
A tree-like query formulated as $\wedge_{i=0}^{n-1}(e_{i},r_{i},?a)$, involves $n$ distinct triples with different subject entities converging to the same answer entity.

### 4.2 Benchmark Construction

Given a KGQA dataset and its corresponding KG, the construction of a QA attribution benchmark includes three main steps: 1) Extension of KG Queries, where we add logical operators to enhance the complexity of the original queries in the KGQA dataset; 2) Generation of Structured Attributions, which is to extract varied KG subgraphs for different attribution categories; 3) Generation of Textual Attributions, where the KG sub-graphs are transformed into textual citations, questions are expanded and answers are rephrased.

#### 4.2.1 Extension of KG Queries

**Table 3: The rules for each type of original query ${l}$ to the extended query $l^{\prime}$, utilizing two query operations: intersection ($\wedge$) and union ($\vee$). All queries are classified according to their structure as single-triple (S.) queries, path-like (P.) queries, tree-like (T.) queries and union-tree-like (U.) queries. The ‘Examples’ column presents corresponding graph representations for the case where $n=2$, $m=2$, and $k=0$. In these graphs, grey nodes represent variables for answer entities, white nodes represent entities or variables for intermediate entities.**
| Original Query ${l}$ | Extended Query ${l}^{\prime}$ |  |  |  |  |
| --- | --- | --- | --- | --- | --- |
| Definitions | Structures | Examples | Definitions | Structures | Examples |
| ($e_{0},r_{0},?a$) | S. |  | ($e_{0},r_{0},?a)$ | U. |  |
| $\vee(e_{1},r_{0},?a)\vee\ldots\vee(e_{m},r_{0},?a)$ |  |  |  |  |  |
| $[e_{0},r_{0},?v_{1},\ldots,?v_{n-1},r_{n-1},?a]$ | P. |  | $[e_{0},r_{0},?v_{1},\ldots,?v_{n-1},r_{n-1},?a]$ | P. |  |
| $\land(e_{n},r_{n},e_{1})$ |  |  |  |  |  |
| $[e_{0},r_{0},?v_{1},\ldots,?v_{n-1},r_{n-1},?a]$ | T. |  |  |  |  |
| $\land(e_{n},r_{n},?a)$ |  |  |  |  |  |
| $\wedge_{i=0}^{n-1}(e_{i},r_{i},?a)$ | T. |  | $\wedge_{i=0}^{n-1}(e_{i},r_{i},?a),\ i\neq k$ | T. |  |
| $\land(e_{n},r_{n},e_{k})\land(e_{k},r_{k},?a)$ |  |  |  |  |  |
| $\wedge_{i=0}^{n-1}(e_{i},r_{i},?a)\land(e_{n},r_{n},?a)$ | T. |  |  |  |  |

For each KGQA example $S=(q_{0},a_{0},l)$, we extend the original logical query $l$ to ${l}^{{}^{\prime}}$ using specific query extension rules.
These rules are designed based on the logical operations intersection (a.k.a conjunction, $\wedge$) and union (a.k.a disjunction, $\vee$) Ren et al. ().

Table 3 describes the extension rules for the extension process.
For a single-triple query $l$, we apply union to extend it.
Initially, we retrieve entities in the KG sharing the same name as $e_{0}$ in $l$, resulting in a set $\{e_{1},\ldots,e_{m}\}$, where $m$ represents the total number of entities retrieved, which can be zero.
Subsequently, we generate logical queries $(e_{1},r_{0},?a)$, $\ldots$, $(e_{m},r_{0},?a)$ by combining the retrieved entities and the relation $r_{0}$ from $l$. These queries are then merged with $l$ via union to construct a union-tree-like query structure, implying that the final answer is a union of the set of answers obtained from each subquery.
For a path-like query or a tree-like query, we apply the intersection operation in two ways.
The first way involves identifying the unique subject entity $e_{1}$ in the path-like query or selecting a random subject entity $e_{k}$ in the tree-like query. We then retrieve a corresponding triple $(e_{1},r_{n+1},e_{n+1})$ or $(e_{k},r_{n+1},e_{n+1})$ in the KG, where $r_{n+1}$ is a relation not included in $l$. This newly identified triple is then appended to $l$ ($e_{1}$ or $e_{k}$ are connected nodes).
After this extension process, the structure of a path-like query and a tree-like query remains the same. In the second way, we add to $l$ a new query $(e_{n+1},r_{n+1},?a)$. The intersection of the answer entity obtained by the new query with that obtained by $l$ is ensured to be non-empty. Through this extension, both the path-like query and tree-like query are converted into the tree-like query.

For both a path-like query (where $n\geq 2$) and a tree-like query, two intersection extensions are equally probable. In contrast, the single-triple query, as a particular case of path-like queries, undergoes four actions with equal likelihood: union extension, two intersection extensions, and no extension (to preserve some single-triple queries).
The resulting queries are of four types: single-tree query, union-tree-like query, tree-like query and path-like query, which correspond to the single, union, intersection and concatenation types of the attribution complexity, respectively.

#### 4.2.2 Generation of Structured Attributions

We first obtain a KG subgraph $\mathcal{G}$ by grounding each extended query ${l}^{{}^{\prime}}$ in the KG, which returns the entities that are assigned to all the variables in the query for inferring the answer. Such a subgraph $\mathcal{G}$ is regarded as the structured attribution to support the answer to the question, and it belongs to the attribution category of supportive.
To get structured attributions of the other three categories, i.e., insufficient, contradictory, and irrelevant, we have the following strategies to edit the subgraph $\mathcal{G}$.

##### Insufficient

We obtain the insufficient subgraph $\mathcal{G}_{In}$, which cannot fully support the acquisition of the answer, using a subgraph deletion strategy. If $l^{\prime}$ is a path-like query, we randomly delete one triple in the subgraph $\mathcal{G}$. If $l^{\prime}$ is a tree-like query or a union-tree query, we randomly delete a path from one of the subject entity to the answer.
If $l^{\prime}$ is the single-triple query, the delete operation is not performed.

##### Contradictory

We obtain the contradictory subgraph $\mathcal{G}_{C}$, whose reasoning results contradict the answer, by replacing the answer entity in $\mathcal{G}$ with a non-answer entity that has the same type as the answer entity. For ${l}^{\prime}$ involving the intersection operation, we replace the answer entity in $\mathcal{G}$. For ${l}^{\prime}$involving the union operation, we replace one of the answer entities in $\mathcal{G}$.

##### Irrelevant

We obtain the irrelevant subgraph $\mathcal{G}_{Ir}$, which is not associated with the answer, by selecting another subgraph in KG. For each subgraph $\mathcal{G}$, we retrieve the KG to obtain a subgraph $\mathcal{G}_{I}r$ that has the same structure as $\mathcal{G}$ but involves completely different entities and relations (except for the subject entity in $\mathcal{G}$).

#### 4.2.3 Generation of Natural Language Questions, Answers and Attributions

We employ GPT-3.5-turbo with prompts to transform the subgraphs of $\mathcal{G}$, $\mathcal{G}_{In}$, $\mathcal{G}_{C}$ and $\mathcal{G}_{Ir}$ into natural language citations of categories of supportive, insufficient, contradictory and irrelevant, respectively.
Additionally, if the original logical query $l$ performs an extension operation, the original question $q_{0}$ in $S$ will be extended to a new question $q$ accordingly using GPT-3.5-turbo. Also, the answer entity $a_{0}$ will be paraphrased as the long answer statement $a$.
Eventually, we generate an attribution QA sample that encompasses four components: the question $q$, the answer statement ${a}$, the textual citation ${c}$ and the corresponding attribution category $t$. More details about the generation process for each sample are provided in Appendix A.

**Table 4: CAQA statistics across different attribution categories and different attribution complexity levels.**
| Classes | Train | Test | Total |  |
| --- | --- | --- | --- | --- |
| 137,211 | 23,963 | 161,174 |  |  |
| Categories | Sup. | 39,489 | 6,668 | 46,157 |
| Ins. | 28,868 | 5,065 | 33,933 |  |
| Con. | 36,620 | 6,423 | 43,043 |  |
| Irr. | 32,234 | 5,807 | 38,041 |  |
| Complexity Levels | S. | 53,795 | 9,043 | 62,838 |
| C. | 46,783 | 8,455 | 55,238 |  |
| U. | 5,347 | 886 | 6,233 |  |
| I. | 31,286 | 5,579 | 36,865 |  |

**Table 5: The performance of the different attribution evaluators on our CAQA benchmark. Evaluators of the first (resp. second) part follow the zero-shot (resp. fine-tuning) setting.**
| Evaluators (Size) | CAQA |  |  |  |  |
| --- | --- | --- | --- | --- | --- |
| Sup. | Ins. | Con. | Irr. | Overall |  |
| LLaMA-2 (7B) | 0.423 | 0.121 | 0.057 | 0.170 | 0.279 |
| LLaMA-2-chat (7B) | 0.462 | 0.158 | 0.058 | 0.053 | 0.183 |
| Mistral (7B) | 0.456 | 0.178 | 0.191 | 0.153 | 0.305 |
| Mistral-Instruct (7B) | 0.591 | 0.189 | 0.159 | 0.016 | 0.324 |
| Vicuna (7B) | 0.437 | 0.007 | 0.001 | 0.000 | 0.111 |
| LLaMA-2 (13B) | 0.418 | 0.164 | 0.161 | 0.125 | 0.279 |
| LLaMA-2-chat (13B) | 0.469 | 0.171 | 0.173 | 0.103 | 0.224 |
| Vicuna (13B) | 0.485 | 0.049 | 0.000 | 0.000 | 0.143 |
| GPT-3.5-turbo | 0.592 | 0.150 | 0.616 | 0.497 | 0.506 |
| GPT-4 | 0.829 | 0.430 | 0.776 | 0.628 | 0.687 |
| AutoIS (11B) | 0.609 | - | - | - | 0.152 |
| AttrScore (13B) | 0.667 | - | 0.611 | - | 0.320 |
| LLaMA-2 (7B) | 0.922 | 0.897 | 0.944 | 0.933 | 0.926 |
| LLaMA-2-chat (7B) | 0.925 | 0.903 | 0.943 | 0.927 | 0.930 |
| Mistral (7B) | 0.927 | 0.908 | 0.944 | 0.849 | 0.882 |
| Vicuna (7B) | 0.937 | 0.907 | 0.940 | 0.906 | 0.932 |
| LLaMA-2 (13B) | 0.929 | 0.907 | 0.938 | 0.923 | 0.925 |
| Vicuna (13B) | 0.942 | 0.923 | 0.939 | 0.923 | 0.933 |

## 5 Experimental Setup

### 5.1 Benchmarks

##### Complex Attributed Question Answering (CAQA)

The CAQA benchmark is constructed using an automated methodology detailed in Section 4, using two KGQA datasets GrailQA Gu et al. () and WebQuestionsSP Yih et al. () with the KG of Freebase Bollacker et al. (). The CAQA benchmark comprises a total of 161,174 samples, and is partitioned into a training set with 137,211 samples, which is used when the evaluator needs fine-tuning or training, and a test set with 23,963 samples. Table 4 presents the distribution of these samples across different attribution categories and attribution complexity levels.
Note that we also asked human beings to annotate the attribution categories of 600 testing samples for analyzing their consistency with the automatically generated categories across the evaluators (see results in Section 6.3).
The details of the CAQA benchmark construction are described in Appendix B.

##### ACLE-Manual

We enhanced the ALCE dataset Gao et al. () by adding manual annotations and creating an additional test set. Such enhancement enables us to compare the performance of attribution evaluators trained by our CAQA benchmark against existing specially developed QA attribution evaluators.
Significantly, the ALCE dataset includes 800 manually annotated samples and primarily features three distinct attribution labels.
In line with our study goals, we annotated an extra 50 samples using the four attribution labels we have proposed. This approach is designed to improve our ability to conduct in-depth attribution analysis and accurately identify errors.

### 5.2 Attribution Evaluators

We test a few automatic attribution evaluation methods under both the zero-shot setting where the model is not trained with any of the QA attribution samples, and the fine-tuning setting where the model is trained with some QA attribution samples.
Three kinds of LLMs including LLaMA-2 Touvron et al. (), Vicuna Chiang et al. (), and Mistral Jiang et al. () are used for both settings, with different scales.
For the zero-shot setting, we also include ChatGPT (gpt-3.5-turbo-0613), GPT-4 (gpt-4-0613), and two specially developed QA attribution evaluators AutoIS Honovich et al. () and AttrScore Yue et al. ().
More implementation details of the experiments are given in Appendix C.

### 5.3 Metircs

For all experiment results in this work, we report the F1 score for the performance on each attribution category (or each complexity level) calculated according its precision and recall, and the micro-F1 score for the overall performance. The micro-F1 score is used because the distribution of attribution categories (or complexity levels) is unbalanced.

## 6 Experimental Results

**Table 6: Performance of all evaluators on various level of attribution complexity. Evaluators of the first (resp. second) part follow the zero-shot (resp. fine-tuning) setting.**
| Evaluators (Size) | CAQA |  |  |  |
| --- | --- | --- | --- | --- |
| S. | C. | I. | U. |  |
| LLaMA-2 (7B) | 0.286 | 0.249 | 0.282 | 0.260 |
| LLaMA-2-chat (7B) | 0.281 | 0.235 | 0.291 | 0.290 |
| Mistral (7B) | 0.315 | 0.281 | 0.294 | 0.265 |
| Mistral-Instruct (7B) | 0.339 | 0.278 | 0.300 | 0.271 |
| Vicuna (7B) | 0.341 | 0.268 | 0.290 | 0.285 |
| LLaMA-2 (13B) | 0.314 | 0.270 | 0.303 | 0.253 |
| LLaMA-2-chat (13B) | 0.338 | 0.279 | 0.305 | 0.278 |
| Vicuna (13B) | 0.339 | 0.257 | 0.296 | 0.288 |
| GPT-3.5 | 0.551 | 0.323 | 0.346 | 0.525 |
| GPT-4 | 0.743 | 0.416 | 0.501 | 0.787 |
| AutoIS (11B) | 0.403 | 0.171 | 0.272 | 0.281 |
| AttrScore (13B) | 0.473 | 0.333 | 0.308 | 0.303 |
| LLaMA-2 (7B) | 0.923 | 0.815 | 0.931 | 0.921 |
| LLaMA-2-chat (7B) | 0.935 | 0.820 | 0.930 | 0.924 |
| Mistral (7B) | 0.935 | 0.831 | 0.921 | 0.905 |
| Vicuna (7B) | 0.956 | 0.823 | 0.936 | 0.939 |
| LLaMA-2 (13B) | 0.954 | 0.824 | 0.936 | 0.939 |
| Vicuna (13B) | 0.950 | 0.847 | 0.935 | 0.940 |

### 6.1 Overall Results on CAQA

Table 5 shows the evaluation of the different attribution evaluators on the CAQA benchmark. Our analysis is as follows:

##### Performance in the Zero-shot Setting

In the zero-shot setting, there is a noticeable variation in performance among different evaluators. Small-scale LLMs generally struggle with identifying nuanced attribution categories, showing marginal improvement in the supportive category.
Although the existing evaluation methods AutoIS and AttrScore are limited by the training data and cannot identify all attribution categories, they outperform other small-scale LLMs in recognized attribution categories. This underscores the significance of training data tailored to specific instructions.
Larger models such as GPT-3.5 and GPT-4 demonstrate improved performance due to their extensive training data. However, their ability to identify insufficient attribution category remains limited, as evidenced by GPT-3.5’s low F1 score of 1.5% in this category. Interestingly, models fine-tuned with instructional data (e.g., LLaMA-2-chat, Mistral-Instruct) do not necessarily outperform their non-instructional counterparts (LLaMA-2, Mistral) in the zero-shot setting, although we believe that understanding the prompts is critical to our task.

##### Performace in the Fine-tuning Setting

Fine-tuning with our benchmark data significantly enhanced evaluator performance, with most exceeding 90% accuracy across all attribution categories. This improvement underscores the effectiveness of fine-tuning, especially notable in the case of Vicuna, which initially lagged but excelled post-tuning. Our results indicate that while LLMs face challenges in attribution, targeted tuning can markedly boost their abilities, offering a path to refine LLM performance and address hallucination issues. However, despite these advancements, the fine-tuned models still struggle with the insufficient category, highlighting ongoing challenges in attribution recognition.

### 6.2 Impact of Attribution Complexity

Table 6 indicates that in a zero-shot setting, smaller-scale LLMs exhibit comparable performance across different levels of attribution complexity, with marginally enhanced efficiency at the simpler single complexity level. Notably, GPT-4 consistently achieves the highest scores in all categories. This highlights its advanced capability in processing complex reasoning tasks, especially in the union category, where it surpasses other evaluators by over 26%.

In the fine-tuning setting, all models show significant improvements in performance at all levels of attribution complexity, suggesting that fine-tuning significantly enhances the evaluators’ ability to process complex reasoning. The Vicuna models, both Vicuna (7B) and Vicuna (13B), register the highest performance post-fine-tuning. However, it is noteworthy that fine-tuning particularly highlights the challenge posed by concatenation complexity, i.e., after the fine-tuning, the performance gap between the evaluator on concatenation and on the other complexity levels becomes significant.

Figure: Figure 2: Overall results of different evaluators on CAQA, against automatically generated categories vs human annotated categories. The dashed curve indicates the equal results. The Pearson correlation across all the evaluators is 0.97.
Refer to caption: extracted/5369910/figures/figure-3.png

### 6.3 Analysis with Human Category Annotations

Consistency of categories. We first directly compare the automatically generated categories with the human annotated categories by measuring Cohen’s kappa coefficient on the testing samples of CAQA.
This coefficient is 0.65, indicating substantial consistency between the two sets of categories.

Consistency on evaluators.
We also analyze the consistency between the automatically generated categories and the human annotated categories over the overall results (micro-F1 scores) of the 14 evaluators as shown in Figure 5.
We can find the the measured results of different evaluators are mostly quite close (i.e., the points are close the to the dashed $y=x$ curve).
We also calculate the Pearson’s correlation coefficient of the two lists of overall results, which is 0.97.
This reveals an exceptionally high consistency between the two kinds of categories, affirming that the evaluation with the automatically generated categories is close to manual evaluation.

### 6.4 Results on ALCE-Manual

**Table 7: Comparison of the Vicuna (13B) model trained with the training set of CAQA and existing attribution evaluators on ALCE-Manual.**
| Evaluators | ALCE-Manual |  |  |  |  |
| --- | --- | --- | --- | --- | --- |
| Sup. | Ins. | Con. | Irr. | Overall |  |
| AttrScore (13B) | 0.44 | - | 0.38 | 0.41 | 0.36 |
| AutoIS (11B) | 0.09 | - | - | 0.33 | 0.20 |
| Vicuna (13B) | 0.40 | 0.25 | 0.35 | 0.51 | 0.42 |

To validate the usefulness of CAQA for developing attribution evaluators, we employ ALCE-Manual to test the performance of the existing evaluators AutoIS (11B) and AttrScore (13B), and Vicuna (13B) fine-tuned on the CAQA benchmark. Table 7 shows that Vicuna (13B) emerges as the most versatile and effective across the dataset, as evidenced by its balanced performance in individual classes and the highest overall Micro-F1 score. This demonstrates that the CAQA benchmark is effective for developing attribution evaluators using the existing LLMs. Appendix D shows specific examples of the three evalutors and the analyses.

## 7 Conclusion and Future Work

This work has advanced the field of analyzing and developing evaluators for natural language QA attribution in the era of LLM.
To this end, we developed an automatic approach that can extract attributed QA benchmarks with different attribution complexity levels and fine-grained attribution categories from KGs.
We have not only analyzed 14 LLM-based automatic evaluators and verified the effeteness of the generated benchmark CAQA, but also compared the automatically generated categories with human annotated categories, showing their high consistency.
In the future, we will study using CAQA and its other versions to augment QA attributions by providing evaluation feedback.

## Appendix A Generation of Natural Language Questions, Answers and Attributions

This section presents examples for generating natural language questions, answers, and citations using the GPT-3.5-turbo model. Our approach involves using distinct prompts for transforming subgraphs into comprehensible natural language citations, extending original questions, and converting answer entities into detailed answer statements. Table 8 demonstrates the conversion of knowledge graph subgraphs into natural language citations.
Table 9 illustrates the process of extending the original questions.
Table 10 provides an example of how answer entities are transformed into long-form answer statements.

Table: Table 8: An example about converting a subgraph to a natural language citation using GPT-3.5-turbo.

Table: Table 9: An example about extending the original question to an extended question using GPT-3.5-turbo.

Table: Table 10: An example about converting the answer entity to a long answer statement using GPT-3.5-turbo.

## Appendix B CAQA Benchmark Construction and Statistics

The CAQA benchmark is built on the top of two KGQA datasets, GrailQA and WebQuestionsSP, with the knowledge graph Freebase, forming a comprehensive attribution evaluation tool.
We selectively include samples from these two datasets whose logical queries align with single-triple, path-like, or tree-like queries, as delineated in Section 4.1.
For path queries, we collect the example with a path length of at most two hops. We treat paths incorporating CVT (Compound Value Type) nodes as one-hop. For example, [(Harper Lee, person.education $?cvt$), ($?cvt$ education.institution, Monroe County High School)] is a one-hop path, where the node $?cvt$ holds no actual meaning. Regarding tree-liked queries, we restrict our selection to those with a maximum of two non-answer nodes, meaning up to two subject entities.

The length distribution (i.e., the number of tokens) of citations in the training and test sets of the CAQA benchmark is depicted in Figures 4 and 4.
These distributions reveal a concentration of citations around 25 tokens, with a minority exceeding 60 tokens. In future work, we aim to enhance the complexity and length of natural language references by developing more intricate subgraphs.
Additionally, Figure 5 presents the domain distribution within the CAQA benchmark. This distribution underscores the benchmark’s broad domain coverage and its encompassment of various sub-domains, highlighting the diversity of our benchmark.

## Appendix C Implementation Details

Table: Table 11: Different prompts designed for different evaluators are used to guide the generation of attribution categories.

Table 11 describes the different prompt designs against the various attribution evaluators.
AutoIS is a natural language inference (NLI) model(^2^22https://huggingface.co/google/t5_xxl_true_nli_mixture) based on T5-11B that outputs a “1” to indicate that the citation supports the answer statement or a “0” to indicate a lack of support.
AttrScore is a uniform name for attribution evaluators developed on various LLMs, and we use the best-performing attribution evaluator (Vicuna-13B) on the original work for comparison.
In the comparative experiments with three evaluators on the ALCE-Manual benchmark, we categorized both “extrapolatory” outcomes (as identified by AttrScore) and “0” outcomes (as identified by AutoIS) under the attribution category of “irrelevant”. This categorization is grounded on the introduction of the training dataset presentation described in the original work.

For model fine-tuning, we use the prompt of “Other Evaluators” depicted in Table 11 as input of all models, and the output of the model is one of the four attribution categories proposed. We use two A100 80G GPUs for full parameter fine-tuning and one A100 80G GPU for the inference phase. During inference, text generation is conducted with a temperature setting of 0. If LLMs produce an attribution category with an explanation, we extract the predicted label using regular expression techniques.

## Appendix D Case Study on ALCE-Manual

Table 12 presents two ALCE-Manual examples, illustrating the attribution categories “insufficient” and “irrelevant”, respectively. It shows that these two categories, which are not included in the previous attribution categories, are common and different in practical situations. In example 1, where the attribution category is “insufficient”, most of the answer statement (highlighted in green) is mentioned in the citation, but the key information “The Maryland Transportation Authority” (highlighted in yellow) is not mentioned in the citation. This demonstrates the subtleties that can render an attribution insufficient. In example 2, which is categorised as “irrelevant”, the entirety of the answer statement is irrelevant to the citation. This exemplifies a clear case of irrelevant attribution.
Notably, previous evaluators, AutoIS and AttrScore, are unable to accurately classify these cases. In contrast, Vicuna, an evaluator trained with our CAQA benchmark, successfully identifies the correct attribution categories. This underscores the effectiveness and practicality of employing the CAQA benchmark for developing attribution evaluators.

Figure: Figure 3: Histogram of the number of tokens across all citations in the CAQA benchmark training set.
Refer to caption: extracted/5369910/figures/data_sta_train.png

Figure: Figure 5: The distribution of examples across different domains in the CAQA benchmark.
Refer to caption: x2.png

Table: Table 12: Two examples of the results of the three attribution evaluators on ACLE-manual. Content in yellow highlights portions of the answer statement not found in the citation, whereas green indicates content present in the citation.

## Peer Reviews

confidence: 5
contribution: 3
initial_rating: 5
presentation: 3
questions: - How do you verify the quality of converted natural language style questions?
- What is the inter-agreement score of human annotations?
soundness: 3
strengths: - CAQA uses KGs to generate complex QA benchmarks automatically, enabling scalability and minimizing manual annotation effort.
- Different reasoning complexities are considered, highlighting LLMs' capabilities in handling logical relationships between facts.
- The benchmark includes fine-grained attribution categories.
summary: The paper presents CAQA (Complex Attributed Question Answering), a large-scale automatically generated benchmark designed to assess the attribution capabilities of QA systems, particularly Large Language Models (LLMs). CAQA leverages Knowledge Graphs (KGs) to create comprehensive attribution categories and to handle complex reasoning scenarios. The benchmark distinguishes between supportive, partially supportive, contradictory, and irrelevant evidence types and introduces reasoning complexity through different forms of evidence combination (e.g., union, intersection, concatenation).
weaknesses: - The task setting seems very similar to NLI to me, more discussions are needed.
- Lack of a few details about the human annotation process.
- The distribution of the complexity is biased.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 4
questions: See "Weaknesses".
soundness: 3
strengths: 1. This paper introduces CAQA, a large-scale benchmark for evaluating complex attributions in QA.
2. The CAQA dataset contains various new definitions (e.g., fine-grained attribute categories and attribution complexities), and the data construction process is automatic, considerate, and comprehensive.
3. This paper contains comprehensive experiments. In addition to model performance on CAQA, it also includes fine-grained analysis, human consistency, and out-of-distribution data.
summary: This paper introduces Complex Attributed Question Answering (CAQA), a large-scale benchmark designed to evaluate complex attributions in question answering (QA). CAQA is automatically generated using knowledge graphs (KGs), includes a broader range of attribution categories along with intricate attribution reasoning scenarios, and is also aligned with human annotations. Experiments with two specifically developed evaluators and nine large language model (LLM) evaluators reveal that these models struggle to identify negative attribution categories and handle complex attribution reasoning in both zero-shot and few-shot settings but mostly perform relatively well in the fine-tuning setting.
weaknesses: 1. This paper only considers GPT-3.5 and GPT-4 as closed-source LLMs, and some open-source LLMs used may be outdated (e.g., Mistral-7B has revolutionized various versions). Adding more diverse and latest models in experiments would have greater contributions and help to discover which LLMs perform best on this challenging task.
2. There is a lack of comparisons with human performance on (a subset) of the dataset, which would better illustrate the performance gap and the challenge of the dataset.
3. While the contribution of the paper centers on a new challenging benchmark, it would be much helpful if the authors can provide an error analysis, which will direct newcomers in future research.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: Some discussion on the ambiguity (and actual errors) in the labeled categories would be useful (e.g., human annotator agreements on a sample). 

Also would be good to discuss the lack of context consideration which is usually very important in real usage (e.g., the example in the paper "Who plays Fruma Sarah in Fiddler on the Roof" depends on which version of Fiddler on the Roof is being referenced).
soundness: 3
strengths: The dataset is relevant for the important topic of answers with attributions from LLMs. Being able to carefully validate whether an answer actually follows from the sources is an important skill, and this dataset aims at helping with this.

The paper is well written, clearly describing the approach.

The use of the KG to create various incorrect attributions, together with using LLM to rewrite at text, seems quite effective.

The paper provides access to the full dataset for exploration which is truly helpful in assessing it.

The methods are tested on a more realistic, OOD, dataset.
summary: The paper introduces the dataset Complex Attributed Question Answering (CAQA), containing answers to questions with associated source attributions, where the attributions may or may not support the answer. The non-support attributions are divided into 3 labeled categories: Partially supported, Contradictory Irrelevant.

They evaluate how well different LLMs can classify Q+A+source into these 4 categories, finding that in many cases they struggle to do well, especially on distinguishing the non-supportive categories.

The CAQA dataset is constructed from existing KGQA datasets (GrailQA and WebQuestionsSP), making use of the associated knowledge graph to produce different types of non-supportive evidence (and using GPT-3.5 to turn KG triples into natural language sentences). The resulting dataset is quite big (137k train, 24k test), allowing for fine-tuning experiments as well. The fine-tuned models do very well in distribution, and they also do limited out-of-distribution evaluation on a subset of ALCE further annotated with these non-supportive categories, showing promising results there as well.
weaknesses: While breaking down the non-supportive cases into three subcategories can be helpful for understanding limitations, the boundary between them can be quite unclear. Also the prompt for the non-GPT models doesn't go into great detail (beyond some examples) on what each category means. For instance, the "contradictory" evidence is often for actual true facts, so they're not actually contradiction, it's just the "wrong" evidence.

E.g., the answer "The person who founded the United States Coast Guard also founded the United States Department of the Treasury." is presented as being contradicted by the source "Alexander Hamilton is the founder of the United States Coast Guard and the Montgomery County Sheriff's Office, which is a government agency.", but this isn't really a contradiction, it's more like missing evidence. A true contradiction should lead you to think the answer is actually false, if you trust the source.

The "Partial support" category also can be quite subjective, as in the case of "The 2011 Estoril Open tournament event competition is the Men's Singles." being partially supported by "The 2011 Estoril Open had a men's singles competition."  (what's missing is apparently that "2011 Estoril Open" was "tournament event competition", but that's pretty much implied by the fact that they had a men's single compeition).

Because of this, it might also be useful to report the most important "supported" vs "not supported" scores.

Another concern is the simplicity of the dataset, with simple QA assertions attributed by short source sentences. How does good performance on CAQA transfer to more realistic settings. And can it be used to train better source attribution models as well? There is some exploration of this with the OOD ALCE dataset, but the effect (e.g., between Vicuna-13B and Vicuna-13B-finetuned) isn't as impactful as one might have hoped.

---

confidence: 3
contribution: 3
initial_rating: 5
presentation: 3
questions: 1. How might CAQA be adapted to handle dynamic or temporal data in QA tasks?
2, What specific types of biases were identified or considered when using LLM-generated prompts?
3. Are there plans to include more diverse logical operations, such as negation, in future iterations of CAQA?
4. Could the inclusion of human-in-the-loop evaluations further enhance the quality of the generated benchmark data?
5, Extend the benchmark's applicability by including examples from various knowledge domains (e.g., medical, legal) to test the robustness of attributions in specialized contexts.
6. The reliance on GPT models for generating natural language representations from KGs may introduce subtle biases. Addressing how these biases are minimized or discussing potential implications would strengthen the manuscript.
7. Discussing how CAQA could be adapted for such tasks would add value especially how to address the challenges in more diverse, such as open-domain QA systems. .
soundness: 3
strengths: The use of KGs for automatic construction of the benchmark is novel, making the process scalable and adaptable.
The research tests various models and demonstrates the needs of fine-tuning for achieving robust performance.
The benchmark shows high consistency with human evaluations, supporting its credibility as an effective tool for future developments in QA systems.
The choice to test multiple LLMs, including state-of-the-art models like GPT-4 and LLaMA variants, provides a robust analysis of performance across different model scales and settings.
The inclusion of a wide range of attribution types and complexity levels sets a high standard for evaluating QA systems.
summary: This manuscript aims to bridge the gap in attribution evaluators' use of knowledge graphs by providing detailed categories. This study's experiment offers multiple configurations in zero-shot, few-shot, and fine-tuned contexts, demonstrating that the fine-tuning process can significantly improve performance. This benchmark aims to address the shortcomings of existing attribution evaluators, which face challenges with intricate attribution categories and sophisticated reasoning processes.
weaknesses: The benchmark is tailored for KG-based QA tasks, which may not reflect the challenges present in more diverse, open-domain QA systems. 
The reliance on GPT models for generating natural language representations from KGs may introduce subtle biases.
The rationale behind choosing specific complexity types (e.g., concatenation, intersection) could be expanded with examples illustrating real-world implications of these complexities in QA.

Meta-review: This paper presents options for evaluating complex attributed question answering tasks.  I think this paper can't be accepted due to multiple reasons:

1.  I think the "partially supported" category does not make any sense for the attribution task, which was originally proposed by Rashkin et al (2023).  Either a claim in a response is attributable to evidence or not.  Hence, focusing too much on that category--which this paper does, weakens its experimental design.  Several reviewers point this out.

2.  It is unclear to me whether the paper will generalize to tasks beyond ones that rely on KGs--another point mentioned by reviewers.

It will be great to address these issues in addition to the finer grained issues mentioned below, to improve the draft.

Decision: Reject