The Ladder: A Reliable Leaderboard for Machine Learning Competitions

Introduction

Machine learning competitions have become an extremely popular format for solving prediction and classification problems of all kinds. A number of companies such as Netflix have organized major competitions in the past and some start-ups like Kaggle specialize in hosting machine learning competitions. In a typical competition hundreds of participants will compete for prize money by repeatedly submitting classifiers to the host in an attempt to improve on their previously best score. The score reflects the performance of the classifier on some subset of the data, which are typically partitioned into two sets: a training set and a test set. The training set is publicly available with both the individual instances and their corresponding class labels. The test set is publicly available as well, but the class labels are withheld. Predicting these missing class labels is the goal of the participant and a valid submission is simply a list of labels—one for each point in the test set.

The central component of any competition is the leaderboard which ranks all teams in the competition by the score of their best submission. This leads to the fundamental problem of maintaining a leaderboard that accurately reflects the true strength of a classifier. What makes this problem so challenging is that participants may begin to incorporate the feedback from the leaderboard into the design of their classifier thus creating a dependence between the classifier and the data on which it is evaluated. In such cases, it is well known that the holdout set no longer gives an unbiased estimate of the classifier’s true performance. To counteract this problem, existing solutions such as the one used by Kaggle further partition the test set into two parts. One part of the test set is used for computing scores on the public leaderboard. The other is used to rank all submissions after the competition ended. This final ranking is often referred to as the private leaderboard. While this solution increases the quality of the private leaderboard, it does not address the problem of maintaining accuracy on the public leaderboard. Indeed, numerous posts on the forums of Kaggle report on the problem of “overfitting to the holdout” meaning that some scores on the public leaderboard are inflated compared to final scores. To mitigate this problem Kaggle primarily restricts the rate of re-submission and to some extent the numerical precision of the released scores.

Yet, in spite of its obvious importance, there is relatively little theory on how to design a leaderboard with rigorous quality guarantees. Basic questions remain difficult to assess, such as, can we a priori quantify how accurate existing leaderboard mechanisms are and can we design better methods?

While the theory of estimating the true loss of a classifier or set of classifiers from a finite sample is decades old, much of theory breaks down due to the sequential and adaptive nature of the estimation problem that arises when maintaining a leaderboard. First of all, there is no a priori understanding of which learning algorithms are going to be used, the complexity of the classifiers they are producing, and how many submissions there are going to be. Indeed, submissions are just a list of labels and do not even specify how these labels were obtained. Second, any submission might incorporate statistical information about the withheld class labels that was revealed by the score of previous submissions. In such cases, the public leaderboard may no longer provide an unbiased estimate of the true score. To make matters worse, very recent results suggest that maintaining accurate estimates on a sequence of many adaptively chosen classifiers may be computationally intractable [HU, SU].

We introduce a notion of accuracy called leaderboard accuracy tailored to the format of a competition. Intuitively, high leaderboard accuracy entails that each score represented on the leaderboard is close to the true score of the corresponding classifier on the unknown distribution from which the data were drawn. Our primary theoretical contributions are the following.

We show that there is a simple and natural algorithm we call Ladder that achieves high leaderboard accuracy in a fully adaptive model of estimation in which we place no restrictions on the data analyst whatsoever. In fact, we don’t even limit the number of submissions an analyst can make. Formally, our worst-case upper bound shows that if we normalize scores to be in $$the maximum error of our algorithm on any estimate is never worse than$O((\log(k)/n)^{1/3})$where$k$is the number of submissions and$n$is the size of the data used to compute the leaderboard. In contrast, we observe that the error of the Kaggle mechanism (and similar solutions) scales with the number of submissions as$\sqrt{k}$so that our algorithm features an exponential improvement in$k$.

We also prove an information-theoretic lower bound on the leaderboard accuracy demonstrating that no estimator can achieve error smaller than $\Omega((\log(k)/n)^{1/2}).$

