Visual Confusion Label Tree For Image Classification

TL;DR

This paper introduces a tree-based classifier to replace fully-connected layers in CNNs, significantly improving speed and accuracy for image classification on datasets like CIFAR-100 and ImageNet.

Contribution

It proposes a Visual Confusion Label Tree with hierarchical SVM classifiers to enhance discriminability and reduce inference time in CNNs for real-time applications.

Findings

Achieved 124x and 115x speedup on AlexNet and VGG16.

Improved top-1 accuracy by 4.3% on CIFAR-100.

Improved top-1 accuracy by 2.4% on ImageNet.

Abstract

Convolution neural network models are widely used in image classification tasks. However, the running time of such models is so long that it is not the conforming to the strict real-time requirement of mobile devices. In order to optimize models and meet the requirement mentioned above, we propose a method that replaces the fully-connected layers of convolution neural network models with a tree classifier. Specifically, we construct a Visual Confusion Label Tree based on the output of the convolution neural network models, and use a multi-kernel SVM plus classifier with hierarchical constraints to train the tree classifier. Focusing on those confusion subsets instead of the entire set of categories makes the tree classifier more discriminative and the replacement of the fully-connected layers reduces the original running time. Experiments show that our tree classifier obtains a significant improvement over the state-of-the-art tree classifier by 4.3% and 2.4% in terms of top-1 accuracy on CIFAR-100 and ImageNet datasets respectively. Additionally, our method achieves 124x and 115x speedup ratio compared with fully-connected layers on AlexNet and VGG16 without accuracy decline.

Tables

Table 1. Table 1 : Classification accuracy of different tree classifiers.

Approaches	CIFAR-100	ImageNet
Semantic ontology	$48.95\%$	$44.47\%$
Label tree	$52.04\%$	$49.64\%$
Visual tree	$51.30\%$	$51.03\%$
Enhanced visual tree	$54.33\%$	$58.76\%$
Visual confusion label tree	$58.63\%$	$61.18\%$

Table 2. Table 2 : Experiment results on CIFAR-100

Approaches	Accuracy	Test time (ms)	Speedup
AlexNet	$54.02\%$	$3.4215$	-
VCLT_AlexNet	$58.63\%$	$0.0275$	$\mathrm{𝟏𝟐𝟒}\times$
VGG16	$72.21\%$	$4.3713$	-
VCLT_VGG16	$72.23\%$	$0.0381$	$\mathrm{𝟏𝟏𝟓}\times$

Table 3. Table 3 : Experiment results on ImageNet

Approaches	Accuracy	Test time (ms)	Speedup
AlexNet	$57.24\%$	$5.5263$	-
VCLT_AlexNet	$61.18\%$	$0.1493$	$\mathrm{𝟑𝟕}\times$
VGG16	$71.53\%$	$6.7981$	-
VCLT_VGG16	$66.71\%$	$0.2427$	$\mathrm{𝟐𝟖}\times$

Table 4. Table 4 : Results on ImageNet (compressed CNN models)

Approaches	Accuracy
DeepCom	$57.24\%$
VCLT_DeepCom	$60.73\%$
BWN	$57.08\%$
VCLT_BWN	$57.11\%$
XNOR	$42.37\%$
VCLT_XNOR	$42.48\%$

Table 5. Table 1 : Comparison of the computation on different datasets in theory(unit:million mult-adds)

Classifier	CIFAR-100	ImageNet
FC	34	42
Tree Classifier	0.14	0.52
Speedup	233$\times$	78$\times$

Equations

$$f_{c_j}^l=K(\mathbf{x},{\mathbf{x}}^{\prime })+b$$

$$K(\mathbf{x},{\mathbf{x}}^{\prime })=\sum _{m=1}^M{d}_m{K}_m(\mathbf{x},{\mathbf{x}}^{\prime })$$

$$d_m\ge 0,\sum _{m=1}^M{d}_m=1$$

$$\underset{f_0,f_{c_j},b,\xi ,d}{\min }\frac{1}{2}\Vert f_0{\Vert }^2+\frac{\lambda }{2}\sum _{j=1}^R\sum _{m=1}^M\frac{1}{d_m}\Vert f_{c_j}{\Vert }^2+C\sum _{j=1}^R{\xi }_j$$

