Query Rewriting for Effective Misinformation Discovery

In this paper, we focus on the task of query rewriting for discovering similar claims from an opaque search end-point. We have a collection of input claims ($C_{1},C_{2},...,C_{n}$) that contain at least one fact-checkable claim. For any given claim $C_{i}$ in the collection, there exists one or more collections of similar claims ($SC_{i1},SC_{i2},...,SC_{im}$), either supporting or refuting the claim in-part or as a whole. The RL agent operates on a fixed set of actions $\mathbf{A}=\{A_{1},A_{2},...,A_{k}\}$ that can be applied to any of $C_{i}$’s tokens ($T_{i1},T_{i2},...,T_{iq}$), where $k$ is the number of possible actions, $q$ is the number of tokens in $C_{i}$. We rewrite the query by applying the sequence of actions ($A_{ij},1\leq i\leq k,1\leq j\leq q$) generated by the RL model to the original query. We can then use this improved query to retrieve related evidence statements.

Our system rewrites a query using concepts from RL and query expansion. We pass the query into a pre-trained language model and then use the pooled representation from the final layer as the state representation. We use a decision transformer architecture, where states, actions, and rewards are provided to the model as a flattened sequence. The decision transformer uses a decoder-only GPT architecture Radford et al. (2018) to learn the optimal policy during training time. During inference time, it autoregressively predicts actions for a given state. An overview of our model architecture is shown in Figure 2. Below, we describe important elements of the model architecture related to the query rewriting process.

We implement these actions using WordNet Miller (1994) and the spaCy’s part-of-speech tagger. Note that only certain actions are permitted for each part of speech tag: verbs support all four actions, nouns, adjectives and adverbs support all actions except changing verb tense, and stop words and other parts of speech support only the remove action.

Since access to social media API search endpoints is limited, it is difficult to train an RL agent on top of them. Furthermore, the changing nature of misinformation on social media is another important factor to take into account, given that misinformative posts are periodically removed from social media platforms and are thus no longer available once fact-checked. These issues made us opt for a simulated search environment, with the added benefit of making our methods adaptable to arbitrary search endpoints. We experiment with two main systems:

The FEVER dataset Thorne et al. (2018) is a collection of manually written claims from Wikipedia that are connected with evidence sentences that either “support” or “refute” them. Since we are interested in claims linked to related evidence, we discard the claims in the dataset labeled as “NotEnoughInfo.” This leaves us with 102,292 claims in the training and 13,089 claims in the development sets. Schuster et al. (2019) identified issues caused by the construction processes of the original FEVER dataset such as uses of negation in claims being heavily correlated with the “refute” outcome, therefore causing a “claim only” fact verification system to performs as well as an evidence-aware fact verification system. However, since our work is not concerned with the fact verification application of FEVER, we do not find this to be an issue.

FEVER is a well-known dataset among the misinformation and fact-checking communities. Even if FEVER is not a social media dataset, it is nonetheless based on user-contributed data, and thus we believe that the findings obtained using this dataset can be generalized to claims on social media platforms with minor domain-specific revisions, especially since the linguistic structure of claims and discussions around them is similar to the claims in the FEVER dataset.

To generate training data, we transform FEVER pairs (claim, evidence set) into sequences of editing actions that improve upon the original query. These transformations are obtained by exploring the state space of possible outcomes after applying different permutations of edits on the initial claims. We use a Breadth-First Search (BFS) strategy that applies editing actions to an input claim $C_{i0}$ and finds the collection of the action sequences of $(C_{ij-1},A_{j},C_{ij},R)$ that can improve the initial claim, where $C_{ij}$ is the generated claim after applying the edit $A_{j}$ to the claim $C_{ij-1}$, and $R$ is the reward of $Q(C_{ij})$ (querying retriever with $C_{ij}$).

Although understanding the effects of different search algorithms on our model remains an interesting problem for future work, our experiments show that using simple heuristics on BFS search is effective while generating training data from the FEVER dataset. For instance, we find that limiting the depth of the breadth-first exploration to K levels is effective for improving the query results. Also, when conducting parallel runs on different sections of the dataset, even for K = 4, the vanilla depth-limited BFS takes a half to 2 days to generate the training data. Additionally, we find that restricting the state-space search to include only improvement edits at every step reduces the size of the search space. We also prune search paths leading to minor improvements (i.e. less than 3%) or at random in 5% of instances. Since most edits do not lead to significant improvements, it is unlikely we skip meaningful paths during the search. Finally, we only include sequences with the highest gains through serial edits, e.g. picking the top 50 or 100 most beneficial editing sequences for each claim, in our training set. Overall, these heuristics improve the generation speed and quality of the training instances.

Moreover, our ability to learn good editing actions depends on how well we can generate training examples. By setting $K$, the maximum depth for search to 4, we are able to get improvements up to 41.21 AP@50 scores for 45,658 claims, on average, against the BM25 retriever. We also discard training examples with reward values already at maximum, since it is impossible to improve beyond the perfect score, and also edited claims leading to no improvement. Figure 3 shows examples of the sequences of claims generated by different actions. Table 2 reports the distribution of actions as well as the average improvement of AP@50 scores for each action when tested against the BM25 retriever.

