Label Mapping Neural Networks with Response Consolidation for Class Incremental Learning

05/20/2019 ∙ by Xu Zhang, et al. ∙ 0

Class incremental learning refers to a special multi-class classification task, in which the number of classes is not fixed but is increasing with the continual arrival of new data. Existing researches mainly focused on solving catastrophic forgetting problem in class incremental learning. To this end, however, these models still require the old classes cached in the auxiliary data structure or models, which is inefficient in space or time. In this paper, it is the first time to discuss the difficulty without support of old classes in class incremental learning, which is called as softmax suppression problem. To address these challenges, we develop a new model named Label Mapping with Response Consolidation (LMRC), which need not access the old classes anymore. We propose the Label Mapping algorithm combined with the multi-head neural network for mitigating the softmax suppression problem, and propose the Response Consolidation method to overcome the catastrophic forgetting problem. Experimental results on the benchmark datasets show that our proposed method achieves much better performance compared to the related methods in different scenarios.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Over the years, the fast development of Deep Neural Network (DNN) has been witnessed in various fields he2016deep ; krizhevsky2012imagenet . However, there are still many challenges that hinder developing a DNN-based intelligence system targeted at real-world applications. One of these challenges is how to enable deep networks to learn incremental classes from streaming data, like the way human beings learn new concepts from daily life. It is also called as class incremental learning, where batches of labelled data of new classes are made available gradually xiao2014error . We expect the model should be updated continually so that the knowledge embedded in new classes can be incorporated without sacrificing the learned knowledge of old classes too much zhou2002hybrid .

The class incremental learning of neural networks has been studied since a long time ago. It is widely recognized that the catastrophic forgetting phenomenon mccloskey1989catastrophic is the biggest obstacle for neural networks to keep the memory of old classes. The reason for this notorious problem is that the crucial network weights for old classes are changed to meet the objectives of new arriving classes kirkpatrick2017overcoming . Catastrophic forgetting also occurs in task incremental learning van2018generative and reinforcement continual learning kirkpatrick2017overcoming , where the training data of different tasks are also fed incrementally.

A general and straightforward solution to the catastrophic forgetting problem is Rehearsal robins1998catastrophic : the neural network is able to retrain by the old classes while learning new classes. In general, the methods of this category need to utilize a data pool to cache the old classes, or a generative model to generate some pseudo old training samples for retraining robins1998catastrophic ; shin2017continual ; van2018generative . Rehearsal can significantly alleviate the catastrophic forgetting problem, but it also needs to retrain the model with the data of the old classes and requires extra storage space. However, the motivation of class incremental learning is aiming to reduce the training load by a progressive learning way zhou2002hybrid . In other words, the model should be better trained based on its current parameters and the data of new classes instead of the data of all classes. In addition, in some scenarios, such as data streams, the model may not be able to access the data of some old classes at all.

For overcoming catastrophic forgetting without the help of Rehearsal, some excellent methods are recently proposed and achieve outstanding results, including Elastic Weight Consolidation (EWC) kirkpatrick2017overcoming , Learning without Forgetting (LwF)  li2017learning , Synaptic Intelligence (SI) zenke2017continual , etc. However, almost all of these models are focused on task incremental learning or reinforcement continual learning. When applied to class incremental learning problem directly, these models suffer from another intractable problem. We call it as softmax suppression, which cannot be solved merely by overcoming catastrophic forgetting.

Softmax suppression refers that the output probabilities of the new classes suppress that of the old classes in the classification layer. The main reason for this phenomenon is : a) The network is trained without the support of Rehearsal, i.e. the network being trained cannot access the old classes anymore. b) New classes and old classes are trained in the same softmax layer.

We illustrate an example of softmax suppression in Fig. 1 (Left). Owing to the first point, the output probabilities of new classes given by the network definitely exceed that of old classes. It is because that the network should output the higher probabilities of new classes for meeting the training objectives. Due to the second point, the higher probabilities of new classes would inevitably lead to lower probabilities of old classes because the sum of all probabilities is 1. Therefore, as long as the model is unable to access the data of old classes during training, whatever methods we adopt for preventing the catastrophic forgetting, this suppression effect would still clamp the output probabilities of the old classes so that we cannot predict them.