$${\forall }_{j=1}^R:y_j{f}_{c_j}=y_j(\sum _{m=1}^M{K}_{m,c_j}({\mathbf{x}}_j,{\mathbf{x}}_j^{\prime })+b)\ge 1-{\xi }_j,{\xi }_j>0$$

$$\underset{f_0,f_{c_j},b,\xi ,d}{\min }\frac{1}{2}\Vert f_0^l{\Vert }^2+\frac{\lambda }{2}\sum _{j=1}^R\sum _{m=1}^M\frac{1}{d_m}\Vert f_{c_j}^l{\Vert }^2+C\sum _{j=1}^R{\xi }_j$$

$${\forall }_{j=1}^R:y_j{f}_{c_j}=y_j(\sum _{m=1}^M{K}_{m,c_j}({\mathbf{x}}_j,{\mathbf{x}}_j^{\prime })+b)\ge 1-{\xi }_j,{\xi }_j>0$$

$${\forall }_{j=1}^R:f_{c_j}^l(x_j)\ge f_{c_i}^{l+1}(x_j),(x_j,y_j)\in c_j\in c_i$$

$$\begin{array}[]{l}P_{A}=P^{1}_{AB}\times P^{2}_{A}\\ P_{B}=P^{1}_{AB}\times P^{2}_{B}\\ P_{C}=P^{1}_{C}\end{array}$$

$$\begin{array}[]{l}P_{A}\propto d_{AC}\times d_{AB}\\ P_{B}\propto d_{AC}\times d_{AB}\\ P_{C}\propto d_{AC}\end{array}$$

$$\begin{array}[]{l}P_{A}\propto d_{AB}\times d_{AC}\\ P_{B}\propto d_{AB}\\ P_{C}\propto d_{AB}\times d_{AC}\end{array}$$

$$\begin{array}[]{l}P_{A}\propto d_{AB}\\ P_{B}\propto d_{AB}\\ P_{C}\propto d_{AC}\end{array}$$

$$P_T=P_A+P_B+P_C$$

$$\begin{array}[]{l}P_{T_{1}}\propto(2d_{AC}\times d_{AB}+d_{AC})\\ P_{T_{2}}\propto(2d_{AC}\times d_{AB}+d_{AB})\\ P_{T_{3}}\propto(2d_{AB}+d_{AC})\end{array}$$

$$\begin{array}[]{l}P_{T_{1}}=k(2d_{AC}\times d_{AB}+d_{AC})\\ P_{T_{2}}=k(2d_{AC}\times d_{AB}+d_{AB})\\ P_{T_{3}}=k(2d_{AB}+d_{AC})\end{array}$$

$$\begin{array}[]{l}P_{T_{1}}-P_{T_{2}}=k(d_{AC}-d_{AB})\\ \because d_{AC}>d_{AB}\\ \therefore P_{T_{1}}>P_{T_{2}}\end{array}$$

$$P_{T_1}-P_{T_4}=k(2d_{AB}(d_{AC}-1))$$

$$Ou{t}_m=\sum _{i=1}^{N}C(w_m,f_i)+b_m,m=1,2,...,M$$

$$C(w,f)=\sum _{i=1}^n\sum _{j=1}^n{w}_{ij}{f}_{ij}$$

$$2Nd=2\times 18\times 4096=147456$$

Full text

**Index Terms— ** Image classification, convolution neural network, confusion graph, label tree

1 Introduction

Deep convolution neural network(CNN) models are developing rapidly and it has evolved to the state-of-the-art technique [1] in image classification tasks. However, when applied to real-time applications on embedded devices where the power and storage are limited, CNN models can not meet the real-time demands because of its large amount of computation. Therefore, optimizing and accelerating these CNN models on embedded devices has become a challenge.

In view of this problem, researches have proposed a variety of compression and acceleration methods such as reducing the precision of multiplication and addition operations [2], setting the weights and inputs to binary codes [3], a skillful integration among several effective methods [4] and structure changing  [5, 6, 7]. However, the computation of a CNN model mainly induced by the computation of fully-connected(FC) layers [4]. The methods mentioned above mainly focus on the compression on the convolution layers and have not resolved the huge computation problem of FC layers.

