# Difference between revisions of "IPBoost"

## Introduction

Boosting is an important and a fairly standard technique in a classification that combines several base learners (learners which have a “low accuracy”), into one boosted learner (learner with a “high accuracy”). Pioneered by the AdaBoost approach of Freund & Schapire, 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:

Let $T$ represents the number of iteration and $t$ represents the iterator.

for $t= 1, \cdots, T$ do the following:

1. Train a learner $\mu_t$ from a given class of base learners on the data distribution $\mathcal D_t$
2. Evaluate the performance of $\mu_t$ by computing its loss.
3. Push weight of the data distribution $\mathcal D_t$ towards the misclassified examples leading to $\mathcal D_{t+1}$, usually a relatively good model will have a higher weight on those data that misclassified.

Finally, the learners are combined with some form of voting (e.g., soft or hard voting, averaging, thresholding).

A close inspection of most 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. However, they can be defeated easily by a small number of incorrect labels which can be quite difficult to fix. The reason being is that we try to solve misclassified examples by moving the weights around, which results in bad performance on unseen data (Shown by zoomed example to the right). 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 some quite 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 to learn a classifier:

Recently non-convex optimization approaches for solving machine learning problems have gained significant attention. In this paper, the non-convex boosting in classification using integer programming has been explored, and the real-world practicability of the approach while circumventing shortcomings of convex boosting approaches is also shown. The paper reports results that are comparable to or better than current state-of-the-art approaches.

## 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. Noisy labels are an issue because when a model is trained with excessive amounts of noisy labels, the performance and accuracy deteriorate greatly. 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 $(x_1,y_1),\cdots, (x_N,y_N)$ be the training set with points $x_i \in \mathbb{R}^d$ and two-class labels $y_i \in \{\pm 1\}$

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

Our boosting model is captured by the integer programming problem. We can call this our primal 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*}

For the error function $\eta$, three options were considered:

(i) $\pm 1$ classification from learners $$\eta_{ij} := 2\mathbb{I}[h_j(x_i) = y_i] - 1 = y_i \cdot h_j(x_i)$$ (ii) class probabilities of learners $$\eta_{ij} := 2\mathbb{P}[h_j(x_i) = y_i] - 1$$ (iii) SAMME.R error function for learners $$\frac{1}{2}y_i\log\left(\frac{\mathbb{P}[h_j(x_i) = 1]}{\mathbb{P}[h_j(x_i) = -1]}\right)$$

### Solution of the IP using Column Generation

The goal of column generation is to provide an efficient way to solve the linear programming relaxation of the primal by allowing the $z_i$ variables to assume fractional values. Moreover, columns, i.e., the base learners, $\mathcal L \subseteq [L].$ are left out because there are too many to handle efficiently and most of them will have their associated weight equal to zero in the optimal solution anyway. To generate columns, a branch and bound framework is used. Columns are generated within a branch-and-bound framework leading effectively to a branch-and-bound-and-price algorithm being used; this is significantly more involved compared to column generation in linear programming. To check the optimality of an LP solution, a subproblem, called the pricing problem, is solved to try to identify columns with a profitable reduced cost. If such columns are found, the LP is re-optimized. Branching occurs when no profitable columns are found, but the LP solution does not satisfy the integrality conditions. Branch and price apply column generation at every node of the branch and bound tree.

The restricted master primal problem is

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

Its restricted dual problem is:

\begin{align*}\max \rho &\sum^{N}_{i=1}w_i + v - \sum^{N}_{i=1}u_i \\ s.t. &\sum_{i=1}^N \eta_{ij}w_k+ v \le 0 \ \ \ \forall j \in L \\ &(1+\rho)w_i - u_i \le 1 \ \ \ \forall i \in [N] \\ &w \ge 0, u \ge 0, v\ free\end{align*}

Furthermore, there is a pricing problem used to determine, for every supposed optimal solution of the dual, whether the solution is actually optimal, or whether further constraints need to be added into the primal solution. With this pricing problem, we check whether the solution to the restricted dual is feasible. This pricing problem can be expressed as follows:

$$\sum_{i=1}^N \eta_{ij}w_k^* + v^* > 0$$

The optimal misclassification values are determined by a branch-and-price process that branches on the variables $z_i$ and solves the intermediate LPs using column generation.

### Algorithm

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

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

### Sparsification

