There’s a well-understood phenomenon in machine learning called *overfitting*. The idea is best shown by a graph:

Let me explain. The vertical axis represents the error of a hypothesis. The horizontal axis represents the complexity of the hypothesis. The blue curve represents the error of a machine learning algorithm’s output on its training data, and the red curve represents the *generalization* of that hypothesis to the real world. The overfitting phenomenon is marker in the middle of the graph, before which the training error and generalization error both go down, but after which the training error continues to fall while the generalization error rises.

The explanation is a sort of numerical version of Occam’s Razor that says more complex hypotheses can model a *fixed* data set better and better, but at some point a simpler hypothesis better models the underlying phenomenon that generates the data. To optimize a particular learning algorithm, one wants to set parameters of their model to hit the minimum of the red curve.

This is where things get juicy. Boosting, which we covered in gruesome detail previously, has a natural measure of complexity represented by the number of rounds you run the algorithm for. Each round adds one additional “weak learner” weighted vote. So running for a thousand rounds gives a vote of a thousand weak learners. Despite this, boosting **doesn’t overfit** on many datasets. In fact, and this is a shocking fact, researchers observed that Boosting would hit **zero training error, **they kept running it for more rounds, and the generalization error kept going down! It seemed like the complexity could grow arbitrarily without penalty.

Schapire, Freund, Bartlett, and Lee proposed a theoretical explanation for this based on the notion of a margin, and the goal of this post is to go through the details of their theorem and proof. Remember that the standard AdaBoost algorithm produces a set of *weak hypotheses* and a corresponding weight for each round . The classifier at the end is a weighted majority vote of all the weak learners (roughly: weak learners with high error on “hard” data points get less weight).

**Definition:** The *signed* *confidence *of a labeled example is the weighted sum:

The *margin* of is the quantity . The notation implicitly depends on the outputs of the AdaBoost algorithm via “conf.”

We use the product of the label and the confidence for the observation that if and only if the classifier is incorrect. The theorem we’ll prove in this post is

**Theorem: **With high probability over a random choice of training data, for any generalization error of boosting is bounded from above by

In words, the generalization error of the boosting hypothesis is bounded by the distribution of margins observed *on the training data*. To state and prove the theorem more generally we have to return to the details of PAC-learning. Here and in the rest of this post, denotes , the probability over a random example drawn from the distribution , and denotes the probability over a random (training) set of examples drawn from .

**Theorem: **Let be a set of random examples chosen from the distribution generating the data. Assume the weak learner corresponds to a finite hypothesis space of size , and let . Then with probability at least (over the choice of ), **every** weighted-majority vote function satisfies the following generalization bound for every .

In other words, this phenomenon is a fact about voting schemes, not boosting in particular. From now on, a “majority vote” function will mean to take the sign of a sum of the form , where and . This is the “convex hull” of the set of weak learners . If is infinite (in our proof it will be finite, but we’ll state a generalization afterward), then only finitely many of the in the sum may be nonzero.

To prove the theorem, we’ll start by defining a class of functions corresponding to “unweighted majority votes with duplicates:”

**Definition: **Let be the set of functions of the form where and the may contain duplicates (some of the may be equal to some other of the ).

Now every majority vote function can be written as a weighted sum of with weights (I’m using instead of to distinguish arbitrary weights from those weights arising from Boosting). So any such defines a natural distribution over where you draw function with probability . I’ll call this distribution . If we draw from this distribution times and take an unweighted sum, we’ll get a function . Call the random process (distribution) generating functions in this way . In diagram form, the logic goes

weights distribution over function in by drawing times according to .

The main fact about the relationship between and is that each is completely determined by the other. Obviously is determined by because we defined it that way, but is also completely determined by as follows:

Proving the equality is an exercise for the reader.

*Proof of Theorem. *First we’ll split the probability into two pieces, and then bound each piece.