Another classification method based on a tree classifier, which is an appropriate method for large-scale recognition problems with thousands of categories, has received extensive attention and substantial development. There are several methods to construct the structure of the tree classifier such as leveraging the semantic ontologies (taxonomies) [8, 9, 10], learning label trees [11] and probabilistic label trees [12], learning visual trees [13, 14] and enhanced visual tree [15]. Compared with the FC layers in the CNN models, the tree classifier has the advantage of small amount of calculation and the computation complexity of the tree classifier is $\mathcal{O}(logN)$ [11]. However, there has been no work that replaces FC layers with the tree classifier because most previous work construct the structure of the tree classifier by clustering directly from the image dataset. Previous methods do not utilize the information of FC layers so the accuracy is limited, which restricts the application of tree classification in accelerating depth CNN models. Moreover, this limitation also results in the separation of research on tree classification and deep CNN models and both of them can not benefit from each other.

[16] discovered that deep CNN models have visual confusions that is similar to human beings and we believe this characteristic can be used as the metric to construct the Label Tree. Therefore, we propose to use the community detection algorithm to construct the Label Tree, called Visual Confusion Label Tree(VCLT). With this method, we can fully utilize the information of FC layers in the CNN models. Compared with previous Label Tree building methods, the advantage of the VCLT is that there is no need to manually set parameters and do clustering tasks during tree construction. In addition, our VCLT is constructed directly based on the features in deep CNN models so it has a more reasonable structure which is beneficial for improving the accuracy of the tree classifier. Moreover, to the best of our knowledge, VCLT is the first effort that connects the CNN model and the Label Tree directly so the tree structure fully inherits the information contained in the FC layers.

There are two main contributions in this paper as follows.

• •

Visual Confusion Label Tree: Our construction method is based on the hierarchical community detection algorithm. Using this algorithm on the output of FC layers we can construct a tree classifier whose structure is more suitable for deep CNN models. With this method we can improve the accuracy of the tree classifier compared with previous work by $2.4\%$–$4.3\%$ and we can prove in theory.

• •

Replace the FC layers with the tree classifier: After constructing the label tree, we replace the FC layers from the deep CNN models with our VCLT and we propose an effective algorithm to train our tree classifier. With this replacement we reduce the amount of computation in FC layers by $37\times$–$124\times$ without sacrificing the accuracy of original CNN-based methods.

2 Label Tree in a Nutshell

The concept of the Label Tree was first proposed in [11] aiming at classification and a label tree is a tree $T=(N,E,F,L)$ with $n+1$ indexed nodes $N=\{0,\dots,n\}$ where $E=\{(p_{1},c_{1}),(p_{|E|},c_{|E|})\}$ is a set of edges that are ordered pairs of parent and child node indices, $F=\{f_{1},\ldots,f_{n}\}$ are label predictors and label sets $L=\{l_{0},\ldots,l_{n}\}$ are associated to each node. Except the root of the tree, all other nodes have one parent and arbitrary number of children. The label sets indicate the set of labels to which a point should belong if it arrives at the given node. Classifying an example begins at the root node and for each edge leading to a child $(s,c)\in E$ one computes the score of the label predictor $f_{c}(x)$ which predicts whether the example $x$ belongs to the set of labels $l_{c}$. One takes the most confident prediction, traverses to that child node, and then repeats the process. Classification is complete when one arrives at a node that identifies only a single label that is the predicted class. More details about Label Trees can be found in [11, 14, 17].

3 Visual Confusion Label Tree and Training

3.1 Definition of the Visual Confusion Label Tree

Definition 1**.**

A Visual Confusion Label Tree is a tree $T=(\mathscr{N},\mathscr{V},\mathscr{E},\mathscr{L})$ with $k$ hierarchical layers $\mathscr{N}=\{n_{1},\dots,n_{k}\}$ where $n_{id}$ denotes the number of nodes in the $id$th layer, the node sets $\mathscr{V}=\{V_{1},\dots,V_{k}\}$ where $V_{id}$ is a set of nodes in the $id$th layer and $V_{id}=\{v_{1},\dots,v_{n_{id}}\}$, branch edges $\mathscr{E}=\{(p_{1},c_{1}),\dots,(p_{|\mathscr{E}|},p_{|\mathscr{E}|})\}$ which are ordered pairs of parent and child node indices and labels sets $\mathscr{L}=\{L_{1},\dots,L_{s}\}$ where $L_{id}$ is a label set of nodes in the $id$th layer and $L_{id}=\{l_{1},\dots,l_{n_{id}}\}$ where $l_{s}$ denotes the label set of the $s$th node in this layer.