We conduct an exploration experiment on the MNIST dataset to verify this problem. We firstly train a CNN model on the first two classes. Then we expand the output dimension and keep training the network on the latter two classes. During the training process of the latter two classes, the model cannot access the previous two classes anymore. Except simple fine tuning on the final classification layer, we also try to utilize EWC and LwF method to prevent the network from forgetting the old classes. After training, we test the model on all four classes, including the old two classes and new two classes. The average output probabilities on four positions of final softmax layer are shown in Fig. 1 (Right). It is obvious that whatever anti-forgetting techniques we adopt, after training on the latter two classes, the output probabilities tend to concentrate on the new classes. Even if we fed the testing samples of the old classes into the network, the model still recognizes them as the new classes.

Figure 1: Left: Example of softmax suppression. The green neural units represent old classes and the yellow neural units represent new classes. Right: Softmax Suppression Problem Exploration Result.

In summary, in order to achieve class incremental learning without Rehearsal, a new model is required to handle catastrophic forgetting and softmax suppression simultaneously. In this paper, we propose a new method, named Label Mapping with Response Consolidation (LMRC). We propose Label Mapping (LM) algorithm to mitigate the softmax suppression problem and Response Consolidation (RC) algorithm to handle the catastrophic forgetting problem. The highlight of this paper is that we achieve class incremental learning of deep neural networks without accessing the data of old classes anymore. Moreover, if allowed, the accuracy of LMRC could also be further improved with Rehearsal without any changes to the model.

2 Proposed Approach

2.1 Overview

In this paper, we propose a novel and universal class incremental learning model, named Label Mapping with Response Consolidation (LMRC). The framework of LMRC is shown in Fig. 2 (Left). LMRC utilizes a multi-head neural network as the basic architecture, as shown in the red boxes of Fig. 2 (Left). The Old Model (blue part) represents the previous network trained on the old classes, and the New Model (green part) represents the network being trained on the new classes. When new classes arrive, a new head is accordingly added to the New Model for training these new classes, like head 2 shown in Fig. 2 (Left). After that, the training data of the new classes are propagated through all old heads (i.e. head 1 ) of the Old Model and the outputs are denoted as the

response vectors

. Then, a set of label vectors are generated by the Label Mapping algorithm (gray part), which can be regarded as the labels of the new classes data. The label vectors and the response vectors are the desired targets of the new head and the old heads in the New Model, respectively. Therefore, we train the network to make the outputs of these heads ( and in Fig. 2 (Left)) to approximate these targets, respectively.

Figure 2: Left: The framework of LMRC. Right: The testing process of LMRC. represents the output vector from a head, represents the label vector,

represents the cosine similarity.

2.2 Multi-head network structure

The softmax suppression problem described in Sec. 1

is a great obstacle in class incremental learning. The reason for this problem is that the old classes and the new classes share the same classification layer during training and testing. In order to deal with this problem, we seek inspirations from the multi-task deep learning model, which owns multiple

heads on top of the network. Each head is a single softmax layer for classification. Using the multi-head network, the new classes and the old classes can be assigned to different heads for training and predicting. For example, when we encounter new classes in the streaming data, we open up a new head on the top of the network to train these new classes, like head 2 in Fig. 2 (Left). We can say that this head governs these new classes. In this way, the probabilities of new classes do not suppress those of old classes anymore because they are not trained in the same softmax layer.

Of course, this solution faces an important problem. Different from the multi-task learning, in the testing phase, we do not know which head should be used to predict the input samples. For example, Head A governs the Class 1 and Head B governs the Class 2. If a testing sample is fed into the multi-head network and given the same high probability by both of heads, the model would not be able to judge which one should be chosen as the final output. We call it as Confusion Problem. As the number of heads increasing, or the number of classes governed by the heads increasing, Confusion Problem would become more and more significant.