Complementing our theoretical worst-case upper bound and lower bound, we make a number of practical contributions:

We provide a parameter-free variant of our algorithm that can be deployed in a real competition with no tuning required whatsoever.

To demonstrate the strength of our parameter-free algorithm we conduct two opposing experiments. The first is an adversarial—yet practical—attack on the leaderboard that aims to create as much of a bias as possible with a given number of submissions. We compare the performance of the Kaggle mechanism to that of the Ladder mechanism under this attack. We observe that the accuracy of the Kaggle mechanism diminishes rapidly with the number of submissions, while our algorithm encounters only a small bias in its estimates.

In a second experiment, we evaluate our algorithm on real submission files from a Kaggle competition. The data set presents a difficult benchmark as little overfitting occurred and the errors of the Kaggle leaderboard were generally within the expected statistical deviations given the properties of the data set. Even on this benchmark our algorithm produced a leaderboard that is very close to that computed by Kaggle. Through a sequence of significance tests we assess that the differences between the two leaderboards on this competition are not statistically significant.

In summary, our algorithm supports strong theoretical results while suggesting a simple and practical solution. Importantly, it is one and the same parameter-free algorithm that withstands our adversarial attack and simultaneously achieves high utility in a real Kaggle competition.

An important aspect of our algorithm is that it only releases a score to the participant if the score presents a statistically significant improvement over the previously best submission of the participant. Intuitively, this prevents the participant from exploiting or overfitting to minor fluctuations in the observed score values.

2 Related Work

There is a vast literature on preventing overfitting in the context of model assessment and selection. See, for example, Chapter 7 of [HTF] for background. Two particularly popular practical approaches are various forms of cross-validation and bootstrapping. It is important to note though that when scoring a submission for the leaderboard, neither of these techniques applies. One problem is that participants submit only a list of labels and not the corresponding learning algorithms. In particular, the organizer of the competition has no means of retraining the model on a different split of the data. Similarly, the natural bootstrap estimate of the expected loss of a classifier given a finite sample is simply the empirical average of the loss on the finite sample, which is what existing solutions release anyway. The other substantial obstacle is that even if these methods applied, their theoretical guarantees in the adaptive setting of estimation are largely not understood.

This bound readily implies a corresponding result for leaderboard accuracy albeit worse than the one we show. One issue is that this algorithm requires the entire test set to be withheld and not just the labels as is required in the Kaggle application. The bigger obstacle is that the algorithm is unfortunately not computationally efficient and this is inherent. In fact, no computationally efficient algorithm can give non-trivial error on $k>n^{2+o(1)}$ adaptively chosen functions as was shown recently [HU, SU] under a standard computational hardness assumption.

Matching this hardness result, there is a computationally efficient algorithm in [DFH+] that achieves an error bound of $O(k^{1/5}\log(k)^{3/5}/n^{2/5})$ which implies a bound on leaderboard accuracy that is worse than ours for all $k>n^{1/3}.$ They also give an algorithm (called EffectiveRounds) with accuracy $O(\sqrt{r\log(k)/n})$ when the number of “rounds of adaptivity” is at most $r.$ While we do not have a bound on $r$ in our setting better than $k$The parameter $r$ corresponds to the depth of the adaptive tree we define in the proof of Theorem 3.1. While we bound the size of the tree, the depth could be as large as $k.$, the proof technique relies on sample splitting and a similar argument could be used to prove our upper bound. However, our argument does not require sample splitting and this is very important for the practical applicability of the algorithm.

We sidestep the hardness result by going to a more specialized notion of accuracy that is surprisingly still sufficient for the leaderboard application. However, it does not resolve the more general question raised in [DFH+]. In particular, we do not always provide a loss estimate for each submitted classifier, but only for those that made a significant improvement over the previous best. This seemingly innocuous change is enough to circumvent the aforementioned hardness results.

Acknowledgments