We extend the notation in [11] to Definition 1. The number $k$ in Definition 1, which is the number of the hierarchical layers of VCLT, is equal to the number of iterations of hierarchical community detection algorithm run on a related confusion graph(detailed in Section 3.2).

3.2 Visual Confusion Label Tree Establishing

Given a dataset $D$ and its corresponding classification model $M$, Algorithm 1 establishes the VCLT $T$ defined in Definition 1 using confusion graph generation and community detection algorithm. There are 3 main steps in Algorithm 1. The first is using the confusion graph generation algorithm to build a confusion graph. The second is using the hierarchical community detection algorithm to reveal communities in the confusion graph. The last is establishing a VCLT with the results of the second step.

Specifically, for the function “GenerateConfusionGraph”, we utilize the confusion graph establishing algorithm from [16]. This algorithm firstly normalizing the top-$\tau$ classification scores of each test sample and then accumulating each normalized score to the weight of the edge that connects the labeled category and the predicted category. For the function “HierarchicalCommunityDetect”, we use the algorithm from  [18]. This algorithm is an iterative algorithm and it will continue running until the modularity is converged. This function outputs the $\mathscr{P}$ and $\mathscr{C}$. The $\mathscr{P}$ is a set of arrays which refer to the community set at each iteration and the $\mathscr{P}$ has the same structure as the $\mathscr{V}$ in Definition 1. The $\mathscr{C}$ is almost the same as the $\mathscr{P}$ except for the member in the $\mathscr{C}$ refer to the label set of communities at each iteration. In particular, as for line$6$ in Algorithm 1, we just add the mark of the communities to $\mathscr{V}$ instead of the vertexes in these communities.

We use the Algorithm 1 to construct a VCLT on CIFAR-10 dataset and the construction process is shown in Fig. 1 where the confusion graph and the communities inside are on the left and the corresponding VCLT is on the right. The left side of Fig. 1 is divided into four steps: Initial and Iteration $1$ to $3$. We apply the function “GenerateConfusionGraph” to generate a confusion graph which is shown at the Initial step. Each vertex represents one category in the dataset and the weight of each edge quantifies the confusion between two connected categories. For instance, the strongest link between “dog” and “cat” denotes that the model may highly probably confuse dogs with cats. Contrarily, the weak edge connecting “dog” and “ship” indicates that the confusion between them is weak. Then we use the function “HierarchicalCommunityDetect” on the confusion graph and get the community structure of the graph from fine-grained to course-grained at each iteration of this algorithm. At Iter. $1$, as is illustrated in Fig. 1, we get five fine-grained communities and set five corresponding nodes to the tree called “node: level$3$”. As each member in a community refers to one category, we link the leaf nodes to level$3$ nodes. For instance, we link “node$4$: cat” and “node$6$: dog” to “node$14$: level$3$”. At Iter. $2$, we get two coarse-grained communities based on communities detected in Iter. $1$ and each fine-grained community at Iter. $1$ is a member of the coarse-grained community at Iter. $2$. Then we link level$3$ nodes to level$2$ nodes based on this relationship. For instance, we link “node$13$: level$3$”, “node$14$: level$3$” and “node$15$: level$3$” to “node$17$: level$2$”. Similarly, at Iter. $3$, we link “node$16$: level$2$” and “node$17$: level$2$” to “root$18$: level$1$” and whole finish the construction process.

As is proposed in [11], in order to achieve high classification accuracy, an ideal label tree should make the fine-grained categories contained in sibling leaf nodes under the same parent node as similar as possible while making the coarse-grained categories contained in parent nodes as dissimilar as possible. Our VCLT structure satisfies this because the categories in leaf nodes are strongly confused while those in parent nodes are weakly confused. Using Algorithm 1, we also construct a VCLT on CIFAR-100 dataset shown in Fig. 2. Compared with the Enhanced Visual Tree (EVT) structure in [15], our VCLT is more reasonable. For example, EVT puts “whale”, “shark”, “skyscraper”, “rocket” and “mountain” into one coarse-grained category while our VCLT divides them into three independent coarse-grained categories. Another example is that EVT divides “bicycle” and “motorcycle” into two different coarse-grained categories but our VCLT puts them into the same fine-grained category due to the strong visual similarity between them.