The reason behind this problem is that the traditional softmax layer suffers from high intra-class variations wen2016discriminative . Each head cannot recognize the unknown classes that not governed by it. It means that each head will unexpectedly output high probabilities of the classes that are not governed by it. In order to solve this problem, we propose the Label Mapping algorithm to reduce the intra-class variations and improve the distinctiveness among the heads.

2.3 Label Mapping

2.3.1 Label Mapping Algorithm

To enhance the intra-class compactness, we replace the tradition softmax layer by the combination of label vectors and negative cosine similarity loss. In general classification task, we always denote classes by one-hot coding. The one-hot codes of different classes are mutually orthogonal. In LMRC, we still denote the classes by high dimensional vectors, i.e. label vectors. Nevertheless, these label vectors do not have to be strictly orthogonal to each other, but they should still guarantee enough distinctiveness to distinguish different classes. The pseudo code of Label Mapping is shown in Algorithm 1.

0:    New Classes Number, ; Label Vector Dimension, ; Similarity Threshold, ; Max sampling times, ; Label Candidate Vectors Set, ;
0:    Label Candidate Vectors Set, ;
1:  ;
2:   = 0;
3:  while  do
4:      Sample a vector randomly;
5:      if  then
6:          
7:      else if  then
8:          ;
9:          ;
10:      else
11:          ;
12:      end if
13:  end while
14:  return  ;
Algorithm 1 Label Mapping

The main idea of Label Mapping is to generate a set of random vectors for classes denotation. In order to satisfy the distinctiveness requirement, we specify a threshold , which controls the upper bound of the cosine similarities among the label vectors. We randomly sample a unit vector

under uniform distribution 

muller1959note . If the candidate set is empty, will be added into it directly. Otherwise, needs to be compared with all the vectors in . If the cosine similarity between any candidate vector in and is higher than , should be discarded. Then a new vector is randomly re-sampled and the above process is repeated. This process goes on until enough label vectors are generated, or the has reached the upper limitation . Finally, each label vector in is assigned to a specific class.

2.3.2 Training Phase with Label Vectors

During the training phase, we use label vectors instead of one-hot codes as the learning targets of our neural network. Each head in our multi-head network is a normalized linear layer, thus the output of each head is a normalized -dimensional vector instead of probabilities. We use the negative cosine similarity

between the output vector and the ground truth, i.e. label vector, as the loss function for new classes.

To be specific, we denote as the multi-head neural network, and as the th existing head of the network. Without loss of generality, we assume that each head governs classes. When a new classes dataset , which also contains classes, emerges in training set, a new head is added to the network accordingly. Meanwhile, a set of label vectors are generated according to Algorithm 1 for these new classes. We denote as the label vector of the -th classes governed by the -th head. We expect that

can correctly classify the new classes, therefore we force the output vector

of sample ( represents -th class) to move closer to the corresponding label vectors , while keeping them away from the label vectors of old classes in other old heads. By this way, we compel the output vectors of the network to concentrate on the neighborhood of corresponding label vectors for enhancing the intra-class compactness. Meanwhile, by the advantage of the Label Mapping, the label vectors are distinguishable enough so that the inter-class difference can also be guaranteed. The loss function of can be defined as Eq (1). We call it as New Classes Loss.

(1)

2.3.3 Testing Phase with Label Vectors

Since the Confusion Problem is mitigated by Label Mapping, we can adopt the Winner-Take-All (WTA) strategy in the testing phase, as shown in Fig. 2 (Right). The testing samples are fed into the network and forward propagated through all heads (Head 1 to Head in Fig. 2 (Right)). We calculate the similarity between the output vector of each head () and the label vectors governed by the corresponding heads (), so that we can obtain similarity values in total, as shown in Eq (2).

(2)

Finally, the class whose similarity is highest is seen as the final prediction result, as shown in Eq (3).

(3)

2.3.4 Analysis of Label Mapping Algorithm

Label Mapping Algorithm can generate distinguishing label vectors as the learning targets of classes. In order to accommodate continual arriving new classes, we need to investigate the capacity of Label Mapping Algorithm. From the probability view, we estimate the number of label vectors that can be generated by the Label Mapping Algorithm as following:

(4)

where is:

(5)

where , and are consistent with the notations in Algorithm 1. Eq (4) represents that we can take label vectors under the probability of . If is large enough, or is not tight, the amount of label vectors is able to satisfy the requirements of general class incremental learning. More details about the analysis of Label Mapping Algorithm can be found in the Appendix.

2.4 Response Consolidation

If the multi-head neural network with Label Mapping is trained incrementally without Rehearsal, it will still suffer from the catastrophic forgetting problem. It is because that when we optimize the loss function of the new head, the output of old heads would definitely be affected by the shared parameters in the bottom layers. Inspired by LwF li2017learning , we propose Response Consolidation (RC) method to overcome catastrophic forgetting without the help of old classes.

We aim to make the outputs of the old heads remain stable during the new training process. Therefore, we copy the entire model as before training and freeze its weights. Then we propagate the training data of new classes through each head in and get the response vector :

(6)

Then we use as the memory targets and maximize the cosine similarity between the and the output vector of the head in , as Eq (7). We call it as Response Loss. In this way, we can force to maintain the old behavior as , so that we can keep the memory of the old classes.

(7)

Finally, we sum up the New Classes Loss in Eq (1) and the Response Loss with a weight parameter . We define the loss function as follows.

(8)

2.5 LMRC with Rehearsal Extension

Although LMRC can work well without auxiliary data of the old classes, it can also be combined with various Rehearsal methods easily and flexibly. By means of Rehearsal, the model is able to review the information of the old classes to improve its accuracy.

Specifically, when the old classes are available, we can train each head using the data of all classes (assume classes in total), rather than merely those classes governed by itself. It can be formalized as Eq (9). We call it as Review Loss.

(9)

In this way, each head can get the information of other classes governed by other heads so that they can further learn the distinctiveness among all the classes by the . The final loss function is Eq (10), which is the combination of New Classes Loss, Response Loss, and Review Loss.

(10)

The testing phase is still the same as Fig. 2 (Right). Note that LMRC utilizes Label Mapping instead of one-hot coding. It means that no matter how many classes there are, the dimensionality of label vectors are fixed. Even if we increase the number of classes to be learned on each head, the network structure does not need to be changed at all. Therefore, except for the input data, the training and testing processes are exactly the same as those of standard LMRC.

3 Experiment

In order to evaluate the effectiveness of LMRC, we conduct a series of experiments on two benchmark datasets, including CIFAR-100 krizhevsky2009learning

and ImageNet-200

yao2015tiny . We compare the accuracy of LMRC with that of other related methods. After that, we validate the advantages of Label Mapping and Response Consolidation, respectively. The experimental source code can be referred in https://github.com/personal-paper-code/LMRC.

3.1 Setup and Implementation

We conduct experiments on two benchmark datasets. Each dataset is divided into several parts by classes. Each part, called as a Class Batch, contains the data of several classes that do not overlap with other parts. In CIFAR-100/ImageNet-200, we divide 100/200 classes into 10 class batches, respectively. The training sets of these class batches are fed into the model sequentially for training. Note that when the model is being trained on the current class batch, the previous class batches cannot be accessed anymore. After that, we predict the testing sets of all classes that have been trained. Finally, we calculate the average incremental accuracy castro2018end-to-end of all class batches. All the reported results are the average accuracies of 5 executions of experiments. Particularly, we report the top-5 accuracy on Imagenet-200 dataset. For the fairness of comparison, we fix the architecture of the basic neural network and related hyper-parameters strictly. More details about the experiment are introduced in the Appendix.

3.2 Effectiveness of LMRC

