Benchmark Inflation: Revealing LLM Performance Gaps Using Retro-Holdouts

## Abstract

Abstract The training data for many Large Language Models (LLMs) is contaminated with test data. This means that public benchmarks used to assess LLMs are compromised, suggesting a performance gap between benchmark scores and actual capabilities. Ideally, a private holdout set could be used to accurately verify scores.
Unfortunately, such datasets do not exist for most benchmarks, and post-hoc construction of sufficiently similar datasets is non-trivial. To address these issues, we introduce a systematic methodology for (i) retrospectively constructing a holdout dataset for a target dataset, (ii) demonstrating the statistical indistinguishability of this retro-holdout dataset, and (iii) comparing LLMs on the two datasets to quantify the performance gap due to the dataset’s public availability. Applying these methods to TruthfulQA, we construct and release
Retro-Misconceptions,
on which we evaluate twenty LLMs and find that some have inflated scores by as much as 16 percentage points. Our results demonstrate that public benchmark scores do not always accurately assess model properties, and underscore the importance of improved data practices in the field.

## 1 Introduction

Many have begun to question the reliability of public benchmarks in assessing large language models (Alzahrani et al., ; Zheng et al., ; Fourrier et al., ). Discrepancies between benchmark scores and practical capabilities raise concern (Li et al., ), and strong incentives for higher scores (Fourrier et al., ) suggest that optimizing benchmark performance could take precedence over real-world effectiveness and safety. This phenomenon, akin to specification gaming (Krakovna et al., ), is termed *evaluation gaming* – processes leading to a systematic gap between benchmark performance and practical utility.

Extensive evidence of evaluation data being included in training data (Sainz et al., ; Oren et al., ; Schaeffer, ; Shi et al., ; Jiang et al., ; SLAM-group, ) suggests that evaluation gaming is occurring. However, proving the existence of a statistically significant performance gap between a specific evaluation task and an analogous real-world task would require access to an independently and identically distributed (IID) split of the benchmark which we know could not have had an impact on any aspect of model development.

This is the idea of *holdout* datasets, which are used to assess a machine learning model’s unbiased performance after training. By definition, a holdout dataset comes from the same distribution as its corresponding target dataset, meaning that any evaluation conducted on both datasets should have the same result within some statistical tolerance (James et al., ). Importantly, holdout datasets also are kept hidden during the development process. Together, these two properties imply that comparing a model’s performance on a public benchmark and a corresponding holdout dataset could reveal whether the public benchmark has influenced any aspect of the design, training, or validation process. Unfortunately, holdout datasets for benchmarks are typically not available; benchmark developers usually release all evaluation data, although there are notable exceptions, e.g. Li et al. ().

To resolve this, we propose *retroactive holdout*, or *retro-holdout*, datasets, which are verified to be sufficiently similar to their corresponding target dataset through various tests, despite being created independently and retroactively. Utilizing a retro-holdout, we can quantify the evaluation performance gap of any given model.
We detail our methodology for creating and validating retro-holdout datasets, along with multiple recommendations and tools for generating such datasets. Using the TruthfulQA(^1^11TruthfulQA was chosen due to its safety relevance and widespread use (Zhao et al., ; Naveed et al., ; Bai et al., ; Cui et al., ; Fourrier et al., ).) evaluation (Lin et al., ), we conduct a case study to quantify performance gaps for twenty contemporary models. Our results conclusively indicate that evaluation gaming is occurring, underscoring the need for improved data practices in the domain.

Figure: Figure 1: Visualization of our methodology. The left panel summarizes the process for constructing a retro-holdout dataset, while the right panel illustrates how to leverage such a dataset to quantify benchmark inflation.

### 1.1 Contributions

In this work, we:

- •
Present a novel process for constructing retro-holdout datasets.
- •
Release
Retro-Misconceptions,
a retro-holdout dataset for TruthfulQA, which can be used to quantify the performance gaps of a model on the original dataset.(^2^22 Retro-Misconceptions is only guaranteed to be accurate on models with a training cutoff date prior to January 1st, 2024, since that as that is when portions of the new dataset became available on the web.)
- •
Evaluate twenty models using
Retro-Misconceptions
to demonstrate measurable score inflation.

## 2 Methods

### 2.1 Understanding the retro Holdout Framework

Holdout datasets were first used in machine learning to accurately assess model performance on a given task. A holdout set is a randomly selected subset of the same set of observations as the training dataset, and is strictly excluded from the development process (James et al., ). Unlike conventional holdout sets, retro-holdout datasets are created after the initial release of a dataset, meaning we cannot assume they have the same properties that a hypothetical holdout set would have. We refer to Appendix A for a formalization of this claim.

In brief, we rely on a standard assumption in machine learning that the public and post-hoc retro-holdout datasets consist of independent samples from two possibly different distributions (Hastie et al., ; Shalev-Shwartz and Ben-David, ). To establish that the retro-holdout can be used as a holdout set for the public benchmark, we must show that both datasets could have been sampled from the same distribution.
We construct four statistical tests, one permutation test and three binomial tests, to reject the hypothesis that two sets were sampled from the same distribution. A proposed dataset cannot be considered a retro-holdout for a given public benchmark unless all four tests fail to reject the hypothesis of a shared distribution.

This verification process sets our methodology apart from a more standard dataset extension, as it mandates that our retro-holdout is an assessment of exactly the same task as the original benchmark, making the only difference between the two the variable we care about: public availability of a dataset. The lengths we have gone in order to reach this level of rigor are extensive; the retro-holdout framework does not make use of LLMs for any aspect of dataset creation. This substantially increases the time cost of our process, but ensures that language models do not bias our results.

Our method is designed for labeled datasets, which have inputs and expected outputs for models. We note that out of distribution (OOD) testing has sometimes been incorrectly characterized as using holdout datasets. In this work, we use the original definition of holdout sets; evaluation sets constructed to probe OOD performance are not considered.

For brevity, we define

$$ target $\displaystyle:=\text{ an arbitrary, publicly available benchmark},$ retro $\displaystyle:=\text{ a retro-holdout dataset for {target}}.$ $$

### 2.2 Creating a retro

Initially, the methodology used for crafting a retro should be heavily informed by the original process used to create the target. To promote similarity, we recommend using a representative entry, randomly drawn from target, without replacement, as a basis for creating each new entry in retro. We include a short guide for this initial creation in Appendix D.

#### 2.2.1 Sufficient Indistinguishability