When building the boosting model, one of the challenges is to balance model accuracy and generalization. A sparse model is generally easier to interpret. In order to control complexity, overfitting, and generalization of the model, typically some sparsity is applied, which is easier to interpret for some applications. The goal of sparsification is to minimize the following: $$\sum_{i=1}^{N}z_i+\sum_{i=1}^{L}\alpha_iy_i$$ There are two techniques commonly used. One is early stopping, another is regularization by adding a complexity term for the learners in the objective function. Previous approaches in the context of LP-based boosting have promoted sparsity by means of cutting planes. Sparsification can be handled in the approach introduced in this paper by solving a delayed integer program using additional cutting planes.

## Results and Performance

All tests were run on identical Linux clusters with Intel Xeon Quad Core CPUs, with 3.50GHz, 10 MB cache, and 32 GB of main memory.

The following results reflect IPBoost's performance in hard instances. Note that by hard instances, we mean a binary classification problem with predefined labels. These examples are tailored to using the ±1 classification from learners. On every hard instance sample, IPBoost significantly outperforms both LPBoost and AdaBoost (although implementations depending on the libraries used have often caused results to differ slightly). For the considered instances the best value for the margin ρ was 0.05 for LPBoost and IPBoost; AdaBoost has no margin parameter. The accuracy reported is test accuracy recorded across various different walkthroughs of the algorithm, while $L$ denotes the aggregate number of learners required to find the optimal learner, N is the number of points and $\gamma$ refers to the noise level.

For the next table, the classification instances from LIBSVM data sets available at [1]. We report accuracies on the test set and train set, respectively. In each case, we report the averages of the accuracies over 10 runs with a different random seed and their standard deviations. We can see IPboost again outperforming LPBoost and AdaBoost significantly. Solving Integer Programming problems is no doubt more computationally expensive than traditional boosting methods like AdaBoost. The average run time of IPBoost (for ρ = 0.05) being 1367.78 seconds, as opposed to LPBoost's 164.35 seconds and AdaBoost's 3.59 seconds reflects exactly that. However, on the flip side, we gain much better stability in our results, as well as higher scores across the board for both training and test sets.

## Conclusion

IP-boosting avoids the bad performance on well-known hard classes and improves upon LP-boosting and AdaBoost on the LIBSVM instances where even a few percent improvements is valuable. The major drawback is that the running time with the current implementation is much longer. Nevertheless, the algorithm can be improved in the future by solving the intermediate LPs only approximately and deriving tailored heuristics that generate decent primal solutions to save on time.

The approach is suited very well to an offline setting in which training may take time and where even a small improvement is beneficial or when convex boosters have egregious behaviour. It can also be served as a tool to investigate the general performance of methods like this.

The IPBoost algorithm added extra complexity into basic boosting models to gain slight accuracy gain while greatly increased the time spent. It is 381 times slower compared to an AdaBoost model on a small dataset which makes the actual usage of this model doubtable. If we are supplied with a larger dataset with millions of records this model would take too long to complete. The base classifier choice was XGBoost which is too complicated for a base classifier, maybe try some weaker learners such as tree stumps to compare the result with other models. In addition, this model might not be accurate compared to the model-ensembling technique where each model utilizes a different algorithm.

I think IP Boost can be helpful in cases where a small improvement in accuracy is worth the additional computational effort involved. For example, there are applications in Finance where predicting the movement of stock prices slightly more accurately can help traders make millions more. In such cases, investing in expensive computing systems to implement such boosting techniques can perhaps be justified.

Although the IPBoost can generate better results compared to the base boosting models such as AdaBoost. The time complexity of IPBoost is much higher than other models. Hence, it will be problem to apply IPBoost to the real-world training data since those training data will be large and it's hard to deal with. Thus, we are left with the question that this IPBoost is only a little bit more accurate than the base boosting models but a lot more time complex. So is the model really worth it?

## Critique

In the introduction section, should change the sentence"3. Push weight of the data ... will have a higher weight on those data that misclassified." to "... will have a higher weight on those data that are misclassified.

In practise AdaBoost & LP Boost are quite robust to over fitting. In practise if you use simple weak learns stumps (1-level decision trees) then the algorithms are much less prone to over fitting. However the noise level in the data, particularly for AdaBoost is prone to overfitting on noisy datasets. To avoid this use regularised models (AdaBoostReg, LPBoost). Further, when in higher dimensional spaces, AdaBoost can suffer, since its just a linear combination of classifiers. You can use k-fold cross validation to set the stopping parameter to improve this.

## References

• Pfetsch, M. E., & Pokutta, S. (2020). IPBoost--Non-Convex Boosting via Integer Programming. arXiv preprint arXiv:2002.04679.
• Freund, Y., & Schapire, R. E. (1995, March). A desicion-theoretic generalization of on-line learning and an application to boosting. In European conference on computational learning theory (pp. 23-37). Springer, Berlin, Heidelberg. pdf