15-859(B) Machine Learning Theory 02/11/09 * Boosting, contd: Adaboost ======================================================================== Basic setup: Suppose we have an algorithm A that claims on every distribution to be able to get error at most p = 1/2 - gamma. (let's ignore the delta parameter). How can we use this as a black box to get error epsilon? Or, as a practical matter: say we have a learning algorithm that's good at finding rules-of-thumb. How can we use it to produce a really good classifier? (Or output a "challenge dataset" where any progress will help us do better?) Last time we looked at one method for reducing error (Rob Schapire's original approach). This involved calling A 3 times on specially reweighted distributions and taking majority vote. If hypotheses produced by A have error p, then the result has error 3p^2 - 2p^3 = 1/2 - gamma[3/2 - 2*gamma^2]. (so you can see the new gamma is bigger) We then calculated the depth of tree needed to get to error epsilon, which was O(log(1/gamma) + loglog(1/epsilon)). So, the *size* of tree needed (3^depth) is poly(1/gamma, log(1/epsilon)). ============================================== Adaboost idea: Instead of doing majorities of majorities, let's just keep repeating step 2 of the previous scheme, each time reweighting the examples so that the previous hypothesis gets error exactly 1/2. Then take a big vote of all the hypotheses, weighted in some way by how good they were on the distributions they came from. In fact, this will look a lot like the randomized weighted majority algorithm, except the examples are playing the role of the "experts". What could we hope for? Suppose we want to get error epsilon, and A always gave us hypotheses of error 1/2 - gamma where the errors were *independent*. How many calls would we need so that the majority vote had error epsilon? I.e., if we pick a random example, we want at most an epsilon probability of the vote being wrong. This is like flipping a coin of bias 1/2 - gamma and we want at most an epsilon chance of more heads than tails. Hoeffding bounds say that want want the number of flips T to satisfy e^{-2*T*gamma^2} = epsilon, so the number of flips needed is O((1/gamma)^2 log(1/epsilon)). We are going to be able to achieve this, even though A is not necessarily so nice. In fact, as a byproduct, this argument actually gives a *proof* of a form of Hoeffding bounds. Adaboost -------- First draw large sample that will be sufficient by Occam/VC arguments. Use Weighted-majority, but in peculiar way. Experts will correspond to examples. Weighting of experts will be the current distribution. "trials" will correspond to the weak hypotheses. Specifically, the algorithm is: 0. Draw n examples. 1. Start with weight w_i = 1 on each example x_i. The associated prob dist D has P(x_i) = w_i/W, where W = sum(w_i). 2. For t=1 to T do: Feed D to weak algorithm, get back hypothesis h_t. [Draw picture] Let beta_t = (error rate)/(1 - error rate) of h_t on D Now update D: Multiply w_i by beta_t if h_t(x_i) is correct. (notice: h_t now has 50% error on the new distribution) 3. Final hypothesis: let alpha_t = ln(1/beta_t). Output a majority vote weighted by the alphas. I.e., h(x) = sign(sum_t alpha_t * h_t(x)) if we view labels as +/-1. Claim: training error(hl) < e^{-2*sum_t[ (gamma_t)^2 ]} where 1/2 - gamma_t = error rate of h_t on D_t. So, if each time we have error at most 1/2 - gamma, we run it T times, we get e^{-2T gamma^2}. If our goal is to achieve error epsilon, then we need to run this O((1/gamma)^2 * log(1/epsilon)) times. (Notice similarity to Hoeffding formula) ANALYSIS ======== To simplify things, let's assume all gamma_t's are the same. Call it gamma. Then beta is fixed, and the final hypothesis is just a straight majority vote over the h_t's. Some notation: error = 1/2 - gamma (error of each weak hypothesis) beta = error/(1-error) = (1/2 - gamma)/(1/2 + gamma) T = number of steps we run this procedure Let's now analyze as in randomized WM, by putting upper and lower bounds on the final weight. For the upper bound, suppose we currently have a total weight of W. Since a (1-error) fraction of W gets multiplied by beta, after this step that portion has weight only error*W, so the total weight is 2*error*W. Since the total weight starts at n, this means that: W_final <= n*(2*error)^T = n*(1 - 2*gamma)^T Now, let's look at the lower bound. To do the lower bound, notice that any example on which our majority vote makes a mistake must have weight at least beta^{T/2}, since if our majority vote is wrong then we could have multiplied it by beta *at most* T/2 times. So, if in the end our error rate is epsilon (so we make a mistake on epsilon*n points), then W_final >= beta^{T/2} * epsilon * n Combining our upper and lower bounds gives us: epsilon <= [(1 - 2*gamma)^2 / beta]^{T/2} = [4*(1/2 - gamma)*(1/2 + gamma)]^{T/2} = [1 - 4*gamma^2]^{T/2}. Now we use our favorite inequality: 1-x <= e^{-x} epsilon <= e^{-2T*gamma^2}. QED ======================= So, just to summarize, if we had T hypotheses of *independent* error 1/2 - gamma, then Hoeffding bounds give us this bound on the error rate of their majority vote. What we are able to do with Adaboost is achieve this error with an arbitrary weak learning algorithm, that just guarantees that to give error at most 1/2 - gamma on whatever distribution it's given. What about true error versus empirical error? What we really have at this point is a bound on empirical error. To have a bound on true error we need our sample to be large enough so that not only do we get uniform convergence over the hypothesis space H used by A, but also we get uniform convergence over "majority votes of O(1/gamma^2 * log(1/epsilon)) hypotheses in H". To get a feel for this, let MAJ_k(H) be the functions you can get by taking majorities of k functions in H. If there are H[m] ways of splitting m points using functions in H, then there are at most {H[m] \choose k} ways of splitting functions using majorities. So, the sample size bound just needs to increase by a multiple of k. Margin analysis =============== Actually, one thing people noticed in practice is that if you keep running Adaboost past this limit, you don't end up overfitting. There's a nice way of looking at this in terms of "L_1 margins". Let's define g = alpha_1 h_1 + ... + alpha_T h_T, so our final hypothesis h(x) is sign(g(x)). Let's scale the alpha_t's so they sum to 1. Now, define the margin of g (or h) on an example x of label y to be y*g(x). If you look carefully at our analysis of adaboost, it ends up showing not only that there can't be too many examples where the majority vote is wrong (negative margin) but in fact there can't be too many where the majority vote is barely right. In fact if you keep running the algorithm, the fraction of examples with margin < gamma will go to 0 (because those examples have too high a weight compared to the upper bound of (1 - 2*gamma)^T. What does this mean? One thing about having margin gamma is that even if T is huge, you can whp produce the exact same prediction that h does by just viewing g as a probability distribution and sampling from it k = (1/gamma^2)*log(1/epsilon) times, and then taking majority vote over the sample. So, as long as we have enough data so that these "small majority votes" aren't overfitting, then h can't be overfitting by much either. More formally, let h' be the randomized prediction function that given a new example x predicts the majority vote over k random draws from distribution g. Then the true error rates must satisfy err(h') >= err(h)/2 since if h(x) is incorrect, this means that each random draw from g has at least a 50% chance of giving the wrong answer on x, so h' has at least a 50% chance of being incorrect. But we argued that the empirical error of h' is low, and furthermore we have enough data so the empirical error of h' is close to its true error. Therefore the true error of h must be low too.