TL;DR
The paper introduces a Siamese Deep Forest (SDF), an alternative to Siamese neural networks, which uses a modified training set and a weighted class distribution to improve similarity measurement, especially with limited data.
Contribution
It proposes a novel SDF model based on gcForest, incorporating a quadratic optimization for weighting class probabilities to enhance similarity learning.
Findings
Effective distance metric demonstrated in experiments
Prevents overfitting with limited training data
Offers an alternative to neural network-based Siamese models
Abstract
A Siamese Deep Forest (SDF) is proposed in the paper. It is based on the Deep Forest or gcForest proposed by Zhou and Feng and can be viewed as a gcForest modification. It can be also regarded as an alternative to the well-known Siamese neural networks. The SDF uses a modified training set consisting of concatenated pairs of vectors. Moreover, it defines the class distributions in the deep forest as the weighted sum of the tree class probabilities such that the weights are determined in order to reduce distances between similar pairs and to increase them between dissimilar points. We show that the weights can be obtained by solving a quadratic optimization problem. The SDF aims to prevent overfitting which takes place in neural networks when only limited training data are available. The numerical experiments illustrate the proposed distance metric method.
Click any figure to enlarge with its caption.
Figure 1
Figure 2
Figure 3
Figure 4| type | index |
|---|---|
| cascade level | |
| forest | |
| tree | |
| class |
| gcF | SDF | gcF | SDF | gcF | SDF | gcF | SDF | |
|---|---|---|---|---|---|---|---|---|
| gcF | SDF | gcF | SDF | gcF | SDF | gcF | SDF | |
|---|---|---|---|---|---|---|---|---|
| gcF | SDF | gcF | SDF | gcF | SDF | gcF | SDF | |
|---|---|---|---|---|---|---|---|---|
| gcF | SDF | gcF | SDF | gcF | SDF | gcF | SDF | |
|---|---|---|---|---|---|---|---|---|
| gcF | SDF | gcF | SDF | gcF | SDF | gcF | SDF | |
|---|---|---|---|---|---|---|---|---|
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
A Siamese Deep Forest
Lev V. Utkin1 and Mikhail A. Ryabinin2
Department of Telematics
Peter the Great St.Petersburg Polytechnic University
St.Petersburg, Russia
e-mail: 1[email protected], 2[email protected]
Abstract
A Siamese Deep Forest (SDF) is proposed in the paper. It is based on the Deep Forest or gcForest proposed by Zhou and Feng and can be viewed as a gcForest modification. It can be also regarded as an alternative to the well-known Siamese neural networks. The SDF uses a modified training set consisting of concatenated pairs of vectors. Moreover, it defines the class distributions in the deep forest as the weighted sum of the tree class probabilities such that the weights are determined in order to reduce distances between similar pairs and to increase them between dissimilar points. We show that the weights can be obtained by solving a quadratic optimization problem. The SDF aims to prevent overfitting which takes place in neural networks when only limited training data are available. The numerical experiments illustrate the proposed distance metric method.
Keywords: classification, random forest, decision tree, Siamese, deep learning, metric learning, quadratic optimization
1 Introduction
One of the important machine learning tasks is to compare pairs of objects, for example, pairs of images, pairs of data vectors, etc. There are a lot of approaches for solving the task. One of the approaches is based on computing a corresponding pairwise metric function which measures a distance between data vectors or a similarity between the vectors. This approach is called the metric learning [1, 14, 27]. It is pointed out by Bellet et al. [1] in their review paper that the metric learning aims to adapt the pairwise real-valued metric function, for example, the Mahalanobis distance or the Euclidean distance, to a problem of interest using the information provided by training data. A detailed description of the metric learning approaches is also represented by Le Capitaine [5] and by Kulis [14]. The basic idea underlying the metric learning solution is that the distance between similar objects should be smaller than the distance between different objects.
Suppose there is a training set consisting of pairs of examples and such that a binary label is assigned to every pair . If two data vectors and are semantically similar or belong to the same class of objects, then takes the value [math]. If the vectors correspond to different or semantically dissimilar objects, then takes the value . This implies that the training set can be divided into two subsets. The first subset is called the similar or positive set and is defined as
[TABLE]
The second subset is the dissimilar or negative set. It is defined as
[TABLE]
If we have two observation vectors and from the training set, then the distance should be minimized if and are semantically similar, and it should be maximized between dissimilar and . The most general and popular real-valued metric function is the squared Mahalanobis distance which is defined for vectors and as
[TABLE]
Here is a symmetric positive semi-defined matrix. If and are random vectors from the same distribution with covariance matrix , then . If is the identity matrix, then is the squared Euclidean distance.
Given subsets and , the metric learning optimization problem can be formulated as follows:
[TABLE]
where is a loss function that penalizes violated constraints; is some regularizer on ; is the regularization parameter.
There are many useful loss functions which take into account the condition that the distance between similar objects should be smaller than the distance between different objects. These functions define a number of learning methods. It should be noted that the learning methods using the Mahalanobis distance assume some linear structure of data. If this is not valid, then the kernelization of linear methods is one of the possible ways for solving the metric learning problem. Bellet et al. [1] review several approaches and algorithms to deal with nonlinear forms of metrics. In particular, these are the Support Vector Metric Learning algorithm provided by Xu et al. [26], the Gradient-Boosted Large Margin Nearest Neighbors method proposed by Kedem et al. [12], the Hamming Distance Metric Learning algorithm provided by Norouzi et al. [19].
A powerful implementation of the metric learning dealing with non-linear data structures is the so-called Siamese neural network introduced by Bromley et al. [4] in order to solve signature verification as a problem of image matching. This network consists of two identical sub-networks joined at their outputs. The two sub-networks extract features from two input examples during training, while the joining neuron measures the distance between the two feature vectors. The Siamese architecture has been exploited in many applications, for example, in face verification [7], in the one-shot learning in which predictions are made given only a single example of each new class [13], in constructing an inertial gesture classification [2], in deep learning [23], in extracting speaker-specific information [6], for face verification in the wild [11]. This is only a part of successful applications of Siamese neural networks. Many modifications of Siamese networks have been developed, including fully-convolutional Siamese networks [3], Siamese networks combined with a gradient boosting classifier [15], Siamese networks with the triangular similarity metric [27].
One of the difficulties of the Siamese neural network as well as other neural networks is that limited training data lead to overfitting when training neural networks. Many different methods have been developed to prevent overfitting, for example, dropout methods [21] which are based on combination of the results of different networks by randomly dropping out neurons in the network. A very interesting new method which can be regarded as an alternative to deep neural networks is the deep forest proposed by Zhou and Feng [28] and called the gcForest. In fact, this is a multi-layer structure where each layer contains many random forests, i.e., this is an ensemble of decision tree ensembles. Zhou and Feng [28] point out that their approach is highly competitive to deep neural networks. In contrast to deep neural networks which require great effort in hyperparameter tuning and large-scale training data, gcForest is much easier to train and can perfectly work when there are only small-scale training data. The deep forest solves tasks of classification as well as regression. Therefore, by taking into account its advantages, it is important to modify it in order to develop a structure solving the metric learning task. We propose the so-called Siamese Deep Forest (SDF) which can be regarded as an alternative to the Siamese neural networks and which is based on the gcForest proposed by Zhou and Feng [28] and can be viewed as its modification. Three main ideas underlying the SDF can be formulated as follows:
We propose to modify training set by using concatenated pairs of vectors. 2. 2.
We define the class distributions in the deep forest as the weighted sum of the tree class probabilities where the weights are determined in order to reduce distances between semantically similar pairs of examples and to increase them between dissimilar pairs. The weights are training parameters of the SDF. 3. 3.
We apply the greedy algorithm for training the SDF, i.e., the weights are successively computed for every layer or level of the forest cascade.
We consider the case of the weakly supervised learning [1] when there are no information about the class labels of individual training examples, but only information in the form of sets and is provided, i.e., we know only semantic similarity of pairs of training data. However, the case of the fully supervised learning when the class labels of individual training examples are known can be considered in the same way.
It should be noted that the SDF cannot be called Siamese in the true sense of the word. It does not consist of two gcForests like the Siamese neural network. However, its aim coincides with the Siamese network aim. Therefore, we give this name for the gcForest modification.
The paper is organized as follows. Section 2 gives a very short introduction into the Siamese neural networks. A short description of the gcForest proposed by Zhou and Feng [28] is given in Section 3. The ideas underlying the SDF are represented in Section 4 in detail. A modification of the gcForest using the weighted averages, which can be regarded as a basis of the SDF is provided in Section 5. Algorithms for training and testing the SDF are considered in Section 6. Numerical experiments with real data illustrating cases when the proposed SDF outperforms the gcForest are given in Section 7. Concluding remarks are provided in Section 8.
2 Siamese neural networks
Before studying the SDF, we consider the Siamese neural network which is an efficient and popular tool for dealing with data of the form and . It will be a basis for constructing the SDF.
A standard architecture of the Siamese network given in the literature (see, for example, [7]) is shown in Fig. 1. Let and be two data vectors corresponding to a pair of elements from a training set, for example, images. Suppose that is a map of and to a low-dimensional space such that it is implemented as a neural network with the weight matrix . At that, parameters are shared by two neural networks and denoted as and and corresponding to different input vectors, i.e., they are the same for the two neural networks. The property of the same parameters in the Siamese neural network is very important because it defines the corresponding training algorithm. By comparing the outputs and using the Euclidean distance , we measure the compatibility between and .
If we assume for simplicity that the neural network has one hidden layer, then there holds
[TABLE]
Here is an activation function; is the weight matrix such that its element is the weight of the connection between unit in the input layer and unit in the hidden layer, , ; is a bias vector; is the vector of neuron activations, which depends on the input vector .
The Siamese neural network is trained on pairs of observations by using specific loss functions, for example, the following contrastive loss function:
[TABLE]
where is a predefined threshold.
Hence, the total error function for minimizing is defined as
[TABLE]
Here is a regularization term added to improve generalization of the neural network, is a hyper-parameter which controls the strength of the regularization. The above problem can be solved by using the stochastic gradient descent scheme.
3 Deep Forest
According to [28], the gcForest generates a deep forest ensemble, with a cascade structure. Representation learning in deep neural networks mostly relies on the layer-by-layer processing of raw features. The gcForest representational learning ability can be further enhanced by the so-called multi-grained scanning. Each level of cascade structure receives feature information processed by its preceding level, and outputs its processing result to the next level. Moreover, each cascade level is an ensemble of decision tree forests. We do not consider in detail the Multi-Grained Scanning where sliding windows are used to scan the raw features because this part of the deep forest is the same in the SDF. However, the most interesting component of the gcForest from the SDF construction point of view is the cascade forest.
Given an instance, each forest produces an estimate of class distribution by counting the percentage of different classes of examples at the leaf node where the concerned instance falls into, and then averaging across all trees in the same forest. The class distribution forms a class vector, which is then concatenated with the original vector to be input to the next level of cascade. The usage of the class vector as a result of the random forest classification is very similar to the idea underlying the stacking method [24]. The stacking algorithm trains the first-level learners using the original training data set. Then it generates a new data set for training the second-level learner (meta-learner) such that the outputs of the first-level learners are regarded as input features for the second-level learner while the original labels are still regarded as labels of the new training data. In fact, the class vectors in the gcForest can be viewed as the meta-learners. In contrast to the stacking algorithm, the gcForest simultaneously uses the original vector and the class vectors (meta-learners) at the next level of cascade by means of their concatenation. This implies that the feature vector is enlarged and enlarged after every cascade level. The architecture of the cascade proposed by Zhou and Feng [28] is shown in Fig. 2. It can be seen from the figure that each level of the cascade consists of two different pairs of random forests which generate 3-dimensional class vectors concatenated each other and with the original input. After the last level, we have the feature representation of the input feature vector, which can be classified in order to get the final prediction. Zhou and Feng [28] propose to use different forests at every level in order to provide the diversity which is an important requirement for the random forest construction.
4 Three ideas underlying the SDF
The SDF aims to function like the standard Siamese neural network. This implies that the SDF should provide large distances between semantically similar pairs of vectors and small distances between dissimilar pairs. We propose three main ideas underlying the SDF:
Denote the set indices of all pairs and as We train every tree by using the concatenation of two vectors and such that the class is defined by the semantical similarity of the vectors. In fact, the trees are trained on the basis of two classes and reflect the semantical similarity of pairs, but not classes of separate examples. With this concatenation, we define a new set of classes such that we do not need to know separate classes for or for . As a result, we have a new training set and exploit only the information about the semantical similarity. The concatenation is not necessary when the classes of training elements are known, i.e., we have a set of labels . In this case, only the second idea can be applied. 2. 2.
We partially use some modification of ideas provided by Xiong et al. [25] and Dong et al. [8]. In particular, Xiong et al. [25] considered an algorithm for solving the metric learning problem by means of the random forests. The proposed metric is able to implicitly adapt its distance function throughout the feature space. Dong et al. [8] proposed a random forest metric learning (RFML) algorithm, which combines semi-multiple metrics with random forests to better separate the desired targets and background in detecting and identifying target pixels based on specific spectral signatures in hyperspectral image processing. A common idea underlying the metric learning algorithms in [25] and [8] is that the distance measure between a pair of training elements for a combination of trees is defined as average of some special functions of the training elements. For example, if a random forest is a combination of decision trees , then the distance measure is
[TABLE]
Here is a mapping function which is specifically defined in [25] and [8]. We combine the above ideas with the idea of probability distributions of classes provided in [28] in order to produce a new feature vector after every level of the cascade forest. According to [28], each forest of a cascade level produces an estimate of the class probability distribution by counting the percentage of different classes of training examples at the leaf node where the concerned instance falls into, and then averaging across all trees in the same forest. Our idea is to define the forest class distribution as a weighted sum of the tree class probabilities. At that, the weights are computed in an optimal way in order to reduce distances between similar pairs and to increase them between dissimilar points.
The obtained weights are very similar to weights of the neural network connections between neurons, which are also computed during training the neural network. The trained values of weights in the SDF are determined in accordance with a loss function defining properties of the SDF or the neural network. Due to this similarity, we will call levels of the cascade as layers sometimes.
It should be also noted that the first idea can be sufficient for implementing the SDF because the additional features (the class vectors) produced by the previous cascade levels partly reflect the semantical similarity of pairs of examples. However, in order to enhance the discriminative capability of the SDF, we modify the corresponding class distributions. 3. 3.
We apply the greedy algorithm for training the SDF that is we train separately every level starting from the first level such that every next level uses results of training at the previous level. In contrast to many neural networks, the weights considered above are successively computed for every layer or level of the forest cascade.
5 The SDF construction
Let us introduce notations for indices corresponding to different deep forest components. The indices and their sets of values are shown in Table 1. One can see from Table 1, that there are levels of the deep forest or the cascade, every level contains forests such that every forest consists of trees. If we use the concatenation of two vectors and for defining new classes of semantically similar and dissimilar pairs, then the number of classes is . It should be noted that the class corresponds to label of a training example from the set .
Suppose we have trained trees in the SDF. One of the approaches underlying the deep forest is that the class distribution forms a class vector which is then concatenated with the original vector to be an input to the next level of the cascade. Suppose a pair of the original vectors is , and the is the probability of class for the pair produced by the -th tree from the -th forest at the cascade level . Below we use the triple index in order to indicate that the element belongs to the -th tree from the -th forest at the cascade level . The same can be said about subsets of the triple. Then, according to [28], the element of the class vector corresponding to class and produced by the -th forest in the gcForest is determined as
[TABLE]
Denote the obtained class vector as . Then the concatenated vector after the first level of the cascade is
[TABLE]
It is composed of the original vectors , and class vectors obtained from forests at the first level. In the same way, we can write the concatenated vector after the -th level of the cascade as
[TABLE]
In order to reduce the number of indices, we omit the index below because all derivations will concern only level , where may be arbitrary from to . We also replace notations and with and , respectively, assuming that the number of forests and numbers of trees strongly depend on the cascade level.
The vector in (2) has been derived in accordance with the gcForest algorithm [28]. However, in order to implement the SDF, we propose to change the method for computing elements of the class vector, namely, the averaging is replaced with the weighted sum of the form:
[TABLE]
Here is a weight for combining the class probabilities of the -th tree from the -th forest at the cascade level . The weights play a key role in implementing the SDF. An illustration of the weighted averaging is shown in Fig. 3, where we partly modify a picture from [28] (the left part is copied from [28, Fig. 2]) in order to show how elements of the class vector are derived as a simple weighted sum. It can be seen from Fig. 3 that two-class distribution is estimated by counting the percentage of different classes ( or ) of new training concatenated examples at the leaf node where the concerned example falls into. Then the class vector of is computed as the weighted average. It is important to note that we weigh trees belonging to one of the forests, but not classes, i.e., the weights do not depend on the class . Moreover, the weights characterize trees, but not training elements. This implies that they do not depend on the vectors , too. One can also see from Fig. 3 that the augmented features and or the class vector corresponding to the -th forest are obtained as weighted sums, i.e., there hold
[TABLE]
The weights are restricted by the following obvious condition:
[TABLE]
In other words, we have the weighted averages for every forest, and the corresponding weights can be regarded as trained parameters in order to decrease the distance between semantically similar and and to increase the distance between dissimilar and . Therefore, we have to develop a way for training the SDF, i.e., for computing the weights for every forest and for every cascade level.
Now we have numbers for every class. Let us analyze these numbers from the point of the SDF aim view.
First, we consider the case when and . However, we may have non-zero for both classes. It is obvious that (the average probability of class ) should be as large as possible because . Moreover, (the average probability of class ) should be as small as possible because .
We can similarly write conditions for the case when and . In this case, should be as small as possible because , and should be as large as possible because .
In sum, we should increase (decrease) if (). In other words, we have to find the weights maximizing (minimizing) when (). The ideal case is when by and by . However, the vector of weights has to be the same for every class, and it does not depend on a certain class. At first glance, we could find optimal weights for every individual forest separately from other forests. However, we should analyze simultaneously all forests because some vectors of weights may compensate those vectors which cannot efficiently separate and .
6 The SDF training and testing
We apply the greedy algorithm for training the SDF, namely, we train separately every level starting from the first level such that every next level uses results of training at the previous level. The training process at every level consists of two parts. The first part aims to train all trees by applying all pairs of training examples. This part does not significantly differ from the training of the original deep forest proposed by Zhou and Feng [28]. The difference is that we use pairs of concatenated vectors and two classes corresponding to semantic similarity of the pairs. The second part is to compute the weights , . This can be done by minimizing the following objective function over unit (probability) simplices in denoted as , i.e., over non-negative vectors , , that sum up to one:
[TABLE]
Here is a vector produced as the concatenation of vectors , , is a regularization term, is a hyper-parameter which controls the strength of the regularization. We define the regularization term as
[TABLE]
The loss function has to increase values of augmented features corresponding to the class and to decrease features corresponding to the class for semantically similar pairs . Moreover, the loss function has to increase values of augmented features corresponding to the class and to decrease features corresponding to the class for dissimilar pairs .
6.1 Convex loss function
Let us denote the set of vectors as . In order to efficiently solve the problem (5), the condition of the convexity of in the domain of should be fulfilled. One of the ways for determining the loss function is to consider a distance between two vectors and at the -th level. However, we do not have separate vectors and . We have one vector whose parts correspond to vectors and . Therefore, this is a distance between elements of the concatenated vector obtained at level and augmented features , , of a special form. Let us consider the expression for the above distance in detail. It consists of terms. The first term denoted as is the Euclidean distance between two parts of the output vector obtained at the previous level
[TABLE]
Here is the -th element of , is the length of the input vector for the -th level or the length of the output vector for the level with the number .
Let us consider elements and now. We have to provide the distance between these elements as large as possible taking into account . In particular, if , then we should decrease the difference . If , then we should decrease the difference . Let us introduce the variable if , and if . Then the following expression characterizing the augmented features and can be written:
[TABLE]
Substituting (3) into the above expression, we get next terms
[TABLE]
where
[TABLE]
Finally, we can write
[TABLE]
So, we have to maximize with respect to under constraints (4). Since does not depend on , then we consider the following objective function
[TABLE]
The function is convex in the interval of . Then the objective function as the sum of the convex functions is convex too with respect to weights.
6.2 Quadratic optimization problem
Let us consider the problem (7) under constraints (4) in detail. Introduce a new variable defined as
[TABLE]
Then problem (7) can be rewritten as
[TABLE]
subject to (4)
[TABLE]
We have obtained the standard quadratic optimization problem with linear constraints and variables and . It can be solved by using the well-known standard methods.
It is interesting to note that the optimization problem (8)-(9) can be decomposed into problems of the form:
[TABLE]
subject to (4)
[TABLE]
Indeed, by returning to problem (8)-(9), we can see that the subset of variables and for a certain and constraints for these variables do not overlap with the subset of similar variables for another and the corresponding constraints. This implies that (8) can be rewritten as
[TABLE]
and the problem can be decomposed.
So, we solve the problem (10)-(11) for every and get vectors which form the vector . The above means that the optimal weights are separately determined for individual forests.
6.3 A general algorithm for training and the SDF testing
In sum, we can write a general algorithm for training the SDF (see Algorithm 1). Its complexity mainly depends on the number of levels.
Having the trained SDF with computed weights for every cascade level, we can make decision about the semantic similarity of a new pair of examples and . First, the vectors make to be concatenated. By using the trained decision trees and the weights for every level , the pair is augmented at each level. Finally, we get
[TABLE]
Here is the augmented part of the vector consisting of elements from subvectors and corresponding to the class and to the class , respectively. The original examples and are semantically similar if the sum of all elements from is larger than the sum of elements from , i.e., , where is the unit vector. In contrast to the similar examples, the condition means that and are semantically dissimilar and . We can introduce a threshold for a more robust decision making. The examples and are classified as semantically similar and if . The case can be viewed as undeterminable.
It is important to note that the identical weights, i.e., the gcForest can be regarded as a special case of the SDF.
7 Numerical experiments
We compare the SDF with the gcForest whose inputs are concatenated examples from series data sets. In other words, we compare the SDF having computed (trained) weights with the SDF having identical weights. The SDF has the same cascade structure as the standard gcForest described in [28]. Each level (layer) of the cascade structure consists of 2 complete-random tree forests and 2 random forests. Three-fold cross-validation is used for the class vector generation. The number of cascade levels is automatically determined.
A software in Python implementing the gcForest is available at https://github.com/leopiney/deep-forest. We modify this software in order to implement the procedure for computing optimal weights and weighted averages . Moreover, we use pairs of concatenated examples composed of individual examples as training and testing data.
Every accuracy measure used in numerical experiments is the proportion of correctly classified cases on a sample of data. To evaluate the average accuracy, we perform a cross-validation with repetitions, where in each run, we randomly select training data and test data.
First, we compare the SDF with the gcForest by using some public data sets from UCI Machine Learning Repository [17]: the Yeast data set (1484 instances, 8 features, 10 classes), the Ecoli data set (336 instances, 8 features, 8 classes), the Parkinsons data set (197 instances, 23 features, 2 classes), the Ionosphere data set (351 instances, 34 features, 2 classes). A more detailed information about the data sets can be found from, respectively, the data resources. Different values for the regularization hyper-parameter have been tested, choosing those leading to the best results.
In order to investigate how the number of decision trees impact on the classification accuracy, we study the SDF by different number of trees, namely, we take , , , . It should be noted that Zhou and Feng [28] used trees in every forest.
Results of numerical experiments for the Parkinsons data set are shown in Table 2. It contains the accuracy measures obtained for the gcForest (denoted as gcF) and the SDF as functions of the number of trees in every forest and the number of pairs in the training set. It can be seen from Table 2 that the accuracy of the SDF exceeds the same measure of the gcForest in most cases. At that, the difference is rather large for the small amount of training data. In particular, the largest differences between accuracy measures of the SDF and the gcForest are observed by , and . Similar results of numerical experiments for the Ecoli data set are given in Table 3. It is interesting to point out that the number of trees in every forest significantly impacts on the difference between accuracy measures of the SDF and gcForest. It follows from Table 3 that this difference is smallest by the large number of trees and by the large amount of training data. If we look at the last row of Table 3, then we see that the accuracy obtained for the SDF by is reached for the gcForest by . The largest difference between accuracy measures of the SDF and the gcForest is observed by and . The same can be seen from Table 2. This implies that the proposed modification of the gcForest allows us to reduce the training time. Table 4 provides accuracy measures for the Yeast data set. We again can see that the proposed SDF outperforms the gcForest for most cases. It is interesting to note from Table 4 that the increasing number of trees in every forest may lead to reduced accuracy measures. If we look at the row of Table 4 corresponding to pairs in the training set, then we can see that the accuracy measures by trees exceed the same measures by larger numbers of trees. Moreover, the largest difference between accuracy measures of the SDF and the gcForest is observed by and . Numerical results for the Ionosphere data set are represented in Table 5. It follows from Table 5 that the largest difference between accuracy measures of the SDF and the gcForest is observed by and .
The numerical results for all analyzed data sets show that the SDF significantly outperforms the gcForest by small number of training data ( or ). This is an important property of the SDF which are especially efficient when the amount of training data is rather small.
It should be noted that the multi-grained scanning proposed in [28] was not applied to investigating the above data sets having relatively small numbers of features. The above numerical results have been obtained by using only the forest cascade structure.
When we deal with the large-scale data, the multi-grained scanning scheme should be use. In particular, for analyzing the well-known MNIST data set, we used the same scheme for window sizes as proposed in [28], where feature windows with sizes , , are chosen for raw features. We study the SDF by applying the MNIST database which is a commonly used large database of pixel handwritten digit images [16]. It has a training set of 60,000 examples, and a test set of 10,000 examples. The digits are size-normalized and centered in a fixed-size image. The data set is available at http://yann.lecun.com/exdb/mnist/. The main problem in using the multi-grained scanning scheme is that pairs of the original examples are concatenated. As a result, the direct scanning leads to scanning windows covering some parts from every example belonging to a concatenated pair, which do not correspond the images themselves. Therefore, we apply the following modification of the multi-grained scanning scheme. Two identical windows simultaneously scan two concatenated images such that pairs of feature windows are produced due to this procedure, which are concatenated for processing by means of the forest cascade. Fig. 4 illustrates the used procedure. Results of numerical experiments for the MNIST data set are shown in Table 6. It can be seen from Table 6 that the largest difference between accuracy measures of the SDF and the gcForest is observed by and . It is interesting to note that the SDF as well as the gcForest provide good results even by the small amount of training data. At that, the SDF outperforms the gcForest in the most cases.
An interesting observation has been made during numerical experiments. We have discovered that the variable , initially taking the values for and for , can be viewed as a tuning parameter in order to control the number of the cascade levels used in the training process and to improve the classification performance of the SDF. One of the great advantages of the gcForest is its automatic determination of the number of cascade levels. It is shown by Zhou and Feng [28], that the performance of the whole cascade is estimated on validation set after training a current level. The training procedure in the gcForest terminates if there is no significant performance gain. It turns out that the value of significantly impact on the number of cascade levels if to apply the termination procedure implemented in the gcForest. Moreover, we can adaptively change the values of with every level. It has been revealed that one of the best change of is , where for and for . Of course, this is an empirical observation. However, it can be taken as a direction for further improving the SDF.
8 Conclusion
One of the implementations of the SDF has been represented in the paper. It should be noted that other modifications of the SDF can be obtained. First of all, we can improve the optimization algorithm by applying a more complex loss function and computing optimal weights, for example, by means of the Frank-Wolfe algorithm [9]. We can use a more powerful optimization algorithm, for example, an algorithm proposed by Hazan and Luo [10]. Moreover, we do not need to search for the convex loss function because there are efficient optimization algorithms, for example, a non-convex modification of the Frank-Wolfe algorithm proposed by Reddi et al. [20], which allows us to solve the considered optimization problems. The trees and forests can be also replaced with other classification approaches, for example, with SVMs and boosting algorithms. However, the above modifications can be viewed as directions for further research.
The linear combinations of weights for every forest have been used in the SDF. However, this class of combinations can be extended by considering non-linear functions of weights. Moreover, it turns out that the weights of trees can model various machine learning peculiarities and allow us to solve many machine learning tasks by means of the gsForest. This is also a direction for further research.
It should be noted that the weights have been restricted by constraints of the form (4), i.e., the weights of every forest belong to the unit simplex whose dimensionality is defined by the number of trees in the forest. However, numerical experiments have illustrated that it is useful to reduce the set of weights in some cases. Moreover, this reduction can be carried out adaptively by taking into account the classification error at every level. One of the ways for adaptive reduction of the unit simplex is to apply imprecise statistical models, for example, the linear-vacuous mixture or imprecise -contaminated models proposed by Walley [22]. This study is also a direction for further research.
We have considered a weakly supervised learning algorithm when there are no information about the class labels of individual training examples, but we know only semantic similarity of pairs of training data. It is also interesting to extend the proposed ideas on the case of fully supervised algorithms when only the class labels of individual training examples are known. The main goal of fully supervised distance metric learning is to use discriminative information in distance metric learning to keep all the data samples in the same class close and those from different classes separated [18]. Therefore, another direction for further research is to adapt the proposed algorithm for the case of available class labels.
Acknowledgement
The reported study was partially supported by RFBR, research project No. 17-01-00118.
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[1] A. Bellet, A. Habrard, and M. Sebban. A survey on metric learning for feature vectors and structured data. ar Xiv preprint ar Xiv:1306.6709 , 28 Jun 2013.
- 2[2] S. Berlemont, G. Lefebvre, S. Duffner, and C. Garcia. Siamese neural network based similarity metric for inertial gesture classification and rejection. In Automatic Face and Gesture Recognition (FG), 2015 11th IEEE International Conference and Workshops on , volume 1, pages 1–6. IEEE, May 2015.
- 3[3] L. Bertinetto, J. Valmadre, J.F. Henriques, A. Vedaldi, and P.H.S. Torr. Fully-convolutional siamese networks for object tracking. ar Xiv:1606.09549 v 2 , 14 Sep 2016.
- 4[4] J. Bromley, J.W. Bentz, L. Bottou, I. Guyon, Y. Le Cun, C. Moore, E. Sackinger, and R. Shah. Signature verification using a siamese time delay neural network. International Journal of Pattern Recognition and Artificial Intelligence , 7(4):737–744, 1993.
- 5[5] H. Le Capitaine. Constraint selection in metric learning. ar Xiv:1612.04853 v 1, 14 Dec 2016.
- 6[6] K. Chen and A. Salman. Extracting speaker-specific information with a regularized siamese deep network. In Advances in Neural Information Processing Systems 24 (NIPS 2011) , pages 298–306. Curran Associates, Inc., 2011.
- 7[7] S. Chopra, R. Hadsell, and Y. Le Cun. Learning a similarity metric discriminatively, with application to face verification. In 2005 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR’05) , volume 1, pages 539–546. IEEE, 2005.
- 8[8] Y. Dong, B. Du, and L. Zhang. Target detection based on random forest metric learning. IEEE Journal of Selected Topics in Applied Earth Observations and Remote Sensing , 8(4):1830–1838, 2015.