During our experiments, we use the original decision transformer implementation.¹¹1https://github.com/kzl/decision-transformer We use a 6-layer decoder-only transformer with 8 heads, embedding dimension of 768. We set $K$ (also called a block size) to be the maximum number of edits to the original query. We pad all sequences shorter than $K$. After flattening all the returns-to-go, states and actions, our sequence becomes of length $K*3$.

We use the all-mpnet-base-v2 embedding model from the Huggingface’s sentence transformers library.²²2https://huggingface.co/sentence-transformers We also experimented with the all-MiniLM-L12 model from the sentence transformers, but the results were worse, possibly because of all-MiniLM-L12 being a smaller model. Our intermediate state representations for an input claim is a vector of size $768$. Our model is trained with cross entropy loss for 5 epochs performed on one Nvidia 2080Ti GPU.

Results in Table 3 show that the decision transformer model with fine-tuned state embeddings and dense rewards outperforms all systems with BM25 as retriever and AP@50 as reward. The same model trained with sparse rewards—hiding the intermediate rewards during training—does slightly worse than the dense reward setting, suggesting that providing more granular information about each action’s reward during training brings performance advantages. Both models turn the input into a significantly more effective query with performance improvements of up to 23% (relatively) as compared to just searching for the original claim. According to Table 4 these gains are the highest for kNN as retriever and recall as reward. Table 3 also shows that performing a random sequence of edit actions negatively affects performance. This suggests that there is a “query improvement process" that needs to be learned and applying a random sequence of edits by itself does not bring any inherent advantages, i.e. our systems do well not because there is an inherent gain in how we transform the problem, since if that was true, applying random action sequences should have yielded improvements over the claim baseline, which it did not.

Figure 4 shows the mean AP@50 (mAP@50) score changes for all the generated sequences for the experiment of decision transformer with sparse reward. We plot the mAP@50 scores for queries generated at each step, where the x-axis shows the number of edits, with 1 representing the original claim and 5 the final rewritten query. The size of the circle indicates the number of queries at each turn. If the claim achieves the perfect score, no further rewrites will be generated in the next turn and we stop early. We observe sequences with improved mAP@50 scores shrink along the turns. This indicates that some claims reach a perfect mAP@50 score after only one or two modifications. In contrast, for sequences with a decreased mAP@50 scores, the circle sizes remain the same while performance drops. This suggests that for such claims, the more the model modifies it, the worse its performance is. For the sequence of claims with the same mAP@50 scores at the beginning and the end, there is a slight up and down for the slopes for the lines in between. This suggests that there are some sequences where the modified query achieves a better score while later modifications hurt the performance or vice versa. However, such scenarios are rare. Of the 13,089 claims in the development set, 1541 claims have the same AP@50 scores at the beginning and the end. Among these, 1243 are constant along the entire sequence and 271 have minor score changes, as reflected in Figure 4 as the blue line (mAP@50${}_{\text{{e}}}$ = mAP@50${}_{\text{{b}}}$).

Figure 5 shows the distribution of actions in the model output corresponding to increased performance, no changes in performance, and decreased performance. We can see that most of the actions lead to no performance change. The remove and swap with synonym actions result more often in increases in performance than decreases. In contrast, add synonym and change tense to present simple more often result in performance reduction. Figure 6 shows the average change per action. In this plot we observe that the net performance changes for remove and swap with synonym are positive, with an average of 1.83 and 0.88, respectively. The net performance changes for add synonym and change tense to present simple are negative, with an average of -0.34 and -0.98, respectively. We hypothesize that the model does not learn add synonym and change tense to present simple actions well due to the sparsity of such examples in the data as shown in Table 2. We further discuss the importance of these actions in Section 6.

We conduct ablation experiments to evaluate the ability of our system in adapting to arbitrary endpoints and different performance metrics. Although the space of possible ablations is far larger than what we present here, we pick three dimensions of ablations that could be useful for practitioners and future researchers: (i) retriever type (BM25 or kNN), (ii) reward metric (average precision, recall, reciprocal rank) and (iii) presence of negative training examples.

Table 4 shows the results on each ablation when compared against a baseline of just using the initial claim. Across different metrics and retrievers we observe improvements in query performance: our system improves the original claim of up to 11% absolute recall points (42% relative improvement) and works on both BM25 and kNN retrievers. We also observe that the inclusion of training sequences with query performance decrease (negative training examples), consistently leads to performance decreases on all metrics and retrievers as compared to just training on positive edit sequences –with the only exception of querying kNN with RR as reward. We posit that this performance gap is due to the difference in data quality, i.e, providing our models with noiseless training signals leads to more effective queries. However, even in cases where we include negative training examples our models still meaningfully improve over the original claim.