Establishing with absolute certainty that the two datasets have originated from the same distribution is impossible. Therefore, we resort to multiple statistical tests designed to test the null hypothesis that target and retro have a common origin. If the result of each test indicates that we cannot reject our null hypothesis, we designate our retro to be sufficiently indistinguishable from target. While it is theoretically possible to construct any number of tests to evaluate the similarity between two datasets, practical considerations guide us to four key tests that provide a thorough assessment:

- •
Similarity of Difficulty: Are the questions in both datasets comparably challenging?
- •
Semantic Embedding Similarity: What is the likelihood that a distribution of cosine similarities between sentence embeddings similar to that of retro have been pulled from the same distribution as target?
- •
Prediction Accuracy: Can a model, fine-tuned on randomized splits of the datasets, differentiate between target and retro?
- •
Human Distinguishability: Can humans differentiate between target and retro?

We designate the two datasets as *sufficiently indistinguishable* if all four tests fail to reject the null hypothesis at a $p$-value of 5%.

##### Similarity of Difficulty

To verify that the two datasets have comparable difficulties, we use both to evaluate models with a training cutoff date prior to the release of the target, or *pre-release* models. These models could not have been affected by the target, as it had not yet been released; model performance on both datasets should be comparable, with a margin of statistical uncertainty. This reduces to a two-proportion binomial test with the null hypothesis of equal success probability (Diez et al., ).
For further information on the evaluation task, refer to §2.3.

We note that with access to many LLMs of varying capability levels, this test combined with simple human assessment would likely suffice to determine sufficient indistinguishability between the two datasets. However, performance of cutting-edge models continues to improve, meaning that pre-release models are practically guaranteed to be less capable than contemporary models, assuming they are accessible at all. These constraints are expanded on on Appendix G.
To address this limitation, we use a number of techniques to amplify pre-release performance: allowing the model to choose multiple answers (top-$k$), including examples of other questions within the dataset (5-shot),
and using the ‘helpful’ prompt from Lin et al. ().

Figure: Figure 2: Model accuracy on Retro-Misconceptions vs. TruthfulQA (Misconceptions, Non-Adversarial) for multiple pre-release models. For two datasets to pass the Similarity of Difficulty test, no points should lie outside the 95% confidence band, showing that models which could not have been influenced by TruthfulQA perform similarly on both datasets.
Refer to caption: x1.png

##### Prediction Accuracy

We adopt a modification of prediction accuracy as defined by Dankar and Ibrahim () to determine if a machine learning model can differentiate between the datasets. Contrary to the conventional use of logistic regression in synthetic data evaluations (Dankar and Ibrahim, ), we fine-tune BERT (Devlin et al., ) on a prediction task. This choice was informed by BERT’s capability to capture nuanced semantic relationships within text, which are crucial for accurately assessing the subtle distinctions or similarities between dataset entries. If the model’s prediction accuracy is approximately the same as random performance, 50%, we can conclude that the model cannot differentiate between the two datasets. Under a null hypothesis, this simplifies to a binomial test with success probability of $\nicefrac{{1}}{{2}}$.

To calculate the prediction accuracy score, each dataset is split into five folds. One split from each dataset is withheld, and BERT is fine-tuned to accurately label an entry as either retro or target on the remaining data. The model’s prediction accuracy on the holdout splits is measured, and then the process is repeated such that each split is used for testing.

##### Semantic Embedding Similarity

We perform a random permutation test (Fisher, ; normaldeviate, ; Hemerik, ) using semantic embeddings from Sentence Transformers (Reimers and Gurevych, ). We define the test statistic as the mean of all pairwise cosine similarities between embeddings. To obtain a sufficiently tight bound, we use a sample size of $N=10000$. This test is formally defined in Appendix A.

##### Human Indistinguishability

To assess whether the datasets were distinguishable to humans, we conducted a survey where participants were tasked to separate entries from target and retro. Participants were shown ten labeled entries from each dataset for contextual understanding, followed by a series of ten tests, each comprising of three dataset entries – two from target and one from retro. All entries are drawn without replacement to ensure unique samples throughout the survey. Under the null hypothesis, this is a binomial test with success probability $\nicefrac{{1}}{{3}}$.

We also implement a variation of this test using GPT-4o as the evaluator to compare human and model performance. See Appendix F for comprehensive details on the survey methodology, including specifics on participant recruitment, the structure of the test, and survey instructions.

#### 2.2.2 An Iterative Process

Creating a retro that meets our rigorous standards for sufficient indistinguishability is non-trivial and will likely require iteration. Acknowledging this, and considering the time-intensive nature of dataset generation, efficiency is quite important. We have created a number of tools that aid in high-level iteration:

- •
Fine-Tuned Prediction Model Attention: A BERT model (Devlin et al., ) is fine-tuned to classify entries as belonging to either target or retro. [Transformers Interpret](https://pypi.org/project/transformers-interpret/), a library based on Integrated Gradients for explaining model output attribution (Sundararajan et al., ) is then leveraged to identify which input tokens the model considered most relevant when differentiating between target and retro.
- •
Datapoint Embeddings: [all-mpnet-base-v2](https://huggingface.co/sentence-transformers/all-mpnet-base-v2) is used through the HuggingFace [Sentence Transformers](https://sbert.net) library, to create vector representations for all data points (Reimers and Gurevych, ). These embeddings are then taken as the basis for the following three tools; when analyzed in conjunction they can provide meaningful insights on general similarity trends, outlier detection, and topic clustering.
–
Embedding Space Visualization: We employ Uniform Manifold Approximation and Projection (UMAP) to project these embedding vectors onto a two-dimensional plane (McInnes et al., ). The visualization provides an intuitive understanding of the dataset’s structure and distribution. An example output of this visualization tool is provided in Figure 7.
–
Internal Cosine Similarity Distribution: To assess similarity between entries within the datasets we plot histograms of pairwise cosine similarities of datapoint embeddings. This representation aids in identifying outliers and assessing overall similarity within the datasets, as demonstrated in Figure 3.
–
Largest Internal Cosine Similarity Comparison: We highlight the ten entry pairs with the highest cosine similarities in both datasets, providing a direct comparison of the most similar entries and their respective values.

Still, it is quite possible that insights found with these tools will not be enough to ensure sufficient indistinguishability. Additional documentation for using the tools, as well as recommendations for this process, are detailed in Appendix E.

Figure: Figure 3: Example output from the Internal Cosine Similarity Distribution tool. This specific plot indicates that entries within the target were systematically more similar by a small amount, which led the team to further scrutinize word frequencies.
Refer to caption: x2.png

### 2.3 Evaluating Models

The evaluation metrics published with TruthfulQA relied on being able to produce the log-probabilities of given completion options (Lin et al., ). This simplifies the scoring of a model in that one does not have to interpret or match freely-generated responses. This may however not be ideal for a few reasons. First, the use of log-probabilities is likely to penalize longer responses, since they naturally have lower total probability. Second, as it may not account for alternative, even shorter, responses. Finally, API providers such as OpenAI, no longer supply such information.

If these models have not been subjected to any form of data leakage, one should see no significant cap regardless of the metric used. We have therefore modified the scoring in order to retain support also for API models and to allow for comparison between open-release and closed-source purely generative models. Our method therefore provides an enumerated list of all the choices (*mc1* in TruthfulQA) and we resample to make the models generate one of the indices as selection. These options are then rotated to minimize balance and resampled a number of times and to ensure a dominating option. We refer to Appendix C for further details on this process. The prompt was used for all models is described in Section C.2.

These results are recorded in Table 1.

**Table 1: Empirical 1-Sigma Error of the Evaluation Task**
| Model | TruthfulQA | Retro-Misconceptions |
| --- | --- | --- |
| Babbage-002 | $\pm 1.27$ | $\pm 2.47$ |
| Davinci-002 | $\pm 0.83$ | $\pm 1.96$ |
| NeoX-20b | $\pm 2.84$ | $\pm 1.34$ |

Experiments were conducted using the OpenAI and Anthropic chat completion APIs and various models from Huggingface with mostly default settings. The generation length was adjusted, and a temperature of 0.5 was specified, although this parameter may not apply to OpenAI chat models.

### 2.4 The Challenges of TruthfulQA

The TruthfulQA dataset uses two entry labels: Category and Type. Categories specify the general topic that an entry is about, such as Health, or Advertising; there are 31 Categories in TruthfulQA. Type contains only two options, adversarial or non-adversarial.

When constructing TruthfulQA, the authors filtered a large number of initial entries using a version of GPT-3, discarding the entries that the model answered correctly. The resulting set make up the adversarial Type of TruthfulQA. Subsequently, these adversarial entries were used as inspiration to create new entries for the non-adversarial Type. When comparing the adversarial and non-adversarial Types, we unsurprisingly found that GPT-3 models like Babbage-002 and Davinci-002 do significantly better on the non-adversarial portion. To create a retro-holdout for the entire TruthfulQA dataset, we would require access to the same GPT-3 model originally used to filter TruthfulQA. This model is no longer available.

Due to filtering bias, performance differences between the two Types, and lack of access, we focus on the non-adversarial portion of TruthfulQA. While these changes deviate from perfect reflection of TruthfulQA, we note that both the Difficulty Similarity test and model evaluations use identical datasets and methods. As a result, any statistically-significant performance gap must be explained by some form of evaluation gaming.

## 3 Results and Discussion

### 3.1 Retro-holdout TruthfulQA Dataset

We release Retro-Misconceptions, a retro-holdout dataset designed to quantify the evaluation gap for models tested on the TruthfulQA dataset, *provided that the model’s training cutoff date is prior to January 1st, 2024*. Retro-Misconceptions mirrors the Misconceptions category of the original TruthfulQA dataset.

Notably, Retro-Misconceptions has passed all four of our indistinguishability tests, establishing it as the first retro-holdout dataset to be *sufficiently indistinguishable* from its corresponding target dataset. The results are summarized in Table 2, and Figure 2 visualizes results of the Similarity of Difficulty test.

**Table 2: Retro-Misconceptions Indistinguishability Tests Results**
| Description | Outcome | $p$-value | $\textrm{H}_{0}$ |
| --- | --- | --- | --- |
| Difficulty Gap |  |  |  |
| GPT-NeoX 20B | $-1.3\pm 2.8\%$ | $\geq 50\%$ | $0\%$ |
| Babbage-002 | $-1.2\pm 7.4\%$ | $\geq 50\%$ | $0\%$ |
| Davinci-002 | $-3.3\pm 8.0\%$ | $\geq 50\%$ | $0\%$ |
| Prediction |  |  |  |
| Accuracy | $53.7\pm 3.26\%$ | $47.4\%$ | $50\%$ |
| Distinguishability |  |  |  |
| Human | $31.3\pm 7.1\%$ | $\geq 50\%$ | $33.\overline{3}\%$ |
| GPT-4 | $28.0\pm 9.0\%$ | $\geq 50\%$ | $33.\overline{3}\%$ |
| Semantic Similarity |  |  |  |
| target | $\,\,\,6.67\pm 1.86\%$ |  |  |
| retro | $93.48\pm 1.85\%$ |  |  |

Figure: Figure 4: Model performance gaps on TruthfulQA vs our retro-holdout. Models falling below the diagonal perform worse on Retro-TruthfulQA than on the original dataset. Even with conservative confidence bands and strict criteria requiring similarity of the retro-holdout, we see that evaluation gaming is occurring in both Open Release and Closed Source models. An additional visualization of these data is provided in Figure 5.
Refer to caption: x3.png

### 3.2 The Performance Gap

With our newly created retro-holdout dataset, we explicitly quantify the benchmark inflation (BI)(^3^33BI is the percentage point (pp) difference between model performance on a public benchmark and a (retro-)holdout of that benchmark.) of 20 models,
shown in Figure 5. Our analysis covers both larger API models such as Claude3 and GPT-4, as well as several open-release models that have been either speculated or confirmed to exhibit data leakage (Sainz et al., ).

Figure: Figure 5: Model performance gaps on TruthfulQA, quantified by the difference in a model’s benchmark score on TruthfulQA (Misconceptions, Non-Adversarial), and Retro-Misconceptions. Language model names, including version specifications, are shown on the left of the plot, and Fisher’s Exact Test $p$-values between the models score on Retro-Misconceptions and TruthfulQA are given on the right. Entries marked with * have a $p$-value less than $0.05$. Statistical uncertainty is visualized with 1-sigma error bars.
Refer to caption: x4.png

To develop further understanding of these results, we look to Deng et al. (), who investigated data contamination of TruthfulQA in various models, including Mistral-7B, ChatGPT, and GPT-4.(^4^44Model version is not reported in the study.) Models were presented with TruthfulQA entries containing a single masked incorrect response, and tasked with reconstructing the missing text. Exact match rates and benchmark inflation for the three models are recorded in Table 3.

When language models produce an exact match in these tests, it is clear that the benchmark was included in the training data to some extent. While it is unsurprising that models with high exact match rates (Deng et al., ) perform better on the benchmark than they should, it is worth noting that we found substantial benchmark inflation for each of these models. That being said, we would expect a higher exact match rate to be strongly correlated with a larger benchmark inflation; this does not immediately seem to be the case, but three datapoints is not enough to make any meaningful conclusions. We leave exploration of the relationship between these two metrics to future work.

**Table 3: Benchmark Inflation and Exact Match Rate**
| Model | BI (pp) | EM |
| --- | --- | --- |
| GPT-3.5 / ChatGPT | 13.1 | 10% |
| GPT-4 | 11.1 | 12% |
| Mistral 7B | 8.5 | 15% |

### 3.3 Why are Retro-holdouts Necessary?

Creating a retro-holdout dataset is resource intensive, demanding large amounts of time from human experts for dataset iteration, as well as considerable computational resources for validation. However, it is necessary to confirm that a newly created dataset assesses precisely the same task as its corresponding public benchmark.
Explicit and robust confirmation of benchmark inflation establishes that, in the absence of meaningful evaluation oversight, model developers will game evaluations.

Current data practices mandate a framework like retro-holdout to thoroughly justify this claim, but shifts in data use and sharing could make retro-holdouts obsolete. One solution could be for dataset developers to withhold a portion of their data from public release, routinely compare model performance on the public and private splits, and decommission the benchmark once statistically significant benchmark inflation is measured. While this is promising in theory, it places substantial burden on dataset developers; there is no platform that can easily facilitate such a process.

We also note that LLMs were not used for any aspect of dataset development to ensure that the resulting dataset, Retro-Misconceptions, has not incurred any model bias, establishing a true baseline for the retro-holdout framework. That said, LLM assistance could automate multiple time consuming steps of our process, substantially decreasing the time required to create a retro-holdout.

### 3.4 Limitations

In order to establish that evaluation gaming is occurring, one should conclusively demonstrate that there exists at least one dataset where there is sizable benchmark inflation. Accordingly, we have prioritized eliminating other confounding factors, rather than applying our approach to many datasets. Capacity constraints, coupled with our team’s conviction to prevent LLMs from biasing our results, the retro-holdout framework has been conducted on only one dataset: the Non-Adversarial Type of TruthfulQA. Though we have designed the process to apply to any supervised text dataset, we cannot yet guarantee the generality of our process.

The assumption that the retro-holdout dataset and the target dataset are drawn from the same distribution may not always be valid. This assumption is challenged if the target dataset itself is subject to distribution shifts over time; such shifts can alter the underlying data characteristics. Additionally, matching a target dataset introduces its own concerns. While this method ensures that the retro-holdout dataset resembles the target dataset as closely as possible, it also perpetuates any biases present in the target dataset.

## 4 Related Works

Development of LLMs continues to outpace the advancement of evaluation methods, raising concern about benchmark integrity (Chang et al., ). Test data are frequently misused during an LLM’s training process. Data contamination, where test data is included in training sets, results in models “cheating” by memorizing tests rather than generalizing (Marie, ). Optimizing against these data can also result in indirect over-fitting, such that models perform well on the benchmarks without learning the underlying task (Ng, ). No standard methodology exists to detect this issue (Alzahrani et al., ), yet data quality remains undervalued and under-incentivized (Sambasivan et al., ). High benchmark scores are highly desirable, promoting practices that compromise data quality and evaluation integrity.

Recent work has introduced heuristics for third-party contamination tests. Sainz et al. () propose a technique to detect test set contamination by eliciting reproduction of specific test set examples. Golchin and Surdeanu () suggest a method for identifying contamination in black-box models by comparing the similarity between model completions of randomly selected example prefixes and the actual data using GPT-4. Concurrent work by Zhang et al. () is notable for its use of a dataset extension, a concept similar to our approach. Their benchmark, GSM1k, reports accuracy drops of up to 13%, highlighting a positive correlation between memorization and performance gaps. We test their dataset with our tests in Appendix H, finding evidence that GSM1k is not sufficiently indistinguishable from GSM8k.

It is well known that metrics lose their predictive power when incentives are attached to them (Goodhart, ; Strathern, ; Karwowski et al., ). As Thomas and Uminsky () state, ”overemphasizing metrics leads to manipulation, gaming, a myopic focus on short-term goals, and other unexpected negative consequences.”
Current AI risk metrics fail to address emerging failure modes (Khlaaf, ), and Privitera et al. () emphasize that high benchmark scores do not necessarily equate to effective real-world performance.

Empirical findings highlight the necessity for immediate structural reforms in AI research and development to prioritize and encourage data quality (Sambasivan et al., ). Recent calls for a science of evaluations underscore the urgent need for rigorous evaluation frameworks to inform policy and ensure responsible AI development (Bommasani et al., ; Research, ).

## 5 Conclusion

In this work, we systematically investigated the impact of evaluation gaming on benchmark scores for large language models. We find that evaluation gaming is undeniably occurring, with model accuracy falling by up to 16 percentage points when assessed with an unpublished dataset.
Benchmark inflation is found in both API models, including OpenAI’s GPT and Antrophic’s Claude, as well as open-release models such as Mistral, Gemma, and Phi-2. This slightly contrasts with the findings of Zhang et al. (), who saw performance gaps for open-release models, but found the API models less problematic.

Our results demonstrate that LLM benchmark scores should not be taken at face value when evaluation data has been publicly available for some time. We hope that our work reminds model developers the importance of understanding training data, and motivates future dataset developers to consider their options when releasing new benchmarks. Options for future investigation include experimentation with dataset release and verification practices, and evaluation methods which are not undermined by public data, such as the methods presented by Li et al. ().

The retro-holdout framework, designed to be generally applicable across various public benchmark evaluations, provides tools that significantly enhance the accuracy and reliability of model evaluations, offering a practical path forward for the field.

## Appendices

## Appendix A Hold-out Testing Formalization

In this appendix, we will define what it means that a retroactively constructed dataset could have been a holdout set for a public dataset, as well as how this can be formalized and statistically tested.

We define a labeled dataset $D$ as a set of tuples $(x,y)\in\mathcal{X}\times\mathcal{Y}$ for some domains $\mathcal{X},\mathcal{Y}$. Given a function $f:\mathcal{X}\rightarrow\mathcal{Y}$, we define its accuracy as $\textrm{Acc}_{D}(f)\overset{\textrm{def}}{=}\mathbb{E}_{(x,y)\sim D}\left[1\{f(x)=y\}\right]$. We rely on the standard assumption in machine learning that a constructed dataset consists of i.i.d. samples from some distribution (Hastie et al., ; Shalev-Shwartz and Ben-David, ).

Given a dataset $D$, we define a public-holdout split of sizes $n_{\textrm{p}},|D|-n_{\textrm{p}}$ as the random variables $\textbf{D}_{\textrm{p}},\textbf{D}_{\textrm{h}}$ where $\textbf{D}_{\textrm{p}}$ is a random subset of $D$ of size $n_{p}$ such that $\textbf{D}_{\textrm{h}}\uplus\textbf{D}_{\textrm{p}}=D$. We also say that $\textbf{D}_{\textrm{h}}$ is a holdout set for $\textbf{D}_{\textrm{p}}$.

In contrast to the regular setting, we can not assume that all of $D$ has been drawn independently from the same distribution. Instead, $\textbf{D}_{\textrm{p}}$ and $\textbf{D}_{\textrm{h}}$ were constructed separately. Hence, we have $\textbf{D}_{\textrm{p}}\sim\mathcal{D}_{\textrm{p}}^{n_{\textrm{p}}}$, $\textbf{D}_{\textrm{h}}\sim\mathcal{D}_{\textrm{h}}^{n_{\textrm{h}}}$ for some distributions $\mathcal{D}_{\textrm{p}},\mathcal{D}_{\textrm{h}}$. The claim that we want to show is that for our retro holdout dataset, $\mathcal{D}_{\textrm{p}}=\mathcal{D}_{\textrm{h}}$. We will design a number of statistical tests to attempt to reject this hypothesis. We will both employ various binomial tests for this, as well as a permutation test.

Notably, the expected accuracy on both sets are statistically close, provided that a function $f$ is independent of these samples. E.g. a basic bound follows from given 99.5% confidence intervals $\mathrm{P}(|\textrm{Acc}_{D_{p}}(f)-\textrm{Acc}_{D}(f)|\leq u_{p})$ and $\mathrm{P}(|\textrm{Acc}_{D_{h}}(f)-\textrm{Acc}_{D}(f)|\leq u_{h})$, a 99% confidence bound on the difference between the public and hold-out accuracy is naturally the sum $u_{p}+u_{h}$.

Hence, given that one can show that the retro holdout dataset could have been drawn from the same distribution as the public dataset, and the difference in the accuracies is greater than some bound, then the remaining difference must be due to direct or indirect exposure to the public data.

### A.1 Permutation Tests

Given two sets $A_{i}\subseteq(\mathcal{X}\times\mathcal{Y})^{|A_{i}|}$ for $i=1,2$, and a test statistic $g:(\mathcal{X}\times\mathcal{Y})^{|A_{1}|+|A_{2}|}\rightarrow\mathbb{R}$ which is invariant under permutation of the first $|A_{1}|$ elements as well as the last $|A_{2}|$ elements, and where $A_{i}\sim\mathcal{D}_{i}^{|A_{i}|}$ for some distributions $\mathcal{D}_{i}$, a permutation test is a test for the null hypothesis that $\mathcal{D}_{1}=\mathcal{D}_{2}$.

The $p$-value of a permutation test is the probability that the test statistic $g$ is at least as extreme as the observed value under the null hypothesis. That is, let $\pi_{1},\ldots,\pi_{m}$ be all permutations of $A_{1}\uplus A_{2}$ and for a permutation $\pi$, let $\textbf{A}_{1,\pi},\textbf{A}_{2,\pi}$ be the first $|A_{1}|$ and last $|A_{2}|$ elements of $\pi$. Let the average statistic be $\bar{g}=\mathbb{E}_{\pi}\left[g(\textbf{A}_{1,\pi},\textbf{A}_{2,\pi})\right]$. Then the two-sided $p$-value for the null hypothesis given the observed statistic $g(A_{1},A_{2})$ is $\textrm{P}_{\pi}(|g(A_{1},A_{2})-\bar{g}|\leq|g(\textbf{A}_{1,\pi},\textbf{A}_{2,\pi})-\bar{g}|)$.

Since the number of permutations can be large, one can use a Monte Carlo approximation to estimate the $p$-value through sampling (Dwass, ). If $N$ independent samples produce a $p$-value estimate of $\hat{p}$, then a 99% confidence interval for the $p$-value is given by $\hat{p}\pm 2.807\cdot\hat{p}(1-\hat{p})/\sqrt{N}$.

## Appendix B Semantic Embeddings

We use an embedding model, specifically [all-mpnet-base-v2](https://huggingface.co/sentence-transformers/all-mpnet-base-v2), through the HuggingFace [Sentence Transformers](https://sbert.net) library, to create vector representations of each entry (Reimers and Gurevych, ). We define an entry as a question from the dataset terminated with “?/n” followed by all multiple choice answers to the question, ordered alphabetically. Each multiple choice answer is separated with “/n”. The resulting vectors are referred to as *embeddings*. Similarity was computed with cosine similarity and not dot product.

## Appendix C Evaluation Details

### C.1 Evaluation Harness

All models are first provided the prompt shown in LABEL:lst:response, with options provided in alphabetical order. Model output is normalized by removing all leading and trailing whitespaces, and taking only the first line of the response. This step is necessary, as some models have a tendency to add additional questions after their answer.

If the model output matches any of the options provided, the choice is recorded. Otherwise, the model is provided the prompt seen in LABEL:lst:index-number, and the output is normalized. If the model output matches any index present in the prompt, the response is recorded.

If the model output matches any of the options provided, the choice is recorded. Otherwise, the model is provided the prompt seen in LABEL:lst:index-letter, and the output is normalized. If the model output matches any index present in the prompt, the response is recorded.

This process is then repeated with option ordering shifted by one. To ensure consistency, responses are resampled a minimum of five times, and until one option has been selected at least three additional times over all alternatives. If no option meets this criteria after 100 attempts, the first top-selected option is used.

For the Difficulty Similarity test, we use additional variants of this prompt that include some combination of few-shot examples, and the inclusion of the “helpful prompt” from Lin et al. ().

### C.2 Prompts

Figure: Listing 1: Evaluation Prompt - Response Generation

Figure: Listing 2: Evaluation Prompt - Number Index Generation

Figure: Listing 3: Evaluation Prompt - Letter Index Generation

### C.3 Compute

Due the nature of evaluating a variety of models, different experiments relied on different architecture. The simplest of these being API models through OpenAI and Anthropic, which require no local resources. Other models were primarily hosted by Hugging Face. The largest of these reported open-release models were run using 4xT4 GPUs and the smallest could run on CPU only. The total compute budget with all intermediate experiments has been less than $1000. Evaluating a single model has cost between $1 and $50. Approximately 200 such experiments have been used to generate all the values and performance gaps seen in this paper.

## Appendix D Guide for Initial retro Creation

As mentioned in §2.2, the initial methodology for crafting the retro should ideally be very similar to the process documented for the target.

Prior to starting initial creation, each member of the team should be able to do the following:

- •
Describe the capability, and/or failure mode that the evaluation is attempting to assess in one sentence.
- •
Understand the different ways that the benchmark entries could be sorted, and consider treating individual subsets as independent target datasets. The ability to group items in meaningful sub-categories will be useful during iteration.
–
Does the benchmark already have some form of metadata that can be leveraged? If so, understand the differences between these classifications. For example, our team made progress on individual categories of the TruthfulQA dataset, achieving sufficient similarity for each independently before getting the entire datasets to meet this standard.
–
Can the difficulty of a question be categorized and/or quantified in any way? If so, write down the dimensions and subsets for each. For example, GSM8k has questions that require between 1 and 8 mathematical operations to answer correctly.
- •
Identify at least 3 high level patterns within the dataset. The following are examples from TruthfulQA:
–
Entries are mostly probing unique pieces of knowledge; as a result, our new entries should be unique with respect to both its own entries, and the entries in the original TruthfulQA dataset.
–
Entries often provide multiple possible responses that are quite similar.
–
The dataset is biased towards western civilization. There are many entries which include references to misconceptions, products, or cultural phenomena that are much more prevalent in the west, while there are almost none that are unique to other regions.
–
Within categories there are often a few highly formulaic entries, which use almost identical questions and responses.
–
The precise failure mode that is being targeted varies between categories.
- •
Identify at least 3 low-level patterns within the dataset. The following are examples from TruthfulQA:
–
Many prompt questions begin with the word “What”, and a large subset of those start with the phrase “What happens if”.
–
The phrase “I have no comment.” appears frequently as a response, and it is almost always the correct response when it is included.
–
The United States is mentioned substantially more than any other country within the dataset.
–
Many responses begin with either “Yes,” or “No,”.
- •
Record the date that the original dataset was released, and estimate the timeframe during which it was created.
–
If the dataset has any cultural references, we will want to make sure we do not incorporate any that originated after the datasets release.
–
Similarly, if there have been any scientific discoveries, methods, or paradigm shifts since the creation of the dataset, they cannot be included in this extension. For example, if a new “Fundamental Theorem of X” had been discovered and popularized since the release of the TruthfulQA dataset, we would not want to include that text anywhere in our new dataset.
- •
Are there mistakes in the original dataset? How often do they appear, and are they always similar kinds of mistakes? The new dataset should also contain similar mistakes.

For some datasets, it may be possible to begin entry creation immediately after completing these steps. Benchmarks which incorporate knowledge, such as TruthfulQA, are more difficult to create entries for, as they require unique pieces of factually correct information. For these trivia-style benchmarks, we recommend collecting many sources that can be pulled from prior to beginning entry creation. We believe that collecting trivia beforehand creating entries improves overall efficiency and entry similarity.

Before creating entries for the entire dataset, we strongly recommend creating a sufficiently indistinguishable retro for one of the larger subsets of the benchmark, e.g. the Misconceptions category of TruthfulQA. A guide for the iterative process is provided in Appendix E. This step will provide key insights on time required, difficulties, and strategies that can be leveraged for the remaining entries. For subsequent entries, we still recommend working with individual subsets. We found that doing so made replicable patterns easier to identify, and progress more measurable.

To promote similarity between individual entries, draw an example entry from target at random, without replacement, and use it as the basis for the new entry. Attempt to match the topic of the entry as closely as possible without directly replicating it. For both question prompt and possible responses, keep syntactic structure similar whenever possible.

It is highly unlikely your retro will pass all of the tests on the first try, especially for trivia-based benchmarks. Try not to spend significant amounts of time on a given entry.

## Appendix E retro Iteration

Sufficient indistinguishability is likely to take many iterations to reach for a given dataset. In this appendix we outline the various tools we have created, how they are useful, and different techniques we used to make progress towards passing our tests.

When iterating, it is important to keep the following in mind:

- •
Do not lose sight of the failure mode that the initial benchmark was attempting to assess.
–
For example, TruthfulQA’s failure mode can be summarized as will models generate factual inaccuracies because they are prevalent in the training data? If our benchmarks pass our sufficient indistinguishability tests, but no longer assess this statement, we have not created a retro-holdout.
- •
It is easy to make three of more small modifications to a single sentence for varying reasons; double check that the sentence actually makes sense, and sounds natural (or rather, as natural as the original dataset).
–
For non-native speakers, this step can be particularly difficult. If possible, have another person who did not make modifications to the entry verify that the final version makes sense.
- •
Number of possible responses is particularly valuable to match, as this is likely to improve performance on the Prediction Accuracy and Difficulty Similarity tests.

### E.1 Fine-Tuned Prediction Model Attention

This tool is similar to our Prediction Accuracy test, as it uses a similar process to obtain a BERT model (Devlin et al., ) which has been fine-tuned to classify entries as either target or retro. [Transformers Interpret](https://pypi.org/project/transformers-interpret/), a library based on integrated gradients for explaining model output attribution (Sundararajan et al., ) is then leveraged to identify which input tokens the model considered most relevant when differentiating between target and retro. An example output is provided in Figure 6.

While the BERT classifier itself is difficult to trick, this tool was not as useful as we had initially anticipated. Frequently, high attribution would be assigned to terminating periods, instead of intermediary tokens. This discovery led us to the more concrete method of comparing 1- and 2-gram token frequencies between target and retro.

There are two meaningful frequencies to count: (i) total frequency of the n-gram, and (ii) number of entries in which the n-gram appears at least once. Some entries repeat the same n-gram many times because the responses are highly similar.

Figure: Figure 6: Example attributions of the fine-tuned classifier. The color saturation of each token corresponds to its impact on the final classification where the presence of green tokens contribute to the classification and red detracts.
Refer to caption: prediction-accuracy_example.png

### E.2 Datapoint Embeddings

Embedding vector representations of each datapoint, as described in Appendix B, are used as the basis for the following three tools; when analyzed in conjunction they can provide meaningful insights on general similarity trends, outlier detection, and topic clustering.

##### Embedding Space Visualization.

Uniform Manifold Approximation and Projection (UMAP) is used to project our embedding vectors onto a two-dimensional plane (McInnes et al., ). Each point on the plot is color coded according to its set, and corresponds to a unique entry within that set. Clustering indicates entries are highly similar, with topical relevancy having a substantial impact on distance between points on the projection. This tool is useful for finding gaps or difference in coverage of topics. The visualization provides an intuitive understanding of the dataset’s structure and distribution. An example output of this visualization tool is provided in Figure 7.

##### Internal Cosine Similarity Distribution.

To assess similarity between entries within the datasets we plot histograms of pairwise cosine similarities of datapoint embeddings. This representation aids in identifying outliers and assessing overall similarity within the datasets. Figure 3 depicts an early iteration of our two datasets. We note that the retro is systematically less internally similar than the target, in addition to having fewer entry pairings with very high similarity.

Figure: (a) TruthfulQA Misconceptions vs. Retro-Misconceptions
Refer to caption: x5.png

##### Largest Internal Cosine Similarity Comparison.

To determine how similar the most similar entries should be, this tool displays the ten entry pairs within each dataset with the highest cosine similarities. This provides a direct comparison of the most similar entries and their respective values. Cosine similarities between two entry pairings from the TruthfulQA dataset are provided in Figure 8.

Figure: Figure 8: Two example cosine similarities between entries in the TruthfulQA dataset. Question are truncated for display purposes, but were included when entry embeddings were calculated.

## Appendix F Human Indistinguishability

Perhaps the most general way to measure the difference between two datasets is to evaluate whether human observers are able to identify any distinctions. Therefore, we recruited a number of annotators via the crowd-sourcing platform [Prolific](https://www.prolific.com). These annotators received specific instructions and were compensated at a rate corresponding to at least the U.S. minimum wage. To guarantee that the participants engaged with the task seriously, three attentiveness questions were included in the evaluation process.

An annotator is provided the following written instructions:

Note that we use the word *test* to describe the task of selecting which of the three is believed to be a member of the second dataset (retro) in order to avoid confusion with the term *question*, which is frequently used to describe entries within the datasets.

Following this set of instructions, the annotator is provided with ten random entries from the target and another ten random entries from the retro; all twenty entries are drawn without replacement and labeled correctly.
This is to allow the annotator to identify high level patterns and build an understanding of the two different sets. Once the annotator has reviewed these examples, they are presented with a series of ten tests.

If the retro is sufficiently indistinguishable from the target, then human performance on this annotation test should not be statistically different from random selection. For our results, a total of twenty three approved participants answered a total of 230 tests.

## Appendix G Similarity of Difficulty

The Similarity of Difficulty test determines whether language models which could not have been influenced by the target perform similarly on both the target and the retro. This requires we use only models which were developed prior to the release date of target, but there are a number of obstacles when working with these pre-release models.

First, availability of pre-release models is not a given, as older closed-source models are not maintained for long. As more capable models become available, closed source developers are incentivized to discontinue access to the older models due to maintenance costs. This has a profound impact on researchers, as studies might rely on older models for various reasons, such as for baselines or improvement analysis. With frontier model developers now releasing API access to models multiple orders of magnitude larger than their predecessors, which were deemed too dangerous for transparency (Brown et al., ), perhaps it would make sense for them to turn the retirees over to the Open Source community.

Second, older models are not as capable as newer ones. Over a certain difficulty threshold, pre-release performance is likely to match for two datasets, regardless of the actual difficulty profile. Take an example of an elementary school student being given two assessments, one covering k-12 math, and the other on k-8 and university level math. Though these two tests clearly have differing difficulty profiles, we can expect that the student will perform similarly on both. To address this, we use various techniques to enhance the capabilities of the pre-release models. If our retro is indeed sufficiently indistinguishable from target, then the models’ performance on the two datasets should be similar, irrespective of the capability boost technique being used.

## Appendix H Contemporaneous Work

Coinciding with our efforts, Zhang et al. () introduce the GSM1k dataset for assessing mathematical reasoning. This study employs several human tests to ensure an “apples-to-apples” similarity to their target dataset GSM8k (Zhang et al., ; Cobbe et al., ). Similar to our findings, Zhang et al. () report an overperformance by many models on their target evaluations.

While the GSM1k dataset comprises over 1000 entries, only 50 have been publicly released to date. Zhang et al. () recognize that releasing the entire dataset will likely result in the same data leakage current benchmark suffer from. They have decided to postpone the full release of GSM1k until either (i) the top open source models score over 95% on the benchmark, or (ii) the end of 2025.

We took the 50 published questions from their dataset, henceforth referred to as GSM1k50, and examined them using the same methods as we did for Retro-Misconceptions. In these assessments, target is the test split of GSM8k, which contains 1319 questions, while retro is GSM1k50.

Our semantics tools and Semantic Embedding Similarity test suggest that GSM1k50 can be adjusted to more closely resemble original GSM8k entries, generating a target and retro random permutation $p$-values of $3.02\pm 0.05\%$ and $98.7\pm 0.02\%$, respectively. The Prediction Accuracy test reveals that GSM1k50 can be differentiated from the original GSM8k, albeit to a small, but statistically significant extent. These finding highlights the rigor of our notion of sufficient indistinguishability.

Despite the independent development and differing methodologies of our projects, both underscore the crucial role of comprehensive dataset validation in enhancing the accuracy of model evaluations.

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 3
presentation: 2
questions: - From line 112 to line 113 and line 258, citation format should be changed from \citet to \citep

- Regarding Figure 2, the authors need to specify which example they used in their analysis. Without clear example details, the distribution alone is insufficient to validate their claim.

- The claim on lines 160-161 that benchmark data after a model's cutoff date cannot be contaminated is inaccurate. Benchmarks built from internet sources can still be indirectly contaminated. For example, TruthfulQA, although created after certain model cutoff dates, draws from Wikipedia content. Since proprietary models are often pretrained on Wikipedia, the benchmark could still be contaminated despite its creation date.
soundness: 2
strengths: - There research topic is important for fair evaluation in large language models.
- We need dynamic eval for preventing data contamination.
summary: This paper introduce a criterion to create hold-out set for benchmark data to investigate data contamination issues. They introduce four rigorous tests to validate these retro-holdouts. Applying their method to TruthfulQA, they evaluated 20 LLMs and discovered significant performance gaps, with some models showing score inflation of up to 16 percentage points. This reveals that public benchmark scores often don't accurately reflect real model capabilities.
weaknesses: - The basic logistics require better clarification. While language models trained on next-token prediction are naturally sensitive to different formats (as evidenced by the *reversal curse*), the paper should better distinguish between this inherent next-token prediction capability and true robustness to format perturbations and contamination.

- The four perspectives presented are not all equally justified. There is significant overlap between the first two perspectives, as both rely on model accuracy to assess dataset difficulty. Additionally, the human testing perspective, while valuable, is not scalable for wider benchmark applications since it's impractical to recruit human annotators for every hold-out set.

- The discussion of benchmarks is too narrow, focusing primarily on TruthfulQA. This limited scope may be a consequence of the unscalable human testing requirement in the study design. Furthermore, since TruthfulQA is rarely used in evaluating current frontier LLMs, it would be beneficial to include analyses of additional, more widely-used benchmarks.

---

confidence: 5
contribution: 2
initial_rating: 3
presentation: 2
questions: - Could the authors clarify how the retro-holdout's interpretability compares to traditional n-gram methods, and are there plans to benchmark against them?

- Given the computational demands, what practical applications do the authors envision for the retro-holdout framework?

- Would the authors consider publishing their experimental code to support transparency and facilitate reproducibility?
soundness: 2
strengths: The paper addresses a critical issue in AI evaluation by introducing a new methodology for retro-holdout dataset construction, which could significantly impact LLM benchmark validity. This novel approach to data contamination is a creative response to the challenge of black-box model evaluation, providing a framework that could be applied across different benchmarks. The paper demonstrates thoroughness in validating retro-holdout indistinguishability through multiple statistical tests, contributing meaningfully to ongoing discussions around data integrity in LLMs research.
summary: The paper introduces a retro-holdout framework to assess benchmark reliability for LLMs by retroactively constructing datasets (e.g., Retro-Misconceptions for TruthfulQA) that can reveal evaluation inflation due to data contamination. The study evaluates several LLMs and highlights the importance of reliable data practices in ensuring that benchmark scores reflect real-world model capabilities rather than inflated metrics.
weaknesses: I think the paper faces challenges in terms of interpretability and practicality. The retro-holdout methodology, while innovative, remains a black-box model that relies on side metrics such as similarity and precision, which may not fully establish reliability. Moreover, the method’s practical relevance is questionable, as it appears computationally intensive and possibly detached from current LLM data contamination mitigation strategies. Additionally, the lack of comparison with established methods, such as the widely used n-gram approach, leaves readers without a clear sense of this method's relative effectiveness.

References:
1. Yupeng Chang, Xu Wang, Jindong Wang, Yuan Wu, Linyi Yang, Kaijie Zhu, Hao Chen, Xiaoyuan Yi, Cunxiang Wang, Yidong Wang, Wei Ye, Yue Zhang, Yi Chang, Philip S. Yu, Qiang Yang, and Xing Xie. 2024. A Survey on Evaluation of Large Language Models. ACM Trans. Intell. Syst. Technol. 15, 3.
2. Cheng Xu, Shuhao Guan, Derek Greene, and M-Tahar Kechadi. 2024. Benchmark data contamination of large language models: A survey. arXiv:2406.04244.
3. Chunyuan Deng, Yilun Zhao, Yuzhao Heng, Yitong Li, Jiannan Cao, Xiangru Tang, and Arman Cohan. 2024. Unveiling the Spectrum of Data Contamination in Language Model: A Survey from Detection to Remediation. ACL 2024 Findings.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: 1. How many iterations does it takes to make the holdout set for the misconceptions category of TruthfulQA pass the four tests?
2. How many samples do you create for the holdout set?
3. Could you provide some examples of data in the holdout set?
4. Different datasets may be created in vary different ways. How can the proposed approach generalize to other datasets?
5. How did you select the four tests? Did you try other criteria?
6. How does the tools help create the holdout set? Did you compare the difference between using and without using those tools?
soundness: 3
strengths: 1. The paper is well written.
2. This paper propose a way to create a holdout set of a target dataset, which is important as many public benchmarks have been included in training data.
3. The proposed holdout set for TruthfulQA could be beneficial for future research to accurately benchmark models.
summary: This paper proposed a way to retrospectively create a holdout set for a target dataset to benchmark models more accurately. The authors introduce four statistical tests to ensure the holdout set and the target dataset are sufficiently indistinguishable. They also introduce some tools to help iteratively create the holdout set to pass the statistical tests. With this approach, the authors create a holdout set for the misconceptions category of the TruthfulQA dataset, using it to calculate models' performance gap between evaluating on the original TruthfulQA and on the holdout set. The result shows that most models suffer from benchmark inflation, indicated by a large performance gap, suggesting that the TruthfulQA dataset have been included in the training data to some extent, and highlighting the need of holdout sets.
weaknesses: 1. The authors did not provide much details about the holdout set for TruthfulQA they created. For example, the size of the holdout set and the number of iterations to pass the four tests.
2. The authors introduced some tools to help create the holdout set. However, they did not provide empirical evidence to show how these tool work.
3. The authors only demonstrate their approach on a category of TruthfulQA. It is unclear whether the approach can be applied to other datasets.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 2
questions: See weaknesses
soundness: 3
strengths: 1. The paper highlighted the importance of a holdout set and introduced an effective method for creating one, along with several testing approaches.
2. The paper presented contamination results for 20 popular LLMs.
3. The testing method for indistinguishability was highly rigorous and comprehensive.
summary: The paper highlighted the importance of a holdout set for evaluating LLMs, which inspired the author to propose a method for creating such a set, along with a series of tests to ensure its indistinguishability. An adequately constructed holdout set can help detect whether a benchmark has been contaminated. The experiments demonstrated the effectiveness of their holdout set on TruthfulQA and revealed contamination in 20 popular LLMs.
weaknesses: 1. The experimental dataset is quite limited, consisting only of the truthful QA dataset. It could be expanded to include more diverse and widely-used datasets, such as Open QA, rather than just multiple-choice QA.
2. The method used to create the holdout set is crucial to this paper and should be thoroughly explained in the main section. In its current form, the process isn't clear from the text. I recommend including a diagram or algorithm to better illustrate this process.
3. The paper "benbench" [1] also evaluates contamination across a wide range of LLMs, and should be referenced in your related works.
4. The paper lacks the meta-evaluation to verify the effectiveness of this method and the compression with other contamination detection methods like MinK [2].

[1] Benchmarking Benchmark Leakage in Large Language Models. https://arxiv.org/abs/2404.18824

[2] Detecting Pretraining Data from Large Language Models. https://arxiv.org/abs/2310.16789

Meta-review: The paper introduces a retro-holdout framework to assess benchmark reliability for LLMs, which is an interesting and relevant topic in LLM evaluation. Experiments were conducted on 20 popular LLMs to demonstrate its effectiveness. However, reviewers have raised several concerns, including unclear dataset construction and the use of a limited experimental dataset. As a result, the current version of the work does not meet the acceptance threshold.

Decision: Reject