We thank Ben Hamner at Kaggle Inc., for providing us with the submission files from the Photo Quality competition, as well as many helpful discussions. We are grateful to Aaron Roth for pointing out an argument similar to that appearing in the proof of Theorem 3.1 in a different context. We thank John Duchi for many stimulating discussions.

3 Preliminaries

We assume that we are given a sample $S=\{(x_{1},y_{1}),\dots,(x_{n},y_{n})\}$ drawn i.i.d. from an unknown distribution ${\cal D}$ over $X\times Y.$ We define the empirical loss of a classifier $f$ on the sample $S$ as

Sequential and Adaptive Loss Estimation

In this section we formally define the adaptive model of estimation that we work in and present our definition of leaderboard accuracy. Given a sequence of classifiers $f_{1},\dots,f_{k}$ and a finite sample $S$ of size $n,$ a fundamental estimation problem is to compute estimates $R_{1},\dots,R_{k}$ such that

The standard way of estimating the true loss is via the empirical loss. If we assume that all functions $f_{1},\dots,f_{k}$ are fixed independently of the sample $S$, then Hoeffding’s bound and the union bound imply

In the adaptive setting, however, we assume that the classifier $f_{t}$ may be chosen as a function of the previous estimates and the previously chosen classifiers. Formally, there exists a mapping ${\cal A}$ such that for all $t\in[k]:$

We will assume for simplicity that ${\cal A}$ is a deterministic algorithm. The tuple $(f_{1},R_{1},\dots,f_{t-1},R_{t-1})$ is nevertheless a random variable due to the random sample used to compute the estimates.

Unfortunately, in the case where the choice of $f_{t}$ depends on previous estimates, we may no longer apply Hoeffding’s bound to control $R_{S}(f_{t})$. In fact, recent work [HU, SU] shows that no computationally efficient estimator can achieve error $o(1)$ on more than $n^{2+o(1)}$ adaptively chosen functions (under a standard hardness assumption). Since we’re primarily interested in a computationally efficient algorithm, these hardness results demonstrate that the goal of achieving the accuracy guarantee specified in inequality (1) is too stringent in the adaptive setting when $k$ is large. We will therefore introduce a weaker notion of accuracy called leaderboard accuracy under which we can circumvent the hardness results and nevertheless achieve a guarantee strong enough for our application.

The goal of an accurate leaderboard is to guarantee that at each step $t\leqslant k,$ the leaderboard accurately reflects the best classifier among those classifiers $f_{1},\dots,f_{k}$ submitted so far. In other words, while we do not need an accurate estimate for each $f_{t},$ we wish to maintain that the $t$-th estimate $R_{t}$ correctly reflects the minimum loss achieved by any classifier so far. This leads to the following definition.

Given an adaptively chosen sequence of classifiers $f_{1},\dots,f_{k},$ we define the leaderboard error of estimates $R_{1},\dots,R_{k}$ as

Given an algorithm that achieves high leaderboard accuracy there are two simple ways to extend it to provide a full leaderboard:

Use one instance of the algorithm for each team to maintain the best score achieved by each team.

Use one instance of the algorithm for each rank on the leaderboard. When a new submission comes in, evaluate it against each instance in descending order to determine its place on the leaderboard.

The first variant is straightforward to implement, but requires the assumption that competitors don’t use several accounts (a practice that is typically against the terms of use of a competition). The second variant is more conservative and does not need this assumption.

The Ladder Mechanism

We introduce an algorithm called the Ladder Mechanism that achieves small leaderboard accuracy. The algorithm is very simple. For each given function, it compares the empirical loss estimate of the function to the previously smallest loss. If the estimate is below the previous best by some margin, it releases the estimate and updates the best estimate. Importantly, if the estimate is not smaller by a margin, the algorithm releases the previous best loss (rather than the new estimate). A formal description follows in Figure 1.

