{'fraction_non_alphanumeric': 0.03197527395335768, 'fraction_numerical': 0.006518685023883113, 'mean_word_length': 4.551552019965684, 'pattern_counts': {'":': 0, '<': 4, '<?xml version=': 0, '>': 1, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 6, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Robust Optimal Classification Trees under Noisy Labels

In this paper we propose a novel methodology to construct Optimal Classification Trees that takes into account that noisy labels may occur in the training sample. Our approach rests on two main elements: (1) the splitting rules for the classification trees are designed to maximize the separation margin between classes applying the paradigm of SVM; and (2) some of the labels of the training sample are allowed to be changed during the construction of the tree trying to detect the label noise. Both features are considered and integrated together to design the resulting Optimal Classification Tree. We present a Mixed Integer Non Linear Programming formulation for the problem, suitable to be solved using any of the available off-the-shelf solvers. The model is analyzed and tested on a battery of standard datasets taken from UCI Machine Learning repository, showing the effectiveness of our approach.


Introduction
Discrete Optimization has experienced a tremendous growth in the last decades, both in its theoretical and practical sides, partially provoked by the emergence of new computational resources as well as real-world applications that have boosted this growth. This impulse has also motivated the use of Discrete Optimization models to deal with problems involving a large number of variables and constraints, that years before would have not been possible to be dealt with. One of the fields in which Discrete Optimization has caused a larger impact is in Machine Learning. The incorporation of binary decisions to the classical approaches as Support Vector Machine [15], Classification Trees [13], Linear Regression and Clustering, amongst other, has considerably enhanced their performance in terms of accuracy and interpretability (see e.g. [2,4,7,9,10,11,12,17,21]). In particular, one of the most interesting applications of Machine Learning is that related with Supervised Classification.
Supervised classification aims at finding hidden patterns from a training sample of labeled data in order to predict the labels of out-of-sample data. Several methods have been proposed in order to construct highly predictive classification tools. Some of the most widely used methodologies are based on Deep Learning mechanisms [1], k-Nearest Neighborhoods [16,26], Naïve Bayes [23], Classification Trees [13,20] and Support Vector Machines [15]. The massive use of these tools has induced, in many situations, that malicious adversaries adaptively manipulate their data to mislead the outcome of an automatic analysis, and new classification rules must be designed to handle the possibility of this noise in the training labels. A natural example are the spam filters for emails, where malicious emails are becoming more difficult to automatically be detected since they have started to incorporate patterns that typically appear in legitimate emails. As a consequence, the development of robust methods against these kind of problems has attracted the attention of researchers (see e.g., [5,8]).
In the context of binary classification problems, Support Vector Machines (SVM), introduced by Cortes and Vapnik [15], builds the decision rule by means of a separating hyperplane with large margin between classes. This hyperplane is obtained by solving a Non Linear Problem (NLP), in which the goal is to separate data by their two differentiated classes, maximizing the margin between them and minimizing the misclassification errors. In Classification and Regression Trees (CART), firstly introduced by Breiman et. al [13], one constructs the decision rule based on a hierarchical relation among a set of nodes which is used to define paths that lead observations from the root node (highest node in the hierarchical relation), to some of the leaves in which a class is assigned to the data. These paths are obtained according to different optimization criteria over the predictor variables of the training sample. The decision rule comes up naturally, the classes predicted for new observations are the ones assigned to the terminal nodes in which observations fall in. Historically, CART is obtained heuristically through a greedy approach, in which each level of the tree is sequentially constructed: Starting at the root node and using the whole training sample, the method minimizes an impurity measure function obtaining as a result a split that divides the sample into two disjoint sets which determine the two descendant nodes. This process is repeated until a given termination criterion is reached (minimum number of observations belonging to a leaf, maximum depth of the tree, or minimum percentage of observations of the same class on a leaf, among others). In this approach, the tree grows following a top-down greedy approach, an idea that is also shared in other popular decision tree methods like C4.5 [25] or ID3 [24]. The advantage of these methods is that the decision rule can be obtained rather quickly even for large training samples, since the whole process relies on solving manageable problems at each node. Furthermore, these rules are interpretable since the splits only take into account information about lower or upper bounds on a single feature. Nevertheless, there are some remarkable disadvantages in these heuristic methodologies. The first one is that they may not obtain the optimal classification tree, since they look for the best split locally at each node, not taking into account the splits that will come afterwards. Thus, these local branches may not capture the proper structure of the data, leading to misclassification errors in out-of-sample observations. The second one is that, specially under some termination criteria, the solutions provided by these methods can result into very deep (complex) trees, resulting in overfitting and, at times, loosing interpretability of the classification rule. This difficulty is usually overcome by pruning the tree as it is being constructed by comparing the gain on the impurity measure reduction with respect to the complexity cost of the tree.
Mixing together the powerful features of standard classification methods and Discrete Optimization has motivated the study of supervised classification methods under a new paradigm (see [6]). In particular, recently, Bertsimas and Dunn [4] introduced the notion of Optimal Classification Trees (OCT) by approaching CART under optimization lens, providing a Mixed Integer Linear Programming formulation to optimally construct Classification Trees. In this formulation, binary variables are introduced to model the different decisions to be taken in the construction of the trees: deciding whether a split is applied and if an observation belongs to a terminal node. Moreover, the authors proved that this model can be solved for reasonable size datasets, and equally important, that for many different real datasets, significant improvements in accuracy with respect to CART can be obtained. In contrast to the standard CART approach, OCT builds the tree by solving a single optimization problem taking into account (in the objective function) the complexity of the tree, avoiding post pruning processes. Moreover, every split is directly applied in order to minimize the misclassification errors on the terminal nodes, and hence, OCTs are more likely to capture the essence of the data. Furthermore, OCTs can be easily adapted in the so-called OCT-H model to decide on splits based on hyperplanes (oblique) instead of in single variables. Another remarkable advantage of using optimization tools in supervised classification methods is that features such as sparsity or robustness, can be incorporated to the models by means of binary variables and constraints [22]. The interested reader is refereed to the recent survey [14]. We would like to finish this discussion pointing out one of the main differences between SVM and Classification Trees: SVM accounts for misclassification errors based on distances (to the separating hyperplane), i.e., the closer to the correct side of the separating hyperplane, the better, whereas in Classification Trees all misclassified observations are equally penalized.
Recently, Blanco et. al [8] proposed different SVM-based methods that provide robust classifiers under the hypothesis of label noises. The main idea supporting those methods is that labels are not reliable, and in the process of building classification rules it may be beneficial to flip some of the labels of the training sample to obtain more accurate classifiers. With this paradigm, one of the proposed methods, RE-SVM, is based on constructing a SVM separating hyperplane, but simultaneously allowing observations to be relabeled during the training process. The results obtained by this method, in datasets in which noise was added to the training labels, showed that this strategy outperforms, in terms of accuracy, classical SVM and other SVM-based robust methodologies. See [5] for alternative robust classifiers under label noise.
In this paper we propose a novel binary supervised classification method, called Optimal Classification Tree with Support Vector Machines (OCTSVM), that profits both from the ideas of SVM and OCT to build classification rules. Specifically, our method uses the hierarchical structure of OCTs, which leads to easily interpretable rules, but splits are based on SVM hyperplanes, maximizing the margin between the two classes at each node of the tree. The fact that the combination of SVM and classification tree tools provides enhanced classifiers is not new. A similar approach can be found in [3]. Nevertheless, in that paper the authors analyze the greedy CART strategy by incorporating, sequentially the maximization of the margin, over known assignments of observations to the leaves of the tree. Opposite to that, OCTSVM does not assume those assumptions and it performs an exact optimization approach. Moreover, this new method also incorporates decisions on relabeling observations in the training dataset, making it specially suitable for datasets where adversary attacks are suspected. The results of our experiments show that OCTSVM outperforms other existing methods under similar testing conditions. The rest of the paper is organized as follows. In Section 2 we recall the main ingredients of our approach, in particular, SVM, RE-SVM and OCTs, as well as the notation used through the paper. Section 3 is devoted to introduce our methodology, and presents a valid Mixed Integer Non Linear Progamming (MINLP) formulation. In Section 4 we report the results obtained in our computational experience, in particular, the comparison of our method with OCT, OCT-H and the greedy CART. Finally, some conclusions and further research on the topic are drawn in Section 5.

Preliminaries
In this section we recall the main ingredients in the approach that will be presented in Section 3 which allows us to construct robust classifiers under label noises, namely, Support Vector Machines with Relabeling (RE-SVM) and Optimal Classification Trees with oblique splits (OCT-H).
All through this paper, we consider that we are given a training sample X = {(x 1 , y 1 ) , . . . (x n , y n ), } ⊆ R p ×{−1, +1}, in which p features have been measured for a set of n individuals (x 1 , . . . , x n ) as well as a ±1 label is also known for each of them (y 1 , . . . , y n ). The goal of supervised classification is, to derive, from X , a decision rule D X : R p → {−1, 1} capable to accurately predict the right label of out-sample observations given only the values of the features. We assume, without loss of generality that the features are normalized, i.e., x i ∈ [0, 1] p .
One of the most used optimization-based method to construct classifiers for binary labels is SVM [15]. This classifier is constructed by means of a separating hyperplane in the feature space, H = {z ∈ R p : ω z + ω 0 = 0}, such that the decision rule becomes: To construct such a hyperplane, SVM chooses the one that simultaneously maximizes the separation between classes and minimizes the errors of misclassified observations. These errors are measures proportional to the distances (in the feature space) from the observations to their label half-space. SVM can be formulated as a convex non linear programming (NLP) problem. This approach allows one for the use of a kernel function as a way of embedding the original data in a higher dimension space where the separation may be easier without increasing the difficulty of solving the problem (the so-called kernel trick).
On the other hand, SVM has also been studied in the context of robust classification. In [8] three new models derived from SVM are developed to be applicable to datasets in which the observations may have wrong labels in the training sample. This characteristic is incorporated into the models by allowing some of the labels to be swapped (relabelled) at the same time that the separating hyperplane is built. Two of these models combine SVM with cluster techniques in a single optimization problem while the third method, the so-called RE-SVM, relabels observations based on misclassification errors without using clustering techniques, what makes it easier to train. The RE-SVM problem can be formulated as: where ξ i takes value 1 if the ith observation of the training sample is relabelled, and 0 otherwise and e i is the misclassifying error defined as the hinge loss: The costs parameters c 1 and c 2 (unit cost per misclassifying error and per relabelled observation) allows one to find a trade-off between large separation between classes: c 1 and c 2 are parameters modelling the unit cost of misclassified errors and relabelling, respectively. ( · 2 stands for the Euclidean norm in R p .) Constraints (1) assures the correct definition of the hinge loss and relabelling variables. The problem above can be reformulated as a Mixed Integer Second Order Cone Optimization (MISOCO) problem, for which off-the-shelf optimization solvers as CPLEX or Gurobi are able to solve medium size instances in reasonable CPU time.
Classification Trees (CT) are a family of classification methods based on a hierarchical relation among a set of nodes. The decision rule for CT methods is built by recursively partitioning the feature space by means of hyperplanes. At the first stage, a root node for the tree is considered where all the observations belongs to. Branches are sequentially created by splits on the feature space, creating intermediate nodes until a leaf node is reached. Then, the predicted label for an observation is given by the majority class of the leaf node where it belongs to.
Specifically, at each node, t, of the tree a hyperplane H t = {z ∈ R p : ω t z + ω t0 = 0} is constructed and the splits are defined as ω t z + ω t0 < 0 (left branch) and ω t z + ω t0 ≥ 0 (right branch). In Fig. 1 we show a simple classification tree with depth two, for a small dataset with 6 observations, that are correctly classified on the leaves.
The most popular method to construct Classification Trees from a training dataset is CART, introduced by Brieman et. al [13]. CART is a greedy heuristic approach, which myopically constructs the tree without further foreseen to deeper nodes. Starting at the root node, it decides the splits by means of hyperplanes minimizing an impurity function in each node. Each split results in two new nodes, and this procedure is repeated until a stopping criterion is reached (maximal depth, minimum number of observations in the same class, etc). CART produces deep trees, which may lead to overfitting in out-of-sample observations. Also, trees are normally subject to a prune process based on the trade-off between the impurity function reduction and a cost-complexity parameter. The main advantage of CART is that it is easy to implement and fast to train. On the other hand, Bertsimas and Dunn [4] have recently proposed an optimal approach to build CTs by solving a mathematical programming problems which builds the decision tree in a compact model considering its whole structure and at the same time making decisions on pruning or not pruning the branches.
Given a maximum depth, D, for the Classification Tree it can have at most T = 2 D+1 − 1 nodes. These nodes are differentiated in two types: We use the following notation concerning the hierarchical structure of a tree: • p(t): parent node of node t, for t = 1, . . . , T .
• τ bl : set of nodes that follow the left branch on the path from their parent nodes. Analogously, we define τ br as the set of nodes whose right branch has been followed on the path from their parent nodes. • u: set of nodes that have the same depth inside the tree. We represent by U the whole set of levels. The root node is the zero-level, u 0 , hence, for a given depth D we have D + 1 levels, being u D the set of leaf nodes.
OCTs are constructed by minimizing the following objective function: where L t stands for the misclassification errors at the leaf t (measured as the number of wrongly classified observations in the leaf), and d t is a binary variable that indicates if a split is produced at t. Therefore, the constant α is used to regulate the trade-off between the complexity (depth) and the accuracy (misclassifying errors of the training sample) of the tree. In its simplest version, motivated by what it is done in CART, the splits are defined by means of a single variable, i.e., in the form ω tj x j + ω t0 ≤ 0. Nevertheless, OCT can be extended to a more complex version where the splits are hyperplanes defined by their normal vector, a ∈ R p which is known as OCT-H. Moreover, a robust version of OCT has also been studied under the noise label scenario in [5].

Optimal Classification Trees with SVM splits and Relabeling (OCTSVM)
This section is devoted to introduce our new classification methodology, namely OCTSVM. The rationale of this approach is to combine the advantage of hierarchical classification methods such as Classification Trees, with the benefits from using distance-based classification errors, by means of hyperplanes maximizing the margin between classes (SVM paradigm). Therefore, this new model rests on the idea of constructing an optimal classification tree in which the splits of the nodes are performed by following the underling ideas of model (RE − SVM): 1) the splits are induced by hyperplanes in which the positive and the negative class are separated maximizing the margin between classes, 2) minimizing the classification errors, and 3) allowing observations to be relabeled along the training process. In contrast to what it is done in other Classification Tree methods, OCTSVM does not make a distinction (beyond the hierarchical one) between branch and leaf nodes, in the sense that RE-SVM based splits are sequentially applied in each node, and the final classification for any observation comes from the hyperplanes resulting at the last level of the tree, in case there are no pruned branches, or at the last node where a split was made in case of a pruned branch.
As it has been pointed out before, OCT-H is a classification tree that allows the use of general (oblique) hyperplane splits, which is built by solving a single optimization problem that takes into account the whole structure of the tree. Nevertheless, despite the good results this method has proven to obtain in real classification problems, a further improvement is worth to be considered. In Fig.  2 we see a set of points in the plane differentiated by colors in two classes. Looking at the left picture, one can see one of the optimal solutions of OCT-H for depth equal to two, where the red hyperplane is the split applied at the root node and the black ones are applied on the left and right descendants, which define the four leaves. This solution is optimal, for a certain value of the cost-complexity parameters, since it does not make any mistakes on the final classification. Nevertheless, since this method does not have any kind of control on the distances from points to the hyperplanes, one can observe that the blue class has very tiny margins at the leaves, and hence, for this class, misclassification errors are more likely to occur in out-of-sample observations. On the other hand, on the right side of Fig. 2 one sees another possible optimal solution for the OCTSVM model with depth equal to one. Again, the red hyperplane is the split applied at the root node and the black ones are the classification splits applied at the two leaves. Despite these two methods are obtaining a perfect classification on the training sample, Fig. 2 shows that OCTSVM provides a more balanced solution than OCT-H since it has wider margins between both classes, what could be translated into a higher accuracy for out of sample observations. In order to formulate the OCTSVM as a MINLP, we will start describing the rationale of its objective function that must account for the margins induced by the splits at all nodes, the classification errors, the penalty paid for relabelling observations and the cost complexity of the final classification tree. To formulate the above concepts we need different sets of variables. First of all, we consider continuous variables: ω t ∈ R p , ω t 0 ∈ R, t = 1, . . . , T , which represent the coefficients and the intercept of the hyperplane performing the split at node t. Taking into account that the margin of a hyperplane is given by 2 ||ωt|| , maximizing the minimum margin between classes induced by the splits can be done introducing an auxiliary variable δ ∈ R (that will be minimized in the objective function) which is enforced by the following constraints: Once the maximization of the margin is set, we have to model the minimization of the errors at the nodes, whereas at the same time we minimize the number of relabelled observations. These two tasks are accomplished by the variables e it ∈ R, i = 1, . . . , n, t = 1, . . . , T , that account for the misclassification error of observation i at node t, and ξ it ∈ {0, 1} binary variables modelling whether observation i is relabeled or not at node t. If c 1 and c 2 are the unit costs of misclassification and relabelling, respectively, our goal is achieved adding to the objective function the following two terms: The correct meaning of these two sets of variables must be enforced by some families of constraints that we describe next. Nevertheless, for the sake of readability before describing those constraints modeling these e it and ξ it , we must introduce another family of variables the β it ∈ R p , β i0 ∈ R, i = 1, . . . , n, t = 1, . . . , T , which are continuous variables equal to the coefficients of the separating hyperplane at node t when observation i is relabelled, and equal to zero otherwise. In addition, we consider binary variables z it ∈ {0, 1} needed to control whether observation i belongs to node t of the tree. Now, putting all these elements together, as it is done in RE-SVM, we can properly define the splits and their errors at each node of the tree using the following constraints: β itj = ξ it ω tj , ∀i = 1, . . . , N, t = 0, . . . , T, j = 0, . . . , p.
Constraints (4), which can be easily linearized, are used to define the β it variables: they equal the ω t variables when the observation i is relabelled (ξ i = 1), and are equal to zero otherwise (ξ i = 0). On the other hand, constraints (3) control the relabelling at each node of the tree. If an observation i is in node t (z it = 1), and ξ i = 0, we obtain the standard SVM constraints for the separating hyperplane. Nevertheless, if ξ i = 1, then the separating constraints are applied for the observation i as if its class were the opposite to its actual one, i.e., as if observation i is relabeled. Moreover, since M is a big enough constant, these constraints do not have any kind of impact in the error variables of node t if observation i does not belong to this node (z it = 0). The final term to be included in the objective function of the problem is the complexity of the resulting tree. Following the approach in OCT and OCT-H, we consider binary variables d t ∈ {0, 1} , t = 1, . . . , T , that account whether a split is applied at node t. Thus, to control the tree complexity resulting of the process, we minimize the sum of these variables multiplied by a cost penalty c 3 .
Gathering all the components together, the objective function to be minimized in our problem results in According to this, we need to consider the following constraints so as to obtain a suitable modeling for the d t variables: By imposing this, and being M a big enough constant, d t = 0 only if ω t 2 = 0, that is, if there is no split at node t. On the other hand, in case a split is applied at node t, ω t 2 > 0, and hence d t is forced to assume the value one. Another point that is important to remark about the d t variables is that once a non-leaf node does not split (that is, the corresponding branch is pruned at this node), the successors of node t can not make splits either to maintain the correct hierarchical structure of the tree. Recalling that p(t) is the parent node of node t, we can guarantee this relationship throughout the following constraints There are still some details left that must be imposed to make the model work as required. In the decision tree, observations start at the root node and they advance descending through the levels of the tree until they reach a leaf or a pruned node. Hence, we have to guarantee that observations must belong to one, and only one, node per level. By means of the z it variables, this can be easily done by the usual assignment constraints applied in each level, u ∈ U , of the tree: Moreover, for consistency in the relation between a node and its ancestor, it is clear that if observation i is in node t (z it = 1), then, observation i must be also in the parent of node t (z ip(t) = 1), with the only exception of the root node. Besides, if observation i is not in node t (z it = 0), then i can not be in its successors, and this is modeled by adding the following constraints to the problem: So far, the OCTSVM model has everything it needs to properly perform the splits by following the RE-SVM rationale described in (RE − SVM), taking into consideration the tree complexity, and maintaining the hierarchical relationship among nodes. The last element that we need to take care of, to assure the correct performance of the whole model, is to define how observations follow their paths inside the tree. We get from constraints (8) that observations move from parent to children (nodes), but every non terminal node has a left and a right child node, and we need to establish how observations take the left or the right branch. Since the splits are made by the separating hyperplane, we force observations that lie on the positive half space of a hyperplane to follow the right branch of the parent node, and observations that lie con the negative one to take the left branch. This behavior is modeled with the binary variables θ it ∈ {0, 1}, that are used to identify if observation i lies in the positive half space of the separating hyperplane at node t, θ it = 1, or if observation i lies on the negative half space, θ it = 0. By considering M a big enough constant, the correct behavior of path followed by the observations is enforced by the following constraints: Hence, by making use of these θ it variables, and distinguishing between nodes that come from left splits, τ bl (nodes indexed by even numbers), and right splits, τ br (nodes indexed by odd numbers), we control that the observations follow the paths through the branches in the way we described above throughout the following constraints: According to constraints (11), if an observation i is on the parent node of an even node t (z ip(t) = 1), and i lies on the negative half space of the hyperplane defining the split on p(t) (θ ip(t) = 0), then z it is forced to be 1. Hence, θ ip(t) = 0 implies that observation i takes the left branch to the child node t ∈ τ bl . Moreover, we can see that this constraint is consistent since if z ip(t) = 1, but observation i is not in the left child node, z it = 0, t ∈ τ bl , then θ ip(t) equals 1, and which means that observation i lies on the positive half space of the hyperplane of p(t).
On the other hand, constraints 12 are similar but for the right child nodes, τ br . If an observation i is in the parent node of an odd node t ∈ τ br , and i lies on the positive half space of the hyperplane of p(t) (θ ip(t) = 1), then, z it = 1 what means that observation i has to be on node t.
Gathering all the constraints together, the OCTSVM model is obtained by solving the following MINLP:

Experiments
In this section we present the results of our computational experiments. Four different Classification Tree-based methods are compared, CART, OCT, OCT-H and OCTSVM, on eight popular real-life datasets from UCI Machine Learning Repository [18]. The considered datasets together with their dimensions (n: number of observations and p: number of features) are shown in Table 1 Our computational experience focuses on the analysis of the accuracy of the different classification trees-based methods. This analysis is based in four different experiments per each one of the eight considered dataset. Our goal is to analyze the robustness of the different methods against label noise in the data. Therefore, in our experiments we use, apart from the original datasets, three different modifications where in each one of them a percentage of the labels in the sample are randomly flipped. The percentages of flipped labels range in {0%, 20%, 30%, 40%}, where 0% indicates that the original training data set is used to construct the tree.
We perform a 4-fold cross-validation scheme, i.e., datasets are split into four random train-test partitions. One of the folds is used for training the model while the rest are used for testing. When testing the classification rules, we compute the accuracy, in percentage, on out of sample data: The CART method was coded in R using the rpart library. OCT, OCT-H and OCTSVM mathematical programming models were coded in Python and solved using Gurobi 8.1.1 on a PC Intel Core i7-7700 processor at 2.81 GHz and 16GB of RAM. A time limit of 30 seconds was set for training.
The calibration of the parameters of the different optimization-based models compared in these experiments was set as follows: • For OCTSVM we used a grid on 10 i : i = −5, . . . , 5 for the constants c 1 and c 2 , and a smaller one 10 i : i = −2, . . . , 2 for c 3 . • For CART, OCT and OCT-H we used the same grid 10 i : i = −5, . . . , 5 for the cost-complexity constant, and a threshold on the minimum number of observations per leaf equal to a 5% of the training sample size.
Last to mention, the depth, D, considered in these experiments was equal to three for CART, OCT and OCT-H, whereas for OCTSVM we fixed depth equal to two, creating consequently trees with 3 levels, to set a fair comparison among the different methods.
For each dataset, we replicate each experiment four times. In Table 2 we show the average accuracies for each one of the methods and datasets. The best average accuracies are highlighted (boldfaced).
Observe that when 0% of the training labels are flipped (i.e., the original dataset), a general trend in terms of accuracy can be observed: CART < OCT < OCT-H < OCTSVM, with the only exception of Wholesale in which CART obtains a non-meaningful slightly larger average accuracy. We would like to emphasize that these results are not surprising. Indeed, on the one hand, OCT is an optimal classification version of the CART algorithm, and hence better results should be expected from this model, as already shown in the computational experience in [4], and also evidenced in our experiments. Moreover, OCT is just a restricted version of OCT-H, in that in the latter, the set of admissible hyperplanes is larger than in the former. Also, as already pointed out in Fig. 2, OCTSVM goes one step further and, apart from allowing oblique hyperplanes based trees, has a more solid structure due to the margin maximization, the distance based errors and the possibility of relabeling points. All together turns into higher accuracy results as pointed out in our experiments. In some datasets the comparison of the different methods gives rather similar results, however in some others OCTSVM is above a 5% percent of accuracy with respect to the other three methods.
Turning to the results on datasets with flipped labels on the training dataset, OCTSVM clearly outperforms the rest of methods and consistently keeps its advantage in terms of accuracy with respect to the other three methods. OCT and OCT-H, which are both above CART, alternate higher-lower results among the different datasets. Our method, namely OCTSVM, clearly is capable to capture the wrongly labeled observations and constructs classification rules able to reach higher accuracies, even when 40% of the labels were flipped, while other methods, give rise to classifiers that significantly worsen their performance in terms of accuracy in the test sample.
The global average accuracy in the case that labels are not flipped using OCTSVM is 82.44%, being 2% better than OCT-H, 3% better than OCT and 10% better than CART. If 40% of the labels are flipped the situation is similar, being OCTSVM also 10% better than CART, and then, clearly showing the robustness of our method under label noises.