We have implemented four comparative methods, including Fine-tuning, EWC  kirkpatrick2017overcoming , LwF.MC castro2018end-to-end and LwF.MT li2017learning to validate the effectiveness of LMRC. Fine-tuning means that when new classes arrive, we only expand the dimension of softmax layer and one-hot codes for training the new classes, but take no measures to overcome the softmax suppression and catastrophic forgetting problems. In EWC/LwF.MC, we not only expand the dimension but also use the EWC/LwF algorithm to handle the catastrophic forgetting problem. LwF.MT refers to the multi-head implementation of LwF. It is similar to LMRC but uses the traditional softmax layer in all heads instead of Label Mapping. The accuracies of LMRC and the related methods on all class batches are shown in Fig. 3. The average incremental accuracy is shown in the legend.

From Fig. 3, we can see that LwF.MC and EWC perform as poorly as Fine-tuning, which only remember the information of the current class batch. The results show that even if those methods could overcome catastrophic forgetting, the softmax suppression problem in class incremental learning remains an obstacle for them. In addition, we noted that LwF.MT performs better than the above three methods. We conclude that the multi-head architecture is effective for class incremental learning. LMRC achieves the highest accuracy in all class batches of all datasets. For example, in ImageNet-200 dataset, LMRC can achieve a much higher average incremental accuracy of , which exceeds the other methods by about . Most importantly, these remarkable results of LMRC are obtained without any assistance of Rehearsal.

(a) CIFAR-100
(b) Imagenet-200
Figure 3: The accuracies of LMRC and related methods on all class batches.

3.3 Effectiveness of LMRC after extending with Rehearsal

If allowed, we can extend LMRC with Rehearsal, in which our model is allowed to access the previous data of old classes. In this experiment, we use a data pool as the Rehearsal component. Considering the fairness and universality, we randomly select several samples from each old class and add them into a data pool, without any elaborate sampling strategy. We combine the data pool with all comparison methods in Sec. 3.2 except LwF.MT, which is not suitable for using old data. The experimental results are shown in Table. 1.

Comparing with Fig. 3, it is clear that Rehearsal improves the accuracy of all models. However, LMRC can still achieve the best accuracy in all datasets. We have also noticed that as we decrease the size of data pool (from 100 to 20), LMRC achieves a much larger marginal advantage compared with the related methods. It means that LMRC can perform better with much fewer samples of old classes.

Model Dataset CIFAR-100 ImageNet-200
Sample Num 20 50 100 20 50 100
Fine-tuning 0.392 0.513 0.606 0.563 0.671 0.721
EWC 0.408 0.522 0.602 0.557 0.673 0.728
LwF.MC 0.402 0.516 0.607 0.564 0.665 0.731
LMRC 0.497 0.542 0.622 0.662 0.691 0.738
Table 1: Average incremental accuracy of class incremental models with Rehearsal extension

3.4 Effectiveness of Label Mapping

3.4.1 Compare with LwF.MT

LwF.MT and LMRC both utilize multi-head network. One of the differences between LwF.MT and LMRC is that the latter uses Label Mapping but LwF.MT uses one-hot coding. By comparing LMRC with LwF.MT, we can evaluate the role of Label Mapping in class incremental learning. From Fig. 3, it is can be seen that LMRC performs much better than LwF.MT in all class batches. We also noticed that LwF.MT performs better in the early stage than the later. It is because that the probabilities come from different heads and are not easily confused under a small number of classes. However, the confusion effect would become more significant as the number of classes increases. In contrast, LMRC can maintain a much higher accuracy because we use Label Mapping to generate label vectors, which can achieve high distinctiveness among the heads.

3.4.2 Class Capacity

Theoretically, a class incremental learning model should have no limitation on the class amount. Thus, we conduct an experiment to explore how many label vectors can be generated by the Label Mapping algorithm. We specify the maximum random sampling times and count how many label vectors can be found out. The result is shown in Fig. 4 (a). It is evident that when the dimensionality of vector space increases, or we set a looser similarity threshold , it is much easier to obtain more label vectors. We can easily generate label vectors by our algorithm, which can meet the requirement of the class incremental learning task. We also show the theoretical result of Label Mapping in the Appendix. It is basically consistent with our empirical experiment result.

(a) Class Capacity
(b) CIFAR-100
(c) Imagenet-200
Figure 4: (a): Class capacity of Label Mapping under different dimension and threshold . (b) & (c): Classification accuracy of LMRC and LM (CIFAR-100 & ImageNet-200).