For any sequence of adaptively chosen classifiers $f_{1},\dots,f_{k},$ the Ladder Mechanism satisfies for all $t\leqslant k$ and $\varepsilon>0,$

In particular, for some $\eta=O(n^{-1/3}\log^{1/3}(kn)),$ the Ladder Mechanism achieves with high probability,

Let ${\cal A}$ be the adaptive analyst generating the function sequence. Fix $t\leqslant k.$ The algorithm ${\cal A}$ naturally defines a rooted tree ${\cal T}$ of depth $t$ recursively defined as follows:

The root is labeled by $f_{1}={\cal A}(\emptyset).$

Each node at depth $1<i<t$ corresponds to one realization $(h_{1},r_{1},\dots,h_{i-1},r_{i-1})$ of the random variable $(f_{1},R_{1},\dots,f_{i-1},R_{i-1})$ and is labeled by $h_{i}={\cal A}(h_{1},r_{1},\dots,h_{i-1},r_{i-1}).$ Its children are defined by each possible value of the output $R_{i}$ of Ladder Mechanism on the sequence $h_{1},r_{1},\dots,r_{i-1},h_{i}.$

Let $B=(1/\eta+2)\log(4t/\eta).$ Then, $|{\cal T}|\leqslant 2^{B}.$

To prove the claim, we will uniquely encode each node in the tree using $B$ bits of information. The claim then follows directly. The compression argument is as follows. We use $\lfloor\log(t)\rfloor\leqslant\log(2t)$ bits to specify the depth of the node in the tree. We then specify the index of each $1\leqslant i\leqslant t$ for which $R_{i}\leqslant R_{i-1}-\eta$ together with the value $R_{i}.$ Note that since $R_{i}\in$ there can be at most $\lceil 1/\eta\rceil\leqslant(1/\eta)+1$ many such steps. Moreover, there are at most $\lceil 1/\eta\rceil$ many possible values for $R_{i}=[R_{S}(f_{i})]_{\eta}.$ Hence, specifying all such indices requires at most $(1/\eta+1)(\log(2/\eta)+\log(2t))$ bits. It is easy that this uniquely identifies each node in the graph, since for every index $i$ not explicitly listed we know that $R_{i}=R_{i-1}.$ The total number of bits we used is:

The theorem now follows by applying a union bound over all nodes in ${\cal T}$ and using Hoeffding’s inequality for each fixed node. Let $F$ be the set of all functions appearing in ${\cal T}.$

Moreover, it is clear that conditioned on the event that

at step $i^{*}$ where the minimum of $R_{\cal D}(f_{i})$ is attained, the Ladder Mechanism must output an estimate $R_{i^{*}}$ which is within $\varepsilon+\eta$ of $R_{\cal D}(f_{i^{*}}).$ This concludes the proof. ∎

We next show that $\Omega(\sqrt{\log(k)/n})$ is a lower bound on the best possible leaderboard accuracy that we might hope to achieve. This is true even if the functions are not adaptively chosen but fixed ahead of time.

There are classifiers $f_{1},\dots f_{k}$ and a bounded loss function for which we have the minimax lower bound

Here the infimum is taken over all estimators $R\colon X^{n}\to^{k}$ that take $n$ samples from a distribution ${\cal D}$ and produce $k$ estimates $R_{1},\dots,R_{k}=\widehat{\theta}(x_{1},\dots,x_{n}).$ The expectation is taken over $n$ samples from ${\cal D}.$

We will reduce the problem of mean estimation in a certain high-dimensional distribution family to that of obtaining small leaderboard error. Our lower bound then follows from lower bounds for the corresponding mean estimation problem.

Indeed, let $R$ be the estimator that achieves minimax leaderboard accuracy. Define the estimator $\widehat{\theta}$ as follows:

Given $x_{1},\dots,x_{n}$ compute $R_{1},\dots R_{k}=R(x_{1},\dots,x_{n}).$