Conclusions and Further Research
Supervised classification is a fruitful field that has attracted the attention of researchers for many years. One of the methods that has experienced a more in depth transformation in the last years is classification trees. Since the pioneer contribution by Breiman et al. [13], where CART was proposed, this technique has included tools from mathematical optimization giving rise to the so called OCT [4,5], methods that are optimal in some sense. In spite of that, there is still some more room for further improvements, in particular making classifiers more robust against perturbed datasets. Our contribution is this paper goes in that direction and it augments the catalogue of classification tree methods able to handle noise in the labels of the dataset.
We have proposed a new optimal classification tree approach able to handle label noise in the data. Two main elements support our approach: the splitting rules for the classification trees are designed to maximize the separation margin between classes and wrong labels of the training sample are detected and changed at the same time that the classifier is built. The method is encoded on a Mixed Integer Second Order Order Cone Optimization problem so that one can solve medium size instances by any of the nowadays available off-the-shelf solvers. We report intensive computational experiments on a battery of datasets taken from UCI Machine Learning repository showing the effectiveness and usefulness of our approach.
Future research lines on this topic include the analysis of nonlinear splits when branching in OCTSVM, both using kernel tools derived from SVM classifiers or specific families of nonlinear separators. This approach will result into more flexible classifiers able to capture the nonlinear trends of many real-life datasets. Additionally, we also plan to address the design of math-heuristic algorithms which keep the essence of OCTs but capable to train larger datasets.