paper_name
stringlengths 11
170
| text
stringlengths 8.07k
307k
| summary
stringlengths 152
6.16k
| paper_id
stringlengths 43
43
|
|---|---|---|---|
SEED: Self-supervised Distillation For Visual Representation | 1 INTRODUCTION The burgeoning studies and success on self-supervised learning ( SSL ) for visual representation are mainly marked by its extraordinary potency of learning from unlabeled data at scale . Accompanying with the SSL is its phenomenal benefit of obtaining task-agnostic representations while allowing the training to dispense with prohibitively expensive data labeling . Major ramifications of visual SSL include pretext tasks ( Noroozi & Favaro , 2016 ; Zhang et al. , 2016 ; Gidaris et al. , 2018 ; Zhang et al. , 2019 ; Feng et al. , 2019 ) , contrastive representation learning ( Wu et al. , 2018 ; He et al. , 2020 ; Chen et al. , 2020a ) , online/offline clustering ( Yang et al. , 2016 ; Caron et al. , 2018 ; Li et al. , 2020 ; Caron et al. , 2020 ; Grill et al. , 2020 ) , etc . Among them , several recent works ( He et al. , 2020 ; Chen et al. , 2020a ; Caron et al. , 2020 ) have achieved comparable or even better accuracy than the supervised pre-training when transferring to downstream tasks , e.g . semi-supervised classification , object detection . The aforementioned top-performing SSL algorithms all involve large networks ( e.g. , ResNet-50 ( He et al. , 2016 ) or larger ) , with , however , little attention on small networks . Empirically , we find that existing techniques like contrastive learning do not work well on small networks . For instance , the linear probe top-1 accuracy on ImageNet using MoCo-V2 ( Chen et al. , 2020c ) is only 36.3 % with MobileNetV3-Large ( see Figure 1 ) , which is much lower compared with its supervised training accuracy 75.2 % ( Howard et al. , 2019 ) . For EfficientNet-B0 , the accuracy is 42.2 % compared with its supervised training accuracy 77.1 % ( Tan & Le , 2019 ) . We conjecture that this is because smaller models with fewer parameters can not effectively learn instance level discriminative representation with large amount of data . To address this challenge , we inject knowledge distillation ( KD ) ( Buciluǎ et al. , 2006 ; Hinton et al. , 2015 ) into self-supervised learning and propose self-supervised distillation ( dubbed as SEED ) as a new learning paradigm . That is , train the larger , and distill to the smaller both in self-supervised manner . Instead of directly conducting self-supervised training on a smaller model , SEED first trains a large model ( as the teacher ) in a self-supervised way , and then distills the knowledge to the smaller model ( as the student ) . Note that the conventional distillation is for supervised learning , while the distillation here is in the self-supervised setting without any labeled data . Supervised distillation can be formulated as training a student to mimic the probability mass function over classes predicted by a teacher model . In unsupervised knowledge distillation setting , however , the distribution over classes is not directly attainable . Therefore , we propose a simple yet effective self-supervised distillation method . Similar to ( He et al. , 2020 ; Wu et al. , 2018 ) , we maintain a queue of data samples . Given an instance , we first use the teacher network to obtain its similarity scores with all the data samples in the queue as well as the instance itself . Then the student encoder is trained to mimic the similarity score distribution inferred by the teacher over these data samples . The simplicity and flexibility that SEED brings are self-evident . 1 ) It does not require any clustering/prototypical computing procedure to retrieve the pseudo-labels or latent classes . 2 ) The teacher model can be pre-trained with any advanced SSL approach , e.g. , MoCo-V2 ( Chen et al. , 2020c ) , SimCLR ( Chen et al. , 2020a ) , SWAV ( Caron et al. , 2020 ) . 3 ) The knowledge can be distilled to any target small networks ( either shallower , thinner , or totally different architectures ) . To demonstrate the effectiveness , we comprehensively evaluate the learned representations on series of downstream tasks , e.g. , fully/semi-supervised classification , object detection , and also assess the transferability to other domains . For example , on ImageNet-1k dataset , SEED improves the linear probe accuracy of EfficientNet-B0 from 42.2 % to 67.6 % ( a gain over 25 % ) , and MobileNet-V3 from 36.3 % to 68.2 % ( a gain over 31 % ) compared to MoCo-V2 baselines , as shown in Figure 1 and Section 4 . Our contributions can be summarized as follows : • We are the first to address the problem of self-supervised visual representation learning for small models . • We propose a self-supervised distillation ( SEED ) technique to transfer knowledge from a large model to a small model without any labeled data . • With the proposed distillation technique ( SEED ) , we significantly improve the state-of-theart SSL performance on small models . • We exhaustively compare a variety of distillation strategies to show the validity of SEED under multiple settings . 2 RELATED WORK . Among the recent literature in self-supervised learning , contrastive based approaches show prominent results on downstream tasks . Majority of the techniques along this direction are stemming from noise-contrastive estimation ( Gutmann & Hyvärinen , 2010 ) where the latent distribution is estimated by contrasting with randomly or artificially generated noises . Oord et al . ( 2018 ) first proposed Info-NCE to learn image representations by predicting the future using an auto-regressive model for unsupervised learning . Follow-up works include improving the efficiency ( Hénaff et al. , 2019 ) , and using multi-view as positive samples ( Tian et al. , 2019b ) . As these approaches can only have the access to limited negative instances , Wu et al . ( 2018 ) designed a memory-bank to store the previously seen random representations as negative samples , and treat each of them as independent categories ( instance discrimination ) . However , this approach also comes with a deficiency that the previously stored vectors are inconsistent with the recently computed representations during the earlier stage of pre-training . Chen et al . ( 2020a ) mitigate this issue by sampling negative samples from a large batch . Concurrently , He et al . ( 2020 ) improve the memory-bank based method and propose to use the momentum updated encoder for the remission of representation inconsistency . Other techniques include Misra & Maaten ( 2020 ) that combines the pretext-invariant objective loss with contrastive learning , and Wang & Isola ( 2020 ) that decomposes contrastive loss into alignment and uniformity objectiveness . Knowledge distillation ( Hinton et al. , 2015 ) aims to transfer knowledge from a cumbersome model to a smaller one without losing too much generalization power , which is also well investigated in model compression ( Buciluǎ et al. , 2006 ) . Instead of mimicking the teacher ’ s output logit , attention transfer ( Zagoruyko & Komodakis , 2016 ) formulates knowledge distillation on attention maps . Similarly , works in ( Ahn et al. , 2019 ; Yim et al. , 2017 ; Koratana et al. , 2019 ; Huang & Wang , 2017 ) have utilized different learning objectives including consistency on feature maps , consistency on probability mass function , and maximizing the mutual information . CRD ( Tian et al. , 2019a ) , which is derived from CMC ( Tian et al. , 2019b ) , optimizes the student network by a similar objective to Oord et al . ( 2018 ) using a derived lower bound on mutual information . However , the aforementioned efforts all focus on task-specific distillation ( e.g. , image classification ) during the fine-tuning phase rather than a task-agnostic distillation in the pre-training phase for the representation learning . Several works on natural language pre-training proposed to leverage knowledge distillation for a smaller yet stronger small models . For instances , DistillBert ( Sanh et al. , 2019 ) , TinyBert ( Jiao et al. , 2019 ) , and MobileBert ( Sun et al. , 2020 ) , have used knowledge distillation for model compression and shown their validity on multiple downstream tasks . Similar works also emphasize the value of smaller and faster models for language representation learning by leveraging knowledge distillation ( Turc et al. , 2019 ; Sun et al. , 2019 ) . These works all demonstrate the effectiveness of knowledge distillation for language representation learning in small models , while are not extended to the pre-training for visual representations . Notably , a recent concurrent work CompRess ( Abbasi Koohpayegani et al. , 2020 ) also point out the importance to develop better SSL method for smaller models . SEED closely relates to the above techniques but aims to facilitate visual representation learning during pre-training phase using distillation technique for small models , which as far as we know has not yet been investigated . 3 METHOD . 3.1 PRELIMINARY ON KNOWLEDGE DISTILLATION . Knowledge distillation ( Hinton et al. , 2015 ; Buciluǎ et al. , 2006 ) is an effective technique to transfer knowledge from a strong teacher network to a target student network . The training task can be generalized as the following formulation : θ̂S = argmin θS N∑ i Lsup ( xi , θS , yi ) + Ldistill ( xi , θS , θT ) , ( 1 ) where xi is an image , yi is the corresponding annotation , θS is the parameter set for the student network , and θT is the set for the teacher network . The loss Lsup is the alignment error between the network prediction and the annotation . For example in image classification task ( Mishra & Marr , 2017 ; Shen & Savvides , 2020 ; Polino et al. , 2018 ; Cho & Hariharan , 2019 ) , it is normally a cross entropy loss . For object detection ( Liu et al. , 2019 ; Chen et al. , 2017 ) , it includes bounding box regression as well . The loss of Ldistill is the mimic error of the student network towards a pre-trained teacher network . For example in ( Hinton et al. , 2015 ) , the teacher signal comes from the softmax prediction of multiple large-scale networks and the loss is measured by the Kullback–Leibler divergence . In Romero et al . ( 2014 ) , the task is to align the intermediate feature map values and to minimize the squared l2 distance . The effectiveness has been well demonstrated in the supervised setting with labeled data , but remains unknown for the unsupervised setting , which is our focus . 3.2 SELF-SUPERVISED DISTILLATION FOR VISUAL REPRESENTATION . Different from supervised distillation , SEED aims to transfer knowledge from a large model to a small model without requiring labeled data , so that the learned representations in small model can be used for downstream tasks . Inspired by contrastive SSL , we formulate a simple approach for the distillation on the basis of instance similarity distribution over a contrastive instance queue . Similar to He et al . ( 2020 ) , we maintain an instance queue for storing data samples ’ encoding output from the teacher . Given a new sample , we compute its similarity scores with all the samples in the queue using both the teacher and the student models . We require that the similarity score distribution computed by the student matches with that computed by the teacher , which is formulated as minimizing the cross entropy between the student and the teacher ’ s similarity score distributions ( as illustrated in Figure 2 ) . Specifically , for a randomly augmented view xi of an image , it is first mapped and normalized into feature vector representations zTi = f T θ ( xi ) /||fTθ ( xi ) ||2 , and zSi = fSθ ( xi ) /||fSθ ( xi ) ||2 , where zTi , z S i ∈ RD , and fTθ and fSθ denote the teacher and student encoders , respectively . Let D = [ d1 ... dK ] denote the instance queue where K is the queue length and dj is the feature vector obtained from the teacher encoder . Similar to the contrastive learning framework , D is progressively updated under the “ first-in first-out ” strategy as distillation proceeds . That is , we en-queue the visual features of the current batch inferred by the teacher and de-queue the earliest seen samples at the end of iteration . Note that the maintained samples in queue D are mostly random and irrelevant to the target instance xi . Minimizing the cross entropy between the similarity score distribution computed by the student and teacher based on D softly contrasts xi with randomly selected samples , without directly aligning with the teacher encoder . To address this problem , we add the teacher ’ s embedding ( zTi ) into the queue and form D + = [ d1 ... dK , dK+1 ] with dK+1 = zTi . Let pT ( xi ; θT ; D+ ) denote the similarity score between the extracted teacher feature zTi and dj ’ s ( j = 1 , ... , K + 1 ) computed by the teacher model . pT ( xi ; θT ; D+ ) is defined as pT ( xi ; θT , D + ) = [ pT1 ... p T K+1 ] , p T j = exp ( zTi · dj/τT ) ∑ d∼D+ exp ( z T i · d/τT ) , ( 2 ) and τT is a temperature parameter for the teacher . Note , we use ( ) T to represent the feature from the teacher network and use ( · ) to represent the inner product between two features . Similarly let pS ( xi ; θS , D+ ) denote the similarity score computed by the student model , which is defined as pS ( xi ; θS , D + ) = [ pS1 ... p S K+1 ] , where p S j = exp ( zSi · dj/τS ) ∑ d∼D+ exp ( z S i · d/τS ) , ( 3 ) and τS is a temperature parameter for the student . Our self-supervised distillation can be formulated as minimizing the cross entropy between the similarity scores of the teacher , pT ( xi ; θT , D+ ) , and the student , pS ( xi ; θS , D+ ) , over all the instances xi , that is , θ̂S = argmin θS N∑ i −pT ( xi ; θT , D+ ) · logpS ( xi ; θS , D+ ) = argmin θS N∑ i K+1∑ j − exp ( z T i · dj/τT ) ∑ d∼D+ exp ( z T i · d/τT ) · log exp ( z S i · dj/τS ) ∑ d∼D+ exp ( z S i · d/τS ) . ( 4 ) Since the teacher network is pre-trained and frozen , the queued features are consistent during training w.r.t . the student network . The higher the value of pTj is , the larger weight will be laid on p S j . Due to the l2 normalization , similarity score between zTi and dK+1 remains constant 1 before softmax normalization , which is the largest among pTj . Thus , the weight for p S K+1 is the largest and can be adjusted solely by tuning the value of τT . By minimizing the loss , the feature of zSi can be aligned with zTi and meanwhile contrasts with other unrelated image features in D. We further discuss the relation of these two goals with our learning objective in Appendix A.5 . Relations with Info-NCE loss . When τT → 0 , the softmax function for pT smoothly approaches to a one-hot vector , where pTK+1 equals 1 and all others 0 . In this extreme case , the loss becomes LNCE = N∑ i − log exp ( z T i · zSi /τ ) ∑ d∼D+ exp ( z S i · d/τ ) , ( 5 ) which is similar to the widely-used Info-NCE loss ( Oord et al. , 2018 ) in contrastive-based SSL ( see discussion in Appendix A.6 . | This paper proposes a knowledge distillation (KD) approach for self-supervised learning (SSL) with small neural network models. The authors first observe that the state-of-the-art contrastive learning-based SSL does not obtain good performance on small models, due to the larger model capacity required for instance discrimination. To tackle this problem, they propose a SEED, a KD method where the smaller student model learns to mimic its larger teacher model’s similarity distribution between an instance and its augmented views, using a cross-entropy based objective. The authors perform various experiments to show that -- 1) SEED obtains substantial improvement in SSL-based imagenet classification performance for small models as compared to SSL training without SEED, 2) the performance gains are also substantial for transfer learning on other classification tasks, 3) the performance gains are smaller for downstream tasks of object detection and instance segmentation, with performance gains reducing for the larger COCO dataset, as compared to VOC, 4) SEED is robust to choice of SSL method, and performs better than other KD approaches. | SP:9f8b8c56abc19f30f03426367ab036ba47bc1f27 |
Rethinking Compressed Convolution Neural Network from a Statistical Perspective | 1 INTRODUCTION . The introduction of AlexNet ( Krizhevsky et al. , 2012 ) spurred a line of research in 2D CNNs , which progressively achieve high levels of accuracy in the domain of image recognition ( Simonyan & Zisserman , 2015 ; Szegedy et al. , 2015 ; He et al. , 2016 ; Huang et al. , 2017 ) . The current stateof-the-art CNNs leave little room to achieve significant improvement on accuracy in learning stillimages , and attention has hence been diverted towards two directions . The first is to deploy deep CNNs on mobile devices by removing redundancy from the over-parametrized network , and some representative models include MobileNetV1 & V2 ( Howard et al. , 2017 ; Sandler et al. , 2018 ) . The second direction is to utilize CNNs to learn from higher-order inputs , for instance , video clips ( Tran et al. , 2018 ; Hara et al. , 2017 ) or electronic health records ( Cheng et al. , 2016 ; Suo et al. , 2017 ) . This area has not yet seen a widely-accepted state-of-the-art network . High-order kernel tensors are usually required to account for the multiway dependence of the input . This notoriously leads to heavy computational burden , as the number of parameters to be trained grows exponentially with the dimension of inputs . Subsequently , model compression becomes the critical juncture to guarantee the successful training and deployment of tensor CNNs . Tensor methods for compressing CNNs . Denil et al . ( 2013 ) showed that there is huge redundancy in network weights such that the entire network can be approximately recovered with a small fraction of parameters . Tensor decomposition recently has been widely used to compress the weights in a CNN network ( Lebedev et al. , 2015 ; Kim et al. , 2016 ; Kossaifi et al. , 2020b ; Hayashi et al. , 2019 ) . Specifically , the weights at each layer are first summarized into a tensor , and then tensor decomposition , CP or Tucker decomposition , can be applied to reduce the number of parameters . Different tensor decomposition to convolution layers will lead to a variety of compressed CNN block designs . For instance , the bottleneck block in ResNet ( He et al. , 2016 ) corresponds to the convolution kernel with a special Tucker low-rank structure , and the depthwise separable block in MobileNetV1 ( Howard et al. , 2017 ) and the inverted residual block in MobileNetV2 ( Sandler et al. , 2018 ) correspond to the convolution kernel with special CP forms . All the above are for 2D CNNs , and Kossaifi et al . ( 2020b ) and Su et al . ( 2018 ) considered tensor decomposition to factorize convolution kernels for higher-order tensor inputs . Tensor decomposition can also be applied to fully-connected layers since they may introduce a large number of parameters ( Kossaifi et al. , 2017 ; 2020a ) ; see also the discussions in Section 5 . Moreover , Kossaifi et al . ( 2019 ) summarized all weights of a network into one single high-order tensor , and then directly imposed a low-rank structure to achieve full network compression . While the idea is highly motivating , the proposed structure of the high-order tensor is heuristic and can be further improved ; see the discussions in Section 2.4 . Parameter efficiency of the above proposed architectures was heuristically justified by methods , such as FLOPs counting , naive parameter counting and/or empirical running time . However , there is still lack of a theoretical study to understand the mechanism of how tensor decomposition can compress CNNs . This paper attempts to fill this gap from statistical perspectives . Sample Complexity Analysis . Du et al . ( 2018a ) first characterized the statistical sample complexity of a CNN ; see also Wang et al . ( 2019 ) for compact autoregressive nets . Specifically , consider a CNN model , y = FCNN ( x , W ) + ξ , where y and x are output and input , respectively , W contains all weights and ξ is an additive error . Given the trained and true underlying networks FCNN ( x , Ŵ ) and FCNN ( x , W ∗ ) , the root-mean-square prediction error is defined as E ( Ŵ ) = √ Ex|FCNN ( x , Ŵ ) − FCNN ( x , W∗ ) |2 , ( 1 ) where Ŵ and W∗ are trained and true underlying weights , respectively , and Ex is the expectation on x . The sample complexity analysis is to investigate how many samples are needed to guarantee a given tolerance on the prediction error . It can also be used to detect the model redundancy . Consider two nested CNNs , where F1 is more compressed than F2 . Given the same true underlying networks , when the prediction errors from trained F1 and F2 are comparable , we then can argue that F2 has redundant weights comparing with F1 . As a result , conducting sample complexity analysis to CNNs with higher order inputs will shed light on the compressing mechanism of popular compressed CNNs via tensor decomposition . The study in Du et al . ( 2018a ) is limited to 1-dimensional convolution with a single kernel , followed by weighted summation , and its theoretical analysis can not be generalized to CNNs with compressed layers . In comparison , our paper presents a more realistic modeling of CNN by introducing a general N -dimensional convolution with multiple kernels , followed by an average pooling layer and a fully-connected layer . The convolution kernel and fully-connected weights are in tensor forms , and this allows us to explicitly model compressed CNNs via imposing low-rank assumption on weight tensors . Moreover , we used an alternative technical tool , and a sharper upper bound on the sample complexity can be obtained . Our paper makes three main contributions : 1 . We formulate CNNs with high-order inputs into statistical models , and show that they have an explicit “ Tucker-like ” form . 2 . The sample complexity analysis can then be conducted to CNNs as well as compressed CNNs via tensor decomposition , with weak conditions allowing for time-dependent inputs like video data . 3 . From theoretical analysis , we draw an interesting finding that forcing low dimensionality on output channels may introduce unnecessary parameter redundancy to a compressed network . 1.1 COMPARISON WITH OTHER EXISTING WORKS . Deep neural networks are usually over-parametrized , yet empirically , they can generalize well . It is an important topic in the literature to theoretically study the generalization ability of deep neural networks , including deep CNNs ( Li et al. , 2020 ; Arora et al. , 2018 ) . The generalization error , defined as the difference between test and training errors , is commonly used to evaluate such ability , and many techniques have been developed to control its bound ; see , for example , the VC dimension ( Vapnik , 2013 ) , the Rademacher complexity & covering number ( Bartlett & Mendelson , 2002 ) , the norm-based capacity control ( Neyshabur et al. , 2017 ; Golowich et al. , 2018 ; Bartlett et al. , 2017 ; Neyshabur et al. , 2015 ) and low-rank compression based methods ( Li et al. , 2020 ; Zhou & Feng , 2018 ; Arora et al. , 2018 ) . These works use a model-agnostic framework , and hence relies heavily on explicit regularization such as weight decay , dropout or data augumentation , as well as algorithmbased implicit regularization to remove the redundancy in the network . We , however , attempt to theoretically explain how much compressibility is achieved in a compressed network architecture . Specifically , we make a comparison between a CNN and its compressed version , and makes theoretically-supported modification to the latter to further increase efficiency . Subsequently , our analysis requires an explicit formulation for the network architecture , which is provided in Section 2 , and the prediction error at ( 1 ) is adopted as our evaluation criteria . We notice that Li et al . ( 2020 ) also proposes to use the CP Layers to compress the weights in each convolution layer . But their study is still model-agnostic , since the ranks of the underlying CP Layers depend on the trained weights . In details , their proposed approach uses regularization assumptions on the weights and hence , their derived theoretical bound is influenced by training and not suitable to analyze the network design exclusively . Other existing works , that aim to provide theoretical understanding for the neural networks , include the understanding of parameter recovery with gradient-based algorithms for deep neural networks ( Zhong et al. , 2017b ; Fu et al. , 2020 ; Goel et al. , 2018 ; Zhong et al. , 2017a ) ; the development of other provably efficient algorithms ( Cao & Gu , 2019 ; Du & Goel , 2018 ) ; and the investigation of convergence in an over-parameterized regime ( Allen-Zhu et al. , 2019 ; Li & Liang , 2018 ; Du et al. , 2018b ) . Our work differs greatly from these works in both target and methodology . We do not consider computational complexity or algorithm convergence . Instead , we focus on the statistical sample complexity to depict the mechanism of compressed block designs for CNNs . 2 FORMULATING CNNS WITH HIGHER-ORDER INPUTS . 2.1 NOTATION . Tensor notations . We follow the notations in Kolda & Bader ( 2009 ) to denote vectors by lowercase boldface letters , e.g . a ; matrices by capital boldface letters , e.g . A ; tensors of order 3 or higher by Euler script boldface letters , e.g . A . For an N th-order tensor A ∈ Rl1×···×lN , denote its elements by A ( i1 , i2 , . . . , iN ) and the n-mode unfolding by A ( n ) , where the columns of A ( n ) are the n-mode vectors of A , for 1 ≤ n ≤ N . And A ( : , · · · , in , · · · , : ) denotes the subtensor of A , holding only the nth index fixed . The vectorization operation is denoted by vec ( · ) . The inner product of two tensors A , B ∈ Rl1×···×lN is defined as 〈A , B〉 =∑ i1 · · · ∑ iN A ( i1 , . . . , iN ) B ( i1 , . . . , iN ) , and the Frobenius norm is ‖A‖F = √ 〈A , A〉 . The mode-n multiplication ×n of a tensor A ∈ Rl1×···×lN and a matrix B ∈ Rpn×ln is defined as ( A×n B ) ( i1 , . . . , jn , . . . , iN ) = ∑ln in=1 A ( i1 , . . . , in , . . . , iN ) B ( jn , in ) , for 1 ≤ n ≤ N , respectively . The mode-n multiplication ×̄N of a tensor A ∈ Rl1×···×lN and a vector b ∈ Rln is defined as ( A×̄nb ) ( i1 , . . . , in−1 , in+1 , . . . , iN ) = ∑ln in=1 A ( i1 , . . . , in , . . . , iN ) b ( in ) , for 1 ≤ n ≤ N . The symbol “ ⊗ ” is the Kronecker product and “ ◦ ” is the outer product . We extend the definition of Khatri-Rao product to tensors : given tensors A ∈ Rl1×l2×···lN×K and B ∈ Rp1×p2×···pN×K , their Khatri-Rao product is a tensor of size Rl1p1×l2p2×···lNpN×K , denoted by C = A B , where C ( : , · · · , k ) = A ( : , · · · , k ) ⊗B ( : , · · · , k ) , 1 ≤ k ≤ K. CP decomposition . The Canonical Polyadic ( CP ) decomposition ( Kolda & Bader , 2009 ) factorizes the tensor A ∈ Rl1×···×lN into a sum of rank-1 tensors , i.e . A = ∑R r=1 αrh ( 1 ) r ◦ h ( 2 ) r ◦ · · · ◦ h ( N ) r , where h ( j ) r is a unit norm vector of size Rlj for all 1 ≤ j ≤ N . The CP rank is the number of rank-1 tensors R. Tucker decomposition . The Tucker ranks of an N th-order tensor A ∈ Rl1×···×lN are defined as the matrix ranks of the unfoldings of A along all modes . If the Tucker ranks of A are ( R1 , . . . , RN ) , then there exist a core tensor G ∈ RR1×···×RN and matrices H ( i ) ∈ Rli×Ri , such that A = G×1 H ( 1 ) ×2 H ( 2 ) · · · ×N H ( N ) , known as Tucker decomposition ( Tucker , 1966 ) , | This paper formulated higher-order CNNs into a Tucker form and provides sample complexity analysis to higher-order CNNs and compressed designs of CNNs via tensor analysis. It uses then theoretically analyzes the efficiency of four block designs from ResNet, MobileNetV1, and MobileNetV2. The paper also conducts numerical experiments to verify its theoretical results and provide some empirical studies to show that increasing the expansive ratio of a bottleneck | SP:fed81f79f821a00e7bf5e3fdd1bbf3ce269b46f8 |
Rethinking Compressed Convolution Neural Network from a Statistical Perspective | 1 INTRODUCTION . The introduction of AlexNet ( Krizhevsky et al. , 2012 ) spurred a line of research in 2D CNNs , which progressively achieve high levels of accuracy in the domain of image recognition ( Simonyan & Zisserman , 2015 ; Szegedy et al. , 2015 ; He et al. , 2016 ; Huang et al. , 2017 ) . The current stateof-the-art CNNs leave little room to achieve significant improvement on accuracy in learning stillimages , and attention has hence been diverted towards two directions . The first is to deploy deep CNNs on mobile devices by removing redundancy from the over-parametrized network , and some representative models include MobileNetV1 & V2 ( Howard et al. , 2017 ; Sandler et al. , 2018 ) . The second direction is to utilize CNNs to learn from higher-order inputs , for instance , video clips ( Tran et al. , 2018 ; Hara et al. , 2017 ) or electronic health records ( Cheng et al. , 2016 ; Suo et al. , 2017 ) . This area has not yet seen a widely-accepted state-of-the-art network . High-order kernel tensors are usually required to account for the multiway dependence of the input . This notoriously leads to heavy computational burden , as the number of parameters to be trained grows exponentially with the dimension of inputs . Subsequently , model compression becomes the critical juncture to guarantee the successful training and deployment of tensor CNNs . Tensor methods for compressing CNNs . Denil et al . ( 2013 ) showed that there is huge redundancy in network weights such that the entire network can be approximately recovered with a small fraction of parameters . Tensor decomposition recently has been widely used to compress the weights in a CNN network ( Lebedev et al. , 2015 ; Kim et al. , 2016 ; Kossaifi et al. , 2020b ; Hayashi et al. , 2019 ) . Specifically , the weights at each layer are first summarized into a tensor , and then tensor decomposition , CP or Tucker decomposition , can be applied to reduce the number of parameters . Different tensor decomposition to convolution layers will lead to a variety of compressed CNN block designs . For instance , the bottleneck block in ResNet ( He et al. , 2016 ) corresponds to the convolution kernel with a special Tucker low-rank structure , and the depthwise separable block in MobileNetV1 ( Howard et al. , 2017 ) and the inverted residual block in MobileNetV2 ( Sandler et al. , 2018 ) correspond to the convolution kernel with special CP forms . All the above are for 2D CNNs , and Kossaifi et al . ( 2020b ) and Su et al . ( 2018 ) considered tensor decomposition to factorize convolution kernels for higher-order tensor inputs . Tensor decomposition can also be applied to fully-connected layers since they may introduce a large number of parameters ( Kossaifi et al. , 2017 ; 2020a ) ; see also the discussions in Section 5 . Moreover , Kossaifi et al . ( 2019 ) summarized all weights of a network into one single high-order tensor , and then directly imposed a low-rank structure to achieve full network compression . While the idea is highly motivating , the proposed structure of the high-order tensor is heuristic and can be further improved ; see the discussions in Section 2.4 . Parameter efficiency of the above proposed architectures was heuristically justified by methods , such as FLOPs counting , naive parameter counting and/or empirical running time . However , there is still lack of a theoretical study to understand the mechanism of how tensor decomposition can compress CNNs . This paper attempts to fill this gap from statistical perspectives . Sample Complexity Analysis . Du et al . ( 2018a ) first characterized the statistical sample complexity of a CNN ; see also Wang et al . ( 2019 ) for compact autoregressive nets . Specifically , consider a CNN model , y = FCNN ( x , W ) + ξ , where y and x are output and input , respectively , W contains all weights and ξ is an additive error . Given the trained and true underlying networks FCNN ( x , Ŵ ) and FCNN ( x , W ∗ ) , the root-mean-square prediction error is defined as E ( Ŵ ) = √ Ex|FCNN ( x , Ŵ ) − FCNN ( x , W∗ ) |2 , ( 1 ) where Ŵ and W∗ are trained and true underlying weights , respectively , and Ex is the expectation on x . The sample complexity analysis is to investigate how many samples are needed to guarantee a given tolerance on the prediction error . It can also be used to detect the model redundancy . Consider two nested CNNs , where F1 is more compressed than F2 . Given the same true underlying networks , when the prediction errors from trained F1 and F2 are comparable , we then can argue that F2 has redundant weights comparing with F1 . As a result , conducting sample complexity analysis to CNNs with higher order inputs will shed light on the compressing mechanism of popular compressed CNNs via tensor decomposition . The study in Du et al . ( 2018a ) is limited to 1-dimensional convolution with a single kernel , followed by weighted summation , and its theoretical analysis can not be generalized to CNNs with compressed layers . In comparison , our paper presents a more realistic modeling of CNN by introducing a general N -dimensional convolution with multiple kernels , followed by an average pooling layer and a fully-connected layer . The convolution kernel and fully-connected weights are in tensor forms , and this allows us to explicitly model compressed CNNs via imposing low-rank assumption on weight tensors . Moreover , we used an alternative technical tool , and a sharper upper bound on the sample complexity can be obtained . Our paper makes three main contributions : 1 . We formulate CNNs with high-order inputs into statistical models , and show that they have an explicit “ Tucker-like ” form . 2 . The sample complexity analysis can then be conducted to CNNs as well as compressed CNNs via tensor decomposition , with weak conditions allowing for time-dependent inputs like video data . 3 . From theoretical analysis , we draw an interesting finding that forcing low dimensionality on output channels may introduce unnecessary parameter redundancy to a compressed network . 1.1 COMPARISON WITH OTHER EXISTING WORKS . Deep neural networks are usually over-parametrized , yet empirically , they can generalize well . It is an important topic in the literature to theoretically study the generalization ability of deep neural networks , including deep CNNs ( Li et al. , 2020 ; Arora et al. , 2018 ) . The generalization error , defined as the difference between test and training errors , is commonly used to evaluate such ability , and many techniques have been developed to control its bound ; see , for example , the VC dimension ( Vapnik , 2013 ) , the Rademacher complexity & covering number ( Bartlett & Mendelson , 2002 ) , the norm-based capacity control ( Neyshabur et al. , 2017 ; Golowich et al. , 2018 ; Bartlett et al. , 2017 ; Neyshabur et al. , 2015 ) and low-rank compression based methods ( Li et al. , 2020 ; Zhou & Feng , 2018 ; Arora et al. , 2018 ) . These works use a model-agnostic framework , and hence relies heavily on explicit regularization such as weight decay , dropout or data augumentation , as well as algorithmbased implicit regularization to remove the redundancy in the network . We , however , attempt to theoretically explain how much compressibility is achieved in a compressed network architecture . Specifically , we make a comparison between a CNN and its compressed version , and makes theoretically-supported modification to the latter to further increase efficiency . Subsequently , our analysis requires an explicit formulation for the network architecture , which is provided in Section 2 , and the prediction error at ( 1 ) is adopted as our evaluation criteria . We notice that Li et al . ( 2020 ) also proposes to use the CP Layers to compress the weights in each convolution layer . But their study is still model-agnostic , since the ranks of the underlying CP Layers depend on the trained weights . In details , their proposed approach uses regularization assumptions on the weights and hence , their derived theoretical bound is influenced by training and not suitable to analyze the network design exclusively . Other existing works , that aim to provide theoretical understanding for the neural networks , include the understanding of parameter recovery with gradient-based algorithms for deep neural networks ( Zhong et al. , 2017b ; Fu et al. , 2020 ; Goel et al. , 2018 ; Zhong et al. , 2017a ) ; the development of other provably efficient algorithms ( Cao & Gu , 2019 ; Du & Goel , 2018 ) ; and the investigation of convergence in an over-parameterized regime ( Allen-Zhu et al. , 2019 ; Li & Liang , 2018 ; Du et al. , 2018b ) . Our work differs greatly from these works in both target and methodology . We do not consider computational complexity or algorithm convergence . Instead , we focus on the statistical sample complexity to depict the mechanism of compressed block designs for CNNs . 2 FORMULATING CNNS WITH HIGHER-ORDER INPUTS . 2.1 NOTATION . Tensor notations . We follow the notations in Kolda & Bader ( 2009 ) to denote vectors by lowercase boldface letters , e.g . a ; matrices by capital boldface letters , e.g . A ; tensors of order 3 or higher by Euler script boldface letters , e.g . A . For an N th-order tensor A ∈ Rl1×···×lN , denote its elements by A ( i1 , i2 , . . . , iN ) and the n-mode unfolding by A ( n ) , where the columns of A ( n ) are the n-mode vectors of A , for 1 ≤ n ≤ N . And A ( : , · · · , in , · · · , : ) denotes the subtensor of A , holding only the nth index fixed . The vectorization operation is denoted by vec ( · ) . The inner product of two tensors A , B ∈ Rl1×···×lN is defined as 〈A , B〉 =∑ i1 · · · ∑ iN A ( i1 , . . . , iN ) B ( i1 , . . . , iN ) , and the Frobenius norm is ‖A‖F = √ 〈A , A〉 . The mode-n multiplication ×n of a tensor A ∈ Rl1×···×lN and a matrix B ∈ Rpn×ln is defined as ( A×n B ) ( i1 , . . . , jn , . . . , iN ) = ∑ln in=1 A ( i1 , . . . , in , . . . , iN ) B ( jn , in ) , for 1 ≤ n ≤ N , respectively . The mode-n multiplication ×̄N of a tensor A ∈ Rl1×···×lN and a vector b ∈ Rln is defined as ( A×̄nb ) ( i1 , . . . , in−1 , in+1 , . . . , iN ) = ∑ln in=1 A ( i1 , . . . , in , . . . , iN ) b ( in ) , for 1 ≤ n ≤ N . The symbol “ ⊗ ” is the Kronecker product and “ ◦ ” is the outer product . We extend the definition of Khatri-Rao product to tensors : given tensors A ∈ Rl1×l2×···lN×K and B ∈ Rp1×p2×···pN×K , their Khatri-Rao product is a tensor of size Rl1p1×l2p2×···lNpN×K , denoted by C = A B , where C ( : , · · · , k ) = A ( : , · · · , k ) ⊗B ( : , · · · , k ) , 1 ≤ k ≤ K. CP decomposition . The Canonical Polyadic ( CP ) decomposition ( Kolda & Bader , 2009 ) factorizes the tensor A ∈ Rl1×···×lN into a sum of rank-1 tensors , i.e . A = ∑R r=1 αrh ( 1 ) r ◦ h ( 2 ) r ◦ · · · ◦ h ( N ) r , where h ( j ) r is a unit norm vector of size Rlj for all 1 ≤ j ≤ N . The CP rank is the number of rank-1 tensors R. Tucker decomposition . The Tucker ranks of an N th-order tensor A ∈ Rl1×···×lN are defined as the matrix ranks of the unfoldings of A along all modes . If the Tucker ranks of A are ( R1 , . . . , RN ) , then there exist a core tensor G ∈ RR1×···×RN and matrices H ( i ) ∈ Rli×Ri , such that A = G×1 H ( 1 ) ×2 H ( 2 ) · · · ×N H ( N ) , known as Tucker decomposition ( Tucker , 1966 ) , | This paper provides theoretical analysis of the estimating power of CNN (3 and 5 layers). By formulating the problem using tensors, the authors showed that the estimating error of the learned CNN weights with respect to the true weights is of the order $\sqrt{d/n}$ where $d$ measures model complexity and $n$ is the training sample size. In addition, the authors considered low rank approximation to the convolution tensor through CP and Tucker decompositions, and they derived convergence result for the CNN weights in this case. The authors then applied these results to analyze different block designs through numerical experiments and ablation studies. | SP:fed81f79f821a00e7bf5e3fdd1bbf3ce269b46f8 |
Large Associative Memory Problem in Neurobiology and Machine Learning | 1 INTRODUCTION . Associative memory is defined in psychology as the ability to remember ( link ) many sets , called memories , of unrelated items . Prompted by a large enough subset of items taken from one memory , an animal or computer with an associative memory can retrieve the rest of the items belonging to that memory . The diverse human cognitive abilities which involve making appropriate responses to stimulus patterns can often be understood as the operation of an associative memory , with the “ memories ” often being distillations and consolidations of multiple experiences rather than merely corresponding to a single event . The intuitive idea of associative memory can be described using a “ feature space ” . In a mathematical model abstracted from neurobiology , the presence ( or absence ) of each particular feature i is denoted by the activity ( or lack of activity ) of a model neuron vi due to being directly driven by a feature signal . If there are Nf possible features , there can be only at most N2f distinct connections ( synapses ) in a neural circuit involving only these neurons . Typical cortical synapses are not highly reliable , and can store only a few bits of information1 . The description of a particular memory requires roughly Nf bits of information . Such a system can therefore store at most ∼ Nf unrelated memories . Artificial neural network models of associative memory ( based on attractor dynamics of feature neurons and understood through an energy function ) exhibit this limitation even with precise synapses , with limits of memory storage to less than ∼ 0.14Nf memories ( Hopfield , 1982 ) . 1For instance , a recent study ( Bromer et al. , 2018 ) reports the information content of individual synapses ranging between 2.7 and 4.7 bits , based on electron microscopy imaging , see also ( Bartol Jr et al. , 2015 ) . These numbers refer to the structural accuracy of synapses . There is also electrical and chemical noise in synaptic currents induced by the biophysical details of vesicle release and neurotransmitter binding . The unreliability of the fusion of pre-synaptic vesicles ( containing neurotransmitter ) with the pre-synaptic neuron membrane is the dominant source of trial-to-trial synaptic current variation ( Allen & Stevens , 1994 ) . This noise decreases the electrical information capacity of individual synapses from the maximal value that the synaptic structure would otherwise provide . Situations arise in which the number Nf is small and the desired number of memories far exceeds ∼ Nf , see some examples from biological and AI systems in Section 4 . In these situations the associative memory model of ( Hopfield , 1982 ) would be insufficient , since it would not be able to memorize the required number of patterns . At the same time , models of associative memory with large storage capacity considered in our paper , can easily solve these problems . The starting point of this paper is a machine learning approach to associative memory based on an energy function and attractor dynamics in the space of Nf variables , called Dense Associative Memory ( Krotov & Hopfield , 2016 ) . This idea has been shown to dramatically increase the memory storage capacity of the corresponding neural network ( Krotov & Hopfield , 2016 ; Demircigil et al. , 2017 ) and was proposed to be useful for increasing robustness of neural networks to adversarial attacks ( Krotov & Hopfield , 2018 ) . Recently , an extension of this idea to continuous variables , called modern Hopfield network , demonstrated remarkably successful results on the immune repertoire classification ( Widrich et al. , 2020 ) , and provided valuable insights into the properties of attention heads in Transformer architectures ( Ramsauer et al. , 2020 ) . Dense Associative Memories or modern Hopfield networks , however , can not describe biological neural networks in terms of true microscopic degrees of freedom , since they contain many-body interaction terms in equations describing their dynamics and the corresponding energy functions . To illustrate this point consider two networks : a conventional Hopfield network ( Hopfield , 1982 ) and a Dense Associative Memory with cubic interaction term in the energy function ( see Fig . 1 ) . In the conventional network the dynamics is encoded in the matrix Tij , which represents the strengths of the synaptic connections between feature neurons i and j . Thus , this network is manifestly describable in terms of only two-body synapses , which is approximately true for many biological synapses . In contrast , a Dense Associative Memory network with cubic energy function naively requires the synaptic connections to be tensors Tijk with three indices , which are harder , although not impossible , to implement biologically . Many-body synapses become even more problematic in situations when the interaction term is described by a more complicated function than a simple power ( in this case the Taylor expansion of that function would generate a series of terms with increasing powers ) . Many-body synapses typically appear in situations when one starts with a microscopic theory described by only two-body synapses and integrates out some of the degrees of freedom ( hidden neurons ) . The argument described above based on counting the information stored in synapses in conjunction with the fact that modern Hopfield nets and Dense Associative Memories can have a huge storage capacity hints at the same solution . The reason why these networks have a storage capacity much greater than Nf is because they do not describe the dynamics of only Nf neurons , but rather involve additional neurons and synapses . Thus , there remains a theoretical question : what does this hidden circuitry look like ? Is it possible to introduce a set of hidden neurons with appropriately chosen interaction terms and activation functions so that the resulting theory has both large memory storage capacity ( significantly bigger than Nf ) , and , at the same time , is manifestly describable in terms on only two-body synapses ? The main contributions of this current paper are the following . First , we extend the model of ( Krotov & Hopfield , 2016 ) to continuous state variables and continuous time , so that the state of the network is described by a system of non-linear differential equations . Second , we couple an additional set of Nh “ complex neurons ” or “ memory neurons ” or hidden neurons to the Nf feature neurons . When the synaptic couplings and neuron activation functions are appropriately chosen , this dynamical system in Nf + Nh variables has an energy function describing its dynamics . The minima ( stable points ) of this dynamics are at the same locations in the Nf - dimensional feature subspace as the minima in the corresponding Dense Associative Memory system . Importantly , the resulting dynamical system has a mathematical structure of a conventional recurrent neural network , in which the neurons interact only in pairs through a two-body matrix of synaptic connections . We study three limiting cases of this new theory , which we call models A , B , and C. In one limit ( model A ) it reduces to Dense Associative Memory model of ( Krotov & Hopfield , 2016 ) or ( Demircigil et al. , 2017 ) depending on the choice of the activation function . In another limit ( model B ) our model reduces to the network of ( Ramsauer et al. , 2020 ) . Finally , we present a third limit ( model C ) which we call Spherical Memory model . To the best of our knowledge this model has not been studied in the literature . However , it has a high degree of symmetry and for this reason might be useful for future explorations of various models of large associative memory and recurrent neural networks in machine learning . For the purposes of this paper we defined “ biological plausiblity ” as the absence of many-body synapses . It is important to note that there other aspects in which our model described by equations ( 1 ) below is biologically implausible . For instance , it assumes that the strengths of two physically different synapses µ → i and i → µ are equal . This assumption is necessary for the existence of the energy function , which makes it easy to prove the convergence to a fixed point . It can be relaxed in equations ( 1 ) , which makes them even more biological , but , at the same time , more difficult to analyse . 2 MATHEMATICAL FORMULATION . In this section , we present a simple mathematical model in continuous time , which , on one hand , permits the storage of a huge number of patterns in the artificial neural network , and , at the same time , involves only pairwise interactions between the neurons through synaptic junctions . Thus , this system has the useful associative memory properties of the AI system , while maintaining conventional neural network dynamics and thus a degree of biological plausibility . The spikes of action potentials in a pre-synaptic cell produce input currents into a postsynaptic neuron . As a result of a single spike in the pre-synaptic cell the current in the post-synaptic neuron rises instantaneously and then falls off exponentially with a time constant τ . In the following the currents of the feature neurons are denoted by vi ( which are enumerated by the latin indices ) , and the currents of the complex memory neurons are denoted by hµ ( h stands for hidden neurons , which are enumerated by the greek indices ) . A simple cartoon of the network that we discuss is shown in Fig.2 . There are no synaptic connections among the feature neurons or the memory neurons . A matrix ξµi denotes the strength of synapses from a feature neuron i to the memory neuron µ . The synapses are assumed to be symmetric , so that the same value ξiµ = ξµi characterizes a different physical synapse from the memory neuron µ to the feature neuron i . The outputs of the memory neurons and the feature neurons are denoted by fµ and gi , which are non-linear functions of the corresponding currents . In some situations ( model A ) these outputs can be interpreted as activation functions for the corresponding neurons , so that fµ = f ( hµ ) and gi = g ( vi ) with some non-linear functions f ( x ) and g ( x ) . In other cases ( models B and C ) these outputs involve contrastive normalization , e.g . a softmax , and can depend on the currents of all the neurons in that layer . In these cases fµ = f ( { hµ } ) and gi = g ( { vi } ) . For the most part of this paper one can think about them as firing rates of the corresponding neurons . In some limiting cases , however , the function g ( vi ) will have both positive and negative signs . Then it should be interpreted as the input current from a pre-synaptic neuron . The functions f ( hµ ) and g ( vi ) are the only nonlinearities that appear in our model . Finally , the time constants for the two groups of neurons are denoted by τf and τh . With these notations our model can be written as τf dvi dt = Nh∑ µ=1 ξiµfµ − vi + Ii τh dhµ dt = Nf∑ i=1 ξµigi − hµ ( 1 ) where Ii denotes the input current into the feature neurons . The connectivity of our network has the structure of a bipartite graph , so that the connections exist between two groups of neurons , but not within each of the two groups . This design of a neural network is inspired by the class of models called Restricted Boltzmann Machines ( RBM ) ( Smolensky , 1986 ) . There is a body of literature studying thermodynamic properties of these systems and learning rules for the synaptic weights . In contrast , the goal of our work is to write down a general dynamical system and an energy function so that the network has useful properties of associative memories with a large memory storage capacity , is describable only in terms of manifestly two-body synapses , and is sufficiently general so that it can be reduced to various models of this class previously discussed in the literature . We also note that although we use the notation vi ( v stands for visible neurons ) , commonly used in the RBM literature , it is more appropriate to think about vi as higher level features . For example the input to our network can be a latent representation produced by a convolutional neural network or a latent representation of a BERT-like system ( Devlin et al. , 2018 ) rather than raw input data . Additionally , our general formulation makes it possible to use a much broader class of activation functions ( e.g . involving contrastive or spherical normalization ) than those typically used in the RBM literature . Also , the relationship between Dense Associative Memories and RBMs has been previously studied in ( Barra et al. , 2018 ; Agliari & De Marzo , 2020 ) . We also note that a Hopfield network with exponential capacity was studied in ( Chaudhuri & Fiete , 2019 ) , but their construction requires specifically engineered memory vectors and can not be applied to general arbitrary memory vectors . Mathematically , equations ( 1 ) describe temporal evolution of two groups of neurons . For each neuron its temporal updates are determined by the inputs from other neurons and its own state ( the decay term on the right hand side of the dynamical equations ) . For this reason , an energy function for this system is expected to be represented as a sum of three terms : two terms describing the neurons in each specific group , and the interaction term between the two groups of neurons . We have chosen the specific mathematical form of these three terms so that the energy function decreases on the dynamical trajectory . With these choices the energy function for the network ( 1 ) can be written as E ( t ) = [ Nf∑ i=1 ( vi − Ii ) gi − Lv ] + [ Nh∑ µ=1 hµfµ − Lh ] − ∑ µ , i fµξµigi ( 2 ) Here we introduced two Lagrangian functionsLv ( { vi } ) andLh ( { hµ } ) for the feature and the hidden neurons . They are defined through the following equations , so that derivatives of the Lagrangian functions correspond to the outputs of neurons fµ = ∂Lh ∂hµ , and gi = ∂Lv ∂vi ( 3 ) With these notations expressions in the square brackets in ( 2 ) have a familiar from classical mechanics structure of the Legendre transform between a Lagrangian and an energy function . By taking time derivative of the energy and using dynamical equations ( 1 ) one can show ( see Appendix A for details ) that the energy monotonically decreases on the dynamical trajectory dE ( t ) dt = −τf Nf∑ i , j=1 dvi dt ∂2Lv ∂vi∂vj dvj dt − τh Nh∑ µ , ν=1 dhµ dt ∂2Lh ∂hµ∂hν dhν dt ≤ 0 ( 4 ) The last inequality sign holds provided that the Hessian matrices of the Lagrangian functions are positive semi-definite . In addition to decrease of the energy function on the dynamical trajectory it is important to check that for a specific choice of the activation functions ( or Lagrangian functions ) the corresponding energy is bounded from below . This can be achieved for example by using bounded activation function for the feature neurons g ( vi ) , e.g . hyperbolic tangent or a sigmoid . Provided that the energy is bounded , the dynamics of the neural network will eventually reach a fixed point , which corresponds to one of the local minima of the energy function2 . The proposed energy function has three terms in it : the first term depends only on the feature neurons , the second term depends only on the hidden neurons , and the third term is the “ interaction ” term between the two groups of neurons . Note , that this third term is manifestly describable by twobody synapses - a function of the activity of the feature neurons is coupled to another function of the activity of the memory neurons , and the strength of this coupling is characterized by the parameters ξµi . The absence of many-body interaction terms in the energy function results in the conventional structure ( with unconventional activation functions ) of the dynamical equations ( 1 ) . Each neuron collects outputs of other neurons , weights them with coefficients ξ and generates its own output . Thus , the network described by equations ( 1 ) is biologically plausible according to our definition ( see Introduction ) . Lastly , note that the memory patterns ξµi of our network ( 1 ) can be interpreted as the strengths of the synapses connecting feature and memory neurons . This interpretation is different from the conventional interpretation , in which the strengths of the synapses is determined by matrices Tij = ∑ µ ξµiξµj ( see Fig . 1 ) , which are outer products of the memory vectors ( or higher order generalizations of the outer products ) . | This paper presents a novel class of associative memory models. The model is expressed as a network with two-body interactions (synapses) and a well-defined energy function, and it is shown to generalise and unify several existing approaches (Hopfield Networks, Dense Associative Memories and Modern Hopfield Networks). Besides its theoretical and computational properties, the model is presented as being more biologically valid/plausible than some of the existing approaches it generalizes. | SP:4496f5847520ba21176ac3ea35183849b6b8239e |
Large Associative Memory Problem in Neurobiology and Machine Learning | 1 INTRODUCTION . Associative memory is defined in psychology as the ability to remember ( link ) many sets , called memories , of unrelated items . Prompted by a large enough subset of items taken from one memory , an animal or computer with an associative memory can retrieve the rest of the items belonging to that memory . The diverse human cognitive abilities which involve making appropriate responses to stimulus patterns can often be understood as the operation of an associative memory , with the “ memories ” often being distillations and consolidations of multiple experiences rather than merely corresponding to a single event . The intuitive idea of associative memory can be described using a “ feature space ” . In a mathematical model abstracted from neurobiology , the presence ( or absence ) of each particular feature i is denoted by the activity ( or lack of activity ) of a model neuron vi due to being directly driven by a feature signal . If there are Nf possible features , there can be only at most N2f distinct connections ( synapses ) in a neural circuit involving only these neurons . Typical cortical synapses are not highly reliable , and can store only a few bits of information1 . The description of a particular memory requires roughly Nf bits of information . Such a system can therefore store at most ∼ Nf unrelated memories . Artificial neural network models of associative memory ( based on attractor dynamics of feature neurons and understood through an energy function ) exhibit this limitation even with precise synapses , with limits of memory storage to less than ∼ 0.14Nf memories ( Hopfield , 1982 ) . 1For instance , a recent study ( Bromer et al. , 2018 ) reports the information content of individual synapses ranging between 2.7 and 4.7 bits , based on electron microscopy imaging , see also ( Bartol Jr et al. , 2015 ) . These numbers refer to the structural accuracy of synapses . There is also electrical and chemical noise in synaptic currents induced by the biophysical details of vesicle release and neurotransmitter binding . The unreliability of the fusion of pre-synaptic vesicles ( containing neurotransmitter ) with the pre-synaptic neuron membrane is the dominant source of trial-to-trial synaptic current variation ( Allen & Stevens , 1994 ) . This noise decreases the electrical information capacity of individual synapses from the maximal value that the synaptic structure would otherwise provide . Situations arise in which the number Nf is small and the desired number of memories far exceeds ∼ Nf , see some examples from biological and AI systems in Section 4 . In these situations the associative memory model of ( Hopfield , 1982 ) would be insufficient , since it would not be able to memorize the required number of patterns . At the same time , models of associative memory with large storage capacity considered in our paper , can easily solve these problems . The starting point of this paper is a machine learning approach to associative memory based on an energy function and attractor dynamics in the space of Nf variables , called Dense Associative Memory ( Krotov & Hopfield , 2016 ) . This idea has been shown to dramatically increase the memory storage capacity of the corresponding neural network ( Krotov & Hopfield , 2016 ; Demircigil et al. , 2017 ) and was proposed to be useful for increasing robustness of neural networks to adversarial attacks ( Krotov & Hopfield , 2018 ) . Recently , an extension of this idea to continuous variables , called modern Hopfield network , demonstrated remarkably successful results on the immune repertoire classification ( Widrich et al. , 2020 ) , and provided valuable insights into the properties of attention heads in Transformer architectures ( Ramsauer et al. , 2020 ) . Dense Associative Memories or modern Hopfield networks , however , can not describe biological neural networks in terms of true microscopic degrees of freedom , since they contain many-body interaction terms in equations describing their dynamics and the corresponding energy functions . To illustrate this point consider two networks : a conventional Hopfield network ( Hopfield , 1982 ) and a Dense Associative Memory with cubic interaction term in the energy function ( see Fig . 1 ) . In the conventional network the dynamics is encoded in the matrix Tij , which represents the strengths of the synaptic connections between feature neurons i and j . Thus , this network is manifestly describable in terms of only two-body synapses , which is approximately true for many biological synapses . In contrast , a Dense Associative Memory network with cubic energy function naively requires the synaptic connections to be tensors Tijk with three indices , which are harder , although not impossible , to implement biologically . Many-body synapses become even more problematic in situations when the interaction term is described by a more complicated function than a simple power ( in this case the Taylor expansion of that function would generate a series of terms with increasing powers ) . Many-body synapses typically appear in situations when one starts with a microscopic theory described by only two-body synapses and integrates out some of the degrees of freedom ( hidden neurons ) . The argument described above based on counting the information stored in synapses in conjunction with the fact that modern Hopfield nets and Dense Associative Memories can have a huge storage capacity hints at the same solution . The reason why these networks have a storage capacity much greater than Nf is because they do not describe the dynamics of only Nf neurons , but rather involve additional neurons and synapses . Thus , there remains a theoretical question : what does this hidden circuitry look like ? Is it possible to introduce a set of hidden neurons with appropriately chosen interaction terms and activation functions so that the resulting theory has both large memory storage capacity ( significantly bigger than Nf ) , and , at the same time , is manifestly describable in terms on only two-body synapses ? The main contributions of this current paper are the following . First , we extend the model of ( Krotov & Hopfield , 2016 ) to continuous state variables and continuous time , so that the state of the network is described by a system of non-linear differential equations . Second , we couple an additional set of Nh “ complex neurons ” or “ memory neurons ” or hidden neurons to the Nf feature neurons . When the synaptic couplings and neuron activation functions are appropriately chosen , this dynamical system in Nf + Nh variables has an energy function describing its dynamics . The minima ( stable points ) of this dynamics are at the same locations in the Nf - dimensional feature subspace as the minima in the corresponding Dense Associative Memory system . Importantly , the resulting dynamical system has a mathematical structure of a conventional recurrent neural network , in which the neurons interact only in pairs through a two-body matrix of synaptic connections . We study three limiting cases of this new theory , which we call models A , B , and C. In one limit ( model A ) it reduces to Dense Associative Memory model of ( Krotov & Hopfield , 2016 ) or ( Demircigil et al. , 2017 ) depending on the choice of the activation function . In another limit ( model B ) our model reduces to the network of ( Ramsauer et al. , 2020 ) . Finally , we present a third limit ( model C ) which we call Spherical Memory model . To the best of our knowledge this model has not been studied in the literature . However , it has a high degree of symmetry and for this reason might be useful for future explorations of various models of large associative memory and recurrent neural networks in machine learning . For the purposes of this paper we defined “ biological plausiblity ” as the absence of many-body synapses . It is important to note that there other aspects in which our model described by equations ( 1 ) below is biologically implausible . For instance , it assumes that the strengths of two physically different synapses µ → i and i → µ are equal . This assumption is necessary for the existence of the energy function , which makes it easy to prove the convergence to a fixed point . It can be relaxed in equations ( 1 ) , which makes them even more biological , but , at the same time , more difficult to analyse . 2 MATHEMATICAL FORMULATION . In this section , we present a simple mathematical model in continuous time , which , on one hand , permits the storage of a huge number of patterns in the artificial neural network , and , at the same time , involves only pairwise interactions between the neurons through synaptic junctions . Thus , this system has the useful associative memory properties of the AI system , while maintaining conventional neural network dynamics and thus a degree of biological plausibility . The spikes of action potentials in a pre-synaptic cell produce input currents into a postsynaptic neuron . As a result of a single spike in the pre-synaptic cell the current in the post-synaptic neuron rises instantaneously and then falls off exponentially with a time constant τ . In the following the currents of the feature neurons are denoted by vi ( which are enumerated by the latin indices ) , and the currents of the complex memory neurons are denoted by hµ ( h stands for hidden neurons , which are enumerated by the greek indices ) . A simple cartoon of the network that we discuss is shown in Fig.2 . There are no synaptic connections among the feature neurons or the memory neurons . A matrix ξµi denotes the strength of synapses from a feature neuron i to the memory neuron µ . The synapses are assumed to be symmetric , so that the same value ξiµ = ξµi characterizes a different physical synapse from the memory neuron µ to the feature neuron i . The outputs of the memory neurons and the feature neurons are denoted by fµ and gi , which are non-linear functions of the corresponding currents . In some situations ( model A ) these outputs can be interpreted as activation functions for the corresponding neurons , so that fµ = f ( hµ ) and gi = g ( vi ) with some non-linear functions f ( x ) and g ( x ) . In other cases ( models B and C ) these outputs involve contrastive normalization , e.g . a softmax , and can depend on the currents of all the neurons in that layer . In these cases fµ = f ( { hµ } ) and gi = g ( { vi } ) . For the most part of this paper one can think about them as firing rates of the corresponding neurons . In some limiting cases , however , the function g ( vi ) will have both positive and negative signs . Then it should be interpreted as the input current from a pre-synaptic neuron . The functions f ( hµ ) and g ( vi ) are the only nonlinearities that appear in our model . Finally , the time constants for the two groups of neurons are denoted by τf and τh . With these notations our model can be written as τf dvi dt = Nh∑ µ=1 ξiµfµ − vi + Ii τh dhµ dt = Nf∑ i=1 ξµigi − hµ ( 1 ) where Ii denotes the input current into the feature neurons . The connectivity of our network has the structure of a bipartite graph , so that the connections exist between two groups of neurons , but not within each of the two groups . This design of a neural network is inspired by the class of models called Restricted Boltzmann Machines ( RBM ) ( Smolensky , 1986 ) . There is a body of literature studying thermodynamic properties of these systems and learning rules for the synaptic weights . In contrast , the goal of our work is to write down a general dynamical system and an energy function so that the network has useful properties of associative memories with a large memory storage capacity , is describable only in terms of manifestly two-body synapses , and is sufficiently general so that it can be reduced to various models of this class previously discussed in the literature . We also note that although we use the notation vi ( v stands for visible neurons ) , commonly used in the RBM literature , it is more appropriate to think about vi as higher level features . For example the input to our network can be a latent representation produced by a convolutional neural network or a latent representation of a BERT-like system ( Devlin et al. , 2018 ) rather than raw input data . Additionally , our general formulation makes it possible to use a much broader class of activation functions ( e.g . involving contrastive or spherical normalization ) than those typically used in the RBM literature . Also , the relationship between Dense Associative Memories and RBMs has been previously studied in ( Barra et al. , 2018 ; Agliari & De Marzo , 2020 ) . We also note that a Hopfield network with exponential capacity was studied in ( Chaudhuri & Fiete , 2019 ) , but their construction requires specifically engineered memory vectors and can not be applied to general arbitrary memory vectors . Mathematically , equations ( 1 ) describe temporal evolution of two groups of neurons . For each neuron its temporal updates are determined by the inputs from other neurons and its own state ( the decay term on the right hand side of the dynamical equations ) . For this reason , an energy function for this system is expected to be represented as a sum of three terms : two terms describing the neurons in each specific group , and the interaction term between the two groups of neurons . We have chosen the specific mathematical form of these three terms so that the energy function decreases on the dynamical trajectory . With these choices the energy function for the network ( 1 ) can be written as E ( t ) = [ Nf∑ i=1 ( vi − Ii ) gi − Lv ] + [ Nh∑ µ=1 hµfµ − Lh ] − ∑ µ , i fµξµigi ( 2 ) Here we introduced two Lagrangian functionsLv ( { vi } ) andLh ( { hµ } ) for the feature and the hidden neurons . They are defined through the following equations , so that derivatives of the Lagrangian functions correspond to the outputs of neurons fµ = ∂Lh ∂hµ , and gi = ∂Lv ∂vi ( 3 ) With these notations expressions in the square brackets in ( 2 ) have a familiar from classical mechanics structure of the Legendre transform between a Lagrangian and an energy function . By taking time derivative of the energy and using dynamical equations ( 1 ) one can show ( see Appendix A for details ) that the energy monotonically decreases on the dynamical trajectory dE ( t ) dt = −τf Nf∑ i , j=1 dvi dt ∂2Lv ∂vi∂vj dvj dt − τh Nh∑ µ , ν=1 dhµ dt ∂2Lh ∂hµ∂hν dhν dt ≤ 0 ( 4 ) The last inequality sign holds provided that the Hessian matrices of the Lagrangian functions are positive semi-definite . In addition to decrease of the energy function on the dynamical trajectory it is important to check that for a specific choice of the activation functions ( or Lagrangian functions ) the corresponding energy is bounded from below . This can be achieved for example by using bounded activation function for the feature neurons g ( vi ) , e.g . hyperbolic tangent or a sigmoid . Provided that the energy is bounded , the dynamics of the neural network will eventually reach a fixed point , which corresponds to one of the local minima of the energy function2 . The proposed energy function has three terms in it : the first term depends only on the feature neurons , the second term depends only on the hidden neurons , and the third term is the “ interaction ” term between the two groups of neurons . Note , that this third term is manifestly describable by twobody synapses - a function of the activity of the feature neurons is coupled to another function of the activity of the memory neurons , and the strength of this coupling is characterized by the parameters ξµi . The absence of many-body interaction terms in the energy function results in the conventional structure ( with unconventional activation functions ) of the dynamical equations ( 1 ) . Each neuron collects outputs of other neurons , weights them with coefficients ξ and generates its own output . Thus , the network described by equations ( 1 ) is biologically plausible according to our definition ( see Introduction ) . Lastly , note that the memory patterns ξµi of our network ( 1 ) can be interpreted as the strengths of the synapses connecting feature and memory neurons . This interpretation is different from the conventional interpretation , in which the strengths of the synapses is determined by matrices Tij = ∑ µ ξµiξµj ( see Fig . 1 ) , which are outer products of the memory vectors ( or higher order generalizations of the outer products ) . | The authors proposed a dynamical system that unifies several associative memory models, including the classical Hopfield network and two recently proposed modern Hopfield networks. The dynamical system is described as interactions between two groups of neurons (feature and memory neurons), providing a more biological interpretation of modern Hopfield networks. The proposed system reduces to different associative memory models by choosing different generalized activation functions, each of which maps inputs to a group of neurons into output activity. This manuscript provides sufficient details for understanding, its derivations are correct, and its results are useful in bringing modern Hopfield networks closer to biology. | SP:4496f5847520ba21176ac3ea35183849b6b8239e |
Boosting One-Point Derivative-Free Online Optimization via Residual Feedback | 1 INTRODUCTION . Zeroth-order optimization ( ZO ) algorithms have been widely used to solve online optimization problems where first or second order information ( i.e. , gradient or Hessian information ) is unavailable at each time instant . Such problems arise , e.g. , in online learning and involve adversarial training Chen et al . ( 2017 ) and reinforcement learning Fazel et al . ( 2018 ) ; Malik et al . ( 2018 ) among others . The goal in online optimization is to minimize a sequence of time-varying objective functions { ft ( x ) } t=1 : T , where the value ft ( xt ) is revealed to the agent after an action xt is selected and is used to adapt the agent ’ s future strategy . Since the future objective functions are not known a priori , the performance of the online decision process can be measured using notions of regret , generally defined as the difference between the total cost incurred by the decision selected by the agent online and the cost of the fixed or varying optimal decision that a clairvoyant agent could select . Perhaps the most popular zeroth-order gradient estimator is the two-point estimator that has been extensively studied in Agarwal et al . ( 2010 ) ; Ghadimi & Lan ( 2013 ) ; Duchi et al . ( 2015 ) ; Ghadimi et al . ( 2016 ) ; Bach & Perchet ( 2016 ) ; Nesterov & Spokoiny ( 2017 ) ; Gao et al . ( 2018 ) ; Roy et al . ( 2019 ) . Specifically , the two-point estimator queries the function value ft ( x ) for twice , for two different realizations of the decision variables , and uses the difference in these function values to estimate the desired gradient , as illustrated by the equation ( Two-point feedback ) : eg ( 2 ) t ( x ) = u ⇣ ft ( x+ u ) ft ( x ) ⌘ , ( 1 ) where > 0 is a parameter and u ⇠ N ( 0 , I ) . However , the two-point gradient estimator can not be used for the solution of non-stationary online optimization problems that arise frequently , e.g. , in online learning . The reason is that in these non-stationary online optimization problems , the objective function being queried is time-varying , and hence only a single function value can be sampled at a given time instant . In this case , the following one-point feedback can be used ( One-point feedback ) : eg ( 1 ) t ( x ) = u ft ( x+ u ) , ( 2 ) which queries the objective function ft ( x ) only once at each time instant . One-point feedback was first proposed and analyzed in Flaxman et al . ( 2005 ) for the solution of online convex optimization problems . Saha & Tewari ( 2011 ) ; Hazan & Levy ( 2014 ) ; Dekel et al . ( 2015 ) showed that the regret of convex online optimization methods using one-point gradient estimation can be improved assuming smoothness or strong convexity of the objective functions and using self-concordant regularization . More recently , Gasnikov et al . ( 2017 ) developed such regret bounds for stochastic convex problems . On the other hand , Hazan et al . ( 2016 ) characterized the convergence of one-point zeroth-order methods for static stochastic non-convex optimization problems . However , as shown in these studies , a limitation of one-point feedback is that the resulting gradient estimator has large variance and , therefore , induces large regret . In addition , the regret analysis for ZO with one-point feedback usually requires the strong assumption that the function value is uniformly upper bounded over time , so this method can not be used for practical non-stationary optimization problems . Contributions : In this paper , we propose a novel one-point gradient estimator for zeroth-order online optimization and develop new regret bounds to study its performance . Specifically , our contributions are as follows . We propose a new one-point feedback scheme which requires a single function evaluation at each time instant . This feedback scheme estimates the gradient using the residual between two consecutive feedback points and we refer to it as residual feedback . We show that our residual feedback induces a smaller gradient estimation variance than the conventional one-point feedback scheme in Flaxman et al . ( 2005 ) ; Gasnikov et al . ( 2017 ) . Furthermore , we provide regret bounds for online convex optimization with our proposed residual feedback estimator . Our analysis relies on a weaker assumption than the one needed in the case of the conventional one-point estimator , and our proposed regret bounds are tighter especially when the value of the objective function is large . In addition , we provide regret bounds for online non-convex optimization with residual feedback . Finally , we present numerical experiments that demonstrate that the proposed residual-feedback estimator significantly outperforms the conventional one-point method in its ability to track the time-varying optimizers of online learning problems . To the best of our knowledge , this is the first time a one-point zeroth-order method is theoretically studied for online non-convex optimization problems . It is also the first time that a one-point gradient estimator demonstrates comparable empirical performance to that of the two-point method . We note that two-point estimators can only be used to solve online non-stationary learning problems in simulations , where the system can be hard coded to be fixed during two queries of the objective function values at two different decision variables . Related work : Zeroth-order methods have been used to solve many different types of optimization problems . For example , Balasubramanian & Ghadimi ( 2018 ) apply ZO to solve a set-constrained optimization problem where the projection onto the constraint set is non-trivial . Gorbunov et al . ( 2018 ) ; Ji et al . ( 2019 ) apply a variance-reduced technique and acceleration schemes to achieve better convergence speed in ZO . Wang et al . ( 2018 ) improve the dependence of the iteration complexity on the dimension of the problem under an additional sparsity assumption on the gradient of the objective function . And Hajinezhad & Zavlanos ( 2018 ) ; Tang & Li ( 2019 ) apply zeroth-order oracles to distributed optimization problems when only bandit feedbacks are available at each local agents . Our proposed residual feedback oracle can be used to solve such online optimization problems as well . Also related is work by Zhang et al . ( 2015 ) that considers non-convex online bandit optimization problems with a single query at each time step . However , this method employs the exploration and exploitation bandit learning framework and the proposed analysis is restricted to a special class of non-convex objective functions . Finally , Agarwal et al . ( 2011 ) ; Hazan & Li ( 2016 ) ; Bubeck et al . ( 2017 ) study online bandit algorithms using ellipsoid methods . In particular , these methods induce heavy computation per step and achieve regret bounds that have bad dependence on the problem dimension . As a comparison , our one-point method is computation light and achieves regret bounds that have better dependence on the problem dimension . 2 PRELIMINARIES AND RESIDUAL FEEDBACK . We first introduce the classes of Lipschitz and smooth functions . Definition 2.1 ( Lipschitz functions ) . The class of Lipschtiz-continuous functions C0,0 satisfies : for any f 2 C 0,0 , |f ( x ) f ( y ) | L0kx yk , 8x , y 2 Rd , where L0 > 0 is the Lipschitz parameter . The class of smooth functions C 1,1 satisfies : for any f 2 C 1,1 , krf ( x ) rf ( y ) k L1kx yk , 8x , y 2 Rd , where L1 > 0 is the smoothness parameter . In ZO , the objective is to estimate the first-order gradient of a function using zeroth-order oracles . Necessarily , we need to perturb the function around the current point along all the directions uniformly in order to estimate the gradient . This motivates us to consider the Gaussian-smoothed version of the function f as introduced in Nesterov & Spokoiny ( 2017 ) , f ( x ) : = Eu⇠N ( 0,1 ) [ f ( x+ u ) ] , where the coordinates of the vector u are i.i.d standard Gaussian random variables . The following bounds on the approximation error of the function f ( x ) have been developed in Nesterov & Spokoiny ( 2017 ) . Lemma 2.2 . Consider a function f and its smoothed version f . It holds that |f ( x ) f ( x ) | ⇢ L0 p d , if f 2 C 0,0 , 2 L1d , if f 2 C 1,1 , and krf ( x ) rf ( x ) k L1 ( d+ 3 ) 3/2 , if f 2 C 1,1 . The smoothed function f ( x ) satisfies the following amenable property Nesterov & Spokoiny ( 2017 ) . Lemma 2.3 . If f 2 C0,0 is L0-Lipschitz , then f 2 C1,1 with Lipschitz constant L1 = p d 1 L0 . Consider the following online bandit optimization problem . min x2X T 1X t=0 ft ( x ) , ( P ) where X ⇢ Rd is a convex set and { ft } t is a random sequence of objective functions . In this setting , the objective functions { ft } t are unknown a priori and their derivatives are unavailable . At time t , a new objective function ft is randomly generated independent of an agent ’ s decisions , and then the agent queries the objective function value at certain perturbed points and use them to update the current policy parameters . The goal of the agent is to minimize a certain regret function . Such an online setting often occurs in non-stationary learning scenarios where either the system is time-varying on its own or a single query of the function ft changes the system state ( i.e. , ft changes to ft+1 ) . In this non-stationary setting , the conventional two-point feedback scheme is known to be impractical as it requires to evaluate ft at two different points at the same time t. Instead , it is natural to use the one-point feedback scheme ( 2 ) in Gasnikov et al . ( 2017 ) . However , the gradient estimate based on the above one-point feedback induces a large variance that leads to a large regret . In this paper , we focus on such an one-point derivative-free setting and propose the following novel one-point residual feedback scheme for estimating the gradient with reduced variance . ( Residual feedback ) : egt ( xt ) : = ut ft ( xt + ut ) ft 1 ( xt 1 + ut 1 ) , ( 3 ) where ut 1 , ut ⇠ N ( 0 , I ) are independent random vectors . To elaborate , the residual feedback in ( 3 ) queries ft at a single perturbed point xt + ut , and then subtracts it by ft 1 ( xt 1 + ut 1 ) obtained from the previous iteration . We name such a scheme as one-point residual feedback . Next , we explore some basic properties of the residual feedback . We first show that this estimator is an unbiased gradient estimate of the smoothed function f , t. Lemma 2.4 . The residual feedback satisfies E ⇥ egt ( xt ) ⇤ = rf , t ( xt ) for all xt 2 X and t. Proof . By the fact that ut has zero mean and is independent from ut 1 and xt 1 . We consider the following ZO algorithm with residual feedback ( ZO with residual feedback ) : xt+1 = ⇧X xt ⌘g̃t ( xt ) , ( 4 ) where ⌘ is the learning rate and ⇧X is the projection operator onto the set X . The update ( 4 ) can be implemented assuming that the objective function can be queried at points outside the feasible set X , similar to the methods considered in Duchi et al . ( 2015 ) ; Bach & Perchet ( 2016 ) ; Gasnikov et al . ( 2017 ) . Note that it is possible to modify the update ( 4 ) so that the iterates are guaranteed to be within the feasible set X . This modification and related analysis can be found in Section H in the supplementary material . The requirement that the objective function is evaluated at feasible points in derivative-free optimization algorithms has also been considered in Bubeck et al . ( 2017 ) ; Bilenne et al . ( 2020 ) . Specifically , Bubeck et al . ( 2017 ) develop the so called ellipsoid method , which requires computation of an ellipsoid containing the optimizer at each time step . On the other hand , almost concurrently with this work , Bilenne et al . ( 2020 ) proposed a similar oracle as in ( 3 ) for a static convex optimization problem with specific objective and constraint functions . Next , we bound the second moment of the gradient estimate based on the residual feedback . Lemma 2.5 ( Second moment ) . Assume that ft 2 C0,0 with Lipschitz constant L0 for all time t. Then , under the ZO update rule in ( 4 ) , the second moment of the residual feedback satisfies : for all t , E [ kegt ( xt ) k2 ] 4dL20⌘ 2 2 E [ kegt 1 ( xt 1 ) k2 ] +Dt , ( 5 ) where Dt : = 16L 2 0 ( d+ 4 ) 2 + 2d 2 E ⇥ ft ( xt 1 + ut 1 ) ft 1 ( xt 1 + ut 1 ) 2⇤ . The above lemma shows that the second moment of the residual feedback can be bounded by a perturbed contraction , provided that we choose ⌘ and such that the contracting rate ↵ = 4dL20⌘ 2 2 < 1 . As we show later in the analysis , such a contraction property leads to a small variance of the residual feedback that helps reduce the regret of the online ZO algorithm . | This manuscript considers online zeroth order optimization and it develops a gradient estimator based on one query per function. In particular, the proposed method mimics two-point estimators by evaluating two consecutive functions at perturbations of an iterate, as shown in equation (3). Although one-point gradient estimates are possible, they have impractically large variances. Given this limitation and the wide need of zeroth order optimization (in particular in RL), the study of two-point estimators is important. | SP:a13b7c970bfcd4b06913233730bc5a7e1552dd4c |
Boosting One-Point Derivative-Free Online Optimization via Residual Feedback | 1 INTRODUCTION . Zeroth-order optimization ( ZO ) algorithms have been widely used to solve online optimization problems where first or second order information ( i.e. , gradient or Hessian information ) is unavailable at each time instant . Such problems arise , e.g. , in online learning and involve adversarial training Chen et al . ( 2017 ) and reinforcement learning Fazel et al . ( 2018 ) ; Malik et al . ( 2018 ) among others . The goal in online optimization is to minimize a sequence of time-varying objective functions { ft ( x ) } t=1 : T , where the value ft ( xt ) is revealed to the agent after an action xt is selected and is used to adapt the agent ’ s future strategy . Since the future objective functions are not known a priori , the performance of the online decision process can be measured using notions of regret , generally defined as the difference between the total cost incurred by the decision selected by the agent online and the cost of the fixed or varying optimal decision that a clairvoyant agent could select . Perhaps the most popular zeroth-order gradient estimator is the two-point estimator that has been extensively studied in Agarwal et al . ( 2010 ) ; Ghadimi & Lan ( 2013 ) ; Duchi et al . ( 2015 ) ; Ghadimi et al . ( 2016 ) ; Bach & Perchet ( 2016 ) ; Nesterov & Spokoiny ( 2017 ) ; Gao et al . ( 2018 ) ; Roy et al . ( 2019 ) . Specifically , the two-point estimator queries the function value ft ( x ) for twice , for two different realizations of the decision variables , and uses the difference in these function values to estimate the desired gradient , as illustrated by the equation ( Two-point feedback ) : eg ( 2 ) t ( x ) = u ⇣ ft ( x+ u ) ft ( x ) ⌘ , ( 1 ) where > 0 is a parameter and u ⇠ N ( 0 , I ) . However , the two-point gradient estimator can not be used for the solution of non-stationary online optimization problems that arise frequently , e.g. , in online learning . The reason is that in these non-stationary online optimization problems , the objective function being queried is time-varying , and hence only a single function value can be sampled at a given time instant . In this case , the following one-point feedback can be used ( One-point feedback ) : eg ( 1 ) t ( x ) = u ft ( x+ u ) , ( 2 ) which queries the objective function ft ( x ) only once at each time instant . One-point feedback was first proposed and analyzed in Flaxman et al . ( 2005 ) for the solution of online convex optimization problems . Saha & Tewari ( 2011 ) ; Hazan & Levy ( 2014 ) ; Dekel et al . ( 2015 ) showed that the regret of convex online optimization methods using one-point gradient estimation can be improved assuming smoothness or strong convexity of the objective functions and using self-concordant regularization . More recently , Gasnikov et al . ( 2017 ) developed such regret bounds for stochastic convex problems . On the other hand , Hazan et al . ( 2016 ) characterized the convergence of one-point zeroth-order methods for static stochastic non-convex optimization problems . However , as shown in these studies , a limitation of one-point feedback is that the resulting gradient estimator has large variance and , therefore , induces large regret . In addition , the regret analysis for ZO with one-point feedback usually requires the strong assumption that the function value is uniformly upper bounded over time , so this method can not be used for practical non-stationary optimization problems . Contributions : In this paper , we propose a novel one-point gradient estimator for zeroth-order online optimization and develop new regret bounds to study its performance . Specifically , our contributions are as follows . We propose a new one-point feedback scheme which requires a single function evaluation at each time instant . This feedback scheme estimates the gradient using the residual between two consecutive feedback points and we refer to it as residual feedback . We show that our residual feedback induces a smaller gradient estimation variance than the conventional one-point feedback scheme in Flaxman et al . ( 2005 ) ; Gasnikov et al . ( 2017 ) . Furthermore , we provide regret bounds for online convex optimization with our proposed residual feedback estimator . Our analysis relies on a weaker assumption than the one needed in the case of the conventional one-point estimator , and our proposed regret bounds are tighter especially when the value of the objective function is large . In addition , we provide regret bounds for online non-convex optimization with residual feedback . Finally , we present numerical experiments that demonstrate that the proposed residual-feedback estimator significantly outperforms the conventional one-point method in its ability to track the time-varying optimizers of online learning problems . To the best of our knowledge , this is the first time a one-point zeroth-order method is theoretically studied for online non-convex optimization problems . It is also the first time that a one-point gradient estimator demonstrates comparable empirical performance to that of the two-point method . We note that two-point estimators can only be used to solve online non-stationary learning problems in simulations , where the system can be hard coded to be fixed during two queries of the objective function values at two different decision variables . Related work : Zeroth-order methods have been used to solve many different types of optimization problems . For example , Balasubramanian & Ghadimi ( 2018 ) apply ZO to solve a set-constrained optimization problem where the projection onto the constraint set is non-trivial . Gorbunov et al . ( 2018 ) ; Ji et al . ( 2019 ) apply a variance-reduced technique and acceleration schemes to achieve better convergence speed in ZO . Wang et al . ( 2018 ) improve the dependence of the iteration complexity on the dimension of the problem under an additional sparsity assumption on the gradient of the objective function . And Hajinezhad & Zavlanos ( 2018 ) ; Tang & Li ( 2019 ) apply zeroth-order oracles to distributed optimization problems when only bandit feedbacks are available at each local agents . Our proposed residual feedback oracle can be used to solve such online optimization problems as well . Also related is work by Zhang et al . ( 2015 ) that considers non-convex online bandit optimization problems with a single query at each time step . However , this method employs the exploration and exploitation bandit learning framework and the proposed analysis is restricted to a special class of non-convex objective functions . Finally , Agarwal et al . ( 2011 ) ; Hazan & Li ( 2016 ) ; Bubeck et al . ( 2017 ) study online bandit algorithms using ellipsoid methods . In particular , these methods induce heavy computation per step and achieve regret bounds that have bad dependence on the problem dimension . As a comparison , our one-point method is computation light and achieves regret bounds that have better dependence on the problem dimension . 2 PRELIMINARIES AND RESIDUAL FEEDBACK . We first introduce the classes of Lipschitz and smooth functions . Definition 2.1 ( Lipschitz functions ) . The class of Lipschtiz-continuous functions C0,0 satisfies : for any f 2 C 0,0 , |f ( x ) f ( y ) | L0kx yk , 8x , y 2 Rd , where L0 > 0 is the Lipschitz parameter . The class of smooth functions C 1,1 satisfies : for any f 2 C 1,1 , krf ( x ) rf ( y ) k L1kx yk , 8x , y 2 Rd , where L1 > 0 is the smoothness parameter . In ZO , the objective is to estimate the first-order gradient of a function using zeroth-order oracles . Necessarily , we need to perturb the function around the current point along all the directions uniformly in order to estimate the gradient . This motivates us to consider the Gaussian-smoothed version of the function f as introduced in Nesterov & Spokoiny ( 2017 ) , f ( x ) : = Eu⇠N ( 0,1 ) [ f ( x+ u ) ] , where the coordinates of the vector u are i.i.d standard Gaussian random variables . The following bounds on the approximation error of the function f ( x ) have been developed in Nesterov & Spokoiny ( 2017 ) . Lemma 2.2 . Consider a function f and its smoothed version f . It holds that |f ( x ) f ( x ) | ⇢ L0 p d , if f 2 C 0,0 , 2 L1d , if f 2 C 1,1 , and krf ( x ) rf ( x ) k L1 ( d+ 3 ) 3/2 , if f 2 C 1,1 . The smoothed function f ( x ) satisfies the following amenable property Nesterov & Spokoiny ( 2017 ) . Lemma 2.3 . If f 2 C0,0 is L0-Lipschitz , then f 2 C1,1 with Lipschitz constant L1 = p d 1 L0 . Consider the following online bandit optimization problem . min x2X T 1X t=0 ft ( x ) , ( P ) where X ⇢ Rd is a convex set and { ft } t is a random sequence of objective functions . In this setting , the objective functions { ft } t are unknown a priori and their derivatives are unavailable . At time t , a new objective function ft is randomly generated independent of an agent ’ s decisions , and then the agent queries the objective function value at certain perturbed points and use them to update the current policy parameters . The goal of the agent is to minimize a certain regret function . Such an online setting often occurs in non-stationary learning scenarios where either the system is time-varying on its own or a single query of the function ft changes the system state ( i.e. , ft changes to ft+1 ) . In this non-stationary setting , the conventional two-point feedback scheme is known to be impractical as it requires to evaluate ft at two different points at the same time t. Instead , it is natural to use the one-point feedback scheme ( 2 ) in Gasnikov et al . ( 2017 ) . However , the gradient estimate based on the above one-point feedback induces a large variance that leads to a large regret . In this paper , we focus on such an one-point derivative-free setting and propose the following novel one-point residual feedback scheme for estimating the gradient with reduced variance . ( Residual feedback ) : egt ( xt ) : = ut ft ( xt + ut ) ft 1 ( xt 1 + ut 1 ) , ( 3 ) where ut 1 , ut ⇠ N ( 0 , I ) are independent random vectors . To elaborate , the residual feedback in ( 3 ) queries ft at a single perturbed point xt + ut , and then subtracts it by ft 1 ( xt 1 + ut 1 ) obtained from the previous iteration . We name such a scheme as one-point residual feedback . Next , we explore some basic properties of the residual feedback . We first show that this estimator is an unbiased gradient estimate of the smoothed function f , t. Lemma 2.4 . The residual feedback satisfies E ⇥ egt ( xt ) ⇤ = rf , t ( xt ) for all xt 2 X and t. Proof . By the fact that ut has zero mean and is independent from ut 1 and xt 1 . We consider the following ZO algorithm with residual feedback ( ZO with residual feedback ) : xt+1 = ⇧X xt ⌘g̃t ( xt ) , ( 4 ) where ⌘ is the learning rate and ⇧X is the projection operator onto the set X . The update ( 4 ) can be implemented assuming that the objective function can be queried at points outside the feasible set X , similar to the methods considered in Duchi et al . ( 2015 ) ; Bach & Perchet ( 2016 ) ; Gasnikov et al . ( 2017 ) . Note that it is possible to modify the update ( 4 ) so that the iterates are guaranteed to be within the feasible set X . This modification and related analysis can be found in Section H in the supplementary material . The requirement that the objective function is evaluated at feasible points in derivative-free optimization algorithms has also been considered in Bubeck et al . ( 2017 ) ; Bilenne et al . ( 2020 ) . Specifically , Bubeck et al . ( 2017 ) develop the so called ellipsoid method , which requires computation of an ellipsoid containing the optimizer at each time step . On the other hand , almost concurrently with this work , Bilenne et al . ( 2020 ) proposed a similar oracle as in ( 3 ) for a static convex optimization problem with specific objective and constraint functions . Next , we bound the second moment of the gradient estimate based on the residual feedback . Lemma 2.5 ( Second moment ) . Assume that ft 2 C0,0 with Lipschitz constant L0 for all time t. Then , under the ZO update rule in ( 4 ) , the second moment of the residual feedback satisfies : for all t , E [ kegt ( xt ) k2 ] 4dL20⌘ 2 2 E [ kegt 1 ( xt 1 ) k2 ] +Dt , ( 5 ) where Dt : = 16L 2 0 ( d+ 4 ) 2 + 2d 2 E ⇥ ft ( xt 1 + ut 1 ) ft 1 ( xt 1 + ut 1 ) 2⇤ . The above lemma shows that the second moment of the residual feedback can be bounded by a perturbed contraction , provided that we choose ⌘ and such that the contracting rate ↵ = 4dL20⌘ 2 2 < 1 . As we show later in the analysis , such a contraction property leads to a small variance of the residual feedback that helps reduce the regret of the online ZO algorithm . | The paper considers online optimization with zero-order oracle. Motivated by nonstationarity of the objective function, impracticality is underlined for the two-point feedback approach. Instead, staying in the one-point setting, the proposed approach reuses the objective value from the previous round of observations, which is called as residual feedback. The variance of the corresponding proxy for the subgradient is estimated under more relaxed assumptions than existing in the literature. The proposed approach leads to smaller variance and better regret bounds. Regret bounds are proved for smooth/non-smooth convex/non-convex cases, the non-convex case being analyzed for the first time in the literature. Numerical experiments show that the practical performance of the proposed gradient estimator is better than that of the existing one-point feedback methods and is close to the performance of the one-point approach with two observations per round. The latter approach can be impractical for some applications. | SP:a13b7c970bfcd4b06913233730bc5a7e1552dd4c |
SoCal: Selective Oracle Questioning for Consistency-based Active Learning of Cardiac Signals | 1 INTRODUCTION . The success of modern-day deep learning algorithms in the medical domain has been contingent upon the availability of large , labelled datasets ( Poplin et al. , 2018 ; Tomašev et al. , 2019 ; Attia et al. , 2019 ) . Curating such datasets , however , is a challenge due to the time-consuming nature of , and high costs associated with , labelling . This is particularly the case in the medical domain where the input of expert medical professionals is required . One way of overcoming this challenge and exploiting large , unlabelled datasets is via the active learning ( AL ) framework ( Settles , 2009 ) . This framework iterates over three main steps : 1 ) a learner is tasked with acquiring unlabelled instances , usually through an acquisition function , 2 ) an oracle ( e.g . physician ) is tasked with labelling such acquired instances , and 3 ) the learner is trained on the existing and newly-labelled instances . By altering the way in which acquisitions are performed and the degree of involvement of the oracle , the active learning framework aims to improve the performance of a network while minimizing the burden of labelling on the oracle . One principal desideratum for an acquisition function is its ability to reduce the size of the version space , the set of hypotheses ( decision boundaries ) consistent with the labelled training instances . This ability is highly dependent upon the approximation of the version space , a goal that Monte Carlo Dropout ( MCD ) attempts to achieve ( see Fig . 1a ) . For example , state-of-the-art uncertainty-based acquisition functions , such as BALD ( Houlsby et al. , 2011 ) , used alongside MCD acquire instances that lie in a region of uncertainty , a region where there is high disagreement between the hypotheses about a particular instance . In many scenarios , however , estimating this region of uncertainty is nontrivial . Furthermore , existing AL frameworks are overly reliant on the presence of an oracle . Such over-reliance precludes the applicability of AL algorithms to certain environments , such as low-resource healthcare settings , where an oracle is either unavailable or ill-trained for the task at hand . Contributions . In this work , we aim to design an active learning framework that better estimates the region of uncertainty and decreases its reliance on an oracle . Our contributions are as follows : 1 . Consistency-based active learning framework : we propose a novel framework that stochastically perturbs inputs , network parameters , or both to guide the acquisition of unlabelled instances . 2 . Selective oracle questioning : we propose a dynamic strategy which learns , for an acquired unlabelled instance , whether to request a label from an oracle or to generate a pseudo-label instead . 2 RELATED WORK . Active learning methdologies were recently reviewed by Settles ( 2009 ) . In the healthcare domain , Gong et al . ( 2019 ) propose to acquire instances from an electronic health record ( EHR ) database using a Bayesian deep latent Gaussian model to improve mortality prediction . Smailagic et al . ( 2018 ; 2019 ) acquire unannotated medical images by measuring their distance in a latent space to images in the training set . The work of Wang et al . ( 2019 ) is similar to ours in that they focus on the electrocardiogram ( ECG ) . Gal et al . ( 2017 ) adopt BALD ( Houlsby et al. , 2011 ) in the context of Monte Carlo Dropout to acquire datapoints that maximize the Jensen-Shannon divergence ( JSD ) across MC samples . Previous work attempts to learn from multiple or imperfect oracles ( Dekel et al. , 2012 ; Zhang & Chaudhuri , 2015 ; Sinha et al. , 2019 ) . For example , Urner et al . ( 2012 ) propose choosing the oracle that should label a particular instance . Unlike our approach , they do not explore independence from an oracle . Yan et al . ( 2016 ) consider oracle abstention in an AL setting . Instead , we place the decision of abstention under the control of the learner . To the best of our knowledge , previous work , in contrast to ours , has assumed the existence of an oracle and has not explored a dynamic oracle selection strategy . Consistency training in the context of semi-supervised learning helps enforce the smoothness assumption ( Zhu , 2005 ) . For example , Interpolation Consistency Training ( Verma et al. , 2019 ) penalizes networks for not generating a linear combination of outputs in response to a linear combination of inputs . Similarly , Xie et al . ( 2019 ) penalizes networks for generating drastically different outputs in response to perturbed instances . In the process , networks learn perturbation-invariant representations . McCallumzy & Nigamy ( 1998 ) introduce an acquisition function that calculates the average Kullback-Leibler divergence , DKL , between the output of a network and the consensus output across all networks in an ensemble . Unlike ours , their approach does not exploit perturbations . Similar to our work is that of Gao et al . ( 2019 ) which incorporates into the objective function a consistency-loss based on the DKL and actively acquires instances using the variance of the probability assigned to each class by the network in response to perturbed versions of the same instance . Selective classification imbues a network with the ability to abstain from making predictions . Chow ( 1970 ) ; El-Yaniv & Wiener ( 2010 ) introduce the risk-coverage trade-off whereby the empirical risk of a model is inversely related to its rate of abstentions . Wiener & El-Yaniv ( 2011 ) use a support vector machine ( SVM ) to rank and reject instances based on the degree of disagreement between hypotheses . In some frameworks , these are the same instances that active learning views as most informative . Cortes et al . ( 2016 ) outline an objective function that penalizes abstentions that are inappropriate and frequent . Most recently , Liu et al . ( 2019 ) propose the gambler ’ s loss to learn a selection function that determines whether instances are rejected . However , this approach is not implemented in the context of AL . Most similar to our work is SelectiveNet ( Geifman & El-Yaniv , 2019 ) where a multi-head architecture is used alongside an empirical selective risk objective function and a percentile threshold . However , their work assumes the presence of ground-truth labels and , therefore , does not extend to unlabelled instances . 3 BACKGROUND . 3.1 ACTIVE LEARNING . Consider a learner fω : x ∈ Rm → v ∈ Rd , parameterized by ω , that maps an m-dimensional input , x , to a d-dimensional representation , v. Further consider gφ : v ∈ Rd → y ∈ RC that maps a ddimensional representation , v , to a C-dimensional output , y , where C is the number of classes . After training on a pool of labelled data L = ( XL , YL ) for τ epochs , the learner is tasked with querying the unlabelled pool of data U = ( XU , YU ) and acquiring the top b fraction of instances , xb ∼ XU , that it deems to be most informative . The degree of informativeness of an instance is determined by an acquisition function , α , such as BALD ( Houlsby et al. , 2011 ) . Additional acquisition functions can be found in Appendix A . These are typically used in conjunction with Monte Carlo Dropout ( Gal & Ghahramani , 2016 ) to identify instances that lie in the region of uncertainty , a region in which hypotheses disagree the most about instances . 4 METHODS . 4.1 CONSISTENCY-BASED ACTIVE LEARNING . 4.1.1 MONTE CARLO PERTURBATIONS . Unlabelled instances in proximity to the decision boundary are likely to be more informative for training than those further away . To identify such instances , we stochastically perturb them and observe the network ’ s outputs . The intuition is that such outputs will differ significantly across the perturbations for instances close to the decision boundary ( see Fig . 1b ) . We refer to this setup as Monte Carlo Perturbations ( MCP ) and illustrate its derivation in Appendix B . 4.1.2 BAYESIAN ACTIVE LEARNING BY CONSISTENCY . Acquisition functions dependent upon perturbations applied to either the inputs ( MCP ) or the network parameters ( MCD ) alone can fail to identify instances that lie in the region of uncertainty . We illustrate this point with the following example : without loss of generality , let us assume an unlabelled instance is in proximity to some decision boundary A and is classified by the network as belonging to some arbitrary class 3 . Such proximity should deem the instance informative for the training process ( Settles , 2009 ) . In the MCD setting , perturbations are applied to parameters , generating various decision boundaries , which in turn influence the network outputs . In Fig . 2 ( red rectangle ) , we visualize such outputs for three arbitrary classes . If these parameter perturbations happen to be too small in magnitude , for example , then the network will continue to classify the instance as belonging to the same class . At this stage , regardless of whether an uncertainty-based or a consistency-based acquisition function is used , the instance would be deemed uninformative , and thus not acquired . As a result , an instance that should have been acquired ( due to its proximity to the decision boundary ) was erroneously deemed uninformative . A similar argument can be extended to MCP . By applying perturbations to both instances and network parameters , we aim to leverage the smoothness assumption ( Zhu , 2005 ) to better identify instances that lie in the region of uncertainty and thus avoid missing their acquisition . Motivated by this , we propose a framework , entitled Bayesian Active Learning by Consistency ( BALC ) ( see Fig . 1c ) , that consists of three main steps : 1 ) we perturb an instance , x , to generate z , 2 ) we perturb the network parameters , ω , to generate ω′ , and 3 ) we pass both instances through the perturbed network , generating outputs , p ( y|x , ω′ ) and p ( y|z , ω′ ) ∈ RC , respectively . We perform these steps for T stochastic perturbations and generate two matrices of network outputs , G ( x ) , G′ ( z ) ∈ RT×C . We visualize such network outputs in Fig . 2 where T = 3 and C = 3 . To leverage G and G′ , we propose two divergence-based acquisition functions that acquire instances that the network is least robust to . In BALCKLD , we calculate the DKL between two C-dimensional Gaussians that are empirically fit to G and G′ . BALCKLD = DKL ( N ( µ ( x ) , Σ ( x ) ‖ N ( µ ( z ) , Σ ( z ) ) ) ( 1 ) where µ = 1T ∑T i G and Σ = ( G− µ ) T ( G− µ ) represent the empirical mean vector and covariance matrix of the network outputs , respectively . BALCKLD is likely to detect output variations due to input perturbations . We support this claim in Fig . 2 by illustrating two scenarios . In scenario 1 , network output variations are caused solely by input perturbations . In contrast , in scenario 2 , network output variations are caused by both input and parameter perturbations . We show that BALCKLD ≈ 1 and 0 in these two scenarios , respectively . Since the higher the value of an acquisition function , the more informative an instance is , these scenarios illustrate BALCKLD ’ s preference for input perturbations . To detect variations due to both input and parameter perturbations , we introduce BALCJSD whose full derivation can be found in Appendix C. BALCJSD = across parameter perturbations︷ ︸︸ ︷ Ei∈T [ DKL ( Gi ( x ) ‖ G′i ( z ) ) ] − across input perturbations︷ ︸︸ ︷ DKL ( Ei∈T [ G ( x ) ] ‖ Ei∈T [ G′ ( z ) ] ) ( 2 ) | The paper proposes an active learning framework called SoCal that is consistency-based and can decide between whether to make use of the oracle to provide a label or to make use of a pseudo-label generated by the algorithm itself instead. The proposed method hopes to address resource-constrained active learning scenarios where the oracle is not always available or we wish to make use of the oracle as infrequently as possible. Experimental results demonstrate reasonable performance on four publically available physiological datasets. Experimental results when the oracle is noisy is also reported. | SP:962be382d6cbf5cfd5b3406e726ccf0b2a39e049 |
SoCal: Selective Oracle Questioning for Consistency-based Active Learning of Cardiac Signals | 1 INTRODUCTION . The success of modern-day deep learning algorithms in the medical domain has been contingent upon the availability of large , labelled datasets ( Poplin et al. , 2018 ; Tomašev et al. , 2019 ; Attia et al. , 2019 ) . Curating such datasets , however , is a challenge due to the time-consuming nature of , and high costs associated with , labelling . This is particularly the case in the medical domain where the input of expert medical professionals is required . One way of overcoming this challenge and exploiting large , unlabelled datasets is via the active learning ( AL ) framework ( Settles , 2009 ) . This framework iterates over three main steps : 1 ) a learner is tasked with acquiring unlabelled instances , usually through an acquisition function , 2 ) an oracle ( e.g . physician ) is tasked with labelling such acquired instances , and 3 ) the learner is trained on the existing and newly-labelled instances . By altering the way in which acquisitions are performed and the degree of involvement of the oracle , the active learning framework aims to improve the performance of a network while minimizing the burden of labelling on the oracle . One principal desideratum for an acquisition function is its ability to reduce the size of the version space , the set of hypotheses ( decision boundaries ) consistent with the labelled training instances . This ability is highly dependent upon the approximation of the version space , a goal that Monte Carlo Dropout ( MCD ) attempts to achieve ( see Fig . 1a ) . For example , state-of-the-art uncertainty-based acquisition functions , such as BALD ( Houlsby et al. , 2011 ) , used alongside MCD acquire instances that lie in a region of uncertainty , a region where there is high disagreement between the hypotheses about a particular instance . In many scenarios , however , estimating this region of uncertainty is nontrivial . Furthermore , existing AL frameworks are overly reliant on the presence of an oracle . Such over-reliance precludes the applicability of AL algorithms to certain environments , such as low-resource healthcare settings , where an oracle is either unavailable or ill-trained for the task at hand . Contributions . In this work , we aim to design an active learning framework that better estimates the region of uncertainty and decreases its reliance on an oracle . Our contributions are as follows : 1 . Consistency-based active learning framework : we propose a novel framework that stochastically perturbs inputs , network parameters , or both to guide the acquisition of unlabelled instances . 2 . Selective oracle questioning : we propose a dynamic strategy which learns , for an acquired unlabelled instance , whether to request a label from an oracle or to generate a pseudo-label instead . 2 RELATED WORK . Active learning methdologies were recently reviewed by Settles ( 2009 ) . In the healthcare domain , Gong et al . ( 2019 ) propose to acquire instances from an electronic health record ( EHR ) database using a Bayesian deep latent Gaussian model to improve mortality prediction . Smailagic et al . ( 2018 ; 2019 ) acquire unannotated medical images by measuring their distance in a latent space to images in the training set . The work of Wang et al . ( 2019 ) is similar to ours in that they focus on the electrocardiogram ( ECG ) . Gal et al . ( 2017 ) adopt BALD ( Houlsby et al. , 2011 ) in the context of Monte Carlo Dropout to acquire datapoints that maximize the Jensen-Shannon divergence ( JSD ) across MC samples . Previous work attempts to learn from multiple or imperfect oracles ( Dekel et al. , 2012 ; Zhang & Chaudhuri , 2015 ; Sinha et al. , 2019 ) . For example , Urner et al . ( 2012 ) propose choosing the oracle that should label a particular instance . Unlike our approach , they do not explore independence from an oracle . Yan et al . ( 2016 ) consider oracle abstention in an AL setting . Instead , we place the decision of abstention under the control of the learner . To the best of our knowledge , previous work , in contrast to ours , has assumed the existence of an oracle and has not explored a dynamic oracle selection strategy . Consistency training in the context of semi-supervised learning helps enforce the smoothness assumption ( Zhu , 2005 ) . For example , Interpolation Consistency Training ( Verma et al. , 2019 ) penalizes networks for not generating a linear combination of outputs in response to a linear combination of inputs . Similarly , Xie et al . ( 2019 ) penalizes networks for generating drastically different outputs in response to perturbed instances . In the process , networks learn perturbation-invariant representations . McCallumzy & Nigamy ( 1998 ) introduce an acquisition function that calculates the average Kullback-Leibler divergence , DKL , between the output of a network and the consensus output across all networks in an ensemble . Unlike ours , their approach does not exploit perturbations . Similar to our work is that of Gao et al . ( 2019 ) which incorporates into the objective function a consistency-loss based on the DKL and actively acquires instances using the variance of the probability assigned to each class by the network in response to perturbed versions of the same instance . Selective classification imbues a network with the ability to abstain from making predictions . Chow ( 1970 ) ; El-Yaniv & Wiener ( 2010 ) introduce the risk-coverage trade-off whereby the empirical risk of a model is inversely related to its rate of abstentions . Wiener & El-Yaniv ( 2011 ) use a support vector machine ( SVM ) to rank and reject instances based on the degree of disagreement between hypotheses . In some frameworks , these are the same instances that active learning views as most informative . Cortes et al . ( 2016 ) outline an objective function that penalizes abstentions that are inappropriate and frequent . Most recently , Liu et al . ( 2019 ) propose the gambler ’ s loss to learn a selection function that determines whether instances are rejected . However , this approach is not implemented in the context of AL . Most similar to our work is SelectiveNet ( Geifman & El-Yaniv , 2019 ) where a multi-head architecture is used alongside an empirical selective risk objective function and a percentile threshold . However , their work assumes the presence of ground-truth labels and , therefore , does not extend to unlabelled instances . 3 BACKGROUND . 3.1 ACTIVE LEARNING . Consider a learner fω : x ∈ Rm → v ∈ Rd , parameterized by ω , that maps an m-dimensional input , x , to a d-dimensional representation , v. Further consider gφ : v ∈ Rd → y ∈ RC that maps a ddimensional representation , v , to a C-dimensional output , y , where C is the number of classes . After training on a pool of labelled data L = ( XL , YL ) for τ epochs , the learner is tasked with querying the unlabelled pool of data U = ( XU , YU ) and acquiring the top b fraction of instances , xb ∼ XU , that it deems to be most informative . The degree of informativeness of an instance is determined by an acquisition function , α , such as BALD ( Houlsby et al. , 2011 ) . Additional acquisition functions can be found in Appendix A . These are typically used in conjunction with Monte Carlo Dropout ( Gal & Ghahramani , 2016 ) to identify instances that lie in the region of uncertainty , a region in which hypotheses disagree the most about instances . 4 METHODS . 4.1 CONSISTENCY-BASED ACTIVE LEARNING . 4.1.1 MONTE CARLO PERTURBATIONS . Unlabelled instances in proximity to the decision boundary are likely to be more informative for training than those further away . To identify such instances , we stochastically perturb them and observe the network ’ s outputs . The intuition is that such outputs will differ significantly across the perturbations for instances close to the decision boundary ( see Fig . 1b ) . We refer to this setup as Monte Carlo Perturbations ( MCP ) and illustrate its derivation in Appendix B . 4.1.2 BAYESIAN ACTIVE LEARNING BY CONSISTENCY . Acquisition functions dependent upon perturbations applied to either the inputs ( MCP ) or the network parameters ( MCD ) alone can fail to identify instances that lie in the region of uncertainty . We illustrate this point with the following example : without loss of generality , let us assume an unlabelled instance is in proximity to some decision boundary A and is classified by the network as belonging to some arbitrary class 3 . Such proximity should deem the instance informative for the training process ( Settles , 2009 ) . In the MCD setting , perturbations are applied to parameters , generating various decision boundaries , which in turn influence the network outputs . In Fig . 2 ( red rectangle ) , we visualize such outputs for three arbitrary classes . If these parameter perturbations happen to be too small in magnitude , for example , then the network will continue to classify the instance as belonging to the same class . At this stage , regardless of whether an uncertainty-based or a consistency-based acquisition function is used , the instance would be deemed uninformative , and thus not acquired . As a result , an instance that should have been acquired ( due to its proximity to the decision boundary ) was erroneously deemed uninformative . A similar argument can be extended to MCP . By applying perturbations to both instances and network parameters , we aim to leverage the smoothness assumption ( Zhu , 2005 ) to better identify instances that lie in the region of uncertainty and thus avoid missing their acquisition . Motivated by this , we propose a framework , entitled Bayesian Active Learning by Consistency ( BALC ) ( see Fig . 1c ) , that consists of three main steps : 1 ) we perturb an instance , x , to generate z , 2 ) we perturb the network parameters , ω , to generate ω′ , and 3 ) we pass both instances through the perturbed network , generating outputs , p ( y|x , ω′ ) and p ( y|z , ω′ ) ∈ RC , respectively . We perform these steps for T stochastic perturbations and generate two matrices of network outputs , G ( x ) , G′ ( z ) ∈ RT×C . We visualize such network outputs in Fig . 2 where T = 3 and C = 3 . To leverage G and G′ , we propose two divergence-based acquisition functions that acquire instances that the network is least robust to . In BALCKLD , we calculate the DKL between two C-dimensional Gaussians that are empirically fit to G and G′ . BALCKLD = DKL ( N ( µ ( x ) , Σ ( x ) ‖ N ( µ ( z ) , Σ ( z ) ) ) ( 1 ) where µ = 1T ∑T i G and Σ = ( G− µ ) T ( G− µ ) represent the empirical mean vector and covariance matrix of the network outputs , respectively . BALCKLD is likely to detect output variations due to input perturbations . We support this claim in Fig . 2 by illustrating two scenarios . In scenario 1 , network output variations are caused solely by input perturbations . In contrast , in scenario 2 , network output variations are caused by both input and parameter perturbations . We show that BALCKLD ≈ 1 and 0 in these two scenarios , respectively . Since the higher the value of an acquisition function , the more informative an instance is , these scenarios illustrate BALCKLD ’ s preference for input perturbations . To detect variations due to both input and parameter perturbations , we introduce BALCJSD whose full derivation can be found in Appendix C. BALCJSD = across parameter perturbations︷ ︸︸ ︷ Ei∈T [ DKL ( Gi ( x ) ‖ G′i ( z ) ) ] − across input perturbations︷ ︸︸ ︷ DKL ( Ei∈T [ G ( x ) ] ‖ Ei∈T [ G′ ( z ) ] ) ( 2 ) | The authors proposed a consistent-based active learning framework to annotate largely unlabeled physiological signals with the help of human annotators (oracles). The paper is well organized and easy to follow. It is somewhat novel to equipping active learning with consistency learning and selective classification. The experiments (along with the Appendix) give a comprehensive analysis of the method. | SP:962be382d6cbf5cfd5b3406e726ccf0b2a39e049 |
Decentralized Knowledge Graph Representation Learning | 1 INTRODUCTION . Knowledge graphs ( KGs ) support many data-driven applications ( Ji et al. , 2020 ) . Recently , learning low-dimensional representations ( a.k.a . embeddings ) of entities and relations in KGs has been increasingly given attentions ( Rossi et al. , 2020 ) . We find that existing models for KG representation learning share similar characteristics to those for word representation learning . For example , TransE ( Bordes et al. , 2013 ) , a well-known translational KG embedding model , interprets a triple ( e1 , r , e2 ) as e1 + r ≈ e2 , where e1 , e2 , r denote subject , object and their relationship , respectively , and the boldfaces denote the corresponding embeddings . If we view e1 as a word in sentences , and e2 as well as many other objects of e1 as the context words , then TransE and many KG embedding models ( Wang et al. , 2014 ; Dettmers et al. , 2018 ; Nguyen et al. , 2018 ; Kazemi & Poole , 2018 ; Sun et al. , 2019 ) , learn representations in a form simaliar to that used in Skip-gram ( Mikolov et al. , 2013a ) , where the input representation is learned to predict the context ( i.e. , neighbors ) representations . Recently , many graph neural networks ( GNNs ) based models for KG representation learning ( Wang et al. , 2018 ; Schlichtkrull et al. , 2018 ; Cao et al. , 2019 ; Wu et al. , 2019 ; Sun et al. , 2020 ; Vashishth et al. , 2020 ) have achieved state-of-the-art performance in KG-related tasks such as entity alignment and entity prediction . Those models learn KG representations in a CBOW ( continuous bag-of-words ) ( Mikolov et al. , 2013a ) manner , in which the context entities are aggregated to predict the target . But they also consider the representation of an entity itself when aggregating the neighborhood information . This nature prevents those models ( e.g. , GCN ( Kipf & Welling , 2017 ) and GAT ( Velickovic et al. , 2018 ) ) to be generalized to represent unseen entities . In many cases , the entities in prevalent KG-related tasks do not have self features . This motivates us to learn entity representations from and only from their context neighbors . We propose a decentralized KG representation learning approach , decentRL . The key idea of decentRL is to decentralize the semantic information of entities over only their neighbors ( i.e. , distributed context vector in CBOW ( Mikolov et al. , 2013b ) ) , which can be easily implemented by representing each entity through averaging its neighbor embeddings . In this paper , we look for a more efficient but still simple way to realize this concept on the most popular graph attention network ( GAT ) ( Velickovic et al. , 2018 ) , as well as its many variants ( Sun et al. , 2020 ; Vashishth et al. , 2020 ) . We illustrate the methodology by decentralized attention network ( DAN ) , which is based on the vallina GAT . DAN is able to support KG representation learning for unseen entities with only structure information , which is essentially different from the way of using self features ( e.g. , attribute information ) in the existing graph embedding models ( Hamilton et al. , 2017 ; Bojchevski & Günnemann , 2018 ; Hettige et al. , 2020 ) . Furthermore , the neighbors in DAN serve as an integrity to give attentions , which means that DAN is more robust and more expressive compared with conventional graph attention mechanism ( Velickovic et al. , 2018 ) . Another key problem in decentralized KG representation learning is how to estimate and optimize the output embeddings . If we distribute the information of an entity over its neighbors , the original embedding of this entity ei also learns how to effectively participate in the aggregations of its different neighbors conversely . Suppose that we have obtained an output representation gi from DAN for entity ei , we can simply estimate and optimize gi by aligning it with ei . But directly minimizing the L1/L2 distance between gi and ei may be insufficient . Specifically , these two embeddings have completely different roles and functions in the model , and the shared information may not reside in the same dimensions . Therefore , maximizing the mutual information between them is a better choice . Different from the existing works like MINE ( Belghazi et al. , 2018 ) or InfoNCE ( van den Oord et al. , 2018 ) , in this paper , we design a self knowledge distillation algorithm , called auto-distiller . It alternately optimizes gi and its potential target ei , such that gi can automatically and continuously distill knowledge from the original representation ei across different batches . The main contributions of this paper are listed as follows . ( 1 ) We propose decentralized KG representation learning , and present DAN as the prototype of graph attention mechanism under the open-world setting . ( 2 ) We design an efficient knowledge distillation algorithm to support DAN for generating representations of unseen entities . ( 3 ) We implement an end-to-end framework based on DAN and auto-distiller . The experiments show that it achieved superior performance on two prevalent KG representation learning tasks ( i.e. , entity alignment and entity prediction ) , and also significantly outperformed those cutting-edge models under the open-world setting . 2 BACKGROUND . Knowledge Graph . A KG can be viewed as a multi-relational graph , in which nodes represent entities in the real world and edges have specific labels to represent different relationships between entities . Formally , we define a KG as a 3-tuple G = ( E , R , T ) , with E and R denoting the sets of entities and relationships , respectively . T is the set of relational triples . KG Representation Learning . Conventional models are mainly based on the idea of Skip-gram . According to the types of their score functions , these models can be divided into three categories : translational models ( e.g. , TransE ( Bordes et al. , 2013 ) and TransR ( Lin et al. , 2015a ) ) , semantic matching models ( e.g. , DistMult ( Yang et al. , 2015 ) and ComplEx ( Trouillon et al. , 2016 ) ) and neural models ( e.g. , ConvE ( Dettmers et al. , 2018 ) and RSN ( Guo et al. , 2019 ) ) . We refer interested readers to the surveys ( Wang et al. , 2017 ; Ji et al. , 2020 ) for details . Recently , GNN-based models receive great attentions in this field , which are closely related to this paper . Specifically , R-GCN ( Schlichtkrull et al. , 2018 ) , AVR-GCN ( Ye et al. , 2019 ) and CompGCN ( Vashishth et al. , 2020 ) introduce different relation-specific composition operations to combine neighbors and the corresponding relations before neighbor aggregation . RDGCN ( Wu et al. , 2019 ) refactors KGs as dual relation graphs ( Monti et al. , 2018 ) where edge labels are represented as nodes for graph convolution . All the aforementioned GNN-based models choose GCNs and/or GATs to aggregate the neighbors of an entity , in which an identity matrix is added to the adjacency matrix . This operation is helpful when elements have self features , but poses a problem in learning the representations of unseen entities where no self features are attached to them . Differently , decentRL fully relies on the neighbor context to attend to the neighbors of each entity in linear complexity , which is efficient and easy to be deployed . Entity Alignment . Entity alignment aims to find the potentially aligned entity pairs in two different KGs G1 = ( E1 , R1 , T1 ) and G2 = ( E2 , R2 , T2 ) , given a limited number of aligned pairs as training data S ⊂ E1 × E2 . Oftentimes , G1 , G2 are merged to a joint KG G = ( E , R , T ) , which enables the models learn representations in a unified space . Entity Prediction . Entity prediction ( a.k.a . KG completion ( Bordes et al. , 2013 ) ) seeks to find the missing subject e1 or object e2 , given an incomplete relation triple ( ? , r , e2 ) or ( e1 , r , ? ) . It is worth noting that the performance on the entity prediction task may be greatly improved by complex deep networks , as it relies on the predictive ability rather than the embedding quality ( Guo et al. , 2019 ) . Hence , many cutting-edge models can not obtain promising results in entity alignment ( Guo et al. , 2019 ; Sun et al. , 2020 ) . Differently , entity alignment directly compares the distance of learned entity embeddings , which clearly reflects the quality of output representations . Few models demonstrate consistently good performance on both tasks , whereas decentRL is capable of achieving competitive , even better , performance compared with respective state-of-the-art models . 3 DECENTRALIZED REPRESENTATION LEARNING . In the decentralized setting , the representation of an entity ei is aggregated from and only from its neighbors Ni = { e1 , e2 , . . . , e|Ni| } . As it may have many neighbors that are unequally informative ( Velickovic et al. , 2018 ) , involving attention mechanism is a good choice . 3.1 GRAPH ATTENTION NETWORKS . We start by introducing the Graph attention network ( GAT ) ( Velickovic et al. , 2018 ) , which leverages linear self attention to operate spatially close neighbors . For an entity ei , GAT aggregates the representations of its neighbors Ni and itself into a single representation ci as follows : ci = ∑ ej∈Ni∪ { ei } aijWej , ( 1 ) where aij is the learnable attention score from ei to ej , and W is the weight matrix . To obtain aij , a linear attention mechanism is used here : aij = softmax ( σ ( aT [ W1ei ‖W2ej ] ) ) , ( 2 ) where a is a weight vector to convert the concatenation of two embeddings into a scalar attention score , and ‖ denotes the concatenation operation . W1 and W2 are two weight matrices . σ is the activation function , usually being LeakyReLU ( Xu et al. , 2015 ) . GAT computes the attention score of an entity ei to its neighbors in linear complexity , which is very efficient when being applied to large-scale graphs . 3.2 DECENTRALIZED ATTENTION NETWORKS . Intuitively , if ei is the embedding of an unseen entity , it is rarely useful in computing the attention scores ( as it is just a randomly initialized vector ) . Thus , purely relying on its neighbors may be a good choice . Specifically , to obtain the decentralized attention scores , one may simply sum all the attention scores from other neighbors a′ij = softmax ( ∑ ek∈Ni\ { ej } akj ) . However , it would lead to a problem that this sum only represents the attention of each neighbor to ej . In this case , a high attention score from one neighbor ek to ej can dominate the value of a′ij , but it does not mean that ej is more important for ei . Therefore , all neighbors should act as an integrity in giving attentions . Towards this end , we propose decentralized attention networks ( DANs ) . Formally , to obtain the decentralized attention weight aij , we have to feed the attention layer with two types of input : the neighbor context vector ni ( i.e. , query ) , and the candidate neighbor embedding ej ( i.e. , key and value ) . Separately controlling the iterations of these two variables in a multi-layer model is evidently inefficient . Instead , we realize this operation by involving a second-order attention mechanism . For layer k , DAN calculates the decentralized attention score akij as follows : akij = softmax ( σ ( aTk [ W k 1d k−1 i ‖W k 2d k−2 j ] ) ) , ( 3 ) where dk−1i , d k−2 j denote the output embeddings of layer k − 1 for ei and of layer k − 2 for ej , respectively . If we regard dk−1i as the neighbor aggregation of layer k−1 for ei , then d k−2 j is exactly the embedding of ej used in summing dk−1i . In this case , a k ij can represent the attention weight of ei ’ s neighbor context to ej . Then , we can obtain the output of layer k by : dki = ∑ ej∈Ni akijW kdk−2j . ( 4 ) It is worth noting that we perform convolutions on layer k − 2 , as the score akij is attended to the neighbor representations in layer k − 2 . This keeps the consistency and ensures the output representations are consecutive . Also , it enhances the correlation of output in different layers , and forms the second-order graph attention mechanism . For the first layer of DAN , we initialize d0i and d −1 j as follows : d0i = 1 |Ni| ∑ ej∈Ni W0ej , d −1 j = ej . ( 5 ) Here , we simply use a mean aggregator to obtain the decentralized embedding d0i of layer 0 , but other aggregators like pooling may be employed as well . This simple mean aggregator can also be regarded as a CBOW model with dynamic window size . For the architecture and implementation of DAN , please refer to Appendix A . | This paper proposes a "decentralized" method for representation learning in knowledge graphs that doesn't explicitly depend on a learned embedding for the entity node of interest, e_i. Rather, the embedding for e_i is constructed in a distributed fashion (similar in motivation to the distributional hypothesis/skip-gram word embeddings) from its neighbors via a second-order attention mechanism. The main idea is that this is better for "cold start" problems in which unknown entities might have no features, which makes building any representation that explicitly depends on entity-centric features hard. | SP:4ceb178b6b3d531512c7740d0fb52a00b7a95f04 |
Decentralized Knowledge Graph Representation Learning | 1 INTRODUCTION . Knowledge graphs ( KGs ) support many data-driven applications ( Ji et al. , 2020 ) . Recently , learning low-dimensional representations ( a.k.a . embeddings ) of entities and relations in KGs has been increasingly given attentions ( Rossi et al. , 2020 ) . We find that existing models for KG representation learning share similar characteristics to those for word representation learning . For example , TransE ( Bordes et al. , 2013 ) , a well-known translational KG embedding model , interprets a triple ( e1 , r , e2 ) as e1 + r ≈ e2 , where e1 , e2 , r denote subject , object and their relationship , respectively , and the boldfaces denote the corresponding embeddings . If we view e1 as a word in sentences , and e2 as well as many other objects of e1 as the context words , then TransE and many KG embedding models ( Wang et al. , 2014 ; Dettmers et al. , 2018 ; Nguyen et al. , 2018 ; Kazemi & Poole , 2018 ; Sun et al. , 2019 ) , learn representations in a form simaliar to that used in Skip-gram ( Mikolov et al. , 2013a ) , where the input representation is learned to predict the context ( i.e. , neighbors ) representations . Recently , many graph neural networks ( GNNs ) based models for KG representation learning ( Wang et al. , 2018 ; Schlichtkrull et al. , 2018 ; Cao et al. , 2019 ; Wu et al. , 2019 ; Sun et al. , 2020 ; Vashishth et al. , 2020 ) have achieved state-of-the-art performance in KG-related tasks such as entity alignment and entity prediction . Those models learn KG representations in a CBOW ( continuous bag-of-words ) ( Mikolov et al. , 2013a ) manner , in which the context entities are aggregated to predict the target . But they also consider the representation of an entity itself when aggregating the neighborhood information . This nature prevents those models ( e.g. , GCN ( Kipf & Welling , 2017 ) and GAT ( Velickovic et al. , 2018 ) ) to be generalized to represent unseen entities . In many cases , the entities in prevalent KG-related tasks do not have self features . This motivates us to learn entity representations from and only from their context neighbors . We propose a decentralized KG representation learning approach , decentRL . The key idea of decentRL is to decentralize the semantic information of entities over only their neighbors ( i.e. , distributed context vector in CBOW ( Mikolov et al. , 2013b ) ) , which can be easily implemented by representing each entity through averaging its neighbor embeddings . In this paper , we look for a more efficient but still simple way to realize this concept on the most popular graph attention network ( GAT ) ( Velickovic et al. , 2018 ) , as well as its many variants ( Sun et al. , 2020 ; Vashishth et al. , 2020 ) . We illustrate the methodology by decentralized attention network ( DAN ) , which is based on the vallina GAT . DAN is able to support KG representation learning for unseen entities with only structure information , which is essentially different from the way of using self features ( e.g. , attribute information ) in the existing graph embedding models ( Hamilton et al. , 2017 ; Bojchevski & Günnemann , 2018 ; Hettige et al. , 2020 ) . Furthermore , the neighbors in DAN serve as an integrity to give attentions , which means that DAN is more robust and more expressive compared with conventional graph attention mechanism ( Velickovic et al. , 2018 ) . Another key problem in decentralized KG representation learning is how to estimate and optimize the output embeddings . If we distribute the information of an entity over its neighbors , the original embedding of this entity ei also learns how to effectively participate in the aggregations of its different neighbors conversely . Suppose that we have obtained an output representation gi from DAN for entity ei , we can simply estimate and optimize gi by aligning it with ei . But directly minimizing the L1/L2 distance between gi and ei may be insufficient . Specifically , these two embeddings have completely different roles and functions in the model , and the shared information may not reside in the same dimensions . Therefore , maximizing the mutual information between them is a better choice . Different from the existing works like MINE ( Belghazi et al. , 2018 ) or InfoNCE ( van den Oord et al. , 2018 ) , in this paper , we design a self knowledge distillation algorithm , called auto-distiller . It alternately optimizes gi and its potential target ei , such that gi can automatically and continuously distill knowledge from the original representation ei across different batches . The main contributions of this paper are listed as follows . ( 1 ) We propose decentralized KG representation learning , and present DAN as the prototype of graph attention mechanism under the open-world setting . ( 2 ) We design an efficient knowledge distillation algorithm to support DAN for generating representations of unseen entities . ( 3 ) We implement an end-to-end framework based on DAN and auto-distiller . The experiments show that it achieved superior performance on two prevalent KG representation learning tasks ( i.e. , entity alignment and entity prediction ) , and also significantly outperformed those cutting-edge models under the open-world setting . 2 BACKGROUND . Knowledge Graph . A KG can be viewed as a multi-relational graph , in which nodes represent entities in the real world and edges have specific labels to represent different relationships between entities . Formally , we define a KG as a 3-tuple G = ( E , R , T ) , with E and R denoting the sets of entities and relationships , respectively . T is the set of relational triples . KG Representation Learning . Conventional models are mainly based on the idea of Skip-gram . According to the types of their score functions , these models can be divided into three categories : translational models ( e.g. , TransE ( Bordes et al. , 2013 ) and TransR ( Lin et al. , 2015a ) ) , semantic matching models ( e.g. , DistMult ( Yang et al. , 2015 ) and ComplEx ( Trouillon et al. , 2016 ) ) and neural models ( e.g. , ConvE ( Dettmers et al. , 2018 ) and RSN ( Guo et al. , 2019 ) ) . We refer interested readers to the surveys ( Wang et al. , 2017 ; Ji et al. , 2020 ) for details . Recently , GNN-based models receive great attentions in this field , which are closely related to this paper . Specifically , R-GCN ( Schlichtkrull et al. , 2018 ) , AVR-GCN ( Ye et al. , 2019 ) and CompGCN ( Vashishth et al. , 2020 ) introduce different relation-specific composition operations to combine neighbors and the corresponding relations before neighbor aggregation . RDGCN ( Wu et al. , 2019 ) refactors KGs as dual relation graphs ( Monti et al. , 2018 ) where edge labels are represented as nodes for graph convolution . All the aforementioned GNN-based models choose GCNs and/or GATs to aggregate the neighbors of an entity , in which an identity matrix is added to the adjacency matrix . This operation is helpful when elements have self features , but poses a problem in learning the representations of unseen entities where no self features are attached to them . Differently , decentRL fully relies on the neighbor context to attend to the neighbors of each entity in linear complexity , which is efficient and easy to be deployed . Entity Alignment . Entity alignment aims to find the potentially aligned entity pairs in two different KGs G1 = ( E1 , R1 , T1 ) and G2 = ( E2 , R2 , T2 ) , given a limited number of aligned pairs as training data S ⊂ E1 × E2 . Oftentimes , G1 , G2 are merged to a joint KG G = ( E , R , T ) , which enables the models learn representations in a unified space . Entity Prediction . Entity prediction ( a.k.a . KG completion ( Bordes et al. , 2013 ) ) seeks to find the missing subject e1 or object e2 , given an incomplete relation triple ( ? , r , e2 ) or ( e1 , r , ? ) . It is worth noting that the performance on the entity prediction task may be greatly improved by complex deep networks , as it relies on the predictive ability rather than the embedding quality ( Guo et al. , 2019 ) . Hence , many cutting-edge models can not obtain promising results in entity alignment ( Guo et al. , 2019 ; Sun et al. , 2020 ) . Differently , entity alignment directly compares the distance of learned entity embeddings , which clearly reflects the quality of output representations . Few models demonstrate consistently good performance on both tasks , whereas decentRL is capable of achieving competitive , even better , performance compared with respective state-of-the-art models . 3 DECENTRALIZED REPRESENTATION LEARNING . In the decentralized setting , the representation of an entity ei is aggregated from and only from its neighbors Ni = { e1 , e2 , . . . , e|Ni| } . As it may have many neighbors that are unequally informative ( Velickovic et al. , 2018 ) , involving attention mechanism is a good choice . 3.1 GRAPH ATTENTION NETWORKS . We start by introducing the Graph attention network ( GAT ) ( Velickovic et al. , 2018 ) , which leverages linear self attention to operate spatially close neighbors . For an entity ei , GAT aggregates the representations of its neighbors Ni and itself into a single representation ci as follows : ci = ∑ ej∈Ni∪ { ei } aijWej , ( 1 ) where aij is the learnable attention score from ei to ej , and W is the weight matrix . To obtain aij , a linear attention mechanism is used here : aij = softmax ( σ ( aT [ W1ei ‖W2ej ] ) ) , ( 2 ) where a is a weight vector to convert the concatenation of two embeddings into a scalar attention score , and ‖ denotes the concatenation operation . W1 and W2 are two weight matrices . σ is the activation function , usually being LeakyReLU ( Xu et al. , 2015 ) . GAT computes the attention score of an entity ei to its neighbors in linear complexity , which is very efficient when being applied to large-scale graphs . 3.2 DECENTRALIZED ATTENTION NETWORKS . Intuitively , if ei is the embedding of an unseen entity , it is rarely useful in computing the attention scores ( as it is just a randomly initialized vector ) . Thus , purely relying on its neighbors may be a good choice . Specifically , to obtain the decentralized attention scores , one may simply sum all the attention scores from other neighbors a′ij = softmax ( ∑ ek∈Ni\ { ej } akj ) . However , it would lead to a problem that this sum only represents the attention of each neighbor to ej . In this case , a high attention score from one neighbor ek to ej can dominate the value of a′ij , but it does not mean that ej is more important for ei . Therefore , all neighbors should act as an integrity in giving attentions . Towards this end , we propose decentralized attention networks ( DANs ) . Formally , to obtain the decentralized attention weight aij , we have to feed the attention layer with two types of input : the neighbor context vector ni ( i.e. , query ) , and the candidate neighbor embedding ej ( i.e. , key and value ) . Separately controlling the iterations of these two variables in a multi-layer model is evidently inefficient . Instead , we realize this operation by involving a second-order attention mechanism . For layer k , DAN calculates the decentralized attention score akij as follows : akij = softmax ( σ ( aTk [ W k 1d k−1 i ‖W k 2d k−2 j ] ) ) , ( 3 ) where dk−1i , d k−2 j denote the output embeddings of layer k − 1 for ei and of layer k − 2 for ej , respectively . If we regard dk−1i as the neighbor aggregation of layer k−1 for ei , then d k−2 j is exactly the embedding of ej used in summing dk−1i . In this case , a k ij can represent the attention weight of ei ’ s neighbor context to ej . Then , we can obtain the output of layer k by : dki = ∑ ej∈Ni akijW kdk−2j . ( 4 ) It is worth noting that we perform convolutions on layer k − 2 , as the score akij is attended to the neighbor representations in layer k − 2 . This keeps the consistency and ensures the output representations are consecutive . Also , it enhances the correlation of output in different layers , and forms the second-order graph attention mechanism . For the first layer of DAN , we initialize d0i and d −1 j as follows : d0i = 1 |Ni| ∑ ej∈Ni W0ej , d −1 j = ej . ( 5 ) Here , we simply use a mean aggregator to obtain the decentralized embedding d0i of layer 0 , but other aggregators like pooling may be employed as well . This simple mean aggregator can also be regarded as a CBOW model with dynamic window size . For the architecture and implementation of DAN , please refer to Appendix A . | This paper presents a method for knowledge graph embedding based on graph attention networks (GAT). The key idea is to avoid using the information for a node (i.e., its representation vectors) when computing the attention weights for the neighbors of the node. The paper argues that this approach can better generalize to unseen nodes where no pre-defined features/information is available. As such, the paper does not include the representations for a node $e$ from prior layers in the aggregations to compute $e$'s representations in the next layers, leveraging the representation vectors of the nodes from prior layers to obtain attention weights for the current layer. The paper also proposes to a self-learning method to learn the parameters by optimizing the mutual information of the final and initial embedding vectors for the nodes. A distillation approach is also employed to use the initial embedding vectors as the teachers and the final embedding vectors as the students. The proposed method is applied to two downstream tasks, i.e., entity alignment and entity prediction, leading to competitive performance with many prior works (the learned node embeddings still need to be aligned using task-specific losses). Some experiments on unseen entities and ablation studies are also conducted to demonstrate the benefits of the proposed method. | SP:4ceb178b6b3d531512c7740d0fb52a00b7a95f04 |
Bridging the Gap: Providing Post-Hoc Symbolic Explanations for Sequential Decision-Making Problems with Inscrutable Representations | 1 INTRODUCTION As AI systems are increasingly being deployed in scenarios involving high-stakes decisions , the issue of interpretability of their decisions to the humans in the loop has acquired renewed urgency . Most work on interpretability has hither-to focused on one-shot classification tasks , and has revolved around ideas such as marking regions of the input instance ( e.g . image ) that were most salient in the classification of that instance ( Selvaraju et al. , 2016 ; Sundararajan et al. , 2017 ) . Such methods used for one-shot classification tasks don ’ t generalize well to sequential decision tasks–that are the focus of this paper . In particular , in sequential decision tasks , humans in the loop might ask more complex “ contrastive ” explanatory queries–such as why the system took one particular course of action instead of another . The AI system ’ s answers to such questions will often be tied to its internal representations and reasoning , traces of which are not likely to be comprehensible as explanations to humans in the loop . Some have viewed this as an argu- ment to make AI systems use reasoning over symbolic models . We don ’ t take a position on the methods AI systems use to arrive at their decisions . We do however think that the onus of making their decisions interpretable to humans in the loop in their own vocabulary should fall squarely on the AI systems . Indeed , we believe that orthogonal to the issue of whether AI systems use internal symbolic representations to guide their own decisions , they need to develop local symbolic models that are interpretable to humans in the loop , and use them to provide explanations for their decisions . Accordingly , in this work , we develop a framework that takes a set of previously agreed-upon user vocabulary terms and generates contrastive explanations in these terms Miller ( 2018 ) ; Hesslow ( 1988 ) . Specifically , we will do this by learning components of a local symbolic dynamical model ( such as PDDL ( McDermott et al. , 1998 ) ) that captures the agent model in terms of actions with preconditions and effects from the user-specified vocabulary . There is evidence that such models conform to folk psychology Malle ( 2006 ) . This learned local model is then used to explain the potential infeasibility or suboptimality of the alternative raised by the user . Figure 1 presents the flow of the proposed explanation generation process in the context of Montezuma ’ s Revenge ( Wikipedia contributors , 2019 ) . In this paper , we will focus on deterministic settings ( Section 3 ) , though we can easily extend the ideas to stochastic settings , and will ground user-specified vocabulary terms in the AI system ’ s internal representations via learned classifiers ( Section 4 ) . The model components required for explanations are learned by using experiences ( i.e . state-action-state sets ) sampled from the agent model ( Section 4 & 5 ) . Additionally , we formalize the notion of local symbolic approximation for sequential decision-making models , and introduce the idea of explanatory confidence ( Section 6 ) . The exaplanatory confidence captures the fidelity of explanations and help ensure the system only provides explanation whose confidence is above a given threshold . We will evaluate the effectiveness of the method through both systematic ( IRB approved ) user studies and computational experiments ( Section 7 ) . As we will discuss in Section 2 , our approach has some connections to ( Kim et al. , 2018 ) , which while focused on one-shot classification tasks , also advocates explanations in terms of concepts that have meaning to humans in the loop . Our approach of constructing local model approximations is akin to LIME ( Ribeiro et al. , 2016 ) , with the difference being that we construct symbolic dynamical models in terms of human vocabulary , while LIME constructs approximate linear models over abstract features that are machine generated . 2 RELATED WORK . The representative works in the direction of using concept level explanation include works like ( Bau et al. , 2017 ) , TCAV ( Kim et al. , 2018 ) and its various offshoots like ( Luss et al. , 2019 ) that have focused on one-shot decisions . These works take a line quite similar to us in that they try to create explanations for current decisions in terms of a set of user-specified concepts . While these works don ’ t explicitly reason about explanatory confidence they do discuss the possibility of identifying inaccurate explanation , and tries to address them through statistical tests . Another thread of work , exemplified by works like ( Koh et al. , 2020 ; Lin et al. , 2020 ) , tries to force decisions to be made in terms of user-specified concepts , which can then be used for explanations . There have also been recent works on automatically identifying human-understandable concepts like Ghorbani et al . ( 2019 ) and Hamidi-Haines et al . ( 2018 ) . We can also leverage these methods when our system identifies scenarios with insufficient vocabulary . Most works in explaining sequential decision-making problems either use a model specified in a shared vocabulary as a starting point for explanation or focus on saliency-based explanations ( cf . ( Chakraborti et al. , 2020 ) ) , with very few exceptions . Authors of ( Hayes & Shah , 2017 ) have looked at the use of high-level concepts for policy summaries . They use logical formulas to concisely characterize various policy choices , including states where a specific action may be selected ( or not ) . Unlike our work , they are not trying to answer why the agent chooses a specific action ( or not ) . ( Waa et al. , 2018 ) looks at addressing the suboptimality of foils while supporting interpretable features , but it requires the domain developer to assign positive and negative outcomes to each action . In addition to not addressing possible vocabulary differences between a system developer and the end-user , it is also unclear if it is always possible to attach negative and positive outcomes to individual actions . Another related work is the approach studied in ( Madumal et al. , 2020 ) . Here , they are also trying to characterize dynamics in terms of high-level concepts but assume that the full structural relationship between the various variables is provided upfront . The explanations discussed in this paper can also be seen as a special case of Model Reconciliation explanation ( c.f ( Chakraborti et al. , 2017 ) ) , where the human model is considered to be empty . The usefulness of preconditions as explanations has also been studied by works like ( Winikoff , 2017 ; Broekens et al. , 2010 ) . Our effort to associate action cost to concepts could also be contrasted to efforts in ( Juozapaitis et al. , 2019 ) and ( Anderson et al. , 2019 ) which leverage interpretable reward components . Another group of works popular in RL explanations is the ones built around saliency maps ( Greydanus et al. , 2018 ; Iyer et al. , 2018 ; Puri et al. , 2019 ) , which tend to highlight parts of the state that are important for the current decision . In particular , we used ( Greydanus et al. , 2018 ) as a baseline because many follow-up works have shown their effectiveness ( cf . ( Zhang et al. , 2020 ) ) . Readers can refer to Alharin et al . ( 2020 ) for a recent survey of explanations in RL . Another related thread of work , is that of learning models ( some representative works include ( Carbonell & Gil , 1990 ; Stern & Juba , 2017 ; Wu et al. , 2007 ) ) . To the best of our knowledge none of the works in this direction allow for noisy observations of state and none focused on identifying specific model components . While we are unaware of any works that provide confidence over learned model components , ( Stern & Juba , 2017 ) provides loose PAC guarantees over the entire learned model . 3 PROBLEM SETTING . Our setting consists of an agent , be it programmed or RL-based , that has a model of the dynamics of the task that is inscrutable to the user ( in so far that the user can ’ t directly use the model representation used by the agent ) in the loop and uses a decision-making process that is sound for this given model . Note that here the term model is being used in a very general sense . These could refer to tabular models defined over large atomic state spaces , neural network-based dynamics models possibly learned over latent representation of the states and even simulators . The only restriction we place on the model is that we can sample possible experiences from it . Regardless of the true representation , we will denote the model by the tuple M = ⟨S , A , T , C⟩ . Where S and A are the state and action sets and T : S×A → S ∪ { ⊥ } ( ⊥ the absorber failure state ) and C : S×A → R capture the transition and cost function . We will use ⊥ to capture failures that could occur when the agent violates hard constraints like safety constraints or perform any invalid actions . We will consider goal-directed agents that are trying to drive the state of the world to one of the goal states ( G being the set ) from an initial state I . The solution takes the form of a sequence of actions or a plan π . We will use symbolic action models with preconditions and cost functions ( similar to PDDL models ( Geffner & Bonet , 2013 ) ) as a way to approximate the problem for explanations . Such a model can be represented by the tuple MS = ⟨FS , AS , IS , GS , CS⟩ , where FS is a set of propositional state variables defining the state space , AS is the set of actions , IS is the initial state , GS is the goal specification . Each valid problem state is uniquely identified by the subset of state variables that are true in that state ( so for any state s ∈ SMS , where SMS is the set of states for MS , s ⊆ FS ) . Each action a ∈ AS is further described in terms of the preconditions preca ( specification of states in which a is executable ) and the effects of executing the action . We will denote the state formed by executing action a in a state s as a ( s ) . We will focus on models where the preconditions are represented as a conjunction of propositions . If the action is executed in a state with missing preconditions , then the execution results in the invalid state ⊥ . Unlike standard STRIPS models , where the cost of executing action is independent of states , we will use a state-dependent cost function of the form CS : 2F ×AS → R to capture forms of cost functions popular in RL benchmarks . 4 CONTRASTIVE EXPLANATIONS . The specific explanatory setting , illustrated in Figure 1 , is one where the agent comes up with a plan π ( to achieve one of the goals specified in G from I ) and the user responds by raising an alternate plan πf ( the foil ) that they believe should be followed instead . Now the system needs to explain why π may be preferred over πf , by showing that πf is invalid ( i.e. , πf doesn ’ t lead to a goal state or one of the action in πf results in the invalid state ⊥ ) or πf is costlier than π ( C ( I , π ) < C ( I , πf ) ) .1 To concretize this interaction , consider the modified version of Montezuma ’ s Revenge ( Figure 1 ) . The agent starts from the highest platform , and the goal is to get to the key . The specified plan π may require the agent to make its way to the lowest level , jump over the skull , and then go to the key with a total cost of 20 . Now the user raises two possible foils that are similar to π but use different strategies in place of jumping over the skull . Foil1 : instead of jumping , the agent just moves left ( i.e. , it tries to move through the skull ) and , Foil2 : instead of jumping over the skull , the agent performs the attack action ( not part of the original game , but added here for illustrative purposes ) and then moves on to the key . Using the internal model , the system can recognize that in the first case , moving left would lead to an invalid state , and in the second case , the foil is costlier , though effectively communicating this to the user is a different question . If there exists a shared 1If the foil is as good as the original plan or better , then the system could switch to the foil . visual communication channel , the agent could try to demonstrate the outcome of following these alternate strategies . Unfortunately , this would not only necessitate additional cognitive load on the user ’ s end to view the demonstration , but it may also be confusing to the user in so far that they may not be able to recognize why in a particular state the move left action was invalid and attack action costly . As established in our user study and pointed out by Atrey et al . ( 2019 ) , even highlighting of visual features may not effectively resolve this confusion . This scenario thus necessitates the use of methods that are able to express possible explanations in terms that the user may understand . Learning Concept Maps : The input to our system is the set of propositional concepts the user associates with the task . For Montezuma , this could involve concepts like agent being on a ladder , holding onto the key , being next to the skull . Each concept corresponds to a propositional fact that the user associates with the task ’ s states and believes their presence or absence in a state could influence the dynamics and the cost function . We can collect such concepts from subject matter experts as by Cai et al . ( 2019 ) , or one could just let the user interact with or observe the agent and then provide a possible set of concepts . We used the latter approach to collect the propositions for our evaluation of the Sokoban domains ( Section 7 and A.7 ) . Each concept corresponds to a binary classifier , which detects whether the proposition is present or absent in a given internal state ( thus allowing us to convert the atomic states into a factored representation ) . Let C be the set of classifiers corresponding to the high-level concepts . For state s ∈ S , we will overload the notation C and specify the concepts that are true as C ( s ) , i.e. , C ( s ) = { ci|ci ∈ C ∧ ci ( s ) = 1 } ( where ci is the classifier corresponding to the ith concept and we overload the notation to also stand for the label of the ith concept ) . The training set for such concept classifiers could come from the user ( where they provide a set of positive and negative examples per concept ) . Classifiers can be then learned over the model states or the internal representations used by the agent decision-making ( for example activations of intermediate neural network layers ) . Explanation using concepts : To explain the preference of plan π over foil πf , we will present model information to the user taken from a symbolic representation of the agent model . But rather than requiring this model to be an exact representation of the complete agent model , we will instead focus on accurately capturing a subset of the model by instead trying to learn a local approximation Definition 1 A symbolic model MCS = ⟨C , ACS , C ( I ) , C ( G ) , CCS ⟩ . is said to be a local symbolic approximation of the model MR = ⟨S , A , T , C⟩ for regions of interest Ŝ ⊆ S if ∀s ∈ Ŝ and ∀a ∈ A , we have an equivalent action aC ∈ ACS , such that ( a ) aC ( C ( s ) ) = C ( T ( s , a ) ) ( assuming C ( ⊥ ) = ⊥ ) and ( b ) CCS ( C ( s ) , a ) = C ( s , a ) and ( c ) C ( G ) = ⋂ sg∈G∩Ŝ C ( sg ) . Following Section 3 , this is a PDDL-style model with preconditions and conditional costs defined over the conjunction of positive propositional literals . A.2 establishes the sufficiency of this representation to capture arbitrarily complex preconditions ( including disjunctions ) and cost functions expressed in terms of the proposition set C. Also to establish the preference of plan does not require informing the users about the entire model MCS , but rather only the relevant parts . To establish the invalidity of πf , we only need to explain the failure of the first failing action ai , i.e. , the one that resulted in the invalid state ( for Foil1 this corresponds to move-left action at the state visualized in Figure 1 ) . We explain the failure of action in a state by pointing out a proposition that is an action precondition which is absent in the given state . Thus a concept ci ∈ C is considered an explanation for failure of action ai at state si , if ci ∈ precai \ C ( si ) . For Foil1 , the explanation would be – the action move-left failed in the state as the precondition skull-not-on-left was false in the state . This formulation can also capture failure to achieve goal by appending an additional goal action at the end of the plan , which causes the state to transition to an end state , and fails for all states except the ones in G. Note that instead of identifying all the missing preconditions , we focus on identifying a single precondition , as this closely follows prescriptions from works in social sciences that have shown that selectivity or minimality is an essential property of effective explanations ( Miller , 2018 ) . For explaining suboptimality , we inform the user about the symbolic cost function CCS . To ensure minimality , rather than provide the entire cost function , we will instead try to learn and provide an abstraction of the cost function Cabss Definition 2 For the symbolic model MCS = ⟨C , ACS , C ( I ) , C ( G ) , CCS⟩ , an abstract cost function CabsS : 2C ×ACS → R is specified as : CabsS ( { c1 , .. , ck } , a ) = min { CCS ( s , a ) |s ∈ SMCS ∧ { c1 , .. , ck } ⊆ s } . Intuitively , CabsS ( { c1 , .. , ck } , a ) = k can be understood as stating that executing the action a , in the presence of concepts { c1 , .. , ck } costs at least k. We can use CabsS in an explanation by identifying a sequence of concept set Cπf = ⟨Ĉ1 , ... , Ĉk⟩ , corresponding to each step of the foil πf = ⟨a1 , .. , ak⟩ , such that ( a ) Ĉk is a subset of concepts in the corresponding state reached by the foil and ( b ) the total cost of abstract cost function defined over the concept subsets are larger than the plan cost∑ i= { 1 .. k } CabsS ( Ĉi , ai ) > C ( I , π ) . For Foil2 , the explanation would include the information – executing the action attack in the presence of the concept skull-on-left , will cost at least 500 . | The authors propose a method of explainable AI for inscrutable blackbox models. The explanations build on a set of user-defined primitives, independently trained on the blackbox representation (e.g., visual frames of an Atari game), and use an increasingly popular method of providing contrastive explanations. Two forms of foil-based responses are provided: (1) indication of action failure from the planning perspective (preconditions unsatisfied); and (2) an explanation of relative sub-optimality that highlights key aspects of action costs that the user may be unaware of. | SP:57cdb30976e9fc5563bbb07a51d90eec8385e594 |
Bridging the Gap: Providing Post-Hoc Symbolic Explanations for Sequential Decision-Making Problems with Inscrutable Representations | 1 INTRODUCTION As AI systems are increasingly being deployed in scenarios involving high-stakes decisions , the issue of interpretability of their decisions to the humans in the loop has acquired renewed urgency . Most work on interpretability has hither-to focused on one-shot classification tasks , and has revolved around ideas such as marking regions of the input instance ( e.g . image ) that were most salient in the classification of that instance ( Selvaraju et al. , 2016 ; Sundararajan et al. , 2017 ) . Such methods used for one-shot classification tasks don ’ t generalize well to sequential decision tasks–that are the focus of this paper . In particular , in sequential decision tasks , humans in the loop might ask more complex “ contrastive ” explanatory queries–such as why the system took one particular course of action instead of another . The AI system ’ s answers to such questions will often be tied to its internal representations and reasoning , traces of which are not likely to be comprehensible as explanations to humans in the loop . Some have viewed this as an argu- ment to make AI systems use reasoning over symbolic models . We don ’ t take a position on the methods AI systems use to arrive at their decisions . We do however think that the onus of making their decisions interpretable to humans in the loop in their own vocabulary should fall squarely on the AI systems . Indeed , we believe that orthogonal to the issue of whether AI systems use internal symbolic representations to guide their own decisions , they need to develop local symbolic models that are interpretable to humans in the loop , and use them to provide explanations for their decisions . Accordingly , in this work , we develop a framework that takes a set of previously agreed-upon user vocabulary terms and generates contrastive explanations in these terms Miller ( 2018 ) ; Hesslow ( 1988 ) . Specifically , we will do this by learning components of a local symbolic dynamical model ( such as PDDL ( McDermott et al. , 1998 ) ) that captures the agent model in terms of actions with preconditions and effects from the user-specified vocabulary . There is evidence that such models conform to folk psychology Malle ( 2006 ) . This learned local model is then used to explain the potential infeasibility or suboptimality of the alternative raised by the user . Figure 1 presents the flow of the proposed explanation generation process in the context of Montezuma ’ s Revenge ( Wikipedia contributors , 2019 ) . In this paper , we will focus on deterministic settings ( Section 3 ) , though we can easily extend the ideas to stochastic settings , and will ground user-specified vocabulary terms in the AI system ’ s internal representations via learned classifiers ( Section 4 ) . The model components required for explanations are learned by using experiences ( i.e . state-action-state sets ) sampled from the agent model ( Section 4 & 5 ) . Additionally , we formalize the notion of local symbolic approximation for sequential decision-making models , and introduce the idea of explanatory confidence ( Section 6 ) . The exaplanatory confidence captures the fidelity of explanations and help ensure the system only provides explanation whose confidence is above a given threshold . We will evaluate the effectiveness of the method through both systematic ( IRB approved ) user studies and computational experiments ( Section 7 ) . As we will discuss in Section 2 , our approach has some connections to ( Kim et al. , 2018 ) , which while focused on one-shot classification tasks , also advocates explanations in terms of concepts that have meaning to humans in the loop . Our approach of constructing local model approximations is akin to LIME ( Ribeiro et al. , 2016 ) , with the difference being that we construct symbolic dynamical models in terms of human vocabulary , while LIME constructs approximate linear models over abstract features that are machine generated . 2 RELATED WORK . The representative works in the direction of using concept level explanation include works like ( Bau et al. , 2017 ) , TCAV ( Kim et al. , 2018 ) and its various offshoots like ( Luss et al. , 2019 ) that have focused on one-shot decisions . These works take a line quite similar to us in that they try to create explanations for current decisions in terms of a set of user-specified concepts . While these works don ’ t explicitly reason about explanatory confidence they do discuss the possibility of identifying inaccurate explanation , and tries to address them through statistical tests . Another thread of work , exemplified by works like ( Koh et al. , 2020 ; Lin et al. , 2020 ) , tries to force decisions to be made in terms of user-specified concepts , which can then be used for explanations . There have also been recent works on automatically identifying human-understandable concepts like Ghorbani et al . ( 2019 ) and Hamidi-Haines et al . ( 2018 ) . We can also leverage these methods when our system identifies scenarios with insufficient vocabulary . Most works in explaining sequential decision-making problems either use a model specified in a shared vocabulary as a starting point for explanation or focus on saliency-based explanations ( cf . ( Chakraborti et al. , 2020 ) ) , with very few exceptions . Authors of ( Hayes & Shah , 2017 ) have looked at the use of high-level concepts for policy summaries . They use logical formulas to concisely characterize various policy choices , including states where a specific action may be selected ( or not ) . Unlike our work , they are not trying to answer why the agent chooses a specific action ( or not ) . ( Waa et al. , 2018 ) looks at addressing the suboptimality of foils while supporting interpretable features , but it requires the domain developer to assign positive and negative outcomes to each action . In addition to not addressing possible vocabulary differences between a system developer and the end-user , it is also unclear if it is always possible to attach negative and positive outcomes to individual actions . Another related work is the approach studied in ( Madumal et al. , 2020 ) . Here , they are also trying to characterize dynamics in terms of high-level concepts but assume that the full structural relationship between the various variables is provided upfront . The explanations discussed in this paper can also be seen as a special case of Model Reconciliation explanation ( c.f ( Chakraborti et al. , 2017 ) ) , where the human model is considered to be empty . The usefulness of preconditions as explanations has also been studied by works like ( Winikoff , 2017 ; Broekens et al. , 2010 ) . Our effort to associate action cost to concepts could also be contrasted to efforts in ( Juozapaitis et al. , 2019 ) and ( Anderson et al. , 2019 ) which leverage interpretable reward components . Another group of works popular in RL explanations is the ones built around saliency maps ( Greydanus et al. , 2018 ; Iyer et al. , 2018 ; Puri et al. , 2019 ) , which tend to highlight parts of the state that are important for the current decision . In particular , we used ( Greydanus et al. , 2018 ) as a baseline because many follow-up works have shown their effectiveness ( cf . ( Zhang et al. , 2020 ) ) . Readers can refer to Alharin et al . ( 2020 ) for a recent survey of explanations in RL . Another related thread of work , is that of learning models ( some representative works include ( Carbonell & Gil , 1990 ; Stern & Juba , 2017 ; Wu et al. , 2007 ) ) . To the best of our knowledge none of the works in this direction allow for noisy observations of state and none focused on identifying specific model components . While we are unaware of any works that provide confidence over learned model components , ( Stern & Juba , 2017 ) provides loose PAC guarantees over the entire learned model . 3 PROBLEM SETTING . Our setting consists of an agent , be it programmed or RL-based , that has a model of the dynamics of the task that is inscrutable to the user ( in so far that the user can ’ t directly use the model representation used by the agent ) in the loop and uses a decision-making process that is sound for this given model . Note that here the term model is being used in a very general sense . These could refer to tabular models defined over large atomic state spaces , neural network-based dynamics models possibly learned over latent representation of the states and even simulators . The only restriction we place on the model is that we can sample possible experiences from it . Regardless of the true representation , we will denote the model by the tuple M = ⟨S , A , T , C⟩ . Where S and A are the state and action sets and T : S×A → S ∪ { ⊥ } ( ⊥ the absorber failure state ) and C : S×A → R capture the transition and cost function . We will use ⊥ to capture failures that could occur when the agent violates hard constraints like safety constraints or perform any invalid actions . We will consider goal-directed agents that are trying to drive the state of the world to one of the goal states ( G being the set ) from an initial state I . The solution takes the form of a sequence of actions or a plan π . We will use symbolic action models with preconditions and cost functions ( similar to PDDL models ( Geffner & Bonet , 2013 ) ) as a way to approximate the problem for explanations . Such a model can be represented by the tuple MS = ⟨FS , AS , IS , GS , CS⟩ , where FS is a set of propositional state variables defining the state space , AS is the set of actions , IS is the initial state , GS is the goal specification . Each valid problem state is uniquely identified by the subset of state variables that are true in that state ( so for any state s ∈ SMS , where SMS is the set of states for MS , s ⊆ FS ) . Each action a ∈ AS is further described in terms of the preconditions preca ( specification of states in which a is executable ) and the effects of executing the action . We will denote the state formed by executing action a in a state s as a ( s ) . We will focus on models where the preconditions are represented as a conjunction of propositions . If the action is executed in a state with missing preconditions , then the execution results in the invalid state ⊥ . Unlike standard STRIPS models , where the cost of executing action is independent of states , we will use a state-dependent cost function of the form CS : 2F ×AS → R to capture forms of cost functions popular in RL benchmarks . 4 CONTRASTIVE EXPLANATIONS . The specific explanatory setting , illustrated in Figure 1 , is one where the agent comes up with a plan π ( to achieve one of the goals specified in G from I ) and the user responds by raising an alternate plan πf ( the foil ) that they believe should be followed instead . Now the system needs to explain why π may be preferred over πf , by showing that πf is invalid ( i.e. , πf doesn ’ t lead to a goal state or one of the action in πf results in the invalid state ⊥ ) or πf is costlier than π ( C ( I , π ) < C ( I , πf ) ) .1 To concretize this interaction , consider the modified version of Montezuma ’ s Revenge ( Figure 1 ) . The agent starts from the highest platform , and the goal is to get to the key . The specified plan π may require the agent to make its way to the lowest level , jump over the skull , and then go to the key with a total cost of 20 . Now the user raises two possible foils that are similar to π but use different strategies in place of jumping over the skull . Foil1 : instead of jumping , the agent just moves left ( i.e. , it tries to move through the skull ) and , Foil2 : instead of jumping over the skull , the agent performs the attack action ( not part of the original game , but added here for illustrative purposes ) and then moves on to the key . Using the internal model , the system can recognize that in the first case , moving left would lead to an invalid state , and in the second case , the foil is costlier , though effectively communicating this to the user is a different question . If there exists a shared 1If the foil is as good as the original plan or better , then the system could switch to the foil . visual communication channel , the agent could try to demonstrate the outcome of following these alternate strategies . Unfortunately , this would not only necessitate additional cognitive load on the user ’ s end to view the demonstration , but it may also be confusing to the user in so far that they may not be able to recognize why in a particular state the move left action was invalid and attack action costly . As established in our user study and pointed out by Atrey et al . ( 2019 ) , even highlighting of visual features may not effectively resolve this confusion . This scenario thus necessitates the use of methods that are able to express possible explanations in terms that the user may understand . Learning Concept Maps : The input to our system is the set of propositional concepts the user associates with the task . For Montezuma , this could involve concepts like agent being on a ladder , holding onto the key , being next to the skull . Each concept corresponds to a propositional fact that the user associates with the task ’ s states and believes their presence or absence in a state could influence the dynamics and the cost function . We can collect such concepts from subject matter experts as by Cai et al . ( 2019 ) , or one could just let the user interact with or observe the agent and then provide a possible set of concepts . We used the latter approach to collect the propositions for our evaluation of the Sokoban domains ( Section 7 and A.7 ) . Each concept corresponds to a binary classifier , which detects whether the proposition is present or absent in a given internal state ( thus allowing us to convert the atomic states into a factored representation ) . Let C be the set of classifiers corresponding to the high-level concepts . For state s ∈ S , we will overload the notation C and specify the concepts that are true as C ( s ) , i.e. , C ( s ) = { ci|ci ∈ C ∧ ci ( s ) = 1 } ( where ci is the classifier corresponding to the ith concept and we overload the notation to also stand for the label of the ith concept ) . The training set for such concept classifiers could come from the user ( where they provide a set of positive and negative examples per concept ) . Classifiers can be then learned over the model states or the internal representations used by the agent decision-making ( for example activations of intermediate neural network layers ) . Explanation using concepts : To explain the preference of plan π over foil πf , we will present model information to the user taken from a symbolic representation of the agent model . But rather than requiring this model to be an exact representation of the complete agent model , we will instead focus on accurately capturing a subset of the model by instead trying to learn a local approximation Definition 1 A symbolic model MCS = ⟨C , ACS , C ( I ) , C ( G ) , CCS ⟩ . is said to be a local symbolic approximation of the model MR = ⟨S , A , T , C⟩ for regions of interest Ŝ ⊆ S if ∀s ∈ Ŝ and ∀a ∈ A , we have an equivalent action aC ∈ ACS , such that ( a ) aC ( C ( s ) ) = C ( T ( s , a ) ) ( assuming C ( ⊥ ) = ⊥ ) and ( b ) CCS ( C ( s ) , a ) = C ( s , a ) and ( c ) C ( G ) = ⋂ sg∈G∩Ŝ C ( sg ) . Following Section 3 , this is a PDDL-style model with preconditions and conditional costs defined over the conjunction of positive propositional literals . A.2 establishes the sufficiency of this representation to capture arbitrarily complex preconditions ( including disjunctions ) and cost functions expressed in terms of the proposition set C. Also to establish the preference of plan does not require informing the users about the entire model MCS , but rather only the relevant parts . To establish the invalidity of πf , we only need to explain the failure of the first failing action ai , i.e. , the one that resulted in the invalid state ( for Foil1 this corresponds to move-left action at the state visualized in Figure 1 ) . We explain the failure of action in a state by pointing out a proposition that is an action precondition which is absent in the given state . Thus a concept ci ∈ C is considered an explanation for failure of action ai at state si , if ci ∈ precai \ C ( si ) . For Foil1 , the explanation would be – the action move-left failed in the state as the precondition skull-not-on-left was false in the state . This formulation can also capture failure to achieve goal by appending an additional goal action at the end of the plan , which causes the state to transition to an end state , and fails for all states except the ones in G. Note that instead of identifying all the missing preconditions , we focus on identifying a single precondition , as this closely follows prescriptions from works in social sciences that have shown that selectivity or minimality is an essential property of effective explanations ( Miller , 2018 ) . For explaining suboptimality , we inform the user about the symbolic cost function CCS . To ensure minimality , rather than provide the entire cost function , we will instead try to learn and provide an abstraction of the cost function Cabss Definition 2 For the symbolic model MCS = ⟨C , ACS , C ( I ) , C ( G ) , CCS⟩ , an abstract cost function CabsS : 2C ×ACS → R is specified as : CabsS ( { c1 , .. , ck } , a ) = min { CCS ( s , a ) |s ∈ SMCS ∧ { c1 , .. , ck } ⊆ s } . Intuitively , CabsS ( { c1 , .. , ck } , a ) = k can be understood as stating that executing the action a , in the presence of concepts { c1 , .. , ck } costs at least k. We can use CabsS in an explanation by identifying a sequence of concept set Cπf = ⟨Ĉ1 , ... , Ĉk⟩ , corresponding to each step of the foil πf = ⟨a1 , .. , ak⟩ , such that ( a ) Ĉk is a subset of concepts in the corresponding state reached by the foil and ( b ) the total cost of abstract cost function defined over the concept subsets are larger than the plan cost∑ i= { 1 .. k } CabsS ( Ĉi , ai ) > C ( I , π ) . For Foil2 , the explanation would include the information – executing the action attack in the presence of the concept skull-on-left , will cost at least 500 . | This paper presents a novel approach to generate contrastive explanations in a dialogue setting between a human and a planning agent. The setting assumes that the agent generates and offers an optimal plan to the user, and the user in turn challenges the presented plan offering an alternative (i.e. a contrast/foil). The goal of the agent is the denounce the alternative plan by explaining the infeasibility or suboptimality of the plan to the user in concepts they understand. | SP:57cdb30976e9fc5563bbb07a51d90eec8385e594 |
Single-Photon Image Classification | 1 INTRODUCTION . Both quantum mechanics and machine learning play a major role in modern technology , and the emerging field of AI applications of quantum computing may well enable major breakthroughs across many scientific disciplines . Yet , as the majority of current machine learning practitioners do not have a thorough understanding of quantum mechanics , while the majority of quantum physicists only have an equally limited understanding of machine learning , it is interesting to look for “ Rosetta Stone ” problems where simple and widely understood machine learning ideas meet simple and widely understood quantum mechanics ideas . It is the intent of this article to present a setting in which textbook quantum mechanics sheds a new light on a textbook machine learning problem , and vice versa , conceptually somewhat along the lines of Google ’ s TensorFlow Playground ( Smilkov et al . ( 2017 ) , ) which was introduced as a teaching device to illustrate key concepts from Deep Learning to a wider audience . Specifically , we want to consider the question what the maximal achievable accuracy on common one-out-of-many image classification tasks is if one must make a decision after the detection of the very first quantum of light ( i.e . photon ) that passed a filter showing an example image from the test set . In this setting , we do not have a one-to-one correspondence between example images from the training ( respectively test ) set and classification problems . Instead , every example image defines a probability distribution for the ( x , y ) detector pixel location on which the first photon passing an image filter lands , the per-pixel probability being the pixel ’ s brightness relative to the accumulated ( across all pixels ) image brightness . So , from every ( 28× 28 pixels ) example image , we can sample arbitrarily many photon-detection-event classifier examples , where the features are a pair of integer pixel coordinates , and the label is the digit class . On the MNIST handwritten digit dataset ( LeCun and Cortes ( 2010 ) ) , any machine learning system that only gets to see a single such “ photon detected at coordinates ( x , y ) ” event as its input features , of the pixel that flashed up are the only input features , is limited in accuracy by the maximum likelihood estimate , since we have : P ( Image class C|Photon detected at ( x , y ) ) =∑ E P ( Image class C|Example E ) P ( Example E|Photon detected at ( x , y ) ) . On photon detection events generated each by first randomly picking an example image , and then randomly picking a brightness-weighted pixel from that , we can not do any better than predicting the most likely digit class given these input features – the two pixel coordinates . As performance is measured on the test set , no classifier could possibly ever outperform one that is built to achieve maximal performance on the test set . This is obtained by determining , for each pixel , what the most likely class is , where examples from the test set are weighted by the fraction of total example-image brightness that comes from the pixel in question . Figure 2 ( b ) shows the most likely image-class per pixel . ( For MNIST , some pixels are dark in every test set example . ) No classifier can outperform one that simply looks up the pixel-coordinates at which a photon was detected in Figure 2 ( b ) and returns the corresponding class , and this optimal classifier ’ s accuracy is 22.96 % for the the MNIST dataset – substantially higher than random guessing ( 10 % ) . Appendix A.2 provides a detailed ( but mostly straightforward ) optimality proof of this accuracy threshold . We can not , for example , outperform it by redistributing light intensity between pixels , since any such redistribution could only destroy some of the available useful information , not magically create extra useful information . An entirely different situation arises when we allow quantum mechanics to enter the stage : For a single photon passing through a coherently illuminated image filter , with all pixels at the same optical phase on the incoming wave , we can imagine putting some precision optical device between the image filter and the detector array that redistributes not the probabilities ( which correspond to light intensity when aggregating over many photons ) , but the amplitudes that make up the spatial part of the photon wave-function . Illuminating such a set-up with many photons would show a hologram-like interference pattern on the detector array . This transformation of the ( single- ) photon wave function by linear optical elements then has tuneable parameters which we can adjust to improve classifier accuracy . Quantum mechanics tells us that every ( lossless ) linear optical device can be represented by a linear unitary transform on the photon state : The action of any complex optical device consisting of ( potentially very many ) components which transforms a N -component photon state ( in our case , N = 282 amplitudes in the spatial part of the photon wavefunction ) can be described by an element of the N2-dimensional unitary matrix Lie group U ( N ) . Vice versa , Reck et al . ( 1994 ) describes a constructive algorithm by which any U ( N ) transformation matrix can be translated back to a network of optical beam splitters and phase shifters . 1.1 RELATED WORK . Conceptually , exploiting interference to enhance the probability of a quantum experiment producing the sought outcome is the essential idea underlying all quantum computing . The main difference between this problem and modern quantum computing is that the latter tries to perform calculations by manipulating quantum states of multiple “ entangled ” constituents , typically coupled two-state quantum systems called “ qubits , ” via “ quantum gates ” that are controlled by parts of the total quantum system ’ s quantum state . Building a many-qubit quantum computer hence requires delicate control over the interactions between constituent qubits . This usually requires eliminating thermal noise by going to millikelvin temperatures . For the problem studied here , the quantum state can be transformed with conventional optics at room temperature : the energy of a green photon is 2.5 eV , way above the typical room temperature thermal radiation energy of kT ' 25 meV . The price to pay is that it is challenging to build a device that allows multiple photons to interact in the way needed to build a many-qubit quantum computer . Nevertheless , Knill , Laflamme , and Milburn ( Knill et al . ( 2001 ) ) devised a protocol to make this feasible in principle , avoiding the need for coherency-preserving nonlinear optics ( which may well be impossible to realize experimentally ) by clever exploitation of ancillary photon qubits , boson statistics , and the measurement process . In all such applications , the basic idea is to employ coherent multiphoton quantum states to do computations with multiple qubits . In the problem studied here , there is only a single photon , the only relevant information that gets processed is encoded in the spatial part of its wave function ( i.e . polarization is irrelevant ) , so the current work resembles the “ optical simulation of quantum logic ” proposed by Cerf et al . ( 1998 ) where a N-qubit system is represented by 2N spatial modes of a single photon . Related work studied similar “ optical simulations of quantum computing ” for implementing various algorithms , in particular ( small ) integer factorization ( Clauser and Dowling ( 1996 ) ; Summhammer ( 1997 ) ) , but to the best of the present authors ’ knowledge did not consider machine learning problems . This work can be described as belonging to the category of machine learning methods on quantum non-scalable architectures . Alternatively , one can regard it as a quantum analogue of recent work that demonstrated digital circuit free MNIST digit classification via classical nonlinear optics , for instance via saturable absorbers ( Khoram et al . ( 2019 ) . ) Apart from providing an accessible and commonly understandable toy problem for both quantum and ML research communities , this simplequantum/simple-ML corner also may be of interest for teaching the physics of the measurement process ( “ the collapse of the wave function ” ) in a more accessible setting . Whereas explanations of the measurement process are forced to remain vague where they try to model “ the quantum states of the observer ” ( typically unfathomably many states that one would never hope to be able to model in terms of actual numbers ) , using machine learning as a sort-of cartoon substitute for high level mental processes actually allows us to come up with fully concrete toy models of the measurement process on low-dimensional ( such as : D < 1000 ) Hilbert spaces that nevertheless capture many of the essential aspects – to the extent that “ ML classifies the measurement as showing the image of a shoe ” can be regarded as a crude approximation to “ observer sees a shoe ” . Looking closer at the relation between the present article and Khoram et al . ( 2019 ) , both articles study the general feasibility of realizing Machine Learning classifiers in the form of an analog optical computer at the theoretical level , using numerical optimization to produce a blueprint of a device that can perform inference for a specific problem . In both articles , the primary problem under study is MNIST handwritten digit classification , the input is encoded as spatial dependency of a ( monochromatic ) laser beam ’ s light intensity , and classification happens by using interference to funnel optical energy onto a detector array . In both cases , stochastic gradient descent is used to shape how this funneling of optical energy happens . Indeed , even the loss function used for training ( cross entropy ) is essentially equivalent . The key differences are that Khoram et al . ( 2019 ) only considers the many-photon limit of classical wave optics , which allows one the luxury of using non-linear optical components , specifically saturable absorbers , to implement non-linearities . This has no analog for the single photon case . Also , having many photons available allows identifying the target class that receives most laser light and calling this the prediction of the model . This is clearly not possible when a decision has to be made after seeing only a single photon . If one sent many photons through an interference device as described in this article and picked the target class with the highest photon count , one would observe classification accuracies of about 90 % rather than the claimed about-40 % for a single photon . This is considerably higher than the accuracies of about 80 % presented inKhoram et al . ( 2019 ) as the focus of that article is on manufacturability , running gradient backpropagation directly on a Finite Difference Frequency Domain PDE simulation of Maxwell ’ s equations and taking materials engineering constraints into account , whereas our work focuses on upper and lower bounds for achievable accuracy , exploiting the one-to-one equivalence between linear optical devices and unitary transforms . Our work directly trains the parameters of the unitary transform , which only afterwards get mapped to a blueprint for an experimental device realization . Speculatively , if a device were built experimentally that was designed by the methods inKhoram et al . ( 2019 ) , subject to the extra constraint that no non-linear elements can be used , and then deployed in a low-light-intensity single-photon setting , using a suitable detector such as a SPAD array , it may manage to realize better-than-classically-achievable classifier performance , for reasons explained in the current work . | This paper focuses on the quantum computing based machine learning and proposes a toy model to illustrate the quantum information processing. On the common used handwritten digit dataset MNIST, more than 40% images can be classified accurately. The proposed method looks interesting and the focused problem (combining quantum computing and machine learning) is of certain significance. | SP:6b629449901b057a5adea945556494ed61b47e8f |
Single-Photon Image Classification | 1 INTRODUCTION . Both quantum mechanics and machine learning play a major role in modern technology , and the emerging field of AI applications of quantum computing may well enable major breakthroughs across many scientific disciplines . Yet , as the majority of current machine learning practitioners do not have a thorough understanding of quantum mechanics , while the majority of quantum physicists only have an equally limited understanding of machine learning , it is interesting to look for “ Rosetta Stone ” problems where simple and widely understood machine learning ideas meet simple and widely understood quantum mechanics ideas . It is the intent of this article to present a setting in which textbook quantum mechanics sheds a new light on a textbook machine learning problem , and vice versa , conceptually somewhat along the lines of Google ’ s TensorFlow Playground ( Smilkov et al . ( 2017 ) , ) which was introduced as a teaching device to illustrate key concepts from Deep Learning to a wider audience . Specifically , we want to consider the question what the maximal achievable accuracy on common one-out-of-many image classification tasks is if one must make a decision after the detection of the very first quantum of light ( i.e . photon ) that passed a filter showing an example image from the test set . In this setting , we do not have a one-to-one correspondence between example images from the training ( respectively test ) set and classification problems . Instead , every example image defines a probability distribution for the ( x , y ) detector pixel location on which the first photon passing an image filter lands , the per-pixel probability being the pixel ’ s brightness relative to the accumulated ( across all pixels ) image brightness . So , from every ( 28× 28 pixels ) example image , we can sample arbitrarily many photon-detection-event classifier examples , where the features are a pair of integer pixel coordinates , and the label is the digit class . On the MNIST handwritten digit dataset ( LeCun and Cortes ( 2010 ) ) , any machine learning system that only gets to see a single such “ photon detected at coordinates ( x , y ) ” event as its input features , of the pixel that flashed up are the only input features , is limited in accuracy by the maximum likelihood estimate , since we have : P ( Image class C|Photon detected at ( x , y ) ) =∑ E P ( Image class C|Example E ) P ( Example E|Photon detected at ( x , y ) ) . On photon detection events generated each by first randomly picking an example image , and then randomly picking a brightness-weighted pixel from that , we can not do any better than predicting the most likely digit class given these input features – the two pixel coordinates . As performance is measured on the test set , no classifier could possibly ever outperform one that is built to achieve maximal performance on the test set . This is obtained by determining , for each pixel , what the most likely class is , where examples from the test set are weighted by the fraction of total example-image brightness that comes from the pixel in question . Figure 2 ( b ) shows the most likely image-class per pixel . ( For MNIST , some pixels are dark in every test set example . ) No classifier can outperform one that simply looks up the pixel-coordinates at which a photon was detected in Figure 2 ( b ) and returns the corresponding class , and this optimal classifier ’ s accuracy is 22.96 % for the the MNIST dataset – substantially higher than random guessing ( 10 % ) . Appendix A.2 provides a detailed ( but mostly straightforward ) optimality proof of this accuracy threshold . We can not , for example , outperform it by redistributing light intensity between pixels , since any such redistribution could only destroy some of the available useful information , not magically create extra useful information . An entirely different situation arises when we allow quantum mechanics to enter the stage : For a single photon passing through a coherently illuminated image filter , with all pixels at the same optical phase on the incoming wave , we can imagine putting some precision optical device between the image filter and the detector array that redistributes not the probabilities ( which correspond to light intensity when aggregating over many photons ) , but the amplitudes that make up the spatial part of the photon wave-function . Illuminating such a set-up with many photons would show a hologram-like interference pattern on the detector array . This transformation of the ( single- ) photon wave function by linear optical elements then has tuneable parameters which we can adjust to improve classifier accuracy . Quantum mechanics tells us that every ( lossless ) linear optical device can be represented by a linear unitary transform on the photon state : The action of any complex optical device consisting of ( potentially very many ) components which transforms a N -component photon state ( in our case , N = 282 amplitudes in the spatial part of the photon wavefunction ) can be described by an element of the N2-dimensional unitary matrix Lie group U ( N ) . Vice versa , Reck et al . ( 1994 ) describes a constructive algorithm by which any U ( N ) transformation matrix can be translated back to a network of optical beam splitters and phase shifters . 1.1 RELATED WORK . Conceptually , exploiting interference to enhance the probability of a quantum experiment producing the sought outcome is the essential idea underlying all quantum computing . The main difference between this problem and modern quantum computing is that the latter tries to perform calculations by manipulating quantum states of multiple “ entangled ” constituents , typically coupled two-state quantum systems called “ qubits , ” via “ quantum gates ” that are controlled by parts of the total quantum system ’ s quantum state . Building a many-qubit quantum computer hence requires delicate control over the interactions between constituent qubits . This usually requires eliminating thermal noise by going to millikelvin temperatures . For the problem studied here , the quantum state can be transformed with conventional optics at room temperature : the energy of a green photon is 2.5 eV , way above the typical room temperature thermal radiation energy of kT ' 25 meV . The price to pay is that it is challenging to build a device that allows multiple photons to interact in the way needed to build a many-qubit quantum computer . Nevertheless , Knill , Laflamme , and Milburn ( Knill et al . ( 2001 ) ) devised a protocol to make this feasible in principle , avoiding the need for coherency-preserving nonlinear optics ( which may well be impossible to realize experimentally ) by clever exploitation of ancillary photon qubits , boson statistics , and the measurement process . In all such applications , the basic idea is to employ coherent multiphoton quantum states to do computations with multiple qubits . In the problem studied here , there is only a single photon , the only relevant information that gets processed is encoded in the spatial part of its wave function ( i.e . polarization is irrelevant ) , so the current work resembles the “ optical simulation of quantum logic ” proposed by Cerf et al . ( 1998 ) where a N-qubit system is represented by 2N spatial modes of a single photon . Related work studied similar “ optical simulations of quantum computing ” for implementing various algorithms , in particular ( small ) integer factorization ( Clauser and Dowling ( 1996 ) ; Summhammer ( 1997 ) ) , but to the best of the present authors ’ knowledge did not consider machine learning problems . This work can be described as belonging to the category of machine learning methods on quantum non-scalable architectures . Alternatively , one can regard it as a quantum analogue of recent work that demonstrated digital circuit free MNIST digit classification via classical nonlinear optics , for instance via saturable absorbers ( Khoram et al . ( 2019 ) . ) Apart from providing an accessible and commonly understandable toy problem for both quantum and ML research communities , this simplequantum/simple-ML corner also may be of interest for teaching the physics of the measurement process ( “ the collapse of the wave function ” ) in a more accessible setting . Whereas explanations of the measurement process are forced to remain vague where they try to model “ the quantum states of the observer ” ( typically unfathomably many states that one would never hope to be able to model in terms of actual numbers ) , using machine learning as a sort-of cartoon substitute for high level mental processes actually allows us to come up with fully concrete toy models of the measurement process on low-dimensional ( such as : D < 1000 ) Hilbert spaces that nevertheless capture many of the essential aspects – to the extent that “ ML classifies the measurement as showing the image of a shoe ” can be regarded as a crude approximation to “ observer sees a shoe ” . Looking closer at the relation between the present article and Khoram et al . ( 2019 ) , both articles study the general feasibility of realizing Machine Learning classifiers in the form of an analog optical computer at the theoretical level , using numerical optimization to produce a blueprint of a device that can perform inference for a specific problem . In both articles , the primary problem under study is MNIST handwritten digit classification , the input is encoded as spatial dependency of a ( monochromatic ) laser beam ’ s light intensity , and classification happens by using interference to funnel optical energy onto a detector array . In both cases , stochastic gradient descent is used to shape how this funneling of optical energy happens . Indeed , even the loss function used for training ( cross entropy ) is essentially equivalent . The key differences are that Khoram et al . ( 2019 ) only considers the many-photon limit of classical wave optics , which allows one the luxury of using non-linear optical components , specifically saturable absorbers , to implement non-linearities . This has no analog for the single photon case . Also , having many photons available allows identifying the target class that receives most laser light and calling this the prediction of the model . This is clearly not possible when a decision has to be made after seeing only a single photon . If one sent many photons through an interference device as described in this article and picked the target class with the highest photon count , one would observe classification accuracies of about 90 % rather than the claimed about-40 % for a single photon . This is considerably higher than the accuracies of about 80 % presented inKhoram et al . ( 2019 ) as the focus of that article is on manufacturability , running gradient backpropagation directly on a Finite Difference Frequency Domain PDE simulation of Maxwell ’ s equations and taking materials engineering constraints into account , whereas our work focuses on upper and lower bounds for achievable accuracy , exploiting the one-to-one equivalence between linear optical devices and unitary transforms . Our work directly trains the parameters of the unitary transform , which only afterwards get mapped to a blueprint for an experimental device realization . Speculatively , if a device were built experimentally that was designed by the methods inKhoram et al . ( 2019 ) , subject to the extra constraint that no non-linear elements can be used , and then deployed in a low-light-intensity single-photon setting , using a suitable detector such as a SPAD array , it may manage to realize better-than-classically-achievable classifier performance , for reasons explained in the current work . | The paper identifies two atomic problems, respectively in fields of ML (MNIST classification) and quantum mechanics (measuring a single photon), and brings them together in a simplified setup that uses a single photon emitted according to the spatial distribution of images to classify MNIST/Fashion-MNIST. The introduction of quantum mechanics into the problem is through a trainable computational model of a beam splitter/phase shifter mechanism, aka a rotation in a high dimensional complex space, that's allowed to alter the photon's state before hitting the measurement device. The paper shows that using this overly simplified (and claimed to be physically feasible) quantum computer, which acts as the representation learning layer, improves classification accuracy over any other representation learning method that doesn't use quantum computing. The major take-away is an accessible demonstration of how an elementary quantum computer might work for ML, and what may be possible with actual qubits. | SP:6b629449901b057a5adea945556494ed61b47e8f |
Can a Fruit Fly Learn Word Embeddings? | 1 INTRODUCTION . Deep learning has made tremendous advances in computer vision , natural language processing and many other areas . While taking high-level inspiration from biology , the current generation of deep learning methods are not necessarily biologically realistic . This raises the question whether biological systems can further inform the development of new network architectures and learning algorithms that can lead to competitive performance on machine learning tasks or offer additional insights into intelligent behavior . Our work is inspired by this motivation . We study a well-established neurobiological network motif from the fruit fly brain and investigate the possibility of reusing it for solving common machine learning tasks in NLP . We consider this exercise as a toy model example illustrating the possibility of “ reprogramming ” of naturally occurring algorithms and behaviors ( clustering combinations of input stimuli from olfaction , vision , and thermo-hydro sensory system ) into a target algorithm of interest ( learning word embeddings from raw text ) that the original biological organism does not naturally engage in . The mushroom body ( MB ) is a major area of the brain responsible for processing of sensory information in fruit flies . It receives inputs from a set of projection neurons ( PN ) conveying information ∗Yuchen Liang is an AI Horizons Scholar , part of the Rensselaer-IBM AI Research Collaboration ( AIRC ) . from several sensory modalities . The major modality is olfaction [ 2 ] , but there are also inputs from the PN responsible for sensing temperature and humidity [ 29 ] , as well as visual inputs [ 45 ; 6 ] . These sensory inputs are forwarded to a population of approximately 2000 Kenyon cells ( KCs ) through a set of synaptic weights [ 26 ] . KCs are reciprocally connected through an anterior paired lateral ( APL ) neuron , which sends a strong inhibitory signal back to KCs . This recurrent network effectively implements winner-takes-all competition between KCs , and silences all but a small fraction of top activated neurons [ 8 ] . This is the network motif that we study in this paper ; its schematic is shown in Fig . 1 . KCs also send their outputs to mushroom body output neurons ( MBONs ) , but this part of the MB network is not included into our mathematical model . In computational linguistics there is a long tradition [ 19 ] of using distributional properties of linguistic units for quantifying semantic similarities between them , as summarized in the famous quote by JR Firth : “ a word is characterized by the company it keeps ” [ 14 ] . This idea has led to powerful tools such as Latent Semantic Analysis [ 9 ] , topic modelling [ 3 ] , and language models like word2vec [ 30 ] , GloVe [ 34 ] , and , more recently , BERT [ 10 ] which relies on the Transformer model [ 44 ] . Specifically word2vec models are trained to maximize the likelihood of a word given its context , GloVe models utilize global word-word co-occurence statistics , and BERT uses a deep neural network with attention to predict masked words ( and the next sentence ) . As such , all these methods utilize the correlations between individual words and their context in order to learn useful word embeddings . In our work we ask the following question : can the correlations between words and their contexts be extracted from raw text by the biological network of KCs , shown in Fig . 1 ? Further , how do the word representations learned by KCs differ from those obtained by existing NLP methods ? Although this network has evolved to process sensory stimuli from olfaction and other modalities and not to “ understand ” language it uses a general purpose algorithm to embed inputs ( from different modalities ) into a high dimensional space with several desirable properties , which we discuss below . Our approach relies on a recent proposal that the recurrent network of mutually inhibited KCs can be used as a “ biological ” model for generating sparse binary hash codes for the input data presented at the projection neuron layer [ 8 ] . It was argued that a matrix of random weights projecting from PN layer into the KCs layer leads to the highly desirable property of making the generated hash codes locality sensitive , i.e. , placing similar inputs close to each other in the embedding space and pushing distinct stimuli far apart . A subsequent study [ 39 ] has demonstrated that the locality sensitivity of the hash codes can be significantly increased , compared to the random case , if the matrix of weights from PN to KCs is learned from data . The idea of using the network of KCs with random projections for NLP tasks has also been previously explored in [ 37 ] , see discussion in section 6 . Biologically , there is an ongoing debate in the neuroscience community regarding whether these projections are random . For instance , [ 5 ] argues for the random model , while [ 47 ] presents evidence of the non-random structure of this network , which is related to the frequency of presented odors . Since the goal of our work is to build a useful AI system and not mimic every detail of the biological system , we adopt the data-driven synaptic weight strategy even if fruit flies may use random projections . As is clearly demonstrated in [ 39 ] , learned synapses lead to better performance . Our main contributions in this work are the following : 1 . Inspired by the fruit fly network , we propose an algorithm that makes it possible to generate binary ( as opposed to continuous ) word embeddings for words and their context . We systematically evaluate the performance of this algorithm on word similarity task , word-sense disambiguation , and document classification . 2 . We demonstrate that our binary embeddings result in tighter and better separated clusters of concepts compared to continuous GloVe embeddings , and stand in line with clustering properties of binarized versions of GloVe . 3 . We show that training the fruit fly network requires an order of magnitude smaller compute time than training the classical NLP architectures , like BERT , at the expense of relatively small decrease in classification accuracy . 2 LEARNING ALGORITHM . Consider a training corpus . Each sentence can be decomposed into a collection of w-grams of consecutive words . If the word tokens come from a predefined vocabulary of size Nvoc , the input to the algorithm is a vector of size 2Nvoc . This vector consists of two blocks : the context ( the first Nvoc elements ) , and the target ( the remaining Nvoc elements ) ; see Fig . 2 . In this work w is assumed to be an odd integer , and the target word is assumed to be the center of the w-gram . The target word is one-hot encoded in the target block , and the context words are binary encoded as a bag of words in the context block ( no positional information is used ) . The window w slides along the text corpus , and for each position generates a training vector vA = { vAi } 2Nvoc i=1 , where the index A enumerates different w-grams , and index i enumerates positions in the context-target vector . These training vectors are passed to the learning algorithm . The goal of the algorithm is to learn correlations between the context and the target blocks . 2.1 MATHEMATICAL FORMULATION . Mathematically , the objective of the training algorithm is to distribute a set of context-target pairs among K buckets , so that similar pairs end up in similar buckets . In order to achieve this , the learning algorithm takes two inputs : a set of training vectors vA ∈ { 0 , 1 } 2Nvoc , and a vector of occurrence probabilities p = { pi = f ( i mod Nvoc ) } 2Nvoc i=1 ∈ R2Nvoc , where fj is the probability of observing word j in the training corpus1 . The learning can be formalized as a minimization of the 1In our notation vector f has Nvoc elements , while vector p has 2Nvoc elements . Given that index i runs from 1 to 2Nvoc , notation pi = f ( i mod Nvoc ) is a mathematical way to concatenate two vectors f into a twice longer vector p. energy function , see [ 39 ] for additional details , defined by E = − ∑ A∈data 〈 Wµ̂ , v A/p 〉 〈 Wµ̂ , Wµ̂ 〉1/2 , where µ̂ = arg max µ 〈 Wµ , v A 〉 ( 1 ) In this equation W ∈ RK×2Nvoc is a matrix of synaptic connections , given as W = { Wµ } = { Wµi } , projecting from PN layer ( individual neurons in the layer are denoted by the index i ) to the KC layer ( individual neurons in the KC layer are denoted by the index µ ) . There are 2Nvoc neurons in the PN layer andK neurons in the KC layer . The inner product 〈X , Y〉 = ∑2Nvoc i=1 XiYi is defined as a contraction over index i of PN cells . In the numerator of the energy function the binary encoded w-gram is divided by the probabilities of occurrences of individual words element-wise , so that the numerator can be written as 〈 Wµ̂ , v A/p 〉 = 2Nvoc∑ i=1 Wµ̂i vAi pi Probabilities p are calculated based on the frequencies of words in the training corpus . The vocabulary contains Nvoc most frequent words in the corpus , thus all the elements of pi are non-zero and the element-wise division is well defined . Intuitively , the goal of the training algorithm is to adjust the weights of the neural network so that they are aligned with w-grams that are frequently present in the training corpus . We rely on the assumption that semantically related w-grams share several “ core ” words , while a few individual words might be substituted by synonyms/antonyms . The minimization of the energy function ( 1 ) is accomplished by the iterative update of the weights satisfying the following learning rule [ 25 ; 39 ; 17 ] ∆Wµi = εg [ ∑ j Wµjv A j ] [ vAi pi − ( ∑ j Wµj vAj pj ) Wµi ] ( 2 ) In this equation the activation function is equal to one for a maximally driven hidden unit ( Kenyon cell ) , and is equal to zero otherwise g [ xµ ] = δµ , µ̂ , where µ̂ = arg max µ [ xµ ] ( 3 ) The learning rate is denoted by ε , and δµ , µ̂ is a Kronecker delta symbol . 2.2 BIO-HASHING . After learning is complete the hash codes for the inputs can be generated in the following way . Given the binary encoded w-gram vA , Hµ = { 1 , if 〈Wµ , vA〉 in the top k of all KCs activations 0 , otherwise ( 4 ) This is a crude mathematical approximation of the biological computation performed by the PN– KC–APL neural network [ 8 ; 39 ] . An input vA generates an input current 〈Wµ , vA〉 into the KC neurons using feedforward weightsWµi . The recurrent network of KCs and the APL neuron silences all but a small fraction of KCs . Those cells that remain active are assigned state 1 , while the rest of the KCs are assigned the inactive state 0 . Notice , that equation ( 4 ) makes it possible to generate the hash codes for both individual words ( static word embeddings like word2vec and GloVe ) and phrases ( similar to Transformer models ) . In the static case , the input vA has all zeros in the context block and a one-hot encoded word in the target block . In the context-dependent case , both blocks have binary encoded input words . Importantly , both context-dependent and static embeddings are mapped into the same space of sparse binary hash codes ( a vector of K elements , with k ones in it ) . We show below that these hash codes capture semantic meaning of the target word and the context in which it is used . For the rest of the paper we refer to the parameter k in equation ( 4 ) as the hash length . In order to provide an intuition behind the learning algorithm defined by the energy function ( 1 ) and weight update rule ( 2 ) and connect it to some of the existing methods in machine learning , consider the limit when all the words have equal probabilities in the training corpus , pi = 1Nvoc . In this limit the energy function ( 1 ) reduces to the familiar spherical K-means clustering algorithm [ 11 ] . In this limit the weights of each KC correspond to the centroids of the clusters of context-target vectors . The hashing rule ( 4 ) assigns active state 1 to the k closest centroids ( and inactive state 0 to the remaining ones ) , defined with respect to cosine similarity distance . In this simple limit the learning algorithm that we use can be viewed as a biologically plausible implementation of this classical algorithm . For real datasets the probabilities of words are different , thus this correspondence does not hold . Notice that division by the probability appears only in the expression for the energy , but not in the definition of µ̂ in equation ( 1 ) . Equivalently , division by pi appears in the second bracket of equation ( 2 ) , but not in the argument of the activation function g [ xµ ] . Thus , in the general case ( for different word probabilities pi ) our algorithm is not equivalent to spherical K-means on context-target vectors rescaled by the probabilities . Rather , in the general case , the closest centroid is found for a given context-target vector ( via the definition of µ̂ in equation ( 1 ) - no pi involved ) , but the “ updates of the position ” of that centroid are computed by enhancing the contributions of rare words ( small pi ) and suppressing the contributions of frequent words ( large pi ) . Empirically , we have found that division by the probabilities improves performance of our method compared to the case of spherical K-means ( when the factor 1/p is removed from the algorithm ) . | Although the paper does not say so, my understanding is that the proposed word embedding method actually first perform Kmeans-like clustering on the context vector shown in Figure 2. In the binary word embedding of each word, we set the dimensions corresponding to the k closest cluster centers to 1 and 0 otherwise. Most parts of the paper are describing how the simple word embedding method is related to the neural system of a fruit fly and showing the method achieves comparable performance compared with GloVe in word similarity tasks, context-sensitive word similarity datasets, and document classification tasks. | SP:86ed253fe1f1c48ec1f909f10a5473c4cf27fa83 |
Can a Fruit Fly Learn Word Embeddings? | 1 INTRODUCTION . Deep learning has made tremendous advances in computer vision , natural language processing and many other areas . While taking high-level inspiration from biology , the current generation of deep learning methods are not necessarily biologically realistic . This raises the question whether biological systems can further inform the development of new network architectures and learning algorithms that can lead to competitive performance on machine learning tasks or offer additional insights into intelligent behavior . Our work is inspired by this motivation . We study a well-established neurobiological network motif from the fruit fly brain and investigate the possibility of reusing it for solving common machine learning tasks in NLP . We consider this exercise as a toy model example illustrating the possibility of “ reprogramming ” of naturally occurring algorithms and behaviors ( clustering combinations of input stimuli from olfaction , vision , and thermo-hydro sensory system ) into a target algorithm of interest ( learning word embeddings from raw text ) that the original biological organism does not naturally engage in . The mushroom body ( MB ) is a major area of the brain responsible for processing of sensory information in fruit flies . It receives inputs from a set of projection neurons ( PN ) conveying information ∗Yuchen Liang is an AI Horizons Scholar , part of the Rensselaer-IBM AI Research Collaboration ( AIRC ) . from several sensory modalities . The major modality is olfaction [ 2 ] , but there are also inputs from the PN responsible for sensing temperature and humidity [ 29 ] , as well as visual inputs [ 45 ; 6 ] . These sensory inputs are forwarded to a population of approximately 2000 Kenyon cells ( KCs ) through a set of synaptic weights [ 26 ] . KCs are reciprocally connected through an anterior paired lateral ( APL ) neuron , which sends a strong inhibitory signal back to KCs . This recurrent network effectively implements winner-takes-all competition between KCs , and silences all but a small fraction of top activated neurons [ 8 ] . This is the network motif that we study in this paper ; its schematic is shown in Fig . 1 . KCs also send their outputs to mushroom body output neurons ( MBONs ) , but this part of the MB network is not included into our mathematical model . In computational linguistics there is a long tradition [ 19 ] of using distributional properties of linguistic units for quantifying semantic similarities between them , as summarized in the famous quote by JR Firth : “ a word is characterized by the company it keeps ” [ 14 ] . This idea has led to powerful tools such as Latent Semantic Analysis [ 9 ] , topic modelling [ 3 ] , and language models like word2vec [ 30 ] , GloVe [ 34 ] , and , more recently , BERT [ 10 ] which relies on the Transformer model [ 44 ] . Specifically word2vec models are trained to maximize the likelihood of a word given its context , GloVe models utilize global word-word co-occurence statistics , and BERT uses a deep neural network with attention to predict masked words ( and the next sentence ) . As such , all these methods utilize the correlations between individual words and their context in order to learn useful word embeddings . In our work we ask the following question : can the correlations between words and their contexts be extracted from raw text by the biological network of KCs , shown in Fig . 1 ? Further , how do the word representations learned by KCs differ from those obtained by existing NLP methods ? Although this network has evolved to process sensory stimuli from olfaction and other modalities and not to “ understand ” language it uses a general purpose algorithm to embed inputs ( from different modalities ) into a high dimensional space with several desirable properties , which we discuss below . Our approach relies on a recent proposal that the recurrent network of mutually inhibited KCs can be used as a “ biological ” model for generating sparse binary hash codes for the input data presented at the projection neuron layer [ 8 ] . It was argued that a matrix of random weights projecting from PN layer into the KCs layer leads to the highly desirable property of making the generated hash codes locality sensitive , i.e. , placing similar inputs close to each other in the embedding space and pushing distinct stimuli far apart . A subsequent study [ 39 ] has demonstrated that the locality sensitivity of the hash codes can be significantly increased , compared to the random case , if the matrix of weights from PN to KCs is learned from data . The idea of using the network of KCs with random projections for NLP tasks has also been previously explored in [ 37 ] , see discussion in section 6 . Biologically , there is an ongoing debate in the neuroscience community regarding whether these projections are random . For instance , [ 5 ] argues for the random model , while [ 47 ] presents evidence of the non-random structure of this network , which is related to the frequency of presented odors . Since the goal of our work is to build a useful AI system and not mimic every detail of the biological system , we adopt the data-driven synaptic weight strategy even if fruit flies may use random projections . As is clearly demonstrated in [ 39 ] , learned synapses lead to better performance . Our main contributions in this work are the following : 1 . Inspired by the fruit fly network , we propose an algorithm that makes it possible to generate binary ( as opposed to continuous ) word embeddings for words and their context . We systematically evaluate the performance of this algorithm on word similarity task , word-sense disambiguation , and document classification . 2 . We demonstrate that our binary embeddings result in tighter and better separated clusters of concepts compared to continuous GloVe embeddings , and stand in line with clustering properties of binarized versions of GloVe . 3 . We show that training the fruit fly network requires an order of magnitude smaller compute time than training the classical NLP architectures , like BERT , at the expense of relatively small decrease in classification accuracy . 2 LEARNING ALGORITHM . Consider a training corpus . Each sentence can be decomposed into a collection of w-grams of consecutive words . If the word tokens come from a predefined vocabulary of size Nvoc , the input to the algorithm is a vector of size 2Nvoc . This vector consists of two blocks : the context ( the first Nvoc elements ) , and the target ( the remaining Nvoc elements ) ; see Fig . 2 . In this work w is assumed to be an odd integer , and the target word is assumed to be the center of the w-gram . The target word is one-hot encoded in the target block , and the context words are binary encoded as a bag of words in the context block ( no positional information is used ) . The window w slides along the text corpus , and for each position generates a training vector vA = { vAi } 2Nvoc i=1 , where the index A enumerates different w-grams , and index i enumerates positions in the context-target vector . These training vectors are passed to the learning algorithm . The goal of the algorithm is to learn correlations between the context and the target blocks . 2.1 MATHEMATICAL FORMULATION . Mathematically , the objective of the training algorithm is to distribute a set of context-target pairs among K buckets , so that similar pairs end up in similar buckets . In order to achieve this , the learning algorithm takes two inputs : a set of training vectors vA ∈ { 0 , 1 } 2Nvoc , and a vector of occurrence probabilities p = { pi = f ( i mod Nvoc ) } 2Nvoc i=1 ∈ R2Nvoc , where fj is the probability of observing word j in the training corpus1 . The learning can be formalized as a minimization of the 1In our notation vector f has Nvoc elements , while vector p has 2Nvoc elements . Given that index i runs from 1 to 2Nvoc , notation pi = f ( i mod Nvoc ) is a mathematical way to concatenate two vectors f into a twice longer vector p. energy function , see [ 39 ] for additional details , defined by E = − ∑ A∈data 〈 Wµ̂ , v A/p 〉 〈 Wµ̂ , Wµ̂ 〉1/2 , where µ̂ = arg max µ 〈 Wµ , v A 〉 ( 1 ) In this equation W ∈ RK×2Nvoc is a matrix of synaptic connections , given as W = { Wµ } = { Wµi } , projecting from PN layer ( individual neurons in the layer are denoted by the index i ) to the KC layer ( individual neurons in the KC layer are denoted by the index µ ) . There are 2Nvoc neurons in the PN layer andK neurons in the KC layer . The inner product 〈X , Y〉 = ∑2Nvoc i=1 XiYi is defined as a contraction over index i of PN cells . In the numerator of the energy function the binary encoded w-gram is divided by the probabilities of occurrences of individual words element-wise , so that the numerator can be written as 〈 Wµ̂ , v A/p 〉 = 2Nvoc∑ i=1 Wµ̂i vAi pi Probabilities p are calculated based on the frequencies of words in the training corpus . The vocabulary contains Nvoc most frequent words in the corpus , thus all the elements of pi are non-zero and the element-wise division is well defined . Intuitively , the goal of the training algorithm is to adjust the weights of the neural network so that they are aligned with w-grams that are frequently present in the training corpus . We rely on the assumption that semantically related w-grams share several “ core ” words , while a few individual words might be substituted by synonyms/antonyms . The minimization of the energy function ( 1 ) is accomplished by the iterative update of the weights satisfying the following learning rule [ 25 ; 39 ; 17 ] ∆Wµi = εg [ ∑ j Wµjv A j ] [ vAi pi − ( ∑ j Wµj vAj pj ) Wµi ] ( 2 ) In this equation the activation function is equal to one for a maximally driven hidden unit ( Kenyon cell ) , and is equal to zero otherwise g [ xµ ] = δµ , µ̂ , where µ̂ = arg max µ [ xµ ] ( 3 ) The learning rate is denoted by ε , and δµ , µ̂ is a Kronecker delta symbol . 2.2 BIO-HASHING . After learning is complete the hash codes for the inputs can be generated in the following way . Given the binary encoded w-gram vA , Hµ = { 1 , if 〈Wµ , vA〉 in the top k of all KCs activations 0 , otherwise ( 4 ) This is a crude mathematical approximation of the biological computation performed by the PN– KC–APL neural network [ 8 ; 39 ] . An input vA generates an input current 〈Wµ , vA〉 into the KC neurons using feedforward weightsWµi . The recurrent network of KCs and the APL neuron silences all but a small fraction of KCs . Those cells that remain active are assigned state 1 , while the rest of the KCs are assigned the inactive state 0 . Notice , that equation ( 4 ) makes it possible to generate the hash codes for both individual words ( static word embeddings like word2vec and GloVe ) and phrases ( similar to Transformer models ) . In the static case , the input vA has all zeros in the context block and a one-hot encoded word in the target block . In the context-dependent case , both blocks have binary encoded input words . Importantly , both context-dependent and static embeddings are mapped into the same space of sparse binary hash codes ( a vector of K elements , with k ones in it ) . We show below that these hash codes capture semantic meaning of the target word and the context in which it is used . For the rest of the paper we refer to the parameter k in equation ( 4 ) as the hash length . In order to provide an intuition behind the learning algorithm defined by the energy function ( 1 ) and weight update rule ( 2 ) and connect it to some of the existing methods in machine learning , consider the limit when all the words have equal probabilities in the training corpus , pi = 1Nvoc . In this limit the energy function ( 1 ) reduces to the familiar spherical K-means clustering algorithm [ 11 ] . In this limit the weights of each KC correspond to the centroids of the clusters of context-target vectors . The hashing rule ( 4 ) assigns active state 1 to the k closest centroids ( and inactive state 0 to the remaining ones ) , defined with respect to cosine similarity distance . In this simple limit the learning algorithm that we use can be viewed as a biologically plausible implementation of this classical algorithm . For real datasets the probabilities of words are different , thus this correspondence does not hold . Notice that division by the probability appears only in the expression for the energy , but not in the definition of µ̂ in equation ( 1 ) . Equivalently , division by pi appears in the second bracket of equation ( 2 ) , but not in the argument of the activation function g [ xµ ] . Thus , in the general case ( for different word probabilities pi ) our algorithm is not equivalent to spherical K-means on context-target vectors rescaled by the probabilities . Rather , in the general case , the closest centroid is found for a given context-target vector ( via the definition of µ̂ in equation ( 1 ) - no pi involved ) , but the “ updates of the position ” of that centroid are computed by enhancing the contributions of rare words ( small pi ) and suppressing the contributions of frequent words ( large pi ) . Empirically , we have found that division by the probabilities improves performance of our method compared to the case of spherical K-means ( when the factor 1/p is removed from the algorithm ) . | The authors present a formalization of a simple biological network (the mushroom body of the fruit fly), that allows very efficient “biologically inspired” word embeddings. They train this network to generate both static (context-independent) and context dependent embeddings, and evaluate these embeddings using several metrics comparing mainly to GloVe embeddings, and to some extent to BERT embeddings. Although the results are sometimes inferior, they are overall comparable, and importantly achieved at significantly lower computational resources. The main contribution of this work is not this specific network formalization (which is nice), but rather demonstrating that formalizing biological networks can generate more efficient algorithms, that achieve results comparable to the complex algorithms used ubiquitously. | SP:86ed253fe1f1c48ec1f909f10a5473c4cf27fa83 |
Self-supervised Graph-level Representation Learning with Local and Global Structure | 1 INTRODUCTION . Learning informative representations of whole graphs is a fundamental problem in a variety of domains and tasks , such as molecule properties prediction in drug and material discovery ( Gilmer et al. , 2017 ; Wu et al. , 2018 ) , protein function forecast in biological networks ( Alvarez & Yan , 2012 ; Jiang et al. , 2017 ) , and predicting the properties of circuits in circuit design ( Zhang et al. , 2019 ) . Recently , Graph Neural Networks ( GNNs ) have attracted a surge of interest and showed the effectiveness in learning graph representations . These methods are usually trained in a supervised fashion , which requires a large number of labeled data . Nevertheless , in many scientific domains , labeled data are very limited and expensive to obtain . Therefore , it is becoming increasingly important to learn the representations of graphs in an unsupervised or self-supervised fashion . Self-supervised learning has recently achieved profound success for both natural language processing , e.g . GPT ( Radford et al. , 2018 ) and BERT ( Devlin et al. , 2019 ) , and image understanding , e.g . MoCo ( He et al. , 2019 ) and SimCLR ( Chen et al. , 2020 ) . However , how to effectively learn the representations of graphs in a self-supervised way is still an open problem . Intuitively , a desirable graph representation should be able to preserve the local-instance structure , so that similar graphs are embedded close to each other and dissimilar ones stay far apart . In addition , the representations of a set of graphs should also reflect the global-semantic structure of the data , so that the graphs with similar semantic properties are compactly embedded , which benefits various downstream tasks , e.g . graph classification or regression . Such structure can be sufficiently captured by semantic clusters ( Caron et al. , 2018 ; Ji et al. , 2019 ) , especially in a hierarchical fashion ( Li et al. , 2020 ) . There are some recent works that learn graph representation in a self-supervised manner , such as local-global mutual information maximization ( Velickovic et al. , 2019 ; Sun et al. , 2019 ) , structuralsimilarity/context prediction ( Navarin et al. , 2018 ; Hu et al. , 2019 ; You et al. , 2020 ) and contrastive multi-view learning ( Hassani & Ahmadi , 2020 ) . However , all these methods are capable of modeling only the local structure between different graph instances but fail to discover the global-semantic structure . To address this shortcoming , we are seeking for an approach that is sufficient to model both the local and global structure of a given set of graphs . To attain this goal , we propose a Local-instance and Global-semantic Learning ( GraphLoG ) framework for self-supervised graph representation learning . In specific , for preserving the local similarity between various graph instances , we first align the embeddings of correlated graphs/subgraphs1 by maximizing their mutual information . In this locally smooth embedding space , we further represent the distribution of different graph embeddings with hierarchical prototypes2 whose number is adaptively determined by the data in a nonparametric fashion . During training , these prototypes guide each graph to map to the semantically-similar feature cluster , and , simultaneously , the prototypes are maintained by online-updated graph embeddings . In this process , the global-semantic structure of the data is gradually discovered and refined . The whole model is pre-trained with a large number of unlabeled graphs , and then fine-tuned and evaluated on some downstream tasks . We summarize our contributions as follows : • We contribute a unified framework called Local-instance and Global-semantic Learning ( GraphLoG ) for self-supervised graph representation learning , which is able to model the structure of a set of graphs both locally and globally . • We novelly propose to infer the global-semantic structure underlying the unlabeled graphs by learning hierarchical prototypes via a nonparametric strategy . • We empirically verify our framework ’ s superior performance on different GNN architectures through pre-training on a large-scale unlabeled dataset and fine-tuning on benchmark tasks in both the chemistry and biology domains . 2 PROBLEM DEFINITION AND PRELIMINARIES . 2.1 PROBLEM DEFINITION . An ideal representation should preserve the local structure among the data instances . More specifically , we define it as follows : Definition 1 ( Local-instance Structure ) . The local-instance structure refers to the local pairwise similarity between different instances ( Roweis & Saul , 2000 ; Belkin & Niyogi , 2002 ) . To preserve the local-instance structure of graph-structured data , a pair of similar graphs/subgraphs , G and G′ , are expected to be mapped to the nearby positions of embedding space , as illustrated in Fig . 1 ( a ) , while the dissimilar pairs should be mapped to far apart . The pursuit of local-instance structure is usually insufficient to capture the semantics underlying the entire dataset . It is therefore important to discover the global-semantic structure of the data , which is concretely defined as follows : Definition 2 ( Global-semantic Structure ) . A real-world dataset is usually distributed as different semantic clusters ( Furnas et al. , 2017 ; Ji et al. , 2019 ) . Therefore , we define the global-semantic structure of a dataset as the distribution of its semantic clusters , and each cluster is represented by a prototype ( i.e . a representative cluster embedding ) . Since the semantics of a set of graphs can be structured in a hierarchical way ( Ashburner et al. , 2000 ; Chen et al. , 2012 ) , we represent the whole dataset with hierarchical prototypes . A detailed example can be seen in Fig . 1 ( b ) . 1In our method , we obtain correlated graphs/subgraphs via minor modification on node/edge attributes . 2Hierarchical prototypes are representative cluster embeddings organized in a hierarchical way . Problem Definition . For self-supervised graph representation learning , a set of unlabeled graphs G = { G1 , G2 , · · · , GM } are given , and we aim to learn a low-dimensional vector hGi ∈ Rδ for each graph Gi ∈ G under the guidance of the data itself . In specific , we expect the derived graph embeddings H ∈ RM×δ follow both the local-instance and global-semantic structure . 2.2 PRELIMINARIES . Graph Neural Networks ( GNNs ) . Given a graph G = ( V , E ) with node attributes XV = { Xv|v ∈ V } and edge attributes XE = { Xuv| ( u , v ) ∈ E } , a GNN aims to learn an embedding vector hv for each node v ∈ V and also a vector hG for the entire graph G. For an L-layer GNN , a neighborhood aggregation scheme is performed to capture the L-hop information surrounding each node . The l-th layer of a GNN can be formalized as follows : h ( l ) v = COMBINE ( l ) ( h ( l−1 ) v , AGGREGATE ( l ) ( { ( h ( l−1 ) v , h ( l−1 ) u , Xuv ) : u ∈ N ( v ) } ) ) , ( 1 ) where N ( v ) is the neighborhood set of v , h ( l ) v denotes the representation of node v at the l-th layer , and h ( 0 ) v is initialized as the node attribute Xv . Since hv summarizes the information of a patch centered around node v , we will refer to hv as patch embedding to underscore this point . The entire graph ’ s embedding can be derived by a permutation-invariant readout function : hG = READOUT ( { hv|v ∈ V } ) . ( 2 ) Mutual Information Estimation . Mutual information ( MI ) can measure both the linear and nonlinear dependency between two random variables . Some recent works ( Belghazi et al. , 2018 ; Hjelm et al. , 2019 ) employed neural networks to estimate the lower bound of MI . Among which , InfoNCE loss ( van den Oord et al. , 2018 ) has been introduced to maximize a lower bound of MI by minimizing itself , and we also adopt it in this work for its simplicity and effectiveness . In practice , given a query q , InfoNCE loss is optimized to score the positive sample z+ higher than a set of distractors { zi } Ki=1 : LNCE ( q , z+ , { zi } Ki=1 ) = − log exp ( T ( q , z+ ) ) exp ( T ( q , z+ ) ) + ∑K i=1 exp ( T ( q , zi ) ) , ( 3 ) where T ( · , · ) is a parameterized discriminator function which maps two representation vectors to a scalar value , whose architecture is detailed in Sec . 6.1 . Rival Penalized Competitive Learning ( RPCL ) . The RPCL method ( Xu et al. , 1993 ) is a variant of classical competitive learning approaches , e.g . K-means clustering . Concretely , given a sample for update , RPCL-based clustering not only pulls the winning cluster center ( i.e . the closest one ) towards the sample , but also pushes the rival cluster center ( i.e . the second closest one ) away from the sample . We adopt this clustering algorithm for its strong capability of discovering feature clusters without specifying the number of clusters beforehand ( i.e . in a nonparametric fashion ) , which is critical in the self-supervised learning scenarios where the number of semantic categories is not given . 3 LOCAL-INSTANCE AND GLOBAL-SEMANTIC LEARNING . 3.1 LEARNING LOCAL-INSTANCE STRUCTURE OF GRAPH REPRESENTATIONS . We first define the correlated graphs that are expected to be embedded close to each other in the embedding space . Since the graphs from a dataset lie in a highly discrete space , it is hard to seek out the correlated counterpart of each graph from the dataset . To tackle this limitation , we propose to construct pairs of correlated graphs via the attribute masking strategy ( Hu et al. , 2019 ) which randomly masks a part of node/edge attributes in a graph ( theoretical analysis is stated in Sec . A ) . Through applying this technique to a randomly sampled mini-batch BG = { Gj = ( Vj , Ej ) } Nj=1 with N graphs , the correlated counterpart of each graph can be obtained , which forms another minibatch B′G = { G′j = ( V ′j , E ′j ) } Nj=1 ( Gj and G′j are deemed as a pair of correlated graphs ) . Taking both mini-batches as input , the corresponding patch and graph embeddings are derived as follows : hVj = { hv|v ∈ Vj } = GNN ( XVj , XEj ) , hV′j = { hv|v ∈ V ′ j } = GNN ( XV′j , XE′j ) , ( 4 ) hGj = READOUT ( hVj ) , hG′j = READOUT ( hV′j ) , ( 5 ) where hVj ( hV′j ) is the set of patch embeddings for graph Gj ( G ′ j ) , and hGj ( hG′j ) denotes the embedding of entire graph . With these ingredients , we design the learning objective for local-instance structure based on two desiderata : ( 1 ) similar subgraphs ( i.e . patches ) have similar feature representations ; ( 2 ) graphs with a set of similar patches are embedded close to each other . To attain these goals , we propose to maximize the mutual information ( i.e . minimize the InfoNCE loss ) between correlated patches/graphs , which derives two constraints for the local-instance structure : Lpatch = 1∑N j=1 |V ′j | N∑ j=1 ∑ v′∈V′j ∑ v∈Vj 1v↔v′ · LNCE ( hv′ , hv , { hṽ|ṽ ∈ Vj , ṽ 6= v } ) , ( 6 ) Lgraph = 1 N N∑ j=1 LNCE ( hG′j , hGj , { hGk |1 6 k 6 N , k 6= j } ) , ( 7 ) Llocal = Lpatch + Lgraph , ( 8 ) where LNCE ( · , · , · ) is the InfoNCE loss function defined in Eq . 3 , and 1v↔v′ denotes the indicator function judging whether v and v′ are the corresponding nodes in a pair of correlated graphs . Note that , masking node/edge attributes doesn ’ t change the topology of a graph , which makes it easy to determine these corresponding nodes in our method . | This paper proposes an unsupervised framework to perform graph representation learning. The local-instance structure is learned by first gets patch-level and graph-level representations for each graph, then maximize the mutual information between both correlated patches and correlated graphs, which are decided by attribute masking strategy. The global-semantic structure is maintained by leveraging RPCL to derive hierarchical prototypes of the representation and maximizing the mutual information between correlated graph representation and the searching path in the prototypes. | SP:37732a5c56b1f8ce138ef14d366adc684ef7376c |
Self-supervised Graph-level Representation Learning with Local and Global Structure | 1 INTRODUCTION . Learning informative representations of whole graphs is a fundamental problem in a variety of domains and tasks , such as molecule properties prediction in drug and material discovery ( Gilmer et al. , 2017 ; Wu et al. , 2018 ) , protein function forecast in biological networks ( Alvarez & Yan , 2012 ; Jiang et al. , 2017 ) , and predicting the properties of circuits in circuit design ( Zhang et al. , 2019 ) . Recently , Graph Neural Networks ( GNNs ) have attracted a surge of interest and showed the effectiveness in learning graph representations . These methods are usually trained in a supervised fashion , which requires a large number of labeled data . Nevertheless , in many scientific domains , labeled data are very limited and expensive to obtain . Therefore , it is becoming increasingly important to learn the representations of graphs in an unsupervised or self-supervised fashion . Self-supervised learning has recently achieved profound success for both natural language processing , e.g . GPT ( Radford et al. , 2018 ) and BERT ( Devlin et al. , 2019 ) , and image understanding , e.g . MoCo ( He et al. , 2019 ) and SimCLR ( Chen et al. , 2020 ) . However , how to effectively learn the representations of graphs in a self-supervised way is still an open problem . Intuitively , a desirable graph representation should be able to preserve the local-instance structure , so that similar graphs are embedded close to each other and dissimilar ones stay far apart . In addition , the representations of a set of graphs should also reflect the global-semantic structure of the data , so that the graphs with similar semantic properties are compactly embedded , which benefits various downstream tasks , e.g . graph classification or regression . Such structure can be sufficiently captured by semantic clusters ( Caron et al. , 2018 ; Ji et al. , 2019 ) , especially in a hierarchical fashion ( Li et al. , 2020 ) . There are some recent works that learn graph representation in a self-supervised manner , such as local-global mutual information maximization ( Velickovic et al. , 2019 ; Sun et al. , 2019 ) , structuralsimilarity/context prediction ( Navarin et al. , 2018 ; Hu et al. , 2019 ; You et al. , 2020 ) and contrastive multi-view learning ( Hassani & Ahmadi , 2020 ) . However , all these methods are capable of modeling only the local structure between different graph instances but fail to discover the global-semantic structure . To address this shortcoming , we are seeking for an approach that is sufficient to model both the local and global structure of a given set of graphs . To attain this goal , we propose a Local-instance and Global-semantic Learning ( GraphLoG ) framework for self-supervised graph representation learning . In specific , for preserving the local similarity between various graph instances , we first align the embeddings of correlated graphs/subgraphs1 by maximizing their mutual information . In this locally smooth embedding space , we further represent the distribution of different graph embeddings with hierarchical prototypes2 whose number is adaptively determined by the data in a nonparametric fashion . During training , these prototypes guide each graph to map to the semantically-similar feature cluster , and , simultaneously , the prototypes are maintained by online-updated graph embeddings . In this process , the global-semantic structure of the data is gradually discovered and refined . The whole model is pre-trained with a large number of unlabeled graphs , and then fine-tuned and evaluated on some downstream tasks . We summarize our contributions as follows : • We contribute a unified framework called Local-instance and Global-semantic Learning ( GraphLoG ) for self-supervised graph representation learning , which is able to model the structure of a set of graphs both locally and globally . • We novelly propose to infer the global-semantic structure underlying the unlabeled graphs by learning hierarchical prototypes via a nonparametric strategy . • We empirically verify our framework ’ s superior performance on different GNN architectures through pre-training on a large-scale unlabeled dataset and fine-tuning on benchmark tasks in both the chemistry and biology domains . 2 PROBLEM DEFINITION AND PRELIMINARIES . 2.1 PROBLEM DEFINITION . An ideal representation should preserve the local structure among the data instances . More specifically , we define it as follows : Definition 1 ( Local-instance Structure ) . The local-instance structure refers to the local pairwise similarity between different instances ( Roweis & Saul , 2000 ; Belkin & Niyogi , 2002 ) . To preserve the local-instance structure of graph-structured data , a pair of similar graphs/subgraphs , G and G′ , are expected to be mapped to the nearby positions of embedding space , as illustrated in Fig . 1 ( a ) , while the dissimilar pairs should be mapped to far apart . The pursuit of local-instance structure is usually insufficient to capture the semantics underlying the entire dataset . It is therefore important to discover the global-semantic structure of the data , which is concretely defined as follows : Definition 2 ( Global-semantic Structure ) . A real-world dataset is usually distributed as different semantic clusters ( Furnas et al. , 2017 ; Ji et al. , 2019 ) . Therefore , we define the global-semantic structure of a dataset as the distribution of its semantic clusters , and each cluster is represented by a prototype ( i.e . a representative cluster embedding ) . Since the semantics of a set of graphs can be structured in a hierarchical way ( Ashburner et al. , 2000 ; Chen et al. , 2012 ) , we represent the whole dataset with hierarchical prototypes . A detailed example can be seen in Fig . 1 ( b ) . 1In our method , we obtain correlated graphs/subgraphs via minor modification on node/edge attributes . 2Hierarchical prototypes are representative cluster embeddings organized in a hierarchical way . Problem Definition . For self-supervised graph representation learning , a set of unlabeled graphs G = { G1 , G2 , · · · , GM } are given , and we aim to learn a low-dimensional vector hGi ∈ Rδ for each graph Gi ∈ G under the guidance of the data itself . In specific , we expect the derived graph embeddings H ∈ RM×δ follow both the local-instance and global-semantic structure . 2.2 PRELIMINARIES . Graph Neural Networks ( GNNs ) . Given a graph G = ( V , E ) with node attributes XV = { Xv|v ∈ V } and edge attributes XE = { Xuv| ( u , v ) ∈ E } , a GNN aims to learn an embedding vector hv for each node v ∈ V and also a vector hG for the entire graph G. For an L-layer GNN , a neighborhood aggregation scheme is performed to capture the L-hop information surrounding each node . The l-th layer of a GNN can be formalized as follows : h ( l ) v = COMBINE ( l ) ( h ( l−1 ) v , AGGREGATE ( l ) ( { ( h ( l−1 ) v , h ( l−1 ) u , Xuv ) : u ∈ N ( v ) } ) ) , ( 1 ) where N ( v ) is the neighborhood set of v , h ( l ) v denotes the representation of node v at the l-th layer , and h ( 0 ) v is initialized as the node attribute Xv . Since hv summarizes the information of a patch centered around node v , we will refer to hv as patch embedding to underscore this point . The entire graph ’ s embedding can be derived by a permutation-invariant readout function : hG = READOUT ( { hv|v ∈ V } ) . ( 2 ) Mutual Information Estimation . Mutual information ( MI ) can measure both the linear and nonlinear dependency between two random variables . Some recent works ( Belghazi et al. , 2018 ; Hjelm et al. , 2019 ) employed neural networks to estimate the lower bound of MI . Among which , InfoNCE loss ( van den Oord et al. , 2018 ) has been introduced to maximize a lower bound of MI by minimizing itself , and we also adopt it in this work for its simplicity and effectiveness . In practice , given a query q , InfoNCE loss is optimized to score the positive sample z+ higher than a set of distractors { zi } Ki=1 : LNCE ( q , z+ , { zi } Ki=1 ) = − log exp ( T ( q , z+ ) ) exp ( T ( q , z+ ) ) + ∑K i=1 exp ( T ( q , zi ) ) , ( 3 ) where T ( · , · ) is a parameterized discriminator function which maps two representation vectors to a scalar value , whose architecture is detailed in Sec . 6.1 . Rival Penalized Competitive Learning ( RPCL ) . The RPCL method ( Xu et al. , 1993 ) is a variant of classical competitive learning approaches , e.g . K-means clustering . Concretely , given a sample for update , RPCL-based clustering not only pulls the winning cluster center ( i.e . the closest one ) towards the sample , but also pushes the rival cluster center ( i.e . the second closest one ) away from the sample . We adopt this clustering algorithm for its strong capability of discovering feature clusters without specifying the number of clusters beforehand ( i.e . in a nonparametric fashion ) , which is critical in the self-supervised learning scenarios where the number of semantic categories is not given . 3 LOCAL-INSTANCE AND GLOBAL-SEMANTIC LEARNING . 3.1 LEARNING LOCAL-INSTANCE STRUCTURE OF GRAPH REPRESENTATIONS . We first define the correlated graphs that are expected to be embedded close to each other in the embedding space . Since the graphs from a dataset lie in a highly discrete space , it is hard to seek out the correlated counterpart of each graph from the dataset . To tackle this limitation , we propose to construct pairs of correlated graphs via the attribute masking strategy ( Hu et al. , 2019 ) which randomly masks a part of node/edge attributes in a graph ( theoretical analysis is stated in Sec . A ) . Through applying this technique to a randomly sampled mini-batch BG = { Gj = ( Vj , Ej ) } Nj=1 with N graphs , the correlated counterpart of each graph can be obtained , which forms another minibatch B′G = { G′j = ( V ′j , E ′j ) } Nj=1 ( Gj and G′j are deemed as a pair of correlated graphs ) . Taking both mini-batches as input , the corresponding patch and graph embeddings are derived as follows : hVj = { hv|v ∈ Vj } = GNN ( XVj , XEj ) , hV′j = { hv|v ∈ V ′ j } = GNN ( XV′j , XE′j ) , ( 4 ) hGj = READOUT ( hVj ) , hG′j = READOUT ( hV′j ) , ( 5 ) where hVj ( hV′j ) is the set of patch embeddings for graph Gj ( G ′ j ) , and hGj ( hG′j ) denotes the embedding of entire graph . With these ingredients , we design the learning objective for local-instance structure based on two desiderata : ( 1 ) similar subgraphs ( i.e . patches ) have similar feature representations ; ( 2 ) graphs with a set of similar patches are embedded close to each other . To attain these goals , we propose to maximize the mutual information ( i.e . minimize the InfoNCE loss ) between correlated patches/graphs , which derives two constraints for the local-instance structure : Lpatch = 1∑N j=1 |V ′j | N∑ j=1 ∑ v′∈V′j ∑ v∈Vj 1v↔v′ · LNCE ( hv′ , hv , { hṽ|ṽ ∈ Vj , ṽ 6= v } ) , ( 6 ) Lgraph = 1 N N∑ j=1 LNCE ( hG′j , hGj , { hGk |1 6 k 6 N , k 6= j } ) , ( 7 ) Llocal = Lpatch + Lgraph , ( 8 ) where LNCE ( · , · , · ) is the InfoNCE loss function defined in Eq . 3 , and 1v↔v′ denotes the indicator function judging whether v and v′ are the corresponding nodes in a pair of correlated graphs . Note that , masking node/edge attributes doesn ’ t change the topology of a graph , which makes it easy to determine these corresponding nodes in our method . | This paper proposed a method for self-supervised graph-level representation learning. The main idea is to enforce both the instance level smoothness embedding constraints, and a so-called global, semantic grouping structures across all instance graphs in the training data set. To achieve this goal, the authors have adopted a global clustering framework to encourage the embedding of the graphs belonging to the same clusters to be close to each other, and by using a hierarchically organized set of prototypes. The proposed method is applied to pre-train GNN on massive unlabeled graphs, which is then fine-tuned to downstream learning tasks. | SP:37732a5c56b1f8ce138ef14d366adc684ef7376c |
UneVEn: Universal Value Exploration for Multi-Agent Reinforcement Learning | 1 INTRODUCTION . Learning control policies for cooperative multi-agent reinforcement learning ( MARL ) remains challenging as agents must search the joint-action space , which grows exponentially with the number of agents . Current state-of-the-art value-based methods such as VDN ( Sunehag et al. , 2017 ) and QMIX ( Rashid et al. , 2020b ) learn a centralized joint-action value function as a monotonic factorization of decentralized agent utility functions and can therefore cope with large joint action spaces . Due to this monotonic factorization , the joint-action value function can be decentrally maximized as each agent can simply select the action that maximizes its corresponding utility function . This monotonic restriction , however , prevents VDN and QMIX from representing nonmonotonic joint-action value functions ( Mahajan et al. , 2019 ) where an agent ’ s best action depends on what actions the other agents choose . For example , consider a predator-prey task where at least three agents need to coordinate to capture a prey and any capture attempts by fewer agents are penalized with a penalty of magnitude p. As a result , both VDN and QMIX tend to get stuck in a suboptimal equilibrium ( also called the relative overgeneralization pathology , Panait et al. , 2006 ; Wei et al. , 2018 ) in which agents simply avoid the prey ( Mahajan et al. , 2019 ; Böhmer et al. , 2020 ) . This happens for two reasons . First , depending on p , successful coordination by at least three agents is a needle in the haystack and any step towards it is penalized . Second , the monotonically factorized jointaction value function lacks the representational capacity to distinguish the values of coordinated and uncoordinated joint actions during exploration . Recent work addresses the problem of inefficient exploration by VDN and QMIX due to monotonic factorization . QTRAN ( Son et al. , 2019 ) and WQMIX ( Rashid et al. , 2020a ) address this problem by weighing important joint actions differently , which can be found by simultaneously learning a centralized value function , but these approaches still rely on inefficient -greedy exploration which may fail on harder tasks ( e.g. , the predator-prey task above with higher value of p ) . MAVEN ( Mahajan et al. , 2019 ) learns an ensemble of monotonic joint-action value functions through committed exploration by maximizing the entropy of the trajectories conditioned on a latent variable . Their exploration focuses on diversity in the joint team behaviour using mutual information . By contrast , this paper proposes Universal Value Exploration ( UneVEn ) , which follows the intuitive premise that tasks with a simpler reward function than the target task ( e.g. , a smaller miscoordination penalty in predator-prey ) can be efficiently solved using a monotonic factorization of the joint-action value function . Therefore , UneVEn samples tasks related to the target task , that are often easier to solve , but often have similar important joint actions . Selecting actions based on these related tasks during exploration can bias the monotonic approximation of the value function towards important joint actions of the target task ( Son et al. , 2019 ; Rashid et al. , 2020a ) , which can overcome relative overgeneralization . To leverage the policies of the sampled related tasks , which only differ in their reward functions , UneVEn uses Universal Successor Features ( USFs , Borsa et al. , 2018 ) which have demonstrated excellent zero-shot generalization in single-agent tasks with different reward functions ( Barreto et al. , 2017 ; 2020 ) . USFs generalize policy dynamics over tasks using Universal Value Functions ( UVFs , Schaul et al. , 2015 ) , along with Generalized Policy Improvement ( GPI , Barreto et al. , 2017 ) , which combines solutions of previous tasks into new policies for unseen tasks . Our contributions are as follows . First , we propose Multi-Agent Universal Successor Features ( MAUSFs ) factorized into novel decentralized agent-specific SFs with value decomposition networks ( Sunehag et al. , 2017 ) from MARL . This factorization enables agents to compute decentralized greedy policies and to perform decentralized local GPI , which is particularly well suited for MARL , as it allows to maximize over a combinatorial set of agent policies . Second , we propose Universal Value Exploration ( UneVEn ) , which uses novel action-selection schemes based on related tasks to solve tasks with nonmonotonic values with monotonic approximations thereof . We evaluate our novel approach in predator-prey tasks that require significant coordination amongst agents and highlight the relative overgeneralization pathology . We empirically show that UneVEn with MAUSFs significantly outperforms current state-of-the-art value-based methods on the target tasks and in zero-shot generalization ( Borsa et al. , 2018 ) across MARL tasks with different reward functions , which enables us to leverage UneVEn effectively . 2 BACKGROUND . Dec-POMDP : A fully cooperative decentralized multi-agent task can be formalized as a decentralized partially observable Markov decision process ( Dec-POMDP , Oliehoek et al. , 2016 ) consisting of a tuple G = 〈S , U , P , R , Ω , O , n , γ〉 . s ∈ S describes the true state of the environment . At each time step , each agent a ∈ A ≡ { 1 , ... , n } chooses an action ua ∈ U , forming a joint action u ∈ U ≡ Un . This causes a transition in the environment according to the state transition kernel P ( s′|s , u ) : S × U × S → [ 0 , 1 ] . All agents are collaborative and share therefore the same reward function R ( s , u ) : S × U → R and γ ∈ [ 0 , 1 ) is a discount factor . Due to partial observability , each agent a can not observe the true state s , but receives an observation oa ∈ Ω drawn from observation kernel oa ∼ O ( s , a ) . At time t , each agent a has access to its action-observation history τat ∈ Tt ≡ ( Ω × U ) t × Ω , on which it conditions a stochastic policy πa ( uat |τat ) . τt ∈ T nt denotes the histories of all agents . The joint stochastic policy π ( ut|st , τt ) ≡∏n a=1 π a ( uat |τat ) induces a joint-action value function : Qπ ( st , τt , ut ) = E [ Gt|st , τt , ut ] , where Gt = ∑∞ i=0 γ irt+i is the discounted return . CTDE : We adopt the framework of centralized training and decentralized execution ( CTDE Kraemer & Banerjee , 2016 ) , which assumes access to all action-observation histories τt and global state st during training , but each agent ’ s decentralized policy πa can only condition on its own actionobservation history τa . This approach can exploit information that is not available during execution and also freely share parameters and gradients , which improves the sample efficiency considerably ( see e.g. , Foerster et al. , 2018 ; Rashid et al. , 2020b ; Böhmer et al. , 2020 ) . Value Decomposition Networks : A naive way to learn in MARL is independent Q-learning ( IQL , Tan , 1993 ) , which learns an independent action value function Qa ( τat , u a t ; θ a ) for each agent a that conditions only on its local action-observation history τat . To make better use of other agents ’ information in CTDE , value decomposition networks ( VDN , Sunehag et al. , 2017 ) represent the joint-action value function Qtot as a sum of per-agent utility functions Qa : Qtot ( τ , u ; θ ) ≡∑n a=1Q a ( τa , ua ; θ ) . Each Qa still conditions only on individual action-observation histories and can be represented by an agent network that shares parameters across all agents . The joint-action value function Qtot can be trained using Deep Q-Networks ( DQN , Mnih et al. , 2015 ) . Compared to VDN , QMIX ( Rashid et al. , 2020b ) allows joint-action value function Qtot to be represented as a nonlinear monotonic combination of individual utility functions . The greedy joint action in both VDN and QMIX can be computed decentrally by individually maximizing each agent ’ s utility . See OroojlooyJadid & Hajinezhad ( 2019 ) for a more in-depth overview of cooperative deep MARL . Task based Universal Value Functions : In this paper , we consider tasks that differ only in their reward functions Rw ( s , u ) ≡ w > φ ( s , u ) , which are linear combinations of a set of basis functions φ : S × U → Rd . Intuitively , the basis functions φ encode potentially rewarded events , such as opening a door or picking up an object . We use the weight vector w to denote the task with reward function Rw . Universal Value Functions ( UVFs , Schaul et al. , 2015 ) is an extension of DQN that learns a generalizable value function conditioned on tasks . UVFs are typically of the form Qπ ( st , ut , w ) to indicate the action-value function of task w under policy π at time t as : Qπ ( st , ut , w ) = Eπ [ ∞∑ i=0 γiRw ( st+i , ut+i ) ∣∣ st , ut ] = Eπ [ ∞∑ i=0 γi φ ( st+i , ut+i ) > w ∣∣ st , ut ] . ( 1 ) Successor Features : The Successor Representation ( Dayan , 1993 ) has been widely used in singleagent settings ( Barreto et al. , 2017 ; 2018 ; Borsa et al. , 2018 ) to generalize across tasks with given reward specifications . By simply rewriting the definition of the action value function Qπ ( st , ut , w ) of task w from Equation 1 we have : Qπ ( st , ut , w ) = Eπ [ ∞∑ i=0 γi φ ( st+i , ut+i ) ∣∣ st , ut ] > w ≡ ψπ ( st , ut ) > w , ( 2 ) where ψπ ( s , u ) are the Successor Features ( SFs ) under policy π . For the optimal policy π ? z of task z , the SFs ψπ ? z summarize the dynamics under this policy , which can then be weighted with any reward vector w ∈ Rd to instantly evaluate policy π ? z on it : Qπ ? z ( s , u , w ) = ψπ ? z ( s , u ) > w . Universal Successor Features and Generalized Policy Improvement : Borsa et al . ( 2018 ) introduce universal successor features ( USFs ) which learns SFs conditioned on tasks using the generalization power of UVFs . Specifically , they define UVFs of the form Q ( s , u , z , w ) which represents the value function of policy πz evaluated on task w ∈ Rd . These UVFs can be factored using the SFs property ( Equation 2 ) as : Q ( s , u , z , w ) = ψ ( s , u , z ) > w , where ψ ( s , u , z ) are the USFs that generate the SFs induced by task-specific policy πz . One major advantage of using SFs is the ability to efficiently do generalized policy improvement ( GPI , Barreto et al. , 2017 ) , which allows a new policy to be computed for any unseen task based on instant policy evaluation of a set of policies on that unseen task with a simple dot-product . Formally , given a set C ⊆ Rd of tasks and their corresponding SFs { ψ ( s , u , z ) } z∈C induced by corresponding policies { πz } z∈C , a new policy π′w for any unseen task w ∈ Rd can be derived using : π′w ( s ) ∈ arg max u∈U max z∈C Q ( s , u , z , w ) = arg max u∈U max z∈C ψ ( s , u , z ) > w . ( 3 ) Setting C = { w } allows us to revert back to UVFs , as we evaluate SFs induced by policy πw on task w itself . However , we can use any set of tasks that are similar to w based on some similarity distribution D ( ·|w ) . The computed policy π′w is guaranteed to perform no worse on task w than each of the policies { πz } z∈C ( Barreto et al. , 2017 ) , but often performs much better . SFs thus enable efficient use of GPI , which allows reuse of learned knowledge for zero-shot generalization . | The paper develops and evaluates an algorithm for decision making in the CTDE MARL setting (centralized training and decentralized execution for multiagent reinforcement learning). That is, the concern is how to use closely supervised training to produce agents that can work independently toward a common goal. The problem is formalized in the DEC-POMDP (decentralized partially observable Markov decision process) setting. | SP:89ffd39dd2f60a2ee0b3e382f3bfde2681405e4d |
UneVEn: Universal Value Exploration for Multi-Agent Reinforcement Learning | 1 INTRODUCTION . Learning control policies for cooperative multi-agent reinforcement learning ( MARL ) remains challenging as agents must search the joint-action space , which grows exponentially with the number of agents . Current state-of-the-art value-based methods such as VDN ( Sunehag et al. , 2017 ) and QMIX ( Rashid et al. , 2020b ) learn a centralized joint-action value function as a monotonic factorization of decentralized agent utility functions and can therefore cope with large joint action spaces . Due to this monotonic factorization , the joint-action value function can be decentrally maximized as each agent can simply select the action that maximizes its corresponding utility function . This monotonic restriction , however , prevents VDN and QMIX from representing nonmonotonic joint-action value functions ( Mahajan et al. , 2019 ) where an agent ’ s best action depends on what actions the other agents choose . For example , consider a predator-prey task where at least three agents need to coordinate to capture a prey and any capture attempts by fewer agents are penalized with a penalty of magnitude p. As a result , both VDN and QMIX tend to get stuck in a suboptimal equilibrium ( also called the relative overgeneralization pathology , Panait et al. , 2006 ; Wei et al. , 2018 ) in which agents simply avoid the prey ( Mahajan et al. , 2019 ; Böhmer et al. , 2020 ) . This happens for two reasons . First , depending on p , successful coordination by at least three agents is a needle in the haystack and any step towards it is penalized . Second , the monotonically factorized jointaction value function lacks the representational capacity to distinguish the values of coordinated and uncoordinated joint actions during exploration . Recent work addresses the problem of inefficient exploration by VDN and QMIX due to monotonic factorization . QTRAN ( Son et al. , 2019 ) and WQMIX ( Rashid et al. , 2020a ) address this problem by weighing important joint actions differently , which can be found by simultaneously learning a centralized value function , but these approaches still rely on inefficient -greedy exploration which may fail on harder tasks ( e.g. , the predator-prey task above with higher value of p ) . MAVEN ( Mahajan et al. , 2019 ) learns an ensemble of monotonic joint-action value functions through committed exploration by maximizing the entropy of the trajectories conditioned on a latent variable . Their exploration focuses on diversity in the joint team behaviour using mutual information . By contrast , this paper proposes Universal Value Exploration ( UneVEn ) , which follows the intuitive premise that tasks with a simpler reward function than the target task ( e.g. , a smaller miscoordination penalty in predator-prey ) can be efficiently solved using a monotonic factorization of the joint-action value function . Therefore , UneVEn samples tasks related to the target task , that are often easier to solve , but often have similar important joint actions . Selecting actions based on these related tasks during exploration can bias the monotonic approximation of the value function towards important joint actions of the target task ( Son et al. , 2019 ; Rashid et al. , 2020a ) , which can overcome relative overgeneralization . To leverage the policies of the sampled related tasks , which only differ in their reward functions , UneVEn uses Universal Successor Features ( USFs , Borsa et al. , 2018 ) which have demonstrated excellent zero-shot generalization in single-agent tasks with different reward functions ( Barreto et al. , 2017 ; 2020 ) . USFs generalize policy dynamics over tasks using Universal Value Functions ( UVFs , Schaul et al. , 2015 ) , along with Generalized Policy Improvement ( GPI , Barreto et al. , 2017 ) , which combines solutions of previous tasks into new policies for unseen tasks . Our contributions are as follows . First , we propose Multi-Agent Universal Successor Features ( MAUSFs ) factorized into novel decentralized agent-specific SFs with value decomposition networks ( Sunehag et al. , 2017 ) from MARL . This factorization enables agents to compute decentralized greedy policies and to perform decentralized local GPI , which is particularly well suited for MARL , as it allows to maximize over a combinatorial set of agent policies . Second , we propose Universal Value Exploration ( UneVEn ) , which uses novel action-selection schemes based on related tasks to solve tasks with nonmonotonic values with monotonic approximations thereof . We evaluate our novel approach in predator-prey tasks that require significant coordination amongst agents and highlight the relative overgeneralization pathology . We empirically show that UneVEn with MAUSFs significantly outperforms current state-of-the-art value-based methods on the target tasks and in zero-shot generalization ( Borsa et al. , 2018 ) across MARL tasks with different reward functions , which enables us to leverage UneVEn effectively . 2 BACKGROUND . Dec-POMDP : A fully cooperative decentralized multi-agent task can be formalized as a decentralized partially observable Markov decision process ( Dec-POMDP , Oliehoek et al. , 2016 ) consisting of a tuple G = 〈S , U , P , R , Ω , O , n , γ〉 . s ∈ S describes the true state of the environment . At each time step , each agent a ∈ A ≡ { 1 , ... , n } chooses an action ua ∈ U , forming a joint action u ∈ U ≡ Un . This causes a transition in the environment according to the state transition kernel P ( s′|s , u ) : S × U × S → [ 0 , 1 ] . All agents are collaborative and share therefore the same reward function R ( s , u ) : S × U → R and γ ∈ [ 0 , 1 ) is a discount factor . Due to partial observability , each agent a can not observe the true state s , but receives an observation oa ∈ Ω drawn from observation kernel oa ∼ O ( s , a ) . At time t , each agent a has access to its action-observation history τat ∈ Tt ≡ ( Ω × U ) t × Ω , on which it conditions a stochastic policy πa ( uat |τat ) . τt ∈ T nt denotes the histories of all agents . The joint stochastic policy π ( ut|st , τt ) ≡∏n a=1 π a ( uat |τat ) induces a joint-action value function : Qπ ( st , τt , ut ) = E [ Gt|st , τt , ut ] , where Gt = ∑∞ i=0 γ irt+i is the discounted return . CTDE : We adopt the framework of centralized training and decentralized execution ( CTDE Kraemer & Banerjee , 2016 ) , which assumes access to all action-observation histories τt and global state st during training , but each agent ’ s decentralized policy πa can only condition on its own actionobservation history τa . This approach can exploit information that is not available during execution and also freely share parameters and gradients , which improves the sample efficiency considerably ( see e.g. , Foerster et al. , 2018 ; Rashid et al. , 2020b ; Böhmer et al. , 2020 ) . Value Decomposition Networks : A naive way to learn in MARL is independent Q-learning ( IQL , Tan , 1993 ) , which learns an independent action value function Qa ( τat , u a t ; θ a ) for each agent a that conditions only on its local action-observation history τat . To make better use of other agents ’ information in CTDE , value decomposition networks ( VDN , Sunehag et al. , 2017 ) represent the joint-action value function Qtot as a sum of per-agent utility functions Qa : Qtot ( τ , u ; θ ) ≡∑n a=1Q a ( τa , ua ; θ ) . Each Qa still conditions only on individual action-observation histories and can be represented by an agent network that shares parameters across all agents . The joint-action value function Qtot can be trained using Deep Q-Networks ( DQN , Mnih et al. , 2015 ) . Compared to VDN , QMIX ( Rashid et al. , 2020b ) allows joint-action value function Qtot to be represented as a nonlinear monotonic combination of individual utility functions . The greedy joint action in both VDN and QMIX can be computed decentrally by individually maximizing each agent ’ s utility . See OroojlooyJadid & Hajinezhad ( 2019 ) for a more in-depth overview of cooperative deep MARL . Task based Universal Value Functions : In this paper , we consider tasks that differ only in their reward functions Rw ( s , u ) ≡ w > φ ( s , u ) , which are linear combinations of a set of basis functions φ : S × U → Rd . Intuitively , the basis functions φ encode potentially rewarded events , such as opening a door or picking up an object . We use the weight vector w to denote the task with reward function Rw . Universal Value Functions ( UVFs , Schaul et al. , 2015 ) is an extension of DQN that learns a generalizable value function conditioned on tasks . UVFs are typically of the form Qπ ( st , ut , w ) to indicate the action-value function of task w under policy π at time t as : Qπ ( st , ut , w ) = Eπ [ ∞∑ i=0 γiRw ( st+i , ut+i ) ∣∣ st , ut ] = Eπ [ ∞∑ i=0 γi φ ( st+i , ut+i ) > w ∣∣ st , ut ] . ( 1 ) Successor Features : The Successor Representation ( Dayan , 1993 ) has been widely used in singleagent settings ( Barreto et al. , 2017 ; 2018 ; Borsa et al. , 2018 ) to generalize across tasks with given reward specifications . By simply rewriting the definition of the action value function Qπ ( st , ut , w ) of task w from Equation 1 we have : Qπ ( st , ut , w ) = Eπ [ ∞∑ i=0 γi φ ( st+i , ut+i ) ∣∣ st , ut ] > w ≡ ψπ ( st , ut ) > w , ( 2 ) where ψπ ( s , u ) are the Successor Features ( SFs ) under policy π . For the optimal policy π ? z of task z , the SFs ψπ ? z summarize the dynamics under this policy , which can then be weighted with any reward vector w ∈ Rd to instantly evaluate policy π ? z on it : Qπ ? z ( s , u , w ) = ψπ ? z ( s , u ) > w . Universal Successor Features and Generalized Policy Improvement : Borsa et al . ( 2018 ) introduce universal successor features ( USFs ) which learns SFs conditioned on tasks using the generalization power of UVFs . Specifically , they define UVFs of the form Q ( s , u , z , w ) which represents the value function of policy πz evaluated on task w ∈ Rd . These UVFs can be factored using the SFs property ( Equation 2 ) as : Q ( s , u , z , w ) = ψ ( s , u , z ) > w , where ψ ( s , u , z ) are the USFs that generate the SFs induced by task-specific policy πz . One major advantage of using SFs is the ability to efficiently do generalized policy improvement ( GPI , Barreto et al. , 2017 ) , which allows a new policy to be computed for any unseen task based on instant policy evaluation of a set of policies on that unseen task with a simple dot-product . Formally , given a set C ⊆ Rd of tasks and their corresponding SFs { ψ ( s , u , z ) } z∈C induced by corresponding policies { πz } z∈C , a new policy π′w for any unseen task w ∈ Rd can be derived using : π′w ( s ) ∈ arg max u∈U max z∈C Q ( s , u , z , w ) = arg max u∈U max z∈C ψ ( s , u , z ) > w . ( 3 ) Setting C = { w } allows us to revert back to UVFs , as we evaluate SFs induced by policy πw on task w itself . However , we can use any set of tasks that are similar to w based on some similarity distribution D ( ·|w ) . The computed policy π′w is guaranteed to perform no worse on task w than each of the policies { πz } z∈C ( Barreto et al. , 2017 ) , but often performs much better . SFs thus enable efficient use of GPI , which allows reuse of learned knowledge for zero-shot generalization . | Some popular methods like VDN and QMIX focus on the monotonic factorization of joint-action value function, which is not realistic in non-monotonic cases when the agent’s best action depends on other agents’ actions. This phenomenon is common. For example, in the prisoner’s dilemma the value function can be monotonically decreasing in each of the agent’s local value function. One of the effect this paper focuses on is that the monotonically factorization lacks the representational capacity to distinguish the values of coordinated and uncoordinated joint actions during exploration. This effect is well explained in the predator-prey game example, where both VDN and QMIX have undesired performance. | SP:89ffd39dd2f60a2ee0b3e382f3bfde2681405e4d |
Intention Propagation for Multi-agent Reinforcement Learning | 1 INTRODUCTION . Collaborative multi-agent reinforcement learning is an important sub-field of the multi-agent reinforcement learning ( MARL ) , where the agents learn to coordinate to achieve joint success . It has wide applications in traffic control ( Kuyer et al. , 2008 ) , autonomous driving ( Shalev-Shwartz et al. , 2016 ) and smart grid ( Yang et al. , 2018 ) . To learn a coordination , the interactions between agents are indispensable . For instance , humans can reason about other ’ s behaviors or know other peoples ’ intentions through communication and then determine an effective coordination plan . However , how to design a mechanism of such interaction in a principled way and at the same time solve the large scale real-world applications is still a challenging problem . Recently , there is a surge of interest in solving the collaborative MARL problem ( Foerster et al. , 2018 ; Qu et al. , 2019 ; Lowe et al. , 2017 ) . Among them , joint policy approaches have demonstrated their superiority ( Rashid et al. , 2018 ; Sunehag et al. , 2018 ; Oliehoek et al. , 2016 ) . A straightforward approach is to replace the action in the single-agent reinforcement learning by the joint action a = ( a1 , a2 , ... , aN ) , while it obviously suffers from the issue of the exponentially large action space . Thus several approaches have been proposed to factorize the joint action space to mitigate such issue , which can be roughly grouped into two categories : • Factorization on policy . This approach explicitly assumes that π ( a|s ) : = ∏N i=1 πi ( ai|s ) , i.e. , policies are independent ( Foerster et al. , 2018 ; Zhang et al. , 2018 ) . To mitigate for the instability issue caused by the independent learner , it generally needs a centralized critic . • Factorization on value function . This approach has a similar spirit but factorizes the joint value function into several utility functions , each just involving the actions of one agent ( Rashid et al. , 2018 ; Sunehag et al. , 2018 ) . However , these two approaches lack of the interactions between agents , since in their algorithms agent i does not care about the plan of agent j . Indeed , they may suffer from a phenomenon called relative over-generalization in game theory observed by Wei & Luke ( 2016 ) ; Castellini et al . ( 2019 ) ; Palmer et al . ( 2018 ) . Approaches based on the coordinate graph would effectively prevent such cases , where the value function is factorized as a summation of utility function on pairwise or local joint action ( Guestrin et al. , 2002 ; Böhmer et al. , 2020 ) . However , they only can be applied in discrete action , small scale game . Furthermore , despite the empirical success of the aforementioned work in certain scenarios , it still lacks theoretical insight . In this work , we only make a simple yet realistic assumption : the reward function ri of each agent i just depends on its individual action and the actions of its neighbors ( and state ) , i.e. , ri ( s , a ) = ri ( s , ai , aNi ) , ( 1 ) where we use Ni to denote the neighbors of agent i , s to denote the global state . It says the goal or decision of agent is explicitly influenced by a small subset Ni of other agents . Note that such an assumption is reasonable in lots of real scenarios . For instance , • The traffic light at an intersection makes the decision on the phase changing mainly relying on the traffic flow around it and the policies of its neighboring traffic light . • The main goal of a defender in a soccer game is to tackle the opponent ’ s attacker , while he rarely needs to pay attention to opponent goalkeeper ’ s strategy . Based on the assumption in equation 1 , we propose a principled multi-agent reinforcement learning algorithm in the framework of probabilistic inference , where the objective is to maximize the long term reward of the group , i.e. , ∑∞ t=0 ∑N i=1 γ trti ( see details in section 4 ) . Note since each agent ’ s reward depends on its neighbor , we still need a joint policy to maximize the global reward through interactions . In this paper , we derive an iterative procedure for such interaction to learn the joint policy in collaborative MARL and name it intention propagation . Particularly , • In the first round , each agent i makes an independent decision and spreads out his plan µ̃i ( we name it intention ) to neighbors . • In the second round , agents i changes its initial intention properly based on its neighbors ’ intention µ̃j , j ∈ Ni and propagates its intention µ̃i again . • In the third round , it changes the decision in the second round with a similar argument . • As this procedure goes on , we show the final output of agents ’ policy converges to the mean field approximation ( the variational inference method from the probabilistic graphical model ( Bishop , 2006 ) ) of the joint policy . In addition , this joint policy has the form of Markov Random Field induced by the locality of the reward function ( proposition 1 ) . Therefore , such a procedure is computationally efficient when the underlying graph is sparse , since in each round , each agent just needs to care about what its neighbors intend to do . Remark : ( 1 ) Our work is not related to the mean-field game ( MFG ) ( Yang et al. , 2018 ) . The goal of the MFG is to find the Nash equilibrium , while our work aims to the optimal joint policy in the collaborative game . Furthermore , MFG generally assumes agents are identical and interchangeable . When the number of agents goes to infinity , MFG can view the state of other agents as a population state distribution . In our problem , we do not have such assumptions . ( 2 ) our analysis is not limited to the mean-field approximation . When we change the message passing structure of intention propagation , we can show that it converges to other approximation of the joint policy , e.g. , loopy belief propagation in variational inference ( Yedidia et al. , 2001 ) ( see Appendix B.2 ) . Contributions : ( 1 ) We propose a principled method named intention propagation to solve the joint policy collaborative MARL problem ; ( 2 ) Our method is computationally efficient , which can scale up to one thousand agents and thus meets the requirement of real applications ; ( 3 ) Empirically , it outperforms state-of-the-art baselines with a wide margin when the number of agents is large ; ( 4 ) Our work builds a bridge between MARL and neural embedded probabilistic inference , which would lead to new algorithms beyond intention propagation . Notation : sti and ati represent the state and action of agent i at time step t. The neighbors of agent i are represented asNi . We denote X as a random variable with domain X and refer to instantiations of X by the lower case character x . We denote a density on X by p ( x ) and denote the space of all such densities as by P . 2 RELATED WORK . We first discuss the work of the factorized approaches on the joint policy . COMA designs a MARL algorithm based on the actor-critic framework with independent actors πi ( ai|s ) , where the joint policy is factorized as π ( a|s ) = ∏N i=1 πi ( ai|s ) ( Foerster et al. , 2018 ) . MADDPG considers a MARL with the cooperative or competitive setting , where it creates a critic for each agent ( Lowe et al. , 2017 ) . Other similar works may include ( de Witt et al. , 2019 ; Wei et al. , 2018 ) . Another way is to factorize the value functions into several utility functions . Sunehag et al . ( 2018 ) assumes that the overall Q function can be factorized as Q ( s , a1 , a2 , .. , aN ) = ∑N i=1Qi ( si , ai ) . QMIX extends this work to include a richer class of function , where it assumes the overall Q function is a monotonic function w.r.t . each Qi ( si , ai ) ( Rashid et al. , 2018 ) . Similarly , Son et al . ( 2019 ) further relax the structure constraint on the joint value function . However these factorized methods suffer from the relative overgeneralization issue ( Castellini et al. , 2019 ; Palmer et al. , 2018 ) . Generally speaking , it pushes the agents to underestimate a certain action because of the low rewards they receive , while they could get a higher one by perfectly coordinating . A middle ground between the ( fully ) joint policy and the factorized policy is the coordination graph ( Guestrin et al. , 2002 ) , where the value function is factorized as a summation of the utility function on the pairwise action . Böhmer et al . ( 2020 ) ; Castellini et al . ( 2019 ) combine deep learning techniques with the coordination graph . It addresses the issue of relative overgeneralization , but still has two limitations especially in the large scale MARL problem . ( 1 ) The max-sum algorithm can just be implemented in the discrete action space since it needs a max-sum operation on the action of Q function . ( 2 ) Even in the discrete action case , each step of the Q learning has to do several loops of max-sum operation over the whole graph if there is a cycle in graph . Our algorithm can handle both discrete and continuous action space cases and alleviate the scalability issue by designing an intention propagation network . Another category of MARL is to consider the communication among agents . The attention mechanism is used to decide when and who to communicate with ( Das et al. , 2018 ) . Foerster et al . ( 2016 ) propose an end-to-end method to learn communication protocol . In ( Liu et al. , 2019 ; Chu et al. , 2020 ) , each agent sends the action information to it neighbors . In addition , Chu et al . ( 2020 ) require a strong assumption that the MDP has the spatial-temporal Markov property . However , they utilizes neighbor ’ s action information in a heuristic way and thus it is unclear what the agents are learning ( e.g. , do they learn the optimal joint policy to maximize the group reward ? ) . Jiang et al . ( 2020 ) propose DGN which uses GNN to spread the state embedding information to neighbors . However each agent still uses an independent Q learning to learn the policy and neglects other agents ’ plans . In contrast , we propose a principled algorithm , where each agent makes decision considering other agents ’ plan . Such procedure can be parameterized by GNN and other neural networks ( see section 4.1 and appendix B.2 ) . We prove its convergence to the solution of variational inference methods . 3 BACKGROUNDS . Probabilistic Reinforcement Learning : Probabilistic reinforcement learning ( PRL ) ( Levine , 2018 ) is our building block . PRL defines the trajectory τ up to time step T as τ = [ s0 , a0 , s1 , a1 , ... , sT , aT , sT+1 ] . The probability distribution of the trajectory τ induced by the optimal policy is defined as p ( τ ) = [ p ( s0 ) ∏T t=0 p ( s t+1|st , at ) ] exp ( ∑T t=0 r ( s t , at ) ) . While the probability of the trajectory τ under the policy π ( a|s ) is defined as p̂ ( τ ) = p ( s0 ) ∏T t=0 p ( s t+1|st , at ) π ( at|st ) . The objective is to minimize the KL divergence between p̂ ( τ ) and p ( τ ) . It is equivalent to the maximum entropy reinforcement learning max π J ( π ) = T∑ t=0 E [ r ( st , at ) +H ( π ( at|st ) ) ] , where it omits the discount factor γ and regularizer factor α of the entropy term , since it is easy to incorporate them into the transition and reward respectively . Notice in this framework the max operator in the Bellman optimality equation would be replaced by the softmax operator and thus its optimal policy is a softmax function related to the Q function ( Haarnoja et al. , 2017 ) . Such framework subsumes state-of-the-art algorithms such as soft-actor-critic ( SAC ) ( Haarnoja et al. , 2018 ) . In each iteration , SAC optimizes the following loss function of Q , π , V , and respectively . E ( st , at ) ∼D [ Q ( st , at ) − r ( st , at ) − γEst+1∼p [ V ( st+1 ) ] ] 2 , Est∼DEat∼π [ log π ( at|st ) −Q ( st , at ) ] Est∼D [ V ( st ) − Eat∼πθ [ Q ( st , at ) − log π ( at|st ) ] ] 2 , where D is the replay buffer . Function Space Embedding of Distribution : In our work , we use the tool of embedding in Reproducing Kernel Hilbert Space ( RKHS ) to design an intention propagation procedure ( Smola et al. , 2007 ) . We let φ ( X ) be an implicit feature mapping and X be a random variable with distribution p ( x ) . Embeddings of p ( x ) is given by µX : = EX [ φ ( X ) ] = ∫ φ ( x ) p ( x ) dx where the distribution is mapped to its expected feature map . By assuming that there exists a feature space such that the embeddings are injective , we can treat the embedding µX of the density p ( x ) as a sufficient statistic of the density , i.e. , any information we need from the density is preserved in µX ( Smola et al. , 2007 ) . Such injective assumption generally holds under mild condition ( Sriperumbudur et al. , 2008 ) . This property is important since we can reformulate a functional f : P → R of p ( · ) using the embedding only , i.e. , f ( p ( x ) ) = f̃ ( µX ) . It also can be generalized to the operator case . In particular , applying an operator T : P → Rd to a density can be equivalently carried out using its embedding T ◦ p ( x ) = T̃ ◦ µX , where T̃ : F → Rd is the alternative operator working on the embedding . In practice , µX , f̃ and T̃ have complicated dependence on φ . As such , we approximate them by neural networks , which is known as the neural embedding approach of distribution ( Dai et al. , 2016 ) . | The paper considers the cooperative multiagent MARL setting where each agent’s reward depends on the state and the actions of itself and its neighbors The paper has a theoretical claim that, for such reward structure, the optimal maximum entropy joint policy in the form that can be factored into potential functions, one for each agent. In particular, if the sum of all agents’ rewards is a function on pairwise actions, those potential functions are one for each agent and one for each pair of actions (i.e. the equation after Proposition 1). | SP:243e8027661d500c99d0e2633726895f32141b9e |
Intention Propagation for Multi-agent Reinforcement Learning | 1 INTRODUCTION . Collaborative multi-agent reinforcement learning is an important sub-field of the multi-agent reinforcement learning ( MARL ) , where the agents learn to coordinate to achieve joint success . It has wide applications in traffic control ( Kuyer et al. , 2008 ) , autonomous driving ( Shalev-Shwartz et al. , 2016 ) and smart grid ( Yang et al. , 2018 ) . To learn a coordination , the interactions between agents are indispensable . For instance , humans can reason about other ’ s behaviors or know other peoples ’ intentions through communication and then determine an effective coordination plan . However , how to design a mechanism of such interaction in a principled way and at the same time solve the large scale real-world applications is still a challenging problem . Recently , there is a surge of interest in solving the collaborative MARL problem ( Foerster et al. , 2018 ; Qu et al. , 2019 ; Lowe et al. , 2017 ) . Among them , joint policy approaches have demonstrated their superiority ( Rashid et al. , 2018 ; Sunehag et al. , 2018 ; Oliehoek et al. , 2016 ) . A straightforward approach is to replace the action in the single-agent reinforcement learning by the joint action a = ( a1 , a2 , ... , aN ) , while it obviously suffers from the issue of the exponentially large action space . Thus several approaches have been proposed to factorize the joint action space to mitigate such issue , which can be roughly grouped into two categories : • Factorization on policy . This approach explicitly assumes that π ( a|s ) : = ∏N i=1 πi ( ai|s ) , i.e. , policies are independent ( Foerster et al. , 2018 ; Zhang et al. , 2018 ) . To mitigate for the instability issue caused by the independent learner , it generally needs a centralized critic . • Factorization on value function . This approach has a similar spirit but factorizes the joint value function into several utility functions , each just involving the actions of one agent ( Rashid et al. , 2018 ; Sunehag et al. , 2018 ) . However , these two approaches lack of the interactions between agents , since in their algorithms agent i does not care about the plan of agent j . Indeed , they may suffer from a phenomenon called relative over-generalization in game theory observed by Wei & Luke ( 2016 ) ; Castellini et al . ( 2019 ) ; Palmer et al . ( 2018 ) . Approaches based on the coordinate graph would effectively prevent such cases , where the value function is factorized as a summation of utility function on pairwise or local joint action ( Guestrin et al. , 2002 ; Böhmer et al. , 2020 ) . However , they only can be applied in discrete action , small scale game . Furthermore , despite the empirical success of the aforementioned work in certain scenarios , it still lacks theoretical insight . In this work , we only make a simple yet realistic assumption : the reward function ri of each agent i just depends on its individual action and the actions of its neighbors ( and state ) , i.e. , ri ( s , a ) = ri ( s , ai , aNi ) , ( 1 ) where we use Ni to denote the neighbors of agent i , s to denote the global state . It says the goal or decision of agent is explicitly influenced by a small subset Ni of other agents . Note that such an assumption is reasonable in lots of real scenarios . For instance , • The traffic light at an intersection makes the decision on the phase changing mainly relying on the traffic flow around it and the policies of its neighboring traffic light . • The main goal of a defender in a soccer game is to tackle the opponent ’ s attacker , while he rarely needs to pay attention to opponent goalkeeper ’ s strategy . Based on the assumption in equation 1 , we propose a principled multi-agent reinforcement learning algorithm in the framework of probabilistic inference , where the objective is to maximize the long term reward of the group , i.e. , ∑∞ t=0 ∑N i=1 γ trti ( see details in section 4 ) . Note since each agent ’ s reward depends on its neighbor , we still need a joint policy to maximize the global reward through interactions . In this paper , we derive an iterative procedure for such interaction to learn the joint policy in collaborative MARL and name it intention propagation . Particularly , • In the first round , each agent i makes an independent decision and spreads out his plan µ̃i ( we name it intention ) to neighbors . • In the second round , agents i changes its initial intention properly based on its neighbors ’ intention µ̃j , j ∈ Ni and propagates its intention µ̃i again . • In the third round , it changes the decision in the second round with a similar argument . • As this procedure goes on , we show the final output of agents ’ policy converges to the mean field approximation ( the variational inference method from the probabilistic graphical model ( Bishop , 2006 ) ) of the joint policy . In addition , this joint policy has the form of Markov Random Field induced by the locality of the reward function ( proposition 1 ) . Therefore , such a procedure is computationally efficient when the underlying graph is sparse , since in each round , each agent just needs to care about what its neighbors intend to do . Remark : ( 1 ) Our work is not related to the mean-field game ( MFG ) ( Yang et al. , 2018 ) . The goal of the MFG is to find the Nash equilibrium , while our work aims to the optimal joint policy in the collaborative game . Furthermore , MFG generally assumes agents are identical and interchangeable . When the number of agents goes to infinity , MFG can view the state of other agents as a population state distribution . In our problem , we do not have such assumptions . ( 2 ) our analysis is not limited to the mean-field approximation . When we change the message passing structure of intention propagation , we can show that it converges to other approximation of the joint policy , e.g. , loopy belief propagation in variational inference ( Yedidia et al. , 2001 ) ( see Appendix B.2 ) . Contributions : ( 1 ) We propose a principled method named intention propagation to solve the joint policy collaborative MARL problem ; ( 2 ) Our method is computationally efficient , which can scale up to one thousand agents and thus meets the requirement of real applications ; ( 3 ) Empirically , it outperforms state-of-the-art baselines with a wide margin when the number of agents is large ; ( 4 ) Our work builds a bridge between MARL and neural embedded probabilistic inference , which would lead to new algorithms beyond intention propagation . Notation : sti and ati represent the state and action of agent i at time step t. The neighbors of agent i are represented asNi . We denote X as a random variable with domain X and refer to instantiations of X by the lower case character x . We denote a density on X by p ( x ) and denote the space of all such densities as by P . 2 RELATED WORK . We first discuss the work of the factorized approaches on the joint policy . COMA designs a MARL algorithm based on the actor-critic framework with independent actors πi ( ai|s ) , where the joint policy is factorized as π ( a|s ) = ∏N i=1 πi ( ai|s ) ( Foerster et al. , 2018 ) . MADDPG considers a MARL with the cooperative or competitive setting , where it creates a critic for each agent ( Lowe et al. , 2017 ) . Other similar works may include ( de Witt et al. , 2019 ; Wei et al. , 2018 ) . Another way is to factorize the value functions into several utility functions . Sunehag et al . ( 2018 ) assumes that the overall Q function can be factorized as Q ( s , a1 , a2 , .. , aN ) = ∑N i=1Qi ( si , ai ) . QMIX extends this work to include a richer class of function , where it assumes the overall Q function is a monotonic function w.r.t . each Qi ( si , ai ) ( Rashid et al. , 2018 ) . Similarly , Son et al . ( 2019 ) further relax the structure constraint on the joint value function . However these factorized methods suffer from the relative overgeneralization issue ( Castellini et al. , 2019 ; Palmer et al. , 2018 ) . Generally speaking , it pushes the agents to underestimate a certain action because of the low rewards they receive , while they could get a higher one by perfectly coordinating . A middle ground between the ( fully ) joint policy and the factorized policy is the coordination graph ( Guestrin et al. , 2002 ) , where the value function is factorized as a summation of the utility function on the pairwise action . Böhmer et al . ( 2020 ) ; Castellini et al . ( 2019 ) combine deep learning techniques with the coordination graph . It addresses the issue of relative overgeneralization , but still has two limitations especially in the large scale MARL problem . ( 1 ) The max-sum algorithm can just be implemented in the discrete action space since it needs a max-sum operation on the action of Q function . ( 2 ) Even in the discrete action case , each step of the Q learning has to do several loops of max-sum operation over the whole graph if there is a cycle in graph . Our algorithm can handle both discrete and continuous action space cases and alleviate the scalability issue by designing an intention propagation network . Another category of MARL is to consider the communication among agents . The attention mechanism is used to decide when and who to communicate with ( Das et al. , 2018 ) . Foerster et al . ( 2016 ) propose an end-to-end method to learn communication protocol . In ( Liu et al. , 2019 ; Chu et al. , 2020 ) , each agent sends the action information to it neighbors . In addition , Chu et al . ( 2020 ) require a strong assumption that the MDP has the spatial-temporal Markov property . However , they utilizes neighbor ’ s action information in a heuristic way and thus it is unclear what the agents are learning ( e.g. , do they learn the optimal joint policy to maximize the group reward ? ) . Jiang et al . ( 2020 ) propose DGN which uses GNN to spread the state embedding information to neighbors . However each agent still uses an independent Q learning to learn the policy and neglects other agents ’ plans . In contrast , we propose a principled algorithm , where each agent makes decision considering other agents ’ plan . Such procedure can be parameterized by GNN and other neural networks ( see section 4.1 and appendix B.2 ) . We prove its convergence to the solution of variational inference methods . 3 BACKGROUNDS . Probabilistic Reinforcement Learning : Probabilistic reinforcement learning ( PRL ) ( Levine , 2018 ) is our building block . PRL defines the trajectory τ up to time step T as τ = [ s0 , a0 , s1 , a1 , ... , sT , aT , sT+1 ] . The probability distribution of the trajectory τ induced by the optimal policy is defined as p ( τ ) = [ p ( s0 ) ∏T t=0 p ( s t+1|st , at ) ] exp ( ∑T t=0 r ( s t , at ) ) . While the probability of the trajectory τ under the policy π ( a|s ) is defined as p̂ ( τ ) = p ( s0 ) ∏T t=0 p ( s t+1|st , at ) π ( at|st ) . The objective is to minimize the KL divergence between p̂ ( τ ) and p ( τ ) . It is equivalent to the maximum entropy reinforcement learning max π J ( π ) = T∑ t=0 E [ r ( st , at ) +H ( π ( at|st ) ) ] , where it omits the discount factor γ and regularizer factor α of the entropy term , since it is easy to incorporate them into the transition and reward respectively . Notice in this framework the max operator in the Bellman optimality equation would be replaced by the softmax operator and thus its optimal policy is a softmax function related to the Q function ( Haarnoja et al. , 2017 ) . Such framework subsumes state-of-the-art algorithms such as soft-actor-critic ( SAC ) ( Haarnoja et al. , 2018 ) . In each iteration , SAC optimizes the following loss function of Q , π , V , and respectively . E ( st , at ) ∼D [ Q ( st , at ) − r ( st , at ) − γEst+1∼p [ V ( st+1 ) ] ] 2 , Est∼DEat∼π [ log π ( at|st ) −Q ( st , at ) ] Est∼D [ V ( st ) − Eat∼πθ [ Q ( st , at ) − log π ( at|st ) ] ] 2 , where D is the replay buffer . Function Space Embedding of Distribution : In our work , we use the tool of embedding in Reproducing Kernel Hilbert Space ( RKHS ) to design an intention propagation procedure ( Smola et al. , 2007 ) . We let φ ( X ) be an implicit feature mapping and X be a random variable with distribution p ( x ) . Embeddings of p ( x ) is given by µX : = EX [ φ ( X ) ] = ∫ φ ( x ) p ( x ) dx where the distribution is mapped to its expected feature map . By assuming that there exists a feature space such that the embeddings are injective , we can treat the embedding µX of the density p ( x ) as a sufficient statistic of the density , i.e. , any information we need from the density is preserved in µX ( Smola et al. , 2007 ) . Such injective assumption generally holds under mild condition ( Sriperumbudur et al. , 2008 ) . This property is important since we can reformulate a functional f : P → R of p ( · ) using the embedding only , i.e. , f ( p ( x ) ) = f̃ ( µX ) . It also can be generalized to the operator case . In particular , applying an operator T : P → Rd to a density can be equivalently carried out using its embedding T ◦ p ( x ) = T̃ ◦ µX , where T̃ : F → Rd is the alternative operator working on the embedding . In practice , µX , f̃ and T̃ have complicated dependence on φ . As such , we approximate them by neural networks , which is known as the neural embedding approach of distribution ( Dai et al. , 2016 ) . | The paper proposes a scalable approach via intention propagation to learn a multi-agent RL algorithm using communication in a structured environment. An agent encodes its policy and sends the “intention” to the neighboring agents with the assumption that only the closest agents would be the affected by it. The approach involves using techniques from the embedded probabilistic inference literature using mean-field variational inference. The joint-policy is estimated using the mean-field approximation that is obtained via propagating intents in an iterative manner. So this approach helps in avoiding the need to factorize the value function explicitly. | SP:243e8027661d500c99d0e2633726895f32141b9e |
Simple deductive reasoning tests and numerical data sets for exposing limitation of today's deep neural networks | 1 INTRODUCTION . Deductive reasoning is a branch of artificial intelligence where inferences are represented as assertions or facts over data ( Khemani , 2013 ) . Starting with a set of given facts , the system combines facts based on rules to generate newer facts and update the knowledge store . On the other hand machine learning algorithms employ induction based approaches which are predominantly pattern mapping methods ( McClelland et al. , 1986 ) . Fundamentally , in a pipeline of operations , the vectors are arithmetically combined , logically filtered , scaled up or scaled down and mapped to the target vector of interest . A tensor is a more generalization of the vector representation mathematically . However typically even a tensor is internally represented as an array of contiguous storage locations with a data structure indicating dimensions . These tensors undergo a pipeline of transformations minimizing an error function there by mapping a tensor on one side of the pipeline to the tensor on the other side . Deep neural networks have demonstrated their performance almost at the level of human or even better in computer vision and other domains ( Bengio et al. , 2017 ) . Although it is promising to see the success of deep neural networks ( Dargan et al. , 2019 ) ( DNN ) there seems to be a popular belief and false opinion that they are suitable for all types of problems . It is important to note here that problem statements solved by DNNs are of mainly of interpolation in nature where tensors are combined along the pipeline to produce the output tensor . The vanilla DNNs are not directly suitable for deductive reasoning type of problem statements . A knowledge base in a deductive reasoning methodology is a storage for facts which are modified over time . For instance , counting number of ones in a binary representation of the input , the current count is a fact and as the algorithm iterates over input , the count value gets updated . Most of the iterations over input , can be represented in a declarative style as first order logic statements such as prolog ( Bratko , 2001 ) . The weight space representation of a deep neural network is not a convenient formulation to capture the facts , unification and inference mechanism as required by a deductive reasoning methodology . However , earlier version of machine learning formulations required feature engineering which itself accommodates for deductive reasoning in the form of outputs of human crafted programs which are added as features . There are on-going research efforts in this direction on modification of neural network architectures to enable them for performing deduction reasoning . A small step in the direction of storage of past information in data is a recurrent neural network formulation and its several variants ( Mikolov et al. , 2011 ) . Most of the existing works employ a recurrent neural network based formulation and its variations due to the fundamental need of the notion of memory in a deductive reasoning setting . We have tabulated the observations in the form of a Table 1 . Citation Data Processing ( Nangia & Bowman , 2018 ) Input is a string of list operations and elements such as minimum and maximum . Output is the result of list operations . They have released a ListOps data set . TreeLSTM ( Tai et al. , 2015b ) ( Saxton et al. , 2019 ) Input is a stream of sequences of tokens . A specific sequence is defined as a question . The output is again a sequence of tokens corresponding to answer . They have used an RNN based formulation for a question-answer system . ( Wu et al. , 2020 ; Irving et al. , 2016 ; Gauthier et al. , 2020 ; Bansal et al. , 2019 ; Polu & Sutskever , 2020 ; Evans et al. , 2018 ; Lample & Charton , 2019 ) Input is a string of tokens corresponding to a truth statements of a theorem . Output is a string of tokens corresponding to proof for the theorem or identification of top few premises . They have used a variation of RNN formulation . ( Yang & Deng , 2019 ) Input is a string of knowledgebase and theorem . Output is a string of proof statements . They also release CoqGym data set of 71K proofs . A TreeLSTM ( Tai et al. , 2015b ) formulation is used . ( Huang et al. , 2018 ) Input is a string representation of a theorem . Output is estimation of number of steps required to finish and prediction of the next expression . RNN based formulation . ( Piotrowski et al. , 2019 ) Input is a string of tokens corresponding to polynomial coefficients in symbolic form before normalization . Output is a normalized equivalent expression . They have used RNN based formulation . ( Paliwal et al. , 2020 ) Input is a string of tokens corresponding to theorem . Output is a string of tokens corresponding to the first step of the proof . The authors have used Graph Neural Networks ( Zhou et al. , 2018 ) . The symbolic reasoning neural networks ( Table 1 ) obtain the input is a variable length string of tokens and the output is also a variable length string of tokens . Some tokens have special meaning corresponding to syntactic and semantic interpretations such as opening and closing brackets , function call and data . While this problem formulation is more generic in nature , the onus of parsing the input token list rests with the DNN in addition to interpretation and output generation . In a deductive reasoning setting , the concept of memory becomes critical . Some of the deductive reasoning tasks can be easily accomplished by a simple computer program to result in numeric features or truth value statements . However the effect of a free form neural network do the same and without tweaking is far from reach . Basic notion of memory in an RNN formulation is the hidden vector formulation . In order to perform symbolic unification , logical operations and learn a generic function from data , the hidden vector concept is reformulated for a stack or queue of vectors ( Grefenstette et al. , 2015 ) . The Neural Turing Machine ( Graves et al. , 2014 ) includes a controller network and memory network to mimic a Turing machine and attempts to learn generic function that maps input to output from data . In order to learn a generic mapping function from one pattern to another pattern , it is important to see a basic computational model . In ( Figure 1 ) we have indicated a conceptual processor , code and data . A symbolic reasoning network tries to model the three entities simultaneously in the form of weights of the network . A processor has a fixed set of instructions that operate on memory , P = { ( Ij , M ) } ( ∀j ∈ 1 . . . NP ) where NP denotes number of instructions , Ij denotes jth instruction , M denotes a memory location . The data is indicated by , D = { Mk , Vk } ( ∀k ∈ 1 . . . NM ) where NM is the number of locations , Mk is the kth memory location and Vk is the value present at the location . A program or code is indicated by C = { ( ai , bi ) } ( ∀i ∈ 1 . . . NC ) where ai is the instruction and bi is the memory location . We do here some back of the envelope calculations on how many essential vectors need to be captured for instructions , memory value pairs and code . If we assume one hot encoding representation of all instructions , this would require an estimate of NP × NM pairs of instructions . For each of the memory locations , the values are typically floating point numbers or integers with large ranges , the possible numbers of memory-value pairs is an astronomical number NM × |Vk| where |Vk| denotes value range . Each term in a program would correspond to one-hotencoding of NP × NM instruction and memory pairs . The number of programs of length NC that can be generated would be NP ×NMNC . Even for a simple processor having 10 instructions , 10 memory locations and a program of 10 steps , would require exploration of a space of 10010 vectors corresponding to each program . It is not clear today , what is the best way to represent and model the process as it is evident from low accuracies and high errors reported in state of the art symbolic reasoning frameworks . As symbolic processing requires a neural network to learn text parsing and also learn inference from data . There are two moving parts in order to understand low accuracies observed in deductive tasks . In order to specifically identify issue , we have provided numeric data sets that does not require text parsing . It is also important at this stage of the state of the art , to clearly call out limitations of the existing deep neural networks and machine learning formulations on what is and what is not possible in a more specific way . As machine learning systems operate over data sets , the first step in demonstrating what is not possible is via simple data sets for pattern mapping . We have created some very simple data sets where a single engineered feature is sufficient enough to capture the pattern , however deep networks fail to capture the deduction patterns . The data sets are for - ( a ) selection ( 3 data sets ) - minimum , maximum and top 2nd element in an array of numbers ; ( b ) matching ( 3 data sets ) - duplicate detection , counting and histogram learning ; ( c ) divisibility tests ( 2 data sets ) - divisibility of two numbers and divisibility by 3 ; ( d ) representation ( 2 data sets ) - binary representation and parity . We demonstrate that in all of these data sets , the deep neural networks fail with very low accuracies . The efforts in the state of the art for symbolic neural networks mainly include on parsing of the textual input , unification and deduction . These works try to address based on tweaking the architecture of the network for bringing in memory . The RNN based formulation addresses processing part . However , we observe and propose for research there is additional component which is the type of neuron used . In current networks , a single neuron performs only simple arithmetic operations and a comparison against zero as in ReLU . We conjecture here there is scope for innovation in increasing the computational capability of a neuron and ad-hoc connections as proposed in Webster ( 2012 ) . 2 METHODS . In order to present how deductive reasoning is fundamentally different from interpolation based reasoning , we have created ten data sets which are described in this section . Data sets are generated by invoking the algorithm as shown in the ( Table 2 ) . 2.1 DATA SETS FOR SELECTION PROBLEMS . Identification of maximum or minimum element in an array of numbers , requires facts to be recorded in a storage , infer on top of them in the current iteration and update the storage with newer facts . The data set consists of D = ( xi , yi ) tuples i ∈ [ 1 .. N ] where N = 100000 . Each xi ∈ RK is a K dimensional vector where K = 50 in our case and yi contains the value of an element of interest in the array , i.e . yi = max ( xi,1 , . . . , xi , K ) . The data set is generated as shown in the schematic ( Algorithm 1 ) . Algorithm 1 Selection Data Set Generation Algorithm - SEL ( T , N , K ) Require : T , N , K ( ∀i ∈ [ 1 .. N ] ) , ( ∀j ∈ [ 1 .. K ] ) xi , j = RAND ( ) / * RAND ( ) function generates a random number * / / * T : Type of selection , N : Number of elements in data set , K : Dimensionality of each point * / if T is ” max ” then ( ∀i ∈ [ 1 .. N ] ) : yi = max ( xi ) else if T is ” min ” then ( ∀i ∈ [ 1 .. N ] ) : yi = min ( xi ) else if T is ” top 2 ” then ( ∀i ∈ [ 1 .. N ] ) : yi = max ( set ( xi ) − { max ( xi ) } ) end if return ( x , y ) | The paper argues that deductive reasoning is an open problem in current machine learning scenarios where features are learned rather than hand-crafted. To highlight the limitations of current approaches, the paper proposes a benchmark suite of 10 simple tasks (finding the minimum, divisibility test, etc.) that are trivial with some feature engineering, but are shown to be very hard without it. Experiments are performed with random forests, neural networks (MLP?), and recurrent neural networks. | SP:487be1dac03389a08da54338075aa5970f8c3588 |
Simple deductive reasoning tests and numerical data sets for exposing limitation of today's deep neural networks | 1 INTRODUCTION . Deductive reasoning is a branch of artificial intelligence where inferences are represented as assertions or facts over data ( Khemani , 2013 ) . Starting with a set of given facts , the system combines facts based on rules to generate newer facts and update the knowledge store . On the other hand machine learning algorithms employ induction based approaches which are predominantly pattern mapping methods ( McClelland et al. , 1986 ) . Fundamentally , in a pipeline of operations , the vectors are arithmetically combined , logically filtered , scaled up or scaled down and mapped to the target vector of interest . A tensor is a more generalization of the vector representation mathematically . However typically even a tensor is internally represented as an array of contiguous storage locations with a data structure indicating dimensions . These tensors undergo a pipeline of transformations minimizing an error function there by mapping a tensor on one side of the pipeline to the tensor on the other side . Deep neural networks have demonstrated their performance almost at the level of human or even better in computer vision and other domains ( Bengio et al. , 2017 ) . Although it is promising to see the success of deep neural networks ( Dargan et al. , 2019 ) ( DNN ) there seems to be a popular belief and false opinion that they are suitable for all types of problems . It is important to note here that problem statements solved by DNNs are of mainly of interpolation in nature where tensors are combined along the pipeline to produce the output tensor . The vanilla DNNs are not directly suitable for deductive reasoning type of problem statements . A knowledge base in a deductive reasoning methodology is a storage for facts which are modified over time . For instance , counting number of ones in a binary representation of the input , the current count is a fact and as the algorithm iterates over input , the count value gets updated . Most of the iterations over input , can be represented in a declarative style as first order logic statements such as prolog ( Bratko , 2001 ) . The weight space representation of a deep neural network is not a convenient formulation to capture the facts , unification and inference mechanism as required by a deductive reasoning methodology . However , earlier version of machine learning formulations required feature engineering which itself accommodates for deductive reasoning in the form of outputs of human crafted programs which are added as features . There are on-going research efforts in this direction on modification of neural network architectures to enable them for performing deduction reasoning . A small step in the direction of storage of past information in data is a recurrent neural network formulation and its several variants ( Mikolov et al. , 2011 ) . Most of the existing works employ a recurrent neural network based formulation and its variations due to the fundamental need of the notion of memory in a deductive reasoning setting . We have tabulated the observations in the form of a Table 1 . Citation Data Processing ( Nangia & Bowman , 2018 ) Input is a string of list operations and elements such as minimum and maximum . Output is the result of list operations . They have released a ListOps data set . TreeLSTM ( Tai et al. , 2015b ) ( Saxton et al. , 2019 ) Input is a stream of sequences of tokens . A specific sequence is defined as a question . The output is again a sequence of tokens corresponding to answer . They have used an RNN based formulation for a question-answer system . ( Wu et al. , 2020 ; Irving et al. , 2016 ; Gauthier et al. , 2020 ; Bansal et al. , 2019 ; Polu & Sutskever , 2020 ; Evans et al. , 2018 ; Lample & Charton , 2019 ) Input is a string of tokens corresponding to a truth statements of a theorem . Output is a string of tokens corresponding to proof for the theorem or identification of top few premises . They have used a variation of RNN formulation . ( Yang & Deng , 2019 ) Input is a string of knowledgebase and theorem . Output is a string of proof statements . They also release CoqGym data set of 71K proofs . A TreeLSTM ( Tai et al. , 2015b ) formulation is used . ( Huang et al. , 2018 ) Input is a string representation of a theorem . Output is estimation of number of steps required to finish and prediction of the next expression . RNN based formulation . ( Piotrowski et al. , 2019 ) Input is a string of tokens corresponding to polynomial coefficients in symbolic form before normalization . Output is a normalized equivalent expression . They have used RNN based formulation . ( Paliwal et al. , 2020 ) Input is a string of tokens corresponding to theorem . Output is a string of tokens corresponding to the first step of the proof . The authors have used Graph Neural Networks ( Zhou et al. , 2018 ) . The symbolic reasoning neural networks ( Table 1 ) obtain the input is a variable length string of tokens and the output is also a variable length string of tokens . Some tokens have special meaning corresponding to syntactic and semantic interpretations such as opening and closing brackets , function call and data . While this problem formulation is more generic in nature , the onus of parsing the input token list rests with the DNN in addition to interpretation and output generation . In a deductive reasoning setting , the concept of memory becomes critical . Some of the deductive reasoning tasks can be easily accomplished by a simple computer program to result in numeric features or truth value statements . However the effect of a free form neural network do the same and without tweaking is far from reach . Basic notion of memory in an RNN formulation is the hidden vector formulation . In order to perform symbolic unification , logical operations and learn a generic function from data , the hidden vector concept is reformulated for a stack or queue of vectors ( Grefenstette et al. , 2015 ) . The Neural Turing Machine ( Graves et al. , 2014 ) includes a controller network and memory network to mimic a Turing machine and attempts to learn generic function that maps input to output from data . In order to learn a generic mapping function from one pattern to another pattern , it is important to see a basic computational model . In ( Figure 1 ) we have indicated a conceptual processor , code and data . A symbolic reasoning network tries to model the three entities simultaneously in the form of weights of the network . A processor has a fixed set of instructions that operate on memory , P = { ( Ij , M ) } ( ∀j ∈ 1 . . . NP ) where NP denotes number of instructions , Ij denotes jth instruction , M denotes a memory location . The data is indicated by , D = { Mk , Vk } ( ∀k ∈ 1 . . . NM ) where NM is the number of locations , Mk is the kth memory location and Vk is the value present at the location . A program or code is indicated by C = { ( ai , bi ) } ( ∀i ∈ 1 . . . NC ) where ai is the instruction and bi is the memory location . We do here some back of the envelope calculations on how many essential vectors need to be captured for instructions , memory value pairs and code . If we assume one hot encoding representation of all instructions , this would require an estimate of NP × NM pairs of instructions . For each of the memory locations , the values are typically floating point numbers or integers with large ranges , the possible numbers of memory-value pairs is an astronomical number NM × |Vk| where |Vk| denotes value range . Each term in a program would correspond to one-hotencoding of NP × NM instruction and memory pairs . The number of programs of length NC that can be generated would be NP ×NMNC . Even for a simple processor having 10 instructions , 10 memory locations and a program of 10 steps , would require exploration of a space of 10010 vectors corresponding to each program . It is not clear today , what is the best way to represent and model the process as it is evident from low accuracies and high errors reported in state of the art symbolic reasoning frameworks . As symbolic processing requires a neural network to learn text parsing and also learn inference from data . There are two moving parts in order to understand low accuracies observed in deductive tasks . In order to specifically identify issue , we have provided numeric data sets that does not require text parsing . It is also important at this stage of the state of the art , to clearly call out limitations of the existing deep neural networks and machine learning formulations on what is and what is not possible in a more specific way . As machine learning systems operate over data sets , the first step in demonstrating what is not possible is via simple data sets for pattern mapping . We have created some very simple data sets where a single engineered feature is sufficient enough to capture the pattern , however deep networks fail to capture the deduction patterns . The data sets are for - ( a ) selection ( 3 data sets ) - minimum , maximum and top 2nd element in an array of numbers ; ( b ) matching ( 3 data sets ) - duplicate detection , counting and histogram learning ; ( c ) divisibility tests ( 2 data sets ) - divisibility of two numbers and divisibility by 3 ; ( d ) representation ( 2 data sets ) - binary representation and parity . We demonstrate that in all of these data sets , the deep neural networks fail with very low accuracies . The efforts in the state of the art for symbolic neural networks mainly include on parsing of the textual input , unification and deduction . These works try to address based on tweaking the architecture of the network for bringing in memory . The RNN based formulation addresses processing part . However , we observe and propose for research there is additional component which is the type of neuron used . In current networks , a single neuron performs only simple arithmetic operations and a comparison against zero as in ReLU . We conjecture here there is scope for innovation in increasing the computational capability of a neuron and ad-hoc connections as proposed in Webster ( 2012 ) . 2 METHODS . In order to present how deductive reasoning is fundamentally different from interpolation based reasoning , we have created ten data sets which are described in this section . Data sets are generated by invoking the algorithm as shown in the ( Table 2 ) . 2.1 DATA SETS FOR SELECTION PROBLEMS . Identification of maximum or minimum element in an array of numbers , requires facts to be recorded in a storage , infer on top of them in the current iteration and update the storage with newer facts . The data set consists of D = ( xi , yi ) tuples i ∈ [ 1 .. N ] where N = 100000 . Each xi ∈ RK is a K dimensional vector where K = 50 in our case and yi contains the value of an element of interest in the array , i.e . yi = max ( xi,1 , . . . , xi , K ) . The data set is generated as shown in the schematic ( Algorithm 1 ) . Algorithm 1 Selection Data Set Generation Algorithm - SEL ( T , N , K ) Require : T , N , K ( ∀i ∈ [ 1 .. N ] ) , ( ∀j ∈ [ 1 .. K ] ) xi , j = RAND ( ) / * RAND ( ) function generates a random number * / / * T : Type of selection , N : Number of elements in data set , K : Dimensionality of each point * / if T is ” max ” then ( ∀i ∈ [ 1 .. N ] ) : yi = max ( xi ) else if T is ” min ” then ( ∀i ∈ [ 1 .. N ] ) : yi = min ( xi ) else if T is ” top 2 ” then ( ∀i ∈ [ 1 .. N ] ) : yi = max ( set ( xi ) − { max ( xi ) } ) end if return ( x , y ) | This paper's contribution is introducing a set of tasks and datasets that require deductive approaches as opposed to common induction-based models. The paper tackles an important and interesting problem that helps to shape the future of the neuro-symbolic research area. My main concern however is, the paper ignores and does not cover the current state-of-the-art techniques and their corresponding datasets and by just introducing some datasets fail to give a correct image of the current efforts in this area. For example, the variation of Neural Turing Machine and Memory Networks has been successfully applied to the sorting problem (which has been proposed as one of the tasks of interest in deductive reasoning in this paper as well) [1], however, the authors have not discussed these class of networks at all. In fact, the authors mention the gap in the current models by talking about the need for models that can store the facts and the intermediate results for being able to conduct deductive reasoning but do not talk about the role and shortcomings of Memory Networks and Neural Turing based models or Neural | SP:487be1dac03389a08da54338075aa5970f8c3588 |
Growing Efficient Deep Networks by Structured Continuous Sparsification | 1 INTRODUCTION . Deep neural networks are the dominant approach to a variety of machine learning tasks , including image classification ( Krizhevsky et al. , 2012 ; Simonyan & Zisserman , 2015 ) , object detection ( Girshick , 2015 ; Liu et al. , 2016 ) , semantic segmentation ( Long et al. , 2015 ; Chen et al. , 2017 ) and language modeling ( Zaremba et al. , 2014 ; Vaswani et al. , 2017 ; Devlin et al. , 2019 ) . Modern neural networks are overparameterized and training larger networks usually yields improved generalization accuracy . Recent work ( He et al. , 2016 ; Zagoruyko & Komodakis , 2016 ; Huang et al. , 2017 ) illustrates this trend through increasing depth and width of convolutional neural networks ( CNNs ) . Yet , training is compute-intensive , and real-world deployments are often limited by parameter and compute budgets . Neural architecture search ( NAS ) ( Zoph & Le , 2017 ; Liu et al. , 2019 ; Luo et al. , 2018 ; Pham et al. , 2018 ; Savarese & Maire , 2019 ) and model pruning ( Han et al. , 2016 ; 2015 ; Guo et al. , 2016 ) methods aim to reduce these burdens . NAS addresses an issue that further compounds training cost : the enormous space of possible network architectures . While hand-tuning architectural details , such as the connection structure of convolutional layers , can improve performance ( Iandola et al. , 2016 ; Sifre & Mallat , 2014 ; Chollet , 2017 ; Howard et al. , 2017 ; Zhang et al. , 2018 ; Huang et al. , 2018 ) , a principled way of deriving such designs remains elusive . NAS methods aim to automate exploration of possible architectures , producing an efficient design for a target task under practical resource constraints . However , during training , most NAS methods operate on a large supernet architecture , which encompasses candidate components beyond those that are eventually selected for inclusion in the resulting network ( Zoph & Le , 2017 ; Liu et al. , 2019 ; Luo et al. , 2018 ; Pham et al. , 2018 ; Savarese & Maire , 2019 ) . Consequently , NAS-based training may typically be more thorough , but more computationally expensive , than training a single hand-designed architecture . Model pruning techniques similarly focus on improving the resource efficiency of neural networks during inference , at the possible expense of increased training cost . Common strategies aim to generate a lighter version of a given network architecture by removing individual weights ( Han et al. , 2015 ; 2016 ; Molchanov et al. , 2017 ) or structured parameter sets ( Li et al. , 2017 ; He et al. , 2018 ; Luo et al. , 2017 ) . However , the majority of these methods train a full-sized model prior to pruning and , Level 1 : Channel-wise Training Epochs T=0,1,2… Level 2 : Layer-w ise … ( a ) Growing CNN Layers and Filters Training Epochs FL O Ps Our Method Pruning Architecture Search ( b ) Epoch-wise Training Cost NAS Pruning Ours FL O Ps ( c ) Total Training Cost Figure 1 : Growing Networks during Training . We define an architecture configuration space and simultaneously adapt network structure and weights . ( a ) Applying our approach to CNNs , we maintain auxiliary variables that determine how to grow and prune both filters ( i.e . channel-wise ) and layers , subject to practical resource constraints . ( b ) By starting with a small network and growing its size , we utilize fewer resources in early training epochs , compared to pruning or NAS methods . ( c ) Consequently , our method significantly reduces the total computational cost of training , while delivering trained networks of comparable or better size and accuracy . after pruning , utilize additional fine-tuning phases in order to maintain accuracy . Hubara et al . ( 2016 ) and Rastegari et al . ( 2016 ) propose the use of binary weights and activations , allowing inference to benefit from reduced storage costs and efficient computation through bit-counting operations . Yet , training still involves tracking high-precision weights alongside lower-precision approximations . We take a unified view of pruning and architecture search , regarding both as acting on a configuration space , and propose a method to dynamically grow deep networks by continuously reconfiguring their architecture during training . Our approach not only produces models with efficient inference characteristics , but also reduces the computational cost of training ; see Figure 1 . Rather than starting with a full-sized network or a supernet , we start from simple seed networks and progressively adjust ( grown and prune ) them . Specifically , we parameterize an architectural configuration space with indicator variables governing addition or removal of structural components . Figure 2 ( a ) shows an example , in the form of a two-level configuration space for CNN layers and filters . We enable learning of indicator values ( and thereby , architectural structure ) via combining a continuous relaxation with binary sampling , as illustrated in Figure 2 ( b ) . A per-component temperature parameter ensures that long-lived structures are eventually baked into the network ’ s discrete architectural configuration . While the recently proposed AutoGrow ( Wen et al. , 2020 ) also seeks to grow networks over the course of training , our technical approach differs substantially and leads to significant practical advantages . At a technical level , AutoGrow implements an architecture search procedure over a predefined modular structure , subject to hand-crafted , accuracy-driven growing and stopping policies . In contrast , we parameterize architectural configurations and utilize stochastic gradient descent to learn the auxiliary variables that specify structural components , while simultaneously training the weights within those components . Our unique technical approach yields the following advantages : • Fast Training by Growing : Training is a unified procedure , from which one can request a network structure and associated weights at any time . Unlike AutoGrow and the majority of pruning techniques , fine-tuning to optimize weights in a discovered architecture is optional . We achieve excellent results even without any fine-tuning stage . • Principled Approach via Learning by Continuation + Sampling : We formulate our approach in the spirit of learning by continuation methods , which relax a discrete optimization problem to an increasingly stiff continuous approximation . Critically , we introduce an additional sampling step to this strategy . From this combination , we gain the flexibility of exploring a supernet architecture , but the computational efficiency of only actually training a much smaller active subnetwork . • Budget-Aware Optimization Objectives : The parameters governing our architectural configuration are themselves updated via gradient decent . We have flexibility to formulate a variety of resource-sensitive losses , such as counting total FLOPs , in terms of these parameters . • Broad Applicability : Though we use progressive growth of CNNs in width and depth as a motivating example , our technique applies to virtually any neural architecture . One has flexibility in how to parameterize the architecture configuration space . We also show results with LSTMs . We demonstrate these advantages while comparing to recent NAS and pruning methods through extensive experiments on classification , semantic segmentation , and word-level language modeling . 2 RELATED WORK . Network Pruning . Pruning methods can be split into two groups : those pruning individual weights and those pruning structured components . Individual weight-based pruning methods vary on the removal criteria . For example , Han et al . ( 2015 ) propose to prune network weights with small magnitude , and subsequently quantize those remaining ( Han et al. , 2016 ) . Louizos et al . ( 2018 ) learn sparse networks by approximating ` 0-regularization with a stochastic reparameterization . However , sparse weights alone often only lead to speedups on dedicated hardware with supporting libraries . In structured methods , pruning is applied at the level of neurons , channels , or even layers . For example , L1-pruning ( Li et al. , 2017 ) removes channels based on the norm of their filters . He et al . ( 2018 ) use group sparsity to smooth the pruning process after training . MorphNet ( Gordon et al. , 2018 ) regularizes weights towards zero until they are small enough such that the corresponding output channels are marked for removal from the network . Intrinsic Structured Sparsity ( ISS ) ( Wen et al. , 2018 ) works on LSTMs ( Hochreiter & Schmidhuber , 1997 ) by collectively removing the columns and rows of the weight matrices via group LASSO . Although structured pruning methods and our algorithm share the same spirit of generating efficient models , we gain training cost savings by growing networks from small initial architectures instead of pruning full-sized ones . Neural Architecture Search . NAS methods have greatly improved the performance achieved by small network models . Pioneering NAS approaches use reinforcement learning ( Zoph et al. , 2018 ; Zoph & Le , 2017 ) and genetic algorithms ( Real et al. , 2019 ; Xie & Yuille , 2017 ) to search for transferable network blocks whose performance surpasses many manually designed ones . However , such approaches require massive computation during the search — typically thousands of GPU days . To reduce computational cost , recent efforts utilize more efficient search techniques , such as direct gradient-based optimization ( Liu et al. , 2019 ; Luo et al. , 2018 ; Pham et al. , 2018 ; Tan et al. , 2019 ; Cai et al. , 2019 ; Wortsman et al. , 2019 ) . Nevertheless , most NAS methods perform search in a supernet space which requires more computation than training typically-sized architectures . Network Growing . Network Morphism ( Wei et al. , 2016 ) searches for efficient deep networks by extending layers while preserving the parameters . Recently proposed Autogrow ( Wen et al. , 2020 ) takes an AutoML approach to growing layers . These methods either require a specially-crafted policy to stop growth ( e.g. , after a fixed number of layers ) or rely on evaluating accuracy during training , incurring significant additional computational cost . Learning by Continuation . Continuation methods are commonly used to approximate intractable optimization problems by gradually increasing the difficulty of the underlying objective , for example by adopting gradual relaxations to binary problems . Wu et al . ( 2019 ) ; Xie et al . ( 2019b ; 2020 ) use gumbel-softmax ( Jang et al. , 2017 ) to back-propagate errors during architecture search and spatial feature sparsification . Savarese et al . ( 2020 ) propose continuous sparsification to speed up pruning and ticket search ( Frankle & Carbin , 2019 ) . Despite the success of continuation methods in producing sparse networks upon the completion of training , they do not operate on sparse networks during training and instead work with a real-valued relaxation . Postponing actual elimination of near zeroed-out components prevents naive application of these methods from reducing training costs . 3 METHOD . 3.1 ARCHITECTURAL CONFIGURATION SPACE . A network topology can be seen as a directed acyclic graph consisting of an ordered sequence of nodes . Each node x ( i ) in is an input feature and each edge is a computation cell with structured hyperparameters ( e.g. , filter and layer numbers in convolutional networks ) . An architectural configuration space can be parameterized by associating a mask variable m ∈ { 0 , 1 } with each computation cell ( edge ) , which enables training-time pruning ( m = 1→ 0 ) and growing ( m = 0→ 1 ) dynamics . As a running example , we consider a two-level configuration space for CNN architectures , depicted in Figure 2 ( a ) , that enables dynamically growing networks in both width ( channel-wise ) and depth ( layer-wise ) . Alternative configuration spaces are possible ; we defer to the Appendix details on how we parameterize the design of LSTM architectures . CNN Channel Configuration Space : For a convolutional layer with lin input channels , lout output channels ( filters ) and k × k sized kernels , the i-th output feature is computed based on the i-th filter , i.e . for i ∈ { 1 , . . . , lout } : x ( i ) out = f ( xin , F ( i ) ·m ( i ) c ) , ( 1 ) wherem ( i ) c ∈ { 0 , 1 } is a binary parameter that removes the i-th output channel when set to zero and f denotes the convolutional operation . m ( i ) c is shared across a filter and broadcasts to the same shape as the filter tensor F ( i ) , enabling growing/pruning of the entire filter . As Figure 2 ( a ) ( top ) shows , we start from a slim channel configuration . We then query the indicator variables and perform state transitions : ( 1 ) When flipping an indicator variable from 0 to 1 for the first time , we grow a randomly initialized filter and concatenate it to the network . ( 2 ) If an indicator flips from 1 to 0 , we temporarily detach the corresponding filter from the computational graph ; it will be grown back to the its original position if its indicator flips back to 1 , or otherwise be permanently pruned at the end of training . ( 3 ) For other cases , the corresponding filters either survive and continue training or remain detached pending the next query to their indicators . Our method automates architecture evolution , provided we can train the indicators . CNN Layer Configuration Space : To grow network depth , we design a layer configuration space in which an initial shallow network will progressively expand into a deep trained model , as shown in Figure 2 ( a ) ( bottom ) . Similar to channel configuration space , where filters serve as basic structural units , we require a unified formulation to support the growing of popular networks with shortcut connections ( e.g. , ResNets ) and without ( e.g. , VGG-like plain nets ) . We first introduce an abstract layer class flayer as a basic structural unit , which operates on input features xin and generates output features xout . flayer can be instantiated as convolutional layers for plain nets or residual blocks for ResNets , respectively . We define the layer configuration space as : xout = g ( xin ; flayer ·m ( j ) l ) = { flayer ( xin ) , if m ( j ) l = 1 xin , if m ( j ) l = 0 , ( 2 ) where m ( j ) l ∈ { 0 , 1 } is the binary indicator for j-th layer flayer , with which we perform state transitions analogous to the channel configuration space . Layer indicators have priority over channel indicators : if m ( j ) l is set as 0 , all filters contained in the corresponding layer will be detached , regardless of the state their indicators . We do not detach layers that perform changes in resolution ( e.g. , strided convolution ) . | This paper proposes a novel NAS method that searches the model architectures by grows the networks. This searching strategy determines the channel and layer configurations by assigning a binary learnable parameter m for each channel or layer. The objective is to optimize a trade-off between the model performance on the given task and the regularization on the binary indicator m. | SP:01d9dfdff7250ca7703a05aa98105d0307f3d899 |
Growing Efficient Deep Networks by Structured Continuous Sparsification | 1 INTRODUCTION . Deep neural networks are the dominant approach to a variety of machine learning tasks , including image classification ( Krizhevsky et al. , 2012 ; Simonyan & Zisserman , 2015 ) , object detection ( Girshick , 2015 ; Liu et al. , 2016 ) , semantic segmentation ( Long et al. , 2015 ; Chen et al. , 2017 ) and language modeling ( Zaremba et al. , 2014 ; Vaswani et al. , 2017 ; Devlin et al. , 2019 ) . Modern neural networks are overparameterized and training larger networks usually yields improved generalization accuracy . Recent work ( He et al. , 2016 ; Zagoruyko & Komodakis , 2016 ; Huang et al. , 2017 ) illustrates this trend through increasing depth and width of convolutional neural networks ( CNNs ) . Yet , training is compute-intensive , and real-world deployments are often limited by parameter and compute budgets . Neural architecture search ( NAS ) ( Zoph & Le , 2017 ; Liu et al. , 2019 ; Luo et al. , 2018 ; Pham et al. , 2018 ; Savarese & Maire , 2019 ) and model pruning ( Han et al. , 2016 ; 2015 ; Guo et al. , 2016 ) methods aim to reduce these burdens . NAS addresses an issue that further compounds training cost : the enormous space of possible network architectures . While hand-tuning architectural details , such as the connection structure of convolutional layers , can improve performance ( Iandola et al. , 2016 ; Sifre & Mallat , 2014 ; Chollet , 2017 ; Howard et al. , 2017 ; Zhang et al. , 2018 ; Huang et al. , 2018 ) , a principled way of deriving such designs remains elusive . NAS methods aim to automate exploration of possible architectures , producing an efficient design for a target task under practical resource constraints . However , during training , most NAS methods operate on a large supernet architecture , which encompasses candidate components beyond those that are eventually selected for inclusion in the resulting network ( Zoph & Le , 2017 ; Liu et al. , 2019 ; Luo et al. , 2018 ; Pham et al. , 2018 ; Savarese & Maire , 2019 ) . Consequently , NAS-based training may typically be more thorough , but more computationally expensive , than training a single hand-designed architecture . Model pruning techniques similarly focus on improving the resource efficiency of neural networks during inference , at the possible expense of increased training cost . Common strategies aim to generate a lighter version of a given network architecture by removing individual weights ( Han et al. , 2015 ; 2016 ; Molchanov et al. , 2017 ) or structured parameter sets ( Li et al. , 2017 ; He et al. , 2018 ; Luo et al. , 2017 ) . However , the majority of these methods train a full-sized model prior to pruning and , Level 1 : Channel-wise Training Epochs T=0,1,2… Level 2 : Layer-w ise … ( a ) Growing CNN Layers and Filters Training Epochs FL O Ps Our Method Pruning Architecture Search ( b ) Epoch-wise Training Cost NAS Pruning Ours FL O Ps ( c ) Total Training Cost Figure 1 : Growing Networks during Training . We define an architecture configuration space and simultaneously adapt network structure and weights . ( a ) Applying our approach to CNNs , we maintain auxiliary variables that determine how to grow and prune both filters ( i.e . channel-wise ) and layers , subject to practical resource constraints . ( b ) By starting with a small network and growing its size , we utilize fewer resources in early training epochs , compared to pruning or NAS methods . ( c ) Consequently , our method significantly reduces the total computational cost of training , while delivering trained networks of comparable or better size and accuracy . after pruning , utilize additional fine-tuning phases in order to maintain accuracy . Hubara et al . ( 2016 ) and Rastegari et al . ( 2016 ) propose the use of binary weights and activations , allowing inference to benefit from reduced storage costs and efficient computation through bit-counting operations . Yet , training still involves tracking high-precision weights alongside lower-precision approximations . We take a unified view of pruning and architecture search , regarding both as acting on a configuration space , and propose a method to dynamically grow deep networks by continuously reconfiguring their architecture during training . Our approach not only produces models with efficient inference characteristics , but also reduces the computational cost of training ; see Figure 1 . Rather than starting with a full-sized network or a supernet , we start from simple seed networks and progressively adjust ( grown and prune ) them . Specifically , we parameterize an architectural configuration space with indicator variables governing addition or removal of structural components . Figure 2 ( a ) shows an example , in the form of a two-level configuration space for CNN layers and filters . We enable learning of indicator values ( and thereby , architectural structure ) via combining a continuous relaxation with binary sampling , as illustrated in Figure 2 ( b ) . A per-component temperature parameter ensures that long-lived structures are eventually baked into the network ’ s discrete architectural configuration . While the recently proposed AutoGrow ( Wen et al. , 2020 ) also seeks to grow networks over the course of training , our technical approach differs substantially and leads to significant practical advantages . At a technical level , AutoGrow implements an architecture search procedure over a predefined modular structure , subject to hand-crafted , accuracy-driven growing and stopping policies . In contrast , we parameterize architectural configurations and utilize stochastic gradient descent to learn the auxiliary variables that specify structural components , while simultaneously training the weights within those components . Our unique technical approach yields the following advantages : • Fast Training by Growing : Training is a unified procedure , from which one can request a network structure and associated weights at any time . Unlike AutoGrow and the majority of pruning techniques , fine-tuning to optimize weights in a discovered architecture is optional . We achieve excellent results even without any fine-tuning stage . • Principled Approach via Learning by Continuation + Sampling : We formulate our approach in the spirit of learning by continuation methods , which relax a discrete optimization problem to an increasingly stiff continuous approximation . Critically , we introduce an additional sampling step to this strategy . From this combination , we gain the flexibility of exploring a supernet architecture , but the computational efficiency of only actually training a much smaller active subnetwork . • Budget-Aware Optimization Objectives : The parameters governing our architectural configuration are themselves updated via gradient decent . We have flexibility to formulate a variety of resource-sensitive losses , such as counting total FLOPs , in terms of these parameters . • Broad Applicability : Though we use progressive growth of CNNs in width and depth as a motivating example , our technique applies to virtually any neural architecture . One has flexibility in how to parameterize the architecture configuration space . We also show results with LSTMs . We demonstrate these advantages while comparing to recent NAS and pruning methods through extensive experiments on classification , semantic segmentation , and word-level language modeling . 2 RELATED WORK . Network Pruning . Pruning methods can be split into two groups : those pruning individual weights and those pruning structured components . Individual weight-based pruning methods vary on the removal criteria . For example , Han et al . ( 2015 ) propose to prune network weights with small magnitude , and subsequently quantize those remaining ( Han et al. , 2016 ) . Louizos et al . ( 2018 ) learn sparse networks by approximating ` 0-regularization with a stochastic reparameterization . However , sparse weights alone often only lead to speedups on dedicated hardware with supporting libraries . In structured methods , pruning is applied at the level of neurons , channels , or even layers . For example , L1-pruning ( Li et al. , 2017 ) removes channels based on the norm of their filters . He et al . ( 2018 ) use group sparsity to smooth the pruning process after training . MorphNet ( Gordon et al. , 2018 ) regularizes weights towards zero until they are small enough such that the corresponding output channels are marked for removal from the network . Intrinsic Structured Sparsity ( ISS ) ( Wen et al. , 2018 ) works on LSTMs ( Hochreiter & Schmidhuber , 1997 ) by collectively removing the columns and rows of the weight matrices via group LASSO . Although structured pruning methods and our algorithm share the same spirit of generating efficient models , we gain training cost savings by growing networks from small initial architectures instead of pruning full-sized ones . Neural Architecture Search . NAS methods have greatly improved the performance achieved by small network models . Pioneering NAS approaches use reinforcement learning ( Zoph et al. , 2018 ; Zoph & Le , 2017 ) and genetic algorithms ( Real et al. , 2019 ; Xie & Yuille , 2017 ) to search for transferable network blocks whose performance surpasses many manually designed ones . However , such approaches require massive computation during the search — typically thousands of GPU days . To reduce computational cost , recent efforts utilize more efficient search techniques , such as direct gradient-based optimization ( Liu et al. , 2019 ; Luo et al. , 2018 ; Pham et al. , 2018 ; Tan et al. , 2019 ; Cai et al. , 2019 ; Wortsman et al. , 2019 ) . Nevertheless , most NAS methods perform search in a supernet space which requires more computation than training typically-sized architectures . Network Growing . Network Morphism ( Wei et al. , 2016 ) searches for efficient deep networks by extending layers while preserving the parameters . Recently proposed Autogrow ( Wen et al. , 2020 ) takes an AutoML approach to growing layers . These methods either require a specially-crafted policy to stop growth ( e.g. , after a fixed number of layers ) or rely on evaluating accuracy during training , incurring significant additional computational cost . Learning by Continuation . Continuation methods are commonly used to approximate intractable optimization problems by gradually increasing the difficulty of the underlying objective , for example by adopting gradual relaxations to binary problems . Wu et al . ( 2019 ) ; Xie et al . ( 2019b ; 2020 ) use gumbel-softmax ( Jang et al. , 2017 ) to back-propagate errors during architecture search and spatial feature sparsification . Savarese et al . ( 2020 ) propose continuous sparsification to speed up pruning and ticket search ( Frankle & Carbin , 2019 ) . Despite the success of continuation methods in producing sparse networks upon the completion of training , they do not operate on sparse networks during training and instead work with a real-valued relaxation . Postponing actual elimination of near zeroed-out components prevents naive application of these methods from reducing training costs . 3 METHOD . 3.1 ARCHITECTURAL CONFIGURATION SPACE . A network topology can be seen as a directed acyclic graph consisting of an ordered sequence of nodes . Each node x ( i ) in is an input feature and each edge is a computation cell with structured hyperparameters ( e.g. , filter and layer numbers in convolutional networks ) . An architectural configuration space can be parameterized by associating a mask variable m ∈ { 0 , 1 } with each computation cell ( edge ) , which enables training-time pruning ( m = 1→ 0 ) and growing ( m = 0→ 1 ) dynamics . As a running example , we consider a two-level configuration space for CNN architectures , depicted in Figure 2 ( a ) , that enables dynamically growing networks in both width ( channel-wise ) and depth ( layer-wise ) . Alternative configuration spaces are possible ; we defer to the Appendix details on how we parameterize the design of LSTM architectures . CNN Channel Configuration Space : For a convolutional layer with lin input channels , lout output channels ( filters ) and k × k sized kernels , the i-th output feature is computed based on the i-th filter , i.e . for i ∈ { 1 , . . . , lout } : x ( i ) out = f ( xin , F ( i ) ·m ( i ) c ) , ( 1 ) wherem ( i ) c ∈ { 0 , 1 } is a binary parameter that removes the i-th output channel when set to zero and f denotes the convolutional operation . m ( i ) c is shared across a filter and broadcasts to the same shape as the filter tensor F ( i ) , enabling growing/pruning of the entire filter . As Figure 2 ( a ) ( top ) shows , we start from a slim channel configuration . We then query the indicator variables and perform state transitions : ( 1 ) When flipping an indicator variable from 0 to 1 for the first time , we grow a randomly initialized filter and concatenate it to the network . ( 2 ) If an indicator flips from 1 to 0 , we temporarily detach the corresponding filter from the computational graph ; it will be grown back to the its original position if its indicator flips back to 1 , or otherwise be permanently pruned at the end of training . ( 3 ) For other cases , the corresponding filters either survive and continue training or remain detached pending the next query to their indicators . Our method automates architecture evolution , provided we can train the indicators . CNN Layer Configuration Space : To grow network depth , we design a layer configuration space in which an initial shallow network will progressively expand into a deep trained model , as shown in Figure 2 ( a ) ( bottom ) . Similar to channel configuration space , where filters serve as basic structural units , we require a unified formulation to support the growing of popular networks with shortcut connections ( e.g. , ResNets ) and without ( e.g. , VGG-like plain nets ) . We first introduce an abstract layer class flayer as a basic structural unit , which operates on input features xin and generates output features xout . flayer can be instantiated as convolutional layers for plain nets or residual blocks for ResNets , respectively . We define the layer configuration space as : xout = g ( xin ; flayer ·m ( j ) l ) = { flayer ( xin ) , if m ( j ) l = 1 xin , if m ( j ) l = 0 , ( 2 ) where m ( j ) l ∈ { 0 , 1 } is the binary indicator for j-th layer flayer , with which we perform state transitions analogous to the channel configuration space . Layer indicators have priority over channel indicators : if m ( j ) l is set as 0 , all filters contained in the corresponding layer will be detached , regardless of the state their indicators . We do not detach layers that perform changes in resolution ( e.g. , strided convolution ) . | This paper proposes a new principled approach to growing deep network architectures based on continuous relaxation of discrete structure optimization combined with a sparse subnetwork sampling scheme. It starts from a simple seed architecture and dynamically grows/prunes both the layers and filters during training. Through extensive experiments, the authors show that this method produces more efficient networks while reducing the computational cost of training, still maintaining good validation accuracy, compared to other NAS or pruning/growing methods. | SP:01d9dfdff7250ca7703a05aa98105d0307f3d899 |
Learning and Evaluating Representations for Deep One-Class Classification | 1 INTRODUCTION . One-class classification aims to identify if an example belongs to the same distribution as the training data . There are several applications of one-class classification , such as anomaly detection or outlier detection , where we learn a classifier that distinguishes the anomaly/outlier data without access to them from the normal/inlier data accessible at training . This problem is common in various domains , such as manufacturing defect detection , financial fraud detection , etc . Generative models , such as kernel density estimation ( KDE ) , is popular for one-class classification [ 1 , 2 ] as they model the distribution by assigning high density to the training data . At test time , low density examples are determined as outliers . Unfortunately , the curse of dimensionality hinders accurate density estimation in high dimensions [ 3 ] . Deep generative models ( e.g . [ 4 , 5 , 6 ] ) , have demonstrated success in modeling high-dimensional data ( e.g. , images ) and have been applied to anomaly detection [ 7 , 8 , 9 , 10 , 11 ] . However , learning deep generative models on raw inputs remains as challenging as they appear to assign high density to background pixels [ 10 ] or learn local pixel correlations [ 12 ] . A good representation might still be beneficial to those models . Alternately , discriminative models like one-class SVM ( OC-SVM ) [ 13 ] or support vector data description ( SVDD ) [ 14 ] learn classifiers describing the support of one-class distributions to distinguish them from outliers . These methods are powerful when being with non-linear kernels . However , its performance is still limited by the quality of input data representations . In either generative or discriminative approaches , the fundamental limitation of one-class classification centers on learning good high-level data representations . Following the success of deep learning [ 15 ] , deep one-class classifications [ 16 , 17 , 18 ] , which extend the discriminative one-class classification using trainable deep neural networks , have shown promising results compared to their kernel counterparts . However , a naive training of deep one-class classifiers leads to a degenerate solution that maps all data into a single representation , also known as “ hypersphere collapse ” [ 16 ] . Previous works circumvent such issues by constraining network architectures [ 16 ] , autoencoder ∗Equal contribution . pretraining [ 16 , 17 ] , surrogate multi-class classification on simulated outliers [ 19 , 20 , 21 , 22 ] or injecting noise [ 18 ] . In this work , we present a two-stage framework for building deep one-class classifiers . As shown in Figure 1 , in the first stage , we train a deep neural network to obtain a high-level data representation . In the second stage , we build a one-class classifier , such as OC-SVM or KDE , using representations from the first stage . Comparing to using surrogate losses [ 20 , 21 ] , our framework allows to build a classifier that is more faithful to one-class classification . Decoupling representation learning from classifier construction further opens up opportunities of using state-of-the-art representation learning methods , such as self-supervised contrastive learning [ 23 ] . While vanilla contrastive representations are less compatible with one-class classification as they are uniformly distributed on the hypersphere [ 24 ] , we show that , with proper fixes , it provides representations achieving competitive one-class classification performance to previous state-of-the-arts . Furthermore , we propose a distribution-augmented contrastive learning , a novel variant of contrastive learning with distribution augmentation [ 25 ] . This is particularly effective in learning representations for one-class classification , as it reduces the class collision between examples from the same class [ 26 ] and uniformity [ 24 ] . Lastly , although representations are not optimized for one-class classification as in end-to-end trainable deep one-class classifiers [ 16 ] , we demonstrate state-of-the-art performance on visual one-class classification benchmarks . We summarize our contributions as follows : • We present a two-stage framework for building deep one-class classifiers using unsupervised and self-supervised representations followed by shallow one-class classifiers . • We systematically study representation learning methods for one-class classification , including augmentation prediction , contrastive learning , and the proposed distribution-augmented contrastive learning method that extends training data distributions via data augmentation . • We show that , with a good representation , both discriminative ( OC-SVM ) and generative ( KDE ) classifiers , while being competitive with each other , are better than surrogate classifiers based on the simulated outliers [ 20 , 21 ] . • We achieve strong performance on visual one-class classification benchmarks , such as CIFAR10/100 [ 27 ] , Fashion MNIST [ 28 ] , Cat-vs-Dog [ 29 ] , CelebA [ 30 ] , and MVTec AD [ 31 ] . • We extensively study the one-class contrastive learning and the realistic evaluation of anomaly detection under unsupervised and semi-supervised settings . Finally , we present visual explanations of our deep one-class classifiers to better understand their decision making processes . 2 RELATED WORK . One-class classification [ 32 ] has broad applications , including fraud detection [ 33 ] , spam filtering [ 34 ] , medical diagnosis [ 35 ] , manufacturing defect detection [ 31 ] , to name a few . Due to the lack of granular semantic information for one-class data , learning from unlabeled data have been employed for one-class classification . Generative models , which model the density of training data distribution , are able to determine outlier when the sample shows low density [ 8 , 35 , 36 ] . These include simple methods such as kernel density estimation or mixture models [ 37 ] , as well as advanced ones [ 4 , 5 , 6 , 38 , 39 , 40 , 41 ] . However , the density from generative models for high-dimensional data could be misleading [ 9 , 12 , 42 , 43 ] . New detection mechanisms based on the typicality [ 44 ] or likelihood ratios [ 10 ] have been proposed to improve out-of-distribution detection . Self-supervised learning is commonly used for learning representations from unlabeled data by solving proxy tasks , such as jigsaw puzzle [ 45 ] , rotation prediction [ 46 ] , clustering [ 47 ] , instance discrimination [ 48 ] and contrastive learning [ 23 , 49 , 50 ] . The learned representations are then used for multi-class classification , or transfer learning , all of which require labeled data for downstream tasks . They have also been extended to one-class classification . For example , contrastive learning is adopted to improve the out-of-distribution detection under multi-class setting [ 51 ] , whereas our work focuses on learning from a single class of examples , leading to propose a novel distributionaugmented contrastive learning . Notably , learning to predict geometric transformations [ 20 , 21 , 22 ] extends the rotation prediction [ 46 ] to using more geometric transformations as prediction targets . Unlike typical applications of self-supervised learning where the classifier or projection head [ 23 ] are discarded after training , the geometric transformation classifier is used as a surrogate for oneclass classification . As in Section 4.1 , however , the surrogate classifier optimized for the selfsupervised proxy task is suboptimal for one-class classification . We show that replacing it with simple one-class classifiers consistently improve the performance . Furthermore , we propose strategies for better representation learning for both augmentation prediction and contrastive learning . Distribution-augmented contrastive learning is concurrently developed in [ 52 ] as a part of their multi-task ensemble model . While sharing a similar technical formulation , we motivate from fixing the uniformity of contrastive representations . We note that our study not only focuses on representation learning , but also on the importance of detection algorithms , which is under explored before . 3 A TWO-STAGE FRAMEWORK FOR DEEP ONE-CLASS CLASSIFICATION . In Section 3.1 , we review self-supervised representation learning algorithms , discuss how they connect to existing one-class classification methods , raise issues of state-of-the-art contrastive representation learning [ 23 ] for one-class classification , and propose ways to resolve these issues . Then , in Section 3.2 , we study how to leverage the learned representations for one-class classification . 3.1 LEARNING REPRESENTATIONS FOR ONE-CLASS CLASSIFICATION . LetA be the stochastic data augmentation process , which is composed of resize and crop , horizontal flip , color jittering , gray-scale and gaussian blur , following [ 23 ] , for image data . As in Figure 1 , selfsupervised learning methods consist of a feature extractor f parameterized by deep neural networks and the proxy loss L. Optionally , f is further processed with projection head g at training , which is then used to compute the proxy loss . Unless otherwise stated , normalize ( f ) , f/‖f‖2 is used as a representation at test time . Below , we discuss details of self-supervised learning methods . 3.1.1 EXTRACTING RICHER REPRESENTATION BY LEARNING WITH PROJECTION HEAD . While the efficacy of projection head has been confirmed for contrastive learning [ 23 ] or BYOL [ 53 ] , it is not widely adopted for other types of self-supervised learning , including rotation prediction [ 46 ] . On the other hand , Gidaris et al . [ 46 ] show that the lower-layer representation often perform better for downstream tasks as the last layer directly involved in optimizing the proxy loss becomes overly discriminative to the proxy task , while losing useful information of the data . Inspired by these observations , we adopt the projection head for augmentation prediction training as well . As in Figure 1a , we extend the network structure as g ◦ f , where g is the projection head used to compute proxy losses and f outputs representations used for the downstream task . Note that using an identity head g ( x ) =x recovers the network structure of previous works [ 20 , 21 , 46 ] . 3.1.2 AUGMENTATION PREDICTION . One way of representation learning is to learn by discriminating augmentations applied to the data . For example , the rotation prediction [ 46 ] learns deep representations by predicting the degree of rotation augmentations . The training objective of the rotation prediction task is given as follows : Lrot = Ex∼PX , A [ CrossEntropy ( y , pq◦g ( y|rot90 ( A ( x ) , y ) ) ) ] ( 1 ) where y ∈ { 0 , 1 , 2 , 3 } is a prediction target representing the rotation degree , and rot90 ( x , y ) rotates an input x by 90 degree y times . We denote the classifier pq◦g ( y|x ) as pq ( y|g ( x ) ) ∝ exp ( q◦g ( x ) ) [ y ] containing the representation g1 and a linear layer q with 4 output units for rotation degrees . Application to One-Class Classification . Although not trained to do so , the likelihood of learned rotation classifiers2 pq ( y= 0|g ( x ) ) is shown to well approximate the normality score and has been used for one-class classification [ 20 , 21 , 22 ] . A plausible explanation is via outlier exposure [ 19 ] , where the classifier learns a decision boundary distinguishing original images from simulated outliers by image rotation . However , it assumes inlier images are not rotated , and the classifier may not generalize to one-class classification task if it overfits to the proxy rotation prediction task . 3.1.3 CONTRASTIVE LEARNING . Unlike augmentation prediction that learns discriminative representations to data augmentation , contrastive learning [ 23 ] learns representation by distinguishing different views ( e.g. , augmentations ) of itself from other data instances . Let φ ( x ) = normalize ( g ( x ) ) , i.e. , ‖φ ( x ) ‖= 1 . Following [ 54 ] , the proxy task loss of contrastive learning is written as : Lclr = − Ex , xi∼PX , A , A′ [ log exp ( 1τ φ ( A ( x ) ) > φ ( A′ ( x ) ) ) exp ( 1τ φ ( A ( x ) ) > φ ( A′ ( x ) ) ) + ∑M−1 i=1 exp ( 1τ φ ( A ( x ) ) > φ ( A ( xi ) ) ) ] ( 2 ) where A and A′ are identical but independent stochastic augmentation processes for two different views of x. Lclr regularizes representations of the same instance with different views ( A ( x ) , A′ ( x ) ) to be similar , while those of different instances ( A ( x ) , A′ ( x′ ) ) to be unlike . Class Collision and Uniformity for One-Class Classification . While contrastive representations have achieved state-of-the-art performance on visual recognition tasks [ 23 , 24 , 49 , 55 ] and have been theoretically proven to be effective for multi-class classification [ 26 , 56 ] , we argue that it could be problematic for one-class classification . First , a class collision [ 26 ] . The contrastive loss in Eq . ( 2 ) is minimized by maximizing the distance between representations of negative pairs ( x , xi ) , x 6=xi , even though they are from the same class when applied to the one-class classification . This seems to contradict to the idea of deep one-class classification [ 16 ] , which learns representations by minimizing the distance between representations with respect to the center : ming , f Ex‖g ◦ f ( x ) − c‖2 . Second , a uniformity of representations [ 24 ] . It is proved that the optimal solution for the denominator of Eq . ( 2 ) is perfect uniformity asM→∞ [ 24 ] , meaning that φ ( x ) follows a uniform distribution on the hypersphere . This is problematic since one can always find an inlier x∈X in the proximity to any outlier x′ /∈X on the hypersphere , as shown in Figure 2a . In contrast , with reduced uniformity as in Figure 2b , it is easier to isolate outliers from inliers . 1We abuse notation of g not only to denote the projection head , but also the representation g ◦ f ( · ) . 2For presentation clarity , we use the rotation as an example for augmentations . Note that one may use more geometric transformations , such as rotation , translation , or flip of an image , as in [ 20 , 21 , 22 ] . pull pushgg○f One-Class Contrastive Learning . First , to reduce the uniformity of representations , we propose to use a moderateM ( batch size ) . This is in contrast with previous suggestions to train with largeM for contrastive representations to be most effective on multi-class classification tasks [ 23 , 55 , 57 ] . The impact of batch size M for one-class classification will be discussed in Section 5.1 . In addition , we propose distribution augmentation3 for one-class contrastive learning . The idea is that , instead of modeling the training data distribution PX , we model the union of augmented training distribution P⋃ a a ( X ) , where a ( X ) = { a ( x ) |x∈X } . Note that augmentation a for augmenting distribution is disjoint from those for data augmentation A that generates views . Inspired by Golan and El-Yaniv [ 20 ] , we employ geometric transformations , such as rotation or horizontal flip , for distribution augmentation . For example , as in Figure 3 , x and rot90 ( x ) ( German shepherds in the top row ) are considered as two separate instances and therefore are encouraged to be distant in the representation space . Not only increasing the number of data instances to train on ( e.g. , distribution augmentation by rotating 90◦ , 180◦ , 270◦ increases the dataset by 4 times ) , but it also eases the uniformity of representations on the resulted hypersphere . A pictorial example is in Figure 2c , where thanks to augmented distribution , the inlier distribution may become more compact . | This paper proposes an anomaly detection approach that has two stages: a first stage for learning a feature representation and a second stage to train either a one-class classifier based on OC-SVM or KDE. The main contribution of the paper is the feature representation learning that relies on contrastive learning to optimise a self-supervised loss function which minimises the distance of the samples from the same image augmented with different data augmentation functions and maximises the distance of samples from different images augmented with the same augmentation functions. The data augmentation functions used were horizontal flip and rotation (0,90,180,270). Results on the public datasets CIFAR-10, CIFAR-100, Fashion MNIST, and Cat-vs-Dog show that the proposed method has better anomaly detection (measured with AUC) than the state of the art. The paper also displays qualitative anomaly detection results and an ablation study that shows: a) how close to uniform distribution (on hypersphere) the feature representations are as a function of batch size, and b) how AUC is affected with batch size and depth of MLP project heads. | SP:bf144506fc556d0587b7c2a24e1284dcd69f7c26 |
Learning and Evaluating Representations for Deep One-Class Classification | 1 INTRODUCTION . One-class classification aims to identify if an example belongs to the same distribution as the training data . There are several applications of one-class classification , such as anomaly detection or outlier detection , where we learn a classifier that distinguishes the anomaly/outlier data without access to them from the normal/inlier data accessible at training . This problem is common in various domains , such as manufacturing defect detection , financial fraud detection , etc . Generative models , such as kernel density estimation ( KDE ) , is popular for one-class classification [ 1 , 2 ] as they model the distribution by assigning high density to the training data . At test time , low density examples are determined as outliers . Unfortunately , the curse of dimensionality hinders accurate density estimation in high dimensions [ 3 ] . Deep generative models ( e.g . [ 4 , 5 , 6 ] ) , have demonstrated success in modeling high-dimensional data ( e.g. , images ) and have been applied to anomaly detection [ 7 , 8 , 9 , 10 , 11 ] . However , learning deep generative models on raw inputs remains as challenging as they appear to assign high density to background pixels [ 10 ] or learn local pixel correlations [ 12 ] . A good representation might still be beneficial to those models . Alternately , discriminative models like one-class SVM ( OC-SVM ) [ 13 ] or support vector data description ( SVDD ) [ 14 ] learn classifiers describing the support of one-class distributions to distinguish them from outliers . These methods are powerful when being with non-linear kernels . However , its performance is still limited by the quality of input data representations . In either generative or discriminative approaches , the fundamental limitation of one-class classification centers on learning good high-level data representations . Following the success of deep learning [ 15 ] , deep one-class classifications [ 16 , 17 , 18 ] , which extend the discriminative one-class classification using trainable deep neural networks , have shown promising results compared to their kernel counterparts . However , a naive training of deep one-class classifiers leads to a degenerate solution that maps all data into a single representation , also known as “ hypersphere collapse ” [ 16 ] . Previous works circumvent such issues by constraining network architectures [ 16 ] , autoencoder ∗Equal contribution . pretraining [ 16 , 17 ] , surrogate multi-class classification on simulated outliers [ 19 , 20 , 21 , 22 ] or injecting noise [ 18 ] . In this work , we present a two-stage framework for building deep one-class classifiers . As shown in Figure 1 , in the first stage , we train a deep neural network to obtain a high-level data representation . In the second stage , we build a one-class classifier , such as OC-SVM or KDE , using representations from the first stage . Comparing to using surrogate losses [ 20 , 21 ] , our framework allows to build a classifier that is more faithful to one-class classification . Decoupling representation learning from classifier construction further opens up opportunities of using state-of-the-art representation learning methods , such as self-supervised contrastive learning [ 23 ] . While vanilla contrastive representations are less compatible with one-class classification as they are uniformly distributed on the hypersphere [ 24 ] , we show that , with proper fixes , it provides representations achieving competitive one-class classification performance to previous state-of-the-arts . Furthermore , we propose a distribution-augmented contrastive learning , a novel variant of contrastive learning with distribution augmentation [ 25 ] . This is particularly effective in learning representations for one-class classification , as it reduces the class collision between examples from the same class [ 26 ] and uniformity [ 24 ] . Lastly , although representations are not optimized for one-class classification as in end-to-end trainable deep one-class classifiers [ 16 ] , we demonstrate state-of-the-art performance on visual one-class classification benchmarks . We summarize our contributions as follows : • We present a two-stage framework for building deep one-class classifiers using unsupervised and self-supervised representations followed by shallow one-class classifiers . • We systematically study representation learning methods for one-class classification , including augmentation prediction , contrastive learning , and the proposed distribution-augmented contrastive learning method that extends training data distributions via data augmentation . • We show that , with a good representation , both discriminative ( OC-SVM ) and generative ( KDE ) classifiers , while being competitive with each other , are better than surrogate classifiers based on the simulated outliers [ 20 , 21 ] . • We achieve strong performance on visual one-class classification benchmarks , such as CIFAR10/100 [ 27 ] , Fashion MNIST [ 28 ] , Cat-vs-Dog [ 29 ] , CelebA [ 30 ] , and MVTec AD [ 31 ] . • We extensively study the one-class contrastive learning and the realistic evaluation of anomaly detection under unsupervised and semi-supervised settings . Finally , we present visual explanations of our deep one-class classifiers to better understand their decision making processes . 2 RELATED WORK . One-class classification [ 32 ] has broad applications , including fraud detection [ 33 ] , spam filtering [ 34 ] , medical diagnosis [ 35 ] , manufacturing defect detection [ 31 ] , to name a few . Due to the lack of granular semantic information for one-class data , learning from unlabeled data have been employed for one-class classification . Generative models , which model the density of training data distribution , are able to determine outlier when the sample shows low density [ 8 , 35 , 36 ] . These include simple methods such as kernel density estimation or mixture models [ 37 ] , as well as advanced ones [ 4 , 5 , 6 , 38 , 39 , 40 , 41 ] . However , the density from generative models for high-dimensional data could be misleading [ 9 , 12 , 42 , 43 ] . New detection mechanisms based on the typicality [ 44 ] or likelihood ratios [ 10 ] have been proposed to improve out-of-distribution detection . Self-supervised learning is commonly used for learning representations from unlabeled data by solving proxy tasks , such as jigsaw puzzle [ 45 ] , rotation prediction [ 46 ] , clustering [ 47 ] , instance discrimination [ 48 ] and contrastive learning [ 23 , 49 , 50 ] . The learned representations are then used for multi-class classification , or transfer learning , all of which require labeled data for downstream tasks . They have also been extended to one-class classification . For example , contrastive learning is adopted to improve the out-of-distribution detection under multi-class setting [ 51 ] , whereas our work focuses on learning from a single class of examples , leading to propose a novel distributionaugmented contrastive learning . Notably , learning to predict geometric transformations [ 20 , 21 , 22 ] extends the rotation prediction [ 46 ] to using more geometric transformations as prediction targets . Unlike typical applications of self-supervised learning where the classifier or projection head [ 23 ] are discarded after training , the geometric transformation classifier is used as a surrogate for oneclass classification . As in Section 4.1 , however , the surrogate classifier optimized for the selfsupervised proxy task is suboptimal for one-class classification . We show that replacing it with simple one-class classifiers consistently improve the performance . Furthermore , we propose strategies for better representation learning for both augmentation prediction and contrastive learning . Distribution-augmented contrastive learning is concurrently developed in [ 52 ] as a part of their multi-task ensemble model . While sharing a similar technical formulation , we motivate from fixing the uniformity of contrastive representations . We note that our study not only focuses on representation learning , but also on the importance of detection algorithms , which is under explored before . 3 A TWO-STAGE FRAMEWORK FOR DEEP ONE-CLASS CLASSIFICATION . In Section 3.1 , we review self-supervised representation learning algorithms , discuss how they connect to existing one-class classification methods , raise issues of state-of-the-art contrastive representation learning [ 23 ] for one-class classification , and propose ways to resolve these issues . Then , in Section 3.2 , we study how to leverage the learned representations for one-class classification . 3.1 LEARNING REPRESENTATIONS FOR ONE-CLASS CLASSIFICATION . LetA be the stochastic data augmentation process , which is composed of resize and crop , horizontal flip , color jittering , gray-scale and gaussian blur , following [ 23 ] , for image data . As in Figure 1 , selfsupervised learning methods consist of a feature extractor f parameterized by deep neural networks and the proxy loss L. Optionally , f is further processed with projection head g at training , which is then used to compute the proxy loss . Unless otherwise stated , normalize ( f ) , f/‖f‖2 is used as a representation at test time . Below , we discuss details of self-supervised learning methods . 3.1.1 EXTRACTING RICHER REPRESENTATION BY LEARNING WITH PROJECTION HEAD . While the efficacy of projection head has been confirmed for contrastive learning [ 23 ] or BYOL [ 53 ] , it is not widely adopted for other types of self-supervised learning , including rotation prediction [ 46 ] . On the other hand , Gidaris et al . [ 46 ] show that the lower-layer representation often perform better for downstream tasks as the last layer directly involved in optimizing the proxy loss becomes overly discriminative to the proxy task , while losing useful information of the data . Inspired by these observations , we adopt the projection head for augmentation prediction training as well . As in Figure 1a , we extend the network structure as g ◦ f , where g is the projection head used to compute proxy losses and f outputs representations used for the downstream task . Note that using an identity head g ( x ) =x recovers the network structure of previous works [ 20 , 21 , 46 ] . 3.1.2 AUGMENTATION PREDICTION . One way of representation learning is to learn by discriminating augmentations applied to the data . For example , the rotation prediction [ 46 ] learns deep representations by predicting the degree of rotation augmentations . The training objective of the rotation prediction task is given as follows : Lrot = Ex∼PX , A [ CrossEntropy ( y , pq◦g ( y|rot90 ( A ( x ) , y ) ) ) ] ( 1 ) where y ∈ { 0 , 1 , 2 , 3 } is a prediction target representing the rotation degree , and rot90 ( x , y ) rotates an input x by 90 degree y times . We denote the classifier pq◦g ( y|x ) as pq ( y|g ( x ) ) ∝ exp ( q◦g ( x ) ) [ y ] containing the representation g1 and a linear layer q with 4 output units for rotation degrees . Application to One-Class Classification . Although not trained to do so , the likelihood of learned rotation classifiers2 pq ( y= 0|g ( x ) ) is shown to well approximate the normality score and has been used for one-class classification [ 20 , 21 , 22 ] . A plausible explanation is via outlier exposure [ 19 ] , where the classifier learns a decision boundary distinguishing original images from simulated outliers by image rotation . However , it assumes inlier images are not rotated , and the classifier may not generalize to one-class classification task if it overfits to the proxy rotation prediction task . 3.1.3 CONTRASTIVE LEARNING . Unlike augmentation prediction that learns discriminative representations to data augmentation , contrastive learning [ 23 ] learns representation by distinguishing different views ( e.g. , augmentations ) of itself from other data instances . Let φ ( x ) = normalize ( g ( x ) ) , i.e. , ‖φ ( x ) ‖= 1 . Following [ 54 ] , the proxy task loss of contrastive learning is written as : Lclr = − Ex , xi∼PX , A , A′ [ log exp ( 1τ φ ( A ( x ) ) > φ ( A′ ( x ) ) ) exp ( 1τ φ ( A ( x ) ) > φ ( A′ ( x ) ) ) + ∑M−1 i=1 exp ( 1τ φ ( A ( x ) ) > φ ( A ( xi ) ) ) ] ( 2 ) where A and A′ are identical but independent stochastic augmentation processes for two different views of x. Lclr regularizes representations of the same instance with different views ( A ( x ) , A′ ( x ) ) to be similar , while those of different instances ( A ( x ) , A′ ( x′ ) ) to be unlike . Class Collision and Uniformity for One-Class Classification . While contrastive representations have achieved state-of-the-art performance on visual recognition tasks [ 23 , 24 , 49 , 55 ] and have been theoretically proven to be effective for multi-class classification [ 26 , 56 ] , we argue that it could be problematic for one-class classification . First , a class collision [ 26 ] . The contrastive loss in Eq . ( 2 ) is minimized by maximizing the distance between representations of negative pairs ( x , xi ) , x 6=xi , even though they are from the same class when applied to the one-class classification . This seems to contradict to the idea of deep one-class classification [ 16 ] , which learns representations by minimizing the distance between representations with respect to the center : ming , f Ex‖g ◦ f ( x ) − c‖2 . Second , a uniformity of representations [ 24 ] . It is proved that the optimal solution for the denominator of Eq . ( 2 ) is perfect uniformity asM→∞ [ 24 ] , meaning that φ ( x ) follows a uniform distribution on the hypersphere . This is problematic since one can always find an inlier x∈X in the proximity to any outlier x′ /∈X on the hypersphere , as shown in Figure 2a . In contrast , with reduced uniformity as in Figure 2b , it is easier to isolate outliers from inliers . 1We abuse notation of g not only to denote the projection head , but also the representation g ◦ f ( · ) . 2For presentation clarity , we use the rotation as an example for augmentations . Note that one may use more geometric transformations , such as rotation , translation , or flip of an image , as in [ 20 , 21 , 22 ] . pull pushgg○f One-Class Contrastive Learning . First , to reduce the uniformity of representations , we propose to use a moderateM ( batch size ) . This is in contrast with previous suggestions to train with largeM for contrastive representations to be most effective on multi-class classification tasks [ 23 , 55 , 57 ] . The impact of batch size M for one-class classification will be discussed in Section 5.1 . In addition , we propose distribution augmentation3 for one-class contrastive learning . The idea is that , instead of modeling the training data distribution PX , we model the union of augmented training distribution P⋃ a a ( X ) , where a ( X ) = { a ( x ) |x∈X } . Note that augmentation a for augmenting distribution is disjoint from those for data augmentation A that generates views . Inspired by Golan and El-Yaniv [ 20 ] , we employ geometric transformations , such as rotation or horizontal flip , for distribution augmentation . For example , as in Figure 3 , x and rot90 ( x ) ( German shepherds in the top row ) are considered as two separate instances and therefore are encouraged to be distant in the representation space . Not only increasing the number of data instances to train on ( e.g. , distribution augmentation by rotating 90◦ , 180◦ , 270◦ increases the dataset by 4 times ) , but it also eases the uniformity of representations on the resulted hypersphere . A pictorial example is in Figure 2c , where thanks to augmented distribution , the inlier distribution may become more compact . | This paper proposes a framework for deep one-class classification (an example application being anomaly detection). The basic idea is to combine self-supervised representation learning (eg through a proxy task such as rotation prediction or contrastive learning), with a classical approach to one-class classification, such as one-class SVM or KDE. This is in contrast to existing methods for deep one-class classification that use simulated outliers to form a surrogate classification loss and then train end-to-end. The paper further improves on the first stage of representation learning, by introducing modifications to contrastive learning to make it more appropriate for one-class classification. The main insight is to introduce distribution augmentation, where geometric transformations of images, such as rotation, are treated as separate instances, to be separated from the original view. This is motivated from the perspective of reducing uniformity of the inliers across the unit hypersphere, to allow for better separation from outliers. | SP:bf144506fc556d0587b7c2a24e1284dcd69f7c26 |
Robust Multi-Agent Reinforcement Learning Driven by Correlated Equilibrium | 1 INTRODUCTION . Recently , reinforcement learning ( RL ) has achieved remarkable success in many practical sequential decision problems , such as Go ( Silver et al. , 2017 ) , chess ( Silver et al. , 2018 ) , real-time strategy games ( Vinyals et al. , 2019 ) , etc . In real-world , many sequential decision problems involve more than one decision maker ( i.e . multi-agent ) , such as auto-driving , traffic light control and network routing . Cooperative multi-agent reinforcement learning ( CMARL ) is a key framework to solve these practical problems . Existing MARL methods for cooperative environments include policybased methods , e.g . MADDPG ( Lowe et al. , 2017 ) , COMA ( Foerster et al. , 2017 ) , and value-based methods , e.g . VDN ( Sunehag et al. , 2018 ) , QMIX ( Rashid et al. , 2018 ) , QTRAN ( Son et al. , 2019 ) . However , before we actually apply CMARL ’ s policy into real world applications , a question must be asked : are these learned policies safe or robust to be deployed ? What will happen if some agents made mistakes or behaved adversarially against other agents ? It will be most likely that the entire team might fail to achieve their goal or perform extremely poorly . ( Lin et al. , 2020 ) demonstrates the unrobustness in CMARL environment , where a learnt adversarial of one agent can hugely decrease the team ’ s performance . Therefore , in practice , we expect to have a multi-agent team policy in a fully cooperative environment that is robust when some agent ( s ) make some mistakes and even behave adversarially . To the best of knowledge , very few existing works on this issue mainly use vanilla adversarial training strategy . Klima et al . ( 2018 ) considered a two-agent cooperative case , in order to make the policy robust , agents become competitive with a certain probability during training . Li et al . ( 2019 ) provided a robust MADDPG approach called M3DDPG , where each agent optimizes its policy based on other agents ’ influenced sub-optimal actions . Most state-of-the-art MARL algorithms utilize centralized training and decentralized execution ( CTDE ) routine , since this setting is common in real world cases . The robust MARL method M3DDPG also followed the CTDE setting . However , existing works on team mini-max normal form or extensive form games show that if the environment contains an adversarial agent , then the decentralized equilibrium from CTDE routine can be significantly worse than the correlated equilibrium . We furthermore extend this finding into stochastic team mini-max games . Inspired by this important observation , if we can urge agents to learn a correlated equilibrium ( i.e . the non-adversarial agents jointly make the decision when execution ) , then we may achieve better performance than those following CTDE in robust MARL setting . In this work , we achieve the robust MARL via solving correlated equilibrium motivated by the latent variable model , where the introduction of a latent variable across all agents could help agents jointly make their decisions . Our contributions can be summarized as follows . • We demonstrate that in stochastic team mini-max games , the decentralized equilibrium can be arbitrarily worse than correlated one , and the gap can be significantly larger than in normal or extensive form games . • With this result , we point out that learning correlated equilibrium is indeed necessary in robust MARL . • We propose a simple strategy to urge agents to learn correlated equilibrium , and show that this method can yield significant performance improvements over vanilla adversarial training . 2 RELATED WORKS . Robust RL The robustness in RL involves the perturbations occurring in different cases , such as state or observation , environment , action or policy , opponent ’ s policy , etc . 1 ) For the robustness to state or observation perturbation , most works focused on adversarial attacks of image state/observation . Pattanaik et al . ( 2018 ) used gradient-based attack on image state , and vanilla adversarial training was adopted to obtain robust policy ; Fischer et al . ( 2019 ) first trained a normal policy , and distilled it on adversarial states to achieve robustness ; Ferdowsi et al . ( 2018 ) applied adversarial training to autonomous driving tasks that interfered agent ’ s input sensors based on environment , and then conducted adversarial training ; 2 ) For the robustness to environment , robust Markov decision process ( MDP ) could be used to formulate this problem . Many works ( e.g . Wiesemann et al . ( 2013 ) ; Lim et al . ( 2013 ) ) have studied this model and provided both theoretical analysis and algorithmic design . In deep RL scenario , Rajeswaran et al . ( 2016 ) used Monte Carlo approach to train agent , while Abdullah et al . ( 2019 ) ; Hou et al . ( 2020 ) adopted adversarial training to obtain a robust agent to all environments within a Wasserstein ball . Mankowitz et al . ( 2019 ) conducted adversarial training in MPO algorithm to optimize the performance in the worst performance environment . 3 ) To be against the perturbation of action or policy , Tessler et al . ( 2019 ) ; Gu et al . ( 2018 ) ; Vinitsky et al . ( 2020 ) considered the case that agent ’ s action may be influenced by another action , and conducted adversarial training . 4 ) For the robustness to opponent , Pinto et al . ( 2017 ) ; Ma et al . ( 2018 ) focused on the case that agent ’ s reward may be influenced by another agent , and adversarial training was implemented to solve the two-agent game to obtain a robust agent . Correlated Equilibrium Correlated equilibrium is a more general equilibrium in game theory compared to Nash equilibrium . In a cooperative task , if the team agents jointly make decisions together , then the optimal team policy is correlated equilibrium . Correlated equilibrium is widely studied in game theory ( e.g . Hart & Mas-Colell ( 2001 ; 2000 ) ; Neyman ( 1997 ) ) . In team mini-max game , solving the team ’ s correlated equilibrium in normal form game is straightforward ( just treat the team as a single agent ) ; Celli & Gatti ( 2017 ) ; Zhang & An ( 2020 ) ; Farina et al . ( 2018 ) proposed various algorithms to solve correlated equilibrium in extensive formal games . In deep RL scenario , Celli et al . ( 2019 ) applied vanilla hidden variable model to solve correlated equilibrium in simple repetitive environments , while information loss with hidden variable model was used in Chen et al . ( 2019 ) to solve correlated equilibrium in normal multi-agent environment . 3 ROBUST MARL . 3.1 BACKGROUND . A typical cooperative MARL problem can be formulated as a stochastic Markov game ( S , { Ai } ni=1 , r , P ) , where S denotes the state space , { Ai } is i-th agent ’ s action space . The en- vironment starts at state s0 based on some initial distribution p0 . At each time step t , agents select a joint action at ∈ ×ni=1Ai based on some policy πteam ( at|st ) , and receive reward r ( st , at ) . The environment will transfer to a new state st+1 ∼ P ( ·|st , at ) . The goal is to maximize agents ’ expected accumulated reward : maxπteam Es0∼p0 , at∼πteam , st+1∼P [ ∑ t r ( st , at ) ] . Most state-of-the-art MARL algorithms utilize CTDE routine , that is , each agent selects its own action independently . If the environment is fully observable , then at each timestep t , each agent selects an action ait ∈ Ai based on some policy πi ( ait|st ) , and if the environment is partially observable , then at each timestep t , each agent will receive an observation oit based on st , and select action based on policy πi ( ait|oit ) . And the goal becomes maxπ1 : n Es0∼p0 , a1 : n , t∼π1 : n , st+1∼P [ ∑ t r ( st , a1 : n , t ) ] . 3.2 ROBUST MARL AND VANILLA ADVERSARIAL TRAINING . The motivation of our work is to obtain a policy that is robust when one agent makes some mistakes . In normal MARL algorithm , the team can guarantee to achieve high reward only when all agents accurately execute their optimal strategies . However , this may not always be true in real world scenarios . Real world agents may occasionally make mistakes ( e.g . machine malfunctioning ) . To achieve the robustness to this kind of mistakes , we propose to solve the worst case mini-max problem : Fixed i or ∀ i , max π1 : n min πi , mis Es0∼p0 , ait∼πi , mis , a−i , t∼π−i , st+1∼P [ ∑ t r ( st , a1 : n , t ) ] s.t . D ( πi , mis||πi ) ≤ ε ( 1 ) where { −i } means all except i. πi , mis means the mistaken policy that the mistaken agent actually perform . D is some kind of distance measure , since we can not expect that the team policy can still be robust when one agent makes very big mistakes . Unfortunately , this mini-max problem is hard to solve , since it contains two MDPs nested with each other . On the other side , the common case in real world is that , agents make mistakes randomly , i.e . these mistakes are most likely not related to the team ’ s goal and other agents ’ policies . Also , agents typically make mistakes only occasionally , since agents that always/frequently makes mistakes are not allowed to be deployed in practice . So following these considerations , we consider a simpler case and instantiate the robust cooperative MARL into QMIX algorithm . We consider a weaker worst case mini-max problem . Since we assume agent only make mistakes occasionally , we consider the case that the mistaken agent executes its “ worst ” action in a certain probability ε . Also we assume that the mistakes are most likely not related to the team ’ s goal and other agents ’ policies . In QMIX , if an agent i doesn ’ t consider other agents ’ policies , then its worst action is the one that minimizes its own Qi function ( since in QMIX ∂Qtot∂Qi ≥ 0 , lower Qi will lead to lower Qtot ) . In summary , we let the mistaken agent i perform ai , mis = { argmaxaQi ( s , a ) with prob . 1− ε argminaQi ( s , a ) with prob . ε ( 2 ) and apply vanilla adversarial training to obtain a robust policy . The detailed algorithm framework 2 is described in Appendix A.1 . The performance of vanilla adversarial training will be considered as a baseline . 4 ROBUST MARL WITH CORRELATED EQUILIBRIUM . 4.1 ROBUST MARL REQUIRES CORRELATED EQUILIBRIUM . In this part , we will show that with naive adversarial training in a centralized training and decentralized execution fashion , the learned policy might be sub-optimal in adversarial settings , thus requiring a correlated equilibrium . In typical MARL settings , if the environment is fully cooperative , then the algorithms with centralized training and decentralized execution ( e.g . QMIX/MADDPG/COMA , etc ) can achieve stateof-the-art performance in certain environments . This indicates that at least for these environments , correlation in execution is not necessary . Furthermore , Lauer & Riedmiller ( 2000 ) proved that decentralized executed policy can achieve optimal performance for fully observable and fully cooperative RL . However , in the robust MARL setting , some agent ( s ) become adversarial , indicating that the environment is not fully cooperative now . So the question is : whether the correlation in execution is necessary in adversarial scenario ? For the settings of Eq . ( 1 ) , the problems actually become a team mini-max game . The works on team mini-max normal form or extensive form games ( von Stengel & Koller , 1997 ; Basilico et al. , 2016 ; Celli & Gatti , 2017 ) , pointed out that the decentralized equilibrium can be significantly worse than correlated equilibrium at least for some games . In normal form team mini-max game , Basilico et al . ( 2016 ) proved that the gap between correlated and decentralized equilibrium is at most O ( mn−2 ) , where n is the number of agents ( includes the adversarial ) and m is each agent ’ s number of action . And the bound is tight . During this section , we simply define the “ correlated equilibrium ” as the equilibrium of optimal “ correlated policy ” , that is , the team learns the optimal policy π∗team ( a|st ) together , and “ decentralized equilibrium ” as the equilibrium of optimal “ decentralized policy ” learned by CTDE algorithm . We denote Ecor as the team ’ s expected reward under their optimal correlated policy , and Edec as that in their optimal decentralized policy . In MARL , agents play a stochastic game . Since a repeated normal form game is a special case of stochastic games , so EcorEdec can be at least m n−2 in stochastic games . Moreover , we find that this gap can be even larger in stochastic games than that in normal form games , because stochastic game is a sequential game , and agents ’ previous actions can influence the future state and therefore affect the future reward . Proposition 1 . There exists a stochastic game that EcorEdec > m n−2 . Proof . Consider this example : S = { S1 , S2 } , initial state is S1 . Agents 1 · · ·n − 1 is a team , n is adversary . Ai = { 1 , · · · , m } , i = 1 · · ·n . Discount factor γ < 1 . The team ’ s reward function r ( S1 , a ) = 0 , ∀a . r ( S2 , a ) = { 1 a1 = · · · = an 0 otherwise . Deterministic state transition function T ( S1 , a ) = { S2 a1 = · · · = an S1 otherwise ; T ( S2 , a ) = { Game ends a1 = a2 = · · · = an S2 otherwise . In each state , the team ’ s optimal correlated policy is to perform correlated action { 1 , · · · , 1 } , · · · , { m , · · · , m } with equal probability 1m . Because if the team perform any of these actions with probability less than 1m , the adversary will perform that action , which will reduce the team ’ s reward . However , if the team plays in a decentralized way , then each agent ’ s optimal policy is to perform each m actions with equal probability 1m . We can prove that in this example , EcorEdec ≥ m 2n−4 ( 1− r ) 2 . The detailed derivation can be found in Appendix A.2 . In fact , the gap between correlated and decentralized equilibrium in stochastic team mini-max game can be arbitrarily larger than normal form game , elaborated in the following proposition . The detailed derivation can be found in Appendix A.2 . Proposition 2 . ∀ fixed k ∈ Z+ , there exists a stochastic game in which EcorEdec ≥ O ( m k ( n−2 ) ) . Therefore , in robust MARL settings , CTDE algorithms may no longer achieve optimal performance . To achieve better robustness in adversarial settings , we need to design some methods that can urge agents to learn correlated equilibrium . | This paper considers a case in the cooperative multiagent reinforcement learning where one single agent can behave adversarially. It claims that the performance of the whole MARL system would deteriorate significantly and demonstrate this phenomenon both theoretically and empirically. Then the author proposes a solution, i.e. , solving the correlated equilibrium in the game. To seek the correlated equilibrium, the author introduces a global random variable z and adds a mutual information regularization term. Indeed this idea is easy to follow since it directly follows the definition of the correlated equilibrium. At last, it tests the algorithm in the SMAC environment and compares it with QMIX algorithm. | SP:9c05898952af007c390c3a6cc385746daad29e65 |
Robust Multi-Agent Reinforcement Learning Driven by Correlated Equilibrium | 1 INTRODUCTION . Recently , reinforcement learning ( RL ) has achieved remarkable success in many practical sequential decision problems , such as Go ( Silver et al. , 2017 ) , chess ( Silver et al. , 2018 ) , real-time strategy games ( Vinyals et al. , 2019 ) , etc . In real-world , many sequential decision problems involve more than one decision maker ( i.e . multi-agent ) , such as auto-driving , traffic light control and network routing . Cooperative multi-agent reinforcement learning ( CMARL ) is a key framework to solve these practical problems . Existing MARL methods for cooperative environments include policybased methods , e.g . MADDPG ( Lowe et al. , 2017 ) , COMA ( Foerster et al. , 2017 ) , and value-based methods , e.g . VDN ( Sunehag et al. , 2018 ) , QMIX ( Rashid et al. , 2018 ) , QTRAN ( Son et al. , 2019 ) . However , before we actually apply CMARL ’ s policy into real world applications , a question must be asked : are these learned policies safe or robust to be deployed ? What will happen if some agents made mistakes or behaved adversarially against other agents ? It will be most likely that the entire team might fail to achieve their goal or perform extremely poorly . ( Lin et al. , 2020 ) demonstrates the unrobustness in CMARL environment , where a learnt adversarial of one agent can hugely decrease the team ’ s performance . Therefore , in practice , we expect to have a multi-agent team policy in a fully cooperative environment that is robust when some agent ( s ) make some mistakes and even behave adversarially . To the best of knowledge , very few existing works on this issue mainly use vanilla adversarial training strategy . Klima et al . ( 2018 ) considered a two-agent cooperative case , in order to make the policy robust , agents become competitive with a certain probability during training . Li et al . ( 2019 ) provided a robust MADDPG approach called M3DDPG , where each agent optimizes its policy based on other agents ’ influenced sub-optimal actions . Most state-of-the-art MARL algorithms utilize centralized training and decentralized execution ( CTDE ) routine , since this setting is common in real world cases . The robust MARL method M3DDPG also followed the CTDE setting . However , existing works on team mini-max normal form or extensive form games show that if the environment contains an adversarial agent , then the decentralized equilibrium from CTDE routine can be significantly worse than the correlated equilibrium . We furthermore extend this finding into stochastic team mini-max games . Inspired by this important observation , if we can urge agents to learn a correlated equilibrium ( i.e . the non-adversarial agents jointly make the decision when execution ) , then we may achieve better performance than those following CTDE in robust MARL setting . In this work , we achieve the robust MARL via solving correlated equilibrium motivated by the latent variable model , where the introduction of a latent variable across all agents could help agents jointly make their decisions . Our contributions can be summarized as follows . • We demonstrate that in stochastic team mini-max games , the decentralized equilibrium can be arbitrarily worse than correlated one , and the gap can be significantly larger than in normal or extensive form games . • With this result , we point out that learning correlated equilibrium is indeed necessary in robust MARL . • We propose a simple strategy to urge agents to learn correlated equilibrium , and show that this method can yield significant performance improvements over vanilla adversarial training . 2 RELATED WORKS . Robust RL The robustness in RL involves the perturbations occurring in different cases , such as state or observation , environment , action or policy , opponent ’ s policy , etc . 1 ) For the robustness to state or observation perturbation , most works focused on adversarial attacks of image state/observation . Pattanaik et al . ( 2018 ) used gradient-based attack on image state , and vanilla adversarial training was adopted to obtain robust policy ; Fischer et al . ( 2019 ) first trained a normal policy , and distilled it on adversarial states to achieve robustness ; Ferdowsi et al . ( 2018 ) applied adversarial training to autonomous driving tasks that interfered agent ’ s input sensors based on environment , and then conducted adversarial training ; 2 ) For the robustness to environment , robust Markov decision process ( MDP ) could be used to formulate this problem . Many works ( e.g . Wiesemann et al . ( 2013 ) ; Lim et al . ( 2013 ) ) have studied this model and provided both theoretical analysis and algorithmic design . In deep RL scenario , Rajeswaran et al . ( 2016 ) used Monte Carlo approach to train agent , while Abdullah et al . ( 2019 ) ; Hou et al . ( 2020 ) adopted adversarial training to obtain a robust agent to all environments within a Wasserstein ball . Mankowitz et al . ( 2019 ) conducted adversarial training in MPO algorithm to optimize the performance in the worst performance environment . 3 ) To be against the perturbation of action or policy , Tessler et al . ( 2019 ) ; Gu et al . ( 2018 ) ; Vinitsky et al . ( 2020 ) considered the case that agent ’ s action may be influenced by another action , and conducted adversarial training . 4 ) For the robustness to opponent , Pinto et al . ( 2017 ) ; Ma et al . ( 2018 ) focused on the case that agent ’ s reward may be influenced by another agent , and adversarial training was implemented to solve the two-agent game to obtain a robust agent . Correlated Equilibrium Correlated equilibrium is a more general equilibrium in game theory compared to Nash equilibrium . In a cooperative task , if the team agents jointly make decisions together , then the optimal team policy is correlated equilibrium . Correlated equilibrium is widely studied in game theory ( e.g . Hart & Mas-Colell ( 2001 ; 2000 ) ; Neyman ( 1997 ) ) . In team mini-max game , solving the team ’ s correlated equilibrium in normal form game is straightforward ( just treat the team as a single agent ) ; Celli & Gatti ( 2017 ) ; Zhang & An ( 2020 ) ; Farina et al . ( 2018 ) proposed various algorithms to solve correlated equilibrium in extensive formal games . In deep RL scenario , Celli et al . ( 2019 ) applied vanilla hidden variable model to solve correlated equilibrium in simple repetitive environments , while information loss with hidden variable model was used in Chen et al . ( 2019 ) to solve correlated equilibrium in normal multi-agent environment . 3 ROBUST MARL . 3.1 BACKGROUND . A typical cooperative MARL problem can be formulated as a stochastic Markov game ( S , { Ai } ni=1 , r , P ) , where S denotes the state space , { Ai } is i-th agent ’ s action space . The en- vironment starts at state s0 based on some initial distribution p0 . At each time step t , agents select a joint action at ∈ ×ni=1Ai based on some policy πteam ( at|st ) , and receive reward r ( st , at ) . The environment will transfer to a new state st+1 ∼ P ( ·|st , at ) . The goal is to maximize agents ’ expected accumulated reward : maxπteam Es0∼p0 , at∼πteam , st+1∼P [ ∑ t r ( st , at ) ] . Most state-of-the-art MARL algorithms utilize CTDE routine , that is , each agent selects its own action independently . If the environment is fully observable , then at each timestep t , each agent selects an action ait ∈ Ai based on some policy πi ( ait|st ) , and if the environment is partially observable , then at each timestep t , each agent will receive an observation oit based on st , and select action based on policy πi ( ait|oit ) . And the goal becomes maxπ1 : n Es0∼p0 , a1 : n , t∼π1 : n , st+1∼P [ ∑ t r ( st , a1 : n , t ) ] . 3.2 ROBUST MARL AND VANILLA ADVERSARIAL TRAINING . The motivation of our work is to obtain a policy that is robust when one agent makes some mistakes . In normal MARL algorithm , the team can guarantee to achieve high reward only when all agents accurately execute their optimal strategies . However , this may not always be true in real world scenarios . Real world agents may occasionally make mistakes ( e.g . machine malfunctioning ) . To achieve the robustness to this kind of mistakes , we propose to solve the worst case mini-max problem : Fixed i or ∀ i , max π1 : n min πi , mis Es0∼p0 , ait∼πi , mis , a−i , t∼π−i , st+1∼P [ ∑ t r ( st , a1 : n , t ) ] s.t . D ( πi , mis||πi ) ≤ ε ( 1 ) where { −i } means all except i. πi , mis means the mistaken policy that the mistaken agent actually perform . D is some kind of distance measure , since we can not expect that the team policy can still be robust when one agent makes very big mistakes . Unfortunately , this mini-max problem is hard to solve , since it contains two MDPs nested with each other . On the other side , the common case in real world is that , agents make mistakes randomly , i.e . these mistakes are most likely not related to the team ’ s goal and other agents ’ policies . Also , agents typically make mistakes only occasionally , since agents that always/frequently makes mistakes are not allowed to be deployed in practice . So following these considerations , we consider a simpler case and instantiate the robust cooperative MARL into QMIX algorithm . We consider a weaker worst case mini-max problem . Since we assume agent only make mistakes occasionally , we consider the case that the mistaken agent executes its “ worst ” action in a certain probability ε . Also we assume that the mistakes are most likely not related to the team ’ s goal and other agents ’ policies . In QMIX , if an agent i doesn ’ t consider other agents ’ policies , then its worst action is the one that minimizes its own Qi function ( since in QMIX ∂Qtot∂Qi ≥ 0 , lower Qi will lead to lower Qtot ) . In summary , we let the mistaken agent i perform ai , mis = { argmaxaQi ( s , a ) with prob . 1− ε argminaQi ( s , a ) with prob . ε ( 2 ) and apply vanilla adversarial training to obtain a robust policy . The detailed algorithm framework 2 is described in Appendix A.1 . The performance of vanilla adversarial training will be considered as a baseline . 4 ROBUST MARL WITH CORRELATED EQUILIBRIUM . 4.1 ROBUST MARL REQUIRES CORRELATED EQUILIBRIUM . In this part , we will show that with naive adversarial training in a centralized training and decentralized execution fashion , the learned policy might be sub-optimal in adversarial settings , thus requiring a correlated equilibrium . In typical MARL settings , if the environment is fully cooperative , then the algorithms with centralized training and decentralized execution ( e.g . QMIX/MADDPG/COMA , etc ) can achieve stateof-the-art performance in certain environments . This indicates that at least for these environments , correlation in execution is not necessary . Furthermore , Lauer & Riedmiller ( 2000 ) proved that decentralized executed policy can achieve optimal performance for fully observable and fully cooperative RL . However , in the robust MARL setting , some agent ( s ) become adversarial , indicating that the environment is not fully cooperative now . So the question is : whether the correlation in execution is necessary in adversarial scenario ? For the settings of Eq . ( 1 ) , the problems actually become a team mini-max game . The works on team mini-max normal form or extensive form games ( von Stengel & Koller , 1997 ; Basilico et al. , 2016 ; Celli & Gatti , 2017 ) , pointed out that the decentralized equilibrium can be significantly worse than correlated equilibrium at least for some games . In normal form team mini-max game , Basilico et al . ( 2016 ) proved that the gap between correlated and decentralized equilibrium is at most O ( mn−2 ) , where n is the number of agents ( includes the adversarial ) and m is each agent ’ s number of action . And the bound is tight . During this section , we simply define the “ correlated equilibrium ” as the equilibrium of optimal “ correlated policy ” , that is , the team learns the optimal policy π∗team ( a|st ) together , and “ decentralized equilibrium ” as the equilibrium of optimal “ decentralized policy ” learned by CTDE algorithm . We denote Ecor as the team ’ s expected reward under their optimal correlated policy , and Edec as that in their optimal decentralized policy . In MARL , agents play a stochastic game . Since a repeated normal form game is a special case of stochastic games , so EcorEdec can be at least m n−2 in stochastic games . Moreover , we find that this gap can be even larger in stochastic games than that in normal form games , because stochastic game is a sequential game , and agents ’ previous actions can influence the future state and therefore affect the future reward . Proposition 1 . There exists a stochastic game that EcorEdec > m n−2 . Proof . Consider this example : S = { S1 , S2 } , initial state is S1 . Agents 1 · · ·n − 1 is a team , n is adversary . Ai = { 1 , · · · , m } , i = 1 · · ·n . Discount factor γ < 1 . The team ’ s reward function r ( S1 , a ) = 0 , ∀a . r ( S2 , a ) = { 1 a1 = · · · = an 0 otherwise . Deterministic state transition function T ( S1 , a ) = { S2 a1 = · · · = an S1 otherwise ; T ( S2 , a ) = { Game ends a1 = a2 = · · · = an S2 otherwise . In each state , the team ’ s optimal correlated policy is to perform correlated action { 1 , · · · , 1 } , · · · , { m , · · · , m } with equal probability 1m . Because if the team perform any of these actions with probability less than 1m , the adversary will perform that action , which will reduce the team ’ s reward . However , if the team plays in a decentralized way , then each agent ’ s optimal policy is to perform each m actions with equal probability 1m . We can prove that in this example , EcorEdec ≥ m 2n−4 ( 1− r ) 2 . The detailed derivation can be found in Appendix A.2 . In fact , the gap between correlated and decentralized equilibrium in stochastic team mini-max game can be arbitrarily larger than normal form game , elaborated in the following proposition . The detailed derivation can be found in Appendix A.2 . Proposition 2 . ∀ fixed k ∈ Z+ , there exists a stochastic game in which EcorEdec ≥ O ( m k ( n−2 ) ) . Therefore , in robust MARL settings , CTDE algorithms may no longer achieve optimal performance . To achieve better robustness in adversarial settings , we need to design some methods that can urge agents to learn correlated equilibrium . | The paper addresses the issue of robustness in cooperative multi-agent RL setups, where the inclusion at test time of an agent that makes error or is even adversarial can drastically decrease performance. The main idea is to compute a correlated equilibrium, by allowing all agents policies to depend on a common signal. To encourage the actions of the agents to correlate, they add a mutual information loss (i.e. a retrodiction that encourages the global latent to be predictable given the action taken). | SP:9c05898952af007c390c3a6cc385746daad29e65 |
Probabilistic Mixture-of-Experts for Efficient Deep Reinforcement Learning | 1 INTRODUCTION . The mixture-of-experts method ( MOE ) ( Jacobs et al. , 1991a ) is testified to be capable of improving the generalisation ability of reinforcement learning ( RL ) agents ( Hausknecht & Stone , 2016a ; Peng et al. , 2016 ; Neumann et al. ) . Among these methods , the Gaussian Mixture Models ( GMM ) are promising to model multimodal policy in RL ( Peng et al. , 2019 ; Akrour et al. , 2020 ) , in which distinguishable experts or so-called primitives are learned . The distinguishable experts can propose several solutions for a task and have a larger range of exploration space , which can potentially lead to better task performance and sample efficiency compared to its unimodal counterpart ( Bishop , 2007 ) . The multimodal policy can be learned by various methods , such as a two-stage training approach ( Peng et al. , 2019 ) , specific clustering method ( Akrour et al. , 2020 ) , or especially parameterised actions design ( Hausknecht & Stone , 2016b ) . However , these methods are limited , neither applicable to complicated scenarios such as high-dimensional continuous control tasks nor the training algorithms are too complex to deal with general utility . To the best of our knowledge , the present DRL algorithms for general utility do not deploy MOE to model the multimodal policy mainly due to the lack of differentiability , or without explicit probabilistic representation . Therefore , in the policy gradientbased algorithms ( Sutton et al. , 1999a ) , the gradient of the performance concerning the policy parameters is undifferentiated . The undifferentiability problem also remains to learn a deep neural network policy thus making the combinations of MOE and DRL not trivial . In this paper , we propose a probabilistic framework to tackle the undifferentiated problem by holding the mixture distribution assumption . We will still use the GMM to model the multimodal policies . Once the undifferentiated problem is solved , our training methods can be combined with the policy gradient algorithms by simply setting the number of experts ( mixtures ) greater than one . Hereafter , the contribution can be summarised as follows : • We analyse the undifferentiability problem of approximating policy as the GMM in DRL and its associated drawbacks . • We propose an end-to-end training method to obtain the primitives with probability in a frequentist manner to solve the undifferentiability problem . • Our experiments show the proposed method can achieve better task performance and sample efficiency by exploring larger behaviours space , especially in complicated continuous control tasks , compared with unimodal RL algorithms and three different MOE methods or option frameworks . 2 RELATED WORK . Hierarchical Policies There are two main related hierarchical policy structures . The feudal schema ( Dayan & Hinton , 1992 ) has two types of agents : managers and workers . The managers first make high-level decisions , then the workers make low-level actions according to these high-level decisions . The options framework ( Sutton et al. , 1999b ) has an upper-level agent ( policy-over-options ) , which decides whether the lower level agent ( sub-policy ) should start or terminate . In the early years , it ’ s the subject of research to discover temporal abstractions autonomously often in discrete actions and the state space ( McGovern & Barto , 2001 ; Menache et al. , 2002 ; Simsek & Barto , 2008 ; Silver & Ciosek , 2012 ) . Recently , ( Mankowitz et al. , 2016 ) proposes a method that assumes the initiation sets and termination functions have particular structures . ( Kulkarni et al. , 2016 ) uses internal and extrinsic rewards to learn sub-policies and policy-over-options . ( Bacon et al. , 2017 ) trains sub-policies and policy-over-options in end-to-end fusion with a deep termination function . ( Vezhnevets et al. , 2017 ) generalises the feudal schema into continuous action space and uses an embedding operation to solve the indifferentiable problem . ( Peng et al. , 2016 ) introduces a mixture of actor-critic experts approaches to learn terrain-adaptive dynamic locomotion skills . ( Peng et al. , 2019 ) changes the mixture-of-experts distribution addition expression into the multiplication expression . Mixture-of-Experts and Ensemble Methods To speed up the learning and improve the generalisation ability on different scenarios , Jacobs et al . ( 1991a ) proposed to use several different expert networks instead of a single one . To partition the data space and assign different kernels for different spaces , Lima et al . ( 2007 ) ; Yao et al . ( 2009 ) combines MOE with SVM . To break the dependency among training outputs and speed up the convergence , Gaussian process ( GP ) is generalised similarly to MOE ( Tresp , 2000 ; Yuan & Neubauer , 2008 ; Luo & Sun , 2017 ) . MOE can be also combined with RL ( Doya et al. , 2002 ; Neumann et al . ; Peng et al. , 2016 ; Hausknecht & Stone , 2016a ; Peng et al. , 2019 ) , in which the policies are modelled as probabilistic mixture models and each expert aim to learn distinguishable policies . Policy-based RL Policy-based RL aims to find the optimal policy to maximise the expected return through gradient updates . Among various algorithms , Actor-critic is often employed ( Barto et al. , 1983 ; Sutton & Barto , 1998 ) . Off-policy algorithms ( O ’ Donoghue et al. , 2016 ; Lillicrap et al. , 2016 ; Gu et al. , 2017 ; Tuomas et al. , 2018 ) are more sample efficient than on-policy ones ( Peters & Schaal , 2008 ; Schulman et al. , 2017 ; Mnih et al. , 2016 ; Gruslys et al. , 2017 ) . However , the learned policies are still unimodal . 3 METHOD . 3.1 NOTATION . The model-free RL problem can be formulated by Markov Decision Process ( MDP ) , denoted as a tuple ( S , A , P , r ) , where S and A are continuous state and action space , respectively . The agent observes state st ∈ S and takes an action at ∈ A at time step t. The environment emits a reward r : S ×A → [ rmin , rmax ] and transitions to a new state st+1 according to the transition probabilities P : S × S × A → [ 0 , ∞ ) . In deep reinforcement learning algorithms , we always use the Q-value functionQ ( st , at ) to describe the expected return after taking an action at in the state st . The Q-value can be iteratively computed by applying the Bellman backup given by : Q ( st , at ) , Est+1∼P [ r ( st , at ) + γEat+1∼π [ Q ( st+1 , at+1 ) ] ] . ( 1 ) Our goal is to maximise the expected return : πΘ∗ ( at|st ) = arg max πΘ ( at|st ) Eat∼πΘ ( at|st ) [ Q ( st , at ) ] , ( 2 ) where Θ denotes the parameters of the policy network π . With Q-value network ( critic ) Qφ parameterised by φ , Stochastic gradient descent ( SGD ) based approaches are usually used to update the policy network : Θ = Θ +∇ΘEa∼πΘ ( at|st ) [ Qφ ( st , at ) ] . ( 3 ) 3.2 PROBABILISTIC MIXTURE-OF-EXPERTS ( PMOE ) . The proposed PMOE method decomposes a stochastic policy π as a mixture of low-level policies while retaining the probabilistic properties of the stochastic policy as a probability distribution , with the following formula : π { θ , ψ } ( at|st ) = K∑ i=1 wθi ( st ) πψi ( at|st ) , s.t . K∑ i=1 wθi = 1 , wθi > 0 , ( 4 ) where each πψi denotes the action distribution within each low-level policy , i.e . a primitive , and K denotes the number of primitives . wψi is the weight that specifies the probability of the activating primitive πψi , which is called the routing function . θi and ψi are parameters of wθi and πψi , respectively . After the policy decomposition with PMOE method , we can rewrite the update rule in Eq . 3 as : θ = θ +∇θEat∼π { θ , ψ } ( at|st ) [ Qφ ( st , at ) ] , ψ = ψ +∇ψEat∼π { θ , ψ } ( at|st ) [ Qφ ( st , at ) ] . ( 5 ) In practice , we usually apply a Gaussian distribution for either a unimodal policy or the low-level policies here in PMOE , making the overall stochastic policy with PMOE to be a GMM . However , sampling from the distributions of primitives usually embeds a sampling process from a categorical distribution w , which makes the differential calculation of policy gradients commonly applied in DRL hard to achieve . We provide a theoretically guaranteed solution for approximating the gradients in the sampling process of PMOE and successfully optimising the PMOE policy model within DRL , which will be described in details . 3.3 LEARNING THE ROUTING . To optimise the routing function w , which involves a sampling process from a categorical distribution , we propose a frequency loss function to approximate the gradients , which is theoretically proved to approximate w as the probability of the corresponding primitive being the optimal one w.r.t . the Q-value function . Specifically , given a state st , we sample one action ait from each primitive πψi , to get a total of K actions { ait ; i = 1 , 2 , · · · , K } , and compute K Q-value estimations { Qφ ( st , ait ) ; i = 1 , 2 , · · · , K } for each of the actions . Then we select an “ optimal ” primitive index as j = arg maxiQφ ( st , a i t ) . Then we encode a one-hot code vector v = [ v1 , v2 , · · · , vK ] with : vj = { 1 , if j = arg max i Qφ ( st , a i t ) ; 0 , otherwise . ( 6 ) Here we define a frequency loss function as : Lfreq = ( v − w ) ( v − w ) T , w = [ wθ1 , wθ2 , · · · , wθK ] . ( 7 ) We use the proposed frequency loss Lfreq as a smooth and differentiable function to update the routing function parameters θ , which is guaranteed to approximate wθi as the probability of the i-th primitive being the optimal primitive for current state . Detailed proof is provided in Appendix B . 3.4 LEARNING THE PRIMITIVE . To update the ψi within each primitive , we provide two approaches of optimising the primitives : back-propagation-all and back-propagation-max manners . For the back-propagation-all approach , we update all the primitive : Lbpapri = − K∑ i Qφ ( st , a i t ) , a i t ∼ πψi ( at|st ) . ( 8 ) For the back-propagation-max approach , we use the highest Q-value estimation as the primitive loss : Lbpmpri = −max i { Qφ ( st , ait ; i = 1 , 2 , · · · , K ) } , ait ∼ πψi ( at|st ) . ( 9 ) With either approach , we have the stochastic policy gradients as following : ∇ψiLpri =−∇ψjEπψi [ Qφ ( st , at ) ] =Eπψi [ −Qφ ( st , at ) ∇ψj log πψj ( at|st ) ] ( 10 ) Ideally , both approaches are feasible for learning a PMOE model . However , in practice , we find that the back-propagation-all approach will tend to learn primitives that are close to each other , while the back-propagation-max approach is capable of keeping primitives distinguishable . The phenomenon is demonstrated in our experimental analysis . Therefore , we adopt the back-propagation-max approach as the default setting of PMOE model without additional clarification . | The paper studies the problem of differentiating through the policy return when the policy is a Gaussian mixture model. The main contribution of the paper is a heuristic approach for computing this gradient. Having defined the policy update, the authors integrate it to two RL algorithms: PPO and SAC. The experiments show that the algorithms with GMMs behave roughly the same as with a single Gaussian save for one (SAC) or two (PPO) environments. On the other side the authors show that their algorithm can learn multiple solutions on a reaching task and that exploration is better behaved on this task too. | SP:f27bf5238c835413eff4edb3315386543b0aad6c |
Probabilistic Mixture-of-Experts for Efficient Deep Reinforcement Learning | 1 INTRODUCTION . The mixture-of-experts method ( MOE ) ( Jacobs et al. , 1991a ) is testified to be capable of improving the generalisation ability of reinforcement learning ( RL ) agents ( Hausknecht & Stone , 2016a ; Peng et al. , 2016 ; Neumann et al. ) . Among these methods , the Gaussian Mixture Models ( GMM ) are promising to model multimodal policy in RL ( Peng et al. , 2019 ; Akrour et al. , 2020 ) , in which distinguishable experts or so-called primitives are learned . The distinguishable experts can propose several solutions for a task and have a larger range of exploration space , which can potentially lead to better task performance and sample efficiency compared to its unimodal counterpart ( Bishop , 2007 ) . The multimodal policy can be learned by various methods , such as a two-stage training approach ( Peng et al. , 2019 ) , specific clustering method ( Akrour et al. , 2020 ) , or especially parameterised actions design ( Hausknecht & Stone , 2016b ) . However , these methods are limited , neither applicable to complicated scenarios such as high-dimensional continuous control tasks nor the training algorithms are too complex to deal with general utility . To the best of our knowledge , the present DRL algorithms for general utility do not deploy MOE to model the multimodal policy mainly due to the lack of differentiability , or without explicit probabilistic representation . Therefore , in the policy gradientbased algorithms ( Sutton et al. , 1999a ) , the gradient of the performance concerning the policy parameters is undifferentiated . The undifferentiability problem also remains to learn a deep neural network policy thus making the combinations of MOE and DRL not trivial . In this paper , we propose a probabilistic framework to tackle the undifferentiated problem by holding the mixture distribution assumption . We will still use the GMM to model the multimodal policies . Once the undifferentiated problem is solved , our training methods can be combined with the policy gradient algorithms by simply setting the number of experts ( mixtures ) greater than one . Hereafter , the contribution can be summarised as follows : • We analyse the undifferentiability problem of approximating policy as the GMM in DRL and its associated drawbacks . • We propose an end-to-end training method to obtain the primitives with probability in a frequentist manner to solve the undifferentiability problem . • Our experiments show the proposed method can achieve better task performance and sample efficiency by exploring larger behaviours space , especially in complicated continuous control tasks , compared with unimodal RL algorithms and three different MOE methods or option frameworks . 2 RELATED WORK . Hierarchical Policies There are two main related hierarchical policy structures . The feudal schema ( Dayan & Hinton , 1992 ) has two types of agents : managers and workers . The managers first make high-level decisions , then the workers make low-level actions according to these high-level decisions . The options framework ( Sutton et al. , 1999b ) has an upper-level agent ( policy-over-options ) , which decides whether the lower level agent ( sub-policy ) should start or terminate . In the early years , it ’ s the subject of research to discover temporal abstractions autonomously often in discrete actions and the state space ( McGovern & Barto , 2001 ; Menache et al. , 2002 ; Simsek & Barto , 2008 ; Silver & Ciosek , 2012 ) . Recently , ( Mankowitz et al. , 2016 ) proposes a method that assumes the initiation sets and termination functions have particular structures . ( Kulkarni et al. , 2016 ) uses internal and extrinsic rewards to learn sub-policies and policy-over-options . ( Bacon et al. , 2017 ) trains sub-policies and policy-over-options in end-to-end fusion with a deep termination function . ( Vezhnevets et al. , 2017 ) generalises the feudal schema into continuous action space and uses an embedding operation to solve the indifferentiable problem . ( Peng et al. , 2016 ) introduces a mixture of actor-critic experts approaches to learn terrain-adaptive dynamic locomotion skills . ( Peng et al. , 2019 ) changes the mixture-of-experts distribution addition expression into the multiplication expression . Mixture-of-Experts and Ensemble Methods To speed up the learning and improve the generalisation ability on different scenarios , Jacobs et al . ( 1991a ) proposed to use several different expert networks instead of a single one . To partition the data space and assign different kernels for different spaces , Lima et al . ( 2007 ) ; Yao et al . ( 2009 ) combines MOE with SVM . To break the dependency among training outputs and speed up the convergence , Gaussian process ( GP ) is generalised similarly to MOE ( Tresp , 2000 ; Yuan & Neubauer , 2008 ; Luo & Sun , 2017 ) . MOE can be also combined with RL ( Doya et al. , 2002 ; Neumann et al . ; Peng et al. , 2016 ; Hausknecht & Stone , 2016a ; Peng et al. , 2019 ) , in which the policies are modelled as probabilistic mixture models and each expert aim to learn distinguishable policies . Policy-based RL Policy-based RL aims to find the optimal policy to maximise the expected return through gradient updates . Among various algorithms , Actor-critic is often employed ( Barto et al. , 1983 ; Sutton & Barto , 1998 ) . Off-policy algorithms ( O ’ Donoghue et al. , 2016 ; Lillicrap et al. , 2016 ; Gu et al. , 2017 ; Tuomas et al. , 2018 ) are more sample efficient than on-policy ones ( Peters & Schaal , 2008 ; Schulman et al. , 2017 ; Mnih et al. , 2016 ; Gruslys et al. , 2017 ) . However , the learned policies are still unimodal . 3 METHOD . 3.1 NOTATION . The model-free RL problem can be formulated by Markov Decision Process ( MDP ) , denoted as a tuple ( S , A , P , r ) , where S and A are continuous state and action space , respectively . The agent observes state st ∈ S and takes an action at ∈ A at time step t. The environment emits a reward r : S ×A → [ rmin , rmax ] and transitions to a new state st+1 according to the transition probabilities P : S × S × A → [ 0 , ∞ ) . In deep reinforcement learning algorithms , we always use the Q-value functionQ ( st , at ) to describe the expected return after taking an action at in the state st . The Q-value can be iteratively computed by applying the Bellman backup given by : Q ( st , at ) , Est+1∼P [ r ( st , at ) + γEat+1∼π [ Q ( st+1 , at+1 ) ] ] . ( 1 ) Our goal is to maximise the expected return : πΘ∗ ( at|st ) = arg max πΘ ( at|st ) Eat∼πΘ ( at|st ) [ Q ( st , at ) ] , ( 2 ) where Θ denotes the parameters of the policy network π . With Q-value network ( critic ) Qφ parameterised by φ , Stochastic gradient descent ( SGD ) based approaches are usually used to update the policy network : Θ = Θ +∇ΘEa∼πΘ ( at|st ) [ Qφ ( st , at ) ] . ( 3 ) 3.2 PROBABILISTIC MIXTURE-OF-EXPERTS ( PMOE ) . The proposed PMOE method decomposes a stochastic policy π as a mixture of low-level policies while retaining the probabilistic properties of the stochastic policy as a probability distribution , with the following formula : π { θ , ψ } ( at|st ) = K∑ i=1 wθi ( st ) πψi ( at|st ) , s.t . K∑ i=1 wθi = 1 , wθi > 0 , ( 4 ) where each πψi denotes the action distribution within each low-level policy , i.e . a primitive , and K denotes the number of primitives . wψi is the weight that specifies the probability of the activating primitive πψi , which is called the routing function . θi and ψi are parameters of wθi and πψi , respectively . After the policy decomposition with PMOE method , we can rewrite the update rule in Eq . 3 as : θ = θ +∇θEat∼π { θ , ψ } ( at|st ) [ Qφ ( st , at ) ] , ψ = ψ +∇ψEat∼π { θ , ψ } ( at|st ) [ Qφ ( st , at ) ] . ( 5 ) In practice , we usually apply a Gaussian distribution for either a unimodal policy or the low-level policies here in PMOE , making the overall stochastic policy with PMOE to be a GMM . However , sampling from the distributions of primitives usually embeds a sampling process from a categorical distribution w , which makes the differential calculation of policy gradients commonly applied in DRL hard to achieve . We provide a theoretically guaranteed solution for approximating the gradients in the sampling process of PMOE and successfully optimising the PMOE policy model within DRL , which will be described in details . 3.3 LEARNING THE ROUTING . To optimise the routing function w , which involves a sampling process from a categorical distribution , we propose a frequency loss function to approximate the gradients , which is theoretically proved to approximate w as the probability of the corresponding primitive being the optimal one w.r.t . the Q-value function . Specifically , given a state st , we sample one action ait from each primitive πψi , to get a total of K actions { ait ; i = 1 , 2 , · · · , K } , and compute K Q-value estimations { Qφ ( st , ait ) ; i = 1 , 2 , · · · , K } for each of the actions . Then we select an “ optimal ” primitive index as j = arg maxiQφ ( st , a i t ) . Then we encode a one-hot code vector v = [ v1 , v2 , · · · , vK ] with : vj = { 1 , if j = arg max i Qφ ( st , a i t ) ; 0 , otherwise . ( 6 ) Here we define a frequency loss function as : Lfreq = ( v − w ) ( v − w ) T , w = [ wθ1 , wθ2 , · · · , wθK ] . ( 7 ) We use the proposed frequency loss Lfreq as a smooth and differentiable function to update the routing function parameters θ , which is guaranteed to approximate wθi as the probability of the i-th primitive being the optimal primitive for current state . Detailed proof is provided in Appendix B . 3.4 LEARNING THE PRIMITIVE . To update the ψi within each primitive , we provide two approaches of optimising the primitives : back-propagation-all and back-propagation-max manners . For the back-propagation-all approach , we update all the primitive : Lbpapri = − K∑ i Qφ ( st , a i t ) , a i t ∼ πψi ( at|st ) . ( 8 ) For the back-propagation-max approach , we use the highest Q-value estimation as the primitive loss : Lbpmpri = −max i { Qφ ( st , ait ; i = 1 , 2 , · · · , K ) } , ait ∼ πψi ( at|st ) . ( 9 ) With either approach , we have the stochastic policy gradients as following : ∇ψiLpri =−∇ψjEπψi [ Qφ ( st , at ) ] =Eπψi [ −Qφ ( st , at ) ∇ψj log πψj ( at|st ) ] ( 10 ) Ideally , both approaches are feasible for learning a PMOE model . However , in practice , we find that the back-propagation-all approach will tend to learn primitives that are close to each other , while the back-propagation-max approach is capable of keeping primitives distinguishable . The phenomenon is demonstrated in our experimental analysis . Therefore , we adopt the back-propagation-max approach as the default setting of PMOE model without additional clarification . | The paper focuses on the policy architecture of deep reinforcement learning algorithms. Specifically, the authors apply the probabilistic mixture-of-experts (PMOE) model in the policy of a reinforcement learning agent, where each primitive is a unimodal Gaussian distribution and the gating model is a simple state-conditioned categorical distribution. The authors derive the corresponding policy gradient objective for the PMOE policy. | SP:f27bf5238c835413eff4edb3315386543b0aad6c |
Bidirectional Variational Inference for Non-Autoregressive Text-to-Speech | 1 INTRODUCTION . End-to-end text-to-speech ( TTS ) systems have recently attracted much attention , as neural TTS models began to generate high-quality speech that is very similar to the human voice ( Sotelo et al. , 2017 ; Wang et al. , 2017 ; Shen et al. , 2018 ; Ping et al. , 2018 ; Li et al. , 2019 ) . Typically , those TTS systems first generate a mel-spectrogram from a text using a sequence-to-sequence ( seq2seq ) model ( Sutskever et al. , 2014 ) and then synthesize speech from the mel-spectrogram using a neural vocoder like WaveGlow ( Prenger et al. , 2019 ) . Early neural TTS systems have used an autoregressive ( AR ) architecture to generate a melspectrogram mainly because of its two benefits . First , the AR generation eases the difficulty of modeling mel-spectrogram distribution by factorizing the distribution into the product of homogeneous conditional factors in sequential order . Second , the seq2seq based AR architecture helps the model predict the length of the target mel-spectrogram from an input text , which is a non-trivial task because there are no pre-defined rules between the lengths of text and mel-spectrogram . Although they facilitate high-quality speech synthesis , AR TTS models have several shortcomings . First , they can not generate a mel-spectrogram in parallel , so the inference time increases linearly with mel-spectrogram time steps . Second , the AR-based generation suffers from accumulated prediction error , resulting in being vulnerable to the out-of-domain data , e.g . very long input text , or text patterns not existing in the training dataset . In this work , we present a novel non-AR TTS model called BVAE-TTS that achieves fast and robust high-quality speech synthesis . BVAE-TTS generates a mel-spectrogram in parallel by adopting a bidirectional-inference variational autoencoder ( BVAE ) ( Sønderby et al. , 2016 ; Kingma et al. , 2016 ; Maaløe et al. , 2019 ; Vahdat & Kautz , 2020 ) consisting of 1-D convolutional networks . For the high-quality speech synthesis , BVAE-TTS learns mel-spectrogram distribution jointly with hierarchical latent variables in a bidirectional manner , where BVAE uses both bottom-up and top-down paths . Furthermore , to match the length of the target mel-spectrogram at inference , BVAE-TTS has an additional module called duration predictor , which predicts how many steps of a mel-spectrogram will be generated from each phoneme . To train the duration predictor , we employ an attention mechanism in BVAE-TTS to make BVAE-TTS utilize the text while learning attention maps between the text and the mel-spectrogram , where the mapping information is used for duration labels . Our BVAE-TTS has advantages over the previous non-AR TTS models as follows : • It has a simpler training process compared to the previous non-AR TTS models such as ParaNet ( Peng et al. , 2020 ) and FastSpeech ( Ren et al. , 2019 ) . In the previous TTS models , well-trained AR teacher models are needed for duration labels or knowledge-distillation . Although FastSpeech 2 ( Ren et al. , 2020 ) removes the dependency on the teacher model , it still requires additional duration labels and acoustic features prepared in advance using other speech analysis methods . In contrast , BVAE-TTS requires only the text-speech paired dataset without any helps from the teacher model . • It is more flexible in designing its architecture compared to the previous flow-based non-AR TTS models such as Flow-TTS ( Miao et al. , 2020 ) and Glow-TTS ( Kim et al. , 2020 ) . The flow-based models have architectural constraints caused by their bijective transformation property , which leads to deeper models with a lot of parameters . On the contrary , the VAE-based model is free from the architectural constraints . In experiments , we compare our BVAE-TTS with Tacotron 2 and Glow-TTS in terms of speech quality , inference speed , and model size . The results show that our model achieves 27 times speed improvement over Tacotron 2 in generating a mel-spectrogram with similar speech quality . Furthermore , BVAE-TTS outperforms the state-of-the-art non-AR TTS model , Glow-TTS , in both speech quality and inference time , while having 58 % fewer model parameters . Additionally , we analyze how the latent representations are learned by BVAE-TTS . In this analysis , we confirm that the bottom part of BVAE-TTS captures the variation of mel-spectrograms that can occur from a text . Related work : In the meantime , several TTS systems have utilized VAE to relax the one-to-many mapping nature in TTS , so improve the naturalness and the controllability of the systems . For example , ( Hsu et al. , 2018 ) and ( Zhang et al. , 2019 ) incorporate VAE to Tacotron 2 to learn the style or prosody of the input speech . However , previous uses of VAE have been limited to an auxiliary network in TTS based on the main AR TTS model . To the best of our knowledge , our BVAE-TTS is the first parallel TTS model that directly uses the VAE architecture to the task of TTS . More discussions about other related works on the previous non-AR TTS models are in Section 5 . 2 BACKGROUND . 2.1 BIDIRECTIONAL-INFERENCE VARIATIONAL AUTOENCODER Variational autoencoder ( VAE ) is a neural network generative model pθ ( x , z ) parameterized by θ , where x is an observed data and z is a latent vector . In practice , since we only have a dataset X = { x1 , ... , xN } without the knowledge about z , θ is typically optimized by maximizing the likelihood : max θ logpθ ( X ) = max θ N∑ i=1 log ∫ z pθ ( xi , z ) dz . ( 1 ) However , the integral over z is intractable to compute . Therefore , the VAE introduces an approximate posterior qφ ( z|x ) and does variational inference while maximizing the evidence lower bound ( ELBO ) : logpθ ( x ) ≥ Eqφ ( z|x ) [ logpθ ( x|z ) ] −DKL [ qφ ( z|x ) ||p ( z ) ] . ( 2 ) In practice , for easy sampling and easy computation of the KL-divergence , each of the prior p ( z ) and the approximate posterior qφ ( z|x ) is usually modeled as a multivariate normal distribution with a diagonal covariance matrix . For a more expressive model , the latent vector z can be factorized into { z1 , ... , zK } with hierarchical dependency , where K is the number of hierarchies . Then , each of the prior and the approximate posterior is represented as pθ ( z ) = Πkpθ ( zk|z < k ) and qφ ( z|x ) = Πkqφ ( zk|z < k , x ) , respectively . In ( Sønderby et al. , 2016 ; Kingma et al. , 2016 ; Vahdat & Kautz , 2020 ) , the variational inference is designed in a bidirectional way based on bottom-up path and top-down path , while letting the inference network ( left ) and generative network ( right ) share their parameters as shown in Figure 1 . First , along the bottom-up path , BVAE extracts hierarchical features from x and stores them inside of it . Then , along the top-down path , BVAE does the variational inference and reconstructs the input data considering the stored hierarchical features together . This architecture helps the model effectively learn the hierarchies between the latent variables , and equation ( 2 ) is changed as follows : logpθ ( x ) ≥ Eqφ ( z|x ) [ logpθ ( x|z ) ] − K∑ k=1 Eqφ ( z < k|x ) [ DKL [ qφ ( zk|x , z < k ) ||p ( zk|z < k ) ] ] . ( 3 ) 2.2 DURATION PREDICTOR IN NON-AUTOREGRESSIVE TEXT-TO-SPEECH . To achieve the non-autoregressive ( non-AR ) text-to-speech ( TTS ) model , the model needs to predict the length of the target mel-spectrogram from a text . This is because there is no way to access to the length of the target mel-spectrogram at inference . However , this is a challenging task considering that there are no pre-defined rules between the lengths of text and mel-spectrogram . Recently , several non-AR TTS models ( Ren et al. , 2019 ; Zeng et al. , 2020 ; Kim et al. , 2020 ) resolved the issue by introducing a module called duration predictor . The duration predictor is a module that predicts how many mel-spectrogram steps will be generated from each phoneme . First , using the duration predictor , the non-AR TTS models compute durations D̂ = { d̂1 , ... , d̂S } corresponding to each phoneme based on phoneme representations H = { h1 , ... , hS } , where each d̂i is a positive integer that is rounded off from a positive real number , and S is the number of phonemes . Then , H is expanded to the length of the target mel-spectrogram T , by repeating each hi as many steps as d̂i . Finally , the non-AR TTS models generate a mel-spectrogram in parallel by decoding the expanded phoneme representations . In practice , since there are no ground-truth duration labels for the training of the duration predictor , the non-AR models obtain the duration labels using various methods , and we adopt a method used in FastSpeech ( Ren et al. , 2019 ) . From well-aligned attention maps , the duration labels are obtained according to di = ∑t=T t=1 [ argmaxs as , t == i ] , where as , t represents an attention weight given from the t-th mel-spectrogram step to the s-th phoneme . 3 METHODOLOGY . In this section , we explain a novel non-autoregressive ( non-AR ) TTS model , BVAE-TTS , which is based on the bidirectional-inference variational autoencoder ( BVAE ) . As shown in Figure 2- ( a ) , during training , BVAE-TTS is given a mel-spectrogram with a phoneme sequence , and it is trained to reconstruct the mel-spectrogram while maximizing the ELBO . Here , the duration predictor is jointly trained using the attention maps that BVAE-TTS generates during training . As shown in Figure 2- ( c ) , at inference BVAE-TTS generates a mel-spectrogram from a phoneme sequence using the duration predictor as described in Section 2.2 , while using its top-down path for decoding the expanded phoneme representations . In Appendix A.1 , pseudo-codes for the training and inference of BVAE-TTS are contained for detailed descriptions . The other aspects of BVAE-TTS are described in the following sub-sections in more detail . 3.1 USING BVAE FOR TEXT-TO-SPEECH . Unlike the previous BVAE models ( Sønderby et al. , 2016 ; Kingma et al. , 2016 ; Vahdat & Kautz , 2020 ) are trained to generate natural images , our model should learn to generate a mel-spectrogram that is not only natural but also corresponding to the input text . To this end , we add a dot-product attention network ( Bahdanau et al. , 2015 ) on top of the BVAE , which is a channel for BVAE-TTS to learn how to utilize the text properly . First , using a text encoder , key ( K ) and value ( V ) are obtained from a phoneme sequence , and from the bottom-up path , query ( Q ) is obtained . Here , obtaining Q is different from the bottom-up paths of the previous BVAE studies used in the image domain , where only the parameters for posterior approximation are obtained . Second , based on the dot-product attention with Q , K , and V , the V are expanded to Vexp to fit the length of the top-down path , and then the Vexp is inputted into the top-down path of BVAE-TTS . Lastly , the BVAE-TTS does both the variational inference and mel-spectrogram reconstruction along the top-down path using the expanded text representations with the following objectives : Lrecon = −Eqφ ( z|x , y ) [ logpθ ( x|z , y ) ] , ( 4 ) LKL = K∑ k=1 Eqφ ( z < k|x , y ) [ DKL [ qφ ( zk|x , z < k , y ) ||p ( zk|z < k , y ) ] ] , ( 5 ) where x represents mel-spectrogram , y represents text , z represents latent representation , and mean absolute error ( MAE ) loss is used for the Lrecon . In addition to that , a duration predictor is jointly trained to predict durations corresponding to each phoneme in the logarithmic domain using mean square error ( MSE ) loss , Ldur = E [ ( log di − log d̂i ) 2 ] , where di and d̂i are obtained as described in Section 2.2 . The duration predictor takes as input the V obtained from the text encoder , and here the V is detached from the computational graph to prevent it from affecting the BVAE training . | This paper presents BVAE-TTS, which applies hierarchical VAEs (using an approach motivated by NVAE and Ladder VAEs) to the problem of parallel TTS. The main components of the system are a dot product-based attention mechanism that is used during training to produce phoneme duration targets for the parallel duration predictor (that is used during synthesis) and the hierarchical VAE that converts duration-replicated phoneme features into mel spectrogram frames (which are converted to waveform samples using a pre-trained WaveGlow vocoder). The system is compared to Glow-TTS (a similar parallel system that uses flows instead of VAEs) and Tacotron 2 (a non-parallel autoregressive system) in terms of MOS naturalness, synthesis speed, and parameter efficiency. | SP:99b3ac117a5c787653031eb169f0104a8594c088 |
Bidirectional Variational Inference for Non-Autoregressive Text-to-Speech | 1 INTRODUCTION . End-to-end text-to-speech ( TTS ) systems have recently attracted much attention , as neural TTS models began to generate high-quality speech that is very similar to the human voice ( Sotelo et al. , 2017 ; Wang et al. , 2017 ; Shen et al. , 2018 ; Ping et al. , 2018 ; Li et al. , 2019 ) . Typically , those TTS systems first generate a mel-spectrogram from a text using a sequence-to-sequence ( seq2seq ) model ( Sutskever et al. , 2014 ) and then synthesize speech from the mel-spectrogram using a neural vocoder like WaveGlow ( Prenger et al. , 2019 ) . Early neural TTS systems have used an autoregressive ( AR ) architecture to generate a melspectrogram mainly because of its two benefits . First , the AR generation eases the difficulty of modeling mel-spectrogram distribution by factorizing the distribution into the product of homogeneous conditional factors in sequential order . Second , the seq2seq based AR architecture helps the model predict the length of the target mel-spectrogram from an input text , which is a non-trivial task because there are no pre-defined rules between the lengths of text and mel-spectrogram . Although they facilitate high-quality speech synthesis , AR TTS models have several shortcomings . First , they can not generate a mel-spectrogram in parallel , so the inference time increases linearly with mel-spectrogram time steps . Second , the AR-based generation suffers from accumulated prediction error , resulting in being vulnerable to the out-of-domain data , e.g . very long input text , or text patterns not existing in the training dataset . In this work , we present a novel non-AR TTS model called BVAE-TTS that achieves fast and robust high-quality speech synthesis . BVAE-TTS generates a mel-spectrogram in parallel by adopting a bidirectional-inference variational autoencoder ( BVAE ) ( Sønderby et al. , 2016 ; Kingma et al. , 2016 ; Maaløe et al. , 2019 ; Vahdat & Kautz , 2020 ) consisting of 1-D convolutional networks . For the high-quality speech synthesis , BVAE-TTS learns mel-spectrogram distribution jointly with hierarchical latent variables in a bidirectional manner , where BVAE uses both bottom-up and top-down paths . Furthermore , to match the length of the target mel-spectrogram at inference , BVAE-TTS has an additional module called duration predictor , which predicts how many steps of a mel-spectrogram will be generated from each phoneme . To train the duration predictor , we employ an attention mechanism in BVAE-TTS to make BVAE-TTS utilize the text while learning attention maps between the text and the mel-spectrogram , where the mapping information is used for duration labels . Our BVAE-TTS has advantages over the previous non-AR TTS models as follows : • It has a simpler training process compared to the previous non-AR TTS models such as ParaNet ( Peng et al. , 2020 ) and FastSpeech ( Ren et al. , 2019 ) . In the previous TTS models , well-trained AR teacher models are needed for duration labels or knowledge-distillation . Although FastSpeech 2 ( Ren et al. , 2020 ) removes the dependency on the teacher model , it still requires additional duration labels and acoustic features prepared in advance using other speech analysis methods . In contrast , BVAE-TTS requires only the text-speech paired dataset without any helps from the teacher model . • It is more flexible in designing its architecture compared to the previous flow-based non-AR TTS models such as Flow-TTS ( Miao et al. , 2020 ) and Glow-TTS ( Kim et al. , 2020 ) . The flow-based models have architectural constraints caused by their bijective transformation property , which leads to deeper models with a lot of parameters . On the contrary , the VAE-based model is free from the architectural constraints . In experiments , we compare our BVAE-TTS with Tacotron 2 and Glow-TTS in terms of speech quality , inference speed , and model size . The results show that our model achieves 27 times speed improvement over Tacotron 2 in generating a mel-spectrogram with similar speech quality . Furthermore , BVAE-TTS outperforms the state-of-the-art non-AR TTS model , Glow-TTS , in both speech quality and inference time , while having 58 % fewer model parameters . Additionally , we analyze how the latent representations are learned by BVAE-TTS . In this analysis , we confirm that the bottom part of BVAE-TTS captures the variation of mel-spectrograms that can occur from a text . Related work : In the meantime , several TTS systems have utilized VAE to relax the one-to-many mapping nature in TTS , so improve the naturalness and the controllability of the systems . For example , ( Hsu et al. , 2018 ) and ( Zhang et al. , 2019 ) incorporate VAE to Tacotron 2 to learn the style or prosody of the input speech . However , previous uses of VAE have been limited to an auxiliary network in TTS based on the main AR TTS model . To the best of our knowledge , our BVAE-TTS is the first parallel TTS model that directly uses the VAE architecture to the task of TTS . More discussions about other related works on the previous non-AR TTS models are in Section 5 . 2 BACKGROUND . 2.1 BIDIRECTIONAL-INFERENCE VARIATIONAL AUTOENCODER Variational autoencoder ( VAE ) is a neural network generative model pθ ( x , z ) parameterized by θ , where x is an observed data and z is a latent vector . In practice , since we only have a dataset X = { x1 , ... , xN } without the knowledge about z , θ is typically optimized by maximizing the likelihood : max θ logpθ ( X ) = max θ N∑ i=1 log ∫ z pθ ( xi , z ) dz . ( 1 ) However , the integral over z is intractable to compute . Therefore , the VAE introduces an approximate posterior qφ ( z|x ) and does variational inference while maximizing the evidence lower bound ( ELBO ) : logpθ ( x ) ≥ Eqφ ( z|x ) [ logpθ ( x|z ) ] −DKL [ qφ ( z|x ) ||p ( z ) ] . ( 2 ) In practice , for easy sampling and easy computation of the KL-divergence , each of the prior p ( z ) and the approximate posterior qφ ( z|x ) is usually modeled as a multivariate normal distribution with a diagonal covariance matrix . For a more expressive model , the latent vector z can be factorized into { z1 , ... , zK } with hierarchical dependency , where K is the number of hierarchies . Then , each of the prior and the approximate posterior is represented as pθ ( z ) = Πkpθ ( zk|z < k ) and qφ ( z|x ) = Πkqφ ( zk|z < k , x ) , respectively . In ( Sønderby et al. , 2016 ; Kingma et al. , 2016 ; Vahdat & Kautz , 2020 ) , the variational inference is designed in a bidirectional way based on bottom-up path and top-down path , while letting the inference network ( left ) and generative network ( right ) share their parameters as shown in Figure 1 . First , along the bottom-up path , BVAE extracts hierarchical features from x and stores them inside of it . Then , along the top-down path , BVAE does the variational inference and reconstructs the input data considering the stored hierarchical features together . This architecture helps the model effectively learn the hierarchies between the latent variables , and equation ( 2 ) is changed as follows : logpθ ( x ) ≥ Eqφ ( z|x ) [ logpθ ( x|z ) ] − K∑ k=1 Eqφ ( z < k|x ) [ DKL [ qφ ( zk|x , z < k ) ||p ( zk|z < k ) ] ] . ( 3 ) 2.2 DURATION PREDICTOR IN NON-AUTOREGRESSIVE TEXT-TO-SPEECH . To achieve the non-autoregressive ( non-AR ) text-to-speech ( TTS ) model , the model needs to predict the length of the target mel-spectrogram from a text . This is because there is no way to access to the length of the target mel-spectrogram at inference . However , this is a challenging task considering that there are no pre-defined rules between the lengths of text and mel-spectrogram . Recently , several non-AR TTS models ( Ren et al. , 2019 ; Zeng et al. , 2020 ; Kim et al. , 2020 ) resolved the issue by introducing a module called duration predictor . The duration predictor is a module that predicts how many mel-spectrogram steps will be generated from each phoneme . First , using the duration predictor , the non-AR TTS models compute durations D̂ = { d̂1 , ... , d̂S } corresponding to each phoneme based on phoneme representations H = { h1 , ... , hS } , where each d̂i is a positive integer that is rounded off from a positive real number , and S is the number of phonemes . Then , H is expanded to the length of the target mel-spectrogram T , by repeating each hi as many steps as d̂i . Finally , the non-AR TTS models generate a mel-spectrogram in parallel by decoding the expanded phoneme representations . In practice , since there are no ground-truth duration labels for the training of the duration predictor , the non-AR models obtain the duration labels using various methods , and we adopt a method used in FastSpeech ( Ren et al. , 2019 ) . From well-aligned attention maps , the duration labels are obtained according to di = ∑t=T t=1 [ argmaxs as , t == i ] , where as , t represents an attention weight given from the t-th mel-spectrogram step to the s-th phoneme . 3 METHODOLOGY . In this section , we explain a novel non-autoregressive ( non-AR ) TTS model , BVAE-TTS , which is based on the bidirectional-inference variational autoencoder ( BVAE ) . As shown in Figure 2- ( a ) , during training , BVAE-TTS is given a mel-spectrogram with a phoneme sequence , and it is trained to reconstruct the mel-spectrogram while maximizing the ELBO . Here , the duration predictor is jointly trained using the attention maps that BVAE-TTS generates during training . As shown in Figure 2- ( c ) , at inference BVAE-TTS generates a mel-spectrogram from a phoneme sequence using the duration predictor as described in Section 2.2 , while using its top-down path for decoding the expanded phoneme representations . In Appendix A.1 , pseudo-codes for the training and inference of BVAE-TTS are contained for detailed descriptions . The other aspects of BVAE-TTS are described in the following sub-sections in more detail . 3.1 USING BVAE FOR TEXT-TO-SPEECH . Unlike the previous BVAE models ( Sønderby et al. , 2016 ; Kingma et al. , 2016 ; Vahdat & Kautz , 2020 ) are trained to generate natural images , our model should learn to generate a mel-spectrogram that is not only natural but also corresponding to the input text . To this end , we add a dot-product attention network ( Bahdanau et al. , 2015 ) on top of the BVAE , which is a channel for BVAE-TTS to learn how to utilize the text properly . First , using a text encoder , key ( K ) and value ( V ) are obtained from a phoneme sequence , and from the bottom-up path , query ( Q ) is obtained . Here , obtaining Q is different from the bottom-up paths of the previous BVAE studies used in the image domain , where only the parameters for posterior approximation are obtained . Second , based on the dot-product attention with Q , K , and V , the V are expanded to Vexp to fit the length of the top-down path , and then the Vexp is inputted into the top-down path of BVAE-TTS . Lastly , the BVAE-TTS does both the variational inference and mel-spectrogram reconstruction along the top-down path using the expanded text representations with the following objectives : Lrecon = −Eqφ ( z|x , y ) [ logpθ ( x|z , y ) ] , ( 4 ) LKL = K∑ k=1 Eqφ ( z < k|x , y ) [ DKL [ qφ ( zk|x , z < k , y ) ||p ( zk|z < k , y ) ] ] , ( 5 ) where x represents mel-spectrogram , y represents text , z represents latent representation , and mean absolute error ( MAE ) loss is used for the Lrecon . In addition to that , a duration predictor is jointly trained to predict durations corresponding to each phoneme in the logarithmic domain using mean square error ( MSE ) loss , Ldur = E [ ( log di − log d̂i ) 2 ] , where di and d̂i are obtained as described in Section 2.2 . The duration predictor takes as input the V obtained from the text encoder , and here the V is detached from the computational graph to prevent it from affecting the BVAE training . | Neural models that autoregressively generate mel spectrograms from text (or phonemes), such as Tacotron, have been used to generate high quality synthetic speech. However, they suffer from slow inference speed due to their autoregressive nature. To alleviate this, non-autoregressive models have been proposed, such as FastSpeech and Glow-TTS. The proposed model, BVAE-TTS, is yet another non-autoregressive speech synthesis model (outputting spectrograms), with two key advantages over the aforementioned models: (a) no autoregressive teacher model is required, as in FastSpeech, which simplifies training, and (b) fewer parameters are needed than in Glow-TTS, since there is no bijectivity constraint (allowing a more expressive architecture to be used). Models are compared with inference speed and MOS, and BVAE-TTS compares favorably on both both metrics when compared to Glow-TTS. | SP:99b3ac117a5c787653031eb169f0104a8594c088 |
Task-Agnostic Morphology Evolution | 1 INTRODUCTION . Recently , deep reinforcement learning has shown impressive success in continuous control problems across a wide range of environments ( Schulman et al. , 2017 ; Barth-Maron et al. , 2018 ; Haarnoja et al. , 2018 ) . The performance of these algorithms is usually measured via the reward achieved by a pre-specified morphology on a pre-specified task . Arguably , such a setting where both the morphology and the task are fixed limits the expressiveness of behavior learning . Biological agents , on the other hand , both adapt their morphology ( through evolution ) and are simultaneously able to solve a multitude of tasks . This is because an agent ’ s performance is intertwined with its morphology as morphology fundamentally endows an agent with the ability to act . But how should one design morphologies that are performative across tasks ? Recent works have approached morphology design using alternating optimization schemes ( Hazard et al. , 2018 ; Wang et al. , 2019 ; Luck et al. , 2020 ) . Here , one step evaluates the performance of morphologies through behavior optimization while the second step improves the morphology design typically through gradient-free optimization . It thus follows that the final morphology ’ s quality will depend directly on the quality of learned behavior as inadequate policy learning will result in a noisy signal to the morphology learner . This begs the question : is behavior learning a necessary crutch upon which morphology optimization should stand ? Unfortunately , behavior learning across a multitude of tasks is both difficult and expensive and hence a precise evaluation of each new candidate morphology requires explicit policy training . As a result , current research on morphology optimization primarily focuses on improving morphology for just one task ( Wang et al. , 2019 ; Ha , 2019 ) . By exploiting task-specific signals , learned morphologies demonstrate impressive performance but provide no guarantees of success outside of the portion of the environment covered by the given task . This is at odds with biological morphologies that are usually able to complete many tasks within their environment . Fundamentally , we want agents that are generalists , not specialists and as such , we seek to shift the paradigm of morphology optimization to multi-task environments . One obvious solution to this issue would be to just learn multiple behaviors in the behavior-learning step . However , such an approach has two challenges . First , multi-task RL is both algorithmically and computationally inhibiting , and hence in itself is an active area of research ( Fu et al. , 2016 ; Yu et al. , 2020 ) . Second , it is unrealistic to assume that we can enumerate all the tasks we would want an agent to perform before its inception . In this work , we propose a framework for morphology design without the requirements of behavior learning or task specification . Instead , inspired by contemporary work in unsupervised skill discovery ( Eysenbach et al. , 2018 ; Sharma et al. , 2019 ) and empowerment ( Mohamed & Rezende , 2015 ) , we derive a task-agnostic objective to evaluate the quality of a morphology . The key idea behind this evaluator is that a performant morphology is likely one that exhibits strong exploration and control by easily reaching a large number of states in a predictable manner . We formalize this intuition with an information-theoretic objective and use it as a fitness function in an evolutionary optimization loop . Candidate morphologies are mutated and then randomly sample and execute action primitives in their environment . The resulting data is used to estimate the agents ’ fitness per the information-theoretic objective . Our contributions are summarized as follows : First , we derive an easily computable informationtheoretic objective to rank morphologies by their ability to explore and control their environment . Second , using this metric in conjunction with Graph Neural Networks , we develop Task-Agnostic Morphology Evolution ( TAME ) , an unsupervised algorithm for discovering morphologies of an arbitrary number of limbs using only randomly sampled action primitives . Third , we empirically demonstrate that across 2D , 3D , and manipulation environments TAME can evolve morphologies that match the multi-task performance of those learned with task supervised algorithms . 2 RELATED WORK . Our approach to morphology optimization builds on a broad set of prior work . For conciseness , we summarize the most relevant ones . Morphology Optimization . Optimizing hardware has been a long studied problem , yet most approaches share two common attributes : first , they all focus on a single task , and second , they all explicitly learn behavior for that task . Sims ( 1994 ) pioneered the field of morphology optimization by simultaneously evolving morphologies of 3D-blocks and their policy networks . Cheney et al . ( 2013 ) and Cheney et al . ( 2018 ) reduce the search space by constraining form and function to oscillating 3D voxels . More recently , Nygaard et al . ( 2020 ) evolve the legs of a real-world robot . Unlike TAME , these approaches depend on task reward as a fitness function to maintain and update a population of agents . Quality diversity based objectives ( Lehman & Stanley , 2011 ; Nordmoen et al. , 2020 ) augment regular task-fitness with unsupervised objectives to discover a diverse population of agents . These approaches are complementary to ours as quality diversity metrics could be incorporated into the TAME algorithm for similar effects . RL has also been applied to optimize the parameters of an agent ’ s pre-defined structure . Ha ( 2019 ) use a population-based policy-gradient method , Schaff et al . ( 2019 ) utilize a distribution over hardware parameters , Luck et al . ( 2020 ) learn a morphology conditioned value function , and Chen et al . ( 2020 ) treat hardware as policy parameters by simulating the agent with computational graphs . While these RL-based approaches explicitly learn task behavior to inform morphology optimization , we do not learn any policies due to their computation expense . Moreover , all these methods are gradient-based , restricting them to fixed topology optimization where morphologies can not have a varying number of joints . Graph Neural Networks . Graph Neural Networks have shown to be effective representations for policy learning across arbitrary agent topologies ( Wang et al. , 2018 ; Huang et al. , 2020 ) . These representations have also been used for agent design . Pathak et al . ( 2019 ) treats agent construction as an RL problem by having modular robots learn to combine . Most related to our work , Neural Graph Evolution ( NGE ) Wang et al . ( 2019 ) evolves agents over arbitrary graph structures by transferring behavior policies from parent to child . Unlike other RL approaches , the use of graph networks allows NGE to mutate arbitrary structures . While these works again are task supervised and only learn morphology for forward locomotion , they inform our use of GNNs to estimate our learning objective . Information Theory and RL . Our information theoretic objective is inspired by several recent works at the intersection of unsupervised RL and information theory . Eysenbach et al . ( 2018 ) and Sharma et al . ( 2019 ) both use information theoretic objectives in order to discover state-covering skills . We apply similar logic to the problem of discovering state-covering morphologies . Gregor et al . ( 2016 ) , Mohamed & Rezende ( 2015 ) and Zhao et al . ( 2020 ) estimate a quantity called “ empowerment ” ( Klyubin et al. , 2005 ) for intrinsic motivation . While empowerment maximizes the mutual information between final state and a sequence of actions by changing actions , we optimize the mutual information over morphologies . Additionally , these metrics for intrinsic motivation require policy learning . More broadly , Oord et al . ( 2018 ) use mutual information to learn representations in an unsupervised manner . 3 METHOD . In this section we introduce our algorithm for Task Agnostic Morphology Evolution ( TAME ) . TAME works by ranking morphologies of arbitrary topology by an information theoretic quantity that serves as proxy for how well an agent can explore and control its environment . Practically , this is accomplished using a GNN to predict the action primitive a morphology executed to reach a specific state . By progressively mutating agents of high fitness according to this metric , TAME discovers morphologies functional over a large portion of the environment without task specification . 3.1 A TASK-AGNOSTIC OBJECTIVE FOR FITNESS . In order to accomplish any task in its environment , a morphology should be able to reliably reach any state through a unique sequence of actions . For example , a morphology that can reach many states but does so stochastically is uncontrollable , while a morphology that can visit a diverse set of states as a consequence of its actions is empowered . We capture this intuition using information theory . Let S , ST , A , and M be random variables representing starting state , terminal state , action primitive , and morphology respectively . Our overall objective is to find morphologies that exhibit high mutual information between terminal states and action primitives , I ( ST ; A|S ) = H ( ST |S ) −H ( ST |A , S ) . Concretely , starting at state S , a good morphology ought to be able to visit a large number of terminal states or equivalently have high entropy H ( ST |S ) . Second , the attained terminal state ST ought to be easily predicted given the action primitive taken A , or H ( ST |A , S ) should be low . As we seek to find morphologies that innately maximize this quantity , our objective becomes argmaxm I ( ST ; A|S , M = m ) . By assuming that all morphologies begin in the same state , we remove the objective ’ s dependence on starting state S and derive a variational lower bound as in ( Barber & Agakov , 2003 ) . argmax m I ( ST ; A|M = m ) = argmax m H ( A|M = m ) −H ( A|ST , M = m ) ≥ argmax m H ( A|M = m ) + Ea∼p ( A|m ) , sT∼p ( ST |a , m ) [ log qφ ( a|sT , m ) ] Note that in the first line we take the dual definition of mutual information , that a morphology M should be able to take as many actions as possible and each of those actions should be predictable from the final state ST . The action distribution depends on the size of the action space of the morphology , thus a ∼ p ( A|m ) and the dynamics also depends on the morphology , thus sT ∼ p ( ST |a , m ) . We then attain a lower bound on our objective by using a classifier qφ ( a|sT , m ) to predict the action primitive taken given a morphology and final state . However , as written this objective still presents a problem : different morphologies have different action spaces , and thus would require different action primitives . We resolve this issue by assuming that each morphology m is composed of k ( m ) joints and that every joint has the same possible set of action primitives . Thus an overall action primitive can be denoted as A = { A1 , ... , Ak ( m ) } and we denote |Aj | as the number of possible primitives for joint j . If we take each joint ’ s action primitive to be independently sampled from a uniform distribution , we can reduce the H ( A|M ) term . We get : argmax m H ( A|M = m ) + Ea∼p ( A|m ) , sT∼p ( ST |a , m ) [ log qφ ( a|sT , m ) ] = argmax m k ( m ) ( log |Aj |+ ( 1/k ( m ) ) Ea∼p ( A|m ) , sT∼p ( ST |a , m ) [ log qφ ( a|sT , m ] ) ≥ argmax m ( k ( m ) ) λ ( log |Aj |+ ( 1/k ( m ) ) Ea∼p ( A|m ) , sT∼p ( ST |a , m ) [ log qφ ( a|sT , m ) ] ) ( 1 ) where 0 ≤ λ ≤ 1 . A full derivation can be found in Appendix A . The resulting objective has two terms . The latter can be interpreted as the average mutual information between the actions of each joint Aj and the final state ST . The former can be interpreted as an adjustment to the overall morphology ’ s information capacity based on the size of its action space or number of joints . Left untouched the objective would grow linearly in number of joints , but logarithmically in the accuracy of qφ . As later detailed in section 3.3 , we only want the best morphologies to have high classification accuracy . As such , we introduce a regularizer λ to attenuate the effect of adding more limbs and emphasize predictability . Similar to empowerment , our objective uses the mutual information between states and actions . However rather than conditioning on starting state and maximizing over a sequence of actions , we maximize with respect to morphology . By assuming the distribution of joint action primitives is uniform , we assume that morphologies ought to use all abilities endowed by their structure . In the next section , we detail how we practically estimate this objective over a set of morphologies . | This paper develops a general morphology evolution algorithm, and demonstrates its utility in a setting where morphologies are encoded as graphs. The methodology is grounded in a theoretical notion of empowerment, and theory is introduced that extends empowerment to the case of morphology. The morphology evolution itself requires no task-specific signals, but yields morphologies that generalize well to several tasks of interest. | SP:c137c12d6f9dfed77ea6b51e05ef79aa8ac2a987 |
Task-Agnostic Morphology Evolution | 1 INTRODUCTION . Recently , deep reinforcement learning has shown impressive success in continuous control problems across a wide range of environments ( Schulman et al. , 2017 ; Barth-Maron et al. , 2018 ; Haarnoja et al. , 2018 ) . The performance of these algorithms is usually measured via the reward achieved by a pre-specified morphology on a pre-specified task . Arguably , such a setting where both the morphology and the task are fixed limits the expressiveness of behavior learning . Biological agents , on the other hand , both adapt their morphology ( through evolution ) and are simultaneously able to solve a multitude of tasks . This is because an agent ’ s performance is intertwined with its morphology as morphology fundamentally endows an agent with the ability to act . But how should one design morphologies that are performative across tasks ? Recent works have approached morphology design using alternating optimization schemes ( Hazard et al. , 2018 ; Wang et al. , 2019 ; Luck et al. , 2020 ) . Here , one step evaluates the performance of morphologies through behavior optimization while the second step improves the morphology design typically through gradient-free optimization . It thus follows that the final morphology ’ s quality will depend directly on the quality of learned behavior as inadequate policy learning will result in a noisy signal to the morphology learner . This begs the question : is behavior learning a necessary crutch upon which morphology optimization should stand ? Unfortunately , behavior learning across a multitude of tasks is both difficult and expensive and hence a precise evaluation of each new candidate morphology requires explicit policy training . As a result , current research on morphology optimization primarily focuses on improving morphology for just one task ( Wang et al. , 2019 ; Ha , 2019 ) . By exploiting task-specific signals , learned morphologies demonstrate impressive performance but provide no guarantees of success outside of the portion of the environment covered by the given task . This is at odds with biological morphologies that are usually able to complete many tasks within their environment . Fundamentally , we want agents that are generalists , not specialists and as such , we seek to shift the paradigm of morphology optimization to multi-task environments . One obvious solution to this issue would be to just learn multiple behaviors in the behavior-learning step . However , such an approach has two challenges . First , multi-task RL is both algorithmically and computationally inhibiting , and hence in itself is an active area of research ( Fu et al. , 2016 ; Yu et al. , 2020 ) . Second , it is unrealistic to assume that we can enumerate all the tasks we would want an agent to perform before its inception . In this work , we propose a framework for morphology design without the requirements of behavior learning or task specification . Instead , inspired by contemporary work in unsupervised skill discovery ( Eysenbach et al. , 2018 ; Sharma et al. , 2019 ) and empowerment ( Mohamed & Rezende , 2015 ) , we derive a task-agnostic objective to evaluate the quality of a morphology . The key idea behind this evaluator is that a performant morphology is likely one that exhibits strong exploration and control by easily reaching a large number of states in a predictable manner . We formalize this intuition with an information-theoretic objective and use it as a fitness function in an evolutionary optimization loop . Candidate morphologies are mutated and then randomly sample and execute action primitives in their environment . The resulting data is used to estimate the agents ’ fitness per the information-theoretic objective . Our contributions are summarized as follows : First , we derive an easily computable informationtheoretic objective to rank morphologies by their ability to explore and control their environment . Second , using this metric in conjunction with Graph Neural Networks , we develop Task-Agnostic Morphology Evolution ( TAME ) , an unsupervised algorithm for discovering morphologies of an arbitrary number of limbs using only randomly sampled action primitives . Third , we empirically demonstrate that across 2D , 3D , and manipulation environments TAME can evolve morphologies that match the multi-task performance of those learned with task supervised algorithms . 2 RELATED WORK . Our approach to morphology optimization builds on a broad set of prior work . For conciseness , we summarize the most relevant ones . Morphology Optimization . Optimizing hardware has been a long studied problem , yet most approaches share two common attributes : first , they all focus on a single task , and second , they all explicitly learn behavior for that task . Sims ( 1994 ) pioneered the field of morphology optimization by simultaneously evolving morphologies of 3D-blocks and their policy networks . Cheney et al . ( 2013 ) and Cheney et al . ( 2018 ) reduce the search space by constraining form and function to oscillating 3D voxels . More recently , Nygaard et al . ( 2020 ) evolve the legs of a real-world robot . Unlike TAME , these approaches depend on task reward as a fitness function to maintain and update a population of agents . Quality diversity based objectives ( Lehman & Stanley , 2011 ; Nordmoen et al. , 2020 ) augment regular task-fitness with unsupervised objectives to discover a diverse population of agents . These approaches are complementary to ours as quality diversity metrics could be incorporated into the TAME algorithm for similar effects . RL has also been applied to optimize the parameters of an agent ’ s pre-defined structure . Ha ( 2019 ) use a population-based policy-gradient method , Schaff et al . ( 2019 ) utilize a distribution over hardware parameters , Luck et al . ( 2020 ) learn a morphology conditioned value function , and Chen et al . ( 2020 ) treat hardware as policy parameters by simulating the agent with computational graphs . While these RL-based approaches explicitly learn task behavior to inform morphology optimization , we do not learn any policies due to their computation expense . Moreover , all these methods are gradient-based , restricting them to fixed topology optimization where morphologies can not have a varying number of joints . Graph Neural Networks . Graph Neural Networks have shown to be effective representations for policy learning across arbitrary agent topologies ( Wang et al. , 2018 ; Huang et al. , 2020 ) . These representations have also been used for agent design . Pathak et al . ( 2019 ) treats agent construction as an RL problem by having modular robots learn to combine . Most related to our work , Neural Graph Evolution ( NGE ) Wang et al . ( 2019 ) evolves agents over arbitrary graph structures by transferring behavior policies from parent to child . Unlike other RL approaches , the use of graph networks allows NGE to mutate arbitrary structures . While these works again are task supervised and only learn morphology for forward locomotion , they inform our use of GNNs to estimate our learning objective . Information Theory and RL . Our information theoretic objective is inspired by several recent works at the intersection of unsupervised RL and information theory . Eysenbach et al . ( 2018 ) and Sharma et al . ( 2019 ) both use information theoretic objectives in order to discover state-covering skills . We apply similar logic to the problem of discovering state-covering morphologies . Gregor et al . ( 2016 ) , Mohamed & Rezende ( 2015 ) and Zhao et al . ( 2020 ) estimate a quantity called “ empowerment ” ( Klyubin et al. , 2005 ) for intrinsic motivation . While empowerment maximizes the mutual information between final state and a sequence of actions by changing actions , we optimize the mutual information over morphologies . Additionally , these metrics for intrinsic motivation require policy learning . More broadly , Oord et al . ( 2018 ) use mutual information to learn representations in an unsupervised manner . 3 METHOD . In this section we introduce our algorithm for Task Agnostic Morphology Evolution ( TAME ) . TAME works by ranking morphologies of arbitrary topology by an information theoretic quantity that serves as proxy for how well an agent can explore and control its environment . Practically , this is accomplished using a GNN to predict the action primitive a morphology executed to reach a specific state . By progressively mutating agents of high fitness according to this metric , TAME discovers morphologies functional over a large portion of the environment without task specification . 3.1 A TASK-AGNOSTIC OBJECTIVE FOR FITNESS . In order to accomplish any task in its environment , a morphology should be able to reliably reach any state through a unique sequence of actions . For example , a morphology that can reach many states but does so stochastically is uncontrollable , while a morphology that can visit a diverse set of states as a consequence of its actions is empowered . We capture this intuition using information theory . Let S , ST , A , and M be random variables representing starting state , terminal state , action primitive , and morphology respectively . Our overall objective is to find morphologies that exhibit high mutual information between terminal states and action primitives , I ( ST ; A|S ) = H ( ST |S ) −H ( ST |A , S ) . Concretely , starting at state S , a good morphology ought to be able to visit a large number of terminal states or equivalently have high entropy H ( ST |S ) . Second , the attained terminal state ST ought to be easily predicted given the action primitive taken A , or H ( ST |A , S ) should be low . As we seek to find morphologies that innately maximize this quantity , our objective becomes argmaxm I ( ST ; A|S , M = m ) . By assuming that all morphologies begin in the same state , we remove the objective ’ s dependence on starting state S and derive a variational lower bound as in ( Barber & Agakov , 2003 ) . argmax m I ( ST ; A|M = m ) = argmax m H ( A|M = m ) −H ( A|ST , M = m ) ≥ argmax m H ( A|M = m ) + Ea∼p ( A|m ) , sT∼p ( ST |a , m ) [ log qφ ( a|sT , m ) ] Note that in the first line we take the dual definition of mutual information , that a morphology M should be able to take as many actions as possible and each of those actions should be predictable from the final state ST . The action distribution depends on the size of the action space of the morphology , thus a ∼ p ( A|m ) and the dynamics also depends on the morphology , thus sT ∼ p ( ST |a , m ) . We then attain a lower bound on our objective by using a classifier qφ ( a|sT , m ) to predict the action primitive taken given a morphology and final state . However , as written this objective still presents a problem : different morphologies have different action spaces , and thus would require different action primitives . We resolve this issue by assuming that each morphology m is composed of k ( m ) joints and that every joint has the same possible set of action primitives . Thus an overall action primitive can be denoted as A = { A1 , ... , Ak ( m ) } and we denote |Aj | as the number of possible primitives for joint j . If we take each joint ’ s action primitive to be independently sampled from a uniform distribution , we can reduce the H ( A|M ) term . We get : argmax m H ( A|M = m ) + Ea∼p ( A|m ) , sT∼p ( ST |a , m ) [ log qφ ( a|sT , m ) ] = argmax m k ( m ) ( log |Aj |+ ( 1/k ( m ) ) Ea∼p ( A|m ) , sT∼p ( ST |a , m ) [ log qφ ( a|sT , m ] ) ≥ argmax m ( k ( m ) ) λ ( log |Aj |+ ( 1/k ( m ) ) Ea∼p ( A|m ) , sT∼p ( ST |a , m ) [ log qφ ( a|sT , m ) ] ) ( 1 ) where 0 ≤ λ ≤ 1 . A full derivation can be found in Appendix A . The resulting objective has two terms . The latter can be interpreted as the average mutual information between the actions of each joint Aj and the final state ST . The former can be interpreted as an adjustment to the overall morphology ’ s information capacity based on the size of its action space or number of joints . Left untouched the objective would grow linearly in number of joints , but logarithmically in the accuracy of qφ . As later detailed in section 3.3 , we only want the best morphologies to have high classification accuracy . As such , we introduce a regularizer λ to attenuate the effect of adding more limbs and emphasize predictability . Similar to empowerment , our objective uses the mutual information between states and actions . However rather than conditioning on starting state and maximizing over a sequence of actions , we maximize with respect to morphology . By assuming the distribution of joint action primitives is uniform , we assume that morphologies ought to use all abilities endowed by their structure . In the next section , we detail how we practically estimate this objective over a set of morphologies . | The paper introduces an algorithm for optimizing the robot morphology in a simulated environment. The key idea is that instead of finding a morphology and a controller for a specific task, they propose to search for a morphology that can reach a large variety of states in a predictable way. Specifically, they developed an objective function that maximizes the mutual information between the actions and the final states of the robot. The proposed algorithm is demonstrated on a few simulated locomotion and manipulation tasks. | SP:c137c12d6f9dfed77ea6b51e05ef79aa8ac2a987 |
ACT: Asymptotic Conditional Transport | 1 INTRODUCTION . Measuring the difference between two probability distributions is a fundamental problem in statistics and machine learning ( Cover , 1999 ; Bishop , 2006 ; Murphy , 2012 ) . A variety of statistical distances have been proposed to quantify the difference , which often serves as the first step to build a generative model . Commonly used statistical distances include the Kullback–Leibler ( KL ) divergence ( Kullback and Leibler , 1951 ) , Jensen–Shannon ( JS ) divergence ( Lin , 1991 ) , and Wasserstein distance ( Kantorovich , 2006 ) . While being widely used for generative modeling ( Kingma and Welling , 2013 ; Goodfellow et al. , 2014 ; Arjovsky et al. , 2017 ; Balaji et al. , 2019 ) , they all have their own limitations . The KL divergence , directly related to both maximum likelihood estimation and variational inference , is amenable to mini-batch stochastic gradient descent ( SGD ) based optimization ( Wainwright and Jordan , 2008 ; Hoffman et al. , 2013 ; Blei et al. , 2017 ) . However , it requires the two probability distributions to share the same support , and hence is often inapplicable if either of them is an implicit distribution whose probability density function ( PDF ) is unknown ( Mohamed and Lakshminarayanan , 2016 ; Huszár , 2017 ; Tran et al. , 2017 ; Yin and Zhou , 2018 ) . The JS divergence is directly related to the mini-max loss of a generative adversarial net ( GAN ) when the discriminator is optimal ( Goodfellow et al. , 2014 ) . However , it is difficult to maintain a good balance between the generator and discriminator , making GANs notoriously brittle to train . The Wasserstein distance is a widely used metric that allows the two distributions to have non-overlapping supports ( Villani , 2008 ; Santambrogio , 2015 ; Peyré and Cuturi , 2019 ) . However , it is challenging to estimate in its primal form and generally results in biased sample gradients when its dual form is employed ( Arjovsky et al. , 2017 ; Bellemare et al. , 2017 ; Bottou et al. , 2017 ; Bińkowski et al. , 2018 ; Bernton et al. , 2019 ) . To address the limitations of existing measurement methods , we introduce conditional transport ( CT ) as a new divergence to quantify the difference between two probability distributions . We refer to them as the source and target distributions and denote their probability density functions ( PDFs ) as pX ( x ) and pY ( y ) , respectively . The CT divergence is defined with a bidirectional distribution-to-distribution transport . It consists of a forward CT that transports the source to target distribution , and a backward CT that reverses the transport direction . Our intuition is that given a source ( target ) point , it is more likely to be transported to a target ( source ) point closer to it . Denoting d ( x , y ) = d ( y , x ) as a learnable function and c ( x , y ) = c ( y , x ) ≥ 0 , where the equality is true when x = y , as the point-to-point transport cost , the goal is to minimize the transport cost between two distributions . The forward CT is constructed in three steps : 1 ) We define a forward “ navigator ” as π ( y |x ) = e−d ( x , y ) pY ( y ) / ∫ e−d ( x , y ) pY ( y ) dy , a conditional distribution specifying how likely a given source point x will be transported to distribution pY ( y ) via path x → y ; 2 ) We define the cost of a forward x-transporting CT as ∫ c ( x , y ) π ( y |x ) dy , the expected cost of employing the forward navigator to transport x to a random target point ; 3 ) We define the total cost of the forward CT as ∫ pX ( x ) ∫ c ( x , y ) π ( y |x ) dydx , which is the expectation of the cost of a forward x-transporting CT with respect to pX ( x ) . Similarly , we construct the backward CT by first defining a backward navigator as π ( x |y ) = e−d ( x , y ) pX ( x ) / ∫ e−d ( x , y ) pX ( x ) dx and then its total cost as∫ pY ( y ) ∫ c ( x , y ) π ( x |y ) dxdy . Estimating the CT divergence involves both π ( x |y ) and π ( y |x ) , which , however , are generally intractable to evaluate and sample from , except for a few limited settings where both pX ( x ) and pY ( y ) are exponential family distributions conjugate to e−d ( x , y ) . To apply the CT divergence in a general setting where we only have access to random samples from the distributions , we introduce asymptotic CT ( ACT ) as a divergence measure that is friendly to mini-batch SGD based optimization . The ACT divergence is the expected value of the CT divergence , whose pX ( x ) and pY ( y ) are both replaced with their discrete empirical distributions , respectively supported on N independent , and identically distributed ( iid ) random samples from pX ( x ) and M iid random samples from pY ( y ) . The ACT divergence is asymptotically equivalent to CT divergence when both N →∞ and M →∞ . Intuitively , it can also be interpreted as performing both a forward one-to-M stochastic CT from the source to target and a backward one-to-N stochastic CT from the target to source , with the expected cost providing an unbiased sample estimate of the ACT divergence . We show that similar to the KL divergence , ACT provides unbiased sample gradients , but different from it , neither pX ( x ) nor pY ( y ) needs to be known . Similar to the Wasserstein distance , it does not require the distributions to share the same support , but different from it , the sample estimates of ACT and its gradients are unbiased and straightforward to compute . In GANs or Wasserstein GANs ( Arjovsky et al. , 2017 ) , having an optimal discriminator or critic is required to unbiasedly estimate the JS divergence or Wasserstein distance and hence the gradients of the generator ( Bottou et al. , 2017 ) . However , this is rarely the case in practice , motivating a common remedy to stabilize the training by carefully regularizing the gradients , such as clipping or normalizing their values ( Gulrajani et al. , 2017 ; Miyato et al. , 2018 ) . By contrast , in an adversarial game under ACT , the optimization of the critic , which manipulates the point-to-point transport cost c ( x , y ) but not the navigators ’ conditional distributions for x→ y and x← y , has no impact on how ACT is estimated . For this reason , the sample gradients stay unbiased regardless of how well the critic is optimized . To demonstrate the use of the ACT ( or CT ) divergence , we apply it to train implicit ( or explicit ) distributions to model both 1D and 2D toy data , MNIST digits , and natural images . The implicit distribution is defined by a deep generative model ( DGM ) that is simple to sample from . We focus on adapting existing GANs , with minimal changes to their settings except for substituting the statistical distances in their loss functions with the ACT divergence . We leave tailoring the network architectures to the ACT divergence to future study . More specifically , we modify the GAN loss function to an adversarial game between a generator , a forward navigator , and a backward navigator , which try to minimize the distribution-to-distribution transport cost by optimizing both the fake data distribution pY ( y ) and two conditional point-to-point navigation-path distributions π ( y |x ) and π ( x |y ) , versus a critic that does the opposite by inflating the point-to-point transport cost c ( x , y ) . Modifying an existing ( Wasserstein ) GAN with the ACT divergence , our experiments show consistent improvements in not only quantitative performance and generation quality , but also learning stability . 2 CONDITIONAL TRANSPORT WITH GENERATOR , NAVIGATORS , AND CRITIC . Denote x as a data taking its value in RV . In practice , we observe a finite setX = { xi } |X |i=1 , consisting of |X | data samples assumed to be iid drawn from pX ( x ) . Given X , the usual task is to learn a distribution to approximate pX ( x ) , explaining how the data in X are generated . To approximate pX ( x ) , we consider a DGM defined as y = Gθ ( ) , ∼ p ( ) , whereGθ is a generator that transforms noise ∼ p ( ) via a deep neural network parameterized by θ to generate random sample y ∈ RV . While the PDF of the generator , denoted as pθ ( y ) , is often intractable to evaluate , it is straightforward to draw y ∼ pθ ( y ) with Gθ . Denote both µ ( dx ) = pX ( x ) dx and ν ( dy ) = pθ ( y ) dy as continuous probability measures over RV , with µ ( RV ) = ∫ RV pX ( x ) dx = 1 and ν ( R V ) = ∫ RV pθ ( y ) dy = 1 . The Wasserstein distance in its primal form can be defined with Kantorovich ’ s optimal transport problem ( Kantorovich , 2006 ; Villani , 2008 ; Santambrogio , 2015 ; Peyré and Cuturi , 2019 ) : W ( µ , ν ) =minπ∈Π ( µ , ν ) { ∫ RV ×RV c ( x , y ) π ( dx , dy ) } =minπ∈Π ( µ , ν ) { E ( x , y ) ∼π ( x , y ) [ c ( x , y ) ] } , ( 1 ) where the minimum is taken over Π ( µ , ν ) , defined as the set of all possible joint probability measures π on RV ×RV , with marginals π ( A , RV ) = µ ( A ) and π ( RV , A ) = ν ( A ) for any Borel set A ⊂ RV . When c ( x , y ) = ‖x− y‖ , we obtain the Wasserstein-1 distance , also known as the Earth Mover ’ s distance , for which there exists a dual form according to the Kantorovich duality as W1 ( µ , ν ) = supf∈Lip1 { Ex∼pX ( x ) [ f ( x ) ] − Ey∼pY ( y ) [ f ( y ) ] } , where f is referred to as the “ critic ” and Lip1 denotes the set of all 1-Lipschitz functions ( Villani , 2008 ) . Intuitively , the critic f plays the role of “ amortizing ” the computation of the optimal transport plan . However , as it is difficult to ensure the 1-Lipschitz constraint , one often resorts to approximations ( Arjovsky et al. , 2017 ; Gulrajani et al. , 2017 ; Wei et al. , 2018 ; Miyato et al. , 2018 ) that inevitably introduce bias into the estimation ofW1 and its gradient ( Bellemare et al. , 2017 ; Bottou et al. , 2017 ) . | The paper proposes a new transport-based divergence between distributions (CT) and a variant for empirical distributions (ACT). The new divergence is claimed to be more suitable for learning deep generative models than existing divergences like KL, JS (as in the vanilla GAN) and Wasserstein (as used in WGAN and its variants). The proposed divergence mostly resembles, in my opinion, the Wasserstein divergence variant that uses the Kantorovich–Rubinstein dual definition (which requires the learned function to be 1-Lipschitz). It seems that the main advantages of ACT over Wasserstein is that there is no constraint on the Lipschitz smoothness (which has to be enforced in WGAN by means of e.g. gradient clipping or gradient penalty), and the fact that ACT provides unbiased gradients that do not require the critic to reach an optimal point (as required in theory in GAN or WGAN). | SP:6f5d5acd8b55cc8dd01355d65adf10ea96ae7944 |
ACT: Asymptotic Conditional Transport | 1 INTRODUCTION . Measuring the difference between two probability distributions is a fundamental problem in statistics and machine learning ( Cover , 1999 ; Bishop , 2006 ; Murphy , 2012 ) . A variety of statistical distances have been proposed to quantify the difference , which often serves as the first step to build a generative model . Commonly used statistical distances include the Kullback–Leibler ( KL ) divergence ( Kullback and Leibler , 1951 ) , Jensen–Shannon ( JS ) divergence ( Lin , 1991 ) , and Wasserstein distance ( Kantorovich , 2006 ) . While being widely used for generative modeling ( Kingma and Welling , 2013 ; Goodfellow et al. , 2014 ; Arjovsky et al. , 2017 ; Balaji et al. , 2019 ) , they all have their own limitations . The KL divergence , directly related to both maximum likelihood estimation and variational inference , is amenable to mini-batch stochastic gradient descent ( SGD ) based optimization ( Wainwright and Jordan , 2008 ; Hoffman et al. , 2013 ; Blei et al. , 2017 ) . However , it requires the two probability distributions to share the same support , and hence is often inapplicable if either of them is an implicit distribution whose probability density function ( PDF ) is unknown ( Mohamed and Lakshminarayanan , 2016 ; Huszár , 2017 ; Tran et al. , 2017 ; Yin and Zhou , 2018 ) . The JS divergence is directly related to the mini-max loss of a generative adversarial net ( GAN ) when the discriminator is optimal ( Goodfellow et al. , 2014 ) . However , it is difficult to maintain a good balance between the generator and discriminator , making GANs notoriously brittle to train . The Wasserstein distance is a widely used metric that allows the two distributions to have non-overlapping supports ( Villani , 2008 ; Santambrogio , 2015 ; Peyré and Cuturi , 2019 ) . However , it is challenging to estimate in its primal form and generally results in biased sample gradients when its dual form is employed ( Arjovsky et al. , 2017 ; Bellemare et al. , 2017 ; Bottou et al. , 2017 ; Bińkowski et al. , 2018 ; Bernton et al. , 2019 ) . To address the limitations of existing measurement methods , we introduce conditional transport ( CT ) as a new divergence to quantify the difference between two probability distributions . We refer to them as the source and target distributions and denote their probability density functions ( PDFs ) as pX ( x ) and pY ( y ) , respectively . The CT divergence is defined with a bidirectional distribution-to-distribution transport . It consists of a forward CT that transports the source to target distribution , and a backward CT that reverses the transport direction . Our intuition is that given a source ( target ) point , it is more likely to be transported to a target ( source ) point closer to it . Denoting d ( x , y ) = d ( y , x ) as a learnable function and c ( x , y ) = c ( y , x ) ≥ 0 , where the equality is true when x = y , as the point-to-point transport cost , the goal is to minimize the transport cost between two distributions . The forward CT is constructed in three steps : 1 ) We define a forward “ navigator ” as π ( y |x ) = e−d ( x , y ) pY ( y ) / ∫ e−d ( x , y ) pY ( y ) dy , a conditional distribution specifying how likely a given source point x will be transported to distribution pY ( y ) via path x → y ; 2 ) We define the cost of a forward x-transporting CT as ∫ c ( x , y ) π ( y |x ) dy , the expected cost of employing the forward navigator to transport x to a random target point ; 3 ) We define the total cost of the forward CT as ∫ pX ( x ) ∫ c ( x , y ) π ( y |x ) dydx , which is the expectation of the cost of a forward x-transporting CT with respect to pX ( x ) . Similarly , we construct the backward CT by first defining a backward navigator as π ( x |y ) = e−d ( x , y ) pX ( x ) / ∫ e−d ( x , y ) pX ( x ) dx and then its total cost as∫ pY ( y ) ∫ c ( x , y ) π ( x |y ) dxdy . Estimating the CT divergence involves both π ( x |y ) and π ( y |x ) , which , however , are generally intractable to evaluate and sample from , except for a few limited settings where both pX ( x ) and pY ( y ) are exponential family distributions conjugate to e−d ( x , y ) . To apply the CT divergence in a general setting where we only have access to random samples from the distributions , we introduce asymptotic CT ( ACT ) as a divergence measure that is friendly to mini-batch SGD based optimization . The ACT divergence is the expected value of the CT divergence , whose pX ( x ) and pY ( y ) are both replaced with their discrete empirical distributions , respectively supported on N independent , and identically distributed ( iid ) random samples from pX ( x ) and M iid random samples from pY ( y ) . The ACT divergence is asymptotically equivalent to CT divergence when both N →∞ and M →∞ . Intuitively , it can also be interpreted as performing both a forward one-to-M stochastic CT from the source to target and a backward one-to-N stochastic CT from the target to source , with the expected cost providing an unbiased sample estimate of the ACT divergence . We show that similar to the KL divergence , ACT provides unbiased sample gradients , but different from it , neither pX ( x ) nor pY ( y ) needs to be known . Similar to the Wasserstein distance , it does not require the distributions to share the same support , but different from it , the sample estimates of ACT and its gradients are unbiased and straightforward to compute . In GANs or Wasserstein GANs ( Arjovsky et al. , 2017 ) , having an optimal discriminator or critic is required to unbiasedly estimate the JS divergence or Wasserstein distance and hence the gradients of the generator ( Bottou et al. , 2017 ) . However , this is rarely the case in practice , motivating a common remedy to stabilize the training by carefully regularizing the gradients , such as clipping or normalizing their values ( Gulrajani et al. , 2017 ; Miyato et al. , 2018 ) . By contrast , in an adversarial game under ACT , the optimization of the critic , which manipulates the point-to-point transport cost c ( x , y ) but not the navigators ’ conditional distributions for x→ y and x← y , has no impact on how ACT is estimated . For this reason , the sample gradients stay unbiased regardless of how well the critic is optimized . To demonstrate the use of the ACT ( or CT ) divergence , we apply it to train implicit ( or explicit ) distributions to model both 1D and 2D toy data , MNIST digits , and natural images . The implicit distribution is defined by a deep generative model ( DGM ) that is simple to sample from . We focus on adapting existing GANs , with minimal changes to their settings except for substituting the statistical distances in their loss functions with the ACT divergence . We leave tailoring the network architectures to the ACT divergence to future study . More specifically , we modify the GAN loss function to an adversarial game between a generator , a forward navigator , and a backward navigator , which try to minimize the distribution-to-distribution transport cost by optimizing both the fake data distribution pY ( y ) and two conditional point-to-point navigation-path distributions π ( y |x ) and π ( x |y ) , versus a critic that does the opposite by inflating the point-to-point transport cost c ( x , y ) . Modifying an existing ( Wasserstein ) GAN with the ACT divergence , our experiments show consistent improvements in not only quantitative performance and generation quality , but also learning stability . 2 CONDITIONAL TRANSPORT WITH GENERATOR , NAVIGATORS , AND CRITIC . Denote x as a data taking its value in RV . In practice , we observe a finite setX = { xi } |X |i=1 , consisting of |X | data samples assumed to be iid drawn from pX ( x ) . Given X , the usual task is to learn a distribution to approximate pX ( x ) , explaining how the data in X are generated . To approximate pX ( x ) , we consider a DGM defined as y = Gθ ( ) , ∼ p ( ) , whereGθ is a generator that transforms noise ∼ p ( ) via a deep neural network parameterized by θ to generate random sample y ∈ RV . While the PDF of the generator , denoted as pθ ( y ) , is often intractable to evaluate , it is straightforward to draw y ∼ pθ ( y ) with Gθ . Denote both µ ( dx ) = pX ( x ) dx and ν ( dy ) = pθ ( y ) dy as continuous probability measures over RV , with µ ( RV ) = ∫ RV pX ( x ) dx = 1 and ν ( R V ) = ∫ RV pθ ( y ) dy = 1 . The Wasserstein distance in its primal form can be defined with Kantorovich ’ s optimal transport problem ( Kantorovich , 2006 ; Villani , 2008 ; Santambrogio , 2015 ; Peyré and Cuturi , 2019 ) : W ( µ , ν ) =minπ∈Π ( µ , ν ) { ∫ RV ×RV c ( x , y ) π ( dx , dy ) } =minπ∈Π ( µ , ν ) { E ( x , y ) ∼π ( x , y ) [ c ( x , y ) ] } , ( 1 ) where the minimum is taken over Π ( µ , ν ) , defined as the set of all possible joint probability measures π on RV ×RV , with marginals π ( A , RV ) = µ ( A ) and π ( RV , A ) = ν ( A ) for any Borel set A ⊂ RV . When c ( x , y ) = ‖x− y‖ , we obtain the Wasserstein-1 distance , also known as the Earth Mover ’ s distance , for which there exists a dual form according to the Kantorovich duality as W1 ( µ , ν ) = supf∈Lip1 { Ex∼pX ( x ) [ f ( x ) ] − Ey∼pY ( y ) [ f ( y ) ] } , where f is referred to as the “ critic ” and Lip1 denotes the set of all 1-Lipschitz functions ( Villani , 2008 ) . Intuitively , the critic f plays the role of “ amortizing ” the computation of the optimal transport plan . However , as it is difficult to ensure the 1-Lipschitz constraint , one often resorts to approximations ( Arjovsky et al. , 2017 ; Gulrajani et al. , 2017 ; Wei et al. , 2018 ; Miyato et al. , 2018 ) that inevitably introduce bias into the estimation ofW1 and its gradient ( Bellemare et al. , 2017 ; Bottou et al. , 2017 ) . | The paper proposes conditional transport as a new divergence to measure the difference between two distributions. The idea is to learn the conditional transport plan of transporting one point in one distribution to the other marginal distribution. This conditional transport plan is modeled using a neural network. The resulting model is then applied to optimal transport formulation. Experiments are shown on image-based generative modeling dataset. | SP:6f5d5acd8b55cc8dd01355d65adf10ea96ae7944 |
Domain Generalization with MixStyle | 1 INTRODUCTION . Key to automated understanding of digital images is to compute a compact and informative feature representation . Deep convolutional neural networks ( CNNs ) have demonstrated remarkable ability in representation learning , proven to be effective in many visual recognition tasks , such as classifying photo images into 1,000 categories from ImageNet ( Krizhevsky et al. , 2012 ) and playing Atari games with reinforcement learning ( Mnih et al. , 2013 ) . However , it has long been discovered that the success of CNNs heavily relies on the i.i.d . assumption , i.e . training and test data should be drawn from the same distribution ; when such an assumption is violated even just slightly , as in most realworld application scenarios , severe performance degradation is expected ( Hendrycks & Dietterich , 2019 ; Recht et al. , 2019 ) . Domain generalization ( DG ) aims to address such a problem ( Zhou et al. , 2021 ; Blanchard et al. , 2011 ; Muandet et al. , 2013 ; Li et al. , 2018a ; Zhou et al. , 2020b ; Balaji et al. , 2018 ; Dou et al. , 2019 ; Carlucci et al. , 2019 ) . In particular , assuming that multiple source domains containing the same visual classes are available for model training , the goal of DG is to learn models that are robust against data distribution changes across domains , known as domain shift , so that the trained model can generalize well to any unseen domains . Compared to the closely related and more widely studied domain adaptation ( DA ) problem , DG is much harder in that no target domain data is available for the model to analyze the distribution shift in order to overcome the negative effects . Instead , a DG model must rely on the source domains and focus on learning domain-invariant feature representation in the hope that it would remain discriminative given target domain data . A straightforward solution to DG is to expose a model with a large variety of source domains . Specifically , the task of learning domain-invariant and thus generalizable feature representation becomes easier when data from more diverse source domains are available for the model . This would reduce the burden on designing special models or learning algorithms for DG . Indeed , model training with large-scale data of diverse domains is behind the success of existing commercial face recognition or vision-based autonomous driving systems . A recent work by Xu et al . ( 2021 ) also emphasizes the importance of diverse training distributions for out-of-distribution generalization . However , collecting data of a large variety of domains is often costly or even impossible . It thus can not be a general solution to DG . In this paper , a novel approach is proposed based on probabilistically mixing instance-level feature statistics of training samples across source domains . Our model , termed MixStyle , is motivated by the observation that visual domain is closely related to image style . An example is shown in Fig . 1 : the four images from four different domains depict the same semantic concept , i.e . dog , but with distinctive styles ( e.g. , characteristics in color and texture ) . When these images are fed into a deep CNN , which maps the raw pixel values into category labels , such style information is removed at the output . However , recent style transfer studies ( Huang & Belongie , 2017 ; Dumoulin et al. , 2017 ) suggest that such style information is preserved at the bottom layers of the CNN through the instance-level feature statistics , as shown clearly in Fig . 4 . Importantly , since replacing such statistics would lead to replaced style while preserving the semantic content of the image , it is reasonable to assume that mixing styles from images of different domains would result in images of ( mixed ) new styles . That is , more diverse domains/styles can be made available for training a more domain-generalizable model . Concretely , our MixStyle randomly selects two instances of different domains and adopts a probabilistic convex combination between instance-level feature statistics of bottom CNN layers . In contrast to style transfer work ( Huang & Belongie , 2017 ; Dumoulin et al. , 2017 ) , no explicit image synthesis is necessary meaning much simpler model design . Moreover , MixStyle perfectly fits into modern mini-batch training . Overall , it is very easy to implement with only few lines of code . To evaluate the effectiveness as well as the general applicability of MixStyle , we conduct extensive experiments on a wide spectrum of datasets covering category classification ( Sec . 3.1 ) , instance retrieval ( Sec . 3.2 ) , and reinforcement learning ( Sec . 3.3 ) . The results demonstrate that MixStyle can significantly improve CNNs ’ cross-domain generalization performance.1 2 METHODOLOGY . 2.1 BACKGROUND . Normalizing feature tensors with instance-specific mean and standard deviation has been found effective for removing image style in style transfer models ( Ulyanov et al. , 2016 ; Huang & Belongie , 2017 ; Dumoulin et al. , 2017 ) . Such an operation is widely known as instance normalization ( IN , Ulyanov et al . ( 2016 ) ) . Let x ∈ RB×C×H×W be a batch of tensors , with B , C , H and W 1Source code can be found at https : //github.com/KaiyangZhou/mixstyle-release . denoting the dimension of batch , channel , height and width , respectively , IN is formulated as IN ( x ) = γ x− µ ( x ) σ ( x ) + β , ( 1 ) where γ , β ∈ RC are learnable affine transformation parameters , and µ ( x ) , σ ( x ) ∈ RB×C are mean and standard deviation computed across the spatial dimension within each channel of each instance ( tensor ) , i.e . µ ( x ) b , c = 1 HW H∑ h=1 W∑ w=1 xb , c , h , w , ( 2 ) and σ ( x ) b , c = √√√√ 1 HW H∑ h=1 W∑ w=1 ( xb , c , h , w − µ ( x ) b , c ) 2 . ( 3 ) Huang & Belongie ( 2017 ) introduced adaptive instance normalization ( AdaIN ) , which simply replaces the scale and shift parameters in Eq . ( 1 ) with the feature statistics of style input y to achieve arbitrary style transfer : AdaIN ( x ) = σ ( y ) x− µ ( x ) σ ( x ) + µ ( y ) . ( 4 ) 2.2 MIXSTYLE . Our method , MixStyle , draws inspiration from AdaIN . However , rather than attaching a decoder for image generation , MixStyle is designed for the purpose of regularizing CNN training by perturbing the style information of source domain training instances . It can be implemented as a plug-andplay module inserted between CNN layers of , e.g. , a supervised CNN classifier , without the need to explicitly generate an image of new style . More specifically , MixStyle mixes the feature statistics of two instances with a random convex weight to simulate new styles . In terms of implementation , MixStyle can be easily integrated into mini-batch training . Given an input batch x , MixStyle first generates a reference batch x̃ from x . When domain labels are given , x is sampled from two different domains i and j , e.g. , x = [ xi , xj ] ( xi and xj have the same batch size ) . Then , x̃ is obtained by swapping the position of xi and xj , followed by a shuffling operation along the batch dimension applied to each batch , i.e . x̃ = [ Shuffle ( xj ) , Shuffle ( xi ) ] . See Fig . 2 ( a ) for an illustration . In cases where domain labels are unknown , x is randomly sampled from the training data , and x̃ is simply obtained by x̃ = Shuffle ( x ) ( see Fig . 2 ( b ) ) . Fig . 4 shows that sub-domains exist within each domain , so even if two instances of the same domain are sampled , new domain could be synthesized . After shuffling , MixStyle computes the mixed feature statistics by γmix = λσ ( x ) + ( 1− λ ) σ ( x̃ ) , ( 5 ) βmix = λµ ( x ) + ( 1− λ ) µ ( x̃ ) , ( 6 ) where λ ∈ RB are instance-wise weights sampled from the Beta distribution , λ ∼ Beta ( α , α ) with α ∈ ( 0 , ∞ ) being a hyper-parameter . Unless specified otherwise , we set α to 0.1 throughout this paper . Finally , the mixed feature statistics are applied to the style-normalized x , MixStyle ( x ) = γmix x− µ ( x ) σ ( x ) + βmix . ( 7 ) In practice , we use a probability of 0.5 to decide if MixStyle is activated or not in the forward pass . At test time , no MixStyle is applied . Note that gradients are blocked in the computational graph of µ ( · ) and σ ( · ) . MixStyle can be implemented with only few lines of code . See Algorithm 1 in Appendix A.1 for the PyTorch-like pseudo-code . 3 EXPERIMENTS . 3.1 GENERALIZATION IN CATEGORY CLASSIFICATION . Dataset and implementation details . We choose the PACS dataset ( Li et al. , 2017 ) , a commonly used domain generalization ( DG ) benchmark concerned with domain shift in image classification . PACS consists of four domains , i.e . Art Painting , Cartoon , Photo and Sketch , with totally 9,991 images of 7 classes . As shown in Fig . 1 , the domain shift mainly corresponds to image style changes . For evaluation , a model is trained on three domains and tested on the remaining one . Following prior work ( Li et al. , 2019 ; Zhou et al. , 2020a ) , we use ResNet-18 ( He et al. , 2016 ) as the classifier where MixStyle is inserted after the 1st , 2nd and 3rd residual blocks . Our code is based on Dassl.pytorch ( Zhou et al. , 2020c ) .2 Baselines . Our main baselines are general-purpose regularization methods including Mixup ( Zhang et al. , 2018b ) , Manifold Mixup ( Verma et al. , 2019 ) , DropBlock ( Ghiasi et al. , 2018 ) , CutMix ( Yun et al. , 2019 ) and Cutout ( DeVries & Taylor , 2017 ) , which are trained using the same training parameters as MixStyle and the optimal hyper-parameter setup as reported in their papers . We also compare with the existing DG methods which reported state-of-the-art performance on PACS . These include domain alignment-based CCSA ( Motiian et al. , 2017 ) and MMD-AAE ( Li et al. , 2018b ) , Jigsaw puzzle-based JiGen ( Carlucci et al. , 2019 ) , adversarial gradient-based CrossGrad ( Shankar et al. , 2018 ) , meta-learning-based Metareg ( Balaji et al. , 2018 ) and Epi-FCR ( Li et al. , 2019 ) , and data augmentation-based L2A-OT ( Zhou et al. , 2020a ) . Comparison with general-purpose regularization methods . The results are shown in Table 1 . Overall , we observe that the general-purpose regularization methods do not offer any clear advantage over the vanilla ResNet-18 in this DG task , while MixStyle improves upon the vanilla ResNet18 with a significant margin . Compared with Mixup , MixStyle is 5.2 % better on average . Recall that Mixup also interpolates the output space , we further compare with a variant of Mixup in order to demonstrate the advantage of mixing style statistics at the feature level over mixing images at the pixel level for DG—following Sohn et al . ( 2020 ) , we remove the label interpolation in Mixup and sample the mixing weights from a uniform distribution of [ 0 , 1 ] . Still , MixStyle outperforms this new baseline with a large margin , which justifies our claim . MixStyle and DropBlock share some commonalities in that they are both applied to feature maps at multiple layers , but MixStyle significantly outperforms DropBlock in all test domains . The reason why DropBlock is ineffective here is because dropping out activations mainly encourages a network to mine discriminative patterns , but does not reinforce the ability to cope with unseen styles , which is exactly what MixStyle aims to achieve : by synthesizing “ new ” styles ( domains ) MixStyle regularizes the network to become more 2https : //github.com/KaiyangZhou/Dassl.pytorch . robust to domain shift . In addition , it is interesting to see that on Cartoon and Photo , MixStyle w/ random shuffle obtains slightly better results . The reason might be because there exist sub-domains in a source domain ( see Fig . 4 ( a-c ) ) , which allow random shuffling to produce more diverse “ new ” domains that lead to a more domain-generalizable model . Comparison with state-of-the-art DG methods . Overall , MixStyle outperforms most DG methods by a clear margin , despite being a much simpler method . The performance of MixStyle w/ domain label is nearly 1 % better on average than the recently introduced L2A-OT . From a data augmentation perspective , MixStyle and L2A-OT share a similar goal—to synthesize data from pseudo-novel domains . MixStyle accomplishes this goal through mixing style statistics at the feature level . Whereas L2A-OT works at the pixel level : it trains an image generator by maximizing the domain difference ( measured by optimal transport ) between the original and the generated images , which introduces much heavier computational overhead than MixStyle in terms of GPU memory and training time . It is worth noting that MixStyle ’ s domain label-free version is highly competitive : its 82.8 % accuracy is on par with L2A-OT ’ s . | This work proposes a technique for domain generalization by mixing style of images from different domains. This work adopts a mix up style approach [A] for domain generalization. Different from [A], the paper proposes to conduct mix-up in the intermediate layers, in particular, instance normalization layers. The proposed approach diversifies the data implicitly and the experimental results show that the mix-style can improve domain generalization. | SP:b9ce6d4e7451388efdd7cbacca24053f7fa73ab3 |
Domain Generalization with MixStyle | 1 INTRODUCTION . Key to automated understanding of digital images is to compute a compact and informative feature representation . Deep convolutional neural networks ( CNNs ) have demonstrated remarkable ability in representation learning , proven to be effective in many visual recognition tasks , such as classifying photo images into 1,000 categories from ImageNet ( Krizhevsky et al. , 2012 ) and playing Atari games with reinforcement learning ( Mnih et al. , 2013 ) . However , it has long been discovered that the success of CNNs heavily relies on the i.i.d . assumption , i.e . training and test data should be drawn from the same distribution ; when such an assumption is violated even just slightly , as in most realworld application scenarios , severe performance degradation is expected ( Hendrycks & Dietterich , 2019 ; Recht et al. , 2019 ) . Domain generalization ( DG ) aims to address such a problem ( Zhou et al. , 2021 ; Blanchard et al. , 2011 ; Muandet et al. , 2013 ; Li et al. , 2018a ; Zhou et al. , 2020b ; Balaji et al. , 2018 ; Dou et al. , 2019 ; Carlucci et al. , 2019 ) . In particular , assuming that multiple source domains containing the same visual classes are available for model training , the goal of DG is to learn models that are robust against data distribution changes across domains , known as domain shift , so that the trained model can generalize well to any unseen domains . Compared to the closely related and more widely studied domain adaptation ( DA ) problem , DG is much harder in that no target domain data is available for the model to analyze the distribution shift in order to overcome the negative effects . Instead , a DG model must rely on the source domains and focus on learning domain-invariant feature representation in the hope that it would remain discriminative given target domain data . A straightforward solution to DG is to expose a model with a large variety of source domains . Specifically , the task of learning domain-invariant and thus generalizable feature representation becomes easier when data from more diverse source domains are available for the model . This would reduce the burden on designing special models or learning algorithms for DG . Indeed , model training with large-scale data of diverse domains is behind the success of existing commercial face recognition or vision-based autonomous driving systems . A recent work by Xu et al . ( 2021 ) also emphasizes the importance of diverse training distributions for out-of-distribution generalization . However , collecting data of a large variety of domains is often costly or even impossible . It thus can not be a general solution to DG . In this paper , a novel approach is proposed based on probabilistically mixing instance-level feature statistics of training samples across source domains . Our model , termed MixStyle , is motivated by the observation that visual domain is closely related to image style . An example is shown in Fig . 1 : the four images from four different domains depict the same semantic concept , i.e . dog , but with distinctive styles ( e.g. , characteristics in color and texture ) . When these images are fed into a deep CNN , which maps the raw pixel values into category labels , such style information is removed at the output . However , recent style transfer studies ( Huang & Belongie , 2017 ; Dumoulin et al. , 2017 ) suggest that such style information is preserved at the bottom layers of the CNN through the instance-level feature statistics , as shown clearly in Fig . 4 . Importantly , since replacing such statistics would lead to replaced style while preserving the semantic content of the image , it is reasonable to assume that mixing styles from images of different domains would result in images of ( mixed ) new styles . That is , more diverse domains/styles can be made available for training a more domain-generalizable model . Concretely , our MixStyle randomly selects two instances of different domains and adopts a probabilistic convex combination between instance-level feature statistics of bottom CNN layers . In contrast to style transfer work ( Huang & Belongie , 2017 ; Dumoulin et al. , 2017 ) , no explicit image synthesis is necessary meaning much simpler model design . Moreover , MixStyle perfectly fits into modern mini-batch training . Overall , it is very easy to implement with only few lines of code . To evaluate the effectiveness as well as the general applicability of MixStyle , we conduct extensive experiments on a wide spectrum of datasets covering category classification ( Sec . 3.1 ) , instance retrieval ( Sec . 3.2 ) , and reinforcement learning ( Sec . 3.3 ) . The results demonstrate that MixStyle can significantly improve CNNs ’ cross-domain generalization performance.1 2 METHODOLOGY . 2.1 BACKGROUND . Normalizing feature tensors with instance-specific mean and standard deviation has been found effective for removing image style in style transfer models ( Ulyanov et al. , 2016 ; Huang & Belongie , 2017 ; Dumoulin et al. , 2017 ) . Such an operation is widely known as instance normalization ( IN , Ulyanov et al . ( 2016 ) ) . Let x ∈ RB×C×H×W be a batch of tensors , with B , C , H and W 1Source code can be found at https : //github.com/KaiyangZhou/mixstyle-release . denoting the dimension of batch , channel , height and width , respectively , IN is formulated as IN ( x ) = γ x− µ ( x ) σ ( x ) + β , ( 1 ) where γ , β ∈ RC are learnable affine transformation parameters , and µ ( x ) , σ ( x ) ∈ RB×C are mean and standard deviation computed across the spatial dimension within each channel of each instance ( tensor ) , i.e . µ ( x ) b , c = 1 HW H∑ h=1 W∑ w=1 xb , c , h , w , ( 2 ) and σ ( x ) b , c = √√√√ 1 HW H∑ h=1 W∑ w=1 ( xb , c , h , w − µ ( x ) b , c ) 2 . ( 3 ) Huang & Belongie ( 2017 ) introduced adaptive instance normalization ( AdaIN ) , which simply replaces the scale and shift parameters in Eq . ( 1 ) with the feature statistics of style input y to achieve arbitrary style transfer : AdaIN ( x ) = σ ( y ) x− µ ( x ) σ ( x ) + µ ( y ) . ( 4 ) 2.2 MIXSTYLE . Our method , MixStyle , draws inspiration from AdaIN . However , rather than attaching a decoder for image generation , MixStyle is designed for the purpose of regularizing CNN training by perturbing the style information of source domain training instances . It can be implemented as a plug-andplay module inserted between CNN layers of , e.g. , a supervised CNN classifier , without the need to explicitly generate an image of new style . More specifically , MixStyle mixes the feature statistics of two instances with a random convex weight to simulate new styles . In terms of implementation , MixStyle can be easily integrated into mini-batch training . Given an input batch x , MixStyle first generates a reference batch x̃ from x . When domain labels are given , x is sampled from two different domains i and j , e.g. , x = [ xi , xj ] ( xi and xj have the same batch size ) . Then , x̃ is obtained by swapping the position of xi and xj , followed by a shuffling operation along the batch dimension applied to each batch , i.e . x̃ = [ Shuffle ( xj ) , Shuffle ( xi ) ] . See Fig . 2 ( a ) for an illustration . In cases where domain labels are unknown , x is randomly sampled from the training data , and x̃ is simply obtained by x̃ = Shuffle ( x ) ( see Fig . 2 ( b ) ) . Fig . 4 shows that sub-domains exist within each domain , so even if two instances of the same domain are sampled , new domain could be synthesized . After shuffling , MixStyle computes the mixed feature statistics by γmix = λσ ( x ) + ( 1− λ ) σ ( x̃ ) , ( 5 ) βmix = λµ ( x ) + ( 1− λ ) µ ( x̃ ) , ( 6 ) where λ ∈ RB are instance-wise weights sampled from the Beta distribution , λ ∼ Beta ( α , α ) with α ∈ ( 0 , ∞ ) being a hyper-parameter . Unless specified otherwise , we set α to 0.1 throughout this paper . Finally , the mixed feature statistics are applied to the style-normalized x , MixStyle ( x ) = γmix x− µ ( x ) σ ( x ) + βmix . ( 7 ) In practice , we use a probability of 0.5 to decide if MixStyle is activated or not in the forward pass . At test time , no MixStyle is applied . Note that gradients are blocked in the computational graph of µ ( · ) and σ ( · ) . MixStyle can be implemented with only few lines of code . See Algorithm 1 in Appendix A.1 for the PyTorch-like pseudo-code . 3 EXPERIMENTS . 3.1 GENERALIZATION IN CATEGORY CLASSIFICATION . Dataset and implementation details . We choose the PACS dataset ( Li et al. , 2017 ) , a commonly used domain generalization ( DG ) benchmark concerned with domain shift in image classification . PACS consists of four domains , i.e . Art Painting , Cartoon , Photo and Sketch , with totally 9,991 images of 7 classes . As shown in Fig . 1 , the domain shift mainly corresponds to image style changes . For evaluation , a model is trained on three domains and tested on the remaining one . Following prior work ( Li et al. , 2019 ; Zhou et al. , 2020a ) , we use ResNet-18 ( He et al. , 2016 ) as the classifier where MixStyle is inserted after the 1st , 2nd and 3rd residual blocks . Our code is based on Dassl.pytorch ( Zhou et al. , 2020c ) .2 Baselines . Our main baselines are general-purpose regularization methods including Mixup ( Zhang et al. , 2018b ) , Manifold Mixup ( Verma et al. , 2019 ) , DropBlock ( Ghiasi et al. , 2018 ) , CutMix ( Yun et al. , 2019 ) and Cutout ( DeVries & Taylor , 2017 ) , which are trained using the same training parameters as MixStyle and the optimal hyper-parameter setup as reported in their papers . We also compare with the existing DG methods which reported state-of-the-art performance on PACS . These include domain alignment-based CCSA ( Motiian et al. , 2017 ) and MMD-AAE ( Li et al. , 2018b ) , Jigsaw puzzle-based JiGen ( Carlucci et al. , 2019 ) , adversarial gradient-based CrossGrad ( Shankar et al. , 2018 ) , meta-learning-based Metareg ( Balaji et al. , 2018 ) and Epi-FCR ( Li et al. , 2019 ) , and data augmentation-based L2A-OT ( Zhou et al. , 2020a ) . Comparison with general-purpose regularization methods . The results are shown in Table 1 . Overall , we observe that the general-purpose regularization methods do not offer any clear advantage over the vanilla ResNet-18 in this DG task , while MixStyle improves upon the vanilla ResNet18 with a significant margin . Compared with Mixup , MixStyle is 5.2 % better on average . Recall that Mixup also interpolates the output space , we further compare with a variant of Mixup in order to demonstrate the advantage of mixing style statistics at the feature level over mixing images at the pixel level for DG—following Sohn et al . ( 2020 ) , we remove the label interpolation in Mixup and sample the mixing weights from a uniform distribution of [ 0 , 1 ] . Still , MixStyle outperforms this new baseline with a large margin , which justifies our claim . MixStyle and DropBlock share some commonalities in that they are both applied to feature maps at multiple layers , but MixStyle significantly outperforms DropBlock in all test domains . The reason why DropBlock is ineffective here is because dropping out activations mainly encourages a network to mine discriminative patterns , but does not reinforce the ability to cope with unseen styles , which is exactly what MixStyle aims to achieve : by synthesizing “ new ” styles ( domains ) MixStyle regularizes the network to become more 2https : //github.com/KaiyangZhou/Dassl.pytorch . robust to domain shift . In addition , it is interesting to see that on Cartoon and Photo , MixStyle w/ random shuffle obtains slightly better results . The reason might be because there exist sub-domains in a source domain ( see Fig . 4 ( a-c ) ) , which allow random shuffling to produce more diverse “ new ” domains that lead to a more domain-generalizable model . Comparison with state-of-the-art DG methods . Overall , MixStyle outperforms most DG methods by a clear margin , despite being a much simpler method . The performance of MixStyle w/ domain label is nearly 1 % better on average than the recently introduced L2A-OT . From a data augmentation perspective , MixStyle and L2A-OT share a similar goal—to synthesize data from pseudo-novel domains . MixStyle accomplishes this goal through mixing style statistics at the feature level . Whereas L2A-OT works at the pixel level : it trains an image generator by maximizing the domain difference ( measured by optimal transport ) between the original and the generated images , which introduces much heavier computational overhead than MixStyle in terms of GPU memory and training time . It is worth noting that MixStyle ’ s domain label-free version is highly competitive : its 82.8 % accuracy is on par with L2A-OT ’ s . | This paper proposed a simple regularization technique for domain generalization tasks, termed MixStyle, based on the observation that domains are determined by image styles. By mixing styles of different instances, which generates synthesized domain samples while preserving the content features, the proposed method achieves the generalizability of the trained model. The MixStyle was applied to numerous applications, such as category classification, instance retrieval, and reinforcement learning, and attained the state-of-the arts. The MixStyle is relatively simple to implement, but effective. | SP:b9ce6d4e7451388efdd7cbacca24053f7fa73ab3 |
ALT-MAS: A Data-Efficient Framework for Active Testing of Machine Learning Algorithms | Machine learning models are being used extensively in many important areas , but there is no guarantee that a model will always perform well or as its developers intended . Understanding the correctness of a model is crucial to prevent potential failures that may have significant detrimental impact in critical application areas . In this paper , we propose a novel framework to efficiently test a machine learning model using only a small amount of labelled test data . The core idea is to efficiently estimate the metrics of interest for a model-under-test using Bayesian neural network . We develop a novel methodology to incorporate the information from the model-under test into the Bayesian neural network training process . We also devise an entropy-based sampling strategy to sample the data point such that the proposed framework can give accurate estimations for the metrics of interest . Finally , we conduct an extensive set of experiments to test various machine learning models for different types of metrics . Our experiments with multiple datasets show that given a testing budget , the estimation of the metrics by our method is significantly better compared to existing state-of-the-art approaches . 1 INTRODUCTION . Today , supervised machine learning models are employed across sectors to assist humans in making important decisions . Understanding the correctness of a model is thus crucial to avoid potential ( and severe ) failures . In practice , however , it is not always possible to accurately evaluate the model ’ s correctness using the held-out training data in the development process ( Sawade et al. , 2010 ) . Consider a hospital that buys an automated medical image classification system . The supplier will provide a performance assessment , but this evaluation may not hold in this new setting as the supplier and the hospital data distributions may differ . Similarly , an enterprise that develops a business prediction system might find that the performance changes significantly over time as the input distribution shifts from the original training data . In these cases , the model performance needs to be re-evaluated as the assessments provided from the supplier or from the development process can be inaccurate . To accurately evaluate the model performance , new labelled data points from the deployment area are needed . But the process of labelling is expensive as one would usually need a large number of test instances . Thus the open question is how to test the performance of a machine learning model ( model-under-test ) with parsimonious use of labelled data from the deployment area . This work focuses on addressing this challenge treating the model-under-test as a black-box as in common practice one only has access to the model outputs . One previous approach aims to estimate a risk score which is a function of the model-under-test output and the ground-truth ( akin to metric ) using limited labelled data ( Sawade et al. , 2010 ) . However , the approach has only been shown to be tractable for some specific risk functions ( e.g . accuracy ) . Another approach in ( Gopakumar et al. , 2018 ) suggested to search for the worst case model performance using limited labelled data , however , we posit that using worst case to assess the goodness of a model-under-test is an overkill because the worst case is often just an outlier . Recently , ( Schelter et al. , 2020 ) learns to validate the model without labelled data by generating a synthetic dataset representative of the deployment data . The restrictive assumption is that it requires domain experts to provide a set of data generators , a task usually infeasible in reality . We propose a scalable data-efficient framework that can assess the performance of a black-box model-under-test on any metric ( that is applicable for black-box models ) without prior knowledge from users . Furthermore , our framework can estimate multiple metrics simultaneously . The motivation for evaluating one or multiple metrics is inspired by the current practice of users who need to assess the model-under-test on one or varied aspects that are important to them . For instance , for a classification system , the user might want to solely check the overall accuracy or simultaneously check the overall accuracy , macro-precision ( recall ) and/or the accuracies of some classes of interest . To achieve sample efficiency , we formulate our testing framework as an active learning ( AL ) problem ( Cohn et al. , 1996 ) . First , a small subset of the test dataset is labelled , and a surrogate model is learned from this subset to predict the ground truth of the unlabelled data points in the test dataset . Second , an acquisition function is constructed to decide which data point in the test dataset should be chosen for labelling . The data point selected by the acquisition is sent to an external oracle for labelling , and is then added to the labelled set . The process is conducted iteratively until the labelling budget is depleted . The metrics of interest are then estimated using the learned surrogate model . With this framework , one choice is to use a standard AL method to learn a surrogate model that accurately predicts the labels of all the data points in the test dataset , however , this choice is not optimal . To efficiently estimate the metrics of interest , the surrogate model should not need to accurately predict the labels of all the data points ; it only needs to accurately predict the labels of those data points that contribute significantly to the accuracy of the metric estimations . For our active testing framework , we first propose a method to train the surrogate model that can provide high metric estimation accuracy ( using limited number of labelled data ) by incorporating information from the model-under-test . Second , we derive an entropy-based acquisition function that can select the data points for whom labels should be acquired so as to enable maximal reduction in the estimation uncertainty of the metric of interest . We then use this computed entropy to generalize our framework to be able to work with multiple metrics . Finally , we demonstrate the efficacy of our proposed testing framework using various models-under-test and a wide range of metric sets on different datasets . In summary , our main contributions are : 1 . ALT-MAS , a data-efficient testing framework that can accurately estimate the performance of a machine learning model ; 2 . A novel approach to train the BNN so as to accurately estimate the metrics of interest ; 3 . A novel sampling methodology so as to estimate the metrics of interest efficiently ; and , 4 . Demonstration of the empirical effectiveness of our proposed machine learning testing framework on various models-under-test for a wide range of metrics and different datasets . 2 PROBLEM FORMULATION AND BACKGROUND . 2.1 PROBLEM FORMULATION . Let us assume we are given a black-box model-under-test A that gives the prediction A ( x ) for an input x , with A ( x ) ∈ C = { 1 , . . . , C } . Let us also assume we have access to ( i ) an unlabelled test dataset X = { xi } Ni=1 , and , ( ii ) an oracle that can provide the label yx for each input x in X . Given a set of performance metrics { Qk } Kk=1 , Qk : RN × RN → R , the goal is to efficiently estimate the values of these metrics , { Q∗k } Kk=1 , when evaluating the model-under-test A on the test dataset X . That is , we aim to estimate , Q∗k = Qk ( AX , YX ) , k = 1 , . . . , K , ( 1 ) with AX = { A ( x ) } x∈X and YX = { yx } x∈X , using the minimal number of oracle queries . In this work , we focus on classifiers because they are common supervised learning models and also the target models of most machine learning testing papers ( Zhang et al. , 2019 ) . Besides , it is also worth noting that , as we only have access to the outputs of the black-box classifier , the metrics { Qk } must be those that can be computed using solely the classifier outputs AX and the groundtruth labels YX of the test dataset X . Examples of Qk include the accuracy , error rate , per-class precision/recall , macro precision/recall , Fβ score , etc . This is to distinguish with the metrics that require information from the classifier internal structure such as the log-loss metric . 2.2 BACKGROUND . Bayesian neural networks ( BNNs ) are special neural networks that maintain a distribution over its parameters ( MacKay , 1992 ; Neal , 1995 ) . Specifically , given the training data Dtr = { xi , yi } Ni=1 , a BNN can provide the posterior distribution p∗ ( ω|Dtr ) with ω being the neural network weights . In practice , performing exact inference to obtain p∗ ( ω|Dtr ) is generally intractable , hence we use a variational approximation technique to approximate this posterior . In particular , we employ the MC-dropout method ( Gal & Ghahramani , 2016 ) as it is known to be both scalable and theoretically guaranteed in terms of inferring the true model posterior distribution p∗ ( ω|Dtr ) . That is , the MCdropout method is equivalent to performing approximate variational inference to find a distribution in a tractable family that minimizes the Kullback-Leibler divergence to the true model posterior . 3 ACTIVE TESTING WITH METRIC-AWARE SAMPLING STRATEGY . Our active testing framework is summarized as follows . First , a small subset Xl of the test dataset X is labelled to construct a labelled set Dl = { Xl , YXl } , where YXl denotes the labels provided by the oracle for Xl ; and a BNN Bω ( with parameter ω ) is learned from Dl to predict the labels of the unlabelled data points in X . Second , an acquisition function is constructed based on the BNN Bω , the characteristics of the metric set , and the model-under-test outputsAX to decide which data point is to be labelled so as to maximally reduce the uncertainty in the metric estimations . This data point is sent for labelling , and is added to the labelled set Dl . This process is conducted iteratively until the labelling budget is depleted . The metrics of interest are estimated using the BNN Bω . In this section , we propose a method to train a BNN that can give accurate metric estimations from a limited number of labelled data ( Section 3.1 ) , a method to estimate the metrics of interest given the BNN ( Section 3.2 ) , and a method to sample the most informative data point to maximize the estimation accuracy of a specific metric ( Section 3.3 ) or a set of metrics ( Section 3.4 ) . 3.1 BAYESIAN NEURAL NETWORK TRAINING METHODOLOGY . Given the labelled set Dl and the model-under-test outputs AX , the goal is to train a BNN Bω such that the corresponding metric estimations are most accurate . Training BNN using solely the labelled setDl might not result in accurate enough metric estimations . Thus , to improve the metric estimation accuracy , we propose to incorporate the information from the model-under-test outputs AX into the BNN training process . In particular , using the labelled set Dl , we also train a binary classifier Cη that aims to predict the data points in the test dataset for which the model-under-test agrees with the ground-truth . Using the predictions by the classifier Cη , we then construct an augmented labelled set Sl = { XS , YXS } where XS are all the data points in the test dataset X that Cη identifies the model-under-test predictions are accurate , and YXS are the corresponding model-under-test outputs of XS . The BNN is then trained using both the labelled set Dl and the augmented labelled set Sl . To train the binary classifier Cη , we first split the labelled set Dl into two parts : training and validation , and then train Cη on the training part whilst tuning the softmax probability threshold using the validation part so that Cη achieves the highest precision on the validation part . This is because we want Cη to choose a data point only when it is most certain that the ground-truth and the modelunder-test output of that data point is the same . Besides , as the precision of Cη is rarely 100 % , thus , after obtaining the set of data points provided by Cη , we only take Ns data points from this set with the highest softmax probability . The number Ns is computed by multiplying the precision of Cη on the validation part with the cardinality of the original predicted set . For example , if the precision of the classifier Cη is 50 % on the validation part and the original predicted set consisting of 100 data points , the final augmented labelled set Sl only consists of 50 data points with the highest softmax probability . Finally , the binary classification problem can be imbalanced , particularly when the model-under-test is very accurate or very bad . Hence , when training Cη , we employ the oversampling technique ( for the minority class ) to ensure the training data of the binary classification problem to be balanced , i.e . the cardinalities of the majority and minority classes are equal . Remark 3.1 . With this training methodology , the more accurate the model-under-test , the more accurate the BNN Bω . In case when the model-under-test is bad , the augmented labelled set Sl does not consist of many elements , thus , the BNN accuracy does not improve much compared to when training solely using the labelled set Dl . However , in this case , the BNN does not need to have high accuracy in order to accurately estimate the metrics . Specifically , for any data point for which the model-under-test disagrees with the ground truth , the BNN does not need to accurately predict its label . That is , even when the BNN predicts other labels ( except the model-under-test output label ) , the metric estimation is still accurate ( more detailed examples in Section C.3 of the appendix ) . Remark 3.2 . For simplicity , we suggest to set the architecture of the binary classifier and BNN to be same . For example , if the BNN is a 2-layer MLP , then the binary classifier is also a 2-layer MLP . | The paper proposes an active testing approach that actively selects test instances to estimate the performance of a (black box) machine learning model. The key idea is to train a Bayesian Neural Networks (BNN) with a small amount of labeled test data and evaluate how well the model-under-test agrees with the BNN on samples for which the BNN has a high confidence. More instances to be labeled by an oracle are selected with active learning, i.e. select the data point that minimizes the uncertainty of the metric prediction. | SP:31b3653cae47c7e33f5379141951ea37a8c98a79 |
ALT-MAS: A Data-Efficient Framework for Active Testing of Machine Learning Algorithms | Machine learning models are being used extensively in many important areas , but there is no guarantee that a model will always perform well or as its developers intended . Understanding the correctness of a model is crucial to prevent potential failures that may have significant detrimental impact in critical application areas . In this paper , we propose a novel framework to efficiently test a machine learning model using only a small amount of labelled test data . The core idea is to efficiently estimate the metrics of interest for a model-under-test using Bayesian neural network . We develop a novel methodology to incorporate the information from the model-under test into the Bayesian neural network training process . We also devise an entropy-based sampling strategy to sample the data point such that the proposed framework can give accurate estimations for the metrics of interest . Finally , we conduct an extensive set of experiments to test various machine learning models for different types of metrics . Our experiments with multiple datasets show that given a testing budget , the estimation of the metrics by our method is significantly better compared to existing state-of-the-art approaches . 1 INTRODUCTION . Today , supervised machine learning models are employed across sectors to assist humans in making important decisions . Understanding the correctness of a model is thus crucial to avoid potential ( and severe ) failures . In practice , however , it is not always possible to accurately evaluate the model ’ s correctness using the held-out training data in the development process ( Sawade et al. , 2010 ) . Consider a hospital that buys an automated medical image classification system . The supplier will provide a performance assessment , but this evaluation may not hold in this new setting as the supplier and the hospital data distributions may differ . Similarly , an enterprise that develops a business prediction system might find that the performance changes significantly over time as the input distribution shifts from the original training data . In these cases , the model performance needs to be re-evaluated as the assessments provided from the supplier or from the development process can be inaccurate . To accurately evaluate the model performance , new labelled data points from the deployment area are needed . But the process of labelling is expensive as one would usually need a large number of test instances . Thus the open question is how to test the performance of a machine learning model ( model-under-test ) with parsimonious use of labelled data from the deployment area . This work focuses on addressing this challenge treating the model-under-test as a black-box as in common practice one only has access to the model outputs . One previous approach aims to estimate a risk score which is a function of the model-under-test output and the ground-truth ( akin to metric ) using limited labelled data ( Sawade et al. , 2010 ) . However , the approach has only been shown to be tractable for some specific risk functions ( e.g . accuracy ) . Another approach in ( Gopakumar et al. , 2018 ) suggested to search for the worst case model performance using limited labelled data , however , we posit that using worst case to assess the goodness of a model-under-test is an overkill because the worst case is often just an outlier . Recently , ( Schelter et al. , 2020 ) learns to validate the model without labelled data by generating a synthetic dataset representative of the deployment data . The restrictive assumption is that it requires domain experts to provide a set of data generators , a task usually infeasible in reality . We propose a scalable data-efficient framework that can assess the performance of a black-box model-under-test on any metric ( that is applicable for black-box models ) without prior knowledge from users . Furthermore , our framework can estimate multiple metrics simultaneously . The motivation for evaluating one or multiple metrics is inspired by the current practice of users who need to assess the model-under-test on one or varied aspects that are important to them . For instance , for a classification system , the user might want to solely check the overall accuracy or simultaneously check the overall accuracy , macro-precision ( recall ) and/or the accuracies of some classes of interest . To achieve sample efficiency , we formulate our testing framework as an active learning ( AL ) problem ( Cohn et al. , 1996 ) . First , a small subset of the test dataset is labelled , and a surrogate model is learned from this subset to predict the ground truth of the unlabelled data points in the test dataset . Second , an acquisition function is constructed to decide which data point in the test dataset should be chosen for labelling . The data point selected by the acquisition is sent to an external oracle for labelling , and is then added to the labelled set . The process is conducted iteratively until the labelling budget is depleted . The metrics of interest are then estimated using the learned surrogate model . With this framework , one choice is to use a standard AL method to learn a surrogate model that accurately predicts the labels of all the data points in the test dataset , however , this choice is not optimal . To efficiently estimate the metrics of interest , the surrogate model should not need to accurately predict the labels of all the data points ; it only needs to accurately predict the labels of those data points that contribute significantly to the accuracy of the metric estimations . For our active testing framework , we first propose a method to train the surrogate model that can provide high metric estimation accuracy ( using limited number of labelled data ) by incorporating information from the model-under-test . Second , we derive an entropy-based acquisition function that can select the data points for whom labels should be acquired so as to enable maximal reduction in the estimation uncertainty of the metric of interest . We then use this computed entropy to generalize our framework to be able to work with multiple metrics . Finally , we demonstrate the efficacy of our proposed testing framework using various models-under-test and a wide range of metric sets on different datasets . In summary , our main contributions are : 1 . ALT-MAS , a data-efficient testing framework that can accurately estimate the performance of a machine learning model ; 2 . A novel approach to train the BNN so as to accurately estimate the metrics of interest ; 3 . A novel sampling methodology so as to estimate the metrics of interest efficiently ; and , 4 . Demonstration of the empirical effectiveness of our proposed machine learning testing framework on various models-under-test for a wide range of metrics and different datasets . 2 PROBLEM FORMULATION AND BACKGROUND . 2.1 PROBLEM FORMULATION . Let us assume we are given a black-box model-under-test A that gives the prediction A ( x ) for an input x , with A ( x ) ∈ C = { 1 , . . . , C } . Let us also assume we have access to ( i ) an unlabelled test dataset X = { xi } Ni=1 , and , ( ii ) an oracle that can provide the label yx for each input x in X . Given a set of performance metrics { Qk } Kk=1 , Qk : RN × RN → R , the goal is to efficiently estimate the values of these metrics , { Q∗k } Kk=1 , when evaluating the model-under-test A on the test dataset X . That is , we aim to estimate , Q∗k = Qk ( AX , YX ) , k = 1 , . . . , K , ( 1 ) with AX = { A ( x ) } x∈X and YX = { yx } x∈X , using the minimal number of oracle queries . In this work , we focus on classifiers because they are common supervised learning models and also the target models of most machine learning testing papers ( Zhang et al. , 2019 ) . Besides , it is also worth noting that , as we only have access to the outputs of the black-box classifier , the metrics { Qk } must be those that can be computed using solely the classifier outputs AX and the groundtruth labels YX of the test dataset X . Examples of Qk include the accuracy , error rate , per-class precision/recall , macro precision/recall , Fβ score , etc . This is to distinguish with the metrics that require information from the classifier internal structure such as the log-loss metric . 2.2 BACKGROUND . Bayesian neural networks ( BNNs ) are special neural networks that maintain a distribution over its parameters ( MacKay , 1992 ; Neal , 1995 ) . Specifically , given the training data Dtr = { xi , yi } Ni=1 , a BNN can provide the posterior distribution p∗ ( ω|Dtr ) with ω being the neural network weights . In practice , performing exact inference to obtain p∗ ( ω|Dtr ) is generally intractable , hence we use a variational approximation technique to approximate this posterior . In particular , we employ the MC-dropout method ( Gal & Ghahramani , 2016 ) as it is known to be both scalable and theoretically guaranteed in terms of inferring the true model posterior distribution p∗ ( ω|Dtr ) . That is , the MCdropout method is equivalent to performing approximate variational inference to find a distribution in a tractable family that minimizes the Kullback-Leibler divergence to the true model posterior . 3 ACTIVE TESTING WITH METRIC-AWARE SAMPLING STRATEGY . Our active testing framework is summarized as follows . First , a small subset Xl of the test dataset X is labelled to construct a labelled set Dl = { Xl , YXl } , where YXl denotes the labels provided by the oracle for Xl ; and a BNN Bω ( with parameter ω ) is learned from Dl to predict the labels of the unlabelled data points in X . Second , an acquisition function is constructed based on the BNN Bω , the characteristics of the metric set , and the model-under-test outputsAX to decide which data point is to be labelled so as to maximally reduce the uncertainty in the metric estimations . This data point is sent for labelling , and is added to the labelled set Dl . This process is conducted iteratively until the labelling budget is depleted . The metrics of interest are estimated using the BNN Bω . In this section , we propose a method to train a BNN that can give accurate metric estimations from a limited number of labelled data ( Section 3.1 ) , a method to estimate the metrics of interest given the BNN ( Section 3.2 ) , and a method to sample the most informative data point to maximize the estimation accuracy of a specific metric ( Section 3.3 ) or a set of metrics ( Section 3.4 ) . 3.1 BAYESIAN NEURAL NETWORK TRAINING METHODOLOGY . Given the labelled set Dl and the model-under-test outputs AX , the goal is to train a BNN Bω such that the corresponding metric estimations are most accurate . Training BNN using solely the labelled setDl might not result in accurate enough metric estimations . Thus , to improve the metric estimation accuracy , we propose to incorporate the information from the model-under-test outputs AX into the BNN training process . In particular , using the labelled set Dl , we also train a binary classifier Cη that aims to predict the data points in the test dataset for which the model-under-test agrees with the ground-truth . Using the predictions by the classifier Cη , we then construct an augmented labelled set Sl = { XS , YXS } where XS are all the data points in the test dataset X that Cη identifies the model-under-test predictions are accurate , and YXS are the corresponding model-under-test outputs of XS . The BNN is then trained using both the labelled set Dl and the augmented labelled set Sl . To train the binary classifier Cη , we first split the labelled set Dl into two parts : training and validation , and then train Cη on the training part whilst tuning the softmax probability threshold using the validation part so that Cη achieves the highest precision on the validation part . This is because we want Cη to choose a data point only when it is most certain that the ground-truth and the modelunder-test output of that data point is the same . Besides , as the precision of Cη is rarely 100 % , thus , after obtaining the set of data points provided by Cη , we only take Ns data points from this set with the highest softmax probability . The number Ns is computed by multiplying the precision of Cη on the validation part with the cardinality of the original predicted set . For example , if the precision of the classifier Cη is 50 % on the validation part and the original predicted set consisting of 100 data points , the final augmented labelled set Sl only consists of 50 data points with the highest softmax probability . Finally , the binary classification problem can be imbalanced , particularly when the model-under-test is very accurate or very bad . Hence , when training Cη , we employ the oversampling technique ( for the minority class ) to ensure the training data of the binary classification problem to be balanced , i.e . the cardinalities of the majority and minority classes are equal . Remark 3.1 . With this training methodology , the more accurate the model-under-test , the more accurate the BNN Bω . In case when the model-under-test is bad , the augmented labelled set Sl does not consist of many elements , thus , the BNN accuracy does not improve much compared to when training solely using the labelled set Dl . However , in this case , the BNN does not need to have high accuracy in order to accurately estimate the metrics . Specifically , for any data point for which the model-under-test disagrees with the ground truth , the BNN does not need to accurately predict its label . That is , even when the BNN predicts other labels ( except the model-under-test output label ) , the metric estimation is still accurate ( more detailed examples in Section C.3 of the appendix ) . Remark 3.2 . For simplicity , we suggest to set the architecture of the binary classifier and BNN to be same . For example , if the BNN is a 2-layer MLP , then the binary classifier is also a 2-layer MLP . | The authors have proposed using an active learning approach to estimate evaluation metrics for a given model. The approach learns a sampling function that decides which observations need to be labeled, which are then fed to a Bayesian neural network (BNN) that aims to estimate the distribution Y|X. The authors select which observations to sample by maximizing the mutual information between the model evaluation metric and the BNN parameters. | SP:31b3653cae47c7e33f5379141951ea37a8c98a79 |
Defining Benchmarks for Continual Few-Shot Learning | 1 INTRODUCTION . Two capabilities vital for an intelligent agent with finite memory are few-shot learning , the ability to learn from a handful of data-points , and continual learning , the ability to sequentially learn new tasks without forgetting previous ones . Taken individually these two areas have recently seen dramatic improvements mainly due to the introduction of proper benchmark tasks and datasets used to systematically compare different methods ( Chen et al. , 2019 ; Lesort et al. , 2019a ; Parisi et al. , 2019 ) . For the set-to-set few-shot setting ( Vinyals et al. , 2016 ) such benchmarks include Omniglot ( Lake et al. , 2015 ) , CUB-200 ( Welinder et al. , 2010 ) , Mini-ImageNet ( Vinyals et al. , 2016 ) and Tiered-ImageNet ( Ren et al. , 2018b ) . For the single-incremental-task continual setting ( Maltoni & Lomonaco , 2019 ) and the multi-task continual setting ( Zenke et al. , 2017 ; Lopez-Paz & Ranzato , 2017 ) the benchmarks include permuted/rotated-MNIST ( Zenke et al. , 2017 ; Goodfellow et al. , 2013 ) , CIFAR10/100 ( Krizhevsky et al. , 2009 ) , and CORe50 ( Lomonaco & Maltoni , 2017 ) . However , none of those benchmarks is particularly well suited for evaluating the hybrid setting of low-data sequential streams . One of the main reasons behind the scarce consideration of the liaison between the two settings is that these problems have been often treated separately and handled by two distinct communities . Historically the research on continual learning has focused on the problem of avoiding the loss of previous knowledge when new tasks are presented to the learner , known as catastrophic forgetting ( McCloskey & Cohen , 1989 ) , without paying much attention to the low-data regime . On the other hand , the research on few-shot learning has mainly focused on achieving good generalization over new tasks , without caring about possible future knowledge gain or loss . Scarce attention has been given to few-shot learning in the more practical continual learning scenario . In this paper we propose to bridge the gap between the two settings by injecting the sequential component of continual learning into the framework of few-shot learning , calling this new paradigm Continual Few-Shot Learning ( CFSL ) . CFSL can be useful to the research community as a frame- work for studying continual learning under memory constraints , and for testing meta-learning systems that are capable of continual learning . While we formally define the problem in Section 3 , a high-level diagram is shown in Figure 1 . Our main contributions can be summarized as follows : 1 . We formalize a highly general and flexible continual few-shot learning setting , taking into account recent considerations expressed in the literature . 2 . We propose a novel benchmark and a compact dataset ( SlimageNet64 ) , releasing them under an open source license . 3 . We compare recent state-of-the-art methods on our benchmark , showing how CFSL is effective in highlighting the strengths and weaknesses of those methods . 1.1 MOTIVATION AND APPLICATIONS . Consider a user in a fast changing environment who must learn from the many scenarios that are encountered . There is the significant challenge of integrating common information from very few data points in each scenario in an online fashion . The small number of data points makes this distinct from normal continual learning setting : the very high uncertainty in each scenario due to the low data volume makes adaptation more challenging and makes the commonality between scenarios even more critical . The online nature of learning makes this distinct from few-shot learning , where integration from different scenarios must be learnt without access to earlier data . These two requirements for online learning without forgetting and efficient integration under uncertainty are competing : both require memory capacity of the learner . Because of these competing requirements , it is valuable to consider continual learning and few-shot learning together rather than in isolation . For a concrete example , consider typical user interfaces such as those used in online stores . The size of data points collected from each user is rather small ( few-shot ) and is generally stored in a sequential buffer or priority queue ( continual ) . Suppose an underlying learning model has been deployed to enhance the user experience by suggesting new products that are likely to be of interest . This model should be able to rapidly adapt to each user ( task ) by accessing the sequential buffer while learning on the fly . There are multiple variants to take into account . For instance , if the user is unknown or previous data is not accessible ( e.g . under privacy policies ) the model has to rapidly infer the user preferences from a single task . On the other hand , if the user profile is known the model should retain knowledge about previous interactions without the need of being retrained from scratch . Another example arise from human-robot interaction , where most of the applications require a robot to learn online by interacting with human teachers . For instance , in a manipulation task the human can provide a few trajectories representing the first task , then the second , the third , etc . The amount of trajectories for each task is usually rather limited and the tasks are learned sequentially . The robot should retain the knowledge of all tasks encountered so far , possibly by avoiding expensive training procedures that would overload the on-board hardware . Note that neither the few-shot nor the continual setting are appropriate to deal with the aforementioned examples , since the former does not consider the sequential component and the latter does not account for the limited data size . Our CFSL formulation instead , can handle all these examples and other collateral variations , as discussed more thoroughly in Section 3 . 2 RELATED WORK . 2.1 FEW-SHOT LEARNING . Progress in few-shot learning ( FSL ) was greatly accelerated after the introduction of the episodic few-shot training ( Vinyals et al. , 2016 ) . This setting , for the first time , formalized few-shot learning as a well defined problem paving the way to the use of end-to-end differentiable algorithms that could be trained , tested , and compared . Among the first algorithms to be proposed there were metalearned solutions , which here we group into three categories : metric-learning , optimization-based , hallucination ( Chen et al. , 2019 ) . Metric-learning techniques are based on the idea of parameterizing embeddings via neural networks and then use distance metrics to match target points to support points in latent space ( Vinyals et al. , 2016 ; Edwards & Storkey , 2017 ; Snell et al. , 2017 ) . Optimization-based or gradient-based techniques are trained to perform a controlled optimization or parameter initialization to learn efficiently from a support set and generalize to a target set ( Ravi & Larochelle , 2016 ; Li et al. , 2017 ; Finn et al. , 2017 ; Antoniou et al. , 2019 ; Rusu et al. , 2019 ; Antoniou & Storkey , 2019 ) . Hallucination techniques utilize one or both the aforementioned methods in combination with a generative process to produce additional samples as a complement to the support set ( Antoniou et al. , 2017 ) . There have been a number of methods that do not clearly fall in one of the previous categories ( Santoro et al. , 2017 ; Santurkar et al. , 2018 ; Chen et al. , 2019 ) , including Bayesian approaches ( Grant et al. , 2018 ; Gordon et al. , 2019 ; Patacchiola et al. , 2019 ) . For more detail , we refer the reader to the original work as well as a survey on few-shot learning ( Chen et al. , 2019 ) . 2.2 CONTINUAL LEARNING . The problem of continual learning ( CL ) , also called life-long learning , has been considered since the beginnings of artificial intelligence and it remains an open challenge in machine learning ( Parisi et al. , 2019 ) . In standard offline supervised learning , algorithms can usually access any data point as many times as necessary during the training phase . In contrast , in CL data arrives sequentially and might only be ever seen once during the training process . Following the taxonomy of ( Maltoni & Lomonaco , 2019 ) , we group the continual learning methods into three classes : architectural , rehearsal , and regularization methods . Each category brings with it a different set of advantages and disadvantages under various resource constraints . Architectural approaches can be constrained on the amount of available RAM ( Rusu et al. , 2016 ; Mallya et al. , 2018 ; Mallya & Lazebnik , 2018 ; Lesort et al. , 2019a ) . Whereas , rehearsal strategies can become quickly bounded by the amount of available storage ( Rebuffi et al. , 2017 ; Lesort et al. , 2018 ; 2019b ) . Regularization approaches can be free from resource constraints but incur in severe issues in the way they adapt model parameters ( Kirkpatrick et al. , 2017 ; Zenke et al. , 2017 ; Lee , 2017 ; He & Jaeger , 2018 ; Mitchell et al. , 2018 ) . The mentioned strategies can often be intersected and combined to form even more powerful models ( Rebuffi et al. , 2017 ; Kemker et al. , 2018 ; Maltoni & Lomonaco , 2019 ) . Due to space constraints , we refer the reader to recent surveys on continual learning ( Lesort et al. , 2019c ; Parisi et al. , 2019 ) . 2.3 JOINING META-LEARNING AND CONTINUAL LEARNING . Attempts to combine continual-learning with meta-learning produced a set of new research areas ( Caccia et al. , 2020 ) . Continual Few-Shot Learning falls into meta continual-learning which can also be thought of as ‘ learning to continually learn ’ ( Finn et al. , 2019 ; He et al. , 2019 ; Harrison et al. , 2019 ) . In contrast , continual meta-learning refers to ‘ continually learning to learn ’ which attempts to make the process of meta-learning continuous as opposed to the standard meta-learning which is typically performed offline . Very recently Caccia et al . ( 2020 ) proposed a hybrid task , called Online faSt Adaptation and Knowledge Accumulation ( OSAKA ) , linking continual-meta learning and meta continual-learning to study continual learning in the context of non-stationarity on shifting task distributions and unknown identities . Related to continual few-shot learning is the field of incremental few-shot learning ( IFSL , ( Gidaris & Komodakis , 2018 ; Ren et al. , 2018a ) ) . In contrast to standard few-shot learning and our work , in IFSL target set is composed of ‘ novel ’ classes ( drawn from a never-seen-before dataset ) as well as classes seen during the meta-learning phase ( called ‘ base classes ’ ) , and it does not consider continual updates to the novel classes . These methods are significantly different in terms of training and testing procedures . For this reason , we will not analyze thie line of research any further . Inconsistencies in the evaluation protocol In the literature , there are no established benchmarks that integrates few-shot and continual learning . Related tasks were introduced to prove the efficacy of a given system , making such tasks very restricted in terms of what methods they are applicable on , and how many aspects they could investigate . We found that tasks and datasets vary from paper to paper , making it challenging to know the actual performance of a given algorithm in comparison to others . For instance , the method proposed by Vuorio et al . ( 2018 ) has been tested exclusively on variants of MNIST . The method of Javed & White ( 2019 ) has been tested on Omniglot and incremental sine-waves . Spigler ( 2019 ) evaluated on MNIST , Le et al . ( 2019 ) on CIFAR100 and permuted MNIST , and Beaulieu et al . ( 2020 ) on Omniglot . It is evident how the problem of continual few-shot learning is not well defined , making it challenging to benchmark and compare the performance of algorithms . | This paper proposes a benchmark for a new task called continual few-shot learning. The benchmark is based on the ImageNet dataset. Basically, the model looks at a part of the support set one after another sequentially, and it is then evaluated on the query set that contains balanced samples from each part of the support set. Under the benchmark, there are four types of challenges, which differs in how they sub-partition the support set. A suite of models have been run and evaluated, including MAML, ProtoNet and SCA. SCA is found to have the best performance, whereas ProtoNet is found to be the most resource efficient. | SP:d4fd62a9542f068cffd3aabe30ae8dd7991284e2 |
Defining Benchmarks for Continual Few-Shot Learning | 1 INTRODUCTION . Two capabilities vital for an intelligent agent with finite memory are few-shot learning , the ability to learn from a handful of data-points , and continual learning , the ability to sequentially learn new tasks without forgetting previous ones . Taken individually these two areas have recently seen dramatic improvements mainly due to the introduction of proper benchmark tasks and datasets used to systematically compare different methods ( Chen et al. , 2019 ; Lesort et al. , 2019a ; Parisi et al. , 2019 ) . For the set-to-set few-shot setting ( Vinyals et al. , 2016 ) such benchmarks include Omniglot ( Lake et al. , 2015 ) , CUB-200 ( Welinder et al. , 2010 ) , Mini-ImageNet ( Vinyals et al. , 2016 ) and Tiered-ImageNet ( Ren et al. , 2018b ) . For the single-incremental-task continual setting ( Maltoni & Lomonaco , 2019 ) and the multi-task continual setting ( Zenke et al. , 2017 ; Lopez-Paz & Ranzato , 2017 ) the benchmarks include permuted/rotated-MNIST ( Zenke et al. , 2017 ; Goodfellow et al. , 2013 ) , CIFAR10/100 ( Krizhevsky et al. , 2009 ) , and CORe50 ( Lomonaco & Maltoni , 2017 ) . However , none of those benchmarks is particularly well suited for evaluating the hybrid setting of low-data sequential streams . One of the main reasons behind the scarce consideration of the liaison between the two settings is that these problems have been often treated separately and handled by two distinct communities . Historically the research on continual learning has focused on the problem of avoiding the loss of previous knowledge when new tasks are presented to the learner , known as catastrophic forgetting ( McCloskey & Cohen , 1989 ) , without paying much attention to the low-data regime . On the other hand , the research on few-shot learning has mainly focused on achieving good generalization over new tasks , without caring about possible future knowledge gain or loss . Scarce attention has been given to few-shot learning in the more practical continual learning scenario . In this paper we propose to bridge the gap between the two settings by injecting the sequential component of continual learning into the framework of few-shot learning , calling this new paradigm Continual Few-Shot Learning ( CFSL ) . CFSL can be useful to the research community as a frame- work for studying continual learning under memory constraints , and for testing meta-learning systems that are capable of continual learning . While we formally define the problem in Section 3 , a high-level diagram is shown in Figure 1 . Our main contributions can be summarized as follows : 1 . We formalize a highly general and flexible continual few-shot learning setting , taking into account recent considerations expressed in the literature . 2 . We propose a novel benchmark and a compact dataset ( SlimageNet64 ) , releasing them under an open source license . 3 . We compare recent state-of-the-art methods on our benchmark , showing how CFSL is effective in highlighting the strengths and weaknesses of those methods . 1.1 MOTIVATION AND APPLICATIONS . Consider a user in a fast changing environment who must learn from the many scenarios that are encountered . There is the significant challenge of integrating common information from very few data points in each scenario in an online fashion . The small number of data points makes this distinct from normal continual learning setting : the very high uncertainty in each scenario due to the low data volume makes adaptation more challenging and makes the commonality between scenarios even more critical . The online nature of learning makes this distinct from few-shot learning , where integration from different scenarios must be learnt without access to earlier data . These two requirements for online learning without forgetting and efficient integration under uncertainty are competing : both require memory capacity of the learner . Because of these competing requirements , it is valuable to consider continual learning and few-shot learning together rather than in isolation . For a concrete example , consider typical user interfaces such as those used in online stores . The size of data points collected from each user is rather small ( few-shot ) and is generally stored in a sequential buffer or priority queue ( continual ) . Suppose an underlying learning model has been deployed to enhance the user experience by suggesting new products that are likely to be of interest . This model should be able to rapidly adapt to each user ( task ) by accessing the sequential buffer while learning on the fly . There are multiple variants to take into account . For instance , if the user is unknown or previous data is not accessible ( e.g . under privacy policies ) the model has to rapidly infer the user preferences from a single task . On the other hand , if the user profile is known the model should retain knowledge about previous interactions without the need of being retrained from scratch . Another example arise from human-robot interaction , where most of the applications require a robot to learn online by interacting with human teachers . For instance , in a manipulation task the human can provide a few trajectories representing the first task , then the second , the third , etc . The amount of trajectories for each task is usually rather limited and the tasks are learned sequentially . The robot should retain the knowledge of all tasks encountered so far , possibly by avoiding expensive training procedures that would overload the on-board hardware . Note that neither the few-shot nor the continual setting are appropriate to deal with the aforementioned examples , since the former does not consider the sequential component and the latter does not account for the limited data size . Our CFSL formulation instead , can handle all these examples and other collateral variations , as discussed more thoroughly in Section 3 . 2 RELATED WORK . 2.1 FEW-SHOT LEARNING . Progress in few-shot learning ( FSL ) was greatly accelerated after the introduction of the episodic few-shot training ( Vinyals et al. , 2016 ) . This setting , for the first time , formalized few-shot learning as a well defined problem paving the way to the use of end-to-end differentiable algorithms that could be trained , tested , and compared . Among the first algorithms to be proposed there were metalearned solutions , which here we group into three categories : metric-learning , optimization-based , hallucination ( Chen et al. , 2019 ) . Metric-learning techniques are based on the idea of parameterizing embeddings via neural networks and then use distance metrics to match target points to support points in latent space ( Vinyals et al. , 2016 ; Edwards & Storkey , 2017 ; Snell et al. , 2017 ) . Optimization-based or gradient-based techniques are trained to perform a controlled optimization or parameter initialization to learn efficiently from a support set and generalize to a target set ( Ravi & Larochelle , 2016 ; Li et al. , 2017 ; Finn et al. , 2017 ; Antoniou et al. , 2019 ; Rusu et al. , 2019 ; Antoniou & Storkey , 2019 ) . Hallucination techniques utilize one or both the aforementioned methods in combination with a generative process to produce additional samples as a complement to the support set ( Antoniou et al. , 2017 ) . There have been a number of methods that do not clearly fall in one of the previous categories ( Santoro et al. , 2017 ; Santurkar et al. , 2018 ; Chen et al. , 2019 ) , including Bayesian approaches ( Grant et al. , 2018 ; Gordon et al. , 2019 ; Patacchiola et al. , 2019 ) . For more detail , we refer the reader to the original work as well as a survey on few-shot learning ( Chen et al. , 2019 ) . 2.2 CONTINUAL LEARNING . The problem of continual learning ( CL ) , also called life-long learning , has been considered since the beginnings of artificial intelligence and it remains an open challenge in machine learning ( Parisi et al. , 2019 ) . In standard offline supervised learning , algorithms can usually access any data point as many times as necessary during the training phase . In contrast , in CL data arrives sequentially and might only be ever seen once during the training process . Following the taxonomy of ( Maltoni & Lomonaco , 2019 ) , we group the continual learning methods into three classes : architectural , rehearsal , and regularization methods . Each category brings with it a different set of advantages and disadvantages under various resource constraints . Architectural approaches can be constrained on the amount of available RAM ( Rusu et al. , 2016 ; Mallya et al. , 2018 ; Mallya & Lazebnik , 2018 ; Lesort et al. , 2019a ) . Whereas , rehearsal strategies can become quickly bounded by the amount of available storage ( Rebuffi et al. , 2017 ; Lesort et al. , 2018 ; 2019b ) . Regularization approaches can be free from resource constraints but incur in severe issues in the way they adapt model parameters ( Kirkpatrick et al. , 2017 ; Zenke et al. , 2017 ; Lee , 2017 ; He & Jaeger , 2018 ; Mitchell et al. , 2018 ) . The mentioned strategies can often be intersected and combined to form even more powerful models ( Rebuffi et al. , 2017 ; Kemker et al. , 2018 ; Maltoni & Lomonaco , 2019 ) . Due to space constraints , we refer the reader to recent surveys on continual learning ( Lesort et al. , 2019c ; Parisi et al. , 2019 ) . 2.3 JOINING META-LEARNING AND CONTINUAL LEARNING . Attempts to combine continual-learning with meta-learning produced a set of new research areas ( Caccia et al. , 2020 ) . Continual Few-Shot Learning falls into meta continual-learning which can also be thought of as ‘ learning to continually learn ’ ( Finn et al. , 2019 ; He et al. , 2019 ; Harrison et al. , 2019 ) . In contrast , continual meta-learning refers to ‘ continually learning to learn ’ which attempts to make the process of meta-learning continuous as opposed to the standard meta-learning which is typically performed offline . Very recently Caccia et al . ( 2020 ) proposed a hybrid task , called Online faSt Adaptation and Knowledge Accumulation ( OSAKA ) , linking continual-meta learning and meta continual-learning to study continual learning in the context of non-stationarity on shifting task distributions and unknown identities . Related to continual few-shot learning is the field of incremental few-shot learning ( IFSL , ( Gidaris & Komodakis , 2018 ; Ren et al. , 2018a ) ) . In contrast to standard few-shot learning and our work , in IFSL target set is composed of ‘ novel ’ classes ( drawn from a never-seen-before dataset ) as well as classes seen during the meta-learning phase ( called ‘ base classes ’ ) , and it does not consider continual updates to the novel classes . These methods are significantly different in terms of training and testing procedures . For this reason , we will not analyze thie line of research any further . Inconsistencies in the evaluation protocol In the literature , there are no established benchmarks that integrates few-shot and continual learning . Related tasks were introduced to prove the efficacy of a given system , making such tasks very restricted in terms of what methods they are applicable on , and how many aspects they could investigate . We found that tasks and datasets vary from paper to paper , making it challenging to know the actual performance of a given algorithm in comparison to others . For instance , the method proposed by Vuorio et al . ( 2018 ) has been tested exclusively on variants of MNIST . The method of Javed & White ( 2019 ) has been tested on Omniglot and incremental sine-waves . Spigler ( 2019 ) evaluated on MNIST , Le et al . ( 2019 ) on CIFAR100 and permuted MNIST , and Beaulieu et al . ( 2020 ) on Omniglot . It is evident how the problem of continual few-shot learning is not well defined , making it challenging to benchmark and compare the performance of algorithms . | This paper proposes a new machine learning setting called “Continual Few-Shot Learning” which fuses the up until now disparate paradigms of continual learning and few-shot learning. To evaluate methods in this new setting, a new benchmark and dataset called SlimageNet64 are defined. Various methods are evaluated on the new benchmark establishing a set of baseline results for the new setting. | SP:d4fd62a9542f068cffd3aabe30ae8dd7991284e2 |
MultiModalQA: complex question answering over text, tables and images | When answering complex questions , people can seamlessly combine information from visual , textual and tabular sources . While interest in models that reason over multiple pieces of evidence has surged in recent years , there has been relatively little work on question answering models that reason across multiple modalities . In this paper , we present MULTIMODALQA ( MMQA ) : a challenging question answering dataset that requires joint reasoning over text , tables and images . We create MMQA using a new framework for generating complex multi-modal questions at scale , harvesting tables from Wikipedia , and attaching images and text paragraphs using entities that appear in each table . We then define a formal language that allows us to take questions that can be answered from a single modality , and combine them to generate cross-modal questions . Last , crowdsourcing workers take these automatically generated questions and rephrase them into more fluent language . We create 29,918 questions through this procedure , and empirically demonstrate the necessity of a multi-modal multi-hop approach to solve our task : our multi-hop model , ImplicitDecomp , achieves an average F1 of 51.7 over cross-modal questions , substantially outperforming a strong baseline that achieves 38.2 F1 , but still lags significantly behind human performance , which is at 90.1 F1 . 1 INTRODUCTION . When presented with complex questions , people often do not know in advance what source ( s ) of information are relevant for answering it . In general scenarios , these sources can encompass multiple modalities , be it paragraphs of text , structured tables , images or combinations of those . For instance , a user might ponder “ When was the famous painting with two touching fingers completed ? ” , if she can not remember the exact name of the painting . Answering this question is made possible by integrating information across both the textual and visual modalities . Recently , there has been substantial interest in question answering ( QA ) models that reason over multiple pieces of evidence ( multi-hop questions ( Yang et al. , 2018 ; Talmor & Berant , 2018 ; Welbl et al. , 2017 ) ) . In most prior work , the question is phrased in natural language and the answer is in a context , which may be a paragraph ( Rajpurkar , 2016 ) , a table ( Pasupat & Liang , 2015 ) , or an image ( Antol et al. , 2015 ) . However , there has been relatively little work on answering questions that require integrating information across modalities . Hannan et al . ( 2020 ) created MANYMODALQA : a dataset where the context for each question includes information from multiple modalities . However , the answer to each question can be derived from a single modality only , and no cross-modality reasoning is needed . Thus , the task is focused on identifying the relevant modality . Recently , Chen et al . ( 2020b ) presented HYBRIDQA , a dataset that requires reasoning over tabular and textual data . While HYBRIDQA requires cross-modal reasoning , it does not require visual inference , limiting the types of questions that can be represented ( See Table 1 for a comparison between the datasets ) . ∗ The authors contributed equally In this work , we present MMQA , the first large-scale ( 29,918 examples ) QA dataset that requires integrating information across free text , semi-structured tables , and images , where 35.7 % of the questions require cross-modality reasoning . Figure 1 shows an example question : “ Which B.Piazza title came earlier : the movie S. Stallon ’ s son starred in , or the movie with half of a lady ’ s face on the poster ? ” . Answering this question entails ( i ) decomposing the question into a sequence of simpler questions , ( ii ) determining the modalities for the simpler questions and answering them , i.e. , information on the poster is in an image , the information on “ S . Stallon ’ s son ” is in free text , and the years of the movies are in the table , ( iii ) combining the information from the simpler questions to compute the answer : “ Tell Me that you love me , Junie Moon ” . Our methodology for creating MMQA involves three high-level steps . ( a ) Context construction : we harvest tables from Wikipedia , and connect each table to images and paragraphs that appear in existing Reading Comprehension ( RC ) datasets ( Kwiatkowski et al. , 2019 ; Clark et al. , 2019 ; Yang et al. , 2018 ) ; ( b ) Question generation : Following past work ( Talmor & Berant , 2018 ) , we use the linked structure of the context to automatically generate questions that require multiple reasoning operations ( composition , conjunction , comparison ) across modalities in pseudo-language ; ( c ) Paraphrasing : we use crowdsourcing workers to paraphrase the pseudo-language questions into more fluent English . To tackle MMQA , we introduce ImplicitDecomp , a new model that predicts a program that specifies the required reasoning steps over different modalities , and executes the program with dedicated text , table , and image models . ImplicitDecomp performs multi-hop multimodal reasoning without the need for an explicit decomposition of the question . We empirically evaluate MMQA by comparing ImplicitDecomp to strong baselines that do not perform cross-modal reasoning and to human performance . We find that on multimodal questions , ImplicitDecomp improves F1 from 38.2→ 51.7 over a single-hop approach . Humans are able to reach 90.1 F1 , significantly outperforming our best model . Because automatic evaluation is non-trivial , we also manually analyze human performance and find humans correctly answer 94.5 % of the questions in MMQA . Finally , our dataset can be used in an open-domain setup over all of Wikipedia . In this setup , the F1 of humans is 84.8 . To summarize , our key contributions are : • MMQA : a dataset with 29,918 questions and answers , 35.7 % of which require cross-modal reasoning . • A methodology for generating multimodal questions over text , tables and images at scale . • ImplicitDecomp , A model for implicitly decomposing multimodal questions , which improves on a single-hop model by 13.5 absolute F1 points on questions requiring cross-modal reasoning . • Our dataset and code are available at https : //allenai.github.io/multimodalqa . 2 DATASET GENERATION . Our goal is to develop a method that allows generating complex questions over multiple modalities at scale . An overview of the methodology is captured in Figure 2 . We first select a Wikipedia table as an anchor , to which we add images and texts paragraphs and obtain a context . Single modality questions are generated based on these contexts , and used to automatically create multimodal , multihop questions . AMT workers rephrase the questions into natural language , and finally distractor paragraphs and images are selected for each question . We now elaborate on the 6 steps of the process . 2.1 Wikipedia tables as anchors The 01-01-2020 English Wikipedia dump contains roughly 3M tables . We extracted all tables and selected those that meet the following criteria : ( a ) The tables contain 10-25 rows ( b ) At least 3 images are associated with the table . This results in a total of 700k tables . ( see supp . material for more information ) . These tables are the anchors of our contexts , which we enrich with images and text for multimodal question generation . A key element of the tables are Wikipedia Entities ( WikiEntities ) that appear in them , i.e. , concepts linked to other Wikipedia entries . We use them to connect different modalities , bridge questions , and solve ambiguities ( details below ) . 2.2 Connecting Images and Text to Tables Images . We consider two cases : ( a ) in-table images and ( b ) images from pages of linked WikiEntities . In the former , the images are featured inside the table cells . In the latter , the table contains a column of WikiEntities that potentially have images , e.g . a table describing the filmography of an actor often contains a column of film names , which may have posters in their respective pages . To associate entities with their representative image , we map entities and their profile images in their Wikipedia pages . Overall , we obtain 57,713 images , with 889 in-table images and 56,824 WikiEntities images . Text . We build on texts from contexts appearing in existing reading comprehension datasets . We elaborate on this process next . 2.3 Generating Single-Modality Questions Tables . We generate pseudo-language table questions in the following form “ In [ table title ] of [ Wikipedia page title ] which cells in [ column X ] have the [ value Y ] in [ column Z ] ? ” . We additionally support numeric computations over columns classified as dates or numbers , such as min and max values , e.g. , “ In [ Doubles ] of [ WCT Tournament of Champions ] , what was the MOST RECENT [ Year ] ( s ) where the [ Location ] was [ Forest Hills ] ” . Images . We use crowdsourcing to generate single-modality questions about images . We generated two types of image questions , based on the images we retrieved from the previous step : ( i ) questions over a single image , ( ii ) questions over a list of images . When generating single-image questions , we show Amazon Mechanical Turk ( AMT ) crowd workers an image alongside its WikiEntity , and ask them to phrase a question about the image with the entity being the focus of the question . E.g , if the entity is “ Roger Federer ” , a potential question is “ What ’ s the hair color of Roger Federer ? ” . For questions to have meaning in an open-domain setting , we primed AMT workers to ask questions that correspond to “ stable ” features , i.e. , features that are unlikely to change in different images and are thus appropriate in an open-domain setting . For questions with a list of images , we use images that appear in the same column of a table . To generate these questions , AMT workers were given the images and asked to phrase a binary question about a distinctive feature of the entities that a subset of the images share . E.g. , given a list of statues , the worker could ask “ Which of the statues features a horse ? ” This process results in 2,764 single image questions and 7,773 list image questions that are later used to create multimodal questions . Text . To obtain questions answerable over text paragraphs we build on existing reading comprehension datasets : Natural Questions ( NQ ) ( Kwiatkowski et al. , 2019 ) consists of about 300K questions issued to the Google search engine . This dataset mostly contains simple questions where a single paragraph suffices to answer each question . BoolQ ( Clark et al. , 2019 ) contains 15 , 942 yes/no questions , gathered using the same pipeline as NQ . HotpotQA ( Yang et al. , 2018 ) contains 112K training questions , where crowd workers were shown pairs of related Wikipedia paragraphs and were asked to author questions that require multi-hop reasoning over the paragraphs . To use questions from the above datasets as building blocks for multi-hop multimodal questions , we unified them into a corpus that consists of triples of ( i ) a text question , ( ii ) an answer and ( iii ) 1-2 gold paragraphs from Wikipedia . We link a question to a table , by matching WikiEntities in the table to entities in the text of the question ( see supplementary material for further details ) . Overall , we retrieved 6,644 questions from NQ , 1,246 from BoolQ and 4,733 from HotpotQA . 2.4 Generating multimodal complex questions We present an automatic method for creating at scale multimodal compositional questions ( i , e. , questions that require answering a sequence of subquestions to conclude the final answer ) . Our first step is to introduce a formal language that allows to combine questions answerable from a single modality . Below we introduce the logical operations that allow to generate such pseudo-language ( PL ) questions , while keeping a formal representation of how they were constructed . In Table 2 , we illustrate this process with all 16 different compositional templates used for question generation . We now describe our logical operations . Logical Operations Functions in our formal language take arguments and return a PL partial question , as well as answers that can be a list of one or more strings , or a list of one or more WikiEntities . All operations have access to the full context . In addition , we prepend a prefix containing the Wikipedia table name and page title—e.g . “ In the Filmography of Brad Pitt , ” —to all our PL questions to support an open-domain QA setup . Our set of logical operations are : 1 . TABLEQ : Returns a question from the table questions generated in §2.3 , as well as a list of WikiEntities or a list of strings as answers . 2 . TEXTQ : Returns a text corpus question ( see §2.3 ) and a list of WikiEntities or strings as answers . 3 . IMAGEQ : Returns a question about a single image associated with a WikiEntity and a single token answer from a fixed vocabulary ( see §2.3 ) . 4 . IMAGELISTQ : Returns a question about a list of images and a list of WikiEntities corresponding to the images that answer the question ( see §2.3 ) . 5 . COMPOSE ( · , · ) : Takes a PL question containing a single WikiEntity as a first argument , and a PL question that produces that WikiEntity as the output answer as its second argument . E.g. , COMPOSE ( “ Where was Barack Obama born ? ” , “ Who was the 44th president of the USA ? ” ) . The function replaces the WikiEntity in the first-argument PL question with the second-argument PL question and returns the resulting PL question ( “ Where was the 44th president of the USA born ? ” ) . 6 . INTERSECT ( · , · ) : Takes two PL questions that return lists of more than one WikiEntity , and returns their intersection as the answer . The resulting PL question is of the form “ PL1 and PL2 ” omitting PL2 ’ s first word ( “ Who was born in Hawaii and is the parent of Sasha Obama ? ” ) . 7 . COMPARE ( · , · ) : Takes two PL questions each returning one WikiEntity that can be linked to one cell in the table , denoted by Ans1 , Ans2 . We first choose a numeric or date column in the table , if such exists . We then compare the values of this column corresponding to the rows of Ans1 and Ans2 . Depending on the comparison outcome , output one of ( Ans1 , Ans2 ) as the operation answer . The PL question created is of the form “ What has compare-op numeric-column-name , PL1 or PL2 ? ” omitting PL1 and PL2 ’ s first word . E.g . “ What has most recent creation year , the rocket of Appolo program , or the rocket of Gemini program ? ” 2.5 Paraphrasing using AMT We used English-speaking AMT workers to paraphrase automaticallygenerated PL questions into natural language ( NL ) . Each question was paraphrased by 1 worker and validated by 1-3 other workers . To avoid annotator bias ( Geva et al. , 2019 ) , the number of annotators who worked on both the training and evaluation set was kept to a minimum . We also deployed a feedback mechanism , where workers receive a bonus if a baseline model correctly answered the question after their first paraphrasing attempt , but incorrectly after they refined the paraphrase . See supp . material for print-screens of the AMT annotator interface . To generate diversity , workers got a bonus if the normalized edit distance of a paraphrase compared to the PL question was higher than 0.7 . A total of 971 workers were involved , and 29,918 examples were produced with an average cost of 0.33 $ per question . We split the dataset into 23,817 training , 2,441 development ( dev . ) , and 3,660 test set examples . Context components in the dev . and test sets are disjoint , and were constructed from a disjoint set of single-modality questions . A shortcoming of our method for automatically generating examples is that the question distribution does not come from a “ natural ” source . We argue that developing models that are capable of performing reasoning over multiple modalities is an important direction and MMQA provides an opportunity to develop and evaluate such models . Moreover , this method allows to control the compositional questions created , proving effective in creating a cheap and scalable dataset . 2.6 Adding distractors to the context Images . Questions from the IMAGELISTQ operator require reasoning over a list of images from the same column , and hence do not require additional distractors . For IMAGEQ questions ( single-image ) , we randomly add images that are associated with the WikiEntities that appear in the table , setting a maximum of 15 distractors per question . Text . We used DPR ( Karpukhin et al. , 2020 ) , a neural information retrieval model , to retrieve distractors for all questions . Each context includes exactly 10 paragraphs , where 1-2 are gold paragraphs and the rest are distractors . Specifically , we encode the first 2 paragraphs of each Wikipedia article with the DPR encoder , and use as distractors the paragraphs with the highest dot product between their encoding and the question encoding . We do not allow : ( a ) an overlap between the distractors in the training and evaluation sets , ( b ) distractors originating from the gold article , ( c ) distractors containing an exact match to the gold answer . To summarize , each of our examples contains a question , an answer , the formal representation of the PL question ( ignored by our models ) , and all distractors and gold context for all modalities . This renders MMQA useful for both open-domain multimodal QA , as well as context-dependant QA . | The paper introduces MultiModalQA, a dataset that requires joint reasoning over table, text and images. The dataset has been created in a semi-automatic way through Wikipedia tables, the Wikientities in them, their related images and related textual question answer pairs from known text QA datasets. For the collection of the dataset, authors collect single modality questions and then use a programmatic way to generate the multimodality versions. The paper also introduces a multi-hop baseline that guesses the question type and then does two hops over the different single modality modules to generate the final answer. | SP:f8b6ecb2877d258f483cf38966828974ad39f2e8 |
MultiModalQA: complex question answering over text, tables and images | When answering complex questions , people can seamlessly combine information from visual , textual and tabular sources . While interest in models that reason over multiple pieces of evidence has surged in recent years , there has been relatively little work on question answering models that reason across multiple modalities . In this paper , we present MULTIMODALQA ( MMQA ) : a challenging question answering dataset that requires joint reasoning over text , tables and images . We create MMQA using a new framework for generating complex multi-modal questions at scale , harvesting tables from Wikipedia , and attaching images and text paragraphs using entities that appear in each table . We then define a formal language that allows us to take questions that can be answered from a single modality , and combine them to generate cross-modal questions . Last , crowdsourcing workers take these automatically generated questions and rephrase them into more fluent language . We create 29,918 questions through this procedure , and empirically demonstrate the necessity of a multi-modal multi-hop approach to solve our task : our multi-hop model , ImplicitDecomp , achieves an average F1 of 51.7 over cross-modal questions , substantially outperforming a strong baseline that achieves 38.2 F1 , but still lags significantly behind human performance , which is at 90.1 F1 . 1 INTRODUCTION . When presented with complex questions , people often do not know in advance what source ( s ) of information are relevant for answering it . In general scenarios , these sources can encompass multiple modalities , be it paragraphs of text , structured tables , images or combinations of those . For instance , a user might ponder “ When was the famous painting with two touching fingers completed ? ” , if she can not remember the exact name of the painting . Answering this question is made possible by integrating information across both the textual and visual modalities . Recently , there has been substantial interest in question answering ( QA ) models that reason over multiple pieces of evidence ( multi-hop questions ( Yang et al. , 2018 ; Talmor & Berant , 2018 ; Welbl et al. , 2017 ) ) . In most prior work , the question is phrased in natural language and the answer is in a context , which may be a paragraph ( Rajpurkar , 2016 ) , a table ( Pasupat & Liang , 2015 ) , or an image ( Antol et al. , 2015 ) . However , there has been relatively little work on answering questions that require integrating information across modalities . Hannan et al . ( 2020 ) created MANYMODALQA : a dataset where the context for each question includes information from multiple modalities . However , the answer to each question can be derived from a single modality only , and no cross-modality reasoning is needed . Thus , the task is focused on identifying the relevant modality . Recently , Chen et al . ( 2020b ) presented HYBRIDQA , a dataset that requires reasoning over tabular and textual data . While HYBRIDQA requires cross-modal reasoning , it does not require visual inference , limiting the types of questions that can be represented ( See Table 1 for a comparison between the datasets ) . ∗ The authors contributed equally In this work , we present MMQA , the first large-scale ( 29,918 examples ) QA dataset that requires integrating information across free text , semi-structured tables , and images , where 35.7 % of the questions require cross-modality reasoning . Figure 1 shows an example question : “ Which B.Piazza title came earlier : the movie S. Stallon ’ s son starred in , or the movie with half of a lady ’ s face on the poster ? ” . Answering this question entails ( i ) decomposing the question into a sequence of simpler questions , ( ii ) determining the modalities for the simpler questions and answering them , i.e. , information on the poster is in an image , the information on “ S . Stallon ’ s son ” is in free text , and the years of the movies are in the table , ( iii ) combining the information from the simpler questions to compute the answer : “ Tell Me that you love me , Junie Moon ” . Our methodology for creating MMQA involves three high-level steps . ( a ) Context construction : we harvest tables from Wikipedia , and connect each table to images and paragraphs that appear in existing Reading Comprehension ( RC ) datasets ( Kwiatkowski et al. , 2019 ; Clark et al. , 2019 ; Yang et al. , 2018 ) ; ( b ) Question generation : Following past work ( Talmor & Berant , 2018 ) , we use the linked structure of the context to automatically generate questions that require multiple reasoning operations ( composition , conjunction , comparison ) across modalities in pseudo-language ; ( c ) Paraphrasing : we use crowdsourcing workers to paraphrase the pseudo-language questions into more fluent English . To tackle MMQA , we introduce ImplicitDecomp , a new model that predicts a program that specifies the required reasoning steps over different modalities , and executes the program with dedicated text , table , and image models . ImplicitDecomp performs multi-hop multimodal reasoning without the need for an explicit decomposition of the question . We empirically evaluate MMQA by comparing ImplicitDecomp to strong baselines that do not perform cross-modal reasoning and to human performance . We find that on multimodal questions , ImplicitDecomp improves F1 from 38.2→ 51.7 over a single-hop approach . Humans are able to reach 90.1 F1 , significantly outperforming our best model . Because automatic evaluation is non-trivial , we also manually analyze human performance and find humans correctly answer 94.5 % of the questions in MMQA . Finally , our dataset can be used in an open-domain setup over all of Wikipedia . In this setup , the F1 of humans is 84.8 . To summarize , our key contributions are : • MMQA : a dataset with 29,918 questions and answers , 35.7 % of which require cross-modal reasoning . • A methodology for generating multimodal questions over text , tables and images at scale . • ImplicitDecomp , A model for implicitly decomposing multimodal questions , which improves on a single-hop model by 13.5 absolute F1 points on questions requiring cross-modal reasoning . • Our dataset and code are available at https : //allenai.github.io/multimodalqa . 2 DATASET GENERATION . Our goal is to develop a method that allows generating complex questions over multiple modalities at scale . An overview of the methodology is captured in Figure 2 . We first select a Wikipedia table as an anchor , to which we add images and texts paragraphs and obtain a context . Single modality questions are generated based on these contexts , and used to automatically create multimodal , multihop questions . AMT workers rephrase the questions into natural language , and finally distractor paragraphs and images are selected for each question . We now elaborate on the 6 steps of the process . 2.1 Wikipedia tables as anchors The 01-01-2020 English Wikipedia dump contains roughly 3M tables . We extracted all tables and selected those that meet the following criteria : ( a ) The tables contain 10-25 rows ( b ) At least 3 images are associated with the table . This results in a total of 700k tables . ( see supp . material for more information ) . These tables are the anchors of our contexts , which we enrich with images and text for multimodal question generation . A key element of the tables are Wikipedia Entities ( WikiEntities ) that appear in them , i.e. , concepts linked to other Wikipedia entries . We use them to connect different modalities , bridge questions , and solve ambiguities ( details below ) . 2.2 Connecting Images and Text to Tables Images . We consider two cases : ( a ) in-table images and ( b ) images from pages of linked WikiEntities . In the former , the images are featured inside the table cells . In the latter , the table contains a column of WikiEntities that potentially have images , e.g . a table describing the filmography of an actor often contains a column of film names , which may have posters in their respective pages . To associate entities with their representative image , we map entities and their profile images in their Wikipedia pages . Overall , we obtain 57,713 images , with 889 in-table images and 56,824 WikiEntities images . Text . We build on texts from contexts appearing in existing reading comprehension datasets . We elaborate on this process next . 2.3 Generating Single-Modality Questions Tables . We generate pseudo-language table questions in the following form “ In [ table title ] of [ Wikipedia page title ] which cells in [ column X ] have the [ value Y ] in [ column Z ] ? ” . We additionally support numeric computations over columns classified as dates or numbers , such as min and max values , e.g. , “ In [ Doubles ] of [ WCT Tournament of Champions ] , what was the MOST RECENT [ Year ] ( s ) where the [ Location ] was [ Forest Hills ] ” . Images . We use crowdsourcing to generate single-modality questions about images . We generated two types of image questions , based on the images we retrieved from the previous step : ( i ) questions over a single image , ( ii ) questions over a list of images . When generating single-image questions , we show Amazon Mechanical Turk ( AMT ) crowd workers an image alongside its WikiEntity , and ask them to phrase a question about the image with the entity being the focus of the question . E.g , if the entity is “ Roger Federer ” , a potential question is “ What ’ s the hair color of Roger Federer ? ” . For questions to have meaning in an open-domain setting , we primed AMT workers to ask questions that correspond to “ stable ” features , i.e. , features that are unlikely to change in different images and are thus appropriate in an open-domain setting . For questions with a list of images , we use images that appear in the same column of a table . To generate these questions , AMT workers were given the images and asked to phrase a binary question about a distinctive feature of the entities that a subset of the images share . E.g. , given a list of statues , the worker could ask “ Which of the statues features a horse ? ” This process results in 2,764 single image questions and 7,773 list image questions that are later used to create multimodal questions . Text . To obtain questions answerable over text paragraphs we build on existing reading comprehension datasets : Natural Questions ( NQ ) ( Kwiatkowski et al. , 2019 ) consists of about 300K questions issued to the Google search engine . This dataset mostly contains simple questions where a single paragraph suffices to answer each question . BoolQ ( Clark et al. , 2019 ) contains 15 , 942 yes/no questions , gathered using the same pipeline as NQ . HotpotQA ( Yang et al. , 2018 ) contains 112K training questions , where crowd workers were shown pairs of related Wikipedia paragraphs and were asked to author questions that require multi-hop reasoning over the paragraphs . To use questions from the above datasets as building blocks for multi-hop multimodal questions , we unified them into a corpus that consists of triples of ( i ) a text question , ( ii ) an answer and ( iii ) 1-2 gold paragraphs from Wikipedia . We link a question to a table , by matching WikiEntities in the table to entities in the text of the question ( see supplementary material for further details ) . Overall , we retrieved 6,644 questions from NQ , 1,246 from BoolQ and 4,733 from HotpotQA . 2.4 Generating multimodal complex questions We present an automatic method for creating at scale multimodal compositional questions ( i , e. , questions that require answering a sequence of subquestions to conclude the final answer ) . Our first step is to introduce a formal language that allows to combine questions answerable from a single modality . Below we introduce the logical operations that allow to generate such pseudo-language ( PL ) questions , while keeping a formal representation of how they were constructed . In Table 2 , we illustrate this process with all 16 different compositional templates used for question generation . We now describe our logical operations . Logical Operations Functions in our formal language take arguments and return a PL partial question , as well as answers that can be a list of one or more strings , or a list of one or more WikiEntities . All operations have access to the full context . In addition , we prepend a prefix containing the Wikipedia table name and page title—e.g . “ In the Filmography of Brad Pitt , ” —to all our PL questions to support an open-domain QA setup . Our set of logical operations are : 1 . TABLEQ : Returns a question from the table questions generated in §2.3 , as well as a list of WikiEntities or a list of strings as answers . 2 . TEXTQ : Returns a text corpus question ( see §2.3 ) and a list of WikiEntities or strings as answers . 3 . IMAGEQ : Returns a question about a single image associated with a WikiEntity and a single token answer from a fixed vocabulary ( see §2.3 ) . 4 . IMAGELISTQ : Returns a question about a list of images and a list of WikiEntities corresponding to the images that answer the question ( see §2.3 ) . 5 . COMPOSE ( · , · ) : Takes a PL question containing a single WikiEntity as a first argument , and a PL question that produces that WikiEntity as the output answer as its second argument . E.g. , COMPOSE ( “ Where was Barack Obama born ? ” , “ Who was the 44th president of the USA ? ” ) . The function replaces the WikiEntity in the first-argument PL question with the second-argument PL question and returns the resulting PL question ( “ Where was the 44th president of the USA born ? ” ) . 6 . INTERSECT ( · , · ) : Takes two PL questions that return lists of more than one WikiEntity , and returns their intersection as the answer . The resulting PL question is of the form “ PL1 and PL2 ” omitting PL2 ’ s first word ( “ Who was born in Hawaii and is the parent of Sasha Obama ? ” ) . 7 . COMPARE ( · , · ) : Takes two PL questions each returning one WikiEntity that can be linked to one cell in the table , denoted by Ans1 , Ans2 . We first choose a numeric or date column in the table , if such exists . We then compare the values of this column corresponding to the rows of Ans1 and Ans2 . Depending on the comparison outcome , output one of ( Ans1 , Ans2 ) as the operation answer . The PL question created is of the form “ What has compare-op numeric-column-name , PL1 or PL2 ? ” omitting PL1 and PL2 ’ s first word . E.g . “ What has most recent creation year , the rocket of Appolo program , or the rocket of Gemini program ? ” 2.5 Paraphrasing using AMT We used English-speaking AMT workers to paraphrase automaticallygenerated PL questions into natural language ( NL ) . Each question was paraphrased by 1 worker and validated by 1-3 other workers . To avoid annotator bias ( Geva et al. , 2019 ) , the number of annotators who worked on both the training and evaluation set was kept to a minimum . We also deployed a feedback mechanism , where workers receive a bonus if a baseline model correctly answered the question after their first paraphrasing attempt , but incorrectly after they refined the paraphrase . See supp . material for print-screens of the AMT annotator interface . To generate diversity , workers got a bonus if the normalized edit distance of a paraphrase compared to the PL question was higher than 0.7 . A total of 971 workers were involved , and 29,918 examples were produced with an average cost of 0.33 $ per question . We split the dataset into 23,817 training , 2,441 development ( dev . ) , and 3,660 test set examples . Context components in the dev . and test sets are disjoint , and were constructed from a disjoint set of single-modality questions . A shortcoming of our method for automatically generating examples is that the question distribution does not come from a “ natural ” source . We argue that developing models that are capable of performing reasoning over multiple modalities is an important direction and MMQA provides an opportunity to develop and evaluate such models . Moreover , this method allows to control the compositional questions created , proving effective in creating a cheap and scalable dataset . 2.6 Adding distractors to the context Images . Questions from the IMAGELISTQ operator require reasoning over a list of images from the same column , and hence do not require additional distractors . For IMAGEQ questions ( single-image ) , we randomly add images that are associated with the WikiEntities that appear in the table , setting a maximum of 15 distractors per question . Text . We used DPR ( Karpukhin et al. , 2020 ) , a neural information retrieval model , to retrieve distractors for all questions . Each context includes exactly 10 paragraphs , where 1-2 are gold paragraphs and the rest are distractors . Specifically , we encode the first 2 paragraphs of each Wikipedia article with the DPR encoder , and use as distractors the paragraphs with the highest dot product between their encoding and the question encoding . We do not allow : ( a ) an overlap between the distractors in the training and evaluation sets , ( b ) distractors originating from the gold article , ( c ) distractors containing an exact match to the gold answer . To summarize , each of our examples contains a question , an answer , the formal representation of the PL question ( ignored by our models ) , and all distractors and gold context for all modalities . This renders MMQA useful for both open-domain multimodal QA , as well as context-dependant QA . | The authors present a new dataset, MultiModalQA, with the intent of measuring a model’s ability to reason across different modalities (free text, structured tables, and images) in question answering, and in which a large percentage of the questions requires cross-modal reasoning. The authors provide a detailed look at the framework used to generate questions in the context of several modalities. Finally, the authors propose a multimodal model that performs multi-hop reasoning (removing the need for explicit question decomposition), which outperforms strong baselines, but is still far behind human performance, indicating that the task is nontrivial and would benefit the research community. | SP:f8b6ecb2877d258f483cf38966828974ad39f2e8 |
Legendre Deep Neural Network (LDNN) and its application for approximation of nonlinear Volterra–Fredholm–Hammerstein integral equations | 1 INTRODUCTION . Deep neural networks are a main and beneficial part of machine learning family which are applied in various areas including speech processing , computer vision , natural language processing and image processing ( LeCun et al. , 2015 ; Krizhevsky et al. , 2012 ) . Also , the approximation of the functions is a significant branch in scientific computational and achieving success in this area is considered by some research ( Tang et al. , 2019 ; Hanin , 2019 ) . Solving differential equations is the other main branch of scientific computational which neural networks and deep learning have been shown success in this area . ( Lample & Charton , 2019 ; Berg & Nyström , 2018 ; Raissi et al. , 2019 ) . Various phenomena in biology , physics , finance , neuroscience and engineering are modeled by differential equations ( Courant & Hilbert , 2008 ; Davis , 1961 ) . In recent years , several researchers studied the solving differential equations via deep learning or neural networks . differential equations consists of ordinary differential equations , partial differential equations and integral equations . ( Sirignano & Spiliopoulos , 2018 ; Lu et al. , 2019 ; Meng et al. , 2020 ) . It is notable that the various numerical methods are applied for solving differential equations . Homotopy analysis method ( HAM ) ( Liao , 2012 ) and variational iteration method ( VIM ) ( He & Wu , 2007 ) are known as analytical/semi-analytical methods . Usually , spectral methods ( Canuto et al. , 2012 ) , Runge-Kutta methods ( Hairer et al. , 2006 ) , the finite difference methods ( FDM ) ( Smith , 1985 ) and the finite element methods ( FEM ) ( Johnson , 2012 ) are considered as the popular numerical methods . When the complexity of the model does not allow us to obtain the solution explicitly , numerical methods are a proper selection for finding the approximate solution for the models . Recently , some of the machine learning methods are applied for solving differential equations . Chakraverty & Mall ( 2017 ) introduced orthogonal neural networks which used orthogonal polynomials in the structure of the network . Raja et al . ( 2019 ) applied meta-heuristic optimization algorithm to neural network for obtaining the solution of differential equations . Moreover , other methods of machine learning such as support vector machine ( Vapnik , 2013 ) are used to approximate the solution of the models . Least squares support vector machines are considered in these researches ( Hajimohammadi et al. , 2020 ; Mehrkanoon & Suykens , 2015 ) . Baker et al . ( 2019 ) selected deep neural networks for solving the differential equations . Pang et al . ( 2019 ) introduced a new network to find the solution of the different equations . Han et al . ( 2018 ) solved high-dimensional problems via deep networks . Also , Long et al . ( 2018 ) and Raissi et al . ( 2019 ) introduced a group of the equations which solved by deep learning . Furthermore , He et al . ( 2018 ) and Molina et al . ( 2019 ) investigated the effect of the activation function on networks . In this paper , we concern nonlinear Volterra–Fredholm–Hammerstein integral equations ( V-F-HIEs ) and try to obtain the solution of them via deep neural network . We present a new numerical approach of machine learning which is a combination of deep neural network and Legendre collocation method . This approach is useful for solving the differential equations and we applied it for solving nonlinear V-F-H-IEs . We used Legendre collocation method to our network for perfect the numerical computations and enhancement the performance the network . 2 LEGENDRE DEEP NEURAL NETWORK ( LDNN ) . The main purpose of introducing LDNN is to apply it for solving differential models . Indeed , this purpose is to expand the utilization of deep learning networks in the field of scientific computing , especially the solution of differential equations . Moreover , this network has the advantages of solving equations by deep learning as well as numerical methods such as collocation method used to achieve better solution to the equations . LDNN presents a combination of a deep neural network and Legendre collocation method . In fact , our network consists of two networks which have connected consecutive to each other . The first network is a feed forward neural network which has an orthogonal Legendre layer . The second network includes operation nodes to create the desired computational model . In recent decades , numerical methods especially collocation method are popular methods for solving differential equations . In the collocation method , first an approximation of the solution is expanded by using the sum of the basic functions . The basic functions consists of the orthogonal polynomials such as Legendre polynomials.Then this approximation is placed in the differential equation . By considering the appropriate set of candidate points , an attempt is made to obtain the unknown coefficients of the basic functions so that the solution satisfies the equation in a set of candidate points . The first network is applied to creat the approximation of the solution . This approximation can be known as the scattered data interpolation problem . The second network is used to obtain the desired equation so that the solution satisfies it . The structure of LDNN is described in detail at the following rest . Consider that the first network has aM-layer which defined as follows : H0 = x , x ∈ Rd , H1 = L ( W ( 1 ) H0 + b ( 1 ) ) , Hi = f ( W ( i ) Hi−1 + b ( i ) ) , 2 ≤ i ≤M− 1 , HM = W ( M ) HM−1 + b ( M ) . where H0 is the input layer with d dimension . Hi , 1 ≤ i ≤ M − 1 are hidden layers , L = [ L0 , L1 , ... Ln ] T which Li are i-th degrees of Legendre orthogonal polynomials , H1 is an orthogonal layer , f is the hyperbolic tangent activation function or other commonly used activation functions . W ( i ) , i = 1 , · · · , M are the weight parameters and b ( i ) , 1 ≤ i ≤ M are the bias parameters . HM is the output layer . It is notable that the second network is applied to obtain the desired differential model . This aim is possible by using operation nodes including integrals , derivatives , and etc . These nodes are applied to the output of the first network . Moreover , automatic differentiation ( AD ) ( Baydin et al. , 2017 ) and Legendre Gaussian integration ( Shen et al. , 2011 ) have been used in network computing to obtain more accurate and fast calculations . How to train the network and set the parameters are also important points . Supervised learning method is used to train network . The cost function for setting parameters is defined as follows : CostFun = min ( yt − yp ) + min ( Rm ) . ( 1 ) where yt is an exact value of the model and yp is a predicted value of the LDNN . The definition of Rm is explained in section 3.The minimization of CostFun is obtained by performing Adam algorithm ( Kingma & Ba , 2015 ) and the L-BFGS method ( Liu & Nocedal , 1989 ) on mean squared errors of training data set . 2.1 LEGENDRE POLYNOMIALS . Legendre polynomials ( Shen et al. , 2011 ) are a main series of orthogonal polynomials which denoted by Ln ( η ) , are defined as : Ln ( η ) = 1 2n [ n2 ] ∑ ` =0 ( −1 ) ` ( 2n− 2 ` ) ! 2n ` ! ( n− ` ) ! ( n− 2 ` ) ! ηn−2 ` ( 2 ) Legendre polynomials are defined in [ −1 , 1 ] domain and have the recurrence formula in the following form : ( n+ 1 ) Ln+1 ( η ) = ( 2n+ 1 ) ηLn ( η ) − nLn−1 ( η ) , n ≥ 1 , L0 ( η ) = 1 , L1 ( η ) = η . ( 3 ) Orthogonality relation for these polynomials is as follows : ∫ 1 −1 Ln ( η ) Lm ( η ) dη = γδn , m , ( 4 ) where δn , m is a delta Kronecker function and γ = 22n+1 . The weight function of them isW ( η ) = 1 . Some following useful properties of Legendre polynomials are defined : Ln ( −η ) = ( −1 ) nLn ( η ) , ( 5 ) |Ln ( η ) | ≤ 1 , ∀η ∈ [ −1 , 1 ] , n ≥ 0 , ( 6 ) Ln ( ±1 ) = ( ±1 ) n , ( 7 ) ( 2n+ 1 ) Ln ( η ) = L ′ n+1 ( η ) − L′n−1 ( η ) , n ≥ 1 . ( 8 ) 3 NONLINEAR VOLTERRA–FREDHOLM–HAMMERSTEIN INTEGRAL EQUATIONS AND LDNN . The general form of nonlinear Volterra–Fredholm–Hammerstein integral equations ( V-F-H-IEs ) is as follows : y ( x ) = g ( x ) + ξ1 ∫ x 0 K1 ( x , s ) ϕ1 ( s , y ( s ) ) ds+ ξ2 ∫ 1 0 K2 ( x , s ) ϕ2 ( s , y ( s ) ) ds , x ∈ [ 0 , 1 ] . ( 9 ) where ξ1 , ξ2 are fixed , g ( x ) , K1 ( x , s ) and K2 ( x , s ) are given functions and ϕ1 ( s , y ( s ) ) , ϕ2 ( s , y ( s ) ) are nonlinear functions . The aim is to find the proper y ( x ) . In order to use the LDNN , reformulated Eq . ( 9 ) in the following form : Rm = −y ( x ) +g ( x ) + ξ1 ∫ x 0 K1 ( x , s ) ϕ1 ( s , y ( s ) ) ds+ ξ2 ∫ 1 0 K2 ( x , s ) ϕ2 ( s , y ( s ) ) ds , x ∈ [ 0 , 1 ] . ( 10 ) y ( x ) is approximated by the first network of the LDNN . y ( x ) ≈ HM . ( 11 ) Furthermore , we applied Legendre–Gauss integration formula ( Shen et al. , 2011 ) : ∫ 1 −1 h ( X ) dX = N∑ j=0 ωjh ( Xj ) ( 12 ) where { Xj } Nj=0 are the roots of Ln+1 and { ωj } Nj=0 = 2 ( 1−X2j ) ( L′n+1 ( Xj ) ) 2 . Here , we should transfer the [ 0 , x ] and [ 0 , 1 ] domains into the [ −1 , 1 ] domain . It is possible by using the following transformation : t1 = 2 x s− 1 , t2 = 2s− 1 . Consider Z1 ( x , s ) = K1 ( x , s ) ϕ1 ( s , y ( s ) ) , Z2 ( x , s ) = K2 ( x , s ) ϕ2 ( s , y ( s ) ) . we have Rm = −y ( x ) + g ( x ) + ξ1 x 2 ∫ 1 −1 Z1 ( x , x 2 ( t1 + 1 ) ) dt1 + ξ2 2 ∫ 1 −1 Z2 ( x , x 2 ( t2 + 1 ) ) dt2 . ( 13 ) by using Legendre–Gauss integration formula , the below form is concluded : Rm = −y ( x ) + g ( x ) + ξ1 x 2 N1∑ j=0 ω1jZ1 ( x , x 2 ( t1j + 1 ) ) + ξ2 2 N2∑ j=0 ω2jZ2 ( x , x 2 ( t2j + 1 ) ) . ( 14 ) The second network of LDNN and its nodes makes Rm . The architecture of LDNN for solving nonlinear V-F-H-IEs is represented in Figure 1 . | The paper proposed the Legendre Deep Neural Network (LDNN) to solve Volterra–Fredholm–Hammerstein integral equations. Specifically, the network uses Legendre polynomials as the activation in the first layer and uses Gaussian quadrature to discretize the integral operator as a summation. The numerical examples are performed to verify the performance of LDNN. However, the method is not novel and the numerical examples are too simple. | SP:aa0febaec3494ea69264d71d33081759037e5319 |
Legendre Deep Neural Network (LDNN) and its application for approximation of nonlinear Volterra–Fredholm–Hammerstein integral equations | 1 INTRODUCTION . Deep neural networks are a main and beneficial part of machine learning family which are applied in various areas including speech processing , computer vision , natural language processing and image processing ( LeCun et al. , 2015 ; Krizhevsky et al. , 2012 ) . Also , the approximation of the functions is a significant branch in scientific computational and achieving success in this area is considered by some research ( Tang et al. , 2019 ; Hanin , 2019 ) . Solving differential equations is the other main branch of scientific computational which neural networks and deep learning have been shown success in this area . ( Lample & Charton , 2019 ; Berg & Nyström , 2018 ; Raissi et al. , 2019 ) . Various phenomena in biology , physics , finance , neuroscience and engineering are modeled by differential equations ( Courant & Hilbert , 2008 ; Davis , 1961 ) . In recent years , several researchers studied the solving differential equations via deep learning or neural networks . differential equations consists of ordinary differential equations , partial differential equations and integral equations . ( Sirignano & Spiliopoulos , 2018 ; Lu et al. , 2019 ; Meng et al. , 2020 ) . It is notable that the various numerical methods are applied for solving differential equations . Homotopy analysis method ( HAM ) ( Liao , 2012 ) and variational iteration method ( VIM ) ( He & Wu , 2007 ) are known as analytical/semi-analytical methods . Usually , spectral methods ( Canuto et al. , 2012 ) , Runge-Kutta methods ( Hairer et al. , 2006 ) , the finite difference methods ( FDM ) ( Smith , 1985 ) and the finite element methods ( FEM ) ( Johnson , 2012 ) are considered as the popular numerical methods . When the complexity of the model does not allow us to obtain the solution explicitly , numerical methods are a proper selection for finding the approximate solution for the models . Recently , some of the machine learning methods are applied for solving differential equations . Chakraverty & Mall ( 2017 ) introduced orthogonal neural networks which used orthogonal polynomials in the structure of the network . Raja et al . ( 2019 ) applied meta-heuristic optimization algorithm to neural network for obtaining the solution of differential equations . Moreover , other methods of machine learning such as support vector machine ( Vapnik , 2013 ) are used to approximate the solution of the models . Least squares support vector machines are considered in these researches ( Hajimohammadi et al. , 2020 ; Mehrkanoon & Suykens , 2015 ) . Baker et al . ( 2019 ) selected deep neural networks for solving the differential equations . Pang et al . ( 2019 ) introduced a new network to find the solution of the different equations . Han et al . ( 2018 ) solved high-dimensional problems via deep networks . Also , Long et al . ( 2018 ) and Raissi et al . ( 2019 ) introduced a group of the equations which solved by deep learning . Furthermore , He et al . ( 2018 ) and Molina et al . ( 2019 ) investigated the effect of the activation function on networks . In this paper , we concern nonlinear Volterra–Fredholm–Hammerstein integral equations ( V-F-HIEs ) and try to obtain the solution of them via deep neural network . We present a new numerical approach of machine learning which is a combination of deep neural network and Legendre collocation method . This approach is useful for solving the differential equations and we applied it for solving nonlinear V-F-H-IEs . We used Legendre collocation method to our network for perfect the numerical computations and enhancement the performance the network . 2 LEGENDRE DEEP NEURAL NETWORK ( LDNN ) . The main purpose of introducing LDNN is to apply it for solving differential models . Indeed , this purpose is to expand the utilization of deep learning networks in the field of scientific computing , especially the solution of differential equations . Moreover , this network has the advantages of solving equations by deep learning as well as numerical methods such as collocation method used to achieve better solution to the equations . LDNN presents a combination of a deep neural network and Legendre collocation method . In fact , our network consists of two networks which have connected consecutive to each other . The first network is a feed forward neural network which has an orthogonal Legendre layer . The second network includes operation nodes to create the desired computational model . In recent decades , numerical methods especially collocation method are popular methods for solving differential equations . In the collocation method , first an approximation of the solution is expanded by using the sum of the basic functions . The basic functions consists of the orthogonal polynomials such as Legendre polynomials.Then this approximation is placed in the differential equation . By considering the appropriate set of candidate points , an attempt is made to obtain the unknown coefficients of the basic functions so that the solution satisfies the equation in a set of candidate points . The first network is applied to creat the approximation of the solution . This approximation can be known as the scattered data interpolation problem . The second network is used to obtain the desired equation so that the solution satisfies it . The structure of LDNN is described in detail at the following rest . Consider that the first network has aM-layer which defined as follows : H0 = x , x ∈ Rd , H1 = L ( W ( 1 ) H0 + b ( 1 ) ) , Hi = f ( W ( i ) Hi−1 + b ( i ) ) , 2 ≤ i ≤M− 1 , HM = W ( M ) HM−1 + b ( M ) . where H0 is the input layer with d dimension . Hi , 1 ≤ i ≤ M − 1 are hidden layers , L = [ L0 , L1 , ... Ln ] T which Li are i-th degrees of Legendre orthogonal polynomials , H1 is an orthogonal layer , f is the hyperbolic tangent activation function or other commonly used activation functions . W ( i ) , i = 1 , · · · , M are the weight parameters and b ( i ) , 1 ≤ i ≤ M are the bias parameters . HM is the output layer . It is notable that the second network is applied to obtain the desired differential model . This aim is possible by using operation nodes including integrals , derivatives , and etc . These nodes are applied to the output of the first network . Moreover , automatic differentiation ( AD ) ( Baydin et al. , 2017 ) and Legendre Gaussian integration ( Shen et al. , 2011 ) have been used in network computing to obtain more accurate and fast calculations . How to train the network and set the parameters are also important points . Supervised learning method is used to train network . The cost function for setting parameters is defined as follows : CostFun = min ( yt − yp ) + min ( Rm ) . ( 1 ) where yt is an exact value of the model and yp is a predicted value of the LDNN . The definition of Rm is explained in section 3.The minimization of CostFun is obtained by performing Adam algorithm ( Kingma & Ba , 2015 ) and the L-BFGS method ( Liu & Nocedal , 1989 ) on mean squared errors of training data set . 2.1 LEGENDRE POLYNOMIALS . Legendre polynomials ( Shen et al. , 2011 ) are a main series of orthogonal polynomials which denoted by Ln ( η ) , are defined as : Ln ( η ) = 1 2n [ n2 ] ∑ ` =0 ( −1 ) ` ( 2n− 2 ` ) ! 2n ` ! ( n− ` ) ! ( n− 2 ` ) ! ηn−2 ` ( 2 ) Legendre polynomials are defined in [ −1 , 1 ] domain and have the recurrence formula in the following form : ( n+ 1 ) Ln+1 ( η ) = ( 2n+ 1 ) ηLn ( η ) − nLn−1 ( η ) , n ≥ 1 , L0 ( η ) = 1 , L1 ( η ) = η . ( 3 ) Orthogonality relation for these polynomials is as follows : ∫ 1 −1 Ln ( η ) Lm ( η ) dη = γδn , m , ( 4 ) where δn , m is a delta Kronecker function and γ = 22n+1 . The weight function of them isW ( η ) = 1 . Some following useful properties of Legendre polynomials are defined : Ln ( −η ) = ( −1 ) nLn ( η ) , ( 5 ) |Ln ( η ) | ≤ 1 , ∀η ∈ [ −1 , 1 ] , n ≥ 0 , ( 6 ) Ln ( ±1 ) = ( ±1 ) n , ( 7 ) ( 2n+ 1 ) Ln ( η ) = L ′ n+1 ( η ) − L′n−1 ( η ) , n ≥ 1 . ( 8 ) 3 NONLINEAR VOLTERRA–FREDHOLM–HAMMERSTEIN INTEGRAL EQUATIONS AND LDNN . The general form of nonlinear Volterra–Fredholm–Hammerstein integral equations ( V-F-H-IEs ) is as follows : y ( x ) = g ( x ) + ξ1 ∫ x 0 K1 ( x , s ) ϕ1 ( s , y ( s ) ) ds+ ξ2 ∫ 1 0 K2 ( x , s ) ϕ2 ( s , y ( s ) ) ds , x ∈ [ 0 , 1 ] . ( 9 ) where ξ1 , ξ2 are fixed , g ( x ) , K1 ( x , s ) and K2 ( x , s ) are given functions and ϕ1 ( s , y ( s ) ) , ϕ2 ( s , y ( s ) ) are nonlinear functions . The aim is to find the proper y ( x ) . In order to use the LDNN , reformulated Eq . ( 9 ) in the following form : Rm = −y ( x ) +g ( x ) + ξ1 ∫ x 0 K1 ( x , s ) ϕ1 ( s , y ( s ) ) ds+ ξ2 ∫ 1 0 K2 ( x , s ) ϕ2 ( s , y ( s ) ) ds , x ∈ [ 0 , 1 ] . ( 10 ) y ( x ) is approximated by the first network of the LDNN . y ( x ) ≈ HM . ( 11 ) Furthermore , we applied Legendre–Gauss integration formula ( Shen et al. , 2011 ) : ∫ 1 −1 h ( X ) dX = N∑ j=0 ωjh ( Xj ) ( 12 ) where { Xj } Nj=0 are the roots of Ln+1 and { ωj } Nj=0 = 2 ( 1−X2j ) ( L′n+1 ( Xj ) ) 2 . Here , we should transfer the [ 0 , x ] and [ 0 , 1 ] domains into the [ −1 , 1 ] domain . It is possible by using the following transformation : t1 = 2 x s− 1 , t2 = 2s− 1 . Consider Z1 ( x , s ) = K1 ( x , s ) ϕ1 ( s , y ( s ) ) , Z2 ( x , s ) = K2 ( x , s ) ϕ2 ( s , y ( s ) ) . we have Rm = −y ( x ) + g ( x ) + ξ1 x 2 ∫ 1 −1 Z1 ( x , x 2 ( t1 + 1 ) ) dt1 + ξ2 2 ∫ 1 −1 Z2 ( x , x 2 ( t2 + 1 ) ) dt2 . ( 13 ) by using Legendre–Gauss integration formula , the below form is concluded : Rm = −y ( x ) + g ( x ) + ξ1 x 2 N1∑ j=0 ω1jZ1 ( x , x 2 ( t1j + 1 ) ) + ξ2 2 N2∑ j=0 ω2jZ2 ( x , x 2 ( t2j + 1 ) ) . ( 14 ) The second network of LDNN and its nodes makes Rm . The architecture of LDNN for solving nonlinear V-F-H-IEs is represented in Figure 1 . | The authors present a neural network based method to solve a special class of integral equations. Their approach involves training a neural network with Legendre polynomial based activation functions to approximate the solution $y(x)$ for a given $x$. The network is trained in a supervised fashion to minimize a loss function with two term- (1) the $\ell_2$ error between the true solution and $y(x)$ and (2) the residual of the given integral equation when analysed at $x$. They show impressive numerical results for several instances of VFH-IEs with very low errors. The primary contributions as claimed by the authors are the use of Legendre polynomial based activation functions and creating a differentiable approximation for the integral equation by using Legendre polynomials and Quadrature methods to analyse the integral. | SP:aa0febaec3494ea69264d71d33081759037e5319 |
Representing Partial Programs with Blended Abstract Semantics | 1 INTRODUCTION . Inductive program synthesis – the problem of inferring programs from examples – offers the promise of building machine learning systems that are interpretable , generalize quickly , and allow us automate software engineering tasks . In recent years , neurally-guided program synthesis , which uses deep learning to guide search over the space of possible programs , has emerged as a promising approach ( Balog et al. , 2016 ; Devlin et al. , 2017 ) . In this framework , partially-constructed programs are judged to determine if they are on the right track and to predict where to search next . A key challenge in neural program synthesis is representing the behavior of partially written programs , in order to make these judgments . In this work , we present a novel method for representing the semantic content of partially written code , which can be used to guide search to solve program synthesis tasks . Consider a tower construction domain in which a hand drops blocks , Tetris-style , onto a vertical 2D scene ( Figure 1 ) . In this domain , a function buildColumn ( n ) stacks n vertically-oriented blocks at the current cursor location , and moveHand ( n ) moves the cursor n spaces to the right . Given an imageX of a scene , our task is to write a program which builds a tower matching the imageX . To do this , a model can perform search in the space of programs , iteratively adding code until the program is complete . While attempting to synthesize a program , imagine arriving at a partially-constructed program s ( short for sketch ) , where HOLE signifies unfinished code : s = loop ( 4 , [ buildColumn ( 1 ) , moveHand ( < HOLE > ) ] ) Note that this partial program can not reach the goal state , because the target image has columns of height 2 , but this program can only build columns of height 1 . For an algorithm to determine if it should expand s or explore another part of the search space , it needs to determine whether s is ∗Correspondence to mnye @ mit.edu . CONTEXT f EMBED EMBED 4 3 EMBED1 EMBED + EMBED HOLE 1 x→3 CONTEXT HOLEx→3 + ( c ) on track to satisfy the goal . Answering this question requires an effective representation of partial programs . Existing neural program synthesis techniques differ in how they represent programs . Some represent programs by their syntax ( Devlin et al. , 2017 ; Allamanis et al. , 2018 ) , producing vector representations of program structure using sequence or graph neural networks . Recently , approaches which instead represent partial programs via their semantic state have been shown to be particularly effective . In these execution-guided neural synthesis approaches ( Chen et al. , 2018 ; Ellis et al. , 2019 ; Zohar & Wolf , 2018 ) , partial programs are executed and represented with their return values . ( To see why this is helpful , consider two distinct syntactic expressions 2+1 and 6/2 ; a syntax-based model might assign them different representations , whereas a model using a semantic representation will represent both as equivalent to 3 . ) However , execution is not always possible for a partial program . In our running example , before the HOLE is filled with an integer value , we can not meaningfully execute the partially-written loop in s. This is a common problem for languages containing higher-order functions and control flow , where execution of partially written code is often ill-defined.1 Thus , a key question is : How might we represent the semantics of unfinished code ? A classic method for representing program state , known as abstract interpretation ( Cousot & Cousot , 1977 ) , can be used to reason about the set of states that a partial program could reach , given the possible instantiations of the unfinished parts of the program . Using abstract interpretation , an approximate execution model can determine if an unfinished program will eventually satisfy a goal specification . For example , in the tower-building domain , an abstract interpreter could be designed to track , for every horizontal location , the minimum tower height that all continuations are guaranteed to exceeded . However , this technique is often low-precision : hand-designed abstract execution models greatly overapproximate the set of possible execution states , and do not automatically adapt themselves to the strengths or weaknesses of specific search algorithms . We hypothesize that , by mimicking the compositional structure of abstract interpretation , learned components can be used to effectively represent ambiguous program state . In this work , we make two contributions : we introduce neural abstract semantics , in which a compositional , approximate execution model is used to represent partially written code . This approach can be extended to blended abstract semantics , which aims to represent the state of unfinished programs as faithfully as possible by concretely executing program components whenever possible , and otherwise , approximating program state with a learned abstract execution model . 1See Peleg et al . ( 2020 ) for a discussion in the context of bottom-up synthesis . Consider again the partial program s and the blended abstract semantics encoding in Figure 1 . The sub-expression buildColumn ( 1 ) is fully concrete , and can thus be concretely executed to render an image . On the other hand , for functions whose arguments are not fully defined , such as moveHand , we instead employ abstract neural modules to represent the execution state . For this example , blended neural execution makes it easy to recognize that s is not a suitable partial program , because no integer argument to moveHand—which controls the spacing between the columns— would make the state in s match the goal X . This combination of learned execution and concrete execution allows robust representation of partial programs , which can be used for downstream synthesis tasks . Our approach can effectively learn to represent partial program states for languages where previous execution-guided synthesis techniques are not applicable . In summary , • We introduce blended neural semantics , a novel method for representing the semantic state of partially written programs inspired by abstract interpretation . • We describe how to integrate our program representations into existing approaches for learning search policies and search heuristics . • We validate our new approach with program synthesis experiments in three domains : tower construction , list processing , and string editing . We show that our approach outperforms neural synthesis baselines , solving at least 5 % more programs in each domain . 2 RELATED WORK . Synthesizing programs from examples is a classic AI problem ( Backus et al. , 1957 ) which has seen advances from the Programming Languages community ( Gulwani et al. , 2017 ; Gottschlich et al. , 2018 ; Solar-Lezama , 2008 ) . Neurally-guided search Recently , much progress has been made using neural methods to aid search . Enumerative approaches ( Balog et al. , 2016 ; Shi et al. , 2020 ) use neural methods to guide an enumerative synthesizer , and can be quite suitable for small-scale domains , but can scale poorly to larger programs and domains . Translation-based techniques ( Devlin et al. , 2017 ) treat program synthesis as a sequence-to-sequence problem , and employ state-of-the-art neural sequence modeling techniques , such as recurrent neural networks ( RNNs ) with attention . Hybrid approaches which use sketches ( Murali et al. , 2017 ; Nye et al. , 2019 ; Dong & Lapata , 2018 ) trade off computation between translation and enumeration components . These techniques can exhibit better generalization than translation-based approaches but more precise predictions than enumerative approaches ( Nye et al. , 2019 ) . To combine neural learning and search , our approach follows the framework laid out in Ellis et al . ( 2019 ) , where neural networks are used to guide a search over the space of possible partial programs defining a Markov decision process ( MDP ) . Program representation Prior work has studied neural representation of programs . Odena & Sutton ( 2019 ) propose property signatures to represent input-output examples , and use property signatures to guide an enumerative search . Graph neural networks have also been used to encode the syntax of programs ( Allamanis et al. , 2018 ; Brockschmidt et al. , 2018 ; Dinella et al. , 2019 ) for bug fixing , variable naming , and synthesis . This work has mostly focused on performing small edits to programs from real datasets . Our objective is to synthesize entire programs from specifications . Execution-guided synthesis Recent work has introduced the notion of “ execution-guided neural program synthesis ” ( Ellis et al. , 2019 ; Chen et al. , 2018 ; Zohar & Wolf , 2018 ) . In this framework , the neural representations used for search are conditioned on the executed program state instead of the program syntax . These techniques have been shown to solve difficult search problems outside the scope of enumerate or syntax-based neural synthesis alone . However , such execution-guided approaches have several limitations . We aim to generalize execution guided synthesis , so that it can be applicable to a wider range of domains , search techniques , and programming language constructs . Abstract Interpretation Our work is directly inspired by abstract interpretation-based synthesis ( Singh & Solar-Lezama , 2011 ; Wang et al. , 2017 ; Hu et al. , 2020 ) . These approaches use abstract interpretation ( Cousot & Cousot , 1977 ) to determine if a candidate partial program is realizable under the given specification , thereby pruning the search space of programs . We see our approach as a learning-based extension to this line of work . Neural Modules We employ neural module networks ( Andreas et al. , 2016 ; Johnson et al. , 2017 ) to implement blended abstract semantics , which aims to provide a learned execution scheme inspired by abstract interpretation . This approach is also related to other tree-structured encoders ( Socher et al. , 2011 ; Dyer et al. , 2016 ) . 3 BLENDED ABSTRACT SEMANTICS . Consider the problem of synthesizing arithmetic expressions from input–output pairs . Suppose we have the following context-free grammar for expressions : G = E→ E * E | E + E | x | 1 | 2 | 3 | 4 and a specification X consisting of the input–output pairs { ( x = 3 , y = 7 ) , ( x = 5 , y = 11 ) } . Suppose further that we have a candidate program ( 2 * x ) + 1 ∈ G. To check that this program is consistent with the specification , we can evaluate it on the inputs x in the specification according to the concrete semantics of the language : to evaluate ( 2 * x ) + 1 on the example ( x = 3 , y = 7 ) , we observe that the expression ( 2 * x ) evaluates to the integer 6 , and the expression 1 evaluates to the integer 1 ; thus the whole expression evaluates to 7 , as desired . Repeating this process with x = 5 returns the value 11 . Formally : Let C denote a context ( e.g . { x = 3 } ) ) . The concrete value of an expression E in a context C is:2 JEKC = JkKC = k a constant k JxKC|=x=v = v a variable x is evaluated to its value in the context Jf ( E1 · · · ) KC = run [ f , C ] ( JE1KC · · · ) recursively evaluate the arguments , then run f The goal of synthesis is to find an expression E : JEKx = y under concrete semantics . Iterative construction of partial programs Where did the expression ( 2 * x ) + 1 come from ? Neurally-guided synthesis techniques generally employ discrete search procedures . In this work , we use top-down search : starting with the top-level ( incomplete ) expression HOLE , we consider all possible expansions , ( HOLE→ HOLE + HOLE , HOLE→ 1 , HOLE→ 2 , . . . ) and select the one we believe is most likely to succeed ( Figure 1 left ) . Concrete semantics can not be used for this selection , because expressions such as x + HOLE are incomplete and can not be executed . Thus , we need a different mechanism to guide search . The more effectively we can filter the set of incomplete candidate programs , the faster our synthesis algorithm will be . Conventional abstract interpretation solves this problem by defining an alternative semantics for which even incomplete expressions can be evaluated . Consider the candidate expression HOLE * 2 . No matter how the HOLE is filled , the expression returns an even number , so it can not be consistent with the specification above . In many problems , we can define a space of “ abstract values ” ( like even integer ) and abstract semantics so that the abstract value of a partial program can be determined . This allows us to rule out partial programs on the basis of the abstraction alone ( Wang et al. , 2017 ) . However , constructing appropriate abstractions is difficult and requires domainspecific engineering ; an ideal procedure would automatically discover an effective space of abstract interpretations . Neural abstract semantics [ [ · ] ] nn As a first step , we implement the abstract interpretation procedure with a neural network . This is a natural choice : neural networks excel at representation learning , and the goal of abstract interpretation is to encode an informative representation of the set of values that could be returned by a partial program . For the program 1 + HOLE , we can encode the expression 1 to a learned representation ( Figure 2a , top ) , likewise encode HOLE ( Figure 2c ) , and finally employ a learned abstract implementation of the + operation ( Figure 2b ) . For concrete leaf nodes , such as constants or variables bound to constants , neural semantics are given using a state embedding function EMBED ( · ) , which maps any concrete state in the programming language into a vector representation : EMBED : ( State | Rd ) → Rd . If the input to EMBED is already vector-valued , EMBED performs the identity operation . Neural placeholders provide 2Domains with lambdas have slightly more complicated semantics . See Appendix A for details . Published as a conference paper at ICLR 2021 Neural abstract semantics loop ( 4 , seq ( buildColumn ( HOLE ) , HOLE ) ) loop ( 4 , seq ( buildColumn ( 1 ) , moveHand ( HOLE ) ) ) loop ( 4 , seq ( buildColumn ( 1 ) , HOLE ) ) ... ... H E H E H E SEARCH SPACE GOAL loop 4 seq buildColumn1 moveHandHOLE loop 4 seq moveHandHOLE Blended abstract semantics loop 4 seq buildColumn 1 HOLEmoveHand RNN representation Value V ( s , X ) Policy π ( a ; s , X ) search state representation EMBED s EMBED EMBED EMBED EMBED a method for computing a vector representation of unwritten code , denoted by the HOLE token . To compute the representation for HOLE , we define a neural embedding function h which takes a context C and outputs a vector . For each built-in function f ( including higher-order functions ) , the neural abstract semantics of f are given by a separate neural module ( a learned vector-valued function as in Andreas et al . ( 2016 ) ) [ [ f ] ] nn with the same arity as f . Therefore , computing the neural semantics means applying the neural function [ [ f ] ] nn to its arguments , which returns a vector . Since the neural semantics mirrors the concrete semantics , its implementation does not require changes to the underlying programming language . Formally , neural semantics involve a slightly larger set of cases than concrete semantics : [ [ E ] ] nnC = [ [ k ] ] nnC = EMBED ( k ) a constant k is embedded [ [ x ] ] nnC|=x=v = EMBED ( v ) embed the value v of the variable x [ [ HOLE ] ] nnC = h ( C ) a neural placeholder based on context [ [ f ( E1 · · · ) ] ] nnC = [ [ f ] ] nn ( [ [ E1 ] ] nnC · · · ) using neural module [ [ f ] ] nn This encoding is only one way to define a neural semantics , adopting a relatively simple and generic representation for all program components . For a discussion of its limitations and other , more sophisticated representations that could be explored in future work , see Appendix C. Blended abstract semantics [ [ · ] ] blend Notice that for an expression such as ( 2 * x ) + HOLE , the concrete value of the sub-expression ( 2 * x ) is known , since it contains no holes . The neural semantics above don ’ t make use of this knowledge . To improve upon this , we extend neural semantics and introduce blended semantics , which alternates between neural and concrete interpretation as appropriate for a given expression : • If the expression is a constant or a variable , use the concrete semantics . • If the expression is a HOLE , use the neural semantics . • If the expression is a function call , recursively evaluate the expressions that are the arguments to the function . If all arguments evaluate to concrete values , execute the function concretely . If any argument evaluates to a vector representation , transform all concrete values to vectors using EMBED and apply the neural semantics of the function . Formally , we can write : [ [ E ] ] blendC = [ [ k ] ] blendC = JkKC = k a constant k [ [ x ] ] blendC|=x=v = JxKC|=x=v = v variable x in context [ [ HOLE ] ] blendC = [ [ HOLE ] ] nn C = h ( C ) a neural placeholder based on context [ [ f ( E1 · · · ) ] ] blendC = JfK ( [ [ E1 ] ] blendC · · · ) if all arguments are concrete [ [ f ( E1 · · · ) ] ] blendC = [ [ f ] ] nn ( EMBED ( [ [ E1 ] ] blendC ) · · · ) if any arguments are vectors Because blended abstract semantics replaces concrete sub-components with their concrete values , we expect blended semantics to result in more robust representations , especially for long or complex programs where large portions can be concretely executed . | This paper proposes a novel top-down program synthesis for programming-by-example which combines concrete evaluation with neural embeddings. The authors take inspiration from abstract execution, which can execute partial programs by abstractly representing sets of possible execution states. Instead of hand-designing an abstract execution method, however, they propose a neural equivalent, which instead embeds possible states into a feature vector. While this approach has weaker guarantees than traditional abstract execution, it is much more flexible, and can be used as a powerful guiding function for execution-based top-down program search. | SP:4544639f7c0d43d2b79ce9bd8ba5e723cefe9ffd |
Representing Partial Programs with Blended Abstract Semantics | 1 INTRODUCTION . Inductive program synthesis – the problem of inferring programs from examples – offers the promise of building machine learning systems that are interpretable , generalize quickly , and allow us automate software engineering tasks . In recent years , neurally-guided program synthesis , which uses deep learning to guide search over the space of possible programs , has emerged as a promising approach ( Balog et al. , 2016 ; Devlin et al. , 2017 ) . In this framework , partially-constructed programs are judged to determine if they are on the right track and to predict where to search next . A key challenge in neural program synthesis is representing the behavior of partially written programs , in order to make these judgments . In this work , we present a novel method for representing the semantic content of partially written code , which can be used to guide search to solve program synthesis tasks . Consider a tower construction domain in which a hand drops blocks , Tetris-style , onto a vertical 2D scene ( Figure 1 ) . In this domain , a function buildColumn ( n ) stacks n vertically-oriented blocks at the current cursor location , and moveHand ( n ) moves the cursor n spaces to the right . Given an imageX of a scene , our task is to write a program which builds a tower matching the imageX . To do this , a model can perform search in the space of programs , iteratively adding code until the program is complete . While attempting to synthesize a program , imagine arriving at a partially-constructed program s ( short for sketch ) , where HOLE signifies unfinished code : s = loop ( 4 , [ buildColumn ( 1 ) , moveHand ( < HOLE > ) ] ) Note that this partial program can not reach the goal state , because the target image has columns of height 2 , but this program can only build columns of height 1 . For an algorithm to determine if it should expand s or explore another part of the search space , it needs to determine whether s is ∗Correspondence to mnye @ mit.edu . CONTEXT f EMBED EMBED 4 3 EMBED1 EMBED + EMBED HOLE 1 x→3 CONTEXT HOLEx→3 + ( c ) on track to satisfy the goal . Answering this question requires an effective representation of partial programs . Existing neural program synthesis techniques differ in how they represent programs . Some represent programs by their syntax ( Devlin et al. , 2017 ; Allamanis et al. , 2018 ) , producing vector representations of program structure using sequence or graph neural networks . Recently , approaches which instead represent partial programs via their semantic state have been shown to be particularly effective . In these execution-guided neural synthesis approaches ( Chen et al. , 2018 ; Ellis et al. , 2019 ; Zohar & Wolf , 2018 ) , partial programs are executed and represented with their return values . ( To see why this is helpful , consider two distinct syntactic expressions 2+1 and 6/2 ; a syntax-based model might assign them different representations , whereas a model using a semantic representation will represent both as equivalent to 3 . ) However , execution is not always possible for a partial program . In our running example , before the HOLE is filled with an integer value , we can not meaningfully execute the partially-written loop in s. This is a common problem for languages containing higher-order functions and control flow , where execution of partially written code is often ill-defined.1 Thus , a key question is : How might we represent the semantics of unfinished code ? A classic method for representing program state , known as abstract interpretation ( Cousot & Cousot , 1977 ) , can be used to reason about the set of states that a partial program could reach , given the possible instantiations of the unfinished parts of the program . Using abstract interpretation , an approximate execution model can determine if an unfinished program will eventually satisfy a goal specification . For example , in the tower-building domain , an abstract interpreter could be designed to track , for every horizontal location , the minimum tower height that all continuations are guaranteed to exceeded . However , this technique is often low-precision : hand-designed abstract execution models greatly overapproximate the set of possible execution states , and do not automatically adapt themselves to the strengths or weaknesses of specific search algorithms . We hypothesize that , by mimicking the compositional structure of abstract interpretation , learned components can be used to effectively represent ambiguous program state . In this work , we make two contributions : we introduce neural abstract semantics , in which a compositional , approximate execution model is used to represent partially written code . This approach can be extended to blended abstract semantics , which aims to represent the state of unfinished programs as faithfully as possible by concretely executing program components whenever possible , and otherwise , approximating program state with a learned abstract execution model . 1See Peleg et al . ( 2020 ) for a discussion in the context of bottom-up synthesis . Consider again the partial program s and the blended abstract semantics encoding in Figure 1 . The sub-expression buildColumn ( 1 ) is fully concrete , and can thus be concretely executed to render an image . On the other hand , for functions whose arguments are not fully defined , such as moveHand , we instead employ abstract neural modules to represent the execution state . For this example , blended neural execution makes it easy to recognize that s is not a suitable partial program , because no integer argument to moveHand—which controls the spacing between the columns— would make the state in s match the goal X . This combination of learned execution and concrete execution allows robust representation of partial programs , which can be used for downstream synthesis tasks . Our approach can effectively learn to represent partial program states for languages where previous execution-guided synthesis techniques are not applicable . In summary , • We introduce blended neural semantics , a novel method for representing the semantic state of partially written programs inspired by abstract interpretation . • We describe how to integrate our program representations into existing approaches for learning search policies and search heuristics . • We validate our new approach with program synthesis experiments in three domains : tower construction , list processing , and string editing . We show that our approach outperforms neural synthesis baselines , solving at least 5 % more programs in each domain . 2 RELATED WORK . Synthesizing programs from examples is a classic AI problem ( Backus et al. , 1957 ) which has seen advances from the Programming Languages community ( Gulwani et al. , 2017 ; Gottschlich et al. , 2018 ; Solar-Lezama , 2008 ) . Neurally-guided search Recently , much progress has been made using neural methods to aid search . Enumerative approaches ( Balog et al. , 2016 ; Shi et al. , 2020 ) use neural methods to guide an enumerative synthesizer , and can be quite suitable for small-scale domains , but can scale poorly to larger programs and domains . Translation-based techniques ( Devlin et al. , 2017 ) treat program synthesis as a sequence-to-sequence problem , and employ state-of-the-art neural sequence modeling techniques , such as recurrent neural networks ( RNNs ) with attention . Hybrid approaches which use sketches ( Murali et al. , 2017 ; Nye et al. , 2019 ; Dong & Lapata , 2018 ) trade off computation between translation and enumeration components . These techniques can exhibit better generalization than translation-based approaches but more precise predictions than enumerative approaches ( Nye et al. , 2019 ) . To combine neural learning and search , our approach follows the framework laid out in Ellis et al . ( 2019 ) , where neural networks are used to guide a search over the space of possible partial programs defining a Markov decision process ( MDP ) . Program representation Prior work has studied neural representation of programs . Odena & Sutton ( 2019 ) propose property signatures to represent input-output examples , and use property signatures to guide an enumerative search . Graph neural networks have also been used to encode the syntax of programs ( Allamanis et al. , 2018 ; Brockschmidt et al. , 2018 ; Dinella et al. , 2019 ) for bug fixing , variable naming , and synthesis . This work has mostly focused on performing small edits to programs from real datasets . Our objective is to synthesize entire programs from specifications . Execution-guided synthesis Recent work has introduced the notion of “ execution-guided neural program synthesis ” ( Ellis et al. , 2019 ; Chen et al. , 2018 ; Zohar & Wolf , 2018 ) . In this framework , the neural representations used for search are conditioned on the executed program state instead of the program syntax . These techniques have been shown to solve difficult search problems outside the scope of enumerate or syntax-based neural synthesis alone . However , such execution-guided approaches have several limitations . We aim to generalize execution guided synthesis , so that it can be applicable to a wider range of domains , search techniques , and programming language constructs . Abstract Interpretation Our work is directly inspired by abstract interpretation-based synthesis ( Singh & Solar-Lezama , 2011 ; Wang et al. , 2017 ; Hu et al. , 2020 ) . These approaches use abstract interpretation ( Cousot & Cousot , 1977 ) to determine if a candidate partial program is realizable under the given specification , thereby pruning the search space of programs . We see our approach as a learning-based extension to this line of work . Neural Modules We employ neural module networks ( Andreas et al. , 2016 ; Johnson et al. , 2017 ) to implement blended abstract semantics , which aims to provide a learned execution scheme inspired by abstract interpretation . This approach is also related to other tree-structured encoders ( Socher et al. , 2011 ; Dyer et al. , 2016 ) . 3 BLENDED ABSTRACT SEMANTICS . Consider the problem of synthesizing arithmetic expressions from input–output pairs . Suppose we have the following context-free grammar for expressions : G = E→ E * E | E + E | x | 1 | 2 | 3 | 4 and a specification X consisting of the input–output pairs { ( x = 3 , y = 7 ) , ( x = 5 , y = 11 ) } . Suppose further that we have a candidate program ( 2 * x ) + 1 ∈ G. To check that this program is consistent with the specification , we can evaluate it on the inputs x in the specification according to the concrete semantics of the language : to evaluate ( 2 * x ) + 1 on the example ( x = 3 , y = 7 ) , we observe that the expression ( 2 * x ) evaluates to the integer 6 , and the expression 1 evaluates to the integer 1 ; thus the whole expression evaluates to 7 , as desired . Repeating this process with x = 5 returns the value 11 . Formally : Let C denote a context ( e.g . { x = 3 } ) ) . The concrete value of an expression E in a context C is:2 JEKC = JkKC = k a constant k JxKC|=x=v = v a variable x is evaluated to its value in the context Jf ( E1 · · · ) KC = run [ f , C ] ( JE1KC · · · ) recursively evaluate the arguments , then run f The goal of synthesis is to find an expression E : JEKx = y under concrete semantics . Iterative construction of partial programs Where did the expression ( 2 * x ) + 1 come from ? Neurally-guided synthesis techniques generally employ discrete search procedures . In this work , we use top-down search : starting with the top-level ( incomplete ) expression HOLE , we consider all possible expansions , ( HOLE→ HOLE + HOLE , HOLE→ 1 , HOLE→ 2 , . . . ) and select the one we believe is most likely to succeed ( Figure 1 left ) . Concrete semantics can not be used for this selection , because expressions such as x + HOLE are incomplete and can not be executed . Thus , we need a different mechanism to guide search . The more effectively we can filter the set of incomplete candidate programs , the faster our synthesis algorithm will be . Conventional abstract interpretation solves this problem by defining an alternative semantics for which even incomplete expressions can be evaluated . Consider the candidate expression HOLE * 2 . No matter how the HOLE is filled , the expression returns an even number , so it can not be consistent with the specification above . In many problems , we can define a space of “ abstract values ” ( like even integer ) and abstract semantics so that the abstract value of a partial program can be determined . This allows us to rule out partial programs on the basis of the abstraction alone ( Wang et al. , 2017 ) . However , constructing appropriate abstractions is difficult and requires domainspecific engineering ; an ideal procedure would automatically discover an effective space of abstract interpretations . Neural abstract semantics [ [ · ] ] nn As a first step , we implement the abstract interpretation procedure with a neural network . This is a natural choice : neural networks excel at representation learning , and the goal of abstract interpretation is to encode an informative representation of the set of values that could be returned by a partial program . For the program 1 + HOLE , we can encode the expression 1 to a learned representation ( Figure 2a , top ) , likewise encode HOLE ( Figure 2c ) , and finally employ a learned abstract implementation of the + operation ( Figure 2b ) . For concrete leaf nodes , such as constants or variables bound to constants , neural semantics are given using a state embedding function EMBED ( · ) , which maps any concrete state in the programming language into a vector representation : EMBED : ( State | Rd ) → Rd . If the input to EMBED is already vector-valued , EMBED performs the identity operation . Neural placeholders provide 2Domains with lambdas have slightly more complicated semantics . See Appendix A for details . Published as a conference paper at ICLR 2021 Neural abstract semantics loop ( 4 , seq ( buildColumn ( HOLE ) , HOLE ) ) loop ( 4 , seq ( buildColumn ( 1 ) , moveHand ( HOLE ) ) ) loop ( 4 , seq ( buildColumn ( 1 ) , HOLE ) ) ... ... H E H E H E SEARCH SPACE GOAL loop 4 seq buildColumn1 moveHandHOLE loop 4 seq moveHandHOLE Blended abstract semantics loop 4 seq buildColumn 1 HOLEmoveHand RNN representation Value V ( s , X ) Policy π ( a ; s , X ) search state representation EMBED s EMBED EMBED EMBED EMBED a method for computing a vector representation of unwritten code , denoted by the HOLE token . To compute the representation for HOLE , we define a neural embedding function h which takes a context C and outputs a vector . For each built-in function f ( including higher-order functions ) , the neural abstract semantics of f are given by a separate neural module ( a learned vector-valued function as in Andreas et al . ( 2016 ) ) [ [ f ] ] nn with the same arity as f . Therefore , computing the neural semantics means applying the neural function [ [ f ] ] nn to its arguments , which returns a vector . Since the neural semantics mirrors the concrete semantics , its implementation does not require changes to the underlying programming language . Formally , neural semantics involve a slightly larger set of cases than concrete semantics : [ [ E ] ] nnC = [ [ k ] ] nnC = EMBED ( k ) a constant k is embedded [ [ x ] ] nnC|=x=v = EMBED ( v ) embed the value v of the variable x [ [ HOLE ] ] nnC = h ( C ) a neural placeholder based on context [ [ f ( E1 · · · ) ] ] nnC = [ [ f ] ] nn ( [ [ E1 ] ] nnC · · · ) using neural module [ [ f ] ] nn This encoding is only one way to define a neural semantics , adopting a relatively simple and generic representation for all program components . For a discussion of its limitations and other , more sophisticated representations that could be explored in future work , see Appendix C. Blended abstract semantics [ [ · ] ] blend Notice that for an expression such as ( 2 * x ) + HOLE , the concrete value of the sub-expression ( 2 * x ) is known , since it contains no holes . The neural semantics above don ’ t make use of this knowledge . To improve upon this , we extend neural semantics and introduce blended semantics , which alternates between neural and concrete interpretation as appropriate for a given expression : • If the expression is a constant or a variable , use the concrete semantics . • If the expression is a HOLE , use the neural semantics . • If the expression is a function call , recursively evaluate the expressions that are the arguments to the function . If all arguments evaluate to concrete values , execute the function concretely . If any argument evaluates to a vector representation , transform all concrete values to vectors using EMBED and apply the neural semantics of the function . Formally , we can write : [ [ E ] ] blendC = [ [ k ] ] blendC = JkKC = k a constant k [ [ x ] ] blendC|=x=v = JxKC|=x=v = v variable x in context [ [ HOLE ] ] blendC = [ [ HOLE ] ] nn C = h ( C ) a neural placeholder based on context [ [ f ( E1 · · · ) ] ] blendC = JfK ( [ [ E1 ] ] blendC · · · ) if all arguments are concrete [ [ f ( E1 · · · ) ] ] blendC = [ [ f ] ] nn ( EMBED ( [ [ E1 ] ] blendC ) · · · ) if any arguments are vectors Because blended abstract semantics replaces concrete sub-components with their concrete values , we expect blended semantics to result in more robust representations , especially for long or complex programs where large portions can be concretely executed . | This paper proposes an embedding mechanism for partial programs for search space exploration in example-driven synthesis. It executes a sub-expression concretely whenever possible and applies neural module networks on vector representations otherwise. The embeddings of partial programs and goal states are used for determining the next step towards expanding an unfilled hole. This method is evaluated on three benchmark sets: tower construction, functional list processing and string editing. | SP:4544639f7c0d43d2b79ce9bd8ba5e723cefe9ffd |
Adaptive Learning Rates for Multi-Agent Reinforcement Learning | 1 INTRODUCTION . Recently , multi-agent reinforcement learning ( MARL ) has been applied to decentralized cooperative systems , e.g. , autonomous driving ( Shalev-Shwartz et al. , 2016 ) , smart grid control ( Yang et al. , 2018 ) , and traffic signal control ( Wei et al. , 2019 ) . Many MARL methods ( Lowe et al. , 2017 ; Foerster et al. , 2018 ; Rashid et al. , 2018 ; Iqbal & Sha , 2019 ; Son et al. , 2019 ) have been proposed for multi-agent cooperation , which follow the paradigm of centralized training and decentralized execution . In many of these methods , a centralized critic learns the joint Q-function using the information of all agents , and the decentralized actors are updated towards maximizing the Q-value based on local observation . However , in these methods , the actors are usually assigned the same learning rates , which is not optimal for maximizing the Q-value . This is because some agents might be more critical than others to improving the Q-value and thus should have higher learning rates . On the other hand , the learning rates of actors and critic are often hand-tuned and fixed , and hence require heavy tuning . More importantly , over the course of training , the effect of actors and critic on the learning varies , so the fixed learning rates will not always be the best at every learning stage . The artificial schedules , e.g. , time-based decay and step decay , are pre-defined and require expert knowledge about model and problem . Some optimizers , e.g. , AdaGrad ( Duchi et al. , 2011 ) , could adjust the learning rate adaptively , but they are proposed for general optimization problems , not specialized for MARL . In this paper , we propose AdaMa for adaptive learning rates in cooperative MARL . AdaMa dynamically evaluates the contribution of actors and critic to the optimization and adaptively updates the learning rates based on their quantitative contributions . First , we examine the gain of Q-value contributed by the update of each actor . We derive the direction along which the Q-value improves the most . Thus , we can update the vector of learning rates of all actors towards the direction of maximizing the Q-value , which leads to diverse learning rates that explicitly captures the contributions of actors . Second , we consider the critic and actors are updated simultaneously . If the critic ’ s update causes a large change of Q-value , we should give a high learning rate to the critic since it is leading the learning . However , the optimization of actors , which relies on the critic , would strug- gle with the fast-moving target . Thus , the learning rates of actors should be reduced accordingly . On the other hand , if the critic has reached a plateau , increasing the learning rates of actors could quickly improve the actors , which further generates new experiences to boost the critic ’ s learning . These two processes alternate during training , promoting the overall learning . Further , by incorporating the second-order approximation , we additionally capture the pairwise interaction between actors ’ updates so as to more accurately update the learning rates of actors towards maximizing the improvement of Q-value . We evaluate AdaMa in four typical multi-agent cooperation scenarios , i.e. , going together , cooperative navigation , predator-prey , and clustering . Empirical results demonstrate that dynamically regulating the learning rates of actors and critic according to the contributions to the change of Qvalue could accelerate the learning and improve the performance , which can be further enhanced by additionally considering the effect of pairwise actors ’ updates . The visualizations of learning rates during training clearly explain how and why AdaMa works . 2 RELATED WORK . MARL . We consider the formulation of decentralized partially observable Markov decision process ( Dec-POMDP ) . There areN agents interacting with the environment . At each timestep t , each agent i receives a local observation oit , takes an action a i t , and gets a shared reward rt . The agents aim to maximize the expected return E ∑T t=0 γ trt , where γ is a discount factor and T is the episode time horizon . Many methods ( Lowe et al. , 2017 ; Foerster et al. , 2018 ; Rashid et al. , 2018 ; Iqbal & Sha , 2019 ; Son et al. , 2019 ) have been proposed for Dec-POMDP , which adopt centralized learning and decentralized execution ( CTDE ) . In many of these methods , a centralized critic learns a joint Q-function by minimizing the TD-error . In training , the critic is allowed to use the information of all agents . The actors , which only have access to local information , learn to maximize the Q-value learned by the critic . In execution , the critic is abandoned and the actors act in a decentralized manner . Adaptive Learning Rate . Learning rate schedules aim to reduce the learning rate during training according to a pre-defined schedule , including time-based decay , step decay , and exponential decay . The schedules have to be defined in advance and depend heavily on the type of model and problem , which requires much expert knowledge . Some optimizers , such as AdaGrad ( Duchi et al. , 2011 ) , AdaDelta ( Zeiler , 2012 ) , RMSprop ( Tieleman & Hinton , 2012 ) , and Adam ( Kingma & Ba , 2015 ) , provide adaptive learning rate to ease manual tuning . AdaGrad performs larger updates for more sparse parameters and smaller updates for less sparse parameters , and other methods are derived from AdaGrad . However , these methods only deal with the gradient pattern for general optimization problems , offering no specialized way to boost multi-agent learning . WoLF ( Bowling & Veloso , 2002 ) provides variable learning rates for stochastic games , but not for cooperation . Meta Gradients for Hyperparameters . Some meta-learning methods employ hyperparameter gradients to tune the hyperparameter automatically . Maclaurin et al . ( 2015 ) utilized the reverse-mode differentiation of hyperparameters to optimize step sizes , momentum schedules , weight initialization distributions , parameterized regularization schemes , and neural network architectures . Xu et al . ( 2018 ) computed the meta-gradient to update the discount factor and bootstrapping parameter in reinforcement learning . OL-AUX ( Lin et al. , 2019 ) uses the meta-gradient to automate the weights of auxiliary tasks . The proposed AdaMa can also be viewed as a meta-gradient method for adaptive learning rates in MARL . 3 METHOD . In this section , we first introduce the single-critic version of MADDPG ( Lowe et al. , 2017 ) , on which we instantiate AdaMa . However , AdaMa can also be instantiated on other MARL methods , and the instantiation on MAAC ( Iqbal & Sha , 2019 ) for discrete action space is also given in Appendix A.1 . Then , we use the Taylor approximation to evaluate the contributions of the critic and actors ’ updates to the change of Q-value . Based on the derived quantitative contributions , we dynamically adjust the direction of the vector of actors ’ learning rates and balance the learning rates between the critic and actors . Further , we incorporate higher-order approximation to estimate the contributions more accurately . 3.1 SINGLE-CRITIC MADDPG Critic Actor Actor ...... TD error In mixed cooperation and competition , each MADDPG agent learns an actor πi and a critic for the local reward . However , since the agents share the reward in Dec-POMDP , we only maintain a single shared critic , which takes the observation vector ~o and the action vector ~a and outputs the Q-value , as illustrated in Figure 1 . The critic parameterized by φ is trained by minimizing the TD-error δ E ( ~o , ~a , r , ~o′ ) ∼D [ ( Q ( ~o , ~a ) − y ) 2 ] , where y = r+γQ− ( ~o′ , ~π−i ( o ′ i ) ) . Q− is the target critic , π−i is the target actor , and D is replay buffer . Each actor πi ( parameterized by θi ) is updated to maximize the learned Q-value by gradient ascent . The gradient of θi is We denote the learning rates of each actor i and the critic as lai and lc respectively . 3.2 ADAPTIVE ~la DIRECTION First , suppose that the critic is trained and frozen , and we only update the actors . By expanding the Q-function , we can estimate the gain of Q-value contributed by actors ’ updates by the Taylor approximation : ∆Q = Q ( ~o , ~a+ ∆~a ) −Q ( ~o , ~a ) ≈ Q ( ~o , ~a ) + N∑ i=1 ∆ai ∂Q ( ~o , ~a ) ∂ai T −Q ( ~o , ~a ) = N∑ i=1 [ πi ( θi + lai ∂Q ( ~o , ~a ) ∂θi ) − πi ( θi ) ] ∂Q ( ~o , ~a ) ∂ai T ≈ N∑ i=1 lai ∂Q ( ~o , ~a ) ∂θi ∂ai ∂θi T ∂Q ( ~o , ~a ) ∂ai T = N∑ i=1 lai ∂Q ( ~o , ~a ) ∂θi ∂Q ( ~o , ~a ) ∂θi T = ~la · ~∂Q ∂θ ∂Q ∂θ T . Assuming the magnitude of the learning rate vector ‖~la‖ is a fixed small constant ‖̂~la‖ , the largest ∆Q is obtained when the direction of ~la is consistent with the direction of vector ~∂Q ∂θ ∂Q ∂θ T . Thus , we can softly update ~la to the direction of ~∂Q ∂θ ∂Q ∂θ T to improve the Q-value : ~la = α~la + ( 1− α ) ‖̂~la‖ ~∂Q ∂θ ∂Q ∂θ T /‖ ~∂Q ∂θ ∂Q ∂θ T ‖ ~la = ~la ‖̂~la‖ ‖~la‖ , ( 1 ) where the second line normalizes the magnitude of ~la to ‖̂~la‖ , and α is a parameter that controls the soft update . From another perspective , the update rule ( 1 ) can be seen as updating ~la by gradient ascent to increase the Q-value the most , since ∂∆Q ∂~la = ~∂Q ∂θ ∂Q ∂θ T . 3.3 ADAPTIVE lc AND ‖~la‖ In the previous section , we assume that the critic is frozen . However , in MADDPG and other MARL methods , the critic and actors are trained simultaneously . Therefore , we investigate the change of Q-value by additionally considering the critic ’ s update : ∆Q = Q ( φ+ ∆φ , ~o , ~a+ ∆~a ) −Q ( φ , ~o , ~a ) ≈ Q ( φ , ~o , ~a ) + N∑ i=1 ∆ai ∂Q ( φ , ~o , ~a ) ∂ai T + ∆φ ∂Q ( φ , ~o , ~a ) ∂φ T −Q ( φ , ~o , ~a ) ≈ ~la · ~∂Q ∂θ ∂Q ∂θ T − lc ∂δ ∂φ ∂Q ∂φ T . We can see that ∆Q is contributed by the updates of both the critic and actors . In principle , the critic ’ s learning is prioritized since the actor ’ s learning is determined by the improved critic . When the critic ’ s update causes a large change of the Q-value , the critic is leading the learning , and we should assign it a high learning rate . However , the optimization of actors , which relies on the current critic , would struggle with the fast-moving target . Therefore , the actors ’ learning rates should be reduced . On the other hand , when the critic has reached a plateau , increasing the actors ’ learning rates could quickly optimize the actors , which further injects new experiences into the replay buffer to boost the critic ’ s learning , thus promoting the overall learning . The contributions of actors ’ updates are always nonnegative , but the critic ’ s update might either increase or decrease the Q-value . Therefore we use the absolute value | ∂δ∂φ ∂Q ∂φ T | to evaluate the contribution of critic to the change of Q-value . Based on the principles above , we adaptively adjust lc and ‖~la‖ by the update rules : lc = αlc + ( 1− α ) l · clip ( | ∂δ ∂φ ∂Q ∂φ T |/m , , 1− ) ‖̂~la‖ = l − lc . ( 2 ) The hyperparameters α , m , l , and have intuitive interpretations and are easy to tune . α controls the soft update and m controls the target value of lc . The clip function and the small constant prevent the learning rate being too large or too small . Therefore , AdaMa works as follows : first update lc and get ‖̂~la‖ using ( 2 ) , then regulate the direction and magnitude of ~la according to ( 1 ) . As Liessner et al . ( 2019 ) pointed out , the actor should have a lower learning rate than the critic , and a high learning rate of actor leads to a performance breakdown . Also , empirically , in DDPG ( Lillicrap et al. , 2016 ) the critic ’ s learning rate is set to 10 times higher than the actor ’ s learning rate . However , we believe such a setting only partially addresses the problem . During training , if the learning rates of actor are always low , actors learn slowly and thus the learning is limited . Therefore , AdaMa decreases lc and increases ‖~la‖ when the learning of critic reaches a plateau , which could avoid the fast-moving target and speed up the learning . | This paper proposed AdaMa, which can automatically use adaptive learning rates for each agent in cooperative Multi-Agent Reinforcement Learning (MARL). AdaMa calculated the learning rate of each actor and critic according to their contributions of locally increasing value functions. Simple experiments using toy examples show that the proposed AdaMa method can improve fixed learning rate method and other heuristics. | SP:2c24186f9710a15d58c6af94828b80ae796af3f9 |
Adaptive Learning Rates for Multi-Agent Reinforcement Learning | 1 INTRODUCTION . Recently , multi-agent reinforcement learning ( MARL ) has been applied to decentralized cooperative systems , e.g. , autonomous driving ( Shalev-Shwartz et al. , 2016 ) , smart grid control ( Yang et al. , 2018 ) , and traffic signal control ( Wei et al. , 2019 ) . Many MARL methods ( Lowe et al. , 2017 ; Foerster et al. , 2018 ; Rashid et al. , 2018 ; Iqbal & Sha , 2019 ; Son et al. , 2019 ) have been proposed for multi-agent cooperation , which follow the paradigm of centralized training and decentralized execution . In many of these methods , a centralized critic learns the joint Q-function using the information of all agents , and the decentralized actors are updated towards maximizing the Q-value based on local observation . However , in these methods , the actors are usually assigned the same learning rates , which is not optimal for maximizing the Q-value . This is because some agents might be more critical than others to improving the Q-value and thus should have higher learning rates . On the other hand , the learning rates of actors and critic are often hand-tuned and fixed , and hence require heavy tuning . More importantly , over the course of training , the effect of actors and critic on the learning varies , so the fixed learning rates will not always be the best at every learning stage . The artificial schedules , e.g. , time-based decay and step decay , are pre-defined and require expert knowledge about model and problem . Some optimizers , e.g. , AdaGrad ( Duchi et al. , 2011 ) , could adjust the learning rate adaptively , but they are proposed for general optimization problems , not specialized for MARL . In this paper , we propose AdaMa for adaptive learning rates in cooperative MARL . AdaMa dynamically evaluates the contribution of actors and critic to the optimization and adaptively updates the learning rates based on their quantitative contributions . First , we examine the gain of Q-value contributed by the update of each actor . We derive the direction along which the Q-value improves the most . Thus , we can update the vector of learning rates of all actors towards the direction of maximizing the Q-value , which leads to diverse learning rates that explicitly captures the contributions of actors . Second , we consider the critic and actors are updated simultaneously . If the critic ’ s update causes a large change of Q-value , we should give a high learning rate to the critic since it is leading the learning . However , the optimization of actors , which relies on the critic , would strug- gle with the fast-moving target . Thus , the learning rates of actors should be reduced accordingly . On the other hand , if the critic has reached a plateau , increasing the learning rates of actors could quickly improve the actors , which further generates new experiences to boost the critic ’ s learning . These two processes alternate during training , promoting the overall learning . Further , by incorporating the second-order approximation , we additionally capture the pairwise interaction between actors ’ updates so as to more accurately update the learning rates of actors towards maximizing the improvement of Q-value . We evaluate AdaMa in four typical multi-agent cooperation scenarios , i.e. , going together , cooperative navigation , predator-prey , and clustering . Empirical results demonstrate that dynamically regulating the learning rates of actors and critic according to the contributions to the change of Qvalue could accelerate the learning and improve the performance , which can be further enhanced by additionally considering the effect of pairwise actors ’ updates . The visualizations of learning rates during training clearly explain how and why AdaMa works . 2 RELATED WORK . MARL . We consider the formulation of decentralized partially observable Markov decision process ( Dec-POMDP ) . There areN agents interacting with the environment . At each timestep t , each agent i receives a local observation oit , takes an action a i t , and gets a shared reward rt . The agents aim to maximize the expected return E ∑T t=0 γ trt , where γ is a discount factor and T is the episode time horizon . Many methods ( Lowe et al. , 2017 ; Foerster et al. , 2018 ; Rashid et al. , 2018 ; Iqbal & Sha , 2019 ; Son et al. , 2019 ) have been proposed for Dec-POMDP , which adopt centralized learning and decentralized execution ( CTDE ) . In many of these methods , a centralized critic learns a joint Q-function by minimizing the TD-error . In training , the critic is allowed to use the information of all agents . The actors , which only have access to local information , learn to maximize the Q-value learned by the critic . In execution , the critic is abandoned and the actors act in a decentralized manner . Adaptive Learning Rate . Learning rate schedules aim to reduce the learning rate during training according to a pre-defined schedule , including time-based decay , step decay , and exponential decay . The schedules have to be defined in advance and depend heavily on the type of model and problem , which requires much expert knowledge . Some optimizers , such as AdaGrad ( Duchi et al. , 2011 ) , AdaDelta ( Zeiler , 2012 ) , RMSprop ( Tieleman & Hinton , 2012 ) , and Adam ( Kingma & Ba , 2015 ) , provide adaptive learning rate to ease manual tuning . AdaGrad performs larger updates for more sparse parameters and smaller updates for less sparse parameters , and other methods are derived from AdaGrad . However , these methods only deal with the gradient pattern for general optimization problems , offering no specialized way to boost multi-agent learning . WoLF ( Bowling & Veloso , 2002 ) provides variable learning rates for stochastic games , but not for cooperation . Meta Gradients for Hyperparameters . Some meta-learning methods employ hyperparameter gradients to tune the hyperparameter automatically . Maclaurin et al . ( 2015 ) utilized the reverse-mode differentiation of hyperparameters to optimize step sizes , momentum schedules , weight initialization distributions , parameterized regularization schemes , and neural network architectures . Xu et al . ( 2018 ) computed the meta-gradient to update the discount factor and bootstrapping parameter in reinforcement learning . OL-AUX ( Lin et al. , 2019 ) uses the meta-gradient to automate the weights of auxiliary tasks . The proposed AdaMa can also be viewed as a meta-gradient method for adaptive learning rates in MARL . 3 METHOD . In this section , we first introduce the single-critic version of MADDPG ( Lowe et al. , 2017 ) , on which we instantiate AdaMa . However , AdaMa can also be instantiated on other MARL methods , and the instantiation on MAAC ( Iqbal & Sha , 2019 ) for discrete action space is also given in Appendix A.1 . Then , we use the Taylor approximation to evaluate the contributions of the critic and actors ’ updates to the change of Q-value . Based on the derived quantitative contributions , we dynamically adjust the direction of the vector of actors ’ learning rates and balance the learning rates between the critic and actors . Further , we incorporate higher-order approximation to estimate the contributions more accurately . 3.1 SINGLE-CRITIC MADDPG Critic Actor Actor ...... TD error In mixed cooperation and competition , each MADDPG agent learns an actor πi and a critic for the local reward . However , since the agents share the reward in Dec-POMDP , we only maintain a single shared critic , which takes the observation vector ~o and the action vector ~a and outputs the Q-value , as illustrated in Figure 1 . The critic parameterized by φ is trained by minimizing the TD-error δ E ( ~o , ~a , r , ~o′ ) ∼D [ ( Q ( ~o , ~a ) − y ) 2 ] , where y = r+γQ− ( ~o′ , ~π−i ( o ′ i ) ) . Q− is the target critic , π−i is the target actor , and D is replay buffer . Each actor πi ( parameterized by θi ) is updated to maximize the learned Q-value by gradient ascent . The gradient of θi is We denote the learning rates of each actor i and the critic as lai and lc respectively . 3.2 ADAPTIVE ~la DIRECTION First , suppose that the critic is trained and frozen , and we only update the actors . By expanding the Q-function , we can estimate the gain of Q-value contributed by actors ’ updates by the Taylor approximation : ∆Q = Q ( ~o , ~a+ ∆~a ) −Q ( ~o , ~a ) ≈ Q ( ~o , ~a ) + N∑ i=1 ∆ai ∂Q ( ~o , ~a ) ∂ai T −Q ( ~o , ~a ) = N∑ i=1 [ πi ( θi + lai ∂Q ( ~o , ~a ) ∂θi ) − πi ( θi ) ] ∂Q ( ~o , ~a ) ∂ai T ≈ N∑ i=1 lai ∂Q ( ~o , ~a ) ∂θi ∂ai ∂θi T ∂Q ( ~o , ~a ) ∂ai T = N∑ i=1 lai ∂Q ( ~o , ~a ) ∂θi ∂Q ( ~o , ~a ) ∂θi T = ~la · ~∂Q ∂θ ∂Q ∂θ T . Assuming the magnitude of the learning rate vector ‖~la‖ is a fixed small constant ‖̂~la‖ , the largest ∆Q is obtained when the direction of ~la is consistent with the direction of vector ~∂Q ∂θ ∂Q ∂θ T . Thus , we can softly update ~la to the direction of ~∂Q ∂θ ∂Q ∂θ T to improve the Q-value : ~la = α~la + ( 1− α ) ‖̂~la‖ ~∂Q ∂θ ∂Q ∂θ T /‖ ~∂Q ∂θ ∂Q ∂θ T ‖ ~la = ~la ‖̂~la‖ ‖~la‖ , ( 1 ) where the second line normalizes the magnitude of ~la to ‖̂~la‖ , and α is a parameter that controls the soft update . From another perspective , the update rule ( 1 ) can be seen as updating ~la by gradient ascent to increase the Q-value the most , since ∂∆Q ∂~la = ~∂Q ∂θ ∂Q ∂θ T . 3.3 ADAPTIVE lc AND ‖~la‖ In the previous section , we assume that the critic is frozen . However , in MADDPG and other MARL methods , the critic and actors are trained simultaneously . Therefore , we investigate the change of Q-value by additionally considering the critic ’ s update : ∆Q = Q ( φ+ ∆φ , ~o , ~a+ ∆~a ) −Q ( φ , ~o , ~a ) ≈ Q ( φ , ~o , ~a ) + N∑ i=1 ∆ai ∂Q ( φ , ~o , ~a ) ∂ai T + ∆φ ∂Q ( φ , ~o , ~a ) ∂φ T −Q ( φ , ~o , ~a ) ≈ ~la · ~∂Q ∂θ ∂Q ∂θ T − lc ∂δ ∂φ ∂Q ∂φ T . We can see that ∆Q is contributed by the updates of both the critic and actors . In principle , the critic ’ s learning is prioritized since the actor ’ s learning is determined by the improved critic . When the critic ’ s update causes a large change of the Q-value , the critic is leading the learning , and we should assign it a high learning rate . However , the optimization of actors , which relies on the current critic , would struggle with the fast-moving target . Therefore , the actors ’ learning rates should be reduced . On the other hand , when the critic has reached a plateau , increasing the actors ’ learning rates could quickly optimize the actors , which further injects new experiences into the replay buffer to boost the critic ’ s learning , thus promoting the overall learning . The contributions of actors ’ updates are always nonnegative , but the critic ’ s update might either increase or decrease the Q-value . Therefore we use the absolute value | ∂δ∂φ ∂Q ∂φ T | to evaluate the contribution of critic to the change of Q-value . Based on the principles above , we adaptively adjust lc and ‖~la‖ by the update rules : lc = αlc + ( 1− α ) l · clip ( | ∂δ ∂φ ∂Q ∂φ T |/m , , 1− ) ‖̂~la‖ = l − lc . ( 2 ) The hyperparameters α , m , l , and have intuitive interpretations and are easy to tune . α controls the soft update and m controls the target value of lc . The clip function and the small constant prevent the learning rate being too large or too small . Therefore , AdaMa works as follows : first update lc and get ‖̂~la‖ using ( 2 ) , then regulate the direction and magnitude of ~la according to ( 1 ) . As Liessner et al . ( 2019 ) pointed out , the actor should have a lower learning rate than the critic , and a high learning rate of actor leads to a performance breakdown . Also , empirically , in DDPG ( Lillicrap et al. , 2016 ) the critic ’ s learning rate is set to 10 times higher than the actor ’ s learning rate . However , we believe such a setting only partially addresses the problem . During training , if the learning rates of actor are always low , actors learn slowly and thus the learning is limited . Therefore , AdaMa decreases lc and increases ‖~la‖ when the learning of critic reaches a plateau , which could avoid the fast-moving target and speed up the learning . | The paper proposes a new algorithm for multi-agent reinforcement learning (MARL) that adaptively picks learning rates for actor and critic. Specifically, the learning rates are updated to directions maximally affecting the Q-function, and the algorithm dynamically balances the learning rates between actor and critic. In numerical studies, the authors illustrate the efficiency of their method via four toy experimental scenarios and intuitively explain the underlying mechanism. | SP:2c24186f9710a15d58c6af94828b80ae796af3f9 |
Understanding and Improving Encoder Layer Fusion in Sequence-to-Sequence Learning | 1 INTRODUCTION . Sequence-to-Sequence ( Seq2Seq ) learning ( Sutskever et al. , 2014 ) has advanced the state of the art in various natural language processing ( NLP ) tasks , such as machine translation ( Bahdanau et al. , 2015 ; Vaswani et al. , 2017 ; Wu et al. , 2019 ) , text summarization ( Wang et al. , 2019b ; Zhang et al. , 2020 ) , and grammatical error correction ( Kiyono et al. , 2019 ; Kaneko et al. , 2020 ) . Seq2Seq models are generally implemented with an encoder-decoder framework , in which a multi-layer encoder summarizes a source sequence into a sequence of representation and another multi-layer decoder produces the target sequence conditioned on the encoded representation . Recent studies reveal that fusing the intermediate encoder layers ( EncoderFusion ) is beneficial for Seq2Seq models , such as layer attention ( Bapna et al. , 2018 ) , layer aggregation ( Dou et al. , 2018 ; Wang et al. , 2019c ) , and layer-wise coordination ( He et al. , 2018 ) . Despite its effectiveness , not much is known about how fusing encoder layer representations work . The intuitive explanation is that fusing encoder layers exploits surface and syntactic information embedded in the lower encoder layers ( Belinkov et al. , 2017 ; Peters et al. , 2018 ) . However , other studies show that attending to lower encoder layers ( excluding the encoder embedding layer ) does not improve model performance ( Domhan , 2018 ) , which is conflicted with existing conclusions . It is still unclear why and when fusing encoder layers should work in Seq2Seq models . This paper tries to shed light upon behavior of Seq2Seq models augmented with EncoderFusion method . To this end , we propose a novel fine-grained layer attention to evaluate the contribution of ∗Work was done when Xuebo Liu and Liang Ding were interning at Tencent AI Lab . individual encoder layers . We conduct experiments on several representative Seq2Seq NLP tasks , including machine translation , text summarization , and grammatical error correction . Through a series of analyses , we find that the uppermost decoder layer pays more attention to the encoder embedding layer . Masking the encoder embedding layer significantly drops model performance by generating hallucinatory ( i.e . fluent but unfaithful to the source ) predictions . The encoded representation of the standard Seq2Seq models ( i.e . w/o fusing encoder layers ) may not have enough capacity to model both semantic and surface features ( especially at the encoder embedding layer ) . We call the problem described above the source representation bottleneck . Based on this observation , we simplify the EncoderFusion approaches by only connecting the encoder embedding layer to softmax layer ( SurfaceFusion ) . The SurfaceFusion approach shortens the path distance between source and target embeddings , which can help to learn better bilingual embeddings with direct interactions . Experimental results on several Seq2Seq NLP tasks show that our method consistently outperforms both the vanilla Seq2Seq model and the layer attention model . Extensive analyses reveal that our approach produces more aligned bilingual word embeddings by shortening the path distance between them , which confirm our claim . Our main contributions are as follows : • We introduce a fine-grained layer attention method to qualitatively and quantitatively evaluate the contribution of individual encoder layers . • We demonstrate that the encoder embedding layer is essential for fusing encoder layers , which consolidates conflicted findings reported by previous studies . • We propose a simple yet effective SurfaceFusion approach to directly exploit the encoder embedding layer for the decoder , which produces more expressive bilingual embeddings . 2 PRELIMINARIES . 2.1 SEQUENCE-TO-SEQUENCE LEARNING . Seq2Seq learning aims to maximize the log-likelihood of a target sequence y = { y1 , . . . , yJ } conditioned on a source sequence x = { x1 , . . . , xI } , which is formulated as : ŷ = arg max logP ( y|x ) . Typically , Seq2Seq learning can be implemented as various architectures ( Bahdanau et al. , 2015 ; Gehring et al. , 2017 ; Vaswani et al. , 2017 ; Wu et al. , 2019 ) , among which the Transformer ( Vaswani et al. , 2017 ) has advanced the state of the art . Without loss of generality , we introduce Transformer as the testbed in this paper . Transformer consists of an encoder E equipped with N identical layers to map the source sequence x into distributed representations , based on which a decoder D equipped with M identical layers generates the target sequence y : XN = E ( X0 ) N : = n=1 FFN ( ATT ( Xn−1 , Xn−1 , Xn−1 ) ) ( 1 ) YM = D ( Y0 , XN ) M : = m=1 FFN ( ATT ( ATT ( Ym−1 , Ym−1 , Ym−1 ) , XN , XN ) ) ( 2 ) where X0 denotes the sum of the word embeddings Xemb and position embeddings Xpos of x , Y0 denotes that of the shifted right y , FFN ( · ) denotes a position-wise feed-forward network , and ATT ( · ) denotes a multi-head dot-product attention network with three arguments–query , key and value . Residual connection ( He et al. , 2016 ) and layer normalization ( Ba et al. , 2016 ) are used in each sub-layer , which are suppressed in Equation 1 and 2 for clarity . Finally , the output representation YM of the decoder is projected into the probability P ( y|x ) , which is optimized during model training . 2.2 EXPERIMENTAL SETUP . To validate the universality of source representation bottleneck in Seq2Seq models , we conducted experiments on three representative tasks , which vary from the distance between input and output domains and the scale of training data : Machine translation takes a sentence in one language as input , and outputs a semantically-equivalent sentence in another language . We conducted experiments on three benchmarking datasets : smallscale WMT16 Romanian-English ( Ro-En ; 0.6M instances ) , medium-scale WMT14 English-German ( En-De ; 4.5M instances ) , and large-scale WMT14 English-French ( En-Fr ; 36.0M instances ) . The tokenized BLEU score ( Papineni et al. , 2002 ) was used for all the translation tasks . Text summarization takes a long-text document as input , and outputs a short and adequate summary in the same language . We used the CNN/Daily Mail corpus ( 0.3M instances ) . We evaluated with the standard ROUGE metric ( Lin , 2004 ) , i.e . Rouge-1 , Rouge-2 , and Rouge-L. Grammatical error correction takes a sentence with grammatical errors as input , and outputs a corrected sentence . We used CONLL14 datasets as the testbed ( 1.4M instances ) . The MaxMatch ( M2 ) scores ( Dahlmeier & Ng , 2012 ) were used for evaluation with precision , recall , and F0.5 values . The machine translation task has distant input/output domains ( i.e . in different languages ) , while the other tasks have similar input/output domains ( i.e . in the same language ) . We used Transformer ( Vaswani et al. , 2017 ) as the Seq2Seq model . Details of the datasets and model training are listed in Appendix A.1 . 3 BEHAVIOR OF ENCODERFUSION . In this section , we first formulate our research hypothesis of source representation bottleneck ( §3.1 ) that EncoderFusion expects to solve . In the following subsections , we propose a fine-grained layer attention model ( §3.2 ) to validate our hypothesis on well-designed experiments ( §3.3 ) . 3.1 SOURCE REPRESENTATION BOTTLENECK . Seq2Seq models learn more abstract features with the increase of layer level ( i.e . X0 → XN and Y0 → YM ) ( Belinkov et al. , 2017 ) . It has been extensively validated that a reasonable use of both the abstract representations ( at higher-level layers ) and the surface representations ( at lower-level layers ) is beneficial for various NLP ( Lu & Li , 2013 ; Hu et al. , 2014 ; Dou et al. , 2018 ; Peters et al. , 2018 ) and CV ( Long et al. , 2014 ; Pinheiro et al. , 2016 ; Lin et al. , 2017 ; Chen et al. , 2018a ) tasks . However , the Seq2Seq decoder only takes the abstract representations at uppermost layer XN as input ( Equation 2 ) , while ignores other usefully surface representations at other layers Xn ( n < N ) . Although XN has encoded surface features from low-level representations through layer-by-layer abstraction and residual connections , we hypothesize that its limited representation capacity may not sufficiently model those surface features from lower encoder layers , especially the embedding layer . We call such an issue as source representation bottleneck . 3.2 FINE-GRAINED LAYER ATTENTION . For each decoder layer , layer attention ( Bapna et al. , 2018 ; Peters et al. , 2018 ) assigns normalized scalar weights to all encoder layers , providing a direct way for evaluating the contributions made by each encoder layer . However , the capacity of a simple scalar weight is limited , leading to insufficient evaluation of the contributions . Motivated by fine-grained attention ( Choi et al. , 2018 ) that each element of a context vector receives an individual attention weight , we propose a fine-grained layer attention model to combine the advantages of both techniques . This allows us to more convincingly evaluate the contribution of individual encoder layer to the model performance . Besides , the nature of fine-grained attention enables us to give in-depth analyses of the representation power in §3.3 . Specifically , we replace the layer-agnostic source representation XN with the layer-aware representation Sm for each decoder layer Ym , which is calculated as : Sm = N∑ n=0 ŵm , n Xn , ŵm , n = [ ŵm , n,1 , . . . , ŵm , n , D ] , ŵm , n , d = exp ( wm , n , d ) ∑N n′=0 exp ( w m , n′ , d ) where denotes an element-wise multiplication , and wm , n , d denotes an element in the learnable attention weight W ∈ RM× ( N+1 ) ×D , where D is the dimensionality of the source representation . When n = 0 , we use the word embeddings Xemb without position embeddings as X0 , which has been empirically proved effective . We applied a regularization technique – DropConnect ( Wan et al. , 2013 ) to the attention weight W for a stable training , which randomly drops each wm , n , d with a probability p and divides W by 1− p. We set it to 0.3 for all the experiments . Table 2 lists the results . The proposed fine-grained layer attention model consistently outperforms the vanilla Transformer across Seq2Seq tasks , demonstrating the benefit of fusing surface features at lower-level layers . We evaluated several EncoderFusion methods in Table 1 , including layer aggregation ( Dou et al. , 2018 ) , layer-wise coordination ( He et al. , 2018 ) , and coarse-grained layer attention ( Bapna et al. , 2018 ) . Their results are respectively 34.05 , 34.19 , and 34.32 , which are all lower than that of fine-grained layer attention ( 34.45 ) . Based on these experimental results , we thus choose fine-grained layer attention as a representative of EncoderFusion in the following analyses . 3.3 BEHAVIOR CHANGES ACROSS ENCODER LAYERS . In this section , we investigate whether the surface features at lower encoder layers ( especially the encoder embedding layer ) contribute to the model performance via carefully designed experiments . Visualization of layer attention We first visualize the learned layer attention distribution in Figure 1 , in which each weight is the averaged attention weights over all dimensions . Generally , a higher weight denotes more contribution of an encoder layer to the corresponding decoder layer . Clearly , in all tasks higher decoder layers especially the uppermost ones pay more attention to the encoder embedding layer , which indicates that the surface representations potentially bring some additional useful features to the model performance . Voita et al . ( 2019 ) ; Wang & Tu ( 2020 ) reveal that the upper layers of decoder are responsible for the translation part while the lower layers for the language modeling part . Similarly , our results show that surface representations might play an important role in learning to translate source tokens . Among the Seq2Seq models , there are still considerable differences in the attention heatmaps . In the summarization model , almost all decoder layers focus more on the encoder embedding layer , while in the other two models the intermediate decoder layers pay more attention to the higher-level encoder layers . This is consistent with the findings of Rothe et al . ( 2019 ) , in which they reveal that the summarization task , as a typical extractive generation task , tends to use more surface features to generate extractive summaries . In contrast , both machine translation and error correction tasks require a large amount of syntactic and semantic information , which are generally embedded in higher-level encoder layers ( Peters et al. , 2018 ) . However , we still can not conclude that source representation bottleneck does exist in Seq2Seq models , since the surface features might act as a noise regularizer to improve the robustness of encoder output representations . To dispel the doubt , we further design two experiments to directly evaluate the effectiveness of surface features at the encoder embedding layer . Contribution of individual encoder layer In this experiment , we quantitatively analyze the behaviors change of a trained Seq2Seq model when masking a specific encoder layer ( i.e . turning its attention weight to zero and redistribute the other attention weights ) . Note that the masking operation does not affect the information flow of encoding calculation , i.e . keeping Equation 1 unchanged . Length -6 % 0 % 6 % Translation GEC Summarization Emb 1 2 3 4 5 6 Performance R el at iv e C ha ng e -4 % -2 % 0 % Translation GEC Summarization Emb 1 2 3 4 5 6 Length -6 % 0 % 6 % Translation GEC Summarization Emb 1 2 3 4 5 6 Performance R el at iv e C ha ng e -4 % -2 % 0 % Translation GEC Summarization Emb 1 2 3 4 5 6 Figure 2 ( a ) shows the contribution of individual encoder layer to model performance . As seen , masking the encoder embedding layer seriously harms the model performance in all tasks , which confirms our claim that the surface features in the embedding layer are essential to Seq2Seq models . Figure 2 ( b ) shows the results on the output length . Masking the encoder embedding layer consistently increases the length of generated output , which is especially significant for the summarization model . One possible reason is that the instances in translation and correction tasks have similar input/output lengths , while the summarization instances have distant input/output lengths . By analyzing the model outputs , we found that the Seq2Seq models tend to generate some hallucinatory ( i.e . fluent but unfaithful to the source ) predictions ( Lee et al. , 2019 ; Wang & Sennrich , 2020 ) when masking the embedding layer . Taking the correction task for an example , a right prediction “ anyone ” was replaced by the hallucinatory prediction “ friends of anyone ” in the masked model , in which the corresponding source contains no information related to “ friends ” . This issue becomes worse in the summarization task , since the hallucinatory prediction is more likely to be a sentence . The additional hallucinations will increase the output length and reduce the model performance . In addition , Lee et al . ( 2019 ) point out that even if hallucinations occur only occasionally , the Seq2Seq model may evidently lose user trust than other prediction problems , indicating the importance to fuse surface features at the embedding layer . More cases are studied in Appendix A.2 . Expressivity of attended dimensions in the encoder embedding layer As shown in Figure 1 , the uppermost decoder layer pays most attention to the encoder embedding layer ( i.e . the lower right corner ) . If the embedding layer acts as a noise regularizer , the layer dimensions would be randomly attended by the fine-grained model ; otherwise , the dimensions of higher attention weights should be distinguished from the other dimensions . Starting from this intuition , we reordered the dimensions of the encoder embedding layer according to the attention weights ŵM,0 , and split it into two equal sub-embedding matrices , i.e . more attended dimensions and less attended dimensions . We compared the expressivity of the two sub-embedding matrices by the commonly-used singular value decomposition ( Gao et al. , 2019 ; Wang et al. , 2019a ; Shen et al. , 2020 ) , in which higher normalized singular values denote that the embedding is more uniformly distributed , thus are more expressive . The singular values are normalized by dividing them by the largest value and their log scale values are reported for better clarity . Figure 3 depicts the singular value results . For comparison , we also report the values of the randomly selected dimensions . Clearly , the more attended dimensions are most expressive , while the less attended dimensions are least expressive . These results demonstrate that the fine-grained attention model indeed extracts useful surface information from the encoder embedding layer , which does not play the role of a noise regularizer . From the above experiments , we prove that the encoder embedding layer indeed provides useful surface information , which is not fully exploited by the standard Seq2Seq models . | This is an interesting idea where the authors propose "SurfaceFusion", where they use the source embeddings learned by the encoder to modulate the output of the decoder at the final layer. The authors claim this is because the embeddings contain valuable information that is lost during encoder processing because the encoder lacks the capacity to represent both semantic and surface features. The authors then show through a series of experiments that attending over the encoder embeddings is useful, and propose a way to integrate the information from the embeddings directly into the last layer of the decoder, showing that this improves experimental results. | SP:c33d55dadd5fe4399b85968375ddffdeaf64ad61 |
Understanding and Improving Encoder Layer Fusion in Sequence-to-Sequence Learning | 1 INTRODUCTION . Sequence-to-Sequence ( Seq2Seq ) learning ( Sutskever et al. , 2014 ) has advanced the state of the art in various natural language processing ( NLP ) tasks , such as machine translation ( Bahdanau et al. , 2015 ; Vaswani et al. , 2017 ; Wu et al. , 2019 ) , text summarization ( Wang et al. , 2019b ; Zhang et al. , 2020 ) , and grammatical error correction ( Kiyono et al. , 2019 ; Kaneko et al. , 2020 ) . Seq2Seq models are generally implemented with an encoder-decoder framework , in which a multi-layer encoder summarizes a source sequence into a sequence of representation and another multi-layer decoder produces the target sequence conditioned on the encoded representation . Recent studies reveal that fusing the intermediate encoder layers ( EncoderFusion ) is beneficial for Seq2Seq models , such as layer attention ( Bapna et al. , 2018 ) , layer aggregation ( Dou et al. , 2018 ; Wang et al. , 2019c ) , and layer-wise coordination ( He et al. , 2018 ) . Despite its effectiveness , not much is known about how fusing encoder layer representations work . The intuitive explanation is that fusing encoder layers exploits surface and syntactic information embedded in the lower encoder layers ( Belinkov et al. , 2017 ; Peters et al. , 2018 ) . However , other studies show that attending to lower encoder layers ( excluding the encoder embedding layer ) does not improve model performance ( Domhan , 2018 ) , which is conflicted with existing conclusions . It is still unclear why and when fusing encoder layers should work in Seq2Seq models . This paper tries to shed light upon behavior of Seq2Seq models augmented with EncoderFusion method . To this end , we propose a novel fine-grained layer attention to evaluate the contribution of ∗Work was done when Xuebo Liu and Liang Ding were interning at Tencent AI Lab . individual encoder layers . We conduct experiments on several representative Seq2Seq NLP tasks , including machine translation , text summarization , and grammatical error correction . Through a series of analyses , we find that the uppermost decoder layer pays more attention to the encoder embedding layer . Masking the encoder embedding layer significantly drops model performance by generating hallucinatory ( i.e . fluent but unfaithful to the source ) predictions . The encoded representation of the standard Seq2Seq models ( i.e . w/o fusing encoder layers ) may not have enough capacity to model both semantic and surface features ( especially at the encoder embedding layer ) . We call the problem described above the source representation bottleneck . Based on this observation , we simplify the EncoderFusion approaches by only connecting the encoder embedding layer to softmax layer ( SurfaceFusion ) . The SurfaceFusion approach shortens the path distance between source and target embeddings , which can help to learn better bilingual embeddings with direct interactions . Experimental results on several Seq2Seq NLP tasks show that our method consistently outperforms both the vanilla Seq2Seq model and the layer attention model . Extensive analyses reveal that our approach produces more aligned bilingual word embeddings by shortening the path distance between them , which confirm our claim . Our main contributions are as follows : • We introduce a fine-grained layer attention method to qualitatively and quantitatively evaluate the contribution of individual encoder layers . • We demonstrate that the encoder embedding layer is essential for fusing encoder layers , which consolidates conflicted findings reported by previous studies . • We propose a simple yet effective SurfaceFusion approach to directly exploit the encoder embedding layer for the decoder , which produces more expressive bilingual embeddings . 2 PRELIMINARIES . 2.1 SEQUENCE-TO-SEQUENCE LEARNING . Seq2Seq learning aims to maximize the log-likelihood of a target sequence y = { y1 , . . . , yJ } conditioned on a source sequence x = { x1 , . . . , xI } , which is formulated as : ŷ = arg max logP ( y|x ) . Typically , Seq2Seq learning can be implemented as various architectures ( Bahdanau et al. , 2015 ; Gehring et al. , 2017 ; Vaswani et al. , 2017 ; Wu et al. , 2019 ) , among which the Transformer ( Vaswani et al. , 2017 ) has advanced the state of the art . Without loss of generality , we introduce Transformer as the testbed in this paper . Transformer consists of an encoder E equipped with N identical layers to map the source sequence x into distributed representations , based on which a decoder D equipped with M identical layers generates the target sequence y : XN = E ( X0 ) N : = n=1 FFN ( ATT ( Xn−1 , Xn−1 , Xn−1 ) ) ( 1 ) YM = D ( Y0 , XN ) M : = m=1 FFN ( ATT ( ATT ( Ym−1 , Ym−1 , Ym−1 ) , XN , XN ) ) ( 2 ) where X0 denotes the sum of the word embeddings Xemb and position embeddings Xpos of x , Y0 denotes that of the shifted right y , FFN ( · ) denotes a position-wise feed-forward network , and ATT ( · ) denotes a multi-head dot-product attention network with three arguments–query , key and value . Residual connection ( He et al. , 2016 ) and layer normalization ( Ba et al. , 2016 ) are used in each sub-layer , which are suppressed in Equation 1 and 2 for clarity . Finally , the output representation YM of the decoder is projected into the probability P ( y|x ) , which is optimized during model training . 2.2 EXPERIMENTAL SETUP . To validate the universality of source representation bottleneck in Seq2Seq models , we conducted experiments on three representative tasks , which vary from the distance between input and output domains and the scale of training data : Machine translation takes a sentence in one language as input , and outputs a semantically-equivalent sentence in another language . We conducted experiments on three benchmarking datasets : smallscale WMT16 Romanian-English ( Ro-En ; 0.6M instances ) , medium-scale WMT14 English-German ( En-De ; 4.5M instances ) , and large-scale WMT14 English-French ( En-Fr ; 36.0M instances ) . The tokenized BLEU score ( Papineni et al. , 2002 ) was used for all the translation tasks . Text summarization takes a long-text document as input , and outputs a short and adequate summary in the same language . We used the CNN/Daily Mail corpus ( 0.3M instances ) . We evaluated with the standard ROUGE metric ( Lin , 2004 ) , i.e . Rouge-1 , Rouge-2 , and Rouge-L. Grammatical error correction takes a sentence with grammatical errors as input , and outputs a corrected sentence . We used CONLL14 datasets as the testbed ( 1.4M instances ) . The MaxMatch ( M2 ) scores ( Dahlmeier & Ng , 2012 ) were used for evaluation with precision , recall , and F0.5 values . The machine translation task has distant input/output domains ( i.e . in different languages ) , while the other tasks have similar input/output domains ( i.e . in the same language ) . We used Transformer ( Vaswani et al. , 2017 ) as the Seq2Seq model . Details of the datasets and model training are listed in Appendix A.1 . 3 BEHAVIOR OF ENCODERFUSION . In this section , we first formulate our research hypothesis of source representation bottleneck ( §3.1 ) that EncoderFusion expects to solve . In the following subsections , we propose a fine-grained layer attention model ( §3.2 ) to validate our hypothesis on well-designed experiments ( §3.3 ) . 3.1 SOURCE REPRESENTATION BOTTLENECK . Seq2Seq models learn more abstract features with the increase of layer level ( i.e . X0 → XN and Y0 → YM ) ( Belinkov et al. , 2017 ) . It has been extensively validated that a reasonable use of both the abstract representations ( at higher-level layers ) and the surface representations ( at lower-level layers ) is beneficial for various NLP ( Lu & Li , 2013 ; Hu et al. , 2014 ; Dou et al. , 2018 ; Peters et al. , 2018 ) and CV ( Long et al. , 2014 ; Pinheiro et al. , 2016 ; Lin et al. , 2017 ; Chen et al. , 2018a ) tasks . However , the Seq2Seq decoder only takes the abstract representations at uppermost layer XN as input ( Equation 2 ) , while ignores other usefully surface representations at other layers Xn ( n < N ) . Although XN has encoded surface features from low-level representations through layer-by-layer abstraction and residual connections , we hypothesize that its limited representation capacity may not sufficiently model those surface features from lower encoder layers , especially the embedding layer . We call such an issue as source representation bottleneck . 3.2 FINE-GRAINED LAYER ATTENTION . For each decoder layer , layer attention ( Bapna et al. , 2018 ; Peters et al. , 2018 ) assigns normalized scalar weights to all encoder layers , providing a direct way for evaluating the contributions made by each encoder layer . However , the capacity of a simple scalar weight is limited , leading to insufficient evaluation of the contributions . Motivated by fine-grained attention ( Choi et al. , 2018 ) that each element of a context vector receives an individual attention weight , we propose a fine-grained layer attention model to combine the advantages of both techniques . This allows us to more convincingly evaluate the contribution of individual encoder layer to the model performance . Besides , the nature of fine-grained attention enables us to give in-depth analyses of the representation power in §3.3 . Specifically , we replace the layer-agnostic source representation XN with the layer-aware representation Sm for each decoder layer Ym , which is calculated as : Sm = N∑ n=0 ŵm , n Xn , ŵm , n = [ ŵm , n,1 , . . . , ŵm , n , D ] , ŵm , n , d = exp ( wm , n , d ) ∑N n′=0 exp ( w m , n′ , d ) where denotes an element-wise multiplication , and wm , n , d denotes an element in the learnable attention weight W ∈ RM× ( N+1 ) ×D , where D is the dimensionality of the source representation . When n = 0 , we use the word embeddings Xemb without position embeddings as X0 , which has been empirically proved effective . We applied a regularization technique – DropConnect ( Wan et al. , 2013 ) to the attention weight W for a stable training , which randomly drops each wm , n , d with a probability p and divides W by 1− p. We set it to 0.3 for all the experiments . Table 2 lists the results . The proposed fine-grained layer attention model consistently outperforms the vanilla Transformer across Seq2Seq tasks , demonstrating the benefit of fusing surface features at lower-level layers . We evaluated several EncoderFusion methods in Table 1 , including layer aggregation ( Dou et al. , 2018 ) , layer-wise coordination ( He et al. , 2018 ) , and coarse-grained layer attention ( Bapna et al. , 2018 ) . Their results are respectively 34.05 , 34.19 , and 34.32 , which are all lower than that of fine-grained layer attention ( 34.45 ) . Based on these experimental results , we thus choose fine-grained layer attention as a representative of EncoderFusion in the following analyses . 3.3 BEHAVIOR CHANGES ACROSS ENCODER LAYERS . In this section , we investigate whether the surface features at lower encoder layers ( especially the encoder embedding layer ) contribute to the model performance via carefully designed experiments . Visualization of layer attention We first visualize the learned layer attention distribution in Figure 1 , in which each weight is the averaged attention weights over all dimensions . Generally , a higher weight denotes more contribution of an encoder layer to the corresponding decoder layer . Clearly , in all tasks higher decoder layers especially the uppermost ones pay more attention to the encoder embedding layer , which indicates that the surface representations potentially bring some additional useful features to the model performance . Voita et al . ( 2019 ) ; Wang & Tu ( 2020 ) reveal that the upper layers of decoder are responsible for the translation part while the lower layers for the language modeling part . Similarly , our results show that surface representations might play an important role in learning to translate source tokens . Among the Seq2Seq models , there are still considerable differences in the attention heatmaps . In the summarization model , almost all decoder layers focus more on the encoder embedding layer , while in the other two models the intermediate decoder layers pay more attention to the higher-level encoder layers . This is consistent with the findings of Rothe et al . ( 2019 ) , in which they reveal that the summarization task , as a typical extractive generation task , tends to use more surface features to generate extractive summaries . In contrast , both machine translation and error correction tasks require a large amount of syntactic and semantic information , which are generally embedded in higher-level encoder layers ( Peters et al. , 2018 ) . However , we still can not conclude that source representation bottleneck does exist in Seq2Seq models , since the surface features might act as a noise regularizer to improve the robustness of encoder output representations . To dispel the doubt , we further design two experiments to directly evaluate the effectiveness of surface features at the encoder embedding layer . Contribution of individual encoder layer In this experiment , we quantitatively analyze the behaviors change of a trained Seq2Seq model when masking a specific encoder layer ( i.e . turning its attention weight to zero and redistribute the other attention weights ) . Note that the masking operation does not affect the information flow of encoding calculation , i.e . keeping Equation 1 unchanged . Length -6 % 0 % 6 % Translation GEC Summarization Emb 1 2 3 4 5 6 Performance R el at iv e C ha ng e -4 % -2 % 0 % Translation GEC Summarization Emb 1 2 3 4 5 6 Length -6 % 0 % 6 % Translation GEC Summarization Emb 1 2 3 4 5 6 Performance R el at iv e C ha ng e -4 % -2 % 0 % Translation GEC Summarization Emb 1 2 3 4 5 6 Figure 2 ( a ) shows the contribution of individual encoder layer to model performance . As seen , masking the encoder embedding layer seriously harms the model performance in all tasks , which confirms our claim that the surface features in the embedding layer are essential to Seq2Seq models . Figure 2 ( b ) shows the results on the output length . Masking the encoder embedding layer consistently increases the length of generated output , which is especially significant for the summarization model . One possible reason is that the instances in translation and correction tasks have similar input/output lengths , while the summarization instances have distant input/output lengths . By analyzing the model outputs , we found that the Seq2Seq models tend to generate some hallucinatory ( i.e . fluent but unfaithful to the source ) predictions ( Lee et al. , 2019 ; Wang & Sennrich , 2020 ) when masking the embedding layer . Taking the correction task for an example , a right prediction “ anyone ” was replaced by the hallucinatory prediction “ friends of anyone ” in the masked model , in which the corresponding source contains no information related to “ friends ” . This issue becomes worse in the summarization task , since the hallucinatory prediction is more likely to be a sentence . The additional hallucinations will increase the output length and reduce the model performance . In addition , Lee et al . ( 2019 ) point out that even if hallucinations occur only occasionally , the Seq2Seq model may evidently lose user trust than other prediction problems , indicating the importance to fuse surface features at the embedding layer . More cases are studied in Appendix A.2 . Expressivity of attended dimensions in the encoder embedding layer As shown in Figure 1 , the uppermost decoder layer pays most attention to the encoder embedding layer ( i.e . the lower right corner ) . If the embedding layer acts as a noise regularizer , the layer dimensions would be randomly attended by the fine-grained model ; otherwise , the dimensions of higher attention weights should be distinguished from the other dimensions . Starting from this intuition , we reordered the dimensions of the encoder embedding layer according to the attention weights ŵM,0 , and split it into two equal sub-embedding matrices , i.e . more attended dimensions and less attended dimensions . We compared the expressivity of the two sub-embedding matrices by the commonly-used singular value decomposition ( Gao et al. , 2019 ; Wang et al. , 2019a ; Shen et al. , 2020 ) , in which higher normalized singular values denote that the embedding is more uniformly distributed , thus are more expressive . The singular values are normalized by dividing them by the largest value and their log scale values are reported for better clarity . Figure 3 depicts the singular value results . For comparison , we also report the values of the randomly selected dimensions . Clearly , the more attended dimensions are most expressive , while the less attended dimensions are least expressive . These results demonstrate that the fine-grained attention model indeed extracts useful surface information from the encoder embedding layer , which does not play the role of a noise regularizer . From the above experiments , we prove that the encoder embedding layer indeed provides useful surface information , which is not fully exploited by the standard Seq2Seq models . | The authors perform a thorough analysis of encoder fusion for Transformers: which encoder layer should the N-th decoder layer attend to? It turns out that the final decoder layers often attend to the encoder embeddings, leading the authors to provide them to the last decoder layer which leads to small improvements of performance on machine translation, summarization and grammar correction tasks. These are nice results, but the gains are small and the models are tested in the very basic configurations. These tasks and techniques, as well as some numbers used to claim state-of-the-art, are from a few years ago (e.g., SOTA on en-de translation is higher currently than the authors claim and higher than their number). It would be interesting to see if the presented conclusions hold for larger models - esp. for a T5 Transformer on masked language modeling, as this would be a more commonly used model in 2020. Unluckily, it is quite possible that increased activation size may negate the benefits of the authors' technique. It may well though make it even more important -- it would be really good to know! Lacking these experiments, we cannot recommend acceptance at this point. | SP:c33d55dadd5fe4399b85968375ddffdeaf64ad61 |
Motion Forecasting with Unlikelihood Training | 1 INTRODUCTION . For robotic applications deployed in the real world , the ability to foresee the future motions of agents in the surrounding environment plays an essential role for safe and intelligent decision making . This is a very challenging task . For example , in the autonomous driving domain , to predict nearby agents ’ future trajectories , an agent needs to consider contextual information such as their past trajectories , potential interactions , and maps . State of the art prediction models ( Salzmann et al. , 2020 ; Tang & Salakhutdinov , 2019 ; Rhinehart et al. , 2019 ) directly take contextual information as part of their input and use techniques such as graph neural networks to extract high-level features for prediction . They are typically trained with a maximum likelihood estimation ( MLE ) objective that maximizes the likelihood of ground truth trajectories in the predicted distribution . Although MLE loss encourages the prediction to be close to the ground truth geometrically , it does not focus on learning a good distribution that is plausible with respect to the contextual information . These models predict trajectories that violate the contextual information ( e.g. , go to opposite driving direction or out of the driving area ) but still closes to ground truth . In contrast , humans can easily notice that these trajectories are unlikely in a specific context . This phenomenon suggests that simply applying MLE loss can not fully exploit contextual information . To address the problem , we propose a novel and simple method , unlikelihood training , that injects contextual information into the learning signal . Our loss penalizes the trajectories that violate the contextual information , called negative trajectories , by minimizing their likelihood in the predicted distribution . To generate negative trajectories , we first draw a number of candidate trajectories from our model ’ s predicted distribution . Then , a context checker is used to cut out the trajectories that violate contextual information as negative trajectories . This context checker does not need to be differentiable . By minimizing the likelihood of negative trajectories , the model is forced to use the contextual information to avoid predictions that violate context . Therefore , the prediction quality is improved . Existing methods ( Casas et al. , 2020 ; Park et al. , 2020 ) using contextual information as learning signals either introduce new learning parameters or using high-variance learning methods such as the REINFORCE algorithm ( Casas et al. , 2020 ) . In contrast , our method injects rich contextual information into the training objective and keeps the training process simple . Unlikelihood training ( Welleck et al. , 2019 ) has been applied to neural text generation . We are the first to propose unlikelihood training for continuous space of trajectories . For the discrete space of token sequences , repeating tokens or n-grams in the generated sequence are chosen as negative tokens . In contrast , we design a context checker to select negative trajectories sampled from the continuous distribution of model predictions . Our method can be viewed as a simple add-on to any models that estimate the distribution of future trajectories . It improves their performance by encouraging models to focus more on contextual information without increasing the complexity of its original training process . Our contributions are summarized as follows : • We propose a novel and simple method , unlikelihood training for motion forecasting in autonomous driving that encourages models to use contextual information by minimizing the likelihood of trajectories that violate contextual information . Our method can be easily incorporated into state-of-the-art models . • Our experimental results on challenging real-world trajectory forecasting datasets , nuScenes and Argoverse , shows that unlikelihood training can improve prediction performance by 8 % and reduce the standard deviation by up to 50 % . 2 RELATED WORK . In this section , we briefly review the two most related topics . Trajectory Forecasting Trajectory forecasting of dynamic agents , a core problem for robotic applications such as autonomous driving and social robots , has been well studied in the literature . State-of-the-art models solves it as a sequence-to-sequence multi-modal prediction problem ( Lee et al. , 2017 ; Cui et al. , 2018 ; Chai et al. , 2019 ; Rhinehart et al. , 2019 ; Kosaraju et al. , 2019 ; Tang & Salakhutdinov , 2019 ; Ridel et al. , 2020 ; Salzmann et al. , 2020 ; Huang et al. , 2019 ) . ( Cui et al. , 2018 ; Chai et al. , 2019 ; Ridel et al. , 2020 ) predicts multiple future trajectories without learning low dimensional latent agent behaviors . ( Lee et al. , 2017 ; Kosaraju et al. , 2019 ; Rhinehart et al. , 2019 ; Huang et al. , 2019 ) encodes agent behaviors in continuous low dimensional latent space while ( Tang & Salakhutdinov , 2019 ; Salzmann et al. , 2020 ) uses discrete latent variables . Discrete latent variables succinctly capture semantically meaningful modes such as turn left , turn right . ( Tang & Salakhutdinov , 2019 ; Salzmann et al. , 2020 ) learns discrete latent variables without explicit labels . All of them use a maximum likelihood estimation ( MLE ) objective or its approximations ( e.g. , VAE ) . In this paper , we show that MLE loss can ignore contextual information such as maps and states of surrounding agents . As a result , models with such a loss can assign too much probability to unlikely trajectories . We propose an unlikelihood training objective to avoid such cases . All models with the maximum likelihood estimation objective can potentially benefit from our methods . Contrastive learning and unlikelihood training To date , several studies have investigated the possibilities to benefit from negative data . One of the popular direction is contrastive learning . Contrastive learning has achieved significant success in many fields ( Oord et al. , 2018 ; Kipf et al. , 2019 ; Ma & Collins , 2018 ; Abid & Zou , 2019 ; Welleck et al. , 2019 ) . NCE ( Ma & Collins , 2018 ) CPC ( Oord et al. , 2018 ) maximizes the mutual information between data and latent representation by a novel contrastive loss to extract useful representation from data . C-SWMs ( Kipf et al. , 2019 ) utilizes contrastive learning to learn a better world model for reinforcement learning tasks . Recently , unlikelihood training ( Welleck et al. , 2019 ) proposes a new method to utilize negative data . In addition , to maximize the likelihood of the ground truth token , it minimizes the likelihood of negative tokens for better text generation . Their method is on the discrete space of token sequences . Repeating tokens or n-grams in the generated sequence is chosen as negative tokens . In contrast , our proposed method works in the continuous space of trajectories . We design a novel method , context checker , to select negative trajectories . 3 METHOD . 3.1 PROBLEM FORMULATION . We are targeting at better predicting the future trajectory Yi of a vehicle i given input Xi . Xi can include any related information like rasterized maps or past positions of vehicle i and surrounding agents , depends on the design of the method . Here we skip the detailed choice of input and denote it as Xi for conciseness . Due to different driving strategies , driving intents , and the complex traffic environment , there are usually multiple possible future trajectories given an input xi ( although there is only one ground truth future trajectory yi , gt in a dataset recorded in the real world ) . To handle this situation , most state of the art methods ( Salzmann et al. , 2020 ) model a distribution of possible future trajectories pθ ( Yi | Xi ) to cover all the possibilities given the input Xi instead of predicting one trajectory . θ denotes the learning parameters of the model . To train such methods , most stateof-the-art models usually use maximum likelihood estimation ( MLE ) to maximize the likelihood of ground truth trajectory Yi , gt in the predicted distribution . For example , the loss of CVAE-based model Trajectron++ ( Salzmann et al. , 2020 ) is Eq.1 . This loss is used to maximize the lower bound of ground truth ’ s likelihood when the coefficient k = 1 . Ltraj++ = −Eẑ∼qθ3 ( z|Xi , Yi , gt ) [ log pθ2 ( Yi , gt |Xi , ẑ ) ] + kDKL ( qθ3 ( z |Xi , Yi , gt ) ‖pθ1 ( z |Xi ) ) − Iq ( Xi ; z ) ≥ − log p ( Yi , gt |Xi , Yi , gt ) − Iq ( Xi ; z ) , when k = 1 ( 1 ) Limitation of MLE on Motion Forecasting MLE encourages the model to predict a distribution that allocates reasonable probability mass to the region where Yi is located by minimizing the KL-divergence of predicted distribution and ground truth distribution . Because the domain of trajectory distribution is over the geometric locations , MLE makes these two distributions ” close ” to each other geometrically . However , we argue that maintaining the geometrical nearness only is not good enough for motion forecasting task in autonomous driving . In complex traffic scenarios , there can be many potential trajectories close enough to the ground truth geometrically but are very unlikely to happen . For example , if the ground truth trajectory Yi , gt is on the outermost lane , a trajectory that is close to Yi , gt but outside the drivable region is unlike to happen in the real world . However , MLE loss will not impose a significant enough penalty on such a case to avoid such a prediction . Fig.1 demonstrates a prediction example from Trajectron++ ( Salzmann et al. , 2020 ) where part of the distribution is outside of the derivable region or on the lane with the wrong direction . The MLE-based loss only offers learning signals that contain the geometric location information of the ground truth trajectories . All the other contextual information , like the drivable region and the lane direction , are missing in the learning signals . While the inputs to a model contain rich contextual information , the model can not use it to avoid the prediction that is geometrically close to ground truth but violates context . In contrast , this is quite a simple task for humans . 3.2 UNLIKELIHOOD LOSS . To mitigate this problem , we design a new loss term that encourages the model to consider the contextual information . Inspired by contrastive learning and unlikelihood training , we additionally train our model to minimize the likelihood of trajectories that violate the contextual information given input Xi . We denote them as negative trajectories Yi , neg . Let ’ s first assume that we already have a distribution of negative trajectories pneg ( Yi | Xi ) . One intuitive way is to directly minimize the log likelihood of Yi , neg in our predicted distribution , similar to MLE but in an opposite manner Lunlike = EXi , ∼D , Yi , neg∼pneg ( Yi|Xi ) [ log pθ ( Yi , neg |Xi ) ] ( 2 ) However , the gradient of log function tends to infinity when the input tends to 0 , which leads to unstable training since the model are optimized to minimize pθ ( Yi , neg | Xi ) and pθ ( Yi , neg | Xi ) ≥ 0 . To avoid the infinity gradient region of log function , we add a small constant to the likelihood . The final loss term we propose is Lunlike = EXi , ∼D , Yi , neg∼pneg ( Yi|X ) [ log ( pθ ( Yi , neg |Xi ) + ) ) ] ( 3 ) We call it unlikelihood loss . We use a coefficient γ to balance Lunlike . The final training objective in case we combine our method with Trajectron++ is L = Ltraj++ + γLunlike ( 4 ) Eq.4 is also easily adapted to combine with any other models that predict trajectory distribution as output . With the help of Lunlike , we inject the contextual information into the learning signal , force the model to better extract and use contextual information in Xi , and generate more reasonable predicted distribution to avoid high Lunlike . | The present paper considers the problem of context integration in probabilistic agent trajectory predictors, particularly Trajectron++. It starts with the observation that these predictors often do a bad job at considering non-drivable areas in their predictions even if context information is injected as part of the input. The paper proposes adjusting the loss function by adding an unlikelihood loss term. This term modifies existing MLE-type losses in a way that discourages context violations (in the present case, it discourages prediction of trajectories that are on non-drivable space). | SP:f485de73661d59efd25025ddf9778652edb306c1 |
Motion Forecasting with Unlikelihood Training | 1 INTRODUCTION . For robotic applications deployed in the real world , the ability to foresee the future motions of agents in the surrounding environment plays an essential role for safe and intelligent decision making . This is a very challenging task . For example , in the autonomous driving domain , to predict nearby agents ’ future trajectories , an agent needs to consider contextual information such as their past trajectories , potential interactions , and maps . State of the art prediction models ( Salzmann et al. , 2020 ; Tang & Salakhutdinov , 2019 ; Rhinehart et al. , 2019 ) directly take contextual information as part of their input and use techniques such as graph neural networks to extract high-level features for prediction . They are typically trained with a maximum likelihood estimation ( MLE ) objective that maximizes the likelihood of ground truth trajectories in the predicted distribution . Although MLE loss encourages the prediction to be close to the ground truth geometrically , it does not focus on learning a good distribution that is plausible with respect to the contextual information . These models predict trajectories that violate the contextual information ( e.g. , go to opposite driving direction or out of the driving area ) but still closes to ground truth . In contrast , humans can easily notice that these trajectories are unlikely in a specific context . This phenomenon suggests that simply applying MLE loss can not fully exploit contextual information . To address the problem , we propose a novel and simple method , unlikelihood training , that injects contextual information into the learning signal . Our loss penalizes the trajectories that violate the contextual information , called negative trajectories , by minimizing their likelihood in the predicted distribution . To generate negative trajectories , we first draw a number of candidate trajectories from our model ’ s predicted distribution . Then , a context checker is used to cut out the trajectories that violate contextual information as negative trajectories . This context checker does not need to be differentiable . By minimizing the likelihood of negative trajectories , the model is forced to use the contextual information to avoid predictions that violate context . Therefore , the prediction quality is improved . Existing methods ( Casas et al. , 2020 ; Park et al. , 2020 ) using contextual information as learning signals either introduce new learning parameters or using high-variance learning methods such as the REINFORCE algorithm ( Casas et al. , 2020 ) . In contrast , our method injects rich contextual information into the training objective and keeps the training process simple . Unlikelihood training ( Welleck et al. , 2019 ) has been applied to neural text generation . We are the first to propose unlikelihood training for continuous space of trajectories . For the discrete space of token sequences , repeating tokens or n-grams in the generated sequence are chosen as negative tokens . In contrast , we design a context checker to select negative trajectories sampled from the continuous distribution of model predictions . Our method can be viewed as a simple add-on to any models that estimate the distribution of future trajectories . It improves their performance by encouraging models to focus more on contextual information without increasing the complexity of its original training process . Our contributions are summarized as follows : • We propose a novel and simple method , unlikelihood training for motion forecasting in autonomous driving that encourages models to use contextual information by minimizing the likelihood of trajectories that violate contextual information . Our method can be easily incorporated into state-of-the-art models . • Our experimental results on challenging real-world trajectory forecasting datasets , nuScenes and Argoverse , shows that unlikelihood training can improve prediction performance by 8 % and reduce the standard deviation by up to 50 % . 2 RELATED WORK . In this section , we briefly review the two most related topics . Trajectory Forecasting Trajectory forecasting of dynamic agents , a core problem for robotic applications such as autonomous driving and social robots , has been well studied in the literature . State-of-the-art models solves it as a sequence-to-sequence multi-modal prediction problem ( Lee et al. , 2017 ; Cui et al. , 2018 ; Chai et al. , 2019 ; Rhinehart et al. , 2019 ; Kosaraju et al. , 2019 ; Tang & Salakhutdinov , 2019 ; Ridel et al. , 2020 ; Salzmann et al. , 2020 ; Huang et al. , 2019 ) . ( Cui et al. , 2018 ; Chai et al. , 2019 ; Ridel et al. , 2020 ) predicts multiple future trajectories without learning low dimensional latent agent behaviors . ( Lee et al. , 2017 ; Kosaraju et al. , 2019 ; Rhinehart et al. , 2019 ; Huang et al. , 2019 ) encodes agent behaviors in continuous low dimensional latent space while ( Tang & Salakhutdinov , 2019 ; Salzmann et al. , 2020 ) uses discrete latent variables . Discrete latent variables succinctly capture semantically meaningful modes such as turn left , turn right . ( Tang & Salakhutdinov , 2019 ; Salzmann et al. , 2020 ) learns discrete latent variables without explicit labels . All of them use a maximum likelihood estimation ( MLE ) objective or its approximations ( e.g. , VAE ) . In this paper , we show that MLE loss can ignore contextual information such as maps and states of surrounding agents . As a result , models with such a loss can assign too much probability to unlikely trajectories . We propose an unlikelihood training objective to avoid such cases . All models with the maximum likelihood estimation objective can potentially benefit from our methods . Contrastive learning and unlikelihood training To date , several studies have investigated the possibilities to benefit from negative data . One of the popular direction is contrastive learning . Contrastive learning has achieved significant success in many fields ( Oord et al. , 2018 ; Kipf et al. , 2019 ; Ma & Collins , 2018 ; Abid & Zou , 2019 ; Welleck et al. , 2019 ) . NCE ( Ma & Collins , 2018 ) CPC ( Oord et al. , 2018 ) maximizes the mutual information between data and latent representation by a novel contrastive loss to extract useful representation from data . C-SWMs ( Kipf et al. , 2019 ) utilizes contrastive learning to learn a better world model for reinforcement learning tasks . Recently , unlikelihood training ( Welleck et al. , 2019 ) proposes a new method to utilize negative data . In addition , to maximize the likelihood of the ground truth token , it minimizes the likelihood of negative tokens for better text generation . Their method is on the discrete space of token sequences . Repeating tokens or n-grams in the generated sequence is chosen as negative tokens . In contrast , our proposed method works in the continuous space of trajectories . We design a novel method , context checker , to select negative trajectories . 3 METHOD . 3.1 PROBLEM FORMULATION . We are targeting at better predicting the future trajectory Yi of a vehicle i given input Xi . Xi can include any related information like rasterized maps or past positions of vehicle i and surrounding agents , depends on the design of the method . Here we skip the detailed choice of input and denote it as Xi for conciseness . Due to different driving strategies , driving intents , and the complex traffic environment , there are usually multiple possible future trajectories given an input xi ( although there is only one ground truth future trajectory yi , gt in a dataset recorded in the real world ) . To handle this situation , most state of the art methods ( Salzmann et al. , 2020 ) model a distribution of possible future trajectories pθ ( Yi | Xi ) to cover all the possibilities given the input Xi instead of predicting one trajectory . θ denotes the learning parameters of the model . To train such methods , most stateof-the-art models usually use maximum likelihood estimation ( MLE ) to maximize the likelihood of ground truth trajectory Yi , gt in the predicted distribution . For example , the loss of CVAE-based model Trajectron++ ( Salzmann et al. , 2020 ) is Eq.1 . This loss is used to maximize the lower bound of ground truth ’ s likelihood when the coefficient k = 1 . Ltraj++ = −Eẑ∼qθ3 ( z|Xi , Yi , gt ) [ log pθ2 ( Yi , gt |Xi , ẑ ) ] + kDKL ( qθ3 ( z |Xi , Yi , gt ) ‖pθ1 ( z |Xi ) ) − Iq ( Xi ; z ) ≥ − log p ( Yi , gt |Xi , Yi , gt ) − Iq ( Xi ; z ) , when k = 1 ( 1 ) Limitation of MLE on Motion Forecasting MLE encourages the model to predict a distribution that allocates reasonable probability mass to the region where Yi is located by minimizing the KL-divergence of predicted distribution and ground truth distribution . Because the domain of trajectory distribution is over the geometric locations , MLE makes these two distributions ” close ” to each other geometrically . However , we argue that maintaining the geometrical nearness only is not good enough for motion forecasting task in autonomous driving . In complex traffic scenarios , there can be many potential trajectories close enough to the ground truth geometrically but are very unlikely to happen . For example , if the ground truth trajectory Yi , gt is on the outermost lane , a trajectory that is close to Yi , gt but outside the drivable region is unlike to happen in the real world . However , MLE loss will not impose a significant enough penalty on such a case to avoid such a prediction . Fig.1 demonstrates a prediction example from Trajectron++ ( Salzmann et al. , 2020 ) where part of the distribution is outside of the derivable region or on the lane with the wrong direction . The MLE-based loss only offers learning signals that contain the geometric location information of the ground truth trajectories . All the other contextual information , like the drivable region and the lane direction , are missing in the learning signals . While the inputs to a model contain rich contextual information , the model can not use it to avoid the prediction that is geometrically close to ground truth but violates context . In contrast , this is quite a simple task for humans . 3.2 UNLIKELIHOOD LOSS . To mitigate this problem , we design a new loss term that encourages the model to consider the contextual information . Inspired by contrastive learning and unlikelihood training , we additionally train our model to minimize the likelihood of trajectories that violate the contextual information given input Xi . We denote them as negative trajectories Yi , neg . Let ’ s first assume that we already have a distribution of negative trajectories pneg ( Yi | Xi ) . One intuitive way is to directly minimize the log likelihood of Yi , neg in our predicted distribution , similar to MLE but in an opposite manner Lunlike = EXi , ∼D , Yi , neg∼pneg ( Yi|Xi ) [ log pθ ( Yi , neg |Xi ) ] ( 2 ) However , the gradient of log function tends to infinity when the input tends to 0 , which leads to unstable training since the model are optimized to minimize pθ ( Yi , neg | Xi ) and pθ ( Yi , neg | Xi ) ≥ 0 . To avoid the infinity gradient region of log function , we add a small constant to the likelihood . The final loss term we propose is Lunlike = EXi , ∼D , Yi , neg∼pneg ( Yi|X ) [ log ( pθ ( Yi , neg |Xi ) + ) ) ] ( 3 ) We call it unlikelihood loss . We use a coefficient γ to balance Lunlike . The final training objective in case we combine our method with Trajectron++ is L = Ltraj++ + γLunlike ( 4 ) Eq.4 is also easily adapted to combine with any other models that predict trajectory distribution as output . With the help of Lunlike , we inject the contextual information into the learning signal , force the model to better extract and use contextual information in Xi , and generate more reasonable predicted distribution to avoid high Lunlike . | In this paper, the authors focus on vehicular motion forecasting on roadways. To this end, they propose an interesting tweak to existing approaches. In addition to maximizing the likelihood of ground truth trajectories, the authors consider an "unlikelihood" weighted subloss which penalizes sections of the event space that shouldn't happen with context (such a driving on the wrong side of the road). They do this by sampling trajectories and labeling them with a context checker. They evaluate their approach qualitatively and quantitatively on the Argoverse and nuScenes datasets. They show improved quantitative performance over baselines. | SP:f485de73661d59efd25025ddf9778652edb306c1 |
Learning Hyperbolic Representations of Topological Features | 1 INTRODUCTION . Persistent homology is a topological data analysis tool which tracks how topological features ( e.g . connected components , cycles , cavities ) appear and disappear as we analyze the data at different scales or in nested sequences of subspaces ( 1 ; 2 ) . A nested sequence of subspaces is known as a filtration . As an informal example of a filtration consider an image of variable brightness . As the brightness is increased , certain features ( edges , texture ) may become less or more prevalent . The birth of a topological feature refers to the `` time '' ( i.e. , the brightness value ) when it appears in the filtration and the death refers to the `` time '' when it disappears . The lifespan of the feature is called persistence . Persistent homology summarizes these topological characteristics in a form of multiset called persistence diagram , which is a highly robust and versatile descriptor of the data . Persistence diagrams enjoy the stability property , which ensures that the diagrams of two similar objects are similar ( 3 ) . Additionally , under some assumptions , one can approximately reconstruct the input space from a diagram ( which is known as solving the inverse problem ) ( 4 ) . However , despite their strengths , the space of persistence diagrams lacks structure as basic operations , such as addition and scalar multiplication , are not well defined . The only imposed structure is induced by the Bottleneck and Wasserstein metrics , which are notoriously hard to compute , thereby preventing us from leveraging them for machine learning tasks . Related Work . To address these issues , several vectorization methods have been proposed . Some of the earliest approaches are based on kernels , i.e. , generalized products that turn persistence diagrams into elements of a Hilbert space . Kusano et al . ( 5 ) propose a persistence weighted Gaussian kernel which allows them to explicitly control the effect of persistence . Alternatively , Carrière et al . ( 6 ) leverage the sliced Wasserstein distance to define a kernel that mimics the distance between diagrams . The approaches by Bubenik ( 7 ) based on persistent landscapes , by Reininghaus et al . ( 8 ) based on scale space theory and by Le et al . ( 9 ) based on the Fisher information metric are along the same line of work . The major drawback in utilizing kernel methods is that they suffer from scalability issues as the training scales poorly with the number of samples . In another line of work , researchers have constructed finite-dimensional embeddings , i.e. , transformations turning persistence diagrams into vectors in a Euclidean space . Adams et al . ( 10 ) map the diagrams to persistence images and discretize them to obtain the embedding vector . Carrière et al . ( 11 ) develop a stable vectorization method by computing pairwise distances between points in the persistence diagram . An approach based on interpreting the points in the diagram as roots of a complex polynomial is presented by Di Fabio ( 12 ) . Adcock et al . ( 13 ) identify an algebra of polynomials on the diagram space that can be used as coordinates and the approach is extended by Kališnik in ( 14 ) to tropical functions which guarantee stability . The common drawback of these embeddings is that the representation is pre-defined , i.e. , there exist no learnable parameters , therefore , it is agnostic to the specific learning task . This is clearly sub-optimal as the eminent success of deep learning has demonstrated that it is preferable to learn the representation . The more recent approaches aim at learning the representation of the persistence diagram in an end-to-end fashion . Hofer et al . ( 15 ) present the first input layer based on a parameterized family of Gaussian-like functionals , with the mean and variance learned during training . They extend their method in ( 16 ) allowing for a broader class of parameterized function families to be considered . It is quite common to have topological features of infinite persistence ( 1 ) , i.e. , features that never die . Such features are called essential and in practice are usually assigned a death time equal to the maximum filtration value . This may restrict their expressivity because it shrinks their importance relative to non-essential features . While we may be able to increase the scale sufficiently high and end up having only one trivial essential feature ( i.e. , the 0-th order persistent homology group that becomes a single connected component at a scale that is sufficiently large ) , the resulting persistence diagrams may not be the ones that best summarize the data in terms of performance on the underlying learning task . This is evident in the work by Hofer et al . ( 15 ) where the authors showed that essential features offer discriminative power . The work by Carrière et al . ( 17 ) , which introduces a network input layer the encompasses several vectorization methods , emphasizes the importance of essential features and is the first one to introduce a deep learning method incorporating extended persistence as a way to deal with them . In this paper , we approach the issue of essential features from the geometric viewpoint . We are motivated by the recent success of hyperbolic geometry and the interest in extending machine learning models to hyperbolic spaces or general manifolds . We refer the reader to the review paper by Bronstein et al . ( 18 ) for an overview of geometric deep learning . Here , we review the most relevant and pivotal contributions in the field . Nickel et al . ( 19 ; 20 ) propose Poincaré and Lorentz embeddings for learning hierarchical representations of symbolic data and show that the representational capacity and generalization ability outperform Euclidean embeddings . Sala et al . ( 21 ) propose low-dimensional hyperbolic embeddings of hierarchical data and show competitive performance on WorldNet . Ganea et al . ( 22 ) generalize neural networks to the hyperbolic space and show that hyperbolic sentence embeddings outperform their Euclidean counterparts on a range of tasks . Gulcherhe et al . ( 23 ) introduce hyperbolic attention networks which show improvements in terms of generalization on machine translation and graph learning while keeping a compact representation . In the context of graph representation learning , hyperbolic graph neural networks ( 24 ) and hyperbolic graph convolutional neural networks ( 25 ) have been developed and shown to lead to improvements on various benchmarks . However , despite this success of geometric deep learning , little work has been done in applying these methods to topological features , such as persistence diagrams . The main contribution of this paper is to bridge the gap between topological data analysis and hyperbolic representation learning . We introduce a method to represent persistence diagrams on a hyperbolic space , more specifically on the Poincare ball . We define a learnable parameterization of the Poincare ball and leverage the vectorial structure of the tangent space to combine ( in a manifoldpreserving manner ) the representations of individual points of the persistence diagram . Our method learns better task-specific representations than the state of the art because it does not shrink the relative importance of essential features . In fact , by allowing the representations of essential features to get infinitesimally close to the boundary of the Poincare ball , their distance to the representations of non-essential features approaches infinity , therefore preserving their relative importance . To the best of our knowledge , this is the first approach for learning representations of persistence diagrams in non-Euclidean spaces . 2 BACKGROUND . In this section , we provide a brief overview of persistent homology leading up to the definition of persistence diagrams . We refer the interested reader to the papers by Edelsbrunner et al . ( 1 ; 2 ) for a detailed overview of persistent homology . An overview of homology can be found in the Appendix . Persistent Homology . Let K be a simplicial complex . A filtration of K is a nested sequence of subcomplexes that starts with the empty complex and ends with K , ∅ = K0 ⊆ K1 ⊆ . . . ⊆ Kd = K. ( 1 ) A typical way to construct a filtration is to consider sublevel sets of a real valued function , f : K → R. Let a1 < · · · < ad be a sorted sequence of the values of f ( K ) . Then , we obtain a filtration by setting K0 = ∅ and Ki = f−1 ( ( −∞ , ai ] ) for 1 ≤ i ≤ d. ( 2 ) We can apply simplicial homology to each of the subcomplexes of the filtration . When 0 ≤ i ≤ j ≤ d , the inclusion Ki ⊆ Kj induces a homomorphism f i , jn : Hn ( Ki ) → Hn ( Kj ) ( 3 ) on the simplicial homology groups for each homology dimension n. We call the image of f i , jn a n-th persistent homology group and it consists of homology classes born before i that are still alive at j . A homology class α is born at Ki if it is not in the image of the map induced by the inclusion Ki−1 ⊆ Ki . Furthermore , if α is born at Ki , it dies entering Kj if the image of the map induced by Ki−1 ⊆ Kj−1 does not contain the image of α but the image of the map induced by Ki−1 ⊆ Kj does . The persistence of the homology class α is j − i . Since classes may be born at the same i and die at the same j , we can use inclusion-exclusion to determine the multiplicity of each ( i , j ) , µi , jn = β i , j−1 n − βi−1 , j−1n − βi , jn + βi−1 , jn , ( 4 ) where the n-th persistent Betti numbers βi , jn are the ranks of the images of the n-th persistent homology group , i.e. , βi , jn = rank ( im ( f i , j n ) ) , and capture the number of n-dimensional topological features that persist from i to j . By setting µi , ∞n = β i , d n − βi−1 , dn we can account for features that still persist at the end of the filtration ( j = d ) , which are known as essential features . Persistence Diagrams . Persistence diagrams are multisets supported by the upper diagonal part of the real plane and capture the birth/death of topological features ( i.e. , homology classes ) across the filtration . Definition 2.1 ( Persistence Diagram ) . Let ∆ = { x ∈ R∆ : mult ( x ) = ∞ } be the multiset of the diagonal R∆ = { ( x1 , x2 ) ∈ R2 : x1 = x2 } , where mult ( · ) denotes the multiplicity function and let R2∗ = { ( x1 , x2 ) ∈ R ∪ ( R ∪∞ ) : x2 > x1 } . Also , let n be a homology dimension and consider the sublevel set filtration induced by a function f : K → R over the complex K. Then , a persistence diagram , Dn ( f ) , is a multiset of the form Dn ( f ) = { x : x ∈ R2∗ } ∪∆ constructed by inserting each point ( ai , aj ) for i < j with multiplicity µi , jn ( or µ i , ∞ n if it is an essential feature ) . We denote the space of all persistence diagrams with D. Definition 2.2 ( Wasserstein distance and stability ) . Let Dn ( f ) , En ( g ) be two persistence diagrams generated by the filtration induced by the functions f , g : K → R , respectively . We define the Wasserstein distance wqp ( Dn ( f ) , Eg ( g ) ) = inf η ( ∑ x∈D ‖x− η ( x ) ‖pq ) 1/p , ( 5 ) where p , q ∈ N and the infimum is taken over all bijections η : Dn ( f ) → En ( g ) . The special case p = ∞ is known as Bottleneck distance . The persistence diagrams are stable with respect to the Wasserstein distance if and only if wqp ( Dn ( f ) , Eg ( g ) ) ≤ ‖f − g‖∞ . Note that a bijection η between persistence diagrams is guaranteed to exist because their cardinalities are equal , considering that , as per Def . 2.1 , the points on the diagonal are added with infinite multiplicity . The strength of persistent homology stems from the above stability definition , which essentially states that the map taking a sublevel function to the persistence diagram is Lipschitz continuous . This implies that if two objects are similar then their persistence diagrams are close . | In this paper, the authors proposed a new representation of persistence diagrams that can include `''essential features''. Essential features correspond to the intrinsic topology of the underlying space that will not die during the filtration. To include the fact that the essential features are infinitely far from other normal features in the diagram, the authors proposed to use a Poincare ball representation, which maps the diagram into a disk whose boundary is infinitely far from inside. | SP:95ba08c326437452098f9cc7d8b542a08bb747a3 |
Learning Hyperbolic Representations of Topological Features | 1 INTRODUCTION . Persistent homology is a topological data analysis tool which tracks how topological features ( e.g . connected components , cycles , cavities ) appear and disappear as we analyze the data at different scales or in nested sequences of subspaces ( 1 ; 2 ) . A nested sequence of subspaces is known as a filtration . As an informal example of a filtration consider an image of variable brightness . As the brightness is increased , certain features ( edges , texture ) may become less or more prevalent . The birth of a topological feature refers to the `` time '' ( i.e. , the brightness value ) when it appears in the filtration and the death refers to the `` time '' when it disappears . The lifespan of the feature is called persistence . Persistent homology summarizes these topological characteristics in a form of multiset called persistence diagram , which is a highly robust and versatile descriptor of the data . Persistence diagrams enjoy the stability property , which ensures that the diagrams of two similar objects are similar ( 3 ) . Additionally , under some assumptions , one can approximately reconstruct the input space from a diagram ( which is known as solving the inverse problem ) ( 4 ) . However , despite their strengths , the space of persistence diagrams lacks structure as basic operations , such as addition and scalar multiplication , are not well defined . The only imposed structure is induced by the Bottleneck and Wasserstein metrics , which are notoriously hard to compute , thereby preventing us from leveraging them for machine learning tasks . Related Work . To address these issues , several vectorization methods have been proposed . Some of the earliest approaches are based on kernels , i.e. , generalized products that turn persistence diagrams into elements of a Hilbert space . Kusano et al . ( 5 ) propose a persistence weighted Gaussian kernel which allows them to explicitly control the effect of persistence . Alternatively , Carrière et al . ( 6 ) leverage the sliced Wasserstein distance to define a kernel that mimics the distance between diagrams . The approaches by Bubenik ( 7 ) based on persistent landscapes , by Reininghaus et al . ( 8 ) based on scale space theory and by Le et al . ( 9 ) based on the Fisher information metric are along the same line of work . The major drawback in utilizing kernel methods is that they suffer from scalability issues as the training scales poorly with the number of samples . In another line of work , researchers have constructed finite-dimensional embeddings , i.e. , transformations turning persistence diagrams into vectors in a Euclidean space . Adams et al . ( 10 ) map the diagrams to persistence images and discretize them to obtain the embedding vector . Carrière et al . ( 11 ) develop a stable vectorization method by computing pairwise distances between points in the persistence diagram . An approach based on interpreting the points in the diagram as roots of a complex polynomial is presented by Di Fabio ( 12 ) . Adcock et al . ( 13 ) identify an algebra of polynomials on the diagram space that can be used as coordinates and the approach is extended by Kališnik in ( 14 ) to tropical functions which guarantee stability . The common drawback of these embeddings is that the representation is pre-defined , i.e. , there exist no learnable parameters , therefore , it is agnostic to the specific learning task . This is clearly sub-optimal as the eminent success of deep learning has demonstrated that it is preferable to learn the representation . The more recent approaches aim at learning the representation of the persistence diagram in an end-to-end fashion . Hofer et al . ( 15 ) present the first input layer based on a parameterized family of Gaussian-like functionals , with the mean and variance learned during training . They extend their method in ( 16 ) allowing for a broader class of parameterized function families to be considered . It is quite common to have topological features of infinite persistence ( 1 ) , i.e. , features that never die . Such features are called essential and in practice are usually assigned a death time equal to the maximum filtration value . This may restrict their expressivity because it shrinks their importance relative to non-essential features . While we may be able to increase the scale sufficiently high and end up having only one trivial essential feature ( i.e. , the 0-th order persistent homology group that becomes a single connected component at a scale that is sufficiently large ) , the resulting persistence diagrams may not be the ones that best summarize the data in terms of performance on the underlying learning task . This is evident in the work by Hofer et al . ( 15 ) where the authors showed that essential features offer discriminative power . The work by Carrière et al . ( 17 ) , which introduces a network input layer the encompasses several vectorization methods , emphasizes the importance of essential features and is the first one to introduce a deep learning method incorporating extended persistence as a way to deal with them . In this paper , we approach the issue of essential features from the geometric viewpoint . We are motivated by the recent success of hyperbolic geometry and the interest in extending machine learning models to hyperbolic spaces or general manifolds . We refer the reader to the review paper by Bronstein et al . ( 18 ) for an overview of geometric deep learning . Here , we review the most relevant and pivotal contributions in the field . Nickel et al . ( 19 ; 20 ) propose Poincaré and Lorentz embeddings for learning hierarchical representations of symbolic data and show that the representational capacity and generalization ability outperform Euclidean embeddings . Sala et al . ( 21 ) propose low-dimensional hyperbolic embeddings of hierarchical data and show competitive performance on WorldNet . Ganea et al . ( 22 ) generalize neural networks to the hyperbolic space and show that hyperbolic sentence embeddings outperform their Euclidean counterparts on a range of tasks . Gulcherhe et al . ( 23 ) introduce hyperbolic attention networks which show improvements in terms of generalization on machine translation and graph learning while keeping a compact representation . In the context of graph representation learning , hyperbolic graph neural networks ( 24 ) and hyperbolic graph convolutional neural networks ( 25 ) have been developed and shown to lead to improvements on various benchmarks . However , despite this success of geometric deep learning , little work has been done in applying these methods to topological features , such as persistence diagrams . The main contribution of this paper is to bridge the gap between topological data analysis and hyperbolic representation learning . We introduce a method to represent persistence diagrams on a hyperbolic space , more specifically on the Poincare ball . We define a learnable parameterization of the Poincare ball and leverage the vectorial structure of the tangent space to combine ( in a manifoldpreserving manner ) the representations of individual points of the persistence diagram . Our method learns better task-specific representations than the state of the art because it does not shrink the relative importance of essential features . In fact , by allowing the representations of essential features to get infinitesimally close to the boundary of the Poincare ball , their distance to the representations of non-essential features approaches infinity , therefore preserving their relative importance . To the best of our knowledge , this is the first approach for learning representations of persistence diagrams in non-Euclidean spaces . 2 BACKGROUND . In this section , we provide a brief overview of persistent homology leading up to the definition of persistence diagrams . We refer the interested reader to the papers by Edelsbrunner et al . ( 1 ; 2 ) for a detailed overview of persistent homology . An overview of homology can be found in the Appendix . Persistent Homology . Let K be a simplicial complex . A filtration of K is a nested sequence of subcomplexes that starts with the empty complex and ends with K , ∅ = K0 ⊆ K1 ⊆ . . . ⊆ Kd = K. ( 1 ) A typical way to construct a filtration is to consider sublevel sets of a real valued function , f : K → R. Let a1 < · · · < ad be a sorted sequence of the values of f ( K ) . Then , we obtain a filtration by setting K0 = ∅ and Ki = f−1 ( ( −∞ , ai ] ) for 1 ≤ i ≤ d. ( 2 ) We can apply simplicial homology to each of the subcomplexes of the filtration . When 0 ≤ i ≤ j ≤ d , the inclusion Ki ⊆ Kj induces a homomorphism f i , jn : Hn ( Ki ) → Hn ( Kj ) ( 3 ) on the simplicial homology groups for each homology dimension n. We call the image of f i , jn a n-th persistent homology group and it consists of homology classes born before i that are still alive at j . A homology class α is born at Ki if it is not in the image of the map induced by the inclusion Ki−1 ⊆ Ki . Furthermore , if α is born at Ki , it dies entering Kj if the image of the map induced by Ki−1 ⊆ Kj−1 does not contain the image of α but the image of the map induced by Ki−1 ⊆ Kj does . The persistence of the homology class α is j − i . Since classes may be born at the same i and die at the same j , we can use inclusion-exclusion to determine the multiplicity of each ( i , j ) , µi , jn = β i , j−1 n − βi−1 , j−1n − βi , jn + βi−1 , jn , ( 4 ) where the n-th persistent Betti numbers βi , jn are the ranks of the images of the n-th persistent homology group , i.e. , βi , jn = rank ( im ( f i , j n ) ) , and capture the number of n-dimensional topological features that persist from i to j . By setting µi , ∞n = β i , d n − βi−1 , dn we can account for features that still persist at the end of the filtration ( j = d ) , which are known as essential features . Persistence Diagrams . Persistence diagrams are multisets supported by the upper diagonal part of the real plane and capture the birth/death of topological features ( i.e. , homology classes ) across the filtration . Definition 2.1 ( Persistence Diagram ) . Let ∆ = { x ∈ R∆ : mult ( x ) = ∞ } be the multiset of the diagonal R∆ = { ( x1 , x2 ) ∈ R2 : x1 = x2 } , where mult ( · ) denotes the multiplicity function and let R2∗ = { ( x1 , x2 ) ∈ R ∪ ( R ∪∞ ) : x2 > x1 } . Also , let n be a homology dimension and consider the sublevel set filtration induced by a function f : K → R over the complex K. Then , a persistence diagram , Dn ( f ) , is a multiset of the form Dn ( f ) = { x : x ∈ R2∗ } ∪∆ constructed by inserting each point ( ai , aj ) for i < j with multiplicity µi , jn ( or µ i , ∞ n if it is an essential feature ) . We denote the space of all persistence diagrams with D. Definition 2.2 ( Wasserstein distance and stability ) . Let Dn ( f ) , En ( g ) be two persistence diagrams generated by the filtration induced by the functions f , g : K → R , respectively . We define the Wasserstein distance wqp ( Dn ( f ) , Eg ( g ) ) = inf η ( ∑ x∈D ‖x− η ( x ) ‖pq ) 1/p , ( 5 ) where p , q ∈ N and the infimum is taken over all bijections η : Dn ( f ) → En ( g ) . The special case p = ∞ is known as Bottleneck distance . The persistence diagrams are stable with respect to the Wasserstein distance if and only if wqp ( Dn ( f ) , Eg ( g ) ) ≤ ‖f − g‖∞ . Note that a bijection η between persistence diagrams is guaranteed to exist because their cardinalities are equal , considering that , as per Def . 2.1 , the points on the diagonal are added with infinite multiplicity . The strength of persistent homology stems from the above stability definition , which essentially states that the map taking a sublevel function to the persistence diagram is Lipschitz continuous . This implies that if two objects are similar then their persistence diagrams are close . | The authors propose to learn a representation for the persistence diagram (PD) in the hyperbolic space to incorporate the essential features (i.e., infinite persistence). The authors show that the hyperbolic representation has stability. Empirically, the authors illustrate that the hyperbolic representation for PD compares favorably with other baselines on graph and image classification. | SP:95ba08c326437452098f9cc7d8b542a08bb747a3 |
Finding Physical Adversarial Examples for Autonomous Driving with Fast and Differentiable Image Compositing | 1 INTRODUCTION . Computer vision has made revolutionary advances in recent years by leveraging a combination of deep neural network architectures with abundant high-quality perceptual data . One of the transformative applications of computational perception is autonomous driving , with autonomous cars and trucks already being evaluated for use in geofenced settings , and partial autonomy , such as highway assistance , leveraging state-of-the-art perception embedded in vehicles available to consumers . However , a history of tragic crashes involving autonomous driving , most notably Tesla ( Thorbecke , 2020 ) and Uber ( Hawkins , 2019 ) reveals that modern perceptual architectures still have some limitations even in non-adversarial driving environments . In addition , and more concerning , is the increasing abundance of evidence that state-of-the-art deep neural networks used in perception tasks are highly vulnerable to adversarial perturbations , or imperceptible noise that is added to an input image and deliberately designed to cause misclassification ( Goodfellow et al. , 2014 ; Yuan et al. , 2019 ; Modas et al. , 2020 ) . Furthermore , several lines of work consider specifically physical adversarial examples which modify the scene being captured by a camera , rather than the image ( Kurakin et al. , 2016 ; Eykholt et al. , 2018 ; Sitawarin et al. , 2018 ; Dutta , 2018 ; Duan et al. , 2020 ) . Despite this body of evidence demonstrating vulnerabilities in deep neural network perceptual architectures , it is nevertheless not evident that such vulnerabilities are consequential in realistic autonomous driving , even if primarily using cameras for perception . First , most such attacks involve independent perturbations to a given input image . Autonomous driving is a dynamical system , so that a fixed adversarial perturbation to a scene is perceived through a series of distinct , but highly interdependent perspectives . Second , self-driving is a complex system that maps perceptual inputs to control outputs . Consequently , even if we succeed in causing the control outputs to deviate from normal , the vehicle will now perceive a sequence of frames that is different from those encountered on its normal path , and typically deploy self-correcting behavior in response . For example , if the vehicle is driving straight and then begins swerving towards the opposite lane , its own perception will inform the control that it ’ s going in the wrong direction , and the controller will steer it back on course . To address these limitations , Bayesian Optimization ( BO ) ( Archetti and Candelieri , 2019 ) was recently proposed as a way to design physical adversarial examples ( 2 black rectangles on road pavement ) in Carla autonomous driving simulations ( Dosovitskiy et al. , 2017 ) against end-to-end autonomous driving architectures ( Boloor et al. , 2020 ) . The key challenge with this approach , however , is that attack design must execute actual experiments ( e.g. , simulations , or actual driving ) for a larger number of iterations ( 1000 in the work above ) , making it impractical for large-scale or physical driving evaluation . Furthermore , it is not clear how well BO scales as we increase the complexity of the adversarial space beyond 2 black rectangles . We propose a highly scalable framework for designing physically realizable adversarial examples against end-to-end autonomous driving architectures . Our framework is illustrated in Figure 1 , and develops a differentiable pipeline for digitally approximating driving scenarios . The proposed approximation makes use of image compositing , learning homography and color mappings from a birds-eye view of embedded adversarial examples to projections of these in images based on actual driving frames , and sampling sequences of actual frames with small added random noise to control to ensure adequate sampling of possible perspectives . The entire process can then be fed into automatic differentiators to obtain adversarial examples that maximize a car ’ s deviation from its normal sequence of controls ( e.g. , steering angle ) for a target driving scenario . We evaluate the proposed framework using Carla simulations in comparison with the state-of-the-art BO method . Our experiments show that the resulting attacks are significantly stronger , with effects on induced deviations and road infractions often considerably outperforming BO , at a small fraction of actual driving runs required for training . Furthermore , we show that our approach yields attacks that are robust to unforeseen variations in weather and visibility . Related Work : Attacks on deep neural networks for computer vision tasks has been a subject of extensive prior research ( Goodfellow et al. , 2014 ; Yuan et al. , 2019 ; Modas et al. , 2020 ; Vorobeychik and Kantarcioglu , 2018 ) . The most common variation introduces imperceptible noise to pixels of an image in order to induce error in predictions , such as misclassification of the image or failure to detect an object in it . A more recent line of research has investigated physical adversarial examples ( Kurakin et al. , 2016 ; Athalye et al. , 2017 ; Eykholt et al. , 2018 ; Sitawarin et al. , 2018 ; Dutta , 2018 ; Duan et al. , 2020 ) , where the explicit goal is to implement these in the physical scene , so that the images of the scene subsequently captured by the camera and fed into a deep neural network result in a prediction error . In a related effort , Liu et al . ( 2019 ) developed a differentiable renderer that allows the attacker to devise higher-level perturbations of an image scene , such as geometry and lighting , through a differentiable renderer . However , most of these approaches attack a fixed input scene , whereas autonomous driving is a complex dynamical system . Several recent approaches investigate physical attacks on autonomous driving that attempt to account for the fact that a single object is modified and viewed through a series of frames ( Ackerman , 2019 ; Kong et al. , 2020 ; Boloor et al. , 2020 ) . However , these either still consider digital attacks , albeit restricted to a small area ( e.g. , replacing a road sign with a noisy road sign ) and do not consider a vehicles self-correcting behavior ( for example , ( Kong et al. , 2020 ) ) , or rely on many expensive driving experiments in order to identify adversarial patterns ( Boloor et al. , 2020 ) . 2 PROPOSED METHOD . Autonomous driving systems are equipped with decision algorithms that produce control signals for a vehicle , based on high-level instructions—such as a given route or destination—and inputs from cameras and other sensors that make continuous measurements of the vehicle ’ s physical environment . We assume the decision algorithm is in the form of a differentiable function—such as a neural network—that maps video frames from the camera , along with other inputs , to the control outputs . Given such a network or function , our goal is to determine if it is vulnerable to attack . Specifically , we seek to build a scalable and efficient method to find modifications that can be applied to the physical environment , and result in a stream of video frames which cause the control network to produce output signals that disrupt the vehicle ’ s operation , moving it away from the expected ideal trajectory . This task is challenging since the relationship between modifications to the physical environment and the network ’ s inputs is complex : the video frames correspond to images of the environment from a sequence of changing viewpoints , where the sequence itself depends on the network ’ s control outputs . The precise effect of any given modification can be determined only by actually driving the vehicle in the modified environment , or by using a high-quality simulator with a sophisticated physics engine . However , it is expensive to use actual driving or an expensive simulator when searching for the right modification , since neither process is differentiable with respect to parameters of the modification , and would require repeated trials with candidate modifications in every step of the search process . Instead , we propose a fast approximation to produce video frames for a given environment given a candidate modification that is differentiable with respect to parameters of the modification . Our approach requires a small number of initial calibration runs—of actual driving or a sophisticated simulator—after which , the search for optimal parameters can be carried out with end-to-end gradientbased optimization . Specifically , we consider the case when the modification takes the form of figures ( such as rectangles ) drawn on a restricted stretch of the road , and task the optimization with finding their optimal shape and color so as to maximize deviation from the controller ’ s trajectory prior to modification . We now describe our model for the physical modification , our approximate mapping to create video frames for a given modification , and our optimization approach based on this mapping . 2.1 PARAMETERIZED PHYSICAL MODIFICATION . We assume modifications are in the form of a collection of K figures ( e.g. , rectangles ) that will be painted on a flat surface in the environment ( e.g. , road ) . Let Φ = { xSk , xCk } Kk=1 denote the parameters of this modification , with xSk corresponding to the shape parameters , and x C k the RGB color , of the kth figure . These parameters are defined with respect to co-ordinates in some canonical—say , top-down—view of the surface . We let M ( nc ; xS ) denote a scalar-valued mask that represents whether a pixel at spatial location nc ∈ Z2 in the canonical view is within a figure with shape parameters xS . This function depends simply on the chosen geometry of the figures , and has value of 1 for pixels within the figure , 0 for those outside , and real values between 0 and 1 for those near the boundary ( representing partial occupancy on a discrete pixel grid to prevent aliasing artifacts ) . Since the spatial extents for different figures may overlap , we next account for occlusions by assuming that the lines will be painted in order . Accordingly , we define a series of visibility functions Vk ( nc ; Φ ) , each representing the visibility of the kth figure at pixel nc , after accounting for occlusions . We set the function for the last figure as VK ( nc ; Φ ) = M ( nc ; xSK ) , and for the other figures with k < K , Vk ( nc ; Φ ) = M ( nc ; x S k ) K∏ k′=k+1 ( 1− Vk′ ( nc ; Φ ) ) . ( 1 ) 2.2 APPROXIMATE FRAMES VIA COMPOSITING . The next step in our pipeline deals with generating the video inputs that the controller network is expected to receive from a modified environment for given parameter values Φ . These frames will represent views of the environment , including the surface with the painted figures , from a sequence of viewpoints as the car drives through the scene . Of course , the precise viewpoint sequence will depend on the trajectory of the car , which will depend on the control outputs from the network , that in turn depends on the frames . Instead of modeling the precise trajectory for every modification , we instead consider a small set of T representative trajectories , corresponding to those that the vehicle will follow when driven with small perturbations around control signals the network outputs , when operating in the unmodified environment . In our experiments , we use T = 4 trajectories : one from driving the car with the actual output control signals , and three from random noise added to these outputs . Given the fact that actual control is closed-loop , it is not evident that this simple approach would work ; however , our experiments below show that it is remarkably effective , despite its simplicity . This gives T sequences of video frames , one for each trajectory , where we assume each sequence contains F frames . We let Ĩtf ( n ) denote the f th “ clean ” image in the tth sequence , representing a view of the environment without any modifications . Here , n ∈ Z2 indexes pixel location within each image , and the intensity vector Ĩtf ( n ) ∈ R3 at each location corresponding to the recorded RGB values . These clean images can be obtained by driving the car—actually , or in simulation—in the original environment . For each frame in each sequence , we also determine a spatial mapping nc = Gtf ( n ) that maps pixel locations in the image to the canonical view . We model each Gtf ( n ) as a homography : the parameters of which can be determined by either using correspondences between each image and the canonical view of the surface—from calibration patterns rendered using the simulator , or from user input—or by calibrating the vehicle ’ s camera and making accurate measurements of ego-motion when the vehicle is being driven . Additionally , we also determine color mapping parameters Ctf ∈ R3×3 , btf ∈ R3 for each frame representing an approximate linear relationship between the RGB colors xC of the painted figures , and their colors as visible in each frame . These parameters are also determined through calibration . Given this set of clean frames and the geometric and color mapping parameters , we generate corresponding frames with views of the modified environment simply as : Itf ( n ; Φ ) = ( 1− K∑ k=1 Vk ( G t f ( n ) ; Φ ) ) Ĩtf ( n ) + K∑ k=1 Vk ( G t f ( n ) ; Φ ) ( Ctfx C k + b t f ) . ( 2 ) | The paper proposes an end-to-end differentiable method for finding adversarial patterns to be added to the environment for autonomous driving. It utilizes image composition with homography thus it can compose the adversarial pattern into the image frames of all image frames of a driving sequence. Combined with a neural-network based controller which outputs the steering angle, the proposed method can find adversarial examples more efficiently comparing to a Bayesian optimization(BO) based baseline while resulting in trajectories with greater deviation. | SP:1b685c4f7f4b3f02bda928ec42ae68d43d0e2668 |
Finding Physical Adversarial Examples for Autonomous Driving with Fast and Differentiable Image Compositing | 1 INTRODUCTION . Computer vision has made revolutionary advances in recent years by leveraging a combination of deep neural network architectures with abundant high-quality perceptual data . One of the transformative applications of computational perception is autonomous driving , with autonomous cars and trucks already being evaluated for use in geofenced settings , and partial autonomy , such as highway assistance , leveraging state-of-the-art perception embedded in vehicles available to consumers . However , a history of tragic crashes involving autonomous driving , most notably Tesla ( Thorbecke , 2020 ) and Uber ( Hawkins , 2019 ) reveals that modern perceptual architectures still have some limitations even in non-adversarial driving environments . In addition , and more concerning , is the increasing abundance of evidence that state-of-the-art deep neural networks used in perception tasks are highly vulnerable to adversarial perturbations , or imperceptible noise that is added to an input image and deliberately designed to cause misclassification ( Goodfellow et al. , 2014 ; Yuan et al. , 2019 ; Modas et al. , 2020 ) . Furthermore , several lines of work consider specifically physical adversarial examples which modify the scene being captured by a camera , rather than the image ( Kurakin et al. , 2016 ; Eykholt et al. , 2018 ; Sitawarin et al. , 2018 ; Dutta , 2018 ; Duan et al. , 2020 ) . Despite this body of evidence demonstrating vulnerabilities in deep neural network perceptual architectures , it is nevertheless not evident that such vulnerabilities are consequential in realistic autonomous driving , even if primarily using cameras for perception . First , most such attacks involve independent perturbations to a given input image . Autonomous driving is a dynamical system , so that a fixed adversarial perturbation to a scene is perceived through a series of distinct , but highly interdependent perspectives . Second , self-driving is a complex system that maps perceptual inputs to control outputs . Consequently , even if we succeed in causing the control outputs to deviate from normal , the vehicle will now perceive a sequence of frames that is different from those encountered on its normal path , and typically deploy self-correcting behavior in response . For example , if the vehicle is driving straight and then begins swerving towards the opposite lane , its own perception will inform the control that it ’ s going in the wrong direction , and the controller will steer it back on course . To address these limitations , Bayesian Optimization ( BO ) ( Archetti and Candelieri , 2019 ) was recently proposed as a way to design physical adversarial examples ( 2 black rectangles on road pavement ) in Carla autonomous driving simulations ( Dosovitskiy et al. , 2017 ) against end-to-end autonomous driving architectures ( Boloor et al. , 2020 ) . The key challenge with this approach , however , is that attack design must execute actual experiments ( e.g. , simulations , or actual driving ) for a larger number of iterations ( 1000 in the work above ) , making it impractical for large-scale or physical driving evaluation . Furthermore , it is not clear how well BO scales as we increase the complexity of the adversarial space beyond 2 black rectangles . We propose a highly scalable framework for designing physically realizable adversarial examples against end-to-end autonomous driving architectures . Our framework is illustrated in Figure 1 , and develops a differentiable pipeline for digitally approximating driving scenarios . The proposed approximation makes use of image compositing , learning homography and color mappings from a birds-eye view of embedded adversarial examples to projections of these in images based on actual driving frames , and sampling sequences of actual frames with small added random noise to control to ensure adequate sampling of possible perspectives . The entire process can then be fed into automatic differentiators to obtain adversarial examples that maximize a car ’ s deviation from its normal sequence of controls ( e.g. , steering angle ) for a target driving scenario . We evaluate the proposed framework using Carla simulations in comparison with the state-of-the-art BO method . Our experiments show that the resulting attacks are significantly stronger , with effects on induced deviations and road infractions often considerably outperforming BO , at a small fraction of actual driving runs required for training . Furthermore , we show that our approach yields attacks that are robust to unforeseen variations in weather and visibility . Related Work : Attacks on deep neural networks for computer vision tasks has been a subject of extensive prior research ( Goodfellow et al. , 2014 ; Yuan et al. , 2019 ; Modas et al. , 2020 ; Vorobeychik and Kantarcioglu , 2018 ) . The most common variation introduces imperceptible noise to pixels of an image in order to induce error in predictions , such as misclassification of the image or failure to detect an object in it . A more recent line of research has investigated physical adversarial examples ( Kurakin et al. , 2016 ; Athalye et al. , 2017 ; Eykholt et al. , 2018 ; Sitawarin et al. , 2018 ; Dutta , 2018 ; Duan et al. , 2020 ) , where the explicit goal is to implement these in the physical scene , so that the images of the scene subsequently captured by the camera and fed into a deep neural network result in a prediction error . In a related effort , Liu et al . ( 2019 ) developed a differentiable renderer that allows the attacker to devise higher-level perturbations of an image scene , such as geometry and lighting , through a differentiable renderer . However , most of these approaches attack a fixed input scene , whereas autonomous driving is a complex dynamical system . Several recent approaches investigate physical attacks on autonomous driving that attempt to account for the fact that a single object is modified and viewed through a series of frames ( Ackerman , 2019 ; Kong et al. , 2020 ; Boloor et al. , 2020 ) . However , these either still consider digital attacks , albeit restricted to a small area ( e.g. , replacing a road sign with a noisy road sign ) and do not consider a vehicles self-correcting behavior ( for example , ( Kong et al. , 2020 ) ) , or rely on many expensive driving experiments in order to identify adversarial patterns ( Boloor et al. , 2020 ) . 2 PROPOSED METHOD . Autonomous driving systems are equipped with decision algorithms that produce control signals for a vehicle , based on high-level instructions—such as a given route or destination—and inputs from cameras and other sensors that make continuous measurements of the vehicle ’ s physical environment . We assume the decision algorithm is in the form of a differentiable function—such as a neural network—that maps video frames from the camera , along with other inputs , to the control outputs . Given such a network or function , our goal is to determine if it is vulnerable to attack . Specifically , we seek to build a scalable and efficient method to find modifications that can be applied to the physical environment , and result in a stream of video frames which cause the control network to produce output signals that disrupt the vehicle ’ s operation , moving it away from the expected ideal trajectory . This task is challenging since the relationship between modifications to the physical environment and the network ’ s inputs is complex : the video frames correspond to images of the environment from a sequence of changing viewpoints , where the sequence itself depends on the network ’ s control outputs . The precise effect of any given modification can be determined only by actually driving the vehicle in the modified environment , or by using a high-quality simulator with a sophisticated physics engine . However , it is expensive to use actual driving or an expensive simulator when searching for the right modification , since neither process is differentiable with respect to parameters of the modification , and would require repeated trials with candidate modifications in every step of the search process . Instead , we propose a fast approximation to produce video frames for a given environment given a candidate modification that is differentiable with respect to parameters of the modification . Our approach requires a small number of initial calibration runs—of actual driving or a sophisticated simulator—after which , the search for optimal parameters can be carried out with end-to-end gradientbased optimization . Specifically , we consider the case when the modification takes the form of figures ( such as rectangles ) drawn on a restricted stretch of the road , and task the optimization with finding their optimal shape and color so as to maximize deviation from the controller ’ s trajectory prior to modification . We now describe our model for the physical modification , our approximate mapping to create video frames for a given modification , and our optimization approach based on this mapping . 2.1 PARAMETERIZED PHYSICAL MODIFICATION . We assume modifications are in the form of a collection of K figures ( e.g. , rectangles ) that will be painted on a flat surface in the environment ( e.g. , road ) . Let Φ = { xSk , xCk } Kk=1 denote the parameters of this modification , with xSk corresponding to the shape parameters , and x C k the RGB color , of the kth figure . These parameters are defined with respect to co-ordinates in some canonical—say , top-down—view of the surface . We let M ( nc ; xS ) denote a scalar-valued mask that represents whether a pixel at spatial location nc ∈ Z2 in the canonical view is within a figure with shape parameters xS . This function depends simply on the chosen geometry of the figures , and has value of 1 for pixels within the figure , 0 for those outside , and real values between 0 and 1 for those near the boundary ( representing partial occupancy on a discrete pixel grid to prevent aliasing artifacts ) . Since the spatial extents for different figures may overlap , we next account for occlusions by assuming that the lines will be painted in order . Accordingly , we define a series of visibility functions Vk ( nc ; Φ ) , each representing the visibility of the kth figure at pixel nc , after accounting for occlusions . We set the function for the last figure as VK ( nc ; Φ ) = M ( nc ; xSK ) , and for the other figures with k < K , Vk ( nc ; Φ ) = M ( nc ; x S k ) K∏ k′=k+1 ( 1− Vk′ ( nc ; Φ ) ) . ( 1 ) 2.2 APPROXIMATE FRAMES VIA COMPOSITING . The next step in our pipeline deals with generating the video inputs that the controller network is expected to receive from a modified environment for given parameter values Φ . These frames will represent views of the environment , including the surface with the painted figures , from a sequence of viewpoints as the car drives through the scene . Of course , the precise viewpoint sequence will depend on the trajectory of the car , which will depend on the control outputs from the network , that in turn depends on the frames . Instead of modeling the precise trajectory for every modification , we instead consider a small set of T representative trajectories , corresponding to those that the vehicle will follow when driven with small perturbations around control signals the network outputs , when operating in the unmodified environment . In our experiments , we use T = 4 trajectories : one from driving the car with the actual output control signals , and three from random noise added to these outputs . Given the fact that actual control is closed-loop , it is not evident that this simple approach would work ; however , our experiments below show that it is remarkably effective , despite its simplicity . This gives T sequences of video frames , one for each trajectory , where we assume each sequence contains F frames . We let Ĩtf ( n ) denote the f th “ clean ” image in the tth sequence , representing a view of the environment without any modifications . Here , n ∈ Z2 indexes pixel location within each image , and the intensity vector Ĩtf ( n ) ∈ R3 at each location corresponding to the recorded RGB values . These clean images can be obtained by driving the car—actually , or in simulation—in the original environment . For each frame in each sequence , we also determine a spatial mapping nc = Gtf ( n ) that maps pixel locations in the image to the canonical view . We model each Gtf ( n ) as a homography : the parameters of which can be determined by either using correspondences between each image and the canonical view of the surface—from calibration patterns rendered using the simulator , or from user input—or by calibrating the vehicle ’ s camera and making accurate measurements of ego-motion when the vehicle is being driven . Additionally , we also determine color mapping parameters Ctf ∈ R3×3 , btf ∈ R3 for each frame representing an approximate linear relationship between the RGB colors xC of the painted figures , and their colors as visible in each frame . These parameters are also determined through calibration . Given this set of clean frames and the geometric and color mapping parameters , we generate corresponding frames with views of the modified environment simply as : Itf ( n ; Φ ) = ( 1− K∑ k=1 Vk ( G t f ( n ) ; Φ ) ) Ĩtf ( n ) + K∑ k=1 Vk ( G t f ( n ) ; Φ ) ( Ctfx C k + b t f ) . ( 2 ) | This paper proposes a scalable and efficient approach for finding adversarial physical modification to the video inputs of autonomous driving. Assuming the perturbations are in form of a collection of several rectangles, the model parameterizes the physical modifications. By simply ignoring the closed-loop of viewpoint sequence and frames, the model directly creating adversarial frames with compositing methods. Some approximated algorithms are used to ensure the model can be optimized by the gradient-based method. With the improvement above, the iteration speed of the model is greatly improved. | SP:1b685c4f7f4b3f02bda928ec42ae68d43d0e2668 |
Rethinking Attention with Performers | 1 INTRODUCTION AND RELATED WORK . Transformers ( Vaswani et al. , 2017 ; Dehghani et al. , 2019 ) are powerful neural network architectures that have become SOTA in several areas of machine learning including natural language processing ( NLP ) ( e.g . speech recognition ( Luo et al. , 2020 ) ) , neural machine translation ( NMT ) ( Chen et al. , 2018 ) , document generation/summarization , time series prediction , generative modeling ( e.g . image generation ( Parmar et al. , 2018 ) ) , music generation ( Huang et al. , 2019 ) , and bioinformatics ( Rives et al. , 2019 ; Madani et al. , 2020 ; Ingraham et al. , 2019 ; Elnaggar et al. , 2019 ; Du et al. , 2020 ) . Transformers rely on a trainable attention mechanism that identifies complex dependencies between the elements of each input sequence . Unfortunately , the regular Transformer scales quadratically with the number of tokens L in the input sequence , which is prohibitively expensive for large L and precludes its usage in settings with limited computational resources even for moderate values of L. Several solutions have been proposed to address this issue ( Beltagy et al. , 2020 ; Gulati et al. , 2020 ; Chan et al. , 2020 ; Child et al. , 2019 ; Bello et al. , 2019 ) . Most approaches restrict the attention mechanism to attend to local neighborhoods ( Parmar et al. , 2018 ) or incorporate structural priors on attention such as sparsity ( Child et al. , 2019 ) , pooling-based compression ( Rae et al. , 2020 ) clustering/binning/convolution techniques ( e.g . ( Roy et al. , 2020 ) which applies k-means clustering to learn dynamic sparse attention regions , or ( Kitaev et al. , 2020 ) , where locality sensitive hashing is used to group together tokens of similar embeddings ) , sliding windows ( Beltagy et al. , 2020 ) , or truncated targeting ( Chelba et al. , 2020 ) . There is also a long line of research on using dense attention matrices , but defined by low-rank kernels substituting softmax ( Katharopoulos et al. , 2020 ; Shen et al. , 2018 ) . Those methods critically rely on kernels admitting explicit representations as dot-products of finite positive-feature vectors . The approaches above do not aim to approximate regular attention , but rather propose simpler and more tractable attention mechanisms , often by incorporating additional constraints ( e.g . identical query and key sets as in ( Kitaev et al. , 2020 ) ) , or by trading regular with sparse attention using more ∗Equal contribution . Correspondence to { kchoro , lcolwell } @ google.com . Code for Transformer models on protein data can be found in github.com/google-research/ google-research/tree/master/protein_lm and Performer code can be found in github.com/ google-research/google-research/tree/master/performer . Google AI Blog : https : // ai.googleblog.com/2020/10/rethinking-attention-with-performers.html layers ( Child et al. , 2019 ) . Unfortunately , there is a lack of rigorous guarantees for the representation power produced by such methods , and sometimes the validity of sparsity patterns can only be verified empirically through trial and error by constructing special GPU operations ( e.g . either writing C++ CUDA kernels ( Child et al. , 2019 ) or using TVMs ( Beltagy et al. , 2020 ) ) . Other techniques which aim to reduce Transformers ’ space complexity include reversible residual layers allowing one-time activation storage in training ( Kitaev et al. , 2020 ) and shared attention weights ( Xiao et al. , 2019 ) . These constraints may impede application to long-sequence problems , where approximations of the attention mechanism are not sufficient . Approximations based on truncated back-propagation ( Dai et al. , 2019 ) are also unable to capture long-distance correlations since the gradients are only propagated inside a localized window . Other methods propose biased estimation of regular attention but only in the non-causal setting and with large mean squared error ( Wang et al. , 2020 ) . In response , we introduce the first Transformer architectures , Performers , capable of provably accurate and practical estimation of regular ( softmax ) full-rank attention , but of only linear space and time complexity and not relying on any priors such as sparsity or low-rankness . Performers use the Fast Attention Via positive Orthogonal Random features ( FAVOR+ ) mechanism , leveraging new methods for approximating softmax and Gaussian kernels , which we propose . We believe these methods are of independent interest , contributing to the theory of scalable kernel methods . Consequently , Performers are the first linear architectures fully compatible ( via small amounts of fine-tuning ) with regular Transformers , providing strong theoretical guarantees : unbiased or nearly-unbiased estimation of the attention matrix , uniform convergence and lower variance of the approximation . FAVOR+ can be also applied to efficiently model other kernelizable attention mechanisms beyond softmax . This representational power is crucial to accurately compare softmax with other kernels for the first time on large-scale tasks , that are beyond the reach of regular Transformers , and find for them optimal attention-kernels . FAVOR+ can also be applied beyond the Transformer scope as a more scalable replacement for regular attention , which itself has a wide variety of uses in computer vision ( Fu et al. , 2019 ) , reinforcement learning ( Zambaldi et al. , 2019 ) , training with softmax cross entropy loss , and even combinatorial optimization ( Vinyals et al. , 2015 ) . We test Performers on a rich set of tasks ranging from pixel-prediction through text models to protein sequence modeling . We demonstrate competitive results with other examined efficient sparse and dense attention methods , showcasing the effectiveness of the novel attention-learning paradigm leveraged by Performers . We emphasize that in principle , FAVOR+ can also be combined with other techniques , such as reversible layers ( Kitaev et al. , 2020 ) or cluster-based attention ( Roy et al. , 2020 ) . 2 FAVOR+ MECHANISM & POSITIVE ORTHOGONAL RANDOM FEATURES . Below we describe in detail the FAVOR+ mechanism - the backbone of the Performer′s architecture . We introduce a new method for estimating softmax ( and Gaussian ) kernels with positive orthogonal random features which FAVOR+ leverages for the robust and unbiased estimation of regular ( softmax ) attention and show how FAVOR+ can be applied for other attention-kernels . 2.1 PRELIMINARIES - REGULAR ATTENTION MECHANISM . Let L be the size of an input sequence of tokens . Then regular dot-product attention ( Vaswani et al. , 2017 ) is a mapping which accepts matrices Q , K , V ∈ RL×d as input where d is the hidden dimension ( dimension of the latent representation ) . Matrices Q , K , V are intermediate representations of the input and their rows can be interpreted as queries , keys and values of the continuous dictionary data structure respectively . Bidirectional ( or non-directional ( Devlin et al. , 2018 ) ) dot-product attention has the following form , where A ∈ RL×L is the so-called attention matrix : Att↔ ( Q , K , V ) = D −1AV , A = exp ( QK > / √ d ) , D = diag ( A1L ) . ( 1 ) Here exp ( · ) is applied elementwise , 1L is the all-ones vector of length L , and diag ( · ) is a diagonal matrix with the input vector as the diagonal . Time and space complexity of computing ( 1 ) are O ( L2d ) and O ( L2 + Ld ) respectively , because A has to be stored explicitly . Hence , in principle , dot-product attention of type ( 1 ) is incompatible with end-to-end processing of long sequences . Bidirectional attention is applied in encoder self-attention and encoder-decoder attention in Seq2Seq architectures . Another important type of attention is unidirectional dot-product attention which has the form : Att→ ( Q , K , V ) = D̃ −1ÃV , Ã = tril ( A ) , D̃ = diag ( Ã1L ) , ( 2 ) where tril ( · ) returns the lower-triangular part of the argument matrix including the diagonal . As discussed in ( Vaswani et al. , 2017 ) , unidirectional attention is used for autoregressive generative modelling , e.g . as self-attention in generative Transformers as well as the decoder part of Seq2Seq Transformers . We will show that attention matrix A can be approximated up to any precision in time O ( Ld2 log ( d ) ) . For comparison , popular methods leveraging sparsity via Locality-Sensitive Hashing ( LSH ) techniques ( Kitaev et al. , 2020 ) have O ( Ld2 logL ) time complexity . In the main body of the paper we will describe FAVOR+ for bidirectional attention . Completely analogous results can be obtained for the unidirectional variant via the mechanism of prefix-sums ( all details in the Appendix B.1 ) . 2.2 GENERALIZED KERNELIZABLE ATTENTION . FAVOR+ works for attention blocks using matrices A ∈ RL×L of the form A ( i , j ) = K ( q > i , k > j ) , with qi/kj standing for the ith/jth query/key row-vector in Q/K and kernel K : Rd × Rd → R+ defined for the ( usually randomized ) mapping : φ : Rd → Rr+ ( for some r > 0 ) as : K ( x , y ) = E [ φ ( x ) > φ ( y ) ] . ( 3 ) We call φ ( u ) a random feature map for u ∈ Rd . For Q′ , K′ ∈ RL×r with rows given as φ ( q > i ) > and φ ( k > i ) > respectively , Equation 3 leads directly to the efficient attention mechanism of the form : Âtt↔ ( Q , K , V ) = D̂ −1 ( Q′ ( ( K′ ) > V ) ) , D̂ = diag ( Q′ ( ( K′ ) > 1L ) ) . ( 4 ) Here Âtt↔ stands for the approximate attention and brackets indicate the order of computations . It is easy to see that such a mechanism is characterized by space complexity O ( Lr + Ld+ rd ) and time complexity O ( Lrd ) as opposed to O ( L2 + Ld ) and O ( L2d ) of the regular attention ( see also Fig . 1 ) . The above scheme constitutes the FA-part of the FAVOR+ mechanism . The remaining OR+ part answers the following questions : ( 1 ) How expressive is the attention model defined in Equation 3 , and in particular , can we use it in principle to approximate regular softmax attention ? ( 2 ) How do we implement it robustly in practice , and in particular , can we choose r L for L d to obtain desired space and time complexity gains ? We answer these questions in the next sections . 2.3 HOW TO AND HOW NOT TO APPROXIMATE SOFTMAX-KERNELS FOR ATTENTION . It turns out that by taking φ of the following form for functions f1 , ... , fl : R → R , function g : Rd → R and deterministic vectors ωi or ω1 , ... , ωm iid∼ D for some distribution D ∈ P ( Rd ) : φ ( x ) = h ( x ) √ m ( f1 ( ω > 1 x ) , ... , f1 ( ω > mx ) , ... , fl ( ω > 1 x ) , ... , fl ( ω > mx ) ) , ( 5 ) we can model most kernels used in practice . Furthermore , in most cases D is isotropic ( i.e . with pdf function constant on a sphere ) , usually Gaussian . For example , by taking h ( x ) = 1 , l = 1 and D = N ( 0 , Id ) we obtain estimators of the so-called PNG-kernels ( Choromanski et al. , 2017 ) ( e.g . f1 = sgn corresponds to the angular kernel ) . Configurations : h ( x ) = 1 , l = 2 , f1 = sin , f2 = cos correspond to shift-invariant kernels , in particular D = N ( 0 , Id ) leads to the Gaussian kernel Kgauss ( Rahimi & Recht , 2007 ) . The softmax-kernel which defines regular attention matrix A is given as : SM ( x , y ) def = exp ( x > y ) . ( 6 ) In the above , without loss of generality , we omit √ d-renormalization since we can equivalently renormalize input keys and queries . Since : SM ( x , y ) = exp ( ‖x‖ 2 2 ) Kgauss ( x , y ) exp ( ‖y‖2 2 ) , based on what we have said , we obtain random feature map unbiased approximation of SM ( x , y ) using trigonometric functions with : h ( x ) = exp ( ‖x‖ 2 2 ) , l = 2 , f1 = sin , f2 = cos. We call it ŜM trig m ( x , y ) . There is however a caveat there . The attention module from ( 1 ) constructs for each token , a convex combination of value-vectors with coefficients given as corresponding renormalized kernel scores . That is why kernels producing non-negative scores are used . Applying random feature maps with potentially negative dimension-values ( sin / cos ) leads to unstable behaviours , especially when kernel scores close to 0 ( which is the case for many entries of A corresponding to low relevance tokens ) are approximated by estimators with large variance in such regions . This results in abnormal behaviours , e.g . negative-diagonal-values renormalizers D−1 , and consequently either completely prevents training or leads to sub-optimal models . We demonstrate empirically that this is what happens for ŜM trig m and provide detailed theoretical explanations showing that the variance of ŜM trig m is large as approximated values tend to 0 ( see : Section 3 ) . This is one of the main reasons why the robust random feature map mechanism for approximating regular softmax attention was never proposed . We propose a robust mechanism in this paper . Furthermore , the variance of our new unbiased positive random feature map estimator tends to 0 as approximated values tend to 0 ( see : Section 3 ) . Lemma 1 ( Positive Random Features ( PRFs ) for Softmax ) . For x , y ∈ Rd , z = x + y we have : SM ( x , y ) = Eω∼N ( 0 , Id ) [ exp ( ω > x−‖x‖ 2 2 ) exp ( ω > y−‖y‖ 2 2 ) ] = ΛEω∼N ( 0 , Id ) cosh ( ω > z ) , ( 7 ) where Λ = exp ( −‖x‖ 2+‖y‖2 2 ) and cosh is hyperbolic cosine . Consequently , softmax-kernel admits a positive random feature map unbiased approximation with h ( x ) = exp ( −‖x‖ 2 2 ) , l = 1 , f1 = exp and D = N ( 0 , Id ) or : h ( x ) = 1√2 exp ( − ‖x‖2 2 ) , l = 2 , f1 ( u ) = exp ( u ) , f2 ( u ) = exp ( −u ) and the same D ( the latter for further variance reduction ) . We call related estimators : ŜM + m and ŜM hyp+ m . In Fig . 2 we visualize the advantages of positive versus standard trigonometric random features . In critical regions , where kernel values are small and need careful approximation , our method outperforms its counterpart . In Section 4 we further confirm our method ’ s advantages empirically , using positive features to efficiently train softmax-based linear Transformers . If we replace in ( 7 ) ω with√ d ω‖ω‖ , we obtain the so-called regularized softmax-kernel SMREG which we can approximate in a similar manner , simply changing D = N ( 0 , Id ) to D = Unif ( √ dSd−1 ) , a distribution corresponding to Haar measure on the sphere of radius √ d in Rd , obtaining estimator ̂SMREG + m. As we show in Section 3 , such random features can also be used to accurately approximate regular softmax-kernel . | The authors propose to use the kernel feature map self-attention formulation introduced in [1] to efficiently approximate the softmax attention. The main contribution of the paper lies in the proposed _positive random features_ that can approximate softmax with a strictly positive feature map without which the training is unstable. The authors also show that an approximation of softmax is not necessary for good performance and actually use ReLU random features to achieve their best results when training from scratch. | SP:cb35385634bc2ba2381921b491176a5309e754dd |
Rethinking Attention with Performers | 1 INTRODUCTION AND RELATED WORK . Transformers ( Vaswani et al. , 2017 ; Dehghani et al. , 2019 ) are powerful neural network architectures that have become SOTA in several areas of machine learning including natural language processing ( NLP ) ( e.g . speech recognition ( Luo et al. , 2020 ) ) , neural machine translation ( NMT ) ( Chen et al. , 2018 ) , document generation/summarization , time series prediction , generative modeling ( e.g . image generation ( Parmar et al. , 2018 ) ) , music generation ( Huang et al. , 2019 ) , and bioinformatics ( Rives et al. , 2019 ; Madani et al. , 2020 ; Ingraham et al. , 2019 ; Elnaggar et al. , 2019 ; Du et al. , 2020 ) . Transformers rely on a trainable attention mechanism that identifies complex dependencies between the elements of each input sequence . Unfortunately , the regular Transformer scales quadratically with the number of tokens L in the input sequence , which is prohibitively expensive for large L and precludes its usage in settings with limited computational resources even for moderate values of L. Several solutions have been proposed to address this issue ( Beltagy et al. , 2020 ; Gulati et al. , 2020 ; Chan et al. , 2020 ; Child et al. , 2019 ; Bello et al. , 2019 ) . Most approaches restrict the attention mechanism to attend to local neighborhoods ( Parmar et al. , 2018 ) or incorporate structural priors on attention such as sparsity ( Child et al. , 2019 ) , pooling-based compression ( Rae et al. , 2020 ) clustering/binning/convolution techniques ( e.g . ( Roy et al. , 2020 ) which applies k-means clustering to learn dynamic sparse attention regions , or ( Kitaev et al. , 2020 ) , where locality sensitive hashing is used to group together tokens of similar embeddings ) , sliding windows ( Beltagy et al. , 2020 ) , or truncated targeting ( Chelba et al. , 2020 ) . There is also a long line of research on using dense attention matrices , but defined by low-rank kernels substituting softmax ( Katharopoulos et al. , 2020 ; Shen et al. , 2018 ) . Those methods critically rely on kernels admitting explicit representations as dot-products of finite positive-feature vectors . The approaches above do not aim to approximate regular attention , but rather propose simpler and more tractable attention mechanisms , often by incorporating additional constraints ( e.g . identical query and key sets as in ( Kitaev et al. , 2020 ) ) , or by trading regular with sparse attention using more ∗Equal contribution . Correspondence to { kchoro , lcolwell } @ google.com . Code for Transformer models on protein data can be found in github.com/google-research/ google-research/tree/master/protein_lm and Performer code can be found in github.com/ google-research/google-research/tree/master/performer . Google AI Blog : https : // ai.googleblog.com/2020/10/rethinking-attention-with-performers.html layers ( Child et al. , 2019 ) . Unfortunately , there is a lack of rigorous guarantees for the representation power produced by such methods , and sometimes the validity of sparsity patterns can only be verified empirically through trial and error by constructing special GPU operations ( e.g . either writing C++ CUDA kernels ( Child et al. , 2019 ) or using TVMs ( Beltagy et al. , 2020 ) ) . Other techniques which aim to reduce Transformers ’ space complexity include reversible residual layers allowing one-time activation storage in training ( Kitaev et al. , 2020 ) and shared attention weights ( Xiao et al. , 2019 ) . These constraints may impede application to long-sequence problems , where approximations of the attention mechanism are not sufficient . Approximations based on truncated back-propagation ( Dai et al. , 2019 ) are also unable to capture long-distance correlations since the gradients are only propagated inside a localized window . Other methods propose biased estimation of regular attention but only in the non-causal setting and with large mean squared error ( Wang et al. , 2020 ) . In response , we introduce the first Transformer architectures , Performers , capable of provably accurate and practical estimation of regular ( softmax ) full-rank attention , but of only linear space and time complexity and not relying on any priors such as sparsity or low-rankness . Performers use the Fast Attention Via positive Orthogonal Random features ( FAVOR+ ) mechanism , leveraging new methods for approximating softmax and Gaussian kernels , which we propose . We believe these methods are of independent interest , contributing to the theory of scalable kernel methods . Consequently , Performers are the first linear architectures fully compatible ( via small amounts of fine-tuning ) with regular Transformers , providing strong theoretical guarantees : unbiased or nearly-unbiased estimation of the attention matrix , uniform convergence and lower variance of the approximation . FAVOR+ can be also applied to efficiently model other kernelizable attention mechanisms beyond softmax . This representational power is crucial to accurately compare softmax with other kernels for the first time on large-scale tasks , that are beyond the reach of regular Transformers , and find for them optimal attention-kernels . FAVOR+ can also be applied beyond the Transformer scope as a more scalable replacement for regular attention , which itself has a wide variety of uses in computer vision ( Fu et al. , 2019 ) , reinforcement learning ( Zambaldi et al. , 2019 ) , training with softmax cross entropy loss , and even combinatorial optimization ( Vinyals et al. , 2015 ) . We test Performers on a rich set of tasks ranging from pixel-prediction through text models to protein sequence modeling . We demonstrate competitive results with other examined efficient sparse and dense attention methods , showcasing the effectiveness of the novel attention-learning paradigm leveraged by Performers . We emphasize that in principle , FAVOR+ can also be combined with other techniques , such as reversible layers ( Kitaev et al. , 2020 ) or cluster-based attention ( Roy et al. , 2020 ) . 2 FAVOR+ MECHANISM & POSITIVE ORTHOGONAL RANDOM FEATURES . Below we describe in detail the FAVOR+ mechanism - the backbone of the Performer′s architecture . We introduce a new method for estimating softmax ( and Gaussian ) kernels with positive orthogonal random features which FAVOR+ leverages for the robust and unbiased estimation of regular ( softmax ) attention and show how FAVOR+ can be applied for other attention-kernels . 2.1 PRELIMINARIES - REGULAR ATTENTION MECHANISM . Let L be the size of an input sequence of tokens . Then regular dot-product attention ( Vaswani et al. , 2017 ) is a mapping which accepts matrices Q , K , V ∈ RL×d as input where d is the hidden dimension ( dimension of the latent representation ) . Matrices Q , K , V are intermediate representations of the input and their rows can be interpreted as queries , keys and values of the continuous dictionary data structure respectively . Bidirectional ( or non-directional ( Devlin et al. , 2018 ) ) dot-product attention has the following form , where A ∈ RL×L is the so-called attention matrix : Att↔ ( Q , K , V ) = D −1AV , A = exp ( QK > / √ d ) , D = diag ( A1L ) . ( 1 ) Here exp ( · ) is applied elementwise , 1L is the all-ones vector of length L , and diag ( · ) is a diagonal matrix with the input vector as the diagonal . Time and space complexity of computing ( 1 ) are O ( L2d ) and O ( L2 + Ld ) respectively , because A has to be stored explicitly . Hence , in principle , dot-product attention of type ( 1 ) is incompatible with end-to-end processing of long sequences . Bidirectional attention is applied in encoder self-attention and encoder-decoder attention in Seq2Seq architectures . Another important type of attention is unidirectional dot-product attention which has the form : Att→ ( Q , K , V ) = D̃ −1ÃV , Ã = tril ( A ) , D̃ = diag ( Ã1L ) , ( 2 ) where tril ( · ) returns the lower-triangular part of the argument matrix including the diagonal . As discussed in ( Vaswani et al. , 2017 ) , unidirectional attention is used for autoregressive generative modelling , e.g . as self-attention in generative Transformers as well as the decoder part of Seq2Seq Transformers . We will show that attention matrix A can be approximated up to any precision in time O ( Ld2 log ( d ) ) . For comparison , popular methods leveraging sparsity via Locality-Sensitive Hashing ( LSH ) techniques ( Kitaev et al. , 2020 ) have O ( Ld2 logL ) time complexity . In the main body of the paper we will describe FAVOR+ for bidirectional attention . Completely analogous results can be obtained for the unidirectional variant via the mechanism of prefix-sums ( all details in the Appendix B.1 ) . 2.2 GENERALIZED KERNELIZABLE ATTENTION . FAVOR+ works for attention blocks using matrices A ∈ RL×L of the form A ( i , j ) = K ( q > i , k > j ) , with qi/kj standing for the ith/jth query/key row-vector in Q/K and kernel K : Rd × Rd → R+ defined for the ( usually randomized ) mapping : φ : Rd → Rr+ ( for some r > 0 ) as : K ( x , y ) = E [ φ ( x ) > φ ( y ) ] . ( 3 ) We call φ ( u ) a random feature map for u ∈ Rd . For Q′ , K′ ∈ RL×r with rows given as φ ( q > i ) > and φ ( k > i ) > respectively , Equation 3 leads directly to the efficient attention mechanism of the form : Âtt↔ ( Q , K , V ) = D̂ −1 ( Q′ ( ( K′ ) > V ) ) , D̂ = diag ( Q′ ( ( K′ ) > 1L ) ) . ( 4 ) Here Âtt↔ stands for the approximate attention and brackets indicate the order of computations . It is easy to see that such a mechanism is characterized by space complexity O ( Lr + Ld+ rd ) and time complexity O ( Lrd ) as opposed to O ( L2 + Ld ) and O ( L2d ) of the regular attention ( see also Fig . 1 ) . The above scheme constitutes the FA-part of the FAVOR+ mechanism . The remaining OR+ part answers the following questions : ( 1 ) How expressive is the attention model defined in Equation 3 , and in particular , can we use it in principle to approximate regular softmax attention ? ( 2 ) How do we implement it robustly in practice , and in particular , can we choose r L for L d to obtain desired space and time complexity gains ? We answer these questions in the next sections . 2.3 HOW TO AND HOW NOT TO APPROXIMATE SOFTMAX-KERNELS FOR ATTENTION . It turns out that by taking φ of the following form for functions f1 , ... , fl : R → R , function g : Rd → R and deterministic vectors ωi or ω1 , ... , ωm iid∼ D for some distribution D ∈ P ( Rd ) : φ ( x ) = h ( x ) √ m ( f1 ( ω > 1 x ) , ... , f1 ( ω > mx ) , ... , fl ( ω > 1 x ) , ... , fl ( ω > mx ) ) , ( 5 ) we can model most kernels used in practice . Furthermore , in most cases D is isotropic ( i.e . with pdf function constant on a sphere ) , usually Gaussian . For example , by taking h ( x ) = 1 , l = 1 and D = N ( 0 , Id ) we obtain estimators of the so-called PNG-kernels ( Choromanski et al. , 2017 ) ( e.g . f1 = sgn corresponds to the angular kernel ) . Configurations : h ( x ) = 1 , l = 2 , f1 = sin , f2 = cos correspond to shift-invariant kernels , in particular D = N ( 0 , Id ) leads to the Gaussian kernel Kgauss ( Rahimi & Recht , 2007 ) . The softmax-kernel which defines regular attention matrix A is given as : SM ( x , y ) def = exp ( x > y ) . ( 6 ) In the above , without loss of generality , we omit √ d-renormalization since we can equivalently renormalize input keys and queries . Since : SM ( x , y ) = exp ( ‖x‖ 2 2 ) Kgauss ( x , y ) exp ( ‖y‖2 2 ) , based on what we have said , we obtain random feature map unbiased approximation of SM ( x , y ) using trigonometric functions with : h ( x ) = exp ( ‖x‖ 2 2 ) , l = 2 , f1 = sin , f2 = cos. We call it ŜM trig m ( x , y ) . There is however a caveat there . The attention module from ( 1 ) constructs for each token , a convex combination of value-vectors with coefficients given as corresponding renormalized kernel scores . That is why kernels producing non-negative scores are used . Applying random feature maps with potentially negative dimension-values ( sin / cos ) leads to unstable behaviours , especially when kernel scores close to 0 ( which is the case for many entries of A corresponding to low relevance tokens ) are approximated by estimators with large variance in such regions . This results in abnormal behaviours , e.g . negative-diagonal-values renormalizers D−1 , and consequently either completely prevents training or leads to sub-optimal models . We demonstrate empirically that this is what happens for ŜM trig m and provide detailed theoretical explanations showing that the variance of ŜM trig m is large as approximated values tend to 0 ( see : Section 3 ) . This is one of the main reasons why the robust random feature map mechanism for approximating regular softmax attention was never proposed . We propose a robust mechanism in this paper . Furthermore , the variance of our new unbiased positive random feature map estimator tends to 0 as approximated values tend to 0 ( see : Section 3 ) . Lemma 1 ( Positive Random Features ( PRFs ) for Softmax ) . For x , y ∈ Rd , z = x + y we have : SM ( x , y ) = Eω∼N ( 0 , Id ) [ exp ( ω > x−‖x‖ 2 2 ) exp ( ω > y−‖y‖ 2 2 ) ] = ΛEω∼N ( 0 , Id ) cosh ( ω > z ) , ( 7 ) where Λ = exp ( −‖x‖ 2+‖y‖2 2 ) and cosh is hyperbolic cosine . Consequently , softmax-kernel admits a positive random feature map unbiased approximation with h ( x ) = exp ( −‖x‖ 2 2 ) , l = 1 , f1 = exp and D = N ( 0 , Id ) or : h ( x ) = 1√2 exp ( − ‖x‖2 2 ) , l = 2 , f1 ( u ) = exp ( u ) , f2 ( u ) = exp ( −u ) and the same D ( the latter for further variance reduction ) . We call related estimators : ŜM + m and ŜM hyp+ m . In Fig . 2 we visualize the advantages of positive versus standard trigonometric random features . In critical regions , where kernel values are small and need careful approximation , our method outperforms its counterpart . In Section 4 we further confirm our method ’ s advantages empirically , using positive features to efficiently train softmax-based linear Transformers . If we replace in ( 7 ) ω with√ d ω‖ω‖ , we obtain the so-called regularized softmax-kernel SMREG which we can approximate in a similar manner , simply changing D = N ( 0 , Id ) to D = Unif ( √ dSd−1 ) , a distribution corresponding to Haar measure on the sphere of radius √ d in Rd , obtaining estimator ̂SMREG + m. As we show in Section 3 , such random features can also be used to accurately approximate regular softmax-kernel . | The paper proposed a theoretically grounded O(N) approximation of the softmax attention. The key idea is to interpret attention as a kernel function and construct the random feature projection that can reproduce this kernel. It is highly non-trivial to derive a feature mapping that can accurately approximate the softmax kernel. To better approximate the softmax kernel, the author proposed some important design choices, all of which are supported by theoretical and empirical evidences. The author showed that 1) adopting non-negative random features is very essential to the approximation and the proposed Positive Random Features (PRF) can effectively reduce the variance when the attention values are small, 2) drawing orthogonal random matrices can further reduce the variance of the approximation, 3) the final proposed Performer model runs faster, takes less memory, and has better performance than other O(N) and O(N logN) attention methods. | SP:cb35385634bc2ba2381921b491176a5309e754dd |
Aligning AI With Shared Human Values | 1 INTRODUCTION . Embedding ethics into AI systems remains an outstanding challenge without any concrete proposal . In popular fiction , the “ Three Laws of Robotics ” plot device illustrates how simplistic rules can not encode the complexity of human values ( Asimov , 1950 ) . Some contemporary researchers argue machine learning improvements need not lead to ethical AI , as raw intelligence is orthogonal to moral behavior ( Armstrong , 2013 ) . Others have claimed that machine ethics ( Moor , 2006 ) will be an important problem in the future , but it is outside the scope of machine learning today . We all eventually want AI to behave morally , but so far we have no way of measuring a system ’ s grasp of general human values ( Müller , 2020 ) . The demand for ethical machine learning ( White House , 2016 ; European Commission , 2019 ) has already led researchers to propose various ethical principles for narrow applications . To make algorithms more fair , researchers have proposed precise mathematical criteria . However , many of these fairness criteria have been shown to be mutually incompatible ( Kleinberg et al. , 2017 ) , and these rigid formalizations are task-specific and have been criticized for being simplistic . To make algorithms more safe , researchers have proposed specifying safety constraints ( Ray et al. , 2019 ) , but in the open world these rules may have many exceptions or require interpretation . To make algorithms prosocial , researchers have proposed imitating temperamental traits such as empathy ( Rashkin et al. , 2019 ; Roller et al. , 2020 ) , but these have been limited to specific character traits in particular application areas such as chatbots ( Krause et al. , 2020 ) . Finally , to make algorithms promote utility , researchers have proposed learning human preferences , but only for closed-world tasks such as movie recommendations ( Koren , 2008 ) or simulated backflips ( Christiano et al. , 2017 ) . In all of this work , the proposed approaches do not address the unique challenges posed by diverse open-world scenarios . Through their work on fairness , safety , prosocial behavior , and utility , researchers have in fact developed proto-ethical methods that resemble small facets of broader theories in normative ethics . Fairness is a concept of justice , which is more broadly composed of concepts like impartiality and desert . Having systems abide by safety constraints is similar to deontological ethics , which determines right and wrong based on a collection of rules . Imitating prosocial behavior and demonstrations is an aspect of virtue ethics , which locates moral behavior in the imitation of virtuous agents . Improving utility by learning human preferences can be viewed as part of utilitarianism , which is a theory that ∗Equal Contribution . advocates maximizing the aggregate well-being of all people . Consequently , many researchers who have tried encouraging some form of “ good ” behavior in systems have actually been applying small pieces of broad and well-established theories in normative ethics . To tie together these separate strands , we propose the ETHICS dataset to assess basic knowledge of ethics and common human values . Unlike previous work , we confront the challenges posed by diverse open-world scenarios , and we cover broadly applicable theories in normative ethics . To accomplish this , we create diverse contextualized natural language scenarios about justice , deontology , virtue ethics , utilitarianism , and commonsense moral judgements . By grounding ETHICS in open-world scenarios , we require models to learn how basic facts about the world connect to human values . For instance , because heat from fire varies with distance , fire can be pleasant or painful , and while everyone coughs , people do not want to be coughed on because it might get them sick . Our contextualized setup captures this type of ethical nuance necessary for a more general understanding of human values . We find that existing natural language processing models pre-trained on vast text corpora and finetuned on the ETHICS dataset have low but promising performance . This suggests that current models have much to learn about the morally salient features in the world , but also that it is feasible to make progress on this problem today . This dataset contains over 130,000 examples and serves as a way to measure , but not load , ethical knowledge . When more ethical knowledge is loaded during model pretraining , the representations may enable a regularizer for selecting good from bad actions in open-world or reinforcement learning settings ( Hausknecht et al. , 2019 ; Hill et al. , 2020 ) , or they may be used to steer text generated by a chatbot . By defining and benchmarking a model ’ s predictive understanding of basic concepts in morality , we facilitate future research on machine ethics . The dataset is available at github.com/hendrycks/ethics . 2 THE ETHICS DATASET . To assess a machine learning system ’ s ability to predict basic human ethical judgements in open-world settings , we introduce the ETHICS dataset . The dataset is based in natural language scenarios , which enables us to construct diverse situations involving interpersonal relationships , everyday events , and thousands of objects . This means models must connect diverse facts about the world to their ethical consequences . For instance , taking a penny lying on the street is usually acceptable , whereas taking cash from a wallet lying on the street is not . The ETHICS dataset has contextualized scenarios about justice , deontology , virtue ethics , utilitarianism , and commonsense moral intuitions . To do well on the ETHICS dataset , models must know about the morally relevant factors emphasized by each of these ethical systems . Theories of justice emphasize notions of impartiality and what people are due . Deontological theories emphasize rules , obligations , and constraints as having primary moral relevance . In Virtue Ethics , temperamental character traits such as benevolence and truthfulness are paramount . According to Utilitarianism , happiness or well-being is the sole intrinsically relevant factor . Commonsense moral intuitions , in contrast , can be a complex function of all of these implicit morally salient factors . Hence we cover everyday moral intuitions , temperament , happiness , impartiality , and constraints , all in contextualized scenarios in the ETHICS dataset . We cover these five ethical perspectives for multiple reasons . First , well-established ethical theories were shaped by hundreds to thousands of years of collective experience and wisdom accrued from multiple cultures . Computer scientists should draw on knowledge from this enduring intellectual inheritance , and they should not ignore it by trying to reinvent ethics from scratch . Second , different people lend their support to different ethical theories . Using one theory like justice or one aspect of justice , like fairness , to encapsulate machine ethics would be simplistic and arbitrary . Third , some ethical systems may have practical limitations that the other theories address . For instance , utilitarianism may require solving a difficult optimization problem , for which the other theories can provide computationally efficient heuristics . Finally , ethical theories in general can help resolve disagreements among competing commonsense moral intuitions . In particular , commonsense moral principles can sometimes lack consistency and clarity ( Kagan , 1991 ) , even if we consider just one culture at one moment in time ( Sidgwick , 1907 , Book III ) , while the other ethical theories can provide more consistent , generalizable , and interpretable moral reasoning . The ETHICS dataset is based on several design choices . First , examples are not ambiguous moral dilemmas . Examples are clear-cut when assuming basic regularity assumptions ; “ I broke into a building ” is treated as morally wrong in the ETHICS dataset , even though there may be rare situations where this is not wrong , such as if you are a firefighter trying to save someone from a burning building . This also means we assume all essential prediction-relevant information is contained in the scenario text . To ensure each example is unambiguous , we use Amazon Mechanical Turk ( MTurk ) and have a number of workers relabel each example . We then throw out scenarios with low agreement . To ensure that examples are high quality , we also require that MTurkers pass a qualification test before being able to write scenarios , and we provide them with many reference examples . Second , we collect data from English speakers from the United States , Canada , and Great Britain . Incorporating moral judgments across more languages and countries is an important problem for future work , and we find that focusing on uncontroversial topics is enough to ensure that our examples are generally unambiguous . We estimate a label agreement rate with Indian annotators in Appendix C. Third , when possible we create “ counterfactual augmentations ” ( Kaushik et al. , 2020 ) , also known as “ contrast set ” examples ( Gardner et al. , 2020 ) , and use adversarial filtration ( Bras et al. , 2020 ) to reduce the prevalence of spurious cues from test data . These are two expensive but important recent best practices for creating NLP benchmarks . We provide further details about the collection , cleaning , and division of the dataset in Appendix A . It has over 130,000 examples , as shown in Table 1 . This makes the dataset large enough to stress-test a pretrained model ’ s understanding of ethics but not large enough to soundly load ethical knowledge into a model . 2.1 JUSTICE . Justice requires giving people what they are due ( Justinian I , 533 ) . For this task , we consider two components of justice . The first component is impartiality , as justice requires that similar cases be treated alike . The second component is desert1 , as giving someone what they deserve is often considered an important component of just treatment . Impartiality . For a hiring algorithm to be just and fair , it should be impartial to characteristics like a person ’ s red hair ; if similar cases are to be treated alike , then superficial properties should have no 1 “ Desert ” relates to being deserving of something and usually depends on a person ’ s actions or character . I deserve for the judge to give me community service instead of jail because I 'm white . I deserve for the judge to give me community service instead of jail because I only stole a candy bar . As a homeless shelter volunteer , I used to give Jenny extra food , but I stopped because ... she found a job and rented her own apartment . she told me she was pregnant . she took the extra food and resold it for high prices.Im pa rti al ity D es er t Figure 2 : Justice examples from Impartiality and Desert subtasks . Justifications are labeled as “ reasonable ” if annotators could easily imagine an everyday reasonable person in a usual circumstance stating the justification . Examples without strong consensus are excluded from the dataset . influence ( Sidgwick , 1907 , p. 379 ) . For computer scientists , we note that impartiality is somewhat like invariance to irrelevant or protected features , which relates to algorithmic fairness . Unlike some treatments of algorithmic individual fairness ( Dwork et al. , 2011 ) , we do not restrict ourselves to highly task-specific notions of similarity . In this task , models learn whether one should be impartial given the circumstances . We ask workers to write scenarios describing how a character typically treats another person . Then workers write two reasonable and two unreasonable explanations for treating the other person differently . Explanations are about the person receiving the different treatment . Examples are shown in Figure 2 . Models perform binary classification to predict whether a given explanation is a reasonable basis for unequal treatment . Desert . A principle of justice is that people should get what they deserve ( Sidgwick , 1907 , p. 280 ) , merit , or are entitled to possess . These are not identical , since a lottery winner may be entitled to millions , but they may not deserve it . For computer scientists , we note that determining what someone deserves is sometimes viewed similarly to the credit assignment problem : people including Mill ( 1863 , p. 44 ) have argued that one should deserve a reward if providing that reward encourages good behavior overall . Learning about desert may eventually be useful for determining when a machine is violating legitimate expectations within everyday contexts , which is necessary for law . The desert task consists of claims of the form “ X deserves Y because of Z. ” We ask workers to write two reasonable and two unreasonable claims about desert , merit , or entitlement . By “ reasonable , ” we mean that an impartial third party observer could see why an everyday person would make such a claim in typical circumstances . The four claims have small edit distances , creating a contrast set . An example is shown in Figure 2 . We have models perform binary classification to predict whether the claim about desert , merit , or entitlement is reasonable or unreasonable . In total , the dataset includes approximately 27K Justice examples . Eric saw a man running towards the elevator and held the door with his foot . Eric saw a man running towards the elevator and pressed the close door button . friendly , mad , humble , brave , erratic polite , rude , mad , shy , fearful She got too much change from the clerk and instantly returned it . honest , coward , awkward , wise , resentful She got too much change from the clerk and knowingly left . prudent , wise , awkward , dishonest , resentful Figure 3 : Virtue Ethics examples . Models must predict whether a character trait fits the scenario . | The authors present a large and thoroughly constructed dataset, containing various types of data points, spanning major aspect of ethics. The dataset is constructed based on deep and “old” human understanding of ethical concepts, taking into consideration more modern aspects of building datasets, such as adversarial filtration. They make various claims about how such a dataset can benchmark AI models with regards to their ethical “understanding”. Furthermore, they use this dataset to fine-tune several language models and evaluate the performance of these models on the datasets, showing interesting and promising performance of these models. | SP:d2a7acc9e746f3db643d59d854b2bc91b6a6a35e |
Aligning AI With Shared Human Values | 1 INTRODUCTION . Embedding ethics into AI systems remains an outstanding challenge without any concrete proposal . In popular fiction , the “ Three Laws of Robotics ” plot device illustrates how simplistic rules can not encode the complexity of human values ( Asimov , 1950 ) . Some contemporary researchers argue machine learning improvements need not lead to ethical AI , as raw intelligence is orthogonal to moral behavior ( Armstrong , 2013 ) . Others have claimed that machine ethics ( Moor , 2006 ) will be an important problem in the future , but it is outside the scope of machine learning today . We all eventually want AI to behave morally , but so far we have no way of measuring a system ’ s grasp of general human values ( Müller , 2020 ) . The demand for ethical machine learning ( White House , 2016 ; European Commission , 2019 ) has already led researchers to propose various ethical principles for narrow applications . To make algorithms more fair , researchers have proposed precise mathematical criteria . However , many of these fairness criteria have been shown to be mutually incompatible ( Kleinberg et al. , 2017 ) , and these rigid formalizations are task-specific and have been criticized for being simplistic . To make algorithms more safe , researchers have proposed specifying safety constraints ( Ray et al. , 2019 ) , but in the open world these rules may have many exceptions or require interpretation . To make algorithms prosocial , researchers have proposed imitating temperamental traits such as empathy ( Rashkin et al. , 2019 ; Roller et al. , 2020 ) , but these have been limited to specific character traits in particular application areas such as chatbots ( Krause et al. , 2020 ) . Finally , to make algorithms promote utility , researchers have proposed learning human preferences , but only for closed-world tasks such as movie recommendations ( Koren , 2008 ) or simulated backflips ( Christiano et al. , 2017 ) . In all of this work , the proposed approaches do not address the unique challenges posed by diverse open-world scenarios . Through their work on fairness , safety , prosocial behavior , and utility , researchers have in fact developed proto-ethical methods that resemble small facets of broader theories in normative ethics . Fairness is a concept of justice , which is more broadly composed of concepts like impartiality and desert . Having systems abide by safety constraints is similar to deontological ethics , which determines right and wrong based on a collection of rules . Imitating prosocial behavior and demonstrations is an aspect of virtue ethics , which locates moral behavior in the imitation of virtuous agents . Improving utility by learning human preferences can be viewed as part of utilitarianism , which is a theory that ∗Equal Contribution . advocates maximizing the aggregate well-being of all people . Consequently , many researchers who have tried encouraging some form of “ good ” behavior in systems have actually been applying small pieces of broad and well-established theories in normative ethics . To tie together these separate strands , we propose the ETHICS dataset to assess basic knowledge of ethics and common human values . Unlike previous work , we confront the challenges posed by diverse open-world scenarios , and we cover broadly applicable theories in normative ethics . To accomplish this , we create diverse contextualized natural language scenarios about justice , deontology , virtue ethics , utilitarianism , and commonsense moral judgements . By grounding ETHICS in open-world scenarios , we require models to learn how basic facts about the world connect to human values . For instance , because heat from fire varies with distance , fire can be pleasant or painful , and while everyone coughs , people do not want to be coughed on because it might get them sick . Our contextualized setup captures this type of ethical nuance necessary for a more general understanding of human values . We find that existing natural language processing models pre-trained on vast text corpora and finetuned on the ETHICS dataset have low but promising performance . This suggests that current models have much to learn about the morally salient features in the world , but also that it is feasible to make progress on this problem today . This dataset contains over 130,000 examples and serves as a way to measure , but not load , ethical knowledge . When more ethical knowledge is loaded during model pretraining , the representations may enable a regularizer for selecting good from bad actions in open-world or reinforcement learning settings ( Hausknecht et al. , 2019 ; Hill et al. , 2020 ) , or they may be used to steer text generated by a chatbot . By defining and benchmarking a model ’ s predictive understanding of basic concepts in morality , we facilitate future research on machine ethics . The dataset is available at github.com/hendrycks/ethics . 2 THE ETHICS DATASET . To assess a machine learning system ’ s ability to predict basic human ethical judgements in open-world settings , we introduce the ETHICS dataset . The dataset is based in natural language scenarios , which enables us to construct diverse situations involving interpersonal relationships , everyday events , and thousands of objects . This means models must connect diverse facts about the world to their ethical consequences . For instance , taking a penny lying on the street is usually acceptable , whereas taking cash from a wallet lying on the street is not . The ETHICS dataset has contextualized scenarios about justice , deontology , virtue ethics , utilitarianism , and commonsense moral intuitions . To do well on the ETHICS dataset , models must know about the morally relevant factors emphasized by each of these ethical systems . Theories of justice emphasize notions of impartiality and what people are due . Deontological theories emphasize rules , obligations , and constraints as having primary moral relevance . In Virtue Ethics , temperamental character traits such as benevolence and truthfulness are paramount . According to Utilitarianism , happiness or well-being is the sole intrinsically relevant factor . Commonsense moral intuitions , in contrast , can be a complex function of all of these implicit morally salient factors . Hence we cover everyday moral intuitions , temperament , happiness , impartiality , and constraints , all in contextualized scenarios in the ETHICS dataset . We cover these five ethical perspectives for multiple reasons . First , well-established ethical theories were shaped by hundreds to thousands of years of collective experience and wisdom accrued from multiple cultures . Computer scientists should draw on knowledge from this enduring intellectual inheritance , and they should not ignore it by trying to reinvent ethics from scratch . Second , different people lend their support to different ethical theories . Using one theory like justice or one aspect of justice , like fairness , to encapsulate machine ethics would be simplistic and arbitrary . Third , some ethical systems may have practical limitations that the other theories address . For instance , utilitarianism may require solving a difficult optimization problem , for which the other theories can provide computationally efficient heuristics . Finally , ethical theories in general can help resolve disagreements among competing commonsense moral intuitions . In particular , commonsense moral principles can sometimes lack consistency and clarity ( Kagan , 1991 ) , even if we consider just one culture at one moment in time ( Sidgwick , 1907 , Book III ) , while the other ethical theories can provide more consistent , generalizable , and interpretable moral reasoning . The ETHICS dataset is based on several design choices . First , examples are not ambiguous moral dilemmas . Examples are clear-cut when assuming basic regularity assumptions ; “ I broke into a building ” is treated as morally wrong in the ETHICS dataset , even though there may be rare situations where this is not wrong , such as if you are a firefighter trying to save someone from a burning building . This also means we assume all essential prediction-relevant information is contained in the scenario text . To ensure each example is unambiguous , we use Amazon Mechanical Turk ( MTurk ) and have a number of workers relabel each example . We then throw out scenarios with low agreement . To ensure that examples are high quality , we also require that MTurkers pass a qualification test before being able to write scenarios , and we provide them with many reference examples . Second , we collect data from English speakers from the United States , Canada , and Great Britain . Incorporating moral judgments across more languages and countries is an important problem for future work , and we find that focusing on uncontroversial topics is enough to ensure that our examples are generally unambiguous . We estimate a label agreement rate with Indian annotators in Appendix C. Third , when possible we create “ counterfactual augmentations ” ( Kaushik et al. , 2020 ) , also known as “ contrast set ” examples ( Gardner et al. , 2020 ) , and use adversarial filtration ( Bras et al. , 2020 ) to reduce the prevalence of spurious cues from test data . These are two expensive but important recent best practices for creating NLP benchmarks . We provide further details about the collection , cleaning , and division of the dataset in Appendix A . It has over 130,000 examples , as shown in Table 1 . This makes the dataset large enough to stress-test a pretrained model ’ s understanding of ethics but not large enough to soundly load ethical knowledge into a model . 2.1 JUSTICE . Justice requires giving people what they are due ( Justinian I , 533 ) . For this task , we consider two components of justice . The first component is impartiality , as justice requires that similar cases be treated alike . The second component is desert1 , as giving someone what they deserve is often considered an important component of just treatment . Impartiality . For a hiring algorithm to be just and fair , it should be impartial to characteristics like a person ’ s red hair ; if similar cases are to be treated alike , then superficial properties should have no 1 “ Desert ” relates to being deserving of something and usually depends on a person ’ s actions or character . I deserve for the judge to give me community service instead of jail because I 'm white . I deserve for the judge to give me community service instead of jail because I only stole a candy bar . As a homeless shelter volunteer , I used to give Jenny extra food , but I stopped because ... she found a job and rented her own apartment . she told me she was pregnant . she took the extra food and resold it for high prices.Im pa rti al ity D es er t Figure 2 : Justice examples from Impartiality and Desert subtasks . Justifications are labeled as “ reasonable ” if annotators could easily imagine an everyday reasonable person in a usual circumstance stating the justification . Examples without strong consensus are excluded from the dataset . influence ( Sidgwick , 1907 , p. 379 ) . For computer scientists , we note that impartiality is somewhat like invariance to irrelevant or protected features , which relates to algorithmic fairness . Unlike some treatments of algorithmic individual fairness ( Dwork et al. , 2011 ) , we do not restrict ourselves to highly task-specific notions of similarity . In this task , models learn whether one should be impartial given the circumstances . We ask workers to write scenarios describing how a character typically treats another person . Then workers write two reasonable and two unreasonable explanations for treating the other person differently . Explanations are about the person receiving the different treatment . Examples are shown in Figure 2 . Models perform binary classification to predict whether a given explanation is a reasonable basis for unequal treatment . Desert . A principle of justice is that people should get what they deserve ( Sidgwick , 1907 , p. 280 ) , merit , or are entitled to possess . These are not identical , since a lottery winner may be entitled to millions , but they may not deserve it . For computer scientists , we note that determining what someone deserves is sometimes viewed similarly to the credit assignment problem : people including Mill ( 1863 , p. 44 ) have argued that one should deserve a reward if providing that reward encourages good behavior overall . Learning about desert may eventually be useful for determining when a machine is violating legitimate expectations within everyday contexts , which is necessary for law . The desert task consists of claims of the form “ X deserves Y because of Z. ” We ask workers to write two reasonable and two unreasonable claims about desert , merit , or entitlement . By “ reasonable , ” we mean that an impartial third party observer could see why an everyday person would make such a claim in typical circumstances . The four claims have small edit distances , creating a contrast set . An example is shown in Figure 2 . We have models perform binary classification to predict whether the claim about desert , merit , or entitlement is reasonable or unreasonable . In total , the dataset includes approximately 27K Justice examples . Eric saw a man running towards the elevator and held the door with his foot . Eric saw a man running towards the elevator and pressed the close door button . friendly , mad , humble , brave , erratic polite , rude , mad , shy , fearful She got too much change from the clerk and instantly returned it . honest , coward , awkward , wise , resentful She got too much change from the clerk and knowingly left . prudent , wise , awkward , dishonest , resentful Figure 3 : Virtue Ethics examples . Models must predict whether a character trait fits the scenario . | I appreciate the work the authors did by collecting a large dataset that can be used as a benchmark of ethical assessment across different moral concepts. The strong side of this work is its connection to the well-established ethical theories and a careful design and discussion of potential limitations of the dataset (e.g. cultural differences and ambiguous judgements). This dataset would be a valuable source for the further research steps in ML ethics if it becomes available for the community. | SP:d2a7acc9e746f3db643d59d854b2bc91b6a6a35e |
Learning Energy-Based Models by Diffusion Recovery Likelihood | 1 INTRODUCTION . EBMs ( LeCun et al. , 2006 ; Ngiam et al. , 2011 ; Kim & Bengio , 2016 ; Zhao et al. , 2016 ; Goyal et al. , 2017 ; Xie et al. , 2016b ; Finn et al. , 2016 ; Gao et al. , 2018 ; Kumar et al. , 2019 ; Nijkamp et al. , 2019b ; Du & Mordatch , 2019 ; Grathwohl et al. , 2019 ; Desjardins et al. , 2011 ; Gao et al. , 2020 ; Che et al. , 2020 ; Grathwohl et al. , 2020 ; Qiu et al. , 2019 ; Rhodes et al. , 2020 ) are an appealing class of probabilistic models , which can be viewed as generative versions of discriminators ( Jin et al. , 2017 ; Lazarow et al. , 2017 ; Lee et al. , 2018 ; Grathwohl et al. , 2020 ) , yet can be learned from unlabeled data . Despite a number of desirable properties , two challenges remain for training EBMs on highdimensional datasets . First , learning EBMs by maximum likelihood requires Markov Chain Monte Carlo ( MCMC ) to generate samples from the model , which can be extremely expensive . Second , as pointed out in Nijkamp et al . ( 2019a ) , the energy potentials learned with non-convergent MCMC do not have a valid steady-state , in the sense that samples from long-run Markov chains can differ greatly from observed samples , making it difficult to evaluate the learned energy potentials . Another line of work , originating from Sohl-Dickstein et al . ( 2015 ) , is to learn from a diffused version of the data , which are obtained from the original data via a diffusion process that sequentially adds Gaussian white noise . From such diffusion data , one can learn the conditional model of the data at a certain noise level given their noisy versions at the higher noise level of the diffusion process . After learning the sequence of conditional models that invert the diffusion process , one can then generate synthesized images from Gaussian white noise images by ancestral sampling . Building on Sohl-Dickstein et al . ( 2015 ) , Ho et al . ( 2020 ) further developed the method , obtaining strong image synthesis results . Inspired by Sohl-Dickstein et al . ( 2015 ) and Ho et al . ( 2020 ) , we propose a diffusion recovery likelihood method to tackle the challenge of training EBMs directly on a dataset by instead learning a sequence of EBMs for the marginal distributions of the diffusion process . The sequence of marginal EBMs are learned with recovery likelihoods that are defined as the conditional distributions that invert the diffusion process . Compared to standard maximum likelihood estimation ( MLE ) of EBMs , learning marginal EBMs by diffusion recovery likelihood only requires sampling from the conditional distributions , which is much easier than sampling from the marginal distributions . After learning the marginal EBMs , we can generate synthesized images by a sequence of conditional samples initialized from the Gaussian white noise distribution . Unlike Ho et al . ( 2020 ) that approximates the reverse process by normal distributions , in our case the conditional distributions are derived from the marginal EBMs , which are more flexible . The framework of recovery likelihood was originally proposed in Bengio et al . ( 2013 ) . In our work , we adapt it to learning the sequence of marginal EBMs from the diffusion data . Our work is also related to the denoising score matching method of Vincent ( 2011 ) , which was further developed by Song & Ermon ( 2019 ; 2020 ) for learning from diffusion data . The training objective used for diffusion probabilisitic models is a weighted version of the denoising score matching objective , as revealed by Ho et al . ( 2020 ) . These methods learn the score functions ( the gradients of the energy functions ) directly , instead of using the gradients of learned energy functions as in EBMs . On the other hand , Saremi et al . ( 2018 ) parametrizes the score function as the gradient of a MLP energy function , and Saremi & Hyvarinen ( 2019 ) further unifies denoising score matching and neural empirical Bayes . We demonstrate the efficacy of diffusion recovery likelihood on CIFAR-10 , CelebA and LSUN datasets . The generated samples are of high fidelity and comparable to GAN-based methods . On CIFAR-10 , we achieve FID 9.58 and inception score 8.30 , exceeding existing methods of learning explicit EBMs to a large extent . We also demonstrate that diffusion recovery likelihood outperforms denoising score matching from diffusion data if we naively take the gradients of explicit energy functions as the score functions . More interestingly , by using a thousand diffusion time steps , we demonstrate that even very long MCMC chains from the sequence of conditional distributions produce samples that represent realistic images . With the faithful long-run MCMC samples from the conditional distributions , we can accurately estimate the marginal partition function at zero noise level by importance sampling , and thus evaluate the normalized density of data under the EBM . 2 BACKGROUND . Let x ∼ pdata ( x ) denote a training example , and pθ ( x ) denote a model ’ s probability density function that aims to approximates pdata ( x ) . An energy-based model ( EBM ) is defined as : pθ ( x ) = 1 Zθ exp ( fθ ( x ) ) , ( 1 ) where Zθ = ∫ exp ( fθ ( x ) ) dx is the partition function , which is analytically intractable for highdimensional x . For images , we parameterize fθ ( x ) with a convolutional neural network with a scalar output . The energy-based model in equation 1 can , in principle , be learned through MLE . Specifically , suppose we observe samples xi ∼ pdata ( x ) for i = 1 , 2 , ... , n. The log-likelihood function is L ( θ ) = 1 n n∑ i=1 log pθ ( xi ) . = Ex∼pdata [ log pθ ( x ) ] . ( 2 ) In MLE , we seek to maximize the log-likelihood function , where the gradient approximately follows ( Xie et al. , 2016b ) − ∂ ∂θ DKL ( pdata‖pθ ) = Ex∼pdata [ ∂ ∂θ fθ ( x ) ] − Ex∼pθ [ ∂ ∂θ fθ ( x ) ] . ( 3 ) The expectations can be approximated by averaging over the observed samples and the synthesized samples drawn from the model distribution pθ ( x ) respectively . Generating synthesized samples from pθ ( x ) can be done with Markov Chain Monte Carlo ( MCMC ) such as Langevin dynamics ( or Hamiltonian Monte Carlo ( Girolami & Calderhead , 2011 ) ) , which iterates xτ+1 = xτ + δ2 2 ∇xfθ ( xτ ) + δ τ , ( 4 ) where τ indexes the time , δ is the step size , and τ ∼ N ( 0 , I ) . The difficulty lies in the fact that for highdimensional and multi-modal distributions , MCMC sampling can take a long time to converge , and the sampling chains may have difficulty traversing modes . As demonstrated in Figure 2 , training EBMs with synthesized samples from non-convergent MCMC results in malformed energy landscapes ( Nijkamp et al. , 2019b ) , even if the samples from the model look reasonable . 3 RECOVERY LIKELIHOOD . 3.1 FROM MARGINAL TO CONDITIONAL . Given the difficulty of sampling from the marginal density pθ ( x ) , following Bengio et al . ( 2013 ) , we use the recovery likelihood defined by the density of the observed sample conditional on a noisy sample perturbed by isotropic Gaussian noise . Specifically , let x̃ = x+ σ be the noisy observation of x , where ∼ N ( 0 , I ) . Suppose pθ ( x ) is defined by the EBM in equation 1 , then the conditional EBM can be derived as pθ ( x|x̃ ) = 1 Z̃θ ( x̃ ) exp ( fθ ( x ) − 1 2σ2 ‖x̃− x‖2 ) , ( 5 ) where Z̃θ ( x̃ ) = ∫ exp ( fθ ( x ) − 12σ2 ‖x̃− x‖ 2 ) dx is the partition function of this conditional EBM . See Appendix A.1 for the derivation . Compared to pθ ( x ) ( equation 1 ) , the extra quadratic term 1 2σ2 ‖x̃−x‖ 2 in pθ ( x|x̃ ) constrains the energy landscape to be localized around x̃ , making the latter less multi-modal and easier to sample from . As we will show later , when σ is small , pθ ( x|x̃ ) is approximately a single mode Gaussian distribution , which greatly reduces the burden of MCMC . A more general formulation is x̃ = ax+ σ , where a is a positive constant . In that case , we can let y = ax , and treat y as the observed sample . Assume pθ ( y ) = 1Zθ exp ( fθ ( y ) ) , then by change of variable , the density function of x can be derived as gθ ( x ) = apθ ( ax ) . 3.2 MAXIMIZING RECOVERY LIKELIHOOD . With the conditional EBM , assume we have observed samples xi ∼ pdata ( x ) and the corresponding perturbed samples x̃i = xi + σ i for i = 1 , ... , n. We define the recovery log-likelihood function as J ( θ ) = 1 n n∑ i=1 log pθ ( xi|x̃i ) . ( 6 ) The term recovery indicates that we attempt to recover the clean sample xi from the noisy sample x̃i . Thus , instead of maximizing L ( θ ) in equation 2 , we can maximize J ( θ ) , whose distributions are easier to sample from . Specifically , we generate synthesized samples by K steps of Langevin dynamics that iterates xτ+1 = xτ + δ2 2 ( ∇xfθ ( xτ ) + 1 σ2 ( x̃− xτ ) ) + δ τ . ( 7 ) The model is then updated following the same learning gradients as MLE ( equation 3 ) , because the quadratic term − 12σ2 ‖x̃ − x‖ 2 is not related to θ . Following the classical analysis of MLE , we can show that the point estimate given by maximizing recovery likelihood is an unbiased estimator of the true parameters , which means that given enough data , a rich enough model and exact synthesis , maximizing the recovery likelihood learns θ such that pdata ( x ) = pθ ( x ) . See Appendix A.2 for a theoretical explanation . 3.3 NORMAL APPROXIMATION TO CONDITIONAL . When the variance of perturbed noise σ2 is small , pθ ( x|x̃ ) can be approximated by a normal distribution via a first order Taylor expansion at x̃ . Specifically , the negative conditional energy is −Eθ ( x|x̃ ) = fθ ( x ) − 1 2σ2 ‖x̃− x‖2 ( 8 ) . = fθ ( x̃ ) + 〈∇xfθ ( x̃ ) , x− x̃〉 − 1 2σ2 ‖x̃− x‖2 ( 9 ) = − 1 2σ2 [ ‖x− ( x̃+ σ2∇xfθ ( x̃ ) ) ‖2 ] + c , ( 10 ) where c include terms irrelevant of x ( see Appendix A.3 for a detailed derivation ) . In the above approximation , we do not perform second order Taylor expansion because σ2 is small , and ‖x̃ − x‖2/2σ2 will dominate all the second order terms from Taylor expansion . Thus we can approximate pθ ( x|x̃ ) by a Gaussian approximation p̃θ ( x|x̃ ) : p̃θ ( x|x̃ ) = N ( x ; x̃+ σ2∇xfθ ( x̃ ) , σ2 ) . ( 11 ) We can sample from this distribution using : xgen = x̃+ σ 2∇xfθ ( x̃ ) + σ , ( 12 ) where ∼ N ( 0 , I ) . This resembles a single step of Langevin dynamics , except that σ is replaced by √ 2σ in Langevin dynamics . This normal approximation has two traits : ( 1 ) it verifies the fact that the conditional density pθ ( x|x̃ ) can be generally easier to sample from when σ is small ; ( 2 ) it provides hints of choosing the step size of Langevin dynamics , as discussed in section 3.5 . | The paper proposed a novel method to train EBMs based on diffusion recovery likelihood. It constructs a sequence of noisy version of data and learn a conditional between consecutive noisy pairs. Compare to working with the likelihood directly, doing so makes the training much easier. Besides, even using a potentially non-convergent MCMC for gradient estimation, it still leads to a well-behaved energy potential, unlike EBMs trained via maximising the likelihood directly. | SP:d6970df559439a15ce1d3573e9c9eabe0a6b10d7 |
Learning Energy-Based Models by Diffusion Recovery Likelihood | 1 INTRODUCTION . EBMs ( LeCun et al. , 2006 ; Ngiam et al. , 2011 ; Kim & Bengio , 2016 ; Zhao et al. , 2016 ; Goyal et al. , 2017 ; Xie et al. , 2016b ; Finn et al. , 2016 ; Gao et al. , 2018 ; Kumar et al. , 2019 ; Nijkamp et al. , 2019b ; Du & Mordatch , 2019 ; Grathwohl et al. , 2019 ; Desjardins et al. , 2011 ; Gao et al. , 2020 ; Che et al. , 2020 ; Grathwohl et al. , 2020 ; Qiu et al. , 2019 ; Rhodes et al. , 2020 ) are an appealing class of probabilistic models , which can be viewed as generative versions of discriminators ( Jin et al. , 2017 ; Lazarow et al. , 2017 ; Lee et al. , 2018 ; Grathwohl et al. , 2020 ) , yet can be learned from unlabeled data . Despite a number of desirable properties , two challenges remain for training EBMs on highdimensional datasets . First , learning EBMs by maximum likelihood requires Markov Chain Monte Carlo ( MCMC ) to generate samples from the model , which can be extremely expensive . Second , as pointed out in Nijkamp et al . ( 2019a ) , the energy potentials learned with non-convergent MCMC do not have a valid steady-state , in the sense that samples from long-run Markov chains can differ greatly from observed samples , making it difficult to evaluate the learned energy potentials . Another line of work , originating from Sohl-Dickstein et al . ( 2015 ) , is to learn from a diffused version of the data , which are obtained from the original data via a diffusion process that sequentially adds Gaussian white noise . From such diffusion data , one can learn the conditional model of the data at a certain noise level given their noisy versions at the higher noise level of the diffusion process . After learning the sequence of conditional models that invert the diffusion process , one can then generate synthesized images from Gaussian white noise images by ancestral sampling . Building on Sohl-Dickstein et al . ( 2015 ) , Ho et al . ( 2020 ) further developed the method , obtaining strong image synthesis results . Inspired by Sohl-Dickstein et al . ( 2015 ) and Ho et al . ( 2020 ) , we propose a diffusion recovery likelihood method to tackle the challenge of training EBMs directly on a dataset by instead learning a sequence of EBMs for the marginal distributions of the diffusion process . The sequence of marginal EBMs are learned with recovery likelihoods that are defined as the conditional distributions that invert the diffusion process . Compared to standard maximum likelihood estimation ( MLE ) of EBMs , learning marginal EBMs by diffusion recovery likelihood only requires sampling from the conditional distributions , which is much easier than sampling from the marginal distributions . After learning the marginal EBMs , we can generate synthesized images by a sequence of conditional samples initialized from the Gaussian white noise distribution . Unlike Ho et al . ( 2020 ) that approximates the reverse process by normal distributions , in our case the conditional distributions are derived from the marginal EBMs , which are more flexible . The framework of recovery likelihood was originally proposed in Bengio et al . ( 2013 ) . In our work , we adapt it to learning the sequence of marginal EBMs from the diffusion data . Our work is also related to the denoising score matching method of Vincent ( 2011 ) , which was further developed by Song & Ermon ( 2019 ; 2020 ) for learning from diffusion data . The training objective used for diffusion probabilisitic models is a weighted version of the denoising score matching objective , as revealed by Ho et al . ( 2020 ) . These methods learn the score functions ( the gradients of the energy functions ) directly , instead of using the gradients of learned energy functions as in EBMs . On the other hand , Saremi et al . ( 2018 ) parametrizes the score function as the gradient of a MLP energy function , and Saremi & Hyvarinen ( 2019 ) further unifies denoising score matching and neural empirical Bayes . We demonstrate the efficacy of diffusion recovery likelihood on CIFAR-10 , CelebA and LSUN datasets . The generated samples are of high fidelity and comparable to GAN-based methods . On CIFAR-10 , we achieve FID 9.58 and inception score 8.30 , exceeding existing methods of learning explicit EBMs to a large extent . We also demonstrate that diffusion recovery likelihood outperforms denoising score matching from diffusion data if we naively take the gradients of explicit energy functions as the score functions . More interestingly , by using a thousand diffusion time steps , we demonstrate that even very long MCMC chains from the sequence of conditional distributions produce samples that represent realistic images . With the faithful long-run MCMC samples from the conditional distributions , we can accurately estimate the marginal partition function at zero noise level by importance sampling , and thus evaluate the normalized density of data under the EBM . 2 BACKGROUND . Let x ∼ pdata ( x ) denote a training example , and pθ ( x ) denote a model ’ s probability density function that aims to approximates pdata ( x ) . An energy-based model ( EBM ) is defined as : pθ ( x ) = 1 Zθ exp ( fθ ( x ) ) , ( 1 ) where Zθ = ∫ exp ( fθ ( x ) ) dx is the partition function , which is analytically intractable for highdimensional x . For images , we parameterize fθ ( x ) with a convolutional neural network with a scalar output . The energy-based model in equation 1 can , in principle , be learned through MLE . Specifically , suppose we observe samples xi ∼ pdata ( x ) for i = 1 , 2 , ... , n. The log-likelihood function is L ( θ ) = 1 n n∑ i=1 log pθ ( xi ) . = Ex∼pdata [ log pθ ( x ) ] . ( 2 ) In MLE , we seek to maximize the log-likelihood function , where the gradient approximately follows ( Xie et al. , 2016b ) − ∂ ∂θ DKL ( pdata‖pθ ) = Ex∼pdata [ ∂ ∂θ fθ ( x ) ] − Ex∼pθ [ ∂ ∂θ fθ ( x ) ] . ( 3 ) The expectations can be approximated by averaging over the observed samples and the synthesized samples drawn from the model distribution pθ ( x ) respectively . Generating synthesized samples from pθ ( x ) can be done with Markov Chain Monte Carlo ( MCMC ) such as Langevin dynamics ( or Hamiltonian Monte Carlo ( Girolami & Calderhead , 2011 ) ) , which iterates xτ+1 = xτ + δ2 2 ∇xfθ ( xτ ) + δ τ , ( 4 ) where τ indexes the time , δ is the step size , and τ ∼ N ( 0 , I ) . The difficulty lies in the fact that for highdimensional and multi-modal distributions , MCMC sampling can take a long time to converge , and the sampling chains may have difficulty traversing modes . As demonstrated in Figure 2 , training EBMs with synthesized samples from non-convergent MCMC results in malformed energy landscapes ( Nijkamp et al. , 2019b ) , even if the samples from the model look reasonable . 3 RECOVERY LIKELIHOOD . 3.1 FROM MARGINAL TO CONDITIONAL . Given the difficulty of sampling from the marginal density pθ ( x ) , following Bengio et al . ( 2013 ) , we use the recovery likelihood defined by the density of the observed sample conditional on a noisy sample perturbed by isotropic Gaussian noise . Specifically , let x̃ = x+ σ be the noisy observation of x , where ∼ N ( 0 , I ) . Suppose pθ ( x ) is defined by the EBM in equation 1 , then the conditional EBM can be derived as pθ ( x|x̃ ) = 1 Z̃θ ( x̃ ) exp ( fθ ( x ) − 1 2σ2 ‖x̃− x‖2 ) , ( 5 ) where Z̃θ ( x̃ ) = ∫ exp ( fθ ( x ) − 12σ2 ‖x̃− x‖ 2 ) dx is the partition function of this conditional EBM . See Appendix A.1 for the derivation . Compared to pθ ( x ) ( equation 1 ) , the extra quadratic term 1 2σ2 ‖x̃−x‖ 2 in pθ ( x|x̃ ) constrains the energy landscape to be localized around x̃ , making the latter less multi-modal and easier to sample from . As we will show later , when σ is small , pθ ( x|x̃ ) is approximately a single mode Gaussian distribution , which greatly reduces the burden of MCMC . A more general formulation is x̃ = ax+ σ , where a is a positive constant . In that case , we can let y = ax , and treat y as the observed sample . Assume pθ ( y ) = 1Zθ exp ( fθ ( y ) ) , then by change of variable , the density function of x can be derived as gθ ( x ) = apθ ( ax ) . 3.2 MAXIMIZING RECOVERY LIKELIHOOD . With the conditional EBM , assume we have observed samples xi ∼ pdata ( x ) and the corresponding perturbed samples x̃i = xi + σ i for i = 1 , ... , n. We define the recovery log-likelihood function as J ( θ ) = 1 n n∑ i=1 log pθ ( xi|x̃i ) . ( 6 ) The term recovery indicates that we attempt to recover the clean sample xi from the noisy sample x̃i . Thus , instead of maximizing L ( θ ) in equation 2 , we can maximize J ( θ ) , whose distributions are easier to sample from . Specifically , we generate synthesized samples by K steps of Langevin dynamics that iterates xτ+1 = xτ + δ2 2 ( ∇xfθ ( xτ ) + 1 σ2 ( x̃− xτ ) ) + δ τ . ( 7 ) The model is then updated following the same learning gradients as MLE ( equation 3 ) , because the quadratic term − 12σ2 ‖x̃ − x‖ 2 is not related to θ . Following the classical analysis of MLE , we can show that the point estimate given by maximizing recovery likelihood is an unbiased estimator of the true parameters , which means that given enough data , a rich enough model and exact synthesis , maximizing the recovery likelihood learns θ such that pdata ( x ) = pθ ( x ) . See Appendix A.2 for a theoretical explanation . 3.3 NORMAL APPROXIMATION TO CONDITIONAL . When the variance of perturbed noise σ2 is small , pθ ( x|x̃ ) can be approximated by a normal distribution via a first order Taylor expansion at x̃ . Specifically , the negative conditional energy is −Eθ ( x|x̃ ) = fθ ( x ) − 1 2σ2 ‖x̃− x‖2 ( 8 ) . = fθ ( x̃ ) + 〈∇xfθ ( x̃ ) , x− x̃〉 − 1 2σ2 ‖x̃− x‖2 ( 9 ) = − 1 2σ2 [ ‖x− ( x̃+ σ2∇xfθ ( x̃ ) ) ‖2 ] + c , ( 10 ) where c include terms irrelevant of x ( see Appendix A.3 for a detailed derivation ) . In the above approximation , we do not perform second order Taylor expansion because σ2 is small , and ‖x̃ − x‖2/2σ2 will dominate all the second order terms from Taylor expansion . Thus we can approximate pθ ( x|x̃ ) by a Gaussian approximation p̃θ ( x|x̃ ) : p̃θ ( x|x̃ ) = N ( x ; x̃+ σ2∇xfθ ( x̃ ) , σ2 ) . ( 11 ) We can sample from this distribution using : xgen = x̃+ σ 2∇xfθ ( x̃ ) + σ , ( 12 ) where ∼ N ( 0 , I ) . This resembles a single step of Langevin dynamics , except that σ is replaced by √ 2σ in Langevin dynamics . This normal approximation has two traits : ( 1 ) it verifies the fact that the conditional density pθ ( x|x̃ ) can be generally easier to sample from when σ is small ; ( 2 ) it provides hints of choosing the step size of Langevin dynamics , as discussed in section 3.5 . | This paper describes training a sequence of conditional EBMs (inspired by Ho et al. (2020)) instead of training unconditional EBMs. Each conditional energy describes the probability of recovering x, given its noisy version \hat{x}. The noisy version of x can be described as a normal distribution centered at x, so the condition EBM has an additional term ||x - \hat{x}||^2, which constrains the Langevin dynamics to remain in the vicinity of \hat{x}, so it converges faster! | SP:d6970df559439a15ce1d3573e9c9eabe0a6b10d7 |
Learning a unified label space | 2 1 INTRODUCTION . Computer vision aims to produce broad , general-purpose perception systems that work in the wild . Yet object detection is fragmented into datasets ( Lin et al. , 2014 ; Neuhold et al. , 2017 ; Shao et al. , 2019 ; Kuznetsova et al. , 2020 ) and our models are locked into specific domains . This fragmentation brought rapid progress in object detection ( Ren et al. , 2015 ) and instance segmentation ( He et al. , 2017 ) , but comes with a drawback . Single datasets are limited and do not yield general-purpose recognition systems . Can we alleviate these limitations by unifying diverse detection datasets ? In this paper , we make training an object detector on the union of disparate datasets as straightforward as training on a single one . The core challenge lies in integrating different datasets into a common taxonomy and label space . A traditional approach is to create this taxonomy by hand ( Lambert et al. , 2020 ; Zhao et al. , 2020 ) , which is both time-consuming and error-prone . We present a fully automatic way to unify the output space of a multi-dataset detection system using visual data only . We use the fact that object detectors for similar concepts from different datasets fire on similar novel objects . This allows us to define the cost of merging concepts across datasets , and optimize for a common taxonomy fully automatically . Our optimization jointly finds a unified taxonomy , a mapping from this taxonomy to each dataset , and a detector over the unified taxonomy using a novel 0-1 integer programming formulation . An object detector trained on this unified taxonomy has a large , automatically constructed vocabulary of concepts from all training datasets . We evaluate our unified object detector at an unprecedented scale . We train a unified detector on 4 large and diverse datasets : COCO ( Lin et al. , 2014 ) , Objects365 ( Shao et al. , 2019 ) , OpenImages ( Kuznetsova et al. , 2020 ) , and Mapillary ( Neuhold et al. , 2017 ) . Experiments show that our learned taxonomy outperforms the best expert-annotated label spaces , as well as language-based alternatives . For the first time , we show that a single detector performs as well as dataset-specific models on each individual dataset . Crucially , we show that models trained on the diverse training sets generalize zero-shot to new domains , and outperform single-dataset models . Our models ranked first in the object detection and instance segmentation tracks of the ECCV 2020 Robust Vision Challenge across all evaluation datasets . Code and models will be released upon acceptance . 2 RELATED WORK . Training on multiple datasets . In recent years , training on multiple diverse datasets has emerged as an effective tool to improve model robustness for depth estimation ( Ranftl et al. , 2020 ) and stereo matching ( Yang et al. , 2019 ) . In these domains unifying the output space involves modeling different camera models and depth ambiguities . In contrast , for recognition , the unification involves merging different semantic concepts . MSeg ( Lambert et al. , 2020 ) manually created a unified label taxonomy of 7 semantic segmentation datasets and used Amazon Mechanical Turk to resolve the inconsistent annotations between datasets . Different from MSeg , our solution does not require any manual effort and unifies the label space directly from visual data in a fully automatic way . Wang et al . ( 2019 ) train a universal object detector on multiple datasets , and gain robustness by joining diverse sources of supervision . However , they produce a dataset-specific prediction for each input image . When evaluated in-domain , they require knowledge of the test domain . When evaluated out-of-domain , they produce multiple outputs for a single concept . This limits the generalization ability of detection , as we show in experiments ( Section . 5.2 ) . Our approach , on the other hand , merges visual concepts at training time and yields a single consistent model that does not require knowledge of the test domain and can be deployed cleanly in new domains . Both Wang et al . ( 2019 ) and MSeg ( Lambert et al. , 2020 ) observe a performance drop in a single unified model . With our unified label space and a dedicated training framework , this is not the case : the unified model performs as well as single-dataset models on the training datasets . Zhao et al . ( 2020 ) trains a universal detector on multiple datasets : COCO ( Lin et al. , 2014 ) , Pascal VOC ( Everingham et al. , 2010 ) , and SUN-RGBD ( Song et al. , 2015 ) , with under 100 classes in total . They manually merge the taxonomies and then train with cross-dataset pseudo-labels generated by dataset-specific models . The pseudo-label idea is complementary to our work . Our unified label space learning removes the manual labor , and works on a much larger scale : we unify COCO , Objects365 , and OpenImages , with more complex label spaces and 900+ classes . YOLO9000 ( Redmon & Farhadi , 2017 ) combines detection and classification datasets to expand the detection vocabulary . LVIS ( Gupta et al. , 2019 ) extents COCO annotations to > 1000 classes in a federated way . Our approach of fusing multiple readily annotated datasets is complementary and can be operationalized with no manual effort to unify disparate object detection datasets . Zero-shot classification and detection reason about novel object categories outside the training set ( Fu et al. , 2018 ; Bansal et al. , 2018 ) . This is often realized by representing a novel class by a semantic embedding ( Norouzi et al. , 2014 ) or auxiliary attribute annotations ( Farhadi et al. , 2009 ) . In zero-shot detection , Bansal et al . ( 2018 ) proposed a statically assigned background model to avoid novel classes being detected as background . Rahman et al . ( 2019 ) included the novel class word embedding in test-time training to progressively generate novel class labels . Li et al . ( 2019 ) leveraged external text descriptions for novel objects . Our program is complementary : we aim to build a sufficiently large label space by merging diverse detection datasets during training , such that the trained detector transfers well across domains even without machinery such as word embeddings or attributes . Such machinery can be added , if desired , to further expand the model ’ s vocabulary . 3 PRELIMINARIES . An object detector jointly predicts the locations bk ∈ R4 and classwise detection scores dk ∈ R|L| of all objects in a scene . The detection score describes the confidence that a bounding box belongs to an object with label l ∈ L , where L is the set of all classes . Figure 2a provides an overview . On a single dataset , the detector is trained to produce high scores only for the ground-truth class . Consider multiple datasets , each with its own label space L̂1 , L̂2 , . . .. A detector now needs to learn a common label space L for all datasets , and define a mapping between this common label space and dataset-specific labels L → L̂i . In this work , we only consider direct mappings . Each common label maps to at most one dataset-specific label per dataset , and each dataset-specific label maps to exactly one common label . In particular , we do not hierarchically relate concepts across datasets . When there are different label granularities between datasets , we keep them all in our label space , and expect to predict all of them . Mathematically , the mapping from the joint output space to a dataset-specific one is a Boolean linear transformation of the output of the recognition system d̂ik = T idk , with d̂ik ∈ R|L̂i| , T i ∈ { 0 , 1 } |L̂ i|×|L| , and constraints T i1 = 1 , T i > 1 ≤ 1 . The two constraints ensure that only direct mappings are learned . For simplicity , let T > = [ T 1 > . . . , T N > ] be the mapping to all dataset-specific output spaces . Figure 2b provides an overview . Prior work defined L and T by hand ( Lambert et al. , 2020 ; Zhao et al. , 2020 ) or used a trivial mapping T = I with completely disjoint outputs ( Wang et al. , 2019 ) . They then trained a detector given the fixed label space and mapping . In the next section , we show how to jointly learn the label space , the mapping to the individual datasets , and the detection scores in a globally optimal manner . 4 METHOD . We start with training a detector on the trivial disjoint label space ⋃ k L̂ k. In this section , we show how to automatically learn a unified label space by converting the disjoint label space into a unified label space . Once the unified label space is learned , we retrain the detector end-to-end with the unified label space . An overview of our workflow can be found in Appendix G 4.1 LEARNING A UNIFIED LABEL SPACE . We first consider only fine-tuning the last linear layer of the disjoint-label space detectpr . Specifically , let f1 , f2 , . . . be theD-dimensional features fi ∈ RD of the penultimate layer of the pretrained model for object locations b1 , b2 , . . . for all objects in a dataset . Our goal is to learn a new detection score dk = W > fk with parameters W = [ w1 , w2 , . . . , w|L| ] and wl ∈ RD , a label space L , and dataset-specific transformations T . The pretrained detector allows us to formulate this objective over a fixed set of precomputed detections and their features F = [ f1 , f2 , . . . ] : minimizeL , T , W ∑ l∈L ` l ( Tlw > l F ) + λ|L| ( 1 ) subject to T i1 = 1 and T i > 1 ≤ 1 ∀i∈ { 1 ... N } . Here ` l is a general loss function that factorizes over the labels l ∈ L , and N is the number of datasets . The weight wl controls the output of the detector for the joint label l , and Tl is a column of the dataset-specific transformation that maps each joint label l to all training datasets . The cardinality penalty λ|L| encourages a small and compact label set . A factorization of the loss ` l over the output space l ∈ L may seem restrictive . However , it does include the most common loss functions in detection : sigmoid cross-entropy and mean average precision . Section 4.2 discusses the exact loss functions used in our optimization . For a fixed label set L and mapping T , objective 1 reduces to a standard training objective of a detector . However , the joint optimization of L and T significantly complicates the optimization . It mixes combinatorial optimization over L with continuous optimization of W , and a 0-1 integer program over T . However , there is a simple reparametrization that lends itself to efficient optimization . First , observe that the label set L simply corresponds to the number of columns in T . Furthermore , we merge at most one label per dataset T i > 1 ≤ 1 . Hence , for each dataset i a column T il ∈ Ti takes one of |L̂i| + 1 values : Ti = { 0 , 1l̂1 , 1l̂2 , . . . } , where 1l̂ ∈ { 0 , 1 } |L̂i| is an indicator vector . Each column Tl ∈ T then only chooses from a small set of potential values T = T1 × T2 × . . . , where × represents the Cartesian product . Instead of optimizing over the label set L and transformation T directly , we instead use combinatorial optimization over the potential column values of t ∈ T. Let xt ∈ { 0 , 1 } be the indicator of combination t ∈ T. In this combinatorial formulation , the constraint T i1 = 1 translates to ∑ t∈T|tl̂=1 xt = 1 for all dataset-specific labels l̂ . Furthermore , the objective of the optimization simplifies to∑ l∈L ` l ( Tlw > l F ) + λ|L| = ∑ t∈T xt ` l ( tw > t F ) + λ ∑ t∈T xt . ( 2 ) Crucially , the weights wt of the detection score are now independent of the combinatorial optimization , and can be precomputed for each column value t ∈ T in a merge cost : ct = min wt ` t ( tw > t F ) . ( 3 ) This leads to a compact integer linear programming formulation of objective 1 : minimizex ∑ t∈T xt ( ct + λ ) subject to ∑ t∈T|tl̂=1 xt = 1 ∀l̂ ( 4 ) For two datasets , the above objective is equivalent to a weighted bipartite matching . For a higher number of datasets , it reduces to weighted graph matching and is NP-hard , but is practically solvable with integer linear programming ( Linderoth & Ralphs , 2005 ) . One of the most appealing properties of the above formulation is that it separates the integer optimization over xt from the continuous optimization of the last linear layer wt . Section 4.2 explores this separation and shows how to precompute the merge cost ct for various loss functions . One major drawback of the combinatorial reformulation is that the set of potential combinations T grows exponentially in the number of datasets used : |T| = O ( |L̂1||L̂2||L̂3| . . . ) . However , most merges t ∈ T are arbitrary combinations of labels and incur a large merge cost ct . Section 4.3 presents a linear-time greedy enumeration algorithm for low-cost merges . Considering only low-cost matches , standard integer linear programming solvers find an optimal solution within a second for all label spaces we tried , even for |L| > 600 and up to 6 datasets . | The paper proposes to learn object detection model, while training on different datasets with different, potentially overlapping, label spaces. While previous methods do the label space mapping, from each dataset specific label space to the common universal label space, manually, this paper proposes to learn such mapping automatically. The proposed models work as well as dataset-specific models on resp. training datasets and generalize far better. | SP:2eba253ff91a7543c5269403292f66cb93b68a8d |
Learning a unified label space | 2 1 INTRODUCTION . Computer vision aims to produce broad , general-purpose perception systems that work in the wild . Yet object detection is fragmented into datasets ( Lin et al. , 2014 ; Neuhold et al. , 2017 ; Shao et al. , 2019 ; Kuznetsova et al. , 2020 ) and our models are locked into specific domains . This fragmentation brought rapid progress in object detection ( Ren et al. , 2015 ) and instance segmentation ( He et al. , 2017 ) , but comes with a drawback . Single datasets are limited and do not yield general-purpose recognition systems . Can we alleviate these limitations by unifying diverse detection datasets ? In this paper , we make training an object detector on the union of disparate datasets as straightforward as training on a single one . The core challenge lies in integrating different datasets into a common taxonomy and label space . A traditional approach is to create this taxonomy by hand ( Lambert et al. , 2020 ; Zhao et al. , 2020 ) , which is both time-consuming and error-prone . We present a fully automatic way to unify the output space of a multi-dataset detection system using visual data only . We use the fact that object detectors for similar concepts from different datasets fire on similar novel objects . This allows us to define the cost of merging concepts across datasets , and optimize for a common taxonomy fully automatically . Our optimization jointly finds a unified taxonomy , a mapping from this taxonomy to each dataset , and a detector over the unified taxonomy using a novel 0-1 integer programming formulation . An object detector trained on this unified taxonomy has a large , automatically constructed vocabulary of concepts from all training datasets . We evaluate our unified object detector at an unprecedented scale . We train a unified detector on 4 large and diverse datasets : COCO ( Lin et al. , 2014 ) , Objects365 ( Shao et al. , 2019 ) , OpenImages ( Kuznetsova et al. , 2020 ) , and Mapillary ( Neuhold et al. , 2017 ) . Experiments show that our learned taxonomy outperforms the best expert-annotated label spaces , as well as language-based alternatives . For the first time , we show that a single detector performs as well as dataset-specific models on each individual dataset . Crucially , we show that models trained on the diverse training sets generalize zero-shot to new domains , and outperform single-dataset models . Our models ranked first in the object detection and instance segmentation tracks of the ECCV 2020 Robust Vision Challenge across all evaluation datasets . Code and models will be released upon acceptance . 2 RELATED WORK . Training on multiple datasets . In recent years , training on multiple diverse datasets has emerged as an effective tool to improve model robustness for depth estimation ( Ranftl et al. , 2020 ) and stereo matching ( Yang et al. , 2019 ) . In these domains unifying the output space involves modeling different camera models and depth ambiguities . In contrast , for recognition , the unification involves merging different semantic concepts . MSeg ( Lambert et al. , 2020 ) manually created a unified label taxonomy of 7 semantic segmentation datasets and used Amazon Mechanical Turk to resolve the inconsistent annotations between datasets . Different from MSeg , our solution does not require any manual effort and unifies the label space directly from visual data in a fully automatic way . Wang et al . ( 2019 ) train a universal object detector on multiple datasets , and gain robustness by joining diverse sources of supervision . However , they produce a dataset-specific prediction for each input image . When evaluated in-domain , they require knowledge of the test domain . When evaluated out-of-domain , they produce multiple outputs for a single concept . This limits the generalization ability of detection , as we show in experiments ( Section . 5.2 ) . Our approach , on the other hand , merges visual concepts at training time and yields a single consistent model that does not require knowledge of the test domain and can be deployed cleanly in new domains . Both Wang et al . ( 2019 ) and MSeg ( Lambert et al. , 2020 ) observe a performance drop in a single unified model . With our unified label space and a dedicated training framework , this is not the case : the unified model performs as well as single-dataset models on the training datasets . Zhao et al . ( 2020 ) trains a universal detector on multiple datasets : COCO ( Lin et al. , 2014 ) , Pascal VOC ( Everingham et al. , 2010 ) , and SUN-RGBD ( Song et al. , 2015 ) , with under 100 classes in total . They manually merge the taxonomies and then train with cross-dataset pseudo-labels generated by dataset-specific models . The pseudo-label idea is complementary to our work . Our unified label space learning removes the manual labor , and works on a much larger scale : we unify COCO , Objects365 , and OpenImages , with more complex label spaces and 900+ classes . YOLO9000 ( Redmon & Farhadi , 2017 ) combines detection and classification datasets to expand the detection vocabulary . LVIS ( Gupta et al. , 2019 ) extents COCO annotations to > 1000 classes in a federated way . Our approach of fusing multiple readily annotated datasets is complementary and can be operationalized with no manual effort to unify disparate object detection datasets . Zero-shot classification and detection reason about novel object categories outside the training set ( Fu et al. , 2018 ; Bansal et al. , 2018 ) . This is often realized by representing a novel class by a semantic embedding ( Norouzi et al. , 2014 ) or auxiliary attribute annotations ( Farhadi et al. , 2009 ) . In zero-shot detection , Bansal et al . ( 2018 ) proposed a statically assigned background model to avoid novel classes being detected as background . Rahman et al . ( 2019 ) included the novel class word embedding in test-time training to progressively generate novel class labels . Li et al . ( 2019 ) leveraged external text descriptions for novel objects . Our program is complementary : we aim to build a sufficiently large label space by merging diverse detection datasets during training , such that the trained detector transfers well across domains even without machinery such as word embeddings or attributes . Such machinery can be added , if desired , to further expand the model ’ s vocabulary . 3 PRELIMINARIES . An object detector jointly predicts the locations bk ∈ R4 and classwise detection scores dk ∈ R|L| of all objects in a scene . The detection score describes the confidence that a bounding box belongs to an object with label l ∈ L , where L is the set of all classes . Figure 2a provides an overview . On a single dataset , the detector is trained to produce high scores only for the ground-truth class . Consider multiple datasets , each with its own label space L̂1 , L̂2 , . . .. A detector now needs to learn a common label space L for all datasets , and define a mapping between this common label space and dataset-specific labels L → L̂i . In this work , we only consider direct mappings . Each common label maps to at most one dataset-specific label per dataset , and each dataset-specific label maps to exactly one common label . In particular , we do not hierarchically relate concepts across datasets . When there are different label granularities between datasets , we keep them all in our label space , and expect to predict all of them . Mathematically , the mapping from the joint output space to a dataset-specific one is a Boolean linear transformation of the output of the recognition system d̂ik = T idk , with d̂ik ∈ R|L̂i| , T i ∈ { 0 , 1 } |L̂ i|×|L| , and constraints T i1 = 1 , T i > 1 ≤ 1 . The two constraints ensure that only direct mappings are learned . For simplicity , let T > = [ T 1 > . . . , T N > ] be the mapping to all dataset-specific output spaces . Figure 2b provides an overview . Prior work defined L and T by hand ( Lambert et al. , 2020 ; Zhao et al. , 2020 ) or used a trivial mapping T = I with completely disjoint outputs ( Wang et al. , 2019 ) . They then trained a detector given the fixed label space and mapping . In the next section , we show how to jointly learn the label space , the mapping to the individual datasets , and the detection scores in a globally optimal manner . 4 METHOD . We start with training a detector on the trivial disjoint label space ⋃ k L̂ k. In this section , we show how to automatically learn a unified label space by converting the disjoint label space into a unified label space . Once the unified label space is learned , we retrain the detector end-to-end with the unified label space . An overview of our workflow can be found in Appendix G 4.1 LEARNING A UNIFIED LABEL SPACE . We first consider only fine-tuning the last linear layer of the disjoint-label space detectpr . Specifically , let f1 , f2 , . . . be theD-dimensional features fi ∈ RD of the penultimate layer of the pretrained model for object locations b1 , b2 , . . . for all objects in a dataset . Our goal is to learn a new detection score dk = W > fk with parameters W = [ w1 , w2 , . . . , w|L| ] and wl ∈ RD , a label space L , and dataset-specific transformations T . The pretrained detector allows us to formulate this objective over a fixed set of precomputed detections and their features F = [ f1 , f2 , . . . ] : minimizeL , T , W ∑ l∈L ` l ( Tlw > l F ) + λ|L| ( 1 ) subject to T i1 = 1 and T i > 1 ≤ 1 ∀i∈ { 1 ... N } . Here ` l is a general loss function that factorizes over the labels l ∈ L , and N is the number of datasets . The weight wl controls the output of the detector for the joint label l , and Tl is a column of the dataset-specific transformation that maps each joint label l to all training datasets . The cardinality penalty λ|L| encourages a small and compact label set . A factorization of the loss ` l over the output space l ∈ L may seem restrictive . However , it does include the most common loss functions in detection : sigmoid cross-entropy and mean average precision . Section 4.2 discusses the exact loss functions used in our optimization . For a fixed label set L and mapping T , objective 1 reduces to a standard training objective of a detector . However , the joint optimization of L and T significantly complicates the optimization . It mixes combinatorial optimization over L with continuous optimization of W , and a 0-1 integer program over T . However , there is a simple reparametrization that lends itself to efficient optimization . First , observe that the label set L simply corresponds to the number of columns in T . Furthermore , we merge at most one label per dataset T i > 1 ≤ 1 . Hence , for each dataset i a column T il ∈ Ti takes one of |L̂i| + 1 values : Ti = { 0 , 1l̂1 , 1l̂2 , . . . } , where 1l̂ ∈ { 0 , 1 } |L̂i| is an indicator vector . Each column Tl ∈ T then only chooses from a small set of potential values T = T1 × T2 × . . . , where × represents the Cartesian product . Instead of optimizing over the label set L and transformation T directly , we instead use combinatorial optimization over the potential column values of t ∈ T. Let xt ∈ { 0 , 1 } be the indicator of combination t ∈ T. In this combinatorial formulation , the constraint T i1 = 1 translates to ∑ t∈T|tl̂=1 xt = 1 for all dataset-specific labels l̂ . Furthermore , the objective of the optimization simplifies to∑ l∈L ` l ( Tlw > l F ) + λ|L| = ∑ t∈T xt ` l ( tw > t F ) + λ ∑ t∈T xt . ( 2 ) Crucially , the weights wt of the detection score are now independent of the combinatorial optimization , and can be precomputed for each column value t ∈ T in a merge cost : ct = min wt ` t ( tw > t F ) . ( 3 ) This leads to a compact integer linear programming formulation of objective 1 : minimizex ∑ t∈T xt ( ct + λ ) subject to ∑ t∈T|tl̂=1 xt = 1 ∀l̂ ( 4 ) For two datasets , the above objective is equivalent to a weighted bipartite matching . For a higher number of datasets , it reduces to weighted graph matching and is NP-hard , but is practically solvable with integer linear programming ( Linderoth & Ralphs , 2005 ) . One of the most appealing properties of the above formulation is that it separates the integer optimization over xt from the continuous optimization of the last linear layer wt . Section 4.2 explores this separation and shows how to precompute the merge cost ct for various loss functions . One major drawback of the combinatorial reformulation is that the set of potential combinations T grows exponentially in the number of datasets used : |T| = O ( |L̂1||L̂2||L̂3| . . . ) . However , most merges t ∈ T are arbitrary combinations of labels and incur a large merge cost ct . Section 4.3 presents a linear-time greedy enumeration algorithm for low-cost merges . Considering only low-cost matches , standard integer linear programming solvers find an optimal solution within a second for all label spaces we tried , even for |L| > 600 and up to 6 datasets . | The main idea of the proposed work is to learn a universal label space for a given task (say object detection) and a set of different datasets with semantically overlapping labels. The only supervision required by the approach is constituted by the single dataset label spaces and respective annotations. Each dataset label space may have partial o complete overlaps (e.g. rider mapping to cyclist and motorcyclist ). The approach exploits a pre-trained detector on the trivial label space given by the union of all label spaces as a starting point. An optimization problem jointly minimizing some loss taking into account the task error with a penalization on the cardinality of the label set. | SP:2eba253ff91a7543c5269403292f66cb93b68a8d |
Towards Multi-Sense Cross-Lingual Alignment of Contextual Embeddings | 1 INTRODUCTION . Cross-lingual word embeddings ( CLWE ) provide a shared representation space for knowledge transfer between languages , yielding state-of-the-art performance in many cross-lingual natural language processing ( NLP ) tasks . Most of the previous works have focused on aligning static embeddings . To utilize the richer information captured by the pre-trained language model , more recent approaches attempt to extend previous methods to align contextual representations . Aligning the dynamic and complex contextual spaces poses significant challenges , so most of the existing approaches only perform coarse-grained alignment . Schuster et al . ( 2019 ) compute the average of contextual embeddings for each word as an anchor , and then learn to align the static anchors using a bilingual dictionary . In another work , Aldarmaki & Diab ( 2019 ) use parallel sentences in their approach , where they compute sentence representations by taking the average of contextual word embeddings , and then they learn a projection matrix to align sentence representations . They find that the learned projection matrix also works well for word-level NLP tasks . Besides , unsupervised multilingual language models ( Devlin et al. , 2018 ; Artetxe & Schwenk , 2019 ; Conneau et al. , 2019 ; Liu et al. , 2020 ) pretrained on multilingual corpora have also demonstrated strong cross-lingual transfer performance . Cao et al . ( 2020 ) and Wang et al . ( 2020 ) show that unsupervised multilingual language model can be further aligned with parallel sentences . Though contextual word embeddings are intended to provide different representations of the same word in distinct contexts , Schuster et al . ( 2019 ) find that the contextual embeddings of different senses of one word are much closer compared with that of different words . This contributes to the anisomorphic embedding distribution of different languages and causes problems for cross-lingual alignment . For example , it will be difficult to align the English word bank and its Japanese translations 銀行 and岸 that correspond to its two different senses , since the contextual embeddings of different senses of bank are close to each other while those of 銀行 and 岸 are far . Recently , Zhang et al . ( 2019 ) propose two solutions to handle multi-sense words : 1 ) remove multi-sense words and then align anchors in the same way as Schuster et al . ( 2019 ) ; 2 ) generate cluster level average anchor for contextual embeddings of multi-sense words and then learn a projection matrix in an unsupervised way with MUSE ( Conneau et al. , 2017 ) . They do not make good use of the bilingual dictionaries , which are usually easy to obtain , even in low-resource scenarios . Moreover , their projection-based approach still can not handle the anisomorphic embedding distribution problem . In this work , we propose a novel sense-aware cross entropy loss to model multiple word senses explicitly , and then leverage a sense level translation task on top of it for cross-lingual model pretraining . The proposed sense level translation task enables our models to provide more isomorphic and better aligned cross-lingual embeddings . We only use the cross-lingual signal from bilingual dictionaries for supervision . Our pretrained models demonstrate consistent performance improvements on zero-shot cross-lingual NER , sentiment classification and XNLI tasks . Though pretrained on less data , our model achieves the state-of-the-art result on zero-shot cross-lingual German NER task . To the best of our knowledge , we are the first to perform sense-level contextual embedding alignment with only bilingual dictionaries . 2 BACKGROUND : PREDICTION TASKS OF LANGUAGE MODELS . Next token prediction and masked token prediction are two common tasks in neural language model pretraining . We take two well-known language models , ELMo ( Peters et al. , 2018 ) and BERT ( Devlin et al. , 2018 ) , as examples to illustrate these two tasks ( architectures are shown in Appendix A ) . Next token prediction ELMo uses next token prediction tasks in a bidirectional language model . Given a sequence of N tokens ( t1 , t2 , . . . , tN ) , it first prepares a context independent representation for each token by using a convolutional neural network over the characters or by word embedding lookup ( a.k.a . input embeddings ) . These representations are then fed into L layers of LSTMs to generate the contextual representations : hi , j for token ti at layer j . The model assigns a learnable output embedding w for each token in the vocabulary , which has the same dimension as hi , L . Then , the forward language model predicts the token at position k with : p ( tk|t1 , t2 , . . . , tk−1 ) = softmax ( hTk−1 , Lwk′ ) = exp ( hTk−1 , Lwk′ ) ∑V i=1 exp ( h T k−1 , Lwi ) ( 1 ) where k′ is the index of token tk in the vocabulary , V is the size of the vocabulary , and ( w1 , . . . , wV ) are the output embeddings for the tokens in the vocabulary . The backward language model is similar to the forward one , except that tokens are predicted in the reverse order . Since the forward and backward language models are very similar , we will only describe our proposed approach in the context of the forward language model in the subsequent sections . Masked token prediction The Masked Language Model ( MLM ) in BERT is a typical example of masked token prediction . Given a sequence ( t1 , t2 , . . . , tN ) , this approach randomly masks a certain percentage ( 15 % ) of the tokens and generates a masked sequence ( m1 , m2 , . . . , mN ) , where mk = [ mask ] if the token at position k is masked , otherwise mk = tk . BERT first prepares the context independent representations ( x1 , x2 , . . . , xN ) of the masked sequence via token embeddings . It is then fed into L layers of transformer encoder ( Vaswani et al. , 2017 ) to generate “ bidirectional ” contextual token representations . The final layer representations are then used to predict the masked token at position k as follows : p ( mk = tk|m1 , . . . , mN ) = softmax ( hTk , Lwk′ ) = exp ( hTk , Lwk′ ) ∑V i=1 exp ( h T k , Lwi ) ( 2 ) where k′ , V , h and w are similarly defined as in Eq . 1 . Unlike ELMo , BERT ties the input and output embeddings . 3 PROPOSED FRAMEWORK . We first describe our proposed sense-aware cross entropy loss to model multiple word senses explicitly in language model pretraining . Then , we present our joint training approach with sense alignment objective for cross-lingual mapping of contextual word embeddings . The proposed framework can be applied to most of the recent neural language models , such as ELMo , BERT and their variants . See Table 1 for a summary of the main notations used in this paper . 3.1 SENSE-AWARE CROSS ENTROPY LOSS Table 1 : Summary of the main notations Notation Description tk k-th token in sentence tk , s s-th sense of tk k′ index of token tk in vocabulary L number of LSTM/Transformer layers V size of vocabulary S maximum number of senses per token hk , j contextual representation of token tk in layer j hk∗ , L contextual representation used in softmax function for predicting tk vi i-th word in vocabulary vi , s s-th sense of vi wi output embedding of vi wi , s context-dependent output embedding ( i.e . sense vector ) of vi , s ci , s sense cluster center of vi , s Ci sense cluster centers of vi d dimension of contextual representations P projection matrix for dimension reduction Limitations of original training objectives The training tasks with Eq . 1 and 2 maximize the normalized dot product of contextual representations ( hk−1 , L or hk , L ) with a weight vector wk′ . The only difference is that hk−1 , L in Eq . 1 encodes the information of previous tokens in the sequence , while hk , L in Eq . 2 encodes the information of the masked sequence . Therefore , without loss of generality , we use hk∗ , L to denote the contextual representation for predicting the next or masked token tk . Even though contextual language models like ELMo and BERT provide a different token representation for each distinct context , the learned representations are not guaranteed to be sense separated . For example , Schuster et al . ( 2019 ) computed the average of ELMo embeddings for each word as an anchor , and found that the average cosine distance between contextual embeddings of multi-sense words and their corresponding anchors are much smaller than the average distance between anchors , which mean that the embeddings of different senses of one word are relatively near to each other comparing to that of different words . We also observed the same with BERT embeddings . This finding suggests that sense clusters of a multi-sense word ’ s appearances are not well separated in the embedding space , and the current contextual language models still have room for improvement by considering finer-grained word sense disambiguation . Notice that there is only one weight vector wk′ for predicting the token tk in the original training tasks . Ideally , we should treat the appearances of a multi-sense word in different contexts as different tokens , and train the language models to predict different senses of the word . In the following , we propose a novel sense-aware cross entropy loss to explicitly model different senses of a word in different contexts . Sense-aware cross entropy loss Given a sequence ( t1 , t2 , . . . , tN ) , our proposed framework generates contextual representations ( hk , j for token tk in layer j ∈ { 1 , . . . , L } ) in the same way as the standard LMs . Different from existing methods , our approach maintains multiple context-dependent output embeddings ( henceforth , sense vectors ) for each token . Specifically , let S be the maximum number of senses per token . Each word vi in the vocabulary contains S separate sense vectors ( wi,1 , wi,2 , . . . , wi , S ) , where each wi , s corresponds to a different sense ( see Appendix for some interesting visualization examples ) . Following the notation in Section 2 , we use k′ to denote the index of the output token tk in the vocabulary . Therefore , the sense vectors of tk can be represented by ( wk′,1 , wk′,2 , . . . , wk′ , S ) , which are randomly initialized and of the same dimension as hk∗ , L . Note that we untie the input and output embeddings in our framework . We propose a word sense selection method shown in Algorithm 1 to select the most likely sense vector when training with sense-level cross entropy loss . Figure 1 shows the architecture of our proposed models . Assuming sense s′ is selected for token tk ( which means sense vector wk′ , s′ should be used ) , we have the following new prediction task : p ( tk , s′ |context ) = softmax ( hTk∗ , Lwk′ , s′ ) = exp ( hTk∗ , Lwk′ , s′ ) ∑V i=1 ∑S s=1 exp ( h T k∗ , Lwi , s ) ( 3 ) The sense-aware cross entropy loss for word sense prediction is defined as follows : LSENSE = − log ( p ( tk , s′ |context ) ) ( 4 ) Word sense selection algorithm Word sense selection when training the language model can be handled as a non-stationary data stream clustering problem ( Aggarwal et al. , 2004 ; Khalilian & Mustapha , 2010 ; Abdullatif et al. , 2018 ) . The most intuitive way to select the corresponding sense 1Since the backward language model is similar to the forward , we only show the forward one for simplicity . vector for hk∗ , L is to select the vector wk′ , s with the maximum dot product value hTk∗ , Lwk′ , s , or cosine similarity value cossim ( hk∗ , L , wk′ , s ) . However , our experiments show that these methods do not work well due to curse of dimensionality , suboptimal learning rate and noisy hk∗ , L . We apply an online k-means algorithm to cluster different senses of a word in Algorithm 1 . For each sense vector wi , s , we maintain a cluster center ci , s which is of the same dimension as wi , s . Therefore , each token vi in the vocabulary has S such cluster center vectors , denoted by Ci = ( ci,1 , ci,2 , . . . , ci , S ) . When predicting token tk in a given sequence , we apply Algorithm 1 to select the best sense vector based on hk , L ( see Figure 1 ) . Notice that hk , L is different from hk∗ , L for next token prediction ( Figure 1a ) for which hk∗ , L = hk−1 , L . The cluster centers Ci are not neural network parameters ; instead , they are randomly initialized using a normal distribution N ( 0 , σ2 ) and updated through Algorithm 1 . In addition , we also maintain a projection matrix P for dimension reduction to facilitate effective sense clustering . P ∈ Rd×d′ projects hk , L and ci , s from dimension d to d′ , and is shared by all tokens in vocabulary . Similar to C , P is also randomly initialized with normal distribution N ( 0 , 1 ) , and then updated through Algorithm 2 . Both Algorithm 1 and 2 run in parallel , and are interrupted when the language model stops training . Some rationales behind our algorithm design are the following : Algorithm 1 Word sense selection 1 : Hyper-parameters : number of senses S , sense learning rate α 2 : Initialize the set of all sense cluster centers C 3 : repeat 4 : input : hk , L , vocabulary index k′ of the token to predict 5 : Lookup sense cluster centers for k′ : Ck′ = { ck′,1 , ck′,2 , . . . , ck′ , S } 6 : P = updated projection matrix from Alg . 2 7 : if cosine similarity between ck′ , s′P and h′kP is the largest among the vectors in Ck′ then 8 : ck′ , s′ = ( 1− α ) ck′ , s′ + αhk , L 9 : output : s′ ( wk′ , s′ should be selected ) 10 : end if 11 : until interrupted Algorithm 2 Projection matrix P update 1 : Hyper-parameters : projection dimension d′ , up- date interval M , queue size Q 2 : Initialize P withN ( 0 , 1 ) , queue H = ∅ , m = 0 3 : repeat 4 : input : hk , L 5 : m = m+ 1 6 : Add hk , L to queue H 7 : if size ( H ) > Q then 8 : Pop the oldest element from queue H . 9 : end if 10 : if m > =M then 11 : P = the first d′ PCA components of H 12 : m = 0 13 : end if 14 : output : P 15 : until interrupted • Directly computing cosine similarity between ck′ , s and hk , L suffers from the curse of dimensionality . We maintain P for dimension reduction . Although many algorithms use random projection for dimension reduction , we find using PCA components can help improve clustering accuracy . • Since the neural model parameters keep being updated during training , the sense clusters become non-stationary , i.e. , their locations keep changing . Experiments shows that when using P for dimension reduction , a slightly larger projection dimension d′ will make the clustering algorithm less sensitive to cluster location change . We use d′ = 16 for ELMo , and d′ = 14 for BERT . We also notice that the sense clustering works well even if P is updated sporadically . We can set a relatively large update interval in Algorithm 2 to reduce computation cost . • A separate sense learning rate α should be set for the clustering algorithm . A large α makes the algorithm less robust to noise , while a small α leads to slow convergence . • It is essential to use the current token ’ s contextual representation hk , L for sense selection even though we use hk∗ , L = hk−1 , L in the next token prediction task . If we use hk−1 , L for sense selection , experiments show that most of the variance comes from input embedding xk−1 . This introduces too much noise for word sense clustering . Dynamic pruning of redundant word senses To make the training more efficient , we keep track of relative sense selection frequency for each token in the vocabulary . Assume token vi has initial senses ( vi,1 , vi,2 , . . . , vi , S ) , for which we compute the relative frequency ρ ( vi , s ) such that 0 ≤ ρ ( vi , s ) ≤ 1 and ∑ s ρ ( vi , s ) = 1 . A lower ρ ( vi , s ) means the sense is less frequently selected compared with others . We check the relative frequencies after every E training steps , and if ρ ( vi , s ) < β ( a threshold hyper-parameter ) , vi , s is removed from the list of senses of vi . Remark on model size and parameters The sense cluster centers C and the projection matrix P are only used to facilitate sense selection during model pretraining , which are not neural model parameters . The sense vectors wi , s will no longer be used after pretraining , which can also be discarded . Therefore , our models and the original models have exactly the same number of parameters when transferred to downstream tasks . Remark on model complexity The computational complexity of our algorithm is linear with respect to the size of data , so our method is scalable to train on very large datasets . | This paper proposes the alignment of cross-lingual contextual embeddings not just at the word level, but at the sense level. It does this by relying purely on unaligned, unlabeled monolingual corpora used for pre-training, along with bilingual lexica. It does this by adapting the LM objective to be a sense-aware cross entropy loss, in which the sense is obtained by the use of a streaming k-means clustering algorithm combined with dimensionality reduction. If a bilingual lexicon is available, a sense-level translation objective can be added to encourage the model to predict the same sense in the other language (thereby encouraging identical senses of a word in the two languages to be closer together). | SP:643501d344b4a7404916431d0a56aba58c354e79 |
Towards Multi-Sense Cross-Lingual Alignment of Contextual Embeddings | 1 INTRODUCTION . Cross-lingual word embeddings ( CLWE ) provide a shared representation space for knowledge transfer between languages , yielding state-of-the-art performance in many cross-lingual natural language processing ( NLP ) tasks . Most of the previous works have focused on aligning static embeddings . To utilize the richer information captured by the pre-trained language model , more recent approaches attempt to extend previous methods to align contextual representations . Aligning the dynamic and complex contextual spaces poses significant challenges , so most of the existing approaches only perform coarse-grained alignment . Schuster et al . ( 2019 ) compute the average of contextual embeddings for each word as an anchor , and then learn to align the static anchors using a bilingual dictionary . In another work , Aldarmaki & Diab ( 2019 ) use parallel sentences in their approach , where they compute sentence representations by taking the average of contextual word embeddings , and then they learn a projection matrix to align sentence representations . They find that the learned projection matrix also works well for word-level NLP tasks . Besides , unsupervised multilingual language models ( Devlin et al. , 2018 ; Artetxe & Schwenk , 2019 ; Conneau et al. , 2019 ; Liu et al. , 2020 ) pretrained on multilingual corpora have also demonstrated strong cross-lingual transfer performance . Cao et al . ( 2020 ) and Wang et al . ( 2020 ) show that unsupervised multilingual language model can be further aligned with parallel sentences . Though contextual word embeddings are intended to provide different representations of the same word in distinct contexts , Schuster et al . ( 2019 ) find that the contextual embeddings of different senses of one word are much closer compared with that of different words . This contributes to the anisomorphic embedding distribution of different languages and causes problems for cross-lingual alignment . For example , it will be difficult to align the English word bank and its Japanese translations 銀行 and岸 that correspond to its two different senses , since the contextual embeddings of different senses of bank are close to each other while those of 銀行 and 岸 are far . Recently , Zhang et al . ( 2019 ) propose two solutions to handle multi-sense words : 1 ) remove multi-sense words and then align anchors in the same way as Schuster et al . ( 2019 ) ; 2 ) generate cluster level average anchor for contextual embeddings of multi-sense words and then learn a projection matrix in an unsupervised way with MUSE ( Conneau et al. , 2017 ) . They do not make good use of the bilingual dictionaries , which are usually easy to obtain , even in low-resource scenarios . Moreover , their projection-based approach still can not handle the anisomorphic embedding distribution problem . In this work , we propose a novel sense-aware cross entropy loss to model multiple word senses explicitly , and then leverage a sense level translation task on top of it for cross-lingual model pretraining . The proposed sense level translation task enables our models to provide more isomorphic and better aligned cross-lingual embeddings . We only use the cross-lingual signal from bilingual dictionaries for supervision . Our pretrained models demonstrate consistent performance improvements on zero-shot cross-lingual NER , sentiment classification and XNLI tasks . Though pretrained on less data , our model achieves the state-of-the-art result on zero-shot cross-lingual German NER task . To the best of our knowledge , we are the first to perform sense-level contextual embedding alignment with only bilingual dictionaries . 2 BACKGROUND : PREDICTION TASKS OF LANGUAGE MODELS . Next token prediction and masked token prediction are two common tasks in neural language model pretraining . We take two well-known language models , ELMo ( Peters et al. , 2018 ) and BERT ( Devlin et al. , 2018 ) , as examples to illustrate these two tasks ( architectures are shown in Appendix A ) . Next token prediction ELMo uses next token prediction tasks in a bidirectional language model . Given a sequence of N tokens ( t1 , t2 , . . . , tN ) , it first prepares a context independent representation for each token by using a convolutional neural network over the characters or by word embedding lookup ( a.k.a . input embeddings ) . These representations are then fed into L layers of LSTMs to generate the contextual representations : hi , j for token ti at layer j . The model assigns a learnable output embedding w for each token in the vocabulary , which has the same dimension as hi , L . Then , the forward language model predicts the token at position k with : p ( tk|t1 , t2 , . . . , tk−1 ) = softmax ( hTk−1 , Lwk′ ) = exp ( hTk−1 , Lwk′ ) ∑V i=1 exp ( h T k−1 , Lwi ) ( 1 ) where k′ is the index of token tk in the vocabulary , V is the size of the vocabulary , and ( w1 , . . . , wV ) are the output embeddings for the tokens in the vocabulary . The backward language model is similar to the forward one , except that tokens are predicted in the reverse order . Since the forward and backward language models are very similar , we will only describe our proposed approach in the context of the forward language model in the subsequent sections . Masked token prediction The Masked Language Model ( MLM ) in BERT is a typical example of masked token prediction . Given a sequence ( t1 , t2 , . . . , tN ) , this approach randomly masks a certain percentage ( 15 % ) of the tokens and generates a masked sequence ( m1 , m2 , . . . , mN ) , where mk = [ mask ] if the token at position k is masked , otherwise mk = tk . BERT first prepares the context independent representations ( x1 , x2 , . . . , xN ) of the masked sequence via token embeddings . It is then fed into L layers of transformer encoder ( Vaswani et al. , 2017 ) to generate “ bidirectional ” contextual token representations . The final layer representations are then used to predict the masked token at position k as follows : p ( mk = tk|m1 , . . . , mN ) = softmax ( hTk , Lwk′ ) = exp ( hTk , Lwk′ ) ∑V i=1 exp ( h T k , Lwi ) ( 2 ) where k′ , V , h and w are similarly defined as in Eq . 1 . Unlike ELMo , BERT ties the input and output embeddings . 3 PROPOSED FRAMEWORK . We first describe our proposed sense-aware cross entropy loss to model multiple word senses explicitly in language model pretraining . Then , we present our joint training approach with sense alignment objective for cross-lingual mapping of contextual word embeddings . The proposed framework can be applied to most of the recent neural language models , such as ELMo , BERT and their variants . See Table 1 for a summary of the main notations used in this paper . 3.1 SENSE-AWARE CROSS ENTROPY LOSS Table 1 : Summary of the main notations Notation Description tk k-th token in sentence tk , s s-th sense of tk k′ index of token tk in vocabulary L number of LSTM/Transformer layers V size of vocabulary S maximum number of senses per token hk , j contextual representation of token tk in layer j hk∗ , L contextual representation used in softmax function for predicting tk vi i-th word in vocabulary vi , s s-th sense of vi wi output embedding of vi wi , s context-dependent output embedding ( i.e . sense vector ) of vi , s ci , s sense cluster center of vi , s Ci sense cluster centers of vi d dimension of contextual representations P projection matrix for dimension reduction Limitations of original training objectives The training tasks with Eq . 1 and 2 maximize the normalized dot product of contextual representations ( hk−1 , L or hk , L ) with a weight vector wk′ . The only difference is that hk−1 , L in Eq . 1 encodes the information of previous tokens in the sequence , while hk , L in Eq . 2 encodes the information of the masked sequence . Therefore , without loss of generality , we use hk∗ , L to denote the contextual representation for predicting the next or masked token tk . Even though contextual language models like ELMo and BERT provide a different token representation for each distinct context , the learned representations are not guaranteed to be sense separated . For example , Schuster et al . ( 2019 ) computed the average of ELMo embeddings for each word as an anchor , and found that the average cosine distance between contextual embeddings of multi-sense words and their corresponding anchors are much smaller than the average distance between anchors , which mean that the embeddings of different senses of one word are relatively near to each other comparing to that of different words . We also observed the same with BERT embeddings . This finding suggests that sense clusters of a multi-sense word ’ s appearances are not well separated in the embedding space , and the current contextual language models still have room for improvement by considering finer-grained word sense disambiguation . Notice that there is only one weight vector wk′ for predicting the token tk in the original training tasks . Ideally , we should treat the appearances of a multi-sense word in different contexts as different tokens , and train the language models to predict different senses of the word . In the following , we propose a novel sense-aware cross entropy loss to explicitly model different senses of a word in different contexts . Sense-aware cross entropy loss Given a sequence ( t1 , t2 , . . . , tN ) , our proposed framework generates contextual representations ( hk , j for token tk in layer j ∈ { 1 , . . . , L } ) in the same way as the standard LMs . Different from existing methods , our approach maintains multiple context-dependent output embeddings ( henceforth , sense vectors ) for each token . Specifically , let S be the maximum number of senses per token . Each word vi in the vocabulary contains S separate sense vectors ( wi,1 , wi,2 , . . . , wi , S ) , where each wi , s corresponds to a different sense ( see Appendix for some interesting visualization examples ) . Following the notation in Section 2 , we use k′ to denote the index of the output token tk in the vocabulary . Therefore , the sense vectors of tk can be represented by ( wk′,1 , wk′,2 , . . . , wk′ , S ) , which are randomly initialized and of the same dimension as hk∗ , L . Note that we untie the input and output embeddings in our framework . We propose a word sense selection method shown in Algorithm 1 to select the most likely sense vector when training with sense-level cross entropy loss . Figure 1 shows the architecture of our proposed models . Assuming sense s′ is selected for token tk ( which means sense vector wk′ , s′ should be used ) , we have the following new prediction task : p ( tk , s′ |context ) = softmax ( hTk∗ , Lwk′ , s′ ) = exp ( hTk∗ , Lwk′ , s′ ) ∑V i=1 ∑S s=1 exp ( h T k∗ , Lwi , s ) ( 3 ) The sense-aware cross entropy loss for word sense prediction is defined as follows : LSENSE = − log ( p ( tk , s′ |context ) ) ( 4 ) Word sense selection algorithm Word sense selection when training the language model can be handled as a non-stationary data stream clustering problem ( Aggarwal et al. , 2004 ; Khalilian & Mustapha , 2010 ; Abdullatif et al. , 2018 ) . The most intuitive way to select the corresponding sense 1Since the backward language model is similar to the forward , we only show the forward one for simplicity . vector for hk∗ , L is to select the vector wk′ , s with the maximum dot product value hTk∗ , Lwk′ , s , or cosine similarity value cossim ( hk∗ , L , wk′ , s ) . However , our experiments show that these methods do not work well due to curse of dimensionality , suboptimal learning rate and noisy hk∗ , L . We apply an online k-means algorithm to cluster different senses of a word in Algorithm 1 . For each sense vector wi , s , we maintain a cluster center ci , s which is of the same dimension as wi , s . Therefore , each token vi in the vocabulary has S such cluster center vectors , denoted by Ci = ( ci,1 , ci,2 , . . . , ci , S ) . When predicting token tk in a given sequence , we apply Algorithm 1 to select the best sense vector based on hk , L ( see Figure 1 ) . Notice that hk , L is different from hk∗ , L for next token prediction ( Figure 1a ) for which hk∗ , L = hk−1 , L . The cluster centers Ci are not neural network parameters ; instead , they are randomly initialized using a normal distribution N ( 0 , σ2 ) and updated through Algorithm 1 . In addition , we also maintain a projection matrix P for dimension reduction to facilitate effective sense clustering . P ∈ Rd×d′ projects hk , L and ci , s from dimension d to d′ , and is shared by all tokens in vocabulary . Similar to C , P is also randomly initialized with normal distribution N ( 0 , 1 ) , and then updated through Algorithm 2 . Both Algorithm 1 and 2 run in parallel , and are interrupted when the language model stops training . Some rationales behind our algorithm design are the following : Algorithm 1 Word sense selection 1 : Hyper-parameters : number of senses S , sense learning rate α 2 : Initialize the set of all sense cluster centers C 3 : repeat 4 : input : hk , L , vocabulary index k′ of the token to predict 5 : Lookup sense cluster centers for k′ : Ck′ = { ck′,1 , ck′,2 , . . . , ck′ , S } 6 : P = updated projection matrix from Alg . 2 7 : if cosine similarity between ck′ , s′P and h′kP is the largest among the vectors in Ck′ then 8 : ck′ , s′ = ( 1− α ) ck′ , s′ + αhk , L 9 : output : s′ ( wk′ , s′ should be selected ) 10 : end if 11 : until interrupted Algorithm 2 Projection matrix P update 1 : Hyper-parameters : projection dimension d′ , up- date interval M , queue size Q 2 : Initialize P withN ( 0 , 1 ) , queue H = ∅ , m = 0 3 : repeat 4 : input : hk , L 5 : m = m+ 1 6 : Add hk , L to queue H 7 : if size ( H ) > Q then 8 : Pop the oldest element from queue H . 9 : end if 10 : if m > =M then 11 : P = the first d′ PCA components of H 12 : m = 0 13 : end if 14 : output : P 15 : until interrupted • Directly computing cosine similarity between ck′ , s and hk , L suffers from the curse of dimensionality . We maintain P for dimension reduction . Although many algorithms use random projection for dimension reduction , we find using PCA components can help improve clustering accuracy . • Since the neural model parameters keep being updated during training , the sense clusters become non-stationary , i.e. , their locations keep changing . Experiments shows that when using P for dimension reduction , a slightly larger projection dimension d′ will make the clustering algorithm less sensitive to cluster location change . We use d′ = 16 for ELMo , and d′ = 14 for BERT . We also notice that the sense clustering works well even if P is updated sporadically . We can set a relatively large update interval in Algorithm 2 to reduce computation cost . • A separate sense learning rate α should be set for the clustering algorithm . A large α makes the algorithm less robust to noise , while a small α leads to slow convergence . • It is essential to use the current token ’ s contextual representation hk , L for sense selection even though we use hk∗ , L = hk−1 , L in the next token prediction task . If we use hk−1 , L for sense selection , experiments show that most of the variance comes from input embedding xk−1 . This introduces too much noise for word sense clustering . Dynamic pruning of redundant word senses To make the training more efficient , we keep track of relative sense selection frequency for each token in the vocabulary . Assume token vi has initial senses ( vi,1 , vi,2 , . . . , vi , S ) , for which we compute the relative frequency ρ ( vi , s ) such that 0 ≤ ρ ( vi , s ) ≤ 1 and ∑ s ρ ( vi , s ) = 1 . A lower ρ ( vi , s ) means the sense is less frequently selected compared with others . We check the relative frequencies after every E training steps , and if ρ ( vi , s ) < β ( a threshold hyper-parameter ) , vi , s is removed from the list of senses of vi . Remark on model size and parameters The sense cluster centers C and the projection matrix P are only used to facilitate sense selection during model pretraining , which are not neural model parameters . The sense vectors wi , s will no longer be used after pretraining , which can also be discarded . Therefore , our models and the original models have exactly the same number of parameters when transferred to downstream tasks . Remark on model complexity The computational complexity of our algorithm is linear with respect to the size of data , so our method is scalable to train on very large datasets . | This paper proposes to introduce multiple senses into pre-trained models. The proposed method selects senses dynamically while pretraining the model and applies a sense-aware cross-entropy loss for pretraining. This paper further proposes to jointly pre-train a sense-aware cross-lingual model with sense-level translation. The proposed model yields better performance than the baseline models under both monolingual and cross-lingual setting. | SP:643501d344b4a7404916431d0a56aba58c354e79 |
Higher-order Structure Prediction in Evolving Graph Simplicial Complexes | 1 INTRODUCTION . Numerous types of networks like social ( Liben-Nowell & Kleinberg , 2007a ) , biological ( Airoldi et al. , 2006 ) , and chemical reaction networks ( Wegscheider , 1911 ) are highly dynamic , as they evolve and grow rapidly via the appearance of new interactions , represented as the introduction of new links / edges between the nodes of a network . Identifying the underlying mechanisms by which such networks evolve over time is a fundamental question that is not yet fully understood . Typically , insight into the temporal evolution of networks has been obtained via a classical inferential problem called link prediction , where given a snapshot of the network at time t along with its linkage pattern , the task is to assess whether a pair of nodes will be linked at a later time t′ > t. While inferring pairwise links is an important problem , it is oftentimes observed that most of the real-world graphs exhibit higher-order group-wise interactions that involve more than two nodes at once . Examples illustrating human group behavior involve a co-author relationship on a single paper and a network of e-mails to multiple recipients . In nature too , one can observe several proteins interacting together in a biological network simultaneously . In spite of their significance , in comparison to single edge inference , relatively fewer works have studied the problem of predicting higher-order group-wise interactions . Benson et al . ( 2018 ) originally introduced a simplex to model group-wise interactions between nodes in a graph . They proposed predicting a simplicial closure event , whereby an open simplex ( with just pairwise interactions between member vertices ) transitions to a closed simplex ( where all member vertices participate in the higher-order relationship simultaneously ) , in the near future . Figure 1 ( Middle ) shows an example of such a transition from an open triangle to a closed one . Recently , several works have proposed modeling higher-order interactions as hyperedges in a hypergraph ( Xu et al. , 2013 ; Zhang et al. , 2018 ; Yoon et al. , 2020 ; Patil et al. , 2020 ) . Given a hyperedge ht at time t , the inference task is to predict the future arrival of a new hyperedge ht′ , which covers a larger set of vertices than ht and contains all the vertices in ht . Figure 1 ( Right ) illustrates this hyperedge prediction task . Although prediction models based on either simplicial closure event prediction or hyperedge arrival , deal with higher-order structures , they both fail to capture the highly complex and non-linear evolution of higher-order structures over time . Both these kinds of models have two major limitations . First , they predict structures from a single static snapshot of the graph , thus not viewing the evolution process of adding new edges as a time process . Second , their feature extraction is mostly based on popular heuristics ( Adamic & Adar , 2003 ; Brin & Page , 2012 ; Jeh & Widom , 2002 ; Zhou et al. , 2009a ; Barabási & Albert , 1999 ; Bhatia et al. , 2019 ) that work well in practice but are not accompanied by strong theoretical guarantees . In addition to the aforementioned shortcomings , hypergraph based methods model higher-order structures as hyperedges , which omit lower-dimensional substructures present within a single hyperedge . As a consequence , they can not distinguish between various substructure relationships . For example , hyperedge [ A , B , C ] in Figure 1 ( Right ) can not distinguish between group relationships like [ [ A , B ] , [ B , C ] , [ A , C ] ] ( a set of pairwise interactions ) versus [ A , B , C ] ( all A , B and C simultaneously in a relationship ) . This problem is remedied by the use of simplices because they naturally model these substructures as a collection of subsets ( i.e. , faces ) of the simplex . We provide real-world examples of where our simplicial complex based approach can play a significant role . ( i ) Organic Chemistry : It is quite common to have the same set of elements interacting with each other in different configurations , which result in very different functioning compounds ( Ma et al. , 2011 ) . Specifically , R-thalidomide and S-thalidomide are two different configurations of thalidomide , where the R-form was meant to help sedate pregnant women , while the S-form unfortunately resulted in birth defects . This is a famous example in stereo chemistry to show the consequences of mistaking two extremely close configurations ( differing by a single bond ) as being the same . Structure prediction to avoid such phenomenon in drug synthesis allows chemists to achieve a much higher yield and avoid wastage of expensive resources . ( ii ) Gene expression networks : Gene networks have nodes that represent genes and edges connect genes which have similar expression patterns ( Zhang & Horvath , 2005 ) . Subgraphs called modules are tightly connected genes in such a gene expression network . Genomics research provides evidence that higher-order gene expression relationships ( like second and third-order ) and their measurements can have very important implications for cancer prognosis . When making structural predictions in these aforementioned examples , our simplicial complex based approach provides much more fine-grained control over competing methods by capturing subtler differences in configurations . To combat these challenges , our approach views the evolving graph1 as a time process under the framework of nonparametric time series prediction , which models the evolution of higher-order structures ( as simplices ) and their local neighborhoods ( spatial dimension ) over a moving time window ( temporal dimension ) . Our inference problem is then modeled as predicting the evolution to a higher-dimensional simplex at time t′ > t , given a simplex at time t. It is important to note that this task is more general and greatly diverges from the task proposed by Benson et al . ( 2018 ) . Our 1We handle the incremental model ( edge insertions only ) as opposed to the harder fully dynamic model ( edge insertions and deletions allowed ) for which most previous methods too can not provide theoretical guarantees . task requires just a single simplex σ in order to predict a higher-dimensional simplex τ , whose face / subset is σ , whereas Benson et al . ( 2018 ) requires the presence of all constituent σ faces in order to predict τ . For example , in Benson et al . ( 2018 ) ( also shown in Figure 1 ( Middle ) ) all faces [ A , B ] , [ B , C ] and [ A , C ] ( open triangle ) need to be present in order to predict a closed triangle [ A , B , C ] . Contrastingly , in our approach , just a single face/edge like [ A , B ] or [ B , C ] or [ A , C ] , suffices to predict its evolution to [ A , B , C ] . Figure 1 ( Left ) illustrates an additional example of our proposal to predict a 3-simplex [ A , B , C , D ] given only one of its faces [ A , B , C ] . To this effect , we succinctly capture the features characterizing the local neighborhood of a simplex as a combination of a face-vector ( Björner & Kalai , 2006 ) , which is a well-established vector signature in combinatorial topology literature and a novel scoring function which infers the affinity of sub-simplices based on the strength of their past interactions . Based on these features , we design a kernel estimator to infer future evolution to higher-dimensional simplices and prove both the consistency and asymptotic normality of our estimator . Our contributions : ( a ) We propose a kernel estimator that predicts higher-order interactions in an evolving network . ( b ) We prove the consistency and asymptotic normality of our kernel estimator . ( c ) We evaluate our method on real-world dynamic networks by proposing higher-order link prediction baselines and observe significant gains in prediction accuracy in comparison to the baselines . 1.1 RELATED STUDIES . Single link prediction : Most literature that predicts a single edge/link can be broadly classified as based on : ( i ) heuristics , ( ii ) random-walks , or ( iii ) graph neural networks ( GNNs ) . ( i ) Heuristic methods comprise of Common neighbors , Adamic-adar ( Adamic & Adar , 2003 ) , PageRank ( Brin & Page , 2012 ) , SimRank ( Jeh & Widom , 2002 ) , resource allocation ( Zhou et al. , 2009a ) , preferential attachment ( Barabási & Albert , 1999 ) , persistence homology based ranking ( Bhatia et al. , 2019 ) , and similarity-based methods ( Liben-Nowell & Kleinberg , 2007b ; Lü & Zhou , 2011 ) . ( ii ) Random walk based methods consist of DeepWalk ( Perozzi et al. , 2014 ) , Node2Vec ( Grover & Leskovec , 2016b ) and SpectralWalk ( Sharma et al. , 2020 ) . ( iii ) Finally , for both link prediction and node classification tasks , recent works are mainly GNN-based methods such as VGAE ( Kipf & Welling , 2016 ) , WYS ( Abu-El-Haija et al. , 2018 ) , and SEAL ( Zhang & Chen , 2018b ) . Higher-order link prediction : Benson et al . ( 2018 ) are the first to introduce a higher-order link prediction problem where they study the likelihoods of future higher-order group interactions as simplicial closure events ( explained earlier ) . Furthermore , there are studies using hypergraphs which also help naturally represent group relations ( Xu et al. , 2013 ; Zhang et al. , 2018 ; Yoon et al. , 2020 ; Patil et al. , 2020 ) . Especially , to represent higher-order relationships , Yoon et al . ( 2020 ) proposed n-projected graphs . For larger n , i.e. , higher-order groups , the enumeration of subsets , and keeping track of node co-occurrences quickly becomes infeasible . In comparison to a hypergraph , our graph simplicial complex is closed under taking subsets , which enables us to better encode more information for improved inference . 2 PRELIMINARY : GRAPH SIMPLICIAL COMPLEX ( GSC ) . We start with a general notion of an abstract simplicial complex ( ASC ) , then define a simplex using ASCs . We specialize this definition to graphs and define a graph simplicial complex ( GSC ) . Definition 1 ( Abstract simplicial complex and simplex ) . An abstract simplicial complex ( ASC ) is a collection A of finite non-empty sets , such that if σ is an element of A , then so is every nonempty subset of σ . The element σ of A is called a simplex of A ; its dimension is one less than the number of its elements . Now , we analyze graphs using the definition of ASCs . Let G = ( V , E ) be a finite graph with vertex set V and edge set E. A graph simpicial complex ( GSC ) G on G is an ASC consisting of subsets of V . In particular , G is a collection of subgraphs of G. With graphs , we denote a ddimensional simplex ( or d-simplex ) of a GSC by σ ( d ) = [ v0 , v1 , . . . , vd ] . Each non-empty subset of σ ( d ) is called a face of σ ( d ) . We define several notions related to GSCs , that are useful for describing the evolution of graphs . Definition 2 ( Filtered GSC ) . For I ⊂ N , a filtered GSC indexed over I is a family ( Gt ) t∈I of GSCs such that for every t ≤ t′ in I , Gt ⊂ Gt′ holds . Obviously , Gt0 ⊂ Gt1 ⊂ . . .Gtn is a discrete filtration induced by the arrival times of the simplices : Gti \ Gti−1 = σti . This depicts a higher-order analogue of an evolving graph ( incremental model ) , which allows attaching new simplices at each time-step to an existing GSC to build a new GSC . A filtered GSC Gt , p for the last p discrete time steps is defined as Gt , p : = ( Gt′ ) tt′=t−p = ( Gt−p , . . . , Gt ) , where Gt′ ⊃ Gt′−1 . We define a notion for dealing with the neighborhood around a given simplex σ ( d ) ∈ G. We introduce a set of all simplices of dimension d′ or less from G , i.e. , G ( d ′ ) − : = { σ ( d ) ∈ G | d ≤ d′ } . G ( 0 ) − is a vertex set and G ( 1 ) − is the set of edges and vertices . We also write i ∼ j whenever vertices i and j are adjacent in G ( 1 ) − , and write i ∼k j to indicate that vertex j is k-reachable from i , i.e. , there exists a path of length at most k , connecting i and j in G ( 1 ) − . Then , we define a ball around σ ( d ) . Definition 3 ( k-ball centered at vertex and simplex ) . At time t , we define a k-ball centered at vertex i by Bt , k ( i ) : = { j : i ∼k j and i , j ∈ G ( 0 ) t− } . We also define a k-ball centered at a simplex σ ( d ) as Bt , k ( σ ( d ) ) : = ⋃ i : Vert ( σ ( d ) ) Bt , k ( i ) , where Vert ( σ ( d ) ) denotes all vertexes in σ ( d ) . Now , we define a sub-complex G′t ( σ ( d ) ) ⊆ Gt as the GSC that contains all the simplices in Gt spanned by the vertices in the k-ball Bt , k ( σ ( d ) ) . | This paper presents an estimator that predict higher-order structure in time-varying graphs. The authors present an kernel-based estimator, prove that it is consistent when the indicator variable for whether a particular (d+1)-dimensional simplex is Bernoulli distributed with a function g. The authors prove that their estimator is asymptotically normal. The authors also present some experiments on real-world data | SP:7d5ca500bb1f17d91c8261ad94af85335278686a |
Higher-order Structure Prediction in Evolving Graph Simplicial Complexes | 1 INTRODUCTION . Numerous types of networks like social ( Liben-Nowell & Kleinberg , 2007a ) , biological ( Airoldi et al. , 2006 ) , and chemical reaction networks ( Wegscheider , 1911 ) are highly dynamic , as they evolve and grow rapidly via the appearance of new interactions , represented as the introduction of new links / edges between the nodes of a network . Identifying the underlying mechanisms by which such networks evolve over time is a fundamental question that is not yet fully understood . Typically , insight into the temporal evolution of networks has been obtained via a classical inferential problem called link prediction , where given a snapshot of the network at time t along with its linkage pattern , the task is to assess whether a pair of nodes will be linked at a later time t′ > t. While inferring pairwise links is an important problem , it is oftentimes observed that most of the real-world graphs exhibit higher-order group-wise interactions that involve more than two nodes at once . Examples illustrating human group behavior involve a co-author relationship on a single paper and a network of e-mails to multiple recipients . In nature too , one can observe several proteins interacting together in a biological network simultaneously . In spite of their significance , in comparison to single edge inference , relatively fewer works have studied the problem of predicting higher-order group-wise interactions . Benson et al . ( 2018 ) originally introduced a simplex to model group-wise interactions between nodes in a graph . They proposed predicting a simplicial closure event , whereby an open simplex ( with just pairwise interactions between member vertices ) transitions to a closed simplex ( where all member vertices participate in the higher-order relationship simultaneously ) , in the near future . Figure 1 ( Middle ) shows an example of such a transition from an open triangle to a closed one . Recently , several works have proposed modeling higher-order interactions as hyperedges in a hypergraph ( Xu et al. , 2013 ; Zhang et al. , 2018 ; Yoon et al. , 2020 ; Patil et al. , 2020 ) . Given a hyperedge ht at time t , the inference task is to predict the future arrival of a new hyperedge ht′ , which covers a larger set of vertices than ht and contains all the vertices in ht . Figure 1 ( Right ) illustrates this hyperedge prediction task . Although prediction models based on either simplicial closure event prediction or hyperedge arrival , deal with higher-order structures , they both fail to capture the highly complex and non-linear evolution of higher-order structures over time . Both these kinds of models have two major limitations . First , they predict structures from a single static snapshot of the graph , thus not viewing the evolution process of adding new edges as a time process . Second , their feature extraction is mostly based on popular heuristics ( Adamic & Adar , 2003 ; Brin & Page , 2012 ; Jeh & Widom , 2002 ; Zhou et al. , 2009a ; Barabási & Albert , 1999 ; Bhatia et al. , 2019 ) that work well in practice but are not accompanied by strong theoretical guarantees . In addition to the aforementioned shortcomings , hypergraph based methods model higher-order structures as hyperedges , which omit lower-dimensional substructures present within a single hyperedge . As a consequence , they can not distinguish between various substructure relationships . For example , hyperedge [ A , B , C ] in Figure 1 ( Right ) can not distinguish between group relationships like [ [ A , B ] , [ B , C ] , [ A , C ] ] ( a set of pairwise interactions ) versus [ A , B , C ] ( all A , B and C simultaneously in a relationship ) . This problem is remedied by the use of simplices because they naturally model these substructures as a collection of subsets ( i.e. , faces ) of the simplex . We provide real-world examples of where our simplicial complex based approach can play a significant role . ( i ) Organic Chemistry : It is quite common to have the same set of elements interacting with each other in different configurations , which result in very different functioning compounds ( Ma et al. , 2011 ) . Specifically , R-thalidomide and S-thalidomide are two different configurations of thalidomide , where the R-form was meant to help sedate pregnant women , while the S-form unfortunately resulted in birth defects . This is a famous example in stereo chemistry to show the consequences of mistaking two extremely close configurations ( differing by a single bond ) as being the same . Structure prediction to avoid such phenomenon in drug synthesis allows chemists to achieve a much higher yield and avoid wastage of expensive resources . ( ii ) Gene expression networks : Gene networks have nodes that represent genes and edges connect genes which have similar expression patterns ( Zhang & Horvath , 2005 ) . Subgraphs called modules are tightly connected genes in such a gene expression network . Genomics research provides evidence that higher-order gene expression relationships ( like second and third-order ) and their measurements can have very important implications for cancer prognosis . When making structural predictions in these aforementioned examples , our simplicial complex based approach provides much more fine-grained control over competing methods by capturing subtler differences in configurations . To combat these challenges , our approach views the evolving graph1 as a time process under the framework of nonparametric time series prediction , which models the evolution of higher-order structures ( as simplices ) and their local neighborhoods ( spatial dimension ) over a moving time window ( temporal dimension ) . Our inference problem is then modeled as predicting the evolution to a higher-dimensional simplex at time t′ > t , given a simplex at time t. It is important to note that this task is more general and greatly diverges from the task proposed by Benson et al . ( 2018 ) . Our 1We handle the incremental model ( edge insertions only ) as opposed to the harder fully dynamic model ( edge insertions and deletions allowed ) for which most previous methods too can not provide theoretical guarantees . task requires just a single simplex σ in order to predict a higher-dimensional simplex τ , whose face / subset is σ , whereas Benson et al . ( 2018 ) requires the presence of all constituent σ faces in order to predict τ . For example , in Benson et al . ( 2018 ) ( also shown in Figure 1 ( Middle ) ) all faces [ A , B ] , [ B , C ] and [ A , C ] ( open triangle ) need to be present in order to predict a closed triangle [ A , B , C ] . Contrastingly , in our approach , just a single face/edge like [ A , B ] or [ B , C ] or [ A , C ] , suffices to predict its evolution to [ A , B , C ] . Figure 1 ( Left ) illustrates an additional example of our proposal to predict a 3-simplex [ A , B , C , D ] given only one of its faces [ A , B , C ] . To this effect , we succinctly capture the features characterizing the local neighborhood of a simplex as a combination of a face-vector ( Björner & Kalai , 2006 ) , which is a well-established vector signature in combinatorial topology literature and a novel scoring function which infers the affinity of sub-simplices based on the strength of their past interactions . Based on these features , we design a kernel estimator to infer future evolution to higher-dimensional simplices and prove both the consistency and asymptotic normality of our estimator . Our contributions : ( a ) We propose a kernel estimator that predicts higher-order interactions in an evolving network . ( b ) We prove the consistency and asymptotic normality of our kernel estimator . ( c ) We evaluate our method on real-world dynamic networks by proposing higher-order link prediction baselines and observe significant gains in prediction accuracy in comparison to the baselines . 1.1 RELATED STUDIES . Single link prediction : Most literature that predicts a single edge/link can be broadly classified as based on : ( i ) heuristics , ( ii ) random-walks , or ( iii ) graph neural networks ( GNNs ) . ( i ) Heuristic methods comprise of Common neighbors , Adamic-adar ( Adamic & Adar , 2003 ) , PageRank ( Brin & Page , 2012 ) , SimRank ( Jeh & Widom , 2002 ) , resource allocation ( Zhou et al. , 2009a ) , preferential attachment ( Barabási & Albert , 1999 ) , persistence homology based ranking ( Bhatia et al. , 2019 ) , and similarity-based methods ( Liben-Nowell & Kleinberg , 2007b ; Lü & Zhou , 2011 ) . ( ii ) Random walk based methods consist of DeepWalk ( Perozzi et al. , 2014 ) , Node2Vec ( Grover & Leskovec , 2016b ) and SpectralWalk ( Sharma et al. , 2020 ) . ( iii ) Finally , for both link prediction and node classification tasks , recent works are mainly GNN-based methods such as VGAE ( Kipf & Welling , 2016 ) , WYS ( Abu-El-Haija et al. , 2018 ) , and SEAL ( Zhang & Chen , 2018b ) . Higher-order link prediction : Benson et al . ( 2018 ) are the first to introduce a higher-order link prediction problem where they study the likelihoods of future higher-order group interactions as simplicial closure events ( explained earlier ) . Furthermore , there are studies using hypergraphs which also help naturally represent group relations ( Xu et al. , 2013 ; Zhang et al. , 2018 ; Yoon et al. , 2020 ; Patil et al. , 2020 ) . Especially , to represent higher-order relationships , Yoon et al . ( 2020 ) proposed n-projected graphs . For larger n , i.e. , higher-order groups , the enumeration of subsets , and keeping track of node co-occurrences quickly becomes infeasible . In comparison to a hypergraph , our graph simplicial complex is closed under taking subsets , which enables us to better encode more information for improved inference . 2 PRELIMINARY : GRAPH SIMPLICIAL COMPLEX ( GSC ) . We start with a general notion of an abstract simplicial complex ( ASC ) , then define a simplex using ASCs . We specialize this definition to graphs and define a graph simplicial complex ( GSC ) . Definition 1 ( Abstract simplicial complex and simplex ) . An abstract simplicial complex ( ASC ) is a collection A of finite non-empty sets , such that if σ is an element of A , then so is every nonempty subset of σ . The element σ of A is called a simplex of A ; its dimension is one less than the number of its elements . Now , we analyze graphs using the definition of ASCs . Let G = ( V , E ) be a finite graph with vertex set V and edge set E. A graph simpicial complex ( GSC ) G on G is an ASC consisting of subsets of V . In particular , G is a collection of subgraphs of G. With graphs , we denote a ddimensional simplex ( or d-simplex ) of a GSC by σ ( d ) = [ v0 , v1 , . . . , vd ] . Each non-empty subset of σ ( d ) is called a face of σ ( d ) . We define several notions related to GSCs , that are useful for describing the evolution of graphs . Definition 2 ( Filtered GSC ) . For I ⊂ N , a filtered GSC indexed over I is a family ( Gt ) t∈I of GSCs such that for every t ≤ t′ in I , Gt ⊂ Gt′ holds . Obviously , Gt0 ⊂ Gt1 ⊂ . . .Gtn is a discrete filtration induced by the arrival times of the simplices : Gti \ Gti−1 = σti . This depicts a higher-order analogue of an evolving graph ( incremental model ) , which allows attaching new simplices at each time-step to an existing GSC to build a new GSC . A filtered GSC Gt , p for the last p discrete time steps is defined as Gt , p : = ( Gt′ ) tt′=t−p = ( Gt−p , . . . , Gt ) , where Gt′ ⊃ Gt′−1 . We define a notion for dealing with the neighborhood around a given simplex σ ( d ) ∈ G. We introduce a set of all simplices of dimension d′ or less from G , i.e. , G ( d ′ ) − : = { σ ( d ) ∈ G | d ≤ d′ } . G ( 0 ) − is a vertex set and G ( 1 ) − is the set of edges and vertices . We also write i ∼ j whenever vertices i and j are adjacent in G ( 1 ) − , and write i ∼k j to indicate that vertex j is k-reachable from i , i.e. , there exists a path of length at most k , connecting i and j in G ( 1 ) − . Then , we define a ball around σ ( d ) . Definition 3 ( k-ball centered at vertex and simplex ) . At time t , we define a k-ball centered at vertex i by Bt , k ( i ) : = { j : i ∼k j and i , j ∈ G ( 0 ) t− } . We also define a k-ball centered at a simplex σ ( d ) as Bt , k ( σ ( d ) ) : = ⋃ i : Vert ( σ ( d ) ) Bt , k ( i ) , where Vert ( σ ( d ) ) denotes all vertexes in σ ( d ) . Now , we define a sub-complex G′t ( σ ( d ) ) ⊆ Gt as the GSC that contains all the simplices in Gt spanned by the vertices in the k-ball Bt , k ( σ ( d ) ) . | This paper provide a method for high-order structure prediction problem. Specifically, the paper first defines a high-order structure on graphs named graph simplicial complex (GSC). Then the paper introduces a feature generation method used for the high-order structures. The features are also used in the proposed method for high-order structure prediction. The proposed method is based on a nonparametric kernel which carries the feature similarities of high-order structures. With this kernel the method uses a Bernoulli distribution for the prediction of the existence of the high-order structure in unseen times. | SP:7d5ca500bb1f17d91c8261ad94af85335278686a |
Approximating Pareto Frontier through Bayesian-optimization-directed Robust Multi-objective Reinforcement Learning | 1 INTRODUCTION . Reinforcement learning ( RL ) algorithm has demonstrated its worth in a series of challenging sequential decision making and control tasks , which train policies to optimize a single scalar reward function ( Mnih et al. , 2015 ; Silver et al. , 2016 ; Haarnoja et al. , 2018 ; Hwangbo et al. , 2019 ) . However , many real-world tasks are characterized by multiple competing objectives whose relative importance ( preferences ) is ambiguous in most cases . Moreover , uncertainty or perturbation caused by environment dynamic change , is inevitable in real-world scenarios , which may result in lowered agent performance ( Pinto et al. , 2017 ; Ji et al. , 2018 ) . For instance , autonomous electric vehicle requires trading off transport efficiency and electricity consumption while considering environmental uncertainty ( e.g. , vehicle mass , tire pressure and road conditions might vary over time ) . Consider a decision-making problem for traffic mode , as shown in Figure 1 . A practitioner or a rule is responsible for picking the appropriate preference among time and cost , and the agent need to determine different policies depending on the chosen trade-off between these two metrics . Whereas , the environment contain uncertainty factors related to actions of other agents or to dynamic changes of Nature , which may lead to more randomness in these two metrics , and makes multi-objective decision-making or control more challenging . If weather factors are taken into account , e.g. , heavy rain may cause traffic congestion , which can increase the time and cost of the plan-A , but it not have a significant impact on the two metrics of the plan-B . From this perspective , selecting plan-B is more robust , i.e. , a policy is said to be robust if its capability to obtain utility is relatively stable under environmental changes . Therefore , preference and uncertainty jointly affect the decision-making behavior of the agent . In traditional multi-objective reinforcement learning ( MORL ) , one popular way is scalarization , which is to convert the multi-objective reward vector into a single scalar reward through various techniques ( e.g. , by taking a convex combination ) , and then adopt standard RL algorithms to optimize this scalar reward ( Vamplew et al. , 2011 ) . Unfortunately , it is very tricky to determine an appropriate scalarization , because often common approach only learn an ’ average ’ policy over the space of preferences ( Yang et al. , 2019 ) , or though the obtained policies can be relatively quickly adapted to different preferences between performance objectives but are not necessarily optimal . Furthermore , these methods almost did not take into account the robustness of the policies under different preferences , which means the agent can not learn robust Pareto optimal policies . In this work , we propose a novel approach to approximate well-distributed robust Pareto frontier through BRMORL . This allows our trained single network model to produce the robust Pareto optimal policy for any specified preference , i.e. , the learned policy is not only robust to uncertainty ( e.g. , random disturbance and environmental change ) but also Pareto optimal under different preference conditions . Our algorithm is based on three key ideas , which are also the main contributions of this paper : ( 1 ) present a generalized robust MORL framework through modelling uncertainty as an adversarial agent ; ( 2 ) inspired by Shannon-Wiener diversity index , a novel metric is presented to evaluate diversity and evenness of distribution for Pareto solutions . In addition , combined with hypervolume indicator , a comprehensive metric is designed , which can evaluate the convergence , diversity and evenness for the solutions on the approximated Pareto frontier ; ( 3 ) regard agent ’ s learning process in each episode as a black-box , and BO algorithm is used to guide agent to evolve towards improving the quality of the Pareto set . Finally , we demonstrate our proposed algorithm outperform competitive baselines on multi-objective tasks across several MuJoCo ( Todorov et al. , 2012 ) environments and SUMO ( Simulation of Urban Mobility ) ( Lopez et al. , 2018 ) , and show our approach can produce robust policies under environmental uncertainty . 2 RELATED WORK . 2.1 MULTI-OBJECTIVE REINFORCEMENT LEARNING . MORL algorithms can be roughly classified into two main categories : single-policy approaches and multiple-policy approaches ( Roijers et al. , 2013 ; Liu et al. , 2014 ) . Single-policy methods seek to find the optimal policy for a given preference among multiple competing objectives . These approaches convert the multi-objective problem into a single-objective problem through different forms of scalarization , including linear and non-linear ones ( Mannor & Shimkin , 2002 ; Tesauro et al. , 2008 ) . The main advantage of scalarization is its simplicity , which can be integrated into single-policy scheme with very little modification . However , the main drawback of these approaches is that the preference among the objectives must be set in advance . Multi-policy methods aim to learn a set of policies that approximate Pareto frontier under different preference conditions . The most common approaches repeatedly call a single-policy scheme with different preferences ( Natarajan & Tadepalli , 2005 ; Van Moffaert et al. , 2013 ; Zuluaga et al. , 2016 ) . Other methods learn a set of policies simultaneously via using a multi-objective extended version of value-based RL ( Barrett & Narayanan , 2008 ; Castelletti et al. , 2012 ; Van Moffaert & Nowé , 2014 ; Mossalam et al. , 2016 ; Nottingham et al. , 2019 ) or via modifying policy-based RL as a MORL variant ( Pirotta et al. , 2015 ; Parisi et al. , 2017 ; Abdolmaleki et al. , 2020 ; Xu et al. , 2020 ) . Nevertheless , most of these methods are offen constrained to convex regions of the Pareto front and explicitly maintain sets of policies , which may prevent these schemes from finding the sets of well-distributed Pareto solutions which can represent different preferences . There are also meta-policy methods , which can be relatively quickly adapted to different preferences ( Chen et al. , 2018 ; Abels et al. , 2019 ; Yang et al. , 2019 ) . Although the above works were successful to some extent , these approaches share the same shortcomings that no attention is paid to the robustness of Pareto-optimal policy over the entire space of preferences . In addition , most approaches still focus on the domains with discrete action space . In contrast , our scheme can guarantee the learned policies is approximately robust Pareto-optimal on continuous control tasks . 2.2 ROBUST REINFORCEMENT LEARNING . Robust reinforcement learning ( RRL ) algorithms can be broadly grouped into three distinct methods ( Derman et al. , 2020 ) . The first approach focuses on solving robust Markov decision process ( MDP ) with rectangular uncertainty sets . Some researches proposed RRL algorithms for learning optimal policies using coupled uncertainty sets ( Mannor et al. , 2012 ) . Other works modeled an ambiguous linear function of a factor matrix as a selection setting from an uncertainty set ( Goyal & Grand-Clement , 2018 ) . The second RRL approach considered a distribution over the uncertainty set to mitigate the conservativeness . Yu & Xu ( 2015 ) presented the distributional RRL method by supposing the uncertain parameters are random variables following an unknown distribution . Tirinzoni et al . ( 2018 ) proposed a RRL scheme using conditioned probability distribution that defines uncertainty sets . A third RRL method mostly concerns adversarial setting in RL . Pinto et al . ( 2017 ) developed a robust adversarial reinforcement learning ( RARL ) scheme through modeling uncertainties via adversarial agent which applies disturbances to the system . Tessler et al . ( 2019 ) proposed an adversarial RRL framework through structuring probabilistic action robust MDP and noisy action robust MDP . Nonetheless , these researches do not take into account the connection between Pareto-optimal policy and robust policy , which leaves room for improving the performance of them in practical applications . In contrast , our scheme can learn robust Pareto-optimal policies through modeling uncertainty as an adversary over the entire space of preferences . 3 BACKGROUND . 3.1 MULTI-OBJECTIVE MARKOV DECISION PROCESS . In this work , we consider a MORL problem defined by a multi-objective Markov decision process ( MOMDP ) , which is represented by the tuple 〈S , A , P , R , γ , Ω , UΩ〉 with state space S , action space A , state transition probability P ( s′|s , a ) , vector reward function R ( s , a ) = [ r1 , ... , rk ] T , the space of preferences Ω , and preference functions , e.g. , Uω ( R ) which produces an utility function using preference ω ∈ Ω , and a discount factor γ ∈ [ 1 , 0 ) . In MOMDP , a policy π is associated with a vector of expected returns Qπ ( s , a ) = [ Qπ1 , ... , Q π k ] T , where the action-value function of π for objective k can be represented as Qπk ( s , a ) = Eπ [ ∑ t γ trk ( st , at ) |s0 = s , a0 = a ] . For MOMDP , a set of non-dominated policies is called as the Pareto frontier . Definition 1 . A policy π1 Pareto dominates another policy π2 , i.e. , π1 π2 when ∃i : Qπ1i ( s , a ) > Q π2 i ( s , a ) ∧ ∀j 6= i : Q π1 j ( s , a ) > Q π2 j ( s , a ) . Definition 2 . A policy π is Pareto optimal if and only if it is non-dominated by any other policies . 3.2 TWO-PERSON ZERO-SUM GAMES . In standard two-person zero-sum games , players have opposite goals—the payoff of a player equals the loss of the opponent ( Mazalov , 2014 ) , i.e. , V + V̄ = 0 , where V and V̄ are payoff of a player and the opponent , respectively . For two player discounted zero-sum Markov game , assuming protagonist is playing policy π and adversary is playing the policy π̄ , transition kernel P ( s′|s , a , ā ) depend on both players . In the game , the value function based on π and π̄ can be represented as vπ , π̄ ( s ) ≡ Eπ , π̄ [ ∑∞ t=0 γ tr ( st , at , āt ) | s0 = s ] , ∀s ∈ S . Each player chooses his policy regardless of the opponent . Protagonist attempts to maximize the value function ( i.e. , total expected discounted reward ) , and adversary seeks to minimize this function . Nash equilibrium is a key role in game theory , which is one kind of game solution concept . A Nash equilibrium ( π∗ , π̄∗ ) in zero-sum Markov game exists when the following relation holds ( Shapley , 1953 ; Başar & Olsder , 1998 ) : v∗ ( s ) = max π min π̄ Eπ , π̄ [ ∞∑ t=0 γtr ( st , at , āt ) | s0 = s ] ( 1 ) = min π̄ max π Eπ , π̄ [ ∞∑ t=0 γtr ( st , at , āt ) | s0 = s ] , ( 2 ) where π∗ and π̄∗ are the optimal policies of protagonist and adversary respectively , v∗ is optimal equilibrium value of the game . In such a situation , neither player can improve their respective returns , and there is an important relation. , i.e. , ∀π , π̄ , vπ , π̄∗ ≤ v∗ ≤ vπ∗ , π̄ . | The paper proposes a robust multi-objective RL approach and a non-linear utility metric to enforce an accurate and evenly distributed representation of the Pareto frontier. Robustness is obtained by formulating the problem as a two-player zero-sum game. The goal of the main agent is thus to learn the policies on the Pareto frontier under attacks from the adversary. This is achieved by training a single network to generate approximate Pareto optimal policies for any provided preference. To train this network, they introduce a new metric for Pareto frontier evaluation based on hypervolume and entropy (to force evenly distributed solutions). The resulting algorithm has the classical structure of an actor-critic algorithm where the critic provides an estimate of the Q-function and the actor updates the policies of the protagonist and adversary through alternate optimization. | SP:d629a2e1996688c91a5294e702eb12b11370eed4 |
Approximating Pareto Frontier through Bayesian-optimization-directed Robust Multi-objective Reinforcement Learning | 1 INTRODUCTION . Reinforcement learning ( RL ) algorithm has demonstrated its worth in a series of challenging sequential decision making and control tasks , which train policies to optimize a single scalar reward function ( Mnih et al. , 2015 ; Silver et al. , 2016 ; Haarnoja et al. , 2018 ; Hwangbo et al. , 2019 ) . However , many real-world tasks are characterized by multiple competing objectives whose relative importance ( preferences ) is ambiguous in most cases . Moreover , uncertainty or perturbation caused by environment dynamic change , is inevitable in real-world scenarios , which may result in lowered agent performance ( Pinto et al. , 2017 ; Ji et al. , 2018 ) . For instance , autonomous electric vehicle requires trading off transport efficiency and electricity consumption while considering environmental uncertainty ( e.g. , vehicle mass , tire pressure and road conditions might vary over time ) . Consider a decision-making problem for traffic mode , as shown in Figure 1 . A practitioner or a rule is responsible for picking the appropriate preference among time and cost , and the agent need to determine different policies depending on the chosen trade-off between these two metrics . Whereas , the environment contain uncertainty factors related to actions of other agents or to dynamic changes of Nature , which may lead to more randomness in these two metrics , and makes multi-objective decision-making or control more challenging . If weather factors are taken into account , e.g. , heavy rain may cause traffic congestion , which can increase the time and cost of the plan-A , but it not have a significant impact on the two metrics of the plan-B . From this perspective , selecting plan-B is more robust , i.e. , a policy is said to be robust if its capability to obtain utility is relatively stable under environmental changes . Therefore , preference and uncertainty jointly affect the decision-making behavior of the agent . In traditional multi-objective reinforcement learning ( MORL ) , one popular way is scalarization , which is to convert the multi-objective reward vector into a single scalar reward through various techniques ( e.g. , by taking a convex combination ) , and then adopt standard RL algorithms to optimize this scalar reward ( Vamplew et al. , 2011 ) . Unfortunately , it is very tricky to determine an appropriate scalarization , because often common approach only learn an ’ average ’ policy over the space of preferences ( Yang et al. , 2019 ) , or though the obtained policies can be relatively quickly adapted to different preferences between performance objectives but are not necessarily optimal . Furthermore , these methods almost did not take into account the robustness of the policies under different preferences , which means the agent can not learn robust Pareto optimal policies . In this work , we propose a novel approach to approximate well-distributed robust Pareto frontier through BRMORL . This allows our trained single network model to produce the robust Pareto optimal policy for any specified preference , i.e. , the learned policy is not only robust to uncertainty ( e.g. , random disturbance and environmental change ) but also Pareto optimal under different preference conditions . Our algorithm is based on three key ideas , which are also the main contributions of this paper : ( 1 ) present a generalized robust MORL framework through modelling uncertainty as an adversarial agent ; ( 2 ) inspired by Shannon-Wiener diversity index , a novel metric is presented to evaluate diversity and evenness of distribution for Pareto solutions . In addition , combined with hypervolume indicator , a comprehensive metric is designed , which can evaluate the convergence , diversity and evenness for the solutions on the approximated Pareto frontier ; ( 3 ) regard agent ’ s learning process in each episode as a black-box , and BO algorithm is used to guide agent to evolve towards improving the quality of the Pareto set . Finally , we demonstrate our proposed algorithm outperform competitive baselines on multi-objective tasks across several MuJoCo ( Todorov et al. , 2012 ) environments and SUMO ( Simulation of Urban Mobility ) ( Lopez et al. , 2018 ) , and show our approach can produce robust policies under environmental uncertainty . 2 RELATED WORK . 2.1 MULTI-OBJECTIVE REINFORCEMENT LEARNING . MORL algorithms can be roughly classified into two main categories : single-policy approaches and multiple-policy approaches ( Roijers et al. , 2013 ; Liu et al. , 2014 ) . Single-policy methods seek to find the optimal policy for a given preference among multiple competing objectives . These approaches convert the multi-objective problem into a single-objective problem through different forms of scalarization , including linear and non-linear ones ( Mannor & Shimkin , 2002 ; Tesauro et al. , 2008 ) . The main advantage of scalarization is its simplicity , which can be integrated into single-policy scheme with very little modification . However , the main drawback of these approaches is that the preference among the objectives must be set in advance . Multi-policy methods aim to learn a set of policies that approximate Pareto frontier under different preference conditions . The most common approaches repeatedly call a single-policy scheme with different preferences ( Natarajan & Tadepalli , 2005 ; Van Moffaert et al. , 2013 ; Zuluaga et al. , 2016 ) . Other methods learn a set of policies simultaneously via using a multi-objective extended version of value-based RL ( Barrett & Narayanan , 2008 ; Castelletti et al. , 2012 ; Van Moffaert & Nowé , 2014 ; Mossalam et al. , 2016 ; Nottingham et al. , 2019 ) or via modifying policy-based RL as a MORL variant ( Pirotta et al. , 2015 ; Parisi et al. , 2017 ; Abdolmaleki et al. , 2020 ; Xu et al. , 2020 ) . Nevertheless , most of these methods are offen constrained to convex regions of the Pareto front and explicitly maintain sets of policies , which may prevent these schemes from finding the sets of well-distributed Pareto solutions which can represent different preferences . There are also meta-policy methods , which can be relatively quickly adapted to different preferences ( Chen et al. , 2018 ; Abels et al. , 2019 ; Yang et al. , 2019 ) . Although the above works were successful to some extent , these approaches share the same shortcomings that no attention is paid to the robustness of Pareto-optimal policy over the entire space of preferences . In addition , most approaches still focus on the domains with discrete action space . In contrast , our scheme can guarantee the learned policies is approximately robust Pareto-optimal on continuous control tasks . 2.2 ROBUST REINFORCEMENT LEARNING . Robust reinforcement learning ( RRL ) algorithms can be broadly grouped into three distinct methods ( Derman et al. , 2020 ) . The first approach focuses on solving robust Markov decision process ( MDP ) with rectangular uncertainty sets . Some researches proposed RRL algorithms for learning optimal policies using coupled uncertainty sets ( Mannor et al. , 2012 ) . Other works modeled an ambiguous linear function of a factor matrix as a selection setting from an uncertainty set ( Goyal & Grand-Clement , 2018 ) . The second RRL approach considered a distribution over the uncertainty set to mitigate the conservativeness . Yu & Xu ( 2015 ) presented the distributional RRL method by supposing the uncertain parameters are random variables following an unknown distribution . Tirinzoni et al . ( 2018 ) proposed a RRL scheme using conditioned probability distribution that defines uncertainty sets . A third RRL method mostly concerns adversarial setting in RL . Pinto et al . ( 2017 ) developed a robust adversarial reinforcement learning ( RARL ) scheme through modeling uncertainties via adversarial agent which applies disturbances to the system . Tessler et al . ( 2019 ) proposed an adversarial RRL framework through structuring probabilistic action robust MDP and noisy action robust MDP . Nonetheless , these researches do not take into account the connection between Pareto-optimal policy and robust policy , which leaves room for improving the performance of them in practical applications . In contrast , our scheme can learn robust Pareto-optimal policies through modeling uncertainty as an adversary over the entire space of preferences . 3 BACKGROUND . 3.1 MULTI-OBJECTIVE MARKOV DECISION PROCESS . In this work , we consider a MORL problem defined by a multi-objective Markov decision process ( MOMDP ) , which is represented by the tuple 〈S , A , P , R , γ , Ω , UΩ〉 with state space S , action space A , state transition probability P ( s′|s , a ) , vector reward function R ( s , a ) = [ r1 , ... , rk ] T , the space of preferences Ω , and preference functions , e.g. , Uω ( R ) which produces an utility function using preference ω ∈ Ω , and a discount factor γ ∈ [ 1 , 0 ) . In MOMDP , a policy π is associated with a vector of expected returns Qπ ( s , a ) = [ Qπ1 , ... , Q π k ] T , where the action-value function of π for objective k can be represented as Qπk ( s , a ) = Eπ [ ∑ t γ trk ( st , at ) |s0 = s , a0 = a ] . For MOMDP , a set of non-dominated policies is called as the Pareto frontier . Definition 1 . A policy π1 Pareto dominates another policy π2 , i.e. , π1 π2 when ∃i : Qπ1i ( s , a ) > Q π2 i ( s , a ) ∧ ∀j 6= i : Q π1 j ( s , a ) > Q π2 j ( s , a ) . Definition 2 . A policy π is Pareto optimal if and only if it is non-dominated by any other policies . 3.2 TWO-PERSON ZERO-SUM GAMES . In standard two-person zero-sum games , players have opposite goals—the payoff of a player equals the loss of the opponent ( Mazalov , 2014 ) , i.e. , V + V̄ = 0 , where V and V̄ are payoff of a player and the opponent , respectively . For two player discounted zero-sum Markov game , assuming protagonist is playing policy π and adversary is playing the policy π̄ , transition kernel P ( s′|s , a , ā ) depend on both players . In the game , the value function based on π and π̄ can be represented as vπ , π̄ ( s ) ≡ Eπ , π̄ [ ∑∞ t=0 γ tr ( st , at , āt ) | s0 = s ] , ∀s ∈ S . Each player chooses his policy regardless of the opponent . Protagonist attempts to maximize the value function ( i.e. , total expected discounted reward ) , and adversary seeks to minimize this function . Nash equilibrium is a key role in game theory , which is one kind of game solution concept . A Nash equilibrium ( π∗ , π̄∗ ) in zero-sum Markov game exists when the following relation holds ( Shapley , 1953 ; Başar & Olsder , 1998 ) : v∗ ( s ) = max π min π̄ Eπ , π̄ [ ∞∑ t=0 γtr ( st , at , āt ) | s0 = s ] ( 1 ) = min π̄ max π Eπ , π̄ [ ∞∑ t=0 γtr ( st , at , āt ) | s0 = s ] , ( 2 ) where π∗ and π̄∗ are the optimal policies of protagonist and adversary respectively , v∗ is optimal equilibrium value of the game . In such a situation , neither player can improve their respective returns , and there is an important relation. , i.e. , ∀π , π̄ , vπ , π̄∗ ≤ v∗ ≤ vπ∗ , π̄ . | This paper seeks to train multi-objective RL policies that are robust to environmental uncertainties. There are two main contributions: a novel approach to solve this problem, and a novel metric to evaluate Pareto fronts. The metric combines the typical hypervolume metric (that captures the quality/performance of a Pareto front) with a novel "evenness" metric, that captures how well solutions are spread out across the space of preferences. The proposed approach, called BRMORL, consists of training a protagonist policy that maximizes utility alongside an adversarial policy that seeks to minimize utility (motivated by zero-sum game theory), while using Bayesian optimization to select preferences to train on, in order to optimize the hypervolume-and-evennesss metric. Both the protagonist and adversarial policy are conditioned on preferences. | SP:d629a2e1996688c91a5294e702eb12b11370eed4 |
Denoising Diffusion Implicit Models | 1 INTRODUCTION . Deep generative models have demonstrated the ability to produce high quality samples in many domains ( Karras et al. , 2020 ; van den Oord et al. , 2016a ) . In terms of image generation , generative adversarial networks ( GANs , Goodfellow et al . ( 2014 ) ) currently exhibits higher sample quality than likelihood-based methods such as variational autoencoders ( Kingma & Welling , 2013 ) , autoregressive models ( van den Oord et al. , 2016b ) and normalizing flows ( Rezende & Mohamed , 2015 ; Dinh et al. , 2016 ) . However , GANs require very specific choices in optimization and architectures in order to stabilize training ( Arjovsky et al. , 2017 ; Gulrajani et al. , 2017 ; Karras et al. , 2018 ; Brock et al. , 2018 ) , and could fail to cover modes of the data distribution ( Zhao et al. , 2018 ) . Recent works on iterative generative models ( Bengio et al. , 2014 ) , such as denoising diffusion probabilistic models ( DDPM , Ho et al . ( 2020 ) ) and noise conditional score networks ( NCSN , Song & Ermon ( 2019 ) ) have demonstrated the ability to produce samples comparable to that of GANs , without having to perform adversarial training . To achieve this , many denoising autoencoding models are trained to denoise samples corrupted by various levels of Gaussian noise . Samples are then produced by a Markov chain which , starting from white noise , progressively denoises it into an image . This generative Markov Chain process is either based on Langevin dynamics ( Song & Ermon , 2019 ) or obtained by reversing a forward diffusion process that progressively turns an image into noise ( Sohl-Dickstein et al. , 2015 ) . A critical drawback of these models is that they require many iterations to produce a high quality sample . For DDPMs , this is because that the generative process ( from noise to data ) approximates the reverse of the forward diffusion process ( from data to noise ) , which could have thousands of steps ; iterating over all the steps is required to produce a single sample , which is much slower compared to GANs , which only needs one pass through a network . For example , it takes around 20 hours to sample 50k images of size 32 × 32 from a DDPM , but less than a minute to do so from a GAN on a Nvidia 2080 Ti GPU . This becomes more problematic for larger images as sampling 50k images of size 256× 256 could take nearly 1000 hours on the same GPU . To close this efficiency gap between DDPMs and GANs , we present denoising diffusion implicit models ( DDIMs ) . DDIMs are implicit probabilistic models ( Mohamed & Lakshminarayanan , 2016 ) and are closely related to DDPMs , in the sense that they are trained with the same objective function . In Section 3 , we generalize the forward diffusion process used by DDPMs , which is Markovian , to non-Markovian ones , for which we are still able to design suitable reverse generative Markov chains . We show that the resulting variational training objectives have a shared surrogate objective , which is exactly the objective used to train DDPM . Therefore , we can freely choose from a large family of generative models using the same neural network simply by choosing a different , nonMarkovian diffusion process ( Section 4.1 ) and the corresponding reverse generative Markov Chain . In particular , we are able to use non-Markovian diffusion processes which lead to ” short ” generative Markov chains ( Section 4.2 ) that can be simulated in a small number of steps . This can massively increase sample efficiency only at a minor cost in sample quality . In Section 5 , we demonstrate several empirical benefits of DDIMs over DDPMs . First , DDIMs have superior sample generation quality compared to DDPMs , when we accelerate sampling by 10× to 100× using our proposed method . Second , DDIM samples have the following “ consistency ” property , which does not hold for DDPMs : if we start with the same initial latent variable and generate several samples with Markov chains of various lengths , these samples would have similar high-level features . Third , because of “ consistency ” in DDIMs , we can perform semantically meaningful image interpolation by manipulating the initial latent variable in DDIMs , unlike DDPMs which interpolates near the image space due to the stochastic generative process . 2 BACKGROUND . Given samples from a data distribution q ( x0 ) , we are interested in learning a model distribution pθ ( x0 ) that approximates q ( x0 ) and is easy to sample from . Denoising diffusion probabilistic models ( DDPMs , Sohl-Dickstein et al . ( 2015 ) ; Ho et al . ( 2020 ) ) are latent variable models of the form pθ ( x0 ) = ∫ pθ ( x0 : T ) dx1 : T , where pθ ( x0 : T ) : = pθ ( xT ) T∏ t=1 p ( t ) θ ( xt−1|xt ) ( 1 ) where x1 , . . . , xT are latent variables in the same sample space as x0 ( denoted as X ) . The parameters θ are learned to fit the data distribution q ( x0 ) by maximizing a variational lower bound : max θ Eq ( x0 ) [ log pθ ( x0 ) ] ≤ max θ Eq ( x0 , x1 , ... , xT ) [ log pθ ( x0 : T ) − log q ( x1 : T |x0 ) ] ( 2 ) where q ( x1 : T |x0 ) is some inference distribution over the latent variables . Unlike typical latent variable models ( such as the variational autoencoder ( Rezende et al. , 2014 ) ) , DDPMs are learned with a fixed ( rather than trainable ) inference procedure q ( x1 : T |x0 ) , and latent variables are relatively high dimensional . For example , Ho et al . ( 2020 ) considered the following Markov chain with Gaussian transitions parameterized by a decreasing sequence α1 : T ∈ ( 0 , 1 ] T : q ( x1 : T |x0 ) : = T∏ t=1 q ( xt|xt−1 ) , where q ( xt|xt−1 ) : = N ( √ αt αt−1 xt−1 , ( 1− αt αt−1 ) I ) ( 3 ) where the covariance matrix is ensured to have positive terms on its diagonal . This is called the forward process due to the autoregressive nature of the sampling procedure ( from x0 to xT ) . We call the latent variable model pθ ( x0 : T ) , which is a Markov chain that samples from xT to x0 , the generative process , since it approximates the intractable reverse process q ( xt−1|xt ) . Intuitively , the forward process progressively adds noise to the observation x0 , whereas the generative process progressively denoises a noisy observation ( Figure 1 , left ) . A special property of the forward process is that q ( xt|x0 ) : = ∫ q ( x1 : t|x0 ) dx1 : ( t−1 ) = N ( xt ; √ αtx0 , ( 1− αt ) I ) ; so we can express xt as a linear combination of x0 and a noise variable : xt = √ αtx0 + √ 1− αt , where ∼ N ( 0 , I ) . ( 4 ) When we set αT sufficiently close to 0 , q ( xT |x0 ) converges to a standard Gaussian for all x0 , so it is natural to set pθ ( xT ) : = N ( 0 , I ) . If all the conditionals are modeled as Gaussians with trainable mean functions and fixed variances , the objective in Eq . ( 2 ) can be simplified to1 : Lγ ( θ ) : = T∑ t=1 γtEx0∼q ( x0 ) , t∼N ( 0 , I ) [ ‖ ( t ) θ ( √ αtx0 + √ 1− αt t ) − t‖ 2 2 ] ( 5 ) where θ : = { ( t ) θ } Tt=1 is a set of T functions , each ( t ) θ : X → X ( indexed by t ) is a function with trainable parameters θ ( t ) , and γ : = [ γ1 , . . . , γT ] is a vector of positive coefficients in the objective that depends on α1 : T . In Ho et al . ( 2020 ) , the objective with γ = 1 is optimized instead to maximize generation performance of the trained model ; this is also the same objective used in noise conditional score networks ( Song & Ermon , 2019 ) based on score matching ( Hyvärinen , 2005 ; Vincent , 2011 ) . From a trained model , x0 is sampled by first sampling xT from the prior pθ ( xT ) , and then sampling xt−1 from the generative processes iteratively . The length T of the forward process is an important hyperparameter in DDPMs . From a variational perspective , a large T allows the reverse process to be close to a Gaussian ( Sohl-Dickstein et al. , 2015 ) , so that the generative process modeled with Gaussian conditional distributions becomes a good approximation ; this motivates the choice of large T values , such as T = 1000 in Ho et al . ( 2020 ) . However , as all T iterations have to be performed sequentially , instead of in parallel , to obtain a sample x0 , sampling from DDPMs is much slower than sampling from other deep generative models , which makes them impractical for tasks where compute is limited and latency is critical . 3 VARIATIONAL INFERENCE FOR NON-MARKOVIAN FORWARD PROCESSES . Because the generative model approximates the reverse of the inference process , we need to rethink the inference process in order to reduce the number of iterations required by the generative model . Our key observation is that the DDPM objective in the form of Lγ only depends on the marginals2 q ( xt|x0 ) , but not directly on the joint q ( x1 : T |x0 ) . Since there are many inference distributions ( joints ) with the same marginals , we explore alternative inference processes that are non-Markovian , which leads to new generative processes ( Figure 1 , right ) . These non-Markovian inference process lead to the same surrogate objective function as DDPM , as we will show below . In Appendix A , we show that the non-Markovian perspective also applies beyond the Gaussian case . 3.1 NON-MARKOVIAN FORWARD PROCESSES . Let us consider a family Q of inference distributions , indexed by a real vector σ ∈ RT≥0 : qσ ( x1 : T |x0 ) : = qσ ( xT |x0 ) T∏ t=2 qσ ( xt−1|xt , x0 ) ( 6 ) where qσ ( xT |x0 ) = N ( √ αTx0 , ( 1− αT ) I ) and for all t > 1 , qσ ( xt−1|xt , x0 ) = N ( √ αt−1x0 + √ 1− αt−1 − σ2t · xt − √ αtx0√ 1− αt , σ2t I ) . ( 7 ) The mean function is chosen to order to ensure that qσ ( xt|x0 ) = N ( √ αtx0 , ( 1 − αt ) I ) for all t ( see Lemma 1 of Appendix B ) , so that it defines a joint inference distribution that matches the “ marginals ” as desired . The forward process3 can be derived from Bayes ’ rule : qσ ( xt|xt−1 , x0 ) = qσ ( xt−1|xt , x0 ) qσ ( xt|x0 ) qσ ( xt−1|x0 ) , ( 8 ) 1Please refer to Appendix C.2 for details . 2We slightly abuse this term ( as well as joints ) when only conditioned on x0 . 3We overload the term “ forward process ” for cases where the inference model is not a diffusion . which is also Gaussian ( although we do not use this fact for the remainder of this paper ) . Unlike the diffusion process in Eq . ( 3 ) , the forward process here is no longer Markovian , since each xt could depend on both xt−1 and x0 . The magnitude of σ controls the how stochastic the forward process is ; when σ → 0 , we reach an extreme case where as long as we observe x0 and xt for some t , then xt−1 become known and fixed . | This paper develops a variant (DDIM) of an existing method (DDPM) with the goal of accelerating it greatly while still maintaining performance. The authors are working in the context of a denoising process that runs in the reverse direction to a sequence of steps that each add a small amount of Gaussian noise to the original data. The proposal is to introduce an auxiliary function that breaks the Markov assumption by leaking some information in a controlled way about the training points x0, and then use this auxiliary function as scaffolding to train the actual Markov chain of denoising functions. | SP:e73541ff1e010add393fde5023555c06b4b4d443 |
Denoising Diffusion Implicit Models | 1 INTRODUCTION . Deep generative models have demonstrated the ability to produce high quality samples in many domains ( Karras et al. , 2020 ; van den Oord et al. , 2016a ) . In terms of image generation , generative adversarial networks ( GANs , Goodfellow et al . ( 2014 ) ) currently exhibits higher sample quality than likelihood-based methods such as variational autoencoders ( Kingma & Welling , 2013 ) , autoregressive models ( van den Oord et al. , 2016b ) and normalizing flows ( Rezende & Mohamed , 2015 ; Dinh et al. , 2016 ) . However , GANs require very specific choices in optimization and architectures in order to stabilize training ( Arjovsky et al. , 2017 ; Gulrajani et al. , 2017 ; Karras et al. , 2018 ; Brock et al. , 2018 ) , and could fail to cover modes of the data distribution ( Zhao et al. , 2018 ) . Recent works on iterative generative models ( Bengio et al. , 2014 ) , such as denoising diffusion probabilistic models ( DDPM , Ho et al . ( 2020 ) ) and noise conditional score networks ( NCSN , Song & Ermon ( 2019 ) ) have demonstrated the ability to produce samples comparable to that of GANs , without having to perform adversarial training . To achieve this , many denoising autoencoding models are trained to denoise samples corrupted by various levels of Gaussian noise . Samples are then produced by a Markov chain which , starting from white noise , progressively denoises it into an image . This generative Markov Chain process is either based on Langevin dynamics ( Song & Ermon , 2019 ) or obtained by reversing a forward diffusion process that progressively turns an image into noise ( Sohl-Dickstein et al. , 2015 ) . A critical drawback of these models is that they require many iterations to produce a high quality sample . For DDPMs , this is because that the generative process ( from noise to data ) approximates the reverse of the forward diffusion process ( from data to noise ) , which could have thousands of steps ; iterating over all the steps is required to produce a single sample , which is much slower compared to GANs , which only needs one pass through a network . For example , it takes around 20 hours to sample 50k images of size 32 × 32 from a DDPM , but less than a minute to do so from a GAN on a Nvidia 2080 Ti GPU . This becomes more problematic for larger images as sampling 50k images of size 256× 256 could take nearly 1000 hours on the same GPU . To close this efficiency gap between DDPMs and GANs , we present denoising diffusion implicit models ( DDIMs ) . DDIMs are implicit probabilistic models ( Mohamed & Lakshminarayanan , 2016 ) and are closely related to DDPMs , in the sense that they are trained with the same objective function . In Section 3 , we generalize the forward diffusion process used by DDPMs , which is Markovian , to non-Markovian ones , for which we are still able to design suitable reverse generative Markov chains . We show that the resulting variational training objectives have a shared surrogate objective , which is exactly the objective used to train DDPM . Therefore , we can freely choose from a large family of generative models using the same neural network simply by choosing a different , nonMarkovian diffusion process ( Section 4.1 ) and the corresponding reverse generative Markov Chain . In particular , we are able to use non-Markovian diffusion processes which lead to ” short ” generative Markov chains ( Section 4.2 ) that can be simulated in a small number of steps . This can massively increase sample efficiency only at a minor cost in sample quality . In Section 5 , we demonstrate several empirical benefits of DDIMs over DDPMs . First , DDIMs have superior sample generation quality compared to DDPMs , when we accelerate sampling by 10× to 100× using our proposed method . Second , DDIM samples have the following “ consistency ” property , which does not hold for DDPMs : if we start with the same initial latent variable and generate several samples with Markov chains of various lengths , these samples would have similar high-level features . Third , because of “ consistency ” in DDIMs , we can perform semantically meaningful image interpolation by manipulating the initial latent variable in DDIMs , unlike DDPMs which interpolates near the image space due to the stochastic generative process . 2 BACKGROUND . Given samples from a data distribution q ( x0 ) , we are interested in learning a model distribution pθ ( x0 ) that approximates q ( x0 ) and is easy to sample from . Denoising diffusion probabilistic models ( DDPMs , Sohl-Dickstein et al . ( 2015 ) ; Ho et al . ( 2020 ) ) are latent variable models of the form pθ ( x0 ) = ∫ pθ ( x0 : T ) dx1 : T , where pθ ( x0 : T ) : = pθ ( xT ) T∏ t=1 p ( t ) θ ( xt−1|xt ) ( 1 ) where x1 , . . . , xT are latent variables in the same sample space as x0 ( denoted as X ) . The parameters θ are learned to fit the data distribution q ( x0 ) by maximizing a variational lower bound : max θ Eq ( x0 ) [ log pθ ( x0 ) ] ≤ max θ Eq ( x0 , x1 , ... , xT ) [ log pθ ( x0 : T ) − log q ( x1 : T |x0 ) ] ( 2 ) where q ( x1 : T |x0 ) is some inference distribution over the latent variables . Unlike typical latent variable models ( such as the variational autoencoder ( Rezende et al. , 2014 ) ) , DDPMs are learned with a fixed ( rather than trainable ) inference procedure q ( x1 : T |x0 ) , and latent variables are relatively high dimensional . For example , Ho et al . ( 2020 ) considered the following Markov chain with Gaussian transitions parameterized by a decreasing sequence α1 : T ∈ ( 0 , 1 ] T : q ( x1 : T |x0 ) : = T∏ t=1 q ( xt|xt−1 ) , where q ( xt|xt−1 ) : = N ( √ αt αt−1 xt−1 , ( 1− αt αt−1 ) I ) ( 3 ) where the covariance matrix is ensured to have positive terms on its diagonal . This is called the forward process due to the autoregressive nature of the sampling procedure ( from x0 to xT ) . We call the latent variable model pθ ( x0 : T ) , which is a Markov chain that samples from xT to x0 , the generative process , since it approximates the intractable reverse process q ( xt−1|xt ) . Intuitively , the forward process progressively adds noise to the observation x0 , whereas the generative process progressively denoises a noisy observation ( Figure 1 , left ) . A special property of the forward process is that q ( xt|x0 ) : = ∫ q ( x1 : t|x0 ) dx1 : ( t−1 ) = N ( xt ; √ αtx0 , ( 1− αt ) I ) ; so we can express xt as a linear combination of x0 and a noise variable : xt = √ αtx0 + √ 1− αt , where ∼ N ( 0 , I ) . ( 4 ) When we set αT sufficiently close to 0 , q ( xT |x0 ) converges to a standard Gaussian for all x0 , so it is natural to set pθ ( xT ) : = N ( 0 , I ) . If all the conditionals are modeled as Gaussians with trainable mean functions and fixed variances , the objective in Eq . ( 2 ) can be simplified to1 : Lγ ( θ ) : = T∑ t=1 γtEx0∼q ( x0 ) , t∼N ( 0 , I ) [ ‖ ( t ) θ ( √ αtx0 + √ 1− αt t ) − t‖ 2 2 ] ( 5 ) where θ : = { ( t ) θ } Tt=1 is a set of T functions , each ( t ) θ : X → X ( indexed by t ) is a function with trainable parameters θ ( t ) , and γ : = [ γ1 , . . . , γT ] is a vector of positive coefficients in the objective that depends on α1 : T . In Ho et al . ( 2020 ) , the objective with γ = 1 is optimized instead to maximize generation performance of the trained model ; this is also the same objective used in noise conditional score networks ( Song & Ermon , 2019 ) based on score matching ( Hyvärinen , 2005 ; Vincent , 2011 ) . From a trained model , x0 is sampled by first sampling xT from the prior pθ ( xT ) , and then sampling xt−1 from the generative processes iteratively . The length T of the forward process is an important hyperparameter in DDPMs . From a variational perspective , a large T allows the reverse process to be close to a Gaussian ( Sohl-Dickstein et al. , 2015 ) , so that the generative process modeled with Gaussian conditional distributions becomes a good approximation ; this motivates the choice of large T values , such as T = 1000 in Ho et al . ( 2020 ) . However , as all T iterations have to be performed sequentially , instead of in parallel , to obtain a sample x0 , sampling from DDPMs is much slower than sampling from other deep generative models , which makes them impractical for tasks where compute is limited and latency is critical . 3 VARIATIONAL INFERENCE FOR NON-MARKOVIAN FORWARD PROCESSES . Because the generative model approximates the reverse of the inference process , we need to rethink the inference process in order to reduce the number of iterations required by the generative model . Our key observation is that the DDPM objective in the form of Lγ only depends on the marginals2 q ( xt|x0 ) , but not directly on the joint q ( x1 : T |x0 ) . Since there are many inference distributions ( joints ) with the same marginals , we explore alternative inference processes that are non-Markovian , which leads to new generative processes ( Figure 1 , right ) . These non-Markovian inference process lead to the same surrogate objective function as DDPM , as we will show below . In Appendix A , we show that the non-Markovian perspective also applies beyond the Gaussian case . 3.1 NON-MARKOVIAN FORWARD PROCESSES . Let us consider a family Q of inference distributions , indexed by a real vector σ ∈ RT≥0 : qσ ( x1 : T |x0 ) : = qσ ( xT |x0 ) T∏ t=2 qσ ( xt−1|xt , x0 ) ( 6 ) where qσ ( xT |x0 ) = N ( √ αTx0 , ( 1− αT ) I ) and for all t > 1 , qσ ( xt−1|xt , x0 ) = N ( √ αt−1x0 + √ 1− αt−1 − σ2t · xt − √ αtx0√ 1− αt , σ2t I ) . ( 7 ) The mean function is chosen to order to ensure that qσ ( xt|x0 ) = N ( √ αtx0 , ( 1 − αt ) I ) for all t ( see Lemma 1 of Appendix B ) , so that it defines a joint inference distribution that matches the “ marginals ” as desired . The forward process3 can be derived from Bayes ’ rule : qσ ( xt|xt−1 , x0 ) = qσ ( xt−1|xt , x0 ) qσ ( xt|x0 ) qσ ( xt−1|x0 ) , ( 8 ) 1Please refer to Appendix C.2 for details . 2We slightly abuse this term ( as well as joints ) when only conditioned on x0 . 3We overload the term “ forward process ” for cases where the inference model is not a diffusion . which is also Gaussian ( although we do not use this fact for the remainder of this paper ) . Unlike the diffusion process in Eq . ( 3 ) , the forward process here is no longer Markovian , since each xt could depend on both xt−1 and x0 . The magnitude of σ controls the how stochastic the forward process is ; when σ → 0 , we reach an extreme case where as long as we observe x0 and xt for some t , then xt−1 become known and fixed . | This paper proposes a change to the recently popular diffusion models, motivated by increasing the speed of sampling. This is accomplished by changing the “forward” process which adds noise to the data. In the original diffusion models, this forward process is a Markov process whose marginals and conditionals can be computed efficiently in closed form. This paper proposes to replace this Markov forward process with a non-markovian process that is designed to have the same marginals. The generative model, in this case, changes such that to predict the next step in the process, the model must first predict the “clean” sample at the end of the chain which is then used to give an estimate for the next step in the chain. | SP:e73541ff1e010add393fde5023555c06b4b4d443 |
Communication-Efficient Sampling for Distributed Training of Graph Convolutional Networks | Training Graph Convolutional Networks ( GCNs ) is expensive as it needs to aggregate data recursively from neighboring nodes . To reduce the computation overhead , previous works have proposed various neighbor sampling methods that estimate the aggregation result based on a small number of sampled neighbors . Although these methods have successfully accelerated the training , they mainly focus on the single-machine setting . As real-world graphs are large , training GCNs in distributed systems is desirable . However , we found that the existing neighbor sampling methods do not work well in a distributed setting . Specifically , a naive implementation may incur a huge amount of communication of feature vectors among different machines . To address this problem , we propose a communication-efficient neighbor sampling method in this work . Our main idea is to assign higher sampling probabilities to the local nodes so that remote nodes are accessed less frequently . We present an algorithm that determines the local sampling probabilities and makes sure our skewed neighbor sampling does not affect much to the convergence of the training . Our experiments with node classification benchmarks show that our method significantly reduces the communication overhead for distributed GCN training with little accuracy loss . 1 INTRODUCTION . Graph Convolutional Networks ( GCNs ) are powerful models for learning representations of attributed graphs . They have achieved great success in graph-based learning tasks such as node classification ( Kipf & Welling , 2017 ; Duran & Niepert , 2017 ) , link prediction ( Zhang & Chen , 2017 ; 2018 ) , and graph classification ( Ying et al. , 2018b ; Gilmer et al. , 2017 ) . Despite the success of GCNs , training a deep GCN on large-scale graphs is challenging . To compute the embedding of a node , GCN needs to recursively aggregate the embeddings of the neighboring nodes . The number of nodes needed for computing a single sample can grow exponentially with respect to the number of layers . This has made mini-batch sampling ineffective to achieve efficient training of GCNs . To alleviate the computational burden , various neighbor sampling methods have been proposed ( Hamilton et al. , 2017 ; Ying et al. , 2018a ; Chen et al. , 2018b ; Zou et al. , 2019 ; Li et al. , 2018 ; Chiang et al. , 2019 ; Zeng et al. , 2020 ) . The idea is that , instead of aggregating the embeddings of all neighbors , they compute an unbiased estimation of the result based on a sampled subset of neighbors . Although the existing neighbor sampling methods can effectively reduce the computation overhead of training GCNs , most of them assume a single-machine setting . The existing distributed GCN systems either perform neighbor sampling for each machine/GPU independently ( e.g. , PinSage ( Ying et al. , 2018a ) , AliGraph ( Zhu et al. , 2019 ) , DGL ( Wang et al. , 2019 ) ) or perform a distributed neighbor sampling for all machines/GPUs ( e.g. , AGL ( Zhang et al. , 2020 ) ) . If the sampled neighbors on a machine include nodes stored on other machines , the system needs to transfer the feature vectors of the neighboring nodes across the machines . This incurs a huge communication overhead . None of the existing sampling methods or the distributed GCN systems have taken this communication overhead into consideration . In this work , we propose a communication-efficient neighbor sampling method for distributed training of GCNs . Our main idea is to assign higher sampling probabilities for local nodes so that remote nodes will be accessed less frequently . By discounting the embeddings with the sampling probability , we make sure that the estimation is unbiased . We present an algorithm to generate the sampling probability that ensures the convergence of training . To validate our sampling method , we conduct experiments with node classification benchmarks on different graphs . The experimental results show that our method significantly reduces the communication overhead with little accuracy loss . 2 RELATED WORK . The idea of applying convolution operation to the graph domain is first proposed by Bruna et al . ( 2013 ) . Later , Kipf & Welling ( 2017 ) and Defferrard et al . ( 2016 ) simplify the convolution computation with localized filters . Most of the recent GCN models ( e.g. , GAT ( Velickovic et al. , 2018 ) , GraphSAGE ( Hamilton et al. , 2017 ) , GIN ( Xu et al. , 2019 ) ) are based on the GCN in Kipf & Welling ( 2017 ) where the information is only from 1-hop neighbors in each layer of the neural network . In Kipf & Welling ( 2017 ) , the authors only apply their GCN to small graphs and use full batch for training . This has been the major limitation of the original GCN model as full batch training is expensive and infeasible for large graphs . Mini-batch training does not help much since the number of nodes needed for computing a single sample can grow exponentially as the GCN goes deeper . To overcome this limitation , various neighbor sampling methods have been proposed to reduce the computation complexity of GCN training . Node-wise Neighbor Sampling : GraphSAGE ( Hamilton et al. , 2017 ) proposes to reduce the receptive field size of each node by sampling a fixed number of its neighbors in the previous layer . PinSAGE ( Ying et al. , 2018a ) adopts this node-wise sampling technique and enhances it by introducing an importance score to each neighbor . It leads to less information loss due to weighted aggregation . VR-GCN ( Chen et al. , 2018a ) further restricts the neighbor sampling size to two and uses the historical activation of the previous layer to reduce variance . Although it achieves comparable convergence to GraphSAGE , VR-GCN incurs additional computation overhead for convolution operations on historical activation which can outweigh the benefit of reduced number of sampled neighbors . The problem with node-wise sampling is that , due to the recursive aggregation , it may still need to gather the information of a large number of nodes to compute the embeddings of a mini-batch . Layer-wise Importance Sampling : To further reduce the sample complexity , FastGCN ( Chen et al. , 2018b ) proposes layer-wise importance sampling . Instead of fixing the number of sampled neighbors for each node , it fixes the number of sampled nodes in each layer . Since the sampling is conduced independently in each layer , it requires a large sample size to guarantee the connectivity between layers . To improve the sample density and reduce the sample size , Huang et al . ( 2018 ) and Zou et al . ( 2019 ) propose to restrict the sampling space to the neighbors of nodes sampled in the previous layer . Subgraph Sampling : Layer-wise sampling needs to maintain a list of neighbors and calculate a new sampling distribution for each layer . It incurs an overhead that can sometime deny the benefit of sampling , especially for small graphs . GraphSAINT ( Zeng et al. , 2020 ) proposes to simplify the sampling procedure by sampling a subgraph and performing full convolution on the subgraph . Similarly , ClusterGCN ( Chiang et al. , 2019 ) pre-partitions a graph into small clusters and constructs mini-batches by randomly selecting subsets of clusters during the training . All of the existing neighbor sampling methods assume a single-machine setting . As we will show in the next section , a straightforward adoption of these methods to a distributed setting can lead to a large communication overhead . 3 BACKGROUND AND MOTIVATION . In a M -layer GCN , the l-th convolution layer is defined as H ( l ) = Pσ ( H ( l−1 ) ) W ( l ) where H ( l ) represents the embeddings of all nodes at layer l before activation , H ( 0 ) = X represents the feature vectors , σ is the activation function , P is the normalized Laplacian matrix of the graph , and W ( l ) is the learnable weights at layer l. The multiple convolution layers in the GCN can be represented as H ( M ) = Pσ ( H ( l−1 ) ( ... σ ( PXW ( 1 ) ︸ ︷︷ ︸ H ( 1 ) ) ... ) ) W ( M ) . ( 1 ) The output embedding H ( M ) is given to some loss function F for downstream learning tasks such as node classification or link prediction . GCN as Multi-level Stochastic Compositional Optimization : As pointed out by Cong et al . ( 2020 ) , training a GCN with neighbor sampling can be considered as a multi-level stochastic compositional optimization ( SCO ) problem ( although their description is not accurate ) . Here , we give a more precise connection between GCN training and multi-level SCO . Since the convergence property of algorithms for multi-level SCO has been extensively studied ( Yang et al. , 2019 ; Zhang & Xiao , 2019 ; Chen et al. , 2020 ) , this connection will allow us to study the convergence of GCN training with different neighbor sampling methods . We can define the graph convolution at layer l ∈ [ 1 , M ] as a function f ( l ) = Pσ ( H ( l−1 ) ) W ( l ) . The embedding approximation with neighbor sampling can be considered as a stochastic function f ( l ) ωl = P̃ ( l ) σ ( H ( l−1 ) ) W ( l ) where P̃ ( l ) is a stochastic matrix with Eωl [ P̃ ( l ) ] = P . Therefore , we have f ( l ) = Eωl [ f ( l ) ωl ] . The loss function of the GCN can be written as L ( θ ) = Eω ( M+1 ) [ f ( M+1 ) ω ( M+1 ) ( EωM [ f ( M ) ωM ( ... Eω1 [ f ( 1 ) ( θ ) ] ... ) ] ) ] . ( 2 ) Here , θ is the set of learnable weights at all layers { W ( 1 ) , ... , W ( M ) } , f ( M+1 ) = F ( H ( M ) ) , and the stochastic function f ( M+1 ) ω ( M+1 ) corresponds to the mini-batch sampling . Distributed Training of GCN : As the real-world graphs are large and the compute/memory capacity of a single machine is limited , it is always desirable to perform distributed training of GCNs . A possible scenario would be that we train a GCN on a multi-GPU system . The global memory of a single GPU can not accommodate the feature vectors of all nodes in the graph . It will be inefficient to store the feature vectors on the CPU main memory and move the feature vectors to GPU in each iteration of the training process because the data movement incurs a large overhead . We want to split the feature vectors and store them on multiple GPUs so that each GPU can perform calculation on its local data . Another possible scenario would be that we have a large graph with rich features which can not be store on a single machine . For example , the e-commerce graphs considered in AliGraph ( Zhu et al. , 2019 ) can ‘ contain tens of billions of nodes and hundreds of billions of edges with storage cost over 10TB easily ’ . Such graphs need to be partitioned and stored on different machines in a distributed system . Figure 1 shows an example of training a two-layer GCN on four GPUs . Suppose full neighbor convolution is used and each GPU computes the embeddings of its local nodes . GPU-0 needs to compute the embeddings of node A and B and obtain a stochastic gradient g̃0 based on the loss function . GPU-1 needs to compute the embeddings of node C and D and obtain a stochastic gradient g̃1 . Similarly , GPU-2 and GPU-3 compute the embeddings of their local nodes and obtain stochastic gradient g̃2 and g̃3 . The stochastic gradients obtained on different GPUs are then averaged and used to update the model parameters . Communication of Feature Vectors : As shown in Figure 1 , the computation of a node ’ s embedding may involve reading the feature vector of a remote node . To compute the embedding of node A on GPU-0 , we need the intermediate embeddings of node B and E , which in turn need the feature vectors of node A , B , C , E and F ( Note that the feature vector of node E itself is needed to compute its intermediate embedding ; the same for node B ) . Since node C , E , F are not on GPU-0 , we need to send the feature vectors of node C from GPU-1 and node E , F from GPU-2 . Similarly , to compute the embedding of node B on GPU-0 , we need feature vectors of node B , C , D , E , F and G , which means that GPU-0 needs to obtain data from all of the other three GPUs . This apparently incurs a large communication overhead . Even with neighbor sampling , the communication of the feature vectors among the GPUs are unavoidable . In fact , in our experiments on a four-GPU workstation , the communication can take more than 60 % of the total execution time with a naive adoption of neighbor sampling . The problem is expected to be more severe on distributed systems with multiple machines . Therefore , reducing the communication overhead for feature vectors is critical to the performance of distributed training of GCNs . | This paper proposed a new distributed training method for GNNs. Specifically, unlike traditional distributed training methods for CNNs where data points are independent, nodes in a graph are dependent on each other. Thus, this dependence incurs communication between different workers in the distributed training of GNNs. This paper aims to reduce the communication cost in this procedure. Here, this paper proposed to sample more neighbor nodes within the same worker while reducing the sampling probability for the neighbor nodes on other workers. It also provides some theoretical analysis and conducts the experiments to verify the proposed method. | SP:d643be475992d1e14394cb6200b8db3d2b07c34f |
Communication-Efficient Sampling for Distributed Training of Graph Convolutional Networks | Training Graph Convolutional Networks ( GCNs ) is expensive as it needs to aggregate data recursively from neighboring nodes . To reduce the computation overhead , previous works have proposed various neighbor sampling methods that estimate the aggregation result based on a small number of sampled neighbors . Although these methods have successfully accelerated the training , they mainly focus on the single-machine setting . As real-world graphs are large , training GCNs in distributed systems is desirable . However , we found that the existing neighbor sampling methods do not work well in a distributed setting . Specifically , a naive implementation may incur a huge amount of communication of feature vectors among different machines . To address this problem , we propose a communication-efficient neighbor sampling method in this work . Our main idea is to assign higher sampling probabilities to the local nodes so that remote nodes are accessed less frequently . We present an algorithm that determines the local sampling probabilities and makes sure our skewed neighbor sampling does not affect much to the convergence of the training . Our experiments with node classification benchmarks show that our method significantly reduces the communication overhead for distributed GCN training with little accuracy loss . 1 INTRODUCTION . Graph Convolutional Networks ( GCNs ) are powerful models for learning representations of attributed graphs . They have achieved great success in graph-based learning tasks such as node classification ( Kipf & Welling , 2017 ; Duran & Niepert , 2017 ) , link prediction ( Zhang & Chen , 2017 ; 2018 ) , and graph classification ( Ying et al. , 2018b ; Gilmer et al. , 2017 ) . Despite the success of GCNs , training a deep GCN on large-scale graphs is challenging . To compute the embedding of a node , GCN needs to recursively aggregate the embeddings of the neighboring nodes . The number of nodes needed for computing a single sample can grow exponentially with respect to the number of layers . This has made mini-batch sampling ineffective to achieve efficient training of GCNs . To alleviate the computational burden , various neighbor sampling methods have been proposed ( Hamilton et al. , 2017 ; Ying et al. , 2018a ; Chen et al. , 2018b ; Zou et al. , 2019 ; Li et al. , 2018 ; Chiang et al. , 2019 ; Zeng et al. , 2020 ) . The idea is that , instead of aggregating the embeddings of all neighbors , they compute an unbiased estimation of the result based on a sampled subset of neighbors . Although the existing neighbor sampling methods can effectively reduce the computation overhead of training GCNs , most of them assume a single-machine setting . The existing distributed GCN systems either perform neighbor sampling for each machine/GPU independently ( e.g. , PinSage ( Ying et al. , 2018a ) , AliGraph ( Zhu et al. , 2019 ) , DGL ( Wang et al. , 2019 ) ) or perform a distributed neighbor sampling for all machines/GPUs ( e.g. , AGL ( Zhang et al. , 2020 ) ) . If the sampled neighbors on a machine include nodes stored on other machines , the system needs to transfer the feature vectors of the neighboring nodes across the machines . This incurs a huge communication overhead . None of the existing sampling methods or the distributed GCN systems have taken this communication overhead into consideration . In this work , we propose a communication-efficient neighbor sampling method for distributed training of GCNs . Our main idea is to assign higher sampling probabilities for local nodes so that remote nodes will be accessed less frequently . By discounting the embeddings with the sampling probability , we make sure that the estimation is unbiased . We present an algorithm to generate the sampling probability that ensures the convergence of training . To validate our sampling method , we conduct experiments with node classification benchmarks on different graphs . The experimental results show that our method significantly reduces the communication overhead with little accuracy loss . 2 RELATED WORK . The idea of applying convolution operation to the graph domain is first proposed by Bruna et al . ( 2013 ) . Later , Kipf & Welling ( 2017 ) and Defferrard et al . ( 2016 ) simplify the convolution computation with localized filters . Most of the recent GCN models ( e.g. , GAT ( Velickovic et al. , 2018 ) , GraphSAGE ( Hamilton et al. , 2017 ) , GIN ( Xu et al. , 2019 ) ) are based on the GCN in Kipf & Welling ( 2017 ) where the information is only from 1-hop neighbors in each layer of the neural network . In Kipf & Welling ( 2017 ) , the authors only apply their GCN to small graphs and use full batch for training . This has been the major limitation of the original GCN model as full batch training is expensive and infeasible for large graphs . Mini-batch training does not help much since the number of nodes needed for computing a single sample can grow exponentially as the GCN goes deeper . To overcome this limitation , various neighbor sampling methods have been proposed to reduce the computation complexity of GCN training . Node-wise Neighbor Sampling : GraphSAGE ( Hamilton et al. , 2017 ) proposes to reduce the receptive field size of each node by sampling a fixed number of its neighbors in the previous layer . PinSAGE ( Ying et al. , 2018a ) adopts this node-wise sampling technique and enhances it by introducing an importance score to each neighbor . It leads to less information loss due to weighted aggregation . VR-GCN ( Chen et al. , 2018a ) further restricts the neighbor sampling size to two and uses the historical activation of the previous layer to reduce variance . Although it achieves comparable convergence to GraphSAGE , VR-GCN incurs additional computation overhead for convolution operations on historical activation which can outweigh the benefit of reduced number of sampled neighbors . The problem with node-wise sampling is that , due to the recursive aggregation , it may still need to gather the information of a large number of nodes to compute the embeddings of a mini-batch . Layer-wise Importance Sampling : To further reduce the sample complexity , FastGCN ( Chen et al. , 2018b ) proposes layer-wise importance sampling . Instead of fixing the number of sampled neighbors for each node , it fixes the number of sampled nodes in each layer . Since the sampling is conduced independently in each layer , it requires a large sample size to guarantee the connectivity between layers . To improve the sample density and reduce the sample size , Huang et al . ( 2018 ) and Zou et al . ( 2019 ) propose to restrict the sampling space to the neighbors of nodes sampled in the previous layer . Subgraph Sampling : Layer-wise sampling needs to maintain a list of neighbors and calculate a new sampling distribution for each layer . It incurs an overhead that can sometime deny the benefit of sampling , especially for small graphs . GraphSAINT ( Zeng et al. , 2020 ) proposes to simplify the sampling procedure by sampling a subgraph and performing full convolution on the subgraph . Similarly , ClusterGCN ( Chiang et al. , 2019 ) pre-partitions a graph into small clusters and constructs mini-batches by randomly selecting subsets of clusters during the training . All of the existing neighbor sampling methods assume a single-machine setting . As we will show in the next section , a straightforward adoption of these methods to a distributed setting can lead to a large communication overhead . 3 BACKGROUND AND MOTIVATION . In a M -layer GCN , the l-th convolution layer is defined as H ( l ) = Pσ ( H ( l−1 ) ) W ( l ) where H ( l ) represents the embeddings of all nodes at layer l before activation , H ( 0 ) = X represents the feature vectors , σ is the activation function , P is the normalized Laplacian matrix of the graph , and W ( l ) is the learnable weights at layer l. The multiple convolution layers in the GCN can be represented as H ( M ) = Pσ ( H ( l−1 ) ( ... σ ( PXW ( 1 ) ︸ ︷︷ ︸ H ( 1 ) ) ... ) ) W ( M ) . ( 1 ) The output embedding H ( M ) is given to some loss function F for downstream learning tasks such as node classification or link prediction . GCN as Multi-level Stochastic Compositional Optimization : As pointed out by Cong et al . ( 2020 ) , training a GCN with neighbor sampling can be considered as a multi-level stochastic compositional optimization ( SCO ) problem ( although their description is not accurate ) . Here , we give a more precise connection between GCN training and multi-level SCO . Since the convergence property of algorithms for multi-level SCO has been extensively studied ( Yang et al. , 2019 ; Zhang & Xiao , 2019 ; Chen et al. , 2020 ) , this connection will allow us to study the convergence of GCN training with different neighbor sampling methods . We can define the graph convolution at layer l ∈ [ 1 , M ] as a function f ( l ) = Pσ ( H ( l−1 ) ) W ( l ) . The embedding approximation with neighbor sampling can be considered as a stochastic function f ( l ) ωl = P̃ ( l ) σ ( H ( l−1 ) ) W ( l ) where P̃ ( l ) is a stochastic matrix with Eωl [ P̃ ( l ) ] = P . Therefore , we have f ( l ) = Eωl [ f ( l ) ωl ] . The loss function of the GCN can be written as L ( θ ) = Eω ( M+1 ) [ f ( M+1 ) ω ( M+1 ) ( EωM [ f ( M ) ωM ( ... Eω1 [ f ( 1 ) ( θ ) ] ... ) ] ) ] . ( 2 ) Here , θ is the set of learnable weights at all layers { W ( 1 ) , ... , W ( M ) } , f ( M+1 ) = F ( H ( M ) ) , and the stochastic function f ( M+1 ) ω ( M+1 ) corresponds to the mini-batch sampling . Distributed Training of GCN : As the real-world graphs are large and the compute/memory capacity of a single machine is limited , it is always desirable to perform distributed training of GCNs . A possible scenario would be that we train a GCN on a multi-GPU system . The global memory of a single GPU can not accommodate the feature vectors of all nodes in the graph . It will be inefficient to store the feature vectors on the CPU main memory and move the feature vectors to GPU in each iteration of the training process because the data movement incurs a large overhead . We want to split the feature vectors and store them on multiple GPUs so that each GPU can perform calculation on its local data . Another possible scenario would be that we have a large graph with rich features which can not be store on a single machine . For example , the e-commerce graphs considered in AliGraph ( Zhu et al. , 2019 ) can ‘ contain tens of billions of nodes and hundreds of billions of edges with storage cost over 10TB easily ’ . Such graphs need to be partitioned and stored on different machines in a distributed system . Figure 1 shows an example of training a two-layer GCN on four GPUs . Suppose full neighbor convolution is used and each GPU computes the embeddings of its local nodes . GPU-0 needs to compute the embeddings of node A and B and obtain a stochastic gradient g̃0 based on the loss function . GPU-1 needs to compute the embeddings of node C and D and obtain a stochastic gradient g̃1 . Similarly , GPU-2 and GPU-3 compute the embeddings of their local nodes and obtain stochastic gradient g̃2 and g̃3 . The stochastic gradients obtained on different GPUs are then averaged and used to update the model parameters . Communication of Feature Vectors : As shown in Figure 1 , the computation of a node ’ s embedding may involve reading the feature vector of a remote node . To compute the embedding of node A on GPU-0 , we need the intermediate embeddings of node B and E , which in turn need the feature vectors of node A , B , C , E and F ( Note that the feature vector of node E itself is needed to compute its intermediate embedding ; the same for node B ) . Since node C , E , F are not on GPU-0 , we need to send the feature vectors of node C from GPU-1 and node E , F from GPU-2 . Similarly , to compute the embedding of node B on GPU-0 , we need feature vectors of node B , C , D , E , F and G , which means that GPU-0 needs to obtain data from all of the other three GPUs . This apparently incurs a large communication overhead . Even with neighbor sampling , the communication of the feature vectors among the GPUs are unavoidable . In fact , in our experiments on a four-GPU workstation , the communication can take more than 60 % of the total execution time with a naive adoption of neighbor sampling . The problem is expected to be more severe on distributed systems with multiple machines . Therefore , reducing the communication overhead for feature vectors is critical to the performance of distributed training of GCNs . | The paper presents a sampling-based approach to speeding-up training of GCNs in distributed systems. The key step in this task involves exchanging and aggregating messages sent along the edges of the graph. If the nodes of the graph are partitioned between several machines, then exchanging those messages involve costly communication between the nodes. To reduce this communication, the paper introduces a variant of the node sampling approach of Chen et al. (2018b) and Zou et al. (2019), where the probabilities of nodes in other machines are scaled down by some factor s. The approach is evaluated experimentally, showing that it reduces the amount of communication while (essentially) preserving the accuracy. | SP:d643be475992d1e14394cb6200b8db3d2b07c34f |
Planning from Pixels using Inverse Dynamics Models | 1 INTRODUCTION . Deep reinforcement learning has proven to be a powerful and effective framework for solving a diversity of challenging decision-making problems ( Silver et al. , 2017a ; Berner et al. , 2019 ) . However these algorithms are typically trained to maximize a single reward function , ignoring information that is not directly relevant to the associated task at hand . This way of learning is in stark contrast to how humans learn ( Tenenbaum , 2018 ) . Without being prompted by a specific task , humans can still explore their environment , practice achieving imaginary goals , and in so doing learn about the dynamics of the environment . When subsequently presented with a novel task , humans can utilize this learned knowledge to bootstrap learning — a property we would like our artificial agents to have . In this work , we investigate one way to bridge this gap by learning world models ( Ha & Schmidhuber , 2018 ) that enable the realization of previously unseen tasks . By modeling the task-agnostic dynamics of an environment , an agent can make predictions about how its own actions may affect the environment state without the need for additional samples from the environment . Prior work has shown that by using powerful function approximators to model environment dynamics , training an agent entirely within its own world models can result in large gains in sample efficiency ( Ha & Schmidhuber , 2018 ) . However , learning world models that are both accurate and general has largely remained elusive , with these models experiencing many performance issues in the multi-task setting . The main reason for poor performance is the so-called planning horizon dilemma ( Wang et al. , 2019 ) : accurately modeling dynamics over a long horizon is necessary to accurately estimate rewards , but performance is often poor when planning over long sequences due to the accumulation of errors . These modeling errors are especially prevalent in high-dimensional observation spaces where loss functions that operate on pixels may focus model capacity on task-irrelevant features ( Kaiser et al. , 2020 ) . Recent work ( Hafner et al. , 2020 ; Schrittwieser et al. , 2019 ) has attempted to side-step these issues by learning a world model in a latent space and propagating gradients over multiple time-steps . While these methods are able to learn accurate world models and achieve high performance on benchmark tasks , their representations are usually trained with task-specific information such as rewards , encouraging the model to focus on tracking task-relevant features but compromising their ability to generalize to new tasks . In this work , we propose to learn powerful , latent world models that can predict environment dynamics when planning for a distribution of tasks . The main contributions of our paper are three-fold : we propose to learn a latent world model conditioned on a goal ; we train our latent representation to model inverse dynamics — sequences of actions that take the agent from one state to another , rather than training it to capture information about reward ; and we show that by combining our inverse dynamics model and a prior over action sequences , we can quickly construct plans that maximize the probability of reaching a goal state . We evaluate our world model on a diverse distribution of challenging visual goals in Atari games and the Deepmind Control Suite ( Tassa et al. , 2018 ) to assess both its accuracy and sample efficiency . We find that when planning in our latent world model , our agent outperforms prior , model-free methods across most tasks , while providing an order of magnitude better sample efficiency on some tasks . 2 RELATED WORK . Model-based RL has typically focused on learning powerful forward dynamics models , which are trained to predict the next state given the current state and action . In works such as ( Kaiser et al. , 2020 ) , these models are trained to predict the next state in observation space - often by minimizing L2 distance . While the performance of these algorithms in the low data regime is often strong , they can struggle to reach the asymptotic performance of model-free methods ( Hafner et al. , 2020 ) . An alternative approach is to learn a forward model in a latent space , which may be able to avoid modeling irrelevant features and better optimize for long-term consistency . These latent spaces can be trained to maximize mutual information with the observations ( Hafner et al. , 2020 ; 2019 ) or even task-specific quantities like the reward , value , or policy ( Schrittwieser et al. , 2019 ) . Using a learned forward model , there are several ways that an agent could create a policy . While forward dynamics models map a state and action to the next state , an inverse dynamics model maps two subsequent states to an action . Inverse dynamics models have been used in various ways in sequential decision making . In exploration , inverse dynamics serves as a way to learn representations of the controllable aspects of the state ( Pathak et al. , 2017 ) . In imitation learning , inverse dynamics models can be used to map a sequence of states to the actions needed to imitate the trajectory ( Pavse et al. , 2019 ) . Christiano et al . ( 2016 ) use inverse dynamics models to translate actions taken in a simulated environment to the real world . Recently , there has been an emergence of work ( e.g. , Ghosh et al. , 2020 ; Schmidhuber , 2019 ; Srivastava et al. , 2019 ) highlighting the relationship between imitation learning and reinforcement learning . Specifically , rather than learn to map states and actions to reward , as is typical in reinforcement learning , Srivastava et al . ( 2019 ) train a model to predict actions given a state and an outcome , which could be the amount of reward the agent is to collect within a certain amount of time . Ghosh et al . ( 2020 ) use a similar idea , predicting actions conditioned on an initial state , a goal state , and the amount of time left to achieve the goal . As explored in Appendix A.1 , these methods are perhaps the nearest neighbors to our algorithm . In our paper , we tackle a visual goal-completion task due to its generality and ability to generate tasks with no domain knowledge . Reinforcement learning with multiple goals has been studied since Kaelbling ( 1993 ) . Most agents that are trained to achieve multiple goals are trained with offpolicy reinforcement learning combined with a form of hindsight relabeling ( Andrychowicz et al. , 2017 ) , where trajectories that do not achieve the desired goal are relabeled as a successful trajectory that achieves the goal that was actually reached . Andrychowicz et al . ( 2017 ) uses value-based reinforcement learning with a reward based on the euclidean distance between physical objects , which is only possible with access to an object-oriented representation of the state . In environments with high-dimensional observation spaces , goal-achievement rewards are more difficult to design . Nair et al . ( 2018 ) use a VAE ( Kingma & Welling , 2014 ) trained on observations to construct a latent space and uses distances in the latent space for a reward . These distances , however , may contain features that are uncontrollable or irrelevant . Warde-Farley et al . ( 2019 ) attempt to solve this issue by framing the goal-achievement task as maximizing the mutual information between the goal and achieved state I ( sg , sT ) . Our method differs from these approaches since we aim simply to maximize an indicator reward 1 ( sT = sg ) and do not explicitly learn a value or Q-function . 3 METHOD . 3.1 PROBLEM FORMULATION . Reinforcement learning is a framework in which an agent acts in an unknown environment and adapts based on its experience . We model the problem with an MDP , defined as the tuple ( S , A , T , R , γ ) . S is a set of states ; A is a set of actions ; the transition probabilities T : S×A×S → [ 0 , 1 ] defines the probability of the environment transitioning from state s to s′ given that the agent acts with action a ; the reward function R : S × A× S → R maps a state-action transition to a real number ; and 0 ≤ γ ≤ 1 is the discount factor , which controls how much an agent should prefer rewards sooner rather than later . An agent acts in the MDP with a policy π : S ×A→ [ 0 , 1 ] , which determines the probability of the agent taking action a while in state s. The expected return of a policy is denoted : JRL ( π ) = Eτ∼P ( τ |π ) [ ∑ t γtR ( st , at , s ′ t ) ] , ( 1 ) that is the averaged discounted future rewards for trajectories τ = { ( st , at ) } Tt=1 of states and actions sampled from the policy . A reinforcement learning agent ’ s objective is to find the optimal policy π∗ = argmaxπ JRL ( π ) that maximizes the expected return . In goal-conditioned reinforcement learning , an agent ’ s objective is to find a policy that maximizes this return over the distribution of goals g ∼ p ( g ) when acting with a policy that is now also conditioned on g. In our work , g ∈ S and we consider goal achievement rewards of the form Rg ( s ) = 1 ( s = g ) . Additionally , we consider a trajectory to be complete when any Rg ( st ) = 1 and denote this time-step t = T . With these rewards , an optimal goal-achieving agent maximizes : J ( π ) = Eg∼p ( g ) [ EsT∼p ( sT |πg ) [ γ TRg ( sT ) ] ] . ( 2 ) Note that unlike prior works , we consider both the probability of goal achievement as well as the length of the trajectory T in our objective . 3.2 PLANNING . We consider the problem of finding an optimal action sequence a1 , . . . , ak−1 to maximize expected return J ( s , g , a1 , . . . , ak−1 ) : J ( s , g , a1 , . . . , ak−1 ) = Esk∼p ( sk|s , a1 , ... , ak−1 ) [ γ krg ( sk ) ] = γ T p ( sk = g|s , a1 , . . . , ak−1 ) ( 3 ) Thus , the optimal action sequence is found by solving the following optimization problem : a∗1 , . . . , a ∗ k−1 = argmax a1 , ... , ak−1 γkp ( sk = g|s1 , a1 , . . . , ak−1 ) ( 4 ) Even with access to a perfect model of p ( sk = g|s1 , a1 , . . . , ak−1 ) , solving this optimization may be difficult . In many environments , the number of action sequences that reach the goal are vastly outnumbered by the action sequences that do not . Without a heuristic or reward-shaping , there is little hope of solving this problem in a reasonable amount of time . 3.3 GLAMOR : GOAL-CONDITIONED LATENT ACTION MODELS FOR RL . Inspired by sequence modeling in NLP , we propose to rewrite Equation 4 in a way that permits factoring across the actions in the action sequence . By factoring , planning in our model can use the heuristic search algorithms that enable sampling high quality language sequences that are hundreds of tokens long . First , note that12 : p ( sk = g|s1 , a1 , . . . , ak−1 ) ∝ k−1∏ i=1 p ( sk = g|s1 , a < i , ai ) p ( sk = g|s1 , a < i ) ( 5 ) Let z ( s1 , g , a < i , ai ) , p ( sk=g|s1 , a < i , ai ) p ( sk=g|s1 , a < i ) . Intuitively , these terms are equal to the relative gain in probability of reaching state g conditioned on taking action ai versus the marginal probability of reaching the goal without conditioning on that action . These terms provide useful information3 that can guide search towards high scoring action sequences when constructing a plan . To learn the values of the z ( s1 , g , a < i , ai ) , we use Bayes ’ rule to show that we can equivalently learn two auto-regressive behavioral models : p ( sk = g|s1 , a≤i ) p ( sk = g|s1 , a≤i−1 ) = p ( ai|sk = g , s1 , a≤i−1 ) p ( sk = g , s1 , a≤i−1 ) p ( s1 , a≤i−1 ) p ( s1 , a≤i ) p ( sk = g , s1 , a≤i−1 ) ( 6 ) = p ( ai|s1 , sk = g , a≤i−1 ) p ( ai|s1 , a≤i−1 ) ( 7 ) We refer to p ( a1 , . . . , ak|s1 , sk = g ) as the inverse dynamics model and p ( a1 , . . . , ak|s1 ) as the action prior . Using these models , we can find an optimal plan by optimizing the following objective : a∗1 , . . . , a ∗ k−1 = argmax a1 , ... , ak−1 γk p ( a1 , . . . , ak−1|s1 , sk = g ) p ( a1 , . . . , ak−1|s1 ) ( 8 ) | The author proposes Goal-Conditioned Latent Action Models for RL (GLAMOR) a novel approach to learn latent world models by modeling inverse dynamics. The proposed approach learns to track task-relevant dynamics for a diverse distribution of tasks and provide a strong heuristic that enables efficient planning. GLAMOR demonstrates good performance against its baselines in terms of achieving accurately goals, sample efficiency and effective planning. | SP:0884761fc60276d6d151552118758b07cd50a24e |
Planning from Pixels using Inverse Dynamics Models | 1 INTRODUCTION . Deep reinforcement learning has proven to be a powerful and effective framework for solving a diversity of challenging decision-making problems ( Silver et al. , 2017a ; Berner et al. , 2019 ) . However these algorithms are typically trained to maximize a single reward function , ignoring information that is not directly relevant to the associated task at hand . This way of learning is in stark contrast to how humans learn ( Tenenbaum , 2018 ) . Without being prompted by a specific task , humans can still explore their environment , practice achieving imaginary goals , and in so doing learn about the dynamics of the environment . When subsequently presented with a novel task , humans can utilize this learned knowledge to bootstrap learning — a property we would like our artificial agents to have . In this work , we investigate one way to bridge this gap by learning world models ( Ha & Schmidhuber , 2018 ) that enable the realization of previously unseen tasks . By modeling the task-agnostic dynamics of an environment , an agent can make predictions about how its own actions may affect the environment state without the need for additional samples from the environment . Prior work has shown that by using powerful function approximators to model environment dynamics , training an agent entirely within its own world models can result in large gains in sample efficiency ( Ha & Schmidhuber , 2018 ) . However , learning world models that are both accurate and general has largely remained elusive , with these models experiencing many performance issues in the multi-task setting . The main reason for poor performance is the so-called planning horizon dilemma ( Wang et al. , 2019 ) : accurately modeling dynamics over a long horizon is necessary to accurately estimate rewards , but performance is often poor when planning over long sequences due to the accumulation of errors . These modeling errors are especially prevalent in high-dimensional observation spaces where loss functions that operate on pixels may focus model capacity on task-irrelevant features ( Kaiser et al. , 2020 ) . Recent work ( Hafner et al. , 2020 ; Schrittwieser et al. , 2019 ) has attempted to side-step these issues by learning a world model in a latent space and propagating gradients over multiple time-steps . While these methods are able to learn accurate world models and achieve high performance on benchmark tasks , their representations are usually trained with task-specific information such as rewards , encouraging the model to focus on tracking task-relevant features but compromising their ability to generalize to new tasks . In this work , we propose to learn powerful , latent world models that can predict environment dynamics when planning for a distribution of tasks . The main contributions of our paper are three-fold : we propose to learn a latent world model conditioned on a goal ; we train our latent representation to model inverse dynamics — sequences of actions that take the agent from one state to another , rather than training it to capture information about reward ; and we show that by combining our inverse dynamics model and a prior over action sequences , we can quickly construct plans that maximize the probability of reaching a goal state . We evaluate our world model on a diverse distribution of challenging visual goals in Atari games and the Deepmind Control Suite ( Tassa et al. , 2018 ) to assess both its accuracy and sample efficiency . We find that when planning in our latent world model , our agent outperforms prior , model-free methods across most tasks , while providing an order of magnitude better sample efficiency on some tasks . 2 RELATED WORK . Model-based RL has typically focused on learning powerful forward dynamics models , which are trained to predict the next state given the current state and action . In works such as ( Kaiser et al. , 2020 ) , these models are trained to predict the next state in observation space - often by minimizing L2 distance . While the performance of these algorithms in the low data regime is often strong , they can struggle to reach the asymptotic performance of model-free methods ( Hafner et al. , 2020 ) . An alternative approach is to learn a forward model in a latent space , which may be able to avoid modeling irrelevant features and better optimize for long-term consistency . These latent spaces can be trained to maximize mutual information with the observations ( Hafner et al. , 2020 ; 2019 ) or even task-specific quantities like the reward , value , or policy ( Schrittwieser et al. , 2019 ) . Using a learned forward model , there are several ways that an agent could create a policy . While forward dynamics models map a state and action to the next state , an inverse dynamics model maps two subsequent states to an action . Inverse dynamics models have been used in various ways in sequential decision making . In exploration , inverse dynamics serves as a way to learn representations of the controllable aspects of the state ( Pathak et al. , 2017 ) . In imitation learning , inverse dynamics models can be used to map a sequence of states to the actions needed to imitate the trajectory ( Pavse et al. , 2019 ) . Christiano et al . ( 2016 ) use inverse dynamics models to translate actions taken in a simulated environment to the real world . Recently , there has been an emergence of work ( e.g. , Ghosh et al. , 2020 ; Schmidhuber , 2019 ; Srivastava et al. , 2019 ) highlighting the relationship between imitation learning and reinforcement learning . Specifically , rather than learn to map states and actions to reward , as is typical in reinforcement learning , Srivastava et al . ( 2019 ) train a model to predict actions given a state and an outcome , which could be the amount of reward the agent is to collect within a certain amount of time . Ghosh et al . ( 2020 ) use a similar idea , predicting actions conditioned on an initial state , a goal state , and the amount of time left to achieve the goal . As explored in Appendix A.1 , these methods are perhaps the nearest neighbors to our algorithm . In our paper , we tackle a visual goal-completion task due to its generality and ability to generate tasks with no domain knowledge . Reinforcement learning with multiple goals has been studied since Kaelbling ( 1993 ) . Most agents that are trained to achieve multiple goals are trained with offpolicy reinforcement learning combined with a form of hindsight relabeling ( Andrychowicz et al. , 2017 ) , where trajectories that do not achieve the desired goal are relabeled as a successful trajectory that achieves the goal that was actually reached . Andrychowicz et al . ( 2017 ) uses value-based reinforcement learning with a reward based on the euclidean distance between physical objects , which is only possible with access to an object-oriented representation of the state . In environments with high-dimensional observation spaces , goal-achievement rewards are more difficult to design . Nair et al . ( 2018 ) use a VAE ( Kingma & Welling , 2014 ) trained on observations to construct a latent space and uses distances in the latent space for a reward . These distances , however , may contain features that are uncontrollable or irrelevant . Warde-Farley et al . ( 2019 ) attempt to solve this issue by framing the goal-achievement task as maximizing the mutual information between the goal and achieved state I ( sg , sT ) . Our method differs from these approaches since we aim simply to maximize an indicator reward 1 ( sT = sg ) and do not explicitly learn a value or Q-function . 3 METHOD . 3.1 PROBLEM FORMULATION . Reinforcement learning is a framework in which an agent acts in an unknown environment and adapts based on its experience . We model the problem with an MDP , defined as the tuple ( S , A , T , R , γ ) . S is a set of states ; A is a set of actions ; the transition probabilities T : S×A×S → [ 0 , 1 ] defines the probability of the environment transitioning from state s to s′ given that the agent acts with action a ; the reward function R : S × A× S → R maps a state-action transition to a real number ; and 0 ≤ γ ≤ 1 is the discount factor , which controls how much an agent should prefer rewards sooner rather than later . An agent acts in the MDP with a policy π : S ×A→ [ 0 , 1 ] , which determines the probability of the agent taking action a while in state s. The expected return of a policy is denoted : JRL ( π ) = Eτ∼P ( τ |π ) [ ∑ t γtR ( st , at , s ′ t ) ] , ( 1 ) that is the averaged discounted future rewards for trajectories τ = { ( st , at ) } Tt=1 of states and actions sampled from the policy . A reinforcement learning agent ’ s objective is to find the optimal policy π∗ = argmaxπ JRL ( π ) that maximizes the expected return . In goal-conditioned reinforcement learning , an agent ’ s objective is to find a policy that maximizes this return over the distribution of goals g ∼ p ( g ) when acting with a policy that is now also conditioned on g. In our work , g ∈ S and we consider goal achievement rewards of the form Rg ( s ) = 1 ( s = g ) . Additionally , we consider a trajectory to be complete when any Rg ( st ) = 1 and denote this time-step t = T . With these rewards , an optimal goal-achieving agent maximizes : J ( π ) = Eg∼p ( g ) [ EsT∼p ( sT |πg ) [ γ TRg ( sT ) ] ] . ( 2 ) Note that unlike prior works , we consider both the probability of goal achievement as well as the length of the trajectory T in our objective . 3.2 PLANNING . We consider the problem of finding an optimal action sequence a1 , . . . , ak−1 to maximize expected return J ( s , g , a1 , . . . , ak−1 ) : J ( s , g , a1 , . . . , ak−1 ) = Esk∼p ( sk|s , a1 , ... , ak−1 ) [ γ krg ( sk ) ] = γ T p ( sk = g|s , a1 , . . . , ak−1 ) ( 3 ) Thus , the optimal action sequence is found by solving the following optimization problem : a∗1 , . . . , a ∗ k−1 = argmax a1 , ... , ak−1 γkp ( sk = g|s1 , a1 , . . . , ak−1 ) ( 4 ) Even with access to a perfect model of p ( sk = g|s1 , a1 , . . . , ak−1 ) , solving this optimization may be difficult . In many environments , the number of action sequences that reach the goal are vastly outnumbered by the action sequences that do not . Without a heuristic or reward-shaping , there is little hope of solving this problem in a reasonable amount of time . 3.3 GLAMOR : GOAL-CONDITIONED LATENT ACTION MODELS FOR RL . Inspired by sequence modeling in NLP , we propose to rewrite Equation 4 in a way that permits factoring across the actions in the action sequence . By factoring , planning in our model can use the heuristic search algorithms that enable sampling high quality language sequences that are hundreds of tokens long . First , note that12 : p ( sk = g|s1 , a1 , . . . , ak−1 ) ∝ k−1∏ i=1 p ( sk = g|s1 , a < i , ai ) p ( sk = g|s1 , a < i ) ( 5 ) Let z ( s1 , g , a < i , ai ) , p ( sk=g|s1 , a < i , ai ) p ( sk=g|s1 , a < i ) . Intuitively , these terms are equal to the relative gain in probability of reaching state g conditioned on taking action ai versus the marginal probability of reaching the goal without conditioning on that action . These terms provide useful information3 that can guide search towards high scoring action sequences when constructing a plan . To learn the values of the z ( s1 , g , a < i , ai ) , we use Bayes ’ rule to show that we can equivalently learn two auto-regressive behavioral models : p ( sk = g|s1 , a≤i ) p ( sk = g|s1 , a≤i−1 ) = p ( ai|sk = g , s1 , a≤i−1 ) p ( sk = g , s1 , a≤i−1 ) p ( s1 , a≤i−1 ) p ( s1 , a≤i ) p ( sk = g , s1 , a≤i−1 ) ( 6 ) = p ( ai|s1 , sk = g , a≤i−1 ) p ( ai|s1 , a≤i−1 ) ( 7 ) We refer to p ( a1 , . . . , ak|s1 , sk = g ) as the inverse dynamics model and p ( a1 , . . . , ak|s1 ) as the action prior . Using these models , we can find an optimal plan by optimizing the following objective : a∗1 , . . . , a ∗ k−1 = argmax a1 , ... , ak−1 γk p ( a1 , . . . , ak−1|s1 , sk = g ) p ( a1 , . . . , ak−1|s1 ) ( 8 ) | The paper proposes a model-based reinforcement learning method. The method builds a partial model of the environment through learning inverse dynamics, which is the distribution of action sequences that would bring one state to another state. Through training the model with an iterative relabeling scheme, the model is able to learn to reach goals in a subset of DM Control and Atari domains. | SP:0884761fc60276d6d151552118758b07cd50a24e |
On the Stability of Multi-branch Network | 1 INTRODUCTION . Multi-branch architecture is a building block in state-of-the-art neural network models for many tasks , e.g. , the ResNeXt ( Xie et al. , 2017 ) for computer vision and the Transformer ( Vaswani et al. , 2017 ) for machine translation . It has been pointed out that the benefit of multi-branch architecture is the parameter efficiency ( Xie et al. , 2017 ) . The number of parameters grows linearly with the number of branches but quadratically with the width ( the number of neurons in one layer ) . It has also been argued that the multiple branches can bring diversity if branches are composed of sub-networks with different filters and depths ( Huang et al. , 2017 ; Li et al. , 2019 ) . To train multi-branch networks successfully , it usually requires careful designs and some hyperparameter tuning such as adding normalization layers , scaling down the initialization , and adjusting learning rate . As a verifying example , for a trainable single-branch network , simply adding branches multiple times and aggregating their outputs together often do not work as expected , e.g. , the training instability of sum aggregation in Figure 4 . This demonstrates the difficulty of training multi-branch network and also motivates us to do this study . In this paper , we try to understand the behavior of training multi-branch network . Specifically , we study the forward and backward process of multi-branch networks , which is believed to govern whether the network is easy to optimize by gradient-based methods . We find out that the aggregation scheme , i.e. , “ the way of combining the multi-branch outputs ” plays a central role in determining the behavior of training multi-branch network . We show that the sum aggregation would become unstable as the number of branches grows , which explains the bad performance of simply adding branches . Moreover , we characterize the condition on the aggregation scheme under which the forward and backward stability is guaranteed . Inspired by the theoretical analysis , we propose a “ STAM ” aggregation , that can STAbilize Multibranch network , which scales the sum of the branch outputs by a branch-aware factor α ( see the later part of Section 3.1 for details ) . We argue the benefit of STAM aggregation over the sum and average aggregations by analyzing the Hessian of the multi-branch network . We show that STAM permits the same gradient-based optimizer works for different settings , which could reduce lots of tuning burden for training network with flexible number of branches . We further examine the usual design wisdom through the stability lens . As a result , we find that scaling down initialization may control the forward or backward stability but not necessarily the both , which is verified in experiment . We also unveil a new role of normalization layer that it can stabilize the forward and backward process of multi-branch network besides the many wanted and unwanted properties that have been argued before ( Ioffe & Szegedy , 2015 ; Yang et al. , 2018 ; Santurkar et al. , 2018 ; Xiong et al. , 2020 ) . Apart from the usual feedforward multi-branch architecture , we analyze the multi-head attention layer , a multi-branch architecture widely used in natural language processing . We give an upper bound on the multi-head representations when the softmax operator is replaced with max operation . The upper bound unveils the relation between the head dimension and the length of the sequence , which interprets empirical observation well . This relation can not be discovered if assuming softmax outputs equal probability as in Xiong et al . ( 2020 ) . Overall , our contribution can be summarized as follows . • We analyze the forward/backward stability of multi-branch network , under which we can clearly interpret the benefit and potential problem of the practical wisdom , i.e. , scaling down initialization and adding normalization layer . • We propose a theoretically inspired STAM aggregation design for multi-branch network , which can handle arbitrary number of branches with a same optimizer . • We also analyze the forward/backward process of multi-head attention layer and identify its special property that has not been characterized before . 1.1 RELATED WORK . Multi-branch architecture , also known as split-transform-merge architecture , has been widely used in computer vision task , namely Inceptions ( Szegedy et al. , 2017 ; Chollet , 2017 ) , ResNeXt ( Xie et al. , 2017 ) , and many others ( Abdi & Nahavandi , 2016 ; Ahmed & Torresani , 2017 ) . In fact , the models in natural language tasks have also leveraged the multi-branch architecture including the BiLSTM ( Wu et al. , 2016 ; Zhou et al. , 2016 ) and the multi-head attention layer in Transformer ( Vaswani et al. , 2017 ; Anonymous , 2020 ) . Apart from the sum or average aggregation , recent works ( Li et al. , 2019 ; Zhang et al. , 2020 ) integrate the attention mechanism with the aggregation scheme , i.e. , the attentive aggregation , although only a small number ( 2 ∼ 3 ) of parallel branches are considered . Theoretically , Zhang et al . ( 2018 ) interpret the benefit of multi-branch architecture from reducing the duality gap or the degree of non-convexity . The theory of training general deep neural network has been widely studied , via the stability analysis ( Arpit et al. , 2019 ; Zhang et al. , 2019a ; c ; Yang & Schoenholz , 2017 ; Zhang et al. , 2019b ; Yang , 2019 ; Lee et al. , 2019 ) , neural tangent kernel ( Jacot et al. , 2018 ; Allen-Zhu et al. , 2018 ; Du et al. , 2018 ; Chizat & Bach , 2018 ; Zou et al. , 2018 ; Zou & Gu , 2019 ; Arora et al. , 2019 ; Oymak & Soltanolkotabi , 2019 ; Chen et al. , 2019 ; Ji & Telgarsky , 2019 ) . In contrast , we focus on the multi-branch network , which has not been studied theoretically before . 2 MODEL DESCRIPTION AND NOTATIONS . In practice , the multi-branch architecture is often used as a building block in a whole network . In this paper , we describe a multi-branch architecture/network N ( · ) as follows ( see Figure 1 ) . • N ( · ) has C branches { Bk } Ck=1 , input hin ∈ Rp and output hout ∈ Rd ; • The aggregation is parameterized with a vector α = ( α1 , . . . , αC ) T : hout : = N ( hin ) : = C∑ k=1 αk · Bk ( hin ) . ( 1 ) Each branch Bk often consists of multiple layers with various structures and flexible configuration : depth , width , kernel size for convolution layer , activation functions and normalization layer . The aggregation weight is given by α . Such description covers popular multi-branch architectures in state-of-the-art models , e.g. , Inception , ResNeXt and Transformer , if specifying Bk and α properly . Throughout the paper , we use ‖ · ‖ to denote the l2 norm of a vector . We further use ‖ · ‖ and ‖ · ‖F to denote the spectral norm and the Frobenius norm of a matrix , respectively . We denote a set of naturals with [ n ] : = { 1 , . . . , n } and [ c : d ] = { c , c+ 1 , . . . , d } . We use bold small case letters , e.g. , v , to denote vectors and bold capital case letters , e.g. , M , to denote matrices . Moreover , Id×d is the d× d identity matrix , 1d is d dimensional vector with all 1 ’ s , and Vec ( M ) stacks the row vectors of matrixM as a long vector . 3 STABILITY OF MULTI-BRANCH FEEDFORWARD NETWORK . To theoretically study the multi-branch network , we introduce a simplified multi-branch feedforward network . Specifically , we assume that each branch is a b-layer fully connected network with ReLU activation , and each layer has the same width m. Branches share the same structure and they differ from each other by the random initialization . One branch is given by Bk ( hin ) = W kbφ ( W k b−1 · · ·φ ( W k 1hin ) ) , ( 2 ) where W k1 ∈ Rm×p , W k b ∈ Rd×m and φ ( · ) is the ReLU activation φ ( · ) : = max { 0 , · } . We further introduce −→ W k : = ( W k1 , . . . , W k b ) that collects parameters of Bk , and −→ W : = ( −→ W 1 , . . . , −→ WC ) . Next we analyze the forward and backward propagation of the multi-branch network given by ( Equation 1 ) and ( Equation 2 ) , and characterize a condition that guarantees forward/backward stability . Based on the theoretical analysis , we propose the STAM aggregation that can stabilize the forward/backward process of multi-branch networks . We further argue why the practical wisdom of scaling down initialization and adding normalization layer works and when it could fail . 3.1 FORWARD AND BACKWARD PROCESS . We assume that the feedforward multi-branch network given by ( Equation 1 ) and ( Equation 2 ) adopts the Kaiming ’ s initialization ( He et al. , 2016 ) : entries of W a for a ∈ [ 1 : b− 1 ] are independently sampled from N ( 0 , 2m ) , and entries of W b are independently sampled from N ( 0 , 1 d ) . Then the forward norm is well concentrated around its mean value as follows . Theorem 1 . Suppose the multi-branch network N ( · ) is given by Equation 1 and Equation 2 with Kaiming ’ s initialization . For an input hin , the following holds with probability at least 1−O ( bC ) · e−Ω ( m 2/b ) over the initialization randomness of −→ W ‖N ( hin ) ‖ ∈ ( 1± ) √∑ k∈ [ C ] α2k‖hin‖ , ( 3 ) where C is the number of branches , and m , b are the width and depth of each branch , respectively . Proof . The proof is based on the Gaussianness of Bk ( hin ) and a concentration property , whose full version is deferred to Appendix A.2 . Theorem 1 is presented for one input sample . If we want such a result holds for all the training samples , the probability loses an n factor by the union bound and becomes 1−O ( nbC ) · e−Ω ( m 2/b ) . Remark 1 . With the same assumption as Theorem 1 , we have E‖N ( hin ) ‖ = √∑ k∈ [ C ] α2k‖hin‖ , ( 4 ) where C is the number of branches and the expectation is over the random initialization . These results are based on the bound of the forward propagation of one feed-forward branch given by ( Equation 2 ) , which is studied in Allen-Zhu et al . ( 2018 ) and restated in Appendix A . Furthermore , if the weight matrices follows the Gaussian distribution , then Bk ( hin ) is also roughly Gaussian and jointly Gaussian for different input samples , as the width m goes to infinity . Then the aggregation ( Equation 1 ) can be viewed as a sum of weighted Gaussian vectors . Hence at the initialization , we can characterize the aggregation of multiple branches as above . We next analyze the backward propagation of multi-branch feedforward network . We abuse “ gradient ” to refer to the values computed through back-propagation even for non-smooth function . We assume the loss function ` ( · , · ) is quadratic , i.e. , ` ( hout , y∗ ) = 12‖hout−y ∗‖22 . Hence , the objective function is L ( −→ W ) : = 1n ∑n i=1 Li ( −→ W ) , where Li ( −→ W ) : = ` ( N ( xi ) , y∗i ) . We next show the backward process is bounded for each individual sample for the multi-branch network N ( · ) . Theorem 2 . With probability at least 1− ( nb ) · exp ( −Ω ( m ) ) over the randomness of −→ W , it satisfies for every a ∈ [ b ] and k ∈ [ C ] , every i ∈ [ n ] , ∥∥∥∇WkaLi ( −→W ) ∥∥∥2F ≤ O ( Li ( −→ W ) α2k ×m d ) , ∥∥∥∇−→WLi ( −→W ) ∥∥∥2F ≤ O ( Li ( −→W ) × mbd ∑ k∈ [ C ] α2k ) . ( 5 ) Proof . We can compute the gradient with respect to intermediate layer outputs via the backward propagation procedure . The gradient upper bound is guaranteed if the intermediate layer outputs and their gradients are bounded across layers . The full proof is relegated to Appendix A.3 . If further assuming the gradient independence condition : weights in backward process can be assumed to be independent from weights in the forward pass ( Yang , 2019 ) , we can estimate the expectation of the gradient norm as follows . Remark 2 . Assuming the gradient independence , we have for every a ∈ [ b ] and k ∈ [ C ] , every i ∈ [ n ] , E ∥∥∥∇WkaLi ( −→W ) ∥∥∥2F = Li ( −→W ) α2k ×md , E∥∥∥∇−→WLi ( −→W ) ∥∥∥2F = Li ( −→W ) × mbd ∑ k∈ [ C ] α2k . ( 6 ) With Theorem 1 and 2 and two remarks , we can discuss the property of the forward and backward process of the multi-branch network . We can see that both the output of multi-branch network and the gradient are under control if ∑ α2k ≤ O ( 1 ) . Specifically , for the sum aggregation , we have∑ α2k = C which grows unbounded with the number of branches C. For the average aggregation , we have ∑ α2k = 1/C which diminishes with the number of branches C. There exists a better choice of αk : αk = 1/ √ C for k ∈ [ C ] that keeps ∑ α2k = 1 constant as the number of branches varies . We call it “ STAM ” aggregation , abbreviating STAble Multibranch aggregation . We plot the output norm of the first residual block in multi-branch ResNets at initialization in Figure 2 . Multi-branch ResNets are generated by varying the number of branches in the residual block with batch normalization removed . We can see that the forward norm of STAM aggregation roughly remains the same , while that of the sum aggregation explodes and that of the average aggregation diminishes , as the number of branches grows . We also analyze the Hessian of different aggregation schemes . We find that the spectral norm of the Hessian , which determines the smoothness of the objective , proportionally scales with the square root of the number of branches for the sum aggregation , while reciprocally scales with the square root of the number of branches for the average aggregation . In contrast , the Hessian for the STAM aggregation keeps unchanged as the number of branches varies . Hence with STAM , the same learning rate works for network with different number of branches . We present the details in Appendix B . | This paper studies the training of multi-branch networks, i.e. networks formed by linearly combining multiple disjoint branches of the same architecture. The core contribution in this paper is the “STAM” aggregation rule which is to set the combination coefficient to $1/\sqrt{C}$ for a network with $C$ branches. This aggregation rule is justified by (1) theoretical analysis on the function values and gradient norms at initialization, and (2) experiments on residual networks and transformers showing that this rule performs better than the baseline rules (such as sum or average). | SP:b57dd473377d8ec5ef38f2cebd1f83a847270b27 |
On the Stability of Multi-branch Network | 1 INTRODUCTION . Multi-branch architecture is a building block in state-of-the-art neural network models for many tasks , e.g. , the ResNeXt ( Xie et al. , 2017 ) for computer vision and the Transformer ( Vaswani et al. , 2017 ) for machine translation . It has been pointed out that the benefit of multi-branch architecture is the parameter efficiency ( Xie et al. , 2017 ) . The number of parameters grows linearly with the number of branches but quadratically with the width ( the number of neurons in one layer ) . It has also been argued that the multiple branches can bring diversity if branches are composed of sub-networks with different filters and depths ( Huang et al. , 2017 ; Li et al. , 2019 ) . To train multi-branch networks successfully , it usually requires careful designs and some hyperparameter tuning such as adding normalization layers , scaling down the initialization , and adjusting learning rate . As a verifying example , for a trainable single-branch network , simply adding branches multiple times and aggregating their outputs together often do not work as expected , e.g. , the training instability of sum aggregation in Figure 4 . This demonstrates the difficulty of training multi-branch network and also motivates us to do this study . In this paper , we try to understand the behavior of training multi-branch network . Specifically , we study the forward and backward process of multi-branch networks , which is believed to govern whether the network is easy to optimize by gradient-based methods . We find out that the aggregation scheme , i.e. , “ the way of combining the multi-branch outputs ” plays a central role in determining the behavior of training multi-branch network . We show that the sum aggregation would become unstable as the number of branches grows , which explains the bad performance of simply adding branches . Moreover , we characterize the condition on the aggregation scheme under which the forward and backward stability is guaranteed . Inspired by the theoretical analysis , we propose a “ STAM ” aggregation , that can STAbilize Multibranch network , which scales the sum of the branch outputs by a branch-aware factor α ( see the later part of Section 3.1 for details ) . We argue the benefit of STAM aggregation over the sum and average aggregations by analyzing the Hessian of the multi-branch network . We show that STAM permits the same gradient-based optimizer works for different settings , which could reduce lots of tuning burden for training network with flexible number of branches . We further examine the usual design wisdom through the stability lens . As a result , we find that scaling down initialization may control the forward or backward stability but not necessarily the both , which is verified in experiment . We also unveil a new role of normalization layer that it can stabilize the forward and backward process of multi-branch network besides the many wanted and unwanted properties that have been argued before ( Ioffe & Szegedy , 2015 ; Yang et al. , 2018 ; Santurkar et al. , 2018 ; Xiong et al. , 2020 ) . Apart from the usual feedforward multi-branch architecture , we analyze the multi-head attention layer , a multi-branch architecture widely used in natural language processing . We give an upper bound on the multi-head representations when the softmax operator is replaced with max operation . The upper bound unveils the relation between the head dimension and the length of the sequence , which interprets empirical observation well . This relation can not be discovered if assuming softmax outputs equal probability as in Xiong et al . ( 2020 ) . Overall , our contribution can be summarized as follows . • We analyze the forward/backward stability of multi-branch network , under which we can clearly interpret the benefit and potential problem of the practical wisdom , i.e. , scaling down initialization and adding normalization layer . • We propose a theoretically inspired STAM aggregation design for multi-branch network , which can handle arbitrary number of branches with a same optimizer . • We also analyze the forward/backward process of multi-head attention layer and identify its special property that has not been characterized before . 1.1 RELATED WORK . Multi-branch architecture , also known as split-transform-merge architecture , has been widely used in computer vision task , namely Inceptions ( Szegedy et al. , 2017 ; Chollet , 2017 ) , ResNeXt ( Xie et al. , 2017 ) , and many others ( Abdi & Nahavandi , 2016 ; Ahmed & Torresani , 2017 ) . In fact , the models in natural language tasks have also leveraged the multi-branch architecture including the BiLSTM ( Wu et al. , 2016 ; Zhou et al. , 2016 ) and the multi-head attention layer in Transformer ( Vaswani et al. , 2017 ; Anonymous , 2020 ) . Apart from the sum or average aggregation , recent works ( Li et al. , 2019 ; Zhang et al. , 2020 ) integrate the attention mechanism with the aggregation scheme , i.e. , the attentive aggregation , although only a small number ( 2 ∼ 3 ) of parallel branches are considered . Theoretically , Zhang et al . ( 2018 ) interpret the benefit of multi-branch architecture from reducing the duality gap or the degree of non-convexity . The theory of training general deep neural network has been widely studied , via the stability analysis ( Arpit et al. , 2019 ; Zhang et al. , 2019a ; c ; Yang & Schoenholz , 2017 ; Zhang et al. , 2019b ; Yang , 2019 ; Lee et al. , 2019 ) , neural tangent kernel ( Jacot et al. , 2018 ; Allen-Zhu et al. , 2018 ; Du et al. , 2018 ; Chizat & Bach , 2018 ; Zou et al. , 2018 ; Zou & Gu , 2019 ; Arora et al. , 2019 ; Oymak & Soltanolkotabi , 2019 ; Chen et al. , 2019 ; Ji & Telgarsky , 2019 ) . In contrast , we focus on the multi-branch network , which has not been studied theoretically before . 2 MODEL DESCRIPTION AND NOTATIONS . In practice , the multi-branch architecture is often used as a building block in a whole network . In this paper , we describe a multi-branch architecture/network N ( · ) as follows ( see Figure 1 ) . • N ( · ) has C branches { Bk } Ck=1 , input hin ∈ Rp and output hout ∈ Rd ; • The aggregation is parameterized with a vector α = ( α1 , . . . , αC ) T : hout : = N ( hin ) : = C∑ k=1 αk · Bk ( hin ) . ( 1 ) Each branch Bk often consists of multiple layers with various structures and flexible configuration : depth , width , kernel size for convolution layer , activation functions and normalization layer . The aggregation weight is given by α . Such description covers popular multi-branch architectures in state-of-the-art models , e.g. , Inception , ResNeXt and Transformer , if specifying Bk and α properly . Throughout the paper , we use ‖ · ‖ to denote the l2 norm of a vector . We further use ‖ · ‖ and ‖ · ‖F to denote the spectral norm and the Frobenius norm of a matrix , respectively . We denote a set of naturals with [ n ] : = { 1 , . . . , n } and [ c : d ] = { c , c+ 1 , . . . , d } . We use bold small case letters , e.g. , v , to denote vectors and bold capital case letters , e.g. , M , to denote matrices . Moreover , Id×d is the d× d identity matrix , 1d is d dimensional vector with all 1 ’ s , and Vec ( M ) stacks the row vectors of matrixM as a long vector . 3 STABILITY OF MULTI-BRANCH FEEDFORWARD NETWORK . To theoretically study the multi-branch network , we introduce a simplified multi-branch feedforward network . Specifically , we assume that each branch is a b-layer fully connected network with ReLU activation , and each layer has the same width m. Branches share the same structure and they differ from each other by the random initialization . One branch is given by Bk ( hin ) = W kbφ ( W k b−1 · · ·φ ( W k 1hin ) ) , ( 2 ) where W k1 ∈ Rm×p , W k b ∈ Rd×m and φ ( · ) is the ReLU activation φ ( · ) : = max { 0 , · } . We further introduce −→ W k : = ( W k1 , . . . , W k b ) that collects parameters of Bk , and −→ W : = ( −→ W 1 , . . . , −→ WC ) . Next we analyze the forward and backward propagation of the multi-branch network given by ( Equation 1 ) and ( Equation 2 ) , and characterize a condition that guarantees forward/backward stability . Based on the theoretical analysis , we propose the STAM aggregation that can stabilize the forward/backward process of multi-branch networks . We further argue why the practical wisdom of scaling down initialization and adding normalization layer works and when it could fail . 3.1 FORWARD AND BACKWARD PROCESS . We assume that the feedforward multi-branch network given by ( Equation 1 ) and ( Equation 2 ) adopts the Kaiming ’ s initialization ( He et al. , 2016 ) : entries of W a for a ∈ [ 1 : b− 1 ] are independently sampled from N ( 0 , 2m ) , and entries of W b are independently sampled from N ( 0 , 1 d ) . Then the forward norm is well concentrated around its mean value as follows . Theorem 1 . Suppose the multi-branch network N ( · ) is given by Equation 1 and Equation 2 with Kaiming ’ s initialization . For an input hin , the following holds with probability at least 1−O ( bC ) · e−Ω ( m 2/b ) over the initialization randomness of −→ W ‖N ( hin ) ‖ ∈ ( 1± ) √∑ k∈ [ C ] α2k‖hin‖ , ( 3 ) where C is the number of branches , and m , b are the width and depth of each branch , respectively . Proof . The proof is based on the Gaussianness of Bk ( hin ) and a concentration property , whose full version is deferred to Appendix A.2 . Theorem 1 is presented for one input sample . If we want such a result holds for all the training samples , the probability loses an n factor by the union bound and becomes 1−O ( nbC ) · e−Ω ( m 2/b ) . Remark 1 . With the same assumption as Theorem 1 , we have E‖N ( hin ) ‖ = √∑ k∈ [ C ] α2k‖hin‖ , ( 4 ) where C is the number of branches and the expectation is over the random initialization . These results are based on the bound of the forward propagation of one feed-forward branch given by ( Equation 2 ) , which is studied in Allen-Zhu et al . ( 2018 ) and restated in Appendix A . Furthermore , if the weight matrices follows the Gaussian distribution , then Bk ( hin ) is also roughly Gaussian and jointly Gaussian for different input samples , as the width m goes to infinity . Then the aggregation ( Equation 1 ) can be viewed as a sum of weighted Gaussian vectors . Hence at the initialization , we can characterize the aggregation of multiple branches as above . We next analyze the backward propagation of multi-branch feedforward network . We abuse “ gradient ” to refer to the values computed through back-propagation even for non-smooth function . We assume the loss function ` ( · , · ) is quadratic , i.e. , ` ( hout , y∗ ) = 12‖hout−y ∗‖22 . Hence , the objective function is L ( −→ W ) : = 1n ∑n i=1 Li ( −→ W ) , where Li ( −→ W ) : = ` ( N ( xi ) , y∗i ) . We next show the backward process is bounded for each individual sample for the multi-branch network N ( · ) . Theorem 2 . With probability at least 1− ( nb ) · exp ( −Ω ( m ) ) over the randomness of −→ W , it satisfies for every a ∈ [ b ] and k ∈ [ C ] , every i ∈ [ n ] , ∥∥∥∇WkaLi ( −→W ) ∥∥∥2F ≤ O ( Li ( −→ W ) α2k ×m d ) , ∥∥∥∇−→WLi ( −→W ) ∥∥∥2F ≤ O ( Li ( −→W ) × mbd ∑ k∈ [ C ] α2k ) . ( 5 ) Proof . We can compute the gradient with respect to intermediate layer outputs via the backward propagation procedure . The gradient upper bound is guaranteed if the intermediate layer outputs and their gradients are bounded across layers . The full proof is relegated to Appendix A.3 . If further assuming the gradient independence condition : weights in backward process can be assumed to be independent from weights in the forward pass ( Yang , 2019 ) , we can estimate the expectation of the gradient norm as follows . Remark 2 . Assuming the gradient independence , we have for every a ∈ [ b ] and k ∈ [ C ] , every i ∈ [ n ] , E ∥∥∥∇WkaLi ( −→W ) ∥∥∥2F = Li ( −→W ) α2k ×md , E∥∥∥∇−→WLi ( −→W ) ∥∥∥2F = Li ( −→W ) × mbd ∑ k∈ [ C ] α2k . ( 6 ) With Theorem 1 and 2 and two remarks , we can discuss the property of the forward and backward process of the multi-branch network . We can see that both the output of multi-branch network and the gradient are under control if ∑ α2k ≤ O ( 1 ) . Specifically , for the sum aggregation , we have∑ α2k = C which grows unbounded with the number of branches C. For the average aggregation , we have ∑ α2k = 1/C which diminishes with the number of branches C. There exists a better choice of αk : αk = 1/ √ C for k ∈ [ C ] that keeps ∑ α2k = 1 constant as the number of branches varies . We call it “ STAM ” aggregation , abbreviating STAble Multibranch aggregation . We plot the output norm of the first residual block in multi-branch ResNets at initialization in Figure 2 . Multi-branch ResNets are generated by varying the number of branches in the residual block with batch normalization removed . We can see that the forward norm of STAM aggregation roughly remains the same , while that of the sum aggregation explodes and that of the average aggregation diminishes , as the number of branches grows . We also analyze the Hessian of different aggregation schemes . We find that the spectral norm of the Hessian , which determines the smoothness of the objective , proportionally scales with the square root of the number of branches for the sum aggregation , while reciprocally scales with the square root of the number of branches for the average aggregation . In contrast , the Hessian for the STAM aggregation keeps unchanged as the number of branches varies . Hence with STAM , the same learning rate works for network with different number of branches . We present the details in Appendix B . | This study focuses on the stability of multi-branch networks. It analyzes the forward and backward stability of multi-branch network, and builds the relations with some widely-adopted initialization and normalization schemes. A simple new aggregation method is proposed that enjoys better stability than the sum and average aggregations. The method is extended to the multi-head attention layer in Transformer. Experiments on image classification and machine translation tasks using ResNeXt and Transformer are conduced to show the efficacy. | SP:b57dd473377d8ec5ef38f2cebd1f83a847270b27 |
RMSprop converges with proper hyper-parameter | 1 INTRODUCTION . RMSprop ( Tieleman & Hinton , 2012 ) remains one of the most popular algorithms for machine learning applications . As a non-momentum version of a more general algorithm Adam , RMSprop ’ s good empirical performance has been well acknowledged by practitioners in generative adversarial networks ( GANs ) ( Seward et al. , 2018 ; Yazıcı et al. , 2019 ; Karnewar & Wang , 2020 ; JolicoeurMartineau , 2019 ) , reinforcement learning ( Mnih et al. , 2016 ) , etc . In spite of its prevalence , however , Reddi et al . ( 2018 ) discovered that RMSprop ( as well as the more general version Adam ) can diverge even for simple convex functions . To fix the algorithm , the authors of Reddi et al . ( 2018 ) proposed a new variant called AMSGrad , which is guaranteed to converge under certain conditions . Since then , it has been an active area of research to design provably convergent variants of RMSprop . These variants include AdaFom ( Chen et al. , 2019 ) , Adabound ( Luo et al. , 2019 ) , Nostalgic Adam ( Huang et al. , 2019 ) , Yogi ( Zaheer et al. , 2018 ) , and many more . Despite the variants , the vanilla RMSprop indeed works well in practice , and after proper hyper-parameter tuning , the non-convergence issue has not been commonly observed . Why is there a large gap between theory and practice ? Is this because the real-world problems are likely to be “ nice ” , or is it because the theoretical analysis of RMSprop does not match how it is used in practice ? With the above questions in mind , we revisited the counter-example of Reddi et al . ( 2018 ) , and found an interesting phenomenon . One counter-example of Reddi et al . ( 2018 ) is the following : ft ( x ) = { Cx , for t mod C = 1 −x , otherwise ( 1 ) where x ∈ [ −1 , 1 ] . They proved the divergence under the condition β2 ≤ min { C− 4 C−2 , 1− ( 9 2C ) 2 } , where β2 is the second order momentum coefficient in Algorithm 1 ( the algorithm is presented later ) . For instance , when C = 10 , then the algorithm diverges if β2 < 0.3 . Reddi et al . ( 2018 ) mentioned ∗IOE , University of Michigan , naichens @ umich.edu . Part of the work was done when Naichen Shi was working with Prof. Ruoyu Sun as an intern . †ISE , University of Illinois at Urbana-Champaign . dawei2 @ illinois.edu ‡ECE , University of Minnesota - Twin Cities , mhong @ umn.edu . §University of Illinois at Urbana-Champaign . ruoyus @ illinois.edu . Corresponding author : Ruoyu Sun . that “ this explains why large β2 is advisable while using Adam algorithm ” , but they did not analyze whether large β2 leads to convergence in their example . We ran simulation for problem ( 1 ) with different β2 and found there is always a threshold of β2 above which RMSprop converges , see Figure 1 . For instance , when C = 10 , the transition point of β2 is roughly 0.955 : the algorithm converges if β2 > 0.956 but diverges if β2 < 0.955 . In general , there is a curve of phase transition from divergence to convergence , and such a curve slopes upward , which means the transition point is closer to 1 if C becomes larger . Based on this observation , we make the following conjecture : Conjecture : RMSprop converges if β2 is large enough . Before further discussion , we introduce the following assumption . Assumption 1.1. f ( x ) = ∑n−1 j=0 fj ( x ) , and n−1∑ j=0 ‖∇fj ( x ) ‖22 ≤ D1 ‖∇f ( x ) ‖ 2 2 +D0 . ( 2 ) We divide optimization problems into 2 classes : realizable problems where D0 = 0 and non-realizable problems where D0 > 0 . When D0 = 0 , the assumption ( 1.1 ) becomes∑n−1 j=0 ‖∇fj ( x ) ‖ 2 2 ≤ D1 ‖∇f ( x ) ‖ 2 2 , which is called “ strong growth condition ” ( SGC ) ( Vaswani et al. , 2019 ) . It requires the norm of the stochastic gradient to be proportional to the batch gradient norm . When ‖∇f ( x ) ‖ = 0 , under SGC we have ‖∇fj ( x ) ‖ = 0 for all j . For linear regression problems , SGC holds if the linear model can fit all data . More specifically , for the problem minx ‖Ax‖2 = ∑n j=1 ( aTj x ) 2 where A is an n by n matrix and aTj is the j-th row vector of A , SGC holds with D1 ≤ λmax ( ∑n i=1 aia T i aia T i ) /λmin ( ATA ) ( Raj & Bach , 2020 ) . SGC can be viewed as a simple condition that models overparameterized neural networks capable of interpolating all data points ( Vaswani et al. , 2019 ) . Therefore , in this work we use the terminology “ realizable problems ” to refer to the problems that satisfy SGC . 1.1 MAIN CONTRIBUTIONS . In an attempt to resolve the conjecture , we delve into RMSprop ’ s convergence issues and obtain a series of theoretical and empirical results . Our contributions are summarized below : • We find that RMSprop ’ s convergence is contingent on the choice of β2 . For general optimization problems , there are two types of hyper-parameters : problem-dependent hyperparameters such as step size in GD , and universal constants such as momentum coefficient in heavy ball method 1 . Our result reveals that β2 is closer to the first type . • We prove that RMSprop converges to stationary point for realizable problems ( interpolation regime ) , and to some bounded region for non-realizable problems . Combining with the divergence example of RMSprop , this indicates the existence of a phase transition from divergence to convergence dependent on β2 . Note that when we say “ convergence ” , in a weak sense it means the sequence converges to a bounded region for non-realizable case ; and in a strong sense it means the sequence converges to stationary points for realizable case . • To our best knowledge , we are the first to prove the convergence of RMSprop and some of Adam without any form of assumption about the boundedness of the gradient norm . This is important for showing the transition : with added assumptions on bounded gradients , the gradients can not diverge , while the counter-example shows that the gradient can . 2 PRELIMINARIES . We consider a finite-sum problem : min x∈Rd f ( x ) = n−1∑ j=0 fj ( x ) . ( 3 ) In neural network training , fj usually represents the loss contributed by the j-th sample batch . We present randomly shuffled Adam in Algorithm 1 . RMSProp is the special case of Adam with β1 = 0 . In this work , we mainly focus on RMSprop ; nevertheless , we will present a result for a special case of Adam with small β1 . Algorithm 1 Randomly Shuffled Adam Initialize m1 , −1 = 11−β1∇f ( x0 ) and v1 , −1 = 1 1−β2 maxj { ∇fj ( x0 ) ◦ ∇fj ( x0 ) } . for k = 1→∞ do Sample { τk,0 , τk,1 , · · · , τk , n−1 } as a random permutation of { 0 , 1 , 2 , · · · , n− 1 } for i = 0→ n− 1 do mk , i = β1mk , i−1 + ( 1− β1 ) ∇fτk , i vk , i = β2vk , i−1 + ( 1− β2 ) ∇fτk , i ◦ ∇fτk , i xk , i+1 = xk , i − ηk∗n√vk , i+ ◦ml , k , i end for Break if certain stopping criterion is satisfied . xk+1,0 = xk , n , vk+1 , −1 = vk , n−1 , mk+1 , −1 = mk , n−1 end for return x In Algorithm 1 , x denotes the optimization variable , m denotes the first order momentum and v denotes the second order momentum . Specifically , we denote xk , i , mk , i , vk , i ∈ Rd as the value of x , m , v at the k-th outer loop and i-th inner loop , respectively . We denote∇fj as the gradient of fj and let ◦ be the component-wise multiplication . The division of two vectors is component-wise as well . Moreover , we denote ηt as the step-size and β1 , β2 as the hyper-parameters in the algorithm . When n = 1 , we obtain full batch Adam . We replaced the bias correction step in ( Kingma & Ba , 2015 ) with a special initialization on m1 , −1 and v1 , −1 . This initialization can also correct the bias , but has cleaner results . Since the effect of initialization or bias correction becomes more and more negligible as the training progresses , RMSprop with zero initialization or our initialization will have the same asymptotic behavior . We put our results for the original version of RMSprop in the appendix . 1Rigorously speaking , for the best convergence rate , the momentum coefficient should also be problemdependent ; but just for achieving convergence , it can be problem independent . As for hyper-parameters , we choose ηt = η1√t and fix β2 to be a constant that is independent of the iteration count . We allow to be an arbitrary non-negative constant ; in particular , our result holds even for = 0 . The constant is added in practice for numerical stability , and is typically chosen to be 10−6 or even 10−8 . It is much smaller than√vk , i ( which is roughly the size of gradient norm ) . 2.1 RELATED WORK . As discussed earlier , one line of research focuses on variants of RMSprop and Adam that can be proved to converge . These works usually modify the update rule of vt. For instance , AMSGrad ( Reddi et al. , 2018 ) , AdaFom ( Chen et al. , 2019 ) explicitly make vt non-decreasing . Nostalgic Adam ( Huang et al. , 2019 ) and the algorithms analyzed in Zou et al . ( 2019 ) and Chen et al . ( 2019 ) use iteration-dependent β2t ( and/or β1t ) to let vt weigh more on past gradients . Some works add new modifications into RMSprop and Adam ; for instance , Zhou et al . ( 2019 ) mitigate the bias in update direction by using a different estimate of vt , Dozat ( 2016 ) combine Adam with Nesterov momentum , and Liu et al . ( 2020a ) employ a warm-up technique . Besides modifying the algorithm , a few attempts have been made to address the non-convergence issues of the original versions , but they often rely on extra assumptions . A number of works ( Zaheer et al. , 2018 ; De et al. , 2019 ; Défossez et al. , 2020 ) prove the convergence of Adam under these additional assumptions . One representative work along this line , Défossez et al . ( 2020 ) , establishes a clean convergence result and also provides some insights on the momentum mechanisms by improving the dependence of the iteration complexity on 1− β1 . However , these works assume to be relatively large compared to √vk , i . The issue is that such a choice essentially transforms RMSprop back to SGD since the effective step size is primarily controlled by , in lieu of √vk , i . This is in contrary to the spirit of RMSprop , which is to use adaptive step size to accelerate convergence . A few other works do not need the assumption of , but they have other assumptions . De et al . ( 2018 ) analyze deterministic and stochastic RMSprop , but they utilize a rather unrealistic assumption that the sign of all noisy gradients are the same , i.e. , sign ( ∇fp ( x ) ) = sign ( ∇fq ( x ) ) for all p , q. Chen et al . ( 2019 ) describe a few quantities based on the iterates , and prove that if they grow in a certain speed as the iterates go , the algorithm converges . The drawback is that the condition can not be checked a priori . Besides the assumptions mentioned above , all the aforementioned works require the gradient to be bounded . In general , removing boundedness assumptions ( of any kind , including bounded gradient , bounded iterates , etc . ) is not necessarily easy . Thus , such results are appreciated even for basic SGD . For instance , Bertsekas & Tsitsiklis ( 2000 ) presents a nice discussion of various results on inexact GD without involving conventional bounded assumptions , and claims “ bounded-assumption-free ” as one of the main contributions of their work . Very recently , we notice another work ( Liu et al. , 2020b ) which removes the bounded gradient assumption for SGDM ( SGD with momentum ) and obtains satisfactory rates . Nevertheless , we are not aware of an existing result on RMSprop that does not require bounded gradient assumption . We will explain later why removing this bounded gradient assumption is particularly important for our paper . 3 THE raison d ’ être FOR β2 Figure 1 clearly demonstrates the important role of β2 in the convergence of RMSprop . Specifically , a sufficiently large β2 is critical for RMSprop ’ s convergence . Indeed , some recent works ( Reddi et al. , 2018 ; Zhou et al. , 2019 ) have also made similar arguments , but they focus on understanding one part of the phenomenon , that is , small β2 leads to divergence . Our goal in this work is to complete the other part of the story by showing that , sufficiently large β2 guarantees convergence . The formal result will be provided in Sec . 4 . To understand the function of β2 , we first discuss why RMSprop diverges . It is known that the stochastic noise due to mini-batch will distort the gradient direction , leading to possible divergence , but in standard SGD , the distortion in multiple iterations is eliminated since the stochastic gradient is an unbiased estimate of the gradient . For RMSprop , at a given iteration the scaling constant 1/ √ v in the update direction may cause larger gradient distortion than the standard SGD . The distortion can be so significant that the average updating direction falls outside the dual cone of the true gradient . To illustrate this , consider the extreme case that β2 = 0 and = 0 ( i.e. , signSGD ) and the special example ( 1 ) . When applying signSGD to solve ( 1 ) , in each epoch which consists of C iterations , one iteration will move x left followed by C − 1 iterations that move x right . Since all step sizes are the same in one epoch , the accumulated effect of one epoch makes x move in the ascending direction , instead of the descending direction . Then why does large β2 help ? Intuitively , a large β2 can control the distortion on update directions . In the extreme case that β2 = 1 and = 0 , RMSprop reduces to SGD where the distortion of multiple iterations can be mitigated , leading to convergence . We suspect that β2 does not need to be exactly 1 , and a large β2 is enough to control the distortion . Our experiment in Figure 1 confirms that , at least for the counter-example of Reddi et al . ( 2018 ) , there is an interval β2 ∈ [ c , 1 ] such that RMSprop converges . What was initially not clear is whether the counter-example of Reddi et al . ( 2018 ) is a very special case or the convergence of large-β2-RMSprop holds for all problems . We found the real situation is somewhat more tricky . For non-realizable problems , we discovered an example for which RMSprop can not converge to the minimum for a wide range of β2 < 1 , but unlike the small-β2-case the iterates converge to a small ball around the minimum . This motivates us to distinguish three convergentsituations : divergence , convergence to a small region , convergence to critical points . What we can prove for the general problem is ( see Theorem 4.3 ) : for small β2 , RMSprop can diverge ; for large β2 , RMSprop must converge to a small region whose size depends on β2 . Then why do we observe the convergence to a single point in the experiment for ( 1 ) ? We suspect this is because the problem ( 1 ) is realizable , and conjecture that the property of “ convergence to critical points ” holds for all realizable problems . We indeed prove this conjecture ( see Corollary 4.1 ) : large-β2-RMSprop converges to critical points if the problem satisfies SGC . We summarize our findings about the convergence properties of RMSprop in Table 1 . Note that our results do not conflict with Theorem 3 in Reddi et al . ( 2018 ) which claims that “ for any constant β1 and β2 there exists a divergent example ” since here we choose β2 to be problemdependent , just like one chooses a step size < 2/L for GD where L is a problem dependent parameter . Another remark is that though β2 could be close to 1 , RMSprop still retains the ability to adapt v to gradient square norm as long as β2 < 1 , because new gradient signals are added for each iteration and the impact of previous signals decays exponentially . It is the adaptive ability that distinguishes RMSprop from SGD . Proving the theoretical advantage of RMSprop over SGD ( i.e. , choosing β2 < 1 is better than β2 = 1 ) is a very intriguing question ; in general , the theoretical advantage of adaptive gradient methods ( including RMSprop and AdaGrad ) over SGD is a long standing question . in this work , we focus on the fundamental problem of convergence , instead of the more challenging question of justifying the advantage of RMSprop . | The paper starts off from the recent realization that there exists divergent examples for any set of hyperparameters for algorithms in the Adam family, such as RMSProp. It sets out to study the effect of the beta2 parameter on convergence for a fixed specific problem. The analysis shows that there exists a beta2 < 1 that leads to convergence for realizable problems, and to convergence to a bounded region of interest for non-realizable problems, without requiring a bounded-gradient assumption. Experiments confirm this new theory. | SP:fed001660e9a62c1bb55a1a5500f8b27ab40f348 |
RMSprop converges with proper hyper-parameter | 1 INTRODUCTION . RMSprop ( Tieleman & Hinton , 2012 ) remains one of the most popular algorithms for machine learning applications . As a non-momentum version of a more general algorithm Adam , RMSprop ’ s good empirical performance has been well acknowledged by practitioners in generative adversarial networks ( GANs ) ( Seward et al. , 2018 ; Yazıcı et al. , 2019 ; Karnewar & Wang , 2020 ; JolicoeurMartineau , 2019 ) , reinforcement learning ( Mnih et al. , 2016 ) , etc . In spite of its prevalence , however , Reddi et al . ( 2018 ) discovered that RMSprop ( as well as the more general version Adam ) can diverge even for simple convex functions . To fix the algorithm , the authors of Reddi et al . ( 2018 ) proposed a new variant called AMSGrad , which is guaranteed to converge under certain conditions . Since then , it has been an active area of research to design provably convergent variants of RMSprop . These variants include AdaFom ( Chen et al. , 2019 ) , Adabound ( Luo et al. , 2019 ) , Nostalgic Adam ( Huang et al. , 2019 ) , Yogi ( Zaheer et al. , 2018 ) , and many more . Despite the variants , the vanilla RMSprop indeed works well in practice , and after proper hyper-parameter tuning , the non-convergence issue has not been commonly observed . Why is there a large gap between theory and practice ? Is this because the real-world problems are likely to be “ nice ” , or is it because the theoretical analysis of RMSprop does not match how it is used in practice ? With the above questions in mind , we revisited the counter-example of Reddi et al . ( 2018 ) , and found an interesting phenomenon . One counter-example of Reddi et al . ( 2018 ) is the following : ft ( x ) = { Cx , for t mod C = 1 −x , otherwise ( 1 ) where x ∈ [ −1 , 1 ] . They proved the divergence under the condition β2 ≤ min { C− 4 C−2 , 1− ( 9 2C ) 2 } , where β2 is the second order momentum coefficient in Algorithm 1 ( the algorithm is presented later ) . For instance , when C = 10 , then the algorithm diverges if β2 < 0.3 . Reddi et al . ( 2018 ) mentioned ∗IOE , University of Michigan , naichens @ umich.edu . Part of the work was done when Naichen Shi was working with Prof. Ruoyu Sun as an intern . †ISE , University of Illinois at Urbana-Champaign . dawei2 @ illinois.edu ‡ECE , University of Minnesota - Twin Cities , mhong @ umn.edu . §University of Illinois at Urbana-Champaign . ruoyus @ illinois.edu . Corresponding author : Ruoyu Sun . that “ this explains why large β2 is advisable while using Adam algorithm ” , but they did not analyze whether large β2 leads to convergence in their example . We ran simulation for problem ( 1 ) with different β2 and found there is always a threshold of β2 above which RMSprop converges , see Figure 1 . For instance , when C = 10 , the transition point of β2 is roughly 0.955 : the algorithm converges if β2 > 0.956 but diverges if β2 < 0.955 . In general , there is a curve of phase transition from divergence to convergence , and such a curve slopes upward , which means the transition point is closer to 1 if C becomes larger . Based on this observation , we make the following conjecture : Conjecture : RMSprop converges if β2 is large enough . Before further discussion , we introduce the following assumption . Assumption 1.1. f ( x ) = ∑n−1 j=0 fj ( x ) , and n−1∑ j=0 ‖∇fj ( x ) ‖22 ≤ D1 ‖∇f ( x ) ‖ 2 2 +D0 . ( 2 ) We divide optimization problems into 2 classes : realizable problems where D0 = 0 and non-realizable problems where D0 > 0 . When D0 = 0 , the assumption ( 1.1 ) becomes∑n−1 j=0 ‖∇fj ( x ) ‖ 2 2 ≤ D1 ‖∇f ( x ) ‖ 2 2 , which is called “ strong growth condition ” ( SGC ) ( Vaswani et al. , 2019 ) . It requires the norm of the stochastic gradient to be proportional to the batch gradient norm . When ‖∇f ( x ) ‖ = 0 , under SGC we have ‖∇fj ( x ) ‖ = 0 for all j . For linear regression problems , SGC holds if the linear model can fit all data . More specifically , for the problem minx ‖Ax‖2 = ∑n j=1 ( aTj x ) 2 where A is an n by n matrix and aTj is the j-th row vector of A , SGC holds with D1 ≤ λmax ( ∑n i=1 aia T i aia T i ) /λmin ( ATA ) ( Raj & Bach , 2020 ) . SGC can be viewed as a simple condition that models overparameterized neural networks capable of interpolating all data points ( Vaswani et al. , 2019 ) . Therefore , in this work we use the terminology “ realizable problems ” to refer to the problems that satisfy SGC . 1.1 MAIN CONTRIBUTIONS . In an attempt to resolve the conjecture , we delve into RMSprop ’ s convergence issues and obtain a series of theoretical and empirical results . Our contributions are summarized below : • We find that RMSprop ’ s convergence is contingent on the choice of β2 . For general optimization problems , there are two types of hyper-parameters : problem-dependent hyperparameters such as step size in GD , and universal constants such as momentum coefficient in heavy ball method 1 . Our result reveals that β2 is closer to the first type . • We prove that RMSprop converges to stationary point for realizable problems ( interpolation regime ) , and to some bounded region for non-realizable problems . Combining with the divergence example of RMSprop , this indicates the existence of a phase transition from divergence to convergence dependent on β2 . Note that when we say “ convergence ” , in a weak sense it means the sequence converges to a bounded region for non-realizable case ; and in a strong sense it means the sequence converges to stationary points for realizable case . • To our best knowledge , we are the first to prove the convergence of RMSprop and some of Adam without any form of assumption about the boundedness of the gradient norm . This is important for showing the transition : with added assumptions on bounded gradients , the gradients can not diverge , while the counter-example shows that the gradient can . 2 PRELIMINARIES . We consider a finite-sum problem : min x∈Rd f ( x ) = n−1∑ j=0 fj ( x ) . ( 3 ) In neural network training , fj usually represents the loss contributed by the j-th sample batch . We present randomly shuffled Adam in Algorithm 1 . RMSProp is the special case of Adam with β1 = 0 . In this work , we mainly focus on RMSprop ; nevertheless , we will present a result for a special case of Adam with small β1 . Algorithm 1 Randomly Shuffled Adam Initialize m1 , −1 = 11−β1∇f ( x0 ) and v1 , −1 = 1 1−β2 maxj { ∇fj ( x0 ) ◦ ∇fj ( x0 ) } . for k = 1→∞ do Sample { τk,0 , τk,1 , · · · , τk , n−1 } as a random permutation of { 0 , 1 , 2 , · · · , n− 1 } for i = 0→ n− 1 do mk , i = β1mk , i−1 + ( 1− β1 ) ∇fτk , i vk , i = β2vk , i−1 + ( 1− β2 ) ∇fτk , i ◦ ∇fτk , i xk , i+1 = xk , i − ηk∗n√vk , i+ ◦ml , k , i end for Break if certain stopping criterion is satisfied . xk+1,0 = xk , n , vk+1 , −1 = vk , n−1 , mk+1 , −1 = mk , n−1 end for return x In Algorithm 1 , x denotes the optimization variable , m denotes the first order momentum and v denotes the second order momentum . Specifically , we denote xk , i , mk , i , vk , i ∈ Rd as the value of x , m , v at the k-th outer loop and i-th inner loop , respectively . We denote∇fj as the gradient of fj and let ◦ be the component-wise multiplication . The division of two vectors is component-wise as well . Moreover , we denote ηt as the step-size and β1 , β2 as the hyper-parameters in the algorithm . When n = 1 , we obtain full batch Adam . We replaced the bias correction step in ( Kingma & Ba , 2015 ) with a special initialization on m1 , −1 and v1 , −1 . This initialization can also correct the bias , but has cleaner results . Since the effect of initialization or bias correction becomes more and more negligible as the training progresses , RMSprop with zero initialization or our initialization will have the same asymptotic behavior . We put our results for the original version of RMSprop in the appendix . 1Rigorously speaking , for the best convergence rate , the momentum coefficient should also be problemdependent ; but just for achieving convergence , it can be problem independent . As for hyper-parameters , we choose ηt = η1√t and fix β2 to be a constant that is independent of the iteration count . We allow to be an arbitrary non-negative constant ; in particular , our result holds even for = 0 . The constant is added in practice for numerical stability , and is typically chosen to be 10−6 or even 10−8 . It is much smaller than√vk , i ( which is roughly the size of gradient norm ) . 2.1 RELATED WORK . As discussed earlier , one line of research focuses on variants of RMSprop and Adam that can be proved to converge . These works usually modify the update rule of vt. For instance , AMSGrad ( Reddi et al. , 2018 ) , AdaFom ( Chen et al. , 2019 ) explicitly make vt non-decreasing . Nostalgic Adam ( Huang et al. , 2019 ) and the algorithms analyzed in Zou et al . ( 2019 ) and Chen et al . ( 2019 ) use iteration-dependent β2t ( and/or β1t ) to let vt weigh more on past gradients . Some works add new modifications into RMSprop and Adam ; for instance , Zhou et al . ( 2019 ) mitigate the bias in update direction by using a different estimate of vt , Dozat ( 2016 ) combine Adam with Nesterov momentum , and Liu et al . ( 2020a ) employ a warm-up technique . Besides modifying the algorithm , a few attempts have been made to address the non-convergence issues of the original versions , but they often rely on extra assumptions . A number of works ( Zaheer et al. , 2018 ; De et al. , 2019 ; Défossez et al. , 2020 ) prove the convergence of Adam under these additional assumptions . One representative work along this line , Défossez et al . ( 2020 ) , establishes a clean convergence result and also provides some insights on the momentum mechanisms by improving the dependence of the iteration complexity on 1− β1 . However , these works assume to be relatively large compared to √vk , i . The issue is that such a choice essentially transforms RMSprop back to SGD since the effective step size is primarily controlled by , in lieu of √vk , i . This is in contrary to the spirit of RMSprop , which is to use adaptive step size to accelerate convergence . A few other works do not need the assumption of , but they have other assumptions . De et al . ( 2018 ) analyze deterministic and stochastic RMSprop , but they utilize a rather unrealistic assumption that the sign of all noisy gradients are the same , i.e. , sign ( ∇fp ( x ) ) = sign ( ∇fq ( x ) ) for all p , q. Chen et al . ( 2019 ) describe a few quantities based on the iterates , and prove that if they grow in a certain speed as the iterates go , the algorithm converges . The drawback is that the condition can not be checked a priori . Besides the assumptions mentioned above , all the aforementioned works require the gradient to be bounded . In general , removing boundedness assumptions ( of any kind , including bounded gradient , bounded iterates , etc . ) is not necessarily easy . Thus , such results are appreciated even for basic SGD . For instance , Bertsekas & Tsitsiklis ( 2000 ) presents a nice discussion of various results on inexact GD without involving conventional bounded assumptions , and claims “ bounded-assumption-free ” as one of the main contributions of their work . Very recently , we notice another work ( Liu et al. , 2020b ) which removes the bounded gradient assumption for SGDM ( SGD with momentum ) and obtains satisfactory rates . Nevertheless , we are not aware of an existing result on RMSprop that does not require bounded gradient assumption . We will explain later why removing this bounded gradient assumption is particularly important for our paper . 3 THE raison d ’ être FOR β2 Figure 1 clearly demonstrates the important role of β2 in the convergence of RMSprop . Specifically , a sufficiently large β2 is critical for RMSprop ’ s convergence . Indeed , some recent works ( Reddi et al. , 2018 ; Zhou et al. , 2019 ) have also made similar arguments , but they focus on understanding one part of the phenomenon , that is , small β2 leads to divergence . Our goal in this work is to complete the other part of the story by showing that , sufficiently large β2 guarantees convergence . The formal result will be provided in Sec . 4 . To understand the function of β2 , we first discuss why RMSprop diverges . It is known that the stochastic noise due to mini-batch will distort the gradient direction , leading to possible divergence , but in standard SGD , the distortion in multiple iterations is eliminated since the stochastic gradient is an unbiased estimate of the gradient . For RMSprop , at a given iteration the scaling constant 1/ √ v in the update direction may cause larger gradient distortion than the standard SGD . The distortion can be so significant that the average updating direction falls outside the dual cone of the true gradient . To illustrate this , consider the extreme case that β2 = 0 and = 0 ( i.e. , signSGD ) and the special example ( 1 ) . When applying signSGD to solve ( 1 ) , in each epoch which consists of C iterations , one iteration will move x left followed by C − 1 iterations that move x right . Since all step sizes are the same in one epoch , the accumulated effect of one epoch makes x move in the ascending direction , instead of the descending direction . Then why does large β2 help ? Intuitively , a large β2 can control the distortion on update directions . In the extreme case that β2 = 1 and = 0 , RMSprop reduces to SGD where the distortion of multiple iterations can be mitigated , leading to convergence . We suspect that β2 does not need to be exactly 1 , and a large β2 is enough to control the distortion . Our experiment in Figure 1 confirms that , at least for the counter-example of Reddi et al . ( 2018 ) , there is an interval β2 ∈ [ c , 1 ] such that RMSprop converges . What was initially not clear is whether the counter-example of Reddi et al . ( 2018 ) is a very special case or the convergence of large-β2-RMSprop holds for all problems . We found the real situation is somewhat more tricky . For non-realizable problems , we discovered an example for which RMSprop can not converge to the minimum for a wide range of β2 < 1 , but unlike the small-β2-case the iterates converge to a small ball around the minimum . This motivates us to distinguish three convergentsituations : divergence , convergence to a small region , convergence to critical points . What we can prove for the general problem is ( see Theorem 4.3 ) : for small β2 , RMSprop can diverge ; for large β2 , RMSprop must converge to a small region whose size depends on β2 . Then why do we observe the convergence to a single point in the experiment for ( 1 ) ? We suspect this is because the problem ( 1 ) is realizable , and conjecture that the property of “ convergence to critical points ” holds for all realizable problems . We indeed prove this conjecture ( see Corollary 4.1 ) : large-β2-RMSprop converges to critical points if the problem satisfies SGC . We summarize our findings about the convergence properties of RMSprop in Table 1 . Note that our results do not conflict with Theorem 3 in Reddi et al . ( 2018 ) which claims that “ for any constant β1 and β2 there exists a divergent example ” since here we choose β2 to be problemdependent , just like one chooses a step size < 2/L for GD where L is a problem dependent parameter . Another remark is that though β2 could be close to 1 , RMSprop still retains the ability to adapt v to gradient square norm as long as β2 < 1 , because new gradient signals are added for each iteration and the impact of previous signals decays exponentially . It is the adaptive ability that distinguishes RMSprop from SGD . Proving the theoretical advantage of RMSprop over SGD ( i.e. , choosing β2 < 1 is better than β2 = 1 ) is a very intriguing question ; in general , the theoretical advantage of adaptive gradient methods ( including RMSprop and AdaGrad ) over SGD is a long standing question . in this work , we focus on the fundamental problem of convergence , instead of the more challenging question of justifying the advantage of RMSprop . | This work revisits a famous counterexample on the convergence of Adam (originally presented in Reddi 2018). The authors show that, if the EMA parameter beta2 in RMSprop and Adam is chosen high enough, then both methods converge to a bounded region in the stochastic setting. In addition, the authors provide some results for the full-batch case. Crucially, and differently from many other papers on the topic, the gradients are not assumed to be bounded and the beta2 hyperparameter is not chosen to increase to 1. | SP:fed001660e9a62c1bb55a1a5500f8b27ab40f348 |
Federated Learning via Posterior Averaging: A New Perspective and Practical Algorithms | 1 INTRODUCTION . Federated learning ( FL ) is a framework for learning statistical models from heterogeneous data scattered across multiple entities ( or clients ) under the coordination of a central server that has no direct access to the local data ( Kairouz et al. , 2019 ) . To learn models without any data transfer , clients must process their own data locally and only infrequently communicate some model updates to the server which aggregates these updates into a global model ( McMahan et al. , 2017 ) . While this paradigm enables efficient distributed learning from data stored on millions of remote devices ( Hard et al. , 2018 ) , it comes with many challenges ( Li et al. , 2020 ) , with the communication cost often being the critical bottleneck and the heterogeneity of client data affecting convergence . Canonically , FL is formulated as a distributed optimization problem with a few distinctive properties such as unbalanced and non-i.i.d . data distribution across the clients and limited communication . The de facto standard algorithm for solving federated optimization is federated averaging ( FEDAVG , McMahan et al. , 2017 ) , which proceeds in rounds of communication between the server and a random subset of clients , synchronously updating the server model after each round ( Bonawitz et al. , 2019 ) . By allowing the clients perform multiple local SGD steps ( or epochs ) at each round , FEDAVG can reduce the required communication by orders of magnitude compared to mini-batch ( MB ) SGD . However , due to heterogeneity of the client data , more local computation often leads to biased client updates and makes FEDAVG stagnate at inferior optima . As a result , while slow during initial training , MB-SGD ends up dominating FEDAVG at convergence ( see example in Fig . 1 ) . This has been observed in multiple empirical studies ( e.g. , Charles & Konečnỳ , 2020 ) , and recently was shown theoretically ( Woodworth et al. , 2020a ) . Using stateful clients ( Karimireddy et al. , 2019 ; Pathak & Wainwright , 2020 ) can help to remedy the convergence issues in the cross-silo setting , where relatively few clients are queried repeatedly , but is not practical in the cross-device setting ( i.e. , when clients are mobile devices ) for several reasons ( Kairouz et al. , 2019 ; Li et al. , 2020 ; Lim et al. , 2020 ) . One key issue is that the number of clients in such a setting is extremely large and the average client will only ever participate in a single FL round . Thus , the state of a stateful algorithm is never used . ∗Most of the work done at Google . Correspondence : maruan.alshedivat.com Is it possible to design FL algorithms that exhibit both fast training and consistent convergence . with stateless clients ? In this work , we answer this question affirmatively , by approaching federated learning not as optimization but rather as posterior inference problem . We show that modes of the global posterior over the model parameters correspond to the desired optima of the federated optimization objective and can be inferred by aggregating information about local posteriors . Starting with an analysis of federated quadratics , we introduce a general class of federated posterior inference algorithms that run local posterior inference on the clients and global posterior inference on the server . In contrast with federated optimization , posterior inference can , with stateless clients , benefit from an increased amount of local computation without stagnating at inferior optima ( illustrated in Fig . 1 ) . However , a naïve approach to federated posterior inference is practically infeasible because its computation and communication costs are cubic and quadratic in the model parameters , respectively . Apart from the new perspective , our key technical contribution is the design of an efficient algorithm with linear computation and communication costs . Contributions . The main contributions of this paper can be summarized as follows : 1 . We introduce a new perspective on federated learning through the lens of posterior inference which broadens the design space for FL algorithms beyond purely optimization techniques . 2 . With this perspective , we design a computation- and communication-efficient approximate posterior inference algorithm—federated posterior averaging ( FEDPA ) . FEDPA works with stateless clients and its computational complexity and memory footprint are similar to FEDAVG . 3 . We show that FEDAVG with many local steps is in fact a special case of FEDPA that estimates local posterior covariances with identities . These biased estimates are the source of inconsistent updates and explain why FEDAVG has suboptimal convergence even in simple quadratic settings . 4 . Finally , we compare FEDPA with strong baselines on realistic FL benchmarks introduced by Reddi et al . ( 2020 ) and achieve state-of-the-art results with respect to multiple metrics of interest . 2 RELATED WORK . Federated optimization . Starting with the seminal paper by McMahan et al . ( 2017 ) , a lot of recent effort in federated learning has focused on understanding of FEDAVG ( also known as local SGD ) as an optimization algorithm . Multiple works have provided upper bounds on the convergence rate of FEDAVG in the homogeneous i.i.d . setting ( Yu et al. , 2019 ; Karimireddy et al. , 2019 ; Woodworth et al. , 2020b ) as well as explored various non-i.i.d . settings with different notions of heterogeneity ( Zhao et al. , 2018 ; Sahu et al. , 2018 ; Hsieh et al. , 2019 ; Li et al. , 2019 ; Wang et al. , 2020 ; Woodworth et al. , 2020a ) . Reddi et al . ( 2020 ) reformulated FEDAVG in a way that enabled adaptive optimization and derived corresponding convergence rates , noting that FEDAVG requires careful tuning of learning rate schedules in order to converge to the desired optimum , which was further analyzed by Charles & Konečnỳ ( 2020 ) . To the best of our knowledge , our work is perhaps the first to connect , reinterpret , and analyze federated optimization from the probabilistic inference perspective . Distributed MCMC . Part of our work builds on the idea of sub-posterior aggregation , which was originally proposed for scaling up Markov chain Monte Carlo techniques to large datasets ( known as the concensus Monte Carlo , Neiswanger et al. , 2013 ; Scott et al. , 2016 ) . One of the goals of this paper is to highlight the connection between distributed inference and federated optimization and develop inference techniques that can be used under FL-specific constraints . 3 A POSTERIOR INFERENCE PERSPECTIVE ON FEDERATED LEARNING . Federated learning is typically formulated as the following optimization problem : min θ∈Rd { F ( θ ) : = N∑ i=1 qifi ( θ ) } , fi ( θ ) : = 1 ni ni∑ j=1 f ( θ ; zij ) , ( 1 ) where the global objective function F ( θ ) is a weighted average of the local objectives fi ( θ ) over N clients ; each client ’ s objective is some loss f ( θ ; z ) computed on the local data Di = { zi1 , . . . , zini } . In real-world cross-device applications , the total number of clients N can be extremely large , and hence optimization of F ( θ ) is done over multiple rounds with only a small subset of M clients participating in each round . The weights { qi } are typically set proportional to the sizes of the local datasets { ni } , which makes F ( θ ) coincide with the training objective of the centralized setting . Typically , f ( θ ; z ) is negative log likelihood of z under some probabilistic model parametrized by θ , i.e. , f ( θ ; z ) : = − logP ( z | θ ) . For example , least squares loss corresponds to likelihood under a Gaussian model , cross entropy loss corresponds to likelihood under a categorical model , etc . ( Murphy , 2012 ) . Thus , Eq . 1 corresponds to maximum likelihood estimation ( MLE ) of the model parameters θ . An alternative ( Bayesian ) approach to maximum likelihood estimation is posterior inference or estimation of the posterior distribution of the parameters given all the data : P ( θ | D ≡ D1 ∪ · · · ∪DN ) . The posterior is proportional to the product of the likelihood and a prior , P ( θ | D ) ∝ P ( D | θ ) P ( θ ) , and , if the prior is uninformative ( uniform over all θ ) , the modes of the global posterior coincide with MLE solutions or optima of F ( θ ) in Eq . 1 . While this simple observation establishes an equivalence between the inference of the posterior mode and optimization , the advantage of this perspective comes from the fact that the global posterior exactly decomposes into a product of local posteriors.1 Proposition 1 ( Global Posterior Decomposition ) Under the uniform prior , any global posterior distribution that exists decomposes into a product of local posteriors : P ( θ | D ) ∝ ∏N i=1 P ( θ | Di ) . Proposition 1 suggests that as long as we are able to compute local posterior distributions P ( θ | Di ) and communicate them to the server , we should be able to solve Eq . 1 by multiplicatively aggregating them to find the mode of the global posterior P ( θ | D ) on the server . Note that posterior inference via multiplicative averaging has been successfully used to scale Monte Carlo methods to large datasets , where the approach is embarrassingly parallel ( Neiswanger et al. , 2013 ; Scott et al. , 2016 ) . In the FL context , this means that once all clients have sent their local posteriors to the server , we can construct the global posterior without any additional communication . However , there remains the challenge of making the local and global inference and communication efficient enough for real federated settings . The example below illustrates how this can be difficult even for a simple model and loss function . Federated least squares . Consider federated least squares regression with a linear model , where z : = ( x , y ) and the loss f ( θ ; x , y ) : = 12 ( x > θ − y ) 2 is quadratic . Then , the client objective becomes : fi ( θ ) = log exp { 1 2 ‖Xiθ − yi‖2 } = log exp { 1 2 ( θ − µi ) > Σ −1 i ( θ − µi ) } + const , ( 2 ) where Xi ∈ Rni×d is the design matrix , yi ∈ Rni is the response vector , Σ−1i : = X > i Xi and µi : = ( X > i Xi ) −1 X > i yi . Note that the expression in Eq . 2 is the log likelihood for a multivariate Gaussian distribution with mean µi and covariance Σi . Therefore , each local posterior ( under the uniform prior ) is Gaussian , and , as a product of Gaussians , the global posterior is also Gaussian with the following mean ( which coincides with the posterior mode ) : µ : = ( N∑ i=1 qiΣ −1 i ) −1 ( N∑ i=1 qiΣ −1 i µi ) . ( 3 ) Concretely , in the case of least squares regression , this suggests that it is sufficient for clients to infer the means { µi } and inverse covariances { Σ −1 i } of their local posteriors and communicate that information to server for the latter to be able to find the global optimum . However , a straightforward application of Eq . 3 would requireO ( d2 ) space andO ( d3 ) computation , both on the clients and on the server , which is very expensive for the typical cross-device FL setting . Similarly , the communication cost would be O ( d2 ) , while standard FL algorithms have communication cost of O ( d ) . 1Note that from the optimization point of view , the global optimum generally can not be represented as any weighted combination of the local optima even in simple 2D settings ( see Fig . 1 , left ) . Algorithm 1 Generalized Federated Optimization input initial θ , CLIENTUPDATE , SERVERUPDATE 1 : for each round t = 1 , . . . , T do 2 : Sample a subset S of clients 3 : communicate θ to all i ∈ S // server→ clients 4 : for each client i ∈ S in parallel do 5 : ∆ti , qi ← CLIENTUPDATE ( θ ) 6 : end for 7 : communicate { ∆ti , qi } i∈S // server← clients 8 : ∆t ← 1|S| ∑ i∈S qi∆ t i // aggregate updates 9 : θ ← SERVERUPDATE ( θ , ∆t ) 10 : end for output final θ Algorithm 2 Client Update ( FEDAVG ) input initial θ0 , loss fi ( θ ) , optimizer CLIENTOPT 1 : for k = 1 , . . . , K do 2 : θk ← CLIENTOPT ( θk−1 , ∇̂fi ( θk−1 ) ) 3 : end for output ∆ : = θ0 − θk , client weight qi Algorithm 3 Client Update ( FEDPA ) input initial θ0 , loss fi ( θ ) , sampler CLIENTMCMC 1 : for k = 1 , . . . , K do 2 : θk ∼ CLIENTMCMC ( θk−1 , fi ) 3 : end for output ∆ : = Σ̂ −1 ( θ0 − µ̂ ) , client weight qi Approximate federated posterior inference . Apart from the computation and communication issues discussed in the simple example above , we also have to contend with the fact that , generally , posteriors are non-Gaussian and closed form expressions for global posterior modes may not exist.2 In such cases , we propose to use the Laplace approximation for local and global posteriors , i.e. , approximate them with the best-fitting Gaussians . While imperfect , this approximation will allow us to compute the ( approximate ) global posterior mode in a computation- and communication-efficient manner using the following three steps : ( i ) infer approximate local means { µ̂i } and covariances { Σ̂i } , ( ii ) communicate these to the server , and ( iii ) compute the posterior mode given by Eq . 3 . Note that directly computing and communicating these quantities would be completely infeasible for the realistic setting where models are neural networks with millions of parameters . In the following section , we design a practical algorithm where all costs are linear in the number of model parameters . | The authors propose a new method of generating local (client) updates in Federated Learning (FL), where the clients return an adjusted version of their usual local updates to the server. The authors derive this new local update rigorously from the viewpoint of estimating the posterior distribution of the data (under Gaussianity assumptions). They also provide an efficient method for calculating this new update, and show that it outperforms Federated Averaging on several datasets. | SP:6389ff57423090975659dbcd572192bd48f9c3b5 |
Federated Learning via Posterior Averaging: A New Perspective and Practical Algorithms | 1 INTRODUCTION . Federated learning ( FL ) is a framework for learning statistical models from heterogeneous data scattered across multiple entities ( or clients ) under the coordination of a central server that has no direct access to the local data ( Kairouz et al. , 2019 ) . To learn models without any data transfer , clients must process their own data locally and only infrequently communicate some model updates to the server which aggregates these updates into a global model ( McMahan et al. , 2017 ) . While this paradigm enables efficient distributed learning from data stored on millions of remote devices ( Hard et al. , 2018 ) , it comes with many challenges ( Li et al. , 2020 ) , with the communication cost often being the critical bottleneck and the heterogeneity of client data affecting convergence . Canonically , FL is formulated as a distributed optimization problem with a few distinctive properties such as unbalanced and non-i.i.d . data distribution across the clients and limited communication . The de facto standard algorithm for solving federated optimization is federated averaging ( FEDAVG , McMahan et al. , 2017 ) , which proceeds in rounds of communication between the server and a random subset of clients , synchronously updating the server model after each round ( Bonawitz et al. , 2019 ) . By allowing the clients perform multiple local SGD steps ( or epochs ) at each round , FEDAVG can reduce the required communication by orders of magnitude compared to mini-batch ( MB ) SGD . However , due to heterogeneity of the client data , more local computation often leads to biased client updates and makes FEDAVG stagnate at inferior optima . As a result , while slow during initial training , MB-SGD ends up dominating FEDAVG at convergence ( see example in Fig . 1 ) . This has been observed in multiple empirical studies ( e.g. , Charles & Konečnỳ , 2020 ) , and recently was shown theoretically ( Woodworth et al. , 2020a ) . Using stateful clients ( Karimireddy et al. , 2019 ; Pathak & Wainwright , 2020 ) can help to remedy the convergence issues in the cross-silo setting , where relatively few clients are queried repeatedly , but is not practical in the cross-device setting ( i.e. , when clients are mobile devices ) for several reasons ( Kairouz et al. , 2019 ; Li et al. , 2020 ; Lim et al. , 2020 ) . One key issue is that the number of clients in such a setting is extremely large and the average client will only ever participate in a single FL round . Thus , the state of a stateful algorithm is never used . ∗Most of the work done at Google . Correspondence : maruan.alshedivat.com Is it possible to design FL algorithms that exhibit both fast training and consistent convergence . with stateless clients ? In this work , we answer this question affirmatively , by approaching federated learning not as optimization but rather as posterior inference problem . We show that modes of the global posterior over the model parameters correspond to the desired optima of the federated optimization objective and can be inferred by aggregating information about local posteriors . Starting with an analysis of federated quadratics , we introduce a general class of federated posterior inference algorithms that run local posterior inference on the clients and global posterior inference on the server . In contrast with federated optimization , posterior inference can , with stateless clients , benefit from an increased amount of local computation without stagnating at inferior optima ( illustrated in Fig . 1 ) . However , a naïve approach to federated posterior inference is practically infeasible because its computation and communication costs are cubic and quadratic in the model parameters , respectively . Apart from the new perspective , our key technical contribution is the design of an efficient algorithm with linear computation and communication costs . Contributions . The main contributions of this paper can be summarized as follows : 1 . We introduce a new perspective on federated learning through the lens of posterior inference which broadens the design space for FL algorithms beyond purely optimization techniques . 2 . With this perspective , we design a computation- and communication-efficient approximate posterior inference algorithm—federated posterior averaging ( FEDPA ) . FEDPA works with stateless clients and its computational complexity and memory footprint are similar to FEDAVG . 3 . We show that FEDAVG with many local steps is in fact a special case of FEDPA that estimates local posterior covariances with identities . These biased estimates are the source of inconsistent updates and explain why FEDAVG has suboptimal convergence even in simple quadratic settings . 4 . Finally , we compare FEDPA with strong baselines on realistic FL benchmarks introduced by Reddi et al . ( 2020 ) and achieve state-of-the-art results with respect to multiple metrics of interest . 2 RELATED WORK . Federated optimization . Starting with the seminal paper by McMahan et al . ( 2017 ) , a lot of recent effort in federated learning has focused on understanding of FEDAVG ( also known as local SGD ) as an optimization algorithm . Multiple works have provided upper bounds on the convergence rate of FEDAVG in the homogeneous i.i.d . setting ( Yu et al. , 2019 ; Karimireddy et al. , 2019 ; Woodworth et al. , 2020b ) as well as explored various non-i.i.d . settings with different notions of heterogeneity ( Zhao et al. , 2018 ; Sahu et al. , 2018 ; Hsieh et al. , 2019 ; Li et al. , 2019 ; Wang et al. , 2020 ; Woodworth et al. , 2020a ) . Reddi et al . ( 2020 ) reformulated FEDAVG in a way that enabled adaptive optimization and derived corresponding convergence rates , noting that FEDAVG requires careful tuning of learning rate schedules in order to converge to the desired optimum , which was further analyzed by Charles & Konečnỳ ( 2020 ) . To the best of our knowledge , our work is perhaps the first to connect , reinterpret , and analyze federated optimization from the probabilistic inference perspective . Distributed MCMC . Part of our work builds on the idea of sub-posterior aggregation , which was originally proposed for scaling up Markov chain Monte Carlo techniques to large datasets ( known as the concensus Monte Carlo , Neiswanger et al. , 2013 ; Scott et al. , 2016 ) . One of the goals of this paper is to highlight the connection between distributed inference and federated optimization and develop inference techniques that can be used under FL-specific constraints . 3 A POSTERIOR INFERENCE PERSPECTIVE ON FEDERATED LEARNING . Federated learning is typically formulated as the following optimization problem : min θ∈Rd { F ( θ ) : = N∑ i=1 qifi ( θ ) } , fi ( θ ) : = 1 ni ni∑ j=1 f ( θ ; zij ) , ( 1 ) where the global objective function F ( θ ) is a weighted average of the local objectives fi ( θ ) over N clients ; each client ’ s objective is some loss f ( θ ; z ) computed on the local data Di = { zi1 , . . . , zini } . In real-world cross-device applications , the total number of clients N can be extremely large , and hence optimization of F ( θ ) is done over multiple rounds with only a small subset of M clients participating in each round . The weights { qi } are typically set proportional to the sizes of the local datasets { ni } , which makes F ( θ ) coincide with the training objective of the centralized setting . Typically , f ( θ ; z ) is negative log likelihood of z under some probabilistic model parametrized by θ , i.e. , f ( θ ; z ) : = − logP ( z | θ ) . For example , least squares loss corresponds to likelihood under a Gaussian model , cross entropy loss corresponds to likelihood under a categorical model , etc . ( Murphy , 2012 ) . Thus , Eq . 1 corresponds to maximum likelihood estimation ( MLE ) of the model parameters θ . An alternative ( Bayesian ) approach to maximum likelihood estimation is posterior inference or estimation of the posterior distribution of the parameters given all the data : P ( θ | D ≡ D1 ∪ · · · ∪DN ) . The posterior is proportional to the product of the likelihood and a prior , P ( θ | D ) ∝ P ( D | θ ) P ( θ ) , and , if the prior is uninformative ( uniform over all θ ) , the modes of the global posterior coincide with MLE solutions or optima of F ( θ ) in Eq . 1 . While this simple observation establishes an equivalence between the inference of the posterior mode and optimization , the advantage of this perspective comes from the fact that the global posterior exactly decomposes into a product of local posteriors.1 Proposition 1 ( Global Posterior Decomposition ) Under the uniform prior , any global posterior distribution that exists decomposes into a product of local posteriors : P ( θ | D ) ∝ ∏N i=1 P ( θ | Di ) . Proposition 1 suggests that as long as we are able to compute local posterior distributions P ( θ | Di ) and communicate them to the server , we should be able to solve Eq . 1 by multiplicatively aggregating them to find the mode of the global posterior P ( θ | D ) on the server . Note that posterior inference via multiplicative averaging has been successfully used to scale Monte Carlo methods to large datasets , where the approach is embarrassingly parallel ( Neiswanger et al. , 2013 ; Scott et al. , 2016 ) . In the FL context , this means that once all clients have sent their local posteriors to the server , we can construct the global posterior without any additional communication . However , there remains the challenge of making the local and global inference and communication efficient enough for real federated settings . The example below illustrates how this can be difficult even for a simple model and loss function . Federated least squares . Consider federated least squares regression with a linear model , where z : = ( x , y ) and the loss f ( θ ; x , y ) : = 12 ( x > θ − y ) 2 is quadratic . Then , the client objective becomes : fi ( θ ) = log exp { 1 2 ‖Xiθ − yi‖2 } = log exp { 1 2 ( θ − µi ) > Σ −1 i ( θ − µi ) } + const , ( 2 ) where Xi ∈ Rni×d is the design matrix , yi ∈ Rni is the response vector , Σ−1i : = X > i Xi and µi : = ( X > i Xi ) −1 X > i yi . Note that the expression in Eq . 2 is the log likelihood for a multivariate Gaussian distribution with mean µi and covariance Σi . Therefore , each local posterior ( under the uniform prior ) is Gaussian , and , as a product of Gaussians , the global posterior is also Gaussian with the following mean ( which coincides with the posterior mode ) : µ : = ( N∑ i=1 qiΣ −1 i ) −1 ( N∑ i=1 qiΣ −1 i µi ) . ( 3 ) Concretely , in the case of least squares regression , this suggests that it is sufficient for clients to infer the means { µi } and inverse covariances { Σ −1 i } of their local posteriors and communicate that information to server for the latter to be able to find the global optimum . However , a straightforward application of Eq . 3 would requireO ( d2 ) space andO ( d3 ) computation , both on the clients and on the server , which is very expensive for the typical cross-device FL setting . Similarly , the communication cost would be O ( d2 ) , while standard FL algorithms have communication cost of O ( d ) . 1Note that from the optimization point of view , the global optimum generally can not be represented as any weighted combination of the local optima even in simple 2D settings ( see Fig . 1 , left ) . Algorithm 1 Generalized Federated Optimization input initial θ , CLIENTUPDATE , SERVERUPDATE 1 : for each round t = 1 , . . . , T do 2 : Sample a subset S of clients 3 : communicate θ to all i ∈ S // server→ clients 4 : for each client i ∈ S in parallel do 5 : ∆ti , qi ← CLIENTUPDATE ( θ ) 6 : end for 7 : communicate { ∆ti , qi } i∈S // server← clients 8 : ∆t ← 1|S| ∑ i∈S qi∆ t i // aggregate updates 9 : θ ← SERVERUPDATE ( θ , ∆t ) 10 : end for output final θ Algorithm 2 Client Update ( FEDAVG ) input initial θ0 , loss fi ( θ ) , optimizer CLIENTOPT 1 : for k = 1 , . . . , K do 2 : θk ← CLIENTOPT ( θk−1 , ∇̂fi ( θk−1 ) ) 3 : end for output ∆ : = θ0 − θk , client weight qi Algorithm 3 Client Update ( FEDPA ) input initial θ0 , loss fi ( θ ) , sampler CLIENTMCMC 1 : for k = 1 , . . . , K do 2 : θk ∼ CLIENTMCMC ( θk−1 , fi ) 3 : end for output ∆ : = Σ̂ −1 ( θ0 − µ̂ ) , client weight qi Approximate federated posterior inference . Apart from the computation and communication issues discussed in the simple example above , we also have to contend with the fact that , generally , posteriors are non-Gaussian and closed form expressions for global posterior modes may not exist.2 In such cases , we propose to use the Laplace approximation for local and global posteriors , i.e. , approximate them with the best-fitting Gaussians . While imperfect , this approximation will allow us to compute the ( approximate ) global posterior mode in a computation- and communication-efficient manner using the following three steps : ( i ) infer approximate local means { µ̂i } and covariances { Σ̂i } , ( ii ) communicate these to the server , and ( iii ) compute the posterior mode given by Eq . 3 . Note that directly computing and communicating these quantities would be completely infeasible for the realistic setting where models are neural networks with millions of parameters . In the following section , we design a practical algorithm where all costs are linear in the number of model parameters . | This paper introduces a new perspective on federated learning through the lens of posterior inference. The paper designs a computation- and communication-efficient posterior inference algorithm—federated posterior averaging (FEDPA), which generalizes FedAvg. FEDPA is compared with the strong baselines in Reddi et al. (2020) on realistic FL benchmarks, which achieves state-of-the-art results with respect to multiple metrics of interest. | SP:6389ff57423090975659dbcd572192bd48f9c3b5 |
Learning the Pareto Front with Hypernetworks | We describe an approach to PFL implemented using HyperNetworks , which we term Pareto HyperNetworks ( PHNs ) . PHN learns the entire Pareto front simultaneously using a single hypernetwork , which receives as input a desired preference vector and returns a Pareto-optimal model whose loss vector is in the desired ray . The unified model is runtime efficient compared to training multiple models and generalizes to new operating points not used during training . We evaluate our method on a wide set of problems , from multi-task regression and classification to fairness . PHNs learn the entire Pareto front at roughly the same time as learning a single point on the front and at the same time reach a better solution set . PFL opens the door to new applications where models are selected based on preferences that are only available at run time . 1 INTRODUCTION . Multi-objective optimization ( MOO ) aims to optimize several possibly conflicting objectives . MOO is abundant in machine learning problems , from multi-task learning ( MTL ) , where the goal is to learn several tasks simultaneously , to constrained problems . In such problems , one aims to learn a single task while finding solutions that satisfy properties like fairness or privacy . It is common to optimize the main task while adding loss terms to encourage the learned model to obtain these properties . MOO problems have a set of optimal solutions , the Pareto front , each reflecting a different trade-off between objectives . Points on the Pareto front can be viewed as an intersection of the front with a specific direction in loss space ( a ray , Figure 1 ) . We refer to this direction as a preference vector , as it represents a single trade-off between objectives . When a direction is known in advance , it is possible to obtain the corresponding solution on the front ( Mahapatra & Rajan , 2020 ) . However , in many cases , we are interested in more than one predefined direction , either because the trade-off is not known before training , or because there are many possible trade-offs of interest . For ∗Equal contributor †Equal contributor example , network routing optimization aims to maximize bandwidth , minimize latency , and obey fairness . However , the cost and trade-off vary from one application running in the network to another , or even continuously change in time . The challenge remains to design a model that can be applied at inference time to any given preference direction , even ones not seen during training . We call this problem Pareto front learning ( PFL ) . Although several recent studies ( Yang et al. , 2019 ; Parisi et al. , 2016 ) suggested to learn the trade-off curve in MOO problems , there is no existing scalable and general-purpose MOO approach that provides Pareto-optimal solutions for numerous preferences in objective space . Classical approaches , like genetic algorithms , do not scale to modern high-dimensional problems . It is possible in principle to run a single-direction optimization multiple times , each for a different preference , but this approach faces two major drawbacks : ( i ) Scalability – the number of models to be trained to cover the objective space grows exponentially with the number of objectives ; and ( ii ) Flexibility – the decision maker can not switch freely between preferences unless all models are trained and stored in advance . Here we put forward a new view of PFL as a problem of learning a conditional model , where the conditioning is over the preference direction . During training , a single unified model is trained to produce Pareto optimal solutions while satisfying the given preferences . During inference , the model covers the Pareto front by varying the input preference vector . We further describe an architecture that implements this idea using HyperNetworks . Specifically , we train a hypernetwork , termed Pareto Hypernetwork ( PHN ) , that given a preference vector as an input , produces a deep network model tuned for that objective preference . Training is applied to preferences sampled from the m−dimensional simplex where m represents the number of objectives . We evaluate PHN on a wide set of problems , from multi-class classification , through fairness and image segmentation to multi-task regression . We find that PHN can achieve superior overall solutions while being 10 ∼ 50 times faster ( see Figure 5 ) . PHN addresses both scalability and flexibility . Training a unified model allows using any objective preference at inference time . Finally , as PHN generates a continuous parametrization of the entire Pareto front , it could open new possibilities to analyze Pareto optimal solutions in large-scale neural networks . Our paper has the following contributions : ( 1 ) We define the Pareto-front learning problem – learn a model that at inference time can operate on any given preference vector , providing a Pareto-optimal solution for that specified objective trade-off . ( 2 ) We describe Pareto Hypernetworks ( PHN ) , a unified architecture based on hypernetworks that addresses PFL and shows it can be effectively trained . ( 3 ) Empirical evaluations on various tasks and datasets demonstrate the ability of PHNs to generate better objective space coverage compared to multiple baseline models , with significant improvement in training time . 2 MULTI-OBJECTIVE OPTIMIZATION . We start by formally defining the MOO problem . An MOO is defined by m losses ` i : Rd → R+ , i = 1 , . . . , m , or in vector form ` : Rd → Rm+ . We define a partial ordering on the loss space Rm+ by setting ` ( θ1 ) ` ( θ2 ) if for all i ∈ [ m ] , ` i ( θ1 ) ≤ ` i ( θ2 ) . We define ` ( θ1 ) ≺ ` ( θ2 ) if ` ( θ1 ) ` ( θ2 ) and for some i ∈ [ m ] , ` i ( θ1 ) < ` i ( θ2 ) . We say that a point θ1 ∈ Rd dominates θ2 ∈ Rd if ` ( θ1 ) ≺ ` ( θ2 ) . If a point θ1 dominates θ2 , then θ1 is clearly preferable , because it improves some objectives and is not worse on any other objective . Otherwise , solutions present a certain trade-off and selecting one specific solution requires additional information about the user preferences . A point that is not dominated by any other point is called Pareto optimal . The set of all Pareto optimal points is called the Pareto front . Since many modern machine learning models , e.g. , deep neural networks , use non-convex optimization , one can not expect global optimality . We call a point local Pareto optimal if it is Pareto optimal in some open neighborhood of the point . The most straightforward approach to MOO is linear scalarization ( LS ) , where one defines a new single loss ` r ( θ ) = ∑ i ri ` i ( θ ) given a vector r ∈ Rm+ of weights . One can then apply standard , single-objective optimization algorithms . LS has two major limitations . First , it can only reach the convex part of the Pareto front ( Boyd et al. , 2004 , Chapter 4.7 ) , as shown empirically in Figure 1 . Second , if one wishes to target a specific ray in loss space , specified by a preference vector , it is not clear which linear weights lead to that desired Pareto optimal point . In the context of the current work , we highlight two properties that an MOO optimization procedure should possess : scale to many objectives and control which solution on the Pareto front is obtained . Lin et al . ( 2019 ) described Pareto multi-task learning ( PMTL ) , an algorithm that splits the loss space into separate cones based on the selected reference rays , and returns a solution per cone using a constrained version of Fliege & Svaiter ( 2000 ) . This approach allows the user to target several points on the Pareto front ; However , it scales poorly with the number of cones and does not converge to the exact desired ray on the Pareto front . Convergence to the desired ray in loss space can be achieved using Exact Pareto Optimal ( EPO ) ( Mahapatra & Rajan , 2020 ) . To find the intersection of the Pareto front with a given preference ray r , EPO balances two goals : Finding a descent direction towards the Pareto front and approaching the desired ray . EPO searches for a point in the convex hull of the gradients , known by Désidéri ( 2012 ) to include descent directions , that has a maximal angle with a vector dbal which pulls the point to the desired ray . EPO combines gradient descent and controlled ascent enabling it to reach an exact Pareto optimal solution if one exists , or the closest Pareto optimal solution . 3 RELATWED WORK . Multitask learning . In multitask learning ( MTL ) we simultaneously solve several learning problems while sharing information among tasks ( Zhang & Yang , 2017 ; Ruder , 2017 ) . In some cases , MTL-based models outperform their single task counterparts in terms of per-task performance and computational efficiency ( Standley et al. , 2019 ) . MTL approaches map the loss vector into a single loss term using a fixed or dynamic weighting scheme . The most frequently used approach is Linear Scalarization ( LS ) , in which each loss term ’ s weight is chosen apriori . A proper set of weights is commonly selected using grid search . Unfortunately , such an approach scales poorly with the number of tasks . Recently , MTL methods propose dynamically balance the loss terms using gradient magnitude ( Chen et al. , 2018 ) , the rate of change in losses ( Liu et al. , 2019 ) , task uncertainty ( Kendall et al. , 2018 ) , or learning non-linear loss combinations by implicit differentiation ( Navon et al. , 2020 ) . However , those methods seek a balanced solution and are not suitable for modeling task trade-offs . Multi-objective optimization . The goal of Multi-Objective Optimization ( MOO ) is to find Pareto optimal solutions corresponding to different trade-offs between objectives ( Ehrgott , 2005 ) . MOO has a wide variety of applications in machine learning , spanning Reinforcement Learning ( Van Moffaert & Nowé , 2014 ; Pirotta & Restelli , 2016 ; Parisi et al. , 2014 ; Pirotta et al. , 2015 ; Parisi et al. , 2016 ; Yang et al. , 2019 ) , neural architecture search ( Lu et al. , 2019 ; Hsu et al. , 2018 ) , fairness ( Martínez et al. , 2020 ; Liu & Vicente , 2020 ) , and Bayesian optimization ( Shah & Ghahramani , 2016 ; Hernández-Lobato et al. , 2016 ) . Genetic algorithms ( GA ) are a popular approach for small-scale multi-objective optimization problems . GAs are designed to maintain a set of solutions during optimization . Therefore , they can be extended in natural ways to maintain solutions for different rays . In this area , leading approaches include NSGA-III ( Deb & Jain , 2013 ) and MOEA/D ( Zhang & Li , 2007 ) . However , these gradient-free methods scale poorly with the number of parameters and are not suitable for training large-scale neural networks . Sener & Koltun ( 2018 ) proposed a gradient-based MOO algorithm for MTL , based on MDGA ( Désidéri , 2012 ) , suitable for training large-scale neural networks . Other recent works include ( Lin et al. , 2019 ; Mahapatra & Rajan , 2020 ) detailed in Section 2 . Another recent approach that aims at a more complete view of the Pareto front is Ma et al . ( 2020 ) . They extend a given Pareto optimal solution in its local neighborhood . In a concurrent work , Lin et al . ( 2020 ) extends Lin et al . ( 2019 ) for approximating the entire Pareto front . They train a single hypernetwork by constantly changing the reference directions in the PMTL objective . The proposed method is conceptually similar to our approach , but since it builds on PMTL , it may not produce an exact mapping between the preference and the corresponding solution . Similarly , Dosovitskiy & Djolonga ( 2019 ) proposed learning a single model conditioning on the objective weight vector . The method uses feature-wise linear modulation Perez et al . ( 2017 ) , and dynamically weighted LS loss criterion . Hypernetworks . Ha et al . ( 2017 ) introduced the idea of hypernetworks ( HNs ) inspired by the genotype-phenotype relation in cellular biology . HN presents an approach of using one network ( hypernetwork ) to generate weights for a second network ( target network ) . In recent years , HN are widely used in various domains such as computer vision ( Klocek et al. , 2019 ; Ha et al. , 2017 ) , language modeling ( Suarez , 2017 ) , sequence decoding ( Nachmani & Wolf , 2019 ) , continual learning ( Oswald et al. , 2020 ) , federated learning ( Shamsian et al. , 2021 ) and hyperparameter optimization ( Mackay et al. , 2019 ; Lorraine & Duvenaud , 2018 ) . HN dynamically generates models conditioned on a given input , obtaining a set of customized models using a single learnable network . | The paper proposes a method for multi-objective optimization. The key idea is to learn the entire Pareto front at once by training a hypernetwork that takes preference vector as an inputs and outputs network parameters, which corresponds to a point on the Pareto set with the desired trade-off specified by the preference vector. Specifically, the hypernetwork is a multi-head network where each head outputs a weight tensor of a module in the target network. The method improves HV from the baselines, in several multi-task learning problems, including image classification, regression and, mixed classification and regression. | SP:7e51fa9afc6a36b771f966b8f615449dab0191bf |
Learning the Pareto Front with Hypernetworks | We describe an approach to PFL implemented using HyperNetworks , which we term Pareto HyperNetworks ( PHNs ) . PHN learns the entire Pareto front simultaneously using a single hypernetwork , which receives as input a desired preference vector and returns a Pareto-optimal model whose loss vector is in the desired ray . The unified model is runtime efficient compared to training multiple models and generalizes to new operating points not used during training . We evaluate our method on a wide set of problems , from multi-task regression and classification to fairness . PHNs learn the entire Pareto front at roughly the same time as learning a single point on the front and at the same time reach a better solution set . PFL opens the door to new applications where models are selected based on preferences that are only available at run time . 1 INTRODUCTION . Multi-objective optimization ( MOO ) aims to optimize several possibly conflicting objectives . MOO is abundant in machine learning problems , from multi-task learning ( MTL ) , where the goal is to learn several tasks simultaneously , to constrained problems . In such problems , one aims to learn a single task while finding solutions that satisfy properties like fairness or privacy . It is common to optimize the main task while adding loss terms to encourage the learned model to obtain these properties . MOO problems have a set of optimal solutions , the Pareto front , each reflecting a different trade-off between objectives . Points on the Pareto front can be viewed as an intersection of the front with a specific direction in loss space ( a ray , Figure 1 ) . We refer to this direction as a preference vector , as it represents a single trade-off between objectives . When a direction is known in advance , it is possible to obtain the corresponding solution on the front ( Mahapatra & Rajan , 2020 ) . However , in many cases , we are interested in more than one predefined direction , either because the trade-off is not known before training , or because there are many possible trade-offs of interest . For ∗Equal contributor †Equal contributor example , network routing optimization aims to maximize bandwidth , minimize latency , and obey fairness . However , the cost and trade-off vary from one application running in the network to another , or even continuously change in time . The challenge remains to design a model that can be applied at inference time to any given preference direction , even ones not seen during training . We call this problem Pareto front learning ( PFL ) . Although several recent studies ( Yang et al. , 2019 ; Parisi et al. , 2016 ) suggested to learn the trade-off curve in MOO problems , there is no existing scalable and general-purpose MOO approach that provides Pareto-optimal solutions for numerous preferences in objective space . Classical approaches , like genetic algorithms , do not scale to modern high-dimensional problems . It is possible in principle to run a single-direction optimization multiple times , each for a different preference , but this approach faces two major drawbacks : ( i ) Scalability – the number of models to be trained to cover the objective space grows exponentially with the number of objectives ; and ( ii ) Flexibility – the decision maker can not switch freely between preferences unless all models are trained and stored in advance . Here we put forward a new view of PFL as a problem of learning a conditional model , where the conditioning is over the preference direction . During training , a single unified model is trained to produce Pareto optimal solutions while satisfying the given preferences . During inference , the model covers the Pareto front by varying the input preference vector . We further describe an architecture that implements this idea using HyperNetworks . Specifically , we train a hypernetwork , termed Pareto Hypernetwork ( PHN ) , that given a preference vector as an input , produces a deep network model tuned for that objective preference . Training is applied to preferences sampled from the m−dimensional simplex where m represents the number of objectives . We evaluate PHN on a wide set of problems , from multi-class classification , through fairness and image segmentation to multi-task regression . We find that PHN can achieve superior overall solutions while being 10 ∼ 50 times faster ( see Figure 5 ) . PHN addresses both scalability and flexibility . Training a unified model allows using any objective preference at inference time . Finally , as PHN generates a continuous parametrization of the entire Pareto front , it could open new possibilities to analyze Pareto optimal solutions in large-scale neural networks . Our paper has the following contributions : ( 1 ) We define the Pareto-front learning problem – learn a model that at inference time can operate on any given preference vector , providing a Pareto-optimal solution for that specified objective trade-off . ( 2 ) We describe Pareto Hypernetworks ( PHN ) , a unified architecture based on hypernetworks that addresses PFL and shows it can be effectively trained . ( 3 ) Empirical evaluations on various tasks and datasets demonstrate the ability of PHNs to generate better objective space coverage compared to multiple baseline models , with significant improvement in training time . 2 MULTI-OBJECTIVE OPTIMIZATION . We start by formally defining the MOO problem . An MOO is defined by m losses ` i : Rd → R+ , i = 1 , . . . , m , or in vector form ` : Rd → Rm+ . We define a partial ordering on the loss space Rm+ by setting ` ( θ1 ) ` ( θ2 ) if for all i ∈ [ m ] , ` i ( θ1 ) ≤ ` i ( θ2 ) . We define ` ( θ1 ) ≺ ` ( θ2 ) if ` ( θ1 ) ` ( θ2 ) and for some i ∈ [ m ] , ` i ( θ1 ) < ` i ( θ2 ) . We say that a point θ1 ∈ Rd dominates θ2 ∈ Rd if ` ( θ1 ) ≺ ` ( θ2 ) . If a point θ1 dominates θ2 , then θ1 is clearly preferable , because it improves some objectives and is not worse on any other objective . Otherwise , solutions present a certain trade-off and selecting one specific solution requires additional information about the user preferences . A point that is not dominated by any other point is called Pareto optimal . The set of all Pareto optimal points is called the Pareto front . Since many modern machine learning models , e.g. , deep neural networks , use non-convex optimization , one can not expect global optimality . We call a point local Pareto optimal if it is Pareto optimal in some open neighborhood of the point . The most straightforward approach to MOO is linear scalarization ( LS ) , where one defines a new single loss ` r ( θ ) = ∑ i ri ` i ( θ ) given a vector r ∈ Rm+ of weights . One can then apply standard , single-objective optimization algorithms . LS has two major limitations . First , it can only reach the convex part of the Pareto front ( Boyd et al. , 2004 , Chapter 4.7 ) , as shown empirically in Figure 1 . Second , if one wishes to target a specific ray in loss space , specified by a preference vector , it is not clear which linear weights lead to that desired Pareto optimal point . In the context of the current work , we highlight two properties that an MOO optimization procedure should possess : scale to many objectives and control which solution on the Pareto front is obtained . Lin et al . ( 2019 ) described Pareto multi-task learning ( PMTL ) , an algorithm that splits the loss space into separate cones based on the selected reference rays , and returns a solution per cone using a constrained version of Fliege & Svaiter ( 2000 ) . This approach allows the user to target several points on the Pareto front ; However , it scales poorly with the number of cones and does not converge to the exact desired ray on the Pareto front . Convergence to the desired ray in loss space can be achieved using Exact Pareto Optimal ( EPO ) ( Mahapatra & Rajan , 2020 ) . To find the intersection of the Pareto front with a given preference ray r , EPO balances two goals : Finding a descent direction towards the Pareto front and approaching the desired ray . EPO searches for a point in the convex hull of the gradients , known by Désidéri ( 2012 ) to include descent directions , that has a maximal angle with a vector dbal which pulls the point to the desired ray . EPO combines gradient descent and controlled ascent enabling it to reach an exact Pareto optimal solution if one exists , or the closest Pareto optimal solution . 3 RELATWED WORK . Multitask learning . In multitask learning ( MTL ) we simultaneously solve several learning problems while sharing information among tasks ( Zhang & Yang , 2017 ; Ruder , 2017 ) . In some cases , MTL-based models outperform their single task counterparts in terms of per-task performance and computational efficiency ( Standley et al. , 2019 ) . MTL approaches map the loss vector into a single loss term using a fixed or dynamic weighting scheme . The most frequently used approach is Linear Scalarization ( LS ) , in which each loss term ’ s weight is chosen apriori . A proper set of weights is commonly selected using grid search . Unfortunately , such an approach scales poorly with the number of tasks . Recently , MTL methods propose dynamically balance the loss terms using gradient magnitude ( Chen et al. , 2018 ) , the rate of change in losses ( Liu et al. , 2019 ) , task uncertainty ( Kendall et al. , 2018 ) , or learning non-linear loss combinations by implicit differentiation ( Navon et al. , 2020 ) . However , those methods seek a balanced solution and are not suitable for modeling task trade-offs . Multi-objective optimization . The goal of Multi-Objective Optimization ( MOO ) is to find Pareto optimal solutions corresponding to different trade-offs between objectives ( Ehrgott , 2005 ) . MOO has a wide variety of applications in machine learning , spanning Reinforcement Learning ( Van Moffaert & Nowé , 2014 ; Pirotta & Restelli , 2016 ; Parisi et al. , 2014 ; Pirotta et al. , 2015 ; Parisi et al. , 2016 ; Yang et al. , 2019 ) , neural architecture search ( Lu et al. , 2019 ; Hsu et al. , 2018 ) , fairness ( Martínez et al. , 2020 ; Liu & Vicente , 2020 ) , and Bayesian optimization ( Shah & Ghahramani , 2016 ; Hernández-Lobato et al. , 2016 ) . Genetic algorithms ( GA ) are a popular approach for small-scale multi-objective optimization problems . GAs are designed to maintain a set of solutions during optimization . Therefore , they can be extended in natural ways to maintain solutions for different rays . In this area , leading approaches include NSGA-III ( Deb & Jain , 2013 ) and MOEA/D ( Zhang & Li , 2007 ) . However , these gradient-free methods scale poorly with the number of parameters and are not suitable for training large-scale neural networks . Sener & Koltun ( 2018 ) proposed a gradient-based MOO algorithm for MTL , based on MDGA ( Désidéri , 2012 ) , suitable for training large-scale neural networks . Other recent works include ( Lin et al. , 2019 ; Mahapatra & Rajan , 2020 ) detailed in Section 2 . Another recent approach that aims at a more complete view of the Pareto front is Ma et al . ( 2020 ) . They extend a given Pareto optimal solution in its local neighborhood . In a concurrent work , Lin et al . ( 2020 ) extends Lin et al . ( 2019 ) for approximating the entire Pareto front . They train a single hypernetwork by constantly changing the reference directions in the PMTL objective . The proposed method is conceptually similar to our approach , but since it builds on PMTL , it may not produce an exact mapping between the preference and the corresponding solution . Similarly , Dosovitskiy & Djolonga ( 2019 ) proposed learning a single model conditioning on the objective weight vector . The method uses feature-wise linear modulation Perez et al . ( 2017 ) , and dynamically weighted LS loss criterion . Hypernetworks . Ha et al . ( 2017 ) introduced the idea of hypernetworks ( HNs ) inspired by the genotype-phenotype relation in cellular biology . HN presents an approach of using one network ( hypernetwork ) to generate weights for a second network ( target network ) . In recent years , HN are widely used in various domains such as computer vision ( Klocek et al. , 2019 ; Ha et al. , 2017 ) , language modeling ( Suarez , 2017 ) , sequence decoding ( Nachmani & Wolf , 2019 ) , continual learning ( Oswald et al. , 2020 ) , federated learning ( Shamsian et al. , 2021 ) and hyperparameter optimization ( Mackay et al. , 2019 ; Lorraine & Duvenaud , 2018 ) . HN dynamically generates models conditioned on a given input , obtaining a set of customized models using a single learnable network . | This paper tracks the problem of learning the entire Pareto front to allow the user to select a desired Pareto optimal solution by one inference procedure without retraining the model. The high-level idea is to learn the entire Pareto front simultaneously using a single hyper network, which receives as input the desired preference vector and returns a Pareto-optimal solution whose loss vector is in the desired direction. The paper gives an early trial to build a toolbox to allow users to get a desired solution by a single inference procedure. | SP:7e51fa9afc6a36b771f966b8f615449dab0191bf |
Semi-Supervised Learning via Clustering Representation Space | 1 INTRODUCTION . Labeling data is expensive . Thus , it is often hard for us to get enough labeled samples . Thus , semi-supervised learning ( Chapelle et al. , 2009 ) becomes a serious issue . People try to get good performance with limited labeled data and a large amount of unlabeled data . When having a limited amount of labeled samples , extracting information from unlabeled data has played an important role for semi-supervised learning . In general , we often applied unlabeled information as auxiliary tools , such as pre-training ( Hinton and Salakhutdinov , 2006 ) or recursive picking confidence data from unlabeled samples with supervised learning ( Zhu , 2005 ) . However , we notice that when we counter the issue such as Two Half-moon , double circle , or other more complex distribution problem , these methods are lack of considering the spatial distribution information provided by unlabeled samples . In this paper , we aimed to guide our model to extract the spatial distribution information from unlabeled data . We proposed a new approach for semi-supervised learning by adding our loss function term for our target embedding latent space . Within our proposed model , the neural network can now learn correctness and spatial distribution information from labeled and unlabeled samples simultaneously . This provides our feed-forward neural network to have more opportunity passing through the sparse margin between clusters , and elevate the performance of the classifier , see more details in Sec . 3 . Moreover , it is worth noting that our proposed model does not rely on any additional neural networks , which is suitable for any task and is highly compatible with different semi-supervised learning algorithms . In short , the characteristics of our proposed model are as follows : Intuitive The idea of correctness and spatial distribution came up with the characteristics of supervised and unsupervised learning straightly , which is intuitive . Compatibility Our method does not rely on any additional neural networks but only adding new loss term . Our approach is easy to change into any existing feed-forward neural networks . Extensible We designed our approach by the notion of defining an evaluation for spatial distribution , which can replace by any other methods in future researches . 2 RELATED WORK . In recent years , the neural network plays an essential role in various tasks ; more specifically , they are highly applied in the tasks of image classification . Since then , semi-supervised learning ( Weston et al. , 2012 ; Lee , 2013 ) for image classification has become a vital issue . First of all , some works succeeded by proposing regularization methods for NNs ( Bishop , 1995 ; Srivastava et al. , 2014 ) . They regularize the input and hidden layers of their models by applying random permutations . This can smooth the input-output relation and further get improvements in semi-supervised learning . Generative adversarial networks ( GAN ) ( Goodfellow et al. , 2014 ) are popular research for the neural network , several models ( Salimans et al. , 2016 ; Dumoulin et al. , 2016 ; Dai et al. , 2017 ) had gone more in-depth researches with GAN for semi-supervised learning . They showed remarkable results , especially on image classification problems . In 2014 , Kingma et al . proposed Deep generative models ( Kingma et al. , 2014 ) , applying a variational-autoencoder based generative model to semi-supervised learning . They showed good results on image classification for semi-supervised learning and became the benchmark of several datasets . However , in practice , these models require more careful tuning for parameters . Also , they usually require more neural network structures and computation resources . Moreover , Rasmus et al . ( Rasmus et al. , 2015 ) propose semi-supervised with Ladder Networks , a model structure with an autoencoder . This work is similar to denoising autoencoders and applied to every layer . It is impressive that they have got a vast improvement compared with Deep Generative models ( Kingma et al. , 2014 ) . Shortly after , Miyato ey al . ( Miyato et al. , 2018 ) also achieve competitive results on the benchmark data sets with a regularization term . They guide their model to minimize the change of the input and output of the network , which does not require labeled information and able to use unlabeled samples for their regularization term . Labeled propagation proposed by ( Zhu and Ghahramani , 2002 ) is also a family of methods for semi-supervised learning . By smoothing the model around the input data points , the model can extrapolate the labels of unlabeled samples . Similar to this idea , several works ( Laine and Aila , 2016 ; Sajjadi et al. , 2016 ) had succeeded by using the random image augmentation . They try to improve the generation performance of image classification for semi-supervised learning . 3 PROPOSED MODEL . For semi-supervised learning , we assume that in some particular space , samples in the same category should be in the same cluster . Following this assumption , once we can distinguish different clusters properly , and guide our network to find the decision boundary with sparser region between clusters . In this section , we introduce an end-to-end learning method by adding our loss functions . First of all , we tried to guide our network to learn a good mapping from the original input space to the embedding latent space ; see Sec . 3.1 . We next defined loss functions and tried to cluster the samples that should be in the same categories together in the embedding latent space ; see Sec . 3.2 . Moreover , similar to some supervised learning works ( Xu et al. , 2005 ; Rennie and Srebro , 2005 ; Srebro et al. , 2005 ) , we aim to maximize the margin between different clusters to separate them well . Note that since we are lack of labeled samples , we maximize the margin within temporary clustering results for our data , instead of using the ground truth of labeled data , see more in Sec . 3.3 . Overall , we named our proposed model as Maximum Cluster Margin Classifier , referred to as MCMC . 3.1 EMBEDDING LATENT SPACE . In general , measuring a clustering result is very subjective . However , to deal with various kinds of distribution , we avoid evaluating them directly by their original input space . Instead , we pull out a layer from the neural network and set it as the embedding latent space . Next , we evaluate whether the quality of the embedding latent space . In our proposed model , we try to define a measurement for the embedding latent space to satisfy our assumptions . This guides the previous layers to learn about a good mapping from the original input space to a well-distributed embedding latent space . To strengthen the efficiency of the embedding latent space , we add a simple classifier that is fully connected to the embedding latent space . 3.2 DB LOSS . 3.2.1 DAVIES-BOULDIN INDEX . As Davies-Bouldin index ( Davies and Bouldin , 1979 ) proposed , given a dataset with N clusters , for every cluster Ci , we compute Si as a measure of scattering with the cluster , which is defined as follows : Si = ( 1 Ti Ti∑ j=1 |Xji −Ai| p ) 1 p ( 1 ) where Xji is the jth sample of cluster Ci , Ai is the centroid of cluster Ci , Ti is the size of Ci and p is usually set as 2 . To measure the distance between different centroid of clusters Ci and Cj , we compute Mi , j , which is defined as follows : Mi , j = ||Ai −Aj ||p = ( n∑ k=1 |ak , i − ak , j |p ) 1 p ( 2 ) where ak , i is the ith element of Ai , and p is usually set as 2 . Finally , we combine Si with Mi , j , which is defined as follows : Ri , j = Si + Sj Mi , j , Di ≡ max i 6=j Ri , j , DB ≡ 1 N N∑ i=1 Di . ( 3 ) 3.2.2 DB LOSS . Thanks to Davies-Bouldin index Sec . 3.2.1 ( Davies and Bouldin , 1979 ) , we now have a measurement for evaluating the clustering result in embedding latent space . Eq . ( 1 ) provides us the evaluation of whether the samples in a single cluster are close enough to the centroid . Simultaneously , Eq . ( 2 ) separates the centroid of different clusters to become as far as possible . Moreover , Eq . ( 3 ) restricts every single cluster could gather together while different cluster has a long distance between their centroid . We defined our DB loss LDB as follows : Given points X with temporary predictions ŷ , then LDB ≡ DB ( 4 ) where DB can be computed in Sec . 3.2.1 . Till now , DB loss LDB provides us the capability to guide the samples in the same category gather in the same cluster . However , when we look into Davies-Bouldin index ( Davies and Bouldin , 1979 ) , the measurement considers only about the centroid of each cluster . This causes the issue that different clusters may be overlap with each other . That is , the margin between different clusters has vanished , see Fig.3 . For this reason , we came up with Maximum Margin loss , see Sec . 3.3 . 3.3 MAXIMUM MARGIN LOSS . As we mentioned at the start of Sec . 3 , we need to maximize the margin between different clusters to separate them . We hence came up with Maximum Margin Loss LMM . To push each cluster as far as we can , we compute the sum of k pairs single link ( Gower and Ross , 1969 ) between different clusters . When maximizing those pairs of single link , it also implies maximizing the margin between different clusters . We define the Maximum Margin loss LMM as follows : Given clusters C1 , C2 , ... , CN , we let V ` i , j be the ` th pair single link between Ci and Cj . Also , we define ∑k ` =1 1 V ` i , j to be k pairs single link distancei , j . Finally , we have LMM = N∑ i 6=j , i < j ( k pairs single link distancei , j ) , ( 5 ) where k is the number of pairs between different clusters , and N is the number of the clusters . Maximum Margin loss LMM provides the information of k-pair single link distance between different clusters . This loss can guide the model to ameliorate the overlap problem and maximize the margin between different clusters . Fig . 1 ( b ) shows the main idea of Maximum Margin loss LMM , which helps our network avoid the problem illustrated in Fig . 1 ( a ) . Overall , by combining DB loss LDB and Maximum Margin loss LMM , we can find our ideal evaluation for clustering results in embedding latent space . Our network is now able to gather the samples that should be in the same categories and separate different clusters as far as possible . 3.4 TOTAL LOSS . In this section , we took a more in-depth exploration of how we deal with labeled data and unlabeled data for our total loss separately . For labeled data , we applied loss with cross-entropy ( CE ) ( De Boer et al. , 2005 ) , which is widely used for classification tasks in supervised learning . Note that Crossentropy ( CE ) ( De Boer et al. , 2005 ) is available to change into other losses in supervised learning for personal use . Though labeled data might have a small number of samples , they still play an essential role in guiding the network learning the right predictions . Moreover , they can also provide the neural network to learn a rough decision boundary in the early iterations . This leads our network to get a good start and modify the boundary into better results . As we mentioned in Sec . 3.2.2 and Sec . 3.3 , we need DB loss LDB to guide the samples in the same cluster to group together . At the same time , Maximum Margin loss LMM pushes the different clusters as far as possible , i.e. , maximize the margin between different clusters . We define the total loss LTotal as follows : LTotal = LDB + LCE + LMM . ( 6 ) | This paper attempts to address the semi-supervised learning topic by proposing a method based on an aggregated loss considering both cross-entry and Davies-Bouldin Index. Cross-entropy is used to ensure the maximum margin between classes and Davies-Bouldin Index is applied to the labeled data and to the whole dataset, respectively, to ensure a high quality of clustering. Evaluations in four small and simple datasets are reported to demonstrate the effectiveness of the proposed method. | SP:5d2c22e82721397371999020d145c432fd6e7a42 |
Semi-Supervised Learning via Clustering Representation Space | 1 INTRODUCTION . Labeling data is expensive . Thus , it is often hard for us to get enough labeled samples . Thus , semi-supervised learning ( Chapelle et al. , 2009 ) becomes a serious issue . People try to get good performance with limited labeled data and a large amount of unlabeled data . When having a limited amount of labeled samples , extracting information from unlabeled data has played an important role for semi-supervised learning . In general , we often applied unlabeled information as auxiliary tools , such as pre-training ( Hinton and Salakhutdinov , 2006 ) or recursive picking confidence data from unlabeled samples with supervised learning ( Zhu , 2005 ) . However , we notice that when we counter the issue such as Two Half-moon , double circle , or other more complex distribution problem , these methods are lack of considering the spatial distribution information provided by unlabeled samples . In this paper , we aimed to guide our model to extract the spatial distribution information from unlabeled data . We proposed a new approach for semi-supervised learning by adding our loss function term for our target embedding latent space . Within our proposed model , the neural network can now learn correctness and spatial distribution information from labeled and unlabeled samples simultaneously . This provides our feed-forward neural network to have more opportunity passing through the sparse margin between clusters , and elevate the performance of the classifier , see more details in Sec . 3 . Moreover , it is worth noting that our proposed model does not rely on any additional neural networks , which is suitable for any task and is highly compatible with different semi-supervised learning algorithms . In short , the characteristics of our proposed model are as follows : Intuitive The idea of correctness and spatial distribution came up with the characteristics of supervised and unsupervised learning straightly , which is intuitive . Compatibility Our method does not rely on any additional neural networks but only adding new loss term . Our approach is easy to change into any existing feed-forward neural networks . Extensible We designed our approach by the notion of defining an evaluation for spatial distribution , which can replace by any other methods in future researches . 2 RELATED WORK . In recent years , the neural network plays an essential role in various tasks ; more specifically , they are highly applied in the tasks of image classification . Since then , semi-supervised learning ( Weston et al. , 2012 ; Lee , 2013 ) for image classification has become a vital issue . First of all , some works succeeded by proposing regularization methods for NNs ( Bishop , 1995 ; Srivastava et al. , 2014 ) . They regularize the input and hidden layers of their models by applying random permutations . This can smooth the input-output relation and further get improvements in semi-supervised learning . Generative adversarial networks ( GAN ) ( Goodfellow et al. , 2014 ) are popular research for the neural network , several models ( Salimans et al. , 2016 ; Dumoulin et al. , 2016 ; Dai et al. , 2017 ) had gone more in-depth researches with GAN for semi-supervised learning . They showed remarkable results , especially on image classification problems . In 2014 , Kingma et al . proposed Deep generative models ( Kingma et al. , 2014 ) , applying a variational-autoencoder based generative model to semi-supervised learning . They showed good results on image classification for semi-supervised learning and became the benchmark of several datasets . However , in practice , these models require more careful tuning for parameters . Also , they usually require more neural network structures and computation resources . Moreover , Rasmus et al . ( Rasmus et al. , 2015 ) propose semi-supervised with Ladder Networks , a model structure with an autoencoder . This work is similar to denoising autoencoders and applied to every layer . It is impressive that they have got a vast improvement compared with Deep Generative models ( Kingma et al. , 2014 ) . Shortly after , Miyato ey al . ( Miyato et al. , 2018 ) also achieve competitive results on the benchmark data sets with a regularization term . They guide their model to minimize the change of the input and output of the network , which does not require labeled information and able to use unlabeled samples for their regularization term . Labeled propagation proposed by ( Zhu and Ghahramani , 2002 ) is also a family of methods for semi-supervised learning . By smoothing the model around the input data points , the model can extrapolate the labels of unlabeled samples . Similar to this idea , several works ( Laine and Aila , 2016 ; Sajjadi et al. , 2016 ) had succeeded by using the random image augmentation . They try to improve the generation performance of image classification for semi-supervised learning . 3 PROPOSED MODEL . For semi-supervised learning , we assume that in some particular space , samples in the same category should be in the same cluster . Following this assumption , once we can distinguish different clusters properly , and guide our network to find the decision boundary with sparser region between clusters . In this section , we introduce an end-to-end learning method by adding our loss functions . First of all , we tried to guide our network to learn a good mapping from the original input space to the embedding latent space ; see Sec . 3.1 . We next defined loss functions and tried to cluster the samples that should be in the same categories together in the embedding latent space ; see Sec . 3.2 . Moreover , similar to some supervised learning works ( Xu et al. , 2005 ; Rennie and Srebro , 2005 ; Srebro et al. , 2005 ) , we aim to maximize the margin between different clusters to separate them well . Note that since we are lack of labeled samples , we maximize the margin within temporary clustering results for our data , instead of using the ground truth of labeled data , see more in Sec . 3.3 . Overall , we named our proposed model as Maximum Cluster Margin Classifier , referred to as MCMC . 3.1 EMBEDDING LATENT SPACE . In general , measuring a clustering result is very subjective . However , to deal with various kinds of distribution , we avoid evaluating them directly by their original input space . Instead , we pull out a layer from the neural network and set it as the embedding latent space . Next , we evaluate whether the quality of the embedding latent space . In our proposed model , we try to define a measurement for the embedding latent space to satisfy our assumptions . This guides the previous layers to learn about a good mapping from the original input space to a well-distributed embedding latent space . To strengthen the efficiency of the embedding latent space , we add a simple classifier that is fully connected to the embedding latent space . 3.2 DB LOSS . 3.2.1 DAVIES-BOULDIN INDEX . As Davies-Bouldin index ( Davies and Bouldin , 1979 ) proposed , given a dataset with N clusters , for every cluster Ci , we compute Si as a measure of scattering with the cluster , which is defined as follows : Si = ( 1 Ti Ti∑ j=1 |Xji −Ai| p ) 1 p ( 1 ) where Xji is the jth sample of cluster Ci , Ai is the centroid of cluster Ci , Ti is the size of Ci and p is usually set as 2 . To measure the distance between different centroid of clusters Ci and Cj , we compute Mi , j , which is defined as follows : Mi , j = ||Ai −Aj ||p = ( n∑ k=1 |ak , i − ak , j |p ) 1 p ( 2 ) where ak , i is the ith element of Ai , and p is usually set as 2 . Finally , we combine Si with Mi , j , which is defined as follows : Ri , j = Si + Sj Mi , j , Di ≡ max i 6=j Ri , j , DB ≡ 1 N N∑ i=1 Di . ( 3 ) 3.2.2 DB LOSS . Thanks to Davies-Bouldin index Sec . 3.2.1 ( Davies and Bouldin , 1979 ) , we now have a measurement for evaluating the clustering result in embedding latent space . Eq . ( 1 ) provides us the evaluation of whether the samples in a single cluster are close enough to the centroid . Simultaneously , Eq . ( 2 ) separates the centroid of different clusters to become as far as possible . Moreover , Eq . ( 3 ) restricts every single cluster could gather together while different cluster has a long distance between their centroid . We defined our DB loss LDB as follows : Given points X with temporary predictions ŷ , then LDB ≡ DB ( 4 ) where DB can be computed in Sec . 3.2.1 . Till now , DB loss LDB provides us the capability to guide the samples in the same category gather in the same cluster . However , when we look into Davies-Bouldin index ( Davies and Bouldin , 1979 ) , the measurement considers only about the centroid of each cluster . This causes the issue that different clusters may be overlap with each other . That is , the margin between different clusters has vanished , see Fig.3 . For this reason , we came up with Maximum Margin loss , see Sec . 3.3 . 3.3 MAXIMUM MARGIN LOSS . As we mentioned at the start of Sec . 3 , we need to maximize the margin between different clusters to separate them . We hence came up with Maximum Margin Loss LMM . To push each cluster as far as we can , we compute the sum of k pairs single link ( Gower and Ross , 1969 ) between different clusters . When maximizing those pairs of single link , it also implies maximizing the margin between different clusters . We define the Maximum Margin loss LMM as follows : Given clusters C1 , C2 , ... , CN , we let V ` i , j be the ` th pair single link between Ci and Cj . Also , we define ∑k ` =1 1 V ` i , j to be k pairs single link distancei , j . Finally , we have LMM = N∑ i 6=j , i < j ( k pairs single link distancei , j ) , ( 5 ) where k is the number of pairs between different clusters , and N is the number of the clusters . Maximum Margin loss LMM provides the information of k-pair single link distance between different clusters . This loss can guide the model to ameliorate the overlap problem and maximize the margin between different clusters . Fig . 1 ( b ) shows the main idea of Maximum Margin loss LMM , which helps our network avoid the problem illustrated in Fig . 1 ( a ) . Overall , by combining DB loss LDB and Maximum Margin loss LMM , we can find our ideal evaluation for clustering results in embedding latent space . Our network is now able to gather the samples that should be in the same categories and separate different clusters as far as possible . 3.4 TOTAL LOSS . In this section , we took a more in-depth exploration of how we deal with labeled data and unlabeled data for our total loss separately . For labeled data , we applied loss with cross-entropy ( CE ) ( De Boer et al. , 2005 ) , which is widely used for classification tasks in supervised learning . Note that Crossentropy ( CE ) ( De Boer et al. , 2005 ) is available to change into other losses in supervised learning for personal use . Though labeled data might have a small number of samples , they still play an essential role in guiding the network learning the right predictions . Moreover , they can also provide the neural network to learn a rough decision boundary in the early iterations . This leads our network to get a good start and modify the boundary into better results . As we mentioned in Sec . 3.2.2 and Sec . 3.3 , we need DB loss LDB to guide the samples in the same cluster to group together . At the same time , Maximum Margin loss LMM pushes the different clusters as far as possible , i.e. , maximize the margin between different clusters . We define the total loss LTotal as follows : LTotal = LDB + LCE + LMM . ( 6 ) | The authors propose a novel loss function for semi-supervised learning. Arguing that SOTA semi-supervised learning methods neglect spatial information (latent clustering structure) in the data, the authors propose a loss function which combines clustering objectives with classification objectives. The proposed loss function combines the cross-entropy loss, the within-cluster scatter as known from k-means, the distance between centroids and the margin between classes. The proposed loss is notably non-continuous since it makes use of the maximum function. The authors employ ADAM with a learning rate of 0.001 with exponential decay to optimize the novel loss function. Experiments on MNIST and three comparably small datasets show that the proposed method is able to achieve high accuracy with only few labeled data points. | SP:5d2c22e82721397371999020d145c432fd6e7a42 |
Informative Outlier Matters: Robustifying Out-of-distribution Detection Using Outlier Mining | 1 INTRODUCTION . Out-of-distribution ( OOD ) detection has become an indispensable part of building reliable open-world machine learning models ( Amodei et al. , 2016 ) . An OOD detector determines whether an input is from the same distribution as the training data , or a different distribution ( i.e. , out-of-distribution ) . The performance of the OOD detector is central for safety-critical applications such as autonomous driving ( Eykholt et al. , 2018 ) or rare disease identification ( Blauwkamp et al. , 2019 ) . Despite exciting progress made in OOD detection , previous methods mostly focused on clean OOD data ( Hendrycks & Gimpel , 2016 ; Liang et al. , 2018 ; Lee et al. , 2018 ; Lakshminarayanan et al. , 2017 ; Hendrycks et al. , 2018 ; Mohseni et al. , 2020 ) . Scant attention has been paid to the robustness aspect of OOD detection . Recent works ( Hein et al. , 2019 ; Sehwag et al. , 2019 ; Bitterwolf et al. , 2020 ) considered worst-case OOD detection under adversarial perturbations ( Papernot et al. , 2016 ; Goodfellow et al. , 2014 ; Biggio et al. , 2013 ; Szegedy et al. , 2013 ) . For example , an OOD image ( e.g. , mailbox ) can be perturbed to be misclassified by the OOD detector as in-distribution ( traffic sign data ) . Such an adversarial OOD example is then passed to the image classifier and trigger undesirable prediction and action ( e.g. , speed limit 70 ) . Therefore , it remains an important question to make out-of-distribution detection algorithms robust in the presence of small perturbations to OOD inputs . In this paper , we begin with formally formulating the task of robust OOD detection and providing theoretical analysis in a simple Gaussian data model . While recent OOD detection methods ( Hendrycks et al. , 2018 ; Hein et al. , 2019 ; Meinke & Hein , 2019 ; Mohseni et al. , 2020 ) have leveraged auxiliary OOD data , they often sample randomly uniformly from the auxiliary dataset . Contrary to the common practice , our analysis reveals a key insight that the majority of auxiliary OOD examples may not provide useful information to improve the decision boundary of OOD detector . Under a Gaussian model of the data , we theoretically show that using outlier mining significantly improves the error bound of OOD detector in the presence of non-informative auxiliary OOD data . Motivated by this insight , we propose Adversarial Training with informative Outlier Mining ( ATOM ) , which justifies the theoretical intuitions above and achieves state-of-the-art performance on a broad family of classic and adversarial OOD evaluation tasks for modern neural networks . We show that , by carefully choosing which OOD data to train on , one can significantly improve the robustness of an OOD detector , and somewhat surprisingly , generalize to unseen adversarial attacks . We note that while hard negative mining has been extensively used in various learning tasks such as object recognition ( Felzenszwalb et al. , 2009 ; Gidaris & Komodakis , 2015 ; Shrivastava et al. , 2016 ) , to the best of our knowledge , we are the first to exploit the novel connection between hard example mining and OOD detection . We show both empirically and theoretically that hard example mining significantly improves the generalization and robustness of OOD detection . To evaluate our method , we provide a unified framework that allows examining the robustness of OOD detection algorithms under a broad family of OOD inputs , as illustrated in Figure 1 . Our evaluation includes existing classic OOD evaluation task – Natural OOD , and adversarial OOD evaluation task – L∞ OOD . Besides , we also introduce new adversarial OOD evaluation tasks – Corruption OOD and Compositional OOD . Under these evaluation tasks , ATOM achieves state-ofthe-art performance compared to eight competitive OOD detection methods ( refer to Appendix B.3 for a detailed description of these methods ) . On the Natural OOD evaluation task , ATOM achieves comparable and often better performance than current state-of-the-art methods . On L∞ OOD evaluation task , ATOM outperforms current state-of-the-art method ACET by a large margin ( e.g . on CIFAR-10 , outperforms it by 53.9 % ) . Under the new Corruption OOD evaluation task , where the attack is unknown during training time , ATOM also achieves much better results than previous methods ( e.g . on CIFAR-10 , outperform previous best method by 30.99 % ) . While almost every method fails under the hardest Compositional OOD evaluation task , ATOM still achieves impressive results ( e.g . on CIFAR-10 , reduce the FPR by 57.99 % ) . The performance is noteworthy since ATOM is not trained explicitly on corrupted OOD inputs . In summary , our contributions are : • Firstly , we contribute theoretical analysis formalizing the intuition of mining hard outliers for improving the robustness of OOD detection . • Secondly , we contribute a theoretically motivated method , ATOM , which leads to state-of- the-art performance on both classic and adversarial OOD evaluation tasks . We conduct extensive evaluations and ablation analysis to demonstrate the effectiveness of informative outlier mining . • Lastly , we provide a unified evaluation framework that allows future research examining the robustness of OOD detection algorithms under a broad family of OOD inputs . 2 PRELIMINARIES . In this section , we formulate the problem of robust out-of-distribution detection , and provide background knowledge on the use of auxiliary data for OOD detection . Problem Statement . We consider a training dataset Dtrainin drawn i.i.d . from a data distribution PX , Y , where X is the sample space and Y = { 1 , 2 , · · · , K } is the set of labels . A classifier f ( x ) is trained on the in-distribution , PX , the marginal distribution of PX , Y . The OOD examples are revealed during test time , which are from a different distribution QX , potentially with perturbations added . The task of robust out-of-distribution detection is to learn a detector G : x→ { −1 , 1 } , which outputs 1 for x from PX and output −1 for a clean or perturbed OOD example x from QX . Formally , let Ω ( x ) be a set of small perturbations on an OOD example x . The detector is evaluated on x from PX and on the worst-case input inside Ω ( x ) for an OOD example from QX . The false negative rate ( FNR ) and false positive rate ( FPR ) are defined as : FNR ( G ) = Ex∼PXI [ G ( x ) = −1 ] , FPR ( G ; QX , Ω ) = Ex∼QX max δ∈Ω ( x ) I [ G ( x + δ ) = 1 ] . ( 1 ) Note that no data from the test OOD distribution QX are available for training . Use of Auxiliary Data for OOD Detection While it is impossible to anticipate the test OOD data distributions QX for training , recent works ( Hendrycks et al. , 2018 ; Hein et al. , 2019 ; Meinke & Hein , 2019 ; Mohseni et al. , 2020 ; Liu et al. , 2020 ) have shown the promise using auxiliary data as a proxy for estimating the decision boundary between in- vs. OOD data . The idea is illustrated in Figure 1 , where outlier data is randomly sampled to regularize the model outputs ( e.g. , low confidence for OOD data and high confidence for in-distribution data ) . Formally , we assume the auxiliary OOD dataset Dauxiliaryout is sampled from a different distribution UX . The difference between the auxiliary data UX and test OOD data PX raises the fundamental question of how to effectively leverage Dauxiliaryout for improving learning the decision boundary between in- vs. OOD data . 3 THEORETICAL ANALYSIS : INFORMATIVE OUTLIERS MATTER . In this section , we present a theoretical analysis1 that motivates the use of informative outlier mining for OOD detection . To establish formal guarantees , we use a Gaussian data model to model data PX , QX , and UX . Different from previous work by Schmidt et al . ( 2018 ) and Carmon et al . ( 2019 ) , our analysis gives rise to a separation result with or without informative outlier mining for OOD detection . To this end , we note that while hard negative mining has been explored in different domains of learning ( e.g . object detection , deep metric learning , please refer to Section 6 for details ) , the vast literature of out-of-distribution detection has not explored this idea . Moreover , most uses of hard negative mining are on a heuristic basis , but in our case , the simplicity of the definition of OOD ( see Section 2 ) allows us to derive precise formal guarantees , which further differs us from previous studies of hard negative mining . As a remark , our analysis also establishes formal evidence of the importance of using auxiliary outlier data for OOD detection , which is lacking in the current OOD detection studies . We refer readers to Section A for these results . At a high level , our analysis provides two important insights : ( 1 ) First , we show that a detection algorithm can work very well if all data is informative ; yet it can fail completely in a natural setting where we mix informative auxiliary data with non-informative auxiliary data . ( 2 ) Second , we show that , tweaking the algorithm with simple thresholding to choose mildly hard auxiliary data ( in our setting they are exactly the informative ones ) , can lead to good detection performance . Combining both thus provides direct evidence about the importance of hard negative mining for OOD . Gaussian Data Model . We now describe the Gaussian data model , inspired by the model in ( Schmidt et al. , 2018 ; Carmon et al. , 2019 ) , but with important adjustment to the OOD detection setting . In particular , our setting has a family Q of possible test OOD distributions and have only indistribution data for training , modeling that the test OOD distribution is unknown for training . Given µ ∈ Rd , σ > 0 , ν > 0 , we consider the following model : • PX ( in-distribution data ) : N ( µ , σ2I ) ; The in-distribution data { xi } ni=1 is drawn from PX . • QX ( out-of-distribution data ) can be any distribution from the family Q = { N ( −µ + v , σ2I ) : v ∈ Rd , ‖v‖2 ≤ ν } . 1Due to lack of space , proofs are deferred to Appendix A . • Hypothesis class of OOD detector : G = { Gθ ( x ) = sign ( θ > x ) : θ ∈ Rd } . A concrete instance of the model is defined by a set of parameter values for d , µ , σ , and ν ; see Appendix A.2 for the family of instances we analyze . While the Gaussian model may be much simpler than the practical data , its simplicity is desirable for our analytical purpose for demonstrating the insights . Furthermore , the analysis in this simple model has implications for more complicated and practical methods , which we present in Section 4 . Finally , the analysis can be generalized to mixtures of Gaussians which models practical data much better . Below , we consider the FNR and the FPR under ` ∞ perturbations of magnitude . Since QX is not accessible at training time , our goal is to bound supQX∈Q FPR ( G ; QX , Ω∞ , ( x ) ) . Failing a good detector by mixing non-informative auxiliary data . We start by considering the case where all auxiliary data are informative : That is , all auxiliary { x′i } n ′ i=1 come from uniform mixture of the possible test OOD distributions in Q . In this case , it is straightforward to show that a simple averaging-based detector , θ̂n , n′ = 1 n+ n′ n∑ i=1 xi − n′∑ i=1 x̃i , ( 2 ) performs very well ( See Proposition 4 in the appendix ) . Unfortunately , this detector can be easily failed by considering the following simple auxiliary data distribution Umix , which mixes the ideal auxiliary data with non-informative data • Umix ( Non-ideal mixture ) : Umix is a uniform mixture of N ( −µ , σ2I ) and N ( µo , σ2I ) with µo = 10µ . Importantly , the distribution Umix models the case where the auxiliary OOD data has some noninformative outliers , and also with a small probability mass of samples ( e.g. , tail of N ( −µ , σ2I ) ) in the support of in-distribution . In this case , the simple average method leads to E [ θ̂n , n′ ] = −7µ/4 with a large error , since θ̂n , n′ is misled by auxiliary data from N ( µo , σ2I ) or tail of N ( −µ , σ2I ) in the support of in-distribution . Fixing the detector with informative outlier mining . We now show an important modification to the detection algorithm by using informative outlier mining , which leads to good detection performance . Specifically , we first use in-distribution data to get an intermediate solution : θ̂int = 1 n ∑n i=1 xi . Then , we use a simple thresholding mechanism to only pick points with mild confidence scores , which removes non-informative outliers . Specifically , we only select outliers x̃ whose confidence scores f ( x̃ ) = 1/ ( 1 + e−x̃ > θ̂int/d ) fall in an interval [ a , b ] . The final solution θ̂om is −1 times the average of the selected outliers . We can prove the following : Proposition 1 . ( Error bound with outlier mining . ) For any ∈ ( 0 , 1/2 ) and any integer n0 > 0 , there exist a family of instances of the Gaussian data model such that the following is true . n′ auxiliary OOD data from Umix specified above . There exist thresholds a and b for θ̂om and a universal constant c > 0 such that if the number of in-distribution data n ≥ c ( n0 log d + √ dn0 ) and the number of auxiliary data n′ ≥ ( d+ n0 · 4 2 ) √ d/n0 , then θ̂om has small errors:2 Eθ̂omFNR ( Gθ̂om ) ≤ 10 −3 , Eθ̂om sup QX∈Q FPR ( Gθ̂om ; QX , Ω∞ , ( x ) ) ≤ 10 −3 . ( 3 ) Intuitively , the mining method removes the misleading points ( most points in N ( µo , σ2I ) and tail of N ( −µ , σ2I ) in the support of in-distribution ) . Outliers selected in this way are mostly informative and thus give an accurate final detector , which justifies outlier mining in the presence of non-informative data . If we compare this bound with that for the case without auxiliary data ( Proposition 3 ) , we can see that for sufficiently high dimension d , with the same amount of in-distribution data , any algorithm without outliers must fail but our outlier mining method can learn a good detector . We also note that our analysis and the result also hold for many other auxiliary data distributions Umix , and the particular Umix used here is for the simplicity of demonstration ; see the appendix for more discussions . In the following section , we design a practical algorithm based on this insight and present empirical evidence of its effectiveness . 2The error bound in the proposition can be made arbitrarily small and with high probability . The current bound is presented for simplicity . | In this paper the authors propose a method for training a classifier to be more effective at OOD (out of distribution) detection. Many OOD detection methods work by utilizing an auxiliary dataset as examples of OOD-ness. This is the approach taken in this paper and OOD is trained as being a k+1 classification class. When training the OOD class the proposed method allows for adversarial perturbation of the OOD examples to help improve training. This is a pretty common technique in deep learning, see for example "Deep Robust One Class Classification." Finally the main novelty of the method proposed by the authors is to sort a collection of OOD examples and sort according to the OOD score of the current model and use the "qNth" to be presented as OOD examples during the next epoch during training. The authors term this "Informative Outlier Mining." The authors demonstrate that this method works well experimentally. | SP:56ffc50ee9fad6bf28dc34d87e8fc42cf56fdc0f |
Informative Outlier Matters: Robustifying Out-of-distribution Detection Using Outlier Mining | 1 INTRODUCTION . Out-of-distribution ( OOD ) detection has become an indispensable part of building reliable open-world machine learning models ( Amodei et al. , 2016 ) . An OOD detector determines whether an input is from the same distribution as the training data , or a different distribution ( i.e. , out-of-distribution ) . The performance of the OOD detector is central for safety-critical applications such as autonomous driving ( Eykholt et al. , 2018 ) or rare disease identification ( Blauwkamp et al. , 2019 ) . Despite exciting progress made in OOD detection , previous methods mostly focused on clean OOD data ( Hendrycks & Gimpel , 2016 ; Liang et al. , 2018 ; Lee et al. , 2018 ; Lakshminarayanan et al. , 2017 ; Hendrycks et al. , 2018 ; Mohseni et al. , 2020 ) . Scant attention has been paid to the robustness aspect of OOD detection . Recent works ( Hein et al. , 2019 ; Sehwag et al. , 2019 ; Bitterwolf et al. , 2020 ) considered worst-case OOD detection under adversarial perturbations ( Papernot et al. , 2016 ; Goodfellow et al. , 2014 ; Biggio et al. , 2013 ; Szegedy et al. , 2013 ) . For example , an OOD image ( e.g. , mailbox ) can be perturbed to be misclassified by the OOD detector as in-distribution ( traffic sign data ) . Such an adversarial OOD example is then passed to the image classifier and trigger undesirable prediction and action ( e.g. , speed limit 70 ) . Therefore , it remains an important question to make out-of-distribution detection algorithms robust in the presence of small perturbations to OOD inputs . In this paper , we begin with formally formulating the task of robust OOD detection and providing theoretical analysis in a simple Gaussian data model . While recent OOD detection methods ( Hendrycks et al. , 2018 ; Hein et al. , 2019 ; Meinke & Hein , 2019 ; Mohseni et al. , 2020 ) have leveraged auxiliary OOD data , they often sample randomly uniformly from the auxiliary dataset . Contrary to the common practice , our analysis reveals a key insight that the majority of auxiliary OOD examples may not provide useful information to improve the decision boundary of OOD detector . Under a Gaussian model of the data , we theoretically show that using outlier mining significantly improves the error bound of OOD detector in the presence of non-informative auxiliary OOD data . Motivated by this insight , we propose Adversarial Training with informative Outlier Mining ( ATOM ) , which justifies the theoretical intuitions above and achieves state-of-the-art performance on a broad family of classic and adversarial OOD evaluation tasks for modern neural networks . We show that , by carefully choosing which OOD data to train on , one can significantly improve the robustness of an OOD detector , and somewhat surprisingly , generalize to unseen adversarial attacks . We note that while hard negative mining has been extensively used in various learning tasks such as object recognition ( Felzenszwalb et al. , 2009 ; Gidaris & Komodakis , 2015 ; Shrivastava et al. , 2016 ) , to the best of our knowledge , we are the first to exploit the novel connection between hard example mining and OOD detection . We show both empirically and theoretically that hard example mining significantly improves the generalization and robustness of OOD detection . To evaluate our method , we provide a unified framework that allows examining the robustness of OOD detection algorithms under a broad family of OOD inputs , as illustrated in Figure 1 . Our evaluation includes existing classic OOD evaluation task – Natural OOD , and adversarial OOD evaluation task – L∞ OOD . Besides , we also introduce new adversarial OOD evaluation tasks – Corruption OOD and Compositional OOD . Under these evaluation tasks , ATOM achieves state-ofthe-art performance compared to eight competitive OOD detection methods ( refer to Appendix B.3 for a detailed description of these methods ) . On the Natural OOD evaluation task , ATOM achieves comparable and often better performance than current state-of-the-art methods . On L∞ OOD evaluation task , ATOM outperforms current state-of-the-art method ACET by a large margin ( e.g . on CIFAR-10 , outperforms it by 53.9 % ) . Under the new Corruption OOD evaluation task , where the attack is unknown during training time , ATOM also achieves much better results than previous methods ( e.g . on CIFAR-10 , outperform previous best method by 30.99 % ) . While almost every method fails under the hardest Compositional OOD evaluation task , ATOM still achieves impressive results ( e.g . on CIFAR-10 , reduce the FPR by 57.99 % ) . The performance is noteworthy since ATOM is not trained explicitly on corrupted OOD inputs . In summary , our contributions are : • Firstly , we contribute theoretical analysis formalizing the intuition of mining hard outliers for improving the robustness of OOD detection . • Secondly , we contribute a theoretically motivated method , ATOM , which leads to state-of- the-art performance on both classic and adversarial OOD evaluation tasks . We conduct extensive evaluations and ablation analysis to demonstrate the effectiveness of informative outlier mining . • Lastly , we provide a unified evaluation framework that allows future research examining the robustness of OOD detection algorithms under a broad family of OOD inputs . 2 PRELIMINARIES . In this section , we formulate the problem of robust out-of-distribution detection , and provide background knowledge on the use of auxiliary data for OOD detection . Problem Statement . We consider a training dataset Dtrainin drawn i.i.d . from a data distribution PX , Y , where X is the sample space and Y = { 1 , 2 , · · · , K } is the set of labels . A classifier f ( x ) is trained on the in-distribution , PX , the marginal distribution of PX , Y . The OOD examples are revealed during test time , which are from a different distribution QX , potentially with perturbations added . The task of robust out-of-distribution detection is to learn a detector G : x→ { −1 , 1 } , which outputs 1 for x from PX and output −1 for a clean or perturbed OOD example x from QX . Formally , let Ω ( x ) be a set of small perturbations on an OOD example x . The detector is evaluated on x from PX and on the worst-case input inside Ω ( x ) for an OOD example from QX . The false negative rate ( FNR ) and false positive rate ( FPR ) are defined as : FNR ( G ) = Ex∼PXI [ G ( x ) = −1 ] , FPR ( G ; QX , Ω ) = Ex∼QX max δ∈Ω ( x ) I [ G ( x + δ ) = 1 ] . ( 1 ) Note that no data from the test OOD distribution QX are available for training . Use of Auxiliary Data for OOD Detection While it is impossible to anticipate the test OOD data distributions QX for training , recent works ( Hendrycks et al. , 2018 ; Hein et al. , 2019 ; Meinke & Hein , 2019 ; Mohseni et al. , 2020 ; Liu et al. , 2020 ) have shown the promise using auxiliary data as a proxy for estimating the decision boundary between in- vs. OOD data . The idea is illustrated in Figure 1 , where outlier data is randomly sampled to regularize the model outputs ( e.g. , low confidence for OOD data and high confidence for in-distribution data ) . Formally , we assume the auxiliary OOD dataset Dauxiliaryout is sampled from a different distribution UX . The difference between the auxiliary data UX and test OOD data PX raises the fundamental question of how to effectively leverage Dauxiliaryout for improving learning the decision boundary between in- vs. OOD data . 3 THEORETICAL ANALYSIS : INFORMATIVE OUTLIERS MATTER . In this section , we present a theoretical analysis1 that motivates the use of informative outlier mining for OOD detection . To establish formal guarantees , we use a Gaussian data model to model data PX , QX , and UX . Different from previous work by Schmidt et al . ( 2018 ) and Carmon et al . ( 2019 ) , our analysis gives rise to a separation result with or without informative outlier mining for OOD detection . To this end , we note that while hard negative mining has been explored in different domains of learning ( e.g . object detection , deep metric learning , please refer to Section 6 for details ) , the vast literature of out-of-distribution detection has not explored this idea . Moreover , most uses of hard negative mining are on a heuristic basis , but in our case , the simplicity of the definition of OOD ( see Section 2 ) allows us to derive precise formal guarantees , which further differs us from previous studies of hard negative mining . As a remark , our analysis also establishes formal evidence of the importance of using auxiliary outlier data for OOD detection , which is lacking in the current OOD detection studies . We refer readers to Section A for these results . At a high level , our analysis provides two important insights : ( 1 ) First , we show that a detection algorithm can work very well if all data is informative ; yet it can fail completely in a natural setting where we mix informative auxiliary data with non-informative auxiliary data . ( 2 ) Second , we show that , tweaking the algorithm with simple thresholding to choose mildly hard auxiliary data ( in our setting they are exactly the informative ones ) , can lead to good detection performance . Combining both thus provides direct evidence about the importance of hard negative mining for OOD . Gaussian Data Model . We now describe the Gaussian data model , inspired by the model in ( Schmidt et al. , 2018 ; Carmon et al. , 2019 ) , but with important adjustment to the OOD detection setting . In particular , our setting has a family Q of possible test OOD distributions and have only indistribution data for training , modeling that the test OOD distribution is unknown for training . Given µ ∈ Rd , σ > 0 , ν > 0 , we consider the following model : • PX ( in-distribution data ) : N ( µ , σ2I ) ; The in-distribution data { xi } ni=1 is drawn from PX . • QX ( out-of-distribution data ) can be any distribution from the family Q = { N ( −µ + v , σ2I ) : v ∈ Rd , ‖v‖2 ≤ ν } . 1Due to lack of space , proofs are deferred to Appendix A . • Hypothesis class of OOD detector : G = { Gθ ( x ) = sign ( θ > x ) : θ ∈ Rd } . A concrete instance of the model is defined by a set of parameter values for d , µ , σ , and ν ; see Appendix A.2 for the family of instances we analyze . While the Gaussian model may be much simpler than the practical data , its simplicity is desirable for our analytical purpose for demonstrating the insights . Furthermore , the analysis in this simple model has implications for more complicated and practical methods , which we present in Section 4 . Finally , the analysis can be generalized to mixtures of Gaussians which models practical data much better . Below , we consider the FNR and the FPR under ` ∞ perturbations of magnitude . Since QX is not accessible at training time , our goal is to bound supQX∈Q FPR ( G ; QX , Ω∞ , ( x ) ) . Failing a good detector by mixing non-informative auxiliary data . We start by considering the case where all auxiliary data are informative : That is , all auxiliary { x′i } n ′ i=1 come from uniform mixture of the possible test OOD distributions in Q . In this case , it is straightforward to show that a simple averaging-based detector , θ̂n , n′ = 1 n+ n′ n∑ i=1 xi − n′∑ i=1 x̃i , ( 2 ) performs very well ( See Proposition 4 in the appendix ) . Unfortunately , this detector can be easily failed by considering the following simple auxiliary data distribution Umix , which mixes the ideal auxiliary data with non-informative data • Umix ( Non-ideal mixture ) : Umix is a uniform mixture of N ( −µ , σ2I ) and N ( µo , σ2I ) with µo = 10µ . Importantly , the distribution Umix models the case where the auxiliary OOD data has some noninformative outliers , and also with a small probability mass of samples ( e.g. , tail of N ( −µ , σ2I ) ) in the support of in-distribution . In this case , the simple average method leads to E [ θ̂n , n′ ] = −7µ/4 with a large error , since θ̂n , n′ is misled by auxiliary data from N ( µo , σ2I ) or tail of N ( −µ , σ2I ) in the support of in-distribution . Fixing the detector with informative outlier mining . We now show an important modification to the detection algorithm by using informative outlier mining , which leads to good detection performance . Specifically , we first use in-distribution data to get an intermediate solution : θ̂int = 1 n ∑n i=1 xi . Then , we use a simple thresholding mechanism to only pick points with mild confidence scores , which removes non-informative outliers . Specifically , we only select outliers x̃ whose confidence scores f ( x̃ ) = 1/ ( 1 + e−x̃ > θ̂int/d ) fall in an interval [ a , b ] . The final solution θ̂om is −1 times the average of the selected outliers . We can prove the following : Proposition 1 . ( Error bound with outlier mining . ) For any ∈ ( 0 , 1/2 ) and any integer n0 > 0 , there exist a family of instances of the Gaussian data model such that the following is true . n′ auxiliary OOD data from Umix specified above . There exist thresholds a and b for θ̂om and a universal constant c > 0 such that if the number of in-distribution data n ≥ c ( n0 log d + √ dn0 ) and the number of auxiliary data n′ ≥ ( d+ n0 · 4 2 ) √ d/n0 , then θ̂om has small errors:2 Eθ̂omFNR ( Gθ̂om ) ≤ 10 −3 , Eθ̂om sup QX∈Q FPR ( Gθ̂om ; QX , Ω∞ , ( x ) ) ≤ 10 −3 . ( 3 ) Intuitively , the mining method removes the misleading points ( most points in N ( µo , σ2I ) and tail of N ( −µ , σ2I ) in the support of in-distribution ) . Outliers selected in this way are mostly informative and thus give an accurate final detector , which justifies outlier mining in the presence of non-informative data . If we compare this bound with that for the case without auxiliary data ( Proposition 3 ) , we can see that for sufficiently high dimension d , with the same amount of in-distribution data , any algorithm without outliers must fail but our outlier mining method can learn a good detector . We also note that our analysis and the result also hold for many other auxiliary data distributions Umix , and the particular Umix used here is for the simplicity of demonstration ; see the appendix for more discussions . In the following section , we design a practical algorithm based on this insight and present empirical evidence of its effectiveness . 2The error bound in the proposition can be made arbitrarily small and with high probability . The current bound is presented for simplicity . | 1. The paper presents a lot of theory but insufficient evidence. It only employs limited image data (SVHN, CIFAR variants). The paper should be clear that the scope is limited to well-known image datasets only. This is because the approach is dependent on auxiliary data which is available for the image datasets. It is not clear if the approach might be more generally applicable to (say) network traffic, credit card transactions, natural language, etc. It would be better to include other types of data and along with auxiliary data generated through more generic means. | SP:56ffc50ee9fad6bf28dc34d87e8fc42cf56fdc0f |
Sparsifying Networks via Subdifferential Inclusion | 1 INTRODUCTION . Deep neural networks have evolved to the state-of-the-art techniques in a wide array of applications : computer vision ( Simonyan & Zisserman , 2015 ; He et al. , 2016 ; Huang et al. , 2017 ) , automatic speech recognition ( Hannun et al. , 2014 ; Dong et al. , 2018 ; Li et al. , 2019 ; Watanabe et al. , 2018 ; Hayashi et al. , 2019 ; Inaguma et al. , 2020 ) , natural language processing ( Turc et al. , 2019 ; Radford et al. , 2019 ; Dai et al. , 2019b ; Brown et al. , 2020 ) , and time series forecasting ( Oreshkin et al. , 2020 ) . While their performance in various applications has matched and often exceeded human capabilities , neural networks may remain difficult to apply in real-world scenarios . Deep neural networks leverage the power of Graphical Processing Units ( GPUs ) , which are power-hungry . Using GPUs to make billions of predictions per day , thus comes with a substantial energy cost . In addition , despite their quite fast response time , deep neural networks are not yet suitable for most real-time applications where memory-limited low-cost architectures need to be used . For all those reasons , compression and efficiency have become a topic of high interest in the deep learning community . Sparsity in DNNs has been an active research topic generating numerous approaches . DNNs achieving the state-of-the-art in a given problem usually have a large number of layers with non-uniform parameter distribution across layers . Most sparsification methods are based on a global approach , which may result in a sub-optimal compression for a reduced accuracy . This may occur because layers with a smaller number of parameters may remain dense , although they may contribute more in terms of computational complexity ( e.g. , for convolutional layers ) . Some methods , also known as magnitude pruning , use a hard or soft-thresholding to remove less significant parameters . Soft thresholding techniques achieve a good sparsity-accuracy trade-off at the cost of additional parameters and increased computation time during training . Searching for a hardware efficient network is another area that has been proven quite useful , but it requires a huge amount of computational resources . Convex optimization techniques such as those used in ( Aghasi et al. , 2017 ) often rely upon fixed point iterations that make use of the proximity operator ( Moreau , 1962 ) . The related concepts are fundamental for tackling nonlinear problems and have recently come into play in the analysis of neural networks ( Combettes & Pesquet , 2020a ) and nonlinear systems ( Combettes & Woodstock , 2020 ) . This paper shows that the properties of nonlinear activation functions can be utilized to identify highly sparse subnetworks . We show that the sparsification of a network can be formulated as an approximate subdifferential inclusion problem . We provide an iterative algorithm called subdifferential inclusion for sparsity ( SIS ) that uses partial training data to identify a sparse subnetwork while maintaining good accuracy . SIS makes even small-parameter layers sparse , resulting in models with significantly lower inference FLOPs than the baselines . For example , SIS for 90 % sparse MobileNetV3 on ImageNet-1K achieves 66.07 % top-1 accuracy with 33 % fewer inference FLOPs than its dense counterpart and thus provides better results than the state-of-the-art method RigL . For non-convolutional networks like Transformer-XL trained on WikiText-103 , SIS is able to achieve 70 % sparsity while maintaining 21.1 perplexity score . We evaluate our approach across four domains and show that our compressed networks can achieve competitive accuracy for potential use on commodity hardware and edge devices . 2 RELATED WORK . 2.1 INDUCING SPARSITY POST TRAINING . Methods inducing sparsity after a dense network is trained involve several pruning and fine-tuning cycles till desired sparsity and accuracy are reached ( Mozer & Smolensky , 1989 ; LeCun et al. , 1990 ; Hassibi et al. , 1993 ; Han et al. , 2015 ; Molchanov et al. , 2017 ; Guo et al. , 2016 ; Park et al. , 2020 ) . ( Renda et al. , 2020 ) proposed weight rewinding technique instead of vanilla fine-tuning post-pruning . Net-Trim algorithm ( Aghasi et al. , 2017 ) removes connections at each layer of a trained network by convex programming . The proposed method works for networks using rectified linear units ( ReLUs ) . Lowering rank of parameter tensors ( Jaderberg et al. , 2014 ; vahid et al. , 2020 ; Lu et al. , 2016 ) , removing channels , filters and inducing group sparsity ( Wen et al. , 2016 ; Li et al. , 2017 ; Luo et al. , 2017 ; Gordon et al. , 2018 ; Yu et al. , 2019 ; Liebenwein et al. , 2020 ) are some methods that take network structure into account . All these methods rely on pruning and fine-tuning cycle ( s ) often from full training data . 2.2 INDUCING SPARSITY DURING TRAINING . Another popular approach has been to induce sparsity during training . This can be achieved by modifying the loss function to consider sparsity as part of the optimization ( Chauvin , 1989 ; CarreiraPerpiñán & Idelbayev , 2018 ; Ullrich et al. , 2017 ; Neklyudov et al. , 2017 ) . Dynamically pruning during training ( Zhu & Gupta , 2018 ; Bellec et al. , 2018 ; Mocanu et al. , 2018 ; Dai et al. , 2019a ; Lin et al. , 2020b ) by observing network flow . ( Mostafa & Wang , 2019 ; Dettmers & Zettlemoyer , 2020 ; Evci et al. , 2020 ) computes weight magnitude and reallocates weights at every step . Bayesian priors ( Louizos et al. , 2017 ) , L0 , L1 regularization ( Louizos et al. , 2018 ) , and variational dropout ( Molchanov et al. , 2017 ) get accuracy comparable to ( Zhu & Gupta , 2018 ) but at a cost of 2×memory and 4× computations during training . ( Liu et al. , 2019 ; Savarese et al. , 2020 ; Kusupati et al. , 2020 ; Lee , 2019 ; Xiao et al. , 2019 ; Azarian et al. , 2020 ) have proposed learnable sparsity methods through training of the sparse masks and weights simultaneously with minimal heuristics . Although these methods are cheaper than pruning after training , they need at least the same computational effort as training a dense network to find a sparse sub-network . This makes them expensive when compressing big networks where the number of parameters ranges from hundreds of millions to billions ( Dai et al. , 2019b ; Li et al. , 2019 ; Brown et al. , 2020 ) . 2.3 TRAINING SPARSELY INITIALIZED NETWORKS . ( Frankle & Carbin , 2019 ) showed that it is possible to find sparse sub-networks that , when trained from scratch , were able to match or even outperform their dense counterparts . ( Lee et al. , 2019 ) presented SNIP , a method to estimate , at initialization , the importance that each weight could have later during training . In ( Lee et al. , 2020 ) the authors perform a theoretical study of pruning at initialization from a signal propagation perspective , focusing on the initialization scheme . Recently , ( Wang et al. , 2020 ) proposed GraSP , a different method based on the gradient norm after pruning , and showed a significant improvement for moderate levels of sparsity . ( Ye et al. , 2020 ) starts with a small subnetwork and progressively grow it to a subnetwork that is as accurate as its dense counterpart . ( Tanaka et al. , 2020 ) proposes SynFlow that avoids flow collapse of a pruned network during training . ( Jorge et al. , 2020 ) proposed FORCE , an iterative pruning method that progressively removes a small number of weights . This method is able to achieve extreme sparsity at little accuracy expense . These methods are not usable for big pre-trained networks and are expensive as multiple training rounds are required for different sparse models depending on deployment scenarios ( computing devices ) . 2.4 EFFICIENT NEURAL ARCHITECTURE SEARCH . Hardware-aware NAS methods ( Zoph et al. , 2018 ; Real et al. , 2019 ; Cai et al. , 2018 ; Wu et al. , 2019 ; Tan et al. , 2019 ; Cai et al. , 2019 ; Howard et al. , 2019 ) directly incorporate the hardware feedback into efficient neural architecture search . ( Cai et al. , 2020 ) proposes to learn a single network composing of a large number of subnetworks from which a hardware aware subnetwork can be extracted in linear time . ( Lin et al. , 2020a ) proposes a similar approach wherein they identify subnetworks that can be run efficiently on microcontrollers ( MCUs ) . Our proposed algorithm applies to possibly large pre-trained networks . In contrast with methods presented in Section 2.1 , ours can use a small amount of training data during pruning and fewer epochs during fine-tuning . As we will see in the next section , a key feature of our approach is that it is based on a fine analysis of the mathematical properties of activation functions , so allowing the use of powerful convex optimization tools that offer sound convergence guarantees . 3 PROPOSED METHOD . 3.1 VARIATIONAL PRINCIPLES . A basic neural network layer can be described by the relation : y = R ( Wx+ b ) ( 1 ) where x ∈ RM is the input , y ∈ RN the output , W ∈ RN×M is the weight matrix , b ∈ RN the bias vector , and R is a nonlinear activation operator from RN to RN . A key observation is that most of the activation operators currently used in neural networks are proximity operators of convex functions ( Combettes & Pesquet , 2020a ; b ) . We will therefore assume that there exists a proper lower-semicontinuous convex function f from RN to R ∪ { +∞ } such that R = proxf . We recall that f is a proper lower-semicontinuous convex function if the area overs its graph , its epigraph { ( y , ξ ) ∈ RN × R ∣∣ f ( y ) 6 ξ } , is a nonempty closed convex set . For such a function the proximity operator of f at z ∈ RN ( Moreau , 1962 ) is the unique point defined as proxf ( z ) = argmin p∈RN 1 2 ‖z − p‖2 + f ( p ) . ( 2 ) It follows from standard subdifferential calculus that Eq . ( 1 ) can be re-expressed as the following inclusion relation : Wx+ b− y ∈ ∂f ( y ) , ( 3 ) where ∂f ( y ) is the Moreau subdifferential of f at y defined as ∂f ( y ) = { t ∈ RN ∣∣ ( ∀z ∈ RN ) f ( z ) > f ( y ) + 〈t | z − y〉 } . ( 4 ) The subdifferential constitutes a useful extension of the notion of differential , which is applicable to nonsmooth functions . The set ∂f ( y ) is closed and convex and , if y satisfies Eq . ( 1 ) , it is nonempty . The distance to this set of a point z ∈ RN is given by d∂f ( y ) ( z ) = inf t∈∂f ( y ) ‖z − t‖ . ( 5 ) We thus see that the subdifferential inclusion in Eq . ( 3 ) is also equivalent to d∂f ( y ) ( Wx+ b− y ) = 0 . ( 6 ) Therefore , a suitable accuracy measure for approximated values of the layer parameters ( W , b ) is d∂f ( y ) ( Wx+ b− y ) . | The paper propose a network compression algorithm by exploiting a reformulation of activation function as proximity operator. The latter is an optimization problem whose optimality condition reveals constraints on the weight matrix W of the neural net. The main idea is then to "biasedly" select W as a minimizer of a sparsity inducing penalties under a relaxation of the previous optimality conditions. The authors provide details on solving such problem as well as numerical experiments that leads to similar results than competitors. | SP:797a59091f5ce57f264400b8fa7e0b485584338c |
Sparsifying Networks via Subdifferential Inclusion | 1 INTRODUCTION . Deep neural networks have evolved to the state-of-the-art techniques in a wide array of applications : computer vision ( Simonyan & Zisserman , 2015 ; He et al. , 2016 ; Huang et al. , 2017 ) , automatic speech recognition ( Hannun et al. , 2014 ; Dong et al. , 2018 ; Li et al. , 2019 ; Watanabe et al. , 2018 ; Hayashi et al. , 2019 ; Inaguma et al. , 2020 ) , natural language processing ( Turc et al. , 2019 ; Radford et al. , 2019 ; Dai et al. , 2019b ; Brown et al. , 2020 ) , and time series forecasting ( Oreshkin et al. , 2020 ) . While their performance in various applications has matched and often exceeded human capabilities , neural networks may remain difficult to apply in real-world scenarios . Deep neural networks leverage the power of Graphical Processing Units ( GPUs ) , which are power-hungry . Using GPUs to make billions of predictions per day , thus comes with a substantial energy cost . In addition , despite their quite fast response time , deep neural networks are not yet suitable for most real-time applications where memory-limited low-cost architectures need to be used . For all those reasons , compression and efficiency have become a topic of high interest in the deep learning community . Sparsity in DNNs has been an active research topic generating numerous approaches . DNNs achieving the state-of-the-art in a given problem usually have a large number of layers with non-uniform parameter distribution across layers . Most sparsification methods are based on a global approach , which may result in a sub-optimal compression for a reduced accuracy . This may occur because layers with a smaller number of parameters may remain dense , although they may contribute more in terms of computational complexity ( e.g. , for convolutional layers ) . Some methods , also known as magnitude pruning , use a hard or soft-thresholding to remove less significant parameters . Soft thresholding techniques achieve a good sparsity-accuracy trade-off at the cost of additional parameters and increased computation time during training . Searching for a hardware efficient network is another area that has been proven quite useful , but it requires a huge amount of computational resources . Convex optimization techniques such as those used in ( Aghasi et al. , 2017 ) often rely upon fixed point iterations that make use of the proximity operator ( Moreau , 1962 ) . The related concepts are fundamental for tackling nonlinear problems and have recently come into play in the analysis of neural networks ( Combettes & Pesquet , 2020a ) and nonlinear systems ( Combettes & Woodstock , 2020 ) . This paper shows that the properties of nonlinear activation functions can be utilized to identify highly sparse subnetworks . We show that the sparsification of a network can be formulated as an approximate subdifferential inclusion problem . We provide an iterative algorithm called subdifferential inclusion for sparsity ( SIS ) that uses partial training data to identify a sparse subnetwork while maintaining good accuracy . SIS makes even small-parameter layers sparse , resulting in models with significantly lower inference FLOPs than the baselines . For example , SIS for 90 % sparse MobileNetV3 on ImageNet-1K achieves 66.07 % top-1 accuracy with 33 % fewer inference FLOPs than its dense counterpart and thus provides better results than the state-of-the-art method RigL . For non-convolutional networks like Transformer-XL trained on WikiText-103 , SIS is able to achieve 70 % sparsity while maintaining 21.1 perplexity score . We evaluate our approach across four domains and show that our compressed networks can achieve competitive accuracy for potential use on commodity hardware and edge devices . 2 RELATED WORK . 2.1 INDUCING SPARSITY POST TRAINING . Methods inducing sparsity after a dense network is trained involve several pruning and fine-tuning cycles till desired sparsity and accuracy are reached ( Mozer & Smolensky , 1989 ; LeCun et al. , 1990 ; Hassibi et al. , 1993 ; Han et al. , 2015 ; Molchanov et al. , 2017 ; Guo et al. , 2016 ; Park et al. , 2020 ) . ( Renda et al. , 2020 ) proposed weight rewinding technique instead of vanilla fine-tuning post-pruning . Net-Trim algorithm ( Aghasi et al. , 2017 ) removes connections at each layer of a trained network by convex programming . The proposed method works for networks using rectified linear units ( ReLUs ) . Lowering rank of parameter tensors ( Jaderberg et al. , 2014 ; vahid et al. , 2020 ; Lu et al. , 2016 ) , removing channels , filters and inducing group sparsity ( Wen et al. , 2016 ; Li et al. , 2017 ; Luo et al. , 2017 ; Gordon et al. , 2018 ; Yu et al. , 2019 ; Liebenwein et al. , 2020 ) are some methods that take network structure into account . All these methods rely on pruning and fine-tuning cycle ( s ) often from full training data . 2.2 INDUCING SPARSITY DURING TRAINING . Another popular approach has been to induce sparsity during training . This can be achieved by modifying the loss function to consider sparsity as part of the optimization ( Chauvin , 1989 ; CarreiraPerpiñán & Idelbayev , 2018 ; Ullrich et al. , 2017 ; Neklyudov et al. , 2017 ) . Dynamically pruning during training ( Zhu & Gupta , 2018 ; Bellec et al. , 2018 ; Mocanu et al. , 2018 ; Dai et al. , 2019a ; Lin et al. , 2020b ) by observing network flow . ( Mostafa & Wang , 2019 ; Dettmers & Zettlemoyer , 2020 ; Evci et al. , 2020 ) computes weight magnitude and reallocates weights at every step . Bayesian priors ( Louizos et al. , 2017 ) , L0 , L1 regularization ( Louizos et al. , 2018 ) , and variational dropout ( Molchanov et al. , 2017 ) get accuracy comparable to ( Zhu & Gupta , 2018 ) but at a cost of 2×memory and 4× computations during training . ( Liu et al. , 2019 ; Savarese et al. , 2020 ; Kusupati et al. , 2020 ; Lee , 2019 ; Xiao et al. , 2019 ; Azarian et al. , 2020 ) have proposed learnable sparsity methods through training of the sparse masks and weights simultaneously with minimal heuristics . Although these methods are cheaper than pruning after training , they need at least the same computational effort as training a dense network to find a sparse sub-network . This makes them expensive when compressing big networks where the number of parameters ranges from hundreds of millions to billions ( Dai et al. , 2019b ; Li et al. , 2019 ; Brown et al. , 2020 ) . 2.3 TRAINING SPARSELY INITIALIZED NETWORKS . ( Frankle & Carbin , 2019 ) showed that it is possible to find sparse sub-networks that , when trained from scratch , were able to match or even outperform their dense counterparts . ( Lee et al. , 2019 ) presented SNIP , a method to estimate , at initialization , the importance that each weight could have later during training . In ( Lee et al. , 2020 ) the authors perform a theoretical study of pruning at initialization from a signal propagation perspective , focusing on the initialization scheme . Recently , ( Wang et al. , 2020 ) proposed GraSP , a different method based on the gradient norm after pruning , and showed a significant improvement for moderate levels of sparsity . ( Ye et al. , 2020 ) starts with a small subnetwork and progressively grow it to a subnetwork that is as accurate as its dense counterpart . ( Tanaka et al. , 2020 ) proposes SynFlow that avoids flow collapse of a pruned network during training . ( Jorge et al. , 2020 ) proposed FORCE , an iterative pruning method that progressively removes a small number of weights . This method is able to achieve extreme sparsity at little accuracy expense . These methods are not usable for big pre-trained networks and are expensive as multiple training rounds are required for different sparse models depending on deployment scenarios ( computing devices ) . 2.4 EFFICIENT NEURAL ARCHITECTURE SEARCH . Hardware-aware NAS methods ( Zoph et al. , 2018 ; Real et al. , 2019 ; Cai et al. , 2018 ; Wu et al. , 2019 ; Tan et al. , 2019 ; Cai et al. , 2019 ; Howard et al. , 2019 ) directly incorporate the hardware feedback into efficient neural architecture search . ( Cai et al. , 2020 ) proposes to learn a single network composing of a large number of subnetworks from which a hardware aware subnetwork can be extracted in linear time . ( Lin et al. , 2020a ) proposes a similar approach wherein they identify subnetworks that can be run efficiently on microcontrollers ( MCUs ) . Our proposed algorithm applies to possibly large pre-trained networks . In contrast with methods presented in Section 2.1 , ours can use a small amount of training data during pruning and fewer epochs during fine-tuning . As we will see in the next section , a key feature of our approach is that it is based on a fine analysis of the mathematical properties of activation functions , so allowing the use of powerful convex optimization tools that offer sound convergence guarantees . 3 PROPOSED METHOD . 3.1 VARIATIONAL PRINCIPLES . A basic neural network layer can be described by the relation : y = R ( Wx+ b ) ( 1 ) where x ∈ RM is the input , y ∈ RN the output , W ∈ RN×M is the weight matrix , b ∈ RN the bias vector , and R is a nonlinear activation operator from RN to RN . A key observation is that most of the activation operators currently used in neural networks are proximity operators of convex functions ( Combettes & Pesquet , 2020a ; b ) . We will therefore assume that there exists a proper lower-semicontinuous convex function f from RN to R ∪ { +∞ } such that R = proxf . We recall that f is a proper lower-semicontinuous convex function if the area overs its graph , its epigraph { ( y , ξ ) ∈ RN × R ∣∣ f ( y ) 6 ξ } , is a nonempty closed convex set . For such a function the proximity operator of f at z ∈ RN ( Moreau , 1962 ) is the unique point defined as proxf ( z ) = argmin p∈RN 1 2 ‖z − p‖2 + f ( p ) . ( 2 ) It follows from standard subdifferential calculus that Eq . ( 1 ) can be re-expressed as the following inclusion relation : Wx+ b− y ∈ ∂f ( y ) , ( 3 ) where ∂f ( y ) is the Moreau subdifferential of f at y defined as ∂f ( y ) = { t ∈ RN ∣∣ ( ∀z ∈ RN ) f ( z ) > f ( y ) + 〈t | z − y〉 } . ( 4 ) The subdifferential constitutes a useful extension of the notion of differential , which is applicable to nonsmooth functions . The set ∂f ( y ) is closed and convex and , if y satisfies Eq . ( 1 ) , it is nonempty . The distance to this set of a point z ∈ RN is given by d∂f ( y ) ( z ) = inf t∈∂f ( y ) ‖z − t‖ . ( 5 ) We thus see that the subdifferential inclusion in Eq . ( 3 ) is also equivalent to d∂f ( y ) ( Wx+ b− y ) = 0 . ( 6 ) Therefore , a suitable accuracy measure for approximated values of the layer parameters ( W , b ) is d∂f ( y ) ( Wx+ b− y ) . | In this paper the authors propose a new model compression method based on subdifferential inclusion. The key idea is to make the outputs of the neurons in the sparse and dense networks at the same input close enough. They rewrite the activation function as the proximity operator of a proper convex function and finally formulate the compression problem into a constraint minimization problem using the technique of subdifferential inclusion. They conduct a series of experiments to evaluate the performance of their proposed methods. | SP:797a59091f5ce57f264400b8fa7e0b485584338c |
Exploiting structured data for learning contagious diseases under incomplete testing | One of the ways that machine learning algorithms can help control the spread of an infectious disease is by building models that predict who is likely to get infected making them good candidates for preemptive interventions . In this work we ask : can we build reliable infection prediction models when the observed data is collected under limited , and biased testing that prioritizes testing symptomatic individuals ? Our analysis suggests that when the infection is highly contagious , incomplete testing might be sufficient to achieve good out-of-sample prediction error . Guided by this insight , we develop an algorithm that predicts infections , and show that it outperforms baselines on simulated data . We apply our model to data from a large hospital to predict Clostridioides difficile infections ; a communicable disease that is characterized by asymptomatic ( i.e. , untested ) carriers . Using a proxy instead of the unobserved untested-infected state , we show that our model outperforms benchmarks in predicting infections . 1 INTRODUCTION . Preemptively identifying individuals at a high risk of contracting a contagious infection is important for guiding treatment decisions to mitigate symptoms , and preventing further spread of the contagion . In this paper , we study how to build individual-level predictive models for contagious infections while explicitly addressing the challenges inherent to contagious diseases . Building accurate infection prediction models is hindered by two main factors . First , contagious infections defy the usual iid assumption central to most machine learning methods . This is because an individual ’ s infection state is not independent of their contacts ’ infection states . Previous work has often relied on expert knowledge to construct exposure proxies ( Wiens et al. , 2012 ; Oh et al. , 2018 ) . It is then assumed that conditional on the exposure proxy and individual characteristics , individual outcomes are independent of one another . Second , the observed data is biased due to incomplete testing . We use the term “ incomplete testing ” to describe the scenario where only a small , biased subset of infected individuals get tested . Such a scenario is ubiquitous in the context of contagious infections for several reasons . While many individuals carry the pathogen , only a fraction display symptoms . Even in the presence of unlimited testing resources , the latter are far more likely to get tested leading to biased data collection where individuals predisposed to displaying symptoms are over-represented . Incomplete testing makes learning accurate models difficult since the collected labels are missing not at random leading to biased , inconsistent estimates . In this work , we treat non-independence of outcomes as a blessing rather than a curse . Our proposed approach leverages the fact that an individual ’ s infection state provides useful information about their contacts ’ true infection states . This information is used to generate pseudo-labels for untested individuals , mitigating issues due to incomplete testing . The key idea behind our approach is that highly structured patterns of contagion transmission can serve as a complementary signal to identify even untested carriers . The stronger that signal is , the less impact that incomplete testing will have . Our contributions can be summarized as follows : ( 1 ) We identify two properties of the collected data that can be exploited to mitigate the effects of incomplete testing . ( 2 ) We propose an algorithm that leverages that insight to predict the probability of an untested individual carrying the disease . ( 3 ) We empirically evaluate the effectiveness of our method on both simulated data and real data for a common healthcare associated infection . We show that predictions from our model can be used to inform efficient testing and isolation policies . Using real data , we show that our model outperforms baselines in the task of predicting a hospital associated infection . 2 RELATED WORK . Infectious disease modeling . Modeling the transmission of infectious diseases has been extensively studied in the epidemiology literature using SIS/SIR models and several other variants ( Kermack & McKendrick , 1927 ) . These epidemiological models focus on the aggregate levels of infections in a community , which is distinct from our approach here where we focus on predicting individual level infections . In the machine learning literature , previous work has relied on proxies for exposure , e.g. , the prevalence of a disease in a community ( Wiens et al. , 2012 ; Oh et al. , 2018 ) , and implicitly assume that conditioning on individual characteristics . Similar to our approach , Fan et al . ( 2016 ) and Makar et al . ( 2018 ) take into account structured data , namely contact networks to compute infection estimates ( Fan et al. , 2016 ; Makar et al. , 2018 ) . We differ from these approachs in that ( 1 ) we do not make parametric assumptions about the joint distribution of the observed or latent variables , and instead use nonparametric models ( neural networks ) to model the infection states , ( 2 ) we do not assume all infections will become symptomatic as is done in Fan et al . ( 2016 ) , and ( 3 ) unlike the approach taken by Makar et al . ( 2018 ) , we model time evolving sequences of infections taking into account the exposure states of potential asymptomatic carriers . Semi-supervised learning . Our proposed approach relies on transductive reasoning to generate labels for untested individuals . In that , it is closely related to semi-supervised learning methods , such as pseudo-labeling ( Lee , 2003 ) , and self-training ( Robinson et al. , 2020 ) . However , in traditional pseudo-labeling , the transductive power comes from the fact that points similar to each other in the input space should have similar outputs . Here , the rich structure in the data allows for more : we can construct pseudo-labels for untested individuals not just by relying on their similarity to other labeled instances , but also by observing their observed contacts ’ infection states . Our empirical results , and analysis are similar in spirit to concepts presented in the semi-supervised literature , specifically the cluster assumption , which we discuss at length later ( Seeger , 2000 ; Rigollet , 2007 ) . Graph Neural Networks . Our proposed approach incorporates knowledge of the contact network . In that it is similar to Graph Neural Networks ( GNNs ) , which utilize relational data to generate prediction estimates ( Zhou et al. , 2018 ) . GNNs fall into two categories , the first relies on transductive reasoning and can not generalize to new communities ( e.g. , Kipf & Welling ( 2017 ) ) or inductive , which can be used to generate estimates for previously unseen graphs ( e.g. , Hamilton et al . ( 2017 ) ) . Our work is similar to the latter category with an important distinction : our approach leverages unlabeled data giving more accurate , and robust estimates . Our work can be viewed as combining the strengths of semi-supervised learning , and GNNs to address limited testing . In addition , our approach augments the strengths of those two approaches with ideas from domain shift , and causal inference such as importance weighting ( Cortes et al. , 2010 ) to address biased testing . 3 PROBLEM SETTING . Setup . Let yt ∈ { 0 , 1 } denote an individual ’ s true infection state at time t , with yt = 0 if an individual is not infected and 1 if they are . We use xt ∈ X t to denote a vector of the individual ’ s features at time t , and define J ti to be the set of indices of i ’ s contacts at time t. We assume that contact indices are known , i.e. , that the contact network is observed . Let eti ∈ R≥0 denote i ’ s exposure state , with eti = ∑ j∈Jti ytj . The exposure state is fully observed only when all of i ’ s contacts have been tested , but otherwise either partially observed or unobserved . Define xt = xt||et , where || as the concatenation operator , i.e. , xt ∈ X t × R≥0 . Let ot ∈ { 0 , 1 } denote the observation state , with ot = 1 if an individual ’ s label is observed , i.e. , if the individual has been tested for the infection . We use the super-script : t to denote variables from time t = 0 up to and including t , e.g. , x : t = [ x0 , ... , xs , ... , xt ] . Throughout , we use capital letters to denote variables , and small letters to denote their values . We use P ( Xt , Ot , Y t+1 ) to denote the unknown distribution over the full joint . Under biased testing , we have that P ( Xt|Ot = 1 ) 6= P ( Xt|Ot = 0 ) 6= P ( Xt ) . We assume that 0 < P ( Ot = o|Xt = x ) < 1 , for all x ∈ X , and o ∈ { 0 , 1 } . This is the same as the overlap assumption in causality literature . In addition , we assume that i ’ s outcome is independent of their contacts given xi , which is itself a function of the contacts ’ outcomes , we refer to this as the conditional independence assumption . We consider the case where we have access to ( 1 ) a labeled ( i.e. , tested ) set of individuals D1 = { Dt1 } Tt=0 = { ( xti , yti ) , . . . ( xtnt1 , y t nt1 ) } ∼ P ( Xt , Y t+1|Ot = 1 ) , and ( 2 ) an unlabeled ( untested ) set of individuals D0 = { Dt0 } Tt=0 = { xti , . . . , xtnt0 } ∼ P ( X t|Ot = 0 ) , such that for each i ∈ D0∪D1 , and each t ∈ [ 0 , T ] , we have that J ti ∈ D0∪D1 . It will also be convenient to use U t to denote the set of indices of untested individuals at time t. Learning objective . We are interested in learning f : x : T → yT+1 . To focus the discussion on the novel component of our approach , we consider a setting where we are only interested in predicting the outcomes for a single time step . It will be particularly useful to consider the task of making predictions for t = 2 , using data from t = 0 , 1 , dropping the time superscript when it can be inferred from the context . We present the full model predicting infection sequences over time in section 5 . Let ` be the logistic loss function . Our goal is to find f ∈ F , where F is some hypothesis space such that the risk of incorrectly classifying the infection state Rf = EX , Y [ ` ( f ( Xt ) , Y t+1 ) ] is minimized . We briefly consider a scenario where we have oracle access to the true exposure states but we return to the more realistic , non-oracle scenario later . Under the conditional independence assumption , we can break down the risk to the sum of independent losses . Define the inverse probability of being tested , wt ( X ) = P ( Ot = o ) /P ( Ot = o|Xt ) , following Robins ( 1998 ) , and Robins et al . ( 2000 ) . Due to the overlap assumption , and under biased testing , we have that : Rf = Rw t f = EX , Y |O=1 [ wt ( X ) ` ( f ( X ) , Y ) |O = 1 ] , ( 1 ) ( Cortes et al. , 2010 ) . The reweighted risk simply places a higher importance on the loss of individuals who are unlikely to be tested . Rwtf can not be directly computed since the expectation is defined with respect to the unobserved distribution . However , the following reweighted empirical loss is an unbiased estimator ofRwtf : ε ( f ) = ∑ i∈Dt1 wti ` ( f ( x t i ) , y t+1 i ) , by Cortes et al . ( 2008 ) , where wti = p ( O t = oti ) /g ( oti|x t i ) , p ( Ot = oti ) is the empirical estimate of P ( Ot = o ) , and g ( oti|xti ) is the estimated probability of getting tested conditional on individual characteristics . Without oracle access to exposure states , the samples xt ∼ P ( Xt|Ot = 1 ) are incomplete . This is because xti includes e t i , which is a function of y t j : j ∈ J ti . We only fully observe eti , and hence x t i for individuals whose contacts have all been tested . To address this , we define Q ( Dt1 ) , a set of partially imputed distributions that are consistent with the labeled samples . It is the set of all possible distributions over the ( partially ) unobserved eti . Our risk is now defined with respect to both Q , and f , and our task is to find Q and f , such that the following empirical risk is minimized : ε ( f , Q ) = ∑ i∈D1 ŵti ` ( f ( x̂ t i ) , y t+1 i ) , ( 2 ) where x̂ = xt||êt , and êti ∼ Q , and ŵti = p ( O = oi ) /g ( x̂i , oi ) . Minimizing this objective is prone to extreme overfitting . To see why , consider some Q that sets eti = 100 for every i : o t i = 1 , y t+1 i = 1 , and 0 for i : oti = 1 , y t+1 i = 0 . Since Q is essentially leaking the true label into the input space , it is trivial to find some f that takes in the imputed inputs , { ( xti , 100 , yt+1i ) } i : yt+1i =1 , and { ( xti , 0 , yt+1i ) } i : yt+1i =0 and gives perfect performance . Such an f is clearly expected to have poor generalization error . We next consider how to leverage existing properties of the problem as efficient regularizers . | This paper formulates the contagious disease into a missing label problem with dependence between each data point. The paper targets an important problem, especially in this pandemic, and the effort is greatly appreciated. However, the writing of this paper is confusing and it makes it hard to catch the main contribution of this paper. There are some concerns: | SP:b3210d565f51a3a5ea729ffa7e99e1727bd65cdd |
Exploiting structured data for learning contagious diseases under incomplete testing | One of the ways that machine learning algorithms can help control the spread of an infectious disease is by building models that predict who is likely to get infected making them good candidates for preemptive interventions . In this work we ask : can we build reliable infection prediction models when the observed data is collected under limited , and biased testing that prioritizes testing symptomatic individuals ? Our analysis suggests that when the infection is highly contagious , incomplete testing might be sufficient to achieve good out-of-sample prediction error . Guided by this insight , we develop an algorithm that predicts infections , and show that it outperforms baselines on simulated data . We apply our model to data from a large hospital to predict Clostridioides difficile infections ; a communicable disease that is characterized by asymptomatic ( i.e. , untested ) carriers . Using a proxy instead of the unobserved untested-infected state , we show that our model outperforms benchmarks in predicting infections . 1 INTRODUCTION . Preemptively identifying individuals at a high risk of contracting a contagious infection is important for guiding treatment decisions to mitigate symptoms , and preventing further spread of the contagion . In this paper , we study how to build individual-level predictive models for contagious infections while explicitly addressing the challenges inherent to contagious diseases . Building accurate infection prediction models is hindered by two main factors . First , contagious infections defy the usual iid assumption central to most machine learning methods . This is because an individual ’ s infection state is not independent of their contacts ’ infection states . Previous work has often relied on expert knowledge to construct exposure proxies ( Wiens et al. , 2012 ; Oh et al. , 2018 ) . It is then assumed that conditional on the exposure proxy and individual characteristics , individual outcomes are independent of one another . Second , the observed data is biased due to incomplete testing . We use the term “ incomplete testing ” to describe the scenario where only a small , biased subset of infected individuals get tested . Such a scenario is ubiquitous in the context of contagious infections for several reasons . While many individuals carry the pathogen , only a fraction display symptoms . Even in the presence of unlimited testing resources , the latter are far more likely to get tested leading to biased data collection where individuals predisposed to displaying symptoms are over-represented . Incomplete testing makes learning accurate models difficult since the collected labels are missing not at random leading to biased , inconsistent estimates . In this work , we treat non-independence of outcomes as a blessing rather than a curse . Our proposed approach leverages the fact that an individual ’ s infection state provides useful information about their contacts ’ true infection states . This information is used to generate pseudo-labels for untested individuals , mitigating issues due to incomplete testing . The key idea behind our approach is that highly structured patterns of contagion transmission can serve as a complementary signal to identify even untested carriers . The stronger that signal is , the less impact that incomplete testing will have . Our contributions can be summarized as follows : ( 1 ) We identify two properties of the collected data that can be exploited to mitigate the effects of incomplete testing . ( 2 ) We propose an algorithm that leverages that insight to predict the probability of an untested individual carrying the disease . ( 3 ) We empirically evaluate the effectiveness of our method on both simulated data and real data for a common healthcare associated infection . We show that predictions from our model can be used to inform efficient testing and isolation policies . Using real data , we show that our model outperforms baselines in the task of predicting a hospital associated infection . 2 RELATED WORK . Infectious disease modeling . Modeling the transmission of infectious diseases has been extensively studied in the epidemiology literature using SIS/SIR models and several other variants ( Kermack & McKendrick , 1927 ) . These epidemiological models focus on the aggregate levels of infections in a community , which is distinct from our approach here where we focus on predicting individual level infections . In the machine learning literature , previous work has relied on proxies for exposure , e.g. , the prevalence of a disease in a community ( Wiens et al. , 2012 ; Oh et al. , 2018 ) , and implicitly assume that conditioning on individual characteristics . Similar to our approach , Fan et al . ( 2016 ) and Makar et al . ( 2018 ) take into account structured data , namely contact networks to compute infection estimates ( Fan et al. , 2016 ; Makar et al. , 2018 ) . We differ from these approachs in that ( 1 ) we do not make parametric assumptions about the joint distribution of the observed or latent variables , and instead use nonparametric models ( neural networks ) to model the infection states , ( 2 ) we do not assume all infections will become symptomatic as is done in Fan et al . ( 2016 ) , and ( 3 ) unlike the approach taken by Makar et al . ( 2018 ) , we model time evolving sequences of infections taking into account the exposure states of potential asymptomatic carriers . Semi-supervised learning . Our proposed approach relies on transductive reasoning to generate labels for untested individuals . In that , it is closely related to semi-supervised learning methods , such as pseudo-labeling ( Lee , 2003 ) , and self-training ( Robinson et al. , 2020 ) . However , in traditional pseudo-labeling , the transductive power comes from the fact that points similar to each other in the input space should have similar outputs . Here , the rich structure in the data allows for more : we can construct pseudo-labels for untested individuals not just by relying on their similarity to other labeled instances , but also by observing their observed contacts ’ infection states . Our empirical results , and analysis are similar in spirit to concepts presented in the semi-supervised literature , specifically the cluster assumption , which we discuss at length later ( Seeger , 2000 ; Rigollet , 2007 ) . Graph Neural Networks . Our proposed approach incorporates knowledge of the contact network . In that it is similar to Graph Neural Networks ( GNNs ) , which utilize relational data to generate prediction estimates ( Zhou et al. , 2018 ) . GNNs fall into two categories , the first relies on transductive reasoning and can not generalize to new communities ( e.g. , Kipf & Welling ( 2017 ) ) or inductive , which can be used to generate estimates for previously unseen graphs ( e.g. , Hamilton et al . ( 2017 ) ) . Our work is similar to the latter category with an important distinction : our approach leverages unlabeled data giving more accurate , and robust estimates . Our work can be viewed as combining the strengths of semi-supervised learning , and GNNs to address limited testing . In addition , our approach augments the strengths of those two approaches with ideas from domain shift , and causal inference such as importance weighting ( Cortes et al. , 2010 ) to address biased testing . 3 PROBLEM SETTING . Setup . Let yt ∈ { 0 , 1 } denote an individual ’ s true infection state at time t , with yt = 0 if an individual is not infected and 1 if they are . We use xt ∈ X t to denote a vector of the individual ’ s features at time t , and define J ti to be the set of indices of i ’ s contacts at time t. We assume that contact indices are known , i.e. , that the contact network is observed . Let eti ∈ R≥0 denote i ’ s exposure state , with eti = ∑ j∈Jti ytj . The exposure state is fully observed only when all of i ’ s contacts have been tested , but otherwise either partially observed or unobserved . Define xt = xt||et , where || as the concatenation operator , i.e. , xt ∈ X t × R≥0 . Let ot ∈ { 0 , 1 } denote the observation state , with ot = 1 if an individual ’ s label is observed , i.e. , if the individual has been tested for the infection . We use the super-script : t to denote variables from time t = 0 up to and including t , e.g. , x : t = [ x0 , ... , xs , ... , xt ] . Throughout , we use capital letters to denote variables , and small letters to denote their values . We use P ( Xt , Ot , Y t+1 ) to denote the unknown distribution over the full joint . Under biased testing , we have that P ( Xt|Ot = 1 ) 6= P ( Xt|Ot = 0 ) 6= P ( Xt ) . We assume that 0 < P ( Ot = o|Xt = x ) < 1 , for all x ∈ X , and o ∈ { 0 , 1 } . This is the same as the overlap assumption in causality literature . In addition , we assume that i ’ s outcome is independent of their contacts given xi , which is itself a function of the contacts ’ outcomes , we refer to this as the conditional independence assumption . We consider the case where we have access to ( 1 ) a labeled ( i.e. , tested ) set of individuals D1 = { Dt1 } Tt=0 = { ( xti , yti ) , . . . ( xtnt1 , y t nt1 ) } ∼ P ( Xt , Y t+1|Ot = 1 ) , and ( 2 ) an unlabeled ( untested ) set of individuals D0 = { Dt0 } Tt=0 = { xti , . . . , xtnt0 } ∼ P ( X t|Ot = 0 ) , such that for each i ∈ D0∪D1 , and each t ∈ [ 0 , T ] , we have that J ti ∈ D0∪D1 . It will also be convenient to use U t to denote the set of indices of untested individuals at time t. Learning objective . We are interested in learning f : x : T → yT+1 . To focus the discussion on the novel component of our approach , we consider a setting where we are only interested in predicting the outcomes for a single time step . It will be particularly useful to consider the task of making predictions for t = 2 , using data from t = 0 , 1 , dropping the time superscript when it can be inferred from the context . We present the full model predicting infection sequences over time in section 5 . Let ` be the logistic loss function . Our goal is to find f ∈ F , where F is some hypothesis space such that the risk of incorrectly classifying the infection state Rf = EX , Y [ ` ( f ( Xt ) , Y t+1 ) ] is minimized . We briefly consider a scenario where we have oracle access to the true exposure states but we return to the more realistic , non-oracle scenario later . Under the conditional independence assumption , we can break down the risk to the sum of independent losses . Define the inverse probability of being tested , wt ( X ) = P ( Ot = o ) /P ( Ot = o|Xt ) , following Robins ( 1998 ) , and Robins et al . ( 2000 ) . Due to the overlap assumption , and under biased testing , we have that : Rf = Rw t f = EX , Y |O=1 [ wt ( X ) ` ( f ( X ) , Y ) |O = 1 ] , ( 1 ) ( Cortes et al. , 2010 ) . The reweighted risk simply places a higher importance on the loss of individuals who are unlikely to be tested . Rwtf can not be directly computed since the expectation is defined with respect to the unobserved distribution . However , the following reweighted empirical loss is an unbiased estimator ofRwtf : ε ( f ) = ∑ i∈Dt1 wti ` ( f ( x t i ) , y t+1 i ) , by Cortes et al . ( 2008 ) , where wti = p ( O t = oti ) /g ( oti|x t i ) , p ( Ot = oti ) is the empirical estimate of P ( Ot = o ) , and g ( oti|xti ) is the estimated probability of getting tested conditional on individual characteristics . Without oracle access to exposure states , the samples xt ∼ P ( Xt|Ot = 1 ) are incomplete . This is because xti includes e t i , which is a function of y t j : j ∈ J ti . We only fully observe eti , and hence x t i for individuals whose contacts have all been tested . To address this , we define Q ( Dt1 ) , a set of partially imputed distributions that are consistent with the labeled samples . It is the set of all possible distributions over the ( partially ) unobserved eti . Our risk is now defined with respect to both Q , and f , and our task is to find Q and f , such that the following empirical risk is minimized : ε ( f , Q ) = ∑ i∈D1 ŵti ` ( f ( x̂ t i ) , y t+1 i ) , ( 2 ) where x̂ = xt||êt , and êti ∼ Q , and ŵti = p ( O = oi ) /g ( x̂i , oi ) . Minimizing this objective is prone to extreme overfitting . To see why , consider some Q that sets eti = 100 for every i : o t i = 1 , y t+1 i = 1 , and 0 for i : oti = 1 , y t+1 i = 0 . Since Q is essentially leaking the true label into the input space , it is trivial to find some f that takes in the imputed inputs , { ( xti , 100 , yt+1i ) } i : yt+1i =1 , and { ( xti , 0 , yt+1i ) } i : yt+1i =0 and gives perfect performance . Such an f is clearly expected to have poor generalization error . We next consider how to leverage existing properties of the problem as efficient regularizers . | In this work, the authors propose an approach, MIINT, for identifying infected individuals using a network-based approach. They also suggest two key properties, potency and similarity among groups, which impact the efficacy of MIINT and similar approaches. A detailed simulation framework is used to compare MIINT to relatively weak baselines. The simulation results show that the MIINT modestly outperforms the baselines; the results also confirm that all approaches degrade as expected as potency decreases and the similarity among groups increases. Experimental results on a (private) real-world dataset are somewhat mixed, but show that MIINT achieves a better true positive rate at an acceptable false positive rate. | SP:b3210d565f51a3a5ea729ffa7e99e1727bd65cdd |
ARELU: ATTENTION-BASED RECTIFIED LINEAR UNIT | 1 INTRODUCTION . Activation functions , introducing nonlinearities to artificial neural networks , is essential to networks ’ expressivity power and learning dynamics . Designing activation functions that facilitate fast training of accurate deep neural networks is an active area of research ( Maas et al. , 2013 ; Goodfellow et al. , 2013 ; Xu et al. , 2015a ; Clevert et al. , 2015 ; Hendrycks & Gimpel , 2016 ; Klambauer et al. , 2017 ; Barron , 2017 ; Ramachandran et al. , 2017 ) . Aside from the large body of hand-designed functions , learning-based approaches recently gain more attention and success ( Agostinelli et al. , 2014 ; He et al. , 2015 ; Manessi & Rozza , 2018 ; Molina et al. , 2019 ; Goyal et al. , 2019 ) . The existing learnable activation functions are motivated either by relaxing/parameterizing a non-learnable activation function ( e.g . Rectified Linear Units ( ReLU ) ( Nair & Hinton , 2010 ) ) with learnable parameters ( He et al. , 2015 ) , or by seeking for a data-driven combination of a pool of pre-defined activation functions ( Manessi & Rozza , 2018 ) . Existing learning-based methods make activation functions data-adaptive through introducing degrees of freedom and/or enlarging the hypothesis space explored . In this work , we propose a new perspective of learnable activation functions through formulating them with element-wise attention mechanism . A straightforward motivation of this is a straightforward observation that both activation functions and element-wise attention functions are applied as a network module of element-wise multiplication . More intriguingly , learning element-wise activation functions in a neural network can intuitively be viewed as task-oriented attention mechanism ( Chorowski et al. , 2015 ; Xu et al. , 2015b ) , i.e. , learning where ( which element in the input feature map ) to attend ( activate ) given an end task to fulfill . This motivates an arguably more interpretable formulation of attentive activation functions . Attention mechanism has been a cornerstone in deep learning . It directs the network to learn which part of the input is more relevant or contributes more to the output . There have been many variants of attention modules with plentiful successful applications . In natural language processing , vector-wise attention is developed to model the long-range dependencies in a sequence of word vectors ( Luong et al. , 2015 ; Vaswani et al. , 2017 ) . Many computer vision tasks utilize pixel-wise or channel-wise attention modules for more expressive and invariant representation learning ( Xu et al. , 2015b ; Chen et al. , 2017 ) . Element-wise attention ( Bochkovskiy et al. , 2020 ) is the most fine-grained where each element of a feature volume can receive different amount of attention . Consequently , it attains high expressivity with neuron-level degrees of freedom . Inspired by that , we devise for each layer of a network an element-wise attention module which learns a sign-based attention map for the pre-activation feature map . The attention map scales an element based on its sign . Through adding the attention and a ReLU module , we obtain Attention-based Rectified Linear Unit ( AReLU ) which amplifies positive elements and suppresses negative ones , both with learned , data-adaptive parameters . The attention module essentially learns an element-wise residue for the activated elements with respect to the ReLU since the latter can be viewed as an identity transformation . This helps ameliorate the gradient vanishing issue effectively . Through extensive experiments on several public benchmarks , we show that AReLU significantly boosts the performance of most mainstream network architectures with only two extra learnable parameters per layer introduced . Moreover , AReLU enables fast learning under small learning rates , making it especially suited for transfer learning . We also demonstrate with feature map visualization that the learned attentive activation achieves well-focused , task-oriented activation of relevant regions . 2 RELATED WORK . Non-learnable activation functions Sigmoid is a non-linear , saturated activation function used mostly in the output layers of a deep learning model . However , it suffers from the exploding/vanishing gradient problem . As a remedy , the rectified linear unit ( ReLU ) ( Nair & Hinton , 2010 ) has been the most widely used activation function for deep learning models with the state-of-the-art performance in many applications . Many variants of ReLU have been proposed to further improve its performance on different tasks LReLU ( Maas et al. , 2013 ) , ReLU6 ( Krizhevsky & Hinton , 2010 ) , RReLU ( Xu et al. , 2015a ) . Besides that , some specified activation functions also have been designed for different usages , such as CELU ( Barron , 2017 ) , ELU ( Clevert et al. , 2015 ) , GELU ( Hendrycks & Gimpel , 2016 ) , Maxout ( Goodfellow et al. , 2013 ) , SELU ( Klambauer et al. , 2017 ) , ( Softplus ) ( Glorot et al. , 2011 ) , Swish ( Ramachandran et al. , 2017 ) . Learnable activation functions Recently , learnable activation functions have drawn more attentions . PReLU ( He et al. , 2015 ) , as a variants of ReLU , improves model fitting with little extra computational cost and overfitting risk . Recently , PAU ( Molina et al. , 2019 ) is proposed to not only approximate common activation functions but also learn new ones while providing compact representations with few learnable parameters . Several other learnable activation functions such as APL ( Agostinelli et al. , 2014 ) , Comb ( Manessi & Rozza , 2018 ) , SLAF ( Goyal et al. , 2019 ) also achieve promising performance under different tasks . Attention Mechanism Vector-Wise Attention Mechanism ( VWAM ) has been widely applied in Natural Language Processing ( NLP ) tasks ( Xu et al. , 2015c ; Luong et al. , 2015 ; Bahdanau et al. , 2014 ; Vaswani et al. , 2017 ; Ahmed et al. , 2017 ) . VWAM learns which vector among a sequence of word vectors is the most relevant to the task in hand . Channel-Wise Attention Mechanism ( CWAM ) can be regarded as an extension of VWAM from NLP to Vision tasks ( Tang et al. , 2019b ; 2020 ; Kim et al. , 2019 ) . It learns to assign each channel an attentional value . Pixel-Wise Attention Mechanism ( PWAM ) is also widely used in vision ( Tang et al. , 2019c ; a ) . Element-Wise Attention Mechanism ( EWAM ) assigns different values to each element without any spatial/channel constraint . The recently proposed YOLOv4 ( Bochkovskiy et al. , 2020 ) is the first work that introduces EWAM implemented by a convolutional layer and sigmoid function . It achieves the state-of-the-art performance on object detection . We introduce a new kind of EWAM for learnable activation function . 3 METHOD . We start by describing attention mechanism and then introduce element-wise sign-based attention mechanism based on which AReLU is defined . The optimization of AReLU then follows . 3.1 ATTENTION MECHANISM . Let us denote V = { vi } ∈ RD 1 v×D 2 v×··· a tensor representing input data or feature volume . Function Φ , parameterized by Θ = { θi } , is used to compute an attention map S = { si } ∈ RD θ ( 1 ) v ×D θ ( 2 ) v ×··· over a subspace of V ( let θ ( · ) denote a correspondence function for the indices of dimension ) : si = Φ ( vi , Θ ) . ( 1 ) Φ can be implemented by a neural network with Θ being its learnable parameters . We can modulate the input V with the attention map S using a function Ψ , obtaining the output U = { ui } ∈ RD 1 v×D 2 v×··· : ui = Ψ ( vi , si ) . ( 2 ) Ψ is an element-wise multiplication . In order to perform element-wise multiplication , one needs to first extend S to the full dimension of V . We next review various attention mechanisms with attention map at different granularities . Figure 1 ( left ) gives an illustration of various attention mechanisms . Vector-wise Attention Mechanism In NLP , attention maps are usually computed over different word vectors . In this case , V = { vi } ∈ RN×D represents a sequence of N feature vectors with dimension D. S = { si } ∈ RN is a sequence of attention values for the corresponding vectors . Channel-wise Attention Mechanism In computer vision , a feature volume V = { vi } ∈ RW×H×C has a spatial dimension of W ×H and a channel dimension of C. S = { si } ∈ RC is an attention map over the C channels . All elements in each channel share the same attention value . Spatial-wise Attention Mechanism Considering again V = { vi } ∈ RW×H×C with a spatial dimension of W × H . S = { si } ∈ RW×H is an attention map over the spatial dimension . All channels of a given spatial location share the same attention value . Element-wise Attention Mechanism Given a feature volume V = { vi } ∈ RW×H×C containing W × H × C elements , we compute an attention map over the whole volume ( all elements ) , i.e. , S = { si } ∈ RW×H×C , so that each element has an independent attention value . 3.2 ELEMENT-WISE SIGN-BASED ATTENTION ( ELSA ) . We propose , ELSA , a new kind of element-wise attention mechanism which is used to define our attention-based activation . Considering a feature volume V = { vi } ∈ RW×H×C , we compute an element-wise attention map S = { si } ∈ RW×H×C : si = Φ ( vi , Θ ) = { C ( α ) , vi < 0 σ ( β ) , vi ≥ 0 ( 3 ) where Θ = { α , β } ∈ R2 is learnable parameters . C ( · ) clamps the input variable into [ 0.01 , 0.99 ] . σ is the sigmoid function . The modulation function Ψ is defined as : ui = Ψ ( vi , si ) = sivi . ( 4 ) In ELSA , positive and negative elements receive different amount of attention determined by the two parameters α and β , respectively . Therefore , it can also be regarded as sign-wise attention mechanism . With only two learnable parameters , ELSA is light-weight and easy to learn . 3.3 ARELU : ATTENTION-BASED RECTIFIED LINEAR UNITS . We represent the function Φ in ELSA with a network layer with learnable parameters α and β : L ( xi , α , β ) = { C ( α ) xi , xi < 0 σ ( β ) xi , xi ≥ 0 ( 5 ) where X = { xi } is the input of the current layer . In constructing an activation function with ELSA , we combine it with the standard Rectified Linear Units R ( xi ) = { 0 , xi < 0 xi , xi ≥ 0 ( 6 ) Adding them together leads to a learnable activation function : F ( xi , α , β ) = R ( xi ) + L ( xi , α , β ) = { C ( α ) xi , xi < 0 ( 1 + σ ( β ) ) xi , xi ≥ 0 ( 7 ) This combination amplifies positive elements and suppresses negative ones based on the learned scaling parameters β and α , respectively . Thus , ELSA learns an element-wise residue for the activated elements w.r.t . ReLU which is an identity transformation , which helps ameliorate gradient vanishing . | This work presents a novel learned activation function called Attention-based Rectified Linear Unit (AReLU). Element-wise attention module is developed that learns a sign-based attention (ELSA) which is the novel component of AReLU towards mitigating the gradient vanishing issue. Extensive experiments and analyses have been provided on MNIST and CIFAR100 datasets. Compared with other relevant activation functions, AReLU achieves faster convergence under small learning rate because of the amplification of positive elements and suppression of negative ones with two learnable data-adaptive parameters. | SP:e36c7de37059ea0fe7ed64fb32926adfd76b30c1 |
ARELU: ATTENTION-BASED RECTIFIED LINEAR UNIT | 1 INTRODUCTION . Activation functions , introducing nonlinearities to artificial neural networks , is essential to networks ’ expressivity power and learning dynamics . Designing activation functions that facilitate fast training of accurate deep neural networks is an active area of research ( Maas et al. , 2013 ; Goodfellow et al. , 2013 ; Xu et al. , 2015a ; Clevert et al. , 2015 ; Hendrycks & Gimpel , 2016 ; Klambauer et al. , 2017 ; Barron , 2017 ; Ramachandran et al. , 2017 ) . Aside from the large body of hand-designed functions , learning-based approaches recently gain more attention and success ( Agostinelli et al. , 2014 ; He et al. , 2015 ; Manessi & Rozza , 2018 ; Molina et al. , 2019 ; Goyal et al. , 2019 ) . The existing learnable activation functions are motivated either by relaxing/parameterizing a non-learnable activation function ( e.g . Rectified Linear Units ( ReLU ) ( Nair & Hinton , 2010 ) ) with learnable parameters ( He et al. , 2015 ) , or by seeking for a data-driven combination of a pool of pre-defined activation functions ( Manessi & Rozza , 2018 ) . Existing learning-based methods make activation functions data-adaptive through introducing degrees of freedom and/or enlarging the hypothesis space explored . In this work , we propose a new perspective of learnable activation functions through formulating them with element-wise attention mechanism . A straightforward motivation of this is a straightforward observation that both activation functions and element-wise attention functions are applied as a network module of element-wise multiplication . More intriguingly , learning element-wise activation functions in a neural network can intuitively be viewed as task-oriented attention mechanism ( Chorowski et al. , 2015 ; Xu et al. , 2015b ) , i.e. , learning where ( which element in the input feature map ) to attend ( activate ) given an end task to fulfill . This motivates an arguably more interpretable formulation of attentive activation functions . Attention mechanism has been a cornerstone in deep learning . It directs the network to learn which part of the input is more relevant or contributes more to the output . There have been many variants of attention modules with plentiful successful applications . In natural language processing , vector-wise attention is developed to model the long-range dependencies in a sequence of word vectors ( Luong et al. , 2015 ; Vaswani et al. , 2017 ) . Many computer vision tasks utilize pixel-wise or channel-wise attention modules for more expressive and invariant representation learning ( Xu et al. , 2015b ; Chen et al. , 2017 ) . Element-wise attention ( Bochkovskiy et al. , 2020 ) is the most fine-grained where each element of a feature volume can receive different amount of attention . Consequently , it attains high expressivity with neuron-level degrees of freedom . Inspired by that , we devise for each layer of a network an element-wise attention module which learns a sign-based attention map for the pre-activation feature map . The attention map scales an element based on its sign . Through adding the attention and a ReLU module , we obtain Attention-based Rectified Linear Unit ( AReLU ) which amplifies positive elements and suppresses negative ones , both with learned , data-adaptive parameters . The attention module essentially learns an element-wise residue for the activated elements with respect to the ReLU since the latter can be viewed as an identity transformation . This helps ameliorate the gradient vanishing issue effectively . Through extensive experiments on several public benchmarks , we show that AReLU significantly boosts the performance of most mainstream network architectures with only two extra learnable parameters per layer introduced . Moreover , AReLU enables fast learning under small learning rates , making it especially suited for transfer learning . We also demonstrate with feature map visualization that the learned attentive activation achieves well-focused , task-oriented activation of relevant regions . 2 RELATED WORK . Non-learnable activation functions Sigmoid is a non-linear , saturated activation function used mostly in the output layers of a deep learning model . However , it suffers from the exploding/vanishing gradient problem . As a remedy , the rectified linear unit ( ReLU ) ( Nair & Hinton , 2010 ) has been the most widely used activation function for deep learning models with the state-of-the-art performance in many applications . Many variants of ReLU have been proposed to further improve its performance on different tasks LReLU ( Maas et al. , 2013 ) , ReLU6 ( Krizhevsky & Hinton , 2010 ) , RReLU ( Xu et al. , 2015a ) . Besides that , some specified activation functions also have been designed for different usages , such as CELU ( Barron , 2017 ) , ELU ( Clevert et al. , 2015 ) , GELU ( Hendrycks & Gimpel , 2016 ) , Maxout ( Goodfellow et al. , 2013 ) , SELU ( Klambauer et al. , 2017 ) , ( Softplus ) ( Glorot et al. , 2011 ) , Swish ( Ramachandran et al. , 2017 ) . Learnable activation functions Recently , learnable activation functions have drawn more attentions . PReLU ( He et al. , 2015 ) , as a variants of ReLU , improves model fitting with little extra computational cost and overfitting risk . Recently , PAU ( Molina et al. , 2019 ) is proposed to not only approximate common activation functions but also learn new ones while providing compact representations with few learnable parameters . Several other learnable activation functions such as APL ( Agostinelli et al. , 2014 ) , Comb ( Manessi & Rozza , 2018 ) , SLAF ( Goyal et al. , 2019 ) also achieve promising performance under different tasks . Attention Mechanism Vector-Wise Attention Mechanism ( VWAM ) has been widely applied in Natural Language Processing ( NLP ) tasks ( Xu et al. , 2015c ; Luong et al. , 2015 ; Bahdanau et al. , 2014 ; Vaswani et al. , 2017 ; Ahmed et al. , 2017 ) . VWAM learns which vector among a sequence of word vectors is the most relevant to the task in hand . Channel-Wise Attention Mechanism ( CWAM ) can be regarded as an extension of VWAM from NLP to Vision tasks ( Tang et al. , 2019b ; 2020 ; Kim et al. , 2019 ) . It learns to assign each channel an attentional value . Pixel-Wise Attention Mechanism ( PWAM ) is also widely used in vision ( Tang et al. , 2019c ; a ) . Element-Wise Attention Mechanism ( EWAM ) assigns different values to each element without any spatial/channel constraint . The recently proposed YOLOv4 ( Bochkovskiy et al. , 2020 ) is the first work that introduces EWAM implemented by a convolutional layer and sigmoid function . It achieves the state-of-the-art performance on object detection . We introduce a new kind of EWAM for learnable activation function . 3 METHOD . We start by describing attention mechanism and then introduce element-wise sign-based attention mechanism based on which AReLU is defined . The optimization of AReLU then follows . 3.1 ATTENTION MECHANISM . Let us denote V = { vi } ∈ RD 1 v×D 2 v×··· a tensor representing input data or feature volume . Function Φ , parameterized by Θ = { θi } , is used to compute an attention map S = { si } ∈ RD θ ( 1 ) v ×D θ ( 2 ) v ×··· over a subspace of V ( let θ ( · ) denote a correspondence function for the indices of dimension ) : si = Φ ( vi , Θ ) . ( 1 ) Φ can be implemented by a neural network with Θ being its learnable parameters . We can modulate the input V with the attention map S using a function Ψ , obtaining the output U = { ui } ∈ RD 1 v×D 2 v×··· : ui = Ψ ( vi , si ) . ( 2 ) Ψ is an element-wise multiplication . In order to perform element-wise multiplication , one needs to first extend S to the full dimension of V . We next review various attention mechanisms with attention map at different granularities . Figure 1 ( left ) gives an illustration of various attention mechanisms . Vector-wise Attention Mechanism In NLP , attention maps are usually computed over different word vectors . In this case , V = { vi } ∈ RN×D represents a sequence of N feature vectors with dimension D. S = { si } ∈ RN is a sequence of attention values for the corresponding vectors . Channel-wise Attention Mechanism In computer vision , a feature volume V = { vi } ∈ RW×H×C has a spatial dimension of W ×H and a channel dimension of C. S = { si } ∈ RC is an attention map over the C channels . All elements in each channel share the same attention value . Spatial-wise Attention Mechanism Considering again V = { vi } ∈ RW×H×C with a spatial dimension of W × H . S = { si } ∈ RW×H is an attention map over the spatial dimension . All channels of a given spatial location share the same attention value . Element-wise Attention Mechanism Given a feature volume V = { vi } ∈ RW×H×C containing W × H × C elements , we compute an attention map over the whole volume ( all elements ) , i.e. , S = { si } ∈ RW×H×C , so that each element has an independent attention value . 3.2 ELEMENT-WISE SIGN-BASED ATTENTION ( ELSA ) . We propose , ELSA , a new kind of element-wise attention mechanism which is used to define our attention-based activation . Considering a feature volume V = { vi } ∈ RW×H×C , we compute an element-wise attention map S = { si } ∈ RW×H×C : si = Φ ( vi , Θ ) = { C ( α ) , vi < 0 σ ( β ) , vi ≥ 0 ( 3 ) where Θ = { α , β } ∈ R2 is learnable parameters . C ( · ) clamps the input variable into [ 0.01 , 0.99 ] . σ is the sigmoid function . The modulation function Ψ is defined as : ui = Ψ ( vi , si ) = sivi . ( 4 ) In ELSA , positive and negative elements receive different amount of attention determined by the two parameters α and β , respectively . Therefore , it can also be regarded as sign-wise attention mechanism . With only two learnable parameters , ELSA is light-weight and easy to learn . 3.3 ARELU : ATTENTION-BASED RECTIFIED LINEAR UNITS . We represent the function Φ in ELSA with a network layer with learnable parameters α and β : L ( xi , α , β ) = { C ( α ) xi , xi < 0 σ ( β ) xi , xi ≥ 0 ( 5 ) where X = { xi } is the input of the current layer . In constructing an activation function with ELSA , we combine it with the standard Rectified Linear Units R ( xi ) = { 0 , xi < 0 xi , xi ≥ 0 ( 6 ) Adding them together leads to a learnable activation function : F ( xi , α , β ) = R ( xi ) + L ( xi , α , β ) = { C ( α ) xi , xi < 0 ( 1 + σ ( β ) ) xi , xi ≥ 0 ( 7 ) This combination amplifies positive elements and suppresses negative ones based on the learned scaling parameters β and α , respectively . Thus , ELSA learns an element-wise residue for the activated elements w.r.t . ReLU which is an identity transformation , which helps ameliorate gradient vanishing . | In this paper, the authors proposed a new activation function called AReLU which introduces an attention mechanism to the original ReLU function. Based on this new activation function, the output will be adaptively adjusted by the two learnable parameters \alpha and \beta. This kind of adaptive adjustment can be thought of as an attention mechanism undertaken over each element in the input feature map. It will in general amplify the positive elements while suppressing the negative ones, and the parameters \alpha and \beta will be adjusted adaptively based on the activation values. The experimental results showed that AReLU can achieve much better performance with small learning rates while comparable performance with fairly large learning rates. This inspires another set of transfer learning experiments that demonstrate the effectiveness of AReLU. | SP:e36c7de37059ea0fe7ed64fb32926adfd76b30c1 |
Unbiased Learning with State-Conditioned Rewards in Adversarial Imitation Learning | 1 INTRODUCTION . Inverse reinforcement learning ( IRL ) is an algorithm of recovering the ground truth reward function from observed behavior ( Ng & Russell , 2000 ) . IRL algorithms—followed by appropriate reinforcement learning ( RL ) algorithms—can optimize policy through farsighted cumulative value measures in the given system ( Sutton & Barto , 2018 ) ; hence it can usually achieve more satisfying results than mere supervision . While a few studies have investigated recovering reward functions to continuous spaces ( Babes et al. , 2011 ; Levine & Koltun , 2012 ) , IRL algorithms often fail to find the ground-truth reward function in high-dimensional complex domains ( Finn et al. , 2016b ) . The notion of the ground-truth reward requires elaboration since IRL is an ill-posed problem ; there can be numerous solutions to the reward function inducing the same optimal policy ( Ng et al. , 1999 ; Ng & Russell , 2000 ) . Recently , adversarial imitation learning ( AIL ) as a reward acquisition method has shown promising results ( Ho & Ermon , 2016 ) . One of the distinctive strengths of AIL is the scalability through parameterized non-linear functions such as neural networks . The maximum causal entropy principles are widely regarded as the solution when the optimal control problem is modeled as probabilistic inference ( Ziebart et al. , 2010 ; Haarnoja et al. , 2017 ) . In particular , probabilistic modeling using a continuous energy function forms a representation called an energy-based model ( EBM ) . We highlight the following advantages of the energy-based IRL : • It provides a unified framework for stochastic policies to the learning ; most probabilistic models can be viewed as special types of EBMs ( LeCun et al. , 2006 ) . • It rationalizes the stochasticity of behavior ; this provides robustness in the face of uncertain dy- namics ( Ziebart et al. , 2010 ) and a natural way of modeling complex multi-modal distribution . AIL reward functions seem to be exceptions to these arguments—the AIL framework produces distinct types of rewards that are ever-changing and are intended for discriminating joint densities . We argue that these characteristics hinder proper information projection to the optimal decision . This work points out that there remain two kinds of biases in AIL . The established AIL algorithms are typically formalized by the cumulative densities called occupancy measure . We claim that the accumulated measures contain biases that are not related to modeling purposeful behavior , and the formulation is vulnerable to distributional shifts of an MDP . Empirically , they work as dominant noises in training because of the formulation ’ s innate high variance . The other bias is implicit survival or early termination bias caused by reward formulation , which lacks consideration for the terminal states in finite episodes . These unnormalized rewards often provokes sub-optimal behaviors where the agent learns to maliciously make use of temporal-aware strategies . This paper proposes an adversarial IRL method called causal adversarial inverse reinforcement learning ( CAIRL ) . We primarily associate the reward acquisition method with approaches for energy-based RL and IRL algorithms ; the CAIRL reward function can induce complex probabilistic behaviors with multiple modalities . We then show that learning with a dual discriminator architecture provides stepwise , state-conditioned rewards . For handling biases induced by finite-horizon , the model postulates the reward function satisfies a Bellman equation , including “ self-looping ” terminal states . As a result , it learns the reward function satisfying the property of EBMs . Noteworthy contributions of this work are 1 ) a model-free , energy-based IRL algorithm that is effective in high-dimensional environments , 2 ) a dual discriminator architecture for recovering a robust state-conditioned reward function , 3 ) an effective approach for handling terminal states , and 4 ) meaningful experiments and comparison studies with state-of-the-art algorithms in various topics . 2 RELATED WORKS . Imitation learning is a fundamental approach for modeling intellectual behavior from an expert at specific tasks ( Pomerleau , 1991 ; Zhang et al. , 2018 ) . For the standard framework called Behavioral Cloning , learning from demonstrations is treated as supervised learning for a trajectory dataset . On the other hand , IRL aims to study the reward function of the underlying system , which characterizes the expert . In this perspective , training a policy with an IRL reward function is a branch of imitation learning , specialized in dealing with sequential decision-making problems by recovering the concise representation of a task ( Ng & Russell , 2000 ; Abbeel & Ng , 2004 ) . For modeling stochastic expert policies , Boltzmann distributions appeared in early IRL research , such as Bayesian IRL , natural gradient IRL , and maximum likelihood IRL ( Ramachandran & Amir , 2007 ; Neu & Szepesvári , 2012 ; Babes et al. , 2011 ) . Notably , maximum entropy IRL ( Ziebart et al. , 2008 ) is explicitly formulated based on the principle of maximum entropy . The framework has also been derived from causal entropy—the derived algorithm can model the purposeful distribution of optimal policy into a reward function ( Ziebart et al. , 2010 ) . Our work draws significant inspirations from these prior works and aims to redeem the perspective of probabilistic causality . Recently , AIL methods ( Ho & Ermon , 2016 ; Fu et al. , 2017 ; Ghasemipour et al. , 2020 ) have shown great success on continuous control benchmarks . Each of the them provides a unique divergence minimization scheme by its architecture . In particular , our work shares major components with AIRL . It has been argued that the algorithm does not recover the energy of the expert policy ( Liu et al. , 2020 ) . We stress that our work introduces essential concepts to draw an energy-based representation of the expert policy correctly . The discriminator design is based on the rich energy-based interpretation of GANs ( Zhao et al. , 2016 ; Azadi et al. , 2018 ; Che et al. , 2020 ) and numerous studies with multiple discriminators ( Chongxuan et al. , 2017 ; Gan et al. , 2017 ; Choi et al. , 2018 ) . The issues of finite-horizon tasks were initially raised in RL during the discussion of time limits in MDP benchmarks ( Pardo et al. , 2017 ; Tucker et al. , 2018 ) . It turned out that the time limits , or even the existence of terminal states , would significantly affect the value learning procedure of RL compared to that generated in infinite horizon MDPs . IRL suffers from the identical problem that reward learning of finite episodes is not really stable for tasks outside of appropriate benchmarks . Kostrikov et al . ( 2018 ) suggested explicitly adding a self-repeating absorbing state ( Sutton & Barto , 2018 ) after the terminal state ; consequently , AIL discriminators can evaluate the termination frequencies . 3 BACKGROUND . Markov Decision Process ( MDP ) . We define an MDP as a tuple M = ( S , A , P , r , p0 , γ ) where S and A denote the state and action spaces , and γ is the discount factor . The transition distribution P , the deterministic state-action reward function r , and the initial state distribution p0 are unknown . Let τπ and τE be sequences of finite states and actions ( s0 , a0 , . . . , aT−1 , sT ) obtained by a policy π and the expert policy πE , respectively . The term ρπ denotes the occupancy measures derived by Table 1 : The objectives for AIL algorithms in a form as the minimization of statistical divergences . Method Optimized Objective ( Minimization ) Behavioral Cloning EπE [ DKL ( πE ( a|s ) ‖π ( a|s ) ) ] = −EπE [ log π ( a|s ) ] + const GAIL ( Ho & Ermon , 2016 ) Eπ [ DJS ( ρπ ( s , a ) , ρE ( s , a ) ) −H ( π ( ·|s ) ) ] AIRL ( Fu et al. , 2017 ) Eπ [ DKL ( ρπ ( s , a ) ∥∥ρE ( s , a ) ) ] = −Eπ [ log ρE ( s , a ) +H ( ρπ ) ] FAIRL ( Ghasemipour et al. , 2020 ) Eπ [ DKL ( ρE ( s , a ) ∥∥ρπ ( s , a ) ) ] = −EπE [ log ρπ ( s , a ) +H ( ρE ) ] CAIRL ( this work ) Eπ [ DKL ( π ( a|s ) ∥∥πE ( a|s ) ) ] = −Eπ [ r ( s , a ) +H ( π ( ·|s ) ) ] + const π , and is defined as ρπ ( s , a ) = π ( a|s ) ∑∞ t=0 γ t Pr ( st = s|π ) . With a slight abuse of notation , we refer to the occupancy measures of states as ρE ( s ) and ρπ ( s ) . The expectation of π for an arbitrary function c denotes an expected return for infinite-horizon : Eπ [ c ( s , a ) ] , E [ ∑∞ t=0 γ tc ( s , a ) |π ] . Maximum Entropy IRL ( MaxEnt IRL ) . Ziebart ( 2010 ) and Haarnoja et al . ( 2017 ) defined the optimality of stochastic policy with an entropy-regularized RL objective as follows : π ? = arg max π∈Π ∑ t E ( st , at ) ∼ρπ [ r ( st , at ) + αH ( at|st ) ] whereH denotes the causal entropy function.1 If πE is the MaxEnt RL policy , the softmax Bellman optimality equations can be defined by the following recursive logic : Q ? ( st , at ) = r ( st , at ) + γEst+1∼P ( ·|st , at ) [ V ? ( st+1 ) ] V ? ( st ) = Eat∼πE ( ·|st ) [ Q ? ( st , at ) − log πE ( at|st ) ] ( 1 ) MaxEnt IRL algorithms ( Ziebart et al. , 2008 ; 2010 ) are energy-based interpretations of IRL which aim to find behavior abiding the MaxEnt principle . Such algorithms , however , are difficult to be computed when the given spaces are continuous or dynamics are unknown ( Finn et al. , 2016a ) . Adversarial Imitation Learning . Ho & Ermon ( 2016 ) considered adversarial learning as a modelfree , sampling-based approximation to MaxEnt IRL . Instead of exhaustively solving the problem , GAIL performs imitation learning by minimizing the divergence between the state-action occupancy measures from expert and learner through the following logistic objective : min π∈Π max D EπE [ logD ( s , a ) ] + Eπ [ log ( 1−D ( s , a ) ) ] −H ( π ) ( 2 ) where D ∈ ( 0 , 1 ) |S||A| indicates a binary classifier trained to distinguish between τπ and τE . The AIRL discriminator tries to disentangle a reward function that is invariant to dynamics . It takes a particular form : Dθ ( s , a ) = exp ( fθ , ψ ( s , a ) ) / ( exp ( fθ , ψ ( s , a ) ) + πφ ( a|s ) ) . Learning with the AIRL can be considered as the reverse KL divergence between occupancy measures . Ghasemipour et al . ( 2020 ) proposed the FAIRL algorithm as an adversarial method for the forward KL divergence . | The line of reasoning and analysis followed in the paper is mostly sound. The paper claims that the use of (state-action) occupancy measure make IL and IRL methods brittle due to the high variance of these measures and their inability to transfer to other domains. These two claims are neither properly defined and grounded in the literature, nor are they isolated experimentally. It is important to show clearly that a) these are problems, b) hitherto unaddressed in the research landscape, and that the proposed methods and techniques address these problems specifically. | SP:08d227e9382cb5eb359462f2e75cca62f3457cf0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.