Let $i$ be the first coordinate in the sequence $R_{1},\dots,R_{k}$ which is less than $1/2-\varepsilon/2.$

Output the vector $\widehat{\theta}(x_{1},\dots,x_{n})$ which is $1/2-\varepsilon$ in the $i$-th coordinate and $1/2$ everywhere else.

Finally, it is well known and follows from Fano’s inequality that for some $\varepsilon=\Omega(\sqrt{\log(k)/n}),$

where $I(V;X)$ is the mutual information between $V$ and $X.$ Moreover, it is known that

In the second inequality we used that the Kullback-Leibler divergence between a Bernoulli random variable with bias $1/2$ and another one with bias $1/2-\varepsilon$ is at most $O(\varepsilon^{2})$ for all $0<\varepsilon<1/4.$ Moreover, the Kullback-Leibler divergence of $n$ independent samples is at most $n$ times the divergence of a single sample. We conclude that

Setting $\varepsilon=c\sqrt{\log(k)/n}$ for small enough constant $c>0$ completes the proof. ∎

A parameter-free Ladder mechanism

When applying the Ladder Mechanism in practice it can be difficult to choose a fixed step size $\eta$ ahead of time that will work throughout an entire competition. We therefore now give a completely parameter-free version of our algorithm that we will use in our experiments. The algorithm adaptively finds a suitable step size based on previous submissions to the algorithm. The idea is to perform a statistical significance test to judge whether the given submission improves upon the previous one. The test is such that as the best classifier gets increasingly accurate, the step size shrinks accordingly.

The empirical loss of a classifier is the average of $n$ bounded numbers and follows a very accurate normal approximation for sufficiently large $n$ so long as the loss is not biased too much towards $0.$ In our setting, the typical loss if bounded away form so that the normal approximation is reasonable. In order to test whether the empirical loss of one classifier is significantly below the empirical loss of another classifier, it is appropriate to perform a one-sided paired $t$-test. A paired test has substantially more statistical power in settings where the loss vectors that are being compared are highly correlated as is common in a competition.

Keeping this definition in mind, our parameter-free Ladder mechanism in Figure 2 is now very natural. On top of the loss estimate, it also maintains the loss vector of the previously best classifier (starting with the trivial all zeros loss vector).

The algorithm in Figure 2 releases the estimate of $R_{S}(f_{t})$ up to an error of $1/n$ which is significantly below the typical step size of $\Omega(1/\sqrt{n}).$ Looking back at our analysis, this is not a problem since such an estimate only reveals $\log(n)$ bits of information which is the same up to constant factors as an estimate that is accurate to within $1/\sqrt{n}.$ The more critical quantity is the step size as it controls how often the algorithm releases a new estimate.

In the following sections we will show that the parameter-free Ladder mechanism achieves high accuracy both under a strong attack as well as on a real Kaggle competition.

For sufficiently large $n,$ the test statistic on the left hand side of (6) is well approximated by a Student’s $t$-distribution with $n-1$ degrees of freedom. The test performed in our algorithm at each step corresponds to refuting the null hypothesis roughly at the $0.15$ significance level.

It is important to note, however, that our use of this significance test is primarily heuristic. This is because for $t>1,$ due to the adaptive choices of the analyst, the function $f_{t}$ may in general not be independent of the sample $S.$ In such a case, the Student approximation is no longer valid. Besides we apply the test many times, but do not control for multiple comparisons. Nevertheless, the significance test is an intuitive guide for deciding which improvements are statistically significant.

The boosting attack

In this section we describe a new canonical attack that an adversarial analyst might perform in order to boost their ranking on the public leaderboard. Besides being practical in some cases, the attack also serves as an analytical tool to assess the accuracy of concrete mechanisms.

For simplicity we describe the attack only for the $0/1$-loss although it generalizes to other reasonable functions such as the clipped logarithmic loss often used by Kaggle. We assume that the hidden solution is a vector $y\in\{0,1\}^{n}.$ The analyst may submit a vector $u\in\{0,1\}^{n}$ and observe (up to small enough error) the loss