First a probability reminder. If we have two events and (in what’s below, this will be and , we can split up into (where is the opposite of ). This is called the law of total probability. Moreover, because and because these quantities are all at most 1, it’s true that (the conditional probability) and that .

Back to the proof. Notice that for any and any , we can write as a sum:

Now I’ll loosen the first term by removing the second event (that only makes the whole probability bigger) and loosen the second term by relaxing it to a conditional:

Now because the inequality is true for every , it’s also true if we take an expectation of the RHS over any distribution we choose. We’ll choose the distribution to get

And (term 1) is

And is

We can rewrite the probabilities using expectations because (1) the variables being drawn in the distributions are independent, and (2) the probability of an event is the expectation of the indicator function of the event.

Now we’ll bound the terms separately. We’ll start with .

Fix and look at the quantity inside the expectation of .

This should intuitively be very small for the following reason. We’re sampling according to a distribution whose expectation is , and we *know* that . Of course is unlikely to be large.

Mathematically we can prove this by transforming the thing inside the probability to a form suitable for the Chernoff bound. Saying is the same as saying , i.e. that some random variable which is a sum of independent random variables (the ) deviates from its expectation by at least . Since the ‘s are all and constant inside the expectation, they can be removed from the absolute value to get

The Chernoff bound allows us to bound this by an exponential in the number of random variables in the sum, i.e. . It turns out the bound is .

Now recall

For , we don’t want to bound it absolutely like we did for , because there is nothing stopping the classifier from being a bad classifier and having lots of error. Rather, we want to bound it in terms of the probability that . We’ll do this in two steps. In step 1, we’ll go from of the ‘s to of the ‘s.

**Step 1: **For any fixed , if we take a sample of size , then consider the event in which the sample probability deviates from the true distribution by some value , i.e. the event

The claim is this happens with probability at most . This is again the Chernoff bound in disguise, because the expected value of is , and the probability over is an average of random variables (it’s a slightly different form of the Chernoff bound; see this post for more). From now on we’ll drop the when writing .

The bound above holds true for any fixed , but we want a bound over all and . To do that we use the union bound. Note that there are only possible choices for a nonnegative because is a sum of values each of which is either . And there are only possibilities for . So the union bound says the above event will occur with probability at most .

If we want the event to occur with probability at most , we can judiciously pick

And since the bound holds in general, we can take expectation with respect to and nothing changes. This means that for any , our chosen ensures that the following is true with probability at least :

Now for step 2, we bound the probability that on a sample to the probability that on a sample.

**Step 2:** The first claim is that

What we did was break up the LHS into two “and”s, when and (this was still an equality). Then we loosened the first term to since that is only more likely than both and . Then we loosened the second term again using the fact that a probability of an “and” is bounded by the conditional probability.

Now we have the probability of bounded by the probability that plus some stuff. We just need to bound the “plus some stuff” absolutely and then we’ll be done. The argument is the same as our previous use of the Chernoff bound: we assume , and yet . So the deviation of from its expectation is large, and the probability that happens is exponentially small in the amount of deviation. The bound you get is

And again we use the union bound to ensure the failure of this bound for any will be very small. Specifically, if we want the total failure probability to be at most , then we need to pick some ‘s so that . Choosing works.

Putting everything together, we get that with probability at least for every and every , this bound on the failure probability of :

This claim is true for *every* , so we can pick that minimizes it. Doing a little bit of behind-the-scenes calculus that is left as an exercise to the reader, a tight choice of is . And this gives the statement of the theorem.

We proved this for finite hypothesis classes, and if you know what VC-dimension is, you’ll know that it’s a central tool for reasoning about the complexity of infinite hypothesis classes. An analogous theorem can be proved in terms of the VC dimension. In that case, calling the VC-dimension of the weak learner’s output hypothesis class, the bound is

How can we interpret these bounds with so many parameters floating around? That’s where asymptotic notation comes in handy. If we fix and , then the big-O part of the theorem simplifies to , which is easier to think about since goes to zero very fast.

Now the theorem we just proved was about any weighted majority function. The question still remains: why is AdaBoost good? That follows from another theorem, which we’ll state and leave as an exercise (it essentially follows by unwrapping the definition of the AdaBoost algorithm from last time).

**Theorem: **Suppose that during AdaBoost the weak learners produce hypotheses with training errors . Then for any ,

Let’s interpret this for some concrete numbers. Say that and is any fixed value less than . In this case the term inside product becomes and the whole bound tends exponentially quickly to zero in the number of rounds . On the other hand, if we raise to about 1/3, then in order to maintain the LHS tending to zero we would need which is about 20% error.

If you’re interested in learning more about Boosting, there is an excellent book by Freund and Schapire (the inventors of boosting) called Boosting: Foundations and Algorithms. There they include a tighter analysis based on the idea of Rademacher complexity. The bound I presented in this post is nice because the proof doesn’t require any machinery past basic probability, but if you want to reach the cutting edge of knowledge about boosting you need to invest in the technical stuff.

Until next time!

IMHO this article has too many formulas, the exposition could be more paced with some ideas or insight to make it more interesting for beginners. Just my two cents.

LikeLike

Thank you … Super interesting

LikeLike

I wonder if bagging is going in the nearest neighbor direction, that is like human lungs in which you take more oxygen by growing small alveoli. There could be a king of fractal, since a leaf can become a tree. One kind of “learning algorithm fractal dimension” could define a way in which a fractal derivation of a learning algorithm increase its performance in the test. There could be a “fractal learning dimension” related to principal dimensions but generalizing the algorithms and its properties with a fractal objects, in this case averaging or bagging. Looking forward to your next post.

As there is nothing new under the sun says, it could happen that the bagging as a fractal device hypothesis or insight has been previously explored, in that case any link could be appreciated.

LikeLike

Someone mentioned, that the article has too many formulas. I must disagree; it is VERY useful and add details to the original proof which is more vague. Thank you.

LikeLike

Thanks, yes, maybe 20% of the technical posts I write intend to do just that, writing down the details I struggled to work out.

LikeLike