3.3 Visual Confusion Label Tree Classifier Training

Similar to [14], we develop a top-down approach to train classifiers on each node of the VCLT. One parent node contains a set of coarse-grained categories or a set of fine-grained categories. To make full use of these features, we apply a multi-kernel learning algorithm to train the classifier on each node. In order to control the inter-level error propagation, we add a constraint to our learning algorithm. The constraint aims to guarantee that an image must first be assigned to its parent node (higher-level non-leaf node) correctly if it can further be assigned to a child node (lower-level non-leaf node or leaf node). All these methods make the tree classifier over the VCLT more discriminative.

In order to discriminate a given coarse-grained or fine-grained categories on a node $c_{j}$ from its sibling nodes $\{s(c_{j})\}$ under the same parent node $c_{i}=p(c_{j})$, its multi-kernel SVM classifier is defined as:

[TABLE]

where $l$ is the level of node $c_{j}$ and $K(\bm{x},\bm{x}^{\prime})$ is the multi-kernel which is defined as:

[TABLE]

with:

[TABLE]

In our method, we use common kernels such as the linear kernel, the polynomial kernel, and the Gaussian kernel.

We train each classifier node by node from the root to leaf nodes and use the strategy of SVM Plus [21] to train the multi-label SVM classifiers. Specifically, there is a set of labeled training images for $R$ sibling nodes $\{s(c_{j})\}$ under the same parent node $c_{i}=p(c_{j})$, $R\in[2,B]$ (B is the number of sibling nodes) and there are training samples $\Omega=\{(x^{l}_{j},y^{l}_{j})|c_{j}\in c_{i}\}$ ($l$ is the level of the sibling nodes), training the multi-kernel SVM Plus classifiers for $R$ sibling nodes is achieved by optimizing a objective function:

[TABLE]

subject to:

[TABLE]

where $\xi_{j}$ indicates the slack variable, $\lambda$ is the positive regularization parameters, $C$ is the penalty term.

One problem of label tree is that the error propagation may have negative influence on the classification result. If a classification error happens on the parent node, the prediction of this sample will be wrong because the labels of leaf nodes under this misclassified parent node are all incorrect. In order to resolve this problem, we add an inter-level constraint to the SVM plus classifiers. Our strategy is that samples should be classified correctly at the parent level(level:$l+1$) if we want it to be further classified at the current node level(level:$l$). Thus, we add a constraint to guarantee that the score of current node classifier must be larger than the score of its parent node classifier, which can be denoted by Eq.(8). Therefore, we extend Eq.(4,5) to:

[TABLE]

subject to:

[TABLE]

[TABLE]

4 Experiment

4.1 Datasets and Experimental Settings

We use CIFAR-100 [22] and ILSVRC2012 [10] to evaluate the performance of the proposed classification method. CIFAR-100 has $60000$ images of $100$ categories. Each category has $600$ images in which $500$ for training and $100$ for validation. Divided into a training set and a validation set, ILSVRC2012 has over $120$ million images of $1000$ categories and is commonly used to evaluate image classification algorithms. We use the training set for training and validation set for testing. The Mean Accuracy (MA) $(\%)$ [15] is used to capture the performance of each method. A PC with Intel Core i7 and 64GB memory is utilized to run all experiments.

4.2 Comparison of different tree classifiers

In this section, we compare the classification accuracy of our proposed VCLT classifier with those of other state-of-the-art tree classifiers. Trained and tested with CIFAR-100 and ImageNet datasets, we compare the MA of each of the following tree classifiers: semantic ontology [8], label tree [11], visual tree [14] and the enhanced visual tree [15]. In order to train and test each model, we employ the DeCAF [23] features extracted from the FC6 layer of the AlexNet model (its first FC layer) and the classification accuracy of each tree classifier (quantified in MA) is demonstrated in Table 1.

From Table 1, we find the performance of Semantic ontology is the worst because its tree structure is constructed based on semantic space and the image classification process based on feature space. For another four methods based on feature space, the performance of Label tree is worse because of using OvR classifier to construct its tree structure, which is limited to sample imbalance and the performance of classifier. As for Visual tree, it uses the average features extracted directly from the dataset. Enhanced visual tree adopts the spectral clustering method that better reflects the diversity of categories, so its performance is better than the Visual tree. Our VCLT constructs the tree structure based on the confusion of the CNN model, which makes sibling nodes as close as possible and the parent nodes as far as possible. So this tree structure is more proper and we obtain a significant improvement over the Enhanced visual tree by $4.3\%$ and $2.4\%$.