Pick $u_{1},\dots,u_{k}\in\{0,1\}^{n}$ uniformly at random.

Observe loss estimates $l_{1},\dots,l_{k}\in.$

Let $I=\left\{i\colon l_{i}\leqslant 1/2\right\}.$

The vector $y$ corresponds to the target set of labels used for the public leaderboard which the analyst does not know. The vectors $u_{1},\dots,u_{k}$ represent the labels given by a sequence of $k$ classifiers.

The next theorem follows from a standard “boosting argument” using properties of the majority function and the fact that each $u_{i}$ for $i\in I$ has a somewhat larger than expected correlation with $y.$

The previous theorem in particular demonstrates that the Kaggle mechanism has poor leaderboard accuracy if it is invoked with rounding parameter $\alpha\leqslant 1/\sqrt{n}.$ The currently used rounding parameter is $10^{-5}$ which satisfies this assumption for all $n\leqslant 10^{10}.$

There is a sequence of adaptively chosen classifiers $f_{1},\dots,f_{k}$ such that if $R_{i}$ denotes the minimum of the first $i$ loss estimates returned by the Kaggle mechanism (as described in Figure 7) with accuracy $\alpha\leqslant 1/\sqrt{n}$ where $n$ is the size of the data set, then with probability $2/3$ the estimates $R_{1},\dots,R_{k}$ have leaderboard error

Figure 3 compares the performance of the Ladder mechanism with that of the standard Kaggle mechanism under the boosting attack. We chose $N=12000$ as the total number of labels of which $n=4000$ labels are used for determining the public leaderboard under either mechanism. Other parameter settings lead to a similar picture, but these settings correspond roughly to the properties of the real data set that we will analyze later. The Kaggle mechanism gives answers that are accurate up to a rounding error of $10^{-5}.$ Note that $1/\sqrt{4000}\approx 0.0158$ so that the rounding error is well below the critical level of $1/\sqrt{n}.$ The vector $y$ in the description of our attack corresponds to the $4000$ labels used for the public leaderboard. Since the answers given by Kaggle only depend on these labels, the remaining labels play no role in the attack. Importantly, the attack does not need to know the indices of the labels used for the public leaderboard within the entire vector of labels.

The $8000$ coordinates not used for the leaderboard remain unbiased random bits throughout the attack as no information is revealed. In particular, the final submission $u^{*}$ is completely random on those $8000$ coordinates and only biased on the other $4000$ coordinates used for the leaderboard. Therefore, once we evaluate the final submission $u^{*}$ on the test set consisting of the remaining $8000$ coordinates, the resulting loss is close to its expected value of $1/2,$ i.e. the expected loss of a random $0/1$-vector. What we observe, however, is that the Kaggle mechanism gives a strongly biased estimate of the loss of $u^{*}$.

The blue line in Figure 3 displays the performance of the parameter-free version of the Ladder mechanism. Instead of selecting all the vectors with loss at most $1/2$ we modified the attack to be more effective against the Ladder Mechanism. Specifically, we selected all those vectors that successfully lowered the score compared to the previous best. As we have no information about the correlation of the remaining vectors, there is no benefit in including them in the boosting step. Even with this more effective attack, the Ladder mechanism gives a result that is correct to within the expected maximum deviation of the score on $k$ random vectors. The intuitive reason is that every time a vector lowers the best score seen so far, the probability of a subsequent vector crossing the new threshold drops off by a constant factor. In particular there cannot be more than $O(\log(k))$ such steps thus creating a bias of at most $O(\sqrt{\log(k)/n})$ in the boosting step.

Experiments on real Kaggle data

To demonstrate the utility of the Ladder mechanism we turn to real submission data from Kaggle’s “Photo Quality Prediction” challengehttps://www.kaggle.com/c/PhotoQualityPrediction. Here is some basic information about the competition.