3.5 Effectiveness of Response Consolidation

In order to evaluate the effectiveness of Response Consolidation, we compare the accuracy of LMRC and our proposed model without RC (denoted as LM). The result is illustrated in Fig. 4 (a) and (b). It shows that the accuracy of LMRC is much higher than that of LM. Furthermore, we also conclude that the main cause of this result lies in the accuracy decline on old classes. We also illustrate the classification accuracy of old classes (dotted line) in Fig. 4 (a) and (b). It is obvious that the LM cannot memorize the information of the old classes, and therefore its total accuracy is much lower. On the contrary, LMRC is able to keep the information of the old classes very well. Thus it confirms the validity of Response Consolidation.

4 Conclusion

In this paper, we propose a new class incremental learning model, named Label Mapping with Response Consolidation (LMRC). It can work well without accessing the data of old classes. We propose the Label Mapping algorithm for mitigating the softmax suppression problem and propose the Response Consolidation method to handle the catastrophic forgetting problem. In our experiment, LMRC achieves remarkable results compared with the related methods.

References

  • [1] Francisco M Castro, Manuel J Marinjimenez, Nicolas Guil, Cordelia Schmid, and Karteek Alahari. End-to-end incremental learning.

    european conference on computer vision

    , pages 241–257, 2018.
  • [2] Morris H DeGroot and Mark J Schervish. Probability and statistics. Pearson Education, 2012.
  • [3] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In

    Proceedings of the IEEE conference on computer vision and pattern recognition

    , pages 770–778, 2016.
  • [4] J Kiefer and J Wolfowitz. Stochastic estimation of the maximum of a regression function. Annals of Mathematical Statistics, 23(3):462–466, 1952.
  • [5] James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences, page 201611835, 2017.
  • [6] Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
  • [7] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton.

    Imagenet classification with deep convolutional neural networks.

    In Advances in neural information processing systems, pages 1097–1105, 2012.
  • [8] Zhizhong Li and Derek Hoiem. Learning without forgetting. european conference on computer vision, pages 614–629, 2017.
  • [9] Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. In Psychology of learning and motivation, volume 24, pages 109–165. Elsevier, 1989.
  • [10] Mervin E Muller. A note on a method for generating points uniformly on n-dimensional spheres. Communications of the ACM, 2(4):19–20, 1959.
  • [11] Anthony Robins and SIMON McCALLUM. Catastrophic forgetting and the pseudorehearsal solution in hopfield-type networks. Connection Science, 10(2):121–135, 1998.
  • [12] Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep generative replay. neural information processing systems, pages 2990–2999, 2017.
  • [13] Gido M van de Ven and Andreas S Tolias. Generative replay with feedback connections as a general strategy for continual learning. arXiv preprint arXiv:1809.10635, 2018.
  • [14] Yandong Wen, Kaipeng Zhang, Zhifeng Li, and Yu Qiao.

    A discriminative feature learning approach for deep face recognition.

    In European conference on computer vision, pages 499–515. Springer, 2016.
  • [15] whuber (https://stats.stackexchange.com/users/919/whuber). Distribution of scalar products of two random unit vectors in dimensions. Cross Validated. URL:https://stats.stackexchange.com/q/85977 (version: 2017-04-13).
  • [16] Tianjun Xiao, Jiaxing Zhang, Kuiyuan Yang, Yuxin Peng, and Zheng Zhang. Error-driven incremental learning in deep convolutional neural network for large-scale image classification. In Proceedings of the 22nd ACM international conference on Multimedia, pages 177–186. ACM, 2014.
  • [17] Leon Yao and John Miller. Tiny imagenet classification with convolutional neural networks. CS 231N, 2015.
  • [18] Friedemann Zenke, Ben Poole, and Surya Ganguli. Continual learning through synaptic intelligence.

    international conference on machine learning

    , 8:3987–3995, 2017.
  • [19] Zhi-Hua Zhou and Zhao-Qian Chen.

    Hybrid decision tree.

    Knowledge-based systems, 15(8):515–528, 2002.

5 Appendix

5.1 Experiment Implementation Details

For the fairness of comparison, we fix the neural network architecture and related hyper-parameters strictly. We build a ResNet-18 [3]

as the basic CNN structure. The networks are optimized by the Stochastic Gradient Descent (SGD) algorithm

[4]

with a batch size of 128. In CIFAR-100 experiment, the epoch is set to 70. The learning rate begins with 0.05 and is halved at the

th and th epoch. In ImageNet-200 experiment, the epoch is set to 80. The learning rate begins with 0.1 and is halved at the th, th and th epoch. The similarity threshold in Label Mapping is set to and in Eq (8) is set to . The dimension of label vectors is fixed as 100.

5.2 Analysis of Label Mapping Algorithm

Label Mapping Algorithm is able to generate distinguishing label vectors as the learning targets of different classes. Intuitively, the larger the dimension , the more label vectors can be generated by the Label Mapping. Meanwhile, a larger threshold parameter means a much looser restriction on orthogonality, hence more label vectors can also be generated. In this section, we conduct a simple theoretical analysis to confirm this intuition. First of all, we give two lemmas for auxiliary of the analysis.

Lemma1

: Let random variables

and be independent. The vector is uniformly distributed on the surface of the hyper-sphere , where is a normalization factor. The proof of Lemma 1 can be referred in  [10]. Actually, we randomly sample the vectors in Line 4 of Algorithm 1 according to this Lemma.

Lemma2: Let denotes the inner product of two uniformly random unit vectors: and . We can conclude that follows a distribution and the standardized distribution of approaches normality at a rate of . The proof of Lemma 2 can be referred in  [15]

According to the Lemma 2, we can conclude that

approximately follows a Gaussian distribution with

and , i.e.

(11)

We set the Event as that the cosine similarity of two uniformly random unit vectors and is less than threshold . The probability of is as following:

(12)

Note that and are unit vectors so we can get:

(13)

According to the Lemma 2, we have known that . Therefore, we can calculate the as following:

(14)

In the -th step of Algorithm 1, we try to get the -th label vectors when we have already obtained label vectors in the candidate set. Once we get , we can calculate the success probability of -step. We denote the Event B that means we successfully get the -th label vector at once. To make Event B happen, we only need to guarantee those cosine similarities between the new randomly sampled vector and the other label vectors in candidate set are less than . It is worth noting that the existing label vectors are approximately orthogonal. Thus, we assume that the comparison between each candidate label vector and the randomly sampled vector is approximately independent. It can be formalized as following, where is the new randomly sampled vector and denotes the label vector in the candidate set.

(15)

From the Eq (15), we can see that the probability of Event B decreases exponentially with the increase of . It indicates that it becomes more and more difficult to get the -th label vectors as increasing. Therefore, in the algorithm, we try to sample for times in order to get the -th label vector. The success probability of each time is . We set a random variable , which represents that we get the -th label vector in the -th trial. Obviously,

follows the Geometric Distribution 

[2]

. Its Cumulative Distribution Function (CDF) is as following:

(16)

Let , we can get the probability of getting -th label vector by means of Label Mapping Algorithm.

(17)

From the Eq (14), Eq (15) and Eq (17), we can see that as the or increasing, , and would become higher accordingly.

We expect that we can get the -th label vector under a high probability, i.e. , where is a probability threshold. Therefore, we can estimate the number of label vectors as following:

(18)

Once and are specified in advance, is also fixed according to Eq (14). Thus, we can get the theoretical number of label vectors is:

(19)

It means that we can take label vectors under the probability of .

We set different and to observe the changes of . In Sec. 3.4.2, we specify the maximum random sampling times to 10000 and count how many label vectors can be found out. In this section, we also set and . We calculate according to Eq (19). The experimental result is given in Fig. 5. Obviously, it is consistent with the experimental result in Sec. 3.4.2.

Figure 5: Theoretical capacity of Label Mapping under different dimension and threshold