IPBoost

From statwiki
Revision as of 23:36, 15 November 2020 by Msjawad (talk | contribs) (Algorithm)
Jump to: navigation, search

Presented by

Casey De Vera, Solaiman Jawad

Introduction

Boosting (see Wikipedia) is an important (and by now standard) technique in classification to combine several “low accuracy” learners, so-called base learners, into a “high accuracy” learner, a so-called boosted learner. Pioneered by the AdaBoost approach of [FS], in recent decades there has been extensive work on boosting procedures and analyses of their limitations. In a nutshell, boosting procedures are (typically) iterative schemes that roughly work as follows:

for [math] t= 1, \cdots, T [/math] do the following:

  1. Train a learner [math] \mu_t[/math] from a given class of base learners on the data distribution [math] \mathcal D_t[/math]
  2. Evaluate performance of [math] \mu_t[/math] by computing its loss.
  3. Push weight of the data distribution [math] \mathcal D_t[/math] towards misclassified examples leading to [math] \mathcal D_{t+1}[/math]

.

Finally, the learners are combined by some form of voting (e.g., soft or hard voting, averaging, thresholding).
boosting.gif
A close inspection of most (but not all) boosting procedures reveals that they solve an underlying convex optimization problem over a convex loss function by means of coordinate gradient descent. Boosting schemes of this type are often referred to as convex potential boosters. These procedures can achieve exceptional performance on many data sets if the data is correctly labeled. In fact, in theory, provided the class of base learners is rich enough, a perfect strong learner can be constructed that has accuracy 1, however clearly such a learner might not necessarily generalize well. Boosted learners can generate quite some complicated decision boundaries, much more complicated than that of the base learners. Here is an example from Paul van der Laken’s blog / Extreme gradient boosting gif by Ryan Holbrook. Here data is generated online according to some process with optimal decision boundary represented by the dotted line and XGBoost was used learn a classifier:


Recently non-convex optimization approaches for solving machine learning problems have gained significant attention. In this paper we explore non-convex boosting in classification by means of integer programming and demonstrate real-world practicability of the approach while circumventing shortcomings of convex boosting approaches. We report results that are comparable to or better than the current state-of-the-art.

Motivation

In reality we usually face unclean data and so-called label noise, where some percentage of the classification labels might be corrupted. We would also like to construct strong learners for such data. However if we revisit the general boosting template from above, then we might suspect that we run into trouble as soon as a certain fraction of training examples is misclassified: in this case these examples cannot be correctly classified and the procedure shifts more and more weight towards these bad examples. This eventually leads to a strong learner, that perfectly predicts the (flawed) training data, however that does not generalize well anymore. This intuition has been formalized by [LS] who construct a “hard” training data distribution, where a small percentage of labels is randomly flipped. This label noise then leads to a significant reduction in performance of these boosted learners; see tables below. The more technical reason for this problem is actually the convexity of the loss function that is minimized by the boosting procedure. Clearly, one can use all types of “tricks” such as early stopping but at the end of the day this is not solving the fundamental problem.

IPBoost: Boosting via Integer Programming

Integer Program Formulation

Let [math](x_1,y_1),\cdots, (x_N,y_N) [/math] be the training set with points [math]x_i \in \mathbb{R}^d[/math] and two-class labels [math]y_i \in \{\pm 1\}[/math]

  • class of base learners: [math] \Omega :=\{h_1, \cdots, h_L: \mathbb{R}^d \rightarrow \{\pm 1\}\} [/math] and [math]\rho \ge 0[/math] be given.
  • error function [math] \eta [/math]

Our boosting model is captured by the integer programming problem:

$$ \begin{align*} \min &\sum_{i=1}^N z_i \\ s.t. &\sum_{j=1}^L \eta_{ij}\lambda_k+(1+\rho)z_i \ge \rho \ \forall i=1,\cdots, N \\ &\sum_{j=1}^L \lambda_j=1, \lambda \ge 0,\\ &z\in \{0,1\}^N. \end{align*}$$

Solution using branch and price procedure

Algorithm

Input: Examples [math] D = \{(x_i, y_i) | i ∈ I\} ⊆ R^d × \{±1\} [/math], class of base learners [math]Ω [/math], margin [math] ρ [/math]
Output: Boosted learner [math] \sum_{j∈L∗}h_jλ_j^* [/math] with base learners [math] h_j [/math] and weights [math] λ_j^* [/math]

  1. [math] T ← {([0, 1] N, \emptyset)} [/math] // set of local bounds and learners for open subproblems
  2. [math] U ← \infty, L^∗ ← \emptyset [/math] // Upper bound on optimal objective
  1. while [math]\ T \neq \emptyset [/math] do
  2. Choose and remove [math](B,L) [/math] from [math]T [/math]
  3. repeat
  4. Solve (3) using the local bounds on [math] z [/math] in [math]B[/math] with optimal dual solution [math] (w^∗, v^∗, u^∗) [/math]
  5. Find learner [math] h_j ∈ Ω [/math] satisfying (5). // Solve pricing problem.
  6. until [math] h_j [/math] is not found
  1. Let [math] (\widetilde{λ} , \widetilde{z}) [/math] be the final solution of (3) with base learners [math] \widetilde{L} = \{j | \widetilde{λ}_j \gt 0\} [/math]
  1. if [math] \widetilde{z} ∈ \mathbb{Z}^N [/math] and [math] \sum^{N}_{i=1}\widetilde{z}_i \lt U [/math] then
  2. [math] U ← \sum^{N}_{i=1}\widetilde{z}_i, L^∗ ← \widetilde{L}, λ^∗ ← \widetilde{\lambda} [/math] // Update best solution.
  1. else
  2. Choose [math] i ∈ [N] [/math] with [math] \widetilde{z}_i \notin Z [/math]
  3. Set [math] B_0 ← B ∩ \{z_i ≤ 0\}, B_1 ← B ∩ \{z_i ≥ 1\} [/math]
  4. Add [math] (B_0,\widetilde{L}), (B_1,\widetilde{L}) [/math] to T . // Create new branching nodes.
  5. end if
  6. end while
  7. Optionally sparsify final solution [math]L^*[/math]

Results and Performance

References