Our first experiment is to use the parameter-free Ladder mechanism in place of the Kaggle mechanism across all $1785$ submissions and recompute both the public and the private leaderboard. The resulting rankings turn out to be very close to those computed by Kaggle. For example, Table 1 shows the only perturbations in the ranking among the top $10$ submissions.

Figure 4 plots the public versus private scores of the leading $50$ submissions (w.r.t the private leaderboard). The diagonal line indicates an equal private and public score. The plot a small amount of underfitting between the public and private scores. That is, the losses on the public leaderboard generally tend to be slightly higher than on the private leaderboard. This appears to be due random fluctuations in the proportion of hard examples in the public holdout set.

To assess this possibility and gain further insight into the magnitude of statistical deviations of the scores, we randomly split the private holdout set into two equally sized parts and recompute the leaderboards on each part. We repeat the process $20$ times independently and look at the standard deviations of the scores across these $20$ repetitions. Figure 5 shows the results demonstrating that the statistical deviations due to random splitting are large relative to the difference in mean scores. In particular the amount of underfitting observed on the original split is within one standard deviation of the mean scores which cluster close to the diagonal line. We also observed that the top $50$ scores are highly correlated so that across different splits the points are either mostly above or mostly below the diagonal line. This must be due to the fact that the best submissions in this competition used related classifiers that fail to predict roughly the same label set.

To get a better sense of the statistical significance of the difference between the scores of competing submissions we performed a sequence of significance tests. Specifically, we considered the top $10$ submissions taken from the Kaggle public leaderboard and tested on the private data if the true score of the top submission is significantly different from the rank $r$ submission for $r=2,3,\dots,10.$ A suitable test of significance is the paired $t$-test. The score of a submission is the mean of a large number of samples in the interval $$and follows a sufficiently accurate normal approximation. We chose a paired$t$-test rather than an unpaired$t$-test, because it has far greater statistical power in our setting. This is primarily due to the strong correlation between competing submissions. See Equation 6 for a definition of the test statistic. Note that the data that determined the selection of the top$10$ classifiers is independent of the data used to perform the significance tests.

Figure 6 plots the resulting $p$-values before and after correction for multiple comparisons. We see that after applying a Bonferroni correction, the only submissions with a significantly different mean are $8$ and $9.$

These observations give further evidence that the small perturbations we saw in the top $10$ leaderboard between the Kaggle mechanism and the Ladder mechanism are below the level of statistical significance.

Conclusion

We hope that the Ladder mechanism will be helpful in making machine learning competitions more reliable. Beyond the scope of machine learning competitions, it is conceivable that the Ladder mechanism could be useful in other domains where overfitting is currently a concern. For example, in the context of false discovery in the empirical sciences [Ioa, GL], one could imagine using the the Ladder mechanism as a way of keeping track of scientific progress on important public data sets.

Our algorithm can also be seen as an intuitive explanation for why overfitting to the holdout is sometimes not a major problem even in the adaptive setting. If indeed every analyst only uses the holdout set to test if their latest submission is well above the previous best, then they effectively simulate our algorithm.

A beautiful theoretical problem is to resolve the gap between our upper and lower bound. On the practical side, it would be interesting to use the Ladder mechanism in a real competition. One interesting question is if the Ladder mechanism actually encourages higher quality submissions by requiring a certain level of statistically significant improvement over previous submissions.

References

Appendix A Kaggle reference mechanism

As we did for the Ladder Mechanism we describe the algorithm as if the analyst was submitting classifiers $f\colon X\to Y.$ In reality the analyst only submits a list of labels. It is easy to see that such a list of labels is sufficient to compute the empirical loss which is all the algorithm needs to do. The input set $S$ in the description of our algorithm corresponds to the set of data points (and corresponding labels) that Kaggle uses for the public leaderboard.