4.3 Comparison between our tree classifier and CNN models

In this section, we compare the classification accuracy and test time of our VCLT with those of the corresponding CNN model. We choose AlexNet and VGG-Verydeep-16(VGG16) for this comparison. In the AlexNet-based experiment, we firstly train an AlexNet using the CIFAR-100 dataset. Then we employ the DeCAF features extracted from the FC6 layer of AlexNet to train the corresponding VCLT classifier. The classification accuracy and test time of both are shown in Table 2. For a CNN model, the “test time” in Table 2 is the average running time of its FC layers when processing one image. For the VCLT classifier, the “test time” is the average running time of the whole tree classifier when processing one image. As for the VGG16-based experiment, we do the same thing except using the features extracted from the FC14 layer of VGG16 to train the VCLT classifier. Table 3 illustrates this comparison using the ImageNet dataset.

From Table 2 and Table 3, we can see that the classification accuracy of VCLT with AlexNet is around 3% higher than that of the original AlexNet on both CIFAR-100 and ImageNet datasets. In addition, on both datasets, the speedup ratios achieved by replacing the FC layers of AlexNet with our tree classifier are significant ($124\times$ on CIFAR-100 and $37\times$ on ImageNet). Though the accuracy improvement of VCLT with VGG16 is trivial on CIFAR-100 and even negative on ImageNet, the speedup ratios are remarkable, achieving $115\times$ and $28\times$ respectively, which demonstrates VCLT’s promising potential to accelerate CNN-based applications.

Addtionally, we compare the classification accuracy and the speedup ratio of our VCLT with compressed CNN models. Here we choose the Binary-Weights-Net(BWN), XNOR-Net(XNOR) [3] and the DeepCompression Network(DeepCom) [4] for comparison. These compressed CNN models are based on AlexNet and we use their pre-trained models on ImageNet in our experiment. The accuracy results are shown in Table 4, we find out that our VCLT has no accuracy decline.

The speedup ratio results are shown in Fig. 3. For DeepCom, followed [4], comparisons of speedup mainly focus on FC layers and results are shown in DeepCom_FC in Fig. $3$. We find the speedup ratio of our VCLT$(37\times)$ is $30\times$ higher than DeepCom$(7\times)$ when compared with FC layers in the original AlexNet model. For BWN and XNOR, followed [3], comparisons of speedup ratio focus on both FC layers and the entire network. The results are shown respectively in BWN_FC, XNOR_FC, BWN_All and XNOR_All. We find the speedup ratio of our VCLT is $37\times$ higher than BWN$(14\times)$ and $31\times$ higher than XNOR$(33\times)$ when compared on FC layers in the original AlexNet model. As for the entire network model, our VCLT$(2.3\times)$ obtain an improvement over the BWN$(2\times)$ by $0.3\times$ while VCLT$(65\times)$ over the XNOR$(58\times)$ by $7\times$ in terms of speedup ratio.

5 Conclusion

In this paper, we propose a method of replacing the fully-connected layers in CNN models with a tree classifier in image classification applications. We utilize the community detection algorithm to construct a Visual Confusion Label Tree based on the confusion characteristics of CNN models. Then, we use the multi-kernel SVM plus classifier with hierarchical constraints to train the tree classifier on the Visual Confusion Label Tree. Finally, we use this tree classifier to replace fully-connected layers in CNN models. The experimental results on CIFAR-100 and ImageNet demonstrated the advantages of the proposed method over other tree classifiers and original CNN models such as AlexNet and VGG16.

6 Acknowledgements

This work was supported by the Natural Science Foundation of China under the grant No. U1435219, No. 61402507 and No. 61303070.

Appendix A Theoretical Analysis of the Effect on Accuracy when Tree Structure Changed

We consider a problem of three categories classification. We assume that the categories are A, B and C and we can construct four different tree structures, which are shown in Fig.1. According to the definition of the Label Tree, tree structure $T_{1}$ is more reasonable than others for the classification task.

In order to prove it, we assume that we have trained classifiers on these tree structures. At each node of these tree structures, we use SVM for classifier and the SVM classifiers on these nodes are same. Here we assume the distances between every pair of three categories are $d_{AB}$, $d_{AC}$, $d_{BC}$ and $d_{BC}>d_{AC}\gg d_{AB}$, which means category A is similar to B while C is different from both of them. Ideally, the distances in high feature space which is projected by classifier(distance of SVM) among these categories is shown in Fig. 2.

We will prove the tree structure $T_{1}$ is the most ideal tree structure. We choose one of $T_{2}$ and $T_{3}$ to be compared with $T_{1}$ because $T_{2}$ and $T_{3}$ are actually the same.

Proposition A.1**.**

Tree structure $T_{1}$ is better than $T_{2}$ and $T_{4}$.

Proof.

For $T_{1}$, we assume that $P^{1}_{AB}$ denotes the probability of classifying samples in A and B from all the samples correctly at the SVM on the node $1$. Then we define $P^{1}_{C}$, $P^{2}_{A}$, $P^{2}_{B}$ and so on. In addition, we define $P_{A}$, $P_{B}$ and $P_{C}$ as the probability of classifying the three categories from all the samples correctly. Here we know:

[TABLE]

Because the probability that SVM makes a correct classification is in proportion to the distance of SVM. So we get:

[TABLE]

Similarly, for $T_{2}$, we get:

[TABLE]

For $T_{4}$, we get:

[TABLE]

And we know the probability of correct classification for a tree structure $T$ can be defined as:

[TABLE]

The probabilities for $T_{1}$, $T_{2}$ and $T_{4}$ are:

[TABLE]

The SVM classifiers on the nodes of a tree structure are same so the probabilities in Eq.(6) have a same proportion, we denote it as $k$:

[TABLE]

For $P_{T_{1}}$ and $P_{T_{2}}$:

[TABLE]

For $P_{T_{1}}$ and $P_{T_{4}}$:

[TABLE]

If $d_{AC}>1$ then $P_{T_{1}}>P_{T_{4}}$, which demands $d_{AC}$ is very large. From the assumption we know that category C is far from category B and C in the distance of SVM, so $P_{T_{1}}>P_{T_{4}}$.

In summary, Tree structure $T_{1}$ is better than $T_{2}$, $T_{3}$ and $T_{4}$.

∎

Appendix B Theoretical Analysis of the speedup ratio on replacing Fully-Connected layers with the Tree Classifier

In this section we talk about the speedup ratio of our method in theory. Here we take AlexNet on CIFAR-100 and ImageNet datasets as the analysis object and we replace fully-connected(FC) 7 and FC8 layers with the tree classifier. As we all know, each layer of the FC layers is actually a vector inner product process, which can be defined as:

[TABLE]

with:

[TABLE]

where $Out$ is the output of the FC layer, $w$ is the convolution kernel, $f$ is the input of the FC layer, $b$ is the bias, their subscript $m$ denotes that it is the output of the $m$th channel and there are $M$ channels in total. $C$ means convolution operation and $C(w,f)$ denotes a convolution operation between kernel $w$ with a size of $n\times n$ and a feature map $f$. As for FC7 and FC8, the inputs both are feature maps with a size of $1\times 1\times 4096$ and the outputs are a feature map with the size of $1\times 1\times 4096$ and a score vector with the size of $1\times 1\times 1000$. We can calculate the computation using the equation mentioned above.

If we replace the FC layers with our tree classifier, then we should calculate the computation of the tree classifier. The tree classifiers have a hierarchical structure. For one node there is a classifier on each of the child nodes under it. Each classifier under the same parent node computes a result of one test image and the parent node selects which branch to go by comparing all these results. We repeat this process from root node to leaf nodes. Finally the category on the selected leaf node is the classification result. Therefore, the number($N$) of classifiers involved in the classification process is equal to the sum of the number of child nodes under all the nodes in the path from the root node to a specific leaf node. Here we find that the worst situation is the path with the most child nodes and we find this specific number of CIFAR-100 and ImageNet is $18$ and $65$. The dimension($d$) of the features which is used for the classifier is $4096$. Therefore, we can calculate the multi-adds computation of the tree classifier on CIFAR-100 dataset is:

[TABLE]

Similarly, we can calculate the computation on ImageNet dataset is $524288$.

We make a statistic comparison in Table 1.